centaurus-cli 3.0.1 → 3.1.0

package/dist/tools/inspect-symbol.js

@@ -1,341 +1,326 @@
-import * as fs from 'fs/promises';
-import * as path from 'path';
-export class InspectSymbolTool {
-    MAX_SYMBOLS = 100;
-    languageParsers = [
-        {
-            extensions: ['.ts', '.tsx', '.js', '.jsx'],
-            name: 'TypeScript/JavaScript',
-            parse: this.parseTypeScriptJavaScript.bind(this),
-        },
-        {
-            extensions: ['.py'],
-            name: 'Python',
-            parse: this.parsePython.bind(this),
-        },
-        {
-            extensions: ['.java'],
-            name: 'Java',
-            parse: this.parseJava.bind(this),
-        },
-    ];
-    async execute(params, cwd) {
-        const { filePath } = params;
-        const fullPath = path.resolve(cwd, filePath);
-        // Check if file exists
-        try {
-            await fs.access(fullPath);
-        }
-        catch (error) {
-            throw new Error(`File not found: "${filePath}"\n` +
-                `Suggestion: Use find_files to locate the file first, or check the file path.`);
-        }
-        // Detect language from extension
-        const ext = path.extname(filePath).toLowerCase();
-        const parser = this.languageParsers.find(p => p.extensions.includes(ext));
-        if (!parser) {
-            const supportedExts = this.languageParsers
-                .flatMap(p => p.extensions)
-                .join(', ');
-            throw new Error(`Unsupported file type: ${ext}\n` +
-                `Suggestion: inspect_symbol supports: ${supportedExts}`);
-        }
-        // Read file content
-        const content = await fs.readFile(fullPath, 'utf-8');
-        // Parse symbols
-        const allSymbols = parser.parse(content);
-        const truncated = allSymbols.length > this.MAX_SYMBOLS;
-        const symbols = allSymbols.slice(0, this.MAX_SYMBOLS);
-        return {
-            symbols,
-            filePath: this.normalizePath(filePath),
-            language: parser.name,
-            truncated,
-        };
+import * as fs from "fs/promises";
+import * as path from "path";
+class InspectSymbolTool {
+  MAX_SYMBOLS = 100;
+  languageParsers = [
+    {
+      extensions: [".ts", ".tsx", ".js", ".jsx"],
+      name: "TypeScript/JavaScript",
+      parse: this.parseTypeScriptJavaScript.bind(this)
+    },
+    {
+      extensions: [".py"],
+      name: "Python",
+      parse: this.parsePython.bind(this)
+    },
+    {
+      extensions: [".java"],
+      name: "Java",
+      parse: this.parseJava.bind(this)
     }
-    parseTypeScriptJavaScript(content) {
-        const symbols = [];
-        const lines = content.split('\n');
-        // Track current class context for methods
-        let currentClass = null;
-        let classDepth = 0;
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            const lineNumber = i + 1;
-            // Track class context
-            const classMatch = line.match(/^(export\s+)?(abstract\s+)?class\s+(\w+)(\s+extends\s+(\w+))?/);
-            if (classMatch) {
-                currentClass = classMatch[3];
-                classDepth = this.getIndentLevel(line);
-                const signature = line.trim();
-                symbols.push({
-                    name: classMatch[3],
-                    type: 'class',
-                    signature,
-                    line: lineNumber,
-                });
-                continue;
-            }
-            // Reset class context when we exit the class
-            if (currentClass && line.trim() === '}' && this.getIndentLevel(line) === classDepth) {
-                currentClass = null;
-            }
-            // Interface declarations
-            const interfaceMatch = line.match(/^(export\s+)?interface\s+(\w+)/);
-            if (interfaceMatch) {
-                symbols.push({
-                    name: interfaceMatch[2],
-                    type: 'interface',
-                    signature: line.trim(),
-                    line: lineNumber,
-                });
-                continue;
-            }
-            // Type declarations
-            const typeMatch = line.match(/^(export\s+)?type\s+(\w+)/);
-            if (typeMatch) {
-                symbols.push({
-                    name: typeMatch[2],
-                    type: 'type',
-                    signature: line.trim(),
-                    line: lineNumber,
-                });
-                continue;
-            }
-            // Function declarations
-            const functionMatch = line.match(/^(export\s+)?(async\s+)?function\s+(\w+)\s*(\([^)]*\))/);
-            if (functionMatch) {
-                symbols.push({
-                    name: functionMatch[3],
-                    type: 'function',
-                    signature: line.trim(),
-                    line: lineNumber,
-                });
-                continue;
-            }
-            // Arrow function exports
-            const arrowMatch = line.match(/^export\s+const\s+(\w+)\s*=\s*(\([^)]*\))?\s*=>/);
-            if (arrowMatch) {
-                symbols.push({
-                    name: arrowMatch[1],
-                    type: 'export',
-                    signature: line.trim(),
-                    line: lineNumber,
-                });
-                continue;
-            }
-            // Const exports (non-arrow)
-            const constExportMatch = line.match(/^export\s+const\s+(\w+)/);
-            if (constExportMatch && !line.includes('=>')) {
-                symbols.push({
-                    name: constExportMatch[1],
-                    type: 'export',
-                    signature: line.trim(),
-                    line: lineNumber,
-                });
-                continue;
-            }
-            // Method declarations (inside classes)
-            if (currentClass) {
-                const methodMatch = line.match(/^\s+(public\s+|private\s+|protected\s+)?(static\s+)?(async\s+)?(\w+)\s*(\([^)]*\))/);
-                if (methodMatch && !line.includes('function') && methodMatch[4] !== 'if' && methodMatch[4] !== 'for' && methodMatch[4] !== 'while') {
-                    symbols.push({
-                        name: methodMatch[4],
-                        type: 'method',
-                        signature: line.trim(),
-                        line: lineNumber,
-                        parentClass: currentClass,
-                    });
-                }
-            }
-        }
-        return symbols;
+  ];
+  async execute(params, cwd) {
+    const { filePath } = params;
+    const fullPath = path.resolve(cwd, filePath);
+    try {
+      await fs.access(fullPath);
+    } catch (error) {
+      throw new Error(
+        `File not found: "${filePath}"
+Suggestion: Use find_files to locate the file first, or check the file path.`
+      );
     }
-    parsePython(content) {
-        const symbols = [];
-        const lines = content.split('\n');
-        let currentClass = null;
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            const lineNumber = i + 1;
-            // Class definitions
-            const classMatch = line.match(/^class\s+(\w+)(\([^)]*\))?:/);
-            if (classMatch) {
-                currentClass = classMatch[1];
-                symbols.push({
-                    name: classMatch[1],
-                    type: 'class',
-                    signature: line.trim(),
-                    line: lineNumber,
-                });
-                continue;
-            }
-            // Function definitions (top-level)
-            const functionMatch = line.match(/^def\s+(\w+)\s*(\([^)]*\))/);
-            if (functionMatch) {
-                currentClass = null; // Reset class context for top-level functions
-                symbols.push({
-                    name: functionMatch[1],
-                    type: 'function',
-                    signature: line.trim(),
-                    line: lineNumber,
-                });
-                continue;
-            }
-            // Method definitions (indented, inside classes)
-            const methodMatch = line.match(/^\s+def\s+(\w+)\s*(\([^)]*\))/);
-            if (methodMatch && currentClass) {
-                symbols.push({
-                    name: methodMatch[1],
-                    type: 'method',
-                    signature: line.trim(),
-                    line: lineNumber,
-                    parentClass: currentClass,
-                });
-            }
-        }
-        return symbols;
+    const ext = path.extname(filePath).toLowerCase();
+    const parser = this.languageParsers.find((p) => p.extensions.includes(ext));
+    if (!parser) {
+      const supportedExts = this.languageParsers.flatMap((p) => p.extensions).join(", ");
+      throw new Error(
+        `Unsupported file type: ${ext}
+Suggestion: inspect_symbol supports: ${supportedExts}`
+      );
     }
