@skillsmith/core 0.2.0 → 0.4.1

package/dist/src/analysis/incremental.js

@@ -0,0 +1,247 @@
+/**
+ * SMI-1309: Incremental Parsing Support
+ *
+ * Edit tracking utilities for multi-language AST analysis.
+ * Enables efficient incremental parsing by detecting minimal
+ * edit regions between old and new content.
+ *
+ * @see docs/architecture/multi-language-analysis.md
+ * @module analysis/incremental
+ */
+/**
+ * Calculate file edit from content diff
+ *
+ * Converts a simple diff into the format required by
+ * tree-sitter's incremental parsing API.
+ *
+ * @param oldContent - Original file content
+ * @param newContent - Updated file content
+ * @param changeStart - Start index of the change
+ * @param changeEnd - End index in old content
+ * @param newText - Replacement text
+ * @returns FileEdit structure for tree-sitter
+ *
+ * @example
+ * ```typescript
+ * const edit = calculateEdit(
+ *   'hello world',
+ *   'hello there world',
+ *   6, // after 'hello '
+ *   6, // no text removed
+ *   'there ' // inserted text
+ * )
+ * tree.edit(edit)
+ * ```
+ */
+export function calculateEdit(oldContent, newContent, changeStart, changeEnd, newText) {
+    const startPosition = indexToPosition(oldContent, changeStart);
+    const oldEndPosition = indexToPosition(oldContent, changeEnd);
+    const newEndPosition = indexToPosition(newContent, changeStart + newText.length);
+    return {
+        startIndex: changeStart,
+        oldEndIndex: changeEnd,
+        newEndIndex: changeStart + newText.length,
+        startPosition,
+        oldEndPosition,
+        newEndPosition,
+    };
+}
+/**
+ * Convert byte index to row/column position
+ *
+ * Scans through content counting newlines to determine
+ * the row and column for a given byte offset.
+ *
+ * @param content - File content to scan
+ * @param index - Byte offset to convert
+ * @returns Position with row and column (both zero-based)
+ *
+ * @example
+ * ```typescript
+ * const pos = indexToPosition('hello\nworld', 8)
+ * // pos = { row: 1, column: 2 } (the 'r' in 'world')
+ * ```
+ */
+export function indexToPosition(content, index) {
+    let row = 0;
+    let column = 0;
+    const limit = Math.min(index, content.length);
+    for (let i = 0; i < limit; i++) {
+        if (content[i] === '\n') {
+            row++;
+            column = 0;
+        }
+        else {
+            column++;
+        }
+    }
+    return { row, column };
+}
+/**
+ * Convert row/column position to byte index
+ *
+ * Scans through content to find the byte offset for
+ * a given row and column position.
+ *
+ * @param content - File content to scan
+ * @param position - Position to convert
+ * @returns Byte offset, or content length if position is past end
+ *
+ * @example
+ * ```typescript
+ * const index = positionToIndex('hello\nworld', { row: 1, column: 2 })
+ * // index = 8 (the 'r' in 'world')
+ * ```
+ */
+export function positionToIndex(content, position) {
+    let currentRow = 0;
+    let currentColumn = 0;
+    for (let i = 0; i < content.length; i++) {
+        if (currentRow === position.row && currentColumn === position.column) {
+            return i;
+        }
+        if (content[i] === '\n') {
+            currentRow++;
+            currentColumn = 0;
+        }
+        else {
+            currentColumn++;
+        }
+    }
+    return content.length;
+}
+/**
+ * Find the minimal edit between two strings
+ *
+ * Uses a simple prefix/suffix matching algorithm to find
+ * the smallest region that changed between old and new content.
+ * Returns null if contents are identical.
+ *
+ * @param oldContent - Original string
+ * @param newContent - Modified string
+ * @returns EditDiff describing the change, or null if identical
+ *
+ * @example
+ * ```typescript
+ * const diff = findMinimalEdit('hello world', 'hello there world')
+ * // diff = { changeStart: 6, changeEnd: 6, newText: 'there ' }
+ *
+ * const same = findMinimalEdit('hello', 'hello')
+ * // same = null
+ * ```
+ */
+export function findMinimalEdit(oldContent, newContent) {
+    if (oldContent === newContent) {
+        return null;
+    }
+    // Find common prefix length
+    let prefixLength = 0;
+    const minLength = Math.min(oldContent.length, newContent.length);
+    while (prefixLength < minLength && oldContent[prefixLength] === newContent[prefixLength]) {
+        prefixLength++;
+    }
+    // Find common suffix length (after prefix)
+    let oldSuffixStart = oldContent.length;
+    let newSuffixStart = newContent.length;
+    while (oldSuffixStart > prefixLength &&
+        newSuffixStart > prefixLength &&
+        oldContent[oldSuffixStart - 1] === newContent[newSuffixStart - 1]) {
+        oldSuffixStart--;
+        newSuffixStart--;
+    }
+    return {
+        changeStart: prefixLength,
+        changeEnd: oldSuffixStart,
+        newText: newContent.slice(prefixLength, newSuffixStart),
+    };
+}
+/**
+ * Merge multiple edits into a single encompassing edit
+ *
+ * Useful when multiple small edits occur and need to be
+ * applied as a single incremental update.
+ *
+ * Note: This is a simplistic merge that finds the bounding
+ * region. It may over-invalidate if edits are far apart.
+ *
+ * @param edits - Array of edits to merge
+ * @returns Single merged edit, or null if array is empty
+ *
+ * @example
+ * ```typescript
+ * const merged = batchEdits([
+ *   { changeStart: 0, changeEnd: 5, newText: 'HELLO' },
+ *   { changeStart: 10, changeEnd: 15, newText: 'WORLD' }
+ * ])
+ * // merged encompasses both edit regions
+ * ```
+ */
+export function batchEdits(edits) {
+    if (edits.length === 0) {
+        return null;
+    }
+    if (edits.length === 1) {
+        return edits[0];
+    }
+    // Sort by start position
+    const sorted = [...edits].sort((a, b) => a.changeStart - b.changeStart);
+    // Find the bounding box of all edits
+    let minStart = sorted[0].changeStart;
+    let maxEnd = sorted[0].changeEnd;
+    let combinedNewText = '';
+    let lastEnd = sorted[0].changeStart;
+    for (const edit of sorted) {
+        // Check for gaps between edits
+        if (edit.changeStart > lastEnd) {
+            // Gap exists - this is a complex case
+            // For simplicity, we merge anyway and note it may over-invalidate
+        }
+        minStart = Math.min(minStart, edit.changeStart);
+        maxEnd = Math.max(maxEnd, edit.changeEnd);
+        combinedNewText += edit.newText;
+        lastEnd = edit.changeEnd;
+    }
+    return {
+        changeStart: minStart,
+        changeEnd: maxEnd,
+        newText: combinedNewText,
+    };
+}
+/**
+ * Check if an edit is a simple insertion (no deletion)
+ *
+ * @param edit - Edit to check
+ * @returns True if edit only inserts text
+ */
+export function isInsertion(edit) {
+    return edit.changeStart === edit.changeEnd && edit.newText.length > 0;
+}
+/**
+ * Check if an edit is a simple deletion (no insertion)
+ *
+ * @param edit - Edit to check
+ * @returns True if edit only deletes text
+ */
+export function isDeletion(edit) {
+    return edit.changeStart < edit.changeEnd && edit.newText.length === 0;
+}
+/**
+ * Check if an edit is a replacement (both deletion and insertion)
+ *
+ * @param edit - Edit to check
+ * @returns True if edit replaces text
+ */
+export function isReplacement(edit) {
+    return edit.changeStart < edit.changeEnd && edit.newText.length > 0;
+}
+/**
+ * Calculate the size delta of an edit
+ *
+ * @param edit - Edit to analyze
+ * @returns Positive for growth, negative for shrinkage, zero for same size
+ */
+export function editSizeDelta(edit) {
+    const deletedLength = edit.changeEnd - edit.changeStart;
+    return edit.newText.length - deletedLength;
+}
+//# sourceMappingURL=incremental.js.map

