eminiar 0.7.0 → 0.8.0

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "eminiar",
   "displayName": "Eminiar",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Local-first context, memory and knowledge graph for Claude Code: sandboxed execution, FTS5 + vector search, session continuity, code graph.",
   "author": {
     "name": "Ryan Dick"

package/dist/cli.js

@@ -35516,6 +35516,7 @@ __export(store_exports, {
   isValidName: () => isValidName,
   list: () => list,
   memoriesDir: () => memoriesDir,
+  memoriesRel: () => memoriesRel,
   memoryLinks: () => memoryLinks,
   normalizeRelated: () => normalizeRelated,
   read: () => read,
@@ -43457,8 +43458,454 @@ var init_history_api = __esm({
   }
 });
 
+// src/history/lineage.ts
+function mergedBranchName(subject) {
+  const pr = PR_MERGE.exec(subject);
+  if (pr) return { name: pr[2], pr: Number(pr[1]) };
+  const br = BRANCH_MERGE.exec(subject);
+  if (br) return { name: br[1].replace(/^origin\//, "") };
+  return void 0;
+}
+function firstParents(m, sha, stop, max) {
+  const out = [];
+  let cur = sha ? m.bySha.get(sha) : void 0;
+  while (cur && !stop.has(cur.sha) && out.length < max) {
+    out.push(cur);
+    cur = cur.parents[0] ? m.bySha.get(cur.parents[0]) : void 0;
+  }
+  return out;
+}
+function branchLineage(m, opts = {}) {
+  const max = opts.maxPerBranch ?? 500;
+  const def = m.branches.find((b) => b.isDefault && !b.remote) ?? m.branches.find((b) => b.isDefault);
+  const defaultName = def ? def.remote ? def.name.replace(/^[^/]+\//, "") : def.name : m.base ?? "main";
+  const mainline = firstParents(m, def?.sha ?? m.head, /* @__PURE__ */ new Set(), 1e5);
+  const onMain = new Set(mainline.map((c) => c.sha));
+  const byName = /* @__PURE__ */ new Map();
+  const entry = (name) => {
+    let b = byName.get(name);
+    if (!b) {
+      b = {
+        name,
+        commits: [],
+        tipAt: 0,
+        isDefault: name === defaultName,
+        live: false,
+        merged: false,
+        prs: [],
+        merges: []
+      };
+      byName.set(name, b);
+    }
+    return b;
+  };
+  const own2 = /* @__PURE__ */ new Map();
+  const add = (name, cs) => {
+    const set2 = own2.get(name) ?? /* @__PURE__ */ new Set();
+    for (const c of cs) if (!c.merge) set2.add(c.sha);
+    own2.set(name, set2);
+    const b = entry(name);
+    for (const c of cs) b.tipAt = Math.max(b.tipAt, c.at);
+  };
+  add(defaultName, mainline);
+  entry(defaultName).live = !!def;
+  for (const c of mainline) {
+    if (!c.merge || c.parents.length < 2) continue;
+    const found = mergedBranchName(c.subject);
+    const name = found?.name ?? (c.pr ? `PR #${c.pr}` : `merge ${c.short}`);
+    if (name === defaultName) continue;
+    add(name, firstParents(m, c.parents[1], onMain, max));
+    const b = entry(name);
+    b.merged = true;
+    b.merges.push(c.sha);
+    const pr = found?.pr ?? c.pr;
+    if (pr && !b.prs.includes(pr)) b.prs.push(pr);
+  }
+  const locals = new Set(m.branches.filter((b) => !b.remote).map((b) => b.name));
+  for (const ref of [...m.branches].sort((a, b) => Number(a.remote) - Number(b.remote))) {
+    if (ref.isDefault) continue;
+    const name = ref.remote ? ref.name.replace(/^[^/]+\//, "") : ref.name;
+    if (ref.remote && (locals.has(name) || name === "HEAD" || !name)) continue;
+    if (name === defaultName) continue;
+    add(name, firstParents(m, ref.sha, onMain, max));
+    const b = entry(name);
+    b.live = true;
+    b.merged ||= ref.merged;
+    if (!b.tipAt) b.tipAt = ref.at;
+  }
+  for (const [name, set2] of own2) {
+    entry(name).commits = [...set2].map((s) => m.bySha.get(s)).sort((a, b) => b.at - a.at).map((c) => c.sha);
+  }
+  const branches = [...byName.values()];
+  const ownerOf = /* @__PURE__ */ new Map();
+  for (const b of branches)
+    for (const s of b.commits) ownerOf.set(s, [...ownerOf.get(s) ?? [], b.name]);
+  return { defaultName, branches, ownerOf };
+}
+var PR_MERGE, BRANCH_MERGE;
+var init_lineage = __esm({
+  "src/history/lineage.ts"() {
+    "use strict";
+    init_esm_shims();
+    PR_MERGE = /^Merge pull request #(\d+) from [^/\s]+\/(\S+)/;
+    BRANCH_MERGE = /^Merge (?:remote-tracking )?branch '([^']+)'/;
+  }
+});
+
+// src/ui/history-graph-api.ts
+import { existsSync as existsSync24 } from "fs";
+import { join as join28 } from "path";
+function parseList(raw) {
+  if (!raw) return [];
+  try {
+    const v = JSON.parse(raw);
+    return Array.isArray(v) ? v.filter((x) => typeof x === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function metaOf3(raw) {
+  if (!raw) return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function historyGraphKnowledgePayload(ctx, opts = {}) {
+  const db = getStorage(ctx);
+  const m = getHistory(ctx, db);
+  if (!m) return NO_GIT2;
+  reconcile(ctx, db);
+  try {
+    ensureDocsGraph(ctx, db);
+  } catch {
+  }
+  return buildHistoryGraph(ctx, db, m, opts);
+}
+function buildHistoryGraph(ctx, db, m, opts = {}) {
+  const nBranches = Math.max(1, Math.min(50, opts.branches ?? 8));
+  const perBranch = Math.max(1, Math.min(200, opts.commitsPerBranch ?? 25));
+  const perCommit = Math.max(1, Math.min(200, opts.filesPerCommit ?? 12));
+  const limit = Math.max(20, Math.min(2e3, opts.limit ?? 400));
+  const focus = opts.focus?.trim() || null;
+  const { defaultName, branches, ownerOf } = branchLineage(m);
+  const branchBy = new Map(branches.map((b) => [b.name, b]));
+  const memDir = `${memoriesRel(ctx)}/`;
+  const memoryOfPath = (p) => p.startsWith(memDir) && p.endsWith(".md") ? p.slice(memDir.length, -3) : void 0;
+  const memRows = new Map(
+    db.memoryList({ limit: 1e5 }).filter((r) => r.name).map((r) => [r.name, r])
+  );
+  const memFiles = /* @__PURE__ */ new Map();
+  for (const [name, row] of memRows) {
+    const paths2 = /* @__PURE__ */ new Set();
+    for (const id of parseList(row.node_ids)) {
+      const f = fileOf(id);
+      if (f) paths2.add(f);
+    }
+    if (paths2.size) memFiles.set(name, [...paths2]);
+  }
+  const nonMerge = (cs) => cs.filter((c) => !c.merge);
+  const touching = (paths2, cap) => {
+    const out = /* @__PURE__ */ new Map();
+    for (const p of paths2) for (const c of nonMerge(commitsForFile(m, p))) out.set(c.sha, c);
+    return [...out.values()].sort((a, b) => b.at - a.at).slice(0, cap);
+  };
+  const commitSet = /* @__PURE__ */ new Map();
+  const branchSet = /* @__PURE__ */ new Set();
+  let onlyFiles = null;
+  const addCommits = (cs) => {
+    for (const c of cs) commitSet.set(c.sha, c);
+  };
+  let focusId = null;
+  let followOwners = true;
+  const kind = focus ? parseId(focus).kind : null;
+  if (!focus) {
+    followOwners = false;
+    const feature = branches.filter((b) => !b.isDefault && b.commits.length).sort((a, b) => b.tipAt - a.tipAt).slice(0, nBranches);
+    for (const b of feature) {
+      branchSet.add(b.name);
+      addCommits(b.commits.slice(0, perBranch).map((s) => m.bySha.get(s)));
+    }
+    const def = branchBy.get(defaultName);
+    if (def) {
+      branchSet.add(def.name);
+      const oldest = Math.min(...feature.map((b) => b.tipAt), Date.now());
+      addCommits(
+        def.commits.map((s) => m.bySha.get(s)).filter((c, i) => i < perBranch && (feature.length < nBranches || c.at >= oldest))
+      );
+    }
+  } else if (kind === "branch") {
+    const name = focus.slice("branch:".length);
+    const b = branchBy.get(name) ?? branches.find((x) => x.name.endsWith(`/${name}`));
+    if (b) {
+      focusId = branchId(b.name);
+      branchSet.add(b.name);
+      if (b.merged) branchSet.add(defaultName);
+      addCommits(b.commits.slice(0, 150).map((s) => m.bySha.get(s)));
+    }
+    followOwners = false;
+  } else if (kind === "commit") {
+    const c = resolveCommit(m, focus.slice("commit:".length));
+    if (c) {
+      focusId = commitId(c.sha);
+      addCommits([c]);
+      addCommits([...c.origins, ...c.blamedBy].flatMap((s) => m.bySha.get(s) ?? []));
+    }
+  } else if (kind === "memory") {
+    const name = focus.slice("memory:".length);
+    focusId = memoryId(name);
+    const paths2 = memFiles.get(name) ?? [];
+    onlyFiles = new Set(paths2);
+    const own2 = `${memDir}${name}.md`;
+    addCommits([...touching(paths2, 60), ...touching([own2], 20)]);
+  } else if (kind === "doc") {
+    focusId = focus;
+    const paths2 = db.graphEdgesFrom([focus], ["documents"]).map((e) => fileOf(e.dst)).filter((p) => !!p);
+    onlyFiles = new Set(paths2);
+    addCommits(touching(paths2, 60));
+  } else {
+    const path3 = fileOf(focus) ?? focus.replace(/^file:/, "");
+    focusId = fileId(path3);
+    onlyFiles = /* @__PURE__ */ new Set([path3]);
+    addCommits(touching([path3], 60));
+  }
+  if (followOwners)
+    for (const sha of commitSet.keys())
+      for (const name of ownerOf.get(sha) ?? []) branchSet.add(name);
+  const edges = /* @__PURE__ */ new Map();
+  const addEdge = (src, dst, kind2, weight = 1) => {
+    if (src === dst) return;
+    const key = `${src}|${dst}|${kind2}`;
+    if (!edges.has(key)) edges.set(key, { src, dst, kind: kind2, weight });
+  };
+  for (const name of branchSet) {
+    const b = branchBy.get(name);
+    if (!b) continue;
+    for (const sha of b.commits)
+      if (commitSet.has(sha)) addEdge(branchId(name), commitId(sha), "contains");
+    if (b.merged && !b.isDefault && branchSet.has(defaultName))
+      addEdge(branchId(name), branchId(defaultName), "merged_into");
+  }
+  const touchCount = /* @__PURE__ */ new Map();
+  const commitFiles = /* @__PURE__ */ new Map();
+  const recorded = /* @__PURE__ */ new Map();
+  for (const c of commitSet.values()) {
+    const mems = [];
+    const paths2 = [];
+    for (const f of [...c.files].sort((a, b) => b.added + b.deleted - (a.added + a.deleted))) {
+      const mem = memoryOfPath(f.path);
+      if (mem) {
+        mems.push(mem);
+        continue;
+      }
+      if (LOCKFILE.test(f.path)) continue;
+      if (onlyFiles && !onlyFiles.has(f.path)) continue;
+      paths2.push(f.path);
+    }
+    const kept2 = paths2.slice(0, perCommit);
+    commitFiles.set(c.sha, kept2);
+    for (const p of kept2) touchCount.set(p, (touchCount.get(p) ?? 0) + 1);
+    if (mems.length) recorded.set(c.sha, mems);
+  }
+  for (const p of onlyFiles ?? []) if (!touchCount.has(p)) touchCount.set(p, 0);
+  const fileBudget = Math.max(10, limit - branchSet.size - commitSet.size - 40);
+  const files = new Set(
+    [...touchCount.entries()].sort(
+      (a, b) => Number(onlyFiles?.has(b[0]) ?? false) - Number(onlyFiles?.has(a[0]) ?? false) || b[1] - a[1] || (m.files.get(b[0])?.risk ?? 0) - (m.files.get(a[0])?.risk ?? 0) || a[0].localeCompare(b[0])
+    ).slice(0, fileBudget).map(([p]) => p)
+  );
+  for (const [sha, paths2] of commitFiles)
+    for (const p of paths2) if (files.has(p)) addEdge(commitId(sha), fileId(p), "touches");
+  const memories = /* @__PURE__ */ new Set();
+  for (const [sha, mems] of recorded)
+    for (const name of mems) {
+      memories.add(name);
+      addEdge(commitId(sha), memoryId(name), "records");
+    }
+  for (const [name, paths2] of memFiles)
+    for (const p of paths2)
+      if (files.has(p)) {
+        memories.add(name);
+        addEdge(memoryId(name), fileId(p), "mentions");
+      }
+  if (kind === "memory" && focus) memories.add(focus.slice("memory:".length));
+  const docs = /* @__PURE__ */ new Set();
+  if (files.size)
+    for (const e of db.graphEdgesTo(
+      [...files].map((p) => fileId(p)),
+      ["documents"]
+    )) {
+      docs.add(e.src);
+      addEdge(e.src, e.dst, "documents");
+    }
+  if (kind === "doc" && focus) docs.add(focus);
+  for (const l of m.links)
+    if (commitSet.has(l.fix) && commitSet.has(l.origin))
+      addEdge(commitId(l.fix), commitId(l.origin), "fixes", Math.min(3, 1 + l.lines / 20));
+  const nodes = [];
+  for (const name of branchSet) {
+    const b = branchBy.get(name);
+    if (!b) continue;
+    const id = branchId(name);
+    nodes.push({
+      id,
+      label: name,
+      kind: "branch",
+      group: "branch",
+      path: null,
+      line: null,
+      root: id === focusId,
+      at: b.tipAt,
+      commits: b.commits.length,
+      merged: b.merged,
+      live: b.live,
+      isDefault: b.isDefault,
+      prs: b.prs.length ? b.prs : void 0
+    });
+  }
+  for (const c of commitSet.values()) {
+    const id = commitId(c.sha);
+    nodes.push({
+      id,
+      label: c.subject,
+      kind: "commit",
+      group: "commit",
+      path: null,
+      line: null,
+      root: id === focusId,
+      sub: c.kind,
+      bucket: c.bucket,
+      at: c.at,
+      author: c.author,
+      short: c.short,
+      risk: c.risk
+    });
+  }
+  for (const p of files) {
+    const id = fileId(p);
+    const h = m.files.get(p);
+    nodes.push({
+      id,
+      label: p,
+      kind: "file",
+      group: "file",
+      path: p,
+      line: null,
+      root: id === focusId,
+      missing: existsSync24(join28(ctx.root, p)) ? void 0 : true,
+      risk: h?.risk,
+      fixes: h?.fixes
+    });
+  }
+  for (const name of memories) {
+    const id = memoryId(name);
+    const row = memRows.get(name);
+    nodes.push({
+      id,
+      label: name,
+      kind: "memory",
+      group: "memory",
+      path: row?.path ?? null,
+      line: null,
+      root: id === focusId,
+      missing: row ? void 0 : true,
+      sub: row?.kind,
+      status: row?.status ?? (row?.kind === "decision" ? "accepted" : void 0),
+      detail: name.includes("/") ? `${name.split("/")[0]}/` : void 0
+    });
+  }
+  const docRows = new Map(db.graphGetNodes([...docs]).map((n) => [n.id, n]));
+  for (const id of docs) {
+    const row = docRows.get(id);
+    const meta4 = metaOf3(row?.meta);
+    const cat = typeof meta4.category === "string" ? meta4.category : void 0;
+    nodes.push({
+      id,
+      label: row?.name ?? id.slice("doc:".length),
+      kind: "doc",
+      group: "doc",
+      path: row?.path ?? null,
+      line: null,
+      root: id === focusId,
+      missing: row ? void 0 : true,
+      sub: cat,
+      detail: cat ? categoryInfo(cat).label : void 0
+    });
+  }
+  if (focusId && !nodes.some((n) => n.id === focusId)) {
+    const p = parseId(focusId);
+    nodes.push({
+      id: focusId,
+      label: p.rest,
+      kind: p.kind,
+      group: ["branch", "commit", "memory", "doc"].includes(p.kind) ? p.kind : "file",
+      path: p.kind === "file" ? p.rest : null,
+      line: null,
+      root: true,
+      missing: true
+    });
+  }
+  for (const n of nodes) if (n.root) n.seed = true;
+  const deg = /* @__PURE__ */ new Map();
+  for (const e of edges.values()) {
+    deg.set(e.src, (deg.get(e.src) ?? 0) + 1);
+    deg.set(e.dst, (deg.get(e.dst) ?? 0) + 1);
+  }
+  const RANK = {
+    branch: 1,
+    commit: 2,
+    memory: 3,
+    doc: 3,
+    file: 4
+  };
+  nodes.sort(
+    (a, b) => (a.root ? 0 : RANK[a.group]) - (b.root ? 0 : RANK[b.group]) || (b.at ?? 0) - (a.at ?? 0) || (deg.get(b.id) ?? 0) - (deg.get(a.id) ?? 0) || a.id.localeCompare(b.id)
+  );
+  const total = nodes.length;
+  const kept = nodes.slice(0, limit);
+  const keep = new Set(kept.map((n) => n.id));
+  const keptEdges = [...edges.values()].filter((e) => keep.has(e.src) && keep.has(e.dst));
+  return {
+    git: true,
+    focus: focusId ?? focus,
+    defaultBranch: defaultName,
+    nodes: kept,
+    edges: keptEdges,
+    truncated: total > kept.length,
+    total,
+    /** Every branch with own commits, newest first, for the focus picker. */
+    branches: branches.filter((b) => b.commits.length).sort((a, b) => Number(b.isDefault) - Number(a.isDefault) || b.tipAt - a.tipAt).map((b) => ({
+      name: b.name,
+      commits: b.commits.length,
+      tipAt: b.tipAt,
+      merged: b.merged,
+      live: b.live,
+      isDefault: b.isDefault
+    }))
+  };
+}
+var LOCKFILE, branchId, commitId, NO_GIT2;
+var init_history_graph_api = __esm({
+  "src/ui/history-graph-api.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_category();
+    init_graph();
+    init_ids();
+    init_lineage();
+    init_model();
+    init_store();
+    init_storage();
+    LOCKFILE = /(^|\/)(package-lock\.json|npm-shrinkwrap\.json|pnpm-lock\.yaml|yarn\.lock|bun\.lockb?|Cargo\.lock|go\.sum|poetry\.lock|uv\.lock|composer\.lock|Gemfile\.lock)$/;
+    branchId = (name) => `branch:${name}`;
+    commitId = (sha) => `commit:${sha}`;
+    NO_GIT2 = { git: false, error: "not a git repository (or no commits yet)" };
+  }
+});
+
 // src/ui/knowledge-api.ts
-function metaOf3(row) {
+function metaOf4(row) {
   if (!row?.meta) return {};
   try {
     return JSON.parse(row.meta);
@@ -43496,7 +43943,7 @@ function buildKnowledge(ctx, db, opts = {}) {
   const hubsOf = (id) => {
     const n = rows.get(id);
     if (!n) return [];
-    const m = metaOf3(n);
+    const m = metaOf4(n);
     const out = [];
     if (n.kind === "memory") {
       const row = memRows.get(n.name);
@@ -43626,7 +44073,7 @@ function buildKnowledge(ctx, db, opts = {}) {
     }
     const row = graphRows.get(id);
     const base = vis(row, id, id === focus);
-    const m = metaOf3(row);
+    const m = metaOf4(row);
     const node2 = {
       ...base,
       kind: row ? row.kind : kindOfMissing(id),
@@ -43705,9 +44152,9 @@ __export(server_exports, {
   uiDir: () => uiDir
 });
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync24, readFileSync as readFileSync22, statSync as statSync11 } from "fs";
+import { existsSync as existsSync25, readFileSync as readFileSync22, statSync as statSync11 } from "fs";
 import { createServer } from "http";
-import { extname as extname3, join as join28, normalize as normalize6 } from "path";
+import { extname as extname3, join as join29, normalize as normalize6 } from "path";
 import { URL as URL2 } from "url";
 function json2(res, status, body) {
   res.writeHead(status, {
@@ -43729,7 +44176,7 @@ function strList(v) {
   return void 0;
 }
 function uiDir() {
-  return process.env.EMINIAR_UI_DIR || join28(pluginRoot(), "dist", "ui");
+  return process.env.EMINIAR_UI_DIR || join29(pluginRoot(), "dist", "ui");
 }
 function originAllowed(req, port) {
   const host = req.headers.host ?? "";
@@ -43753,14 +44200,14 @@ function originAllowed(req, port) {
 function serveStatic(res, p) {
   const dir = uiDir();
   const rel = p === "/" ? "index.html" : p.replace(/^\/+/, "");
-  const file3 = normalize6(join28(dir, rel));
+  const file3 = normalize6(join29(dir, rel));
   if (!file3.startsWith(normalize6(dir))) return false;
-  if (!existsSync24(file3) || !statSync11(file3).isFile()) return false;
+  if (!existsSync25(file3) || !statSync11(file3).isFile()) return false;
   const type = MIME[extname3(file3).toLowerCase()] ?? "application/octet-stream";
   if (rel === "index.html") {
     const stamp = (name) => {
       try {
-        return `/${name}?v=${Math.floor(statSync11(join28(dir, name)).mtimeMs)}`;
+        return `/${name}?v=${Math.floor(statSync11(join29(dir, name)).mtimeMs)}`;
       } catch {
         return `/${name}`;
       }
@@ -44090,6 +44537,18 @@ async function serve(opts) {
       }
       if (p === "/api/history/graph")
         return json2(res, 200, historyGraphPayload(ctx(), num2("limit", 150)));
+      if (p === "/api/history/knowledge")
+        return json2(
+          res,
+          200,
+          historyGraphKnowledgePayload(ctx(), {
+            focus: str2("focus"),
+            branches: num2("branches", 8),
+            commitsPerBranch: num2("commits", 25),
+            filesPerCommit: num2("files", 12),
+            limit: num2("limit", 400)
+          })
+        );
       if (p === "/api/history/risk")
         return json2(res, 200, historyRiskPayload(ctx(), strList(q.get("paths"))));
       if (p === "/api/history/symbol") {
@@ -44144,6 +44603,7 @@ var init_server = __esm({
     init_api2();
     init_graph_api();
     init_history_api();
+    init_history_graph_api();
     init_knowledge_api();
     MIME = {
       ".html": "text/html; charset=utf-8",
@@ -44167,7 +44627,7 @@ var statusline_exports = {};
 __export(statusline_exports, {
   renderStatusline: () => renderStatusline
 });
-import { existsSync as existsSync25, readFileSync as readFileSync23, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync23, writeFileSync as writeFileSync9 } from "fs";
 function renderStatusline(raw) {
   let input2 = {};
   try {
@@ -44176,7 +44636,7 @@ function renderStatusline(raw) {
   }
   const cache3 = paths().statuslineCache;
   try {
-    if (existsSync25(cache3)) {
+    if (existsSync26(cache3)) {
       const c = JSON.parse(readFileSync23(cache3, "utf8"));
       if (Date.now() - c.at < 5e3 && c.key === (input2.session_id ?? "")) return c.line;
     }

package/dist/server.js

@@ -18023,6 +18023,7 @@ __export(store_exports, {
   isValidName: () => isValidName,
   list: () => list,
   memoriesDir: () => memoriesDir,
+  memoriesRel: () => memoriesRel,
   memoryLinks: () => memoryLinks,
   normalizeRelated: () => normalizeRelated,
   read: () => read,