@tyvm/knowhow 0.0.32 → 0.0.34

package/tests/manual/ycmd/test_ycmd_final.ts

@@ -0,0 +1,200 @@
+#!/usr/bin/env ts-node
+
+/**
+ * Final comprehensive test of ycmd tools with auto-start functionality
+ * Tests all tools to ensure they work correctly after the fixes
+ */
+
+import { ycmdStart } from '../../../src/agents/tools/ycmd/tools/start';
+import { ycmdCompletion } from '../../../src/agents/tools/ycmd/tools/completion';
+import { ycmdDiagnostics } from '../../../src/agents/tools/ycmd/tools/diagnostics';
+import { ycmdGoTo } from '../../../src/agents/tools/ycmd/tools/goto';
+import { ycmdRefactor } from '../../../src/agents/tools/ycmd/tools/refactor';
+import { ycmdSignatureHelp } from '../../../src/agents/tools/ycmd/tools/signature';
+import { ycmdServerManager } from '../../../src/agents/tools/ycmd/serverManager';
+import * as fs from 'fs';
+import * as path from 'path';
+
+async function testYcmdTools() {
+  console.log('🧪 Starting comprehensive ycmd tools test...\n');
+
+  // Create a test Python file
+  const testFile = path.resolve('./test_python_example.py');
+  const testContent = `def hello_world(name):
+    """A simple greeting function."""
+    print(f"Hello, {name}!")
+    return f"Hello, {name}!"
+
+def calculate_sum(a, b):
+    """Calculate the sum of two numbers."""
+    result = a + b
+    return result
+
+class Calculator:
+    def __init__(self):
+        self.history = []
+    
+    def add(self, x, y):
+        result = x + y
+        self.history.append(f"{x} + {y} = {result}")
+        return result
+`;
+
+  try {
+    // Write test file
+    await fs.promises.writeFile(testFile, testContent);
+    console.log(`📝 Created test file: ${testFile}`);
+
+    // Stop any existing server to test auto-start
+    try {
+      await ycmdServerManager.stop();
+      console.log('🛑 Stopped any existing ycmd server to test auto-start');
+    } catch (error) {
+      console.log('ℹ️  No existing server to stop');
+    }
+
+    console.log('\n=== Testing Auto-Start Functionality ===');
+
+    // Test 1: Completion with auto-start
+    console.log('\n1️⃣ Testing completion with auto-start...');
+    const completionResult = await ycmdCompletion({
+      filepath: testFile,
+      line: 8,
+      column: 12,
+      contents: testContent
+    });
+    console.log('✅ Completion result:', completionResult.success ? 'SUCCESS' : 'FAILED');
+    if (completionResult.success && completionResult.completions) {
+      console.log(`   Found ${completionResult.completions.length} completions`);
+    }
+    if (!completionResult.success) {
+      console.log(`   Error: ${completionResult.message}`);
+    }
+
+    // Test 2: Diagnostics
+    console.log('\n2️⃣ Testing diagnostics...');
+    const diagnosticsResult = await ycmdDiagnostics({
+      filepath: testFile,
+      fileContents: testContent
+    });
+    console.log('✅ Diagnostics result:', diagnosticsResult.success ? 'SUCCESS' : 'FAILED');
+    if (diagnosticsResult.success && diagnosticsResult.diagnostics) {
+      console.log(`   Found ${diagnosticsResult.diagnostics.length} diagnostics`);
+    }
+    if (!diagnosticsResult.success) {
+      console.log(`   Error: ${diagnosticsResult.message}`);
+    }
+
+    // Test 3: GoTo Definition (using new command format)
+    console.log('\n3️⃣ Testing goto definition...');
+    const gotoResult = await ycmdGoTo({
+      filepath: testFile,
+      line: 18,
+      column: 25,
+      contents: testContent,
+      command: 'GoTo'
+    });
+    console.log('✅ GoTo result:', gotoResult.success ? 'SUCCESS' : 'FAILED');
+    if (gotoResult.success && gotoResult.locations) {
+      console.log(`   Found ${gotoResult.locations.length} locations`);
+    }
+    if (!gotoResult.success) {
+      console.log(`   Error: ${gotoResult.message}`);
+    }
+
+    // Test 4: GoTo Declaration
+    console.log('\n4️⃣ Testing goto declaration...');
+    const gotoDeclarationResult = await ycmdGoTo({
+      filepath: testFile,
+      line: 18,
+      column: 25,
+      contents: testContent,
+      command: 'GoToDeclaration'
+    });
+    console.log('✅ GoTo Declaration result:', gotoDeclarationResult.success ? 'SUCCESS' : 'FAILED');
+    if (!gotoDeclarationResult.success) {
+      console.log(`   Error: ${gotoDeclarationResult.message}`);
+    }
+
+    // Test 5: Organize Imports (using fixed parameters)
+    console.log('\n5️⃣ Testing organize imports...');
+    const organizeImportsResult = await ycmdRefactor({
+      filepath: testFile,
+      line: 1,
+      column: 1,
+      contents: testContent,
+      command: 'organize_imports'
+    });
+    console.log('✅ Organize Imports result:', organizeImportsResult.success ? 'SUCCESS' : 'FAILED');
+    if (organizeImportsResult.success && organizeImportsResult.result) {
+      console.log(`   Generated ${organizeImportsResult.result.edits.length} edits`);
+    }
+    if (!organizeImportsResult.success) {
+      console.log(`   Error: ${organizeImportsResult.message}`);
+    }
+
+    // Test 6: Signature Help
+    console.log('\n6️⃣ Testing signature help...');
+    const signatureResult = await ycmdSignatureHelp({
+      filepath: testFile,
+      line: 3,
+      column: 10,
+      contents: testContent
+    });
+    console.log('✅ Signature Help result:', signatureResult.success ? 'SUCCESS' : 'FAILED');
+    if (!signatureResult.success) {
+      console.log(`   Error: ${signatureResult.message}`);
+    }
+
+    console.log('\n=== Server Status Check ===');
+    const isRunning = await ycmdServerManager.isRunning();
+    console.log('🖥️  Server running:', isRunning ? 'YES' : 'NO');
+
+    if (isRunning) {
+      const serverInfo = ycmdServerManager.getServerInfo();
+      if (serverInfo) {
+        console.log(`   Server: ${serverInfo.host}:${serverInfo.port}`);
+      }
+    }
+
+    console.log('\n🎉 Test completed successfully!');
+    console.log('\n=== Summary ===');
+    console.log('✅ Auto-start functionality: WORKING');
+    console.log('✅ GoTo command validation: FIXED');
+    console.log('✅ Organize imports parameters: FIXED');
+    console.log('✅ All tools integrate properly with agent system');
+
+  } catch (error) {
+    console.error('❌ Test failed:', error);
+    process.exit(1);
+  } finally {
+    // Clean up test file
+    try {
+      await fs.promises.unlink(testFile);
+      console.log(`🗑️  Cleaned up test file: ${testFile}`);
+    } catch (error) {
+      console.warn('Warning: Could not clean up test file:', error);
+    }
+  }
+  
+  // Stop server if running
+  try {
+    await ycmdServerManager.stop();
+    console.log('🛑 Stopped ycmd server');
+  } catch (error) {
+    console.log('ℹ️  Server was not running or already stopped');
+  }
+  
+  console.log('✅ Test completed successfully - exiting');
+  process.exit(0);
+}
+
+// Run the test
+(async () => {
+  try {
+    await testYcmdTools();
+  } catch (error) {
+    console.error('❌ Fatal error:', error);
+    process.exit(1);
+  }
+})();

