pulse-coder-cli 0.0.1-alpha.1

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "pulse-coder-cli",
+  "version": "0.0.1-alpha.1",
+  "description": "CLI interface for Pulse Coder",
+  "type": "module",
+  "main": "./dist/index.js",
+  "bin": {
+    "pulse-coder": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "@pulse-coder/engine": "workspace:*"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "tsup": "^8.0.0",
+    "vitest": "^1.0.0",
+    "@types/node": "^25.0.10"
+  }
+}

package/src/index.ts

@@ -0,0 +1,321 @@
+import { PulseAgent } from '@pulse-coder/engine';
+import * as readline from 'readline';
+import type { Context } from '@pulse-coder/engine';
+import { SessionCommands } from './session-commands.js';
+import { InputManager } from './input-manager.js';
+
+class CoderCLI {
+  private agent: PulseAgent;
+  private context: Context;
+  private sessionCommands: SessionCommands;
+  private inputManager: InputManager;
+
+  constructor() {
+    // 🎯 现在引擎自动包含内置插件，无需显式配置！
+    this.agent = new PulseAgent({
+      enginePlugins: {
+        // 只配置扩展插件目录，内置插件会自动加载
+        dirs: ['.pulse-coder/engine-plugins', '.coder/engine-plugins', '~/.pulse-coder/engine-plugins', '~/.coder/engine-plugins'],
+        scan: true
+      },
+      userConfigPlugins: {
+        dirs: ['.pulse-coder/config', '.coder/config', '~/.pulse-coder/config', '~/.coder/config'],
+        scan: true
+      }
+      // 注意：不再需要 plugins: [...] 配置
+    });
+    this.context = { messages: [] };
+    this.sessionCommands = new SessionCommands();
+    this.inputManager = new InputManager();
+  }
+
+  private async handleCommand(command: string, args: string[]): Promise<void> {
+    try {
+      switch (command.toLowerCase()) {
+        case 'help':
+          console.log('\n📋 Available commands:');
+          console.log('/help - Show this help message');
+          console.log('/new [title] - Create a new session');
+          console.log('/resume <id> - Resume a saved session');
+          console.log('/sessions - List all saved sessions');
+          console.log('/search <query> - Search in saved sessions');
+          console.log('/rename <id> <new-title> - Rename a session');
+          console.log('/delete <id> - Delete a session');
+          console.log('/clear - Clear current conversation');
+          console.log('/status - Show current session status');
+          console.log('/save - Save current session explicitly');
+          console.log('/exit - Exit the application');
+          break;
+
+        case 'new':
+          const newTitle = args.join(' ') || undefined;
+          await this.sessionCommands.createSession(newTitle);
+          this.context.messages = [];
+          break;
+
+        case 'resume':
+          if (args.length === 0) {
+            console.log('\n❌ Please provide a session ID');
+            console.log('Usage: /resume <session-id>');
+            break;
+          }
+          const sessionId = args[0];
+          const success = await this.sessionCommands.resumeSession(sessionId);
+          if (success) {
+            await this.sessionCommands.loadContext(this.context);
+          }
+          break;
+
+        case 'sessions':
+          await this.sessionCommands.listSessions();
+          break;
+
+        case 'search':
+          if (args.length === 0) {
+            console.log('\n❌ Please provide a search query');
+            console.log('Usage: /search <query>');
+            break;
+          }
+          const query = args.join(' ');
+          await this.sessionCommands.searchSessions(query);
+          break;
+
+        case 'rename':
+          if (args.length < 2) {
+            console.log('\n❌ Please provide session ID and new title');
+            console.log('Usage: /rename <session-id> <new-title>');
+            break;
+          }
+          const renameId = args[0];
+          const newName = args.slice(1).join(' ');
+          await this.sessionCommands.renameSession(renameId, newName);
+          break;
+
+        case 'delete':
+          if (args.length === 0) {
+            console.log('\n❌ Please provide a session ID');
+            console.log('Usage: /delete <session-id>');
+            break;
+          }
+          const deleteId = args[0];
+          await this.sessionCommands.deleteSession(deleteId);
+          break;
+
+        case 'clear':
+          this.context.messages = [];
+          console.log('\n🧹 Current conversation cleared!');
+          break;
+
+        case 'status':
+          const currentId = this.sessionCommands.getCurrentSessionId();
+          console.log(`\n📊 Session Status:`);
+          console.log(`Current Session: ${currentId || 'None (new session)'}`);
+          console.log(`Messages: ${this.context.messages.length}`);
+          if (currentId) {
+            console.log(`To save this session, use: /save`);
+          }
+          break;
+
+        case 'save':
+          if (this.sessionCommands.getCurrentSessionId()) {
+            await this.sessionCommands.saveContext(this.context);
+            console.log('\n💾 Current session saved!');
+          } else {
+            console.log('\n❌ No active session. Create one with /new');
+          }
+          break;
+
+        case 'exit':
+          console.log('💾 Saving current session...');
+          await this.sessionCommands.saveContext(this.context);
+          console.log('Goodbye!');
+          process.exit(0);
+          break;
+
+        default:
+          console.log(`\n⚠️ Unknown command: ${command}`);
+          console.log('Type /help to see available commands');
+      }
+    } catch (error) {
+      console.error('\n❌ Error executing command:', error);
+    }
+  }
+
+  async start() {
+    console.log('🚀 Pulse Coder CLI is running...');
+    console.log('Type your messages and press Enter. Type "exit" to quit.');
+    console.log('Commands starting with "/" will trigger command mode.\n');
+
+    await this.sessionCommands.initialize();
+    await this.agent.initialize();
+
+    // 显示插件状态
+    const pluginStatus = this.agent.getPluginStatus();
+    console.log(`✅ Built-in plugins loaded: ${pluginStatus.enginePlugins.length} plugins`);
+
+    // Auto-create a new session
+    await this.sessionCommands.createSession();
+
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      prompt: '> '
+    });
+
+    let currentAbortController: AbortController | null = null;
+    let isProcessing = false;
+
+    // Handle SIGINT gracefully
+    process.on('SIGINT', () => {
+      if (isProcessing && currentAbortController && !currentAbortController.signal.aborted) {
+        currentAbortController.abort();
+        console.log('\n[Abort] Request cancelled.');
+        return;
+      }
+
+      // Cancel any pending clarification request
+      if (this.inputManager.hasPendingRequest()) {
+        this.inputManager.cancel('User interrupted with Ctrl+C');
+        console.log('\n[Abort] Clarification cancelled.');
+        rl.prompt();
+        return;
+      }
+
+      console.log('\n💾 Saving current session...');
+      this.sessionCommands.saveContext(this.context).then(() => {
+        console.log('👋 Goodbye!');
+        process.exit(0);
+      });
+    });
+
+    // Main input handler
+    const handleInput = async (input: string) => {
+      const trimmedInput = input.trim();
+
+      // Handle clarification requests first
+      if (this.inputManager.handleUserInput(trimmedInput)) {
+        return;
+      }
+
+      if (trimmedInput.toLowerCase() === 'exit') {
+        console.log('💾 Saving current session...');
+        await this.sessionCommands.saveContext(this.context);
+        console.log('👋 Goodbye!');
+        rl.close();
+        return;
+      }
+
+      if (!trimmedInput) {
+        rl.prompt();
+        return;
+      }
+
+      // Handle commands
+      if (trimmedInput.startsWith('/')) {
+        const commandLine = trimmedInput.substring(1);
+        const parts = commandLine.split(/\s+/).filter(part => part.length > 0);
+
+        if (parts.length === 0) {
+          console.log('\n⚠️ Please provide a command after "/"');
+          rl.prompt();
+          return;
+        }
+
+        const command = parts[0];
+        const args = parts.slice(1);
+
+        await this.handleCommand(command, args);
+        rl.prompt();
+        return;
+      }
+
+      // Regular message processing
+      this.context.messages.push({
+        role: 'user',
+        content: trimmedInput,
+      });
+
+      console.log('\n🔄 Processing...\n');
+
+      const ac = new AbortController();
+      currentAbortController = ac;
+      isProcessing = true;
+
+      let sawText = false;
+
+      try {
+        const result = await this.agent.run(this.context, {
+          abortSignal: ac.signal,
+          onText: (delta) => {
+            sawText = true;
+            process.stdout.write(delta);
+          },
+          onToolCall: (toolCall) => {
+            const input = 'input' in toolCall ? toolCall.input : undefined;
+            const inputText = input === undefined ? '' : `(${JSON.stringify(input)})`;
+            process.stdout.write(`\n🔧 ${toolCall.toolName}${inputText}\n`);
+          },
+          onToolResult: (toolResult) => {
+            process.stdout.write(`\n✅ ${toolResult.toolName}\n`);
+          },
+          onStepFinish: (step) => {
+            process.stdout.write(`\n📋 Step finished: ${step.finishReason}\n`);
+          },
+          onClarificationRequest: async (request) => {
+            return await this.inputManager.requestInput(request);
+          },
+          onCompacted: (newMessages) => {
+            this.context.messages = newMessages;
+          },
+          onResponse: (messages) => {
+            this.context.messages.push(...messages);
+          },
+        });
+
+        if (result) {
+          if (!sawText) {
+            console.log(result);
+          } else {
+            console.log();
+          }
+
+          this.context.messages.push({
+            role: 'assistant',
+            content: result,
+          });
+
+          await this.sessionCommands.saveContext(this.context);
+        }
+      } catch (error) {
+        if (error.name === 'AbortError') {
+          console.log('\n[Abort] Operation cancelled.');
+        } else {
+          console.error('\n❌ Error:', error.message);
+        }
+      } finally {
+        isProcessing = false;
+        currentAbortController = null;
+        rl.prompt();
+      }
+    };
+
+    // Start the CLI
+    rl.prompt();
+    rl.on('line', handleInput);
+
+    // Handle terminal close
+    rl.on('close', async () => {
+      console.log('\n💾 Saving current session...');
+      await this.sessionCommands.saveContext(this.context);
+      console.log('👋 Goodbye!');
+      process.exit(0);
+    });
+  }
+}
+
+// Always start the CLI when executed directly
+const cli = new CoderCLI();
+cli.start().catch(error => {
+  console.error('Failed to start CLI:', error);
+  process.exit(1);
+});

