genesis-ai-cli 7.4.5

package/dist/test/cli/dispatcher.test.js

@@ -0,0 +1,332 @@
+"use strict";
+/**
+ * Tests for Genesis Tool Dispatcher
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const node_assert_1 = __importDefault(require("node:assert"));
+const dispatcher_js_1 = require("../../src/cli/dispatcher.js");
+(0, node_test_1.describe)('ToolDispatcher', () => {
+    (0, node_test_1.beforeEach)(() => {
+        (0, dispatcher_js_1.resetDispatcher)();
+    });
+    // ==========================================================================
+    // Parsing Tests
+    // ==========================================================================
+    (0, node_test_1.describe)('Parsing', () => {
+        (0, node_test_1.it)('should parse OpenAI-style tool calls', () => {
+            const dispatcher = (0, dispatcher_js_1.getDispatcher)();
+            const llmCalls = [
+                {
+                    id: 'call_1',
+                    type: 'function',
+                    function: {
+                        name: 'bash',
+                        arguments: '{"command": "ls -la"}',
+                    },
+                },
+                {
+                    id: 'call_2',
+                    type: 'function',
+                    function: {
+                        name: 'edit',
+                        arguments: '{"file_path": "test.ts", "old_string": "foo", "new_string": "bar"}',
+                    },
+                },
+            ];
+            const calls = dispatcher.parseToolCalls(llmCalls);
+            node_assert_1.default.strictEqual(calls.length, 2);
+            node_assert_1.default.strictEqual(calls[0].name, 'bash');
+            node_assert_1.default.strictEqual(calls[0].params.command, 'ls -la');
+            node_assert_1.default.strictEqual(calls[1].name, 'edit');
+            node_assert_1.default.strictEqual(calls[1].params.file_path, 'test.ts');
+        });
+        (0, node_test_1.it)('should parse XML-style tool calls', () => {
+            const dispatcher = (0, dispatcher_js_1.getDispatcher)();
+            const text = `
+        Let me run a command for you.
+        <tool_use name="bash">
+          <param name="command">echo "hello"</param>
+        </tool_use>
+      `;
+            const calls = dispatcher.parseToolCalls(text);
+            node_assert_1.default.strictEqual(calls.length, 1);
+            node_assert_1.default.strictEqual(calls[0].name, 'bash');
+            node_assert_1.default.strictEqual(calls[0].params.command, 'echo "hello"');
+        });
+        (0, node_test_1.it)('should parse invoke-style tool calls', () => {
+            const dispatcher = (0, dispatcher_js_1.getDispatcher)();
+            const text = `
+        <invoke name="git_status">
+          <param name="cwd">/tmp</param>
+        </invoke>
+      `;
+            const calls = dispatcher.parseToolCalls(text);
+            node_assert_1.default.strictEqual(calls.length, 1);
+            node_assert_1.default.strictEqual(calls[0].name, 'git_status');
+            node_assert_1.default.strictEqual(calls[0].params.cwd, '/tmp');
+        });
+        (0, node_test_1.it)('should parse JSON-style tool calls', () => {
+            const dispatcher = (0, dispatcher_js_1.getDispatcher)();
+            const text = `
+        I'll run this tool:
+        {"tool": "bash", "params": {"command": "pwd"}}
+      `;
+            const calls = dispatcher.parseToolCalls(text);
+            node_assert_1.default.strictEqual(calls.length, 1);
+            node_assert_1.default.strictEqual(calls[0].name, 'bash');
+            node_assert_1.default.strictEqual(calls[0].params.command, 'pwd');
+        });
+        (0, node_test_1.it)('should handle multiple tool calls in one response', () => {
+            const dispatcher = (0, dispatcher_js_1.getDispatcher)();
+            const text = `
+        <tool_use name="bash">
+          <param name="command">ls</param>
+        </tool_use>
+        <tool_use name="bash">
+          <param name="command">pwd</param>
+        </tool_use>
+      `;
+            const calls = dispatcher.parseToolCalls(text);
+            node_assert_1.default.strictEqual(calls.length, 2);
+        });
+        (0, node_test_1.it)('should handle empty response', () => {
+            const dispatcher = (0, dispatcher_js_1.getDispatcher)();
+            const calls = dispatcher.parseToolCalls('Just a plain response with no tools.');
+            node_assert_1.default.strictEqual(calls.length, 0);
+        });
+        (0, node_test_1.it)('should handle malformed tool calls gracefully', () => {
+            const dispatcher = (0, dispatcher_js_1.getDispatcher)();
+            const text = `
+        <tool_use name="bash">
+          invalid xml content without params
+        </tool_use>
+      `;
+            // Should not throw
+            const calls = dispatcher.parseToolCalls(text);
+            node_assert_1.default.ok(Array.isArray(calls));
+        });
+    });
+    // ==========================================================================
+    // Routing Tests
+    // ==========================================================================
+    (0, node_test_1.describe)('Routing', () => {
+        (0, node_test_1.it)('should route local tools correctly', () => {
+            const dispatcher = (0, dispatcher_js_1.getDispatcher)();
+            const calls = dispatcher.parseToolCalls([
+                {
+                    id: 'call_1',
+                    type: 'function',
+                    function: { name: 'bash', arguments: '{}' },
+                },
+                {
+                    id: 'call_2',
+                    type: 'function',
+                    function: { name: 'edit', arguments: '{}' },
+                },
+                {
+                    id: 'call_3',
+                    type: 'function',
+                    function: { name: 'git_status', arguments: '{}' },
+                },
+            ]);
+            node_assert_1.default.strictEqual(calls[0].source, 'local');
+            node_assert_1.default.strictEqual(calls[1].source, 'local');
+            node_assert_1.default.strictEqual(calls[2].source, 'local');
+        });
+        (0, node_test_1.it)('should route MCP tools correctly', () => {
+            const dispatcher = (0, dispatcher_js_1.getDispatcher)();
+            const calls = dispatcher.parseToolCalls([
+                {
+                    id: 'call_1',
+                    type: 'function',
+                    function: { name: 'search_arxiv', arguments: '{}' },
+                },
+                {
+                    id: 'call_2',
+                    type: 'function',
+                    function: { name: 'wolfram_query', arguments: '{}' },
+                },
+            ]);
+            node_assert_1.default.strictEqual(calls[0].source, 'mcp');
+            node_assert_1.default.strictEqual(calls[0].mcpServer, 'arxiv');
+            node_assert_1.default.strictEqual(calls[1].source, 'mcp');
+            node_assert_1.default.strictEqual(calls[1].mcpServer, 'wolfram');
+        });
+        (0, node_test_1.it)('should default unknown tools to local', () => {
+            const dispatcher = (0, dispatcher_js_1.getDispatcher)();
+            const calls = dispatcher.parseToolCalls([
+                {
+                    id: 'call_1',
+                    type: 'function',
+                    function: { name: 'unknown_tool', arguments: '{}' },
+                },
+            ]);
+            node_assert_1.default.strictEqual(calls[0].source, 'local');
+        });
+    });
+    // ==========================================================================
+    // Execution Tests
+    // ==========================================================================
+    (0, node_test_1.describe)('Execution', () => {
+        (0, node_test_1.it)('should execute local tools successfully', async () => {
+            const dispatcher = (0, dispatcher_js_1.getDispatcher)();
+            const calls = [
+                {
+                    id: 'call_1',
+                    name: 'bash',
+                    params: { command: 'echo "test"' },
+                    source: 'local',
+                },
+            ];
+            const result = await dispatcher.dispatch(calls);
+            node_assert_1.default.ok(result.results.length > 0);
+            node_assert_1.default.strictEqual(result.results[0].name, 'bash');
+            // May or may not succeed depending on sandbox
+        });
+        (0, node_test_1.it)('should handle failed validation', async () => {
+            const dispatcher = (0, dispatcher_js_1.getDispatcher)();
+            const calls = [
+                {
+                    id: 'call_1',
+                    name: 'edit',
+                    params: {}, // Missing required params
+                    source: 'local',
+                },
+            ];
+            const result = await dispatcher.dispatch(calls);
+            node_assert_1.default.strictEqual(result.results[0].success, false);
+            node_assert_1.default.ok(result.results[0].error);
+        });
+        (0, node_test_1.it)('should handle unknown tools gracefully', async () => {
+            const dispatcher = (0, dispatcher_js_1.getDispatcher)();
+            const calls = [
+                {
+                    id: 'call_1',
+                    name: 'nonexistent_tool',
+                    params: {},
+                    source: 'local',
+                },
+            ];
+            const result = await dispatcher.dispatch(calls);
+            node_assert_1.default.strictEqual(result.results[0].success, false);
+            node_assert_1.default.ok(result.results[0].error?.includes('Unknown tool'));
+        });
+        (0, node_test_1.it)('should track execution duration', async () => {
+            const dispatcher = (0, dispatcher_js_1.getDispatcher)();
+            const calls = [
+                {
+                    id: 'call_1',
+                    name: 'bash',
+                    params: { command: 'echo "test"' },
+                    source: 'local',
+                },
+            ];
+            const result = await dispatcher.dispatch(calls);
+            node_assert_1.default.ok(result.totalDuration >= 0);
+            node_assert_1.default.ok(result.results[0].duration >= 0);
+        });
+        (0, node_test_1.it)('should support parallel execution', async () => {
+            const dispatcher = (0, dispatcher_js_1.getDispatcher)({ maxParallel: 3 });
+            const calls = [
+                { id: 'call_1', name: 'bash', params: { command: 'echo 1' }, source: 'local' },
+                { id: 'call_2', name: 'bash', params: { command: 'echo 2' }, source: 'local' },
+                { id: 'call_3', name: 'bash', params: { command: 'echo 3' }, source: 'local' },
+            ];
+            const result = await dispatcher.dispatch(calls);
+            node_assert_1.default.strictEqual(result.results.length, 3);
+            node_assert_1.default.ok(result.parallelExecutions >= 1);
+        });
+    });
+    // ==========================================================================
+    // History Tests
+    // ==========================================================================
+    (0, node_test_1.describe)('History', () => {
+        (0, node_test_1.it)('should track execution history', async () => {
+            const dispatcher = (0, dispatcher_js_1.getDispatcher)();
+            await dispatcher.dispatch([
+                { id: 'call_1', name: 'bash', params: { command: 'echo 1' }, source: 'local' },
+            ]);
+            await dispatcher.dispatch([
+                { id: 'call_2', name: 'bash', params: { command: 'echo 2' }, source: 'local' },
+            ]);
+            const history = dispatcher.getHistory();
+            node_assert_1.default.strictEqual(history.length, 2);
+        });
+        (0, node_test_1.it)('should clear history', async () => {
+            const dispatcher = (0, dispatcher_js_1.getDispatcher)();
+            await dispatcher.dispatch([
+                { id: 'call_1', name: 'bash', params: { command: 'echo 1' }, source: 'local' },
+            ]);
+            dispatcher.clearHistory();
+            node_assert_1.default.strictEqual(dispatcher.getHistory().length, 0);
+        });
+    });
+    // ==========================================================================
+    // Formatting Tests
+    // ==========================================================================
+    (0, node_test_1.describe)('Formatting', () => {
+        (0, node_test_1.it)('should format results for LLM context', async () => {
+            const dispatcher = (0, dispatcher_js_1.getDispatcher)();
+            const result = await dispatcher.dispatch([
+                { id: 'call_1', name: 'bash', params: { command: 'echo "hello"' }, source: 'local' },
+            ]);
+            const formatted = dispatcher.formatResultsForLLM(result.results);
+            node_assert_1.default.ok(formatted.includes('<tool_results>'));
+            node_assert_1.default.ok(formatted.includes('</tool_results>'));
+            node_assert_1.default.ok(formatted.includes('name="bash"'));
+        });
+    });
+    // ==========================================================================
+    // Tool Listing Tests
+    // ==========================================================================
+    (0, node_test_1.describe)('Tool Listing', () => {
+        (0, node_test_1.it)('should list available tools', () => {
+            const tools = (0, dispatcher_js_1.listAllTools)();
+            node_assert_1.default.ok(tools.local.includes('bash'));
+            node_assert_1.default.ok(tools.local.includes('edit'));
+            node_assert_1.default.ok(Object.keys(tools.mcp).includes('arxiv'));
+        });
+    });
+    // ==========================================================================
+    // Convenience Functions
+    // ==========================================================================
+    (0, node_test_1.describe)('Convenience Functions', () => {
+        (0, node_test_1.it)('dispatchTools should work with string input', async () => {
+            const text = `
+        <tool_use name="bash">
+          <param name="command">echo test</param>
+        </tool_use>
+      `;
+            const result = await (0, dispatcher_js_1.dispatchTools)(text);
+            node_assert_1.default.ok(result.results.length > 0);
+        });
+        (0, node_test_1.it)('executeTool should work', async () => {
+            const result = await (0, dispatcher_js_1.executeTool)('bash', { command: 'echo "hello"' });
+            node_assert_1.default.strictEqual(result.name, 'bash');
+            // Success depends on sandbox config
+        });
+    });
+    // ==========================================================================
+    // Progress Callback Tests
+    // ==========================================================================
+    (0, node_test_1.describe)('Progress Callback', () => {
+        (0, node_test_1.it)('should call progress callback', async () => {
+            const progressCalls = [];
+            const dispatcher = new dispatcher_js_1.ToolDispatcher({
+                onProgress: (status) => {
+                    progressCalls.push(status.phase);
+                },
+            });
+            await dispatcher.dispatch([
+                { id: 'call_1', name: 'bash', params: { command: 'echo 1' }, source: 'local' },
+            ]);
+            node_assert_1.default.ok(progressCalls.includes('validating'));
+            node_assert_1.default.ok(progressCalls.includes('executing'));
+            node_assert_1.default.ok(progressCalls.includes('complete'));
+        });
+    });
+});

package/dist/test/cli/human-loop.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for Genesis Human-in-the-Loop Module
+ */
+export {};