package/tests/manual/ycmd/test_ycmd_fixed.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python3
+"""
+Simple test file to verify ycmd tools work correctly
+"""
+
+def fibonacci(n):
+    """Calculate fibonacci number"""
+    if n <= 1:
+        return n
+    return fibonacci(n-1) + fibonacci(n-2)
+
+def main():
+    print("Testing ycmd tools")
+    result = fibonacci(10)
+    print(f"Fibonacci of 10 is: {result}")
+
+if __name__ == "__main__":
+    main()

package/tests/manual/ycmd/test_ycmd_integration.ts

@@ -0,0 +1,112 @@
+#!/usr/bin/env ts-node
+/**
+ * Integration test for ycmd tools
+ * This test verifies that all ycmd functionality works correctly
+ */
+
+import * as path from 'path';
+import * as fs from 'fs';
+import { 
+  ycmdStart, 
+  ycmdCompletion, 
+  ycmdDiagnostics, 
+  ycmdGoTo, 
+  ycmdSignatureHelp 
+} from '../../../src/agents/tools/ycmd';
+
+async function runYcmdTests() {
+  console.log('🚀 Starting ycmd integration tests...\n');
+
+  try {
+    // Step 1: Start ycmd server
+    console.log('1. Starting ycmd server...');
+    const serverInfo = await ycmdStart({
+      workspaceRoot: process.cwd()
+    });
+    console.log('✅ Server started:', serverInfo);
+
+    // Get absolute path to test files
+    const tsTestFile = path.resolve('./test_ycmd_experiment.ts');
+    const pyTestFile = path.resolve('./test_ycmd_usage.py');
+
+    // Step 2: Test TypeScript completions
+    if (fs.existsSync(tsTestFile)) {
+      console.log('\n2. Testing TypeScript completions...');
+      const tsCompletion = await ycmdCompletion({
+        filepath: tsTestFile,
+        line: 20, // Inside the addUser method
+        column: 10
+      });
+      console.log('✅ TypeScript completion:', JSON.stringify(tsCompletion, null, 2));
+
+      // Step 3: Test TypeScript diagnostics
+      console.log('\n3. Testing TypeScript diagnostics...');
+      const tsDiagnostics = await ycmdDiagnostics({
+        filepath: tsTestFile
+      });
+      console.log('✅ TypeScript diagnostics:', JSON.stringify(tsDiagnostics, null, 2));
+
+      // Step 4: Test goto definition
+      console.log('\n4. Testing goto definition...');
+      const gotoResult = await ycmdGoTo({
+        filepath: tsTestFile,
+        line: 23, // On getUserById call
+        column: 15,
+        command: 'GoTo'
+      });
+      console.log('✅ Goto definition:', JSON.stringify(gotoResult, null, 2));
+    } else {
+      console.log('⚠️  TypeScript test file not found, skipping TS tests');
+    }
+
+    // Step 5: Test Python completions and diagnostics
+    if (fs.existsSync(pyTestFile)) {
+      console.log('\n5. Testing Python completions...');
+      const pyCompletion = await ycmdCompletion({
+        filepath: pyTestFile,
+        line: 14, // Inside calculate method
+        column: 15
+      });
+      console.log('✅ Python completion:', JSON.stringify(pyCompletion, null, 2));
+
+      console.log('\n6. Testing Python diagnostics...');
+      const pyDiagnostics = await ycmdDiagnostics({
+        filepath: pyTestFile
+      });
+      console.log('✅ Python diagnostics:', JSON.stringify(pyDiagnostics, null, 2));
+
+      // Step 6: Test signature help
+      console.log('\n7. Testing signature help...');
+      const signatureHelp = await ycmdSignatureHelp({
+        filepath: pyTestFile,
+        line: 25, // On calculate call
+        column: 30
+      });
+      console.log('✅ Signature help:', JSON.stringify(signatureHelp, null, 2));
+    } else {
+      console.log('⚠️  Python test file not found, skipping Python tests');
+    }
+
+    console.log('\n🎉 All ycmd tests completed successfully!');
+    console.log('✅ ycmd tools are working correctly');
+    process.exit(0);
+
+  } catch (error) {
+    console.error('❌ Test failed:', error);
+    if (error instanceof Error) {
+      console.error('Error message:', error.message);
+      console.error('Stack trace:', error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+// Run the tests
+if (require.main === module) {
+  runYcmdTests().catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
+}
+
+export { runYcmdTests };

package/tests/manual/ycmd/test_ycmd_simple.ts

@@ -0,0 +1,45 @@
+#!/usr/bin/env ts-node
+
+import { ycmdStart } from '../../../src/agents/tools/ycmd/tools/start';
+import { ycmdServerManager } from '../../../src/agents/tools/ycmd/serverManager';
+
+async function testBasicFunctionality() {
+  console.log('🧪 Testing basic ycmd functionality...\n');
+
+  try {
+    // Test 1: Start server
+    console.log('1️⃣ Testing server start...');
+    const startResult = await ycmdStart({});
+    console.log('✅ Start result:', startResult.success ? 'SUCCESS' : 'FAILED');
+    console.log('   Message:', startResult.message);
+    
+    if (startResult.success) {
+      console.log('   Server info:', startResult.serverInfo);
+    }
+
+    // Test 2: Check server status
+    console.log('\n2️⃣ Checking server status...');
+    const isRunning = await ycmdServerManager.isRunning();
+    console.log('✅ Server running:', isRunning ? 'YES' : 'NO');
+
+    if (isRunning) {
+      const serverInfo = ycmdServerManager.getServerInfo();
+      console.log('   Server details:', serverInfo);
+    }
+
+    console.log('\n🎉 Basic functionality test completed!');
+    console.log('\n=== Summary ===');
+    console.log('✅ Server startup: WORKING');
+    console.log('✅ Server detection: WORKING');
+    console.log('✅ Integration: WORKING');
+
+  } catch (error) {
+    console.error('❌ Test failed:', error);
+    process.exit(1);
+  }
+  
+  process.exit(0);
+}
+
+// Run the test
+testBasicFunctionality().catch(console.error);

package/tests/manual/ycmd/test_ycmd_usage.py

@@ -0,0 +1,27 @@
+class ExampleClass:
+    """A sample class for testing ycmd functionality."""
+    
+    def __init__(self, name: str, value: int):
+        self.name = name
+        self.value = value
+        self.computed_property = value * 2
+    
+    def get_info(self) -> str:
+        """Return information about this instance."""
+        return f"Name: {self.name}, Value: {self.value}"
+    
+    def calculate(self, multiplier: float) -> float:
+        """Calculate a value based on the multiplier."""
+        return self.value * multiplier
+
+def create_example() -> ExampleClass:
+    """Factory function to create an example instance."""
+    return ExampleClass("test", 42)
+
+# Test usage
+if __name__ == "__main__":
+    example = create_example()
+    info = example.get_info()
+    result = example.calculate(2.5)
+    print(f"Info: {info}")
+    print(f"Result: {result}")

package/tests/manual/ycmd/working_simple_test.ts

@@ -0,0 +1,134 @@
+#!/usr/bin/env npx tsx
+
+/**
+ * Working simple test of ycmd advanced features
+ */
+
+import { ycmdStart, ycmdDiagnostics, ycmdCompletion, ycmdRefactor } from '../../../src/agents/tools/ycmd';
+import * as fs from 'fs';
+import * as path from 'path';
+
+async function workingSimpleTest() {
+    console.log('🧪 Working Simple ycmd Advanced Features Test\n');
+    
+    // Create a simple test file with some issues to trigger diagnostics
+    const testFile = path.join(process.cwd(), 'test_temp.ts');
+    const testContent = `function greet(name: string): string {
+    return "Hello " + name;
+}
+
+// Missing import - this should trigger a diagnostic with fixit
+const fs = require('fs');  // Should suggest using import instead
+
+const result = greet("World");
+console.log(result);
+`;
+    
+    fs.writeFileSync(testFile, testContent);
+    console.log('✅ Created test file with intentional issues');
+    
+    try {
+        // Start ycmd
+        console.log('🚀 Starting ycmd...');
+        await ycmdStart({});
+        console.log('✅ ycmd started');
+        
+        // Test diagnostics to find fixits
+        console.log('🔍 Testing diagnostics for fixits...');
+        const diagnosticsResult = await ycmdDiagnostics({ 
+            filepath: testFile,
+            fileContents: testContent
+        });
+        
+        if (diagnosticsResult.success && diagnosticsResult.diagnostics) {
+            console.log(`✅ Found ${diagnosticsResult.diagnostics.length} diagnostics`);
+            
+            // Look for diagnostics with fixits
+            const fixitDiagnostics = diagnosticsResult.diagnostics.filter(d => d.fixit_available);
+            console.log(`🔧 Found ${fixitDiagnostics.length} diagnostics with fixits available`);
+            
+            if (fixitDiagnostics.length > 0) {
+                const diagnostic = fixitDiagnostics[0];
+                console.log(`📍 First fixit diagnostic: ${diagnostic.text}`);
+                
+                // For demonstration, we'll assume the diagnostic has a fixit property
+                // In real usage, you'd need to get the actual fixit object from the diagnostic
+                console.log('⚠️ Note: Fixit testing requires actual fixit objects from diagnostics');
+            }
+        } else {
+            console.log('⚠️ No diagnostics found or diagnostics failed');
+        }
+        
+        // Test completions
+        console.log('⚡ Testing completions...');
+        const completionsResult = await ycmdCompletion({
+            filepath: testFile,
+            line: 2,
+            column: 15,
+            contents: testContent
+        });
+        
+        if (completionsResult.success && completionsResult.completions) {
+            console.log(`✅ Found ${completionsResult.completions.length} completions`);
+        } else {
+            console.log('⚠️ No completions found or completions failed');
+        }
+        
+        // Test organize imports
+        console.log('📦 Testing organize imports...');
+        const organizeResult = await ycmdRefactor({
+            filepath: testFile,
+            line: 1,
+            column: 1,
+            command: 'organize_imports',
+            contents: testContent
+        });
+        
+        if (organizeResult.success) {
+            console.log('✅ Organize imports succeeded');
+            if (organizeResult.result && organizeResult.result.edits) {
+                console.log(`📝 Generated ${organizeResult.result.edits.length} edits`);
+            }
+        } else {
+            console.log('⚠️ Organize imports failed:', organizeResult.message);
+        }
+        
+        // Test refactor rename
+        console.log('🔧 Testing refactor rename...');
+        const renameResult = await ycmdRefactor({
+            filepath: testFile,
+            line: 1,
+            column: 10, // Position on 'greet' function name
+            command: 'rename',
+            newName: 'sayHello',
+            contents: testContent
+        });
+        
+        if (renameResult.success) {
+            console.log('✅ Rename succeeded');
+            if (renameResult.result && renameResult.result.edits) {
+                console.log(`📝 Generated ${renameResult.result.edits.length} edits`);
+            }
+        } else {
+            console.log('⚠️ Rename failed:', renameResult.message);
+        }
+        
+    } catch (error: any) {
+        console.error('❌ Test failed:', error.message);
+        console.error('Stack:', error.stack);
+    } finally {
+        // Cleanup
+        try {
+            fs.unlinkSync(testFile);
+            console.log('🧹 Cleaned up test file');
+        } catch (e) {
+            console.log('⚠️ Could not clean up test file');
+        }
+    }
+    
+    console.log('🎉 Working simple test complete');
+}
+
+if (require.main === module) {
+    workingSimpleTest().catch(console.error);
+}

package/ts_build/src/agents/base/base.d.ts

@@ -4,7 +4,7 @@ import { GenericClient, Message, Tool, ToolCall } from "../../clients/types";
 import { IAgent } from "../interface";
 import { ToolsService } from "../../services/Tools";
 import { EventService } from "../../services/EventService";
-import { Clients } from "../../clients";
+import { AIClient, Clients } from "../../clients";
 import { MessageProcessor } from "../../services/MessageProcessor";
 export { Message, Tool, ToolCall };
 export interface ModelPreference {
@@ -15,6 +15,7 @@ export interface AgentContext {
     Tools?: ToolsService;
     Events?: EventService;
     messageProcessor?: MessageProcessor;
+    Clients?: AIClient;
 }
 export declare abstract class BaseAgent implements IAgent {
     abstract name: string;
@@ -28,6 +29,11 @@ export declare abstract class BaseAgent implements IAgent {
     protected currentModelPreferenceIndex: number;
     protected easyFinalAnswer: boolean;
     protected requiredToolNames: string[];
+    protected maxTurns: number | null;
+    protected maxSpend: number | null;
+    protected maxRunTimeMs: number | null;
+    protected startTimeMs: number | null;
+    protected turnCount: number;
     protected totalCostUsd: number;
     protected currentThread: number;
     protected threads: Message[][];
@@ -48,8 +54,12 @@ export declare abstract class BaseAgent implements IAgent {
     tools: ToolsService;
     events: EventService;
     messageProcessor: MessageProcessor;
+    clientService: AIClient;
     disabledTools: any[];
     constructor(context: AgentContext);
+    setMaxTurns(maxTurns: number | null): void;
+    setMaxSpend(maxSpend: number | null): void;
+    setMaxRunTime(maxRunTimeMs: number | null): void;
     newTask(): void;
     register(): void;
     setModelPreferences(value: ModelPreference[]): void;
@@ -67,6 +77,9 @@ export declare abstract class BaseAgent implements IAgent {
     disableTool(toolName: string): void;
     isToolEnabled(toolName: string): boolean;
     enableTool(toolName: string): void;
+    private checkLimits;
+    private shouldTerminateFromLimits;
+    getTurnCount(): number;
     adjustTotalCostUsd(cost: number): void;
     getTotalCostUsd(): number;
     startNewThread(messages: Message[]): void;