-    parseJava(content) {
-        const symbols = [];
-        const lines = content.split('\n');
-        let currentClass = null;
-        let classDepth = 0;
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            const lineNumber = i + 1;
-            // Class declarations
-            const classMatch = line.match(/^\s*(public\s+|private\s+|protected\s+)?(abstract\s+|final\s+)?class\s+(\w+)(\s+extends\s+(\w+))?/);
-            if (classMatch) {
-                currentClass = classMatch[3];
-                classDepth = this.getIndentLevel(line);
-                symbols.push({
-                    name: classMatch[3],
-                    type: 'class',
-                    signature: line.trim(),
-                    line: lineNumber,
-                });
-                continue;
-            }
-            // Interface declarations
-            const interfaceMatch = line.match(/^\s*(public\s+)?interface\s+(\w+)/);
-            if (interfaceMatch) {
-                symbols.push({
-                    name: interfaceMatch[2],
-                    type: 'interface',
-                    signature: line.trim(),
-                    line: lineNumber,
-                });
-                continue;
-            }
-            // Reset class context when we exit
-            if (currentClass && line.trim() === '}' && this.getIndentLevel(line) === classDepth) {
-                currentClass = null;
-            }
-            // Method declarations (inside classes)
-            if (currentClass) {
-                const methodMatch = line.match(/^\s+(public\s+|private\s+|protected\s+)?(static\s+)?(final\s+)?(\w+)\s+(\w+)\s*(\([^)]*\))/);
-                if (methodMatch && !line.includes('class') && !line.includes('interface')) {
-                    symbols.push({
-                        name: methodMatch[5],
-                        type: 'method',
-                        signature: line.trim(),
-                        line: lineNumber,
-                        parentClass: currentClass,
-                    });
-                }
-            }
+    const content = await fs.readFile(fullPath, "utf-8");
+    const allSymbols = parser.parse(content);
+    const truncated = allSymbols.length > this.MAX_SYMBOLS;
+    const symbols = allSymbols.slice(0, this.MAX_SYMBOLS);
+    return {
+      symbols,
+      filePath: this.normalizePath(filePath),
+      language: parser.name,
+      truncated
+    };
+  }
+  parseTypeScriptJavaScript(content) {
+    const symbols = [];
+    const lines = content.split("\n");
+    let currentClass = null;
+    let classDepth = 0;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const lineNumber = i + 1;
+      const classMatch = line.match(/^(export\s+)?(abstract\s+)?class\s+(\w+)(\s+extends\s+(\w+))?/);
+      if (classMatch) {
+        currentClass = classMatch[3];
+        classDepth = this.getIndentLevel(line);
+        const signature = line.trim();
+        symbols.push({
+          name: classMatch[3],
+          type: "class",
+          signature,
+          line: lineNumber
+        });
+        continue;
+      }
+      if (currentClass && line.trim() === "}" && this.getIndentLevel(line) === classDepth) {
+        currentClass = null;
+      }
+      const interfaceMatch = line.match(/^(export\s+)?interface\s+(\w+)/);
+      if (interfaceMatch) {
+        symbols.push({
+          name: interfaceMatch[2],
+          type: "interface",
+          signature: line.trim(),
+          line: lineNumber
+        });
+        continue;
+      }
+      const typeMatch = line.match(/^(export\s+)?type\s+(\w+)/);
+      if (typeMatch) {
+        symbols.push({
+          name: typeMatch[2],
+          type: "type",
+          signature: line.trim(),
+          line: lineNumber
+        });
+        continue;
+      }
+      const functionMatch = line.match(/^(export\s+)?(async\s+)?function\s+(\w+)\s*(\([^)]*\))/);
+      if (functionMatch) {
+        symbols.push({
+          name: functionMatch[3],
+          type: "function",
+          signature: line.trim(),
+          line: lineNumber
+        });
+        continue;
+      }
+      const arrowMatch = line.match(/^export\s+const\s+(\w+)\s*=\s*(\([^)]*\))?\s*=>/);
+      if (arrowMatch) {
+        symbols.push({
+          name: arrowMatch[1],
+          type: "export",
+          signature: line.trim(),
+          line: lineNumber
+        });
+        continue;
+      }
+      const constExportMatch = line.match(/^export\s+const\s+(\w+)/);
+      if (constExportMatch && !line.includes("=>")) {
+        symbols.push({
+          name: constExportMatch[1],
+          type: "export",
+          signature: line.trim(),
+          line: lineNumber
+        });
+        continue;
+      }
+      if (currentClass) {
+        const methodMatch = line.match(/^\s+(public\s+|private\s+|protected\s+)?(static\s+)?(async\s+)?(\w+)\s*(\([^)]*\))/);
+        if (methodMatch && !line.includes("function") && methodMatch[4] !== "if" && methodMatch[4] !== "for" && methodMatch[4] !== "while") {
+          symbols.push({
+            name: methodMatch[4],
+            type: "method",
+            signature: line.trim(),
+            line: lineNumber,
+            parentClass: currentClass
+          });
         }
