@oflow-ai/oflow-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 oFlow Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,117 @@
+# oFlow CLI
+
+AI-powered CLI assistant for developers. Supports multiple AI providers including OpenAI and Chinese open-source models.
+
+## Installation
+
+### Mac/Linux/Ubuntu
+
+```bash
+npm i -g @oflow-ai/oflow-cli
+```
+
+### Windows
+
+1. Restart your terminal (CMD or PowerShell)
+2. Run:
+```bash
+npm install -g @oflow-ai/oflow-cli
+```
+
+## Quick Start
+
+```bash
+# Start oFlow CLI
+oflow
+
+# Configure authentication
+oflow auth
+
+# List available models
+oflow models
+```
+
+## Supported AI Providers
+
+### OpenAI
+- gpt-4o
+- gpt-4o-mini
+- gpt-4-turbo
+- o1-preview
+- o1-mini
+
+### Chinese Open-Source Models
+
+| Provider | Models | Features |
+|----------|--------|----------|
+| DeepSeek | deepseek-chat, deepseek-reasoner | Reasoning with thinking process |
+| Qwen (通义千问) | qwen-turbo/plus/max/long | Chinese optimized |
+| GLM (智谱) | glm-4/plus/flash/long | Free tier available |
+| Baichuan (百川) | Baichuan4, Baichuan3-Turbo | Chinese optimized |
+| Yi (零一万物) | yi-lightning/large/medium | Cost-effective |
+| Moonshot (月之暗面) | moonshot-v1-8k/32k/128k | Long context |
+| SiliconFlow | Multiple open-source models | One-stop API |
+
+## CLI Options
+
+```bash
+oflow [options] [command] [prompt]
+
+Options:
+  -V, --version          output the version number
+  -m, --model <model>    Specify the AI model to use
+  -d, --directory <dir>  Working directory
+  --yolo                 Run in yolo mode (auto-approve all operations)
+  --thinking             Show AI thinking/reasoning process
+  --no-thinking          Hide AI thinking/reasoning process
+  -h, --help             display help for command
+
+Commands:
+  auth [options]         Configure authentication
+  config [options]       View or edit configuration
+  models                 List available AI models
+```
+
+## Slash Commands
+
+Inside the interactive CLI:
+
+| Command | Description |
+|---------|-------------|
+| `/help` | Show help message |
+| `/exit` | Exit CLI |
+| `/clear` | Clear conversation history |
+| `/init` | Analyze current project |
+| `/model [name]` | Show or set current model |
+| `/config` | Show configuration |
+| `/thinking` | Toggle thinking process display |
+| `/tools` | List available tools |
+| `/agents` | List available sub-agents |
+| `/history` | Show conversation history |
+| `/commit` | Generate commit message |
+| `/review` | Review recent code changes |
+
+## Features
+
+- **Multi-provider support**: OpenAI, DeepSeek, Qwen, GLM, and more
+- **Tool calling**: File operations, shell commands, web search
+- **Thinking process**: View AI reasoning for supported models (DeepSeek Reasoner)
+- **Sub-agents**: Specialized agents for different tasks
+- **MCP integration**: Extend with Model Context Protocol servers
+- **Skill system**: Installable skill packages
+- **Sandbox mode**: Isolated execution with Docker/Podman
+
+## Configuration
+
+Configuration is stored in:
+- macOS/Linux: `~/.config/oflow-nodejs/config.json`
+- Windows: `%APPDATA%\oflow-nodejs\config.json`
+
+## Requirements
+
+- Node.js 18.0.0 or higher
+- npm 9.0.0 or higher
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1,8 @@
+export interface CLIOptions {
+    model?: string;
+    yolo?: boolean;
+    sandbox?: boolean;
+    showThinking?: boolean;
+}
+export declare function startInteractiveMode(options: CLIOptions): Promise<void>;
+export declare function runSingleCommand(prompt: string, options: CLIOptions): Promise<void>;

package/dist/cli.js

