@compilr-dev/agents-coding-ts 0.1.0

package/dist/tools/get-exports.js

@@ -0,0 +1,427 @@
+/**
+ * getExports Tool
+ *
+ * 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';
+// 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',
+    properties: {
+        path: {
+            type: 'string',
+            description: 'File to analyze',
+        },
+        includeReExports: {
+            type: 'boolean',
+            description: 'Include re-exports (default: true)',
+            default: true,
+        },
+        resolveReExports: {
+            type: 'boolean',
+            description: 'Resolve re-exports to original source (default: false)',
+            default: false,
+        },
+    },
+    required: ['path'],
+};
+/**
+ * getExports tool - Get all exports from a module
+ */
+export const getExportsTool = defineTool({
+    name: 'get_exports',
+    description: TOOL_DESCRIPTION,
+    inputSchema: TOOL_INPUT_SCHEMA,
+    execute: executeGetExports,
+});
+/**
+ * Execute the getExports tool
+ */
+async function executeGetExports(input) {
+    const { path: inputPath, includeReExports = true, resolveReExports = false } = input;
+    // Validate input
+    if (!inputPath || inputPath.trim().length === 0) {
+        return createErrorResult('Path is required');
+    }
+    try {
+        // Check if path exists
+        try {
+            await fs.access(inputPath);
+        }
+        catch {
+            return createErrorResult(`Path not found: ${inputPath}`);
+        }
+        const stats = await fs.stat(inputPath);
+        if (!stats.isFile()) {
+            return createErrorResult(`Path must be a file: ${inputPath}`);
+        }
+        // Check for supported language
+        const detection = detectLanguage(inputPath);
+        if (!detection.language || !isLanguageSupported(detection.language)) {
+            return createErrorResult(`Unsupported file type: ${path.extname(inputPath)}`);
+        }
+        // Analyze the file
+        const { defaultExport, namedExports, reExports } = await analyzeFileExports(inputPath, includeReExports, resolveReExports);
+        // 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,
+            reExports: reExports?.length ?? 0,
+        };
+        const result = {
+            path: inputPath,
+            defaultExport,
+            namedExports,
+            reExports: includeReExports && reExports && reExports.length > 0 ? reExports : undefined,
+            stats: exportStats,
+        };
+        return createSuccessResult(result);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return createErrorResult(`Failed to analyze exports: ${message}`);
+    }
+}
+/**
+ * Analyze exports in a single file
+ */
+async function analyzeFileExports(filePath, includeReExports, resolveReExports) {
+    const namedExports = [];
+    const reExports = [];
+    let defaultExport;
+    try {
+        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);
+        ts.forEachChild(sourceFile, (node) => {
+            // Handle export declarations
+            if (ts.isExportDeclaration(node)) {
+                const result = extractExportDeclaration(node, sourceFile, fileDir, resolveReExports);
+                if (result.reExport) {
+                    reExports.push(result.reExport);
+                }
+                namedExports.push(...result.exports);
+            }
+            // Handle export assignment (export default ...)
+            else if (ts.isExportAssignment(node)) {
+                defaultExport = extractExportAssignment(node, sourceFile);
+            }
+            // Handle exported declarations (export function, export class, etc.)
+            else if (hasExportModifier(node)) {
+                const exported = extractExportedDeclaration(node, sourceFile);
+                if (exported) {
+                    if (exported.isDefault) {
+                        defaultExport = exported.symbol;
+                    }
+                    else {
+                        namedExports.push(exported.symbol);
+                    }
+                }
+            }
+        });
+    }
+    catch {
+        // Silently skip files that can't be parsed
+    }
+    return {
+        defaultExport,
+        namedExports,
+        reExports: includeReExports ? reExports : undefined,
+    };
+}
+/**
+ * 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;
+}
+/**
+ * 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;
+}
+/**
+ * Extract export declaration (export { ... } or export * from ...)
+ */
+function extractExportDeclaration(node, sourceFile, fileDir, resolveReExports) {
+    const exports = [];
+    const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+    const lineNum = line + 1;
+    // Check for type-only export
+    const typeOnly = node.isTypeOnly;
+    // Re-export from another module
+    if (node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
+        const from = node.moduleSpecifier.text;
+        const resolvedFrom = resolveReExports ? resolveLocalImport(from, fileDir) : undefined;
+        // export * from '...'
+        if (!node.exportClause) {
+            return {
+                exports: [],
+                reExport: {
+                    symbols: '*',
+                    from,
+                    resolvedFrom,
+                    line: lineNum,
+                    typeOnly,
+                },
+            };
+        }
+        // export { a, b } from '...'
+        if (ts.isNamedExports(node.exportClause)) {
+            const symbols = [];
+            for (const element of node.exportClause.elements) {
+                const name = element.name.text;
+                symbols.push(name);
+            }
+            return {
+                exports: [],
+                reExport: {
+                    symbols,
+                    from,
+                    resolvedFrom,
+                    line: lineNum,
+                    typeOnly,
+                },
+            };
+        }
+        // export * as ns from '...'
+        if (ts.isNamespaceExport(node.exportClause)) {
+            return {
+                exports: [],
+                reExport: {
+                    symbols: '*',
+                    from,
+                    resolvedFrom,
+                    line: lineNum,
+                    typeOnly,
+                },
+            };
+        }
+    }
+    // Local named exports: export { a, b }
+    if (node.exportClause && ts.isNamedExports(node.exportClause)) {
+        for (const element of node.exportClause.elements) {
+            const name = element.name.text;
+            exports.push({
+                name,
+                kind: 'unknown',
+                line: lineNum,
+                typeOnly,
+            });
+        }
+    }
+    return { exports };
+}
+/**
+ * Extract export assignment (export default ...)
+ */
+function extractExportAssignment(node, sourceFile) {
+    const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+    const expr = node.expression;
+    let name = 'default';
+    let kind = 'unknown';
+    if (ts.isIdentifier(expr)) {
+        name = expr.text;
+    }
+    else if (ts.isClassExpression(expr)) {
+        kind = 'class';
+        if (expr.name) {
+            name = expr.name.text;
+        }
+    }
+    else if (ts.isFunctionExpression(expr) || ts.isArrowFunction(expr)) {
+        kind = 'function';
+    }
+    return {
+        name,
+        kind,
+        line: line + 1,
+    };
+}
+/**
+ * Extract exported declaration
+ */
+function extractExportedDeclaration(node, sourceFile) {
+    const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+    const lineNum = line + 1;
+    const isDefault = hasDefaultModifier(node);
+    // Function declaration
+    if (ts.isFunctionDeclaration(node)) {
+        const name = node.name?.text ?? 'default';
+        const signature = extractFunctionSignature(node, sourceFile);
+        return {
+            symbol: {
+                name,
+                kind: 'function',
+                line: lineNum,
+                signature,
+            },
+            isDefault,
+        };
+    }
+    // Class declaration
+    if (ts.isClassDeclaration(node)) {
+        const name = node.name?.text ?? 'default';
+        return {
+            symbol: {
+                name,
+                kind: 'class',
+                line: lineNum,
+            },
+            isDefault,
+        };
+    }
+    // Interface declaration
+    if (ts.isInterfaceDeclaration(node)) {
+        return {
+            symbol: {
+                name: node.name.text,
+                kind: 'interface',
+                line: lineNum,
+                typeOnly: true,
+            },
+            isDefault: false,
+        };
+    }
+    // Type alias declaration
+    if (ts.isTypeAliasDeclaration(node)) {
+        return {
+            symbol: {
+                name: node.name.text,
+                kind: 'type',
+                line: lineNum,
+                typeOnly: true,
+            },
+            isDefault: false,
+        };
+    }
+    // Enum declaration
+    if (ts.isEnumDeclaration(node)) {
+        return {
+            symbol: {
+                name: node.name.text,
+                kind: 'enum',
+                line: lineNum,
+            },
+            isDefault: false,
+        };
+    }
+    // Variable statement (export const x = ...)
+    if (ts.isVariableStatement(node)) {
+        const decls = node.declarationList.declarations;
+        if (decls.length > 0) {
+            const firstDecl = decls[0];
+            if (ts.isIdentifier(firstDecl.name)) {
+                const kind = node.declarationList.flags & ts.NodeFlags.Const ? 'variable' : 'variable';
+                return {
+                    symbol: {
+                        name: firstDecl.name.text,
+                        kind,
+                        line: lineNum,
+                    },
+                    isDefault: false,
+                };
+            }
+        }
+    }
+    // Module/namespace declaration
+    if (ts.isModuleDeclaration(node)) {
+        return {
+            symbol: {
+                name: node.name.getText(sourceFile),
+                kind: 'namespace',
+                line: lineNum,
+            },
+            isDefault: false,
+        };
+    }
+    return null;
+}
+/**
+ * Extract function signature
+ */
+function extractFunctionSignature(node, sourceFile) {
+    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 ? '?' : '';
+        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}`;
+}
+/**
+ * Try to resolve a local import path
+ */
+function resolveLocalImport(source, fromDir) {
+    if (!source.startsWith('.') && !source.startsWith('/')) {
+        return undefined; // External package
+    }
+    const basePath = path.resolve(fromDir, source);
+    // First try exact match for paths that already have extensions
+    if (basePath.match(/\.(ts|tsx|js|jsx|mts|mjs|cts|cjs)$/)) {
+        return basePath;
+    }
+    // Try with most likely TypeScript extensions first
+    return basePath + '.ts';
+}
+/**
+ * Get TypeScript script kind from file extension
+ */
+function getScriptKind(filePath) {
+    const ext = filePath.toLowerCase().split('.').pop();
+    switch (ext) {
+        case 'ts':
+            return ts.ScriptKind.TS;
+        case 'tsx':
+            return ts.ScriptKind.TSX;
+        case 'js':
+            return ts.ScriptKind.JS;
+        case 'jsx':
+            return ts.ScriptKind.JSX;
+        case 'mts':
+        case 'cts':
+            return ts.ScriptKind.TS;
+        case 'mjs':
+        case 'cjs':
+            return ts.ScriptKind.JS;
+        default:
+            return ts.ScriptKind.TS;
+    }
+}
+/**
+ * Factory function to create a customized getExports tool
+ */
+export function createGetExportsTool(options) {
+    const { defaultIncludeReExports = true, defaultResolveReExports = false } = options ?? {};
+    return defineTool({
+        name: 'get_exports',
+        description: TOOL_DESCRIPTION,
+        inputSchema: TOOL_INPUT_SCHEMA,
+        execute: async (input) => {
+            return executeGetExports({
+                ...input,
+                includeReExports: input.includeReExports ?? defaultIncludeReExports,
+                resolveReExports: input.resolveReExports ?? defaultResolveReExports,
+            });
+        },
+    });
+}

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

@@ -0,0 +1,27 @@
+/**
+ * getFileStructure Tool
+ *
+ * Analyzes a source file and returns its structural overview:
+ * - Imports and exports
+ * - Classes with methods and properties
+ * - Functions
+ * - Variables and constants
+ * - Type definitions
+ *
+ * Uses TypeScript Compiler API for accurate analysis.
+ */
+import type { Tool } from '@compilr-dev/agents';
+import type { GetFileStructureInput } from './types.js';
+/**
+ * getFileStructure tool - Analyze source file structure
+ */
+export declare const getFileStructureTool: Tool<GetFileStructureInput>;
+/**
+ * Factory function to create a customized getFileStructure tool
+ */
+export declare function createGetFileStructureTool(options?: {
+    /** Default maxDepth */
+    defaultMaxDepth?: number;
+    /** Default includePrivate */
+    defaultIncludePrivate?: boolean;
+}): Tool<GetFileStructureInput>;

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

@@ -0,0 +1,120 @@
+/**
+ * getFileStructure Tool
+ *
+ * Analyzes a source file and returns its structural overview:
+ * - Imports and exports
+ * - Classes with methods and properties
+ * - Functions
+ * - Variables and constants
+ * - Type definitions
+ *
+ * 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';
+// 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',
+    properties: {
+        path: {
+            type: 'string',
+            description: 'Absolute path to the file to analyze',
+        },
+        maxDepth: {
+            type: 'number',
+            description: 'Maximum depth for nested structures (default: 2)',
+            default: 2,
+        },
+        includePrivate: {
+            type: 'boolean',
+            description: 'Include private/internal symbols (default: true)',
+            default: true,
+        },
+    },
+    required: ['path'],
+};
+/**
+ * getFileStructure tool - Analyze source file structure
+ */
+export const getFileStructureTool = defineTool({
+    name: 'get_file_structure',
+    description: TOOL_DESCRIPTION,
+    inputSchema: TOOL_INPUT_SCHEMA,
+    execute: executeGetFileStructure,
+});
+/**
+ * Execute the getFileStructure tool
+ */
+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');
+    }
+    // Check if file exists
+    try {
+        await fs.access(filePath);
+    }
+    catch {
+        return createErrorResult(`File not found: ${filePath}`);
+    }
+    // Check if it's a file (not directory)
+    const stats = await fs.stat(filePath);
+    if (!stats.isFile()) {
+        return createErrorResult(`Path is not a file: ${filePath}`);
+    }
+    // Detect language
+    const detection = detectLanguage(filePath);
+    if (!detection.language) {
+        return createErrorResult(`Unsupported file type: ${path.extname(filePath)}`);
+    }
+    // Check if language is supported
+    if (!isLanguageSupported(detection.language)) {
+        return createErrorResult(`No parser available for language: ${detection.language}`);
+    }
+    try {
+        // Read file content
+        const sourceCode = await fs.readFile(filePath, 'utf-8');
+        // Parse and extract structure
+        const structure = parseTypeScript(sourceCode, filePath, {
+            maxDepth,
+            includePrivate,
+        });
+        // Build full result
+        const result = {
+            path: filePath,
+            language: detection.language,
+            languageConfidence: detection.confidence,
+            ...structure,
+        };
+        return createSuccessResult(result);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return createErrorResult(`Failed to analyze file: ${message}`);
+    }
+}
+/**
+ * Factory function to create a customized getFileStructure tool
+ */
+export function createGetFileStructureTool(options) {
+    const { defaultMaxDepth = 2, defaultIncludePrivate = true } = options ?? {};
+    return defineTool({
+        name: 'get_file_structure',
+        description: TOOL_DESCRIPTION,
+        inputSchema: TOOL_INPUT_SCHEMA,
+        execute: async (input) => {
+            return executeGetFileStructure({
+                ...input,
+                maxDepth: input.maxDepth ?? defaultMaxDepth,
+                includePrivate: input.includePrivate ?? defaultIncludePrivate,
+            });
+        },
+    });
+}

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

@@ -0,0 +1,23 @@
+/**
+ * getImports Tool
+ *
+ * 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';
+/**
+ * getImports tool - Get detailed import information
+ */
+export declare const getImportsTool: Tool<GetImportsInput>;
+/**
+ * Factory function to create a customized getImports tool
+ */
+export declare function createGetImportsTool(options?: {
+    /** Default recursive */
+    defaultRecursive?: boolean;
+    /** Default transitive */
+    defaultTransitive?: boolean;
+    /** Default maxDepth */
+    defaultMaxDepth?: number;
+}): Tool<GetImportsInput>;