Merge pull request #47 from sakamotopaya/eo/cli-refinement

Eo/cli refinement

Author: ericroliver

docs/cli/README.md

@@ -12,18 +12,65 @@ npm install -g roo-cli
 
 ### Basic Usage
 
+#### Interactive Mode (Main Usage)
+
 ```bash
 # Start interactive mode
 roo-cli
+```
+
+Once started, simply type your prompts directly and press Enter:
+
+```
+🤖 Roo> Create a React todo app with TypeScript
+🤖 Roo> Debug the memory leak in my authentication code
+🤖 Roo> Refactor this function to be more efficient
+🤖 Roo> Add unit tests for the user service
+```
+
+**Multi-line prompts:** Use ` ``` ` to start/end multi-line input:
+
+````
+🤖 Roo> ```
+Create a new user registration form
+with validation and error handling
+using React and TypeScript
+````
+
+````
 
-# Run a single task
+**Available REPL commands:**
+- `help` - Show help information
+- `exit` or `quit` - Exit the CLI
+- `clear` - Clear screen
+- `status` - Show current task status
+- `abort` - Abort current running task
+- `config show` - Show configuration
+
+#### Batch Mode (Single Tasks)
+
+```bash
+# Run a single task and exit
 roo-cli --batch "Create a hello world function"
 
 # Run with specific configuration
-roo-cli --config ./my-config.json
+roo-cli --config ./my-config.json --batch "Analyze this codebase"
+
+# Pipe input from stdin
+echo "Fix the bug in user.js" | roo-cli --stdin
+````
 
+#### Configuration
+
+```bash
 # Generate default configuration
 roo-cli --generate-config ~/.roo-cli/config.json
+
+# Show current configuration
+roo-cli config --show
+
+# Validate configuration
+roo-cli config --validate
 ```
 
 ## Documentation Structure

docs/cli/getting-started.md

@@ -78,15 +78,41 @@ Try these commands:
 roo> help
 
 # Show current configuration
-roo> config
-
-# Run a simple task
-roo> "Create a simple hello world function in Python"
+roo> config show
 
 # Exit interactive mode
 roo> exit
 ```
 
