galaxy-code 0.1.6 → 0.1.7

package/dist/tools/code-generate-agent.js

@@ -1,159 +0,0 @@
-/**
- * Code Generate Agent - Planning only (no execution)
- * Receives feature spec → Plans actions → Returns action list
- * Orchestrator will execute the actions
- */
-import { OllamaConnection } from '../connections/ollama.js';
-export class CodeGenerateAgent {
-    constructor() {
-        Object.defineProperty(this, "ollama", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        Object.defineProperty(this, "model", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'qwen3-coder:480b-cloud'
-        });
-        // Lazy initialization - only create connection when needed
-    }
-    getConnection() {
-        if (!this.ollama) {
-            this.ollama = new OllamaConnection({
-                model: this.model,
-            });
-        }
-        return this.ollama;
-    }
-    async execute(input) {
-        try {
-            const systemPrompt = this.buildSystemPrompt();
-            const userPrompt = this.buildUserPrompt(input);
-            const response = await this.getConnection().generate({
-                prompt: userPrompt,
-                system: systemPrompt,
-                model: this.model,
-            });
-            // Parse action plan from AI
-            const actions = this.parseActionPlan(response.response);
-            return {
-                step: input.step,
-                featureName: input.featureName,
-                actions,
-            };
-        }
-        catch (error) {
-            // Return empty actions on error
-            return {
-                step: input.step,
-                featureName: input.featureName,
-                actions: [],
-            };
-        }
-    }
-    buildSystemPrompt() {
-        return `You are an EXPERT CODE GENERATION PLANNER.
-
-# Your Mission:
-Generate a detailed action plan for implementing a feature. You do NOT execute - only plan.
-
-# Available Actions:
-1. read_file - Read existing file for context
-2. write_file - Create/update a file
-3. run_command - Execute shell command
-4. search_files - Search for pattern in files
-
-# Planning Guidelines:
-1. Start by reading relevant existing files
-2. Plan all necessary file writes (components, APIs, types, tests, etc.)
-3. Include dependency installations if needed
-4. Be thorough - include ALL files needed
-
-# Code Quality Requirements:
-- Production-ready, no TODOs or placeholders
-- Full file content, not snippets
-- Proper imports and exports
-- Type safety (TypeScript)
-- Error handling
-- Comments for complex logic
-- Follow framework best practices
-
-# Output Format (VALID JSON ARRAY):
-[
-  {"action": "read_file", "path": "package.json"},
-  {"action": "write_file", "path": "components/Feature.tsx", "content": "full content here"},
-  {"action": "write_file", "path": "api/feature.ts", "content": "full content here"},
-  {"action": "run_command", "command": "npm install new-package"}
-]
-
-CRITICAL: 
-- Output ONLY the JSON array, nothing else. Start with [ and end with ]
-- Include full file content in "content" field, not placeholders`;
-    }
-    buildUserPrompt(input) {
-        let prompt = `# Feature Implementation Plan Request
-
-**Feature**: ${input.featureName}
-**Description**: ${input.featureDescription}
-**Priority**: ${input.priority}
-
-## Technical Stack:
-${JSON.stringify(input.technicalStack, null, 2)}
-`;
-        if (input.userStories && input.userStories.length > 0) {
-            prompt += `\n## User Stories:\n`;
-            input.userStories.forEach(story => {
-                prompt += `- As ${story.as}, I want ${story.want}, so that ${story.so}\n`;
-            });
-        }
-        if (input.dataModel && input.dataModel.length > 0) {
-            prompt += `\n## Data Model:\n${JSON.stringify(input.dataModel, null, 2)}\n`;
-        }
-        if (input.apiEndpoints && input.apiEndpoints.length > 0) {
-            prompt += `\n## API Endpoints:\n`;
-            input.apiEndpoints.forEach(endpoint => {
-                prompt += `- ${endpoint.method} ${endpoint.path}: ${endpoint.description}\n`;
-            });
-        }
-        if (input.acceptanceCriteria && input.acceptanceCriteria.length > 0) {
-            prompt += `\n## Acceptance Criteria:\n`;
-            input.acceptanceCriteria.forEach((criteria, i) => {
-                prompt += `${i + 1}. ${criteria}\n`;
-            });
-        }
-        prompt += `\n## Working Directory: ${process.cwd()}
-
-Generate the action plan as JSON array to implement this feature completely.`;
-        return prompt;
-    }
-    parseActionPlan(content) {
-        // Clean response
-        let cleanContent = content.trim();
-        // Remove markdown code blocks
-        cleanContent = cleanContent.replace(/```json\s*/g, '');
-        cleanContent = cleanContent.replace(/```\s*/g, '');
-        // Find JSON array
-        const startIdx = cleanContent.indexOf('[');
-        const endIdx = cleanContent.lastIndexOf(']');
-        if (startIdx === -1 || endIdx === -1) {
-            console.warn('Invalid action plan format - no JSON array found');
-            return [];
-        }
-        const jsonStr = cleanContent.substring(startIdx, endIdx + 1);
-        try {
-            const actions = JSON.parse(jsonStr);
-            // Filter to only valid action types
-            return actions.filter((action) => action.action === 'read_file' ||
-                action.action === 'write_file' ||
-                action.action === 'run_command' ||
-                action.action === 'search_files');
-        }
-        catch (error) {
-            console.warn(`Failed to parse action plan: ${error}`);
-            return [];
-        }
-    }
-}

