mulby-cli 1.1.5

package/dist/services/ai/providers/gemini.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiProvider = void 0;
+const base_1 = require("./base");
+class GeminiProvider extends base_1.BaseAIProvider {
+    constructor(config) {
+        super(config);
+        this.apiKey = config.apiKey;
+        this.baseURL = config.apiEndpoint || 'https://generativelanguage.googleapis.com/v1beta';
+        this.model = config.model || 'gemini-3-pro-preview';
+    }
+    async chat(messages, options) {
+        const { contents, systemInstruction } = this.convertMessages(messages);
+        const tools = options?.tools ? this.convertTools(options.tools) : undefined;
+        // maxTokens 是最大输出 token 数，使用 getMaxOutputTokens() 获取模型默认值
+        const maxOutputTokens = options?.maxTokens || this.config.maxTokens || this.getMaxOutputTokens();
+        const requestBody = {
+            contents,
+            generationConfig: {
+                maxOutputTokens,
+                temperature: 0.7,
+            }
+        };
+        if (systemInstruction) {
+            requestBody.systemInstruction = { parts: [{ text: systemInstruction }] };
+        }
+        if (tools) {
+            requestBody.tools = [tools];
+        }
+        const url = `${this.baseURL}/models/${this.model}:generateContent?key=${this.apiKey}`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(requestBody),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Gemini API error: ${response.status} ${error}`);
+        }
+        const data = await response.json();
+        return this.parseResponse(data);
+    }
+    async chatStream(messages, onChunk, options) {
+        const { contents, systemInstruction } = this.convertMessages(messages);
+        const tools = options?.tools ? this.convertTools(options.tools) : undefined;
+        // maxTokens 是最大输出 token 数，使用 getMaxOutputTokens() 获取模型默认值
+        const maxOutputTokens = options?.maxTokens || this.config.maxTokens || this.getMaxOutputTokens();
+        const requestBody = {
+            contents,
+            generationConfig: {
+                maxOutputTokens,
+                temperature: 0.7,
+            }
+        };
+        if (systemInstruction) {
+            requestBody.systemInstruction = { parts: [{ text: systemInstruction }] };
+        }
+        if (tools) {
+            requestBody.tools = [tools];
+        }
+        const url = `${this.baseURL}/models/${this.model}:streamGenerateContent?key=${this.apiKey}&alt=sse`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(requestBody),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Gemini API error: ${response.status} ${error}`);
+        }
+        let fullContent = '';
+        const reader = response.body?.getReader();
+        const decoder = new TextDecoder();
+        if (!reader) {
+            throw new Error('Response body is not readable');
+        }
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            const chunk = decoder.decode(value, { stream: true });
+            const lines = chunk.split('\n');
+            for (const line of lines) {
+                if (line.startsWith('data: ')) {
+                    try {
+                        const data = JSON.parse(line.slice(6));
+                        const text = data.candidates?.[0]?.content?.parts?.[0]?.text;
+                        if (text) {
+                            fullContent += text;
+                            onChunk(text);
+                        }
+                    }
+                    catch (e) {
+                        // Ignore parse errors
+                    }
+                }
+            }
+        }
+        // TODO: Handle tool calls in stream if needed
+        return { content: fullContent };
+    }
+    convertMessages(messages) {
+        let systemInstruction;
+        const contents = [];
+        for (const msg of messages) {
+            if (msg.role === 'system') {
+                systemInstruction = typeof msg.content === 'string' ? msg.content : '';
+                continue;
+            }
+            if (msg.role === 'tool') {
+                // 工具响应
+                const lastMessage = contents[contents.length - 1];
+                if (lastMessage && lastMessage.role === 'model') {
+                    lastMessage.parts.push({
+                        functionResponse: {
+                            name: msg.name,
+                            response: {
+                                content: msg.content
+                            }
+                        }
+                    });
+                }
+                continue;
+            }
+            const role = msg.role === 'assistant' ? 'model' : 'user';
+            const parts = [];
+            if (msg.content) {
+                parts.push({ text: msg.content });
+            }
+            if (msg.tool_calls) {
+                for (const toolCall of msg.tool_calls) {
+                    parts.push({
+                        functionCall: {
+                            name: toolCall.function.name,
+                            args: JSON.parse(toolCall.function.arguments)
+                        }
+                    });
+                }
+            }
+            contents.push({ role, parts });
+        }
+        return { contents, systemInstruction };
+    }
+    convertTools(tools) {
+        return {
+            functionDeclarations: tools.map(tool => ({
+                name: tool.function.name,
+                description: tool.function.description,
+                parameters: tool.function.parameters
+            }))
+        };
+    }
+    parseResponse(data) {
+        const candidate = data.candidates?.[0];
+        if (!candidate) {
+            return { content: null };
+        }
+        const parts = candidate.content?.parts || [];
+        let content = '';
+        const toolCalls = [];
+        for (const part of parts) {
+            if (part.text) {
+                content += part.text;
+            }
+            if (part.functionCall) {
+                toolCalls.push({
+                    id: `call_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+                    type: 'function',
+                    function: {
+                        name: part.functionCall.name,
+                        arguments: JSON.stringify(part.functionCall.args)
+                    }
+                });
+            }
+        }
+        return {
+            content: content || null,
+            toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+            usage: data.usageMetadata ? {
+                promptTokens: data.usageMetadata.promptTokenCount || 0,
+                completionTokens: data.usageMetadata.candidatesTokenCount || 0,
+                totalTokens: data.usageMetadata.totalTokenCount || 0
+            } : undefined
+        };
+    }
+}
+exports.GeminiProvider = GeminiProvider;

package/dist/services/ai/providers/glm.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GLMProvider = void 0;
+const openai_1 = require("./openai");
+/**
+ * GLM (智谱AI) Provider
+ * 智谱AI提供与OpenAI兼容的API接口
+ * 文档: https://docs.bigmodel.cn/cn/guide/develop/openai/introduction
+ *
+ * 支持模型:
+ * - glm-4.7: 最新旗舰模型 (200K上下文, 128K输出)
+ * - glm-4.6: 上一代旗舰 (200K上下文, 8K输出)
+ * - glm-4-plus/glm-4: 标准模型 (128K上下文, 4K输出)
+ * - glm-4-long: 长上下文模型 (1M上下文, 4K输出)
+ */
+class GLMProvider extends openai_1.OpenAIProvider {
+    constructor(config) {
+        // 智谱AI使用OpenAI兼容接口
+        // 注意: maxTokens 是最大输出 token 数，不是上下文窗口
+        const glmConfig = {
+            ...config,
+            provider: 'glm',
+            apiEndpoint: config.apiEndpoint || 'https://open.bigmodel.cn/api/paas/v4',
+            model: config.model || 'glm-4-plus',
+            enableThinking: config.enableThinking ?? true,
+            // 不设置默认值，让 getMaxOutputTokens() 从模型推断
+        };
+        super(glmConfig);
+    }
+}
+exports.GLMProvider = GLMProvider;

package/dist/services/ai/providers/minimax.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MiniMaxProvider = void 0;
+const claude_1 = require("./claude");
+/**
+ * MiniMax Provider - 使用 Anthropic SDK 兼容接口
+ *
+ * 支持模型:
+ * - MiniMax-M2.1: 强大多语言编程实力 (200K上下文, 8K输出)
+ * - MiniMax-M2.1-lightning: 极速版 (200K上下文, 8K输出)
+ * - MiniMax-M2: 基础版 (200K上下文, 8K输出)
+ *
+ * API 端点: https://api.minimaxi.com/anthropic
+ */
+class MiniMaxProvider extends claude_1.ClaudeProvider {
+    constructor(config) {
+        const minimaxConfig = {
+            ...config,
+            provider: 'minimax',
+            apiEndpoint: config.apiEndpoint || 'https://api.minimaxi.com/anthropic',
+            model: config.model || 'MiniMax-M2.1',
+            // 不设置默认值，让 getMaxOutputTokens() 从模型推断
+        };
+        super(minimaxConfig);
+    }
+}
+exports.MiniMaxProvider = MiniMaxProvider;

package/dist/services/ai/providers/openai.js

@@ -0,0 +1,177 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIProvider = void 0;
+const openai_1 = __importDefault(require("openai"));
+const base_1 = require("./base");
+class OpenAIProvider extends base_1.BaseAIProvider {
+    constructor(config) {
+        super(config);
+        this.client = new openai_1.default({
+            apiKey: config.apiKey,
+            baseURL: config.apiEndpoint,
+            timeout: (config.timeout || 60) * 1000,
+        });
+    }
+    async chat(messages, options) {
+        const model = options?.model || this.config.model || 'gpt-5.2';
+        // maxTokens 是最大输出 token 数，使用 getMaxOutputTokens() 获取模型默认值
+        let maxTokens = options?.maxTokens || this.config.maxTokens || this.getMaxOutputTokens();
+        // Final safety cast to number
+        maxTokens = Number(maxTokens);
+        if (isNaN(maxTokens))
+            maxTokens = 128000; // gpt-5.2 默认最大输出
+        const requestOptions = {
+            model: model,
+            messages: messages, // Type casting for compatibility
+            temperature: options?.temperature,
+            max_tokens: maxTokens,
+            tools: options?.tools,
+            tool_choice: options?.toolChoice,
+            stream: false,
+        };
+        if (options?.enableThinking || this.config.enableThinking) {
+            requestOptions.extra_body = {
+                thinking: {
+                    type: "enabled",
+                },
+            };
+        }
+        const response = await this.client.chat.completions.create(requestOptions);
+        const choice = response.choices[0];
+        const message = choice.message;
+        let content = message.content;
+        // DeepSeek & GLM reasoning support
+        let reasoningContent;
+        if (message.reasoning_content) {
+            reasoningContent = message.reasoning_content;
+            // Removed: content = `<think>\n${thinking}\n</think>\n\n${content || ''}`;
+            // We now keep content clean and return reasoning_content separately
+        }
+        return {
+            content: content,
+            reasoning_content: reasoningContent,
+            toolCalls: message.tool_calls,
+            usage: response.usage ? {
+                promptTokens: response.usage.prompt_tokens,
+                completionTokens: response.usage.completion_tokens,
+                totalTokens: response.usage.total_tokens
+            } : undefined
+        };
+    }
+    async chatStream(messages, onChunk, options) {
+        const model = options?.model || this.config.model || 'gpt-5.2';
+        // maxTokens 是最大输出 token 数，使用 getMaxOutputTokens() 获取模型默认值
+        let maxTokens = options?.maxTokens || this.config.maxTokens || this.getMaxOutputTokens();
+        // Final safety cast to number
+        maxTokens = Number(maxTokens);
+        if (isNaN(maxTokens))
+            maxTokens = 128000; // gpt-5.2 默认最大输出
+        const requestOptions = {
+            model: model,
+            messages: messages,
+            temperature: options?.temperature,
+            max_tokens: maxTokens,
+            tools: options?.tools,
+            tool_choice: options?.toolChoice,
+            stream: true,
+            stream_options: { include_usage: true }
+        };
+        if (options?.enableThinking || this.config.enableThinking) {
+            requestOptions.extra_body = {
+                thinking: {
+                    type: "enabled",
+                },
+            };
+        }
+        const stream = await this.client.chat.completions.create(requestOptions);
+        let cleanContent = '';
+        let reasoningContent = '';
+        const toolCallsMap = {};
+        let hasStartedThinking = false;
+        let hasEndedThinking = false;
+        let finalUsage = undefined;
+        for await (const chunk of stream) {
+            if (chunk.usage) {
+                finalUsage = chunk.usage;
+            }
+            const choices = chunk.choices || [];
+            if (choices.length === 0)
+                continue;
+            const delta = choices[0].delta;
+            // Handle reasoning content (GLM/DeepSeek)
+            if (delta?.reasoning_content) {
+                if (!hasStartedThinking) {
+                    const startTag = '<think>\n';
+                    onChunk(startTag);
+                    hasStartedThinking = true;
+                }
+                const reasoning = delta.reasoning_content;
+                reasoningContent += reasoning;
+                onChunk(reasoning);
+                continue;
+            }
+            // Close thinking tag if we switch to normal content or tools
+            if (hasStartedThinking && !hasEndedThinking && (delta?.content || delta?.tool_calls)) {
+                const endTag = '\n</think>\n\n';
+                onChunk(endTag);
+                hasEndedThinking = true;
+            }
+            // Handle Content
+            const content = delta?.content || '';
+            if (content) {
+                cleanContent += content;
+                onChunk(content);
+            }
+            // Handle Tool Calls
+            if (delta?.tool_calls) {
+                for (const toolCall of delta.tool_calls) {
+                    const index = toolCall.index;
+                    if (!toolCallsMap[index]) {
+                        toolCallsMap[index] = {
+                            id: toolCall.id || '',
+                            type: toolCall.type || 'function',
+                            function: {
+                                name: toolCall.function?.name || '',
+                                arguments: toolCall.function?.arguments || ''
+                            }
+                        };
+                    }
+                    else {
+                        // Append arguments
+                        if (toolCall.function?.arguments) {
+                            toolCallsMap[index].function.arguments += toolCall.function.arguments;
+                        }
+                    }
+                }
+            }
+        }
+        // Ensure thinking tag is closed if stream ends just after reasoning
+        if (hasStartedThinking && !hasEndedThinking) {
+            const endTag = '\n</think>\n\n';
+            onChunk(endTag);
+            hasEndedThinking = true;
+        }
+        const toolCalls = Object.values(toolCallsMap).map((tc) => ({
+            id: tc.id,
+            type: tc.type,
+            function: {
+                name: tc.function.name,
+                arguments: tc.function.arguments // Keep as string, caller parses it
+            }
+        }));
+        return {
+            content: cleanContent,
+            reasoning_content: reasoningContent || undefined,
+            toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+            usage: finalUsage ? {
+                promptTokens: finalUsage.prompt_tokens,
+                completionTokens: finalUsage.completion_tokens,
+                totalTokens: finalUsage.total_tokens
+            } : undefined
+        };
+    }
+}
+exports.OpenAIProvider = OpenAIProvider;

package/dist/services/ai/tools.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLUGIN_GENERATION_TOOLS = void 0;
+exports.PLUGIN_GENERATION_TOOLS = [
+    {
+        type: 'function',
+        function: {
+            name: 'read_file',
+            description: 'Read the content of a file. Use this to examine existing code or check file status.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Relative path to the file (e.g., package.json, src/ui/App.tsx)' }
+                },
+                required: ['path']
+            }
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'replace_in_file',
+            description: 'Replace a specific part of a file. Use this for small edits (bug fixes, tweaks) to save tokens. It fails if the target string is not found or found multiple times (unless expected).',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Relative path to the file' },
+                    target: { type: 'string', description: 'Exact string to be replaced (must be unique in file)' },
+                    replacement: { type: 'string', description: 'New content to replace the target with' }
+                },
+                required: ['path', 'target', 'replacement']
+            }
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'write_file',
+            description: 'Create or overwrite a file with new content.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Relative path to the file' },
+                    content: { type: 'string', description: 'Complete content of the file' }
+                },
+                required: ['path', 'content']
+            }
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'run_command',
+            description: 'Execute a shell command. Use this for installing dependencies (npm install) or other necessary shell operations. Do NOT run long-running processes like "npm run dev".',
+            parameters: {
+                type: 'object',
+                properties: {
+                    command: { type: 'string', description: 'The shell command to execute' }
+                },
+                required: ['command']
+            }
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'ask_user',
+            description: 'Ask the user a question to clarify requirements or request a decision. Use this frequently during the Product Consultant phase.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    question: { type: 'string', description: 'The question to ask the user' }
+                },
+                required: ['question']
+            }
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'scaffold_project',
+            description: 'Create the project scaffold (React + Vite template). Call this ONLY after you have confirmed requirements with the user in the Product Consultant phase. This will generate: package.json, manifest.json, vite.config.ts, src/ui/App.tsx, etc.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    reason: { type: 'string', description: 'Reason for creating scaffold (e.g., "Requirements confirmed: image stitching tool with drag-drop UI")' }
+                },
+                required: ['reason']
+            }
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'list_dir',
+            description: 'List files and directories in a specific path. Use this to explore the project structure.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Relative path to list (e.g., ".", "src/components")' }
+                },
+                required: ['path']
+            }
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'search_files',
+            description: 'Search for a string or pattern in files. Useful for finding component usage or specific code snippets.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    query: { type: 'string', description: 'String or Regex to search for' },
+                    path: { type: 'string', description: 'Directory to search in (default: ".")' }
+                },
+                required: ['query']
+            }
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'read_file_outline',
+            description: 'Read the outline (symbols, functions, classes) of a file without reading the full content. Saves tokens.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Relative path to the file' }
+                },
+                required: ['path']
+            }
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'delete_file',
+            description: 'Delete a file or directory.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Relative path to delete' }
+                },
+                required: ['path']
+            }
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'move_file',
+            description: 'Move or rename a file.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    source: { type: 'string', description: 'Current path' },
+                    destination: { type: 'string', description: 'New path' }
+                },
+                required: ['source', 'destination']
+            }
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'fetch_url',
+            description: 'Fetch content from a URL to read documentation or external data (converts to Markdown/Text).',
+            parameters: {
+                type: 'object',
+                properties: {
+                    url: { type: 'string', description: 'The URL to fetch' }
+                },
+                required: ['url']
+            }
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'check_types',
+            description: 'Run TypeScript compiler to check for type errors.',
+            parameters: {
+                type: 'object',
+                properties: {},
+                required: []
+            }
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'finish',
+            description: 'Mark the task as complete when all requirements are met.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    summary: { type: 'string', description: 'Summary of what was done and instructions for the user.' }
+                },
+                required: ['summary']
+            }
+        }
+    }
+];