acmecode 1.0.0

package/.acmecode/config.json

@@ -0,0 +1,6 @@
+{
+  "provider": "openai",
+  "model": "o1-mini",
+  "visionProvider": "anthropic",
+  "visionModel": "claude-3-5-sonnet-20241022"
+}

package/README.md

@@ -0,0 +1,124 @@
+# AcmeCode
+
+原生终端的 AI 编程助手。自主运行，读写文件、执行命令、调用 LSP、操控浏览器，帮你完成真实的编程任务。
+
+## 特性
+
+- **多提供商 LLM 支持** — OpenAI、Anthropic、Google、xAI、Mistral、Groq、DeepInfra、OpenRouter，以及任意 OpenAI 兼容接口
+- **内置工具集** — 文件读写编辑、目录浏览、命令执行、ripgrep 搜索、网页抓取、LSP 代码分析、Playwright 浏览器自动化
+- **4 种 Agent 模式** — `agent`（自主）、`plan`（方案设计）、`code`（代码执行）、`zen`（极简对话）
+- **Plan → Code 工作流** — Architect 模式设计方案后自动切换到 Code 模式执行，任务清单持久化跟踪
+- **MCP 协议** — 通过 `.acmecode-mcp.json` 连接外部 MCP 服务器，工具自动注入 Agent
+- **技能系统** — Markdown 文件注入系统提示词，实现专业角色和工作流
+- **会话持久化** — SQLite 本地存储完整对话历史，随时恢复
+- **安全机制** — 危险命令本地检测 + 用户审批
+- **精美 TUI** — 基于 React + Ink，支持 Markdown 渲染、6 种主题、中英文界面
+
+## 安装
+
+```bash
+git clone https://github.com/your-username/acmecode
+cd acmecode
+npm install
+npm run build
+npm link
+```
+
+## 配置
+
+AcmeCode 从 `.env` 文件读取 API 密钥，按以下顺序查找：
+
+1. 当前工作目录的 `.env`
+2. 全局 `~/.acmecode/.env`
+
+```bash
+# OpenAI（或兼容接口，如 DeepSeek、Qwen）
+OPENAI_API_KEY="sk-..."
+OPENAI_BASE_URL="https://api.deepseek.com/v1"  # 可选
+
+# Anthropic
+ANTHROPIC_API_KEY="sk-ant-..."
+
+# Google
+GOOGLE_GENERATIVE_AI_API_KEY="AIza..."
+
+# xAI / Mistral / Groq / DeepInfra / OpenRouter
+XAI_API_KEY="..."
+MISTRAL_API_KEY="..."
+GROQ_API_KEY="..."
+DEEPINFRA_API_KEY="..."
+OPENROUTER_API_KEY="..."
+
+# 网页搜索（可选）
+EXA_API_KEY="..."
+```
+
+## 使用
+
+```bash
+acmecode              # 恢复上次会话
+acmecode -n           # 新建会话
+acmecode -s <id>      # 恢复指定会话
+acmecode --list       # 列出所有历史会话
+acmecode [dir]        # 在指定目录启动
+```
+
+### 斜杠命令
+
+| 命令            | 说明                                                                  |
+| --------------- | --------------------------------------------------------------------- |
+| `/model`        | 切换 LLM 模型                                                         |
+| `/mode`         | 切换 Agent 模式（agent / plan / code / zen）                          |
+| `/vision`       | 切换视觉模型                                                          |
+| `/reason`       | 切换推理模式                                                          |
+| `/skill <name>` | 加载技能文件                                                          |
+| `/theme`        | 切换主题（dark / dracula / tokyonight / nord / catppuccin / monokai） |
+| `/lang`         | 切换界面语言（en / zh）                                               |
+| `/config`       | 查看当前配置                                                          |
+| `/clear`        | 清空聊天记录                                                          |
+| `/cancel`       | 取消当前 Agent 运行                                                   |
+| `/exit`         | 退出                                                                  |
+
+## MCP 服务器
+
+在项目根目录创建 `.acmecode-mcp.json`，或全局创建 `~/.acmecode/mcp.json`：
+
+```json
+{
+  "mcpServers": {
+    "my-server": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-example"]
+    }
+  }
+}
+```
+
+启动时自动发现并将工具注入 Agent。
+
+## 技能系统
+
+在 `~/.acmecode/skills/` 下创建 Markdown 文件：
+
+```markdown
+---
+description: 严格执行最佳实践的代码审查员
+---
+
+你是一位专业的代码审查员...
+```
+
+在 TUI 中运行 `/skill <filename>` 激活。
+
+## 项目上下文
+
+在项目根目录创建 `ACMECODE.md`，AcmeCode 启动时会自动读取并注入系统提示词，结合 Git 状态提供精准的项目上下文。
+
+## 技术栈
+
+- TypeScript 5 + Node.js ESM
+- React 19 + Ink 6（终端 UI）
+- Vercel AI SDK v6（LLM 调用）
+- better-sqlite3（会话存储）
+- Playwright（浏览器自动化）
+- npm workspaces monorepo（`core` / `tui` / `cli`）

