march-cli 0.1.22 → 0.1.23

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

@@ -1,109 +0,0 @@
-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 +0,0 @@
-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),
-  };
-}

package/src/memory/graph/graph-path-removal.mjs

@@ -1,50 +0,0 @@
-import { deleteSubtreePaths, gcEdgeIfPathless, gcNodeSoft } from "./graph-cascades.mjs";
-import { escapeLikePath, graphUri } from "./graph-path-utils.mjs";
-import { resolveGraphPath } from "./graph-primitives.mjs";
-
-export function removeGraphPath(db, path, domain = "core", namespace = "") {
-  if (path === "") throw new Error("Cannot remove root path.");
-
-  const target = resolveGraphPath(db, path, domain, namespace);
-  if (!target) throw new Error(`Path '${graphUri(domain, path)}' not found`);
-
-  const targetNodeUuid = target.node_uuid;
-  const targetEdge = target.edge;
-  if (!targetEdge) throw new Error(`Path '${domain}://${path}' has no edge.`);
-
-  const wouldOrphan = findWouldOrphanChildren(db, { path, domain, namespace, targetNodeUuid });
-  if (wouldOrphan.length > 0) {
-    const details = wouldOrphan.map(e => `'${e.name}' (${e.child_uuid.slice(0, 8)}...)`).join(", ");
-    throw new Error(`Cannot remove '${graphUri(domain, path)}': children would become unreachable: ${details}`);
-  }
-
-  deleteSubtreePaths(db, domain, path, namespace);
-  gcEdgeIfPathless(db, targetEdge);
-  gcNodeSoft(db, targetNodeUuid);
-  return { deleted: graphUri(domain, path) };
-}
-
-function findWouldOrphanChildren(db, { path, domain, namespace, targetNodeUuid }) {
-  const childEdges = db.prepare("SELECT * FROM edges WHERE parent_uuid = ?").all(targetNodeUuid);
-  const wouldOrphan = [];
-  const safe = escapeLikePath(path);
-
-  for (const childEdge of childEdges) {
-    const surviving = db.prepare(`
-      SELECT COUNT(*) AS cnt FROM paths
-      WHERE node_uuid = ?
-      AND NOT (domain = ? AND (path = ? OR path LIKE ? ESCAPE '\\'))
-    `).get(childEdge.child_uuid, domain, path, `${safe}/%`);
-    if (surviving.cnt > 0) continue;
-
-    const targetSurviving = db.prepare(`
-      SELECT * FROM paths
-      WHERE node_uuid = ? AND namespace = ?
-      AND NOT (domain = ? AND (path = ? OR path LIKE ? ESCAPE '\\'))
-      ORDER BY CASE WHEN domain = ? THEN 0 ELSE 1 END, path
-      LIMIT 1
-    `).get(targetNodeUuid, namespace, domain, path, `${safe}/%`, domain);
-    if (!targetSurviving) wouldOrphan.push(childEdge);
-  }
-  return wouldOrphan;
-}

package/src/memory/graph/graph-path-utils.mjs

@@ -1,17 +0,0 @@
-export function escapeLikePath(path) {
-  return String(path).replace(/[%_]/g, "\\$&");
-}
-
-export function graphUri(domain, path) {
-  return `${domain}://${path}`;
-}
-
-export function leafName(path) {
-  return String(path).split("/").pop();
-}
-
-export function pathExists(db, namespace, domain, path) {
-  return Boolean(db.prepare(
-    "SELECT 1 FROM paths WHERE namespace = ? AND domain = ? AND path = ?"
-  ).get(namespace, domain, path));
-}

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