package/dist/src/analysis/incremental.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"incremental.js","sourceRoot":"","sources":["../../../src/analysis/incremental.ts"],"names":[],"mappings":"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"}

package/dist/src/analysis/index.d.ts

@@ -1,15 +1,37 @@
 /**
  * SMI-600: Codebase Analysis Module
  * SMI-1189: Updated to export from split modules
+ * SMI-1303: Extended with multi-language support
+ * SMI-1337: Added metrics and telemetry
  *
- * Provides tools for analyzing TypeScript/JavaScript codebases
+ * Provides tools for analyzing multi-language codebases
  * to extract context for skill recommendations.
  *
  * @see ADR-010: Codebase Analysis Scope
+ * @see docs/architecture/multi-language-analysis.md
  */
 export { CodebaseAnalyzer } from './CodebaseAnalyzer.js';
 export { default } from './CodebaseAnalyzer.js';
-export { SUPPORTED_EXTENSIONS, DEFAULT_EXCLUDE_DIRS, type ImportInfo, type ExportInfo, type FunctionInfo, type FrameworkInfo, type DependencyInfo, type CodebaseContext, type AnalyzeOptions, type ParseResult, } from './types.js';
+export { SUPPORTED_EXTENSIONS, DEFAULT_EXCLUDE_DIRS, LANGUAGE_EXTENSIONS, type SupportedLanguage, type ImportInfo, type ExportInfo, type ExportKind, type FunctionInfo, type FrameworkInfo, type FrameworkRule, type DependencyInfo, type CodebaseContext, type AnalyzeOptions, type ParseResult, type CacheStats, } from './types.js';
 export { parseFile, extractImport, extractExport, extractFunction } from './parsers.js';
