galaxy-code 0.1.6 → 0.1.8

package/dist/tools/galaxy-ui-integration.js

@@ -1,244 +0,0 @@
-import { execa } from 'execa';
-/**
- * Galaxy UI CLI Integration
- * Provides tools to discover, search, and install Galaxy UI components
- *
- * Data Sources:
- * - Component Registry: npm CDN (https://unpkg.com/galaxy-design@latest/dist/registry.json)
- *   Alternative CDN: https://cdn.jsdelivr.net/npm/galaxy-design@latest/dist/registry.json
- * - Documentation: https://galaxy-design.vercel.app
- * - CLI Execution: npx galaxy-design@latest
- */
-const GITHUB_REGISTRY_URL = 'https://unpkg.com/galaxy-design@latest/dist/registry.json';
-const DOCS_BASE_URL = 'https://galaxy-design.vercel.app';
-// Cache for registry data (5 minutes)
-let registryCache = {
-    data: null,
-    timestamp: 0,
-};
-const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
-/**
- * Fetch component registry from GitHub (supports private repos with GITHUB_TOKEN)
- */
-async function fetchRegistry() {
-    const now = Date.now();
-    // Return cached data if still valid
-    if (registryCache.data && now - registryCache.timestamp < CACHE_TTL) {
-        return registryCache.data;
-    }
-    try {
-        // Prepare headers with authentication if GITHUB_TOKEN is available
-        const headers = {
-            'Accept': 'application/vnd.github.v3.raw',
-        };
-        const githubToken = process.env['GITHUB_TOKEN'];
-        if (githubToken) {
-            headers['Authorization'] = `Bearer ${githubToken}`;
-        }
-        const response = await fetch(GITHUB_REGISTRY_URL, { headers });
-        if (!response.ok) {
-            throw new Error(`Failed to fetch registry: ${response.statusText}`);
-        }
-        const data = (await response.json());
-        // Update cache
-        registryCache = {
-            data,
-            timestamp: now,
-        };
-        return data;
-    }
-    catch (error) {
-        throw new Error(`Failed to fetch Galaxy UI registry: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-}
-/**
- * Tool 1: List all components
- * Fetches from GitHub registry.json
- */
-export async function galaxyUIListComponents(params) {
-    const registry = await fetchRegistry();
-    const components = Object.entries(registry.components).map(([name, config]) => ({
-        name,
-        description: config.description,
-        category: config.type,
-        docsUrl: `${DOCS_BASE_URL}/components/${name}`,
-    }));
-    // Filter by category if specified
-    const filtered = params?.category && params.category !== 'all'
-        ? components.filter(c => c.category === params.category)
-        : components;
-    return {
-        total: filtered.length,
-        components: filtered,
-    };
-}
-/**
- * Tool 2: Search components by keyword
- * Searches in component name and description
- */
-export async function galaxyUISearchComponents(params) {
-    const registry = await fetchRegistry();
-    const query = params.query.toLowerCase();
-    const results = Object.entries(registry.components)
-        .map(([name, config]) => {
-        const nameMatch = name.toLowerCase().includes(query);
-        const descMatch = config.description.toLowerCase().includes(query);
-        const categoryMatch = config.type.toLowerCase().includes(query);
-        // Calculate relevance
-        let relevance = 'low';
-        if (nameMatch)
-            relevance = 'high';
-        else if (categoryMatch)
-            relevance = 'medium';
-        else if (descMatch)
-            relevance = 'low';
-        const isMatch = nameMatch || descMatch || categoryMatch;
-        return {
-            name,
-            description: config.description,
-            category: config.type,
-            docsUrl: `${DOCS_BASE_URL}/components/${name}`,
-            relevance,
-            isMatch,
-        };
-    })
-        .filter(result => result.isMatch)
-        .sort((a, b) => {
-        // Sort by relevance: high > medium > low
-        const relevanceOrder = { high: 0, medium: 1, low: 2 };
-        return relevanceOrder[a.relevance] - relevanceOrder[b.relevance];
-    });
-    return {
-        total: results.length,
-        components: results,
-    };
-}
-/**
- * Tool 3: Get component details
- * Returns component info from registry + docs URL
- */
-export async function galaxyUIGetComponent(params) {
-    const registry = await fetchRegistry();
-    const component = registry.components[params.name];
-    if (!component) {
-        throw new Error(`Component "${params.name}" not found. Use galaxy_ui_list_components or galaxy_ui_search_components to find available components.`);
-    }
-    const docsUrl = `${DOCS_BASE_URL}/components/${params.name}`;
-    const docsUrlFramework = params.framework ? `${docsUrl}?framework=${params.framework}` : undefined;
-    return {
-        name: params.name,
-        description: component.description,
-        category: component.type,
-        dependencies: component.dependencies || [],
-        peerDependencies: component.peerDependencies || [],
-        docsUrl,
-        docsUrlFramework,
-        installCommand: `npx galaxy-design add ${params.name}`,
-    };
-}
-/**
- * Tool 4: Get component categories with counts
- * Groups components by category from registry
- */
-export async function galaxyUIGetCategories() {
-    const registry = await fetchRegistry();
-    // Group components by category
-    const categoryMap = new Map();
-    for (const [name, config] of Object.entries(registry.components)) {
-        const category = config.type;
-        if (!categoryMap.has(category)) {
-            categoryMap.set(category, []);
-        }
-        categoryMap.get(category).push(name);
-    }
-    const categories = Array.from(categoryMap.entries())
-        .map(([name, components]) => ({
-        name,
-        count: components.length,
-        components: components.sort(),
-    }))
-        .sort((a, b) => b.count - a.count); // Sort by count descending
-    return { categories };
-}
-/**
- * Tool 5: Add components to project
- * Executes: npx galaxy-design add [components...] --cwd [path]
- */
-export async function galaxyUIAddComponents(params) {
-    try {
-        const args = ['galaxy-design', 'add', ...params.components];
-        if (params.cwd) {
-            args.push('--cwd', params.cwd);
-        }
-        const result = await execa('npx', args, {
-            cwd: params.cwd || process.cwd(),
-            stderr: 'pipe',
-            stdout: 'pipe',
-        });
-        return {
-            success: true,
-            message: `Successfully added components: ${params.components.join(', ')}`,
-            output: result.stdout,
-        };
-    }
-    catch (error) {
-        const execError = error;
-        return {
-            success: false,
-            message: `Failed to add components: ${params.components.join(', ')}`,
-            output: execError.stderr || execError.stdout || 'Unknown error',
-        };
-    }
-}
-/**
- * Tool 6: Initialize Galaxy UI in project
- * Executes: npx galaxy-design@latest init --yes --cwd [path]
- */
-export async function galaxyUIInit(params) {
-    try {
-        const args = ['galaxy-design@latest', 'init'];
-        if (params?.skipPrompts) {
-            args.push('--yes');
-        }
-        if (params?.cwd) {
-            args.push('--cwd', params.cwd);
-        }
-        const result = await execa('npx', args, {
-            cwd: params?.cwd || process.cwd(),
-            stderr: 'pipe',
-            stdout: 'pipe',
-        });
-        return {
-            success: true,
-            message: 'Successfully initialized Galaxy UI',
-            output: result.stdout,
-        };
-    }
-    catch (error) {
-        const execError = error;
-        return {
-            success: false,
-            message: 'Failed to initialize Galaxy UI',
-            output: execError.stderr || execError.stdout || 'Unknown error',
-        };
-    }
-}
-/**
- * Tool 7: Get documentation URL
- * Returns direct link to component docs or main docs
- */
-export function galaxyUIGetDocsUrl(params) {
-    if (params?.component) {
-        const lang = params.language === 'vi' ? '/vi' : '';
-        const url = `${DOCS_BASE_URL}${lang}/components/${params.component}`;
-        return {
-            url,
-            description: `Documentation for ${params.component} component`,
-        };
-    }
-    const lang = params?.language === 'vi' ? '/vi' : '';
-    return {
-        url: `${DOCS_BASE_URL}${lang}`,
-        description: 'Galaxy UI CLI Documentation',
-    };
-}

package/dist/tools/git-operations.d.ts

@@ -1,11 +0,0 @@
-export declare class GitOperations {
-    getStatus(cwd: string): Promise<string>;
-    commit(cwd: string, message: string): Promise<string>;
-    push(cwd: string, remote?: string, branch?: string): Promise<string>;
-    pull(cwd: string, remote?: string, branch?: string): Promise<string>;
-    getDiff(cwd: string, file?: string): Promise<string>;
-    getLog(cwd: string, limit?: number): Promise<string>;
-    listBranches(cwd: string): Promise<string>;
-    createBranch(cwd: string, branchName: string): Promise<string>;
-    switchBranch(cwd: string, branchName: string): Promise<string>;
-}

package/dist/tools/git-operations.js

@@ -1,114 +0,0 @@
-import { exec } from 'child_process';
-import { promisify } from 'util';
-const execAsync = promisify(exec);
-export class GitOperations {
-    async getStatus(cwd) {
-        try {
-            const { stdout } = await execAsync('git status --short', {
-                cwd,
-                timeout: 5000,
-            });
-            return stdout || 'Working tree clean';
-        }
-        catch (error) {
-            return `Not a git repository: ${error.message}`;
-        }
-    }
-    async commit(cwd, message) {
-        try {
-            await execAsync('git add .', { cwd, timeout: 5000 });
-            const { stdout } = await execAsync(`git commit -m "${message.replace(/"/g, '\\"')}"`, {
-                cwd,
-                timeout: 10000,
-            });
-            return stdout;
-        }
-        catch (error) {
-            return `Commit failed: ${error.message}`;
-        }
-    }
-    async push(cwd, remote = 'origin', branch) {
-        try {
-            const branchArg = branch ? ` ${branch}` : '';
-            const { stdout } = await execAsync(`git push ${remote}${branchArg}`, {
-                cwd,
-                timeout: 30000,
-            });
-            return stdout;
-        }
-        catch (error) {
-            return `Push failed: ${error.message}`;
-        }
-    }
-    async pull(cwd, remote = 'origin', branch) {
-        try {
-            const branchArg = branch ? ` ${branch}` : '';
-            const { stdout } = await execAsync(`git pull ${remote}${branchArg}`, {
-                cwd,
-                timeout: 30000,
-            });
-            return stdout;
-        }
-        catch (error) {
-            return `Pull failed: ${error.message}`;
-        }
-    }
-    async getDiff(cwd, file) {
-        try {
-            const fileArg = file ? ` "${file}"` : '';
-            const { stdout } = await execAsync(`git diff${fileArg}`, {
-                cwd,
-                timeout: 10000,
-            });
-            return stdout || 'No changes';
-        }
-        catch (error) {
-            return `Diff failed: ${error.message}`;
-        }
-    }
-    async getLog(cwd, limit = 10) {
-        try {
-            const { stdout } = await execAsync(`git log --oneline -${limit}`, {
-                cwd,
-                timeout: 5000,
-            });
-            return stdout;
-        }
-        catch (error) {
-            return `Log failed: ${error.message}`;
-        }
-    }
-    async listBranches(cwd) {
-        try {
-            const { stdout } = await execAsync('git branch -a', { cwd, timeout: 5000 });
-            return stdout;
-        }
-        catch (error) {
-            return `Branch list failed: ${error.message}`;
-        }
-    }
-    async createBranch(cwd, branchName) {
-        try {
-            const { stdout } = await execAsync(`git checkout -b "${branchName}"`, {
-                cwd,
-                timeout: 5000,
-            });
-            return stdout;
-        }
-        catch (error) {
-            return `Branch creation failed: ${error.message}`;
-        }
-    }
-    async switchBranch(cwd, branchName) {
-        try {
-            const { stdout } = await execAsync(`git checkout "${branchName}"`, {
-                cwd,
-                timeout: 5000,
-            });
-            return stdout;
-        }
-        catch (error) {
-            return `Branch switch failed: ${error.message}`;
-        }
-    }
-}