@@ -1,103 +0,0 @@
-import { ROOT_NODE_UUID } from "../database.mjs";
-
-export function ensureNode(db, nodeUuid) {
-  const existing = db.prepare("SELECT uuid FROM nodes WHERE uuid = ?").get(nodeUuid);
-  if (!existing) {
-    db.prepare("INSERT INTO nodes (uuid) VALUES (?)").run(nodeUuid);
-  }
-  return nodeUuid;
-}
-
-export function insertMemory(db, nodeUuid, content, deprecated = false) {
-  const result = db.prepare(
-    "INSERT INTO memories (node_uuid, content, deprecated) VALUES (?, ?, ?)"
-  ).run(nodeUuid, content, deprecated ? 1 : 0);
-  return { id: Number(result.lastInsertRowid), node_uuid: nodeUuid, content, deprecated: deprecated ? 1 : 0 };
-}
-
-export function getOrCreateEdge(db, parentUuid, childUuid, name, priority = 0, disclosure = null) {
-  const existing = db.prepare(
-    "SELECT id, parent_uuid, child_uuid, name, priority, disclosure FROM edges WHERE parent_uuid = ? AND child_uuid = ?"
-  ).get(parentUuid, childUuid);
-
-  if (existing) return { edge: existing, created: false };
-
-  const result = db.prepare(
-    "INSERT INTO edges (parent_uuid, child_uuid, name, priority, disclosure) VALUES (?, ?, ?, ?, ?)"
-  ).run(parentUuid, childUuid, name, priority, disclosure);
-  const edge = {
-    id: Number(result.lastInsertRowid), parent_uuid: parentUuid, child_uuid: childUuid,
-    name, priority, disclosure,
-  };
-  return { edge, created: true };
-}
-
-export function insertPath(db, namespace, domain, path, edgeId, nodeUuid) {
-  db.prepare(
-    "INSERT OR IGNORE INTO paths (namespace, domain, path, edge_id, node_uuid) VALUES (?, ?, ?, ?, ?)"
-  ).run(namespace, domain, path, edgeId, nodeUuid);
-}
-
-export function resolveGraphPath(db, path, domain = "core", namespace = "") {
-  if (path === "") {
-    return { node_uuid: ROOT_NODE_UUID, edge: null, path_obj: null };
-  }
-  const row = db.prepare(`
-    SELECT p.namespace, p.domain, p.path, p.edge_id, p.node_uuid,
-           e.parent_uuid, e.child_uuid, e.name, e.priority, e.disclosure
-    FROM paths p
-    JOIN edges e ON p.edge_id = e.id
-    WHERE p.namespace = ? AND p.domain = ? AND p.path = ?
-  `).get(namespace, domain, path);
-
-  if (!row) return null;
-  return {
-    path_obj: { namespace: row.namespace, domain: row.domain, path: row.path, edge_id: row.edge_id, node_uuid: row.node_uuid },
-    edge: { id: row.edge_id, parent_uuid: row.parent_uuid, child_uuid: row.child_uuid, name: row.name, priority: row.priority, disclosure: row.disclosure },
-    node_uuid: row.node_uuid,
-  };
-}
-
-export function countPathsForEdge(db, edgeId) {
-  const row = db.prepare("SELECT COUNT(*) AS cnt FROM paths WHERE edge_id = ?").get(edgeId);
-  return row.cnt;
-}
-
-export function countMemoriesForNode(db, nodeUuid) {
-  const row = db.prepare("SELECT COUNT(*) AS cnt FROM memories WHERE node_uuid = ?").get(nodeUuid);
-  return row.cnt;
-}
-
-export function getNextChildNumber(db, parentUuid, namespace) {
-  const rows = db.prepare(`
-    SELECT e.name FROM edges e
-    JOIN paths p ON p.edge_id = e.id
-    WHERE e.parent_uuid = ? AND p.namespace = ?
-  `).all(parentUuid, namespace);
-  let maxNum = 0;
-  for (const row of rows) {
-    const num = parseInt(row.name, 10);
-    if (!Number.isNaN(num) && num > maxNum) maxNum = num;
-  }
-  return maxNum + 1;
-}
-
-export function wouldCreateCycle(db, parentUuid, childUuid) {
-  if (parentUuid === ROOT_NODE_UUID) return false;
-  if (parentUuid === childUuid) return true;
-
-  const visited = new Set([childUuid]);
-  const queue = [childUuid];
-  while (queue.length > 0) {
-    const current = queue.shift();
-    const rows = db.prepare("SELECT child_uuid FROM edges WHERE parent_uuid = ?").all(current);
-    for (const row of rows) {
-      if (row.child_uuid === parentUuid) return true;
-      if (!visited.has(row.child_uuid)) {
-        visited.add(row.child_uuid);
-        queue.push(row.child_uuid);
-      }
-    }
-  }
-  return false;
-}

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

