stigmergy 1.0.68 → 1.0.70

package/test/natural-language-skills-test.js

@@ -0,0 +1,320 @@
+#!/usr/bin/env node
+
+/**
+ * TDD Test Suite for Natural Language Skills Calling
+ * Tests natural language parsing and skill mapping functionality
+ */
+
+const assert = require('assert');
+
+/**
+ * Test scenarios for natural language to skills mapping
+ */
+
+// Test 1: Translation skill detection patterns
+function testTranslationSkillDetection() {
+    console.log('TEST 1: Translation Skill Detection');
+    console.log('-----------------------------------');
+
+    const testCases = [
+        {
+            input: "请帮我把这段中文翻译成英文",
+            expectedSkill: 'translation',
+            expectedParams: { to: 'en', text: '这段中文' },
+            description: 'Chinese to English translation'
+        },
+        {
+            input: "Translate this code comment to Spanish",
+            expectedSkill: 'translation',
+            expectedParams: { to: 'es', text: 'this code comment' },
+            description: 'English to Spanish translation'
+        },
+        {
+            input: "能把这段说明翻译成日语吗？",
+            expectedSkill: 'translation',
+            expectedParams: { to: 'ja', text: '这段说明' },
+            description: 'Chinese to Japanese translation'
+        }
+    ];
+
+    return testCases;
+}
+
+// Test 2: Code analysis skill detection patterns
+function testCodeAnalysisSkillDetection() {
+    console.log('TEST 2: Code Analysis Skill Detection');
+    console.log('--------------------------------------');
+
+    const testCases = [
+        {
+            input: "请分析这个React组件的安全性",
+            expectedSkill: 'code-analysis',
+            expectedParams: { focus: 'security', file: 'React组件' },
+            description: 'React component security analysis'
+        },
+        {
+            input: "Can you analyze the performance of this algorithm?",
+            expectedSkill: 'code-analysis',
+            expectedParams: { focus: 'performance', file: 'this algorithm' },
+            description: 'Algorithm performance analysis'
+        },
+        {
+            input: "检查一下这段代码有没有bug",
+            expectedSkill: 'code-analysis',
+            expectedParams: { focus: 'bugs', file: '这段代码' },
+            description: 'Bug detection in code'
+        }
+    ];
+
+    return testCases;
+}
+
+// Test 3: Code generation skill detection patterns
+function testCodeGenerationSkillDetection() {
+    console.log('TEST 3: Code Generation Skill Detection');
+    console.log('----------------------------------------');
+
+    const testCases = [
+        {
+            input: "请生成一个用户登录的Python代码",
+            expectedSkill: 'code-generation',
+            expectedParams: { requirement: '用户登录', language: 'python' },
+            description: 'Python login code generation'
+        },
+        {
+            input: "帮我写一个React的用户认证组件",
+            expectedSkill: 'code-generation',
+            expectedParams: { requirement: '用户认证组件', framework: 'react' },
+            description: 'React authentication component'
+        }
+    ];
+
+    return testCases;
+}
+
+// Test 4: Documentation skill detection patterns
+function testDocumentationSkillDetection() {
+    console.log('TEST 4: Documentation Skill Detection');
+    console.log('-------------------------------------');
+
+    const testCases = [
+        {
+            input: "请为这个API生成文档",
+            expectedSkill: 'documentation',
+            expectedParams: { target: 'API', format: 'markdown' },
+            description: 'API documentation generation'
+        },
+        {
+            input: "帮我把这个函数写个注释",
+            expectedSkill: 'documentation',
+            expectedParams: { target: '函数', format: 'comments' },
+            description: 'Function comments generation'
+        }
+    ];
+
+    return testCases;
+}
+
+// Test 5: Natural Language Parser Implementation (will fail initially)
+function testNaturalLanguageParser() {
+    console.log('TEST 5: Natural Language Parser');
+    console.log('---------------------------------');
+
+    try {
+        // This will fail initially since we haven't implemented it yet
+        const NaturalLanguageParser = require('../package/src/natural-language/nl-parser.cjs');
+        const parser = new NaturalLanguageParser();
+
+        const testInput = "请帮我把这段代码翻译成英文";
+        const result = parser.parse(testInput);
+
+        assert(result.skill === 'translation', 'Should detect translation skill');
+        assert(result.parameters.to === 'en', 'Should detect target language');
+        assert(result.parameters.text, 'Should extract text to translate');
+
+        console.log('✅ Natural language parser test passed');
+        return true;
+    } catch (error) {
+        console.log(`❌ Natural language parser test failed: ${error.message}`);
+        return false;
+    }
+}
+
+// Test 6: Skill mapping accuracy
+function testSkillMappingAccuracy() {
+    console.log('TEST 6: Skill Mapping Accuracy');
+    console.log('--------------------------------');
+
+    const accuracyTests = [
+        {
+            inputs: [
+                "翻译这段文字",
+                "translate this text",
+                "把这个翻译成英文",
+                "Can you translate this to French?"
+            ],
+            expectedSkill: 'translation',
+            description: 'Translation keyword variations'
+        },
+        {
+            inputs: [
+                "分析这个代码",
+                "analyze this security issue",
+                "检查性能",
+                "review this code"
+            ],
+            expectedSkill: 'code-analysis',
+            description: 'Analysis keyword variations'
+        },
+        {
+            inputs: [
+                "生成代码",
+                "write a function",
+                "create a component",
+                "实现一个功能"
+            ],
+            expectedSkill: 'code-generation',
+            description: 'Generation keyword variations'
+        }
+    ];
+
+    return accuracyTests;
+}
+
+// Test 7: Context-aware parameter extraction
+function testContextAwareParameterExtraction() {
+    console.log('TEST 7: Context-Aware Parameter Extraction');
+    console.log('--------------------------------------------');
+
+    const extractionTests = [
+        {
+            input: "把这个React组件的性能优化一下",
+            expectedParams: {
+                framework: 'react',
+                focus: 'performance',
+                target: '组件'
+            },
+            description: 'React performance optimization parameters'
+        },
+        {
+            input: "请为这个Python API生成安全文档",
+            expectedParams: {
+                language: 'python',
+                target: 'API',
+                focus: 'security',
+                type: 'documentation'
+            },
+            description: 'Python API security documentation'
+        }
+    ];
+
+    return extractionTests;
+}
+
+// Test runner
+function runTests() {
+    console.log('==============================================');
+    console.log('TDD: NATURAL LANGUAGE SKILLS CALLING');
+    console.log('==============================================');
+    console.log('');
+
+    const results = [];
+
+    // Show test scenarios (will drive implementation)
+    console.log('📝 TEST SCENARIOS TO IMPLEMENT:');
+    console.log('');
+
+    // Test 1: Translation patterns
+    const translationTests = testTranslationSkillDetection();
+    console.log('1. Translation Skill Detection:');
+    translationTests.forEach(test => {
+        console.log(`   Input: "${test.input}"`);
+        console.log(`   Expected: ${test.expectedSkill} with params ${JSON.stringify(test.expectedParams)}`);
+        console.log('');
+    });
+
+    // Test 2: Analysis patterns
+    const analysisTests = testCodeAnalysisSkillDetection();
+    console.log('2. Code Analysis Skill Detection:');
+    analysisTests.forEach(test => {
+        console.log(`   Input: "${test.input}"`);
+        console.log(`   Expected: ${test.expectedSkill} with params ${JSON.stringify(test.expectedParams)}`);
+        console.log('');
+    });
+
+    // Test 3: Generation patterns
+    const generationTests = testCodeGenerationSkillDetection();
+    console.log('3. Code Generation Skill Detection:');
+    generationTests.forEach(test => {
+        console.log(`   Input: "${test.input}"`);
+        console.log(`   Expected: ${test.expectedSkill} with params ${JSON.stringify(test.expectedParams)}`);
+        console.log('');
+    });
+
+    // Test 4: Documentation patterns
+    const documentationTests = testDocumentationSkillDetection();
+    console.log('4. Documentation Skill Detection:');
+    documentationTests.forEach(test => {
+        console.log(`   Input: "${test.input}"`);
+        console.log(`   Expected: ${test.expectedSkill} with params ${JSON.stringify(test.expectedParams)}`);
+        console.log('');
+    });
+
+    // Test 5: Parser implementation (will fail initially)
+    results.push(testNaturalLanguageParser());
+    console.log('');
+
+    // Test 6: Accuracy tests
+    const accuracyTests = testSkillMappingAccuracy();
+    console.log('6. Skill Mapping Accuracy Tests:');
+    accuracyTests.forEach(test => {
+        console.log(`   ${test.description}:`);
+        test.inputs.forEach(input => {
+            console.log(`     - "${input}" → should map to ${test.expectedSkill}`);
+        });
+        console.log('');
+    });
+
+    // Test 7: Context extraction
+    const extractionTests = testContextAwareParameterExtraction();
+    console.log('7. Context-Aware Parameter Extraction:');
+    extractionTests.forEach(test => {
+        console.log(`   Input: "${test.input}"`);
+        console.log(`   Expected params: ${JSON.stringify(test.expectedParams)}`);
+        console.log('');
+    });
+
+    // Summary
+    const passed = results.filter(r => r === true).length;
+    const total = results.length;
+
+    console.log('==============================================');
+    console.log('TDD TEST SUMMARY');
+    console.log('==============================================');
+    console.log(`Parser tests passed: ${passed}/${total}`);
+    console.log('');
+
+    if (passed === total) {
+        console.log('🎉 All tests passed! Natural language skills calling is ready.');
+    } else {
+        console.log('⚠️  Parser implementation needed. Time to implement based on these test scenarios!');
+    }
+
+    return passed === total;
+}
+
+// Run tests if called directly
+if (require.main === module) {
+    runTests();
+}
+
+module.exports = {
+    testTranslationSkillDetection,
+    testCodeAnalysisSkillDetection,
+    testCodeGenerationSkillDetection,
+    testDocumentationSkillDetection,
+    testNaturalLanguageParser,
+    testSkillMappingAccuracy,
+    testContextAwareParameterExtraction,
+    runTests
+};

