acmecode 1.0.0

package/dist/core/src/tools/lsp-client.d.ts

@@ -0,0 +1,11 @@
+import { type ChildProcessWithoutNullStreams } from "child_process";
+import { MessageConnection } from "vscode-jsonrpc/lib/node/main.js";
+import type { Diagnostic } from "vscode-languageserver-types";
+export interface LspClient {
+    connection: MessageConnection;
+    process: ChildProcessWithoutNullStreams;
+    diagnostics: Map<string, Diagnostic[]>;
+    openFile: (filePath: string, timeoutMs?: number) => Promise<void>;
+    shutdown: () => Promise<void>;
+}
+export declare function getLspClientForFile(workspaceRoot: string, filePath: string): Promise<LspClient>;

package/dist/core/src/tools/lsp-client.js

@@ -0,0 +1,224 @@
+import { spawn } from "child_process";
+import path from "path";
+import { pathToFileURL } from "url";
+import { createMessageConnection, StreamMessageReader, StreamMessageWriter, } from "vscode-jsonrpc/lib/node/main.js";
+import * as fs from "fs/promises";
+const SERVER_CONFIGS = {
+    typescript: {
+        command: process.platform === "win32" ? "npx.cmd" : "npx",
+        args: ["--no-install", "typescript-language-server", "--stdio"],
+        languageIdResolver: (filePath) => filePath.endsWith(".tsx")
+            ? "typescriptreact"
+            : filePath.endsWith(".jsx")
+                ? "javascriptreact"
+                : filePath.endsWith(".js")
+                    ? "javascript"
+                    : "typescript",
+    },
+    python: {
+        command: process.platform === "win32" ? "npx.cmd" : "npx",
+        // npx pyright-langserver will use standard pyright if available
+        args: ["--no-install", "pyright-langserver", "--stdio"],
+        languageIdResolver: () => "python",
+    },
+    go: {
+        command: "gopls",
+        args: [], // gopls runs in stdio mode by default
+        languageIdResolver: () => "go",
+    },
+    rust: {
+        command: "rust-analyzer",
+        args: [],
+        languageIdResolver: () => "rust",
+    },
+};
+const clients = new Map();
+const clientInitializationPromises = new Map();
+// Track file versions globally across all servers
+const fileVersions = new Map();
+function getLanguageIdForExtension(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if ([".ts", ".tsx", ".js", ".jsx", ".cjs", ".mjs"].includes(ext))
+        return "typescript";
+    if ([".py", ".pyi"].includes(ext))
+        return "python";
+    if ([".go"].includes(ext))
+        return "go";
+    if ([".rs"].includes(ext))
+        return "rust";
+    return null;
+}
+async function getTsServerPath(workspaceRoot) {
+    const localTsServer = path.join(workspaceRoot, "node_modules", "typescript", "lib", "tsserver.js");
+    try {
+        await fs.stat(localTsServer);
+        return localTsServer;
+    }
+    catch { }
+    return null;
+}
+async function resolveTsLsCommand(workspaceRoot) {
+    // Walk up from workspaceRoot looking for node_modules/.bin/typescript-language-server
+    const bin = process.platform === "win32"
+        ? "typescript-language-server.cmd"
+        : "typescript-language-server";
+    let dir = workspaceRoot;
+    for (let i = 0; i < 5; i++) {
+        const candidate = path.join(dir, "node_modules", ".bin", bin);
+        try {
+            await fs.access(candidate);
+            return { command: candidate, args: ["--stdio"] };
+        }
+        catch { }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    // Fallback: try global install via npx (with --no-install to avoid slow download)
+    return {
+        command: process.platform === "win32" ? "npx.cmd" : "npx",
+        args: ["--no-install", "typescript-language-server", "--stdio"],
+    };
+}
+export async function getLspClientForFile(workspaceRoot, filePath) {
+    const langId = getLanguageIdForExtension(filePath);
+    if (!langId) {
+        throw new Error(`Unsupported file extension for LSP: ${filePath}`);
+    }
+    if (clients.has(langId)) {
+        return clients.get(langId);
+    }
+    if (!clientInitializationPromises.has(langId)) {
+        const promise = initializeLspClient(workspaceRoot, langId).catch((err) => {
+            clientInitializationPromises.delete(langId);
+            throw err;
+        });
+        clientInitializationPromises.set(langId, promise);
+    }
+    return clientInitializationPromises.get(langId);
+}
+async function initializeLspClient(workspaceRoot, langId) {
+    let config = SERVER_CONFIGS[langId];
+    // For TypeScript, prefer the local node_modules binary over npx
+    if (langId === "typescript") {
+        const resolved = await resolveTsLsCommand(workspaceRoot);
+        config = { ...config, ...resolved };
+    }
+    console.log(`[LSP] Starting ${langId} language server (${config.command} ${config.args.join(" ")})...`);
+    const proc = spawn(config.command, config.args, {
+        cwd: workspaceRoot,
+        env: { ...process.env },
+        shell: false, // direct binary, no shell needed
+    });
+    // Fast-fail: if the process exits immediately, it's not installed
+    await new Promise((resolve, reject) => {
+        const onExit = (code) => {
+            reject(new Error(`[LSP] ${langId} server exited immediately (code ${code}). Is it installed?`));
+        };
+        proc.once("exit", onExit);
+        // Give it 500ms to either crash or start successfully
+        setTimeout(() => {
+            proc.removeListener("exit", onExit);
+            resolve();
+        }, 500);
+    });
+    // Capture stderr for debug logging
+    proc.stderr.on("data", (data) => {
+        // console.error(`[LSP ${langId}] ${data.toString()}`);
+    });
+    const connection = createMessageConnection(new StreamMessageReader(proc.stdout), new StreamMessageWriter(proc.stdin));
+    const diagnosticsMap = new Map();
+    // Listeners waiting for diagnostics on a specific URI
+    const diagnosticsListeners = new Map();
+    connection.onNotification("textDocument/publishDiagnostics", (params) => {
+        diagnosticsMap.set(params.uri, params.diagnostics);
+        // Notify any waiters for this URI
+        const listeners = diagnosticsListeners.get(params.uri);
+        if (listeners) {
+            diagnosticsListeners.delete(params.uri);
+            for (const cb of listeners)
+                cb();
+        }
+    });
+    connection.onRequest("window/workDoneProgress/create", () => null);
+    connection.onRequest("workspace/configuration", () => [{}]);
+    connection.listen();
+    let initializationOptions = {};
+    if (langId === "typescript") {
+        const tsserverPath = await getTsServerPath(workspaceRoot);
+        if (tsserverPath) {
+            initializationOptions = { tsserver: { path: tsserverPath } };
+        }
+    }
+    // 1. Initialize (with timeout to avoid hanging on slow server startup)
+    const INIT_TIMEOUT_MS = 15000;
+    await Promise.race([
+        connection.sendRequest("initialize", {
+            processId: process.pid,
+            rootUri: pathToFileURL(workspaceRoot).href,
+            capabilities: {
+                textDocument: {
+                    synchronization: { didOpen: true, didChange: true },
+                    publishDiagnostics: { relatedInformation: true },
+                },
+            },
+            initializationOptions,
+        }),
+        new Promise((_, reject) => setTimeout(() => reject(new Error(`[LSP] initialize timed out after ${INIT_TIMEOUT_MS}ms`)), INIT_TIMEOUT_MS)),
+    ]);
+    // 2. Initialized
+    await connection.sendNotification("initialized", {});
+    const client = {
+        connection,
+        process: proc,
+        diagnostics: diagnosticsMap,
+        openFile: async (filePath, timeoutMs = 3000) => {
+            const uri = pathToFileURL(filePath).href;
+            const content = await fs.readFile(filePath, "utf8");
+            const version = fileVersions.get(uri);
+            const resolvedLangId = config.languageIdResolver(filePath);
+            // Set up a promise that resolves when publishDiagnostics fires for this URI
+            const diagReady = new Promise((resolve) => {
+                const existing = diagnosticsListeners.get(uri) ?? [];
+                existing.push(resolve);
+                diagnosticsListeners.set(uri, existing);
+            });
+            if (version !== undefined) {
+                const nextVersion = version + 1;
+                fileVersions.set(uri, nextVersion);
+                await connection.sendNotification("textDocument/didChange", {
+                    textDocument: { uri, version: nextVersion },
+                    contentChanges: [{ text: content }],
+                });
+            }
+            else {
+                fileVersions.set(uri, 0);
+                await connection.sendNotification("textDocument/didOpen", {
+                    textDocument: {
+                        uri,
+                        languageId: resolvedLangId,
+                        version: 0,
+                        text: content,
+                    },
+                });
+            }
+            // Wait for diagnostics or timeout — whichever comes first
+            await Promise.race([
+                diagReady,
+                new Promise((resolve) => setTimeout(resolve, timeoutMs)),
+            ]);
+        },
+        shutdown: async () => {
+            await connection.sendRequest("shutdown");
+            await connection.sendNotification("exit");
+            connection.dispose();
+            proc.kill();
+            clients.delete(langId);
+            clientInitializationPromises.delete(langId);
+            // Note: fileVersions is global, we don't clear it here so documents stay "open" if another server needs them
+        },
+    };
+    clients.set(langId, client);
+    return client;
+}

package/dist/index.js

@@ -0,0 +1,41 @@
+import { Command } from "commander";
+import "dotenv/config";
+import pkg from "../package.json" with { type: "json" };
+import React from 'react';
+import { render } from 'ink';
+import { App } from './tui/App.js';
+import { createSession, listSessions } from './session/index.js';
+import crypto from 'crypto';
+function main() {
+    const program = new Command();
+    program
+        .name("acmecode")
+        .description("AI Coding Assistant CLI")
+        .version(pkg.version)
+        .option('-n, --new', 'Create a new session')
+        .option('-s, --session <id>', 'Resume a specific session ID')
+        .option('--list', 'List all sessions')
+        .action((options) => {
+        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/llm/provider.js

@@ -0,0 +1,34 @@
+import { createOpenAI } from '@ai-sdk/openai';
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { createGoogleGenerativeAI } from '@ai-sdk/google';
+import { getProviderKey, getProviderBaseUrl } from '../config/index.js';
+export function getModel(provider, modelName) {
+    switch (provider) {
+        case 'openai': {
+            const key = getProviderKey('openai');
+            const baseURL = getProviderBaseUrl('openai');
+            if (!key)
+                throw new Error("OPENAI_API_KEY is not set.");
+            const openai = createOpenAI({ apiKey: key, baseURL });
+            return openai.chat(modelName);
+        }
+        case 'anthropic': {
+            const key = getProviderKey('anthropic');
+            const baseURL = getProviderBaseUrl('anthropic');
+            if (!key)
+                throw new Error("ANTHROPIC_API_KEY is not set.");
+            const anthropic = createAnthropic({ apiKey: key, baseURL });
+            return anthropic(modelName);
+        }
+        case 'google': {
+            const key = getProviderKey('google');
+            const baseURL = getProviderBaseUrl('google');
+            if (!key)
+                throw new Error("GOOGLE_GENERATIVE_AI_API_KEY is not set.");
+            const google = createGoogleGenerativeAI({ apiKey: key, baseURL });
+            return google(modelName);
+        }
+        default:
+            throw new Error(`Unsupported provider: ${provider}`);
+    }
+}

package/dist/mcp/index.js

@@ -0,0 +1,84 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { tool as createTool } from 'ai';
+import { z } from 'zod';
+import * as fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+// bypass ai tools strict generic typings
+const tool = (options) => createTool(options);
+const clients = {};
+export async function loadMcpConfig() {
+    // Check project-level first, then global
+    const projectConfigPath = path.join(process.cwd(), '.acmecode-mcp.json');
+    const globalConfigPath = path.join(os.homedir(), '.acmecode', 'mcp.json');
+    for (const configPath of [projectConfigPath, globalConfigPath]) {
+        try {
+            const content = await fs.readFile(configPath, 'utf8');
+            return JSON.parse(content);
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT') {
+                console.error(`Error reading MCP config at ${configPath}:`, err.message);
+            }
+        }
+    }
+    return null;
+}
+// Convert MCP JSON Schema to Zod (simplified for now)
+function jsonSchemaToZod(schema) {
+    // For basic string/object support in AI SDK without complex parsing
+    // In a real implementation, you'd want a robust JSONSchema to Zod converter.
+    return z.any();
+}
+export async function getMcpTools() {
+    const config = await loadMcpConfig();
+    if (!config || !config.mcpServers) {
+        return {};
+    }
+    const aiTools = {};
+    for (const [serverName, serverConfig] of Object.entries(config.mcpServers)) {
+        try {
+            if (!clients[serverName]) {
+                const transport = new StdioClientTransport({
+                    command: serverConfig.command,
+                    args: serverConfig.args || [],
+                    env: { ...process.env, ...(serverConfig.env || {}) },
+                });
+                const client = new Client({ name: `acmecode-client-${serverName}`, version: '1.0.0' }, { capabilities: {} });
+                await client.connect(transport);
+                clients[serverName] = client;
+            }
+            const client = clients[serverName];
+            const { tools } = await client.listTools();
+            for (const mcpTool of tools) {
+                // Prefix tool names with server name to avoid collisions
+                const toolName = `${serverName}__${mcpTool.name}`;
+                aiTools[toolName] = tool({
+                    description: `[MCP: ${serverName}] ${mcpTool.description || mcpTool.name}`,
+                    parameters: z.any(), // Since we bypass types, any works for JSON schema args
+                    execute: async (args) => {
+                        try {
+                            const result = await client.callTool({
+                                name: mcpTool.name,
+                                arguments: args
+                            });
+                            if (result.isError) {
+                                return `Error from MCP tool: ${JSON.stringify(result.content)}`;
+                            }
+                            // Map result content to text
+                            return result.content.map((c) => c.type === 'text' ? c.text : JSON.stringify(c)).join('\n');
+                        }
+                        catch (err) {
+                            return `Exception calling MCP tool: ${err.message}`;
+                        }
+                    }
+                });
+            }
+        }
+        catch (err) {
+            console.error(`Failed to initialize MCP server ${serverName}:`, err.message);
+        }
+    }
+    return aiTools;
+}

package/dist/session/index.js

@@ -0,0 +1,74 @@
+import Database from 'better-sqlite3';
+import path from 'path';
+import os from 'os';
+import * as fs from 'fs';
+let db = null;
+const DB_DIR = path.join(os.homedir(), '.acmecode');
+const DB_PATH = path.join(DB_DIR, 'sessions.db');
+export function initDb() {
+    if (db)
+        return;
+    if (!fs.existsSync(DB_DIR)) {
+        fs.mkdirSync(DB_DIR, { recursive: true });
+    }
+    db = new Database(DB_PATH);
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    );
+    
+    CREATE TABLE IF NOT EXISTS messages (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      role TEXT NOT NULL,
+      content_json TEXT NOT NULL,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      FOREIGN KEY(session_id) REFERENCES sessions(id) ON DELETE CASCADE
+    );
+  `);
+}
+export function createSession(id, title) {
+    initDb();
+    const titleToUse = title || `Session ${new Date().toLocaleString()}`;
+    const stmt = db.prepare('INSERT INTO sessions (id, title) VALUES (?, ?)');
+    stmt.run(id, titleToUse);
+    return { id, title: titleToUse, updated_at: new Date().toISOString() };
+}
+export function saveMessages(sessionId, messages) {
+    initDb();
+    // Clear existing messages for this session to overwrite with the updated array
+    // This is a simple strategy since the messages array grows append-only
+    const deleteStmt = db.prepare('DELETE FROM messages WHERE session_id = ?');
+    deleteStmt.run(sessionId);
+    const insertStmt = db.prepare('INSERT INTO messages (session_id, role, content_json) VALUES (?, ?, ?)');
+    const insertMany = db.transaction((msgs) => {
+        for (const msg of msgs) {
+            insertStmt.run(sessionId, msg.role, JSON.stringify(msg.content));
+        }
+    });
+    insertMany(messages);
+    // Update session timestamp
+    const updateStmt = db.prepare('UPDATE sessions SET updated_at = CURRENT_TIMESTAMP WHERE id = ?');
+    updateStmt.run(sessionId);
+}
+export function loadSession(sessionId) {
+    initDb();
+    const stmt = db.prepare('SELECT role, content_json FROM messages WHERE session_id = ? ORDER BY id ASC');
+    const rows = stmt.all(sessionId);
+    return rows.map(row => ({
+        role: row.role,
+        content: JSON.parse(row.content_json)
+    }));
+}
+export function listSessions() {
+    initDb();
+    const stmt = db.prepare('SELECT id, title, updated_at FROM sessions ORDER BY updated_at DESC');
+    return stmt.all();
+}
+export function deleteSession(sessionId) {
+    initDb();
+    const stmt = db.prepare('DELETE FROM sessions WHERE id = ?');
+    stmt.run(sessionId);
+}

package/dist/skills/index.js

@@ -0,0 +1,32 @@
+import * as fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+export async function loadSkills() {
+    const globalSkillsPath = path.join(os.homedir(), '.acmecode', 'skills');
+    const localSkillsPath = path.join(process.cwd(), '.acmecode', 'skills');
+    const skills = [];
+    for (const dir of [globalSkillsPath, localSkillsPath]) {
+        try {
+            const files = await fs.readdir(dir);
+            for (const file of files) {
+                if (file.endsWith('.md')) {
+                    const content = await fs.readFile(path.join(dir, file), 'utf8');
+                    const name = file.replace('.md', '');
+                    // simple frontmatter parsing
+                    let description = `Skill ${name}`;
+                    const descriptionMatch = content.match(/description:\s*(.*)/i);
+                    if (descriptionMatch) {
+                        description = descriptionMatch[1].trim();
+                    }
+                    skills.push({ name, description, content });
+                }
+            }
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT') {
+                console.warn(`Could not read skills directory ${dir}: ${err.message}`);
+            }
+        }
+    }
+    return skills;
+}

package/dist/tools/index.js

@@ -0,0 +1,96 @@
+import { tool as createTool } from 'ai';
+import { z } from 'zod';
+import * as fs from 'fs/promises';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import path from 'path';
+const execAsync = promisify(exec);
+export const toolDefinitions = {
+    read_file: {
+        description: 'Read the contents of a file. Relative paths are resolved against the current working directory.',
+        parameters: z.object({
+            path: z.string().min(1).describe('The path to the file to read'),
+        }),
+    },
+    write_file: {
+        description: 'Write content to a file. Creates parent directories if needed. Relative paths are resolved against the current working directory.',
+        parameters: z.object({
+            path: z.string().min(1).describe('The path to the file to write'),
+            content: z.string().describe('The content to write into the file'),
+        }),
+    },
+    run_command: {
+        description: 'Run a shell command on the host machine',
+        parameters: z.object({
+            command: z.string().min(1).describe('The shell command to execute'),
+            cwd: z.string().optional().describe('The working directory to run the command in'),
+        }),
+    },
+    list_dir: {
+        description: 'List the contents of a directory. Relative paths are resolved against the current working directory.',
+        parameters: z.object({
+            path: z.string().min(1).describe('The path to the directory to list'),
+        }),
+    },
+};
+export const toolExecutors = {
+    read_file: async (args) => {
+        try {
+            if (!args.path)
+                return `Error: The "path" argument is required`;
+            const filePath = path.resolve(process.cwd(), args.path);
+            const content = await fs.readFile(filePath, 'utf8');
+            return content;
+        }
+        catch (err) {
+            return `Error reading file: ${err.message}`;
+        }
+    },
+    write_file: async (args) => {
+        try {
+            if (!args.path)
+                return `Error: The "path" argument is required`;
+            if (args.content === undefined)
+                return `Error: The "content" argument is required`;
+            const filePath = path.resolve(process.cwd(), args.path);
+            await fs.mkdir(path.dirname(filePath), { recursive: true });
+            await fs.writeFile(filePath, args.content, 'utf8');
+            const lineCount = (args.content.match(/\n/g) || []).length + 1;
+            return `Successfully wrote to ${filePath} (+${lineCount}行)`;
+        }
+        catch (err) {
+            return `Error writing file: ${err.message}`;
+        }
+    },
+    run_command: async (args) => {
+        try {
+            const { stdout, stderr } = await execAsync(args.command, { cwd: args.cwd || process.cwd() });
+            return `Stdout:\n${stdout}\nStderr:\n${stderr}`;
+        }
+        catch (err) {
+            return `Command failed: ${err.message}\nStderr: ${err.stderr}`;
+        }
+    },
+    list_dir: async (args) => {
+        try {
+            // Default to current directory if not specified
+            const targetPath = args.path || '.';
+            const dirPath = path.resolve(process.cwd(), targetPath);
+            const files = await fs.readdir(dirPath);
+            return files.join('\n');
+        }
+        catch (err) {
+            return `Error listing directory: ${err.message}`;
+        }
+    },
+};
+// Create AI SDK tool objects (with execute) for backward compatibility
+const tool = (options) => createTool(options);
+export const builtInTools = {};
+for (const [name, def] of Object.entries(toolDefinitions)) {
+    builtInTools[name] = tool({
+        description: def.description,
+        parameters: def.parameters,
+        execute: toolExecutors[name],
+    });
+}