-        return symbols;
+      }
     }
-    getIndentLevel(line) {
-        const match = line.match(/^(\s*)/);
-        return match ? match[1].length : 0;
+    return symbols;
+  }
+  parsePython(content) {
+    const symbols = [];
+    const lines = content.split("\n");
+    let currentClass = null;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const lineNumber = i + 1;
+      const classMatch = line.match(/^class\s+(\w+)(\([^)]*\))?:/);
+      if (classMatch) {
+        currentClass = classMatch[1];
+        symbols.push({
+          name: classMatch[1],
+          type: "class",
+          signature: line.trim(),
+          line: lineNumber
+        });
+        continue;
+      }
+      const functionMatch = line.match(/^def\s+(\w+)\s*(\([^)]*\))/);
+      if (functionMatch) {
+        currentClass = null;
+        symbols.push({
+          name: functionMatch[1],
+          type: "function",
+          signature: line.trim(),
+          line: lineNumber
+        });
+        continue;
+      }
+      const methodMatch = line.match(/^\s+def\s+(\w+)\s*(\([^)]*\))/);
+      if (methodMatch && currentClass) {
+        symbols.push({
+          name: methodMatch[1],
+          type: "method",
+          signature: line.trim(),
+          line: lineNumber,
+          parentClass: currentClass
+        });
+      }
     }