@@ -1,159 +0,0 @@
-import { ROOT_NODE_UUID } from "../database.mjs";
-
-export function getMemoryByPath(db, path, domain = "core", namespace = "") {
-  if (path === "") {
-    return {
-      id: 0, node_uuid: ROOT_NODE_UUID,
-      content: `Root node for domain '${domain}'.`,
-      priority: 0, disclosure: null, deprecated: false,
-      created_at: null, domain, path: "", alias_count: 0,
-    };
-  }
-
-  const row = db.prepare(`
-    SELECT m.id, m.node_uuid, m.content, m.deprecated, m.created_at,
-           e.priority, e.disclosure, p.domain, p.path
-    FROM paths p
-    JOIN edges e ON p.edge_id = e.id
-    JOIN memories m ON m.node_uuid = e.child_uuid AND m.deprecated = 0
-    WHERE p.namespace = ? AND p.domain = ? AND p.path = ?
-    ORDER BY m.created_at DESC
-    LIMIT 1
-  `).get(namespace, domain, path);
-
-  if (!row) return null;
-
-  const totalPaths = countIncomingPaths(db, row.node_uuid, namespace);
-  const aliasCount = Math.max(0, totalPaths - 1);
-
-  return {
-    id: row.id, node_uuid: row.node_uuid, content: row.content,
-    priority: row.priority, disclosure: row.disclosure,
-    deprecated: !!row.deprecated, created_at: row.created_at,
-    domain: row.domain, path: row.path, alias_count: aliasCount,
-  };
-}
-
-export function getChildren(db, nodeUuid = ROOT_NODE_UUID, contextDomain = null, contextPath = null, namespace = "") {
-  const rows = db.prepare(`
-    SELECT DISTINCT e.id AS edge_id, e.child_uuid, e.name, e.priority, e.disclosure,
-           m.content, m.id AS memory_id
-    FROM edges e
-    JOIN paths p ON p.edge_id = e.id
-    JOIN memories m ON m.node_uuid = e.child_uuid AND m.deprecated = 0
-    WHERE e.parent_uuid = ? AND p.namespace = ?
-    ORDER BY e.priority ASC, e.name
-  `).all(nodeUuid, namespace);
-
-  const childUuids = [...new Set(rows.map(r => r.child_uuid))];
-  const edgeIds = [...new Set(rows.map(r => r.edge_id))];
-
-  const approxChildrenMap = {};
-  if (childUuids.length > 0) {
-    const placeholders = childUuids.map(() => "?").join(",");
-    const counts = db.prepare(`
-      SELECT e.parent_uuid, COUNT(DISTINCT e.id)
-      FROM edges e
-      JOIN paths p ON p.edge_id = e.id
-      WHERE e.parent_uuid IN (${placeholders}) AND p.namespace = ?
-      GROUP BY e.parent_uuid
-    `).all(...childUuids, namespace);
-    for (const c of counts) {
-      approxChildrenMap[c[0]] = c[1];
-    }
-  }
-
-  const pathsByEdgeId = {};
-  if (edgeIds.length > 0) {
-    const placeholders = edgeIds.map(() => "?").join(",");
-    const pathRows = db.prepare(`
-      SELECT * FROM paths WHERE namespace = ? AND edge_id IN (${placeholders})
-    `).all(namespace, ...edgeIds);
-    for (const p of pathRows) {
-      if (!pathsByEdgeId[p.edge_id]) pathsByEdgeId[p.edge_id] = [];
-      pathsByEdgeId[p.edge_id].push(p);
-    }
-  }
-
-  const prefix = contextPath ? `${contextPath}/` : null;
-  const seen = new Set();
-  const children = [];
-
-  for (const row of rows) {
-    if (seen.has(row.child_uuid)) continue;
-    seen.add(row.child_uuid);
-
-    const allPaths = pathsByEdgeId[row.edge_id] ?? [];
-    if (nodeUuid === ROOT_NODE_UUID && contextDomain) {
-      if (!allPaths.some(p => p.domain === contextDomain)) continue;
-    }
-
-    const pathObj = pickBestPath(allPaths, contextDomain, prefix);
-    if (!pathObj) continue;
-
-    children.push({
-      node_uuid: row.child_uuid,
-      edge_id: row.edge_id,
-      name: row.name,
-      domain: pathObj.domain,
-      path: pathObj.path,
-      content_snippet: (row.content ?? "").slice(0, 100) + ((row.content ?? "").length > 100 ? "..." : ""),
-      priority: row.priority,
-      disclosure: row.disclosure,
-      approx_children_count: approxChildrenMap[row.child_uuid] ?? 0,
-    });
-  }
-
-  return children;
-}
-
-export function getRecentMemories(db, limit = 10, namespace = "") {
-  const rows = db.prepare(`
-    SELECT m.id AS memory_id, m.created_at, e.priority, e.disclosure, p.domain, p.path
-    FROM paths p
-    JOIN edges e ON p.edge_id = e.id
-    JOIN memories m ON m.node_uuid = e.child_uuid AND m.deprecated = 0
-    WHERE p.namespace = ?
-    ORDER BY m.created_at DESC
-  `).all(namespace);
-
-  const seen = new Set();
-  const memories = [];
-  for (const row of rows) {
-    if (seen.has(row.memory_id)) continue;
-    seen.add(row.memory_id);
-    memories.push({
-      memory_id: row.memory_id,
-      uri: `${row.domain}://${row.path}`,
-      priority: row.priority,
-      disclosure: row.disclosure,
-      created_at: row.created_at,
-    });
-    if (memories.length >= limit) break;
-  }
-  return memories;
-}
-
-function countIncomingPaths(db, nodeUuid, namespace = "") {
-  const row = db.prepare(
-    "SELECT COUNT(*) AS cnt FROM paths WHERE node_uuid = ? AND namespace = ?"
-  ).get(nodeUuid, namespace);
-  return row.cnt;
-}
-
-function pickBestPath(paths, contextDomain, prefix) {
-  if (paths.length === 0) return null;
-  if (paths.length === 1) return paths[0];
-
-  if (contextDomain && prefix) {
-    for (const p of paths) {
-      if (p.domain === contextDomain && p.path.startsWith(prefix)) return p;
-    }
-  }
-  if (contextDomain) {
-    for (const p of paths) {
-      if (p.domain === contextDomain) return p;
-    }
-  }
-  return paths[0];
-}