package/dist/tools/command-runner.d.ts

@@ -1,14 +0,0 @@
-export interface CommandResult {
-    stdout: string;
-    stderr: string;
-    exitCode: number;
-    command?: string;
-}
-export declare class CommandRunner {
-    runCommand(command: string, cwd: string, timeout?: number): Promise<CommandResult>;
-    detectTestCommand(cwd: string): Promise<string | null>;
-    detectDevCommand(cwd: string): Promise<string | null>;
-    detectBuildCommand(cwd: string): Promise<string | null>;
-    private detectPackageManager;
-    installDependencies(cwd: string): Promise<CommandResult>;
-}

package/dist/tools/command-runner.js

@@ -1,120 +0,0 @@
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import fs from 'fs/promises';
-import path from 'path';
-const execAsync = promisify(exec);
-export class CommandRunner {
-    async runCommand(command, cwd, timeout = 180000) {
-        try {
-            const { stdout, stderr } = await execAsync(command, {
-                cwd,
-                timeout, // Increased to 3 minutes for project creation
-                maxBuffer: 10 * 1024 * 1024,
-            });
-            return {
-                stdout,
-                stderr,
-                exitCode: 0,
-                command,
-            };
-        }
-        catch (error) {
-            return {
-                stdout: error.stdout || '',
-                stderr: error.stderr || error.message,
-                exitCode: error.code || 1,
-                command,
-            };
-        }
-    }
-    async detectTestCommand(cwd) {
-        try {
-            const pkgJsonPath = path.join(cwd, 'package.json');
-            const content = await fs.readFile(pkgJsonPath, 'utf-8');
-            const pkgJson = JSON.parse(content);
-            if (pkgJson.scripts?.test) {
-                return pkgJson.scripts.test;
-            }
-            const packageManager = await this.detectPackageManager(cwd);
-            if (packageManager === 'bun')
-                return 'bun test';
-            if (packageManager === 'pnpm')
-                return 'pnpm test';
-            if (packageManager === 'yarn')
-                return 'yarn test';
-            return 'npm test';
-        }
-        catch {
-            return null;
-        }
-    }
-    async detectDevCommand(cwd) {
-        try {
-            const pkgJsonPath = path.join(cwd, 'package.json');
-            const content = await fs.readFile(pkgJsonPath, 'utf-8');
-            const pkgJson = JSON.parse(content);
-            if (pkgJson.scripts?.dev)
-                return pkgJson.scripts.dev;
-            if (pkgJson.scripts?.start)
-                return pkgJson.scripts.start;
-            const packageManager = await this.detectPackageManager(cwd);
-            if (packageManager === 'bun')
-                return 'bun run dev';
-            if (packageManager === 'pnpm')
-                return 'pnpm dev';
-            if (packageManager === 'yarn')
-                return 'yarn dev';
-            return 'npm run dev';
-        }
-        catch {
-            return null;
-        }
-    }
-    async detectBuildCommand(cwd) {
-        try {
-            const pkgJsonPath = path.join(cwd, 'package.json');
-            const content = await fs.readFile(pkgJsonPath, 'utf-8');
-            const pkgJson = JSON.parse(content);
-            if (pkgJson.scripts?.build) {
-                const packageManager = await this.detectPackageManager(cwd);
-                if (packageManager === 'bun')
-                    return 'bun run build';
-                if (packageManager === 'pnpm')
-                    return 'pnpm build';
-                if (packageManager === 'yarn')
-                    return 'yarn build';
-                return 'npm run build';
-            }
-            return null;
-        }
-        catch {
-            return null;
-        }
-    }
-    async detectPackageManager(cwd) {
-        try {
-            const files = await fs.readdir(cwd);
-            if (files.includes('bun.lockb'))
-                return 'bun';
-            if (files.includes('pnpm-lock.yaml'))
-                return 'pnpm';
-            if (files.includes('yarn.lock'))
-                return 'yarn';
-            return 'npm';
-        }
-        catch {
-            return 'bun'; // Default to bun instead of npm
-        }
-    }
-    async installDependencies(cwd) {
-        const packageManager = await this.detectPackageManager(cwd);
-        const installCmd = packageManager === 'npm'
-            ? 'npm install'
-            : packageManager === 'yarn'
-                ? 'yarn install'
-                : packageManager === 'pnpm'
-                    ? 'pnpm install'
-                    : 'bun install';
-        return this.runCommand(installCmd, cwd, 180000); // 3 minutes timeout
-    }
-}

