march-cli 0.1.21 → 0.1.22

package/src/memory/glossary.mjs

@@ -1,124 +1,124 @@
-export class GlossaryService {
-  constructor(db, namespace = "") {
-    this.db = db;
-    this.namespace = namespace;
-    this.fingerprint = null;
-    this.automaton = null;
-  }
-
-  // ── Aho-Corasick automaton ────────────────────────────────────────
-
-  #ensureAutomaton() {
-    const fp = this.#computeFingerprint();
-    if (fp === this.fingerprint && this.automaton) return;
-    this.fingerprint = fp;
-    this.automaton = this.#buildAutomaton();
-  }
-
-  #computeFingerprint() {
-    const row = this.db.prepare(
-      "SELECT COUNT(*) AS cnt, MAX(id) AS max_id FROM glossary_keywords WHERE namespace = ? OR namespace = 'global'"
-    ).get(this.namespace);
-    return `${row.cnt}:${row.max_id}`;
-  }
-
-  #buildAutomaton() {
-    const keywords = this.db.prepare(
-      "SELECT id, keyword, node_uuid FROM glossary_keywords WHERE namespace = ? OR namespace = 'global'"
-    ).all(this.namespace);
-
-    // Build trie
-    const go = [new Map()];
-    const fail = [0];
-    const output = [new Map()];
-
-    for (const kw of keywords) {
-      let state = 0;
-      for (const ch of kw.keyword) {
-        let next = go[state].get(ch);
-        if (next === undefined) {
-          next = go.length;
-          go.push(new Map());
-          fail.push(0);
-          output.push(new Map());
-          go[state].set(ch, next);
-        }
-        state = next;
-      }
-      output[state].set(kw.id, kw.node_uuid);
-    }
-
-    // Build failure links (BFS)
-    const queue = [];
-    for (const [ch, next] of go[0]) {
-      fail[next] = 0;
-      queue.push(next);
-    }
-
-    while (queue.length > 0) {
-      const r = queue.shift();
-      for (const [ch, s] of go[r]) {
-        queue.push(s);
-        let f = fail[r];
-        while (f > 0 && !go[f].has(ch)) f = fail[f];
-        fail[s] = go[f].has(ch) ? go[f].get(ch) : 0;
-        for (const [kwId, nodeUuid] of output[fail[s]]) {
-          output[s].set(kwId, nodeUuid);
-        }
-      }
-    }
-
-    return { go, fail, output };
-  }
-
-  // ── Public API ─────────────────────────────────────────────────────
-
-  addKeyword(keyword, nodeUuid, namespace = "") {
-    this.db.prepare(
-      "INSERT OR IGNORE INTO glossary_keywords (keyword, node_uuid, namespace) VALUES (?, ?, ?)"
-    ).run(keyword, nodeUuid, namespace);
-    this.fingerprint = null;
-  }
-
-  removeKeyword(keywordId) {
-    this.db.prepare("DELETE FROM glossary_keywords WHERE id = ?").run(keywordId);
-    this.fingerprint = null;
-  }
-
-  findInContent(content) {
-    if (!content) return [];
-    this.#ensureAutomaton();
-    if (!this.automaton) return [];
-
-    const { go, fail, output } = this.automaton;
-    const matches = [];
-    const seen = new Set();
-    let state = 0;
-
-    for (let i = 0; i < content.length; i++) {
-      const ch = content[i];
-      while (state > 0 && !go[state].has(ch)) state = fail[state];
-      state = go[state].has(ch) ? go[state].get(ch) : 0;
-
-      for (const [kwId, nodeUuid] of output[state]) {
-        if (seen.has(kwId)) continue;
-        seen.add(kwId);
-        matches.push({ keyword_id: kwId, node_uuid: nodeUuid });
-      }
-    }
-
-    return matches;
-  }
-
-  getAllKeywords() {
-    return this.db.prepare(
-      "SELECT * FROM glossary_keywords WHERE namespace = ? OR namespace = 'global' ORDER BY keyword"
-    ).all(this.namespace);
-  }
-
-  getKeywordsForNode(nodeUuid) {
-    return this.db.prepare(
-      "SELECT * FROM glossary_keywords WHERE node_uuid = ? AND (namespace = ? OR namespace = 'global')"
-    ).all(nodeUuid, this.namespace);
-  }
-}
+export class GlossaryService {
+  constructor(db, namespace = "") {
+    this.db = db;
+    this.namespace = namespace;
+    this.fingerprint = null;
+    this.automaton = null;
+  }
+
+  // ── Aho-Corasick automaton ────────────────────────────────────────
+
+  #ensureAutomaton() {
+    const fp = this.#computeFingerprint();
+    if (fp === this.fingerprint && this.automaton) return;
+    this.fingerprint = fp;
+    this.automaton = this.#buildAutomaton();
+  }
+
+  #computeFingerprint() {
+    const row = this.db.prepare(
+      "SELECT COUNT(*) AS cnt, MAX(id) AS max_id FROM glossary_keywords WHERE namespace = ? OR namespace = 'global'"
+    ).get(this.namespace);
+    return `${row.cnt}:${row.max_id}`;
+  }
+
+  #buildAutomaton() {
+    const keywords = this.db.prepare(
+      "SELECT id, keyword, node_uuid FROM glossary_keywords WHERE namespace = ? OR namespace = 'global'"
+    ).all(this.namespace);
+
+    // Build trie
+    const go = [new Map()];
+    const fail = [0];
+    const output = [new Map()];
+
+    for (const kw of keywords) {
+      let state = 0;
+      for (const ch of kw.keyword) {
+        let next = go[state].get(ch);
+        if (next === undefined) {
+          next = go.length;
+          go.push(new Map());
+          fail.push(0);
+          output.push(new Map());
+          go[state].set(ch, next);
+        }
+        state = next;
+      }
+      output[state].set(kw.id, kw.node_uuid);
+    }
+
+    // Build failure links (BFS)
+    const queue = [];
+    for (const [ch, next] of go[0]) {
+      fail[next] = 0;
+      queue.push(next);
+    }
+
+    while (queue.length > 0) {
+      const r = queue.shift();
+      for (const [ch, s] of go[r]) {
+        queue.push(s);
+        let f = fail[r];
+        while (f > 0 && !go[f].has(ch)) f = fail[f];
+        fail[s] = go[f].has(ch) ? go[f].get(ch) : 0;
+        for (const [kwId, nodeUuid] of output[fail[s]]) {
+          output[s].set(kwId, nodeUuid);
+        }
+      }
+    }
+
+    return { go, fail, output };
+  }
+
+  // ── Public API ─────────────────────────────────────────────────────
+
+  addKeyword(keyword, nodeUuid, namespace = "") {
+    this.db.prepare(
+      "INSERT OR IGNORE INTO glossary_keywords (keyword, node_uuid, namespace) VALUES (?, ?, ?)"
+    ).run(keyword, nodeUuid, namespace);
+    this.fingerprint = null;
+  }
+
+  removeKeyword(keywordId) {
+    this.db.prepare("DELETE FROM glossary_keywords WHERE id = ?").run(keywordId);
+    this.fingerprint = null;
+  }
+
+  findInContent(content) {
+    if (!content) return [];
+    this.#ensureAutomaton();
+    if (!this.automaton) return [];
+
+    const { go, fail, output } = this.automaton;
+    const matches = [];
+    const seen = new Set();
+    let state = 0;
+
+    for (let i = 0; i < content.length; i++) {
+      const ch = content[i];
+      while (state > 0 && !go[state].has(ch)) state = fail[state];
+      state = go[state].has(ch) ? go[state].get(ch) : 0;
+
+      for (const [kwId, nodeUuid] of output[state]) {
+        if (seen.has(kwId)) continue;
+        seen.add(kwId);
+        matches.push({ keyword_id: kwId, node_uuid: nodeUuid });
+      }
+    }
+
+    return matches;
+  }
+
+  getAllKeywords() {
+    return this.db.prepare(
+      "SELECT * FROM glossary_keywords WHERE namespace = ? OR namespace = 'global' ORDER BY keyword"
+    ).all(this.namespace);
+  }
+
+  getKeywordsForNode(nodeUuid) {
+    return this.db.prepare(
+      "SELECT * FROM glossary_keywords WHERE node_uuid = ? AND (namespace = ? OR namespace = 'global')"
+    ).all(nodeUuid, this.namespace);
+  }
+}