-    normalizePath(filePath) {
-        return filePath.replace(/\\/g, '/');
+    return symbols;
+  }
+  parseJava(content) {
+    const symbols = [];
+    const lines = content.split("\n");
+    let currentClass = null;
+    let classDepth = 0;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const lineNumber = i + 1;
+      const classMatch = line.match(/^\s*(public\s+|private\s+|protected\s+)?(abstract\s+|final\s+)?class\s+(\w+)(\s+extends\s+(\w+))?/);
+      if (classMatch) {
+        currentClass = classMatch[3];
+        classDepth = this.getIndentLevel(line);
+        symbols.push({
+          name: classMatch[3],
+          type: "class",
+          signature: line.trim(),
+          line: lineNumber
+        });
+        continue;
+      }
+      const interfaceMatch = line.match(/^\s*(public\s+)?interface\s+(\w+)/);
+      if (interfaceMatch) {
+        symbols.push({
+          name: interfaceMatch[2],
+          type: "interface",
+          signature: line.trim(),
+          line: lineNumber
+        });
+        continue;
+      }
+      if (currentClass && line.trim() === "}" && this.getIndentLevel(line) === classDepth) {
+        currentClass = null;
+      }
+      if (currentClass) {
+        const methodMatch = line.match(/^\s+(public\s+|private\s+|protected\s+)?(static\s+)?(final\s+)?(\w+)\s+(\w+)\s*(\([^)]*\))/);
+        if (methodMatch && !line.includes("class") && !line.includes("interface")) {
+          symbols.push({
+            name: methodMatch[5],
+            type: "method",
+            signature: line.trim(),
+            line: lineNumber,
+            parentClass: currentClass
+          });
+        }
+      }
     }
+    return symbols;
+  }
+  getIndentLevel(line) {
+    const match = line.match(/^(\s*)/);
+    return match ? match[1].length : 0;
+  }
+  normalizePath(filePath) {
+    return filePath.replace(/\\/g, "/");
+  }
 }
