galaxy-code 0.1.0 → 0.1.2

package/dist/node_modules/@workspace/agent-core/tools/registry.js

@@ -0,0 +1,651 @@
+/**
+ * @author Bùi Trọng Hiếu
+ * @email kevinbui210191@gmail.com
+ * @create 2024-10-08
+ * @modify 2024-10-08
+ * @desc In-memory registry for AI tools.
+ */
+import { BAITAnalyzer } from './ba-it-analyzer.js';
+import { CommandRunner } from './command-runner.js';
+import { DocumentParser } from './document-parser.js';
+import { FileOperations } from './file-operations.js';
+import { GitOperations } from './git-operations.js';
+import { PlanningAgent } from './planning-agent.js';
+import { CodeGenerateAgent } from './code-generate-agent.js';
+import { ProgressReporter } from './progress-reporter.js';
+import * as GalaxyUI from './galaxy-ui-integration.js';
+import { toolEventEmitter } from './tool-event-emitter.js';
+export class ToolRegistry {
+    tools = new Map();
+    fileOps = new FileOperations();
+    gitOps = new GitOperations();
+    commandRunner = new CommandRunner();
+    baAnalyzer = new BAITAnalyzer();
+    documentParser = new DocumentParser();
+    planningAgent = new PlanningAgent();
+    codeGenerateAgent = new CodeGenerateAgent();
+    progressReporter = new ProgressReporter();
+    constructor() {
+        this.registerAllTools();
+    }
+    registerAllTools() {
+        // File operations
+        this.register({
+            name: 'file_read',
+            description: 'Read content of a file',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'File path to read' },
+                },
+                required: ['path'],
+            },
+            execute: async (args) => await this.fileOps.readFile(args.path),
+        });
+        this.register({
+            name: 'file_write',
+            description: 'Write content to a file (creates directories if needed)',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'File path to write' },
+                    content: { type: 'string', description: 'Content to write' },
+                },
+                required: ['path', 'content'],
+            },
+            execute: async (args) => {
+                const result = await this.fileOps.writeFile(args.path, args.content);
+                // Return as JSON string for tool result
+                return JSON.stringify(result);
+            },
+        });
+        this.register({
+            name: 'file_list',
+            description: 'List files in a directory',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Directory path' },
+                    recursive: {
+                        type: 'boolean',
+                        description: 'Recursive listing',
+                        default: false,
+                    },
+                },
+                required: ['path'],
+            },
+            execute: async (args) => {
+                const files = await this.fileOps.listFiles(args.path, args.recursive);
+                return files.join('\n');
+            },
+        });
+        this.register({
+            name: 'file_search',
+            description: 'Search for pattern in files',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Directory to search in' },
+                    pattern: { type: 'string', description: 'Pattern to search for' },
+                },
+                required: ['path', 'pattern'],
+            },
+            execute: async (args) => {
+                const matches = await this.fileOps.searchFiles(args.path, args.pattern);
+                return matches.join('\n') || 'No matches found';
+            },
+        });
+        this.register({
+            name: 'file_tree',
+            description: 'Get file tree structure of a directory',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Directory path' },
+                },
+                required: ['path'],
+            },
+            execute: async (args) => await this.fileOps.getFileTree(args.path),
+        });
+        // Git operations
+        this.register({
+            name: 'git_status',
+            description: 'Get git status of repository',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    cwd: { type: 'string', description: 'Working directory' },
+                },
+                required: ['cwd'],
+            },
+            execute: async (args) => await this.gitOps.getStatus(args.cwd || process.cwd()),
+        });
+        this.register({
+            name: 'git_commit',
+            description: 'Commit changes with message',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    cwd: { type: 'string', description: 'Working directory' },
+                    message: { type: 'string', description: 'Commit message' },
+                },
+                required: ['cwd', 'message'],
+            },
+            execute: async (args) => await this.gitOps.commit(args.cwd || process.cwd(), args.message),
+        });
+        this.register({
+            name: 'git_push',
+            description: 'Push commits to remote',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    cwd: { type: 'string', description: 'Working directory' },
+                    remote: {
+                        type: 'string',
+                        description: 'Remote name',
+                        default: 'origin',
+                    },
+                    branch: { type: 'string', description: 'Branch name (optional)' },
+                },
+                required: ['cwd'],
+            },
+            execute: async (args) => await this.gitOps.push(args.cwd || process.cwd(), args.remote || 'origin', args.branch),
+        });
+        this.register({
+            name: 'git_pull',
+            description: 'Pull changes from remote',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    cwd: { type: 'string', description: 'Working directory' },
+                    remote: {
+                        type: 'string',
+                        description: 'Remote name',
+                        default: 'origin',
+                    },
+                    branch: { type: 'string', description: 'Branch name (optional)' },
+                },
+                required: ['cwd'],
+            },
+            execute: async (args) => await this.gitOps.pull(args.cwd || process.cwd(), args.remote || 'origin', args.branch),
+        });
+        this.register({
+            name: 'git_diff',
+            description: 'Show git diff',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    cwd: { type: 'string', description: 'Working directory' },
+                    file: { type: 'string', description: 'Specific file (optional)' },
+                },
+                required: ['cwd'],
+            },
+            execute: async (args) => await this.gitOps.getDiff(args.cwd || process.cwd(), args.file),
+        });
+        this.register({
+            name: 'git_log',
+            description: 'Show git commit history',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    cwd: { type: 'string', description: 'Working directory' },
+                    limit: {
+                        type: 'number',
+                        description: 'Number of commits',
+                        default: 10,
+                    },
+                },
+                required: ['cwd'],
+            },
+            execute: async (args) => await this.gitOps.getLog(args.cwd || process.cwd(), args.limit || 10),
+        });
+        this.register({
+            name: 'git_branches',
+            description: 'List all branches',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    cwd: { type: 'string', description: 'Working directory' },
+                },
+                required: ['cwd'],
+            },
+            execute: async (args) => await this.gitOps.listBranches(args.cwd || process.cwd()),
+        });
+        // Command runner
+        this.register({
+            name: 'command_run',
+            description: 'Run a shell command',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    command: { type: 'string', description: 'Command to execute' },
+                    cwd: { type: 'string', description: 'Working directory' },
+                    timeout: {
+                        type: 'number',
+                        description: 'Timeout in ms',
+                        default: 60000,
+                    },
+                },
+                required: ['command', 'cwd'],
+            },
+            execute: async (args) => {
+                const result = await this.commandRunner.runCommand(args.command, args.cwd || process.cwd(), args.timeout || 60000);
+                return `stdout:\n${result.stdout}\n\nstderr:\n${result.stderr}`;
+            },
+        });
+        this.register({
+            name: 'test_run',
+            description: 'Run tests in project',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    cwd: { type: 'string', description: 'Project directory' },
+                    command: {
+                        type: 'string',
+                        description: 'Custom test command (optional)',
+                    },
+                },
+                required: ['cwd'],
+            },
+            execute: async (args) => {
+                const testCommand = args.command || (await this.commandRunner.detectTestCommand(args.cwd || process.cwd()));
+                if (!testCommand)
+                    return 'No test command found';
+                const result = await this.commandRunner.runCommand(testCommand, args.cwd || process.cwd(), 120000);
+                return `Test Output:\n${result.stdout}\n\nErrors:\n${result.stderr}`;
+            },
+        });
+        this.register({
+            name: 'install_dependencies',
+            description: 'Install project dependencies (auto-detects package manager)',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    cwd: { type: 'string', description: 'Project directory' },
+                },
+                required: ['cwd'],
+            },
+            execute: async (args) => {
+                const result = await this.commandRunner.installDependencies(args.cwd || process.cwd());
+                return `Installation Output:\n${result.stdout}\n\nErrors:\n${result.stderr}`;
+            },
+        });
+        // BA IT Analyzer Tool
+        this.register({
+            name: 'ba_it_analyze',
+            description: 'Business Analyst for IT projects. Analyzes user requirements and creates comprehensive project specifications with features, tech stack, user stories, data model, and recommendations.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    userRequest: {
+                        type: 'string',
+                        description: "User's project request or requirement",
+                    },
+                    context: {
+                        type: 'string',
+                        description: 'Additional context about the project (optional)',
+                    },
+                },
+                required: ['userRequest'],
+            },
+            execute: async (args) => {
+                const requirement = await this.baAnalyzer.analyze(args.userRequest, args.context);
+                return requirement;
+            },
+        });
+        // Document parser
+        this.register({
+            name: 'document_parse',
+            description: 'Parse document and extract text. Supports: pdf, docx, xlsx (auto-detected from file extension)',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Document file path' },
+                    type: {
+                        type: 'string',
+                        description: 'Type: pdf, docx, xlsx (optional, auto-detected)',
+                    },
+                },
+                required: ['path'],
+            },
+            execute: async (args) => {
+                // Auto-detect type from file extension if not provided
+                let docType = args.type?.toLowerCase();
+                if (!docType) {
+                    const ext = args.path.split('.').pop()?.toLowerCase();
+                    docType = (ext === 'doc' ? 'docx' : ext === 'xls' ? 'xlsx' : ext) || 'docx';
+                }
+                // Validate type
+                if (!['pdf', 'docx', 'xlsx'].includes(docType || '')) {
+                    return `Error: Unsupported document type "${docType}". Supported: PDF, DOCX, XLSX`;
+                }
+                return await this.documentParser.parseDocument(args.path, docType);
+            },
+        });
+        // Planning Agent Tool
+        this.register({
+            name: 'plan_task',
+            description: 'Create step-by-step execution plan based on user context and optional BA analysis. Uses qwen3-coder:480b-cloud for intelligent planning.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    userContext: {
+                        type: 'string',
+                        description: 'User request/context (REQUIRED)',
+                    },
+                    baAnalysis: {
+                        type: 'object',
+                        description: 'BA IT Analysis result (OPTIONAL - if available from ba_it_analyze)',
+                    },
+                },
+                required: ['userContext'],
+            },
+            execute: async (args) => {
+                const plan = await this.planningAgent.generatePlan(args.userContext, args.baAnalysis);
+                // Add critical reminder to plan result
+                const planWithReminder = {
+                    ...plan,
+                    reminder: '⚠️ CRITICAL: You MUST call progress_reporter({step: N, status: "success"|"error"}) after EVERY step execution. NO EXCEPTIONS.',
+                };
+                return planWithReminder;
+            },
+        });
+        // Progress Reporter Tool
+        this.register({
+            name: 'progress_reporter',
+            description: 'Report task completion status for planning steps. Emits events to update UI progress tracking.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    step: {
+                        type: 'number',
+                        description: 'Step number from plan',
+                    },
+                    status: {
+                        type: 'string',
+                        description: 'Step status: success, error, or in_progress',
+                    },
+                    message: {
+                        type: 'string',
+                        description: 'Optional status message',
+                    },
+                    filesCreated: {
+                        type: 'array',
+                        description: 'List of files created in this step',
+                        items: { type: 'string' },
+                    },
+                    commandsRun: {
+                        type: 'array',
+                        description: 'List of commands executed in this step',
+                        items: { type: 'string' },
+                    },
+                },
+                required: ['step', 'status'],
+            },
+            execute: async (args) => {
+                return this.progressReporter.reportProgress(args);
+            },
+        });
+        // Code Generate Agent Tool - Feature executor
+        this.register({
+            name: 'code_generate',
+            description: 'Execute feature implementation with integrated tools. Generates code, writes files, runs commands automatically. Uses qwen3-coder:480b-cloud.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    step: {
+                        type: 'number',
+                        description: 'Step number from plan',
+                    },
+                    featureName: {
+                        type: 'string',
+                        description: 'Feature name from coreFeatures',
+                    },
+                    featureDescription: {
+                        type: 'string',
+                        description: 'Feature description',
+                    },
+                    priority: {
+                        type: 'string',
+                        description: 'must-have | should-have | nice-to-have',
+                    },
+                    technicalStack: {
+                        type: 'object',
+                        description: 'Tech stack from BA analysis',
+                    },
+                    userStories: {
+                        type: 'array',
+                        description: 'User stories (optional)',
+                    },
+                    dataModel: {
+                        type: 'array',
+                        description: 'Data model entities (optional)',
+                    },
+                    apiEndpoints: {
+                        type: 'array',
+                        description: 'API endpoints (optional)',
+                    },
+                    acceptanceCriteria: {
+                        type: 'array',
+                        description: 'Acceptance criteria (optional)',
+                    },
+                },
+                required: ['step', 'featureName', 'featureDescription', 'technicalStack'],
+            },
+            execute: async (args) => {
+                const result = await this.codeGenerateAgent.execute({
+                    step: args.step,
+                    featureName: args.featureName,
+                    featureDescription: args.featureDescription,
+                    priority: args.priority || 'must-have',
+                    technicalStack: args.technicalStack,
+                    userStories: args.userStories,
+                    dataModel: args.dataModel,
+                    apiEndpoints: args.apiEndpoints,
+                    acceptanceCriteria: args.acceptanceCriteria,
+                });
+                return result;
+            },
+        });
+        // Galaxy UI Integration Tools
+        this.register({
+            name: 'galaxy_ui_list',
+            description: 'List all Galaxy UI components. Optional filter by category: form, layout, navigation, interactive, overlay, data-display, utility',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    category: {
+                        type: 'string',
+                        description: 'Filter by category: form, layout, navigation, interactive, overlay, data-display, utility, all',
+                    },
+                },
+            },
+            execute: async (args) => {
+                const result = await GalaxyUI.galaxyUIListComponents(args);
+                return JSON.stringify(result, null, 2);
+            },
+        });
+        this.register({
+            name: 'galaxy_ui_search',
+            description: 'Search Galaxy UI components by keyword in name, description, or category',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    query: { type: 'string', description: 'Search query' },
+                },
+                required: ['query'],
+            },
+            execute: async (args) => {
+                const result = await GalaxyUI.galaxyUISearchComponents(args);
+                return JSON.stringify(result, null, 2);
+            },
+        });
+        this.register({
+            name: 'galaxy_ui_get_component',
+            description: 'Get detailed information about a specific Galaxy UI component including dependencies, docs URL, and install command',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    name: { type: 'string', description: 'Component name' },
+                    framework: {
+                        type: 'string',
+                        description: 'Framework: vue, react, angular (optional)',
+                    },
+                },
+                required: ['name'],
+            },
+            execute: async (args) => {
+                const result = await GalaxyUI.galaxyUIGetComponent(args);
+                return JSON.stringify(result, null, 2);
+            },
+        });
+        this.register({
+            name: 'galaxy_ui_categories',
+            description: 'Get all Galaxy UI component categories with component counts',
+            inputSchema: {
+                type: 'object',
+                properties: {},
+            },
+            execute: async () => {
+                const result = await GalaxyUI.galaxyUIGetCategories();
+                return JSON.stringify(result, null, 2);
+            },
+        });
+        this.register({
+            name: 'galaxy_ui_add',
+            description: 'Add Galaxy UI components to the project. Executes: npx galaxy-design@latest add [components...]',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    components: {
+                        type: 'array',
+                        description: 'Array of component names to add',
+                        items: { type: 'string' },
+                    },
+                    cwd: { type: 'string', description: 'Working directory (optional)' },
+                },
+                required: ['components'],
+            },
+            execute: async (args) => {
+                const result = await GalaxyUI.galaxyUIAddComponents(args);
+                return JSON.stringify(result, null, 2);
+            },
+        });
+        this.register({
+            name: 'galaxy_ui_init',
+            description: 'Initialize Galaxy UI in the project. Executes: npx galaxy-design@latest init',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    cwd: { type: 'string', description: 'Working directory (optional)' },
+                    skipPrompts: {
+                        type: 'boolean',
+                        description: 'Skip prompts and use defaults (optional)',
+                    },
+                },
+            },
+            execute: async (args) => {
+                const result = await GalaxyUI.galaxyUIInit(args);
+                return JSON.stringify(result, null, 2);
+            },
+        });
+        this.register({
+            name: 'galaxy_ui_docs',
+            description: 'Get documentation URL for Galaxy UI components or main documentation',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    component: {
+                        type: 'string',
+                        description: 'Component name (optional)',
+                    },
+                    language: {
+                        type: 'string',
+                        description: 'Language: en or vi (optional)',
+                    },
+                },
+            },
+            execute: async (args) => {
+                const result = GalaxyUI.galaxyUIGetDocsUrl(args);
+                return JSON.stringify(result, null, 2);
+            },
+        });
+    }
+    register(tool) {
+        if (this.tools.has(tool.name)) {
+            throw new Error(`Tool with name "${tool.name}" is already registered.`);
+        }
+        this.tools.set(tool.name, tool);
+    }
+    get(name) {
+        return this.tools.get(name);
+    }
+    list() {
+        return [...this.tools.values()];
+    }
+    getToolsContext(args) {
+        const todoList = args
+            .map((name) => this.tools.get(name))
+            .map((tool) => {
+            return `- ${tool?.name}: ${tool?.description}`;
+        });
+        return `Available Tools:
+                ${todoList.join('\n')}
+                `;
+    }
+    //Lấy list tool dựa trên list args name
+    getToolsByNames(names) {
+        return (names?.map(name => this.tools.get(name)).filter((tool) => tool !== undefined) || [
+            ...this.tools.values(),
+        ]);
+    }
+    // Execute a tool by name with given arguments
+    async executeTool(name, args) {
+        const tool = this.tools.get(name);
+        if (!tool) {
+            throw new Error(`Tool "${name}" not found in registry`);
+        }
+        // Skip emit for progress_reporter (it emits internally)
+        const skipEmit = name === 'progress_reporter';
+        try {
+            // Create execution context (empty for now, can add abortSignal if needed)
+            const context = {};
+            // Execute the tool with args and context
+            const result = await tool.execute(args, context);
+            // Emit success event
+            if (!skipEmit) {
+                const resultStr = typeof result === 'string' ? result : JSON.stringify(result);
+                toolEventEmitter.emitToolExecution({
+                    toolName: name,
+                    content: resultStr,
+                    status: 'success',
+                    toolInfo: {
+                        toolName: name,
+                        args,
+                        result,
+                    },
+                });
+            }
+            return result;
+        }
+        catch (error) {
+            // Emit error event
+            if (!skipEmit) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                toolEventEmitter.emitToolExecution({
+                    toolName: name,
+                    content: `Error: ${errorMsg}`,
+                    status: 'error',
+                    error: errorMsg,
+                    toolInfo: {
+                        toolName: name,
+                        args,
+                    },
+                });
+            }
+            throw error;
+        }
+    }
+}
+export const globalToolRegistry = new ToolRegistry();
+//# sourceMappingURL=registry.js.map