galaxy-code 0.1.2 → 0.1.5

package/dist/tools/planning-agent.js

@@ -0,0 +1,134 @@
+/**
+ * Planning Agent - Creates step-by-step execution plans
+ * Uses gemini-2.5-flash for intelligent planning
+ */
+import { GeminiConnection } from '../connections/gemini.js';
+import { planningSystemPrompt } from '../prompts/planning-agent.js';
+export class PlanningAgent {
+    constructor() {
+        Object.defineProperty(this, "gemini", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'gemini-2.5-flash'
+        });
+        // Lazy initialization - only create connection when needed
+    }
+    getConnection(systemPrompt) {
+        if (!this.gemini) {
+            // Special case: PlanningAgent gets apiKey directly from process.env
+            const apiKey = process.env['GOOGLE_AI_API_KEY'] || process.env['GEMINI_API_KEY'];
+            if (!apiKey) {
+                throw new Error('PlanningAgent requires GOOGLE_AI_API_KEY or GEMINI_API_KEY in environment variables');
+            }
+            this.gemini = new GeminiConnection({
+                type: 'gemini',
+                model: this.model,
+                apiKey: apiKey,
+            }, systemPrompt);
+        }
+        return this.gemini;
+    }
+    async generatePlan(userContext, baAnalysis) {
+        try {
+            let userMessage = `User Context: ${userContext}`;
+            if (baAnalysis) {
+                const baResponse = baAnalysis.ba_it_analyze_response.result;
+                userMessage += `\n\nBA Analysis:\n${JSON.stringify({
+                    type: baResponse.type,
+                    projectName: baResponse.projectName,
+                    coreFeatures: baResponse.coreFeatures.map(f => f.name),
+                    technicalStack: baResponse.technicalStack,
+                }, null, 2)}`;
+            }
+            const systemPrompt = planningSystemPrompt();
+            const response = await this.getConnection(systemPrompt).generate({
+                prompt: userMessage,
+            });
+            // Extract and parse JSON from response
+            const jsonStr = this.extractJSON(response.text);
+            if (!jsonStr) {
+                // Fallback plan if parsing fails
+                return this.createFallbackPlan(userContext);
+            }
+            const plan = JSON.parse(jsonStr);
+            return plan;
+        }
+        catch (error) {
+            // Fallback plan on error
+            return this.createFallbackPlan(userContext);
+        }
+    }
+    extractJSON(content) {
+        // Remove markdown code blocks
+        let cleanContent = content.trim();
+        cleanContent = cleanContent.replace(/```json\s*/g, '');
+        cleanContent = cleanContent.replace(/```\s*/g, '');
+        // Find JSON object with balanced braces
+        const startIdx = cleanContent.indexOf('{');
+        if (startIdx === -1)
+            return null;
+        let braceCount = 0;
+        let inString = false;
+        let escapeNext = false;
+        for (let i = startIdx; i < cleanContent.length; i++) {
+            const char = cleanContent[i];
+            if (escapeNext) {
+                escapeNext = false;
+                continue;
+            }
+            if (char === '\\') {
+                escapeNext = true;
+                continue;
+            }
+            if (char === '"' && !escapeNext) {
+                inString = !inString;
+                continue;
+            }
+            if (!inString) {
+                if (char === '{') {
+                    braceCount++;
+                }
+                else if (char === '}') {
+                    braceCount--;
+                    if (braceCount === 0) {
+                        return cleanContent.substring(startIdx, i + 1);
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    createFallbackPlan(userContext) {
+        return {
+            summary: 'Basic implementation plan',
+            steps: [
+                {
+                    step: 1,
+                    action: 'Check project structure',
+                    tool: 'file_tree',
+                    reasoning: 'Understand existing codebase',
+                },
+                {
+                    step: 2,
+                    action: `Implement: ${userContext}`,
+                    tool: 'file_write',
+                    reasoning: 'Create necessary files',
+                },
+                {
+                    step: 3,
+                    action: 'Test implementation',
+                    tool: 'test_run',
+                    reasoning: 'Verify functionality',
+                },
+            ],
+            estimatedTime: 'medium',
+        };
+    }
+}

package/dist/tools/progress-reporter.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Progress Reporter Tool
+ * Allows code-generate-agent to report task completion status
+ * Emits events via EventEmitter for UI tracking
+ */
+export interface ProgressReport {
+    step: number;
+    status: 'success' | 'error' | 'in_progress';
+    message?: string;
+    filesCreated?: string[];
+    commandsRun?: string[];
+}
+export declare class ProgressReporter {
+    private reports;
+    reportProgress(report: ProgressReport): string;
+    getReports(): ProgressReport[];
+    getAllSuccessful(): boolean;
+    clear(): void;
+}

package/dist/tools/progress-reporter.js

@@ -0,0 +1,52 @@
+/**
+ * Progress Reporter Tool
+ * Allows code-generate-agent to report task completion status
+ * Emits events via EventEmitter for UI tracking
+ */
+import { toolEventEmitter } from './tool-event-emitter.js';
+export class ProgressReporter {
+    constructor() {
+        Object.defineProperty(this, "reports", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+    }
+    reportProgress(report) {
+        this.reports.push(report);
+        const statusEmoji = report.status === 'success' ? '✅' : report.status === 'error' ? '❌' : '⏳';
+        let message = `${statusEmoji} Step ${report.step}: ${report.status.toUpperCase()}`;
+        if (report.message) {
+            message += `\n   ${report.message}`;
+        }
+        if (report.filesCreated && report.filesCreated.length > 0) {
+            message += `\n   📝 Files created: ${report.filesCreated.join(', ')}`;
+        }
+        if (report.commandsRun && report.commandsRun.length > 0) {
+            message += `\n   🔧 Commands run: ${report.commandsRun.join(', ')}`;
+        }
+        // Emit event via EventEmitter
+        toolEventEmitter.emitToolExecution({
+            toolName: 'progress_reporter',
+            content: JSON.stringify({
+                step: report.step,
+                status: report.status,
+                message: report.message,
+                filesCreated: report.filesCreated,
+                commandsRun: report.commandsRun,
+            }),
+            status: report.status === 'success' ? 'success' : report.status === 'error' ? 'error' : 'success', // in_progress treated as success for event
+        });
+        return message;
+    }
+    getReports() {
+        return this.reports;
+    }
+    getAllSuccessful() {
+        return this.reports.every(r => r.status === 'success');
+    }
+    clear() {
+        this.reports = [];
+    }
+}

package/dist/tools/registry.d.ts

@@ -0,0 +1,21 @@
+import type { Tool } from './types.js';
+export declare class ToolRegistry {
+    private readonly tools;
+    private fileOps;
+    private gitOps;
+    private commandRunner;
+    private baAnalyzer;
+    private documentParser;
+    private planningAgent;
+    private codeGenerateAgent;
+    private progressReporter;
+    constructor();
+    private registerAllTools;
+    register<InputValue, OutputValue>(tool: Tool<InputValue, OutputValue>): void;
+    get(name: string): Tool<unknown, unknown> | undefined;
+    list(): Array<Tool<unknown, unknown>>;
+    getToolsContext(args: string[]): string;
+    getToolsByNames(names?: string[]): any[];
+    executeTool(name: string, args: any): Promise<any>;
+}
+export declare const globalToolRegistry: ToolRegistry;