-export { detectFrameworks, hasFramework, getPrimaryFramework, FRAMEWORK_RULES, type FrameworkRule, } from './framework-detector.js';
+export { detectFrameworks, hasFramework, getPrimaryFramework, FRAMEWORK_RULES, } from './framework-detector.js';
+export { LanguageRouter, type LanguageRouterOptions } from './router.js';
+export { AdapterFactory } from './adapters/factory.js';
+export { LanguageDetector, detectLanguage, type LanguageDetectionResult, } from './language-detector.js';
+export { ParseCache, type ParseCacheOptions } from './cache.js';
+export { ResultAggregator, type AggregatorInput, type AggregatorMetadata, type AggregatorOptions, } from './aggregator.js';
+export { AnalysisMetrics, getAnalysisMetrics, initializeAnalysisMetrics, timeParseAsync, timeParseSync, type AnalysisMetricsConfig, type AnalysisMetricsSnapshot, } from './metrics.js';
+export { TreeSitterManager, type TreeSitterManagerOptions, type TreeSitterParser, type TreeSitterTree, type TreeSitterNode, type TreeSitterLanguage, } from './tree-sitter/manager.js';
+export { LanguageAdapter, type LanguageInfo } from './adapters/base.js';
+export { TypeScriptAdapter } from './adapters/typescript.js';
+export { PythonAdapter } from './adapters/python.js';
+export { GoAdapter, parseGoMod, type GoModInfo, type GoExportInfo, type GoFunctionInfo, } from './adapters/go.js';
+export { RustAdapter, parseCargoToml, type RustExportInfo, type RustFunctionInfo, type CargoDependency, } from './adapters/rust.js';
+export { JavaAdapter, parsePomXml, parseBuildGradle, type JavaExportInfo, type JavaFunctionInfo, type MavenDependency, } from './adapters/java.js';
+export { ParserWorkerPool, type ParseTask, type WorkerResult, type WorkerPoolOptions, } from './worker-pool.js';
+export { MemoryMonitor, type MemoryStats, type CleanupResult, type MemoryMonitorOptions, } from './memory-monitor.js';
+export { streamFiles, batchReadFiles, readFilesAsMap, filterByExtension, getFileExtension, estimateMemoryUsage, type FileContent, type StreamOptions, type BatchReadOptions, } from './file-streamer.js';
+export { calculateEdit, indexToPosition, positionToIndex, findMinimalEdit, batchEdits, isInsertion, isDeletion, isReplacement, editSizeDelta, type Point, type FileEdit, type EditDiff, } from './incremental.js';
+export { TreeCache, type CachedTree, type TreeCacheStats, type TreeCacheOptions, } from './tree-cache.js';
+export { IncrementalParser, type IncrementalParseResult, type IncrementalParserOptions, type IncrementalParserStats, } from './incremental-parser.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/analysis/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/analysis/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAA;AAG/C,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,WAAW,GACjB,MAAM,YAAY,CAAA;AAGnB,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAGvF,OAAO,EACL,gBAAgB,EAChB,YAAY,EACZ,mBAAmB,EACnB,eAAe,EACf,KAAK,aAAa,GACnB,MAAM,yBAAyB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/analysis/index.ts"],"names":[],"mappings":"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"}

