galaxy-code 0.1.3 → 0.1.5

package/dist/tools/ba-it-analyzer.d.ts

@@ -0,0 +1,66 @@
+/**
+ * BA IT Analyzer - Business Analyst for IT Projects
+ * Analyzes user requirements and creates detailed functional specifications
+ * NOW WITH DEEP THINK INTEGRATION for complex technical decisions!
+ */
+export interface ProjectRequirement {
+    type: 'create_project' | 'update_project';
+    projectName: string;
+    projectType: string;
+    description: string;
+    coreFeatures: Feature[];
+    technicalStack: TechnicalStack;
+    userStories: UserStory[];
+    dataModel: DataEntity[];
+    apiEndpoints?: APIEndpoint[];
+    estimatedComplexity: 'simple' | 'medium' | 'complex';
+    estimatedTime: string;
+    recommendations: string[];
+    questionsForUser: string[];
+    deepAnalysis?: {
+        question: string;
+        insights: string;
+        considerations: string[];
+    }[];
+}
+export interface Feature {
+    name: string;
+    description: string;
+    priority: 'must-have' | 'should-have' | 'nice-to-have';
+    userStory: string;
+    acceptanceCriteria: string[];
+}
+export interface TechnicalStack {
+    frontend?: string[];
+    backend?: string[];
+    database?: string[];
+    infrastructure?: string[];
+    thirdParty?: string[];
+}
+export interface UserStory {
+    as: string;
+    iWant: string;
+    soThat: string;
+    acceptanceCriteria: string[];
+}
+export interface DataEntity {
+    name: string;
+    description: string;
+    attributes: string[];
+    relationships: string[];
+}
+export interface APIEndpoint {
+    method: string;
+    path: string;
+    description: string;
+    requestBody?: string;
+    response: string;
+}
+export declare class BAITAnalyzer {
+    private ollama;
+    private model;
+    constructor();
+    private getConnection;
+    analyze(userRequest: string, context?: string): Promise<ProjectRequirement>;
+    private extractJSON;
+}

package/dist/tools/ba-it-analyzer.js

@@ -0,0 +1,90 @@
+/**
+ * BA IT Analyzer - Business Analyst for IT Projects
+ * Analyzes user requirements and creates detailed functional specifications
+ * NOW WITH DEEP THINK INTEGRATION for complex technical decisions!
+ */
+import { OllamaConnection } from '../connections/ollama.js';
+import { systemBAITAnalyzerPrompt } from '../prompts/ba-it-analyzer.js';
+export class BAITAnalyzer {
+    constructor() {
+        Object.defineProperty(this, "ollama", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'gpt-oss:120b-cloud'
+        });
+        // Lazy initialization - only create connection when needed
+    }
+    getConnection() {
+        if (!this.ollama) {
+            this.ollama = new OllamaConnection({
+                model: this.model,
+            });
+        }
+        return this.ollama;
+    }
+    async analyze(userRequest, context) {
+        let userMessage = `User Request: ${userRequest}`;
+        if (context) {
+            userMessage += `\n\nAdditional Context:\n${context}`;
+        }
+        const response = await this.getConnection().generate({
+            prompt: userMessage,
+            system: systemBAITAnalyzerPrompt,
+            model: this.model,
+        });
+        // Extract and clean JSON from response
+        const jsonStr = this.extractJSON(response.response);
+        if (!jsonStr) {
+            throw new Error('Failed to extract JSON from BA analysis response');
+        }
+        const projectRequirement = JSON.parse(jsonStr);
+        return projectRequirement;
+    }
+    extractJSON(content) {
+        // Remove markdown code blocks if present
+        let cleanContent = content.trim();
+        cleanContent = cleanContent.replace(/```json\s*/g, '');
+        cleanContent = cleanContent.replace(/```\s*/g, '');
+        // Try to 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;
+    }
+}

package/dist/tools/code-generate-agent.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Code Generate Agent - Planning only (no execution)
+ * Receives feature spec → Plans actions → Returns action list
+ * Orchestrator will execute the actions
+ */
+import type { ProjectRequirement } from './ba-it-analyzer.js';
+export interface CodeGenerateInput {
+    step: number;
+    featureName: string;
+    featureDescription: string;
+    priority: string;
+    technicalStack: ProjectRequirement['technicalStack'];
+    userStories?: Array<{
+        as: string;
+        want: string;
+        so: string;
+    }>;
+    dataModel?: Array<{
+        entity: string;
+        attributes: any;
+        relationships: any;
+    }>;
+    apiEndpoints?: Array<{
+        path: string;
+        method: string;
+        description: string;
+    }>;
+    acceptanceCriteria?: string[];
+}
+export interface CodeGenerateAction {
+    action: 'read_file' | 'write_file' | 'run_command' | 'search_files';
+    path?: string;
+    content?: string;
+    command?: string;
+    pattern?: string;
+}
+export interface CodeGenerateOutput {
+    step: number;
+    featureName: string;
+    actions: CodeGenerateAction[];
+}
+export declare class CodeGenerateAgent {
+    private ollama;
+    private model;
+    constructor();
+    private getConnection;
+    execute(input: CodeGenerateInput): Promise<CodeGenerateOutput>;
+    private buildSystemPrompt;
+    private buildUserPrompt;
+    private parseActionPlan;
+}

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

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

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

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

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

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

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