feat: proper verbose/debug flag support and updated documentation

Author: Cod-e-Codes

README.md

@@ -57,19 +57,19 @@ cd cmd && go build -o codesleuth && cd ..
 
 ```bash
 # Analyze a COBOL file or directory (basic usage)
-./cmd/codesleuth analyze path/to/your/cobol/files
+./cmd/codesleuth.exe analyze path/to/your/cobol/files
 
-# Enable verbose output
-./cmd/codesleuth analyze --verbose path/to/your/cobol/files
+# Enable verbose output (high-level extra info, logs to stderr)
+./cmd/codesleuth.exe analyze --verbose path/to/your/cobol/files
+
+# Enable debug output (detailed trace/internal state, logs to stderr)
+./cmd/codesleuth.exe analyze --debug path/to/your/cobol/files
 
 # Analyze a single file
-./cmd/codesleuth analyze program.cbl
+./cmd/codesleuth.exe analyze program.cbl
 
 # Output analysis to a Markdown file
-./cmd/codesleuth analyze path/to/your/cobol/files > analysis_report.md
-
-# Analyze with debug information (verbose + debug)
-./cmd/codesleuth analyze --verbose --debug complex-program.cbl
+./cmd/codesleuth.exe analyze path/to/your/cobol/files > analysis_report.md
 ```
 
 ---

cmd/main.go

@@ -12,9 +12,11 @@ import (
 )
 
 var verbose bool
+var debug bool
 
 func init() {
-	analyzeCmd.Flags().BoolVar(&verbose, "verbose", false, "Enable verbose debug output")
+	analyzeCmd.Flags().BoolVar(&verbose, "verbose", false, "Enable verbose output")
+	analyzeCmd.Flags().BoolVar(&debug, "debug", false, "Enable debug output")
 }
 
 func main() {
@@ -59,8 +61,17 @@ var analyzeCmd = &cobra.Command{
 			if verbose {
 				parserArgs = append(parserArgs, "--verbose")
 			}
-			cmd := exec.Command(parserArgs[0], parserArgs[1:]...)
-			output, err := cmd.Output()
+			if debug {
+				parserArgs = append(parserArgs, "--debug")
+			}
+			parserCmd := exec.Command(parserArgs[0], parserArgs[1:]...)
+			var parserStdout, parserStderr strings.Builder
+			parserCmd.Stdout = &parserStdout
+			parserCmd.Stderr = &parserStderr
+			err := parserCmd.Run()
+			if (verbose || debug) && parserStderr.Len() > 0 {
+				fmt.Fprint(os.Stderr, parserStderr.String())
+			}
 			if err != nil {
 				fmt.Printf("Error running parser on %s: %v\n", f, err)
 				continue
@@ -69,28 +80,41 @@ var analyzeCmd = &cobra.Command{
 				ProgramName string `json:"program_name"`
 				SourceFile  string `json:"source_file"`
 			}
-			if err := json.Unmarshal(output, &ir); err != nil {
+			if err := json.Unmarshal([]byte(parserStdout.String()), &ir); err != nil {
 				fmt.Printf("Error parsing IR JSON for %s: %v\n", f, err)
 				continue
 			}
 			fmt.Printf("Parsed: %s (program_name: %s)\n", ir.SourceFile, ir.ProgramName)
 
 			// Call Rust summarizer binary
-			sumCmd := exec.Command("..\\summarizer\\target\\release\\summarizer.exe")
+			sumArgs := []string{"..\\summarizer\\target\\release\\summarizer.exe"}
+			if verbose {
+				sumArgs = append(sumArgs, "--verbose")
+			}
+			if debug {
+				sumArgs = append(sumArgs, "--debug")
+			}
+			sumCmd := exec.Command(sumArgs[0], sumArgs[1:]...)
+			var sumStdout, sumStderr strings.Builder
+			sumCmd.Stdout = &sumStdout
+			sumCmd.Stderr = &sumStderr
 			sumIn, err := sumCmd.StdinPipe()
 			if err != nil {
 				fmt.Printf("Error getting stdin pipe for Rust summarizer for %s: %v\n", f, err)
 				continue
 			}
 			go func() {
-				sumIn.Write(output)
+				sumIn.Write([]byte(parserStdout.String()))
 				sumIn.Close()
 			}()
-			summary, err := sumCmd.CombinedOutput()
+			err = sumCmd.Run()
+			if (verbose || debug) && sumStderr.Len() > 0 {
+				fmt.Fprint(os.Stderr, sumStderr.String())
+			}
 			if err != nil {
 				fmt.Printf("Rust summarizer failed for %s: %v\n", f, err)
 			}
-			fmt.Println(string(summary))
+			fmt.Println(sumStdout.String())
 		}
 		// TODO: Call Rust parser and Python pipeline here
 	},

parser/src/main.rs

@@ -16,6 +16,9 @@ struct Args {
     /// Enable verbose debug output
     #[arg(long)]
     verbose: bool,
+    /// Enable debug output
+    #[arg(long)]
+    debug: bool,
 }
 
 // static RE_IDENT_DIV: Lazy<Regex> = Lazy::new(|| Regex::new(r"(?i)^\s*IDENTIFICATION DIVISION\s*\.?$").unwrap());
@@ -690,7 +693,10 @@ fn main() {
         call_graph,
         control_flow_graph,
     };
-    if args.verbose {
+    if args.debug {
+        eprintln!("[DEBUG] Full IR: {}", serde_json::to_string_pretty(&ir).unwrap());
+        // Add more detailed debug output here as needed
+    } else if args.verbose {
         eprintln!("[VERBOSE] Parsed IR: {}", serde_json::to_string_pretty(&ir).unwrap());
     }
     println!("{}", serde_json::to_string_pretty(&ir).unwrap());

summarizer/src/main.rs

@@ -21,6 +21,10 @@ struct Args {
     /// Enable verbose output
     #[arg(short, long)]
     verbose: bool,
+    
+    /// Enable debug output
+    #[arg(long)]
+    debug: bool,
 }
 
 static COBOL_KEYWORDS: Lazy<HashSet<&'static str>> = Lazy::new(|| {
@@ -211,8 +215,6 @@ fn get_str(val: &Option<serde_json::Value>) -> &str {
     }
 }
 
-
-
 fn format_value(val: &Option<serde_json::Value>) -> String {
     if let Some(v) = val {
         match v {
@@ -740,6 +742,13 @@ fn main() -> io::Result<()> {
         Box::new(io::stdout())
     };
 
+    if args.debug {
+        eprintln!("[DEBUG] IR: {:#?}", ir);
+        // Add more detailed debug output here as needed
+    } else if args.verbose {
+        eprintln!("[VERBOSE] Program name: {}", ir.program_name.as_deref().unwrap_or("UNKNOWN"));
+    }
+    
     print_program_info(&mut output, &ir)?;
 
     if let Some(data_div) = &ir.data_division {