@getmikk/core 1.7.1 → 1.8.1

package/src/contract/lock-reader.ts

@@ -3,7 +3,7 @@ import { MikkLockSchema, type MikkLock } from './schema.js'
 import { LockNotFoundError } from '../utils/errors.js'
 
 /**
- * LockReader — reads and validates mikk.lock.json from disk.
+ * LockReader -- reads and validates mikk.lock.json from disk.
  * Uses compact format on disk: default values are omitted to save space.
  * Hydrates omitted fields before validation; compactifies before writing.
  */
@@ -17,7 +17,7 @@ export class LockReader {
             throw new LockNotFoundError()
         }
 
-        const json = JSON.parse(content)
+        const json = JSON.parse(content.replace(/^\uFEFF/, ''))
         const hydrated = hydrateLock(json)
         const result = MikkLockSchema.safeParse(hydrated)
 
@@ -38,11 +38,11 @@ export class LockReader {
 }
 
 // ---------------------------------------------------------------------------
-// Compact format — omit-defaults serialization
+// Compact format -- omit-defaults serialization
 // ---------------------------------------------------------------------------
 // Rules:
 //   1. Never write a field whose value equals its default ([], "", undefined, "unknown")
-//   2. id/name/file/path are derivable from the record key — omit them
+//   2. id/name/file/path are derivable from the record key  omit them
 //   3. Line ranges become tuples: [startLine, endLine]
 //   4. errorHandling becomes tuples: [line, type, detail]
 //   5. detailedLines becomes tuples: [startLine, endLine, blockType]
