@compilr-dev/agents-coding-ts 0.1.0

package/dist/skills/type-analysis.js

@@ -0,0 +1,150 @@
+/**
+ * Type Analysis Skill
+ *
+ * Analyze type hierarchies, interfaces, and their implementations.
+ */
+import { defineSkill } from '@compilr-dev/agents';
+/**
+ * Type analysis skill - Analyze type hierarchies and implementations
+ */
+export const typeAnalysisSkill = defineSkill({
+    name: 'type-analysis',
+    description: 'Analyze type hierarchies, interfaces, and their implementations',
+    prompt: `You are in TYPE ANALYSIS mode. Analyze type relationships in the codebase.
+
+## TOOLS TO USE
+
+1. **get_type_hierarchy**: Analyze inheritance relationships
+   - Find what a class/interface extends
+   - Find what extends/implements a class/interface
+   - Trace the full inheritance chain
+   - Identify abstract vs concrete types
+
+2. **find_implementations**: Find concrete implementations
+   - Find all classes implementing an interface
+   - Find all classes extending an abstract class
+   - See which methods are implemented
+   - Identify partial implementations
+
+## ANALYSIS WORKFLOW
+
+### For Interfaces
+\`\`\`
+// Step 1: Get the interface hierarchy
+get_type_hierarchy({
+  path: "/path/to/file.ts",
+  typeName: "IMyInterface",
+  direction: "descendants"  // Find implementors
+})
+
+// Step 2: Find all implementations
+find_implementations({
+  name: "IMyInterface",
+  scope: "/path/to/project",
+  includeAbstract: false  // Only concrete implementations
+})
+\`\`\`
+
+### For Abstract Classes
+\`\`\`
+// Step 1: Get class hierarchy
+get_type_hierarchy({
+  path: "/path/to/file.ts",
+  typeName: "AbstractBase",
+  direction: "both"  // See parents and children
+})
+
+// Step 2: Find concrete implementations
+find_implementations({
+  name: "AbstractBase",
+  scope: "/path/to/project",
+  includeAbstract: true  // Include abstract subclasses too
+})
+\`\`\`
+
+### For Concrete Classes
+\`\`\`
+// Understand what it inherits from
+get_type_hierarchy({
+  path: "/path/to/file.ts",
+  typeName: "MyClass",
+  direction: "ancestors"  // See parent chain
+})
+\`\`\`
+
+## OUTPUT FORMAT
+
+### Type Overview
+| Property | Value |
+|----------|-------|
+| Name | \`TypeName\` |
+| Kind | interface / abstract class / class |
+| Defined in | path/to/file.ts:42 |
+| Exported | Yes / No |
+| Generic | Yes (T, K) / No |
+
+### Inheritance Chain (ancestors)
+\`\`\`
+TypeName
+  └── extends ParentClass
+        └── extends GrandparentClass
+              └── implements IBaseInterface
+\`\`\`
+
+### Implementations (descendants)
+| Class | File | Status | Missing Methods |
+|-------|------|--------|-----------------|
+| ConcreteA | src/a.ts:10 | ✅ Complete | - |
+| ConcreteB | src/b.ts:25 | ⚠️ Partial | method1, method2 |
+| AbstractC | src/c.ts:5 | 🔷 Abstract | method3 |
+
+### Interface Contract
+| Method | Implementations | Notes |
+|--------|-----------------|-------|
+| \`doSomething()\` | 5/5 | All implement |
+| \`optionalMethod?()\` | 2/5 | Optional, partially implemented |
+
+### Type Relationships Diagram
+\`\`\`
+                    ISerializable
+                         │
+            ┌────────────┼────────────┐
+            │            │            │
+        IEntity     IDocument    IMessage
+            │            │
+       ┌────┴────┐       │
+       │         │       │
+    User      Product  Report
+\`\`\`
+
+### Analysis Summary
+- **Total implementations**: N classes implement this interface
+- **Complete implementations**: X (Y%)
+- **Partial implementations**: Z (list missing methods)
+- **Abstract subclasses**: W
+
+### Recommendations
+1. Classes with missing methods that need attention
+2. Potential interface segregation opportunities
+3. Deep inheritance chains that could be simplified
+
+## COMMON QUESTIONS THIS SKILL ANSWERS
+
+- "What implements IRepository?" → find_implementations
+- "What does UserService extend?" → get_type_hierarchy (ancestors)
+- "What are all the event handlers?" → find_implementations for IEventHandler
+- "Show me the class hierarchy" → get_type_hierarchy (both)
+- "Which classes are missing method X?" → find_implementations (check missingMethods)
+
+## RULES
+
+- Always identify the type kind first (interface, abstract, concrete)
+- For interfaces: focus on implementations
+- For abstract classes: show both hierarchy and implementations
+- For concrete classes: focus on what they inherit
+- Highlight incomplete implementations
+- Note generic type parameters when present
+- Keep diagrams simple - expand on request`,
+    tags: ['types', 'analysis', 'inheritance', 'interfaces', 'architecture'],
+    version: '1.0.0',
+});