package/src/input-manager.ts

@@ -0,0 +1,113 @@
+import type { ClarificationRequest } from '@pulse-coder/engine';
+
+interface PendingRequest {
+  request: ClarificationRequest;
+  resolve: (answer: string) => void;
+  reject: (error: Error) => void;
+  timeoutId?: NodeJS.Timeout;
+}
+
+/**
+ * InputManager handles asynchronous user input for clarification requests.
+ * It manages pending clarification requests and coordinates with the readline interface.
+ */
+export class InputManager {
+  private pendingRequest: PendingRequest | null = null;
+
+  /**
+   * Request user input for a clarification
+   * @param request The clarification request details
+   * @returns Promise that resolves with the user's answer
+   */
+  async requestInput(request: ClarificationRequest): Promise<string> {
+    return new Promise<string>((resolve, reject) => {
+      // If there's already a pending request, reject this one
+      if (this.pendingRequest) {
+        reject(new Error('Another clarification request is already pending'));
+        return;
+      }
+
+      // Display the question to the user
+      console.log(`\n❓ ${request.question}`);
+      if (request.context) {
+        console.log(`   ${request.context}`);
+      }
+      if (request.defaultAnswer) {
+        console.log(`   (Default: ${request.defaultAnswer})`);
+      }
+      console.log(''); // Empty line for spacing
+
+      // Set up timeout if specified
+      let timeoutId: NodeJS.Timeout | undefined;
+      if (request.timeout > 0) {
+        timeoutId = setTimeout(() => {
+          if (this.pendingRequest?.request.id === request.id) {
+            const error = new Error(`Clarification request timed out after ${request.timeout}ms`);
+            this.pendingRequest.reject(error);
+            this.pendingRequest = null;
+          }
+        }, request.timeout);
+      }
+
+      // Store the pending request
+      this.pendingRequest = {
+        request,
+        resolve,
+        reject,
+        timeoutId
+      };
+    });
+  }
+
+  /**
+   * Handle user input - checks if there's a pending clarification request
+   * @param input The user's input
+   * @returns true if input was consumed by a pending clarification, false otherwise
+   */
+  handleUserInput(input: string): boolean {
+    if (!this.pendingRequest) {
+      return false;
+    }
+
+    // Clear the timeout if it exists
+    if (this.pendingRequest.timeoutId) {
+      clearTimeout(this.pendingRequest.timeoutId);
+    }
+
+    // Resolve the pending request with the user's input
+    const trimmedInput = input.trim();
+    this.pendingRequest.resolve(trimmedInput);
+    this.pendingRequest = null;
+
+    return true;
+  }
+
+  /**
+   * Cancel any pending clarification request
+   * @param reason Optional cancellation reason
+   */
+  cancel(reason?: string): void {
+    if (this.pendingRequest) {
+      if (this.pendingRequest.timeoutId) {
+        clearTimeout(this.pendingRequest.timeoutId);
+      }
+
+      this.pendingRequest.reject(new Error(reason || 'Clarification request cancelled'));
+      this.pendingRequest = null;
+    }
+  }
+
+  /**
+   * Check if there's a pending clarification request
+   */
+  hasPendingRequest(): boolean {
+    return this.pendingRequest !== null;
+  }
+
+  /**
+   * Get the current pending request (for debugging/testing)
+   */
+  getPendingRequest(): ClarificationRequest | null {
+    return this.pendingRequest?.request || null;
+  }
+}

