@getmikk/core 1.2.0 → 1.3.0

package/src/hash/file-hasher.ts

@@ -1,30 +1,30 @@
-import { createHash } from 'node:crypto'
-import * as fs from 'node:fs/promises'
-
-/**
- * Compute SHA-256 hash of a string.
- */
-export function hashContent(content: string): string {
-    return createHash('sha256').update(content).digest('hex')
-}
-
-/**
- * Compute SHA-256 hash of a file on disk.
- */
-export async function hashFile(filePath: string): Promise<string> {
-    const content = await fs.readFile(filePath, 'utf-8')
-    return hashContent(content)
-}
-
-/**
- * Hash a specific function body by extracting lines from file content.
- */
-export function hashFunctionBody(
-    fileContent: string,
-    startLine: number,
-    endLine: number
-): string {
-    const lines = fileContent.split('\n')
-    const body = lines.slice(startLine - 1, endLine).join('\n')
-    return hashContent(body)
-}
+import { createHash } from 'node:crypto'
+import * as fs from 'node:fs/promises'
+
+/**
+ * Compute SHA-256 hash of a string.
+ */
+export function hashContent(content: string): string {
+    return createHash('sha256').update(content).digest('hex')
+}
+
+/**
+ * Compute SHA-256 hash of a file on disk.
+ */
+export async function hashFile(filePath: string): Promise<string> {
+    const content = await fs.readFile(filePath, 'utf-8')
+    return hashContent(content)
+}
+
+/**
+ * Hash a specific function body by extracting lines from file content.
+ */
+export function hashFunctionBody(
+    fileContent: string,
+    startLine: number,
+    endLine: number
+): string {
+    const lines = fileContent.split('\n')
+    const body = lines.slice(startLine - 1, endLine).join('\n')
+    return hashContent(body)
+}

package/src/hash/hash-store.ts