+### Sending Prompts in Interactive Mode
+
+In interactive mode, simply type your task directly and press Enter:
+
+```bash
+# Simple prompts - just type naturally
+roo> Create a simple hello world function in Python
+roo> Fix the bug in my authentication code
+roo> Add unit tests for the Calculator class
+roo> Refactor the getUserData function to use async/await
+```
+
+### Multi-line Prompts
+
+For longer, complex prompts, use triple backticks:
+
+````bash
+roo> ```
+Create a React component that:
+- Displays a list of users
+- Has search functionality
+- Includes pagination
+- Uses TypeScript interfaces
+````
+
+`````
+
+The CLI will wait for you to type the closing ```` ``` ```` before processing your request.
+
 ### Batch Mode
 
 For single tasks, use batch mode:
@@ -100,7 +126,7 @@ roo-cli --batch "Analyze this directory structure" --format json
 
 # Run in specific directory
 roo-cli --cwd /path/to/project --batch "Add unit tests to this project"
-```
+`````
 
 ## Step 3: Working with Files
 

src/cli/cli-entry.ts

@@ -7,6 +7,7 @@ import { registerMcpCommands } from "./commands/mcp-commands"
 import { registerExamplesCommands } from "./commands/ExamplesCommand"
 import { showBanner } from "./utils/banner"
 import { CliConfigManager } from "./config/CliConfigManager"
+import { getCLILogger, initializeCLILogger } from "./services/CLILogger"
 import { validateBrowserViewport, validateTimeout } from "./utils/browser-config"
 import { isValidFormat, getAvailableFormatsWithDescriptions } from "./utils/format-detection"
 import { PerformanceMonitoringService } from "./optimization/PerformanceMonitoringService"
@@ -46,6 +47,7 @@ interface CliOptions {
 	continueOnError?: boolean
 	dryRun?: boolean
 	quiet?: boolean
+	thinking?: boolean
 	// Browser options
 	headless: boolean
 	browserViewport?: string
@@ -153,6 +155,7 @@ program
 	.option("--continue-on-error", "Continue execution on command failure")
 	.option("--dry-run", "Show what would be executed without running commands")
 	.option("--quiet", "Suppress non-essential output")
+	.option("--thinking", "Show thinking sections in LLM output", false)
 	.option("--generate-config <path>", "Generate default configuration file at specified path", validatePath)
 	.option("--headless", "Run browser in headless mode (default: true)", true)
 	.option("--no-headless", "Run browser in headed mode")
@@ -168,6 +171,9 @@ program
 	.option("--no-mcp-auto-connect", "Do not automatically connect to enabled MCP servers")
 	.option("--mcp-log-level <level>", "MCP logging level (error, warn, info, debug)", validateMcpLogLevel)
 	.action(async (options: CliOptions) => {
+		// Initialize CLI logger with options
+		initializeCLILogger(options.verbose, options.quiet, options.color, options.thinking)
+
 		// Initialize platform services for CLI context
 		await PlatformServiceFactory.initialize(PlatformContext.CLI, "roo-cline", options.config)
 
@@ -298,14 +304,17 @@ program
 					if (options.stdin) {
 						await nonInteractiveService.executeFromStdin()
 					} else if (options.batch) {
+						getCLILogger().debug(`[cli-entry] Batch option provided: "${options.batch}"`)
 						// Check if batch is a file path or a direct command
-						if (
-							options.batch.includes(".") ||
-							options.batch.startsWith("/") ||
-							options.batch.startsWith("./")
-						) {
+						// First check if it exists as a file
+						const fileExists = fs.existsSync(options.batch)
+						getCLILogger().debug(`[cli-entry] File exists check for "${options.batch}": ${fileExists}`)
+
+						if (fileExists) {
+							getCLILogger().debug("[cli-entry] Treating as file path, using NonInteractiveModeService")
 							await nonInteractiveService.executeFromFile(options.batch)
 						} else {
+							getCLILogger().debug("[cli-entry] Treating as direct command, using BatchProcessor")
 							// Treat as direct command - use existing BatchProcessor
 							const batchProcessor = new BatchProcessor(options, configManager)
 							await batchProcessor.run(options.batch)

src/cli/commands/ExamplesCommand.ts

@@ -323,7 +323,7 @@ export class ExamplesCommand implements IExamplesCommand {
 
 	private loadExamples(): void {
 		if (!existsSync(this.examplesPath)) {
-			console.warn(`Examples directory not found: ${this.examplesPath}`)
+			// Debug: Examples directory not found (only log in verbose mode)
 			return
 		}
 

src/cli/commands/HelpCommand.ts

@@ -91,7 +91,38 @@ export class HelpCommand implements IHelpCommand {
 		console.log("  orchestrator      Workflow coordination")
 		console.log()
 
-		console.log(chalk.white.bold("EXAMPLES:"))
+		console.log(chalk.white.bold("HOW TO SEND PROMPTS:"))
+		console.log("  Interactive Mode:")
+		console.log("    1. Run: roo-cli")
+		console.log("    2. Simply type your prompt directly and press Enter")
+		console.log("    3. For multi-line prompts, type ``` to start/end")
+		console.log()
+		console.log("  Batch Mode:")
+		console.log('    roo-cli --batch "your task description"')
+		console.log()
+		console.log("  Stdin Mode:")
+		console.log('    echo "your task" | roo-cli --stdin')
+		console.log()
+
+		console.log(chalk.white.bold("INTERACTIVE PROMPT EXAMPLES:"))
+		console.log("  🤖 Roo> Create a React todo app with TypeScript")
+		console.log("  🤖 Roo> Debug the memory leak in my authentication code")
+		console.log("  🤖 Roo> Refactor this function to be more efficient")
+		console.log("  🤖 Roo> Add unit tests for the user service")
+		console.log("  🤖 Roo> Fix the CSS styling issues in the header")
+		console.log()
+
+		console.log(chalk.white.bold("INTERACTIVE COMMANDS:"))
+		console.log("  help                                       # Show REPL help")
+		console.log("  exit, quit                                 # Exit the CLI")
+		console.log("  clear                                      # Clear screen")
+		console.log("  status                                     # Show current task status")
+		console.log("  abort                                      # Abort current task")
+		console.log("  config show                                # Show configuration")
+		console.log("  ```                                        # Start/end multi-line input")
+		console.log()
+
+		console.log(chalk.white.bold("CLI EXAMPLES:"))
 		console.log("  roo-cli                                    # Start interactive mode")
 		console.log('  roo-cli --batch "create a todo app"       # Run single task')
 		console.log("  roo-cli --mode debug --verbose            # Debug mode with logging")

src/cli/commands/batch.ts

@@ -4,6 +4,7 @@ import { Task } from "../../core/task/Task"
 import { defaultModeSlug } from "../../shared/modes"
 import type { ProviderSettings, RooCodeSettings } from "@roo-code/types"
 import { CliConfigManager } from "../config/CliConfigManager"