package/src/memory/graph/graph-cascades.mjs

@@ -1,109 +1,109 @@
-import { ROOT_NODE_UUID } from "../database.mjs";
-import { escapeLikePath } from "./graph-path-utils.mjs";
-import {
-  countPathsForEdge,
-  insertPath,
-} from "./graph-primitives.mjs";
-
-export function deprecateNodeMemories(db, nodeUuid, successorId = null) {
-  const conditions = ["node_uuid = ?", "deprecated = 0"];
-  const params = [nodeUuid];
-  if (successorId !== null) {
-    conditions.push("id != ?");
-    params.push(successorId);
-  }
-  const ids = db.prepare(
-    `SELECT id FROM memories WHERE ${conditions.join(" AND ")}`
-  ).all(...params).map(r => r.id);
-
-  if (ids.length > 0) {
-    const placeholders = ids.map(() => "?").join(",");
-    db.prepare(
-      `UPDATE memories SET deprecated = 1, migrated_to = ? WHERE id IN (${placeholders})`
-    ).run(successorId, ...ids);
-  }
-  return ids;
-}
-
-export function cascadeCreatePaths(db, nodeUuid, domain, basePath, namespace = "", visited = new Set()) {
-  if (visited.has(nodeUuid)) return;
-  visited.add(nodeUuid);
-  try {
-    const childEdges = db.prepare(
-      "SELECT * FROM edges WHERE parent_uuid = ?"
-    ).all(nodeUuid);
-    for (const edge of childEdges) {
-      const childPath = `${basePath}/${edge.name}`;
-      insertPath(db, namespace, domain, childPath, edge.id, edge.child_uuid);
-      cascadeCreatePaths(db, edge.child_uuid, domain, childPath, namespace, visited);
-    }
-  } finally {
-    visited.delete(nodeUuid);
-  }
-}
-
-export function deleteSubtreePaths(db, domain, path, namespace = "") {
-  const safe = escapeLikePath(path);
-  const rows = db.prepare(`
-    SELECT namespace, domain, path, edge_id, node_uuid
-    FROM paths
-    WHERE namespace = ? AND domain = ? AND (path = ? OR path LIKE ? ESCAPE '\\')
-  `).all(namespace, domain, path, `${safe}/%`);
-
-  for (const row of rows) {
-    db.prepare(
-      "DELETE FROM paths WHERE namespace = ? AND domain = ? AND path = ?"
-    ).run(row.namespace, row.domain, row.path);
-  }
-  return rows;
-}
-
-export function cascadeDeleteEdge(db, edge) {
-  const edgePaths = db.prepare(
-    "SELECT * FROM paths WHERE edge_id = ?"
-  ).all(edge.id);
-
-  for (const path of edgePaths) {
-    deleteSubtreePaths(db, path.domain, path.path, path.namespace);
-  }
-  db.prepare("DELETE FROM edges WHERE id = ?").run(edge.id);
-}
-
-export function cascadeDeleteNode(db, nodeUuid) {
-  if (nodeUuid === ROOT_NODE_UUID) return null;
-
-  const edges = db.prepare(
-    "SELECT * FROM edges WHERE parent_uuid = ? OR child_uuid = ?"
-  ).all(nodeUuid, nodeUuid);
-  for (const edge of edges) {
-    cascadeDeleteEdge(db, edge);
-  }
-
-  db.prepare("DELETE FROM memories WHERE node_uuid = ?").run(nodeUuid);
-  db.prepare("DELETE FROM glossary_keywords WHERE node_uuid = ?").run(nodeUuid);
-  db.prepare("DELETE FROM nodes WHERE uuid = ?").run(nodeUuid);
-  return { deleted: nodeUuid };
-}
-
-export function gcEdgeIfPathless(db, edge) {
-  if (countPathsForEdge(db, edge.id) > 0) return null;
-  db.prepare("DELETE FROM edges WHERE id = ?").run(edge.id);
-  return { edge_id: edge.id, parent_uuid: edge.parent_uuid, child_uuid: edge.child_uuid };
-}
-
-export function gcNodeSoft(db, nodeUuid) {
-  if (nodeUuid === ROOT_NODE_UUID) return;
-
-  const row = db.prepare(
-    "SELECT COUNT(*) AS cnt FROM paths WHERE node_uuid = ?"
-  ).get(nodeUuid);
-  if (row.cnt > 0) return;
-
-  const incoming = db.prepare("SELECT * FROM edges WHERE child_uuid = ?").all(nodeUuid);
-  for (const edge of incoming) gcEdgeIfPathless(db, edge);
-
-  const outgoing = db.prepare("SELECT * FROM edges WHERE parent_uuid = ?").all(nodeUuid);
-  for (const edge of outgoing) cascadeDeleteEdge(db, edge);
-
-  deprecateNodeMemories(db, nodeUuid);
-}
+import { ROOT_NODE_UUID } from "../database.mjs";
+import { escapeLikePath } from "./graph-path-utils.mjs";
+import {
+  countPathsForEdge,
+  insertPath,
+} from "./graph-primitives.mjs";
+
+export function deprecateNodeMemories(db, nodeUuid, successorId = null) {
+  const conditions = ["node_uuid = ?", "deprecated = 0"];
+  const params = [nodeUuid];
+  if (successorId !== null) {
+    conditions.push("id != ?");
+    params.push(successorId);
+  }
+  const ids = db.prepare(
+    `SELECT id FROM memories WHERE ${conditions.join(" AND ")}`
+  ).all(...params).map(r => r.id);
+
+  if (ids.length > 0) {
+    const placeholders = ids.map(() => "?").join(",");
+    db.prepare(
+      `UPDATE memories SET deprecated = 1, migrated_to = ? WHERE id IN (${placeholders})`
+    ).run(successorId, ...ids);
+  }
+  return ids;
+}
+
+export function cascadeCreatePaths(db, nodeUuid, domain, basePath, namespace = "", visited = new Set()) {
+  if (visited.has(nodeUuid)) return;
+  visited.add(nodeUuid);
+  try {
+    const childEdges = db.prepare(
+      "SELECT * FROM edges WHERE parent_uuid = ?"
+    ).all(nodeUuid);
+    for (const edge of childEdges) {
+      const childPath = `${basePath}/${edge.name}`;
+      insertPath(db, namespace, domain, childPath, edge.id, edge.child_uuid);
+      cascadeCreatePaths(db, edge.child_uuid, domain, childPath, namespace, visited);
+    }
+  } finally {
+    visited.delete(nodeUuid);
+  }
+}
+
+export function deleteSubtreePaths(db, domain, path, namespace = "") {
+  const safe = escapeLikePath(path);
+  const rows = db.prepare(`
+    SELECT namespace, domain, path, edge_id, node_uuid
+    FROM paths
+    WHERE namespace = ? AND domain = ? AND (path = ? OR path LIKE ? ESCAPE '\\')
+  `).all(namespace, domain, path, `${safe}/%`);
+
+  for (const row of rows) {
+    db.prepare(
+      "DELETE FROM paths WHERE namespace = ? AND domain = ? AND path = ?"
+    ).run(row.namespace, row.domain, row.path);
+  }
+  return rows;
+}
+
+export function cascadeDeleteEdge(db, edge) {
+  const edgePaths = db.prepare(
+    "SELECT * FROM paths WHERE edge_id = ?"
+  ).all(edge.id);
+
+  for (const path of edgePaths) {
+    deleteSubtreePaths(db, path.domain, path.path, path.namespace);
+  }
+  db.prepare("DELETE FROM edges WHERE id = ?").run(edge.id);
+}
+
+export function cascadeDeleteNode(db, nodeUuid) {
+  if (nodeUuid === ROOT_NODE_UUID) return null;
+
+  const edges = db.prepare(
+    "SELECT * FROM edges WHERE parent_uuid = ? OR child_uuid = ?"
+  ).all(nodeUuid, nodeUuid);
+  for (const edge of edges) {
+    cascadeDeleteEdge(db, edge);
+  }
+
+  db.prepare("DELETE FROM memories WHERE node_uuid = ?").run(nodeUuid);
+  db.prepare("DELETE FROM glossary_keywords WHERE node_uuid = ?").run(nodeUuid);
+  db.prepare("DELETE FROM nodes WHERE uuid = ?").run(nodeUuid);
+  return { deleted: nodeUuid };
+}
+
+export function gcEdgeIfPathless(db, edge) {
+  if (countPathsForEdge(db, edge.id) > 0) return null;
+  db.prepare("DELETE FROM edges WHERE id = ?").run(edge.id);
+  return { edge_id: edge.id, parent_uuid: edge.parent_uuid, child_uuid: edge.child_uuid };
+}
+
+export function gcNodeSoft(db, nodeUuid) {
+  if (nodeUuid === ROOT_NODE_UUID) return;
+
+  const row = db.prepare(
+    "SELECT COUNT(*) AS cnt FROM paths WHERE node_uuid = ?"
+  ).get(nodeUuid);
+  if (row.cnt > 0) return;
+
+  const incoming = db.prepare("SELECT * FROM edges WHERE child_uuid = ?").all(nodeUuid);
+  for (const edge of incoming) gcEdgeIfPathless(db, edge);
+
+  const outgoing = db.prepare("SELECT * FROM edges WHERE parent_uuid = ?").all(nodeUuid);
+  for (const edge of outgoing) cascadeDeleteEdge(db, edge);
+
+  deprecateNodeMemories(db, nodeUuid);
+}

