acmecode 1.0.0

package/dist/tui/App.js

@@ -0,0 +1,297 @@
+import React, { useState, useRef } from 'react';
+import { Box, Text, Static } from 'ink';
+import TextInput from './TextInput.js';
+import Spinner from './Spinner.js';
+import { runAgent } from '../agent/index.js';
+import { loadSession, saveMessages } from '../session/index.js';
+import { loadSkills } from '../skills/index.js';
+import { getProjectContext } from '../context/index.js';
+import { getProviderKey, getProviderBaseUrl, loadModelConfig, saveProjectModelConfig } from '../config/index.js';
+let cachedModels = [];
+let itemCounter = 0;
+function extractContent(msg) {
+    if (typeof msg.content === 'string')
+        return msg.content;
+    if (Array.isArray(msg.content)) {
+        return msg.content.map((c) => {
+            if (c.type === 'text')
+                return c.text;
+            if (c.type === 'tool-call')
+                return `\n> [Tool Call] ${c.toolName}...\n`;
+            if (c.type === 'tool-result') {
+                const r = typeof c.result === 'string' ? c.result : JSON.stringify(c.result, null, 2);
+                return `\n> [Result: ${c.toolName}]\n${r}\n`;
+            }
+            return '';
+        }).join('');
+    }
+    return '';
+}
+export function App({ sessionId, onExit }) {
+    // displayItems: permanently rendered messages (Static)
+    const [displayItems, setDisplayItems] = useState(() => {
+        try {
+            const saved = loadSession(sessionId) || [];
+            return saved
+                .filter((m) => m.role !== 'tool')
+                .map((m) => {
+                const text = extractContent(m);
+                if (!text && m.role === 'assistant')
+                    return null;
+                return { id: String(itemCounter++), role: m.role, text };
+            })
+                .filter(Boolean);
+        }
+        catch (e) {
+            return [];
+        }
+    });
+    const [currentInput, setCurrentInput] = useState('');
+    const [isGenerating, setIsGenerating] = useState(false);
+    const [streamingText, setStreamingText] = useState('');
+    const [statusText, setStatusText] = useState('');
+    const [activeSkill, setActiveSkill] = useState(null);
+    const [provider, setProvider] = useState(() => {
+        const cfg = loadModelConfig();
+        return cfg.provider;
+    });
+    const [modelName, setModelName] = useState(() => {
+        const cfg = loadModelConfig();
+        return cfg.model;
+    });
+    // Keep a ref for the full messages array (for LLM context), avoid re-rendering on changes
+    const messagesRef = useRef((() => {
+        try {
+            return loadSession(sessionId) || [];
+        }
+        catch {
+            return [];
+        }
+    })());
+    const addDisplayItem = (role, text) => {
+        const item = { id: String(itemCounter++), role, text };
+        setDisplayItems(prev => [...prev, item]);
+        return item;
+    };
+    const handleSubmit = async (value) => {
+        if (value.trim() === '/exit' || value.trim() === '/quit') {
+            onExit();
+            return;
+        }
+        if (value.trim() === '/clear') {
+            setDisplayItems([]);
+            setCurrentInput('');
+            setActiveSkill(null);
+            messagesRef.current = [];
+            return;
+        }
+        if (value.startsWith('/skill')) {
+            const skillName = value.split(' ')[1];
+            setCurrentInput('');
+            if (!skillName) {
+                const skills = await loadSkills();
+                addDisplayItem('assistant', `Available skills:\n${skills.length ? skills.map(s => `- ${s.name}: ${s.description}`).join('\n') : 'No skills found'}`);
+                return;
+            }
+            const skills = await loadSkills();
+            const skill = skills.find(s => s.name === skillName);
+            if (skill) {
+                setActiveSkill(skill);
+                addDisplayItem('assistant', `Activated skill: ${skill.name}`);
+            }
+            else {
+                addDisplayItem('assistant', `Skill not found: ${skillName}`);
+            }
+            return;
+        }
+        if (value.startsWith('/model')) {
+            const args = value.split(' ').slice(1).join(' ').trim();
+            setCurrentInput('');
+            if (args && /^\d+$/.test(args)) {
+                const idx = parseInt(args, 10) - 1;
+                if (cachedModels.length > 0 && idx >= 0 && idx < cachedModels.length) {
+                    const selected = cachedModels[idx];
+                    setProvider('openai');
+                    setModelName(selected.id);
+                    saveProjectModelConfig('openai', selected.id);
+                    addDisplayItem('assistant', `✅ Switched to: ${selected.id} (saved to .acmecode/config.json)`);
+                }
+                else {
+                    addDisplayItem('assistant', `Invalid number. Use /model to list available models first.`);
+                }
+                return;
+            }
+            if (args && args.includes(':')) {
+                const parts = args.split(':');
+                const newProvider = parts[0];
+                const newModel = parts.slice(1).join(':');
+                if (['openai', 'anthropic', 'google'].includes(newProvider)) {
+                    setProvider(newProvider);
+                    setModelName(newModel);
+                    saveProjectModelConfig(newProvider, newModel);
+                    addDisplayItem('assistant', `✅ Switched to ${newProvider}:${newModel} (saved to .acmecode/config.json)`);
+                }
+                else {
+                    addDisplayItem('assistant', `Unknown provider: ${newProvider}. Supported: openai, anthropic, google`);
+                }
+                return;
+            }
+            addDisplayItem('assistant', `Current model: ${provider}:${modelName}\nFetching available models...`);
+            try {
+                const apiKey = getProviderKey('openai');
+                const baseUrl = getProviderBaseUrl('openai');
+                if (!apiKey || !baseUrl) {
+                    addDisplayItem('assistant', 'Error: API key or Base URL not configured.');
+                    return;
+                }
+                const res = await fetch(`${baseUrl}/models`, {
+                    headers: { 'Authorization': `Bearer ${apiKey}` }
+                });
+                if (!res.ok)
+                    throw new Error(`HTTP ${res.status}`);
+                const data = await res.json();
+                const models = (data.data || []);
+                cachedModels = models;
+                if (models.length === 0) {
+                    addDisplayItem('assistant', 'No models found.');
+                }
+                else {
+                    const list = models.map((m, i) => `  ${i + 1}. ${m.id}`).join('\n');
+                    addDisplayItem('assistant', `📋 Available models:\n${list}\n\nUse /model <number> to select.`);
+                }
+            }
+            catch (err) {
+                addDisplayItem('assistant', `Error: ${err.message}`);
+            }
+            return;
+        }
+        if (value.trim() && !isGenerating) {
+            // Show user message immediately (goes into Static)
+            addDisplayItem('user', value);
+            setCurrentInput('');
+            setIsGenerating(true);
+            setStreamingText('');
+            const currentMessages = Array.isArray(messagesRef.current) ? messagesRef.current : [];
+            const newMessages = [...currentMessages, { role: 'user', content: value }];
+            try {
+                let systemPrompt = `You are AcmeCode, an AI coding assistant. Help the user with their programming tasks. You have access to tools that can read/write files and run shell commands. Always respond in the same language as the user.
+
+Current working directory: ${process.cwd()}
+When creating or reading files, always use relative paths (e.g. "snake.html", "src/app.ts") — they will be resolved against the current working directory automatically. Do NOT use absolute paths.
+
+CRITICAL INSTRUCTIONS FOR TOOL CALLING:
+1. You MUST use the official JSON schema format when calling tools.
+2. NEVER output fake tool calls in plain text or markdown (e.g., do NOT write \`[read_file(...)]\` or \`call_tool(...)\` in your response).
+3. After using any tool, you MUST provide a brief text summary of what you did and the result. Never end your turn with just a tool call — always follow up with a human-readable explanation.`;
+                const projectContext = await getProjectContext();
+                if (projectContext)
+                    systemPrompt += projectContext;
+                if (activeSkill)
+                    systemPrompt += `\n\nActive Skill Instructions:\n${activeSkill.content}`;
+                const generator = runAgent(provider, modelName, newMessages, systemPrompt);
+                let fullResponse = '';
+                let lastFlush = Date.now();
+                let didGetMessages = false;
+                setStatusText('思考中...');
+                // Idle timer: if no events for 2s, show "generating code" status
+                let idleTimer = null;
+                const resetIdle = () => {
+                    if (idleTimer)
+                        clearTimeout(idleTimer);
+                    idleTimer = setTimeout(() => {
+                        setStreamingText(fullResponse); // flush any throttled text
+                        setStatusText('⏳ 生成代码中，请稍候...');
+                    }, 2000);
+                };
+                resetIdle();
+                for await (const event of generator) {
+                    resetIdle();
+                    if (event.type === 'text') {
+                        setStatusText('');
+                        fullResponse += event.text;
+                        const now = Date.now();
+                        if (now - lastFlush > 100) {
+                            setStreamingText(fullResponse);
+                            lastFlush = now;
+                        }
+                    }
+                    else if (event.type === 'tool-call') {
+                        const toolIcons = {
+                            read_file: '📖 读取文件',
+                            write_file: '📝 写入文件',
+                            run_command: '⚡ 执行命令',
+                            list_dir: '📂 列出目录',
+                        };
+                        const icon = toolIcons[event.name] || `🔧 ${event.name}`;
+                        // Try to extract a meaningful detail from args
+                        let detail = '';
+                        const args = event.args || {};
+                        if (args.path) {
+                            detail = `: ${args.path}`;
+                        }
+                        else if (args.command) {
+                            detail = `: ${args.command}`;
+                        }
+                        else {
+                            // Show all arg keys as fallback (skip large values like 'content')
+                            const keys = Object.keys(args).filter(k => k !== 'content');
+                            if (keys.length > 0) {
+                                detail = `: ${keys.map(k => `${k}=${JSON.stringify(args[k]).slice(0, 50)}`).join(', ')}`;
+                            }
+                        }
+                        setStatusText(`${icon}${detail}`);
+                        fullResponse += `\n> ${icon}${detail}\n`;
+                        setStreamingText(fullResponse);
+                    }
+                    else if (event.type === 'tool-result') {
+                        const resultStr = typeof event.result === 'string' ? event.result : JSON.stringify(event.result, null, 2);
+                        const shortResult = resultStr
+                            ? (resultStr.length > 200 ? resultStr.slice(0, 200) + '...' : resultStr)
+                            : '完成';
+                        fullResponse += `  ✅ ${shortResult}\n`;
+                        setStreamingText(fullResponse);
+                        setStatusText('思考中...');
+                    }
+                    else if (event.type === 'messages') {
+                        messagesRef.current = event.messages;
+                        saveMessages(sessionId, messagesRef.current);
+                        didGetMessages = true;
+                    }
+                }
+                if (idleTimer)
+                    clearTimeout(idleTimer);
+                setStatusText('');
+                // Move streaming text into Static as a completed message
+                if (fullResponse) {
+                    addDisplayItem('assistant', fullResponse);
+                }
+                if (!didGetMessages) {
+                    const fallback = [...newMessages, { role: 'assistant', content: fullResponse }];
+                    messagesRef.current = fallback;
+                    saveMessages(sessionId, fallback);
+                }
+                setStreamingText('');
+            }
+            catch (err) {
+                addDisplayItem('assistant', `Error: ${err.message}`);
+                setStreamingText('');
+            }
+            finally {
+                setIsGenerating(false);
+            }
+        }
+    };
+    return (React.createElement(Box, { flexDirection: "column", width: "100%" },
+        React.createElement(Static, { items: displayItems }, (item) => (React.createElement(Box, { key: item.id, flexDirection: "column", marginBottom: 0 },
+            React.createElement(Text, { bold: true, color: item.role === 'user' ? 'green' : 'blue' }, item.role === 'user' ? 'You' : 'AcmeCode'),
+            React.createElement(Text, null, item.text)))),
+        isGenerating && !streamingText && statusText ? (React.createElement(Box, { marginY: 0 },
+            React.createElement(Spinner, { label: statusText }))) : null,
+        isGenerating && streamingText ? (React.createElement(Box, { flexDirection: "column", marginBottom: 0 },
+            React.createElement(Text, { bold: true, color: "blue" }, "AcmeCode"),
+            React.createElement(Text, null, streamingText),
+            statusText ? React.createElement(Spinner, { label: statusText }) : null)) : null,
+        !isGenerating ? (React.createElement(Box, null,
+            React.createElement(Text, { color: "green" }, "\u276F "),
+            React.createElement(TextInput, { value: currentInput, onChange: setCurrentInput, onSubmit: handleSubmit, placeholder: "Ask AcmeCode (or type /exit)..." }))) : null));
+}