package/dist/src/analysis/index.js

@@ -1,19 +1,61 @@
 /**
  * SMI-600: Codebase Analysis Module
  * SMI-1189: Updated to export from split modules
+ * SMI-1303: Extended with multi-language support
+ * SMI-1337: Added metrics and telemetry
  *
- * Provides tools for analyzing TypeScript/JavaScript codebases
+ * Provides tools for analyzing multi-language codebases
  * to extract context for skill recommendations.
  *
  * @see ADR-010: Codebase Analysis Scope
+ * @see docs/architecture/multi-language-analysis.md
  */
 // Main analyzer class
 export { CodebaseAnalyzer } from './CodebaseAnalyzer.js';
 export { default } from './CodebaseAnalyzer.js';
-// Types and constants
-export { SUPPORTED_EXTENSIONS, DEFAULT_EXCLUDE_DIRS, } from './types.js';
+// Types and constants (extended for multi-language support)
+export { 
+// Constants
+SUPPORTED_EXTENSIONS, DEFAULT_EXCLUDE_DIRS, LANGUAGE_EXTENSIONS, } from './types.js';
 // Parser functions
 export { parseFile, extractImport, extractExport, extractFunction } from './parsers.js';
 // Framework detection
 export { detectFrameworks, hasFramework, getPrimaryFramework, FRAMEWORK_RULES, } from './framework-detector.js';
+// SMI-1303: Multi-language infrastructure
+// Language router for dispatching to appropriate adapters
+export { LanguageRouter } from './router.js';
+// SMI-1339: Adapter Factory Pattern
+export { AdapterFactory } from './adapters/factory.js';
+// SMI-1340: Language Detection for extensionless files
+export { LanguageDetector, detectLanguage, } from './language-detector.js';
+// Parse result caching
+export { ParseCache } from './cache.js';
+// Result aggregation
+export { ResultAggregator, } from './aggregator.js';
+// SMI-1337: Analysis metrics and telemetry
+export { AnalysisMetrics, getAnalysisMetrics, initializeAnalysisMetrics, timeParseAsync, timeParseSync, } from './metrics.js';
+// Tree-sitter parser management
+export { TreeSitterManager, } from './tree-sitter/manager.js';
+// Language adapters
+export { LanguageAdapter } from './adapters/base.js';
+// Re-export specific adapters
+export { TypeScriptAdapter } from './adapters/typescript.js';
+export { PythonAdapter } from './adapters/python.js';
+export { GoAdapter, parseGoMod, } from './adapters/go.js';
+export { RustAdapter, parseCargoToml, } from './adapters/rust.js';
+export { JavaAdapter, parsePomXml, parseBuildGradle, } from './adapters/java.js';
+// SMI-1308: Performance optimization modules
+// Worker thread pool for parallel file parsing
+export { ParserWorkerPool, } from './worker-pool.js';
+// Memory usage monitoring and cleanup
+export { MemoryMonitor, } from './memory-monitor.js';
+// Memory-efficient file streaming
+export { streamFiles, batchReadFiles, readFilesAsMap, filterByExtension, getFileExtension, estimateMemoryUsage, } from './file-streamer.js';
+// SMI-1309: Incremental Parsing & Tree Caching
+// Edit tracking utilities
+export { calculateEdit, indexToPosition, positionToIndex, findMinimalEdit, batchEdits, isInsertion, isDeletion, isReplacement, editSizeDelta, } from './incremental.js';
+// Tree caching for incremental parsing
+export { TreeCache, } from './tree-cache.js';
+// Incremental parser coordinator
+export { IncrementalParser, } from './incremental-parser.js';
 //# sourceMappingURL=index.js.map

