@compilr-dev/agents-coding-ts 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 scozzola
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @compilr-dev/agents-coding-ts
+ *
+ * TypeScript/JavaScript analysis tools for AI coding agents.
+ * Provides AST-based code analysis, complexity metrics, and type hierarchy tools.
+ */
+export { parseTypeScript, detectLanguage, isLanguageSupported, } from './parser/index.js';
+export { getFileStructureTool, createGetFileStructureTool, findSymbolTool, createFindSymbolTool, findReferencesTool, createFindReferencesTool, getImportsTool, createGetImportsTool, getExportsTool, createGetExportsTool, getCallGraphTool, createGetCallGraphTool, getDependencyGraphTool, createGetDependencyGraphTool, findImplementationsTool, createFindImplementationsTool, getTypeHierarchyTool, createGetTypeHierarchyTool, getComplexityTool, createGetComplexityTool, findDeadCodeTool, createFindDeadCodeTool, findDuplicatesTool, createFindDuplicatesTool, findPatternsTool, createFindPatternsTool, getSignatureTool, createGetSignatureTool, getDocumentationTool, createGetDocumentationTool, } from './tools/index.js';
+export type { SupportedLanguage, ParameterInfo, GetFileStructureInput, FileStructure, ImportInfo, ExportInfo, ClassInfo, FunctionInfo, MethodInfo, PropertyInfo, VariableInfo, TypeDefinitionInfo, FileStats, SymbolKind, SymbolKindFilter, FindSymbolInput, FindSymbolResult, SymbolDefinition, SearchStats, ReferenceType, FindReferencesInput, FindReferencesResult, Reference, FileReferences, GetImportsInput, GetImportsResult, DetailedImport, ImportedSymbol, TransitiveImport, ImportStats, GetExportsInput, GetExportsResult, ExportedSymbol, ExportKind, ReExport, ExportStats, CallGraphDirection, CallType, GetCallGraphInput, GetCallGraphResult, FunctionNode, CallInfo, CallGraphNode, CallGraphStats, GetDependencyGraphInput, GetDependencyGraphResult, ModuleNode, DependencyEdge, CircularDependency, DependencyGraphStats, FindImplementationsInput, FindImplementationsResult, ImplementationInfo, HierarchyDirection, GetTypeHierarchyInput, GetTypeHierarchyResult, TypeHierarchyNode, GetComplexityInput, GetComplexityResult, FileComplexity, FunctionComplexity, ComplexityContributor, ComplexityContributorType, FindDeadCodeInput, FindDeadCodeResult, DeadCodeItem, FindDuplicatesInput, FindDuplicatesResult, DuplicateGroup, CodeLocation, FindPatternsInput, FindPatternsResult, PatternMatch, CodePattern, GetSignatureInput, GetSignatureResult, ParameterDetail, TypeDetail, GenericDetail, Documentation, MemberSignature, SignatureSymbolKind, GetDocumentationInput, GetDocumentationResult, FileDocumentation, DocumentedSymbol, DocumentationSymbolKind, ExtractorOptions, } from './tools/index.js';
+export { codeStructureSkill, dependencyAuditSkill, refactorImpactSkill, typeAnalysisSkill, codeHealthSkill, tsSkills, defineSkill, type Skill, } from './skills/index.js';
+/**
+ * All TypeScript/JavaScript analysis tools for easy registration
+ */
+export declare const tsTools: {
+    readonly getFileStructure: import("@compilr-dev/agents").Tool<import("./tools/types.js").GetFileStructureInput>;
+    readonly findSymbol: import("@compilr-dev/agents").Tool<import("./tools/types.js").FindSymbolInput>;
+    readonly findReferences: import("@compilr-dev/agents").Tool<import("./tools/types.js").FindReferencesInput>;
+    readonly getImports: import("@compilr-dev/agents").Tool<import("./tools/types.js").GetImportsInput>;
+    readonly getExports: import("@compilr-dev/agents").Tool<import("./tools/types.js").GetExportsInput>;
+    readonly getCallGraph: import("@compilr-dev/agents").Tool<import("./tools/types.js").GetCallGraphInput>;
+    readonly getDependencyGraph: import("@compilr-dev/agents").Tool<import("./tools/types.js").GetDependencyGraphInput>;
+    readonly findImplementations: import("@compilr-dev/agents").Tool<import("./tools/types.js").FindImplementationsInput>;
+    readonly getTypeHierarchy: import("@compilr-dev/agents").Tool<import("./tools/types.js").GetTypeHierarchyInput>;
+    readonly getComplexity: import("@compilr-dev/agents").Tool<import("./tools/types.js").GetComplexityInput>;
+    readonly findDeadCode: import("@compilr-dev/agents").Tool<import("./tools/types.js").FindDeadCodeInput>;
+    readonly findDuplicates: import("@compilr-dev/agents").Tool<import("./tools/types.js").FindDuplicatesInput>;
+    readonly findPatterns: import("@compilr-dev/agents").Tool<import("./tools/types.js").FindPatternsInput>;
+    readonly getSignature: import("@compilr-dev/agents").Tool<import("./tools/types.js").GetSignatureInput>;
+    readonly getDocumentation: import("@compilr-dev/agents").Tool<import("./tools/types.js").GetDocumentationInput>;
+};
+/**
+ * Array of all TypeScript/JavaScript analysis tools
+ */
+export declare const allTsTools: readonly [import("@compilr-dev/agents").Tool<import("./tools/types.js").GetFileStructureInput>, import("@compilr-dev/agents").Tool<import("./tools/types.js").FindSymbolInput>, import("@compilr-dev/agents").Tool<import("./tools/types.js").FindReferencesInput>, import("@compilr-dev/agents").Tool<import("./tools/types.js").GetImportsInput>, import("@compilr-dev/agents").Tool<import("./tools/types.js").GetExportsInput>, import("@compilr-dev/agents").Tool<import("./tools/types.js").GetCallGraphInput>, import("@compilr-dev/agents").Tool<import("./tools/types.js").GetDependencyGraphInput>, import("@compilr-dev/agents").Tool<import("./tools/types.js").FindImplementationsInput>, import("@compilr-dev/agents").Tool<import("./tools/types.js").GetTypeHierarchyInput>, import("@compilr-dev/agents").Tool<import("./tools/types.js").GetComplexityInput>, import("@compilr-dev/agents").Tool<import("./tools/types.js").FindDeadCodeInput>, import("@compilr-dev/agents").Tool<import("./tools/types.js").FindDuplicatesInput>, import("@compilr-dev/agents").Tool<import("./tools/types.js").FindPatternsInput>, import("@compilr-dev/agents").Tool<import("./tools/types.js").GetSignatureInput>, import("@compilr-dev/agents").Tool<import("./tools/types.js").GetDocumentationInput>];

