@compilr-dev/agents-coding-ts 0.1.0

package/dist/tools/types.d.ts

@@ -0,0 +1,1302 @@
+/**
+ * Types for Source Code Analysis Tools
+ *
+ * Uses TypeScript Compiler API for structural analysis of source code,
+ * reducing the need for the agent to read and reason through raw text.
+ */
+/**
+ * Supported languages for analysis
+ */
+export type SupportedLanguage = 'typescript' | 'javascript';
+/**
+ * Parameter information for functions/methods
+ */
+export interface ParameterInfo {
+    /** Parameter name */
+    name: string;
+    /** Type annotation (if available) */
+    type?: string;
+}
+/**
+ * Input for getFileStructure tool
+ */
+export interface GetFileStructureInput {
+    /** Absolute path to the file to analyze */
+    path: string;
+    /** Maximum depth for nested structures (default: 2) */
+    maxDepth?: number;
+    /** Include private/internal symbols (default: true) */
+    includePrivate?: boolean;
+}
+/**
+ * Output from getFileStructure tool
+ */
+export interface FileStructure {
+    /** Analyzed file path */
+    path: string;
+    /** Detected language */
+    language: string;
+    /** Language detection confidence (0-1) */
+    languageConfidence: number;
+    /** File imports */
+    imports: ImportInfo[];
+    /** File exports */
+    exports: ExportInfo[];
+    /** Top-level classes */
+    classes: ClassInfo[];
+    /** Top-level functions */
+    functions: FunctionInfo[];
+    /** Top-level variables/constants */
+    variables: VariableInfo[];
+    /** Type definitions (interfaces, types, enums) */
+    types: TypeDefinitionInfo[];
+    /** File statistics */
+    stats?: FileStats;
+}
+/**
+ * Import information
+ */
+export interface ImportInfo {
+    /** Module/package being imported */
+    source: string;
+    /** Named imports */
+    names: string[];
+    /** Default import name */
+    defaultImport?: string;
+    /** Namespace import (import * as x) */
+    namespaceImport?: string;
+    /** Is type-only import */
+    isTypeOnly: boolean;
+}
+/**
+ * Export information
+ */
+export interface ExportInfo {
+    /** Exported symbol name */
+    name: string;
+    /** Is default export */
+    isDefault: boolean;
+    /** Is type-only export */
+    isTypeOnly: boolean;
+}
+/**
+ * Class information
+ */
+export interface ClassInfo {
+    /** Class name */
+    name: string;
+    /** Is exported */
+    exported: boolean;
+    /** Is abstract */
+    abstract?: boolean;
+    /** Class methods */
+    methods?: MethodInfo[];
+    /** Class properties */
+    properties?: PropertyInfo[];
+}
+/**
+ * Function information
+ */
+export interface FunctionInfo {
+    /** Function name */
+    name: string;
+    /** Is exported */
+    exported: boolean;
+    /** Is async */
+    async: boolean;
+    /** Parameters */
+    parameters?: ParameterInfo[];
+    /** Return type (if available) */
+    returnType?: string;
+}
+/**
+ * Method information
+ */
+export interface MethodInfo {
+    /** Method name */
+    name: string;
+    /** Visibility */
+    visibility: 'public' | 'private' | 'protected';
+    /** Is async */
+    async: boolean;
+    /** Is static */
+    static: boolean;
+    /** Parameters */
+    parameters?: ParameterInfo[];
+    /** Return type (if available) */
+    returnType?: string;
+}
+/**
+ * Property information
+ */
+export interface PropertyInfo {
+    /** Property name */
+    name: string;
+    /** Type annotation */
+    type?: string;
+    /** Visibility */
+    visibility: 'public' | 'private' | 'protected';
+    /** Is static */
+    static: boolean;
+    /** Is readonly */
+    readonly?: boolean;
+}
+/**
+ * Variable/constant information
+ */
+export interface VariableInfo {
+    /** Variable name */
+    name: string;
+    /** Declaration kind */
+    kind: 'const' | 'let' | 'var';
+    /** Type annotation */
+    type?: string;
+    /** Is exported */
+    exported: boolean;
+}
+/**
+ * Type definition information (interface, type alias, enum)
+ */
+export interface TypeDefinitionInfo {
+    /** Type name */
+    name: string;
+    /** Kind of type definition */
+    kind: 'interface' | 'type' | 'enum';
+    /** Is exported */
+    exported: boolean;
+}
+/**
+ * File statistics
+ */
+export interface FileStats {
+    /** Total line count */
+    lineCount: number;
+    /** Number of imports */
+    importCount: number;
+    /** Number of exports */
+    exportCount: number;
+    /** Number of classes */
+    classCount: number;
+    /** Number of functions */
+    functionCount: number;
+    /** Number of type definitions */
+    typeCount: number;
+}
+/**
+ * Options for parsing/extraction
+ */
+export interface ExtractorOptions {
+    /** Maximum depth for nested structures */
+    maxDepth?: number;
+    /** Include private members */
+    includePrivate?: boolean;
+}
+/**
+ * Symbol kind for filtering
+ */
+export type SymbolKind = 'function' | 'class' | 'variable' | 'type' | 'interface' | 'enum' | 'method' | 'property';
+/**
+ * Symbol kind filter (includes 'any' for no filtering)
+ */
+export type SymbolKindFilter = SymbolKind | 'any';
+/**
+ * Input for findSymbol tool
+ */
+export interface FindSymbolInput {
+    /** Symbol name to find */
+    symbol: string;
+    /** Scope the search to a specific file or directory */
+    scope?: string;
+    /** Filter by symbol kind */
+    kind?: SymbolKindFilter;
+    /** Maximum results to return (default: 10) */
+    limit?: number;
+    /** Include symbols from node_modules (default: false) */
+    includeNodeModules?: boolean;
+}
+/**
+ * A found symbol definition
+ */
+export interface SymbolDefinition {
+    /** Symbol name */
+    name: string;
+    /** File path */
+    path: string;
+    /** Line number (1-based) */
+    line: number;
+    /** Column number (1-based) */
+    column: number;
+    /** Symbol kind */
+    kind: SymbolKind;
+    /** Containing class/module (if applicable) */
+    container?: string;
+    /** Is exported */
+    exported: boolean;
+    /** Signature (for functions/methods) */
+    signature?: string;
+    /** JSDoc/docstring summary */
+    docSummary?: string;
+    /** Confidence score (0-1) for fuzzy matches */
+    confidence: number;
+}
+/**
+ * Search statistics
+ */
+export interface SearchStats {
+    /** Number of files searched */
+    filesSearched: number;
+    /** Time taken in milliseconds */
+    timeMs: number;
+}
+/**
+ * Output from findSymbol tool
+ */
+export interface FindSymbolResult {
+    /** Symbol that was searched */
+    query: string;
+    /** Found definitions */
+    definitions: SymbolDefinition[];
+    /** Search statistics */
+    stats: SearchStats;
+}
+/**
+ * Reference type - how the symbol is used
+ */
+export type ReferenceType = 'read' | 'write' | 'call' | 'import' | 'export' | 'type' | 'extend' | 'implement';
+/**
+ * Input for findReferences tool
+ */
+export interface FindReferencesInput {
+    /** Symbol name to find */
+    symbol: string;
+    /** File where the symbol is defined (improves accuracy) */
+    definitionFile?: string;
+    /** Line where symbol is defined (improves accuracy) */
+    definitionLine?: number;
+    /** Scope the search to a specific file or directory */
+    scope?: string;
+    /** Maximum results to return (default: 50) */
+    limit?: number;
+    /** Include the definition itself (default: false) */
+    includeDefinition?: boolean;
+    /** Group results by file (default: true) */
+    groupByFile?: boolean;
+}
+/**
+ * A reference to a symbol
+ */
+export interface Reference {
+    /** File path */
+    path: string;
+    /** Line number (1-based) */
+    line: number;
+    /** Column number (1-based) */
+    column: number;
+    /** Reference context (the line of code, trimmed) */
+    context: string;
+    /** Reference type */
+    type: ReferenceType;
+    /** Containing function/method */
+    containingFunction?: string;
+}
+/**
+ * References grouped by file
+ */
+export interface FileReferences {
+    /** File path */
+    path: string;
+    /** References in this file */
+    references: Reference[];
+}
+/**
+ * Output from findReferences tool
+ */
+export interface FindReferencesResult {
+    /** Symbol that was searched */
+    symbol: string;
+    /** Definition location (if found) */
+    definition?: SymbolDefinition;
+    /** References grouped by file (if groupByFile=true) */
+    byFile?: FileReferences[];
+    /** Flat list of references (if groupByFile=false) */
+    references?: Reference[];
+    /** Total reference count */
+    totalCount: number;
+    /** Whether results were truncated */
+    truncated: boolean;
+    /** Search statistics */
+    stats: SearchStats;
+}
+/**
+ * Input for getImports tool
+ */
+export interface GetImportsInput {
+    /** File or directory to analyze */
+    path: string;
+    /** Recursively analyze directory (default: false) */
+    recursive?: boolean;
+    /** Filter to specific import sources */
+    filterSource?: string;
+    /** Include transitive imports (default: false) */
+    transitive?: boolean;
+    /** Max depth for transitive imports (default: 3) */
+    maxDepth?: number;
+}
+/**
+ * An imported symbol
+ */
+export interface ImportedSymbol {
+    /** Symbol name as imported */
+    name: string;
+    /** Original name if aliased */
+    originalName?: string;
+    /** Is default import */
+    isDefault: boolean;
+    /** Is namespace import */
+    isNamespace: boolean;
+    /** Used in file (for dead import detection) */
+    isUsed?: boolean;
+}
+/**
+ * Detailed import information
+ */
+export interface DetailedImport {
+    /** Import source (package or path) */
+    source: string;
+    /** Resolved absolute path (for local imports) */
+    resolvedPath?: string;
+    /** Is external package */
+    isExternal: boolean;
+    /** Is type-only import */
+    typeOnly: boolean;
+    /** Imported symbols */
+    symbols: ImportedSymbol[];
+    /** Line number (1-based) */
+    line: number;
+    /** For external: package version from lockfile */
+    version?: string;
+}
+/**
+ * Transitive import chain
+ */
+export interface TransitiveImport {
+    /** Import chain: [fileA, fileB, fileC] means A->B->C */
+    chain: string[];
+    /** Final imported module */
+    target: string;
+    /** Depth in import tree */
+    depth: number;
+}
+/**
+ * Import statistics
+ */
+export interface ImportStats {
+    /** Total number of imports */
+    totalImports: number;
+    /** Number of external package imports */
+    externalPackages: number;
+    /** Number of internal module imports */
+    internalModules: number;
+    /** Number of type-only imports */
+    typeOnlyImports: number;
+}
+/**
+ * Output from getImports tool
+ */
+export interface GetImportsResult {
+    /** Analyzed path */
+    path: string;
+    /** Direct imports */
+    imports: DetailedImport[];
+    /** Transitive imports (if requested) */
+    transitiveImports?: TransitiveImport[];
+    /** Import statistics */
+    stats: ImportStats;
+}
+/**
+ * Input for getExports tool
+ */
+export interface GetExportsInput {
+    /** File or directory to analyze */
+    path: string;
+    /** Include re-exports (default: true) */
+    includeReExports?: boolean;
+    /** Resolve re-exports to original source (default: false) */
+    resolveReExports?: boolean;
+}
+/**
+ * Kind of exported symbol
+ */
+export type ExportKind = 'function' | 'class' | 'variable' | 'type' | 'interface' | 'enum' | 'namespace' | 'unknown';
+/**
+ * An exported symbol
+ */
+export interface ExportedSymbol {
+    /** Exported name */
+    name: string;
+    /** Kind of export */
+    kind: ExportKind;
+    /** Line number (1-based) */
+    line: number;
+    /** Signature (for functions) */
+    signature?: string;
+    /** JSDoc summary */
+    docSummary?: string;
+    /** Is type-only export */
+    typeOnly?: boolean;
+}
+/**
+ * A re-export (export from another module)
+ */
+export interface ReExport {
+    /** What is being re-exported ('*' for all) */
+    symbols: string[] | '*';
+    /** Source module */
+    from: string;
+    /** Resolved absolute path (for local modules) */
+    resolvedFrom?: string;
+    /** Line number (1-based) */
+    line: number;
+    /** Is type-only re-export */
+    typeOnly?: boolean;
+}
+/**
+ * Export statistics
+ */
+export interface ExportStats {
+    /** Total number of exports */
+    totalExports: number;
+    /** Number of function exports */
+    functions: number;
+    /** Number of class exports */
+    classes: number;
+    /** Number of type/interface exports */
+    types: number;
+    /** Number of variable exports */
+    variables: number;
+    /** Number of re-exports */
+    reExports: number;
+}
+/**
+ * Output from getExports tool
+ */
+export interface GetExportsResult {
+    /** Analyzed path */
+    path: string;
+    /** Default export (if any) */
+    defaultExport?: ExportedSymbol;
+    /** Named exports */
+    namedExports: ExportedSymbol[];
+    /** Re-exports (exports from other modules) */
+    reExports?: ReExport[];
+    /** Export statistics */
+    stats: ExportStats;
+}
+/**
+ * Direction for call graph traversal
+ */
+export type CallGraphDirection = 'callers' | 'callees' | 'both';
+/**
+ * Type of function call
+ */
+export type CallType = 'direct' | 'callback' | 'promise' | 'event' | 'method';
+/**
+ * Input for getCallGraph tool
+ */
+export interface GetCallGraphInput {
+    /** File to analyze */
+    path: string;
+    /** Specific function to analyze (optional - analyzes all if not specified) */
+    functionName?: string;
+    /** Direction: 'callers' | 'callees' | 'both' (default: 'both') */
+    direction?: CallGraphDirection;
+    /** Maximum depth to traverse (default: 2) */
+    maxDepth?: number;
+    /** Include external package calls (default: false) */
+    includeExternal?: boolean;
+    /** Scope directory for finding callers (default: file's directory) */
+    scope?: string;
+}
+/**
+ * A function node in the call graph
+ */
+export interface FunctionNode {
+    /** Function name */
+    name: string;
+    /** File path */
+    path: string;
+    /** Line number (1-based) */
+    line: number;
+    /** Column number (1-based) */
+    column: number;
+    /** Containing class (if method) */
+    className?: string;
+    /** Is async function */
+    async?: boolean;
+    /** Is exported */
+    exported?: boolean;
+}
+/**
+ * Information about a function call
+ */
+export interface CallInfo {
+    /** Called/calling function */
+    function: FunctionNode;
+    /** Line where call occurs (1-based) */
+    callLine: number;
+    /** Column where call occurs (1-based) */
+    callColumn: number;
+    /** Call type */
+    type: CallType;
+    /** Number of call sites (for aggregated results) */
+    count: number;
+}
+/**
+ * A node in the call graph with its edges
+ */
+export interface CallGraphNode {
+    /** Function info */
+    function: FunctionNode;
+    /** Functions this function calls (outgoing edges) */
+    calls: CallInfo[];
+    /** Functions that call this function (incoming edges) */
+    calledBy: CallInfo[];
+}
+/**
+ * Call graph statistics
+ */
+export interface CallGraphStats {
+    /** Total number of functions in the graph */
+    totalFunctions: number;
+    /** Total number of call edges */
+    totalCalls: number;
+    /** Maximum depth reached */
+    maxDepthReached: number;
+    /** Number of external calls (if includeExternal) */
+    externalCalls?: number;
+}
+/**
+ * Output from getCallGraph tool
+ */
+export interface GetCallGraphResult {
+    /** Root function analyzed (if functionName was specified) */
+    root?: FunctionNode;
+    /** Call graph nodes */
+    graph: CallGraphNode[];
+    /** Statistics */
+    stats: CallGraphStats;
+}
+/**
+ * Input for getDependencyGraph tool
+ */
+export interface GetDependencyGraphInput {
+    /** Directory or file to analyze */
+    path: string;
+    /** Include external package dependencies (default: true) */
+    includeExternal?: boolean;
+    /** Include type-only imports (default: true) */
+    includeTypeOnly?: boolean;
+    /** Maximum depth for directory traversal (default: 10) */
+    maxDepth?: number;
+    /** File patterns to include (glob patterns like *.ts, *.tsx, *.js) */
+    include?: string[];
+    /** File patterns to exclude (glob patterns like node_modules, dist) */
+    exclude?: string[];
+}
+/**
+ * A module node in the dependency graph
+ */
+export interface ModuleNode {
+    /** Module path (relative to analysis root) */
+    path: string;
+    /** Absolute path */
+    absolutePath: string;
+    /** Is external package */
+    isExternal: boolean;
+    /** Package name (for external modules) */
+    packageName?: string;
+    /** Number of exports */
+    exportCount?: number;
+}
+/**
+ * A dependency edge in the graph
+ */
+export interface DependencyEdge {
+    /** Source module */
+    from: string;
+    /** Target module */
+    to: string;
+    /** Import type */
+    importType: 'named' | 'default' | 'namespace' | 'side-effect';
+    /** Is type-only import */
+    typeOnly: boolean;
+    /** Number of symbols imported */
+    symbolCount: number;
+    /** Imported symbol names (up to 10) */
+    symbols?: string[];
+}
+/**
+ * A circular dependency chain
+ */
+export interface CircularDependency {
+    /** Modules in the cycle (first and last are the same) */
+    cycle: string[];
+    /** Length of the cycle */
+    length: number;
+}
+/**
+ * Dependency graph statistics
+ */
+export interface DependencyGraphStats {
+    /** Total number of modules */
+    totalModules: number;
+    /** Number of internal modules */
+    internalModules: number;
+    /** Number of external packages */
+    externalPackages: number;
+    /** Total number of dependency edges */
+    totalEdges: number;
+    /** Number of circular dependencies detected */
+    circularDependencies: number;
+    /** List of external package names */
+    externalPackageList: string[];
+    /** Module with most dependencies (imports) */
+    mostDependencies?: {
+        module: string;
+        count: number;
+    };
+    /** Module with most dependents (imported by) */
+    mostDependents?: {
+        module: string;
+        count: number;
+    };
+}
+/**
+ * Output from getDependencyGraph tool
+ */
+export interface GetDependencyGraphResult {
+    /** Root path analyzed */
+    root: string;
+    /** All modules in the graph */
+    modules: ModuleNode[];
+    /** Dependency edges */
+    edges: DependencyEdge[];
+    /** Detected circular dependencies */
+    circularDependencies: CircularDependency[];
+    /** Statistics */
+    stats: DependencyGraphStats;
+}
+/**
+ * Input for findImplementations tool
+ */
+export interface FindImplementationsInput {
+    /** Interface or abstract class name to find implementations of */
+    name: string;
+    /** Scope: file or directory to search in */
+    scope?: string;
+    /** Include abstract classes that partially implement (default: false) */
+    includeAbstract?: boolean;
+    /** Maximum files to search (default: 100) */
+    maxFiles?: number;
+}
+/**
+ * An implementation of an interface or abstract class
+ */
+export interface ImplementationInfo {
+    /** Class/type name */
+    name: string;
+    /** File path */
+    path: string;
+    /** Line number (1-based) */
+    line: number;
+    /** Column number (1-based) */
+    column: number;
+    /** Kind of implementation */
+    kind: 'class' | 'type' | 'object';
+    /** Is abstract (partial implementation) */
+    isAbstract?: boolean;
+    /** Is exported */
+    exported: boolean;
+    /** Methods implemented (if interface) */
+    implementedMethods?: string[];
+    /** Methods missing (if partial) */
+    missingMethods?: string[];
+}
+/**
+ * Output from findImplementations tool
+ */
+export interface FindImplementationsResult {
+    /** Interface/abstract class that was searched */
+    target: string;
+    /** Target location (if found) */
+    targetLocation?: {
+        path: string;
+        line: number;
+    };
+    /** Found implementations */
+    implementations: ImplementationInfo[];
+    /** Statistics */
+    stats: {
+        filesSearched: number;
+        implementationsFound: number;
+        timeMs: number;
+    };
+}
+/**
+ * Direction for type hierarchy traversal
+ */
+export type HierarchyDirection = 'ancestors' | 'descendants' | 'both';
+/**
+ * Input for getTypeHierarchy tool
+ */
+export interface GetTypeHierarchyInput {
+    /** Class or interface name */
+    name: string;
+    /** File where the type is defined (improves accuracy) */
+    file?: string;
+    /** Direction: 'ancestors' | 'descendants' | 'both' (default: 'both') */
+    direction?: HierarchyDirection;
+    /** Maximum depth to traverse (default: 5) */
+    maxDepth?: number;
+    /** Scope for searching descendants */
+    scope?: string;
+}
+/**
+ * A type in the hierarchy
+ */
+export interface TypeHierarchyNode {
+    /** Type name */
+    name: string;
+    /** File path */
+    path: string;
+    /** Line number (1-based) */
+    line: number;
+    /** Kind of type */
+    kind: 'class' | 'interface' | 'type';
+    /** Is abstract */
+    isAbstract?: boolean;
+    /** Is exported */
+    exported: boolean;
+    /** Parent types (extends/implements) */
+    parents?: TypeHierarchyNode[];
+    /** Child types (extended by/implemented by) */
+    children?: TypeHierarchyNode[];
+}
+/**
+ * Output from getTypeHierarchy tool
+ */
+export interface GetTypeHierarchyResult {
+    /** Root type that was analyzed */
+    root: TypeHierarchyNode;
+    /** Flat list of all types in hierarchy */
+    allTypes: TypeHierarchyNode[];
+    /** Statistics */
+    stats: {
+        totalTypes: number;
+        maxDepthReached: number;
+        filesSearched: number;
+    };
+}
+/**
+ * Input for getComplexity tool
+ */
+export interface GetComplexityInput {
+    /** File or directory to analyze */
+    path: string;
+    /** Recursive analysis for directories (default: false) */
+    recursive?: boolean;
+    /** Complexity threshold for warnings (default: 10) */
+    threshold?: number;
+    /** Only return items above threshold (default: false) */
+    onlyAboveThreshold?: boolean;
+    /** Maximum files to analyze (default: 50) */
+    maxFiles?: number;
+}
+/**
+ * Complexity contributor type
+ */
+export type ComplexityContributorType = 'if' | 'else' | 'switch' | 'case' | 'for' | 'while' | 'do' | 'catch' | 'ternary' | 'logical_and' | 'logical_or' | 'nullish' | 'nesting';
+/**
+ * A contributor to complexity score
+ */
+export interface ComplexityContributor {
+    /** Type of complexity contributor */
+    type: ComplexityContributorType;
+    /** Line number */
+    line: number;
+    /** Contribution to complexity score */
+    contribution: number;
+}
+/**
+ * Complexity metrics for a single function
+ */
+export interface FunctionComplexity {
+    /** Function name */
+    name: string;
+    /** Line number */
+    line: number;
+    /** End line number */
+    endLine: number;
+    /** Cyclomatic complexity */
+    cyclomatic: number;
+    /** Cognitive complexity (Sonar-style) */
+    cognitive: number;
+    /** Maximum nesting depth */
+    maxNesting: number;
+    /** Lines of code (excluding blank/comments) */
+    loc: number;
+    /** Parameter count */
+    parameterCount: number;
+    /** Is above threshold */
+    aboveThreshold: boolean;
+    /** Complexity contributors (if above threshold) */
+    contributors?: ComplexityContributor[];
+}
+/**
+ * Complexity metrics for a file
+ */
+export interface FileComplexity {
+    /** File path */
+    path: string;
+    /** File-level metrics */
+    metrics: {
+        /** Total lines */
+        lines: number;
+        /** Lines of code */
+        linesOfCode: number;
+        /** Number of functions */
+        functions: number;
+        /** Number of classes */
+        classes: number;
+        /** Average complexity */
+        avgComplexity: number;
+        /** Maximum complexity */
+        maxComplexity: number;
+    };
+    /** Function-level complexity */
+    functions: FunctionComplexity[];
+}
+/**
+ * Output from getComplexity tool
+ */
+export interface GetComplexityResult {
+    /** Analyzed path */
+    path: string;
+    /** File-level complexity */
+    files: FileComplexity[];
+    /** Summary statistics */
+    summary: {
+        totalFiles: number;
+        totalFunctions: number;
+        averageComplexity: number;
+        maxComplexity: number;
+        aboveThreshold: number;
+        threshold: number;
+    };
+    /** Most complex functions (top 5) */
+    hotspots: Array<{
+        name: string;
+        path: string;
+        line: number;
+        cyclomatic: number;
+        cognitive: number;
+    }>;
+}
+/**
+ * Input for findDeadCode tool
+ */
+export interface FindDeadCodeInput {
+    /** Directory to analyze */
+    path: string;
+    /** Include test files in analysis (default: false) */
+    includeTests?: boolean;
+    /** Check for unused exports (default: true) */
+    checkExports?: boolean;
+    /** Check for unused functions (default: true) */
+    checkFunctions?: boolean;
+    /** Check for unused variables (default: false) */
+    checkVariables?: boolean;
+    /** Maximum files to analyze (default: 100) */
+    maxFiles?: number;
+}
+/**
+ * A potentially dead code item
+ */
+export interface DeadCodeItem {
+    /** Symbol name */
+    name: string;
+    /** File path */
+    path: string;
+    /** Line number */
+    line: number;
+    /** Kind of symbol */
+    kind: 'function' | 'class' | 'variable' | 'type' | 'interface' | 'enum' | 'export';
+    /** Is exported */
+    exported: boolean;
+    /** Confidence level */
+    confidence: 'high' | 'medium' | 'low';
+    /** Reason for flagging */
+    reason: string;
+}
+/**
+ * Output from findDeadCode tool
+ */
+export interface FindDeadCodeResult {
+    /** Analyzed path */
+    path: string;
+    /** Potentially dead code items */
+    deadCode: DeadCodeItem[];
+    /** Statistics */
+    stats: {
+        filesAnalyzed: number;
+        totalExports: number;
+        unusedExports: number;
+        totalFunctions: number;
+        unusedFunctions: number;
+        totalVariables: number;
+        unusedVariables: number;
+    };
+}
+/**
+ * Input for findDuplicates tool
+ */
+export interface FindDuplicatesInput {
+    /** Directory to analyze */
+    path: string;
+    /** Minimum lines for a duplicate (default: 6) */
+    minLines?: number;
+    /** Minimum tokens for a duplicate (default: 50) */
+    minTokens?: number;
+    /** Ignore identical files (default: true) */
+    ignoreIdenticalFiles?: boolean;
+    /** Maximum files to analyze (default: 100) */
+    maxFiles?: number;
+}
+/**
+ * A code location
+ */
+export interface CodeLocation {
+    /** File path */
+    path: string;
+    /** Start line */
+    startLine: number;
+    /** End line */
+    endLine: number;
+}
+/**
+ * A group of duplicate code blocks
+ */
+export interface DuplicateGroup {
+    /** Unique identifier for this group */
+    id: string;
+    /** Number of lines in duplicate */
+    lines: number;
+    /** Number of tokens in duplicate */
+    tokens: number;
+    /** Locations of duplicates */
+    locations: CodeLocation[];
+    /** Sample code (first few lines) */
+    sample: string;
+}
+/**
+ * Output from findDuplicates tool
+ */
+export interface FindDuplicatesResult {
+    /** Analyzed path */
+    path: string;
+    /** Duplicate groups */
+    duplicates: DuplicateGroup[];
+    /** Statistics */
+    stats: {
+        filesAnalyzed: number;
+        duplicateGroups: number;
+        totalDuplicateLines: number;
+        percentageDuplicate: number;
+    };
+}
+/**
+ * A pattern to search for
+ */
+export interface CodePattern {
+    /** Pattern name */
+    name: string;
+    /** Description */
+    description: string;
+    /** Pattern type */
+    type: 'anti-pattern' | 'pattern' | 'smell';
+    /** AST pattern or regex */
+    matcher: string;
+    /** Severity */
+    severity: 'error' | 'warning' | 'info';
+}
+/**
+ * Input for findPatterns tool
+ */
+export interface FindPatternsInput {
+    /** Directory to analyze */
+    path: string;
+    /** Patterns to search for (uses built-in if not specified) */
+    patterns?: CodePattern[];
+    /** Pattern categories to include */
+    categories?: Array<'security' | 'performance' | 'maintainability' | 'all'>;
+    /** Maximum files to analyze (default: 100) */
+    maxFiles?: number;
+}
+/**
+ * A pattern match
+ */
+export interface PatternMatch {
+    /** Pattern that matched */
+    pattern: string;
+    /** Pattern description */
+    description: string;
+    /** Severity */
+    severity: 'error' | 'warning' | 'info';
+    /** File path */
+    path: string;
+    /** Line number */
+    line: number;
+    /** Matched code snippet */
+    snippet: string;
+    /** Suggested fix (if available) */
+    suggestion?: string;
+}
+/**
+ * Output from findPatterns tool
+ */
+export interface FindPatternsResult {
+    /** Analyzed path */
+    path: string;
+    /** Pattern matches */
+    matches: PatternMatch[];
+    /** Statistics */
+    stats: {
+        filesAnalyzed: number;
+        totalMatches: number;
+        byPattern: Record<string, number>;
+        bySeverity: {
+            error: number;
+            warning: number;
+            info: number;
+        };
+    };
+}
+/**
+ * Input for getSignature tool
+ */
+export interface GetSignatureInput {
+    /** File containing the symbol */
+    path: string;
+    /** Symbol name to get signature for */
+    name: string;
+    /** Line number for disambiguation (optional) */
+    line?: number;
+    /** Include full documentation (default: true) */
+    includeDoc?: boolean;
+    /** Expand type aliases (default: false) */
+    expandTypes?: boolean;
+}
+/**
+ * Detailed parameter information
+ */
+export interface ParameterDetail {
+    /** Parameter name */
+    name: string;
+    /** Type string */
+    type: string;
+    /** Expanded type (if expandTypes=true) */
+    expandedType?: string;
+    /** Is optional */
+    optional: boolean;
+    /** Default value (as string) */
+    defaultValue?: string;
+    /** JSDoc description */
+    description?: string;
+    /** Is rest parameter */
+    rest?: boolean;
+}
+/**
+ * Detailed type information
+ */
+export interface TypeDetail {
+    /** Type string */
+    type: string;
+    /** Expanded type */
+    expandedType?: string;
+    /** Is promise */
+    isPromise: boolean;
+    /** Is nullable */
+    nullable: boolean;
+}
+/**
+ * Generic parameter information
+ */
+export interface GenericDetail {
+    /** Generic name (T, K, etc.) */
+    name: string;
+    /** Constraint (extends X) */
+    constraint?: string;
+    /** Default type */
+    default?: string;
+}
+/**
+ * Documentation extracted from JSDoc/TSDoc
+ */
+export interface Documentation {
+    /** Summary (first paragraph) */
+    summary: string;
+    /** Full description */
+    description?: string;
+    /** @param tags */
+    params?: Record<string, string>;
+    /** @returns tag */
+    returns?: string;
+    /** @throws tags */
+    throws?: string[];
+    /** @example tags */
+    examples?: string[];
+    /** @see tags */
+    see?: string[];
+    /** Deprecation message from JSDoc tag */
+    deprecatedMessage?: string;
+    /** @since version */
+    since?: string;
+}
+/**
+ * Member signature (for classes/interfaces)
+ */
+export interface MemberSignature {
+    /** Member name */
+    name: string;
+    /** Member kind */
+    kind: 'property' | 'method' | 'getter' | 'setter';
+    /** Signature string */
+    signature: string;
+    /** Is optional */
+    optional: boolean;
+    /** Is readonly */
+    readonly: boolean;
+    /** Visibility */
+    visibility?: 'public' | 'private' | 'protected';
+    /** Is static */
+    static?: boolean;
+}
+/**
+ * Symbol kind for signature
+ */
+export type SignatureSymbolKind = 'function' | 'method' | 'class' | 'interface' | 'type' | 'enum' | 'variable';
+/**
+ * Output from getSignature tool
+ */
+export interface GetSignatureResult {
+    /** Symbol name */
+    name: string;
+    /** Symbol kind */
+    kind: SignatureSymbolKind;
+    /** File path */
+    path: string;
+    /** Line number */
+    line: number;
+    /** Full signature string */
+    signature: string;
+    /** Formatted signature (multi-line for complex types) */
+    formattedSignature: string;
+    /** Is exported */
+    exported: boolean;
+    /** For functions/methods: parameters */
+    parameters?: ParameterDetail[];
+    /** Return type */
+    returnType?: TypeDetail;
+    /** Generic parameters */
+    generics?: GenericDetail[];
+    /** Full documentation */
+    documentation?: Documentation;
+    /** For classes: constructor signature */
+    constructorSignature?: string;
+    /** For interfaces/classes: members */
+    members?: MemberSignature[];
+}
+/**
+ * Symbol kind for documentation extraction
+ */
+export type DocumentationSymbolKind = 'function' | 'class' | 'interface' | 'type' | 'enum' | 'variable' | 'method' | 'property';
+/**
+ * Input for getDocumentation tool
+ */
+export interface GetDocumentationInput {
+    /** File or directory to analyze */
+    path: string;
+    /** Recursive analysis for directories (default: false) */
+    recursive?: boolean;
+    /** Filter by symbol kinds */
+    kinds?: DocumentationSymbolKind[];
+    /** Only include exported symbols (default: false) */
+    exportedOnly?: boolean;
+    /** Only include symbols with documentation (default: true) */
+    documentedOnly?: boolean;
+    /** Maximum files to analyze (default: 50) */
+    maxFiles?: number;
+    /** Include private class members (default: false) */
+    includePrivate?: boolean;
+}
+/**
+ * Documented symbol information
+ */
+export interface DocumentedSymbol {
+    /** Symbol name */
+    name: string;
+    /** Symbol kind */
+    kind: DocumentationSymbolKind;
+    /** Line number */
+    line: number;
+    /** Is exported */
+    exported: boolean;
+    /** Signature string */
+    signature: string;
+    /** Documentation content */
+    documentation: Documentation;
+    /** Containing class/interface (for methods/properties) */
+    container?: string;
+}
+/**
+ * File documentation information
+ */
+export interface FileDocumentation {
+    /** File path */
+    path: string;
+    /** File-level documentation (module doc comment) */
+    fileDoc?: Documentation;
+    /** Documented symbols in this file */
+    symbols: DocumentedSymbol[];
+    /** Statistics */
+    stats: {
+        totalSymbols: number;
+        documentedSymbols: number;
+        undocumentedSymbols: number;
+        coveragePercent: number;
+    };
+}
+/**
+ * Output from getDocumentation tool
+ */
+export interface GetDocumentationResult {
+    /** Analyzed path */
+    path: string;
+    /** Documentation by file */
+    files: FileDocumentation[];
+    /** Aggregated statistics */
+    summary: {
+        totalFiles: number;
+        totalSymbols: number;
+        documentedSymbols: number;
+        undocumentedSymbols: number;
+        coveragePercent: number;
+    };
+    /** Undocumented exported symbols (for coverage reports) */
+    undocumentedExports?: Array<{
+        name: string;
+        kind: DocumentationSymbolKind;
+        path: string;
+        line: number;
+    }>;
+}