@getmikk/core 2.0.14 → 2.0.16

package/src/graph/symbol-table.ts

@@ -0,0 +1,252 @@
+import type { ParsedFile, ParsedImport } from '../parser/types.js'
+import { normalizePathQuiet } from '../utils/path.js'
+
+export interface SymbolDefinition {
+    id: string
+    name: string
+    type: 'function' | 'class' | 'variable' | 'interface' | 'type' | 'enum'
+    file: string
+    isExported: boolean
+}
+
+export interface ImportAlias {
+    localName: string
+    exportedName: string
+    sourcePath: string
+}
+
+/**
+ * GlobalSymbolTable — The brain of Mikk's semantic reasoning.
+ * Indexes all exported symbols and provides resolution logic for calls.
+ * Supports: named imports, default imports, aliased imports, local symbols, and fuzzy matching.
+ * 
+ * Case sensitivity: Symbol names are case-sensitive for accurate resolution.
+ * Fallback to case-insensitive matching only when no exact match exists.
+ */
+export class GlobalSymbolTable {
+    private exportsByFile = new Map<string, Map<string, SymbolDefinition>>()
+    private symbolsByName = new Map<string, SymbolDefinition[]>()
+    private importAliases: ImportAlias[] = []
+    private reexportsByFile = new Map<string, Map<string, string>>()
+    private resolveCache = new Map<string, string | null>()
+    private resolveCacheOrder: string[] = []
+    private importsByFile = new Map<string, ParsedImport[]>()
+
+    private static readonly MAX_RESOLVE_CACHE_SIZE = 10000
+
+    private cacheResolve(key: string, value: string | null): void {
+        if (this.resolveCache.size >= GlobalSymbolTable.MAX_RESOLVE_CACHE_SIZE) {
+            const oldestKey = this.resolveCacheOrder.shift()
+            if (oldestKey) this.resolveCache.delete(oldestKey)
+        }
+        this.resolveCache.set(key, value)
+        this.resolveCacheOrder.push(key)
+    }
+
+    register(file: ParsedFile): void {
+        const fileExports = new Map<string, SymbolDefinition>()
+        const filePath = normalizePathQuiet(file.path)
+        const fileReexports = new Map<string, string>()
+
+        const registerSymbol = (name: string, type: SymbolDefinition['type'], id: string, isExported: boolean) => {
+            const def: SymbolDefinition = { id, name, type, file: filePath, isExported }
+            
+            if (isExported) {
+                fileExports.set(name, def)
+            }
+
+            const byName = this.symbolsByName.get(name) ?? []
+            byName.push(def)
+            this.symbolsByName.set(name, byName)
+        }
+
+        for (const fn of file.functions) registerSymbol(fn.name, 'function', fn.id, fn.isExported)
+        for (const cls of file.classes ?? []) {
+            registerSymbol(cls.name, 'class', cls.id, cls.isExported)
+            for (const m of cls.methods) {
+                const fullName = `${cls.name}.${m.name}`
+                registerSymbol(fullName, 'function', m.id, false)
+                const byName = this.symbolsByName.get(m.name) ?? []
+                byName.push({ id: m.id, name: m.name, type: 'function', file: filePath, isExported: false })
+                this.symbolsByName.set(m.name, byName)
+            }
+        }
+        for (const gen of file.generics ?? []) {
+            const validType = gen.type === 'interface' || gen.type === 'type' ? gen.type : 'type'
+            registerSymbol(gen.name, validType, gen.id, gen.isExported)
+        }
+        for (const v of file.variables ?? []) registerSymbol(v.name, 'variable', v.id, v.isExported)
+
+        for (const imp of file.imports) {
+            if (!imp.resolvedPath || imp.isDynamic) continue
+            const resolvedPath = normalizePathQuiet(imp.resolvedPath)
+            for (const spec of imp.specifiers ?? []) {
+                if (spec.imported && spec.local && spec.imported !== spec.local) {
+                    this.importAliases.push({
+                        localName: spec.local,
+                        exportedName: spec.imported,
+                        sourcePath: resolvedPath,
+                    })
+                }
+            }
+        }
+
+        for (const re of file.reexports ?? []) {
+            if (re.sourceResolved) {
+                fileReexports.set(re.name, normalizePathQuiet(re.sourceResolved))
+            }
+        }
+
+        this.exportsByFile.set(filePath, fileExports)
+        if (fileReexports.size > 0) {
+            this.reexportsByFile.set(filePath, fileReexports)
+        }
+        const fileImports = file.imports.filter(i => i.resolvedPath && !i.isDynamic)
+        this.importsByFile.set(filePath, fileImports)
+    }
+
+    resolve(callName: string, contextFile: string, imports: ParsedImport[]): string | null {
+        const hasDot = callName.includes('.')
+        const receiver = hasDot ? callName.split('.')[0] : null
+        const simpleName = hasDot ? callName.split('.').pop()! : callName
+        const normalizedContextFile = normalizePathQuiet(contextFile)
+
+        const cacheKey = `${normalizedContextFile}:${callName}`
+        if (this.resolveCache.has(cacheKey)) {
+            return this.resolveCache.get(cacheKey)!
+        }
+
+        const importsToUse = this.importsByFile.get(normalizedContextFile) ?? imports.filter(i => i.resolvedPath && !i.isDynamic)
+        let result: string | null = null
+
+        for (const imp of importsToUse) {
+            if (!imp.resolvedPath) continue
+            const resolvedPath = normalizePathQuiet(imp.resolvedPath)
+
+            if (imp.isDynamic) continue
+
+            if (hasDot && receiver) {
+                if (imp.isDefault && imp.names.some(n => n === receiver || n.toLowerCase() === receiver.toLowerCase())) {
+                    const target = this.getExport(resolvedPath, simpleName)
+                    if (target) { result = target.id; break }
+                    const methodTarget = this.getMethodByClassCaseInsensitive(resolvedPath, receiver, simpleName)
+                    if (methodTarget) { result = methodTarget; break }
+                }
+
+                const alias = this.importAliases.find(
+                    a => a.localName === receiver && a.sourcePath === resolvedPath
+                )
+                if (alias) {
+                    const target = this.getExport(resolvedPath, alias.exportedName)
+                    if (target) { result = target.id; break }
+                }
+
+                const receiverLower = receiver.toLowerCase()
+                const aliasLower = this.importAliases.find(
+                    a => a.localName.toLowerCase() === receiverLower && a.sourcePath === resolvedPath
+                )
+                if (aliasLower) {
+                    const target = this.getExport(resolvedPath, aliasLower.exportedName)
+                    if (target) { result = target.id; break }
+                }
+
+                const methodTarget = this.getMethodByClassCaseInsensitive(resolvedPath, receiver, simpleName)
+                if (methodTarget) { result = methodTarget; break }
+            }
+
+            const matchedLocal = imp.names.find(n => 
+                n === callName || 
+                n === simpleName ||
+                n.toLowerCase() === callName.toLowerCase() ||
+                n.toLowerCase() === simpleName.toLowerCase() ||
+                this.importAliases.some(a => a.localName === n && (a.exportedName === callName || a.exportedName === simpleName)) ||
+                this.importAliases.some(a => a.localName.toLowerCase() === n.toLowerCase() && (a.exportedName.toLowerCase() === callName.toLowerCase() || a.exportedName.toLowerCase() === simpleName.toLowerCase()))
+            )
+            if (matchedLocal) {
+                const alias = this.importAliases.find(a => a.localName === matchedLocal)
+                const exportedName = alias ? alias.exportedName : simpleName
+                const target = this.getExport(resolvedPath, exportedName)
+                if (target) { result = target.id; break }
+            }
+        }
+
+        if (!result) {
+            const localTarget = this.getExport(normalizedContextFile, callName)
+            if (localTarget) { result = localTarget.id }
+        }
+
+        if (!result) {
+            const globalMatches = this.symbolsByName.get(callName) ?? this.symbolsByName.get(simpleName)
+            if (globalMatches?.length === 1) {
+                result = globalMatches[0].id
+            }
+        }
+
+        if (!result) {
+            const lowerCallName = callName.toLowerCase()
+            const lowerSimpleName = simpleName.toLowerCase()
+            const lowerGlobalMatches = this.symbolsByName.get(lowerCallName) ?? this.symbolsByName.get(lowerSimpleName)
+            if (lowerGlobalMatches?.length === 1) {
+                result = lowerGlobalMatches[0].id
+            }
+        }
+
+        if (!result && hasDot && receiver) {
+            const methodTarget = this.getMethodGlobally(receiver, simpleName)
+            if (methodTarget) { result = methodTarget }
+        }
+
+        this.cacheResolve(cacheKey, result)
+        return result
+    }
+
+    private getExport(filePath: string, name: string, visited: Set<string> = new Set()): SymbolDefinition | undefined {
+        if (visited.has(filePath + ':' + name)) return undefined
+        visited.add(filePath + ':' + name)
+
+        const exports = this.exportsByFile.get(filePath)
+        if (exports) {
+            const def = exports.get(name) ?? exports.get(name.toLowerCase())
+            if (def) return def
+        }
+
+        const reexports = this.reexportsByFile.get(filePath)
+        if (reexports) {
+            const reexportPath = reexports.get(name) ?? reexports.get(name.toLowerCase())
+            if (reexportPath) {
+                return this.getExport(reexportPath, name, visited)
+            }
+        }
+
+        return undefined
+    }
+
+    private getMethodByClassCaseInsensitive(filePath: string, className: string, methodName: string): string | null {
+        const exports = this.exportsByFile.get(filePath)
+        if (!exports) return null
+        
+        for (const [name, def] of exports) {
+            if (def.type === 'class' && name.toLowerCase() === className.toLowerCase()) {
+                const methodFullName = `${name}.${methodName}`
+                const method = this.symbolsByName.get(methodFullName)
+                if (method?.length === 1) return method[0].id
+                
+                const methodLowerName = `${name.toLowerCase()}.${methodName.toLowerCase()}`
+                const methodLower = this.symbolsByName.get(methodLowerName)
+                if (methodLower?.length === 1) return methodLower[0].id
+            }
+        }
+        return null
+    }
+
+    private getMethodGlobally(className: string, methodName: string): string | null {
+        for (const [name, defs] of this.symbolsByName) {
+            if (defs[0]?.type === 'class' && name.toLowerCase() === className.toLowerCase()) {
+                const methodFullName = `${name}.${methodName}`
+                const method = this.symbolsByName.get(methodFullName)
+                if (method?.length === 1) return method[0].id
+            }
+        }
+        return null
+    }
+}