package/dist/index.js

@@ -0,0 +1,66 @@
+/**
+ * @compilr-dev/agents-coding-ts
+ *
+ * TypeScript/JavaScript analysis tools for AI coding agents.
+ * Provides AST-based code analysis, complexity metrics, and type hierarchy tools.
+ */
+// Parser exports
+export { parseTypeScript, detectLanguage, isLanguageSupported, } from './parser/index.js';
+// Tool exports
+export { 
+// Tier 1 & 2 Tools
+getFileStructureTool, createGetFileStructureTool, findSymbolTool, createFindSymbolTool, findReferencesTool, createFindReferencesTool, getImportsTool, createGetImportsTool, getExportsTool, createGetExportsTool, getCallGraphTool, createGetCallGraphTool, getDependencyGraphTool, createGetDependencyGraphTool, findImplementationsTool, createFindImplementationsTool, getTypeHierarchyTool, createGetTypeHierarchyTool, 
+// Tier 3 Tools
+getComplexityTool, createGetComplexityTool, findDeadCodeTool, createFindDeadCodeTool, findDuplicatesTool, createFindDuplicatesTool, findPatternsTool, createFindPatternsTool, 
+// Tier 4 Utility Tools
+getSignatureTool, createGetSignatureTool, getDocumentationTool, createGetDocumentationTool, } from './tools/index.js';
+// Skill exports
+export { codeStructureSkill, dependencyAuditSkill, refactorImpactSkill, typeAnalysisSkill, codeHealthSkill, tsSkills, defineSkill, } from './skills/index.js';
+// Tool imports for collections
+import { getFileStructureTool, findSymbolTool, findReferencesTool, getImportsTool, getExportsTool, getCallGraphTool, getDependencyGraphTool, findImplementationsTool, getTypeHierarchyTool, getComplexityTool, findDeadCodeTool, findDuplicatesTool, findPatternsTool, getSignatureTool, getDocumentationTool, } from './tools/index.js';
+/**
+ * All TypeScript/JavaScript analysis tools for easy registration
+ */
+export const tsTools = {
+    // Tier 1 & 2
+    getFileStructure: getFileStructureTool,
+    findSymbol: findSymbolTool,
+    findReferences: findReferencesTool,
+    getImports: getImportsTool,
+    getExports: getExportsTool,
+    getCallGraph: getCallGraphTool,
+    getDependencyGraph: getDependencyGraphTool,
+    findImplementations: findImplementationsTool,
+    getTypeHierarchy: getTypeHierarchyTool,
+    // Tier 3
+    getComplexity: getComplexityTool,
+    findDeadCode: findDeadCodeTool,
+    findDuplicates: findDuplicatesTool,
+    findPatterns: findPatternsTool,
+    // Tier 4
+    getSignature: getSignatureTool,
+    getDocumentation: getDocumentationTool,
+};
+/**
+ * Array of all TypeScript/JavaScript analysis tools
+ */
+export const allTsTools = [
+    // Tier 1 & 2
+    getFileStructureTool,
+    findSymbolTool,
+    findReferencesTool,
+    getImportsTool,
+    getExportsTool,
+    getCallGraphTool,
+    getDependencyGraphTool,
+    findImplementationsTool,
+    getTypeHierarchyTool,
+    // Tier 3
+    getComplexityTool,
+    findDeadCodeTool,
+    findDuplicatesTool,
+    findPatternsTool,
+    // Tier 4
+    getSignatureTool,
+    getDocumentationTool,
+];