package/dist/src/analysis/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/analysis/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,sBAAsB;AACtB,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAA;AAE/C,sBAAsB;AACtB,OAAO,EACL,oBAAoB,EACpB,oBAAoB,GASrB,MAAM,YAAY,CAAA;AAEnB,mBAAmB;AACnB,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAEvF,sBAAsB;AACtB,OAAO,EACL,gBAAgB,EAChB,YAAY,EACZ,mBAAmB,EACnB,eAAe,GAEhB,MAAM,yBAAyB,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/analysis/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,sBAAsB;AACtB,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAA;AAE/C,4DAA4D;AAC5D,OAAO;AACL,YAAY;AACZ,oBAAoB,EACpB,oBAAoB,EACpB,mBAAmB,GAcpB,MAAM,YAAY,CAAA;AAEnB,mBAAmB;AACnB,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAEvF,sBAAsB;AACtB,OAAO,EACL,gBAAgB,EAChB,YAAY,EACZ,mBAAmB,EACnB,eAAe,GAChB,MAAM,yBAAyB,CAAA;AAEhC,0CAA0C;AAE1C,0DAA0D;AAC1D,OAAO,EAAE,cAAc,EAA8B,MAAM,aAAa,CAAA;AAExE,oCAAoC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAEtD,uDAAuD;AACvD,OAAO,EACL,gBAAgB,EAChB,cAAc,GAEf,MAAM,wBAAwB,CAAA;AAE/B,uBAAuB;AACvB,OAAO,EAAE,UAAU,EAA0B,MAAM,YAAY,CAAA;AAE/D,qBAAqB;AACrB,OAAO,EACL,gBAAgB,GAIjB,MAAM,iBAAiB,CAAA;AAExB,2CAA2C;AAC3C,OAAO,EACL,eAAe,EACf,kBAAkB,EAClB,yBAAyB,EACzB,cAAc,EACd,aAAa,GAGd,MAAM,cAAc,CAAA;AAErB,gCAAgC;AAChC,OAAO,EACL,iBAAiB,GAMlB,MAAM,0BAA0B,CAAA;AAEjC,oBAAoB;AACpB,OAAO,EAAE,eAAe,EAAqB,MAAM,oBAAoB,CAAA;AAEvE,8BAA8B;AAC9B,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAA;AAC5D,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACpD,OAAO,EACL,SAAS,EACT,UAAU,GAIX,MAAM,kBAAkB,CAAA;AACzB,OAAO,EACL,WAAW,EACX,cAAc,GAIf,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EACL,WAAW,EACX,WAAW,EACX,gBAAgB,GAIjB,MAAM,oBAAoB,CAAA;AAE3B,6CAA6C;AAE7C,+CAA+C;AAC/C,OAAO,EACL,gBAAgB,GAIjB,MAAM,kBAAkB,CAAA;AAEzB,sCAAsC;AACtC,OAAO,EACL,aAAa,GAId,MAAM,qBAAqB,CAAA;AAE5B,kCAAkC;AAClC,OAAO,EACL,WAAW,EACX,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,gBAAgB,EAChB,mBAAmB,GAIpB,MAAM,oBAAoB,CAAA;AAE3B,+CAA+C;AAE/C,0BAA0B;AAC1B,OAAO,EACL,aAAa,EACb,eAAe,EACf,eAAe,EACf,eAAe,EACf,UAAU,EACV,WAAW,EACX,UAAU,EACV,aAAa,EACb,aAAa,GAId,MAAM,kBAAkB,CAAA;AAEzB,uCAAuC;AACvC,OAAO,EACL,SAAS,GAIV,MAAM,iBAAiB,CAAA;AAExB,iCAAiC;AACjC,OAAO,EACL,iBAAiB,GAIlB,MAAM,yBAAyB,CAAA"}

