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

package/dist/tools/get-exports.js

@@ -4,41 +4,41 @@
  * Get all exports from a module.
  * 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";
 // Tool description
 const TOOL_DESCRIPTION = `Get all exports from a module.
 Returns structured JSON with default export, named exports, and re-exports.
 Use this to understand what a module exposes to other modules.`;
 // Tool input schema
 const TOOL_INPUT_SCHEMA = {
-    type: 'object',
+    type: "object",
     properties: {
         path: {
-            type: 'string',
-            description: 'File to analyze',
+            type: "string",
+            description: "File to analyze",
         },
         includeReExports: {
-            type: 'boolean',
-            description: 'Include re-exports (default: true)',
+            type: "boolean",
+            description: "Include re-exports (default: true)",
             default: true,
         },
         resolveReExports: {
-            type: 'boolean',
-            description: 'Resolve re-exports to original source (default: false)',
+            type: "boolean",
+            description: "Resolve re-exports to original source (default: false)",
             default: false,
         },
     },
-    required: ['path'],
+    required: ["path"],
 };
 /**
  * getExports tool - Get all exports from a module
  */
 export const getExportsTool = defineTool({
-    name: 'get_exports',
+    name: "get_exports",
     description: TOOL_DESCRIPTION,
     inputSchema: TOOL_INPUT_SCHEMA,
     execute: executeGetExports,
@@ -47,10 +47,10 @@ export const getExportsTool = defineTool({
  * Execute the getExports tool
  */
 async function executeGetExports(input) {
-    const { path: inputPath, includeReExports = true, resolveReExports = false } = input;
+    const { path: inputPath, includeReExports = true, resolveReExports = false, } = input;
     // Validate input
     if (!inputPath || inputPath.trim().length === 0) {
-        return createErrorResult('Path is required');
+        return createErrorResult("Path is required");
     }
     try {
         // Check if path exists
@@ -74,17 +74,19 @@ async function executeGetExports(input) {
         // Calculate statistics
         const exportStats = {
             totalExports: namedExports.length + (defaultExport ? 1 : 0),
-            functions: namedExports.filter((e) => e.kind === 'function').length,
-            classes: namedExports.filter((e) => e.kind === 'class').length,
-            types: namedExports.filter((e) => e.kind === 'type' || e.kind === 'interface').length,
-            variables: namedExports.filter((e) => e.kind === 'variable').length,
+            functions: namedExports.filter((e) => e.kind === "function").length,
+            classes: namedExports.filter((e) => e.kind === "class").length,
+            types: namedExports.filter((e) => e.kind === "type" || e.kind === "interface").length,
+            variables: namedExports.filter((e) => e.kind === "variable").length,
             reExports: reExports?.length ?? 0,
         };
         const result = {
             path: inputPath,
             defaultExport,
             namedExports,
-            reExports: includeReExports && reExports && reExports.length > 0 ? reExports : undefined,
+            reExports: includeReExports && reExports && reExports.length > 0
+                ? reExports
+                : undefined,
             stats: exportStats,
         };
         return createSuccessResult(result);
@@ -102,7 +104,7 @@ async function analyzeFileExports(filePath, includeReExports, resolveReExports)
     const reExports = [];
     let defaultExport;
     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);
         const fileDir = path.dirname(filePath);
@@ -146,15 +148,19 @@ async function analyzeFileExports(filePath, includeReExports, resolveReExports)
  * Check if a node has export modifier
  */
 function hasExportModifier(node) {
-    const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
-    return modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+    const modifiers = ts.canHaveModifiers(node)
+        ? ts.getModifiers(node)
+        : undefined;
+    return (modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false);
 }
 /**
  * Check if a node has default modifier
  */
 function hasDefaultModifier(node) {
-    const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
-    return modifiers?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword) ?? false;
+    const modifiers = ts.canHaveModifiers(node)
+        ? ts.getModifiers(node)
+        : undefined;
+    return (modifiers?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword) ?? false);
 }
 /**
  * Extract export declaration (export { ... } or export * from ...)
@@ -168,13 +174,15 @@ function extractExportDeclaration(node, sourceFile, fileDir, resolveReExports) {
     // Re-export from another module
     if (node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
         const from = node.moduleSpecifier.text;
-        const resolvedFrom = resolveReExports ? resolveLocalImport(from, fileDir) : undefined;
+        const resolvedFrom = resolveReExports
+            ? resolveLocalImport(from, fileDir)
+            : undefined;
         // export * from '...'
         if (!node.exportClause) {
             return {
                 exports: [],
                 reExport: {
-                    symbols: '*',
+                    symbols: "*",
                     from,
                     resolvedFrom,
                     line: lineNum,
@@ -205,7 +213,7 @@ function extractExportDeclaration(node, sourceFile, fileDir, resolveReExports) {
             return {
                 exports: [],
                 reExport: {
-                    symbols: '*',
+                    symbols: "*",
                     from,
                     resolvedFrom,
                     line: lineNum,
@@ -220,7 +228,7 @@ function extractExportDeclaration(node, sourceFile, fileDir, resolveReExports) {
             const name = element.name.text;
             exports.push({
                 name,
-                kind: 'unknown',
+                kind: "unknown",
                 line: lineNum,
                 typeOnly,
             });
@@ -234,19 +242,19 @@ function extractExportDeclaration(node, sourceFile, fileDir, resolveReExports) {
 function extractExportAssignment(node, sourceFile) {
     const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
     const expr = node.expression;
-    let name = 'default';
-    let kind = 'unknown';
+    let name = "default";
+    let kind = "unknown";
     if (ts.isIdentifier(expr)) {
         name = expr.text;
     }
     else if (ts.isClassExpression(expr)) {
-        kind = 'class';
+        kind = "class";
         if (expr.name) {
             name = expr.name.text;
         }
     }
     else if (ts.isFunctionExpression(expr) || ts.isArrowFunction(expr)) {
-        kind = 'function';
+        kind = "function";
     }
     return {
         name,
@@ -263,12 +271,12 @@ function extractExportedDeclaration(node, sourceFile) {
     const isDefault = hasDefaultModifier(node);
     // Function declaration
     if (ts.isFunctionDeclaration(node)) {
-        const name = node.name?.text ?? 'default';
+        const name = node.name?.text ?? "default";
         const signature = extractFunctionSignature(node, sourceFile);
         return {
             symbol: {
                 name,
-                kind: 'function',
+                kind: "function",
                 line: lineNum,
                 signature,
             },
@@ -277,11 +285,11 @@ function extractExportedDeclaration(node, sourceFile) {
     }
     // Class declaration
     if (ts.isClassDeclaration(node)) {
-        const name = node.name?.text ?? 'default';
+        const name = node.name?.text ?? "default";
         return {
             symbol: {
                 name,
-                kind: 'class',
+                kind: "class",
                 line: lineNum,
             },
             isDefault,
@@ -292,7 +300,7 @@ function extractExportedDeclaration(node, sourceFile) {
         return {
             symbol: {
                 name: node.name.text,
-                kind: 'interface',
+                kind: "interface",
                 line: lineNum,
                 typeOnly: true,
             },
@@ -304,7 +312,7 @@ function extractExportedDeclaration(node, sourceFile) {
         return {
             symbol: {
                 name: node.name.text,
-                kind: 'type',
+                kind: "type",
                 line: lineNum,
                 typeOnly: true,
             },
@@ -316,7 +324,7 @@ function extractExportedDeclaration(node, sourceFile) {
         return {
             symbol: {
                 name: node.name.text,
-                kind: 'enum',
+                kind: "enum",
                 line: lineNum,
             },
             isDefault: false,
@@ -328,7 +336,9 @@ function extractExportedDeclaration(node, sourceFile) {
         if (decls.length > 0) {
             const firstDecl = decls[0];
             if (ts.isIdentifier(firstDecl.name)) {
-                const kind = node.declarationList.flags & ts.NodeFlags.Const ? 'variable' : 'variable';
+                const kind = node.declarationList.flags & ts.NodeFlags.Const
+                    ? "variable"
+                    : "variable";
                 return {
                     symbol: {
                         name: firstDecl.name.text,
@@ -345,7 +355,7 @@ function extractExportedDeclaration(node, sourceFile) {
         return {
             symbol: {
                 name: node.name.getText(sourceFile),
-                kind: 'namespace',
+                kind: "namespace",
                 line: lineNum,
             },
             isDefault: false,
@@ -357,22 +367,24 @@ function extractExportedDeclaration(node, sourceFile) {
  * Extract function signature
  */
 function extractFunctionSignature(node, sourceFile) {
-    const name = node.name?.text ?? 'anonymous';
+    const name = node.name?.text ?? "anonymous";
     const params = node.parameters.map((p) => {
         const paramName = p.name.getText(sourceFile);
-        const paramType = p.type ? p.type.getText(sourceFile) : 'any';
-        const optional = p.questionToken ? '?' : '';
+        const paramType = p.type ? p.type.getText(sourceFile) : "any";
+        const optional = p.questionToken ? "?" : "";
         return `${paramName}${optional}: ${paramType}`;
     });
-    const returnType = node.type ? node.type.getText(sourceFile) : 'void';
-    const async = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ? 'async ' : '';
-    return `${async}function ${name}(${params.join(', ')}): ${returnType}`;
+    const returnType = node.type ? node.type.getText(sourceFile) : "void";
+    const async = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)
+        ? "async "
+        : "";
+    return `${async}function ${name}(${params.join(", ")}): ${returnType}`;
 }
 /**
  * Try to resolve a local import path
  */
 function resolveLocalImport(source, fromDir) {
-    if (!source.startsWith('.') && !source.startsWith('/')) {
+    if (!source.startsWith(".") && !source.startsWith("/")) {
         return undefined; // External package
     }
     const basePath = path.resolve(fromDir, source);
@@ -381,27 +393,27 @@ function resolveLocalImport(source, fromDir) {
         return basePath;
     }
     // Try with most likely TypeScript extensions first
-    return basePath + '.ts';
+    return basePath + ".ts";
 }
 /**
  * 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;
@@ -413,7 +425,7 @@ function getScriptKind(filePath) {
 export function createGetExportsTool(options) {
     const { defaultIncludeReExports = true, defaultResolveReExports = false } = options ?? {};
     return defineTool({
-        name: 'get_exports',
+        name: "get_exports",
         description: TOOL_DESCRIPTION,
         inputSchema: TOOL_INPUT_SCHEMA,
         execute: async (input) => {

package/dist/tools/get-file-structure.d.ts

@@ -10,8 +10,8 @@
  *
  * Uses TypeScript Compiler API for accurate analysis.
  */
-import type { Tool } from '@compilr-dev/agents';
-import type { GetFileStructureInput } from './types.js';
+import type { Tool } from "@compilr-dev/agents";
+import type { GetFileStructureInput } from "./types.js";
 /**
  * getFileStructure tool - Analyze source file structure
  */

package/dist/tools/get-file-structure.js

@@ -10,40 +10,40 @@
  *
  * Uses TypeScript Compiler API for accurate analysis.
  */
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { defineTool, createSuccessResult, createErrorResult } from '@compilr-dev/agents';
-import { parseTypeScript, detectLanguage, isLanguageSupported } from '../parser/typescript-parser.js';
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { defineTool, createSuccessResult, createErrorResult, } from "@compilr-dev/agents";
+import { parseTypeScript, detectLanguage, isLanguageSupported, } from "../parser/typescript-parser.js";
 // Tool description (shared between tool and factory)
 const TOOL_DESCRIPTION = `Analyze a source file and return its structural overview including imports, exports, classes, functions, and types.
 Use this instead of reading the full file when you need to understand what a file contains.
 Returns structured JSON that's much more compact than raw source code.`;
 // Tool input schema (shared between tool and factory)
 const TOOL_INPUT_SCHEMA = {
-    type: 'object',
+    type: "object",
     properties: {
         path: {
-            type: 'string',
-            description: 'Absolute path to the file to analyze',
+            type: "string",
+            description: "Absolute path to the file to analyze",
         },
         maxDepth: {
-            type: 'number',
-            description: 'Maximum depth for nested structures (default: 2)',
+            type: "number",
+            description: "Maximum depth for nested structures (default: 2)",
             default: 2,
         },
         includePrivate: {
-            type: 'boolean',
-            description: 'Include private/internal symbols (default: true)',
+            type: "boolean",
+            description: "Include private/internal symbols (default: true)",
             default: true,
         },
     },
-    required: ['path'],
+    required: ["path"],
 };
 /**
  * getFileStructure tool - Analyze source file structure
  */
 export const getFileStructureTool = defineTool({
-    name: 'get_file_structure',
+    name: "get_file_structure",
     description: TOOL_DESCRIPTION,
     inputSchema: TOOL_INPUT_SCHEMA,
     execute: executeGetFileStructure,
@@ -55,7 +55,7 @@ async function executeGetFileStructure(input) {
     const { path: filePath, maxDepth = 2, includePrivate = true } = input;
     // Validate input
     if (!filePath || filePath.trim().length === 0) {
-        return createErrorResult('File path is required');
+        return createErrorResult("File path is required");
     }
     // Check if file exists
     try {
@@ -80,7 +80,7 @@ async function executeGetFileStructure(input) {
     }
     try {
         // Read file content
-        const sourceCode = await fs.readFile(filePath, 'utf-8');
+        const sourceCode = await fs.readFile(filePath, "utf-8");
         // Parse and extract structure
         const structure = parseTypeScript(sourceCode, filePath, {
             maxDepth,
@@ -106,7 +106,7 @@ async function executeGetFileStructure(input) {
 export function createGetFileStructureTool(options) {
     const { defaultMaxDepth = 2, defaultIncludePrivate = true } = options ?? {};
     return defineTool({
-        name: 'get_file_structure',
+        name: "get_file_structure",
         description: TOOL_DESCRIPTION,
         inputSchema: TOOL_INPUT_SCHEMA,
         execute: async (input) => {

package/dist/tools/get-imports.d.ts

@@ -4,8 +4,8 @@
  * Get detailed import information for a file or module.
  * Uses TypeScript Compiler API for accurate AST analysis.
  */
-import type { Tool } from '@compilr-dev/agents';
-import type { GetImportsInput } from './types.js';
+import type { Tool } from "@compilr-dev/agents";
+import type { GetImportsInput } from "./types.js";
 /**
  * getImports tool - Get detailed import information
  */

package/dist/tools/get-imports.js

@@ -4,21 +4,21 @@
  * Get detailed import information for a file or module.
  * 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",
 ]);
 // Tool description
 const TOOL_DESCRIPTION = `Get detailed import information for a file or module.
@@ -26,39 +26,39 @@ Returns structured JSON with import sources, symbols, and whether imports are ex
 Use this to understand a file's dependencies and what it imports from other modules.`;
 // Tool input schema
 const TOOL_INPUT_SCHEMA = {
-    type: 'object',
+    type: "object",
     properties: {
         path: {
-            type: 'string',
-            description: 'File or directory to analyze',
+            type: "string",
+            description: "File or directory to analyze",
         },
         recursive: {
-            type: 'boolean',
-            description: 'Recursively analyze directory (default: false)',
+            type: "boolean",
+            description: "Recursively analyze directory (default: false)",
             default: false,
         },
         filterSource: {
-            type: 'string',
-            description: 'Filter to specific import sources (partial match)',
+            type: "string",
+            description: "Filter to specific import sources (partial match)",
         },
         transitive: {
-            type: 'boolean',
-            description: 'Include transitive imports (default: false)',
+            type: "boolean",
+            description: "Include transitive imports (default: false)",
             default: false,
         },
         maxDepth: {
-            type: 'number',
-            description: 'Max depth for transitive imports (default: 3)',
+            type: "number",
+            description: "Max depth for transitive imports (default: 3)",
             default: 3,
         },
     },
-    required: ['path'],
+    required: ["path"],
 };
 /**
  * getImports tool - Get detailed import information
  */
 export const getImportsTool = defineTool({
-    name: 'get_imports',
+    name: "get_imports",
     description: TOOL_DESCRIPTION,
     inputSchema: TOOL_INPUT_SCHEMA,
     execute: executeGetImports,
@@ -70,7 +70,7 @@ async function executeGetImports(input) {
     const { path: inputPath, recursive = false, filterSource, transitive = false, maxDepth = 3, } = input;
     // Validate input
     if (!inputPath || inputPath.trim().length === 0) {
-        return createErrorResult('Path is required');
+        return createErrorResult("Path is required");
     }
     try {
         // Check if path exists
@@ -144,11 +144,11 @@ async function collectFiles(dir, recursive) {
                 if (!recursive)
                     continue;
                 // 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);
@@ -170,7 +170,7 @@ async function collectFiles(dir, recursive) {
 async function analyzeFileImports(filePath) {
     const imports = [];
     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);
         const fileDir = path.dirname(filePath);
@@ -201,7 +201,7 @@ function extractImportInfo(node, sourceFile, fileDir) {
     // phaseModifier is directly the SyntaxKind value (TypeKeyword or DeferKeyword), not a node
     const typeOnly = node.importClause?.phaseModifier === ts.SyntaxKind.TypeKeyword;
     // Determine if external (doesn't start with . or /)
-    const isExternal = !source.startsWith('.') && !source.startsWith('/');
+    const isExternal = !source.startsWith(".") && !source.startsWith("/");
     // Try to resolve local imports
     let resolvedPath;
     if (!isExternal) {
@@ -243,7 +243,7 @@ function extractImportInfo(node, sourceFile, fileDir) {
     // Side-effect import (no symbols)
     if (symbols.length === 0) {
         symbols.push({
-            name: '*',
+            name: "*",
             isDefault: false,
             isNamespace: false,
         });
@@ -269,7 +269,7 @@ function resolveLocalImport(source, fromDir) {
     // Try with most likely TypeScript extensions first
     // We don't check if file exists to avoid async issues
     // Just return the most likely path (.ts is most common)
-    return basePath + '.ts';
+    return basePath + ".ts";
 }
 /**
  * Get transitive imports (imports of imports)
@@ -309,21 +309,21 @@ async function getTransitiveImports(rootFile, directImports, maxDepth) {
  * 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;
@@ -335,7 +335,7 @@ function getScriptKind(filePath) {
 export function createGetImportsTool(options) {
     const { defaultRecursive = false, defaultTransitive = false, defaultMaxDepth = 3, } = options ?? {};
     return defineTool({
-        name: 'get_imports',
+        name: "get_imports",
         description: TOOL_DESCRIPTION,
         inputSchema: TOOL_INPUT_SCHEMA,
         execute: async (input) => {

package/dist/tools/get-signature.d.ts

@@ -4,8 +4,8 @@
  * Get detailed signature information for a function, method, class, or type.
  * Includes parameters, return types, generics, and documentation.
  */
-import type { Tool } from '@compilr-dev/agents';
-import type { GetSignatureInput } from './types.js';
+import type { Tool } from "@compilr-dev/agents";
+import type { GetSignatureInput } from "./types.js";
 /**
  * getSignature tool
  */