package/src/hash/hash-store.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import * as path from 'node:path'
 import * as fs from 'node:fs'
 import Database from 'better-sqlite3'

package/src/index.ts

@@ -8,6 +8,7 @@ export * from './hash/index.js'
 export * from './search/index.js'
 export * from './cache/index.js'
 export * from './security/index.js'
+export * from './analysis/index.js'
 export * from './utils/errors.js'
 export * from './utils/logger.js'
 export { MikkError, ErrorHandler, ErrorBuilder, ErrorCategory, FileSystemError, ModuleLoadError, GraphError, TokenBudgetError, ValidationError, createDefaultErrorListener, createFileNotFoundError, createFileTooLargeError, createPermissionDeniedError, createModuleNotFoundError, createModuleLoadFailedError, createGraphBuildFailedError, createNodeNotFoundError, createTokenBudgetExceededError, createValidationError, isMikkError, getRootCause, toMikkError } from './error-handler.js'
@@ -18,6 +19,7 @@ export { minimatch } from './utils/minimatch.js'
 export { scoreFunctions, findFuzzyMatches, levenshtein, splitCamelCase, extractKeywords } from './utils/fuzzy-match.js'
 export { writeFileAtomic, writeJsonAtomic } from './utils/atomic-write.js'
 export type { AtomicWriteOptions } from './utils/atomic-write.js'