@@ -65,7 +65,7 @@ function compactifyLock(lock: MikkLock): any {
     fnKeys.forEach((k, i) => fnIndexMap.set(k, i))
     out.fnIndex = fnKeys
 
-    // Functions — biggest savings
+    // Functions -- biggest savings
     out.functions = {}
     for (let idx = 0; idx < fnKeys.length; idx++) {
         const fn = lock.functions[fnKeys[idx]]
@@ -123,10 +123,10 @@ function compactifyLock(lock: MikkLock): any {
         }
     }
 
-    // Modules — keep as-is (already small)
+    // Modules -- keep as-is (already small)
     out.modules = lock.modules
 
-    // Files — strip redundant path (it's the key)
+    // Files -- strip redundant path (it's the key)
     out.files = {}
     for (const [key, file] of Object.entries(lock.files)) {
         const c: any = {
@@ -138,12 +138,12 @@ function compactifyLock(lock: MikkLock): any {
         out.files[key] = c
     }
 
-    // Context files — paths/type only, no content
+    // Context files -- paths/type only, no content
     if (lock.contextFiles && lock.contextFiles.length > 0) {
         out.contextFiles = lock.contextFiles.map(({ path, type, size }) => ({ path, type, size }))
     }
 
-    // Routes — keep as-is (already compact)
+    // Routes -- keep as-is (already compact)
     if (lock.routes && lock.routes.length > 0) {
         out.routes = lock.routes
     }
@@ -158,7 +158,7 @@ function hydrateLock(raw: any): any {
     // If it already has the old format (functions have id/name/file), pass through
     const firstFn = Object.values(raw.functions || {})[0] as any
     if (firstFn && typeof firstFn === 'object' && 'id' in firstFn && 'name' in firstFn && 'file' in firstFn) {
-        return raw // Already in full format — no hydration needed
+        return raw // Already in full format -- no hydration needed
     }
 
     const out: any = {
@@ -174,7 +174,7 @@ function hydrateLock(raw: any): any {
     const fnIndex: string[] = raw.fnIndex || []
     const hasFnIndex = fnIndex.length > 0
 
-    // P6: build file→moduleId map before function loop
+    // P6: build file->moduleId map before function loop
     const fileModuleMap: Record<string, string> = {}
     for (const [key, c] of Object.entries(raw.files || {}) as [string, any][]) {
         fileModuleMap[key] = c.moduleId || 'unknown'
@@ -183,11 +183,11 @@ function hydrateLock(raw: any): any {
     // Hydrate functions
     out.functions = {}
     for (const [key, c] of Object.entries(raw.functions || {}) as [string, any][]) {
-        // P7: key is integer index → look up full ID via fnIndex
+        // P7: key is integer index -> look up full ID via fnIndex
         const fullId = hasFnIndex ? (fnIndex[parseInt(key)] || key) : key
         const { name, file } = parseEntityKey(fullId, 'fn:')
         const lines = c.lines || [c.startLine || 0, c.endLine || 0]
-        // P7: integer calls/calledBy → resolve to full string IDs (backward compat: strings pass through)
+        // P7: integer calls/calledBy -> resolve to full string IDs (backward compat: strings pass through)
         const calls = (c.calls || []).map((v: any) => typeof v === 'number' ? (fnIndex[v] ?? null) : v).filter(Boolean)
         const calledBy = (c.calledBy || []).map((v: any) => typeof v === 'number' ? (fnIndex[v] ?? null) : v).filter(Boolean)
 
@@ -277,7 +277,7 @@ function hydrateLock(raw: any): any {
         }
     }
 
-    // Modules — already in full format
+    // Modules -- already in full format
     out.modules = raw.modules
 
     // Pass through

package/src/contract/schema.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod'
 
-// ─── mikk.json schema ──────────────────────────────────────
+// ─── mikk.json schema ───────────────────────────────────
 
 export const MikkModuleSchema = z.object({
     id: z.string(),
@@ -33,7 +33,7 @@ export const MikkContractSchema = z.object({
         description: z.string(),
         language: z.string(),
         framework: z.string().optional(),
-        entryPoints: z.array(z.string()),
+        entryPoints: z.array(z.string()).default([]),
     }),
     declared: z.object({
         modules: z.array(MikkModuleSchema),
@@ -47,7 +47,7 @@ export type MikkContract = z.infer<typeof MikkContractSchema>
 export type MikkModule = z.infer<typeof MikkModuleSchema>
 export type MikkDecision = z.infer<typeof MikkDecisionSchema>
 
-// ─── mikk.lock.json schema ─────────────────────────────────
+// ─── mikk.lock.json schema ──────────────────────────────
 
 export const MikkLockFunctionSchema = z.object({
     id: z.string(),

package/src/index.ts

@@ -5,9 +5,10 @@ export * from './parser/index.js'
 export * from './graph/index.js'
 export * from './contract/index.js'
 export * from './hash/index.js'
+export * from './search/index.js'
 export * from './utils/errors.js'
 export * from './utils/logger.js'
-export { discoverFiles, discoverContextFiles, readFileContent, writeFileContent, fileExists, setupMikkDirectory, readMikkIgnore, parseMikkIgnore, detectProjectLanguage, getDiscoveryPatterns, generateMikkIgnore } from './utils/fs.js'
+export { discoverFiles, discoverContextFiles, readFileContent, writeFileContent, fileExists, setupMikkDirectory, readMikkIgnore, parseMikkIgnore, detectProjectLanguage, getDiscoveryPatterns, generateMikkIgnore, updateGitIgnore, cleanupGitIgnore } from './utils/fs.js'
 export type { ContextFile, ContextFileType, ProjectLanguage } from './utils/fs.js'
 export { minimatch } from './utils/minimatch.js'
 export { scoreFunctions, findFuzzyMatches, levenshtein, splitCamelCase, extractKeywords } from './utils/fuzzy-match.js'

package/src/parser/base-parser.ts

@@ -6,7 +6,7 @@ import type { ParsedFile, ParsedImport } from './types.js'
  */
 export abstract class BaseParser {
     /** Given raw file content as a string, return ParsedFile */
-    abstract parse(filePath: string, content: string): ParsedFile
+    abstract parse(filePath: string, content: string): Promise<ParsedFile>
 
     /** Given a list of parsed files, resolve all import paths to absolute project paths */
     abstract resolveImports(files: ParsedFile[], projectRoot: string): ParsedFile[]

package/src/parser/boundary-checker.ts

@@ -1,29 +1,11 @@
 import * as path from 'node:path'
-import type { MikkContract, MikkLock, MikkLockFunction } from '@getmikk/core'
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
+import type { MikkContract, MikkLock, MikkLockFunction } from '../contract/schema.js'
 
 export type ViolationSeverity = 'error' | 'warning'
 
 export interface BoundaryViolation {
-    /** The function making the illegal import */
-    from: {
-        functionId: string
-        functionName: string
-        file: string
-        moduleId: string
-        moduleName: string
-    }
-    /** The function being illegally called */
-    to: {
-        functionId: string
-        functionName: string
-        file: string
-        moduleId: string
-        moduleName: string
-    }
+    from: { functionId: string; functionName: string; file: string; moduleId: string; moduleName: string }
+    to: { functionId: string; functionName: string; file: string; moduleId: string; moduleName: string }
     rule: string
     severity: ViolationSeverity
 }
@@ -34,251 +16,131 @@ export interface BoundaryCheckResult {
     summary: string
 }
 
-// ---------------------------------------------------------------------------
-// Rule parsing
-// ---------------------------------------------------------------------------
-
-/**
- * Parse constraint strings into structured allow/deny rules.
- *
- * Supported syntax in mikk.json constraints:
- *   "module:auth cannot import module:payments"
- *   "module:cli cannot import module:db"
- *   "module:core has no imports"          → core is completely isolated
- *   "module:api can only import module:core, module:utils"
- */
 interface ParsedRule {
     type: 'deny' | 'allow_only' | 'isolated'
     fromModuleId: string
-    toModuleIds: string[]           // For deny: what's forbidden. For allow_only: what's allowed.
+    toModuleIds: string[]
     raw: string
 }
 
-function parseConstraint(constraint: string): ParsedRule | null {
-    const c = constraint.trim().toLowerCase()
-
-    // "module:X cannot import module:Y"  or "module:X cannot import module:Y, module:Z"
-    const denyMatch = c.match(/^module:(\S+)\s+cannot\s+import\s+(.+)$/)
-    if (denyMatch) {
-        const toModules = denyMatch[2]
-            .split(',')
-            .map(s => s.trim().replace('module:', ''))
-            .filter(Boolean)
-        return { type: 'deny', fromModuleId: denyMatch[1], toModuleIds: toModules, raw: constraint }
-    }
-
-    // "module:X can only import module:A, module:B"
-    const allowOnlyMatch = c.match(/^module:(\S+)\s+can\s+only\s+import\s+(.+)$/)
-    if (allowOnlyMatch) {
-        const toModules = allowOnlyMatch[2]
-            .split(',')
-            .map(s => s.trim().replace('module:', ''))
-            .filter(Boolean)
-        return { type: 'allow_only', fromModuleId: allowOnlyMatch[1], toModuleIds: toModules, raw: constraint }
-    }
-
-    // "module:X has no imports" or "module:X is isolated"
-    const isolatedMatch = c.match(/^module:(\S+)\s+(has\s+no\s+imports|is\s+isolated)$/)
-    if (isolatedMatch) {
-        return { type: 'isolated', fromModuleId: isolatedMatch[1], toModuleIds: [], raw: constraint }
-    }
+function stripPrefix(s: string): string {
+    return s.trim().replace(/^module:/, '')
+}
 
-    return null   // unrecognized constraint — skip silently
+function parseList(raw: string): string[] {
+    return raw.split(/,\s*/).map(stripPrefix).filter(Boolean)
 }
 
-// ---------------------------------------------------------------------------
-// BoundaryChecker
-// ---------------------------------------------------------------------------
+function parseConstraint(constraint: string): ParsedRule | null {
+    const c = constraint.trim()
+    const l = c.toLowerCase()
+    const natDeny = l.match(/^(\S+)\s+(?:must\s+not|cannot|should\s+not)\s+(?:import\s+from|import|call\s+into|call)\s+(.+)$/)
+    if (natDeny) return { type: 'deny', fromModuleId: stripPrefix(natDeny[1]), toModuleIds: parseList(natDeny[2]), raw: c }
+    const natAllow = l.match(/^(\S+)\s+can\s+only\s+(?:import\s+from|import)\s+(.+)$/)
+    if (natAllow) return { type: 'allow_only', fromModuleId: stripPrefix(natAllow[1]), toModuleIds: parseList(natAllow[2]), raw: c }
+    const natIso = l.match(/^(\S+)\s+(?:is\s+isolated|has\s+no\s+imports)$/)
+    if (natIso) return { type: 'isolated', fromModuleId: stripPrefix(natIso[1]), toModuleIds: [], raw: c }
+    const legDeny = l.match(/^module:(\S+)\s+cannot\s+import\s+(.+)$/)
+    if (legDeny) return { type: 'deny', fromModuleId: legDeny[1], toModuleIds: parseList(legDeny[2]), raw: c }
+    const legAllow = l.match(/^module:(\S+)\s+can\s+only\s+import\s+(.+)$/)
+    if (legAllow) return { type: 'allow_only', fromModuleId: legAllow[1], toModuleIds: parseList(legAllow[2]), raw: c }
+    const legIso = l.match(/^module:(\S+)\s+(?:has\s+no\s+imports|is\s+isolated)$/)
+    if (legIso) return { type: 'isolated', fromModuleId: legIso[1], toModuleIds: [], raw: c }
+    console.warn(`[mikk] Constraint skipped: "${c}" - use "auth must not import from payments"`)
+    return null
+}
 
-/**
- * BoundaryChecker — walks the lock file's call graph and checks every
- * cross-module call against the rules declared in mikk.json constraints.
- *
- * This is the CI-ready enforcement layer.
- */
 export class BoundaryChecker {
     private rules: ParsedRule[]
-    private moduleNames: Map<string, string>   // id → name
-
-    constructor(
-        private contract: MikkContract,
-        private lock: MikkLock
-    ) {
-        this.rules = contract.declared.constraints
-            .map(parseConstraint)
-            .filter((r): r is ParsedRule => r !== null)
+    private moduleNames: 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]))
     }
 
-    /** Run boundary check. Returns pass/fail + all violations. */
     check(): BoundaryCheckResult {
         const violations: BoundaryViolation[] = []
 
-        // Pass 1: Check cross-module function calls
         for (const fn of Object.values(this.lock.functions)) {
+            if (fn.moduleId === 'unknown') continue
             for (const calleeId of fn.calls) {
                 const callee = this.lock.functions[calleeId]
-                if (!callee) continue
-                if (fn.moduleId === callee.moduleId) continue  // same module — fine
-
-                // Check this cross-module call against all parsed rules
-                const violation = this.checkCall(fn, callee)
-                if (violation) violations.push(violation)
+                if (!callee || callee.moduleId === 'unknown' || fn.moduleId === callee.moduleId) continue
+                const v = this.checkCall(fn, callee)
+                if (v) violations.push(v)
             }
         }
 
-        // Pass 2: Check cross-module file-level imports
         for (const file of Object.values(this.lock.files)) {
-            if (!file.imports || file.imports.length === 0) continue
+            if (file.moduleId === 'unknown' || !file.imports?.length) continue
             for (const importedPath of file.imports) {
                 const importedFile = this.lock.files[importedPath]
-                if (!importedFile) continue
-                if (file.moduleId === importedFile.moduleId) continue // same module — fine
-
-                const violation = this.checkFileImport(file, importedFile)
-                if (violation) violations.push(violation)
+                if (!importedFile || importedFile.moduleId === 'unknown' || file.moduleId === importedFile.moduleId) continue
+                const v = this.checkFileImport(file, importedFile)
+                if (v) violations.push(v)
             }
         }
 
-        const errorCount = violations.filter(v => v.severity === 'error').length
-        const warnCount = violations.filter(v => v.severity === 'warning').length
-
-        const summary = violations.length === 0
-            ? `✓ All module boundaries respected (${Object.keys(this.lock.functions).length} functions, ${Object.keys(this.lock.files).length} files checked)`
-            : `✗ ${errorCount} boundary error(s), ${warnCount} warning(s) found`
-
-        return {
-            pass: errorCount === 0,
-            violations,
-            summary,
-        }
+        const seen = new Set<string>()
+        const unique = violations.filter(v => {
+            const key = `${v.from.functionId}|${v.to.functionId}|${v.rule}`
+            if (seen.has(key)) return false
+            seen.add(key)
+            return true
+        })
+
+        const fnCount = Object.keys(this.lock.functions).length
+        const fileCount = Object.keys(this.lock.files).length
+        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`
+
+        return { pass: errorCount === 0, violations: unique, summary }
     }
 
-    /**
-     * Check a single cross-module call against parsed rules.
-     * Returns a violation if the call is forbidden, null if it's allowed.
-     */
-    private checkCall(
-        caller: MikkLockFunction,
-        callee: MikkLockFunction
-    ): BoundaryViolation | null {
+    private checkCall(caller: MikkLockFunction, callee: MikkLockFunction): BoundaryViolation | null {
         for (const rule of this.rules) {
             if (rule.fromModuleId !== caller.moduleId) continue
-
-            let forbidden = false
-            let ruleDesc = rule.raw
-
-            if (rule.type === 'isolated') {
-                // Module may not call anything outside itself
-                forbidden = true
-            } else if (rule.type === 'deny') {
-                // Module may not call into these specific modules
-                forbidden = rule.toModuleIds.includes(callee.moduleId)
-            } else if (rule.type === 'allow_only') {
-                // Module may ONLY call into the listed modules (+ itself)
-                forbidden = !rule.toModuleIds.includes(callee.moduleId)
-            }
-
-            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,
-                    },
-                    rule: ruleDesc,
-                    severity: 'error',
-                }
+            const forbidden = rule.type === 'isolated' ? true
+                : rule.type === 'deny' ? rule.toModuleIds.includes(callee.moduleId)
+                : !rule.toModuleIds.includes(callee.moduleId)
+            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 },
+                rule: rule.raw, severity: 'error'
             }
         }
         return null
     }
 
-    /**
-     * Check a single cross-module file import against parsed rules.
-     * Returns a violation if the import is forbidden, null if it's allowed.
-     */
-    private checkFileImport(
-        sourceFile: { path: string; moduleId: string },
-        targetFile: { path: string; moduleId: string }
-    ): BoundaryViolation | null {
+    private checkFileImport(sourceFile: { path: string; moduleId: string }, targetFile: { path: string; moduleId: string }): BoundaryViolation | null {
         for (const rule of this.rules) {
             if (rule.fromModuleId !== sourceFile.moduleId) continue
-
-            let forbidden = false
-
-            if (rule.type === 'isolated') {
-                forbidden = true
-            } else if (rule.type === 'deny') {
-                forbidden = rule.toModuleIds.includes(targetFile.moduleId)
-            } else if (rule.type === 'allow_only') {
-                forbidden = !rule.toModuleIds.includes(targetFile.moduleId)
-            }
-
-            if (forbidden) {
-                return {
-                    from: {
-                        functionId: `file:${sourceFile.path}`,
-                        functionName: path.basename(sourceFile.path),
-                        file: sourceFile.path,
-                        moduleId: sourceFile.moduleId,
-                        moduleName: this.moduleNames.get(sourceFile.moduleId) ?? sourceFile.moduleId,
-                    },
-                    to: {
-                        functionId: `file:${targetFile.path}`,
-                        functionName: path.basename(targetFile.path),
-                        file: targetFile.path,
-                        moduleId: targetFile.moduleId,
-                        moduleName: this.moduleNames.get(targetFile.moduleId) ?? targetFile.moduleId,
-                    },
-                    rule: rule.raw,
-                    severity: 'error',
-                }
+            const forbidden = rule.type === 'isolated' ? true
+                : rule.type === 'deny' ? rule.toModuleIds.includes(targetFile.moduleId)
+                : !rule.toModuleIds.includes(targetFile.moduleId)
+            if (forbidden) return {
+                from: { functionId: `file:${sourceFile.path}`, functionName: path.basename(sourceFile.path), file: sourceFile.path, moduleId: sourceFile.moduleId, moduleName: this.moduleNames.get(sourceFile.moduleId) ?? sourceFile.moduleId },
+                to: { functionId: `file:${targetFile.path}`, functionName: path.basename(targetFile.path), file: targetFile.path, moduleId: targetFile.moduleId, moduleName: this.moduleNames.get(targetFile.moduleId) ?? targetFile.moduleId },
+                rule: rule.raw, severity: 'error'
             }
         }
         return null
     }
 
-    /** Return all cross-module call pairs (useful for generating allow rules) */
     allCrossModuleCalls(): { from: string; to: string; count: number }[] {
         const counts = new Map<string, number>()
-
-        // Count function-level cross-module calls
         for (const fn of Object.values(this.lock.functions)) {
             for (const calleeId of fn.calls) {
                 const callee = this.lock.functions[calleeId]
-                if (!callee || fn.moduleId === callee.moduleId) continue
-                const key = `${fn.moduleId}→${callee.moduleId}`
+                if (!callee || fn.moduleId === callee.moduleId || fn.moduleId === 'unknown' || callee.moduleId === 'unknown') continue
+                const key = `${fn.moduleId}>${callee.moduleId}`
                 counts.set(key, (counts.get(key) ?? 0) + 1)
             }
         }
-
-        // Count file-level cross-module imports
-        for (const file of Object.values(this.lock.files)) {
-            if (!file.imports) continue
-            for (const importedPath of file.imports) {
-                const importedFile = this.lock.files[importedPath]
-                if (!importedFile || file.moduleId === importedFile.moduleId) continue
-                const key = `${file.moduleId}→${importedFile.moduleId}`
-                counts.set(key, (counts.get(key) ?? 0) + 1)
-            }
-        }
-
-        return [...counts.entries()]
-            .map(([key, count]) => {
-                const [from, to] = key.split('→')
-                return { from, to, count }
-            })
-            .sort((a, b) => b.count - a.count)
+        return [...counts.entries()].map(([key, count]) => { const [from, to] = key.split('>'); return { from, to, count } }).sort((a, b) => b.count - a.count)
     }
 }

package/src/parser/go/go-extractor.ts

@@ -4,7 +4,7 @@ import type {
     ParsedParam, ParsedGeneric, ParsedRoute,
 } from '../types.js'
 
-// ─── Go builtins / keywords to skip when extracting calls ───────────────────
+// --- Go builtins / keywords to skip when extracting calls -------------------
 const GO_BUILTINS = new Set([
     'if', 'else', 'for', 'switch', 'select', 'case', 'default', 'break',
     'continue', 'goto', 'fallthrough', 'return', 'go', 'defer', 'range',
@@ -16,7 +16,7 @@ const GO_BUILTINS = new Set([
     'complex64', 'complex128', 'bool', 'byte', 'rune', 'error', 'any',
 ])
 
-// ─── Route detection patterns (Gin, Echo, Chi, Mux, net/http, Fiber) ────────
+// --- Route detection patterns (Gin, Echo, Chi, Mux, net/http, Fiber) --------
 type RoutePattern = { re: RegExp; methodGroup: number; pathGroup: number; handlerGroup: number; fixedMethod?: string }
 
 const ROUTE_PATTERNS: RoutePattern[] = [
@@ -48,7 +48,7 @@ const ROUTE_PATTERNS: RoutePattern[] = [
 ]
 
 /**
- * GoExtractor — pure regex + stateful line scanner for .go files.
+ * GoExtractor -- pure regex + stateful line scanner for .go files.
  * Extracts functions, structs (as classes), imports, exports, and HTTP routes
  * without any external Go AST dependency.
  */
@@ -62,7 +62,7 @@ export class GoExtractor {
         this.lines = content.split('\n')
     }
 
-    // ── Public API ──────────────────────────────────────────────────────────
+    // --- Public API ---------------------------------------------------------
 
     /** Extract all top-level functions (no receiver) */
     extractFunctions(): ParsedFunction[] {
@@ -160,7 +160,7 @@ export class GoExtractor {
         return routes
     }
 
-    // ── Internal scanning ───────────────────────────────────────────────────
+    // --- Internal scanning ---------------------------------------------------
 
     /** Scanned raw function data (before building ParsedFunction) */
     private scanFunctions(): Array<{
@@ -343,7 +343,7 @@ export class GoExtractor {
     }
 }
 
-// ─── Signature parsing ────────────────────────────────────────────────────────
+// --- Signature parsing --------------------------------------------------------
 
 interface GoFuncSignature {
     name: string
@@ -481,7 +481,7 @@ function cleanReturnType(ret: string): string {
     return ret
 }
 
-// ─── Import line parsing ──────────────────────────────────────────────────────
+// --- Import line parsing ------------------------------------------------------
 
 function parseImportLine(line: string): ParsedImport | null {
     const trimmed = line.trim()
@@ -509,7 +509,7 @@ function parseImportLine(line: string): ParsedImport | null {
     return null
 }
 
-// ─── Body analysis ────────────────────────────────────────────────────────────
+// --- Body analysis ------------------------------------------------------------
 
 /**
  * Statefully track brace depth through content, handling:
@@ -661,7 +661,7 @@ function extractErrorHandling(bodyLines: string[], baseLineNumber: number): { li
     return errors
 }
 
-// ─── Comment extraction ───────────────────────────────────────────────────────
+// --- Comment extraction -------------------------------------------------------
 
 function extractLeadingComment(lines: string[], funcLine: number): string {
     // Scan backwards from funcLine for consecutive comment lines
@@ -686,7 +686,7 @@ function extractLeadingComment(lines: string[], funcLine: number): string {
     return ''
 }
 
-// ─── Utility helpers ──────────────────────────────────────────────────────────
+// --- Utility helpers ----------------------------------------------------------
 
 function isExported(name: string): boolean {
     return name.length > 0 && name[0] === name[0].toUpperCase() && name[0] !== name[0].toLowerCase()

package/src/parser/go/go-parser.ts

@@ -5,12 +5,12 @@ import { hashContent } from '../../hash/file-hasher.js'
 import type { ParsedFile } from '../types.js'
 
 /**
- * GoParser — implements BaseParser for .go files.
+ * GoParser -- implements BaseParser for .go files.
  * Uses GoExtractor (regex-based) to pull structured data from Go source
  * without requiring the Go toolchain.
  */
 export class GoParser extends BaseParser {
-    parse(filePath: string, content: string): ParsedFile {
+    async parse(filePath: string, content: string): Promise<ParsedFile> {
         const extractor = new GoExtractor(filePath, content)
 
         return {