@tyvm/knowhow 0.0.33 → 0.0.35

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

@@ -0,0 +1,173 @@
+import { ycmdServerManager } from "../serverManager";
+import * as fs from "fs";
+
+export interface GetLocationsParams {
+  filepath: string;
+  searchString: string;
+  fileContents?: string;
+  matchType?: "exact" | "prefix" | "contains";
+  maxResults?: number;
+}
+
+export interface StringLocation {
+  line: number;
+  column: number;
+  context: string;
+  matchIndex: number;
+}
+
+/**
+ * Find line and column positions for a given string in a file
+ */
+export async function getLocations(params: GetLocationsParams): Promise<{
+  success: boolean;
+  locations?: StringLocation[];
+  message: string;
+}> {
+  try {
+    // Validate parameters
+    if (!params.filepath) {
+      return {
+        success: false,
+        message: "filepath is required",
+      };
+    }
+
+    if (!params.searchString) {
+      return {
+        success: false,
+        message: "searchString is required",
+      };
+    }
+
+    // Read file contents if not provided
+    let contents = params.fileContents;
+    if (!contents) {
+      try {
+        contents = await fs.promises.readFile(params.filepath, "utf8");
+      } catch (error) {
+        return {
+          success: false,
+          message: `Failed to read file: ${(error as Error).message}`,
+        };
+      }
+    }
+
+    const matchType = params.matchType || "exact";
+    const maxResults = params.maxResults || 50;
+    const locations: StringLocation[] = [];
+
+    // Split content into lines for line number calculation
+    const lines = contents.split('\n');
+    
+    // Search through each line
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+      const line = lines[lineIndex];
+      const lineNumber = lineIndex + 1; // 1-based line numbers
+      
+      let searchIndex = 0;
+      while (searchIndex < line.length) {
+        let matchIndex = -1;
+        
+        // Apply different matching strategies
+        switch (matchType) {
+          case "exact":
+            matchIndex = line.indexOf(params.searchString, searchIndex);
+            break;
+          case "prefix":
+            // Find next occurrence where searchString is a prefix
+            for (let i = searchIndex; i <= line.length - params.searchString.length; i++) {
+              if (line.substring(i, i + params.searchString.length) === params.searchString) {
+                // Check if it's at word boundary or start
+                if (i === 0 || /\W/.test(line[i - 1])) {
+                  matchIndex = i;
+                  break;
+                }
+              }
+            }
+            break;
+          case "contains":
+            matchIndex = line.toLowerCase().indexOf(params.searchString.toLowerCase(), searchIndex);
+            break;
+        }
+
+        if (matchIndex === -1) {
+          break; // No more matches in this line
+        }
+
+        // Calculate context (show part of the line around the match)
+        const contextStart = Math.max(0, matchIndex - 20);
+        const contextEnd = Math.min(line.length, matchIndex + params.searchString.length + 20);
+        const context = line.substring(contextStart, contextEnd);
+
+        locations.push({
+          line: lineNumber,
+          column: matchIndex + 1, // 1-based column numbers
+          context: context.trim(),
+          matchIndex: locations.length
+        });
+
+        // Stop if we've reached max results
+        if (locations.length >= maxResults) {
+          break;
+        }
+
+        // Continue searching from after this match
+        searchIndex = matchIndex + 1;
+      }
+
+      // Stop if we've reached max results
+      if (locations.length >= maxResults) {
+        break;
+      }
+    }
+
+    if (locations.length === 0) {
+      return {
+        success: true,
+        locations: [],
+        message: `No matches found for "${params.searchString}" in ${params.filepath}`,
+      };
+    }
+
+    return {
+      success: true,
+      locations,
+      message: `Found ${locations.length} location${locations.length === 1 ? '' : 's'} for "${params.searchString}"`,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed to get locations: ${(error as Error).message}`,
+    };
+  }
+}
+
+/**
+ * Helper function to resolve string to line/column position
+ * Returns the first match or null if not found
+ */
+export async function resolveStringToLocation(
+  filepath: string,
+  searchString: string,
+  fileContents?: string,
+  matchType: "exact" | "prefix" | "contains" = "exact"
+): Promise<{ line: number; column: number } | null> {
+  const result = await getLocations({
+    filepath,
+    searchString,
+    fileContents,
+    matchType,
+    maxResults: 1
+  });
+
+  if (result.success && result.locations && result.locations.length > 0) {
+    const location = result.locations[0];
+    return {
+      line: location.line,
+      column: location.column
+    };
+  }
+
+  return null;
+}

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

@@ -0,0 +1,169 @@
+import { YcmdClient, getFileTypes } from "../client";
+import { ycmdServerManager } from "../serverManager";
+import { ycmdStart } from "./start";
+import { resolveFilePath } from "../utils/pathUtils";
+import { resolveStringToLocation } from "./getLocations";
+import * as fs from "fs";
+
+export interface YcmdGoToParams {
+  filepath: string;
+  line?: number;
+  column?: number;
+  searchString?: string;
+  matchType?: "exact" | "prefix" | "contains";
+  contents?: string;
+  command: "GoTo" | "GoToDeclaration" | "GoToReferences" | "GoToDefinition";
+}
+
+export interface GoToLocation {
+  filepath: string;
+  line: number;
+  column: number;
+  description?: string;
+}
+
+/**
+ * Navigate to definitions, declarations, or references
+ */
+export async function ycmdGoTo(params: YcmdGoToParams): Promise<{
+  success: boolean;
+  locations?: GoToLocation[];
+  message: string;
+}> {
+  try {
+    let line = params.line;
+    let column = params.column;
+
+    // If searchString is provided instead of line/column, resolve it
+    if (params.searchString && (!line || !column)) {
+      const location = await resolveStringToLocation(
+        params.filepath,
+        params.searchString,
+        params.contents,
+        params.matchType || "exact"
+      );
+      
+      if (!location) {
+        return {
+          success: false,
+          message: `Could not find "${params.searchString}" in file ${params.filepath}`,
+        };
+      }
+      
+      line = location.line;
+      column = location.column;
+    }
+
+    // Validate that we have line and column
+    if (!line || !column) {
+      return {
+        success: false,
+        message: "Either line/column or searchString must be provided",
+      };
+    }
+
+    // Validate parameters
+    if (!params.filepath) {
+      return {
+        success: false,
+        message: "filepath is required",
+      };
+    }
+
+    // Setup client and notify file using utility method
+    const setupResult = await ycmdServerManager.setupClientAndNotifyFile({
+      filepath: params.filepath,
+      fileContents: params.contents
+    });
+    
+    if (!setupResult.success) {
+      return {
+        success: false,
+        message: setupResult.message
+      };
+    }
+
+    const { client, resolvedFilePath, contents, filetypes } = setupResult;
+
+    // Execute the appropriate goto command
+    let response: any;
+
+    switch (params.command) {
+      case "GoToDeclaration":
+        response = await client.goToDeclaration(
+          resolvedFilePath,
+          line,
+          column,
+          contents,
+          filetypes
+        );
+        break;
+
+      case "GoToReferences":
+        response = await client.goToReferences(
+          resolvedFilePath,
+          line,
+          column,
+          contents,
+          filetypes
+        );
+        break;
+
+      case "GoToDefinition":
+      case "GoTo":
+      default:
+        response = await client.goToDefinition(
+          resolvedFilePath,
+          line,
+          column,
+          contents,
+          filetypes
+        );
+        break;
+    }
+
+    // Handle response format (can be single location or array)
+    let locations: GoToLocation[];
+
+    if (Array.isArray(response)) {
+      locations = response.map((loc) => ({
+        filepath: loc.filepath,
+        line: loc.line_num,
+        column: loc.column_num,
+        description: loc.description,
+      }));
+    } else if (response && response.filepath) {
+      locations = [
+        {
+          filepath: response.filepath,
+          line: response.line_num,
+          column: response.column_num,
+          description: response.description,
+        },
+      ];
+    } else {
+      locations = [];
+    }
+
+    if (locations.length === 0) {
+      return {
+        success: true,
+        locations: [],
+        message: `No locations found for ${params.command}`,
+      };
+    }
+
+    return {
+      success: true,
+      locations,
+      message: `Found ${locations.length} locations for ${params.command}${
+        locations.length === 1 ? "" : "s"
+      }`,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed to get ${params.command}: ${(error as Error).message}`,
+    };
+  }
+}

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