-/**
- * Format inspect symbol results for display
- */
 function formatInspectSymbolResults(result) {
-    if (result.symbols.length === 0) {
-        return `No symbols found in ${result.filePath}`;
-    }
-    let output = `## Symbol Outline: ${result.filePath}\n\n`;
-    output += `**Language:** ${result.language}\n`;
-    output += `**Symbols Found:** ${result.symbols.length}${result.truncated ? ` (showing first ${result.symbols.length})` : ''}\n\n`;
-    // Group by type
-    const byType = {};
-    for (const symbol of result.symbols) {
-        const type = symbol.type;
-        if (!byType[type]) {
-            byType[type] = [];
-        }
-        byType[type].push(symbol);
+  if (result.symbols.length === 0) {
+    return `No symbols found in ${result.filePath}`;
+  }
+  let output = `## Symbol Outline: ${result.filePath}
+
+`;
+  output += `**Language:** ${result.language}
+`;
+  output += `**Symbols Found:** ${result.symbols.length}${result.truncated ? ` (showing first ${result.symbols.length})` : ""}
+
+`;
+  const byType = {};
+  for (const symbol of result.symbols) {
+    const type = symbol.type;
+    if (!byType[type]) {
+      byType[type] = [];
     }
-    // Display in logical order
-    const order = ['class', 'interface', 'type', 'function', 'export', 'method'];
-    for (const type of order) {
-        if (byType[type] && byType[type].length > 0) {
-            output += `### ${type.charAt(0).toUpperCase() + type.slice(1)}s\n\n`;
-            for (const symbol of byType[type]) {
-                const parentInfo = symbol.parentClass ? ` (in ${symbol.parentClass})` : '';
-                output += `- **${symbol.name}**${parentInfo} - Line ${symbol.line}\n`;
-                if (symbol.signature) {
-                    output += `  \`${symbol.signature}\`\n`;
-                }
-            }
-            output += '\n';
+    byType[type].push(symbol);
+  }
+  const order = ["class", "interface", "type", "function", "export", "method"];
+  for (const type of order) {
+    if (byType[type] && byType[type].length > 0) {
+      output += `### ${type.charAt(0).toUpperCase() + type.slice(1)}s
+
+`;
+      for (const symbol of byType[type]) {
+        const parentInfo = symbol.parentClass ? ` (in ${symbol.parentClass})` : "";
+        output += `- **${symbol.name}**${parentInfo} - Line ${symbol.line}
+`;
+        if (symbol.signature) {
+          output += `  \`${symbol.signature}\`
+`;
         }
+      }
+      output += "\n";
     }
-    return output;
+  }
+  return output;
 }
-/**
- * Tool wrapper for the registry
- */
-export const inspectSymbolTool = {
-    schema: {
-        name: 'inspect_symbol',
-        description: `Get an outline of symbols (classes, functions, methods) in a file without reading the entire file.
-
-WHEN TO USE:
-- To understand file structure before reading details
-- To find specific functions or classes
-- To see what's exported from a module
-- To quickly scan a large file
-
-SUPPORTS: TypeScript, JavaScript, Python, Java
-
+const inspectSymbolTool = {
+  schema: {
+    name: "inspect_symbol",
+    description: `Get an outline of symbols (classes, functions, methods) in a file without reading the entire file.
+
+WHEN TO USE:
+- To understand file structure before reading details
+- To find specific functions or classes
+- To see what's exported from a module
+- To quickly scan a large file
+
+SUPPORTS: TypeScript, JavaScript, Python, Java
+
 This is faster than reading the entire file when you only need to know what functions/classes exist.`,
-        parameters: {
-            type: 'object',
-            properties: {
-                reason_text: {
-                    type: 'string',
-                    description: 'REQUIRED: Brief explanation of why you need the symbol outline. Example: "Checking what functions are exported from this utility module"'
-                },
-                filePath: {
-                    type: 'string',
-                    description: 'Path to the file to inspect (relative to current working directory)'
-                }
-            },
-            required: ['reason_text', 'filePath']
-        }
-    },
-    async execute(args, context) {
-        const tool = new InspectSymbolTool();
-        const params = {
-            filePath: args.filePath
-        };
-        try {
-            const result = await tool.execute(params, context.cwd);
-            return formatInspectSymbolResults(result);
-        }
-        catch (error) {
-            throw new Error(`Inspect symbol failed: ${error.message}`);
+    parameters: {
+      type: "object",
+      properties: {
+        reason_text: {
+          type: "string",
+          description: 'REQUIRED: Brief explanation of why you need the symbol outline. Example: "Checking what functions are exported from this utility module"'
+        },
+        filePath: {
+          type: "string",
+          description: "Path to the file to inspect (relative to current working directory)"
         }
+      },
+      required: ["reason_text", "filePath"]
     }
+  },
+  async execute(args, context) {
+    const tool = new InspectSymbolTool();
+    const params = {
+      filePath: args.filePath
+    };
+    try {
+      const result = await tool.execute(params, context.cwd);
+      return formatInspectSymbolResults(result);
+    } catch (error) {
+      throw new Error(`Inspect symbol failed: ${error.message}`);
+    }
+  }
+};
+export {
+  InspectSymbolTool,
+  inspectSymbolTool
 };
 //# sourceMappingURL=inspect-symbol.js.map