package/test/nl-integration-test.js

@@ -0,0 +1,179 @@
+#!/usr/bin/env node
+
+/**
+ * TDD Test for Natural Language Integration
+ * Tests the integration between natural language parsing and CLI tools
+ */
+
+const assert = require('assert');
+
+async function testNaturalLanguageIntegration() {
+    console.log('TEST: Natural Language Integration');
+    console.log('----------------------------------');
+
+    try {
+        const NaturalLanguageIntegration = require('../package/src/natural-language/nl-integration.cjs');
+        const integration = new NaturalLanguageIntegration();
+
+        // Test 1: Basic natural language processing
+        console.log('Test 1: Basic natural language processing');
+        const result1 = await integration.processNaturalLanguageInput("请帮我把这段中文翻译成英文", "claude");
+
+        assert(result1.success === true, 'Should successfully process translation request');
+        assert(result1.skill === 'translation', 'Should detect translation skill');
+        assert(result1.parameters.to === 'en', 'Should detect target language');
+        console.log('✅ Basic natural language processing test passed');
+
+        // Test 2: Multi-language support
+        console.log('Test 2: Multi-language support');
+        const result2 = await integration.processNaturalLanguageInput("Analyze the security of this React component", "gemini");
+
+        assert(result2.success === true, 'Should process English input');
+        assert(result2.skill === 'code-analysis', 'Should detect code analysis skill');
+        assert(result2.parameters.focus === 'security', 'Should detect security focus');
+        console.log('✅ Multi-language support test passed');
+
+        // Test 3: Skill detection confidence
+        console.log('Test 3: Skill detection confidence');
+        const result3 = await integration.processNaturalLanguageInput("Generate Python code for user login", "qwen");
+
+        assert(result3.confidence > 5, 'Should have high confidence for clear patterns');
+        assert(result3.parameters.language === 'python', 'Should extract programming language');
+        console.log('✅ Skill detection confidence test passed');
+
+        // Test 4: Hook response creation
+        console.log('Test 4: Hook response creation');
+        const hookResponse = integration.createHookResponse("translate this to Spanish", "claude");
+
+        assert(hookResponse.shouldIntercept === true, 'Should intercept skill requests');
+        assert(hookResponse.skill === 'translation', 'Should identify correct skill');
+        assert(hookResponse.options.includes('execute_skill'), 'Should provide execution option');
+        console.log('✅ Hook response creation test passed');
+
+        // Test 5: CLI command processing
+        console.log('Test 5: CLI command processing');
+        const cliResult = await integration.processCliCommand(['analyze', 'this', 'code', 'for', 'security'], 'gemini');
+
+        assert(cliResult.success === true, 'Should process CLI command successfully');
+        assert(cliResult.skill === 'code-analysis', 'Should detect skill from CLI args');
+        console.log('✅ CLI command processing test passed');
+
+        // Test 6: Help message generation
+        console.log('Test 6: Help message generation');
+        const helpMessage = integration.createEnhancedHelp('claude');
+
+        assert(helpMessage.includes('Natural Language Skills'), 'Should include integration info');
+        assert(helpMessage.includes('translate'), 'Should include translation examples');
+        console.log('✅ Help message generation test passed');
+
+        console.log('✅ Natural language integration test passed');
+        return true;
+
+    } catch (error) {
+        console.log(`❌ Natural language integration test failed: ${error.message}`);
+        return false;
+    }
+}
+
+async function testEndToEndScenarios() {
+    console.log('TEST: End-to-End Natural Language Scenarios');
+    console.log('---------------------------------------------');
+
+    try {
+        const NaturalLanguageIntegration = require('../package/src/natural-language/nl-integration.cjs');
+        const integration = new NaturalLanguageIntegration();
+
+        const scenarios = [
+            {
+                name: 'Chinese to English Translation',
+                input: '请帮我把这段API文档翻译成英文',
+                expectedSkill: 'translation',
+                expectedParams: { to: 'en', text: '这段API文档' }
+            },
+            {
+                name: 'React Component Analysis',
+                input: '分析这个React组件的性能问题',
+                expectedSkill: 'code-analysis',
+                expectedParams: { focus: 'performance', file: 'React组件' }
+            },
+            {
+                name: 'Python Code Generation',
+                input: '生成一个用户认证的Python函数',
+                expectedSkill: 'code-generation',
+                expectedParams: { requirement: '用户认证函数', language: 'python' }
+            }
+        ];
+
+        let passed = 0;
+        for (const scenario of scenarios) {
+            console.log(`\nTesting scenario: ${scenario.name}`);
+            console.log(`Input: "${scenario.input}"`);
+
+            const result = await integration.processNaturalLanguageInput(scenario.input, 'claude');
+
+            if (result.success &&
+                result.skill === scenario.expectedSkill) {
+                console.log(`✅ Passed: Detected ${result.skill} with confidence ${result.confidence}`);
+                passed++;
+            } else {
+                console.log(`❌ Failed: Expected ${scenario.expectedSkill}, got ${result.skill || 'none'}`);
+            }
+        }
+
+        console.log(`\nEnd-to-end scenarios: ${passed}/${scenarios.length} passed`);
+        return passed === scenarios.length;
+
+    } catch (error) {
+        console.log(`❌ End-to-end scenarios test failed: ${error.message}`);
+        return false;
+    }
+}
+
+// Main test runner
+async function runTests() {
+    console.log('==============================================');
+    console.log('TDD: NATURAL LANGUAGE INTEGRATION');
+    console.log('==============================================');
+    console.log('');
+
+    const results = [];
+
+    // Test 1: Natural language integration
+    results.push(await testNaturalLanguageIntegration());
+    console.log('');
+
+    // Test 2: End-to-end scenarios
+    results.push(await testEndToEndScenarios());
+    console.log('');
+
+    // Summary
+    const passed = results.filter(r => r === true).length;
+    const total = results.length;
+
+    console.log('==============================================');
+    console.log('TDD INTEGRATION TEST SUMMARY');
+    console.log('==============================================');
+    console.log(`Integration tests passed: ${passed}/${total}`);
+
+    if (passed === total) {
+        console.log('🎉 All integration tests passed!');
+        console.log('✅ Natural language skills integration is ready for CLI tools!');
+    } else {
+        console.log('⚠️  Some integration tests failed. Review implementation.');
+    }
+
+    return passed === total;
+}
+
+// Run tests if called directly
+if (require.main === module) {
+    runTests().then(success => {
+        process.exit(success ? 0 : 1);
+    });
+}
+
+module.exports = {
+    testNaturalLanguageIntegration,
+    testEndToEndScenarios,
+    runTests
+};