package/dist/src/analysis/language-detector.d.ts

@@ -0,0 +1,76 @@
+/**
+ * SMI-1340: Language Detection Heuristics
+ *
+ * Detects programming language of files without extensions using:
+ * - Shebang analysis (#!/usr/bin/python, #!/bin/bash, etc.)
+ * - Content patterns (import statements, syntax markers)
+ * - Magic bytes detection
+ * - Statistical analysis of keywords
+ *
+ * @see docs/architecture/multi-language-analysis.md
+ * @module analysis/language-detector
+ */
+import type { LanguageDetectionResult, LanguageDetectorOptions } from './language-detector.types.js';
+export type { LanguageDetectionResult } from './language-detector.types.js';
+/**
+ * Detects programming language from file content
+ *
+ * Uses multiple heuristics in order of reliability:
+ * 1. Shebang analysis (highest confidence)
+ * 2. Content patterns (high confidence)
+ * 3. Statistical keyword analysis (lower confidence)
+ *
+ * @example
+ * ```typescript
+ * const detector = new LanguageDetector()
+ *
+ * // Detect from shebang
+ * const result1 = detector.detect('#!/usr/bin/env python3\nprint("hello")')
+ * // { language: 'python', confidence: 1.0, method: 'shebang', evidence: ['shebang: #!/usr/bin/env python3'] }
+ *
+ * // Detect from patterns
+ * const result2 = detector.detect('fn main() {\n    println!("Hello");\n}')
+ * // { language: 'rust', confidence: 0.85, method: 'pattern', evidence: ['function definition'] }
+ * ```
+ */
+export declare class LanguageDetector {
+    /** Minimum confidence threshold for detection */
+    private minConfidence;
+    constructor(options?: LanguageDetectorOptions);
+    /**
+     * Detect language from file content
+     *
+     * @param content - File content to analyze
+     * @returns Detection result with language, confidence, and evidence
+     */
+    detect(content: string): LanguageDetectionResult;
+    /**
+     * Detect language from shebang line
+     */
+    detectByShebang(content: string): LanguageDetectionResult;
+    /**
+     * Detect language from content patterns
+     */
+    detectByPatterns(content: string): LanguageDetectionResult;
+    /**
+     * Detect language by statistical keyword analysis
+     */
+    detectByStatistics(content: string): LanguageDetectionResult;
+    /**
+     * Get confidence threshold
+     */
+    getMinConfidence(): number;
+    /**
+     * Set confidence threshold
+     */
+    setMinConfidence(threshold: number): void;
+}
+/**
+ * Convenience function to detect language
+ *
+ * @param content - File content to analyze
+ * @param options - Detection options
+ * @returns Detection result
+ */
+export declare function detectLanguage(content: string, options?: LanguageDetectorOptions): LanguageDetectionResult;
+//# sourceMappingURL=language-detector.d.ts.map

