galaxy-code 0.1.0

package/dist/app.js

@@ -0,0 +1,596 @@
+/**
+ * @author Bùi Trọng Hiếu
+ * @email kevinbui210191@gmail.com
+ * @create 2024-10-08
+ * @modify 2024-10-13
+ * @desc Main Ink interface with config-based agent routing.
+ */
+import process from 'node:process';
+import React, { useMemo, useState, useEffect } from 'react';
+import { Box, Static, Text, useApp, useInput } from 'ink';
+import TextInput from 'ink-text-input';
+import Spinner from 'ink-spinner';
+import figlet from 'figlet';
+import { ClaudeAgent, GeminiAgent, OllamaAgent, } from '@workspace/agent-core/providers';
+import { formatMessage, configManager } from '@workspace/agent-core';
+import { toolEventEmitter } from '@workspace/agent-core/tools';
+const cliVersion = '2.0.0';
+const getTerminalWidth = () => {
+    const width = process.stdout?.columns;
+    return typeof width === 'number' && Number.isFinite(width) ? width : 80;
+};
+const centerLine = (text, width) => {
+    const trimmed = text.replace(/\s+$/u, '');
+    if (!trimmed)
+        return '';
+    const padding = Math.max(0, Math.floor((width - trimmed.length) / 2));
+    return `${' '.repeat(padding)}${trimmed}`;
+};
+const getInforLines = (config) => {
+    const width = getTerminalWidth();
+    const agentStr = config.model;
+    const lines = [
+        { id: 'version', text: cliVersion },
+        {
+            id: 'hints',
+            text: 'ENTER to send • \\ + ENTER for a new line • @ to mention files',
+        },
+        { id: 'cwd', text: `Current folder: ${process.cwd()}` },
+        {
+            id: 'config',
+            text: `Agent=${agentStr} Git=${config.git ? 'ON' : 'OFF'} Test=${config.test ? 'ON' : 'OFF'}`,
+        },
+    ];
+    return lines.map(line => ({
+        id: line.id,
+        text: centerLine(line.text, width - 50),
+    }));
+};
+// Generate ASCII art banner once
+const bannerText = figlet.textSync('GALAXY', {
+    font: 'Standard',
+    horizontalLayout: 'default',
+    verticalLayout: 'default',
+});
+export default function App({ config }) {
+    const { exit } = useApp();
+    const [input, setInput] = useState('');
+    const [messages, setMessages] = useState([
+        { id: 'banner' },
+        // Show config error as system message if exists
+        ...(config.error
+            ? [
+                {
+                    id: 'config-error',
+                    author: 'system',
+                    content: `⚠️ ${config.error}`,
+                    timestamp: Date.now(),
+                },
+            ]
+            : []),
+    ]);
+    const [isProcessing, setIsProcessing] = useState(false);
+    const [commandSuggestions, setCommandSuggestions] = useState([]);
+    const [planning, setPlanning] = useState([]);
+    const [inputHistory, setInputHistory] = useState([]);
+    const [historyIndex, setHistoryIndex] = useState(-1);
+    const [suggestionIndex, setSuggestionIndex] = useState(0);
+    const [currentConfig, setCurrentConfig] = useState(config);
+    const infoLines = getInforLines(currentConfig);
+    // Initialize agent connection based on config
+    const agentConnection = useMemo(() => {
+        // Manual mode = Use Ollama with specific config
+        if (currentConfig.model === 'manual') {
+            // Find manual agent config to get apiKey
+            const manualAgentConfig = currentConfig.agent.find(value => value.type === 'manual');
+            return new OllamaAgent({
+                type: 'ollama',
+                model: 'qwen3-coder:480b-cloud',
+                host: 'https://ollama.com',
+                apiKey: manualAgentConfig?.apiKey,
+            });
+        }
+        // Find agent config by model type
+        const agentConfig = currentConfig.agent.find(value => value.type === currentConfig.model);
+        if (!agentConfig) {
+            return null;
+        }
+        // Direct agent mode (claude, gemini, ollama)
+        switch (currentConfig.model) {
+            case 'claude':
+                return new ClaudeAgent(agentConfig);
+            case 'ollama':
+                return new OllamaAgent(agentConfig);
+            case 'gemini':
+                return new GeminiAgent(agentConfig);
+            default:
+                return null;
+        }
+    }, [currentConfig.model, currentConfig.agent]);
+    const commandCatalog = useMemo(() => [
+        { command: '/help', description: 'Hiển thị danh sách lệnh' },
+        { command: '/exit', description: 'Thoát khỏi Galaxy CLI' },
+        { command: '/clear', description: 'Xóa lịch sử hội thoại hiện tại' },
+        { command: '/history', description: 'Xem danh sách 10 input gần nhất' },
+        { command: '/pwd', description: 'Hiển thị thư mục làm việc hiện tại' },
+        { command: '/information', description: 'Hiển thị thông tin hệ thống' },
+        {
+            command: '/git',
+            description: 'Bật/tắt git operations (/git true|false)',
+        },
+        {
+            command: '/test',
+            description: 'Bật/tắt test planning (/test true|false)',
+        },
+        {
+            command: '/mode',
+            description: 'Chọn agent mode (/mode claude|gemini|ollama|manual)',
+        },
+        { command: '/config', description: 'Mở thư mục chứa file cấu hình' },
+    ], []);
+    // Subscribe to tool execution events
+    useEffect(() => {
+        const unsubscribe = toolEventEmitter.onToolExecution((event) => {
+            // Handle plan_task - Create planning list
+            if (event.toolName === 'plan_task' &&
+                event.status === 'success' &&
+                event.toolInfo?.result) {
+                try {
+                    const plan = event.toolInfo.result;
+                    if (plan.steps && Array.isArray(plan.steps)) {
+                        const planningItems = plan.steps.map((step, index) => ({
+                            step: step.step,
+                            action: step.action,
+                            featureName: step.featureName || '',
+                            featureDescription: step.featureDescription || '',
+                            priority: step.priority || '',
+                            reasoning: step.reasoning || '',
+                            status: index === 0 ? 'in-progress' : 'pending',
+                        }));
+                        setPlanning(planningItems);
+                    }
+                }
+                catch (error) { }
+            }
+            // Handle progress_reporter - Update planning status
+            if (event.toolName === 'progress_reporter') {
+                try {
+                    const progressData = JSON.parse(event.content);
+                    const stepNumber = progressData.step;
+                    const status = progressData.status; // 'success' | 'error' | 'in_progress'
+                    // Map progress_reporter status to PlanningItem status
+                    const mappedStatus = status === 'success'
+                        ? 'completed'
+                        : status === 'error'
+                            ? 'failed'
+                            : 'in-progress';
+                    // Update planning state
+                    setPlanning(prev => {
+                        return prev.map(item => {
+                            // Update current step status
+                            if (item.step === stepNumber) {
+                                return {
+                                    ...item,
+                                    status: mappedStatus,
+                                };
+                            }
+                            // If current step succeeded, mark next step as in-progress
+                            if (status === 'success' &&
+                                item.step === stepNumber + 1 &&
+                                item.status === 'pending') {
+                                return {
+                                    ...item,
+                                    status: 'in-progress',
+                                };
+                            }
+                            return item;
+                        });
+                    });
+                }
+                catch (error) { }
+            }
+            // Add tool execution message to conversation
+            const message = {
+                id: `tool-${Date.now()}-${Math.random()}`,
+                author: 'tool',
+                toolName: event.toolName,
+                content: event.content,
+                toolInfo: event.toolInfo,
+                timestamp: event.timestamp,
+            };
+            setMessages(prev => [...prev, message]);
+        });
+        // Cleanup subscription on unmount
+        return () => {
+            unsubscribe();
+        };
+    }, []);
+    const handleCommand = (raw) => {
+        const [cmd, ...args] = raw.slice(1).split(/\s+/);
+        switch (cmd) {
+            case 'exit':
+                appendMessage('system', 'Goodbye!');
+                exit();
+                return;
+            case 'help':
+                appendMessage('system', [
+                    'Danh sách lệnh:',
+                    ...commandCatalog.map(cmd => `${cmd.command.padEnd(15, ' ')} ${cmd.description}`),
+                ].join('\n'));
+                return;
+            case 'clear':
+                setMessages([{ id: 'banner' }]);
+                setPlanning([]);
+                // Clear agent conversation history
+                if (agentConnection) {
+                    if ('clearHistory' in agentConnection) {
+                        agentConnection.clearHistory();
+                    }
+                }
+                appendMessage('system', '✅ Cleared conversation and progress');
+                return;
+            case 'history':
+                if (inputHistory.length === 0) {
+                    appendMessage('system', 'No history yet.');
+                    return;
+                }
+                {
+                    const recent = [...inputHistory].slice(-10).reverse();
+                    const lines = recent.map((item, idx) => `${idx + 1}. ${item.replace(/\n/g, ' ')}`);
+                    appendMessage('system', ['Recent inputs:', ...lines].join('\n'));
+                }
+                return;
+            case 'pwd':
+                appendMessage('system', `Working directory: ${process.cwd()}`);
+                return;
+            case 'information':
+                {
+                    const agentStr = currentConfig.model;
+                    appendMessage('system', [
+                        '📊 System Information:',
+                        `Name: Galaxy CLI`,
+                        `Version: ${cliVersion}`,
+                        `Current Project: ${process.cwd()}`,
+                        `Agent Mode: ${agentStr}`,
+                        `Git Operations: ${currentConfig.git ? 'ON' : 'OFF'}`,
+                        `Testing: ${currentConfig.test ? 'ON' : 'OFF'}`,
+                    ].join('\n'));
+                }
+                return;
+            case 'mode':
+                {
+                    // No arguments - show current mode
+                    if (args.length === 0) {
+                        const agentStr = currentConfig.model;
+                        if (currentConfig.model === 'manual') {
+                            appendMessage('system', `🤖 Agent Mode: ${agentStr}\n\nUsing Orchestrator Agent with full tool access.`);
+                        }
+                        else {
+                            appendMessage('system', `🤖 Agent Mode: ${agentStr}\n\nDirect chat mode - no tools available.`);
+                        }
+                        return;
+                    }
+                    // Has arguments - switch agent mode
+                    const newMode = args[0]?.toLowerCase() ?? '';
+                    const validModes = ['claude', 'gemini', 'ollama', 'manual'];
+                    // Type guard function
+                    const isValidMode = (mode) => {
+                        return validModes.includes(mode);
+                    };
+                    if (!isValidMode(newMode)) {
+                        appendMessage('system', `❌ Invalid mode: ${newMode}\nValid modes: ${validModes.join(', ')}`);
+                        return;
+                    }
+                    // Check if agent config exists (newMode is now ValidMode type)
+                    const agentConfig = currentConfig.agent.find(value => value.type === newMode);
+                    if (!agentConfig) {
+                        appendMessage('system', `❌ Agent config for "${newMode}" not found in config file.\nPlease add it using /config command.`);
+                        return;
+                    }
+                    // Switch to new mode
+                    setCurrentConfig(prev => ({ ...prev, model: newMode }));
+                    // Clear conversation when switching agents
+                    setMessages([{ id: 'banner' }]);
+                    setPlanning([]);
+                    appendMessage('system', `✅ Switched to ${newMode} mode\n🔄 Conversation cleared`);
+                }
+                return;
+            case 'git':
+                if (args.length === 0) {
+                    appendMessage('system', `Git operations are currently ${currentConfig.git ? 'ON' : 'OFF'}`);
+                    return;
+                }
+                {
+                    const value = args[0]?.toLowerCase() ?? '';
+                    if (value === 'true' || value === 'on') {
+                        setCurrentConfig(prev => ({ ...prev, git: true }));
+                        appendMessage('system', '✅ Git operations enabled');
+                    }
+                    else if (value === 'false' || value === 'off') {
+                        setCurrentConfig(prev => ({ ...prev, git: false }));
+                        appendMessage('system', '❌ Git operations disabled');
+                    }
+                    else {
+                        appendMessage('system', 'Usage: /git true|false');
+                    }
+                }
+                return;
+            case 'test':
+                if (args.length === 0) {
+                    appendMessage('system', `Testing is currently ${currentConfig.test ? 'ON' : 'OFF'}`);
+                    return;
+                }
+                {
+                    const value = args[0]?.toLowerCase() ?? '';
+                    if (value === 'true' || value === 'on') {
+                        setCurrentConfig(prev => ({ ...prev, test: true }));
+                        appendMessage('system', '✅ Test planning enabled');
+                    }
+                    else if (value === 'false' || value === 'off') {
+                        setCurrentConfig(prev => ({ ...prev, test: false }));
+                        appendMessage('system', '❌ Test planning disabled');
+                    }
+                    else {
+                        appendMessage('system', 'Usage: /test true|false');
+                    }
+                }
+                return;
+            case 'config':
+                {
+                    const configPath = configManager.getConfigFilePath();
+                    configManager.openConfigFolder();
+                    appendMessage('system', `📂 Config directory opened\n📄 Config file: ${configPath}`);
+                }
+                return;
+            default:
+                appendMessage('system', `Unknown command: /${cmd}${args.length ? ' ' + args.join(' ') : ''}`);
+        }
+    };
+    const handleSubmit = async (value) => {
+        if (isProcessing)
+            return;
+        const trimmed = value.trim();
+        if (!trimmed)
+            return;
+        if (trimmed.startsWith('/')) {
+            setInput('');
+            handleCommand(trimmed);
+            return;
+        }
+        appendMessage('user', trimmed);
+        setIsProcessing(true);
+        setInput('');
+        setInputHistory(prev => [...prev, trimmed]);
+        setHistoryIndex(-1);
+        try {
+            let responseContent = '';
+            // Route based on agent type
+            // if (currentConfig.model === 'manual') {
+            // 	// Use orchestrator with tools
+            // 	const response = await orchestratorAgent.handleUserInput(
+            // 		trimmed,
+            // 		{
+            // 			gitEnabled: currentConfig.git,
+            // 			testEnabled: currentConfig.test,
+            // 		},
+            // 		appendMessage,
+            // 	);
+            // 	responseContent = response.content;
+            // } else {
+            // Direct chat with specific agent (no tools)
+            if (!agentConnection) {
+                throw new Error('Agent connection not initialized');
+            }
+            const response = await agentConnection.handleUserInput(trimmed, {
+                gitEnabled: currentConfig.git,
+                testEnabled: currentConfig.test,
+            }, appendMessage);
+            responseContent = response.content;
+            // }
+            if (responseContent) {
+                // Only parse step completion in manual mode
+                // if (currentConfig.model === 'manual') {
+                // 	parseStepCompletion(responseContent);
+                // }
+                appendMessage('assistant', responseContent);
+            }
+        }
+        catch (error) {
+            appendMessage('system', `❌ Error: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            setIsProcessing(false);
+        }
+    };
+    // const parseStepCompletion = (content: string) => {
+    // 	const jsonMatch = content.match(
+    // 		/\{step:\s*(\d+),\s*status:\s*['"]completed['"]\}/,
+    // 	);
+    // 	if (jsonMatch) {
+    // 		const stepNum = parseInt(jsonMatch[1] || '0', 10);
+    // 		updateStepStatus(stepNum, 'completed');
+    // 		return;
+    // 	}
+    // 	const checkboxMatch = content.match(/☒\s*Step\s+(\d+):/);
+    // 	if (checkboxMatch) {
+    // 		const stepNum = parseInt(checkboxMatch[1] || '0', 10);
+    // 		updateStepStatus(stepNum, 'completed');
+    // 		return;
+    // 	}
+    // 	const completedMatch = content.match(/Step\s+(\d+):.*?[✅✓]\s*Completed/i);
+    // 	if (completedMatch) {
+    // 		const stepNum = parseInt(completedMatch[1] || '0', 10);
+    // 		updateStepStatus(stepNum, 'completed');
+    // 	}
+    // };
+    // const updateStepStatus = (stepNum: number, status: 'completed') => {
+    // 	setPlanning(prev => {
+    // 		const updated: PlanningItem[] = prev.map(item => {
+    // 			if (item.step === stepNum) {
+    // 				return {...item, status: 'completed' as const};
+    // 			}
+    // 			if (item.step === stepNum + 1 && item.status === 'pending') {
+    // 				return {...item, status: 'in-progress' as const};
+    // 			}
+    // 			return item;
+    // 		});
+    // 		// Update progress tracker
+    // 		return updated;
+    // 	});
+    // };
+    useInput((inputKey, key) => {
+        if (key.ctrl && inputKey === 'c') {
+            exit();
+        }
+        if (commandSuggestions.length > 0 && input.startsWith('/')) {
+            if (key.upArrow || (key.shift && key.tab)) {
+                setSuggestionIndex(prev => (prev - 1 + commandSuggestions.length) % commandSuggestions.length);
+            }
+            else if (key.downArrow || key.tab) {
+                setSuggestionIndex(prev => (prev + 1) % commandSuggestions.length);
+            }
+            else if (key.escape || key.return) {
+                setCommandSuggestions([]);
+                setSuggestionIndex(0);
+            }
+            return;
+        }
+        if (inputHistory.length > 0 && !input.startsWith('/')) {
+            if (key.upArrow) {
+                const newIndex = historyIndex === -1
+                    ? inputHistory.length - 1
+                    : Math.max(0, historyIndex - 1);
+                setHistoryIndex(newIndex);
+                setInput(inputHistory[newIndex] || '');
+            }
+            else if (key.downArrow) {
+                if (historyIndex === -1)
+                    return;
+                const newIndex = historyIndex + 1;
+                if (newIndex >= inputHistory.length) {
+                    setHistoryIndex(-1);
+                    setInput('');
+                }
+                else {
+                    setHistoryIndex(newIndex);
+                    setInput(inputHistory[newIndex] || '');
+                }
+            }
+        }
+    });
+    const appendMessage = (author, text, toolName, toolInfo) => {
+        const message = {
+            id: `${Date.now()}-${author}-${Math.random().toString(16).slice(2)}`,
+            author,
+            content: text,
+            toolName,
+            toolInfo,
+            timestamp: Date.now(),
+        };
+        if (author === 'tool' && toolName === 'plan_task') {
+            const planningItems = text.map((item, index) => ({
+                ...item,
+                status: (index === 0
+                    ? 'in-progress'
+                    : 'pending'),
+            }));
+            setPlanning(planningItems);
+            // Initialize progress tracker (only in manual mode)
+            if (currentConfig.model === 'manual') {
+            }
+        }
+        else {
+            setMessages(prev => [...prev, message]);
+        }
+    };
+    const currentStep = planning.find(p => p.status === 'in-progress');
+    return (React.createElement(React.Fragment, null,
+        React.createElement(Static, { items: messages }, msg => {
+            if (msg.author === 'user') {
+                return (React.createElement(Box, { key: msg.id, flexDirection: "row", marginTop: 1 },
+                    React.createElement(Text, { color: "red" }, `> ${msg.content}`)));
+            }
+            if (msg.author === 'assistant') {
+                return (React.createElement(Box, { key: msg.id, flexDirection: "column", marginTop: 1, borderStyle: "round", borderColor: "blue", paddingX: 1, paddingY: 0 },
+                    React.createElement(Text, null, msg.content)));
+            }
+            if (msg.author === 'tool') {
+                return (React.createElement(Box, { key: msg.id, flexDirection: "row", marginTop: 1 }, formatMessage(msg.content || '', msg.toolName, msg.toolInfo)));
+            }
+            if (msg.author === 'system') {
+                return (React.createElement(Box, { key: msg.id, flexDirection: "row", marginTop: 1 },
+                    React.createElement(Text, { color: "gray" }, `⚙ ${msg.content}`)));
+            }
+            return (React.createElement(Box, { borderColor: "cyan", borderStyle: "round", flexDirection: "row", key: 'banner-box', width: process.stdout.columns },
+                React.createElement(Box, { flexDirection: "column" },
+                    React.createElement(Text, { color: "cyan" }, bannerText)),
+                React.createElement(Box, { borderLeft: true, borderLeftColor: "cyan", flexDirection: "column", marginLeft: 2, marginTop: 1 }, infoLines.map(line => (React.createElement(Text, { key: line.id, dimColor: true }, line.text))))));
+        }),
+        currentConfig.model === 'manual' && planning.length > 0 && (React.createElement(Box, { flexDirection: "column", paddingTop: 1, paddingBottom: 1 },
+            currentStep && (React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { bold: true, color: "cyan" },
+                    "\u26A1 ",
+                    currentStep.action))),
+            planning.map(item => {
+                const checkbox = item.status === 'completed'
+                    ? '☑'
+                    : item.status === 'in-progress'
+                        ? '⚙'
+                        : item.status === 'failed'
+                            ? '❌'
+                            : '☐';
+                const color = item.status === 'completed'
+                    ? 'green'
+                    : item.status === 'in-progress'
+                        ? 'cyan'
+                        : item.status === 'failed'
+                            ? 'red'
+                            : 'gray';
+                return (React.createElement(Box, { key: item.step },
+                    React.createElement(Text, { color: color },
+                        checkbox,
+                        " Step ",
+                        item.step,
+                        ": ",
+                        item.action)));
+            }))),
+        React.createElement(Box, { flexDirection: "row", paddingTop: 1, width: process.stdout.columns }, isProcessing ? (React.createElement(Text, null,
+            React.createElement(Text, { color: "cyan" },
+                React.createElement(Spinner, { type: "dots" })),
+            ' Thinking...')) : null),
+        React.createElement(Box, { borderColor: "green", borderStyle: "round", flexDirection: "column", marginTop: 1 },
+            React.createElement(Box, { alignItems: "center", flexDirection: "row" },
+                React.createElement(Text, { color: "green" }, "> "),
+                React.createElement(TextInput, { value: input, showCursor: !isProcessing, onChange: isProcessing
+                        ? () => { }
+                        : value => {
+                            setInput(value);
+                            if (value.startsWith('/')) {
+                                const partial = value.toLowerCase();
+                                const matches = commandCatalog.filter(cmd => cmd.command.toLowerCase().startsWith(partial));
+                                setCommandSuggestions(matches);
+                                setSuggestionIndex(0);
+                            }
+                            else {
+                                setCommandSuggestions([]);
+                                setSuggestionIndex(0);
+                            }
+                        }, onSubmit: isProcessing
+                        ? () => { }
+                        : rawValue => {
+                            const trimmed = rawValue.trim();
+                            if (trimmed.startsWith('/') &&
+                                commandSuggestions.length > 0) {
+                                const selected = commandSuggestions[suggestionIndex] ??
+                                    commandSuggestions[0];
+                                handleSubmit(selected?.command || '');
+                                return;
+                            }
+                            handleSubmit(rawValue);
+                        }, placeholder: isProcessing
+                        ? 'Processing... (input disabled)'
+                        : 'Type and press Enter to send' }))),
+        commandSuggestions.length > 0 && (React.createElement(Box, { flexDirection: "column", marginTop: 1, borderStyle: "round", borderColor: "gray" }, commandSuggestions.map((cmd, idx) => (React.createElement(Box, { key: cmd.command, paddingX: 1, paddingY: 0, flexDirection: "row" },
+            React.createElement(Text, { color: idx === suggestionIndex ? 'cyan' : undefined }, cmd.command.padEnd(15, ' ')),
+            React.createElement(Text, { dimColor: true }, cmd.description))))))));
+}

package/dist/auto-updater.d.ts

@@ -0,0 +1,21 @@
+export interface UpdateResult {
+    success: boolean;
+    error?: string;
+    needsRestart?: boolean;
+}
+/**
+ * Thực hiện update bằng npm install
+ */
+export declare function performUpdate(version: string): Promise<UpdateResult>;
+/**
+ * Restart CLI với arguments hiện tại
+ */
+export declare function restartCLI(): void;
+/**
+ * Hiển thị thông báo update thành công
+ */
+export declare function showUpdateSuccess(version: string): void;
+/**
+ * Hiển thị thông báo update failed
+ */
+export declare function showUpdateError(error: string): void;