@compilr-dev/agents-coding-ts 0.1.0

package/dist/tools/get-imports.js

@@ -0,0 +1,350 @@
+/**
+ * getImports Tool
+ *
+ * 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';
+// Supported file extensions for searching
+const SUPPORTED_EXTENSIONS = new Set([
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.mts',
+    '.mjs',
+    '.cts',
+    '.cjs',
+]);
+// Tool description
+const TOOL_DESCRIPTION = `Get detailed import information for a file or module.
+Returns structured JSON with import sources, symbols, and whether imports are external or internal.
+Use this to understand a file's dependencies and what it imports from other modules.`;
+// Tool input schema
+const TOOL_INPUT_SCHEMA = {
+    type: 'object',
+    properties: {
+        path: {
+            type: 'string',
+            description: 'File or directory to analyze',
+        },
+        recursive: {
+            type: 'boolean',
+            description: 'Recursively analyze directory (default: false)',
+            default: false,
+        },
+        filterSource: {
+            type: 'string',
+            description: 'Filter to specific import sources (partial match)',
+        },
+        transitive: {
+            type: 'boolean',
+            description: 'Include transitive imports (default: false)',
+            default: false,
+        },
+        maxDepth: {
+            type: 'number',
+            description: 'Max depth for transitive imports (default: 3)',
+            default: 3,
+        },
+    },
+    required: ['path'],
+};
+/**
+ * getImports tool - Get detailed import information
+ */
+export const getImportsTool = defineTool({
+    name: 'get_imports',
+    description: TOOL_DESCRIPTION,
+    inputSchema: TOOL_INPUT_SCHEMA,
+    execute: executeGetImports,
+});
+/**
+ * Execute the getImports tool
+ */
+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');
+    }
+    try {
+        // Check if path exists
+        try {
+            await fs.access(inputPath);
+        }
+        catch {
+            return createErrorResult(`Path not found: ${inputPath}`);
+        }
+        const stats = await fs.stat(inputPath);
+        let allImports = [];
+        const analyzedPath = inputPath;
+        if (stats.isFile()) {
+            // Analyze single file
+            const detection = detectLanguage(inputPath);
+            if (!detection.language || !isLanguageSupported(detection.language)) {
+                return createErrorResult(`Unsupported file type: ${path.extname(inputPath)}`);
+            }
+            allImports = await analyzeFileImports(inputPath);
+        }
+        else if (stats.isDirectory()) {
+            // Analyze directory
+            const files = await collectFiles(inputPath, recursive);
+            for (const filePath of files) {
+                const fileImports = await analyzeFileImports(filePath);
+                allImports.push(...fileImports);
+            }
+        }
+        else {
+            return createErrorResult(`Path is neither a file nor directory: ${inputPath}`);
+        }
+        // Apply filter if specified
+        if (filterSource) {
+            allImports = allImports.filter((imp) => imp.source.includes(filterSource));
+        }
+        // Handle transitive imports
+        let transitiveImports;
+        if (transitive && stats.isFile()) {
+            transitiveImports = await getTransitiveImports(inputPath, allImports, maxDepth);
+        }
+        // Calculate statistics
+        const importStats = {
+            totalImports: allImports.length,
+            externalPackages: allImports.filter((imp) => imp.isExternal).length,
+            internalModules: allImports.filter((imp) => !imp.isExternal).length,
+            typeOnlyImports: allImports.filter((imp) => imp.typeOnly).length,
+        };
+        const result = {
+            path: analyzedPath,
+            imports: allImports,
+            transitiveImports,
+            stats: importStats,
+        };
+        return createSuccessResult(result);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return createErrorResult(`Failed to analyze imports: ${message}`);
+    }
+}
+/**
+ * Collect all supported files in a directory
+ */
+async function collectFiles(dir, recursive) {
+    const files = [];
+    async function walk(currentDir) {
+        const entries = await fs.readdir(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                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') {
+                    continue;
+                }
+                await walk(fullPath);
+            }
+            else if (entry.isFile()) {
+                const ext = path.extname(entry.name).toLowerCase();
+                if (SUPPORTED_EXTENSIONS.has(ext)) {
+                    files.push(fullPath);
+                }
+            }
+        }
+    }
+    await walk(dir);
+    return files;
+}
+/**
+ * Analyze imports in a single file
+ */
+async function analyzeFileImports(filePath) {
+    const imports = [];
+    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) => {
+            if (ts.isImportDeclaration(node)) {
+                const imp = extractImportInfo(node, sourceFile, fileDir);
+                if (imp) {
+                    imports.push(imp);
+                }
+            }
+        });
+    }
+    catch {
+        // Silently skip files that can't be parsed
+    }
+    return imports;
+}
+/**
+ * Extract import information from an import declaration
+ */
+function extractImportInfo(node, sourceFile, fileDir) {
+    const moduleSpecifier = node.moduleSpecifier;
+    if (!ts.isStringLiteral(moduleSpecifier))
+        return null;
+    const source = moduleSpecifier.text;
+    const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+    // Check for type-only import (import type { ... } from '...')
+    // 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('/');
+    // Try to resolve local imports
+    let resolvedPath;
+    if (!isExternal) {
+        resolvedPath = resolveLocalImport(source, fileDir);
+    }
+    // Extract imported symbols
+    const symbols = [];
+    const importClause = node.importClause;
+    if (importClause) {
+        // Default import
+        if (importClause.name) {
+            symbols.push({
+                name: importClause.name.text,
+                isDefault: true,
+                isNamespace: false,
+            });
+        }
+        // Named imports or namespace import
+        if (importClause.namedBindings) {
+            if (ts.isNamedImports(importClause.namedBindings)) {
+                for (const element of importClause.namedBindings.elements) {
+                    symbols.push({
+                        name: element.name.text,
+                        originalName: element.propertyName?.text,
+                        isDefault: false,
+                        isNamespace: false,
+                    });
+                }
+            }
+            else if (ts.isNamespaceImport(importClause.namedBindings)) {
+                symbols.push({
+                    name: importClause.namedBindings.name.text,
+                    isDefault: false,
+                    isNamespace: true,
+                });
+            }
+        }
+    }
+    // Side-effect import (no symbols)
+    if (symbols.length === 0) {
+        symbols.push({
+            name: '*',
+            isDefault: false,
+            isNamespace: false,
+        });
+    }
+    return {
+        source,
+        resolvedPath,
+        isExternal,
+        typeOnly,
+        symbols,
+        line: line + 1, // Convert to 1-based
+    };
+}
+/**
+ * Try to resolve a local import path
+ */
+function resolveLocalImport(source, fromDir) {
+    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
+    // We don't check if file exists to avoid async issues
+    // Just return the most likely path (.ts is most common)
+    return basePath + '.ts';
+}
+/**
+ * Get transitive imports (imports of imports)
+ */
+async function getTransitiveImports(rootFile, directImports, maxDepth) {
+    const transitiveImports = [];
+    const visited = new Set([rootFile]);
+    async function traverse(imports, chain, depth) {
+        if (depth > maxDepth)
+            return;
+        for (const imp of imports) {
+            if (imp.isExternal || !imp.resolvedPath)
+                continue;
+            if (visited.has(imp.resolvedPath))
+                continue;
+            visited.add(imp.resolvedPath);
+            const newChain = [...chain, imp.resolvedPath];
+            transitiveImports.push({
+                chain: newChain,
+                target: imp.source,
+                depth,
+            });
+            // Get imports from this file
+            try {
+                const fileImports = await analyzeFileImports(imp.resolvedPath);
+                await traverse(fileImports, newChain, depth + 1);
+            }
+            catch {
+                // Skip files that can't be analyzed
+            }
+        }
+    }
+    await traverse(directImports, [rootFile], 1);
+    return transitiveImports;
+}
+/**
+ * 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 getImports tool
+ */
+export function createGetImportsTool(options) {
+    const { defaultRecursive = false, defaultTransitive = false, defaultMaxDepth = 3, } = options ?? {};
+    return defineTool({
+        name: 'get_imports',
+        description: TOOL_DESCRIPTION,
+        inputSchema: TOOL_INPUT_SCHEMA,
+        execute: async (input) => {
+            return executeGetImports({
+                ...input,
+                recursive: input.recursive ?? defaultRecursive,
+                transitive: input.transitive ?? defaultTransitive,
+                maxDepth: input.maxDepth ?? defaultMaxDepth,
+            });
+        },
+    });
+}

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

@@ -0,0 +1,20 @@
+/**
+ * getSignature Tool
+ *
+ * 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';
+/**
+ * getSignature tool
+ */
+export declare const getSignatureTool: Tool<GetSignatureInput>;
+/**
+ * Create customizable getSignature tool
+ */
+export declare function createGetSignatureTool(options?: {
+    name?: string;
+    description?: string;
+    defaultIncludeDoc?: boolean;
+}): Tool<GetSignatureInput>;