package/dist/tools/document-parser.d.ts

@@ -1,11 +0,0 @@
-export declare class DocumentParser {
-    parseDocument(filePath: string, type: 'docx' | 'xlsx' | 'pdf'): Promise<string>;
-    private parsePDF;
-    private parseDOCX;
-    private parseXLSX;
-    checkDependencies(): Promise<{
-        pdf: boolean;
-        docx: boolean;
-        xlsx: boolean;
-    }>;
-}

package/dist/tools/document-parser.js

@@ -1,83 +0,0 @@
-import { exec } from 'child_process';
-import { promisify } from 'util';
-const execAsync = promisify(exec);
-export class DocumentParser {
-    async parseDocument(filePath, type) {
-        try {
-            switch (type) {
-                case 'pdf':
-                    return await this.parsePDF(filePath);
-                case 'docx':
-                    return await this.parseDOCX(filePath);
-                case 'xlsx':
-                    return await this.parseXLSX(filePath);
-                default:
-                    throw new Error(`Unsupported document type: ${type}`);
-            }
-        }
-        catch (error) {
-            return `Failed to parse document: ${error.message}`;
-        }
-    }
-    async parsePDF(filePath) {
-        try {
-            const { stdout } = await execAsync(`pdftotext "${filePath}" -`, {
-                timeout: 30000,
-                maxBuffer: 10 * 1024 * 1024,
-            });
-            return stdout || 'No text content found in PDF';
-        }
-        catch (error) {
-            if (error.message.includes('command not found')) {
-                return 'PDF parsing requires pdftotext (install: apt-get install poppler-utils)';
-            }
-            throw error;
-        }
-    }
-    async parseDOCX(filePath) {
-        try {
-            const { stdout } = await execAsync(`pandoc "${filePath}" -t plain`, {
-                timeout: 30000,
-                maxBuffer: 10 * 1024 * 1024,
-            });
-            return stdout || 'No text content found in DOCX';
-        }
-        catch (error) {
-            if (error.message.includes('command not found')) {
-                return 'DOCX parsing requires pandoc (install: apt-get install pandoc)';
-            }
-            throw error;
-        }
-    }
-    async parseXLSX(filePath) {
-        try {
-            const { stdout } = await execAsync(`ssconvert "${filePath}" fd://1`, {
-                timeout: 30000,
-                maxBuffer: 10 * 1024 * 1024,
-            });
-            return stdout || 'No content found in XLSX';
-        }
-        catch (error) {
-            if (error.message.includes('command not found')) {
-                return 'XLSX parsing requires ssconvert (install: apt-get install gnumeric)';
-            }
-            throw error;
-        }
-    }
-    async checkDependencies() {
-        const checkCommand = async (cmd) => {
-            try {
-                await execAsync(`which ${cmd}`, { timeout: 1000 });
-                return true;
-            }
-            catch {
-                return false;
-            }
-        };
-        return {
-            pdf: await checkCommand('pdftotext'),
-            docx: await checkCommand('pandoc'),
-            xlsx: await checkCommand('ssconvert'),
-        };
-    }
-}

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