package/dist/tools/index.d.ts

@@ -1,10 +0,0 @@
-/**
- * @author Bùi Trọng Hiếu
- * @email kevinbui210191@gmail.com
- * @create 2024-10-08
- * @modify 2024-10-08
- * @desc Barrel exports for tool layer.
- */
-export * from './types.js';
-export * from './registry.js';
-export * from './tool-event-emitter.js';

package/dist/tools/index.js

@@ -1,10 +0,0 @@
-/**
- * @author Bùi Trọng Hiếu
- * @email kevinbui210191@gmail.com
- * @create 2024-10-08
- * @modify 2024-10-08
- * @desc Barrel exports for tool layer.
- */
-export * from './types.js';
-export * from './registry.js';
-export * from './tool-event-emitter.js';

package/dist/tools/planning-agent.d.ts

@@ -1,29 +0,0 @@
-/**
- * Planning Agent - Creates step-by-step execution plans
- * Uses gemini-2.5-flash for intelligent planning
- */
-import type { ProjectRequirement } from './ba-it-analyzer.js';
-export interface PlanStep {
-    step: number;
-    action: string;
-    tool: string;
-    reasoning: string;
-}
-export interface ExecutionPlan {
-    summary: string;
-    steps: PlanStep[];
-    estimatedTime: 'quick' | 'medium' | 'long';
-}
-export declare class PlanningAgent {
-    private gemini;
-    private model;
-    constructor();
-    private getConnection;
-    generatePlan(userContext: string, baAnalysis?: {
-        ba_it_analyze_response: {
-            result: ProjectRequirement;
-        };
-    }): Promise<ExecutionPlan>;
-    private extractJSON;
-    private createFallbackPlan;
-}

package/dist/tools/planning-agent.js

@@ -1,134 +0,0 @@
-/**
- * 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

@@ -1,19 +0,0 @@
-/**
- * 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

@@ -1,52 +0,0 @@
-/**
- * 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

@@ -1,21 +0,0 @@
-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;