package/dist/parser/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * TypeScript/JavaScript Parser
+ *
+ * Provides AST parsing capabilities using the TypeScript Compiler API.
+ */
+export { parseTypeScript, detectLanguage, isLanguageSupported, } from './typescript-parser.js';
+export type { SupportedLanguage } from '../tools/types.js';

package/dist/parser/index.js

@@ -0,0 +1,6 @@
+/**
+ * TypeScript/JavaScript Parser
+ *
+ * Provides AST parsing capabilities using the TypeScript Compiler API.
+ */
+export { parseTypeScript, detectLanguage, isLanguageSupported, } from './typescript-parser.js';

package/dist/parser/typescript-parser.d.ts

@@ -0,0 +1,22 @@
+/**
+ * TypeScript/JavaScript Parser using TypeScript Compiler API
+ *
+ * Uses TypeScript's built-in parser for accurate AST analysis.
+ * Works for both TypeScript and JavaScript files.
+ */
+import type { FileStructure, ExtractorOptions, SupportedLanguage } from '../tools/types.js';
+/**
+ * Parse a TypeScript/JavaScript file and extract its structure
+ */
+export declare function parseTypeScript(sourceCode: string, filePath: string, options?: ExtractorOptions): Omit<FileStructure, 'path' | 'language' | 'languageConfidence'>;
+/**
+ * Detect language from file path
+ */
+export declare function detectLanguage(filePath: string): {
+    language: SupportedLanguage | null;
+    confidence: number;
+};
+/**
+ * Check if a language is supported by this parser
+ */
+export declare function isLanguageSupported(language: string): boolean;

package/dist/parser/typescript-parser.js