@@ -1,119 +1,119 @@
-import * as path from 'node:path'
-import * as fs from 'node:fs'
-import Database from 'better-sqlite3'
-import { logger } from '../utils/logger.js'
-
-const CREATE_SCHEMA_SQL = `
-CREATE TABLE IF NOT EXISTS file_hashes (
-  path        TEXT PRIMARY KEY,
-  hash        TEXT NOT NULL,
-  size_bytes  INTEGER NOT NULL,
-  updated_at  INTEGER NOT NULL
-);
-CREATE INDEX IF NOT EXISTS idx_updated_at ON file_hashes(updated_at);
-`
-
-/**
- * HashStore — SQLite-backed persistent store for file content hashes.
- *
- * Survives process restarts, handles concurrent access via WAL mode,
- * and provides fast O(1) lookups for change detection.
- */
-export class HashStore {
-    private db: InstanceType<typeof Database>
-
-    constructor(projectRoot: string) {
-        const dbPath = path.join(projectRoot, '.mikk', 'cache', 'hashes.db')
-        const dbDir = path.dirname(dbPath)
-
-        // Ensure directory exists
-        if (!fs.existsSync(dbDir)) {
-            fs.mkdirSync(dbDir, { recursive: true })
-        }
-
-        this.db = this.openDatabase(dbPath)
-        this.db.exec(CREATE_SCHEMA_SQL)
-    }
-
-    private openDatabase(dbPath: string): InstanceType<typeof Database> {
-        try {
-            const db = new Database(dbPath)
-            // WAL mode: concurrent reads + writes, atomic commits
-            db.pragma('journal_mode = WAL')
-            // Wait up to 5s if locked by another process
-            db.pragma('busy_timeout = 5000')
-            return db
-        } catch (err: any) {
-            // Corrupted database — delete and recreate
-            logger.warn('Hash store corrupted, recreating', { error: err.message })
-            try {
-                fs.unlinkSync(dbPath)
-            } catch { /* ignore */ }
-            const db = new Database(dbPath)
-            db.pragma('journal_mode = WAL')
-            db.pragma('busy_timeout = 5000')
-            return db
-        }
-    }
-
-    /** Get the stored hash for a file path, or null if not tracked */
-    get(filePath: string): string | null {
-        const row = this.db
-            .prepare('SELECT hash FROM file_hashes WHERE path = ?')
-            .get(filePath) as { hash: string } | undefined
-        return row?.hash ?? null
-    }
-
-    /** Store or update the hash for a file */
-    set(filePath: string, hash: string, sizeBytes: number): void {
-        this.db
-            .prepare(
-                `INSERT OR REPLACE INTO file_hashes
-                 (path, hash, size_bytes, updated_at) VALUES (?, ?, ?, ?)`
-            )
-            .run(filePath, hash, sizeBytes, Date.now())
-    }
-
-    /** Remove tracked hash for a (deleted) file */
-    delete(filePath: string): void {
-        this.db
-            .prepare('DELETE FROM file_hashes WHERE path = ?')
-            .run(filePath)
-    }
-
-    /** Return all paths whose updated_at is greater than a timestamp */
-    getChangedSince(timestamp: number): string[] {
-        const rows = this.db
-            .prepare('SELECT path FROM file_hashes WHERE updated_at > ?')
-            .all(timestamp) as { path: string }[]
-        return rows.map(r => r.path)
-    }
-
-    /** Return all tracked file paths */
-    getAllPaths(): string[] {
-        const rows = this.db
-            .prepare('SELECT path FROM file_hashes')
-            .all() as { path: string }[]
-        return rows.map(r => r.path)
-    }
-
-    /** Batch-set multiple hashes inside a single transaction (fast for init) */
-    setBatch(entries: { path: string; hash: string; sizeBytes: number }[]): void {
-        const insert = this.db.prepare(
-            `INSERT OR REPLACE INTO file_hashes
-             (path, hash, size_bytes, updated_at) VALUES (?, ?, ?, ?)`
-        )
-        const now = Date.now()
-        const runAll = this.db.transaction((rows: typeof entries) => {
-            for (const row of rows) {
-                insert.run(row.path, row.hash, row.sizeBytes, now)
-            }
-        })
-        runAll(entries)
-    }
-
-    /** Close the database connection */
-    close(): void {
-        this.db.close()
-    }
-}
+import * as path from 'node:path'
+import * as fs from 'node:fs'
+import Database from 'better-sqlite3'
+import { logger } from '../utils/logger.js'
+
+const CREATE_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS file_hashes (
+  path        TEXT PRIMARY KEY,
+  hash        TEXT NOT NULL,
+  size_bytes  INTEGER NOT NULL,
+  updated_at  INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_updated_at ON file_hashes(updated_at);
+`
+
+/**
+ * HashStore — SQLite-backed persistent store for file content hashes.
+ *
+ * Survives process restarts, handles concurrent access via WAL mode,
+ * and provides fast O(1) lookups for change detection.
+ */
+export class HashStore {
+    private db: InstanceType<typeof Database>
+
+    constructor(projectRoot: string) {
+        const dbPath = path.join(projectRoot, '.mikk', 'cache', 'hashes.db')
+        const dbDir = path.dirname(dbPath)
+
+        // Ensure directory exists
+        if (!fs.existsSync(dbDir)) {
+            fs.mkdirSync(dbDir, { recursive: true })
+        }
+
+        this.db = this.openDatabase(dbPath)
+        this.db.exec(CREATE_SCHEMA_SQL)
+    }
+
+    private openDatabase(dbPath: string): InstanceType<typeof Database> {
+        try {
+            const db = new Database(dbPath)
+            // WAL mode: concurrent reads + writes, atomic commits
+            db.pragma('journal_mode = WAL')
+            // Wait up to 5s if locked by another process
+            db.pragma('busy_timeout = 5000')
+            return db
+        } catch (err: any) {
+            // Corrupted database — delete and recreate
+            logger.warn('Hash store corrupted, recreating', { error: err.message })
+            try {
+                fs.unlinkSync(dbPath)
+            } catch { /* ignore */ }
+            const db = new Database(dbPath)
+            db.pragma('journal_mode = WAL')
+            db.pragma('busy_timeout = 5000')
+            return db
+        }
+    }
+
+    /** Get the stored hash for a file path, or null if not tracked */
+    get(filePath: string): string | null {
+        const row = this.db
+            .prepare('SELECT hash FROM file_hashes WHERE path = ?')
+            .get(filePath) as { hash: string } | undefined
+        return row?.hash ?? null
+    }
+
+    /** Store or update the hash for a file */
+    set(filePath: string, hash: string, sizeBytes: number): void {
+        this.db
+            .prepare(
+                `INSERT OR REPLACE INTO file_hashes
+                 (path, hash, size_bytes, updated_at) VALUES (?, ?, ?, ?)`
+            )
+            .run(filePath, hash, sizeBytes, Date.now())
+    }
+
+    /** Remove tracked hash for a (deleted) file */
+    delete(filePath: string): void {
+        this.db
+            .prepare('DELETE FROM file_hashes WHERE path = ?')
+            .run(filePath)
+    }
+
+    /** Return all paths whose updated_at is greater than a timestamp */
+    getChangedSince(timestamp: number): string[] {
+        const rows = this.db
+            .prepare('SELECT path FROM file_hashes WHERE updated_at > ?')
+            .all(timestamp) as { path: string }[]
+        return rows.map(r => r.path)
+    }
+
+    /** Return all tracked file paths */
+    getAllPaths(): string[] {
+        const rows = this.db
+            .prepare('SELECT path FROM file_hashes')
+            .all() as { path: string }[]
+        return rows.map(r => r.path)
+    }
+
+    /** Batch-set multiple hashes inside a single transaction (fast for init) */
+    setBatch(entries: { path: string; hash: string; sizeBytes: number }[]): void {
+        const insert = this.db.prepare(
+            `INSERT OR REPLACE INTO file_hashes
+             (path, hash, size_bytes, updated_at) VALUES (?, ?, ?, ?)`
+        )
+        const now = Date.now()
+        const runAll = this.db.transaction((rows: typeof entries) => {
+            for (const row of rows) {
+                insert.run(row.path, row.hash, row.sizeBytes, now)
+            }
+        })
+        runAll(entries)
+    }
+
+    /** Close the database connection */
+    close(): void {
+        this.db.close()
+    }
+}

package/src/hash/index.ts

@@ -1,3 +1,3 @@
-export { hashContent, hashFile, hashFunctionBody } from './file-hasher.js'
-export { computeModuleHash, computeRootHash } from './tree-hasher.js'
-export { HashStore } from './hash-store.js'
+export { hashContent, hashFile, hashFunctionBody } from './file-hasher.js'
+export { computeModuleHash, computeRootHash } from './tree-hasher.js'
+export { HashStore } from './hash-store.js'

package/src/hash/tree-hasher.ts

@@ -1,20 +1,20 @@
-import { hashContent } from './file-hasher.js'
-
-/**
- * Compute Merkle tree hash for a module from its file hashes.
- * Sort to ensure order doesn't matter.
- */
-export function computeModuleHash(fileHashes: string[]): string {
-    const sorted = [...fileHashes].sort()
-    return hashContent(sorted.join(''))
-}
-
-/**
- * Compute root hash from all module hashes.
- */
-export function computeRootHash(moduleHashes: Record<string, string>): string {
-    const sorted = Object.entries(moduleHashes)
-        .sort(([a], [b]) => a.localeCompare(b))
-        .map(([, hash]) => hash)
-    return hashContent(sorted.join(''))
-}
+import { hashContent } from './file-hasher.js'
+
+/**
+ * Compute Merkle tree hash for a module from its file hashes.
+ * Sort to ensure order doesn't matter.
+ */
+export function computeModuleHash(fileHashes: string[]): string {
+    const sorted = [...fileHashes].sort()
+    return hashContent(sorted.join(''))
+}
+
+/**
+ * Compute root hash from all module hashes.
+ */
+export function computeRootHash(moduleHashes: Record<string, string>): string {
+    const sorted = Object.entries(moduleHashes)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([, hash]) => hash)
+    return hashContent(sorted.join(''))
+}

package/src/index.ts

@@ -1,12 +1,12 @@
-// @getmikk/core — Public API
-// Every other package imports from '@getmikk/core'
-
-export * from './parser/index.js'
-export * from './graph/index.js'
-export * from './contract/index.js'
-export * from './hash/index.js'
-export * from './utils/errors.js'
-export * from './utils/logger.js'
-export { discoverFiles, readFileContent, writeFileContent, fileExists, setupMikkDirectory } from './utils/fs.js'
-export { minimatch } from './utils/minimatch.js'
-export { scoreFunctions, findFuzzyMatches, levenshtein, splitCamelCase, extractKeywords } from './utils/fuzzy-match.js'
+// @getmikk/core — Public API
+// Every other package imports from '@getmikk/core'
+
+export * from './parser/index.js'
+export * from './graph/index.js'
+export * from './contract/index.js'
+export * from './hash/index.js'
+export * from './utils/errors.js'
+export * from './utils/logger.js'
+export { discoverFiles, readFileContent, writeFileContent, fileExists, setupMikkDirectory } 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

@@ -1,16 +1,16 @@
-import type { ParsedFile, ParsedImport } from './types.js'
-
-/**
- * Abstract base class all language parsers extend.
- * Forces consistency — every parser implements the same interface.
- */
-export abstract class BaseParser {
-    /** Given raw file content as a string, return ParsedFile */
-    abstract parse(filePath: string, content: string): ParsedFile
-
-    /** Given a list of parsed files, resolve all import paths to absolute project paths */
-    abstract resolveImports(files: ParsedFile[], projectRoot: string): ParsedFile[]
-
-    /** Returns which file extensions this parser handles */
-    abstract getSupportedExtensions(): string[]
-}
+import type { ParsedFile, ParsedImport } from './types.js'
+
+/**
+ * Abstract base class all language parsers extend.
+ * Forces consistency — every parser implements the same interface.
+ */
+export abstract class BaseParser {
+    /** Given raw file content as a string, return ParsedFile */
+    abstract parse(filePath: string, content: string): ParsedFile
+
+    /** Given a list of parsed files, resolve all import paths to absolute project paths */
+    abstract resolveImports(files: ParsedFile[], projectRoot: string): ParsedFile[]
+
+    /** Returns which file extensions this parser handles */
+    abstract getSupportedExtensions(): string[]
+}