orquesta-cli 0.1.12

package/src/cli.ts

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+
+/**
+ * Orquesta CLI
+ * AI-powered coding assistant with local LLM support
+ *
+ * Entry Point: CLI application entry point
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import React from 'react';
+import { render } from 'ink';
+import { createRequire } from 'module';
+import { configManager } from './core/config/config-manager.js';
+import { createLLMClient } from './core/llm/llm-client.js';
+import { PlanExecuteApp } from './ui/components/PlanExecuteApp.js';
+import { setupLogging, logger } from './utils/logger.js';
+import { runEvalMode } from './eval/index.js';
+import { initializeOptionalTools } from './tools/registry.js';
+import { sessionManager } from './core/session/session-manager.js';
+
+// Read version from package.json (single source of truth)
+const require = createRequire(import.meta.url);
+const packageJson = require('../package.json') as { version: string };
+
+const program = new Command();
+
+/**
+ * CLI program configuration
+ */
+program
+  .name('orquesta')
+  .description('Orquesta CLI - AI-powered coding assistant with local LLM support')
+  .version(packageJson.version)
+  .helpOption(false);  // Disable -h, --help (use /help command instead)
+
+/**
+ * Default command: Start interactive mode
+ */
+program
+  .option('-p, --print <prompt>', 'Execute a prompt and exit (non-interactive mode)')
+  .option('--dangerously-skip-permissions', 'Skip all permission prompts (auto-approve)')
+  .option('--verbose', 'Enable verbose logging')
+  .option('--debug', 'Enable debug logging')
+  .option('--llm-log', 'Enable LLM logging')
+  .option('--eval', 'Evaluation mode: read JSON from stdin, output NDJSON events')
+  .action(async (options: { print?: string; dangerouslySkipPermissions?: boolean; verbose?: boolean; debug?: boolean; llmLog?: boolean; eval?: boolean }) => {
+    // --eval mode: stdin JSON input, stdout NDJSON event output
+    if (options.eval) {
+      await runEvalMode();
+      return;
+    }
+
+    // -p mode: Execute prompt and exit (orquesta-agent compatibility)
+    if (options.print) {
+      const { EvalRunner } = await import('./eval/eval-runner.js');
+      const runner = new EvalRunner();
+      await runner.run({
+        prompt: options.print,
+        working_dir: process.cwd(),
+      });
+      return;
+    }
+
+    let cleanup: (() => Promise<void>) | null = null;
+    try {
+      // Clear terminal on start
+      process.stdout.write('\x1B[2J\x1B[0f');
+
+      // Show loading spinner immediately (before any async work)
+      const ora = (await import('ora')).default;
+      const spinner = ora({
+        text: chalk.cyan('Loading...'),
+        color: 'cyan',
+      }).start();
+
+      // Setup logging (log level, JSON stream logger, exit handlers)
+      const loggingSetup = await setupLogging({
+        verbose: options.verbose,
+        debug: options.debug,
+        llmLog: options.llmLog,
+      });
+      cleanup = loggingSetup.cleanup;
+
+      // Log session start
+      logger.sessionStart({
+        sessionId: sessionManager.getCurrentSessionId(),
+        verbose: options.verbose,
+        debug: options.debug,
+        llmLog: options.llmLog,
+        cwd: process.cwd(),
+        platform: process.platform,
+        nodeVersion: process.version,
+      });
+
+      // Initialize ConfigManager
+      spinner.text = chalk.cyan('Loading configuration...');
+      logger.flow('Initializing config manager');
+      await configManager.initialize();
+      logger.flow('Config manager initialized');
+
+      // Load saved optional tool states (e.g., browser tools, Office tools)
+      logger.flow('Initializing optional tools');
+      await initializeOptionalTools();
+      logger.flow('Optional tools initialized');
+
+      // Create LLMClient (null if no endpoints)
+      spinner.text = chalk.cyan('Connecting to LLM...');
+      let llmClient = null;
+      let modelInfo = { model: 'Not configured', endpoint: 'Not configured' };
+
+      if (configManager.hasEndpoints()) {
+        logger.flow('Creating LLM client');
+        try {
+          llmClient = createLLMClient();
+          modelInfo = llmClient.getModelInfo();
+          logger.flow('LLM client created', { model: modelInfo.model, endpoint: modelInfo.endpoint });
+        } catch (error) {
+          // Keep null on LLMClient creation failure
+          logger.warn('Failed to create LLM client', { error: error instanceof Error ? error.message : String(error) });
+        }
+      } else {
+        logger.flow('No LLM endpoints configured');
+      }
+
+      // Stop spinner before starting Ink UI
+      spinner.stop();
+      process.stdout.write('\x1B[2J\x1B[0f'); // Clear again for clean UI
+
+      // Start Ink UI (show start message only in verbose/debug/llm-log mode)
+      if (options.verbose || options.debug) {
+        console.log(chalk.cyan('Starting Orquesta CLI...\n'));
+      }
+
+      // Render Ink UI directly in same process (keep stdin raw mode)
+      try {
+        // Use PlanExecuteApp for enhanced functionality
+        // exitOnCtrlC: false - Ctrl+C is handled manually in PlanExecuteApp for smart behavior
+        const { waitUntilExit } = render(
+          React.createElement(PlanExecuteApp, { llmClient, modelInfo }),
+          { exitOnCtrlC: false }
+        );
+
+        // Wait until the UI exits before cleanup
+        await waitUntilExit();
+      } catch (error) {
+        console.log(chalk.yellow('\n⚠️  Cannot start Ink UI.\n'));
+        console.log(chalk.dim(`Error: ${error instanceof Error ? error.message : String(error)}\n`));
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(chalk.red('\n❌ Error occurred:'));
+      if (error instanceof Error) {
+        console.error(chalk.red(error.message));
+      }
+      console.log();
+      process.exit(1);
+    } finally {
+      // Log session end
+      logger.sessionEnd({
+        sessionId: sessionManager.getCurrentSessionId(),
+        exitReason: 'normal',
+      });
+
+      // Cleanup JSON Stream Logger
+      if (cleanup) {
+        await cleanup();
+      }
+    }
+  });
+
+
+/**
+ * Error handling: unknown options
+ */
+program.showHelpAfterError(false);
+program.configureOutput({
+  outputError: (str, write) => {
+    if (str.includes('--help') || str.includes('-h')) {
+      write(chalk.yellow('💡 For help, use /help command after starting the app.\n'));
+    } else {
+      write(chalk.red(str));
+    }
+  }
+});
+
+program.on('command:*', () => {
+  console.error(chalk.red('⚠️  Unknown command.'));
+  console.log(chalk.white('Usage: orquesta [options]\n'));
+  console.log(chalk.white('  -p, --print <prompt>    Execute a prompt and exit\n'));
+  console.log(chalk.white('  --verbose               Enable verbose logging\n'));
+  console.log(chalk.white('  --debug                 Enable debug logging\n'));
+  console.log(chalk.white('\nUse /help in interactive mode for more help.\n'));
+  process.exit(1);
+});
+
+/**
+ * Run CLI program
+ */
+program.parse(process.argv);

package/src/constants.ts

@@ -0,0 +1,47 @@
+/**
+ * Hanseol Constants
+ *
+ * Global constants definition for the project
+ */
+
+import * as path from 'path';
+import * as os from 'os';
+
+/**
+ * Hanseol home directory
+ * ~/.hanseol/
+ */
+export const LOCAL_HOME_DIR = path.join(os.homedir(), '.hanseol');
+
+// Backward compatibility alias
+export const OPEN_HOME_DIR = LOCAL_HOME_DIR;
+
+/**
+ * Config file path
+ * ~/.hanseol/config.json
+ */
+export const CONFIG_FILE_PATH = path.join(LOCAL_HOME_DIR, 'config.json');
+
+/**
+ * Documentation directory
+ * ~/.hanseol/docs/
+ */
+export const DOCS_DIR = path.join(LOCAL_HOME_DIR, 'docs');
+
+/**
+ * Backup directory
+ * ~/.hanseol/backups/
+ */
+export const BACKUPS_DIR = path.join(LOCAL_HOME_DIR, 'backups');
+
+/**
+ * Project-specific log directory
+ * ~/.hanseol/projects/
+ */
+export const PROJECTS_DIR = path.join(LOCAL_HOME_DIR, 'projects');
+
+
+/**
+ * Application version (injected from package.json)
+ */
+export const APP_VERSION = '4.2.2';

package/src/core/compact/compact-manager.ts

@@ -0,0 +1,160 @@
+/**
+ * Compact Manager
+ *
+ * Executes conversation compaction using LLM.
+ * Handles the compact workflow: build prompt → call LLM → parse result.
+ */
+
+import { LLMClient } from '../llm/llm-client.js';
+import { Message } from '../../types/index.js';
+import {
+  COMPACT_SYSTEM_PROMPT,
+  buildCompactUserPrompt,
+  buildCompactedMessages,
+  CompactContext,
+} from './compact-prompts.js';
+import { logger } from '../../utils/logger.js';
+
+/**
+ * Result of compact operation
+ */
+export interface CompactResult {
+  /** Whether compact succeeded */
+  success: boolean;
+  /** Original message count */
+  originalMessageCount: number;
+  /** New message count after compact */
+  newMessageCount: number;
+  /** The compact summary generated */
+  compactedSummary?: string;
+  /** The compacted messages array (for caller to use) */
+  compactedMessages?: Message[];
+  /** Error message if failed */
+  error?: string;
+}
+
+/**
+ * Minimum messages required for compact
+ */
+const MIN_MESSAGES_FOR_COMPACT = 5;
+
+/**
+ * Compact Manager Class
+ */
+export class CompactManager {
+  constructor(private llmClient: LLMClient) {}
+
+  /**
+   * Execute conversation compaction
+   */
+  async compact(
+    messages: Message[],
+    context: CompactContext
+  ): Promise<CompactResult> {
+    logger.enter('CompactManager.compact', {
+      messageCount: messages.length,
+      hasTodos: !!context.todos?.length,
+    });
+
+    // Validate minimum messages
+    const nonSystemMessages = messages.filter(m => m.role !== 'system');
+    if (nonSystemMessages.length < MIN_MESSAGES_FOR_COMPACT) {
+      logger.flow('Compact skipped - not enough messages');
+      logger.exit('CompactManager.compact', { skipped: true });
+      return {
+        success: false,
+        originalMessageCount: messages.length,
+        newMessageCount: messages.length,
+        error: `At least ${MIN_MESSAGES_FOR_COMPACT} messages required. (Current: ${nonSystemMessages.length})`,
+      };
+    }
+
+    try {
+      logger.flow('Building compact prompt');
+
+      // Build the user prompt with context
+      const userPrompt = buildCompactUserPrompt(messages, context);
+
+      logger.vars(
+        { name: 'promptLength', value: userPrompt.length },
+        { name: 'todoCount', value: context.todos?.length || 0 },
+        { name: 'recentFilesCount', value: context.recentFiles?.length || 0 }
+      );
+
+      // Call LLM for compaction
+      logger.flow('Calling LLM for compaction');
+      logger.startTimer('compact-llm');
+
+      const response = await this.llmClient.sendMessage(
+        userPrompt,
+        COMPACT_SYSTEM_PROMPT
+      );
+
+      const elapsed = logger.endTimer('compact-llm');
+      logger.debug('Compact LLM response received', { elapsed, responseLength: response.length });
+
+      // Validate response
+      if (!response || response.trim().length === 0) {
+        throw new Error('LLM returned empty response');
+      }
+
+      // Build compacted messages
+      const compactedMessages = buildCompactedMessages(response, context);
+
+      // Note: contextTracker.reset() is called by PlanExecutor after applying final messages
+      // This keeps CompactManager focused on summary generation only
+
+      logger.flow('Compact completed successfully');
+      logger.vars(
+        { name: 'originalCount', value: messages.length },
+        { name: 'newCount', value: compactedMessages.length }
+      );
+
+      logger.exit('CompactManager.compact', { success: true });
+
+      return {
+        success: true,
+        originalMessageCount: messages.length,
+        newMessageCount: compactedMessages.length,
+        compactedSummary: response,
+        compactedMessages,
+      };
+
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      logger.error('Compact failed', error as Error);
+      logger.exit('CompactManager.compact', { success: false, error: errorMessage });
+
+      return {
+        success: false,
+        originalMessageCount: messages.length,
+        newMessageCount: messages.length,
+        error: `Compact failed: ${errorMessage}`,
+      };
+    }
+  }
+
+  /**
+   * Build compacted messages from summary
+   * Utility method for external use
+   */
+  buildCompactedMessages(summary: string, context: CompactContext): Message[] {
+    return buildCompactedMessages(summary, context);
+  }
+
+  /**
+   * Check if compact is possible
+   */
+  canCompact(messages: Message[]): { canCompact: boolean; reason?: string } {
+    const nonSystemMessages = messages.filter(m => m.role !== 'system');
+
+    if (nonSystemMessages.length < MIN_MESSAGES_FOR_COMPACT) {
+      return {
+        canCompact: false,
+        reason: `At least ${MIN_MESSAGES_FOR_COMPACT} messages required.`,
+      };
+    }
+
+    return { canCompact: true };
+  }
+}

package/src/core/compact/compact-prompts.ts

@@ -0,0 +1,150 @@
+/**
+ * Compact Prompts
+ *
+ * System prompt and user prompt builder for conversation compaction.
+ * Implements dynamic context injection for TODOs, recent files, etc.
+ */
+
+import { Message, TodoItem } from '../../types/index.js';
+
+// Re-export COMPACT_SYSTEM_PROMPT from centralized location
+export { COMPACT_SYSTEM_PROMPT } from '../../prompts/system/compact.js';
+
+/**
+ * Context to inject into compact prompt
+ */
+export interface CompactContext {
+  /** Current TODO list from system state */
+  todos?: TodoItem[];
+  /** Current working directory */
+  workingDirectory?: string;
+  /** Current model name */
+  currentModel?: string;
+  /** Recently accessed files */
+  recentFiles?: string[];
+}
+
+/**
+ * Build user prompt with dynamic context injection
+ */
+export function buildCompactUserPrompt(
+  messages: Message[],
+  context: CompactContext
+): string {
+  const parts: string[] = [];
+
+  // 1. Current System State
+  parts.push('# Current System State');
+  parts.push(`Working Directory: ${context.workingDirectory || process.cwd()}`);
+  if (context.currentModel) {
+    parts.push(`Model: ${context.currentModel}`);
+  }
+
+  // 2. Recent Files (if any)
+  if (context.recentFiles && context.recentFiles.length > 0) {
+    parts.push('');
+    parts.push('Recent Files Accessed:');
+    context.recentFiles.forEach(f => parts.push(`- \`${f}\``));
+  }
+
+  // 3. Current TODO List (MUST PRESERVE - injected from system state)
+  if (context.todos && context.todos.length > 0) {
+    parts.push('');
+    parts.push('# Current TODO List (MUST PRESERVE)');
+    context.todos.forEach(todo => {
+      const statusIcon = todo.status === 'completed' ? 'x' :
+                        todo.status === 'in_progress' ? '~' : ' ';
+      const statusLabel = todo.status === 'in_progress' ? ' [IN PROGRESS]' :
+                         todo.status === 'completed' ? ' [DONE]' : '';
+      parts.push(`- [${statusIcon}] ${todo.title}${statusLabel}`);
+      if (todo.result) {
+        parts.push(`  Result: ${todo.result}`);
+      }
+    });
+  }
+
+  // 4. Conversation History
+  parts.push('');
+  parts.push('# Conversation History to Compress');
+  parts.push('```');
+
+  let messageIndex = 0;
+  messages.forEach((msg) => {
+    // Skip system messages
+    if (msg.role === 'system') return;
+
+    messageIndex++;
+    const role = msg.role === 'user' ? 'USER'
+      : msg.role === 'tool' ? 'TOOL_RESULT'
+      : 'ASSISTANT';
+
+    // For assistant messages with tool_calls, show what tools were called
+    const toolCallInfo = msg.tool_calls?.length
+      ? `\n[Called tools: ${msg.tool_calls.map((tc) => tc.function?.name).join(', ')}]`
+      : '';
+
+    const content = typeof msg.content === 'string'
+      ? msg.content
+      : JSON.stringify(msg.content);
+
+    // Truncate very long messages (keep first 3000 chars)
+    const truncated = content.length > 3000
+      ? content.slice(0, 3000) + '\n... [truncated]'
+      : content;
+
+    if (msg.role === 'tool') {
+      parts.push(`[${messageIndex}] ${role} (call_id: ${msg.tool_call_id || 'unknown'}):`);
+    } else {
+      parts.push(`[${messageIndex}] ${role}:${toolCallInfo}`);
+    }
+    parts.push(truncated);
+    parts.push('');
+  });
+
+  parts.push('```');
+
+  // 5. Compression Instructions
+  parts.push('');
+  parts.push('# Instructions');
+  parts.push('Compress the above conversation into the specified format.');
+  if (context.todos && context.todos.length > 0) {
+    parts.push('CRITICAL: The TODO list above is the CURRENT state - preserve it exactly in your Active Tasks section.');
+  }
+  parts.push('Focus on what matters for continuing the work.');
+
+  return parts.join('\n');
+}
+
+/**
+ * Build messages array after compact
+ * Creates user message with session context, assistant acknowledgment, and continue prompt
+ * Note: System prompt will be added by plan-executor when needed
+ */
+export function buildCompactedMessages(
+  compactSummary: string,
+  context: CompactContext
+): Message[] {
+  // Compact summary as user message (not system) to avoid multiple system messages
+  const contextMessage = `[SESSION CONTEXT - Previous conversation was compacted]
+
+${compactSummary}
+
+---
+Working Directory: ${context.workingDirectory || process.cwd()}
+`;
+
+  return [
+    {
+      role: 'user',
+      content: contextMessage,
+    },
+    {
+      role: 'assistant',
+      content: 'Understood. I have the session context.',
+    },
+    {
+      role: 'user',
+      content: 'Please continue your work.',
+    },
+  ];
+}