@tyvm/knowhow 0.0.33 → 0.0.35

package/src/agents/tools/ycmd/definitions.ts

@@ -0,0 +1,294 @@
+export const definitions = [
+  {
+    type: "function",
+    function: {
+      name: "ycmdStart",
+      description: "Start ycmd server with project configuration for code intelligence features",
+      parameters: {
+        type: "object",
+        properties: {
+          workspaceRoot: {
+            type: "string",
+            description: "Path to the project root directory. Defaults to current working directory and auto-detects TypeScript/Node.js projects via tsconfig.json or package.json",
+          },
+          config: {
+            type: "object",
+            description: "Optional ycmd server configuration",
+            properties: {
+              port: {
+                type: "number",
+                description: "Port for ycmd server (0 for auto-assign)",
+              },
+              logLevel: {
+                type: "string",
+                description: "Log level: debug, info, warning, error",
+              },
+              completionTimeout: {
+                type: "number",
+                description: "Completion timeout in milliseconds",
+              },
+            },
+          },
+        },
+        required: [],
+      },
+      returns: {
+        type: "object",
+        description: "Server information including host, port, and status",
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "ycmdCompletion",
+      description: "Get code completions at a specific position in a file. You can specify the position either with line/column numbers OR with a searchString that will be located automatically.",
+      parameters: {
+        type: "object",
+        properties: {
+          filepath: {
+            type: "string",
+            description: "Path to the file. Can be relative (defaults to current working directory) or absolute",
+          },
+          line: {
+            type: "number",
+            description: "Line number (1-based). Required if searchString is not provided.",
+          },
+          column: {
+            type: "number",
+            description: "Column number (1-based). Required if searchString is not provided.",
+          },
+          searchString: {
+            type: "string",
+            description: "String to search for in the file to determine completion position. Alternative to line/column. Completions will be provided after this string.",
+          },
+          matchType: {
+            type: "string",
+            description: "Type of matching when using searchString: 'exact' for exact match, 'prefix' for prefix matching, 'contains' for substring match",
+            enum: ["exact", "prefix", "contains"],
+          },
+          forceSemantic: {
+            type: "boolean",
+            description: "Force semantic completions instead of identifier-based completions",
+          },
+          fileContents: {
+            type: "string",
+            description: "Current contents of the file (optional if file exists on disk)",
+          },
+        },
+        required: ["filepath"],
+      },
+      returns: {
+        type: "object",
+        description: "Completion results with suggestions and metadata",
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "ycmdGoTo",
+      description: "Navigate to definitions, declarations, or find references for a symbol. You can specify the position either with line/column numbers OR with a searchString that will be located automatically.",
+      parameters: {
+        type: "object",
+        properties: {
+          filepath: {
+            type: "string",
+            description: "Path to the file. Can be relative (defaults to current working directory) or absolute",
+          },
+          line: {
+            type: "number",
+            description: "Line number (1-based). Required if searchString is not provided.",
+          },
+          column: {
+            type: "number",
+            description: "Column number (1-based). Required if searchString is not provided.",
+          },
+          searchString: {
+            type: "string",
+            description: "String to search for in the file to determine the symbol position. Alternative to line/column.",
+          },
+          matchType: {
+            type: "string",
+            description: "Type of matching when using searchString: 'exact' for exact match, 'prefix' for prefix matching, 'contains' for substring match",
+            enum: ["exact", "prefix", "contains"],
+          },
+          command: {
+            type: "string",
+            description: "Navigation command: GoToDefinition, GoToDeclaration, GoToReferences, GoToImplementation",
+            enum: ["GoToDefinition", "GoToDeclaration", "GoToReferences", "GoToImplementation"],
+          },
+          fileContents: {
+            type: "string",
+            description: "Current contents of the file (optional if file exists on disk)",
+          },
+        },
+        required: ["filepath", "command"],
+      },
+      returns: {
+        type: "array",
+        description: "Array of locations with file paths, line numbers, and column numbers",
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "ycmdDiagnostics",
+      description: "Get error and warning diagnostics for a file. You can specify the position either with line/column numbers OR with a searchString that will be located automatically.",
+      parameters: {
+        type: "object",
+        properties: {
+          filepath: {
+            type: "string",
+            description: "Path to the file. Can be relative (defaults to current working directory) or absolute",
+          },
+          line: {
+            type: "number",
+            description: "Line number (1-based, optional, defaults to 1). Required if searchString is not provided.",
+          },
+          column: {
+            type: "number", 
+            description: "Column number (1-based, optional, defaults to 1). Required if searchString is not provided.",
+          },
+          searchString: {
+            type: "string",
+            description: "String to search for in the file to determine the diagnostic position. Alternative to line/column.",
+          },
+          matchType: {
+            type: "string",
+            description: "Type of matching when using searchString: 'exact' for exact match, 'prefix' for prefix matching, 'contains' for substring match",
+            enum: ["exact", "prefix", "contains"],
+          },
+          fileContents: {
+            type: "string",
+            description: "Current contents of the file (optional if file exists on disk)",
+          },
+        },
+        required: ["filepath"],
+      },
+      returns: {
+        type: "array",
+        description: "Array of diagnostic messages with severity, location, and description",
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "ycmdRefactor",
+      description: "Execute refactoring operations like rename, extract method, organize imports",
+      parameters: {
+        type: "object",
+        properties: {
+          filepath: {
+            type: "string",
+            description: "Path to the file. Can be relative (defaults to current working directory) or absolute",
+          },
+          line: {
+            type: "number",
+            description: "Line number (1-based)",
+          },
+          column: {
+            type: "number",
+            description: "Column number (1-based)",
+          },
+          command: {
+            type: "string",
+            description: "Refactoring command: RefactorRename, RefactorExtractMethod, RefactorOrganizeImports, RefactorFixIt",
+            enum: ["RefactorRename", "RefactorExtractMethod", "RefactorOrganizeImports", "RefactorFixIt"],
+          },
+          newName: {
+            type: "string",
+            description: "New name for rename operations",
+          },
+          fileContents: {
+            type: "string",
+            description: "Current contents of the file (optional if file exists on disk)",
+          },
+        },
+        required: ["filepath", "line", "column", "command"],
+      },
+      returns: {
+        type: "object",
+        description: "Refactoring result with file changes and status",
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "ycmdSignatureHelp",
+      description: "Get function signature help and parameter information at cursor position",
+      parameters: {
+        type: "object",
+        properties: {
+          filepath: {
+            type: "string",
+            description: "Path to the file. Can be relative (defaults to current working directory) or absolute",
+          },
+          line: {
+            type: "number",
+            description: "Line number (1-based)",
+          },
+          column: {
+            type: "number",
+            description: "Column number (1-based)",
+          },
+          fileContents: {
+            type: "string",
+            description: "Current contents of the file (optional if file exists on disk)",
+          },
+        },
+        required: ["filepath", "line", "column"],
+      },
+      returns: {
+        type: "object",
+        description: "Signature help with function signatures and parameter information",
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "getLocations",
+      description: "Find line and column positions for a given string in a file. Useful for locating code elements by name rather than coordinates.",
+      parameters: {
+        type: "object",
+        properties: {
+          filepath: {
+            type: "string",
+            description: "Path to the file. Can be relative (defaults to current working directory) or absolute",
+          },
+          searchString: {
+            type: "string",
+            description: "The string to search for in the file",
+          },
+          fileContents: {
+            type: "string",
+            description: "Current contents of the file (optional if file exists on disk)",
+          },
+          matchType: {
+            type: "string",
+            description: "Type of matching: 'exact' for exact string match, 'prefix' for prefix matching at word boundaries, 'contains' for case-insensitive substring match",
+            enum: ["exact", "prefix", "contains"],
+          },
+          maxResults: {
+            type: "number",
+            description: "Maximum number of results to return (default: 50)",
+          },
+        },
+        required: ["filepath", "searchString"],
+      },
+      returns: {
+        type: "object",
+        description: "Array of locations with line numbers, column numbers, and context information",
+        properties: {
+          success: { type: "boolean" },
+          locations: { type: "array" },
+          message: { type: "string" }
+        }
+      },
+    },
+  },
+];

package/src/agents/tools/ycmd/detection.ts

@@ -0,0 +1,211 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { execSync } from 'child_process';
+
+/**
+ * Utility class for detecting existing ycmd installations
+ */
+export class YcmdDetection {
+  /**
+   * Common paths where ycmd might be installed
+   */
+  private static readonly COMMON_PATHS = [
+    // System-wide installations
+    '/usr/local/bin/ycmd',
+    '/usr/bin/ycmd',
+    '/opt/ycmd',
+    // User installations
+    path.join(os.homedir(), '.local/bin/ycmd'),
+    path.join(os.homedir(), '.vim/plugged/YouCompleteMe/third_party/ycmd'),
+    path.join(os.homedir(), '.config/nvim/plugged/YouCompleteMe/third_party/ycmd'),
+    // Knowhow installation path
+    path.join(os.homedir(), '.knowhow/ycmd'),
+  ];
+
+  /**
+   * Check if ycmd is available in the system PATH
+   */
+  static isInPath(): boolean {
+    try {
+      execSync('which ycmd', { stdio: 'pipe' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Find all available ycmd installations
+   */
+  static findInstallations(): string[] {
+    const installations: string[] = [];
+
+    // Check common paths
+    for (const ycmdPath of this.COMMON_PATHS) {
+      if (this.isValidYcmdInstallation(ycmdPath)) {
+        installations.push(ycmdPath);
+      }
+    }
+
+    // Check if ycmd is in PATH
+    if (this.isInPath()) {
+      try {
+        const pathResult = execSync('which ycmd', { encoding: 'utf8' }).trim();
+        if (pathResult && !installations.includes(pathResult)) {
+          installations.push(pathResult);
+        }
+      } catch {
+        // Ignore errors
+      }
+    }
+
+    return installations;
+  }
+
+  /**
+   * Get the preferred ycmd installation path
+   */
+  static getPreferredInstallation(): string | null {
+    const installations = this.findInstallations();
+    
+    if (installations.length === 0) {
+      return null;
+    }
+
+    // Prefer knowhow installation first
+    const knowhowPath = path.join(os.homedir(), '.knowhow/ycmd');
+    if (installations.includes(knowhowPath)) {
+      return knowhowPath;
+    }
+
+    // Then prefer system PATH
+    if (this.isInPath()) {
+      try {
+        return execSync('which ycmd', { encoding: 'utf8' }).trim();
+      } catch {
+        // Fall through to first installation
+      }
+    }
+
+    // Return first available installation
+    return installations[0];
+  }
+
+  /**
+   * Check if a path contains a valid ycmd installation
+   */
+  static isValidYcmdInstallation(ycmdPath: string): boolean {
+    try {
+      // Check if directory exists
+      if (!fs.existsSync(ycmdPath)) {
+        return false;
+      }
+
+      const stat = fs.statSync(ycmdPath);
+      
+      // If it's an executable file (direct ycmd binary)
+      if (stat.isFile()) {
+        return this.isExecutable(ycmdPath);
+      }
+
+      // If it's a directory, look for ycmd executable or ycmd.py
+      if (stat.isDirectory()) {
+        const ycmdBinary = path.join(ycmdPath, 'ycmd');
+        const ycmdScript = path.join(ycmdPath, 'ycmd.py');
+        const ycmdMainScript = path.join(ycmdPath, 'ycmd', '__main__.py');
+
+        return fs.existsSync(ycmdBinary) || 
+               fs.existsSync(ycmdScript) || 
+               fs.existsSync(ycmdMainScript);
+      }
+
+      return false;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Check if a file is executable
+   */
+  private static isExecutable(filePath: string): boolean {
+    try {
+      fs.accessSync(filePath, fs.constants.F_OK | fs.constants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get the ycmd executable command for a given installation path
+   */
+  static getYcmdCommand(ycmdPath: string): string[] {
+    if (!this.isValidYcmdInstallation(ycmdPath)) {
+      throw new Error(`Invalid ycmd installation: ${ycmdPath}`);
+    }
+
+    const stat = fs.statSync(ycmdPath);
+
+    // If it's an executable file
+    if (stat.isFile() && this.isExecutable(ycmdPath)) {
+      return [ycmdPath];
+    }
+
+    // If it's a directory, determine the appropriate command
+    if (stat.isDirectory()) {
+      const ycmdBinary = path.join(ycmdPath, 'ycmd');
+      const ycmdScript = path.join(ycmdPath, 'ycmd.py');
+      const ycmdMainScript = path.join(ycmdPath, 'ycmd', '__main__.py');
+
+      if (fs.existsSync(ycmdBinary) && this.isExecutable(ycmdBinary)) {
+        return [ycmdBinary];
+      }
+
+      if (fs.existsSync(ycmdScript)) {
+        return ['python3', ycmdScript];
+      }
+
+      if (fs.existsSync(ycmdMainScript)) {
+        return ['python3', '-m', 'ycmd'];
+      }
+    }
+
+    throw new Error(`Could not determine ycmd command for: ${ycmdPath}`);
+  }
+
+  /**
+   * Check if Python is available for running ycmd
+   */
+  static isPythonAvailable(): boolean {
+    try {
+      execSync('python3 --version', { stdio: 'pipe' });
+      return true;
+    } catch {
+      try {
+        execSync('python --version', { stdio: 'pipe' });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  }
+
+  /**
+   * Get Python command (python3 or python)
+   */
+  static getPythonCommand(): string {
+    try {
+      execSync('python3 --version', { stdio: 'pipe' });
+      return 'python3';
+    } catch {
+      try {
+        execSync('python --version', { stdio: 'pipe' });
+        return 'python';
+      } catch {
+        throw new Error('Python is not available in PATH');
+      }
+    }
+  }
+}

package/src/agents/tools/ycmd/index.ts

@@ -0,0 +1,11 @@
+// Import all ycmd tool functions
+export { ycmdStart } from './tools/start';
+export { ycmdCompletion } from './tools/completion';
+export { ycmdGoTo } from './tools/goto';
+export { ycmdDiagnostics } from './tools/diagnostics';
+export { ycmdRefactor } from './tools/refactor';
+export { ycmdSignatureHelp } from './tools/signature';
+export { getLocations } from './tools/getLocations';
+
+// Export definitions for tool registration
+export { definitions } from './definitions';