@@ -0,0 +1,423 @@
+/**
+ * TypeScript/JavaScript Parser using TypeScript Compiler API
+ *
+ * Uses TypeScript's built-in parser for accurate AST analysis.
+ * Works for both TypeScript and JavaScript files.
+ */
+import * as ts from 'typescript';
+// Helper to check for a specific modifier kind
+function hasModifierKind(modifiers, kind) {
+    return modifiers?.some((m) => m.kind === kind) ?? false;
+}
+/**
+ * Parse a TypeScript/JavaScript file and extract its structure
+ */
+export function parseTypeScript(sourceCode, filePath, options = {}) {
+    const { maxDepth = 2, includePrivate = true } = options;
+    // Determine script kind based on file extension
+    const scriptKind = getScriptKind(filePath);
+    // Parse the source code
+    const sourceFile = ts.createSourceFile(filePath, sourceCode, ts.ScriptTarget.Latest, true, scriptKind);
+    // Extract all structural information
+    const imports = extractImports(sourceFile);
+    const exports = extractExports(sourceFile);
+    const classes = extractClasses(sourceFile, includePrivate, maxDepth);
+    const functions = extractFunctions(sourceFile);
+    const variables = extractVariables(sourceFile);
+    const types = extractTypes(sourceFile);
+    // Calculate stats
+    const stats = {
+        lineCount: sourceCode.split('\n').length,
+        importCount: imports.length,
+        exportCount: exports.length,
+        classCount: classes.length,
+        functionCount: functions.length,
+        typeCount: types.length,
+    };
+    return {
+        imports,
+        exports,
+        classes,
+        functions,
+        variables,
+        types,
+        stats,
+    };
+}
+/**
+ * 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;
+    }
+}
+/**
+ * Extract import statements
+ */
+function extractImports(sourceFile) {
+    const imports = [];
+    ts.forEachChild(sourceFile, (node) => {
+        if (ts.isImportDeclaration(node)) {
+            const moduleSpecifier = node.moduleSpecifier;
+            if (!ts.isStringLiteral(moduleSpecifier))
+                return;
+            const source = moduleSpecifier.text;
+            // Check for type-only import using modifiers
+            const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
+            const hasTypeKeyword = hasModifierKind(modifiers, ts.SyntaxKind.TypeKeyword);
+            const importInfo = {
+                source,
+                names: [],
+                isTypeOnly: hasTypeKeyword,
+            };
+            const importClause = node.importClause;
+            if (importClause) {
+                // Default import
+                if (importClause.name) {
+                    importInfo.defaultImport = importClause.name.text;
+                }
+                // Named imports
+                if (importClause.namedBindings) {
+                    if (ts.isNamedImports(importClause.namedBindings)) {
+                        for (const element of importClause.namedBindings.elements) {
+                            importInfo.names.push(element.name.text);
+                        }
+                    }
+                    else if (ts.isNamespaceImport(importClause.namedBindings)) {
+                        // import * as foo
+                        importInfo.namespaceImport = importClause.namedBindings.name.text;
+                    }
+                }
+            }
+            imports.push(importInfo);
+        }
+    });
+    return imports;
+}
+/**
+ * Extract export statements
+ */
+function extractExports(sourceFile) {
+    const exports = [];
+    ts.forEachChild(sourceFile, (node) => {
+        // export default ...
+        if (ts.isExportAssignment(node)) {
+            exports.push({
+                name: 'default',
+                isDefault: true,
+                isTypeOnly: false,
+            });
+            return;
+        }
+        // export { ... }
+        if (ts.isExportDeclaration(node)) {
+            // Check for type-only export using modifiers
+            const exportMods = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
+            const isTypeOnlyExport = hasModifierKind(exportMods, ts.SyntaxKind.TypeKeyword);
+            if (node.exportClause && ts.isNamedExports(node.exportClause)) {
+                for (const element of node.exportClause.elements) {
+                    exports.push({
+                        name: element.name.text,
+                        isDefault: false,
+                        isTypeOnly: isTypeOnlyExport,
+                    });
+                }
+            }
+            return;
+        }
+        // Check for export modifier on declarations
+        const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
+        const hasExport = hasModifierKind(modifiers, ts.SyntaxKind.ExportKeyword);
+        const hasDefault = hasModifierKind(modifiers, ts.SyntaxKind.DefaultKeyword);
+        if (hasExport) {
+            let name = 'unknown';
+            if (ts.isFunctionDeclaration(node) && node.name) {
+                name = node.name.text;
+            }
+            else if (ts.isClassDeclaration(node) && node.name) {
+                name = node.name.text;
+            }
+            else if (ts.isVariableStatement(node)) {
+                for (const decl of node.declarationList.declarations) {
+                    if (ts.isIdentifier(decl.name)) {
+                        exports.push({
+                            name: decl.name.text,
+                            isDefault: hasDefault,
+                            isTypeOnly: false,
+                        });
+                    }
+                }
+                return;
+            }
+            else if (ts.isInterfaceDeclaration(node)) {
+                name = node.name.text;
+            }
+            else if (ts.isTypeAliasDeclaration(node)) {
+                name = node.name.text;
+            }
+            else if (ts.isEnumDeclaration(node)) {
+                name = node.name.text;
+            }
+            if (name !== 'unknown' || hasDefault) {
+                exports.push({
+                    name: hasDefault ? 'default' : name,
+                    isDefault: hasDefault,
+                    isTypeOnly: ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node),
+                });
+            }
+        }
+    });
+    return exports;
+}
+/**
+ * Extract class declarations
+ */
+function extractClasses(sourceFile, includePrivate, maxDepth) {
+    const classes = [];
+    ts.forEachChild(sourceFile, (node) => {
+        if (ts.isClassDeclaration(node)) {
+            const classInfo = extractClassInfo(node, includePrivate, maxDepth);
+            if (classInfo) {
+                classes.push(classInfo);
+            }
+        }
+    });
+    return classes;
+}
+/**
+ * Extract information from a class declaration
+ */
+function extractClassInfo(node, includePrivate, _maxDepth) {
+    const name = node.name?.text ?? 'anonymous';
+    const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
+    const isExported = hasModifierKind(modifiers, ts.SyntaxKind.ExportKeyword);
+    const isAbstract = hasModifierKind(modifiers, ts.SyntaxKind.AbstractKeyword);
+    const methods = [];
+    const properties = [];
+    for (const member of node.members) {
+        const memberModifiers = ts.canHaveModifiers(member) ? ts.getModifiers(member) : undefined;
+        const visibility = getVisibility(memberModifiers);
+        // Skip private members if not included
+        if (!includePrivate && visibility === 'private') {
+            continue;
+        }
+        if (ts.isConstructorDeclaration(member)) {
+            const isAsync = hasModifierKind(memberModifiers, ts.SyntaxKind.AsyncKeyword);
+            const isStatic = hasModifierKind(memberModifiers, ts.SyntaxKind.StaticKeyword);
+            methods.push({
+                name: 'constructor',
+                visibility,
+                async: isAsync,
+                static: isStatic,
+                parameters: extractParameters(member.parameters),
+                returnType: member.type ? member.type.getText() : undefined,
+            });
+        }
+        else if (ts.isMethodDeclaration(member)) {
+            const methodName = ts.isIdentifier(member.name) ? member.name.text : 'computed';
+            const isAsync = hasModifierKind(memberModifiers, ts.SyntaxKind.AsyncKeyword);
+            const isStatic = hasModifierKind(memberModifiers, ts.SyntaxKind.StaticKeyword);
+            methods.push({
+                name: methodName,
+                visibility,
+                async: isAsync,
+                static: isStatic,
+                parameters: extractParameters(member.parameters),
+                returnType: member.type ? member.type.getText() : undefined,
+            });
+        }
+        else if (ts.isPropertyDeclaration(member)) {
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- member.name can be undefined for computed properties
+            const propName = member.name && ts.isIdentifier(member.name) ? member.name.text : null;
+            if (propName) {
+                const isStatic = hasModifierKind(memberModifiers, ts.SyntaxKind.StaticKeyword);
+                const isReadonly = hasModifierKind(memberModifiers, ts.SyntaxKind.ReadonlyKeyword);
+                properties.push({
+                    name: propName,
+                    visibility,
+                    static: isStatic,
+                    readonly: isReadonly,
+                    type: member.type ? member.type.getText() : undefined,
+                });
+            }
+        }
+    }
+    return {
+        name,
+        exported: isExported,
+        abstract: isAbstract,
+        methods,
+        properties,
+    };
+}
+/**
+ * Get visibility modifier
+ */
+function getVisibility(modifiers) {
+    if (!modifiers)
+        return 'public';
+    for (const mod of modifiers) {
+        if (mod.kind === ts.SyntaxKind.PrivateKeyword)
+            return 'private';
+        if (mod.kind === ts.SyntaxKind.ProtectedKeyword)
+            return 'protected';
+    }
+    return 'public';
+}
+/**
+ * Extract parameter information
+ */
+function extractParameters(params) {
+    return params.map((param) => ({
+        name: ts.isIdentifier(param.name) ? param.name.text : 'param',
+        type: param.type ? param.type.getText() : undefined,
+    }));
+}
+/**
+ * Extract function declarations
+ */
+function extractFunctions(sourceFile) {
+    const functions = [];
+    ts.forEachChild(sourceFile, (node) => {
+        // Function declarations
+        if (ts.isFunctionDeclaration(node) && node.name) {
+            const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
+            const isExported = hasModifierKind(modifiers, ts.SyntaxKind.ExportKeyword);
+            const isAsync = hasModifierKind(modifiers, ts.SyntaxKind.AsyncKeyword);
+            functions.push({
+                name: node.name.text,
+                exported: isExported,
+                async: isAsync,
+                parameters: extractParameters(node.parameters),
+                returnType: node.type ? node.type.getText() : undefined,
+            });
+        }
+        // Variable declarations that are arrow functions
+        if (ts.isVariableStatement(node)) {
+            const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
+            const isExported = hasModifierKind(modifiers, ts.SyntaxKind.ExportKeyword);
+            for (const decl of node.declarationList.declarations) {
+                if (ts.isIdentifier(decl.name) && decl.initializer) {
+                    if (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer)) {
+                        const funcModifiers = decl.initializer.modifiers;
+                        const isAsync = funcModifiers
+                            ? funcModifiers.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)
+                            : false;
+                        functions.push({
+                            name: decl.name.text,
+                            exported: isExported,
+                            async: isAsync,
+                            parameters: extractParameters(decl.initializer.parameters),
+                            returnType: decl.initializer.type ? decl.initializer.type.getText() : undefined,
+                        });
+                    }
+                }
+            }
+        }
+    });
+    return functions;
+}
+/**
+ * Extract variable declarations (excluding functions)
+ */
+function extractVariables(sourceFile) {
+    const variables = [];
+    ts.forEachChild(sourceFile, (node) => {
+        if (ts.isVariableStatement(node)) {
+            const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
+            const isExported = hasModifierKind(modifiers, ts.SyntaxKind.ExportKeyword);
+            const kind = node.declarationList.flags & ts.NodeFlags.Const ? 'const' : 'let';
+            for (const decl of node.declarationList.declarations) {
+                if (ts.isIdentifier(decl.name)) {
+                    // Skip if this is a function (arrow function or function expression)
+                    if (decl.initializer &&
+                        (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer))) {
+                        continue;
+                    }
+                    variables.push({
+                        name: decl.name.text,
+                        kind: kind,
+                        exported: isExported,
+                        type: decl.type ? decl.type.getText() : undefined,
+                    });
+                }
+            }
+        }
+    });
+    return variables;
+}
+/**
+ * Extract type definitions (interfaces, type aliases, enums)
+ */
+function extractTypes(sourceFile) {
+    const types = [];
+    ts.forEachChild(sourceFile, (node) => {
+        const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
+        const isExported = hasModifierKind(modifiers, ts.SyntaxKind.ExportKeyword);
+        if (ts.isInterfaceDeclaration(node)) {
+            types.push({
+                name: node.name.text,
+                kind: 'interface',
+                exported: isExported,
+            });
+        }
+        else if (ts.isTypeAliasDeclaration(node)) {
+            types.push({
+                name: node.name.text,
+                kind: 'type',
+                exported: isExported,
+            });
+        }
+        else if (ts.isEnumDeclaration(node)) {
+            types.push({
+                name: node.name.text,
+                kind: 'enum',
+                exported: isExported,
+            });
+        }
+    });
+    return types;
+}
+/**
+ * Detect language from file path
+ */
+export function detectLanguage(filePath) {
+    const ext = filePath.toLowerCase().split('.').pop();
+    switch (ext) {
+        case 'ts':
+        case 'tsx':
+        case 'mts':
+        case 'cts':
+            return { language: 'typescript', confidence: 1.0 };
+        case 'js':
+        case 'jsx':
+        case 'mjs':
+        case 'cjs':
+            return { language: 'javascript', confidence: 1.0 };
+        default:
+            return { language: null, confidence: 0 };
+    }
+}
+/**
+ * Check if a language is supported by this parser
+ */
+export function isLanguageSupported(language) {
+    return language === 'typescript' || language === 'javascript';
+}

package/dist/skills/code-health.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Code Health Skill
+ *
+ * Analyze codebase health: complexity, dead code, duplicates, and anti-patterns.
+ */
+/**
+ * Code health skill - Analyze codebase health using Tier 3 tools
+ */
+export declare const codeHealthSkill: import("@compilr-dev/agents").Skill;