@@ -0,0 +1,204 @@
+import { YcmdClient, getFileTypes } from '../client';
+import { ycmdServerManager } from '../serverManager';
+import { resolveFilePath } from '../utils/pathUtils';
+import * as fs from 'fs';
+
+export interface YcmdRefactorParams {
+  filepath: string;
+  line: number;
+  column: number;
+  contents?: string;
+  command: 'rename' | 'extract_method' | 'organize_imports' | 'fix_it';
+  newName?: string; // For rename operations
+  fixitIndex?: number; // For fix_it operations - which fix to apply
+}
+
+export interface RefactorEdit {
+  filepath: string;
+  range: {
+    start: {
+      line: number;
+      column: number;
+    };
+    end: {
+      line: number;
+      column: number;
+    };
+  };
+  newText: string;
+}
+
+export interface RefactorResult {
+  edits: RefactorEdit[];
+  description?: string;
+}
+
+/**
+ * Execute refactoring operations
+ */
+export async function ycmdRefactor(params: YcmdRefactorParams): Promise<{
+  success: boolean;
+  result?: RefactorResult;
+  message: string;
+}> {
+  try {
+    // Validate parameters
+    if (!params.filepath) {
+      return {
+        success: false,
+        message: 'filepath is required'
+      };
+    }
+
+    if (typeof params.line !== 'number' || typeof params.column !== 'number') {
+      return {
+        success: false,
+        message: 'line and column must be numbers'
+      };
+    }
+
+    if (!['rename', 'extract_method', 'organize_imports', 'fix_it'].includes(params.command)) {
+      return {
+        success: false,
+        message: 'command must be one of: rename, extract_method, organize_imports, fix_it'
+      };
+    }
+
+    if (params.command === 'rename' && !params.newName) {
+      return {
+        success: false,
+        message: 'newName is required for rename operations'
+      };
+    }
+
+    if (params.command === 'fix_it' && typeof params.fixitIndex !== 'number') {
+      return {
+        success: false,
+        message: 'fixitIndex is required for fix_it operations'
+      };
+    }
+
+    // Setup client and notify file using utility method
+    const setupResult = await ycmdServerManager.setupClientAndNotifyFile({
+      filepath: params.filepath,
+      fileContents: params.contents
+    });
+    
+    if (!setupResult.success) {
+      return {
+        success: false,
+        message: setupResult.message
+      };
+    }
+
+    const { client, resolvedFilePath, contents, filetypes } = setupResult;
+
+    let response: any;
+
+    // Execute the appropriate refactor command
+    switch (params.command) {
+      case 'rename':
+        response = await client.refactorRename(
+          resolvedFilePath,
+          params.line,
+          params.column,
+          contents,
+          filetypes,
+          params.newName!
+        );
+        break;
+
+      case 'extract_method':
+        response = await client.refactorExtractMethod(
+          resolvedFilePath,
+          params.line,
+          params.column,
+          contents,
+          filetypes
+        );
+        break;
+
+      case 'organize_imports':
+        response = await client.refactorOrganizeImports(
+          resolvedFilePath,
+          params.line,
+          params.column,
+          contents,
+          filetypes
+        );
+        break;
+
+      case 'fix_it':
+        response = await client.refactorFixIt(
+          resolvedFilePath,
+          params.line,
+          params.column,
+          contents,
+          filetypes,
+          params.fixitIndex!
+        );
+        break;
+    }
+
+    // Parse response into standard format
+    let result: RefactorResult;
+
+    if (response && response.fixits && response.fixits.length > 0) {
+      // Handle fixit response format
+      const fixit = response.fixits[0];
+      result = {
+        edits: fixit.chunks.map((chunk: any) => ({
+          filepath: resolvedFilePath,
+          range: {
+            start: {
+              line: chunk.range.start.line_num,
+              column: chunk.range.start.column_num
+            },
+            end: {
+              line: chunk.range.end.line_num,
+              column: chunk.range.end.column_num
+            }
+          },
+          newText: chunk.replacement_text
+        })),
+        description: fixit.text
+      };
+    } else if (response && response.chunks) {
+      // Handle direct chunks response format
+      result = {
+        edits: response.chunks.map((chunk: any) => ({
+          filepath: resolvedFilePath,
+          range: {
+            start: {
+              line: chunk.range.start.line_num,
+              column: chunk.range.start.column_num
+            },
+            end: {
+              line: chunk.range.end.line_num,
+              column: chunk.range.end.column_num
+            }
+          },
+          newText: chunk.replacement_text
+        })),
+        description: response.description
+      };
+    } else {
+      return {
+        success: false,
+        message: `No refactoring available for ${params.command} at this location`
+      };
+    }
+
+    return {
+      success: true,
+      result,
+      message: `Successfully generated ${params.command} refactoring with ${result.edits.length} edit${result.edits.length === 1 ? '' : 's'}`
+    };
+
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed to execute ${params.command}: ${(error as Error).message}`
+    };
+  }
+}

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

@@ -0,0 +1,174 @@
+import { YcmdClient, getFileTypes } from "../client";
+import { ycmdServerManager } from "../serverManager";
+import { resolveFilePath } from "../utils/pathUtils";
+import * as fs from "fs";
+
+export interface YcmdSignatureHelpParams {
+  filepath: string;
+  line: number;
+  column: number;
+  contents?: string;
+}
+
+export interface SignatureParameter {
+  label: string;
+  documentation?: string;
+}
+
+export interface SignatureInformation {
+  label: string;
+  documentation?: string;
+  parameters?: SignatureParameter[];
+}
+
+export interface SignatureHelp {
+  signatures: SignatureInformation[];
+  activeSignature?: number;
+  activeParameter?: number;
+}
+
+/**
+ * Get function signature hints
+ */
+export async function ycmdSignatureHelp(
+  params: YcmdSignatureHelpParams
+): Promise<{
+  success: boolean;
+  signatureHelp?: SignatureHelp;
+  message: string;
+}> {
+  try {
+    // Resolve file path
+    const resolvedFilePath = resolveFilePath(params.filepath);
+
+    // Validate parameters
+    if (!params.filepath) {
+      return {
+        success: false,
+        message: "filepath is required",
+      };
+    }
+
+    if (typeof params.line !== "number" || typeof params.column !== "number") {
+      return {
+        success: false,
+        message: "line and column must be numbers",
+      };
+    }
+
+    // Setup client and notify file using utility method
+    const setupResult = await ycmdServerManager.setupClientAndNotifyFile({
+      filepath: params.filepath,
+      fileContents: params.contents,
+    });
+
+    if (!setupResult.success) {
+      return {
+        success: false,
+        message: setupResult.message,
+      };
+    }
+
+    // Create client
+    const { client, contents, filetypes } = setupResult;
+
+    // Get signature help
+    const response = await client.getSignatureHelp(
+      resolvedFilePath,
+      params.line,
+      params.column,
+      contents,
+      filetypes
+    );
+
+    // Handle different response formats
+    let signatureHelp: SignatureHelp;
+
+    if (response && response.signatures) {
+      // LSP-style response
+      signatureHelp = {
+        signatures: response.signatures.map((sig: any) => ({
+          label: sig.label,
+          documentation: sig.documentation,
+          parameters: sig.parameters?.map((param: any) => ({
+            label: param.label,
+            documentation: param.documentation,
+          })),
+        })),
+        activeSignature: response.activeSignature,
+        activeParameter: response.activeParameter,
+      };
+    } else if (response && response.detailed_info) {
+      // ycmd detailed_info response - convert to signature format
+      const detailedInfo = response.detailed_info;
+      signatureHelp = {
+        signatures: [
+          {
+            label: detailedInfo,
+            documentation: response.extra_menu_info,
+          },
+        ],
+        activeSignature: 0,
+        activeParameter: 0,
+      };
+    } else if (response && typeof response === "string") {
+      // Simple string response
+      signatureHelp = {
+        signatures: [
+          {
+            label: response,
+          },
+        ],
+        activeSignature: 0,
+        activeParameter: 0,
+      };
+    } else {
+      return {
+        success: true,
+        signatureHelp: {
+          signatures: [],
+        },
+        message: "No signature information available at this location",
+      };
+    }
+
+    const signatureCount = signatureHelp.signatures.length;
+    let message = "No signature information available";
+
+    if (signatureCount > 0) {
+      message = `Found ${signatureCount} signature${
+        signatureCount === 1 ? "" : "s"
+      }`;
+
+      if (signatureHelp.activeSignature !== undefined && signatureCount > 1) {
+        message += ` (showing signature ${
+          signatureHelp.activeSignature + 1
+        } of ${signatureCount})`;
+      }
+
+      if (signatureHelp.activeParameter !== undefined) {
+        const activeSignature =
+          signatureHelp.signatures[signatureHelp.activeSignature || 0];
+        if (
+          activeSignature?.parameters &&
+          activeSignature.parameters.length > 0
+        ) {
+          message += `, parameter ${signatureHelp.activeParameter + 1} of ${
+            activeSignature.parameters.length
+          }`;
+        }
+      }
+    }
+
+    return {
+      success: true,
+      signatureHelp,
+      message,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed to get signature help: ${(error as Error).message}`,
+    };
+  }
+}