package/src/memory/graph/graph-diagnostics.mjs

@@ -1,73 +1,73 @@
-import { ROOT_NODE_UUID } from "../database.mjs";
-
-export function getGraphDiagnostics(db, namespace = "", daysStale = 30, maxChildren = 10) {
-  const cutoff = new Date(Date.now() - daysStale * 86400000).toISOString();
-
-  const allRows = db.prepare(`
-    SELECT p.domain, p.path, p.node_uuid, n.created_at, n.last_accessed_at,
-           e.priority, m.id AS memory_id
-    FROM paths p
-    JOIN edges e ON p.edge_id = e.id
-    JOIN nodes n ON n.uuid = e.child_uuid
-    JOIN memories m ON m.node_uuid = n.uuid AND m.deprecated = 0
-    WHERE p.namespace = ?
-  `).all(namespace);
-
-  const staleNodes = {};
-  for (const row of allRows) {
-    const effective = row.last_accessed_at ?? row.created_at ?? cutoff;
-    if (effective >= cutoff) continue;
-    const staleDays = Math.round((Date.now() - new Date(effective).getTime()) / 86400000);
-    const key = row.node_uuid;
-    if (!staleNodes[key] || (row.priority ?? 999) < (staleNodes[key].priority ?? 999)) {
-      staleNodes[key] = {
-        uuid: row.node_uuid,
-        uri: `${row.domain}://${row.path}`,
-        created_at: row.created_at,
-        last_accessed_at: row.last_accessed_at,
-        stale_days: staleDays,
-        priority: row.priority,
-        title: row.path.split("/").pop(),
-        memory_id: row.memory_id,
-      };
-    }
-  }
-
-  const crowdedRows = db.prepare(`
-    SELECT e.parent_uuid, COUNT(DISTINCT e.child_uuid) AS child_count
-    FROM edges e
-    JOIN paths p ON p.edge_id = e.id
-    WHERE p.namespace = ?
-    GROUP BY e.parent_uuid
-    HAVING child_count > ?
-  `).all(namespace, maxChildren);
-
-  const crowdedParents = {};
-  for (const row of crowdedRows) {
-    if (row.parent_uuid === ROOT_NODE_UUID) {
-      crowdedParents[row.parent_uuid] = {
-        uuid: row.parent_uuid,
-        uri: "core://",
-        title: "(root)",
-        child_count: row.child_count,
-      };
-    } else {
-      const p = db.prepare(
-        "SELECT domain, path FROM paths WHERE node_uuid = ? AND namespace = ? LIMIT 1"
-      ).get(row.parent_uuid, namespace);
-      if (p) {
-        crowdedParents[row.parent_uuid] = {
-          uuid: row.parent_uuid,
-          uri: `${p.domain}://${p.path}`,
-          title: p.path.split("/").pop(),
-          child_count: row.child_count,
-        };
-      }
-    }
-  }
-
-  return {
-    stale_nodes: Object.values(staleNodes).sort((a, b) => (a.last_accessed_at ?? a.created_at ?? "").localeCompare(b.last_accessed_at ?? b.created_at ?? "")),
-    crowded_nodes: Object.values(crowdedParents).sort((a, b) => b.child_count - a.child_count),
-  };
-}
+import { ROOT_NODE_UUID } from "../database.mjs";
+
+export function getGraphDiagnostics(db, namespace = "", daysStale = 30, maxChildren = 10) {
+  const cutoff = new Date(Date.now() - daysStale * 86400000).toISOString();
+
+  const allRows = db.prepare(`
+    SELECT p.domain, p.path, p.node_uuid, n.created_at, n.last_accessed_at,
+           e.priority, m.id AS memory_id
+    FROM paths p
+    JOIN edges e ON p.edge_id = e.id
+    JOIN nodes n ON n.uuid = e.child_uuid
+    JOIN memories m ON m.node_uuid = n.uuid AND m.deprecated = 0
+    WHERE p.namespace = ?
+  `).all(namespace);
+
+  const staleNodes = {};
+  for (const row of allRows) {
+    const effective = row.last_accessed_at ?? row.created_at ?? cutoff;
+    if (effective >= cutoff) continue;
+    const staleDays = Math.round((Date.now() - new Date(effective).getTime()) / 86400000);
+    const key = row.node_uuid;
+    if (!staleNodes[key] || (row.priority ?? 999) < (staleNodes[key].priority ?? 999)) {
+      staleNodes[key] = {
+        uuid: row.node_uuid,
+        uri: `${row.domain}://${row.path}`,
+        created_at: row.created_at,
+        last_accessed_at: row.last_accessed_at,
+        stale_days: staleDays,
+        priority: row.priority,
+        title: row.path.split("/").pop(),
+        memory_id: row.memory_id,
+      };
+    }
+  }
+
+  const crowdedRows = db.prepare(`
+    SELECT e.parent_uuid, COUNT(DISTINCT e.child_uuid) AS child_count
+    FROM edges e
+    JOIN paths p ON p.edge_id = e.id
+    WHERE p.namespace = ?
+    GROUP BY e.parent_uuid
+    HAVING child_count > ?
+  `).all(namespace, maxChildren);
+
+  const crowdedParents = {};
+  for (const row of crowdedRows) {
+    if (row.parent_uuid === ROOT_NODE_UUID) {
+      crowdedParents[row.parent_uuid] = {
+        uuid: row.parent_uuid,
+        uri: "core://",
+        title: "(root)",
+        child_count: row.child_count,
+      };
+    } else {
+      const p = db.prepare(
+        "SELECT domain, path FROM paths WHERE node_uuid = ? AND namespace = ? LIMIT 1"
+      ).get(row.parent_uuid, namespace);
+      if (p) {
+        crowdedParents[row.parent_uuid] = {
+          uuid: row.parent_uuid,
+          uri: `${p.domain}://${p.path}`,
+          title: p.path.split("/").pop(),
+          child_count: row.child_count,
+        };
+      }
+    }
+  }
+
+  return {
+    stale_nodes: Object.values(staleNodes).sort((a, b) => (a.last_accessed_at ?? a.created_at ?? "").localeCompare(b.last_accessed_at ?? b.created_at ?? "")),
+    crowded_nodes: Object.values(crowdedParents).sort((a, b) => b.child_count - a.child_count),
+  };
+}