package/test/parameter-parsing-test.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+
+/**
+ * TDD Test for Parameter Parsing Function
+ * Tests that will drive the implementation of proper parameter parsing
+ */
+
+const assert = require('assert');
+
+/**
+ * Parse command line arguments into parameters and tool selection
+ * @param {string[]} args - Array of command line arguments
+ * @returns {Object} - { parameters: {}, tool: string|null }
+ */
+function parseArguments(args) {
+    const parameters = {};
+    let tool = null;
+
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+
+        if (arg.startsWith('--')) {
+            if (arg.includes('=')) {
+                // Format: --key=value
+                const [key, value] = arg.substring(2).split('=', 2);
+                if (key === 'tool') {
+                    tool = value;
+                } else {
+                    parameters[key] = value;
+                }
+            } else {
+                // Format: --key value
+                const key = arg.substring(2);
+                if (key === 'tool') {
+                    tool = args[i + 1];
+                    i++; // Skip next argument as it's the value
+                } else if (i + 1 < args.length && !args[i + 1].startsWith('--')) {
+                    parameters[key] = args[i + 1];
+                    i++; // Skip next argument as it's the value
+                } else {
+                    parameters[key] = true;
+                }
+            }
+        }
+    }
+
+    return { parameters, tool };
+}
+
+function testParameterParsing() {
+    console.log('TEST: Parameter Parsing Function');
+    console.log('--------------------------------');
+
+    const testCases = [
+        {
+            name: 'Key=value format with tool',
+            args: ['--text=hello', '--to=zh', '--tool=claude'],
+            expected: {
+                parameters: { text: 'hello', to: 'zh' },
+                tool: 'claude'
+            }
+        },
+        {
+            name: 'Space-separated format with tool',
+            args: ['--text', 'hello', '--to', 'zh', '--tool', 'gemini'],
+            expected: {
+                parameters: { text: 'hello', to: 'zh' },
+                tool: 'gemini'
+            }
+        },
+        {
+            name: 'Mixed format',
+            args: ['--text=hello', '--to', 'zh', '--file=app.js', '--tool=qwen'],
+            expected: {
+                parameters: { text: 'hello', to: 'zh', file: 'app.js' },
+                tool: 'qwen'
+            }
+        },
+        {
+            name: 'No tool specified',
+            args: ['--text=hello', '--to=zh'],
+            expected: {
+                parameters: { text: 'hello', to: 'zh' },
+                tool: null
+            }
+        },
+        {
+            name: 'Boolean flags',
+            args: ['--verbose', '--debug=true', '--tool=claude'],
+            expected: {
+                parameters: { verbose: true, debug: 'true' },
+                tool: 'claude'
+            }
+        }
+    ];
+
+    let passed = 0;
+    let total = testCases.length;
+
+    for (const testCase of testCases) {
+        console.log(`\nTesting: ${testCase.name}`);
+        console.log(`Input: ${JSON.stringify(testCase.args)}`);
+
+        try {
+            const result = parseArguments(testCase.args);
+
+            // Deep comparison of results
+            const paramsMatch = JSON.stringify(result.parameters) === JSON.stringify(testCase.expected.parameters);
+            const toolMatch = result.tool === testCase.expected.tool;
+
+            if (paramsMatch && toolMatch) {
+                console.log(`✅ PASSED`);
+                console.log(`   Parameters: ${JSON.stringify(result.parameters)}`);
+                console.log(`   Tool: ${result.tool}`);
+                passed++;
+            } else {
+                console.log(`❌ FAILED`);
+                console.log(`   Expected: ${JSON.stringify(testCase.expected)}`);
+                console.log(`   Got: ${JSON.stringify(result)}`);
+
+                if (!paramsMatch) {
+                    console.log(`   Parameters mismatch`);
+                }
+                if (!toolMatch) {
+                    console.log(`   Tool mismatch`);
+                }
+            }
+        } catch (error) {
+            console.log(`❌ ERROR: ${error.message}`);
+        }
+    }
+
+    console.log(`\nParameter Parsing Tests: ${passed}/${total} passed`);
+    return passed === total;
+}
+
+// Run tests if called directly
+if (require.main === module) {
+    const success = testParameterParsing();
+    process.exit(success ? 0 : 1);
+}
+
+module.exports = { parseArguments, testParameterParsing };