package/dist/agent/index.js

@@ -0,0 +1,161 @@
+import { streamText } from 'ai';
+import { getModel } from '../llm/provider.js';
+import { builtInTools, toolExecutors } from '../tools/index.js';
+import { getMcpTools } from '../mcp/index.js';
+const MAX_OUTPUT_LENGTH = 20000; // Safety limit to prevent infinite generation loops
+export async function* runAgent(provider, modelName, messages, systemPrompt) {
+    const model = getModel(provider, modelName);
+    const mcpTools = await getMcpTools();
+    const tools = {
+        ...builtInTools,
+        ...mcpTools,
+    };
+    let currentMessages = [...messages];
+    let stepCount = 0;
+    const MAX_STEPS = 10;
+    // Dedup set persists across ALL steps to prevent re-running the same tool call
+    const globalCalledSet = new Set();
+    while (stepCount < MAX_STEPS) {
+        stepCount++;
+        let stepText = '';
+        const collectedToolCalls = [];
+        const collectedToolResults = [];
+        try {
+            const result = await streamText({
+                model,
+                messages: currentMessages,
+                system: systemPrompt || "You are AcmeCode, an AI coding assistant.",
+                tools,
+                maxSteps: 1,
+            });
+            for await (const chunk of result.fullStream) {
+                if (chunk.type === 'text-delta') {
+                    const text = chunk.textDelta || chunk.text || "";
+                    if (text) {
+                        stepText += text;
+                        if (stepText.length > MAX_OUTPUT_LENGTH) {
+                            yield { type: 'text', text: '\n[Error: Model output exceeded maximum length safety limit]\n' };
+                            break;
+                        }
+                        yield { type: 'text', text };
+                    }
+                }
+                else if (chunk.type === 'tool-call') {
+                    const name = chunk.toolName || '';
+                    const args = chunk.args || {};
+                    if (name) {
+                        collectedToolCalls.push({ name, args });
+                        yield { type: 'tool-call', name, args };
+                    }
+                }
+                else if (chunk.type === 'tool-result') {
+                    const name = chunk.toolName || '';
+                    const rawResult = chunk.result ?? chunk.output ?? '';
+                    const resultStr = typeof rawResult === 'string' ? rawResult : JSON.stringify(rawResult);
+                    collectedToolResults.push({ name, result: resultStr });
+                    yield { type: 'tool-result', name, result: resultStr };
+                }
+            }
+        }
+        catch (err) {
+            yield { type: 'text', text: `\n[Error: ${err.message}]\n` };
+            yield { type: 'messages', messages: currentMessages };
+            return [];
+        }
+        // ── Fallback: Handle R1-style fake tool calls in text ──
+        if (collectedToolCalls.length === 0) {
+            // Strip <think>...</think> blocks — R1 models put draft (often incomplete/empty)
+            // tool calls inside these, but real tool calls come AFTER </think>.
+            const parseText = stepText.replace(/<think>[\s\S]*?<\/think>/g, '').trim();
+            for (const [toolName, toolFn] of Object.entries(toolExecutors)) {
+                // Pattern 1: XML-style  <read_file>path.html</read_file>
+                // Pattern 2: bracket-style  [read_file("path.html")]  or  [read_file('path.html')]  or  [read_file(path.html)]
+                const patterns = [
+                    new RegExp(`<${toolName}>([\\s\\S]*?)<\/${toolName}>`, 'g'),
+                    // Match args inside brackets, allowing quoted strings with spaces
+                    new RegExp(`\\[${toolName}\\(([^\\[\\]]*)\\)\\]`, 'g')
+                ];
+                for (const regex of patterns) {
+                    regex.lastIndex = 0; // always reset before scanning
+                    let match;
+                    while ((match = regex.exec(parseText)) !== null) {
+                        const innerText = match[1].trim();
+                        const args = {};
+                        // Try XML inner args first: <key>value</key>
+                        const argRegex = /<(\w+)>([\s\S]*?)<\/\1>/g;
+                        let argMatch;
+                        let foundInnerArgs = false;
+                        while ((argMatch = argRegex.exec(innerText)) !== null) {
+                            args[argMatch[1]] = argMatch[2].trim();
+                            foundInnerArgs = true;
+                        }
+                        // Fallback: if no XML args, treat inner text as the first positional argument
+                        if (!foundInnerArgs && innerText) {
+                            if (toolName === 'list_dir' || toolName === 'read_file') {
+                                // Strip surrounding quotes (single or double)
+                                args.path = innerText.replace(/^["']|["']$/g, '').trim();
+                            }
+                            else if (toolName === 'run_command') {
+                                args.command = innerText.replace(/^["']|["']$/g, '').trim();
+                            }
+                        }
+                        // Validate we have a non-empty path/command
+                        const firstArgValue = Object.values(args)[0];
+                        if (!firstArgValue)
+                            continue;
+                        // De-duplicate: skip if we already ran this exact call in ANY step
+                        const dedupKey = `${toolName}:${JSON.stringify(args)}`;
+                        if (globalCalledSet.has(dedupKey))
+                            continue;
+                        globalCalledSet.add(dedupKey);
+                        collectedToolCalls.push({ name: toolName, args });
+                        yield { type: 'tool-call', name: toolName, args };
+                        try {
+                            const result = await toolFn(args);
+                            const resultStr = typeof result === 'string' ? result : JSON.stringify(result);
+                            collectedToolResults.push({ name: toolName, result: resultStr });
+                            yield { type: 'tool-result', name: toolName, result: resultStr };
+                        }
+                        catch (err) {
+                            const resultStr = `Error: ${err.message}`;
+                            collectedToolResults.push({ name: toolName, result: resultStr });
+                            yield { type: 'tool-result', name: toolName, result: resultStr };
+                        }
+                    }
+                }
+            }
+        }
+        // ── If no tools were called (native or XML), we're done ──
+        if (collectedToolCalls.length === 0) {
+            currentMessages.push({ role: 'assistant', content: stepText });
+            yield { type: 'messages', messages: currentMessages };
+            return [];
+        }
+        // ── Step 2: Tools were called. We loop again! ──
+        yield { type: 'text', text: '\n' }; // visual separator
+        // Build a full tool result summary for the model.
+        // Do NOT truncate read_file results — the model needs the full file content
+        // to perform its task (otherwise it keeps re-reading the same file).
+        const toolSummary = collectedToolResults.map((tr, i) => {
+            const tc = collectedToolCalls[i];
+            const argsStr = tc ? Object.entries(tc.args)
+                .filter(([k]) => k !== 'content')
+                .map(([k, v]) => `${k}=${JSON.stringify(v)}`)
+                .join(', ') : '';
+            // Only truncate for very large results (>10k chars) to stay within context limits
+            const resultBody = tr.result.length > 10000
+                ? tr.result.slice(0, 10000) + '\n... (content truncated at 10000 chars)'
+                : tr.result;
+            return `### Tool: ${tr.name}(${argsStr})\n\`\`\`\n${resultBody}\n\`\`\``;
+        }).join('\n\n');
+        currentMessages.push({ role: 'assistant', content: stepText });
+        currentMessages.push({
+            role: 'user',
+            content: `[SYSTEM] Here are the complete results of the tools you just called. Do NOT call the same tool with the same arguments again.\n\n${toolSummary}\n\nContinue with your task using the information above. If you have finished the task, output the final result now.`
+        });
+    } // end while
+    // Fallback if max steps reached
+    yield { type: 'text', text: '\n[Note: Reached maximum autonomous steps.]\n' };
+    yield { type: 'messages', messages: currentMessages };
+    return [];
+}

package/dist/cli/bin/acmecode.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import '../src/index.js';

package/dist/cli/package.json

@@ -0,0 +1,25 @@
+{
+    "name": "@acmecode/cli",
+    "version": "1.0.0",
+    "type": "module",
+    "main": "dist/index.js",
+    "bin": {
+        "acmecode": "bin/acmecode.js"
+    },
+    "scripts": {
+        "build": "tsc",
+        "start": "node dist/index.js",
+        "dev": "tsx src/index.ts"
+    },
+    "dependencies": {
+        "@acmecode/core": "^1.0.0",
+        "@acmecode/tui": "^1.0.0",
+        "commander": "^14.0.3",
+        "ink": "^6.8.0",
+        "react": "^19.2.4"
+    },
+    "devDependencies": {
+        "@types/node": "^25.3.0",
+        "@types/react": "^19.2.14"
+    }
+}

package/dist/cli/src/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/src/index.js

@@ -0,0 +1,53 @@
+import { Command } from "commander";
+import { config as dotenvConfig } from "dotenv";
+dotenvConfig({ quiet: true });
+import pkg from "../package.json" with { type: "json" };
+import React from 'react';
+import { render } from 'ink';
+import App from '@acmecode/tui/App.js';
+import { createSession, listSessions } from '@acmecode/core/session/index.js';
+import crypto from 'crypto';
+import path from 'path';
+function main() {
+    const program = new Command();
+    program
+        .name("acmecode")
+        .description("AI Coding Assistant CLI")
+        .version(pkg.version)
+        .argument('[dir]', 'Directory to run in', '.')
+        .option('-n, --new', 'Create a new session')
+        .option('-s, --session <id>', 'Resume a specific session ID')
+        .option('--list', 'List all sessions')
+        .action((dir, options) => {
+        // Change current working directory to the specified directory
+        const targetDir = path.resolve(process.cwd(), dir);
+        try {
+            process.chdir(targetDir);
+        }
+        catch (err) {
+            console.error(`Failed to change directory to ${targetDir}: ${err.message}`);
+            process.exit(1);
+        }
+        if (options.list) {
+            const sessions = listSessions();
+            console.log('Available Sessions:');
+            sessions.forEach(s => console.log(`- ${s.id} (${s.title}) updated at ${s.updated_at}`));
+            process.exit(0);
+        }
+        let sessionId = options.session;
+        // Always create a fresh session unless explicitly resuming one
+        if (!sessionId) {
+            sessionId = crypto.randomUUID().slice(0, 8);
+            createSession(sessionId, `Session ${new Date().toLocaleString()}`);
+        }
+        const { unmount } = render(React.createElement(App, {
+            sessionId: sessionId,
+            onExit: () => {
+                unmount();
+                process.exit(0);
+            }
+        }));
+    });
+    program.parse();
+}
+main();

package/dist/config/index.js

@@ -0,0 +1,92 @@
+import { config } from "dotenv";
+import { resolve, join } from "path";
+import { homedir } from "os";
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+// Load environment variables from .env in project root if it exists
+config();
+// Load environment variables from ~/.acmecode/.env if it exists
+config({ path: resolve(homedir(), ".acmecode", ".env") });
+const GLOBAL_CONFIG_DIR = resolve(homedir(), ".acmecode");
+const GLOBAL_CONFIG_FILE = join(GLOBAL_CONFIG_DIR, "config.json");
+function getProjectConfigDir() {
+    return resolve(process.cwd(), ".acmecode");
+}
+function getProjectConfigFile() {
+    return join(getProjectConfigDir(), "config.json");
+}
+function readJsonFile(filePath) {
+    try {
+        if (existsSync(filePath)) {
+            return JSON.parse(readFileSync(filePath, "utf-8"));
+        }
+    }
+    catch { }
+    return null;
+}
+function writeJsonFile(filePath, data) {
+    const dir = resolve(filePath, "..");
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
+}
+/**
+ * Load model config with priority: project .acmecode/config.json > global ~/.acmecode/config.json > defaults
+ */
+export function loadModelConfig() {
+    // 1. Project-level config
+    const projectConfig = readJsonFile(getProjectConfigFile());
+    if (projectConfig?.provider && projectConfig?.model) {
+        return { provider: projectConfig.provider, model: projectConfig.model };
+    }
+    // 2. Global config
+    const globalConfig = readJsonFile(GLOBAL_CONFIG_FILE);
+    if (globalConfig?.provider && globalConfig?.model) {
+        return { provider: globalConfig.provider, model: globalConfig.model };
+    }
+    // 3. Hardcoded defaults
+    return { provider: "openai", model: "gpt-4o" };
+}
+/**
+ * Save model config to the project's .acmecode/config.json
+ */
+export function saveProjectModelConfig(provider, model) {
+    const filePath = getProjectConfigFile();
+    const existing = readJsonFile(filePath) || {};
+    existing.provider = provider;
+    existing.model = model;
+    writeJsonFile(filePath, existing);
+}
+/**
+ * Save model config to the global ~/.acmecode/config.json
+ */
+export function saveGlobalModelConfig(provider, model) {
+    const existing = readJsonFile(GLOBAL_CONFIG_FILE) || {};
+    existing.provider = provider;
+    existing.model = model;
+    writeJsonFile(GLOBAL_CONFIG_FILE, existing);
+}
+export const getProviderKey = (provider) => {
+    switch (provider) {
+        case "openai":
+            return process.env.OPENAI_API_KEY || "sk-Plobc3VM4qzRkIUAakQjtj7hwHPedlSoU4haaPNWWNIESiya";
+        case "anthropic":
+            return process.env.ANTHROPIC_API_KEY;
+        case "google":
+            return process.env.GOOGLE_GENERATIVE_AI_API_KEY;
+        default:
+            return undefined;
+    }
+};
+export const getProviderBaseUrl = (provider) => {
+    switch (provider) {
+        case "openai":
+            return process.env.OPENAI_BASE_URL || "https://apis.acmecloud.cn/v1";
+        case "anthropic":
+            return process.env.ANTHROPIC_BASE_URL;
+        case "google":
+            return process.env.GOOGLE_GENERATIVE_AI_BASE_URL;
+        default:
+            return undefined;
+    }
+};

package/dist/context/index.js

@@ -0,0 +1,30 @@
+import * as fs from 'fs/promises';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import path from 'path';
+const execAsync = promisify(exec);
+export async function getProjectContext() {
+    let context = '';
+    // 1. ACMECODE.md
+    try {
+        const acmecodePath = path.join(process.cwd(), 'ACMECODE.md');
+        const content = await fs.readFile(acmecodePath, 'utf8');
+        context += `\n\n[Project Instructions (ACMECODE.md)]\n${content}`;
+    }
+    catch (e) {
+        // Ignore if missing
+    }
+    // 2. Git context
+    try {
+        const { stdout: branch } = await execAsync('git rev-parse --abbrev-ref HEAD');
+        const { stdout: status } = await execAsync('git status -s');
+        context += `\n\n[Git Status (Branch: ${branch.trim()})]\n${status.trim() || 'Clean working directory'}`;
+        // Let's also get the last commit message for context
+        const { stdout: log } = await execAsync('git log -1 --oneline');
+        context += `\nLast Commit: ${log.trim()}`;
+    }
+    catch (e) {
+        // Ignore if not a git repo
+    }
+    return context;
+}

package/dist/core/src/agent/index.d.ts

@@ -0,0 +1,52 @@
+import { ProviderType } from "../llm/provider.js";
+import { ReasoningLevel, AgentMode } from "../config/index.js";
+export type AgentEvent = {
+    type: "text";
+    text: string;
+} | {
+    type: "tool-call";
+    name: string;
+    args: Record<string, unknown>;
+    toolCallId?: string;
+} | {
+    type: "tool-call-delta";
+    name: string;
+    args: Record<string, unknown>;
+    partial?: boolean;
+    toolCallId?: string;
+} | {
+    type: "tool-result";
+    name: string;
+    result: string;
+    toolCallId?: string;
+} | {
+    type: "tool-generating";
+    name: string;
+    args: Record<string, unknown>;
+} | {
+    type: "tool-approval-required";
+    name: string;
+    args: Record<string, unknown>;
+    riskLevel?: string;
+    isLocalGuard?: boolean;
+} | {
+    type: "messages";
+    messages: any[];
+    promptLength?: number;
+} | {
+    type: "step";
+    step: number;
+    maxSteps: number;
+} | {
+    type: "finish";
+    usage: any;
+} | {
+    type: "mode-changed";
+    mode: AgentMode;
+    planFile?: string;
+};
+/**
+ * Run the AI agent with streaming, multi-step tool calls, and structured events.
+ * Inspired by opencode's LLM.stream() pattern.
+ */
+export declare function runAgent(provider: ProviderType, modelName: string, messages: any[], systemPrompt?: string, abortSignal?: AbortSignal, reasoningLevel?: ReasoningLevel, agentMode?: AgentMode, activePlanFile?: string, activeSkillContent?: string): AsyncGenerator<AgentEvent, any[], unknown>;