galaxy-code 0.1.2 → 0.1.5

package/dist/app.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import type { MergedConfig } from '@workspace/agent-core';
+import { MergedConfig } from './utils/config-manager.js';
 interface AppProps {
     config: MergedConfig;
 }

package/dist/app.js

@@ -11,11 +11,11 @@ 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 { configManager } from '@workspace/agent-core';
-import { formatMessage } from '@workspace/agent-core/utils/message-formatters';
-import { toolEventEmitter } from '@workspace/agent-core/tools';
-const cliVersion = '0.1.2';
+import { ClaudeAgent, GeminiAgent, OllamaAgent } from './providers/index.js';
+import { configManager } from './utils/config-manager.js';
+import { formatMessage } from './utils/message-formatters.js';
+import { toolEventEmitter } from './tools/index.js';
+const cliVersion = '0.1.4';
 const getTerminalWidth = () => {
     const width = process.stdout?.columns;
     return typeof width === 'number' && Number.isFinite(width) ? width : 80;

package/dist/cli.js

@@ -11,9 +11,9 @@ import { render } from 'ink';
 import meow from 'meow';
 import './env.js';
 import App from './app.js';
-import { configManager } from '@workspace/agent-core';
 import { checkForUpdate, shouldSkipVersion } from './update-checker.js';
 import { performUpdate, restartCLI, showUpdateSuccess, showUpdateError, } from './auto-updater.js';
+import { configManager } from './utils/config-manager.js';
 const cli = meow(`
 	Cách sử dụng
 	  $ galaxy [tùy chọn]
@@ -77,9 +77,9 @@ async function handleAutoUpdate() {
     const config = configManager.getConfig();
     const autoUpdateConfig = config.autoUpdate;
     // Check if auto-update is disabled
-    if (!autoUpdateConfig.enabled
-        || !autoUpdateConfig.checkOnStartup
-        || cli.flags.noAutoUpdate) {
+    if (!autoUpdateConfig.enabled ||
+        !autoUpdateConfig.checkOnStartup ||
+        cli.flags.noAutoUpdate) {
         return false; // Skip update
     }
     try {

package/dist/connections/claude.d.ts

@@ -0,0 +1,71 @@
+/**
+ * @author Bùi Trọng Hiếu
+ * @email kevinbui210191@gmail.com
+ * @create 2024-10-13
+ * @modify 2024-10-13
+ * @desc Claude API connection using Anthropic SDK
+ */
+import Anthropic from '@anthropic-ai/sdk';
+import type { AgentConfig } from '../utils/config-manager.js';
+import type { MessageCallback } from './types.js';
+export type ClaudeModelId = 'claude-3-5-sonnet-20241022' | 'claude-3-5-haiku-20241022' | 'claude-3-opus-20240229' | 'claude-sonnet-4-20250514' | 'claude-sonnet-4.5-20250929';
+export interface ClaudeMessage {
+    role: 'user' | 'assistant';
+    content: string;
+}
+export interface ClaudeStreamChunk {
+    type: 'content_block_delta' | 'message_delta' | 'message_stop';
+    delta?: {
+        text?: string;
+        type?: string;
+    };
+}
+export declare class ClaudeConnection {
+    private client;
+    private model;
+    private conversationHistory;
+    private conversationHistoryWithTools;
+    private systemPrompt?;
+    private toolsRegistry;
+    constructor(config?: AgentConfig, systemPrompt?: string);
+    /**
+     * Send a message and get response
+     */
+    chat(userMessage: string): Promise<string>;
+    /**
+     * Stream response (for future implementation)
+     */
+    chatStream(userMessage: string): AsyncGenerator<string, void, unknown>;
+    /**
+     * Generate single response without conversation history
+     */
+    generate(prompt: string, systemPrompt?: string): Promise<string>;
+    /**
+     * Clear conversation history
+     */
+    clearHistory(): void;
+    /**
+     * Get conversation history
+     */
+    getHistory(): ClaudeMessage[];
+    /**
+     * Set system prompt
+     */
+    setSystemPrompt(prompt: string): void;
+    /**
+     * Get current model
+     */
+    getModel(): ClaudeModelId;
+    /**
+     * Change model
+     */
+    setModel(model: ClaudeModelId): void;
+    /**
+     * Chat with tools support - handles full tool loop
+     */
+    chatWithTools(userMessage: string, tools: Anthropic.Tool[], onMessage?: MessageCallback): Promise<string>;
+    /**
+     * Clear tool conversation history
+     */
+    clearToolHistory(): void;
+}

package/dist/connections/claude.js

@@ -0,0 +1,303 @@
+/**
+ * @author Bùi Trọng Hiếu
+ * @email kevinbui210191@gmail.com
+ * @create 2024-10-13
+ * @modify 2024-10-13
+ * @desc Claude API connection using Anthropic SDK
+ */
+import Anthropic from '@anthropic-ai/sdk';
+import { ToolRegistry } from '../tools/index.js';
+export class ClaudeConnection {
+    constructor(config, systemPrompt) {
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "conversationHistory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "conversationHistoryWithTools", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "systemPrompt", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "toolsRegistry", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new ToolRegistry()
+        });
+        // Only get apiKey from config - no fallback to env
+        const apiKey = config?.apiKey;
+        // if (!apiKey) {
+        // 	throw new Error(
+        // 		'Hiện tại bạn chưa thêm apikey cho model claude. Vui lòng thêm để dùng phần mềm'
+        // 	);
+        // }
+        this.client = new Anthropic({
+            apiKey,
+        });
+        this.model =
+            config?.model || 'claude-sonnet-4.5-20250929';
+        this.systemPrompt = systemPrompt;
+    }
+    /**
+     * Send a message and get response
+     */
+    async chat(userMessage) {
+        // Add user message to history
+        this.conversationHistory.push({
+            role: 'user',
+            content: userMessage,
+        });
+        try {
+            const response = await this.client.messages.create({
+                model: this.model,
+                max_tokens: 8192,
+                system: this.systemPrompt,
+                messages: this.conversationHistory,
+            });
+            // Extract assistant response
+            const assistantMessage = response.content[0]?.type === 'text' ? response.content[0].text : '';
+            // Add to history
+            this.conversationHistory.push({
+                role: 'assistant',
+                content: assistantMessage,
+            });
+            return assistantMessage;
+        }
+        catch (error) {
+            console.error('Claude API Error:', error);
+            throw error;
+        }
+    }
+    /**
+     * Stream response (for future implementation)
+     */
+    async *chatStream(userMessage) {
+        this.conversationHistory.push({
+            role: 'user',
+            content: userMessage,
+        });
+        try {
+            const stream = await this.client.messages.create({
+                model: this.model,
+                max_tokens: 8192,
+                system: this.systemPrompt,
+                messages: this.conversationHistory,
+                stream: true,
+            });
+            let fullResponse = '';
+            for await (const chunk of stream) {
+                if (chunk.type === 'content_block_delta' &&
+                    chunk.delta.type === 'text_delta') {
+                    const text = chunk.delta.text || '';
+                    fullResponse += text;
+                    yield text;
+                }
+            }
+            // Add complete response to history
+            this.conversationHistory.push({
+                role: 'assistant',
+                content: fullResponse,
+            });
+        }
+        catch (error) {
+            console.error('Claude Stream Error:', error);
+            throw error;
+        }
+    }
+    /**
+     * Generate single response without conversation history
+     */
+    async generate(prompt, systemPrompt) {
+        try {
+            const response = await this.client.messages.create({
+                model: this.model,
+                max_tokens: 8192,
+                system: systemPrompt || this.systemPrompt,
+                messages: [
+                    {
+                        role: 'user',
+                        content: prompt,
+                    },
+                ],
+            });
+            return response.content[0]?.type === 'text'
+                ? response.content[0].text
+                : '';
+        }
+        catch (error) {
+            console.error('Claude Generate Error:', error);
+            throw error;
+        }
+    }
+    /**
+     * Clear conversation history
+     */
+    clearHistory() {
+        this.conversationHistory = [];
+    }
+    /**
+     * Get conversation history
+     */
+    getHistory() {
+        return [...this.conversationHistory];
+    }
+    /**
+     * Set system prompt
+     */
+    setSystemPrompt(prompt) {
+        this.systemPrompt = prompt;
+    }
+    /**
+     * Get current model
+     */
+    getModel() {
+        return this.model;
+    }
+    /**
+     * Change model
+     */
+    setModel(model) {
+        this.model = model;
+    }
+    /**
+     * Chat with tools support - handles full tool loop
+     */
+    async chatWithTools(userMessage, tools, onMessage) {
+        // Add user message to history
+        this.conversationHistoryWithTools.push({
+            role: 'user',
+            content: userMessage,
+        });
+        let iteration = 0;
+        const MAX_ITERATIONS = 100; // Safety limit
+        while (iteration < MAX_ITERATIONS) {
+            iteration++;
+            // Call Claude API
+            const response = await this.client.messages.create({
+                model: this.model,
+                max_tokens: 8192,
+                system: this.systemPrompt,
+                messages: this.conversationHistoryWithTools,
+                tools: tools,
+            });
+            // Check stop reason
+            if (response.stop_reason !== 'tool_use') {
+                // No more tools to execute - add final response to history
+                this.conversationHistoryWithTools.push({
+                    role: 'assistant',
+                    content: response.content,
+                });
+                // Extract text from response
+                const textBlock = response.content.find((block) => block.type === 'text');
+                return textBlock?.text || '';
+            }
+            // Add assistant response with tool_use to history
+            this.conversationHistoryWithTools.push({
+                role: 'assistant',
+                content: response.content,
+            });
+            // Execute tools and collect results
+            const toolResults = [];
+            for (const block of response.content) {
+                if (block.type === 'tool_use') {
+                    const toolUseBlock = block;
+                    const toolName = toolUseBlock.name;
+                    const toolInput = toolUseBlock.input;
+                    // Special handling for plan_task and progress_reporter
+                    if (toolName === 'plan_task' || toolName === 'progress_reporter') {
+                        try {
+                            const result = await this.toolsRegistry.executeTool(toolName, toolInput);
+                            const resultStr = typeof result === 'string' ? result : JSON.stringify(result);
+                            toolResults.push({
+                                type: 'tool_result',
+                                tool_use_id: toolUseBlock.id,
+                                content: resultStr,
+                            });
+                        }
+                        catch (error) {
+                            const errorMsg = error instanceof Error ? error.message : String(error);
+                            toolResults.push({
+                                type: 'tool_result',
+                                tool_use_id: toolUseBlock.id,
+                                content: `Error: ${errorMsg}`,
+                                is_error: true,
+                            });
+                        }
+                    }
+                    else {
+                        // Regular tool handling with notification
+                        try {
+                            const result = await this.toolsRegistry.executeTool(toolName, toolInput);
+                            const resultStr = typeof result === 'string' ? result : JSON.stringify(result);
+                            // Notify tool execution
+                            if (onMessage) {
+                                const success = !resultStr.startsWith('❌');
+                                onMessage('tool', resultStr, toolName, {
+                                    success,
+                                    output: resultStr,
+                                });
+                            }
+                            toolResults.push({
+                                type: 'tool_result',
+                                tool_use_id: toolUseBlock.id,
+                                content: resultStr,
+                            });
+                        }
+                        catch (error) {
+                            const errorMsg = error instanceof Error ? error.message : String(error);
+                            // Notify error
+                            if (onMessage) {
+                                onMessage('tool', `❌ Error: ${errorMsg}`, toolName, {
+                                    success: false,
+                                    error: errorMsg,
+                                });
+                            }
+                            toolResults.push({
+                                type: 'tool_result',
+                                tool_use_id: toolUseBlock.id,
+                                content: `Error: ${errorMsg}`,
+                                is_error: true,
+                            });
+                        }
+                    }
+                }
+            }
+            // Add tool results to history
+            this.conversationHistoryWithTools.push({
+                role: 'user',
+                content: toolResults,
+            });
+            // Loop continues to call API again with tool results
+        }
+        // Safety limit reached
+        console.warn(`⚠️ Safety limit (${MAX_ITERATIONS}) reached in Claude tool loop.`);
+        return 'Maximum iteration limit reached. Please try again.';
+    }
+    /**
+     * Clear tool conversation history
+     */
+    clearToolHistory() {
+        this.conversationHistoryWithTools = [];
+    }
+}

package/dist/connections/gemini.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @author Bùi Trọng Hiếu
+ * @email kevinbui210191@gmail.com
+ * @create 2024-10-08
+ * @modify 2024-10-13
+ * @desc Gemini connection helper using @google/genai with improved function call handling.
+ */
+import { FunctionDeclaration, type GenerateContentConfig } from '@google/genai';
+import type { AgentConfig } from '../utils/config-manager.js';
+import type { ToolExecutionInfo } from './types.js';
+export type GeminiGenerateParameters = {
+    readonly prompt: string;
+    readonly config?: GenerateContentConfig;
+};
+export type GeminiChatParameters = {
+    readonly prompt: string;
+    readonly tools?: FunctionDeclaration[];
+    readonly message: string;
+};
+export type GeminiGenerateResult<T = unknown> = {
+    readonly text: string;
+    readonly raw: T;
+};
+export declare class GeminiConnection {
+    private client;
+    private readonly apiKey;
+    private chatSession;
+    private readonly systemInstruction?;
+    private readonly model;
+    private toolsRegistry;
+    constructor(config?: AgentConfig, systemPrompt?: string);
+    initChat(): void;
+    generate(parameters: GeminiGenerateParameters): Promise<GeminiGenerateResult>;
+    chat(message: string, onMessage?: (author: 'tool' | 'assistant', content: string, toolName?: string, toolInfo?: ToolExecutionInfo) => void): Promise<string>;
+    private getToolDeclarations;
+    private convertToFunctionDeclaration;
+    private convertSchemaToGeminiSchema;
+    private convertPropertyToGeminiSchema;
+    private mapTypeToGemini;
+}