@@ -1,17 +0,0 @@
-export interface FileWriteResult {
-    isNewFile: boolean;
-    oldContent?: string;
-    newContent: string;
-    linesAdded: number;
-    linesRemoved: number;
-    path: string;
-}
-export declare class FileOperations {
-    readFile(filePath: string): Promise<string>;
-    writeFile(filePath: string, content: string): Promise<FileWriteResult>;
-    listFiles(dirPath: string, recursive?: boolean): Promise<string[]>;
-    searchFiles(dirPath: string, pattern: string): Promise<string[]>;
-    getFileDiff(filePath: string): Promise<string>;
-    applyPatch(filePath: string, patch: string): Promise<void>;
-    getFileTree(dirPath: string): Promise<string>;
-}

package/dist/tools/file-operations.js

@@ -1,127 +0,0 @@
-import fs from 'fs/promises';
-import path from 'path';
-import { exec } from 'child_process';
-import { promisify } from 'util';
-const execAsync = promisify(exec);
-export class FileOperations {
-    async readFile(filePath) {
-        try {
-            const content = await fs.readFile(filePath, 'utf-8');
-            return content;
-        }
-        catch (error) {
-            throw new Error(`Failed to read file ${filePath}: ${error.message}`);
-        }
-    }
-    async writeFile(filePath, content) {
-        try {
-            // Check if file exists and read old content
-            let isNewFile = false;
-            let oldContent;
-            try {
-                const fileContent = await fs.readFile(filePath, 'utf-8');
-                oldContent = fileContent;
-            }
-            catch {
-                isNewFile = true;
-            }
-            // Create directory if needed
-            await fs.mkdir(path.dirname(filePath), { recursive: true });
-            // Write new content
-            await fs.writeFile(filePath, content, 'utf-8');
-            // Calculate diff stats
-            const newLines = content.split('\n');
-            const oldLines = oldContent ? oldContent.split('\n') : [];
-            let linesAdded = 0;
-            let linesRemoved = 0;
-            if (isNewFile) {
-                linesAdded = newLines.length;
-            }
-            else {
-                // Simple line-based diff calculation
-                // Count removed lines (in old but not in new)
-                linesRemoved = oldLines.length;
-                linesAdded = newLines.length;
-                // Better approach: use set intersection
-                const oldSet = new Set(oldLines);
-                const newSet = new Set(newLines);
-                // Lines only in old = removed
-                const onlyInOld = oldLines.filter(line => !newSet.has(line));
-                // Lines only in new = added
-                const onlyInNew = newLines.filter(line => !oldSet.has(line));
-                linesRemoved = onlyInOld.length;
-                linesAdded = onlyInNew.length;
-            }
-            return {
-                isNewFile,
-                oldContent,
-                newContent: content,
-                linesAdded,
-                linesRemoved,
-                path: filePath,
-            };
-        }
-        catch (error) {
-            throw new Error(`Failed to write file ${filePath}: ${error.message}`);
-        }
-    }
-    async listFiles(dirPath, recursive = false) {
-        try {
-            if (recursive) {
-                const { stdout } = await execAsync(`find "${dirPath}" -type f -not -path "*/node_modules/*" -not -path "*/.git/*" -not -path "*/dist/*" -not -path "*/build/*" | head -500`, { timeout: 10000 });
-                return stdout.trim().split('\n').filter(Boolean);
-            }
-            else {
-                const entries = await fs.readdir(dirPath, { withFileTypes: true });
-                return entries
-                    .filter(entry => entry.isFile())
-                    .map(entry => path.join(dirPath, entry.name));
-            }
-        }
-        catch (error) {
-            throw new Error(`Failed to list files in ${dirPath}: ${error.message}`);
-        }
-    }
-    async searchFiles(dirPath, pattern) {
-        try {
-            const { stdout } = await execAsync(`grep -r "${pattern}" "${dirPath}" --include="*.ts" --include="*.js" --include="*.tsx" --include="*.jsx" --include="*.json" --exclude-dir="node_modules" --exclude-dir=".git" --exclude-dir="dist" -l | head -100`, { timeout: 10000 });
-            return stdout.trim().split('\n').filter(Boolean);
-        }
-        catch {
-            return [];
-        }
-    }
-    async getFileDiff(filePath) {
-        try {
-            const { stdout } = await execAsync(`git diff "${filePath}"`, {
-                timeout: 5000,
-            });
-            return stdout || 'No changes';
-        }
-        catch (error) {
-            return `Not a git repository or file doesn't exist: ${error.message}`;
-        }
-    }
-    async applyPatch(filePath, patch) {
-        try {
-            const tempPatchFile = path.join('/tmp', `patch-${Date.now()}.patch`);
-            await fs.writeFile(tempPatchFile, patch);
-            await execAsync(`patch "${filePath}" < "${tempPatchFile}"`, {
-                timeout: 5000,
-            });
-            await fs.unlink(tempPatchFile);
-        }
-        catch (error) {
-            throw new Error(`Failed to apply patch: ${error.message}`);
-        }
-    }
-    async getFileTree(dirPath) {
-        try {
-            const { stdout } = await execAsync(`tree -L 3 -I "node_modules|.git|dist|build|.venv|venv|ios|android|.expo" -a --charset ascii "${dirPath}" 2>/dev/null || find "${dirPath}" -maxdepth 3 -not -path "*/node_modules/*" -not -path "*/.git/*" | head -500`, { timeout: 20000 });
-            return stdout;
-        }
-        catch (error) {
-            return `Failed to generate file tree: ${error.message}`;
-        }
-    }
-}