+export { normalizeSlashes, normalizePath, normalizePathQuiet, getPathKey, pathsEqual, isSubPath } from './utils/path.js'
 export {
 	runArtifactWriteTransaction,
 	recoverArtifactWriteTransactions,

package/src/parser/base-extractor.ts

@@ -0,0 +1,19 @@
+import type { ParsedFile } from './types.js';
+
+/**
+ * Abstract base class for language-specific metadata extraction.
+ * Extractors can use different engines (Tree-Sitter, OXC, etc.) internally.
+ */
+export abstract class BaseExtractor {
+  /**
+   * Main entry point to parse and extract metadata from a file
+   */
+  abstract extract(filePath: string, content: string): Promise<ParsedFile>;
+
+  /**
+   * Resolve imports for a list of files (optional, default to simple pass-through)
+   */
+  async resolveImports(files: ParsedFile[], _projectRoot: string): Promise<ParsedFile[]> {
+    return files;
+  }
+}

package/src/parser/boundary-checker.ts

@@ -53,21 +53,40 @@ function parseConstraint(constraint: string): ParsedRule | null {
 export class BoundaryChecker {
     private rules: ParsedRule[]
     private moduleNames: Map<string, string>
+    private fileModuleMap: Map<string, string>
 
     constructor(private contract: MikkContract, private lock: MikkLock) {
         this.rules = contract.declared.constraints.map(parseConstraint).filter((r): r is ParsedRule => r !== null)
         this.moduleNames = new Map(contract.declared.modules.map(m => [m.id, m.name]))
+        
+        this.fileModuleMap = new Map()
+        for (const [filePath, fileData] of Object.entries(this.lock.files)) {
+            if (fileData.moduleId && fileData.moduleId !== 'unknown') {
+                this.fileModuleMap.set(filePath.toLowerCase(), fileData.moduleId)
+            }
+        }
+    }
+
+    private getModuleId(fn: any): string {
+        if (fn.moduleId && fn.moduleId !== 'unknown') return fn.moduleId
+        const normalized = (fn.file ?? '').replace(/\\/g, '/').toLowerCase()
+        return this.fileModuleMap.get(normalized) ?? 'unknown'
     }
 
     check(): BoundaryCheckResult {
         const violations: BoundaryViolation[] = []
+        const fnIndex = (this.lock as any).fnIndex ?? []
 
         for (const fn of Object.values(this.lock.functions)) {
-            if (fn.moduleId === 'unknown') continue
-            for (const calleeId of fn.calls) {
+            const fnModuleId = this.getModuleId(fn)
+            if (fnModuleId === 'unknown') continue
+            const calls = (fn.calls ?? []).map((c: any) => typeof c === 'number' ? fnIndex[c] : c).filter(Boolean)
+            for (const calleeId of calls) {
                 const callee = this.lock.functions[calleeId]
-                if (!callee || callee.moduleId === 'unknown' || fn.moduleId === callee.moduleId) continue
-                const v = this.checkCall(fn, callee)
+                if (!callee) continue
+                const calleeModuleId = this.getModuleId(callee)
+                if (calleeModuleId === 'unknown' || fnModuleId === calleeModuleId) continue
+                const v = this.checkCall(fn, callee, fnModuleId, calleeModuleId)
                 if (v) violations.push(v)
             }
         }
@@ -97,21 +116,21 @@ export class BoundaryChecker {
         const errorCount = unique.filter(v => v.severity === 'error').length
         const warnCount = unique.filter(v => v.severity === 'warning').length
         const summary = unique.length === 0
-            ? `All module boundaries respected (${fnCount} functions, ${fileCount} files checked)`
-            : `${errorCount} boundary error(s), ${warnCount} warning(s) found`
+            ? `All module boundaries respected (${fnCount} fns, ${fileCount} files checked)`
+            : `${errorCount} error(s), ${warnCount} warning(s) found`
 
         return { pass: errorCount === 0, violations: unique, summary }
     }
 
-    private checkCall(caller: MikkLockFunction, callee: MikkLockFunction): BoundaryViolation | null {
+    private checkCall(caller: any, callee: any, callerModuleId: string, calleeModuleId: string): BoundaryViolation | null {
         for (const rule of this.rules) {
-            if (rule.fromModuleId !== caller.moduleId) continue
+            if (rule.fromModuleId !== callerModuleId) continue
             const forbidden = rule.type === 'isolated' ? true
-                : rule.type === 'deny' ? rule.toModuleIds.includes(callee.moduleId)
-                : !rule.toModuleIds.includes(callee.moduleId)
+                : rule.type === 'deny' ? rule.toModuleIds.includes(calleeModuleId)
+                : !rule.toModuleIds.includes(calleeModuleId)
             if (forbidden) return {
-                from: { functionId: caller.id, functionName: caller.name, file: caller.file, moduleId: caller.moduleId, moduleName: this.moduleNames.get(caller.moduleId) ?? caller.moduleId },
-                to: { functionId: callee.id, functionName: callee.name, file: callee.file, moduleId: callee.moduleId, moduleName: this.moduleNames.get(callee.moduleId) ?? callee.moduleId },
+                from: { functionId: caller.id, functionName: caller.name, file: caller.file, moduleId: callerModuleId, moduleName: this.moduleNames.get(callerModuleId) ?? callerModuleId },
+                to: { functionId: callee.id, functionName: callee.name, file: callee.file, moduleId: calleeModuleId, moduleName: this.moduleNames.get(calleeModuleId) ?? calleeModuleId },
                 rule: rule.raw, severity: 'error'
             }
         }

package/src/parser/error-recovery.ts

@@ -1,6 +1,7 @@
-import type { ParsedFile, ParsedFunction, ParsedClass, ParsedImport, ParsedParam, CallExpression } from './types.js'
+import type { ParsedFile, ParsedFunction, ParsedClass, ParsedImport, ParsedParam } from './types.js'
 import * as path from 'node:path'
 import { hashContent } from '../hash/file-hasher.js'
+import { toParsedFileLanguage, type RegistryLanguage } from '../utils/language-registry.js'
 
 // ---------------------------------------------------------------------------
 // Error Recovery Engine — graceful degradation when parsing fails
@@ -64,7 +65,7 @@ export class ErrorRecoveryEngine {
       strategy: 'regex-recovery',
       parsed: {
         path: filePath,
-        language: language as ParsedFile['language'],
+        language: toParsedFileLanguage(language as RegistryLanguage),
         hash: hashContent(content),
         parsedAt: Date.now(),
         functions,
@@ -92,7 +93,7 @@ export class ErrorRecoveryEngine {
       strategy: 'minimal-fallback',
       parsed: {
         path: filePath,
-        language: language as ParsedFile['language'],
+        language: toParsedFileLanguage(language as RegistryLanguage),
         hash: hashContent(content),
         parsedAt: Date.now(),
         functions: [],
@@ -510,7 +511,7 @@ export class ErrorRecoveryEngine {
     lines: string[],
     functions: ParsedFunction[],
     classes: ParsedClass[],
-    imports: ParsedImport[]
+    _imports: ParsedImport[]
   ): void {
     const funcPatterns = [
       /function\s+(\w+)\s*\(/,

package/src/parser/function-body-extractor.ts

@@ -0,0 +1,248 @@
+import { readFile } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
+import type { RichFunction } from '../graph/rich-function-index.js'
+
+export interface FunctionBody {
+    id: string
+    name: string
+    file: string
+    startLine: number
+    endLine: number
+    body: string
+    fullSource: string
+    isComplete: boolean
+    trimmedLines: number
+}
+
+export interface BodyExtractOptions {
+    maxLines?: number
+    includeComments?: boolean
+    includeImports?: boolean
+    contextLines?: number
+}
+
+export class FunctionBodyExtractor {
+    private cache: Map<string, string> = new Map()
+    private bodyCache: Map<string, FunctionBody> = new Map()
+
+    async extractBody(fn: RichFunction, options: BodyExtractOptions = {}): Promise<FunctionBody | null> {
+        const cacheKey = `${fn.id}:${fn.startLine}:${fn.endLine}`
+        
+        if (this.bodyCache.has(cacheKey)) {
+            return this.bodyCache.get(cacheKey)!
+        }
+
+        const { maxLines = 500, contextLines = 0 } = options
+        
+        const source = await this.readSource(fn.file)
+        if (!source) {
+            return null
+        }
+
+        const lines = source.split('\n')
+        
+        const startLine = Math.max(0, fn.startLine - 1 - contextLines)
+        const endLine = Math.min(lines.length, fn.endLine + contextLines)
+        
+        const bodyLines = lines.slice(startLine, endLine)
+        const body = bodyLines.join('\n')
+        
+        const isComplete = fn.endLine <= lines.length && bodyLines.length >= fn.endLine - fn.startLine
+        
+        const result: FunctionBody = {
+            id: fn.id,
+            name: fn.name,
+            file: fn.file,
+            startLine: fn.startLine,
+            endLine: fn.endLine,
+            body,
+            fullSource: source,
+            isComplete,
+            trimmedLines: lines.length - endLine,
+        }
+        
+        this.bodyCache.set(cacheKey, result)
+        return result
+    }
+
+    async extractBodies(fns: RichFunction[], options: BodyExtractOptions = {}): Promise<Map<string, FunctionBody>> {
+        const results = new Map<string, FunctionBody>()
+        
+        for (const fn of fns) {
+            const body = await this.extractBody(fn, options)
+            if (body) {
+                results.set(fn.id, body)
+            }
+        }
+        
+        return results
+    }
+
+    async extractBodiesByIds(ids: string[], getFn: (id: string) => RichFunction | undefined, options: BodyExtractOptions = {}): Promise<Map<string, FunctionBody>> {
+        const results = new Map<string, FunctionBody>()
+        
+        const fns = ids.map(id => getFn(id)).filter(Boolean) as RichFunction[]
+        const bodies = await this.extractBodies(fns, options)
+        
+        for (const [id, body] of bodies) {
+            results.set(id, body)
+        }
+        
+        return results
+    }
+
+    private async readSource(filePath: string): Promise<string | null> {
+        if (this.cache.has(filePath)) {
+            return this.cache.get(filePath)!
+        }
+
+        if (!existsSync(filePath)) {
+            return null
+        }
+
+        try {
+            const content = await readFile(filePath, 'utf-8')
+            this.cache.set(filePath, content)
+            return content
+        } catch {
+            return null
+        }
+    }
+
+    clearCache(): void {
+        this.cache.clear()
+        this.bodyCache.clear()
+    }
+
+    getCachedCount(): number {
+        return this.cache.size
+    }
+
+    getBodyCacheCount(): number {
+        return this.bodyCache.size
+    }
+}
+
+export interface ExtractResult {
+    success: boolean
+    body?: string
+    signature?: string
+    params?: string
+    returnType?: string
+    docComment?: string
+    error?: string
+}
+
+export async function extractFunction(
+    filePath: string,
+    functionName: string,
+    options: BodyExtractOptions = {}
+): Promise<ExtractResult> {
+    if (!existsSync(filePath)) {
+        return { success: false, error: 'File not found' }
+    }
+
+    try {
+        const content = await readFile(filePath, 'utf-8')
+        const lines = content.split('\n')
+        
+        let startLine = -1
+        let endLine = -1
+        let braceCount = 0
+        let inFunction = false
+        let foundOpening = false
+        
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i]
+            
+            if (!inFunction && (line.includes(`function ${functionName}`) || line.includes(`const ${functionName}`) || line.includes(`${functionName}(`) || line.includes(`async ${functionName}`))) {
+                if (line.includes(`function ${functionName}`) || line.includes(`async function ${functionName}`) || line.match(new RegExp(`(const|let|var)\\s+${functionName}\\s*=`)) || line.match(new RegExp(`${functionName}\\s*\\(`))) {
+                    inFunction = true
+                    startLine = i
+                }
+            }
+            
+            if (inFunction) {
+                for (const char of line) {
+                    if (char === '{') {
+                        braceCount++
+                        foundOpening = true
+                    } else if (char === '}') {
+                        braceCount--
+                    }
+                }
+                
+                if (foundOpening && braceCount === 0) {
+                    endLine = i + 1
+                    break
+                }
+            }
+        }
+        
+        if (startLine === -1 || endLine === -1) {
+            return { success: false, error: 'Function not found' }
+        }
+        
+        const bodyLines = lines.slice(startLine, endLine)
+        const body = bodyLines.join('\n')
+        
+        const maxLines = options.maxLines || 500
+        const trimmedBody = bodyLines.length > maxLines 
+            ? bodyLines.slice(0, maxLines).join('\n') + '\n// ... (truncated)'
+            : body
+        
+        return {
+            success: true,
+            body: trimmedBody,
+            signature: extractSignature(bodyLines[0] || ''),
+            docComment: extractDocComment(lines, startLine),
+        }
+    } catch (err: any) {
+        return { success: false, error: err.message }
+    }
+}
+
+function extractSignature(line: string): string {
+    const match = line.match(/(?:async\s+)?(?:function\s+)?(?:\w+\s+)?(\w+)\s*\([^)]*\)\s*(?::\s*\w+)?/)
+    return match ? match[0] : line.trim()
+}
+
+function extractDocComment(lines: string[], startLine: number): string | undefined {
+    if (startLine === 0) return undefined
+    
+    const prevLine = lines[startLine - 1]
+    if (prevLine && (prevLine.includes('/**') || prevLine.includes('///') || prevLine.startsWith('//'))) {
+        const commentLines: string[] = []
+        let i = startLine - 1
+        
+        while (i >= 0) {
+            const line = lines[i]
+            if (line.includes('/**') || line.includes("'''")) {
+                commentLines.unshift(line)
+                break
+            } else if (line.trim().startsWith('*') || line.trim().startsWith('//')) {
+                commentLines.unshift(line)
+            } else {
+                break
+            }
+            i--
+        }
+        
+        return commentLines.join('\n') || undefined
+    }
+    
+    return undefined
+}
+
+export function trimBody(body: string, maxLines: number): string {
+    const lines = body.split('\n')
+    if (lines.length <= maxLines) return body
+    
+    return lines.slice(0, maxLines).join('\n') + '\n// ...'
+}
+
+export function getBodyPreview(body: string, maxChars: number = 200): string {
+    const firstLine = body.split('\n')[0]
+    if (firstLine.length <= maxChars) return firstLine
+    return firstLine.slice(0, maxChars) + '...'
+}