@compilr-dev/agents-coding-ts 0.1.2 → 0.1.4

package/dist/tools/find-references.js

@@ -4,21 +4,21 @@
  * Find all usages of a symbol across the codebase.
  * Uses TypeScript Compiler API for accurate AST analysis.
  */
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import * as ts from 'typescript';
-import { defineTool, createSuccessResult, createErrorResult } from '@compilr-dev/agents';
-import { detectLanguage, isLanguageSupported } from '../parser/typescript-parser.js';
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as ts from "typescript";
+import { defineTool, createSuccessResult, createErrorResult, } from "@compilr-dev/agents";
+import { detectLanguage, isLanguageSupported, } from "../parser/typescript-parser.js";
 // Supported file extensions for searching
 const SUPPORTED_EXTENSIONS = new Set([
-    '.ts',
-    '.tsx',
-    '.js',
-    '.jsx',
-    '.mts',
-    '.mjs',
-    '.cts',
-    '.cjs',
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mts",
+    ".mjs",
+    ".cts",
+    ".cjs",
 ]);
 // Helper to check for a specific modifier kind
 function hasModifierKind(modifiers, kind) {
@@ -30,47 +30,47 @@ Returns structured JSON with file paths, line numbers, and reference types.
 Use this to understand how a function, class, or variable is used throughout the project.`;
 // Tool input schema
 const TOOL_INPUT_SCHEMA = {
-    type: 'object',
+    type: "object",
     properties: {
         symbol: {
-            type: 'string',
-            description: 'Symbol name to find references for',
+            type: "string",
+            description: "Symbol name to find references for",
         },
         definitionFile: {
-            type: 'string',
-            description: 'File where the symbol is defined (improves accuracy)',
+            type: "string",
+            description: "File where the symbol is defined (improves accuracy)",
         },
         definitionLine: {
-            type: 'number',
-            description: 'Line where symbol is defined (improves accuracy)',
+            type: "number",
+            description: "Line where symbol is defined (improves accuracy)",
         },
         scope: {
-            type: 'string',
-            description: 'Scope the search to a specific file or directory',
+            type: "string",
+            description: "Scope the search to a specific file or directory",
         },
         limit: {
-            type: 'number',
-            description: 'Maximum results to return (default: 50)',
+            type: "number",
+            description: "Maximum results to return (default: 50)",
             default: 50,
         },
         includeDefinition: {
-            type: 'boolean',
-            description: 'Include the definition itself (default: false)',
+            type: "boolean",
+            description: "Include the definition itself (default: false)",
             default: false,
         },
         groupByFile: {
-            type: 'boolean',
-            description: 'Group results by file (default: true)',
+            type: "boolean",
+            description: "Group results by file (default: true)",
             default: true,
         },
     },
-    required: ['symbol'],
+    required: ["symbol"],
 };
 /**
  * findReferences tool - Find all usages of a symbol
  */
 export const findReferencesTool = defineTool({
-    name: 'find_references',
+    name: "find_references",
     description: TOOL_DESCRIPTION,
     inputSchema: TOOL_INPUT_SCHEMA,
     execute: executeFindReferences,
@@ -82,7 +82,7 @@ async function executeFindReferences(input) {
     const { symbol, definitionFile, definitionLine, scope, limit = 50, includeDefinition = false, groupByFile = true, } = input;
     // Validate input
     if (!symbol || symbol.trim().length === 0) {
-        return createErrorResult('Symbol name is required');
+        return createErrorResult("Symbol name is required");
     }
     const startTime = Date.now();
     const allReferences = [];
@@ -172,11 +172,11 @@ async function collectFiles(dir) {
             const fullPath = path.join(currentDir, entry.name);
             if (entry.isDirectory()) {
                 // Skip node_modules and common non-source directories
-                if (entry.name === 'node_modules' ||
-                    entry.name.startsWith('.') ||
-                    entry.name === 'dist' ||
-                    entry.name === 'build' ||
-                    entry.name === 'coverage') {
+                if (entry.name === "node_modules" ||
+                    entry.name.startsWith(".") ||
+                    entry.name === "dist" ||
+                    entry.name === "build" ||
+                    entry.name === "coverage") {
                     continue;
                 }
                 await walk(fullPath);
@@ -197,7 +197,7 @@ async function collectFiles(dir) {
  */
 async function findDefinitionInFile(filePath, symbolName, targetLine) {
     try {
-        const sourceCode = await fs.readFile(filePath, 'utf-8');
+        const sourceCode = await fs.readFile(filePath, "utf-8");
         const scriptKind = getScriptKind(filePath);
         const sourceFile = ts.createSourceFile(filePath, sourceCode, ts.ScriptTarget.Latest, true, scriptKind);
         let foundDef;
@@ -227,33 +227,35 @@ async function findDefinitionInFile(filePath, symbolName, targetLine) {
 function tryExtractDefinition(node, sourceFile, symbolName, filePath) {
     let name;
     let kind;
-    const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
+    const modifiers = ts.canHaveModifiers(node)
+        ? ts.getModifiers(node)
+        : undefined;
     const exported = hasModifierKind(modifiers, ts.SyntaxKind.ExportKeyword);
     if (ts.isFunctionDeclaration(node) && node.name?.text === symbolName) {
         name = node.name.text;
-        kind = 'function';
+        kind = "function";
     }
     else if (ts.isClassDeclaration(node) && node.name?.text === symbolName) {
         name = node.name.text;
-        kind = 'class';
+        kind = "class";
     }
     else if (ts.isInterfaceDeclaration(node) && node.name.text === symbolName) {
         name = node.name.text;
-        kind = 'interface';
+        kind = "interface";
     }
     else if (ts.isTypeAliasDeclaration(node) && node.name.text === symbolName) {
         name = node.name.text;
-        kind = 'type';
+        kind = "type";
     }
     else if (ts.isEnumDeclaration(node) && node.name.text === symbolName) {
         name = node.name.text;
-        kind = 'enum';
+        kind = "enum";
     }
     else if (ts.isVariableDeclaration(node) &&
         ts.isIdentifier(node.name) &&
         node.name.text === symbolName) {
         name = node.name.text;
-        kind = 'variable';
+        kind = "variable";
     }
     if (name && kind) {
         const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
@@ -275,8 +277,8 @@ function tryExtractDefinition(node, sourceFile, symbolName, filePath) {
 async function searchFileForReferences(filePath, symbolName, definition, includeDefinition) {
     const references = [];
     try {
-        const sourceCode = await fs.readFile(filePath, 'utf-8');
-        const lines = sourceCode.split('\n');
+        const sourceCode = await fs.readFile(filePath, "utf-8");
+        const lines = sourceCode.split("\n");
         const scriptKind = getScriptKind(filePath);
         const sourceFile = ts.createSourceFile(filePath, sourceCode, ts.ScriptTarget.Latest, true, scriptKind);
         // Track current containing function for context
@@ -339,7 +341,7 @@ function tryExtractReference(node, sourceFile, symbolName, filePath, lines, cont
     }
     const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
     const lineIndex = line;
-    const context = lineIndex < lines.length ? lines[lineIndex].trim() : '';
+    const context = lineIndex < lines.length ? lines[lineIndex].trim() : "";
     return {
         path: filePath,
         line: line + 1,
@@ -355,35 +357,37 @@ function tryExtractReference(node, sourceFile, symbolName, filePath, lines, cont
 function determineReferenceType(node) {
     const parent = node.parent;
     // Import statement
-    if (ts.isImportSpecifier(parent) || ts.isImportClause(parent) || ts.isNamespaceImport(parent)) {
-        return 'import';
+    if (ts.isImportSpecifier(parent) ||
+        ts.isImportClause(parent) ||
+        ts.isNamespaceImport(parent)) {
+        return "import";
     }
     // Export statement
     if (ts.isExportSpecifier(parent) || ts.isExportAssignment(parent)) {
-        return 'export';
+        return "export";
     }
     // Type reference (in type annotations)
     if (ts.isTypeReferenceNode(parent)) {
-        return 'type';
+        return "type";
     }
     // Extends clause
     if (ts.isExpressionWithTypeArguments(parent)) {
         const grandparent = parent.parent;
         if (ts.isHeritageClause(grandparent)) {
             if (grandparent.token === ts.SyntaxKind.ExtendsKeyword) {
-                return 'extend';
+                return "extend";
             }
             // Use else for implements to avoid the "always true" comparison error
-            return 'implement';
+            return "implement";
         }
     }
     // Call expression
     if (ts.isCallExpression(parent) && parent.expression === node) {
-        return 'call';
+        return "call";
     }
     // New expression
     if (ts.isNewExpression(parent) && parent.expression === node) {
-        return 'call';
+        return "call";
     }
     // Property access (reading)
     if (ts.isPropertyAccessExpression(parent) && parent.name === node) {
@@ -392,23 +396,23 @@ function determineReferenceType(node) {
         if (ts.isBinaryExpression(grandparent) &&
             grandparent.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
             grandparent.left === parent) {
-            return 'write';
+            return "write";
         }
-        return 'read';
+        return "read";
     }
     // Variable declaration (definition, but also a "write")
     if (ts.isVariableDeclaration(parent) && parent.name === node) {
-        return 'write';
+        return "write";
     }
     // Assignment expression
     if (ts.isBinaryExpression(parent) &&
         parent.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
         parent.left === node) {
-        return 'write';
+        return "write";
     }
     // Parameter declaration
     if (ts.isParameter(parent)) {
-        return 'write';
+        return "write";
     }
     // Function/class/interface declaration (this is a definition)
     if (ts.isFunctionDeclaration(parent) ||
@@ -419,10 +423,10 @@ function determineReferenceType(node) {
         ts.isMethodDeclaration(parent) ||
         ts.isPropertyDeclaration(parent)) {
         // This is a definition, we'll include it based on includeDefinition flag
-        return 'write';
+        return "write";
     }
     // Default to read for other usages
-    return 'read';
+    return "read";
 }
 /**
  * Group references by file
@@ -447,21 +451,21 @@ function groupReferencesByFile(references) {
  * Get TypeScript script kind from file extension
  */
 function getScriptKind(filePath) {
-    const ext = filePath.toLowerCase().split('.').pop();
+    const ext = filePath.toLowerCase().split(".").pop();
     switch (ext) {
-        case 'ts':
+        case "ts":
             return ts.ScriptKind.TS;
-        case 'tsx':
+        case "tsx":
             return ts.ScriptKind.TSX;
-        case 'js':
+        case "js":
             return ts.ScriptKind.JS;
-        case 'jsx':
+        case "jsx":
             return ts.ScriptKind.JSX;
-        case 'mts':
-        case 'cts':
+        case "mts":
+        case "cts":
             return ts.ScriptKind.TS;
-        case 'mjs':
-        case 'cjs':
+        case "mjs":
+        case "cjs":
             return ts.ScriptKind.JS;
         default:
             return ts.ScriptKind.TS;
@@ -473,7 +477,7 @@ function getScriptKind(filePath) {
 export function createFindReferencesTool(options) {
     const { defaultLimit = 50, defaultGroupByFile = true, defaultIncludeDefinition = false, } = options ?? {};
     return defineTool({
-        name: 'find_references',
+        name: "find_references",
         description: TOOL_DESCRIPTION,
         inputSchema: TOOL_INPUT_SCHEMA,
         execute: async (input) => {

package/dist/tools/find-symbol.d.ts

@@ -4,8 +4,8 @@
  * Find the definition location of a symbol across the codebase.
  * Uses TypeScript Compiler API for accurate AST analysis.
  */
-import type { Tool } from '@compilr-dev/agents';
-import type { FindSymbolInput } from './types.js';
+import type { Tool } from "@compilr-dev/agents";
+import type { FindSymbolInput } from "./types.js";
 /**
  * findSymbol tool - Find symbol definitions
  */