package/dist/tools/find-dead-code.d.ts

@@ -0,0 +1,20 @@
+/**
+ * findDeadCode Tool
+ *
+ * Find potentially unused exports, functions, and variables across a codebase.
+ * Uses static analysis to identify code that may be dead.
+ */
+import type { Tool } from '@compilr-dev/agents';
+import type { FindDeadCodeInput } from './types.js';
+/**
+ * findDeadCode tool
+ */
+export declare const findDeadCodeTool: Tool<FindDeadCodeInput>;
+/**
+ * Create customizable findDeadCode tool
+ */
+export declare function createFindDeadCodeTool(options?: {
+    name?: string;
+    description?: string;
+    defaultMaxFiles?: number;
+}): Tool<FindDeadCodeInput>;

package/dist/tools/find-dead-code.js

@@ -0,0 +1,375 @@
+/**
+ * findDeadCode Tool
+ *
+ * Find potentially unused exports, functions, and variables across a codebase.
+ * Uses static analysis to identify code that may be dead.
+ */
+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 = `Find potentially unused exports, functions, and variables.
+Analyzes the codebase to identify code that may be dead (never used).
+Useful for cleanup and reducing bundle size.`;
+// Tool input schema
+const TOOL_INPUT_SCHEMA = {
+    type: 'object',
+    properties: {
+        path: {
+            type: 'string',
+            description: 'Directory to analyze',
+        },
+        includeTests: {
+            type: 'boolean',
+            description: 'Include test files in analysis (default: false)',
+            default: false,
+        },
+        checkExports: {
+            type: 'boolean',
+            description: 'Check for unused exports (default: true)',
+            default: true,
+        },
+        checkFunctions: {
+            type: 'boolean',
+            description: 'Check for unused functions (default: true)',
+            default: true,
+        },
+        checkVariables: {
+            type: 'boolean',
+            description: 'Check for unused variables (default: false)',
+            default: false,
+        },
+        maxFiles: {
+            type: 'number',
+            description: 'Maximum files to analyze (default: 100)',
+            default: 100,
+        },
+    },
+    required: ['path'],
+};
+// Default exclusions
+const DEFAULT_EXCLUDE = ['node_modules', 'dist', 'build', '.git', 'coverage'];
+const TEST_PATTERNS = ['.test.', '.spec.', '__tests__', '__mocks__'];
+/**
+ * findDeadCode tool
+ */
+export const findDeadCodeTool = defineTool({
+    name: 'find_dead_code',
+    description: TOOL_DESCRIPTION,
+    inputSchema: TOOL_INPUT_SCHEMA,
+    execute: executeFindDeadCode,
+});
+/**
+ * Execute the findDeadCode tool
+ */
+async function executeFindDeadCode(input) {
+    const { path: inputPath, includeTests = false, checkExports = true, checkFunctions = true, checkVariables = false, maxFiles = 100, } = input;
+    try {
+        const resolvedPath = path.resolve(inputPath);
+        // Check if path exists
+        try {
+            await fs.access(resolvedPath);
+        }
+        catch {
+            return createErrorResult(`Path not found: ${resolvedPath}`);
+        }
+        const stats = await fs.stat(resolvedPath);
+        if (!stats.isDirectory()) {
+            return createErrorResult('findDeadCode requires a directory path');
+        }
+        // Collect files
+        const files = [];
+        await collectFiles(resolvedPath, files, includeTests, maxFiles);
+        // Build symbol index
+        const definitions = [];
+        const usages = new Set();
+        const importedSymbols = new Set();
+        // First pass: collect all definitions and usages
+        for (const file of files) {
+            await analyzeFile(file, definitions, usages, importedSymbols);
+        }
+        // Find dead code
+        const deadCode = [];
+        // Stats
+        let totalExports = 0;
+        let unusedExports = 0;
+        let totalFunctions = 0;
+        let unusedFunctions = 0;
+        let totalVariables = 0;
+        let unusedVariables = 0;
+        for (const def of definitions) {
+            // Skip index files (re-exports)
+            if (def.path.endsWith('index.ts') || def.path.endsWith('index.js')) {
+                continue;
+            }
+            const isUsed = usages.has(def.name) || importedSymbols.has(def.name);
+            // Check exports
+            if (def.exported && checkExports) {
+                totalExports++;
+                if (!importedSymbols.has(def.name)) {
+                    // Check if it's a main entry point
+                    const isEntryPoint = isLikelyEntryPoint(def.path, def.name);
+                    if (!isEntryPoint) {
+                        unusedExports++;
+                        deadCode.push({
+                            name: def.name,
+                            path: def.path,
+                            line: def.line,
+                            kind: 'export',
+                            exported: true,
+                            confidence: 'medium',
+                            reason: 'Export is not imported anywhere in the codebase',
+                        });
+                    }
+                }
+            }
+            // Check functions
+            if (def.kind === 'function' && checkFunctions) {
+                totalFunctions++;
+                if (!isUsed && !def.exported) {
+                    unusedFunctions++;
+                    deadCode.push({
+                        name: def.name,
+                        path: def.path,
+                        line: def.line,
+                        kind: 'function',
+                        exported: false,
+                        confidence: 'high',
+                        reason: 'Function is not called anywhere in the file',
+                    });
+                }
+            }
+            // Check variables
+            if (def.kind === 'variable' && checkVariables) {
+                totalVariables++;
+                if (!isUsed && !def.exported) {
+                    unusedVariables++;
+                    deadCode.push({
+                        name: def.name,
+                        path: def.path,
+                        line: def.line,
+                        kind: 'variable',
+                        exported: false,
+                        confidence: 'medium',
+                        reason: 'Variable is not referenced after declaration',
+                    });
+                }
+            }
+        }
+        const result = {
+            path: resolvedPath,
+            deadCode,
+            stats: {
+                filesAnalyzed: files.length,
+                totalExports,
+                unusedExports,
+                totalFunctions,
+                unusedFunctions,
+                totalVariables,
+                unusedVariables,
+            },
+        };
+        return createSuccessResult(result);
+    }
+    catch (error) {
+        return createErrorResult(`Failed to find dead code: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Collect files to analyze
+ */
+async function collectFiles(dirPath, files, includeTests, maxFiles, currentDepth = 0) {
+    if (currentDepth > 10 || files.length >= maxFiles)
+        return;
+    try {
+        const entries = await fs.readdir(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+            if (files.length >= maxFiles)
+                break;
+            const fullPath = path.join(dirPath, entry.name);
+            // Skip excluded directories
+            if (entry.isDirectory()) {
+                if (DEFAULT_EXCLUDE.includes(entry.name))
+                    continue;
+                if (!includeTests && entry.name === '__tests__')
+                    continue;
+                await collectFiles(fullPath, files, includeTests, maxFiles, currentDepth + 1);
+            }
+            else if (entry.isFile()) {
+                // Only include TypeScript/JavaScript files
+                if (/\.(ts|tsx|js|jsx)$/.test(entry.name) && !entry.name.endsWith('.d.ts')) {
+                    // Skip test files if not including tests
+                    if (!includeTests && TEST_PATTERNS.some((p) => fullPath.includes(p))) {
+                        continue;
+                    }
+                    files.push(fullPath);
+                }
+            }
+        }
+    }
+    catch {
+        // Ignore permission errors
+    }
+}
+/**
+ * Analyze a file for definitions and usages
+ */
+async function analyzeFile(filePath, definitions, usages, importedSymbols) {
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const detection = detectLanguage(filePath);
+        if (!detection.language || !isLanguageSupported(detection.language)) {
+            return;
+        }
+        const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true, filePath.endsWith('.tsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+        // Collect definitions
+        const visit = (node) => {
+            const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+            // Function declarations
+            if (ts.isFunctionDeclaration(node) && node.name) {
+                const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+                definitions.push({
+                    name: node.name.text,
+                    path: filePath,
+                    line: line + 1,
+                    kind: 'function',
+                    exported: isExported,
+                });
+            }
+            // Class declarations
+            if (ts.isClassDeclaration(node) && node.name) {
+                const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+                definitions.push({
+                    name: node.name.text,
+                    path: filePath,
+                    line: line + 1,
+                    kind: 'class',
+                    exported: isExported,
+                });
+            }
+            // Variable declarations (const, let, var)
+            if (ts.isVariableStatement(node)) {
+                const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+                for (const decl of node.declarationList.declarations) {
+                    if (ts.isIdentifier(decl.name)) {
+                        // Check if it's a function expression
+                        const kind = decl.initializer &&
+                            (ts.isFunctionExpression(decl.initializer) || ts.isArrowFunction(decl.initializer))
+                            ? 'function'
+                            : 'variable';
+                        definitions.push({
+                            name: decl.name.text,
+                            path: filePath,
+                            line: line + 1,
+                            kind,
+                            exported: isExported,
+                        });
+                    }
+                }
+            }
+            // Interface declarations
+            if (ts.isInterfaceDeclaration(node)) {
+                const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+                definitions.push({
+                    name: node.name.text,
+                    path: filePath,
+                    line: line + 1,
+                    kind: 'interface',
+                    exported: isExported,
+                });
+            }
+            // Type alias declarations
+            if (ts.isTypeAliasDeclaration(node)) {
+                const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+                definitions.push({
+                    name: node.name.text,
+                    path: filePath,
+                    line: line + 1,
+                    kind: 'type',
+                    exported: isExported,
+                });
+            }
+            // Enum declarations
+            if (ts.isEnumDeclaration(node)) {
+                const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+                definitions.push({
+                    name: node.name.text,
+                    path: filePath,
+                    line: line + 1,
+                    kind: 'enum',
+                    exported: isExported,
+                });
+            }
+            // Import declarations - track what's imported
+            if (ts.isImportDeclaration(node) && node.importClause) {
+                // Named imports
+                if (node.importClause.namedBindings && ts.isNamedImports(node.importClause.namedBindings)) {
+                    for (const specifier of node.importClause.namedBindings.elements) {
+                        importedSymbols.add(specifier.name.text);
+                    }
+                }
+                // Default import
+                if (node.importClause.name) {
+                    importedSymbols.add(node.importClause.name.text);
+                }
+            }
+            // Track usages (identifiers)
+            if (ts.isIdentifier(node)) {
+                // Skip if it's a declaration name
+                const parent = node.parent;
+                if (!((ts.isFunctionDeclaration(parent) && parent.name === node) ||
+                    (ts.isClassDeclaration(parent) && parent.name === node) ||
+                    (ts.isVariableDeclaration(parent) && parent.name === node) ||
+                    (ts.isInterfaceDeclaration(parent) && parent.name === node) ||
+                    (ts.isTypeAliasDeclaration(parent) && parent.name === node) ||
+                    (ts.isEnumDeclaration(parent) && parent.name === node) ||
+                    (ts.isParameter(parent) && parent.name === node) ||
+                    ts.isImportSpecifier(parent) ||
+                    ts.isExportSpecifier(parent))) {
+                    usages.add(node.text);
+                }
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(sourceFile);
+    }
+    catch {
+        // Ignore errors
+    }
+}
+/**
+ * Check if a symbol is likely an entry point
+ */
+function isLikelyEntryPoint(filePath, symbolName) {
+    // Main entry files
+    const entryPatterns = ['index.ts', 'index.js', 'main.ts', 'main.js', 'app.ts', 'app.js'];
+    const fileName = path.basename(filePath);
+    if (entryPatterns.includes(fileName)) {
+        return true;
+    }
+    // Common exported names that are likely entry points
+    const entrySymbols = ['default', 'main', 'app', 'handler', 'server', 'client'];
+    if (entrySymbols.includes(symbolName.toLowerCase())) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Create customizable findDeadCode tool
+ */
+export function createFindDeadCodeTool(options) {
+    return defineTool({
+        name: options?.name ?? 'find_dead_code',
+        description: options?.description ?? TOOL_DESCRIPTION,
+        inputSchema: TOOL_INPUT_SCHEMA,
+        execute: async (input) => {
+            const modifiedInput = {
+                ...input,
+                maxFiles: input.maxFiles ?? options?.defaultMaxFiles,
+            };
+            return executeFindDeadCode(modifiedInput);
+        },
+    });
+}

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

@@ -0,0 +1,21 @@
+/**
+ * findDuplicates Tool
+ *
+ * Detect duplicate code blocks across the codebase using content hashing.
+ * Helps identify opportunities for refactoring and code reuse.
+ */
+import type { Tool } from '@compilr-dev/agents';
+import type { FindDuplicatesInput } from './types.js';
+/**
+ * findDuplicates tool
+ */
+export declare const findDuplicatesTool: Tool<FindDuplicatesInput>;
+/**
+ * Create customizable findDuplicates tool
+ */
+export declare function createFindDuplicatesTool(options?: {
+    name?: string;
+    description?: string;
+    defaultMinLines?: number;
+    defaultMaxFiles?: number;
+}): Tool<FindDuplicatesInput>;