@@ -0,0 +1,339 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startInteractiveMode = startInteractiveMode;
+exports.runSingleCommand = runSingleCommand;
+const readline = __importStar(require("readline"));
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const core_1 = require("@oflow-ai/core");
+const commands_1 = require("./commands");
+let sandboxExecutor = null;
+let showThinking = false;
+async function startInteractiveMode(options) {
+    const configManager = (0, core_1.getConfigManager)();
+    const auth = configManager.getAuth();
+    if (!auth) {
+        console.log(chalk_1.default.red('Not authenticated. Run `oflow auth` first.'));
+        return;
+    }
+    // 初始化沙箱执行器
+    if (options.sandbox || configManager.get('sandbox')) {
+        sandboxExecutor = await (0, core_1.createSandboxExecutor)();
+        console.log(chalk_1.default.gray(`Sandbox mode: ${sandboxExecutor ? 'enabled' : 'unavailable'}`));
+    }
+    // 获取思考过程显示设置
+    showThinking = options.showThinking ?? configManager.getShowThinking();
+    const model = options.model || configManager.getDefaultModel() || 'gpt-4o';
+    const provider = (0, core_1.createAIProvider)(auth, model);
+    const agentFactory = new core_1.AgentFactory(provider, process.cwd());
+    const conversation = new core_1.Conversation({
+        provider,
+        workingDirectory: process.cwd(),
+        maxTokens: configManager.get('maxTokens'),
+        temperature: configManager.get('temperature'),
+        showThinking: showThinking,
+        onContent: (content) => {
+            process.stdout.write(chalk_1.default.white(content));
+        },
+        onThinking: (thinking) => {
+            // 显示思考过程，使用不同的颜色
+            process.stdout.write(chalk_1.default.magenta(thinking));
+        },
+        onToolCall: (toolCall) => {
+            console.log(chalk_1.default.cyan(`\n🔧 Using tool: ${toolCall.function.name}`));
+        },
+        onToolResult: (result) => {
+            // Tool result is handled silently
+        }
+    });
+    // Set system prompt
+    conversation.setSystemPrompt(getSystemPrompt());
+    console.log(chalk_1.default.bold.blue('\n╔═══════════════════════════════════════╗'));
+    console.log(chalk_1.default.bold.blue('║         Welcome to oflow CLI          ║'));
+    console.log(chalk_1.default.bold.blue('╚═══════════════════════════════════════╝'));
+    console.log('');
+    console.log(chalk_1.default.gray(`Model: ${model}`));
+    console.log(chalk_1.default.gray(`Working directory: ${process.cwd()}`));
+    if (sandboxExecutor) {
+        console.log(chalk_1.default.gray(`Sandbox: enabled`));
+    }
+    console.log(chalk_1.default.gray(`Thinking: ${showThinking ? 'ON' : 'OFF'} (use /thinking to toggle)`));
+    console.log('');
+    console.log(chalk_1.default.gray('Type your message and press Enter to chat.'));
+    console.log(chalk_1.default.gray('Type /help for available commands.'));
+    console.log(chalk_1.default.gray('Type $agent-name to call a sub-agent.'));
+    console.log(chalk_1.default.gray('Type /exit or press Ctrl+C to exit.'));
+    console.log('');
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: chalk_1.default.green('> ')
+    });
+    rl.prompt();
+    rl.on('line', async (line) => {
+        const input = line.trim();
+        if (!input) {
+            rl.prompt();
+            return;
+        }
+        // Check for slash commands
+        if ((0, commands_1.isSlashCommand)(input)) {
+            const shouldContinue = await (0, commands_1.executeSlashCommand)(input, {
+                conversation,
+                rl,
+                configManager
+            });
+            if (!shouldContinue) {
+                rl.close();
+                return;
+            }
+            rl.prompt();
+            return;
+        }
+        // Check for agent calls (starting with $)
+        if (input.startsWith('$')) {
+            await handleAgentCall(input, agentFactory, options);
+            rl.prompt();
+            return;
+        }
+        // Check for shell commands (starting with !)
+        if (input.startsWith('!')) {
+            await executeShellCommand(input.slice(1), sandboxExecutor);
+            rl.prompt();
+            return;
+        }
+        // Check for file reference (starting with @)
+        const processedInput = await processFileReferences(input);
+        // Send to AI
+        const spinner = (0, ora_1.default)('Thinking...').start();
+        try {
+            const response = await conversation.sendMessage(processedInput);
+            spinner.stop();
+            console.log(''); // New line after response
+            rl.prompt();
+        }
+        catch (error) {
+            spinner.fail('Error');
+            console.log(chalk_1.default.red(error instanceof Error ? error.message : String(error)));
+            rl.prompt();
+        }
+    });
+    rl.on('close', () => {
+        console.log(chalk_1.default.bold('\nGoodbye! 👋\n'));
+        process.exit(0);
+    });
+    // Handle Ctrl+C
+    process.on('SIGINT', () => {
+        console.log(chalk_1.default.bold('\nGoodbye! 👋\n'));
+        process.exit(0);
+    });
+}
+async function handleAgentCall(input, agentFactory, options) {
+    // Parse agent call: $agent-type "task description"
+    const match = input.match(/^\$(\w+(?:-\w+)*)\s*(.*)$/);
+    if (!match) {
+        console.log(chalk_1.default.yellow('Invalid agent call format. Use: $agent-type "task"'));
+        console.log(chalk_1.default.gray('Available agents: general-purpose, plan-agent, explore-agent, code-reviewer, frontend-tester'));
+        return;
+    }
+    const agentType = match[1];
+    const task = match[2].replace(/^["']|["']$/g, '');
+    if (!task) {
+        console.log(chalk_1.default.yellow('Please provide a task for the agent.'));
+        return;
+    }
+    try {
+        const agent = agentFactory.createAgent(agentType);
+        console.log(chalk_1.default.cyan(`\n🤖 Starting ${agentType} agent...`));
+        console.log(chalk_1.default.gray(`Task: ${task}\n`));
+        const spinner = (0, ora_1.default)('Agent working...').start();
+        const result = await agent.execute(task, (update) => {
+            spinner.stop();
+            process.stdout.write(update);
+            spinner.start();
+        });
+        spinner.stop();
+        if (result.success) {
+            console.log(chalk_1.default.green('\n\n✓ Agent completed successfully'));
+            if (result.filesModified && result.filesModified.length > 0) {
+                console.log(chalk_1.default.gray('Files modified:'));
+                result.filesModified.forEach(f => console.log(chalk_1.default.gray(`  - ${f}`)));
+            }
+        }
+        else {
+            console.log(chalk_1.default.red('\n\n✗ Agent encountered errors:'));
+            result.errors?.forEach(e => console.log(chalk_1.default.red(`  - ${e}`)));
+        }
+        if (result.output) {
+            console.log(chalk_1.default.gray('\nOutput:'));
+            console.log(result.output);
+        }
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(error instanceof Error ? error.message : String(error)));
+    }
+}
+async function runSingleCommand(prompt, options) {
+    const configManager = (0, core_1.getConfigManager)();
+    const auth = configManager.getAuth();
+    if (!auth) {
+        console.log(chalk_1.default.red('Not authenticated. Run `oflow auth` first.'));
+        return;
+    }
+    // 初始化沙箱执行器
+    if (options.sandbox || configManager.get('sandbox')) {
+        sandboxExecutor = await (0, core_1.createSandboxExecutor)();
+    }
+    const model = options.model || configManager.getDefaultModel() || 'gpt-4o';
+    const provider = (0, core_1.createAIProvider)(auth, model);
+    const conversation = new core_1.Conversation({
+        provider,
+        workingDirectory: process.cwd(),
+        maxTokens: configManager.get('maxTokens'),
+        temperature: configManager.get('temperature'),
+        onContent: (content) => {
+            process.stdout.write(chalk_1.default.white(content));
+        }
+    });
+    conversation.setSystemPrompt(getSystemPrompt());
+    const processedInput = await processFileReferences(prompt);
+    const spinner = (0, ora_1.default)('Processing...').start();
+    try {
+        await conversation.sendMessage(processedInput);
+        spinner.stop();
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail('Error');
+        console.log(chalk_1.default.red(error instanceof Error ? error.message : String(error)));
+    }
+}
+async function executeShellCommand(command, sandbox) {
+    const { spawn } = require('child_modules');
+    if (sandbox && sandbox['config']?.backend !== 'none') {
+        // Use sandbox execution
+        const result = await sandbox.execute(command, process.cwd());
+        if (result.stdout)
+            console.log(result.stdout);
+        if (result.stderr)
+            console.error(result.stderr);
+        if (result.timedOut)
+            console.log(chalk_1.default.yellow('Command timed out'));
+        return;
+    }
+    return new Promise((resolve) => {
+        const isWindows = process.platform === 'win32';
+        const shell = isWindows ? 'powershell.exe' : '/bin/bash';
+        const args = isWindows ? ['-NoProfile', '-Command', command] : ['-c', command];
+        const proc = spawn(shell, args, {
+            stdio: 'inherit',
+            cwd: process.cwd()
+        });
+        proc.on('close', () => {
+            resolve();
+        });
+    });
+}
+async function processFileReferences(input) {
+    const fileRefRegex = /@([^\s]+)/g;
+    const matches = input.matchAll(fileRefRegex);
+    let result = input;
+    const fs = require('fs');
+    const path = require('path');
+    for (const match of matches) {
+        const filePath = match[1];
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            result = result.replace(match[0], `\n[File: ${filePath}]\n${content}\n[End of file]\n`);
+        }
+        catch {
+            // File not found, keep original reference
+        }
+    }
+    return result;
+}
+function getSystemPrompt() {
+    return `You are oflow CLI, an interactive CLI agent specializing in software engineering tasks.
+
+Your primary goal is to help users safely and efficiently complete programming tasks.
+
+# Core Capabilities
+- Read, write, and edit files
+- Execute shell commands
+- Search and analyze code
+- Web search and fetch content
+- Manage project structure
+- Launch specialized sub-agents
+
+# Tools Available
+- read_file: Read file contents
+- write_file: Write to files
+- list_directory: List directory contents
+- glob: Find files by pattern
+- search_file_content: Search within files
+- run_shell_command: Execute shell commands
+- web_search: Search the web
+- web_fetch: Fetch web content
+- replace: Replace text in files
+- image_read: Analyze images
+- pdf_extract: Extract content from PDFs
+- ask_user_question: Ask user for input
+- task: Launch sub-agents
+- save_memory: Save information for future sessions
+
+# Sub-Agents (use $agent-name to call)
+- general-purpose: Complex multi-step tasks
+- plan-agent: Planning and analysis
+- explore-agent: Codebase exploration
+- code-reviewer: Code review
+- frontend-tester: UI testing
+
+# Guidelines
+1. Be concise and helpful
+2. Always explain what you're doing before using tools
+3. Ask for clarification when needed
+4. Prefer editing existing files over creating new ones
+5. Use appropriate tools for each task
+6. Verify changes after making them
+7. Provide actionable suggestions
+
+Current working directory: ${process.cwd()}
+`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"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","sourcesContent":["import * as readline from 'readline';\nimport chalk from 'chalk';\nimport ora from 'ora';\nimport {\n  getConfigManager,\n  createAIProvider,\n  Conversation,\n  Message,\n  AgentFactory,\n  Agent,\n  AgentType,\n  createSandboxExecutor,\n  SandboxExecutor\n} from '@oflow-ai/core';\nimport { isSlashCommand, executeSlashCommand } from './commands';\nimport { renderMarkdown } from './utils/markdown';\n\nexport interface CLIOptions {\n  model?: string;\n  yolo?: boolean;\n  sandbox?: boolean;\n  showThinking?: boolean;\n}\n\nlet sandboxExecutor: SandboxExecutor | null = null;\nlet showThinking = false;\n\nexport async function startInteractiveMode(options: CLIOptions): Promise<void> {\n  const configManager = getConfigManager();\n  const auth = configManager.getAuth();\n\n  if (!auth) {\n    console.log(chalk.red('Not authenticated. Run `oflow auth` first.'));\n    return;\n  }\n\n  // 初始化沙箱执行器\n  if (options.sandbox || configManager.get('sandbox')) {\n    sandboxExecutor = await createSandboxExecutor();\n    console.log(chalk.gray(`Sandbox mode: ${sandboxExecutor ? 'enabled' : 'unavailable'}`));\n  }\n\n  // 获取思考过程显示设置\n  showThinking = options.showThinking ?? configManager.getShowThinking();\n\n  const model = options.model || configManager.getDefaultModel() || 'gpt-4o';\n  const provider = createAIProvider(auth, model);\n  const agentFactory = new AgentFactory(provider, process.cwd());\n\n  const conversation = new Conversation({\n    provider,\n    workingDirectory: process.cwd(),\n    maxTokens: configManager.get('maxTokens'),\n    temperature: configManager.get('temperature'),\n    showThinking: showThinking,\n    onContent: (content) => {\n      process.stdout.write(chalk.white(content));\n    },\n    onThinking: (thinking) => {\n      // 显示思考过程，使用不同的颜色\n      process.stdout.write(chalk.magenta(thinking));\n    },\n    onToolCall: (toolCall) => {\n      console.log(chalk.cyan(`\\n🔧 Using tool: ${toolCall.function.name}`));\n    },\n    onToolResult: (result) => {\n      // Tool result is handled silently\n    }\n  });\n\n  // Set system prompt\n  conversation.setSystemPrompt(getSystemPrompt());\n\n  console.log(chalk.bold.blue('\\n╔═══════════════════════════════════════╗'));\n  console.log(chalk.bold.blue('║         Welcome to oflow CLI          ║'));\n  console.log(chalk.bold.blue('╚═══════════════════════════════════════╝'));\n  console.log('');\n  console.log(chalk.gray(`Model: ${model}`));\n  console.log(chalk.gray(`Working directory: ${process.cwd()}`));\n  if (sandboxExecutor) {\n    console.log(chalk.gray(`Sandbox: enabled`));\n  }\n  console.log(chalk.gray(`Thinking: ${showThinking ? 'ON' : 'OFF'} (use /thinking to toggle)`));\n  console.log('');\n  console.log(chalk.gray('Type your message and press Enter to chat.'));\n  console.log(chalk.gray('Type /help for available commands.'));\n  console.log(chalk.gray('Type $agent-name to call a sub-agent.'));\n  console.log(chalk.gray('Type /exit or press Ctrl+C to exit.'));\n  console.log('');\n\n  const rl = readline.createInterface({\n    input: process.stdin,\n    output: process.stdout,\n    prompt: chalk.green('> ')\n  });\n\n  rl.prompt();\n\n  rl.on('line', async (line) => {\n    const input = line.trim();\n    \n    if (!input) {\n      rl.prompt();\n      return;\n    }\n\n    // Check for slash commands\n    if (isSlashCommand(input)) {\n      const shouldContinue = await executeSlashCommand(input, {\n        conversation,\n        rl,\n        configManager\n      });\n      \n      if (!shouldContinue) {\n        rl.close();\n        return;\n      }\n      \n      rl.prompt();\n      return;\n    }\n\n    // Check for agent calls (starting with $)\n    if (input.startsWith('$')) {\n      await handleAgentCall(input, agentFactory, options);\n      rl.prompt();\n      return;\n    }\n\n    // Check for shell commands (starting with !)\n    if (input.startsWith('!')) {\n      await executeShellCommand(input.slice(1), sandboxExecutor);\n      rl.prompt();\n      return;\n    }\n\n    // Check for file reference (starting with @)\n    const processedInput = await processFileReferences(input);\n\n    // Send to AI\n    const spinner = ora('Thinking...').start();\n    \n    try {\n      const response = await conversation.sendMessage(processedInput);\n      spinner.stop();\n      \n      console.log(''); // New line after response\n      rl.prompt();\n    } catch (error) {\n      spinner.fail('Error');\n      console.log(chalk.red(error instanceof Error ? error.message : String(error)));\n      rl.prompt();\n    }\n  });\n\n  rl.on('close', () => {\n    console.log(chalk.bold('\\nGoodbye! 👋\\n'));\n    process.exit(0);\n  });\n\n  // Handle Ctrl+C\n  process.on('SIGINT', () => {\n    console.log(chalk.bold('\\nGoodbye! 👋\\n'));\n    process.exit(0);\n  });\n}\n\nasync function handleAgentCall(\n  input: string, \n  agentFactory: AgentFactory,\n  options: CLIOptions\n): Promise<void> {\n  // Parse agent call: $agent-type \"task description\"\n  const match = input.match(/^\\$(\\w+(?:-\\w+)*)\\s*(.*)$/);\n  \n  if (!match) {\n    console.log(chalk.yellow('Invalid agent call format. Use: $agent-type \"task\"'));\n    console.log(chalk.gray('Available agents: general-purpose, plan-agent, explore-agent, code-reviewer, frontend-tester'));\n    return;\n  }\n\n  const agentType = match[1] as AgentType;\n  const task = match[2].replace(/^[\"']|[\"']$/g, '');\n\n  if (!task) {\n    console.log(chalk.yellow('Please provide a task for the agent.'));\n    return;\n  }\n\n  try {\n    const agent = agentFactory.createAgent(agentType);\n    console.log(chalk.cyan(`\\n🤖 Starting ${agentType} agent...`));\n    console.log(chalk.gray(`Task: ${task}\\n`));\n\n    const spinner = ora('Agent working...').start();\n    \n    const result = await agent.execute(task, (update) => {\n      spinner.stop();\n      process.stdout.write(update);\n      spinner.start();\n    });\n\n    spinner.stop();\n    \n    if (result.success) {\n      console.log(chalk.green('\\n\\n✓ Agent completed successfully'));\n      if (result.filesModified && result.filesModified.length > 0) {\n        console.log(chalk.gray('Files modified:'));\n        result.filesModified.forEach(f => console.log(chalk.gray(`  - ${f}`)));\n      }\n    } else {\n      console.log(chalk.red('\\n\\n✗ Agent encountered errors:'));\n      result.errors?.forEach(e => console.log(chalk.red(`  - ${e}`)));\n    }\n\n    if (result.output) {\n      console.log(chalk.gray('\\nOutput:'));\n      console.log(result.output);\n    }\n\n  } catch (error) {\n    console.log(chalk.red(error instanceof Error ? error.message : String(error)));\n  }\n}\n\nexport async function runSingleCommand(prompt: string, options: CLIOptions): Promise<void> {\n  const configManager = getConfigManager();\n  const auth = configManager.getAuth();\n\n  if (!auth) {\n    console.log(chalk.red('Not authenticated. Run `oflow auth` first.'));\n    return;\n  }\n\n  // 初始化沙箱执行器\n  if (options.sandbox || configManager.get('sandbox')) {\n    sandboxExecutor = await createSandboxExecutor();\n  }\n\n  const model = options.model || configManager.getDefaultModel() || 'gpt-4o';\n  const provider = createAIProvider(auth, model);\n  const conversation = new Conversation({\n    provider,\n    workingDirectory: process.cwd(),\n    maxTokens: configManager.get('maxTokens'),\n    temperature: configManager.get('temperature'),\n    onContent: (content) => {\n      process.stdout.write(chalk.white(content));\n    }\n  });\n\n  conversation.setSystemPrompt(getSystemPrompt());\n\n  const processedInput = await processFileReferences(prompt);\n  const spinner = ora('Processing...').start();\n\n  try {\n    await conversation.sendMessage(processedInput);\n    spinner.stop();\n    console.log('');\n  } catch (error) {\n    spinner.fail('Error');\n    console.log(chalk.red(error instanceof Error ? error.message : String(error)));\n  }\n}\n\nasync function executeShellCommand(command: string, sandbox?: SandboxExecutor | null): Promise<void> {\n  const { spawn } = require('child_modules');\n  \n  if (sandbox && sandbox['config']?.backend !== 'none') {\n    // Use sandbox execution\n    const result = await sandbox.execute(command, process.cwd());\n    if (result.stdout) console.log(result.stdout);\n    if (result.stderr) console.error(result.stderr);\n    if (result.timedOut) console.log(chalk.yellow('Command timed out'));\n    return;\n  }\n  \n  return new Promise((resolve) => {\n    const isWindows = process.platform === 'win32';\n    const shell = isWindows ? 'powershell.exe' : '/bin/bash';\n    const args = isWindows ? ['-NoProfile', '-Command', command] : ['-c', command];\n\n    const proc = spawn(shell, args, {\n      stdio: 'inherit',\n      cwd: process.cwd()\n    });\n\n    proc.on('close', () => {\n      resolve();\n    });\n  });\n}\n\nasync function processFileReferences(input: string): Promise<string> {\n  const fileRefRegex = /@([^\\s]+)/g;\n  const matches = input.matchAll(fileRefRegex);\n  \n  let result = input;\n  const fs = require('fs');\n  const path = require('path');\n\n  for (const match of matches) {\n    const filePath = match[1];\n    try {\n      const content = fs.readFileSync(filePath, 'utf-8');\n      result = result.replace(match[0], `\\n[File: ${filePath}]\\n${content}\\n[End of file]\\n`);\n    } catch {\n      // File not found, keep original reference\n    }\n  }\n\n  return result;\n}\n\nfunction getSystemPrompt(): string {\n  return `You are oflow CLI, an interactive CLI agent specializing in software engineering tasks.\n\nYour primary goal is to help users safely and efficiently complete programming tasks.\n\n# Core Capabilities\n- Read, write, and edit files\n- Execute shell commands\n- Search and analyze code\n- Web search and fetch content\n- Manage project structure\n- Launch specialized sub-agents\n\n# Tools Available\n- read_file: Read file contents\n- write_file: Write to files\n- list_directory: List directory contents\n- glob: Find files by pattern\n- search_file_content: Search within files\n- run_shell_command: Execute shell commands\n- web_search: Search the web\n- web_fetch: Fetch web content\n- replace: Replace text in files\n- image_read: Analyze images\n- pdf_extract: Extract content from PDFs\n- ask_user_question: Ask user for input\n- task: Launch sub-agents\n- save_memory: Save information for future sessions\n\n# Sub-Agents (use $agent-name to call)\n- general-purpose: Complex multi-step tasks\n- plan-agent: Planning and analysis\n- explore-agent: Codebase exploration\n- code-reviewer: Code review\n- frontend-tester: UI testing\n\n# Guidelines\n1. Be concise and helpful\n2. Always explain what you're doing before using tools\n3. Ask for clarification when needed\n4. Prefer editing existing files over creating new ones\n5. Use appropriate tools for each task\n6. Verify changes after making them\n7. Provide actionable suggestions\n\nCurrent working directory: ${process.cwd()}\n`;\n}"]}

package/dist/commands/index.d.ts

@@ -0,0 +1,9 @@
+import { Conversation, ConfigManager } from '@oflow-ai/core';
+import * as readline from 'readline';
+export interface CommandContext {
+    conversation: Conversation;
+    rl: readline.Interface;
+    configManager: ConfigManager;
+}
+export declare function isSlashCommand(input: string): boolean;
+export declare function executeSlashCommand(input: string, context: CommandContext): Promise<boolean>;