package/src/session-commands.ts

@@ -0,0 +1,142 @@
+import { SessionManager } from './session.js';
+import type { Context } from '@pulse-coder/engine';
+
+export class SessionCommands {
+  private sessionManager: SessionManager;
+  private currentSessionId: string | null = null;
+
+  constructor() {
+    this.sessionManager = new SessionManager();
+  }
+
+  async initialize(): Promise<void> {
+    await this.sessionManager.initialize();
+  }
+
+  getCurrentSessionId(): string | null {
+    return this.currentSessionId;
+  }
+
+  async createSession(title?: string): Promise<string> {
+    const session = await this.sessionManager.createSession(title);
+    this.currentSessionId = session.id;
+    console.log(`\n✅ New session created: ${session.title} (ID: ${session.id})`);
+    return session.id;
+  }
+
+  async resumeSession(id: string): Promise<boolean> {
+    const session = await this.sessionManager.loadSession(id);
+    if (!session) {
+      console.log(`\n❌ Session not found: ${id}`);
+      return false;
+    }
+
+    this.currentSessionId = session.id;
+    console.log(`\n✅ Resumed session: ${session.title} (ID: ${session.id})`);
+    console.log(`📊 Loaded ${session.messages.length} messages`);
+
+    // Show last few messages as context
+    const recentMessages = session.messages.slice(-5);
+    if (recentMessages.length > 0) {
+      console.log('\n💬 Recent conversation:');
+      recentMessages.forEach((msg, index) => {
+        const role = msg.role === 'user' ? '👤 You' : '🤖 Assistant';
+        const contentStr = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content);
+        const preview = contentStr.substring(0, 100) + (contentStr.length > 100 ? '...' : '');
+        console.log(`${index + 1}. ${role}: ${preview}`);
+      });
+    }
+
+    return true;
+  }
+
+  async listSessions(): Promise<void> {
+    const sessions = await this.sessionManager.listSessions();
+    
+    if (sessions.length === 0) {
+      console.log('\n📭 No saved sessions found.');
+      return;
+    }
+
+    console.log('\n📋 Saved sessions:');
+    console.log('='.repeat(80));
+    
+    sessions.forEach((session, index) => {
+      const isActive = session.id === this.currentSessionId ? '✅' : '  ';
+      const date = new Date(session.updatedAt).toLocaleString();
+      console.log(`${index + 1}. ${isActive} ${session.title}`);
+      console.log(`   ID: ${session.id}`);
+      console.log(`   Messages: ${session.messageCount} | Updated: ${date}`);
+      console.log(`   Preview: ${session.preview}`);
+      console.log();
+    });
+  }
+
+  async saveContext(context: Context): Promise<void> {
+    if (!this.currentSessionId) return;
+
+    const session = await this.sessionManager.loadSession(this.currentSessionId);
+    if (!session) return;
+
+    // Sync messages from context
+    session.messages = context.messages.map(msg => ({
+      role: msg.role as 'user' | 'assistant' | 'system',
+      content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
+      timestamp: Date.now(),
+    }));
+
+    await this.sessionManager.saveSession(session);
+  }
+
+  async loadContext(context: Context): Promise<void> {
+    if (!this.currentSessionId) return;
+
+    const session = await this.sessionManager.loadSession(this.currentSessionId);
+    if (!session) return;
+
+    // Load messages into context
+    context.messages = session.messages.map(msg => ({
+      role: msg.role,
+      content: msg.content,
+    }));
+  }
+
+  async searchSessions(query: string): Promise<void> {
+    const sessions = await this.sessionManager.searchSessions(query);
+    
+    if (sessions.length === 0) {
+      console.log(`\n🔍 No sessions found matching "${query}"`);
+      return;
+    }
+
+    console.log(`\n🔍 Search results for "${query}":`);
+    sessions.forEach((session, index) => {
+      console.log(`${index + 1}. ${session.title} (${session.id}) - ${session.messageCount} messages`);
+      console.log(`   Updated: ${new Date(session.updatedAt).toLocaleString()}`);
+      console.log(`   Preview: ${session.preview}`);
+    });
+  }
+
+  async deleteSession(id: string): Promise<boolean> {
+    const success = await this.sessionManager.deleteSession(id);
+    if (success) {
+      console.log(`\n🗑️ Session ${id} deleted`);
+      if (this.currentSessionId === id) {
+        this.currentSessionId = null;
+      }
+    } else {
+      console.log(`\n❌ Failed to delete session ${id}`);
+    }
+    return success;
+  }
+
+  async renameSession(id: string, newTitle: string): Promise<boolean> {
+    const success = await this.sessionManager.updateSessionTitle(id, newTitle);
+    if (success) {
+      console.log(`\n✅ Session ${id} renamed to "${newTitle}"`);
+    } else {
+      console.log(`\n❌ Failed to rename session ${id}`);
+    }
+    return success;
+  }
+}