package/dist/tools/galaxy-ui-integration.d.ts

@@ -1,94 +0,0 @@
-/**
- * Tool 1: List all components
- * Fetches from GitHub registry.json
- */
-export declare function galaxyUIListComponents(params?: {
-    category?: 'form' | 'layout' | 'navigation' | 'interactive' | 'overlay' | 'data-display' | 'utility' | 'all';
-}): Promise<{
-    total: number;
-    components: Array<{
-        name: string;
-        description: string;
-        category: string;
-        docsUrl: string;
-    }>;
-}>;
-/**
- * Tool 2: Search components by keyword
- * Searches in component name and description
- */
-export declare function galaxyUISearchComponents(params: {
-    query: string;
-}): Promise<{
-    total: number;
-    components: Array<{
-        name: string;
-        description: string;
-        category: string;
-        docsUrl: string;
-        relevance: 'high' | 'medium' | 'low';
-    }>;
-}>;
-/**
- * Tool 3: Get component details
- * Returns component info from registry + docs URL
- */
-export declare function galaxyUIGetComponent(params: {
-    name: string;
-    framework?: 'vue' | 'react' | 'angular';
-}): Promise<{
-    name: string;
-    description: string;
-    category: string;
-    dependencies: string[];
-    peerDependencies: string[];
-    docsUrl: string;
-    docsUrlFramework?: string;
-    installCommand: string;
-}>;
-/**
- * Tool 4: Get component categories with counts
- * Groups components by category from registry
- */
-export declare function galaxyUIGetCategories(): Promise<{
-    categories: Array<{
-        name: string;
-        count: number;
-        components: string[];
-    }>;
-}>;
-/**
- * Tool 5: Add components to project
- * Executes: npx galaxy-design add [components...] --cwd [path]
- */
-export declare function galaxyUIAddComponents(params: {
-    components: string[];
-    cwd?: string;
-}): Promise<{
-    success: boolean;
-    message: string;
-    output: string;
-}>;
-/**
- * Tool 6: Initialize Galaxy UI in project
- * Executes: npx galaxy-design@latest init --yes --cwd [path]
- */
-export declare function galaxyUIInit(params?: {
-    cwd?: string;
-    skipPrompts?: boolean;
-}): Promise<{
-    success: boolean;
-    message: string;
-    output: string;
-}>;
-/**
- * Tool 7: Get documentation URL
- * Returns direct link to component docs or main docs
- */
-export declare function galaxyUIGetDocsUrl(params?: {
-    component?: string;
-    language?: 'en' | 'vi';
-}): {
-    url: string;
-    description: string;
-};