@context-vault/core 3.1.6 → 3.1.8

package/src/config.ts

@@ -1,17 +1,17 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { homedir } from "node:os";
-import { DEFAULT_GROWTH_THRESHOLDS, DEFAULT_LIFECYCLE } from "./constants.js";
-import type { VaultConfig } from "./types.js";
+import { existsSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { DEFAULT_GROWTH_THRESHOLDS, DEFAULT_LIFECYCLE } from './constants.js';
+import type { VaultConfig } from './types.js';
 
 export function parseArgs(argv: string[]): Record<string, string | number> {
   const args: Record<string, string | number> = {};
   for (let i = 2; i < argv.length; i++) {
-    if (argv[i] === "--vault-dir" && argv[i + 1]) args.vaultDir = argv[++i];
-    else if (argv[i] === "--data-dir" && argv[i + 1]) args.dataDir = argv[++i];
-    else if (argv[i] === "--db-path" && argv[i + 1]) args.dbPath = argv[++i];
-    else if (argv[i] === "--dev-dir" && argv[i + 1]) args.devDir = argv[++i];
-    else if (argv[i] === "--event-decay-days" && argv[i + 1])
+    if (argv[i] === '--vault-dir' && argv[i + 1]) args.vaultDir = argv[++i];
+    else if (argv[i] === '--data-dir' && argv[i + 1]) args.dataDir = argv[++i];
+    else if (argv[i] === '--db-path' && argv[i + 1]) args.dbPath = argv[++i];
+    else if (argv[i] === '--dev-dir' && argv[i + 1]) args.devDir = argv[++i];
+    else if (argv[i] === '--event-decay-days' && argv[i + 1])
       args.eventDecayDays = Number(argv[++i]);
   }
   return args;
@@ -25,23 +25,23 @@ export function resolveConfig(): VaultConfig {
     (cliArgs.dataDir as string) ||
       process.env.CONTEXT_VAULT_DATA_DIR ||
       process.env.CONTEXT_MCP_DATA_DIR ||
-      join(HOME, ".context-mcp"),
+      join(HOME, '.context-mcp')
   );
   const config: VaultConfig = {
-    vaultDir: join(HOME, ".vault"),
+    vaultDir: join(HOME, '.vault'),
     dataDir,
-    dbPath: join(dataDir, "vault.db"),
-    devDir: join(HOME, "dev"),
+    dbPath: join(dataDir, 'vault.db'),
+    devDir: join(HOME, 'dev'),
     eventDecayDays: 30,
     thresholds: { ...DEFAULT_GROWTH_THRESHOLDS },
     telemetry: false,
-    resolvedFrom: "defaults",
+    resolvedFrom: 'defaults',
     recall: {
       maxResults: 5,
       maxOutputBytes: 2000,
       minRelevanceScore: 0.3,
       excludeKinds: [],
-      excludeCategories: ["event"],
+      excludeCategories: ['event'],
       bodyTruncateChars: 400,
     },
     consolidation: {
@@ -52,14 +52,14 @@ export function resolveConfig(): VaultConfig {
     lifecycle: structuredClone(DEFAULT_LIFECYCLE),
   };
 
-  const configPath = join(dataDir, "config.json");
+  const configPath = join(dataDir, 'config.json');
   if (existsSync(configPath)) {
     try {
-      const fc = JSON.parse(readFileSync(configPath, "utf-8"));
+      const fc = JSON.parse(readFileSync(configPath, 'utf-8'));
       if (fc.vaultDir) config.vaultDir = fc.vaultDir;
       if (fc.dataDir) {
         config.dataDir = fc.dataDir;
-        config.dbPath = join(resolve(fc.dataDir), "vault.db");
+        config.dbPath = join(resolve(fc.dataDir), 'vault.db');
       }
       if (fc.dbPath) config.dbPath = fc.dbPath;
       if (fc.devDir) config.devDir = fc.devDir;
@@ -94,100 +94,85 @@ export function resolveConfig(): VaultConfig {
           };
       }
       if (fc.telemetry != null) config.telemetry = fc.telemetry === true;
-      if (fc.recall && typeof fc.recall === "object") {
+      if (fc.recall && typeof fc.recall === 'object') {
         const r = fc.recall;
-        if (r.maxResults != null)
-          config.recall.maxResults = Number(r.maxResults);
-        if (r.maxOutputBytes != null)
-          config.recall.maxOutputBytes = Number(r.maxOutputBytes);
+        if (r.maxResults != null) config.recall.maxResults = Number(r.maxResults);
+        if (r.maxOutputBytes != null) config.recall.maxOutputBytes = Number(r.maxOutputBytes);
         if (r.minRelevanceScore != null)
           config.recall.minRelevanceScore = Number(r.minRelevanceScore);
-        if (Array.isArray(r.excludeKinds))
-          config.recall.excludeKinds = r.excludeKinds;
+        if (Array.isArray(r.excludeKinds)) config.recall.excludeKinds = r.excludeKinds;
         if (Array.isArray(r.excludeCategories))
           config.recall.excludeCategories = r.excludeCategories;
         if (r.bodyTruncateChars != null)
           config.recall.bodyTruncateChars = Number(r.bodyTruncateChars);
       }
-      if (fc.consolidation && typeof fc.consolidation === "object") {
+      if (fc.consolidation && typeof fc.consolidation === 'object') {
         const c = fc.consolidation;
-        if (c.tagThreshold != null)
-          config.consolidation.tagThreshold = Number(c.tagThreshold);
-        if (c.maxAgeDays != null)
-          config.consolidation.maxAgeDays = Number(c.maxAgeDays);
+        if (c.tagThreshold != null) config.consolidation.tagThreshold = Number(c.tagThreshold);
+        if (c.maxAgeDays != null) config.consolidation.maxAgeDays = Number(c.maxAgeDays);
         if (c.autoConsolidate != null)
           config.consolidation.autoConsolidate = c.autoConsolidate === true;
       }
-      if (fc.lifecycle && typeof fc.lifecycle === "object") {
+      if (fc.lifecycle && typeof fc.lifecycle === 'object') {
         for (const [tier, rules] of Object.entries(fc.lifecycle)) {
-          if (rules && typeof rules === "object") {
+          if (rules && typeof rules === 'object') {
             if (!config.lifecycle[tier]) config.lifecycle[tier] = {};
             if ((rules as Record<string, unknown>).archiveAfterDays != null)
               config.lifecycle[tier].archiveAfterDays = Number(
-                (rules as Record<string, unknown>).archiveAfterDays,
+                (rules as Record<string, unknown>).archiveAfterDays
               );
           }
         }
       }
-      config.resolvedFrom = "config file";
+      config.resolvedFrom = 'config file';
     } catch (e) {
-      throw new Error(
-        `[context-vault] Invalid config at ${configPath}: ${(e as Error).message}`,
-      );
+      throw new Error(`[context-vault] Invalid config at ${configPath}: ${(e as Error).message}`);
     }
   }
   config.configPath = configPath;
 
-  if (
-    process.env.CONTEXT_VAULT_VAULT_DIR ||
-    process.env.CONTEXT_MCP_VAULT_DIR
-  ) {
-    config.vaultDir =
-      process.env.CONTEXT_VAULT_VAULT_DIR || process.env.CONTEXT_MCP_VAULT_DIR!;
-    config.resolvedFrom = "env";
+  if (process.env.CONTEXT_VAULT_VAULT_DIR || process.env.CONTEXT_MCP_VAULT_DIR) {
+    config.vaultDir = process.env.CONTEXT_VAULT_VAULT_DIR || process.env.CONTEXT_MCP_VAULT_DIR!;
+    config.resolvedFrom = 'env';
   }
   if (process.env.CONTEXT_VAULT_DB_PATH || process.env.CONTEXT_MCP_DB_PATH) {
-    config.dbPath =
-      process.env.CONTEXT_VAULT_DB_PATH || process.env.CONTEXT_MCP_DB_PATH!;
-    config.resolvedFrom = "env";
+    config.dbPath = process.env.CONTEXT_VAULT_DB_PATH || process.env.CONTEXT_MCP_DB_PATH!;
+    config.resolvedFrom = 'env';
   }
   if (process.env.CONTEXT_VAULT_DEV_DIR || process.env.CONTEXT_MCP_DEV_DIR) {
-    config.devDir =
-      process.env.CONTEXT_VAULT_DEV_DIR || process.env.CONTEXT_MCP_DEV_DIR!;
-    config.resolvedFrom = "env";
+    config.devDir = process.env.CONTEXT_VAULT_DEV_DIR || process.env.CONTEXT_MCP_DEV_DIR!;
+    config.resolvedFrom = 'env';
   }
   if (
     process.env.CONTEXT_VAULT_EVENT_DECAY_DAYS != null ||
     process.env.CONTEXT_MCP_EVENT_DECAY_DAYS != null
   ) {
     config.eventDecayDays = Number(
-      process.env.CONTEXT_VAULT_EVENT_DECAY_DAYS ??
-        process.env.CONTEXT_MCP_EVENT_DECAY_DAYS,
+      process.env.CONTEXT_VAULT_EVENT_DECAY_DAYS ?? process.env.CONTEXT_MCP_EVENT_DECAY_DAYS
     );
-    config.resolvedFrom = "env";
+    config.resolvedFrom = 'env';
   }
 
   if (process.env.CONTEXT_VAULT_TELEMETRY !== undefined) {
     config.telemetry =
-      process.env.CONTEXT_VAULT_TELEMETRY === "1" ||
-      process.env.CONTEXT_VAULT_TELEMETRY === "true";
+      process.env.CONTEXT_VAULT_TELEMETRY === '1' || process.env.CONTEXT_VAULT_TELEMETRY === 'true';
   }
 
   if (cliArgs.vaultDir) {
     config.vaultDir = cliArgs.vaultDir as string;
-    config.resolvedFrom = "CLI args";
+    config.resolvedFrom = 'CLI args';
   }
   if (cliArgs.dbPath) {
     config.dbPath = cliArgs.dbPath as string;
-    config.resolvedFrom = "CLI args";
+    config.resolvedFrom = 'CLI args';
   }
   if (cliArgs.devDir) {
     config.devDir = cliArgs.devDir as string;
-    config.resolvedFrom = "CLI args";
+    config.resolvedFrom = 'CLI args';
   }
   if (cliArgs.eventDecayDays != null) {
     config.eventDecayDays = cliArgs.eventDecayDays as number;
-    config.resolvedFrom = "CLI args";
+    config.resolvedFrom = 'CLI args';
   }
 
   config.vaultDir = resolve(config.vaultDir);

package/src/constants.ts

@@ -1,8 +1,7 @@
-export const APP_URL = "https://app.context-vault.com";
-export const API_URL = "https://api.context-vault.com";
-export const MARKETING_URL = "https://contextvault.dev";
-export const GITHUB_ISSUES_URL =
-  "https://github.com/fellanH/context-vault/issues";
+export const APP_URL = 'https://app.context-vault.com';
+export const API_URL = 'https://api.context-vault.com';
+export const MARKETING_URL = 'https://context-vault.com';
+export const GITHUB_ISSUES_URL = 'https://github.com/fellanH/context-vault/issues';
 
 export const MAX_BODY_LENGTH = 100 * 1024;
 export const MAX_TITLE_LENGTH = 500;
@@ -20,8 +19,7 @@ export const DEFAULT_GROWTH_THRESHOLDS = {
   eventsWithoutTtl: { warn: 200 },
 };
 
-export const DEFAULT_LIFECYCLE: Record<string, { archiveAfterDays?: number }> =
-  {
-    event: { archiveAfterDays: 90 },
-    ephemeral: { archiveAfterDays: 30 },
-  };
+export const DEFAULT_LIFECYCLE: Record<string, { archiveAfterDays?: number }> = {
+  event: { archiveAfterDays: 90 },
+  ephemeral: { archiveAfterDays: 30 },
+};

package/src/db.ts

@@ -1,45 +1,45 @@
-import { unlinkSync, copyFileSync, existsSync } from "node:fs";
-import { DatabaseSync } from "node:sqlite";
-import type { PreparedStatements } from "./types.js";
+import { unlinkSync, copyFileSync, existsSync } from 'node:fs';
+import { DatabaseSync } from 'node:sqlite';
+import type { PreparedStatements } from './types.js';
 
 export class NativeModuleError extends Error {
   originalError: Error;
   constructor(originalError: Error) {
     const diagnostic = formatNativeModuleError(originalError);
     super(diagnostic);
-    this.name = "NativeModuleError";
+    this.name = 'NativeModuleError';
     this.originalError = originalError;
   }
 }
 
 function formatNativeModuleError(err: Error): string {
-  const msg = err.message || "";
+  const msg = err.message || '';
   return [
     `sqlite-vec extension failed to load: ${msg}`,
-    "",
+    '',
     `  Running Node.js: ${process.version} (${process.execPath})`,
-    "",
-    "  Fix: Reinstall context-vault:",
-    "    npx -y context-vault@latest setup",
-  ].join("\n");
+    '',
+    '  Fix: Reinstall context-vault:',
+    '    npx -y context-vault@latest setup',
+  ].join('\n');
 }
 
 let _sqliteVec: { load: (db: DatabaseSync) => void } | null = null;
 
 async function loadSqliteVec() {
   if (_sqliteVec) return _sqliteVec;
-  const vecMod = await import("sqlite-vec");
+  const vecMod = await import('sqlite-vec');
   _sqliteVec = vecMod;
   return _sqliteVec;
 }
 
 function runTransaction(db: DatabaseSync, fn: () => void): void {
-  db.exec("BEGIN");
+  db.exec('BEGIN');
   try {
     fn();
-    db.exec("COMMIT");
+    db.exec('COMMIT');
   } catch (e) {
-    db.exec("ROLLBACK");
+    db.exec('ROLLBACK');
     throw e;
   }
 }
@@ -105,9 +105,9 @@ export async function initDatabase(dbPath: string): Promise<DatabaseSync> {
 
   function createDb(path: string): DatabaseSync {
     const db = new DatabaseSync(path, { allowExtension: true });
-    db.exec("PRAGMA journal_mode = WAL");
-    db.exec("PRAGMA foreign_keys = ON");
-    db.exec("PRAGMA busy_timeout = 3000");
+    db.exec('PRAGMA journal_mode = WAL');
+    db.exec('PRAGMA foreign_keys = ON');
+    db.exec('PRAGMA busy_timeout = 3000');
     try {
       sqliteVec.load(db);
     } catch (e) {
@@ -117,14 +117,11 @@ export async function initDatabase(dbPath: string): Promise<DatabaseSync> {
   }
 
   const db = createDb(dbPath);
-  const version = (
-    db.prepare("PRAGMA user_version").get() as { user_version: number }
-  ).user_version;
+  const version = (db.prepare('PRAGMA user_version').get() as { user_version: number })
+    .user_version;
 
   if (version > 0 && version < 15) {
-    console.error(
-      `[context-vault] Schema v${version} is outdated. Rebuilding database...`,
-    );
+    console.error(`[context-vault] Schema v${version} is outdated. Rebuilding database...`);
 
     const backupPath = `${dbPath}.v${version}.backup`;
     let backupSucceeded = false;
@@ -132,32 +129,30 @@ export async function initDatabase(dbPath: string): Promise<DatabaseSync> {
       db.close();
       if (existsSync(dbPath)) {
         copyFileSync(dbPath, backupPath);
-        console.error(
-          `[context-vault] Backed up old database to: ${backupPath}`,
-        );
+        console.error(`[context-vault] Backed up old database to: ${backupPath}`);
         backupSucceeded = true;
       } else {
         backupSucceeded = true;
       }
     } catch (backupErr) {
       console.error(
-        `[context-vault] Warning: could not backup old database: ${(backupErr as Error).message}`,
+        `[context-vault] Warning: could not backup old database: ${(backupErr as Error).message}`
       );
     }
 
     if (!backupSucceeded) {
       throw new Error(
         `[context-vault] Aborting schema migration: backup failed for ${dbPath}. ` +
-          `Fix the backup issue or manually back up the file before upgrading.`,
+          `Fix the backup issue or manually back up the file before upgrading.`
       );
     }
 
     unlinkSync(dbPath);
     try {
-      unlinkSync(dbPath + "-wal");
+      unlinkSync(dbPath + '-wal');
     } catch {}
     try {
-      unlinkSync(dbPath + "-shm");
+      unlinkSync(dbPath + '-shm');
     } catch {}
 
     const freshDb = createDb(dbPath);
@@ -178,52 +173,38 @@ export function prepareStatements(db: DatabaseSync): PreparedStatements {
   try {
     return {
       insertEntry: db.prepare(
-        `INSERT INTO vault (id, kind, category, title, body, meta, tags, source, file_path, identity_key, expires_at, created_at, updated_at, source_files, tier) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        `INSERT INTO vault (id, kind, category, title, body, meta, tags, source, file_path, identity_key, expires_at, created_at, updated_at, source_files, tier) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
       ),
       updateEntry: db.prepare(
-        `UPDATE vault SET title = ?, body = ?, meta = ?, tags = ?, source = ?, category = ?, identity_key = ?, expires_at = ?, updated_at = datetime('now') WHERE file_path = ?`,
+        `UPDATE vault SET title = ?, body = ?, meta = ?, tags = ?, source = ?, category = ?, identity_key = ?, expires_at = ?, updated_at = datetime('now') WHERE file_path = ?`
       ),
       deleteEntry: db.prepare(`DELETE FROM vault WHERE id = ?`),
       getRowid: db.prepare(`SELECT rowid FROM vault WHERE id = ?`),
       getRowidByPath: db.prepare(`SELECT rowid FROM vault WHERE file_path = ?`),
       getEntryById: db.prepare(`SELECT * FROM vault WHERE id = ?`),
-      getByIdentityKey: db.prepare(
-        `SELECT * FROM vault WHERE kind = ? AND identity_key = ?`,
-      ),
+      getByIdentityKey: db.prepare(`SELECT * FROM vault WHERE kind = ? AND identity_key = ?`),
       upsertByIdentityKey: db.prepare(
-        `UPDATE vault SET title = ?, body = ?, meta = ?, tags = ?, source = ?, category = ?, file_path = ?, expires_at = ?, source_files = ?, updated_at = datetime('now') WHERE kind = ? AND identity_key = ?`,
-      ),
-      updateSourceFiles: db.prepare(
-        `UPDATE vault SET source_files = ? WHERE id = ?`,
-      ),
-      updateRelatedTo: db.prepare(
-        `UPDATE vault SET related_to = ? WHERE id = ?`,
-      ),
-      insertVecStmt: db.prepare(
-        `INSERT INTO vault_vec (rowid, embedding) VALUES (?, ?)`,
+        `UPDATE vault SET title = ?, body = ?, meta = ?, tags = ?, source = ?, category = ?, file_path = ?, expires_at = ?, source_files = ?, updated_at = datetime('now') WHERE kind = ? AND identity_key = ?`
       ),
+      updateSourceFiles: db.prepare(`UPDATE vault SET source_files = ? WHERE id = ?`),
+      updateRelatedTo: db.prepare(`UPDATE vault SET related_to = ? WHERE id = ?`),
+      insertVecStmt: db.prepare(`INSERT INTO vault_vec (rowid, embedding) VALUES (?, ?)`),
       deleteVecStmt: db.prepare(`DELETE FROM vault_vec WHERE rowid = ?`),
-      updateSupersededBy: db.prepare(
-        `UPDATE vault SET superseded_by = ? WHERE id = ?`,
-      ),
+      updateSupersededBy: db.prepare(`UPDATE vault SET superseded_by = ? WHERE id = ?`),
       clearSupersededByRef: db.prepare(
-        `UPDATE vault SET superseded_by = NULL WHERE superseded_by = ?`,
+        `UPDATE vault SET superseded_by = NULL WHERE superseded_by = ?`
       ),
     };
   } catch (e) {
     throw new Error(
       `Failed to prepare database statements. The database may be corrupted.\n` +
         `Try deleting and rebuilding: context-vault reindex\n` +
-        `Original error: ${(e as Error).message}`,
+        `Original error: ${(e as Error).message}`
     );
   }
 }
 
-export function insertVec(
-  stmts: PreparedStatements,
-  rowid: number,
-  embedding: Float32Array,
-): void {
+export function insertVec(stmts: PreparedStatements, rowid: number, embedding: Float32Array): void {
   const safeRowid = BigInt(rowid);
   if (safeRowid < 1n) throw new Error(`Invalid rowid: ${rowid}`);
   stmts.insertVecStmt.run(safeRowid, embedding);
@@ -237,7 +218,7 @@ export function deleteVec(stmts: PreparedStatements, rowid: number): void {
 
 export function testConnection(db: DatabaseSync): boolean {
   try {
-    db.prepare("SELECT 1").get();
+    db.prepare('SELECT 1').get();
     return true;
   } catch {
     return false;

package/src/embed.ts

@@ -1,6 +1,6 @@
-import { join } from "node:path";
-import { homedir } from "node:os";
-import { mkdirSync } from "node:fs";
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { mkdirSync } from 'node:fs';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 let extractor: any = null;
@@ -14,29 +14,20 @@ async function ensurePipeline(): Promise<typeof extractor> {
 
   loadingPromise = (async () => {
     try {
-      const { pipeline, env } = await import("@huggingface/transformers");
+      const { pipeline, env } = await import('@huggingface/transformers');
 
-      const modelCacheDir = join(homedir(), ".context-mcp", "models");
+      const modelCacheDir = join(homedir(), '.context-mcp', 'models');
       mkdirSync(modelCacheDir, { recursive: true });
       env.cacheDir = modelCacheDir;
 
-      console.error(
-        "[context-vault] Loading embedding model (first run may download ~22MB)...",
-      );
-      extractor = await pipeline(
-        "feature-extraction",
-        "Xenova/all-MiniLM-L6-v2",
-      );
+      console.error('[context-vault] Loading embedding model (first run may download ~22MB)...');
+      extractor = await pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2');
       embedAvailable = true;
       return extractor;
     } catch (e) {
       embedAvailable = false;
-      console.error(
-        `[context-vault] Failed to load embedding model: ${(e as Error).message}`,
-      );
-      console.error(
-        `[context-vault] Semantic search disabled. Full-text search still works.`,
-      );
+      console.error(`[context-vault] Failed to load embedding model: ${(e as Error).message}`);
+      console.error(`[context-vault] Semantic search disabled. Full-text search still works.`);
       return null;
     } finally {
       loadingPromise = null;
@@ -50,34 +41,32 @@ export async function embed(text: string): Promise<Float32Array | null> {
   const ext = await ensurePipeline();
   if (!ext) return null;
 
-  const result = await ext([text], { pooling: "mean", normalize: true });
+  const result = await ext([text], { pooling: 'mean', normalize: true });
   if (!result?.data?.length) {
     extractor = null;
     embedAvailable = null;
     loadingPromise = null;
-    throw new Error("Embedding pipeline returned empty result");
+    throw new Error('Embedding pipeline returned empty result');
   }
   return new Float32Array(result.data);
 }
 
-export async function embedBatch(
-  texts: string[],
-): Promise<(Float32Array | null)[]> {
+export async function embedBatch(texts: string[]): Promise<(Float32Array | null)[]> {
   if (!texts.length) return [];
   const ext = await ensurePipeline();
   if (!ext) return texts.map(() => null);
 
-  const result = await ext(texts, { pooling: "mean", normalize: true });
+  const result = await ext(texts, { pooling: 'mean', normalize: true });
   if (!result?.data?.length) {
     extractor = null;
     embedAvailable = null;
     loadingPromise = null;
-    throw new Error("Embedding pipeline returned empty result");
+    throw new Error('Embedding pipeline returned empty result');
   }
   const dim = result.data.length / texts.length;
   if (!Number.isInteger(dim) || dim <= 0) {
     throw new Error(
-      `Unexpected embedding dimension: ${result.data.length} / ${texts.length} = ${dim}`,
+      `Unexpected embedding dimension: ${result.data.length} / ${texts.length} = ${dim}`
     );
   }
   return texts.map((_, i) => result.data.subarray(i * dim, (i + 1) * dim));

package/src/files.ts

@@ -1,18 +1,18 @@
-import { readdirSync } from "node:fs";
-import { join, resolve, sep } from "node:path";
-import { categoryDirFor } from "./categories.js";
+import { readdirSync } from 'node:fs';
+import { join, resolve, sep } from 'node:path';
+import { categoryDirFor } from './categories.js';
 
-const CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+const CROCKFORD = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
 
 export function ulid(): string {
   const now = Date.now();
-  let ts = "";
+  let ts = '';
   let t = now;
   for (let i = 0; i < 10; i++) {
     ts = CROCKFORD[t & 31] + ts;
     t = Math.floor(t / 32);
   }
-  let rand = "";
+  let rand = '';
   for (let i = 0; i < 16; i++) {
     rand += CROCKFORD[Math.floor(Math.random() * 32)];
   }
@@ -22,11 +22,10 @@ export function ulid(): string {
 export function slugify(text: string, maxLen = 60): string {
   let slug = text
     .toLowerCase()
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-+|-+$/g, "");
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
   if (slug.length > maxLen) {
-    slug =
-      slug.slice(0, maxLen).replace(/-[^-]*$/, "") || slug.slice(0, maxLen);
+    slug = slug.slice(0, maxLen).replace(/-[^-]*$/, '') || slug.slice(0, maxLen);
   }
   return slug;
 }
@@ -51,9 +50,7 @@ export function safeJoin(base: string, ...parts: string[]): string {
   const resolvedBase = resolve(base);
   const result = resolve(join(base, ...parts));
   if (!result.startsWith(resolvedBase + sep) && result !== resolvedBase) {
-    throw new Error(
-      `Path traversal blocked: resolved path escapes base directory`,
-    );
+    throw new Error(`Path traversal blocked: resolved path escapes base directory`);
   }
   return result;
 }
@@ -68,13 +65,13 @@ export function walkDir(dir: string): WalkResult[] {
   function walk(currentDir: string, relDir: string) {
     for (const entry of readdirSync(currentDir, { withFileTypes: true })) {
       const fullPath = join(currentDir, entry.name);
-      if (entry.isDirectory() && !entry.name.startsWith("_")) {
+      if (entry.isDirectory() && !entry.name.startsWith('_')) {
         walk(fullPath, relDir ? join(relDir, entry.name) : entry.name);
-      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+      } else if (entry.isFile() && entry.name.endsWith('.md')) {
         results.push({ filePath: fullPath, relDir });
       }
     }
   }
-  walk(dir, "");
+  walk(dir, '');
   return results;
 }

package/src/formatters.ts

@@ -5,22 +5,22 @@ interface FormatInput {
 }
 
 const FORMATTERS: Record<string, (input: FormatInput) => string> = {
-  insight: ({ body }) => "\n" + body + "\n",
+  insight: ({ body }) => '\n' + body + '\n',
 
   decision: ({ title, body }) => {
     const t = title || body.slice(0, 80);
-    return "\n## Decision\n\n" + t + "\n\n## Rationale\n\n" + body + "\n";
+    return '\n## Decision\n\n' + t + '\n\n## Rationale\n\n' + body + '\n';
   },
 
   pattern: ({ title, body, meta }) => {
     const t = title || body.slice(0, 80);
-    const lang = (meta?.language as string) || "";
-    return "\n# " + t + "\n\n```" + lang + "\n" + body + "\n```\n";
+    const lang = (meta?.language as string) || '';
+    return '\n# ' + t + '\n\n```' + lang + '\n' + body + '\n```\n';
   },
 };
 
 const DEFAULT_FORMATTER = ({ title, body }: FormatInput): string =>
-  title ? "\n# " + title + "\n\n" + body + "\n" : "\n" + body + "\n";
+  title ? '\n# ' + title + '\n\n' + body + '\n' : '\n' + body + '\n';
 
 export function formatBody(kind: string, input: FormatInput): string {
   const fn = FORMATTERS[kind] || DEFAULT_FORMATTER;