+import { getCLILogger } from "../services/CLILogger"
 
 interface BatchOptions extends CliAdapterOptions {
 	cwd: string
@@ -22,53 +23,65 @@ export class BatchProcessor {
 		this.configManager = configManager
 	}
 
+	private logDebug(message: string, ...args: any[]): void {
+		getCLILogger().debug(message, ...args)
+	}
+
+	private logInfo(message: string, ...args: any[]): void {
+		getCLILogger().info(message, ...args)
+	}
+
+	private logError(message: string, ...args: any[]): void {
+		getCLILogger().error(message, ...args)
+	}
+
 	async run(taskDescription: string): Promise<void> {
 		try {
-			if (this.options.verbose) {
-				console.log(chalk.blue("Starting batch mode..."))
-				console.log(chalk.gray(`Working directory: ${this.options.cwd}`))
-				console.log(chalk.gray(`Task: ${taskDescription}`))
-			}
+			this.logDebug("[BatchProcessor] Starting batch mode...")
+			this.logDebug(`[BatchProcessor] Working directory: ${this.options.cwd}`)
+			this.logDebug(`[BatchProcessor] Task: ${taskDescription}`)
 
 			// Create CLI adapters
+			this.logDebug("[BatchProcessor] Creating CLI adapters...")
 			const adapters = createCliAdapters({
 				workspaceRoot: this.options.cwd,
 				isInteractive: false,
 				verbose: this.options.verbose,
 			})
+			this.logDebug("[BatchProcessor] CLI adapters created")
 
 			// Load configuration
+			this.logDebug("[BatchProcessor] Loading configuration...")
+			//const { apiConfiguration } = await this.loadConfiguration()
 			const { apiConfiguration } = await this.loadConfiguration()
+			this.logDebug("[BatchProcessor] Configuration loaded")
 
 			// Create and execute task
-			const task = new Task({
+			this.logDebug("[BatchProcessor] Creating task...")
+
+			// Use Task.create() to get both the instance and the promise
+			const [task, taskPromise] = Task.create({
 				apiConfiguration,
 				task: taskDescription,
 				fileSystem: adapters.fileSystem,
 				terminal: adapters.terminal,
 				browser: adapters.browser,
 				telemetry: adapters.telemetry,
 				workspacePath: this.options.cwd,
-				globalStoragePath: process.env.HOME ? `${process.env.HOME}/.roo-code` : "/tmp/.roo-code",
+				globalStoragePath: process.env.HOME ? `${process.env.HOME}/.agentz` : "/tmp/.agentz",
+				startTask: true,
+				verbose: this.options.verbose,
 			})
 
-			if (this.options.verbose) {
-				console.log(chalk.blue("Task created, starting execution..."))
-			}
+			this.logDebug("[BatchProcessor] Task created, starting execution...")
 
-			// Execute the task
-			await this.executeTask(task)
+			// Execute the task with proper promise handling
+			await this.executeTask(task, taskPromise)
 
-			if (this.options.verbose) {
-				console.log(chalk.green("Task completed successfully"))
-			}
+			this.logDebug("[BatchProcessor] Task completed successfully")
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error)
-			if (this.options.color) {
-				console.error(chalk.red("Batch execution failed:"), message)
-			} else {
-				console.error("Batch execution failed:", message)
-			}
+			this.logError("Batch execution failed:", message)
 			process.exit(1)
 		}
 	}
@@ -161,24 +174,62 @@ export class BatchProcessor {
 		}
 	}
 
-	private async executeTask(task: Task): Promise<void> {
+	private async executeTask(task: Task, taskPromise: Promise<void>): Promise<void> {
 		return new Promise((resolve, reject) => {
+			this.logDebug("[BatchProcessor] Setting up task event handlers...")
+
 			// Set up event handlers
-			task.on("taskCompleted", () => {
+			task.on("taskCompleted", (taskId: string, tokenUsage: any, toolUsage: any) => {
+				this.logDebug(`[BatchProcessor] Task completed: ${taskId}`)
+				this.logDebug(`[BatchProcessor] Token usage:`, tokenUsage)
+				this.logDebug(`[BatchProcessor] Tool usage:`, toolUsage)
 				resolve()
 			})
 
 			task.on("taskAborted", () => {
+				this.logDebug("[BatchProcessor] Task was aborted")
 				reject(new Error("Task was aborted"))
 			})
 
+			task.on("taskStarted", () => {
+				this.logDebug("[BatchProcessor] Task started")
+			})
+
+			task.on("taskPaused", () => {
+				this.logDebug("[BatchProcessor] Task paused")
+			})
+
+			task.on("taskUnpaused", () => {
+				this.logDebug("[BatchProcessor] Task unpaused")
+			})
+
 			// Handle tool failures
 			task.on("taskToolFailed", (taskId: string, tool: string, error: string) => {
+				this.logDebug(`[BatchProcessor] Tool ${tool} failed: ${error}`)
 				reject(new Error(`Tool ${tool} failed: ${error}`))
 			})
 
-			// Start the task - this should be done automatically if startTask is true (default)
-			// The task should start automatically based on the constructor options
+			this.logDebug("[BatchProcessor] Event handlers set up, waiting for task execution...")
+			this.logDebug(`[BatchProcessor] Task ID: ${task.taskId}`)
+			this.logDebug(`[BatchProcessor] Task initialized: ${task.isInitialized}`)
+			this.logDebug(`[BatchProcessor] Task aborted: ${task.abort}`)
+
+			// Wait for the task promise and handle errors
+			taskPromise.catch((error) => {
+				this.logDebug(`[BatchProcessor] Task promise rejected:`, error)
+				reject(error)
+			})
+
+			// Add a timeout to prevent hanging - increased for complex tasks
+			const timeoutMs = 60000 // 60 seconds
+			const timeout = setTimeout(() => {
+				this.logDebug(`[BatchProcessor] Task execution timeout after ${timeoutMs}ms`)
+				reject(new Error(`Task execution timeout after ${timeoutMs}ms`))
+			}, timeoutMs)
+
+			// Clear timeout when task completes
+			task.on("taskCompleted", () => clearTimeout(timeout))
+			task.on("taskAborted", () => clearTimeout(timeout))
 		})
 	}
 }