package/dist/test/cli/human-loop.test.js

@@ -0,0 +1,270 @@
+"use strict";
+/**
+ * Tests for Genesis Human-in-the-Loop Module
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const node_assert_1 = __importDefault(require("node:assert"));
+const human_loop_js_1 = require("../../src/cli/human-loop.js");
+const index_js_1 = require("../../src/tools/index.js");
+(0, node_test_1.describe)('HumanLoop', () => {
+    (0, node_test_1.beforeEach)(() => {
+        (0, human_loop_js_1.resetHumanLoop)();
+    });
+    // ==========================================================================
+    // Configuration Tests
+    // ==========================================================================
+    (0, node_test_1.describe)('Configuration', () => {
+        (0, node_test_1.it)('should use default configuration', () => {
+            const hl = new human_loop_js_1.HumanLoop();
+            node_assert_1.default.ok(hl);
+        });
+        (0, node_test_1.it)('should accept custom configuration', () => {
+            const hl = new human_loop_js_1.HumanLoop({
+                defaultTimeout: 5000,
+                allowSkip: false,
+                useColors: false,
+            });
+            node_assert_1.default.ok(hl);
+        });
+    });
+    // ==========================================================================
+    // Question Types
+    // ==========================================================================
+    (0, node_test_1.describe)('Question Types', () => {
+        (0, node_test_1.it)('should support confirm type', () => {
+            const question = {
+                type: 'confirm',
+                text: 'Do you want to proceed?',
+                default: true,
+            };
+            node_assert_1.default.strictEqual(question.type, 'confirm');
+            node_assert_1.default.strictEqual(question.default, true);
+        });
+        (0, node_test_1.it)('should support choice type with options', () => {
+            const options = [
+                { value: 'a', label: 'Option A', description: 'First option' },
+                { value: 'b', label: 'Option B', recommended: true },
+                { value: 'c', label: 'Option C' },
+            ];
+            const question = {
+                type: 'choice',
+                text: 'Choose one:',
+                options,
+            };
+            node_assert_1.default.strictEqual(question.options?.length, 3);
+            node_assert_1.default.ok(question.options?.[1].recommended);
+        });
+        (0, node_test_1.it)('should support multiChoice type', () => {
+            const question = {
+                type: 'multiChoice',
+                text: 'Select all that apply:',
+                options: [
+                    { value: '1', label: 'One' },
+                    { value: '2', label: 'Two' },
+                    { value: '3', label: 'Three' },
+                ],
+            };
+            node_assert_1.default.strictEqual(question.type, 'multiChoice');
+        });
+        (0, node_test_1.it)('should support text type', () => {
+            const question = {
+                type: 'text',
+                text: 'Enter your name:',
+                default: 'Anonymous',
+            };
+            node_assert_1.default.strictEqual(question.type, 'text');
+            node_assert_1.default.strictEqual(question.default, 'Anonymous');
+        });
+        (0, node_test_1.it)('should support context', () => {
+            const question = {
+                type: 'confirm',
+                text: 'Proceed?',
+                context: 'This will delete 10 files.',
+            };
+            node_assert_1.default.strictEqual(question.context, 'This will delete 10 files.');
+        });
+    });
+    // ==========================================================================
+    // History & Stats
+    // ==========================================================================
+    (0, node_test_1.describe)('History & Stats', () => {
+        (0, node_test_1.it)('should track empty history initially', () => {
+            const hl = new human_loop_js_1.HumanLoop();
+            const history = hl.getHistory();
+            node_assert_1.default.strictEqual(history.length, 0);
+        });
+        (0, node_test_1.it)('should clear history', () => {
+            const hl = new human_loop_js_1.HumanLoop();
+            hl.clearHistory();
+            const history = hl.getHistory();
+            node_assert_1.default.strictEqual(history.length, 0);
+        });
+        (0, node_test_1.it)('should return stats', () => {
+            const hl = new human_loop_js_1.HumanLoop();
+            const stats = hl.stats();
+            node_assert_1.default.strictEqual(stats.totalQuestions, 0);
+            node_assert_1.default.strictEqual(stats.responded, 0);
+            node_assert_1.default.strictEqual(stats.timedOut, 0);
+            node_assert_1.default.strictEqual(stats.cancelled, 0);
+            node_assert_1.default.strictEqual(stats.avgResponseTime, 0);
+        });
+    });
+    // ==========================================================================
+    // Singleton Tests
+    // ==========================================================================
+    (0, node_test_1.describe)('Singleton', () => {
+        (0, node_test_1.it)('should return same instance', () => {
+            const hl1 = (0, human_loop_js_1.getHumanLoop)();
+            const hl2 = (0, human_loop_js_1.getHumanLoop)();
+            node_assert_1.default.strictEqual(hl1, hl2);
+        });
+        (0, node_test_1.it)('should reset singleton', () => {
+            const hl1 = (0, human_loop_js_1.getHumanLoop)();
+            (0, human_loop_js_1.resetHumanLoop)();
+            const hl2 = (0, human_loop_js_1.getHumanLoop)();
+            node_assert_1.default.notStrictEqual(hl1, hl2);
+        });
+    });
+    // ==========================================================================
+    // Tool Registration
+    // ==========================================================================
+    (0, node_test_1.describe)('Tool Registration', () => {
+        (0, node_test_1.it)('should register ask_user tool', () => {
+            const tool = index_js_1.toolRegistry.get('ask_user');
+            node_assert_1.default.ok(tool);
+            node_assert_1.default.strictEqual(tool.name, 'ask_user');
+            node_assert_1.default.ok(tool.description.includes('Ask the user'));
+        });
+        (0, node_test_1.it)('should register confirm tool', () => {
+            const tool = index_js_1.toolRegistry.get('confirm');
+            node_assert_1.default.ok(tool);
+            node_assert_1.default.strictEqual(tool.name, 'confirm');
+        });
+        (0, node_test_1.it)('ask_user should validate params', () => {
+            const tool = index_js_1.toolRegistry.get('ask_user');
+            // Missing text
+            const invalid = tool?.validate?.({});
+            node_assert_1.default.strictEqual(invalid?.valid, false);
+            // Valid
+            const valid = tool?.validate?.({ text: 'Question?' });
+            node_assert_1.default.strictEqual(valid?.valid, true);
+        });
+    });
+    // ==========================================================================
+    // Question Option Tests
+    // ==========================================================================
+    (0, node_test_1.describe)('Question Options', () => {
+        (0, node_test_1.it)('should support recommended option', () => {
+            const options = [
+                { value: 'safe', label: 'Safe approach', recommended: true },
+                { value: 'fast', label: 'Fast approach' },
+            ];
+            const recommended = options.find(o => o.recommended);
+            node_assert_1.default.ok(recommended);
+            node_assert_1.default.strictEqual(recommended.value, 'safe');
+        });
+        (0, node_test_1.it)('should support option descriptions', () => {
+            const options = [
+                { value: 'a', label: 'A', description: 'This is option A' },
+                { value: 'b', label: 'B', description: 'This is option B' },
+            ];
+            node_assert_1.default.strictEqual(options[0].description, 'This is option A');
+        });
+    });
+    // ==========================================================================
+    // Answer Structure Tests
+    // ==========================================================================
+    (0, node_test_1.describe)('Answer Structure', () => {
+        (0, node_test_1.it)('should have correct answer structure', () => {
+            // Simulated answer
+            const answer = {
+                question: {
+                    type: 'confirm',
+                    text: 'Test?',
+                },
+                value: true,
+                responded: true,
+                responseTime: 1500,
+            };
+            node_assert_1.default.strictEqual(answer.value, true);
+            node_assert_1.default.strictEqual(answer.responded, true);
+            node_assert_1.default.ok(answer.responseTime >= 0);
+        });
+        (0, node_test_1.it)('should track timeout', () => {
+            const answer = {
+                question: { type: 'confirm', text: 'Test?' },
+                value: false,
+                responded: false,
+                timedOut: true,
+                responseTime: 5000,
+            };
+            node_assert_1.default.strictEqual(answer.timedOut, true);
+            node_assert_1.default.strictEqual(answer.responded, false);
+        });
+        (0, node_test_1.it)('should track cancellation', () => {
+            const answer = {
+                question: { type: 'choice', text: 'Choose?' },
+                value: '',
+                responded: true,
+                cancelled: true,
+                responseTime: 500,
+            };
+            node_assert_1.default.strictEqual(answer.cancelled, true);
+            node_assert_1.default.strictEqual(answer.value, '');
+        });
+    });
+    // ==========================================================================
+    // Integration Tests (mocked)
+    // ==========================================================================
+    (0, node_test_1.describe)('Integration', () => {
+        (0, node_test_1.it)('should support callback on response', () => {
+            let callbackCalled = false;
+            const hl = new human_loop_js_1.HumanLoop({
+                onResponse: (answer) => {
+                    callbackCalled = true;
+                },
+            });
+            // We can't actually test interactive input here,
+            // but we can verify the callback is set up correctly
+            node_assert_1.default.ok(hl);
+        });
+        (0, node_test_1.it)('should close cleanly', () => {
+            const hl = new human_loop_js_1.HumanLoop();
+            hl.close();
+            // Should not throw
+            node_assert_1.default.ok(true);
+        });
+    });
+    // ==========================================================================
+    // Destructive Operation Tests
+    // ==========================================================================
+    (0, node_test_1.describe)('Destructive Operations', () => {
+        (0, node_test_1.it)('should format destructive warning', () => {
+            // This tests the structure of destructive confirmations
+            const operation = 'Delete all files';
+            const details = '10 files will be permanently removed';
+            // Just verify the strings are valid
+            node_assert_1.default.ok(operation.length > 0);
+            node_assert_1.default.ok(details.length > 0);
+        });
+    });
+    // ==========================================================================
+    // Approach Selection Tests
+    // ==========================================================================
+    (0, node_test_1.describe)('Approach Selection', () => {
+        (0, node_test_1.it)('should format approach options', () => {
+            const task = 'Implement authentication';
+            const approaches = [
+                { name: 'JWT', description: 'Token-based auth', recommended: true },
+                { name: 'Session', description: 'Server-side sessions' },
+                { name: 'OAuth', description: 'Third-party providers' },
+            ];
+            node_assert_1.default.strictEqual(approaches.length, 3);
+            node_assert_1.default.ok(approaches.find(a => a.recommended));
+        });
+    });
+});

package/dist/test/grounding/feedback.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for Genesis Grounding Feedback Loop
+ */
+export {};