package/dist/tui/Spinner.js

@@ -0,0 +1,16 @@
+import React, { useState, useEffect } from 'react';
+import { Text } from 'ink';
+const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+export default function Spinner({ label }) {
+    const [frame, setFrame] = useState(0);
+    useEffect(() => {
+        const timer = setInterval(() => {
+            setFrame(prev => (prev + 1) % frames.length);
+        }, 80);
+        return () => clearInterval(timer);
+    }, []);
+    return (React.createElement(Text, { color: "yellow" },
+        frames[frame],
+        " ",
+        label || 'Thinking...'));
+}

package/dist/tui/TextInput.js

@@ -0,0 +1,98 @@
+import React, { useState, useRef, useEffect } from 'react';
+import { Text, useInput } from 'ink';
+import chalk from 'chalk';
+/**
+ * Custom TextInput that fixes the stale-closure bug in ink-text-input@6.0.0.
+ * When Chinese IME sends a phrase (多个字符), the original component's useInput
+ * callback captures stale `cursorOffset` and `originalValue`, causing characters
+ * to be lost. This version uses refs to always read the latest values.
+ */
+function TextInput({ value, placeholder = '', focus = true, showCursor = true, onChange, onSubmit, }) {
+    const [cursorOffset, setCursorOffset] = useState(value.length);
+    // Refs to avoid stale closures in useInput callback
+    const valueRef = useRef(value);
+    const cursorRef = useRef(cursorOffset);
+    const onChangeRef = useRef(onChange);
+    const onSubmitRef = useRef(onSubmit);
+    valueRef.current = value;
+    cursorRef.current = cursorOffset;
+    onChangeRef.current = onChange;
+    onSubmitRef.current = onSubmit;
+    // Keep cursor in bounds when value changes externally
+    useEffect(() => {
+        if (cursorOffset > value.length) {
+            setCursorOffset(value.length);
+        }
+    }, [value, cursorOffset]);
+    useInput((input, key) => {
+        if (key.upArrow ||
+            key.downArrow ||
+            (key.ctrl && input === 'c') ||
+            key.tab ||
+            (key.shift && key.tab) ||
+            key.escape) {
+            return;
+        }
+        const currentValue = valueRef.current;
+        const currentCursor = cursorRef.current;
+        if (key.return) {
+            onSubmitRef.current?.(currentValue);
+            return;
+        }
+        if (key.leftArrow) {
+            const next = Math.max(0, currentCursor - 1);
+            setCursorOffset(next);
+            cursorRef.current = next;
+            return;
+        }
+        if (key.rightArrow) {
+            const next = Math.min(currentValue.length, currentCursor + 1);
+            setCursorOffset(next);
+            cursorRef.current = next;
+            return;
+        }
+        if (key.backspace || key.delete) {
+            if (currentCursor > 0) {
+                const nextValue = currentValue.slice(0, currentCursor - 1) +
+                    currentValue.slice(currentCursor);
+                const nextCursor = currentCursor - 1;
+                setCursorOffset(nextCursor);
+                cursorRef.current = nextCursor;
+                valueRef.current = nextValue;
+                onChangeRef.current(nextValue);
+            }
+            return;
+        }
+        // Normal character input (including multi-char IME input)
+        const nextValue = currentValue.slice(0, currentCursor) +
+            input +
+            currentValue.slice(currentCursor);
+        const nextCursor = currentCursor + input.length;
+        setCursorOffset(nextCursor);
+        cursorRef.current = nextCursor;
+        valueRef.current = nextValue;
+        onChangeRef.current(nextValue);
+    }, { isActive: focus });
+    // Simplified render — avoid expensive chalk.inverse per-character to reduce flicker
+    if (showCursor && focus) {
+        if (value.length === 0) {
+            if (placeholder) {
+                return React.createElement(Text, null, chalk.inverse(placeholder[0]) + chalk.grey(placeholder.slice(1)));
+            }
+            return React.createElement(Text, null, chalk.inverse(' '));
+        }
+        // Build rendered string with cursor
+        const before = value.slice(0, cursorOffset);
+        const cursorChar = cursorOffset < value.length ? value[cursorOffset] : ' ';
+        const after = cursorOffset < value.length ? value.slice(cursorOffset + 1) : '';
+        return React.createElement(Text, null,
+            before,
+            chalk.inverse(cursorChar),
+            after);
+    }
+    if (value.length === 0 && placeholder) {
+        return React.createElement(Text, null, chalk.grey(placeholder));
+    }
+    return React.createElement(Text, null, value);
+}
+export default React.memo(TextInput);

package/dist/tui/src/App.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+export interface ChatMessage {
+    role: "user" | "assistant" | "system" | "tool";
+    content: any;
+}
+interface AppProps {
+    sessionId: string;
+    onExit: () => void;
+}
+export default function App({ sessionId, onExit, }: AppProps): React.ReactElement | null;
+export {};