@tyvm/knowhow 0.0.32 → 0.0.34

package/tests/manual/ycmd/minimal_advanced_test.ts

@@ -0,0 +1,108 @@
+#!/usr/bin/env npx tsx
+
+/**
+ * Minimal 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 minimalAdvancedTest() {
+  console.log("🧪 Minimal ycmd Advanced Features Test\n");
+
+  // Create a test file with TypeScript code
+  const testFile = path.join(process.cwd(), "minimal_test.ts");
+  const testContent = `function hello(name: string): string {
+    return "Hello " + name;
+}
+
+const result = hello("World");
+console.log(result);
+`;
+
+  fs.writeFileSync(testFile, testContent);
+  console.log("✅ Created minimal test file");
+
+  try {
+    // Start ycmd with shorter timeout expectation
+    console.log("🚀 Starting ycmd (this may take a moment)...");
+    const startResult = await ycmdStart({});
+    console.log(
+      "✅ ycmd start result:",
+      startResult.success ? "SUCCESS" : "FAILED"
+    );
+
+    if (!startResult.success) {
+      console.log("❌ ycmd failed to start:", startResult.message);
+      return;
+    }
+
+    // Test 1: Basic diagnostics
+    console.log("\n🔍 Test 1: Basic diagnostics...");
+    const diagnosticsResult = await ycmdDiagnostics({
+      filepath: testFile,
+      fileContents: testContent,
+    });
+
+    console.log("Diagnostics result:", {
+      success: diagnosticsResult.success,
+      diagnosticCount: diagnosticsResult.diagnostics?.length || 0,
+      message: diagnosticsResult.message,
+    });
+
+    // Test 2: Basic completions
+    console.log("\n⚡ Test 2: Basic completions...");
+    const completionsResult = await ycmdCompletion({
+      filepath: testFile,
+      line: 2,
+      column: 15,
+      contents: testContent,
+    });
+
+    console.log("Completions result:", {
+      success: completionsResult.success,
+      completionCount: completionsResult.completions?.length || 0,
+      message: completionsResult.message,
+    });
+
+    // Test 3: Organize imports (even if no imports present)
+    console.log("\n📦 Test 3: Organize imports...");
+    const organizeResult = await ycmdRefactor({
+      filepath: testFile,
+      line: 1,
+      column: 1,
+      command: "organize_imports",
+      contents: testContent,
+    });
+
+    console.log("Organize imports result:", {
+      success: organizeResult.success,
+      message: organizeResult.message,
+      hasEdits: organizeResult.result?.edits
+        ? organizeResult.result.edits.length > 0
+        : false,
+    });
+
+    console.log("\n🎉 Minimal test completed successfully");
+  } catch (error: any) {
+    console.error("❌ Test failed:", error.message);
+  } finally {
+    // Cleanup
+    try {
+      fs.unlinkSync(testFile);
+      console.log("🧹 Cleaned up test file");
+    } catch (e) {
+      // Silent cleanup failure
+    }
+  }
+}
+
+if (require.main === module) {
+  minimalAdvancedTest().catch(console.error);
+}

package/tests/manual/ycmd/simple_diagnostics_test.ts

@@ -0,0 +1,61 @@
+import { ycmdStart, ycmdDiagnostics } from '../../../src/agents/tools/ycmd';
+import * as fs from 'fs';
+import * as path from 'path';
+
+async function testDiagnostics() {
+    console.log('🔧 Testing ycmd diagnostics...');
+    
+    try {
+        // Start ycmd server
+        console.log('Starting ycmd server...');
+        const startResult = await ycmdStart({
+            workspaceRoot: process.cwd(),
+            logLevel: 'debug'
+        });
+        console.log('✅ ycmd server started:', startResult);
+
+        // Wait for server to initialize
+        console.log('⏳ Waiting 5 seconds for server initialization...');
+        await new Promise(resolve => setTimeout(resolve, 5000));
+
+        const testFile = path.join(process.cwd(), 'tests/ycmd/fixtures/debug_diagnostics.ts');
+        
+        console.log('📁 Test file path:', testFile);
+        
+        // Test diagnostics
+        console.log('🔍 Testing diagnostics...');
+        const diagnostics = await ycmdDiagnostics({
+            filepath: testFile,
+            line: 1,
+            column: 1
+        });
+        
+        console.log('📊 Diagnostics result:');
+        console.log(JSON.stringify(diagnostics, null, 2));
+        
+        // Check if we got meaningful results
+        if (diagnostics && typeof diagnostics === 'object' && 'content' in diagnostics) {
+            const content = diagnostics.content;
+            if (Array.isArray(content) && content.length > 0) {
+                console.log(`✅ SUCCESS: Found ${content.length} diagnostic(s)!`);
+                content.forEach((diag, index) => {
+                    console.log(`  ${index + 1}. ${diag.text || diag.message || JSON.stringify(diag)}`);
+                });
+            } else {
+                console.log('⚠️ No diagnostics found in content array');
+            }
+        } else {
+            console.log('⚠️ Unexpected diagnostics response format');
+        }
+
+        console.log('✅ Test completed successfully');
+        process.exit(0);
+
+    } catch (error) {
+        console.error('❌ Test failed:', error.message);
+        console.error('Stack trace:', error.stack);
+        process.exit(1);
+    }
+}
+
+testDiagnostics();

package/tests/manual/ycmd/simple_test.ts

@@ -0,0 +1,74 @@
+#!/usr/bin/env npx tsx
+
+/**
+ * Simple focused 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 simpleTest() {
+    console.log('🧪 Simple ycmd Advanced Features Test\n');
+    
+    // Create a simple test file
+    const testFile = path.join(process.cwd(), 'test_temp.ts');
+    const testContent = `function greet(name: string): string {
+    return "Hello " + name;
+}
+
+const result = greet("World");
+`;
+    
+    fs.writeFileSync(testFile, testContent);
+    console.log('✅ Created test file');
+    
+    try {
+        // Start ycmd
+        console.log('🚀 Starting ycmd...');
+        await ycmdStart({});
+        console.log('✅ ycmd started');
+        
+        // Test diagnostics
+        console.log('🔍 Testing diagnostics...');
+        const diagnostics = await ycmdDiagnostics({ filepath: testFile });
+        console.log('✅ Diagnostics result:', diagnostics);
+        
+        // Test completions
+        console.log('⚡ Testing completions...');
+        const completions = await ycmdCompletion({
+            filepath: testFile,
+            line: 2,
+            column: 15
+        });
+        console.log('✅ Completions result:', completions);
+        
+        // Test refactor rename
+        console.log('🔧 Testing refactor rename...');
+        const rename = await ycmdRefactor({
+            filepath: testFile,
+            line: 1,
+            column: 10,
+            command: 'rename',
+            newName: 'sayHello'
+        });
+        console.log('✅ Rename result:', rename);
+        
+    } catch (error: any) {
+        console.error('❌ Test failed:', error.message);
+    } finally {
+        // Cleanup
+        try {
+            fs.unlinkSync(testFile);
+            console.log('🧹 Cleaned up test file');
+        } catch (e) {
+            console.log('⚠️ Could not clean up test file');
+        }
+    }
+    
+    console.log('🎉 Simple test complete');
+}
+
+if (require.main === module) {
+    simpleTest().catch(console.error);
+}

package/tests/manual/ycmd/test-typescript-sample.ts

@@ -0,0 +1,34 @@
+// Sample TypeScript file to test ycmd completion
+interface User {
+  id: number;
+  name: string;
+  email: string;
+}
+
+class UserService {
+  private users: User[] = [];
+
+  addUser(user: User): void {
+    this.users.push(user);
+  }
+
+  findUserById(id: number): User | undefined {
+    return this.users.find(u => u.id === id);
+  }
+
+  getAllUsers(): User[] {
+    return this.users;
+  }
+}
+
+const service = new UserService();
+service.addUser({ id: 1, name: "John", email: "john@example.com" });
+
+// Test completion at this point - should show User properties
+const user = service.findUserById(1);
+if (user) {
+  console.log(user.name); // <- cursor here for completion test
+}
+
+// Test go-to-definition on UserService
+const anotherService = new UserService(); // <- should jump to class definition

package/tests/manual/ycmd/test_advanced_features.ts

@@ -0,0 +1,407 @@
+import { YcmdServer } from "../../../src/agents/tools/ycmd/server";
+import {
+  YcmdClient,
+  getFileTypes,
+} from "../../../src/agents/tools/ycmd/client";
+import * as path from "path";
+import * as fs from "fs";
+import { ycmdServerManager } from "../../../src/agents/tools/ycmd/serverManager";
+import { getLocations } from "../../../src/agents/tools/ycmd/tools/getLocations";
+import { wait } from "../../../src/utils";
+
+async function testAdvancedFeatures() {
+  console.log("🧪 Testing Advanced ycmd Features\n");
+
+  const workspaceRoot = process.cwd();
+  // Test files directory
+  const testDir = path.join(workspaceRoot, "tests", "ycmd", "fixtures");
+  if (!fs.existsSync(testDir)) {
+    fs.mkdirSync(testDir, { recursive: true });
+  }
+
+  console.log("📁 Creating test files...\n");
+
+  // === Test File 1: TypeScript with missing imports ===
+  const tsFile = path.join(testDir, "test_imports.ts");
+  const tsContent = `// TypeScript file with missing imports and issues
+const fs = require('fs'); // Should suggest import
+const path = require('path');
+
+interface User {
+    name: string;
+    age: number;
+    email?: string;
+}
+
+function createUser(name: string, age: number): User {
+    return { name, age };
+}
+
+// Missing import for React (if available)
+const component = React.createElement('div');
+
+// Type error - missing property
+const user: User = { name: 'Alice' }; // Missing age
+
+// Unused variable
+const unusedVar = 'test';
+
+export { createUser };
+`;
+
+  const userLocations = await getLocations({
+    filepath: tsFile,
+    fileContents: tsContent,
+    searchString: "user",
+  });
+  const userLocation = userLocations.locations[0];
+
+  const createUserLocations = await getLocations({
+    filepath: tsFile,
+    fileContents: tsContent,
+    searchString: "createUser",
+  });
+  const createUserLocation = createUserLocations.locations[0];
+
+  const returnLocations = await getLocations({
+    filepath: tsFile,
+    fileContents: tsContent,
+    searchString: "return",
+  });
+  const returnLocation = returnLocations.locations[0];
+
+  const { client: tsClient } = await ycmdServerManager.setupClientAndNotifyFile(
+    {
+      filepath: tsFile,
+      fileContents: tsContent,
+    }
+  );
+
+  fs.writeFileSync(tsFile, tsContent);
+  console.log(`✅ Created ${tsFile}`);
+
+  // === Test File 2: JavaScript with formatting issues ===
+  const jsFile = path.join(testDir, "test_format.js");
+  const jsContent = `// JavaScript file with formatting issues
+function   badlyFormatted(  a,b,   c )
+{
+return a+b+c;
+}
+
+const obj={a:1,b:2,c:3};
+
+if(true){
+console.log("badly formatted");
+}
+`;
+
+  fs.writeFileSync(jsFile, jsContent);
+  console.log(`✅ Created ${jsFile}\n`);
+
+  // === BEGIN TESTING ===
+
+  console.log("🔍 TESTING DIAGNOSTICS AND FIXITS\n");
+
+  // Test 1: Get diagnostics for TypeScript file
+  try {
+    console.log("1. Getting diagnostics for TypeScript file...");
+    const filetypes = getFileTypes(tsFile);
+
+    const brokenCode = tsContent.replace("return { name", "return { nade");
+    fs.writeFileSync(tsFile, brokenCode);
+
+    const { client } = await ycmdServerManager.setupClientAndNotifyFile({
+      filepath: tsFile,
+      fileContents: brokenCode,
+    });
+
+    const diagnostics = await client.getDiagnostics(
+      tsFile,
+      tsContent,
+      filetypes
+    );
+
+    console.log(`✅ Found ${diagnostics.length} diagnostics`);
+
+    for (let i = 0; i < diagnostics.length; i++) {
+      const diag = diagnostics[i];
+      console.log(`   Diagnostic ${i + 1}:`);
+      console.log(
+        `   - Line ${diag.location.line_num}, Col ${diag.location.column_num}`
+      );
+      console.log(`   - Kind: ${diag.kind}`);
+      console.log(`   - Text: ${diag.text}`);
+
+      // Check if fixit is available
+      if (diag.fixit_available) {
+        console.log(`   - ✅ Fixit available!`);
+
+        try {
+          const fixitResult = await client.refactorFixIt(
+            tsFile,
+            diag.location.line_num,
+            diag.location.column_num,
+            tsContent,
+            filetypes,
+            0
+          );
+
+          console.log(`   - ✅ Fixit applied successfully`);
+          console.log(`   - Result:`, JSON.stringify(fixitResult, null, 4));
+        } catch (fixitError: any) {
+          console.log(`   - ❌ Fixit failed: ${fixitError.message}`);
+        }
+      } else {
+        console.log(`   - ❌ No fixit available`);
+      }
+      console.log("");
+    }
+  } catch (error: any) {
+    console.log(`❌ Diagnostics failed: ${error.message}\n`);
+  }
+
+  console.log("🔧 TESTING AUTO-IMPORT FEATURES\n");
+
+  // Test 2: Try organize imports
+  try {
+    console.log("2. Testing RefactorOrganizeImports...");
+    const filetypes = getFileTypes(tsFile);
+
+    const { client } = await ycmdServerManager.setupClientAndNotifyFile({
+      filepath: tsFile,
+      fileContents: jsContent,
+    });
+
+    const organizeResult = await client.refactorOrganizeImports(
+      tsFile,
+      1,
+      1,
+      tsContent,
+      filetypes
+    );
+
+    console.log("✅ RefactorOrganizeImports succeeded");
+    console.log("Result:", JSON.stringify(organizeResult, null, 2));
+  } catch (error: any) {
+    console.log(`❌ RefactorOrganizeImports failed: ${error.message}`);
+  }
+
+  // Test 3: Test completions for import suggestions
+  try {
+    console.log("\n3. Testing completions for import suggestions...");
+    const filetypes = getFileTypes(tsFile);
+
+    // Test at position where React is used but not imported
+    const completionRequest = {
+      filepath: tsFile,
+      line_num: 15, // Line with React.createElement
+      column_num: 15, // Column after "React"
+      file_data: {
+        [tsFile]: {
+          contents: tsContent,
+          filetypes,
+        },
+      },
+    };
+
+    const completionResponse = await tsClient.getCompletions(completionRequest);
+    const completions = completionResponse.completions;
+
+    console.log(`✅ Found ${completions.length} completions`);
+
+    // Look for import-related completions
+    const importCompletions = completions.filter(
+      (c) =>
+        c.insertion_text?.includes("import") ||
+        c.detailed_info?.includes("import") ||
+        c.kind?.includes("import")
+    );
+
+    if (importCompletions.length > 0) {
+      console.log(
+        `✅ Found ${importCompletions.length} import-related completions:`
+      );
+      importCompletions.forEach((comp, i) => {
+        console.log(`   ${i + 1}. ${comp.insertion_text} (${comp.kind})`);
+        if (comp.detailed_info) {
+          console.log(`      Info: ${comp.detailed_info}`);
+        }
+      });
+    } else {
+      console.log("❌ No import-related completions found");
+    }
+  } catch (error: any) {
+    console.log(`❌ Completions test failed: ${error.message}`);
+  }
+
+  console.log("\n🔄 TESTING ADVANCED REFACTORING\n");
+
+  // Test 4: Test RefactorRename
+  try {
+    console.log("4. Testing RefactorRename...");
+    const filetypes = getFileTypes(tsFile);
+    const renameResult = await tsClient.refactorRename(
+      tsFile,
+      userLocation.line,
+      userLocation.column,
+      tsContent,
+      filetypes,
+      "buildUser"
+    );
+
+    console.log("✅ RefactorRename succeeded");
+    console.log("Result:", JSON.stringify(renameResult, null, 2));
+  } catch (error: any) {
+    console.log(`❌ RefactorRename failed: ${error.message}`);
+  }
+
+  // Test 5: Test RefactorExtractMethod
+  try {
+    console.log("\n5. Testing RefactorExtractMethod...");
+    const filetypes = getFileTypes(tsFile);
+    const extractResult = await tsClient.refactorExtractMethod(
+      tsFile,
+      returnLocation.line,
+      returnLocation.column,
+      tsContent,
+      filetypes
+    );
+
+    console.log("✅ RefactorExtractMethod succeeded");
+    console.log("Result:", JSON.stringify(extractResult, null, 2));
+  } catch (error: any) {
+    console.log(`❌ RefactorExtractMethod failed: ${error.message}`);
+  }
+
+  console.log("\n📋 TESTING CODE INTELLIGENCE\n");
+
+  // Test 6: Test GetType using signature help
+  try {
+    console.log("6. Testing GetType...");
+    const filetypes = getFileTypes(tsFile);
+    const typeResult = await tsClient.getSignatureHelp(
+      tsFile,
+      userLocation.line,
+      userLocation.column,
+      tsContent,
+      filetypes
+    );
+
+    console.log("✅ GetType succeeded");
+    console.log("Result:", JSON.stringify(typeResult, null, 2));
+  } catch (error: any) {
+    console.log(`❌ GetType failed: ${error.message}`);
+  }
+
+  // Test 7: Test GoToDefinition
+  try {
+    console.log("\n7. Testing GoToDefinition...");
+    const filetypes = getFileTypes(tsFile);
+    const defResult = await tsClient.goToDefinition(
+      tsFile,
+      userLocation.line, // Line on "user"
+      userLocation.column, // Column on "user"
+      tsContent,
+      filetypes
+    );
+
+    console.log("✅ GoToDefinition succeeded");
+    console.log("Result:", JSON.stringify(defResult, null, 2));
+  } catch (error: any) {
+    console.log(`❌ GoToDefinition failed: ${error.message}`);
+  }
+
+  // Test 8: Test GoToReferences
+  try {
+    console.log("\n8. Testing GoToReferences...");
+    const filetypes = getFileTypes(tsFile);
+    const refsResult = await tsClient.goToReferences(
+      tsFile,
+      createUserLocation.line,
+      createUserLocation.column,
+      tsContent,
+      filetypes
+    );
+
+    console.log("✅ GoToReferences succeeded");
+    console.log("Result:", JSON.stringify(refsResult, null, 2));
+  } catch (error: any) {
+    console.log(`❌ GoToReferences failed: ${error.message}`);
+  }
+
+  console.log("\n🔍 TESTING COMMAND DISCOVERY\n");
+
+  // Test 9: Get available refactor commands
+  try {
+    console.log("9. Testing command discovery...");
+    const filetypes = getFileTypes(tsFile);
+    const commands = await tsClient.getRefactorCommands(
+      tsFile,
+      9, // createUser function line
+      10, // createUser function column
+      tsContent,
+      filetypes
+    );
+
+    console.log("✅ Command discovery succeeded");
+    console.log(`Found ${commands.length} available commands:`);
+    commands.forEach((cmd, i) => {
+      console.log(`   ${i + 1}. ${cmd}`);
+    });
+  } catch (error: any) {
+    console.log(`❌ Command discovery failed: ${error.message}`);
+  }
+
+  console.log("\n🔄 TESTING EDGE CASES\n");
+
+  // Test 10: Refactoring on file with syntax errors
+  const syntaxErrorFile = path.join(testDir, "syntax_error.ts");
+  const syntaxErrorContent = `
+function broken(
+    // Missing closing parenthesis and body
+`;
+
+  fs.writeFileSync(syntaxErrorFile, syntaxErrorContent);
+
+  try {
+    console.log("10. Testing refactoring on file with syntax errors...");
+    const filetypes = getFileTypes(syntaxErrorFile);
+    const syntaxRefactorResult = await tsClient.refactorRename(
+      syntaxErrorFile,
+      2, // broken function line
+      10, // broken function column
+      syntaxErrorContent,
+      filetypes,
+      "fixed"
+    );
+
+    console.log("⚠️ Syntax error refactor succeeded (unexpected)");
+    console.log("Result:", JSON.stringify(syntaxRefactorResult, null, 2));
+  } catch (error: any) {
+    console.log(`✅ Syntax error refactor correctly failed: ${error.message}`);
+  }
+
+  // Cleanup test files
+  console.log("\n🧹 Cleaning up test files...");
+  try {
+    fs.unlinkSync(tsFile);
+    fs.unlinkSync(jsFile);
+    fs.unlinkSync(syntaxErrorFile);
+    console.log("✅ Test files cleaned up");
+  } catch (error) {
+    console.log("⚠️ Could not clean up all test files");
+  }
+
+  console.log("\n🎉 Advanced features testing complete!");
+  process.exit(0);
+}
+
+// Run the test
+if (require.main === module) {
+  testAdvancedFeatures().catch((error) => {
+    console.error("Test failed:", error);
+    process.exit(1);
+  });
+}
+
+export { testAdvancedFeatures };