@yurtsever/capsa 0.1.0-alpha.5 → 0.1.0-alpha.6

package/dist/index.js

@@ -7415,6 +7415,7 @@ function findProjectRoot(startDir, homeDir) {
 // ../core/dist/chunk.js
 var DEFAULT_MAX_CHARS = 2e3;
 function chunkMarkdown(markdown, maxChars = DEFAULT_MAX_CHARS) {
+  const body = parseFrontmatter(markdown).body;
   const chunks = [];
   const trail = [];
   let buffer = [];
@@ -7424,11 +7425,12 @@ function chunkMarkdown(markdown, maxChars = DEFAULT_MAX_CHARS) {
     buffer = [];
     if (!text)
       return;
+    const headingPath = trail.filter((s) => Boolean(s));
     for (const part of splitLong(text, maxChars)) {
-      chunks.push({ index: chunks.length, headingPath: [...trail], text: part });
+      chunks.push({ index: chunks.length, headingPath, text: part });
     }
   };
-  for (const line of markdown.split(/\r?\n/)) {
+  for (const line of body.split(/\r?\n/)) {
     if (/^```/.test(line.trim()))
       inFence = !inFence;
     const heading = !inFence && /^(#{1,6})\s+(.*\S)\s*$/.exec(line);
@@ -10072,7 +10074,23 @@ function loadSqlite() {
 }
 var DB_DIR = ".capsa";
 var DB_FILE = "index.db";
-var SCHEMA_VERSION = 3;
+var SCHEMA_VERSION = 5;
+var CONTEXT_LOG_DDL = `
+      -- Every context delivery. This is the measurement for the MVP gate and
+      -- the seed of the organisation tier's audit log. Alone among these
+      -- tables its rows are never dropped, so a row has to stand on its own:
+      -- it records what was delivered (path, heading trail, tokens per chunk)
+      -- rather than chunk ids, which a rebuild hands to different text.
+      CREATE TABLE IF NOT EXISTS context_log (
+        id           INTEGER PRIMARY KEY,
+        created_at   TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
+        source       TEXT NOT NULL,
+        query        TEXT NOT NULL,
+        delivered    TEXT NOT NULL,
+        tokens_est   INTEGER NOT NULL,
+        duration_ms  INTEGER NOT NULL
+      );
+`;
 function dbPath(projectRoot) {
   return join6(projectRoot, DB_DIR, DB_FILE);
 }
@@ -10158,20 +10176,32 @@ var Store = class {
         related    TEXT
       );
 
-      -- Every context delivery. This is the measurement for the MVP gate and
-      -- the seed of the organisation tier's audit log.
-      CREATE TABLE IF NOT EXISTS context_log (
-        id           INTEGER PRIMARY KEY,
-        created_at   TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
-        source       TEXT NOT NULL,
-        query        TEXT NOT NULL,
-        chunk_ids    TEXT NOT NULL,
-        tokens_est   INTEGER NOT NULL,
-        duration_ms  INTEGER NOT NULL
-      );
+      ${CONTEXT_LOG_DDL}
     `);
+    this.migrateContextLog();
     this.db.prepare("INSERT OR REPLACE INTO meta(key, value) VALUES ('dimensions', ?)").run(String(this.dimensions));
   }
+  /**
+   * `context_log` outlives every rebuild, so it is the one table that has to
+   * be migrated in place instead of recreated. v5 replaced `chunk_ids` with
+   * `delivered`: a chunk id is a rowid the next `capsa index` reassigns, so an
+   * older row ended up naming whatever text inherited its ids — the measurement
+   * quietly decayed. Rows written before v5 keep everything that still means
+   * something (when, who asked, what for, at what cost) and carry an empty
+   * delivery, because their ids can no longer be resolved honestly.
+   */
+  migrateContextLog() {
+    const columns = this.db.prepare("PRAGMA table_info(context_log)").all();
+    if (columns.some((c) => c.name === "delivered"))
+      return;
+    this.db.exec(`
+      ALTER TABLE context_log RENAME TO context_log_v4;
+      ${CONTEXT_LOG_DDL}
+      INSERT INTO context_log (id, created_at, source, query, delivered, tokens_est, duration_ms)
+        SELECT id, created_at, source, query, '[]', tokens_est, duration_ms FROM context_log_v4;
+      DROP TABLE context_log_v4;
+    `);
+  }
   getItem(path) {
     return this.db.prepare("SELECT * FROM items WHERE path = ?").get(path);
   }
@@ -10254,11 +10284,22 @@ var Store = class {
     return this.db.prepare("SELECT * FROM items ORDER BY kind, rel_path").all();
   }
   logContext(entry) {
-    this.db.prepare("INSERT INTO context_log (source, query, chunk_ids, tokens_est, duration_ms) VALUES (?, ?, ?, ?, ?)").run(entry.source, entry.query, JSON.stringify(entry.chunkIds), entry.tokensEst, entry.durationMs);
+    this.db.prepare("INSERT INTO context_log (source, query, delivered, tokens_est, duration_ms) VALUES (?, ?, ?, ?, ?)").run(entry.source, entry.query, JSON.stringify(entry.delivered), entry.tokensEst, entry.durationMs);
   }
+  /**
+   * Returns the stored row, not just its id: `created_at` is SQL's to write,
+   * and the indexed item dates itself from it.
+   */
   recordDecision(title, body, related) {
     const res = this.db.prepare("INSERT INTO decisions (title, body, related) VALUES (?, ?, ?)").run(title, body, related ? JSON.stringify(related) : null);
-    return Number(res.lastInsertRowid);
+    return this.decision(Number(res.lastInsertRowid));
+  }
+  decision(id) {
+    return this.db.prepare("SELECT * FROM decisions WHERE id = ?").get(id);
+  }
+  /** Every decision, oldest first. The rows survive `reset()`; the items do not. */
+  listDecisions() {
+    return this.db.prepare("SELECT * FROM decisions ORDER BY id").all();
   }
   close() {
     this.db.close();
@@ -10604,6 +10645,66 @@ function firstHeading2(raw2) {
   return void 0;
 }
 
+// ../index/dist/decision.js
+import { join as join8 } from "path";
+var ITEM_DIR2 = join8(".capsa", "decisions");
+function decisionPath(projectRoot, id) {
+  return join8(projectRoot, ITEM_DIR2, `decision-${id}.md`);
+}
+function decisionItem(projectRoot, row) {
+  const path = decisionPath(projectRoot, row.id);
+  const related = parseRelated(row.related);
+  return {
+    id: stableId(path),
+    format: "decision",
+    formatLabel: "Decision",
+    name: row.title,
+    // The description becomes the provenance line of every embedded chunk.
+    description: row.title,
+    path,
+    scope: "project",
+    projectRoot,
+    content: renderDecision(row, related),
+    metadata: { decisionId: row.id, author: row.author, createdAt: row.created_at, related },
+    knowledge: {
+      kind: "decision",
+      // Written once, never edited: the day it was made is the day it last
+      // changed, so recency ranks it from `created_at`.
+      updatedAt: row.created_at,
+      // No lifecycle to report. "unknown" is the neutral weight (1.0) and
+      // says so out loud instead of leaving the column blank.
+      status: "unknown",
+      relatedPaths: related.length ? related : void 0
+    }
+  };
+}
+function renderDecision(row, related) {
+  const lines = [
+    `# ${row.title}`,
+    "",
+    `decision \`#${row.id}\` \xB7 ${row.author} \xB7 ${row.created_at.slice(0, 10)}`,
+    "",
+    row.body.trim()
+  ];
+  if (related.length) {
+    lines.push("", "## Related", "");
+    for (const p of related)
+      lines.push(`- ${p}`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+function parseRelated(json2) {
+  if (!json2)
+    return [];
+  try {
+    const parsed = JSON.parse(json2);
+    return Array.isArray(parsed) ? parsed.filter((p) => typeof p === "string") : [];
+  } catch {
+    return [];
+  }
+}
+
 // ../index/dist/indexer.js
 function knowledgeAdapters() {
   return [
@@ -10642,26 +10743,15 @@ async function indexProject(projectRoot, embedder, onProgress) {
       }
       if (existing)
         store.deleteItem(existing.id);
-      const chunks = chunkMarkdown(item.content);
-      const searchTexts = chunks.map((c) => withContext(item, c.headingPath, c.text));
-      const vectors = searchTexts.length ? await embedder.embed(searchTexts) : [];
-      const k = item.knowledge;
-      store.upsertItem({
-        id: item.id,
-        format: item.format,
-        kind: k?.kind ?? "instruction",
-        name: item.name,
-        path: item.path,
-        rel_path: relative5(projectRoot, item.path),
-        content_hash: hash2,
-        status: k?.status ?? null,
-        updated_at: k?.updatedAt ?? null,
-        tags: k?.tags ? JSON.stringify(k.tags) : null
-      });
-      chunks.forEach((c, i) => store.insertChunk(item.id, c.index, c.headingPath, c.text, vectors[i], searchTexts[i]));
+      await indexItem(store, embedder, item, projectRoot, hash2);
       indexed++;
       onProgress?.({ phase: "embed", scanned: items.length, indexed, skipped });
     }
+    const decisions = await indexDecisions(store, embedder, projectRoot);
+    for (const path of decisions.paths)
+      seen.add(path);
+    indexed += decisions.indexed;
+    skipped += decisions.skipped;
     let removed = 0;
     for (const row of store.listItems()) {
       if (!seen.has(row.path)) {
@@ -10670,7 +10760,7 @@ async function indexProject(projectRoot, embedder, onProgress) {
       }
     }
     const out = {
-      scanned: items.length,
+      scanned: items.length + decisions.paths.length,
       indexed,
       skipped,
       removed,
@@ -10683,6 +10773,53 @@ async function indexProject(projectRoot, embedder, onProgress) {
     store.close();
   }
 }
+async function indexDecisions(store, embedder, projectRoot) {
+  const out = { paths: [], indexed: 0, skipped: 0 };
+  for (const row of store.listDecisions()) {
+    const item = decisionItem(projectRoot, row);
+    out.paths.push(item.path);
+    const hash2 = sha1(item.content);
+    const existing = store.getItem(item.path);
+    if (existing && existing.content_hash === hash2) {
+      out.skipped++;
+      continue;
+    }
+    if (existing)
+      store.deleteItem(existing.id);
+    await indexItem(store, embedder, item, projectRoot, hash2);
+    out.indexed++;
+  }
+  return out;
+}
+async function recordDecision(store, embedder, projectRoot, input2) {
+  const row = store.recordDecision(input2.title, input2.body, input2.related);
+  const item = decisionItem(projectRoot, row);
+  try {
+    await indexItem(store, embedder, item, projectRoot, sha1(item.content));
+    return { id: row.id, indexed: true };
+  } catch (err) {
+    return { id: row.id, indexed: false, reason: err.message };
+  }
+}
+async function indexItem(store, embedder, item, projectRoot, hash2) {
+  const chunks = chunkMarkdown(item.content);
+  const searchTexts = chunks.map((c) => withContext(item, c.headingPath, c.text));
+  const vectors = searchTexts.length ? await embedder.embed(searchTexts) : [];
+  const k = item.knowledge;
+  store.upsertItem({
+    id: item.id,
+    format: item.format,
+    kind: k?.kind ?? "instruction",
+    name: item.name,
+    path: item.path,
+    rel_path: relative5(projectRoot, item.path),
+    content_hash: hash2,
+    status: k?.status ?? null,
+    updated_at: k?.updatedAt ?? null,
+    tags: k?.tags ? JSON.stringify(k.tags) : null
+  });
+  chunks.forEach((c, i) => store.insertChunk(item.id, c.index, c.headingPath, c.text, vectors[i], searchTexts[i]));
+}
 function withContext(item, headingPath, text) {
   const kind = item.knowledge?.kind ?? "instruction";
   const head = [kind, item.description ?? item.name, ...headingPath].filter(Boolean).join(" \u203A ");
@@ -10895,7 +11032,7 @@ async function retrieve(store, embedder, query, options = {}) {
   store.logContext({
     source: options.source ?? "unknown",
     query,
-    chunkIds: chunks.map((c) => c.chunkId),
+    delivered: chunks.map((c) => ({ rel_path: c.relPath, heading_path: c.headingPath, tokens: c.tokens })),
     tokensEst: tokens,
     durationMs
   });
@@ -40290,8 +40427,13 @@ _capsa: ${result.chunks.length} chunks, ~${result.tokensEst} tokens, ${result.du
   }, async ({ title, body, related }) => {
     const store = openStore(options.projectRoot, embedder);
     try {
-      const id = store.recordDecision(title, body, related);
-      return { content: [{ type: "text", text: `Recorded decision #${id}: ${title}` }] };
+      const { id, indexed, reason } = await recordDecision(store, embedder, options.projectRoot, {
+        title,
+        body,
+        related
+      });
+      const note = indexed ? "" : ` \u2014 not searchable yet (${reason}); run \`capsa index\` once that is fixed`;
+      return { content: [{ type: "text", text: `Recorded decision #${id}: ${title}${note}` }] };
     } finally {
       store.close();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yurtsever/capsa",
-  "version": "0.1.0-alpha.5",
+  "version": "0.1.0-alpha.6",
   "description": "Your project's knowledge in one capsule. Local-first project memory and cockpit for AI coding agents: indexes runbooks, tickets, plans and instruction files, serves the smallest relevant context over MCP.",
   "type": "module",
   "license": "MIT",