@titan-design/brain 0.2.0

package/dist/cli.js

@@ -0,0 +1,2114 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command as Command11 } from "@commander-js/extra-typings";
+
+// src/commands/init.ts
+import { Command } from "@commander-js/extra-typings";
+import { mkdirSync as mkdirSync2, existsSync as existsSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+import { execSync } from "child_process";
+import { createInterface } from "readline";
+
+// src/services/config.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import envPaths from "env-paths";
+var paths = envPaths("brain", { suffix: "" });
+var VALID_EMBEDDERS = ["local", "ollama", "remote"];
+function ensureDir(dir) {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+function validateConfig(config) {
+  if (config.embedder !== void 0 && !VALID_EMBEDDERS.includes(config.embedder)) {
+    throw new Error(
+      `Invalid embedder "${config.embedder}". Must be one of: ${VALID_EMBEDDERS.join(", ")}`
+    );
+  }
+  if (config.fusionWeights !== void 0) {
+    const sum = config.fusionWeights.bm25 + config.fusionWeights.vector;
+    if (Math.abs(sum - 1) > 1e-6) {
+      throw new Error(
+        `Fusion weights must sum to 1.0, got ${sum} (bm25: ${config.fusionWeights.bm25}, vector: ${config.fusionWeights.vector})`
+      );
+    }
+  }
+}
+function getConfigDir(override) {
+  const dir = override ?? paths.config;
+  ensureDir(dir);
+  return dir;
+}
+function getDataDir(override) {
+  const dir = override ?? paths.data;
+  ensureDir(dir);
+  return dir;
+}
+function getConfigPath(configDir) {
+  return join(getConfigDir(configDir), "config.json");
+}
+function getDefaultConfig(dataDir) {
+  return {
+    notesDir: join(homedir(), "brain"),
+    dbPath: join(getDataDir(dataDir), "brain.db"),
+    embedder: "local",
+    fusionWeights: { bm25: 0.3, vector: 0.7 }
+  };
+}
+function loadConfig(configDir, dataDir) {
+  const defaults = getDefaultConfig(dataDir);
+  const filePath = getConfigPath(configDir);
+  if (!existsSync(filePath)) {
+    return defaults;
+  }
+  const raw = JSON.parse(readFileSync(filePath, "utf-8"));
+  return {
+    ...defaults,
+    ...raw,
+    fusionWeights: {
+      ...defaults.fusionWeights,
+      ...raw.fusionWeights
+    }
+  };
+}
+function saveConfig(config, configDir, dataDir) {
+  validateConfig(config);
+  const existing = loadConfig(configDir, dataDir);
+  const merged = {
+    ...existing,
+    ...config,
+    fusionWeights: {
+      ...existing.fusionWeights,
+      ...config.fusionWeights
+    }
+  };
+  const filePath = getConfigPath(configDir);
+  writeFileSync(filePath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+}
+
+// src/services/brain-db.ts
+import Database from "better-sqlite3";
+import * as sqliteVec from "sqlite-vec";
+var SCHEMA_VERSION = 2;
+var BrainDB = class {
+  db;
+  vectorDimensions = null;
+  constructor(dbPath) {
+    this.db = new Database(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+    sqliteVec.load(this.db);
+    this.migrate();
+  }
+  close() {
+    this.db.close();
+  }
+  // --- Schema Migration ---
+  migrate() {
+    const currentVersion = this.db.pragma("user_version", { simple: true });
+    if (currentVersion < 1) {
+      this.db.exec(this.schemaV1());
+      this.db.pragma(`user_version = ${SCHEMA_VERSION}`);
+      this.setMetaValue("schema_version", String(SCHEMA_VERSION));
+    }
+    if (currentVersion >= 1 && currentVersion < 2) {
+      this.db.exec("CREATE INDEX IF NOT EXISTS idx_chunks_note_id ON chunks(note_id)");
+      this.db.pragma("user_version = 2");
+      this.setMetaValue("schema_version", "2");
+    }
+    const dims = this.getMetaValue("embedding_dimensions");
+    if (dims) {
+      this.ensureVectorTable(Number(dims));
+    }
+  }
+  ensureVectorTable(dimensions) {
+    if (this.vectorDimensions === dimensions) return;
+    const existing = this.getMetaValue("embedding_dimensions");
+    if (existing && Number(existing) !== dimensions) {
+      this.db.exec("DROP TABLE IF EXISTS chunk_vectors");
+    }
+    this.db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS chunk_vectors USING vec0(
+        chunk_id TEXT PRIMARY KEY,
+        embedding float[${dimensions}]
+      )
+    `);
+    this.vectorDimensions = dimensions;
+  }
+  schemaV1() {
+    return `
+      CREATE TABLE IF NOT EXISTS files (
+        path        TEXT PRIMARY KEY,
+        hash        TEXT NOT NULL,
+        mtime       INTEGER NOT NULL,
+        indexed_at  INTEGER NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS notes (
+        id            TEXT PRIMARY KEY,
+        file_path     TEXT NOT NULL UNIQUE,
+        title         TEXT NOT NULL,
+        type          TEXT NOT NULL,
+        tier          TEXT NOT NULL,
+        category      TEXT,
+        tags          TEXT,
+        summary       TEXT,
+        confidence    TEXT,
+        status        TEXT DEFAULT 'current',
+        sources       TEXT,
+        created_at    TEXT,
+        modified_at   TEXT,
+        last_reviewed TEXT,
+        review_interval TEXT,
+        expires       TEXT,
+        metadata      TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS relations (
+        source_id   TEXT NOT NULL,
+        target_id   TEXT NOT NULL,
+        type        TEXT NOT NULL,
+        created_at  INTEGER NOT NULL,
+        PRIMARY KEY (source_id, target_id, type)
+      );
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS notes_fts USING fts5(
+        note_id UNINDEXED,
+        title,
+        summary,
+        content,
+        tokenize='unicode61'
+      );
+
+      CREATE TABLE IF NOT EXISTS chunks (
+        id          TEXT PRIMARY KEY,
+        note_id     TEXT NOT NULL,
+        heading     TEXT,
+        content     TEXT NOT NULL,
+        token_count INTEGER,
+        chunk_type  TEXT DEFAULT 'section',
+        FOREIGN KEY (note_id) REFERENCES notes(id)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_chunks_note_id ON chunks(note_id);
+
+      CREATE TABLE IF NOT EXISTS db_meta (
+        key   TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+    `;
+  }
+  // --- Meta ---
+  setMetaValue(key, value) {
+    this.db.prepare("INSERT OR REPLACE INTO db_meta (key, value) VALUES (?, ?)").run(key, value);
+  }
+  getMetaValue(key) {
+    const row = this.db.prepare("SELECT value FROM db_meta WHERE key = ?").get(key);
+    return row?.value ?? null;
+  }
+  // --- Embedding Model ---
+  setEmbeddingModel(model, dimensions) {
+    this.setMetaValue("embedding_model", model);
+    this.setMetaValue("embedding_dimensions", String(dimensions));
+    this.ensureVectorTable(dimensions);
+  }
+  getEmbeddingModel() {
+    const model = this.getMetaValue("embedding_model");
+    const dims = this.getMetaValue("embedding_dimensions");
+    if (!model || !dims) return null;
+    return { model, dimensions: Number(dims) };
+  }
+  checkModelMatch(model) {
+    const stored = this.getEmbeddingModel();
+    if (!stored) return;
+    if (stored.model !== model) {
+      throw new Error(
+        `Embedding model mismatch: DB uses "${stored.model}" but "${model}" was requested. Re-index with --force to switch models.`
+      );
+    }
+  }
+  // --- Table Introspection ---
+  listTables() {
+    const rows = this.db.prepare("SELECT name FROM sqlite_master WHERE type IN ('table', 'view') AND name NOT LIKE 'sqlite_%'").all();
+    return rows.map((r) => r.name);
+  }
+  // --- Note CRUD ---
+  upsertNote(record) {
+    this.db.prepare(
+      `INSERT OR REPLACE INTO notes
+          (id, file_path, title, type, tier, category, tags, summary, confidence, status, sources, created_at, modified_at, last_reviewed, review_interval, expires, metadata)
+        VALUES
+          (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      record.id,
+      record.filePath,
+      record.title,
+      record.type,
+      record.tier,
+      record.category,
+      record.tags,
+      record.summary,
+      record.confidence,
+      record.status,
+      record.sources,
+      record.createdAt,
+      record.modifiedAt,
+      record.lastReviewed,
+      record.reviewInterval,
+      record.expires,
+      record.metadata
+    );
+    return record;
+  }
+  getNoteById(id) {
+    const row = this.db.prepare("SELECT * FROM notes WHERE id = ?").get(id);
+    return row ? rowToNoteRecord(row) : null;
+  }
+  getAllNotes() {
+    const rows = this.db.prepare("SELECT * FROM notes").all();
+    return rows.map(rowToNoteRecord);
+  }
+  deleteNote(id) {
+    const txn = this.db.transaction(() => {
+      this.deleteChunksForNote(id);
+      this.db.prepare("DELETE FROM notes_fts WHERE note_id = ?").run(id);
+      this.db.prepare("DELETE FROM relations WHERE source_id = ? OR target_id = ?").run(id, id);
+      this.db.prepare("DELETE FROM notes WHERE id = ?").run(id);
+    });
+    txn();
+  }
+  // --- File Tracking ---
+  upsertFile(record) {
+    this.db.prepare(
+      `INSERT OR REPLACE INTO files (path, hash, mtime, indexed_at)
+         VALUES (?, ?, ?, ?)`
+    ).run(record.path, record.hash, record.mtime, record.indexedAt);
+  }
+  getFile(path) {
+    const row = this.db.prepare("SELECT * FROM files WHERE path = ?").get(path);
+    return row ? rowToFileRecord(row) : null;
+  }
+  getAllFiles() {
+    const rows = this.db.prepare("SELECT * FROM files").all();
+    const map = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const rec = rowToFileRecord(row);
+      map.set(rec.path, rec);
+    }
+    return map;
+  }
+  deleteFile(path) {
+    this.db.prepare("DELETE FROM files WHERE path = ?").run(path);
+  }
+  // --- Chunk + Vector Operations ---
+  upsertChunks(noteId, chunks, embeddings) {
+    if (embeddings.length > 0) {
+      this.ensureVectorTable(embeddings[0].length);
+    }
+    this.deleteChunksForNote(noteId);
+    const insertChunk = this.db.prepare(
+      `INSERT INTO chunks (id, note_id, heading, content, token_count, chunk_type)
+       VALUES (?, ?, ?, ?, ?, ?)`
+    );
+    const insertVector = this.db.prepare(
+      `INSERT INTO chunk_vectors (chunk_id, embedding)
+       VALUES (?, ?)`
+    );
+    const txn = this.db.transaction(() => {
+      for (let i = 0; i < chunks.length; i++) {
+        const chunk = chunks[i];
+        insertChunk.run(
+          chunk.id,
+          noteId,
+          chunk.heading,
+          chunk.content,
+          chunk.tokenCount,
+          chunk.chunkType
+        );
+        insertVector.run(
+          chunk.id,
+          Buffer.from(embeddings[i].buffer)
+        );
+      }
+    });
+    txn();
+  }
+  getChunksForNote(noteId) {
+    const rows = this.db.prepare("SELECT * FROM chunks WHERE note_id = ? ORDER BY rowid").all(noteId);
+    return rows.map(rowToChunk);
+  }
+  getChunkCount() {
+    const row = this.db.prepare("SELECT COUNT(*) as count FROM chunks").get();
+    return row.count;
+  }
+  deleteChunksForNote(noteId) {
+    const chunkIds = this.db.prepare("SELECT id FROM chunks WHERE note_id = ?").all(noteId);
+    if (chunkIds.length > 0) {
+      const deleteVec = this.db.prepare("DELETE FROM chunk_vectors WHERE chunk_id = ?");
+      const txn = this.db.transaction(() => {
+        for (const { id } of chunkIds) {
+          deleteVec.run(id);
+        }
+      });
+      txn();
+    }
+    this.db.prepare("DELETE FROM chunks WHERE note_id = ?").run(noteId);
+  }
+  // --- Relations ---
+  upsertRelations(noteId, relations) {
+    const txn = this.db.transaction(() => {
+      this.db.prepare("DELETE FROM relations WHERE source_id = ?").run(noteId);
+      const insert = this.db.prepare(
+        `INSERT INTO relations (source_id, target_id, type, created_at)
+         VALUES (?, ?, ?, ?)`
+      );
+      for (const rel of relations) {
+        insert.run(rel.sourceId, rel.targetId, rel.type, Date.now());
+      }
+    });
+    txn();
+  }
+  getRelationsFrom(noteId) {
+    const rows = this.db.prepare("SELECT source_id, target_id, type FROM relations WHERE source_id = ?").all(noteId);
+    return rows.map(rowToRelation);
+  }
+  getRelationsTo(noteId) {
+    const rows = this.db.prepare("SELECT source_id, target_id, type FROM relations WHERE target_id = ?").all(noteId);
+    return rows.map(rowToRelation);
+  }
+  // --- Search API ---
+  searchVector(embedding, limit) {
+    try {
+      return this.db.prepare(
+        `SELECT cv.chunk_id as chunkId, c.note_id as noteId, cv.distance
+         FROM chunk_vectors cv
+         JOIN chunks c ON c.id = cv.chunk_id
+         WHERE embedding MATCH ? AND k = ?
+         ORDER BY distance`
+      ).all(Buffer.from(embedding.buffer), limit);
+    } catch {
+      return [];
+    }
+  }
+  getFilteredNoteIds(filters) {
+    const conditions = [];
+    const params = [];
+    if (filters.tier) {
+      conditions.push("tier = ?");
+      params.push(filters.tier);
+    }
+    if (filters.category) {
+      conditions.push("category = ?");
+      params.push(filters.category);
+    }
+    if (filters.confidence) {
+      conditions.push("confidence = ?");
+      params.push(filters.confidence);
+    }
+    if (filters.since) {
+      conditions.push("modified_at >= ?");
+      params.push(filters.since);
+    }
+    if (filters.tags?.length) {
+      conditions.push(`(${filters.tags.map(() => "tags LIKE ?").join(" AND ")})`);
+      for (const tag of filters.tags) params.push(`%${tag}%`);
+    }
+    if (conditions.length === 0) return null;
+    const rows = this.db.prepare(
+      `SELECT id FROM notes WHERE ${conditions.join(" AND ")}`
+    ).all(...params);
+    return new Set(rows.map((r) => r.id));
+  }
+  getChunkContent(chunkId) {
+    const row = this.db.prepare("SELECT content FROM chunks WHERE id = ?").get(chunkId);
+    return row?.content ?? "";
+  }
+  getFirstChunkForNote(noteId) {
+    const row = this.db.prepare(
+      "SELECT content, heading FROM chunks WHERE note_id = ? ORDER BY rowid LIMIT 1"
+    ).get(noteId);
+    return row ?? null;
+  }
+  getChunkHeading(chunkId, noteId) {
+    if (chunkId) {
+      const row2 = this.db.prepare("SELECT heading FROM chunks WHERE id = ?").get(chunkId);
+      if (row2?.heading) return row2.heading;
+    }
+    const row = this.db.prepare(
+      "SELECT heading FROM chunks WHERE note_id = ? ORDER BY rowid LIMIT 1"
+    ).get(noteId);
+    return row?.heading ?? null;
+  }
+  getNoteByFilePath(filePath) {
+    const row = this.db.prepare("SELECT * FROM notes WHERE file_path = ?").get(filePath);
+    return row ? rowToNoteRecord(row) : null;
+  }
+  // --- FTS ---
+  upsertNoteFTS(noteId, title, summary, content) {
+    this.db.prepare("DELETE FROM notes_fts WHERE note_id = ?").run(noteId);
+    this.db.prepare("INSERT INTO notes_fts (note_id, title, summary, content) VALUES (?, ?, ?, ?)").run(noteId, title, summary, content);
+  }
+  searchFTS(query, limit) {
+    if (!query.trim()) return [];
+    const sanitized = sanitizeFtsQuery(query);
+    if (!sanitized) return [];
+    const rows = this.db.prepare(
+      `SELECT note_id as noteId, rank
+         FROM notes_fts
+         WHERE notes_fts MATCH ?
+         ORDER BY rank
+         LIMIT ?`
+    ).all(sanitized, limit);
+    return rows;
+  }
+};
+function sanitizeFtsQuery(query) {
+  return query.split(/\s+/).filter(Boolean).map((term) => `"${term.replace(/"/g, '""')}"`).join(" ");
+}
+function rowToNoteRecord(row) {
+  return {
+    id: row.id,
+    filePath: row.file_path,
+    title: row.title,
+    type: row.type,
+    tier: row.tier,
+    category: row.category,
+    tags: row.tags,
+    summary: row.summary,
+    confidence: row.confidence,
+    status: row.status ?? "current",
+    sources: row.sources,
+    createdAt: row.created_at,
+    modifiedAt: row.modified_at,
+    lastReviewed: row.last_reviewed,
+    reviewInterval: row.review_interval,
+    expires: row.expires,
+    metadata: row.metadata
+  };
+}
+function rowToFileRecord(row) {
+  return {
+    path: row.path,
+    hash: row.hash,
+    mtime: row.mtime,
+    indexedAt: row.indexed_at
+  };
+}
+function rowToChunk(row) {
+  return {
+    id: row.id,
+    noteId: row.note_id,
+    heading: row.heading,
+    content: row.content,
+    tokenCount: row.token_count,
+    chunkType: row.chunk_type
+  };
+}
+function rowToRelation(row) {
+  return {
+    sourceId: row.source_id,
+    targetId: row.target_id,
+    type: row.type
+  };
+}
+
+// src/adapters/local-embedder.ts
+import {
+  pipeline
+} from "@huggingface/transformers";
+var LocalEmbedder = class {
+  model = "bge-small-en-v1.5";
+  dimensions = 384;
+  extractor = null;
+  async embed(texts) {
+    if (!this.extractor) {
+      this.extractor = await pipeline(
+        "feature-extraction",
+        "Xenova/bge-small-en-v1.5",
+        { dtype: "q8" }
+      );
+    }
+    const output = await this.extractor(texts, {
+      pooling: "mean",
+      normalize: true
+    });
+    return output.tolist();
+  }
+};
+
+// src/adapters/ollama-embedder.ts
+import { Ollama } from "ollama";
+var OllamaEmbedder = class {
+  model = "nomic-embed-text";
+  dimensions = 768;
+  client;
+  constructor(url) {
+    this.client = url ? new Ollama({ host: url }) : new Ollama();
+  }
+  async embed(texts) {
+    const prefixed = texts.map((t) => `search_document: ${t}`);
+    try {
+      const response = await this.client.embed({
+        model: this.model,
+        input: prefixed
+      });
+      return response.embeddings;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `Ollama embedding failed: ${message}. Is Ollama running?`
+      );
+    }
+  }
+};
+
+// src/adapters/remote-embedder.ts
+var RemoteEmbedder = class {
+  constructor(url) {
+    this.url = url;
+  }
+  model = "nomic-embed-text";
+  dimensions = 768;
+  async embed(texts) {
+    const prefixed = texts.map((t) => `search_document: ${t}`);
+    const baseUrl = this.url.replace(/\/+$/, "");
+    let response;
+    try {
+      response = await fetch(`${baseUrl}/api/embed`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ model: this.model, input: prefixed }),
+        signal: AbortSignal.timeout(3e4)
+      });
+    } catch (err) {
+      if (err instanceof DOMException && err.name === "TimeoutError") {
+        throw new Error(`Remote embedding timed out after 30s (${baseUrl})`);
+      }
+      throw err;
+    }
+    if (!response.ok) {
+      throw new Error(
+        `Remote embedding failed: ${response.status} ${response.statusText}`
+      );
+    }
+    const data = await response.json();
+    return data.embeddings;
+  }
+};
+
+// src/adapters/index.ts
+function getEmbedderInfo(backend) {
+  switch (backend) {
+    case "local":
+      return { model: "bge-small-en-v1.5", dimensions: 384 };
+    case "ollama":
+      return { model: "nomic-embed-text", dimensions: 768 };
+    case "remote":
+      return { model: "nomic-embed-text", dimensions: 768 };
+    default:
+      throw new Error(`Unknown embedder backend: ${backend}`);
+  }
+}
+function createEmbedder(config) {
+  switch (config.embedder) {
+    case "local":
+      return new LocalEmbedder();
+    case "ollama":
+      return new OllamaEmbedder(config.ollamaUrl);
+    case "remote":
+      if (!config.ollamaUrl) {
+        throw new Error(
+          "ollamaUrl is required when using the remote embedder"
+        );
+      }
+      return new RemoteEmbedder(config.ollamaUrl);
+    default:
+      throw new Error(`Unknown embedder backend: ${config.embedder}`);
+  }
+}
+
+// src/commands/init.ts
+var SUBDIRS = [
+  "notes",
+  "decisions",
+  "research",
+  "patterns",
+  "logs",
+  "inbox",
+  "archive",
+  "_templates"
+];
+var TEMPLATES = {
+  "note.md": `---
+title: ""
+type: note
+tier: slow
+category: ""
+tags: []
+summary: ""
+confidence: medium
+status: draft
+created: "{{date}}"
+---
+
+# {{title}}
+
+`,
+  "decision.md": `---
+title: ""
+type: decision
+tier: slow
+category: ""
+tags: []
+summary: ""
+confidence: high
+status: current
+created: "{{date}}"
+---
+
+# {{title}}
+
+## Context
+
+## Decision
+
+## Consequences
+
+`,
+  "session-log.md": `---
+title: ""
+type: session-log
+tier: fast
+category: ""
+tags: []
+summary: ""
+date: "{{date}}"
+---
+
+# {{title}}
+
+## What I Did
+
+## What I Learned
+
+## Next Steps
+
+`
+};
+async function checkOllama(url, model) {
+  try {
+    const response = await fetch(`${url}/api/tags`, {
+      signal: AbortSignal.timeout(3e3)
+    });
+    if (!response.ok) return { running: false, hasModel: false };
+    const data = await response.json();
+    const hasModel = data.models?.some((m) => m.name.startsWith(model)) ?? false;
+    return { running: true, hasModel };
+  } catch {
+    return { running: false, hasModel: false };
+  }
+}
+function pullOllamaModel(model) {
+  try {
+    process.stderr.write(`Pulling ${model}...
+`);
+    execSync(`ollama pull ${model}`, { stdio: "inherit", timeout: 12e4 });
+    return true;
+  } catch {
+    process.stderr.write(`Warning: could not pull ${model}. Run "ollama pull ${model}" manually.
+`);
+    return false;
+  }
+}
+async function isLocalEmbedderAvailable() {
+  try {
+    await import("@huggingface/transformers");
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function promptEmbedderChoice() {
+  if (!process.stdin.isTTY) {
+    process.stderr.write(
+      "No embedding backend detected and stdin is not interactive.\nInstall Ollama (https://ollama.com) or run with --embedder local.\n"
+    );
+    return null;
+  }
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  const ask = (q) => new Promise((resolve2) => rl.question(q, resolve2));
+  process.stderr.write("\nNo embedding backend detected.\n");
+  process.stderr.write("  1. Install Ollama (opens ollama.com)\n");
+  process.stderr.write("  2. Use local embeddings (installs @huggingface/transformers)\n");
+  process.stderr.write("  3. Exit\n");
+  const choice = await ask("\nChoice [1/2/3]: ");
+  rl.close();
+  switch (choice.trim()) {
+    case "1": {
+      const openCmd = process.platform === "darwin" ? "open" : "xdg-open";
+      try {
+        execSync(`${openCmd} https://ollama.com`, { stdio: "ignore" });
+      } catch {
+      }
+      process.stderr.write('After installing Ollama, run "brain init" again.\n');
+      return null;
+    }
+    case "2": {
+      process.stderr.write("Installing @huggingface/transformers...\n");
+      try {
+        execSync("npm install -g @huggingface/transformers", {
+          stdio: "inherit",
+          timeout: 12e4
+        });
+        return "local";
+      } catch {
+        process.stderr.write(
+          'Failed to install. Run "npm install -g @huggingface/transformers" manually.\n'
+        );
+        return null;
+      }
+    }
+    default:
+      return null;
+  }
+}
+var initCommand = new Command("init").description("Initialize a new brain workspace").option("--notes-dir <path>", "path to notes directory").option("--embedder <type>", "embedding backend (local, ollama, remote)").option("--json", "output result as JSON").action(async (opts) => {
+  const overrides = {};
+  if (opts.notesDir) overrides.notesDir = opts.notesDir;
+  if (opts.embedder) overrides.embedder = opts.embedder;
+  if (!opts.embedder) {
+    const ollamaUrl = "http://localhost:11434";
+    const ollamaModel = "nomic-embed-text";
+    const status = await checkOllama(ollamaUrl, ollamaModel);
+    if (status.running) {
+      if (!status.hasModel) {
+        pullOllamaModel(ollamaModel);
+      }
+      overrides.embedder = "ollama";
+      overrides.ollamaUrl = ollamaUrl;
+    } else if (await isLocalEmbedderAvailable()) {
+      overrides.embedder = "local";
+    } else {
+      const choice = await promptEmbedderChoice();
+      if (!choice) {
+        process.exitCode = 1;
+        return;
+      }
+      overrides.embedder = choice;
+      if (choice === "ollama") {
+        overrides.ollamaUrl = "http://localhost:11434";
+      }
+    }
+  }
+  saveConfig(overrides);
+  const config = loadConfig();
+  const created = [];
+  for (const sub of SUBDIRS) {
+    const dir = join2(config.notesDir, sub);
+    if (!existsSync2(dir)) {
+      mkdirSync2(dir, { recursive: true });
+      created.push(sub);
+    }
+  }
+  const templatesDir = join2(config.notesDir, "_templates");
+  for (const [filename, content] of Object.entries(TEMPLATES)) {
+    const filePath = join2(templatesDir, filename);
+    if (!existsSync2(filePath)) {
+      writeFileSync2(filePath, content, "utf-8");
+    }
+  }
+  const db = new BrainDB(config.dbPath);
+  const info = getEmbedderInfo(config.embedder);
+  db.setEmbeddingModel(info.model, info.dimensions);
+  db.close();
+  const summary = {
+    notesDir: config.notesDir,
+    dbPath: config.dbPath,
+    embedder: config.embedder,
+    dirsCreated: created
+  };
+  if (opts.json) {
+    process.stdout.write(JSON.stringify(summary) + "\n");
+  } else {
+    process.stderr.write(`Initialized brain at ${config.notesDir}
+`);
+    process.stderr.write(`Database: ${config.dbPath}
+`);
+    process.stderr.write(`Embedder: ${config.embedder}
+`);
+    if (created.length > 0) {
+      process.stderr.write(`Created directories: ${created.join(", ")}
+`);
+    }
+  }
+});
+
+// src/commands/index-cmd.ts
+import { Command as Command2 } from "@commander-js/extra-typings";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
+import { basename, join as join3, relative } from "path";
+
+// src/services/file-scanner.ts
+import { createHash } from "crypto";
+import { readFile, stat } from "fs/promises";
+import { glob } from "glob";
+function hashContent(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+async function scanForChanges(rootDir, knownFiles) {
+  const result = {
+    new: [],
+    modified: [],
+    deleted: [],
+    unchanged: 0
+  };
+  const files = await glob("**/*.md", {
+    cwd: rootDir,
+    absolute: true,
+    ignore: ["**/node_modules/**", "**/.git/**"]
+  });
+  const seen = /* @__PURE__ */ new Set();
+  for (const filePath of files) {
+    seen.add(filePath);
+    const fileStat = await stat(filePath);
+    const mtime = fileStat.mtimeMs;
+    const known = knownFiles.get(filePath);
+    if (!known) {
+      const content2 = await readFile(filePath, "utf-8");
+      const hash2 = hashContent(content2);
+      result.new.push({ path: filePath, hash: hash2, mtime });
+      continue;
+    }
+    if (mtime === known.mtime) {
+      result.unchanged++;
+      continue;
+    }
+    const content = await readFile(filePath, "utf-8");
+    const hash = hashContent(content);
+    if (hash === known.hash) {
+      result.unchanged++;
+    } else {
+      result.modified.push({ path: filePath, hash, mtime });
+    }
+  }
+  for (const [path] of knownFiles) {
+    if (!seen.has(path)) {
+      result.deleted.push(path);
+    }
+  }
+  return result;
+}
+
+// src/services/markdown-parser.ts
+import matter from "gray-matter";
+var MAX_CHUNK_TOKENS = 512;
+var FENCE_OPEN = /^```/;
+var FENCE_CLOSE = /^```\s*$/;
+var MIN_CHUNK_LENGTH = 20;
+function estimateTokens(text) {
+  if (text.length === 0) return 0;
+  return Math.ceil(text.length / 4);
+}
+function parseMarkdown(filePath, content) {
+  const { data, content: body } = matter(content);
+  const id = deriveId(filePath, data);
+  const frontmatter = buildFrontmatter(filePath, data);
+  const chunks = chunkBody(body);
+  const relations = extractRelations(id, data);
+  return { id, filePath, frontmatter, content: body, chunks, relations };
+}
+function deriveId(filePath, data) {
+  if (typeof data.id === "string" && data.id.length > 0) return data.id;
+  const filename = filePath.split("/").pop() ?? filePath;
+  return filename.replace(/\.md$/, "");
+}
+function buildFrontmatter(filePath, data) {
+  const filename = (filePath.split("/").pop() ?? filePath).replace(/\.md$/, "");
+  return {
+    ...data,
+    title: typeof data.title === "string" ? data.title : filename,
+    type: data.type ?? "note",
+    tier: data.tier ?? "slow"
+  };
+}
+function splitIntoSections(body) {
+  const lines2 = body.split("\n");
+  const sections = [];
+  let current = { heading: null, lines: [] };
+  for (const line of lines2) {
+    const match = line.match(/^(#{1,3})\s+(.+)$/);
+    if (match) {
+      sections.push(current);
+      current = { heading: match[2], lines: [] };
+    } else {
+      current.lines.push(line);
+    }
+  }
+  sections.push(current);
+  return sections;
+}
+function chunkBody(body) {
+  const sections = splitIntoSections(body);
+  const chunks = [];
+  for (const section of sections) {
+    const text = section.lines.join("\n").trim();
+    if (text.length < MIN_CHUNK_LENGTH) continue;
+    const tokens = estimateTokens(text);
+    if (tokens <= MAX_CHUNK_TOKENS) {
+      chunks.push({ heading: section.heading, text, tokenCount: tokens });
+    } else {
+      const subChunks = splitOversizedSection(section.heading, text);
+      chunks.push(...subChunks);
+    }
+  }
+  return chunks;
+}
+function splitOversizedSection(heading, text) {
+  const paragraphs = splitParagraphsProtectingFences(text);
+  const chunks = [];
+  let buffer = "";
+  let overlapPrefix = "";
+  for (const para of paragraphs) {
+    const budgetForContent = overlapPrefix.length > 0 ? MAX_CHUNK_TOKENS - estimateTokens(overlapPrefix + "\n\n") : MAX_CHUNK_TOKENS;
+    const bufferWithPara = buffer.length > 0 ? buffer + "\n\n" + para : para;
+    if (estimateTokens(bufferWithPara) > budgetForContent && buffer.length > 0) {
+      const chunkText = overlapPrefix.length > 0 ? overlapPrefix + "\n\n" + buffer : buffer;
+      const tokenCount = estimateTokens(chunkText);
+      chunks.push({ heading, text: chunkText.trim(), tokenCount });
+      overlapPrefix = extractOverlap(buffer);
+      buffer = para;
+    } else {
+      buffer = buffer.length > 0 ? buffer + "\n\n" + para : para;
+    }
+  }
+  if (buffer.length > 0) {
+    const chunkText = overlapPrefix.length > 0 ? overlapPrefix + "\n\n" + buffer : buffer;
+    const tokenCount = estimateTokens(chunkText);
+    chunks.push({ heading, text: chunkText.trim(), tokenCount });
+  }
+  return chunks;
+}
+function extractOverlap(text) {
+  const targetTokens = Math.ceil(estimateTokens(text) * 0.1);
+  const targetChars = targetTokens * 4;
+  if (text.length <= targetChars) return text;
+  return text.slice(-targetChars);
+}
+function splitParagraphsProtectingFences(text) {
+  const lines2 = text.split("\n");
+  const paragraphs = [];
+  let current = [];
+  let inFence = false;
+  for (let i = 0; i < lines2.length; i++) {
+    const line = lines2[i];
+    if (!inFence && FENCE_OPEN.test(line)) {
+      if (current.length > 0) {
+        const joined2 = current.join("\n").trim();
+        if (joined2.length > 0) paragraphs.push(joined2);
+        current = [];
+      }
+      inFence = true;
+      current.push(line);
+      continue;
+    }
+    if (inFence) {
+      current.push(line);
+      if (FENCE_CLOSE.test(line) && current.length > 1) {
+        const joined2 = current.join("\n").trim();
+        if (joined2.length > 0) paragraphs.push(joined2);
+        current = [];
+        inFence = false;
+      }
+      continue;
+    }
+    if (line.trim() === "") {
+      if (current.length > 0) {
+        const joined2 = current.join("\n").trim();
+        if (joined2.length > 0) paragraphs.push(joined2);
+        current = [];
+      }
+    } else {
+      current.push(line);
+    }
+  }
+  const joined = current.join("\n").trim();
+  if (joined.length > 0) paragraphs.push(joined);
+  return paragraphs;
+}
+function extractRelations(sourceId, data) {
+  const relations = [];
+  if (Array.isArray(data.related)) {
+    for (const target of data.related) {
+      if (typeof target === "string") {
+        relations.push({
+          sourceId,
+          targetId: target,
+          type: "related-to"
+        });
+      }
+    }
+  }
+  if (typeof data.supersedes === "string") {
+    relations.push({
+      sourceId,
+      targetId: data.supersedes,
+      type: "supersedes"
+    });
+  }
+  if (typeof data.parent === "string") {
+    relations.push({
+      sourceId,
+      targetId: data.parent,
+      type: "parent"
+    });
+  }
+  return relations;
+}
+
+// src/commands/index-cmd.ts
+var indexCommand = new Command2("index").description("Index new and modified notes").option("--force", "force full re-index (clears all chunks/vectors)").option("--quiet", "suppress output").option("--json", "output result as JSON").action(async (opts) => {
+  const config = loadConfig();
+  const db = new BrainDB(config.dbPath);
+  const embedder = createEmbedder(config);
+  try {
+    if (!opts.force) {
+      db.checkModelMatch(embedder.model);
+    }
+    if (opts.force) {
+      const allNotes = db.getAllNotes();
+      for (const note of allNotes) {
+        db.deleteChunksForNote(note.id);
+      }
+    }
+    db.setEmbeddingModel(embedder.model, embedder.dimensions);
+    const knownFiles = opts.force ? /* @__PURE__ */ new Map() : db.getAllFiles();
+    const changes = await scanForChanges(config.notesDir, knownFiles);
+    const isSkipped = (filePath) => filePath.includes("/_templates/") || basename(filePath) === "_index.md";
+    let indexed = 0;
+    let deleted = 0;
+    const toProcess = [...changes.new, ...changes.modified].filter(
+      (f) => !isSkipped(f.path)
+    );
+    for (const file of toProcess) {
+      const content = readFileSync2(file.path, "utf-8");
+      const parsed = parseMarkdown(file.path, content);
+      const noteRecord = frontmatterToRecord(parsed);
+      db.upsertNote(noteRecord);
+      db.upsertNoteFTS(
+        parsed.id,
+        parsed.frontmatter.title,
+        parsed.frontmatter.summary ?? "",
+        parsed.content
+      );
+      const chunks = rawChunksToChunks(parsed.id, parsed.chunks);
+      if (chunks.length > 0) {
+        const texts = chunks.map((c) => c.content);
+        const embeddings = await embedder.embed(texts);
+        const vectors = embeddings.map((e) => new Float32Array(e));
+        db.upsertChunks(parsed.id, chunks, vectors);
+      }
+      if (parsed.relations.length > 0) {
+        db.upsertRelations(parsed.id, parsed.relations);
+      }
+      db.upsertFile({
+        path: file.path,
+        hash: file.hash,
+        mtime: file.mtime,
+        indexedAt: Date.now()
+      });
+      indexed++;
+    }
+    for (const filePath of changes.deleted.filter((p) => !isSkipped(p))) {
+      const allNotes = db.getAllNotes();
+      const note = allNotes.find((n) => n.filePath === filePath);
+      if (note) {
+        db.deleteNote(note.id);
+      }
+      db.deleteFile(filePath);
+      deleted++;
+    }
+    generateIndex(db, config.notesDir);
+    const summary = {
+      indexed,
+      deleted,
+      unchanged: changes.unchanged,
+      total: db.getAllNotes().length
+    };
+    if (opts.json) {
+      process.stdout.write(JSON.stringify(summary) + "\n");
+    } else if (!opts.quiet) {
+      process.stderr.write(
+        `Indexed ${indexed} file(s), deleted ${deleted}, unchanged ${changes.unchanged}
+`
+      );
+      process.stderr.write(`Total notes: ${summary.total}
+`);
+    }
+  } finally {
+    db.close();
+  }
+});
+function frontmatterToRecord(parsed) {
+  const fm = parsed.frontmatter;
+  return {
+    id: parsed.id,
+    filePath: parsed.filePath,
+    title: fm.title,
+    type: fm.type,
+    tier: fm.tier,
+    category: fm.category ?? null,
+    tags: fm.tags ? fm.tags.join(",") : null,
+    summary: fm.summary ?? null,
+    confidence: fm.confidence ?? null,
+    status: fm.status ?? "current",
+    sources: fm.sources ? JSON.stringify(fm.sources) : null,
+    createdAt: fm.created ?? null,
+    modifiedAt: fm.modified ?? null,
+    lastReviewed: fm["last-reviewed"] ?? null,
+    reviewInterval: fm["review-interval"] ?? null,
+    expires: fm.expires ?? null,
+    metadata: null
+  };
+}
+function rawChunksToChunks(noteId, rawChunks) {
+  return rawChunks.map((rc, i) => ({
+    id: `${noteId}::chunk-${i}`,
+    noteId,
+    heading: rc.heading,
+    content: rc.text,
+    tokenCount: rc.tokenCount,
+    chunkType: "section"
+  }));
+}
+function generateIndex(db, notesDir) {
+  const notes = db.getAllNotes();
+  if (notes.length === 0) return;
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const note of notes) {
+    const cat = note.category ?? "uncategorized";
+    const list = byCategory.get(cat) ?? [];
+    list.push(note);
+    byCategory.set(cat, list);
+  }
+  const lines2 = ["# Index", ""];
+  const sortedCategories = [...byCategory.keys()].sort();
+  for (const cat of sortedCategories) {
+    const catNotes = byCategory.get(cat);
+    lines2.push(`## ${cat}`, "");
+    for (const note of catNotes) {
+      const relPath = relative(notesDir, note.filePath);
+      const summary = note.summary ? ` \u2014 ${note.summary}` : "";
+      lines2.push(`- [${note.title}](${relPath})${summary}`);
+    }
+    lines2.push("");
+  }
+  writeFileSync3(join3(notesDir, "_index.md"), lines2.join("\n"), "utf-8");
+}
+
+// src/commands/search.ts
+import { Command as Command3 } from "@commander-js/extra-typings";
+
+// src/services/search.ts
+var RRF_K = 60;
+var EXCERPT_MAX_LENGTH = 200;
+var OVERFETCH_MULTIPLIER = 3;
+function truncateExcerpt(content) {
+  if (content.length <= EXCERPT_MAX_LENGTH) return content;
+  return content.slice(0, EXCERPT_MAX_LENGTH);
+}
+function parseTags(tagsStr) {
+  if (!tagsStr) return [];
+  return tagsStr.split(",").map((t) => t.trim()).filter(Boolean);
+}
+async function search(db, embedder, query, options, fusionWeights = { bm25: 0.3, vector: 0.7 }) {
+  if (!query.trim()) return [];
+  const limit = options.limit;
+  const overfetchLimit = limit * OVERFETCH_MULTIPLIER;
+  const allowedNoteIds = db.getFilteredNoteIds({
+    tier: options.tier,
+    category: options.category,
+    confidence: options.confidence,
+    since: options.since,
+    tags: options.tags
+  });
+  const ftsResults = db.searchFTS(query, overfetchLimit);
+  const filteredFts = allowedNoteIds ? ftsResults.filter((r) => allowedNoteIds.has(r.noteId)) : ftsResults;
+  const queryText = embedder.model.includes("nomic") ? `search_query: ${query}` : query;
+  const [queryEmbedding] = await embedder.embed([queryText]);
+  const queryVec = new Float32Array(queryEmbedding);
+  const vectorResults = db.searchVector(queryVec, overfetchLimit);
+  const filteredVector = allowedNoteIds ? vectorResults.filter((r) => allowedNoteIds.has(r.noteId)) : vectorResults;
+  const bestVectorByNote = /* @__PURE__ */ new Map();
+  for (const vr of filteredVector) {
+    const existing = bestVectorByNote.get(vr.noteId);
+    if (!existing || vr.distance < existing.distance) {
+      bestVectorByNote.set(vr.noteId, vr);
+    }
+  }
+  const fusionMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < filteredFts.length; i++) {
+    const { noteId } = filteredFts[i];
+    fusionMap.set(noteId, {
+      noteId,
+      bm25Rank: i + 1,
+      vectorRank: null,
+      chunkId: null
+    });
+  }
+  let vectorRank = 1;
+  for (const [noteId, vr] of bestVectorByNote) {
+    const existing = fusionMap.get(noteId);
+    if (existing) {
+      existing.vectorRank = vectorRank;
+      existing.chunkId = vr.chunkId;
+    } else {
+      fusionMap.set(noteId, {
+        noteId,
+        bm25Rank: null,
+        vectorRank,
+        chunkId: vr.chunkId
+      });
+    }
+    vectorRank++;
+  }
+  const scored = [];
+  for (const entry of fusionMap.values()) {
+    let score = 0;
+    if (entry.bm25Rank !== null) {
+      score += fusionWeights.bm25 * (1 / (RRF_K + entry.bm25Rank));
+    }
+    if (entry.vectorRank !== null) {
+      score += fusionWeights.vector * (1 / (RRF_K + entry.vectorRank));
+    }
+    scored.push({ noteId: entry.noteId, score, chunkId: entry.chunkId });
+  }
+  scored.sort((a, b) => b.score - a.score);
+  const topResults = scored.slice(0, limit);
+  const results = [];
+  for (const item of topResults) {
+    const note = db.getNoteById(item.noteId);
+    if (!note) continue;
+    const excerptContent = item.chunkId ? db.getChunkContent(item.chunkId) : db.getFirstChunkForNote(item.noteId)?.content ?? "";
+    results.push({
+      score: item.score,
+      filePath: note.filePath,
+      noteId: note.id,
+      heading: db.getChunkHeading(item.chunkId, item.noteId),
+      excerpt: truncateExcerpt(excerptContent),
+      tier: note.tier,
+      tags: parseTags(note.tags),
+      confidence: note.confidence
+    });
+  }
+  return results;
+}
+
+// src/services/graph.ts
+var MAX_DEPTH = 3;
+var BIDIRECTIONAL_TYPES = /* @__PURE__ */ new Set(["related-to"]);
+function traverseGraph(db, rootId, depth) {
+  const effectiveDepth = Math.min(depth, MAX_DEPTH);
+  const rootNote = db.getNoteById(rootId);
+  const root = {
+    id: rootId,
+    title: rootNote?.title ?? rootId,
+    type: rootNote?.type ?? "note",
+    tier: rootNote?.tier ?? "slow",
+    depth: 0
+  };
+  const visited = /* @__PURE__ */ new Map();
+  visited.set(rootId, 0);
+  const allEdges = [];
+  const frontier = [rootId];
+  for (let d = 0; d < effectiveDepth; d++) {
+    const nextFrontier = [];
+    for (const nodeId of frontier) {
+      const outgoing = db.getRelationsFrom(nodeId);
+      for (const rel of outgoing) {
+        allEdges.push(rel);
+        if (!visited.has(rel.targetId)) {
+          visited.set(rel.targetId, d + 1);
+          nextFrontier.push(rel.targetId);
+        }
+      }
+      const incoming = db.getRelationsTo(nodeId);
+      for (const rel of incoming) {
+        if (!BIDIRECTIONAL_TYPES.has(rel.type)) continue;
+        allEdges.push(rel);
+        if (!visited.has(rel.sourceId)) {
+          visited.set(rel.sourceId, d + 1);
+          nextFrontier.push(rel.sourceId);
+        }
+      }
+    }
+    frontier.length = 0;
+    frontier.push(...nextFrontier);
+  }
+  const nodes = [];
+  for (const [id, nodeDepth] of visited) {
+    const note = id === rootId ? rootNote : db.getNoteById(id);
+    nodes.push({
+      id,
+      title: note?.title ?? id,
+      type: note?.type ?? "note",
+      tier: note?.tier ?? "slow",
+      depth: nodeDepth
+    });
+  }
+  const nodeIds = new Set(visited.keys());
+  const edges = deduplicateEdges(
+    allEdges.filter((e) => nodeIds.has(e.sourceId) && nodeIds.has(e.targetId))
+  );
+  return { root, nodes, edges };
+}
+function expandResults(db, noteIds, depth) {
+  if (noteIds.length === 0) return [];
+  const inputSet = new Set(noteIds);
+  const scoreMap = /* @__PURE__ */ new Map();
+  for (const noteId of noteIds) {
+    const result = traverseGraph(db, noteId, depth);
+    for (const node of result.nodes) {
+      if (inputSet.has(node.id)) continue;
+      const decayed = Math.pow(0.5, node.depth);
+      const existing = scoreMap.get(node.id) ?? 0;
+      scoreMap.set(node.id, Math.max(existing, decayed));
+    }
+  }
+  return Array.from(scoreMap.entries()).map(([noteId, decayedScore]) => ({ noteId, decayedScore })).sort((a, b) => b.decayedScore - a.decayedScore);
+}
+function deduplicateEdges(edges) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const edge of edges) {
+    const key = `${edge.sourceId}|${edge.targetId}|${edge.type}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(edge);
+    }
+  }
+  return result;
+}
+
+// src/commands/search.ts
+var searchCommand = new Command3("search").description("Search notes with hybrid BM25 + vector search").argument("<query>", "search query").option("--json", "output results as JSON").option("--limit <n>", "max results", "10").option("--tier <tier>", "filter by tier (slow, fast)").option("--tags <tags>", "filter by tags (comma-separated)").option("--category <cat>", "filter by category").option("--confidence <level>", "filter by confidence").option("--since <date>", "only notes modified after this date").option("--expand", "include graph-connected notes").action(async (query, opts) => {
+  const config = loadConfig();
+  const db = new BrainDB(config.dbPath);
+  const embedder = createEmbedder(config);
+  try {
+    const searchOpts = {
+      limit: parseInt(opts.limit, 10),
+      tier: opts.tier,
+      tags: opts.tags ? opts.tags.split(",").map((t) => t.trim()) : void 0,
+      category: opts.category,
+      confidence: opts.confidence,
+      since: opts.since
+    };
+    const results = await search(db, embedder, query, searchOpts, config.fusionWeights);
+    const expanded = [];
+    if (opts.expand && results.length > 0) {
+      const noteIds = results.map((r) => r.noteId);
+      const graphExpanded = expandResults(db, noteIds, 1);
+      for (const item of graphExpanded) {
+        const note = db.getNoteById(item.noteId);
+        if (!note) continue;
+        expanded.push({
+          score: item.decayedScore,
+          filePath: note.filePath,
+          noteId: note.id,
+          heading: null,
+          excerpt: note.summary ?? "",
+          tier: note.tier,
+          tags: note.tags ? note.tags.split(",") : [],
+          confidence: note.confidence
+        });
+      }
+    }
+    const allResults = [...results, ...expanded];
+    if (opts.json) {
+      process.stdout.write(JSON.stringify(allResults) + "\n");
+    } else {
+      if (allResults.length === 0) {
+        process.stderr.write("No results found.\n");
+        return;
+      }
+      for (const r of allResults) {
+        const score = r.score.toFixed(3);
+        process.stdout.write(`[${score}] ${r.filePath}
+`);
+        if (r.heading) {
+          process.stdout.write(`  \xA7 ${r.heading}
+`);
+        }
+        if (r.excerpt) {
+          process.stdout.write(`  ${r.excerpt}
+`);
+        }
+        process.stdout.write("\n");
+      }
+    }
+  } finally {
+    db.close();
+  }
+});
+
+// src/commands/status.ts
+import { Command as Command4 } from "@commander-js/extra-typings";
+
+// src/utils.ts
+function parseIntervalDays(interval) {
+  const match = interval.match(/^(\d+)\s*(d|w|m)$/);
+  if (!match) return 90;
+  const value = parseInt(match[1], 10);
+  switch (match[2]) {
+    case "d":
+      return value;
+    case "w":
+      return value * 7;
+    case "m":
+      return value * 30;
+    default:
+      return 90;
+  }
+}
+
+// src/commands/status.ts
+var statusCommand = new Command4("status").description("Show database statistics").option("--json", "output as JSON").action((opts) => {
+  const config = loadConfig();
+  const db = new BrainDB(config.dbPath);
+  try {
+    const notes = db.getAllNotes();
+    const embeddingModel = db.getEmbeddingModel();
+    const byTier = {};
+    const byType = {};
+    const staleNotes = [];
+    const now = /* @__PURE__ */ new Date();
+    for (const note of notes) {
+      byTier[note.tier] = (byTier[note.tier] ?? 0) + 1;
+      byType[note.type] = (byType[note.type] ?? 0) + 1;
+      if (note.lastReviewed && note.reviewInterval) {
+        const reviewed = new Date(note.lastReviewed);
+        const intervalDays = parseIntervalDays(note.reviewInterval);
+        const due = new Date(reviewed.getTime() + intervalDays * 864e5);
+        if (due < now) {
+          staleNotes.push(note.id);
+        }
+      }
+    }
+    const files = db.getAllFiles();
+    let lastIndexed = null;
+    for (const [, file] of files) {
+      if (lastIndexed === null || file.indexedAt > lastIndexed) {
+        lastIndexed = file.indexedAt;
+      }
+    }
+    const totalChunks = db.getChunkCount();
+    const summary = {
+      totalNotes: notes.length,
+      totalChunks,
+      byTier,
+      byType,
+      embeddingModel: embeddingModel?.model ?? null,
+      embeddingDimensions: embeddingModel?.dimensions ?? null,
+      lastIndexed: lastIndexed ? new Date(lastIndexed).toISOString() : null,
+      staleNotes: staleNotes.length,
+      staleNoteIds: staleNotes
+    };
+    if (opts.json) {
+      process.stdout.write(JSON.stringify(summary) + "\n");
+    } else {
+      process.stderr.write(`Notes: ${notes.length}
+`);
+      process.stderr.write(`Chunks: ${totalChunks}
+`);
+      process.stderr.write(`By tier: ${formatMap(byTier)}
+`);
+      process.stderr.write(`By type: ${formatMap(byType)}
+`);
+      if (embeddingModel) {
+        process.stderr.write(
+          `Embedding: ${embeddingModel.model} (${embeddingModel.dimensions}d)
+`
+        );
+      }
+      if (lastIndexed) {
+        process.stderr.write(
+          `Last indexed: ${new Date(lastIndexed).toISOString()}
+`
+        );
+      }
+      if (staleNotes.length > 0) {
+        process.stderr.write(
+          `Stale notes needing review: ${staleNotes.length}
+`
+        );
+      }
+    }
+  } finally {
+    db.close();
+  }
+});
+function formatMap(map) {
+  return Object.entries(map).map(([k, v]) => `${k}=${v}`).join(", ");
+}
+
+// src/commands/add.ts
+import { Command as Command5 } from "@commander-js/extra-typings";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3, existsSync as existsSync3 } from "fs";
+import { join as join4, dirname, resolve } from "path";
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function buildFrontmatter2(opts) {
+  const now = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const title = opts.title ?? "Untitled";
+  const type = opts.type ?? "note";
+  const tier = opts.tier ?? "slow";
+  const lines2 = [
+    "---",
+    `id: ${slugify(title)}`,
+    `title: ${title}`,
+    `type: ${type}`,
+    `tier: ${tier}`
+  ];
+  if (opts.tags) {
+    const tagList = opts.tags.split(",").map((t) => t.trim());
+    lines2.push(`tags: [${tagList.join(", ")}]`);
+  }
+  lines2.push(`created: ${now}`);
+  lines2.push(`modified: ${now}`);
+  lines2.push("---");
+  return lines2.join("\n");
+}
+function hasFrontmatter(content) {
+  return content.trimStart().startsWith("---");
+}
+function resolveOutputPath(notesDir, tier, type, id) {
+  if (tier === "fast") {
+    const now = /* @__PURE__ */ new Date();
+    const yyyy = String(now.getFullYear());
+    const mm = String(now.getMonth() + 1).padStart(2, "0");
+    const dd = String(now.getDate()).padStart(2, "0");
+    return join4(notesDir, "logs", yyyy, mm, `${yyyy}-${mm}-${dd}-${id}.md`);
+  }
+  const TYPE_DIRS = {
+    note: "notes",
+    decision: "decisions",
+    research: "research",
+    pattern: "patterns",
+    meeting: "logs",
+    "session-log": "logs",
+    guide: "notes"
+  };
+  const typeDir = TYPE_DIRS[type];
+  return join4(notesDir, typeDir, `${id}.md`);
+}
+var addCommand = new Command5("add").description("Create a new note from file or stdin").argument("[file]", "Input file path").option("--title <title>", "Note title").option("--type <type>", "Note type (note, decision, pattern, research, meeting, session-log, guide)").option("--tier <tier>", "Note tier (slow, fast)").option("--tags <tags>", "Comma-separated tags").action(async (file, opts) => {
+  const VALID_TYPES2 = ["note", "decision", "pattern", "research", "meeting", "session-log", "guide"];
+  const VALID_TIERS = ["slow", "fast"];
+  if (opts.type && !VALID_TYPES2.includes(opts.type)) {
+    console.error(`Error: invalid type "${opts.type}". Valid types: ${VALID_TYPES2.join(", ")}`);
+    process.exitCode = 1;
+    return;
+  }
+  if (opts.tier && !VALID_TIERS.includes(opts.tier)) {
+    console.error(`Error: invalid tier "${opts.tier}". Valid tiers: ${VALID_TIERS.join(", ")}`);
+    process.exitCode = 1;
+    return;
+  }
+  let content;
+  if (file) {
+    content = readFileSync3(resolve(file), "utf-8");
+  } else if (!process.stdin.isTTY) {
+    content = readFileSync3(0, "utf-8");
+  } else {
+    console.error("Error: provide a file argument or pipe content to stdin");
+    process.exitCode = 1;
+    return;
+  }
+  if (!hasFrontmatter(content)) {
+    const fm = buildFrontmatter2(opts);
+    content = fm + "\n\n" + content;
+  }
+  const parsed = parseMarkdown("temp.md", content);
+  const id = parsed.id;
+  const tier = opts.tier ?? parsed.frontmatter.tier ?? "slow";
+  const type = opts.type ?? parsed.frontmatter.type ?? "note";
+  const config = loadConfig();
+  const outPath = resolveOutputPath(config.notesDir, tier, type, id);
+  const dir = dirname(outPath);
+  if (!existsSync3(dir)) {
+    mkdirSync3(dir, { recursive: true });
+  }
+  writeFileSync4(outPath, content, "utf-8");
+  console.log(outPath);
+});
+
+// src/commands/stale.ts
+import { Command as Command6 } from "@commander-js/extra-typings";
+function computeDaysOverdue(note, overrideDays) {
+  const now = Date.now();
+  const lastReviewed = note.lastReviewed ? new Date(note.lastReviewed).getTime() : null;
+  if (!lastReviewed) return null;
+  if (overrideDays !== void 0) {
+    const daysSince = Math.floor((now - lastReviewed) / (1e3 * 60 * 60 * 24));
+    return daysSince > overrideDays ? daysSince - overrideDays : null;
+  }
+  const interval = note.reviewInterval ? parseIntervalDays(note.reviewInterval) : 90;
+  const dueDate = lastReviewed + interval * 24 * 60 * 60 * 1e3;
+  if (now < dueDate) return null;
+  return Math.floor((now - dueDate) / (1e3 * 60 * 60 * 24));
+}
+var staleCommand = new Command6("stale").description("Find notes needing review").option("--days <n>", "Show notes not reviewed in N days", parseInt).option("--tier <tier>", "Filter by tier (slow, fast)").option("--json", "Output as JSON").action((opts) => {
+  const config = loadConfig();
+  const db = new BrainDB(config.dbPath);
+  try {
+    let notes = db.getAllNotes();
+    if (opts.tier) {
+      notes = notes.filter((n) => n.tier === opts.tier);
+    }
+    const staleNotes = [];
+    for (const note of notes) {
+      const overdue = computeDaysOverdue(note, opts.days);
+      if (overdue !== null && overdue >= 0) {
+        staleNotes.push({
+          noteId: note.id,
+          lastReviewed: note.lastReviewed ?? "never",
+          reviewInterval: note.reviewInterval ?? "90d",
+          daysOverdue: overdue
+        });
+      }
+    }
+    staleNotes.sort((a, b) => b.daysOverdue - a.daysOverdue);
+    if (opts.json) {
+      console.log(JSON.stringify(staleNotes, null, 2));
+    } else if (staleNotes.length === 0) {
+      console.log("No stale notes found.");
+    } else {
+      for (const s of staleNotes) {
+        console.log(
+          `${s.noteId} \u2014 last reviewed ${s.lastReviewed}, interval ${s.reviewInterval}, ${s.daysOverdue} days overdue`
+        );
+      }
+    }
+  } finally {
+    db.close();
+  }
+});
+
+// src/commands/graph.ts
+import { Command as Command7 } from "@commander-js/extra-typings";
+function buildTree(result) {
+  const edgesBySource = /* @__PURE__ */ new Map();
+  for (const edge of result.edges) {
+    const list = edgesBySource.get(edge.sourceId) ?? [];
+    list.push(edge);
+    edgesBySource.set(edge.sourceId, list);
+  }
+  const nodeMap = new Map(result.nodes.map((n) => [n.id, n]));
+  const visited = /* @__PURE__ */ new Set([result.root.id]);
+  function expand(nodeId) {
+    const edges = edgesBySource.get(nodeId) ?? [];
+    const children = [];
+    for (const edge of edges) {
+      if (visited.has(edge.targetId)) continue;
+      visited.add(edge.targetId);
+      const target = nodeMap.get(edge.targetId);
+      children.push({
+        relationType: edge.type,
+        nodeId: edge.targetId,
+        nodeType: target?.type ?? "note",
+        children: expand(edge.targetId)
+      });
+    }
+    return children;
+  }
+  return expand(result.root.id);
+}
+function printTree(rootId, rootType, children) {
+  console.log(`${rootId} (${rootType})`);
+  printChildren(children, "");
+}
+function printChildren(children, prefix) {
+  for (let i = 0; i < children.length; i++) {
+    const isLast = i === children.length - 1;
+    const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    const child = children[i];
+    console.log(`${prefix}${connector}${child.relationType}: ${child.nodeId} (${child.nodeType})`);
+    const childPrefix = prefix + (isLast ? "    " : "\u2502   ");
+    printChildren(child.children, childPrefix);
+  }
+}
+var graphCommand = new Command7("graph").description("Show note relations as a graph").argument("<note-id>", "Root note ID").option("--depth <n>", "Traversal depth", parseInt, 2).option("--json", "Output as JSON").action((noteId, opts) => {
+  const config = loadConfig();
+  const db = new BrainDB(config.dbPath);
+  try {
+    const result = traverseGraph(db, noteId, opts.depth);
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      const tree = buildTree(result);
+      printTree(result.root.id, result.root.type, tree);
+    }
+  } finally {
+    db.close();
+  }
+});
+
+// src/commands/template.ts
+import { Command as Command8 } from "@commander-js/extra-typings";
+var VALID_TYPES = /* @__PURE__ */ new Set([
+  "note",
+  "decision",
+  "meeting",
+  "research",
+  "pattern",
+  "session-log",
+  "guide"
+]);
+function todayISO() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function titleCase(s) {
+  return s.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+function generateTemplate(type) {
+  const today = todayISO();
+  const base = [
+    "---",
+    `id: untitled-${type}`,
+    `title: Untitled ${titleCase(type)}`,
+    `type: ${type}`
+  ];
+  switch (type) {
+    case "note":
+      return lines(
+        ...base,
+        "tier: slow",
+        'category: ""',
+        "tags: []",
+        'summary: ""',
+        "confidence: medium",
+        "status: draft",
+        `created: ${today}`,
+        `modified: ${today}`,
+        `last-reviewed: ${today}`,
+        "review-interval: 90d",
+        "sources: []",
+        "related: []",
+        "---",
+        "",
+        "## Overview",
+        ""
+      );
+    case "decision":
+      return lines(
+        ...base,
+        "tier: slow",
+        'category: ""',
+        "tags: []",
+        'summary: ""',
+        "confidence: high",
+        "status: current",
+        `created: ${today}`,
+        `modified: ${today}`,
+        `last-reviewed: ${today}`,
+        "review-interval: 180d",
+        "sources: []",
+        "related: []",
+        "---",
+        "",
+        "## Context",
+        "",
+        "## Decision",
+        "",
+        "## Consequences",
+        ""
+      );
+    case "meeting":
+      return lines(
+        ...base,
+        "tier: fast",
+        `date: ${today}`,
+        "participants: []",
+        'project: ""',
+        "tags: []",
+        'summary: ""',
+        'outcome: ""',
+        `created: ${today}`,
+        `modified: ${today}`,
+        "review-interval: 30d",
+        "related: []",
+        "---",
+        "",
+        "## Agenda",
+        "",
+        "## Notes",
+        "",
+        "## Action Items",
+        ""
+      );
+    case "research":
+      return lines(
+        ...base,
+        "tier: slow",
+        'category: ""',
+        "tags: []",
+        'summary: ""',
+        "confidence: medium",
+        "status: draft",
+        `created: ${today}`,
+        `modified: ${today}`,
+        `last-reviewed: ${today}`,
+        "review-interval: 90d",
+        "sources: []",
+        "related: []",
+        "---",
+        "",
+        "## Question",
+        "",
+        "## Findings",
+        "",
+        "## Conclusion",
+        ""
+      );
+    case "pattern":
+      return lines(
+        ...base,
+        "tier: slow",
+        'category: ""',
+        "tags: []",
+        'summary: ""',
+        "confidence: high",
+        "status: current",
+        `created: ${today}`,
+        `modified: ${today}`,
+        `last-reviewed: ${today}`,
+        "review-interval: 180d",
+        "sources: []",
+        "related: []",
+        "---",
+        "",
+        "## Problem",
+        "",
+        "## Solution",
+        "",
+        "## Examples",
+        ""
+      );
+    case "session-log":
+      return lines(
+        ...base,
+        "tier: fast",
+        `date: ${today}`,
+        'project: ""',
+        "tags: []",
+        'summary: ""',
+        `created: ${today}`,
+        `modified: ${today}`,
+        'expires: ""',
+        "related: []",
+        "---",
+        "",
+        "## Goal",
+        "",
+        "## Log",
+        "",
+        "## Outcome",
+        ""
+      );
+    case "guide":
+      return lines(
+        ...base,
+        "tier: slow",
+        'category: ""',
+        "tags: []",
+        'summary: ""',
+        "confidence: high",
+        "status: current",
+        `created: ${today}`,
+        `modified: ${today}`,
+        `last-reviewed: ${today}`,
+        "review-interval: 180d",
+        "sources: []",
+        "related: []",
+        "---",
+        "",
+        "## Purpose",
+        "",
+        "## Steps",
+        "",
+        "## Tips",
+        ""
+      );
+    default:
+      return "";
+  }
+}
+function lines(...parts) {
+  return parts.join("\n");
+}
+var templateCommand = new Command8("template").description("Output a frontmatter template for a note type").argument("<type>", "Note type (note, decision, meeting, research, pattern, session-log, guide)").action((type) => {
+  if (!VALID_TYPES.has(type)) {
+    console.error(
+      `Error: unknown type "${type}". Valid types: ${[...VALID_TYPES].join(", ")}`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  process.stdout.write(generateTemplate(type));
+});
+
+// src/commands/archive.ts
+import { Command as Command9 } from "@commander-js/extra-typings";
+import { renameSync, mkdirSync as mkdirSync4, existsSync as existsSync4 } from "fs";
+import { join as join5, basename as basename2 } from "path";
+var archiveCommand = new Command9("archive").description("Move expired fast-tier notes to archive").option("--dry-run", "List files that would be archived without moving them").action((opts) => {
+  const config = loadConfig();
+  const db = new BrainDB(config.dbPath);
+  try {
+    const notes = db.getAllNotes();
+    const now = Date.now();
+    const expired = notes.filter((n) => {
+      if (n.tier !== "fast") return false;
+      if (!n.expires) return false;
+      return new Date(n.expires).getTime() < now;
+    });
+    if (expired.length === 0) {
+      console.log("No expired notes to archive.");
+      return;
+    }
+    for (const note of expired) {
+      const expiresDate = new Date(note.expires);
+      const yyyy = String(expiresDate.getFullYear());
+      const archiveDir = join5(config.notesDir, "archive", yyyy);
+      const filename = basename2(note.filePath);
+      const archivePath = join5(archiveDir, filename);
+      if (opts.dryRun) {
+        console.log(`Would archive: ${note.filePath} \u2192 ${archivePath}`);
+        continue;
+      }
+      if (!existsSync4(archiveDir)) {
+        mkdirSync4(archiveDir, { recursive: true });
+      }
+      if (existsSync4(note.filePath)) {
+        renameSync(note.filePath, archivePath);
+      }
+      db.upsertNote({ ...note, filePath: archivePath });
+    }
+    const verb = opts.dryRun ? "Would archive" : "Archived";
+    console.log(`${verb} ${expired.length} note${expired.length === 1 ? "" : "s"}.`);
+  } finally {
+    db.close();
+  }
+});
+
+// src/commands/config.ts
+import { Command as Command10 } from "@commander-js/extra-typings";
+function getNestedValue(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0 || typeof current !== "object") {
+      return void 0;
+    }
+    current = current[part];
+  }
+  return current;
+}
+function setNestedValue(obj, path, value) {
+  const parts = path.split(".");
+  const result = { ...obj };
+  let current = result;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    const existing = current[part];
+    if (typeof existing === "object" && existing !== null) {
+      current[part] = { ...existing };
+    } else {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  current[parts[parts.length - 1]] = value;
+  return result;
+}
+function parseValue(raw) {
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  const num = Number(raw);
+  if (!isNaN(num) && raw.length > 0) return num;
+  return raw;
+}
+function camelCase(key) {
+  return key.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+function camelCasePath(path) {
+  return path.split(".").map(camelCase).join(".");
+}
+var getSubcommand = new Command10("get").description("Get config value(s)").argument("[key]", "Config key (dot-notation for nested, e.g. fusion-weights.bm25)").action((key) => {
+  const config = loadConfig();
+  if (!key) {
+    console.log(JSON.stringify(config, null, 2));
+    return;
+  }
+  const camelKey = camelCasePath(key);
+  const value = getNestedValue(config, camelKey);
+  if (value === void 0) {
+    console.error(`Error: unknown config key "${key}"`);
+    process.exitCode = 1;
+    return;
+  }
+  if (typeof value === "object") {
+    console.log(JSON.stringify(value, null, 2));
+  } else {
+    console.log(String(value));
+  }
+});
+var setSubcommand = new Command10("set").description("Set a config value").argument("<key>", "Config key (dot-notation for nested)").argument("<value>", "Value to set").action((key, rawValue) => {
+  const camelKey = camelCasePath(key);
+  const value = parseValue(rawValue);
+  const config = loadConfig();
+  const existing = getNestedValue(config, camelKey);
+  if (existing === void 0) {
+    console.error(`Error: unknown config key "${key}"`);
+    process.exitCode = 1;
+    return;
+  }
+  if (existing !== null && typeof value !== typeof existing) {
+    console.error(
+      `Error: type mismatch for "${key}". Expected ${typeof existing}, got ${typeof value}`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const updated = setNestedValue(config, camelKey, value);
+  try {
+    saveConfig(updated);
+    console.log(`Set ${key} = ${String(value)}`);
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exitCode = 1;
+  }
+});
+var configCommand = new Command10("config").description("Get or set configuration values").addCommand(getSubcommand).addCommand(setSubcommand);
+
+// src/cli.ts
+var program = new Command11().name("brain").description("Developer second brain with hybrid RAG search").version("0.1.0").option("--config-dir <path>", "override config directory").option("--db-path <path>", "override database path");
+program.addCommand(initCommand);
+program.addCommand(indexCommand);
+program.addCommand(searchCommand);
+program.addCommand(statusCommand);
+program.addCommand(addCommand);
+program.addCommand(staleCommand);
+program.addCommand(graphCommand);
+program.addCommand(templateCommand);
+program.addCommand(archiveCommand);
+program.addCommand(configCommand);
+program.parseAsync().catch((err) => {
+  process.stderr.write(`Error: ${err.message}
+`);
+  process.exitCode = 1;
+});