package/dist/src/analysis/language-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"language-detector.d.ts","sourceRoot":"","sources":["../../../src/analysis/language-detector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH,OAAO,KAAK,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAA;AAUpG,YAAY,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAA;AAE3E;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,gBAAgB;IAC3B,iDAAiD;IACjD,OAAO,CAAC,aAAa,CAAQ;gBAEjB,OAAO,GAAE,uBAA4B;IAIjD;;;;;OAKG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,uBAAuB;IA4BhD;;OAEG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,uBAAuB;IAqBzD;;OAEG;IACH,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,uBAAuB;IA6C1D;;OAEG;IACH,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,uBAAuB;IA0D5D;;OAEG;IACH,gBAAgB,IAAI,MAAM;IAI1B;;OAEG;IACH,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;CAG1C;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,uBAAuB,GAChC,uBAAuB,CAGzB"}

package/dist/src/analysis/language-detector.js

@@ -0,0 +1,205 @@
+/**
+ * SMI-1340: Language Detection Heuristics
+ *
+ * Detects programming language of files without extensions using:
+ * - Shebang analysis (#!/usr/bin/python, #!/bin/bash, etc.)
+ * - Content patterns (import statements, syntax markers)
+ * - Magic bytes detection
+ * - Statistical analysis of keywords
+ *
+ * @see docs/architecture/multi-language-analysis.md
+ * @module analysis/language-detector
+ */
+// Import patterns
+import { SHEBANG_PATTERNS, CONTENT_PATTERNS, LANGUAGE_KEYWORDS, } from './language-detector.patterns.js';
+/**
+ * Detects programming language from file content
+ *
+ * Uses multiple heuristics in order of reliability:
+ * 1. Shebang analysis (highest confidence)
+ * 2. Content patterns (high confidence)
+ * 3. Statistical keyword analysis (lower confidence)
+ *
+ * @example
+ * ```typescript
+ * const detector = new LanguageDetector()
+ *
+ * // Detect from shebang
+ * const result1 = detector.detect('#!/usr/bin/env python3\nprint("hello")')
+ * // { language: 'python', confidence: 1.0, method: 'shebang', evidence: ['shebang: #!/usr/bin/env python3'] }
+ *
+ * // Detect from patterns
+ * const result2 = detector.detect('fn main() {\n    println!("Hello");\n}')
+ * // { language: 'rust', confidence: 0.85, method: 'pattern', evidence: ['function definition'] }
+ * ```
+ */
+export class LanguageDetector {
+    /** Minimum confidence threshold for detection */
+    minConfidence;
+    constructor(options = {}) {
+        this.minConfidence = options.minConfidence ?? 0.3;
+    }
+    /**
+     * Detect language from file content
+     *
+     * @param content - File content to analyze
+     * @returns Detection result with language, confidence, and evidence
+     */
+    detect(content) {
+        // Try shebang first (highest confidence)
+        const shebangResult = this.detectByShebang(content);
+        if (shebangResult.language && shebangResult.confidence >= this.minConfidence) {
+            return shebangResult;
+        }
+        // Try content patterns
+        const patternResult = this.detectByPatterns(content);
+        if (patternResult.language && patternResult.confidence >= this.minConfidence) {
+            return patternResult;
+        }
+        // Fall back to statistical analysis
+        const statisticalResult = this.detectByStatistics(content);
+        if (statisticalResult.language && statisticalResult.confidence >= this.minConfidence) {
+            return statisticalResult;
+        }
+        // No confident detection
+        return {
+            language: null,
+            confidence: 0,
+            method: 'none',
+            evidence: [],
+        };
+    }
+    /**
+     * Detect language from shebang line
+     */
+    detectByShebang(content) {
+        const firstLine = content.split('\n')[0]?.trim() ?? '';
+        if (!firstLine.startsWith('#!')) {
+            return { language: null, confidence: 0, method: 'shebang', evidence: [] };
+        }
+        for (const { pattern, language } of SHEBANG_PATTERNS) {
+            if (pattern.test(firstLine)) {
+                return {
+                    language,
+                    confidence: 1.0,
+                    method: 'shebang',
+                    evidence: [`shebang: ${firstLine}`],
+                };
+            }
+        }
+        return { language: null, confidence: 0, method: 'shebang', evidence: [] };
+    }
+    /**
+     * Detect language from content patterns
+     */
+    detectByPatterns(content) {
+        const scores = new Map();
+        for (const { pattern, language, weight, description } of CONTENT_PATTERNS) {
+            if (pattern.test(content)) {
+                const current = scores.get(language) ?? { score: 0, evidence: [] };
+                current.score += weight;
+                current.evidence.push(description);
+                scores.set(language, current);
+            }
+        }
+        // Find best match
+        let bestLanguage = null;
+        let bestScore = 0;
+        let bestEvidence = [];
+        for (const [language, { score, evidence }] of scores) {
+            if (score > bestScore) {
+                bestScore = score;
+                bestLanguage = language;
+                bestEvidence = evidence;
+            }
+        }
+        // Normalize confidence to 0-1 range (cap at 1.0)
+        const confidence = Math.min(bestScore / 3, 1.0);
+        // Upgrade JavaScript to TypeScript if TypeScript-specific patterns found
+        if (bestLanguage === 'javascript') {
+            const tsScore = scores.get('typescript')?.score ?? 0;
+            if (tsScore > 0) {
+                bestLanguage = 'typescript';
+                bestEvidence = [...bestEvidence, ...(scores.get('typescript')?.evidence ?? [])];
+            }
+        }
+        return {
+            language: bestLanguage,
+            confidence,
+            method: 'pattern',
+            evidence: bestEvidence.slice(0, 5), // Limit evidence
+        };
+    }
+    /**
+     * Detect language by statistical keyword analysis
+     */
+    detectByStatistics(content) {
+        const contentLower = content.toLowerCase();
+        const words = contentLower.split(/\W+/).filter((w) => w.length > 1);
+        const wordSet = new Set(words);
+        const wordCount = words.length;
+        if (wordCount === 0) {
+            return { language: null, confidence: 0, method: 'statistical', evidence: [] };
+        }
+        const scores = new Map();
+        for (const [language, keywords] of Object.entries(LANGUAGE_KEYWORDS)) {
+            const matchedKeywords = [];
+            for (const keyword of keywords) {
+                if (wordSet.has(keyword.toLowerCase())) {
+                    matchedKeywords.push(keyword);
+                }
+            }
+            if (matchedKeywords.length > 0) {
+                scores.set(language, {
+                    matches: matchedKeywords.length,
+                    keywords: matchedKeywords,
+                });
+            }
+        }
+        // Find best match with highest keyword density
+        let bestLanguage = null;
+        let bestScore = 0;
+        let bestKeywords = [];
+        for (const [language, { matches, keywords }] of scores) {
+            // Normalize by total keyword count for fairness
+            const normalizedScore = matches / LANGUAGE_KEYWORDS[language].length;
+            if (normalizedScore > bestScore) {
+                bestScore = normalizedScore;
+                bestLanguage = language;
+                bestKeywords = keywords;
+            }
+        }
+        // Lower confidence for statistical method
+        const confidence = Math.min(bestScore * 2, 0.7);
+        return {
+            language: bestLanguage,
+            confidence,
+            method: 'statistical',
+            evidence: bestKeywords.slice(0, 5).map((k) => `keyword: ${k}`),
+        };
+    }
+    /**
+     * Get confidence threshold
+     */
+    getMinConfidence() {
+        return this.minConfidence;
+    }
+    /**
+     * Set confidence threshold
+     */
+    setMinConfidence(threshold) {
+        this.minConfidence = Math.max(0, Math.min(1, threshold));
+    }
+}
+/**
+ * Convenience function to detect language
+ *
+ * @param content - File content to analyze
+ * @param options - Detection options
+ * @returns Detection result
+ */
+export function detectLanguage(content, options) {
+    const detector = new LanguageDetector(options);
+    return detector.detect(content);
+}
+//# sourceMappingURL=language-detector.js.map