@plumpslabs/kuma 2.4.10 → 2.4.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plumpslabs/kuma",
-  "version": "2.4.10",
+  "version": "2.4.12",
   "description": "Safety-first context & orchestration engine for AI coding agents. MCP server with mandatory research pipeline, knowledge graph, impact analysis, decision memory, and safety guard — works with any MCP client.",
   "type": "module",
   "main": "dist/index.js",
@@ -27,6 +27,7 @@
     "@modelcontextprotocol/sdk": "^1.7.0",
     "fast-glob": "^3.3.2",
     "sql.js": "^1.14.1",
+    "typescript": "^5.9.3",
     "zod": "^3.24.0"
   },
   "optionalDependencies": {
@@ -40,8 +41,7 @@
     "jest-mock": "^30.4.1",
     "ts-jest": "^29.2.0",
     "ts-node": "^10.9.2",
-    "tsup": "^8.3.0",
-    "typescript": "^5.9.3"
+    "tsup": "^8.3.0"
   },
   "engines": {
     "node": ">=18.0.0"

package/packages/ide/studio/dist/index.js

@@ -73,12 +73,51 @@ function readSessionMetrics(dbPath) {
     return empty;
   }
 }
+function searchByBasename(dir, baseName, maxDepth) {
+  if (maxDepth < 0) return null;
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist") continue;
+      const full = path.join(dir, entry.name);
+      if (entry.isFile() && entry.name.toLowerCase() === baseName.toLowerCase()) return full;
+      if (entry.isDirectory()) {
+        const found = searchByBasename(full, baseName, maxDepth - 1);
+        if (found) return found;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function findFileInMonorepo(root, targetPath) {
+  const direct = path.join(root, targetPath);
+  if (fs.existsSync(direct) && fs.statSync(direct).isFile()) return direct;
+  const targetBase = path.basename(targetPath);
+  try {
+    const entries = fs.readdirSync(root, { withFileTypes: true });
+    for (const ent of entries) {
+      if (ent.isDirectory() && !ent.name.startsWith(".") && ent.name !== "node_modules" && ent.name !== "dist" && ent.name !== "build") {
+        const dirPath = path.join(root, ent.name);
+        const relCand = path.join(dirPath, targetPath);
+        if (fs.existsSync(relCand) && fs.statSync(relCand).isFile()) return relCand;
+        const relSrcCand = path.join(dirPath, "src", targetPath);
+        if (fs.existsSync(relSrcCand) && fs.statSync(relSrcCand).isFile()) return relSrcCand;
+        const found = searchByBasename(dirPath, targetBase, 3);
+        if (found) return found;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
 function detectStaleNodes(db, dbPath) {
   try {
     const root = projectRootFromDb(dbPath);
     const stmt = db.prepare(
-      `SELECT id, file_path, metadata, COUNT(*) as cnt FROM nodes
+      `SELECT id, file_path, type, metadata, COUNT(*) as cnt FROM nodes
        WHERE file_path IS NOT NULL AND file_path != '' AND file_path NOT LIKE '%::%'
+         AND type NOT IN ('decision', 'arch_flow', 'feature_domain', 'feature', 'workflow', 'cross_service_link', 'research')
        GROUP BY file_path ORDER BY cnt DESC LIMIT 500`
     );
     const missing = [];
@@ -86,10 +125,19 @@ function detectStaleNodes(db, dbPath) {
     let staleNodes = 0;
     while (stmt.step()) {
       const row = stmt.getAsObject();
-      const fp = row.file_path;
+      const fp = (row.file_path || "").trim();
       const metadata = row.metadata || "{}";
+      if (!fp || /\s/.test(fp) || !path.extname(fp) || fp.includes("::")) {
+        continue;
+      }
       checked++;
-      const fullPath = path.join(root, fp);
+      let fullPath = path.join(root, fp);
+      if (!fs.existsSync(fullPath)) {
+        const monorepoPath = findFileInMonorepo(root, fp);
+        if (monorepoPath) {
+          fullPath = monorepoPath;
+        }
+      }
       if (!fs.existsSync(fullPath)) {
         const count = Number(row.cnt ?? 1);
         missing.push({ filePath: fp, nodeCount: count, reason: "file_missing" });
@@ -343,7 +391,118 @@ async function getNodeDetail(nodeId) {
         return null;
       }
     }).filter(Boolean);
-    return { node, outgoing, incoming, gotchas };
+    const inDegree = incoming.length;
+    const outDegree = outgoing.length;
+    const isHub = inDegree >= 4;
+    return { node, outgoing, incoming, gotchas, centrality: { inDegree, outDegree, isHub } };
+  } finally {
+    db.close();
+  }
+}
+function saveDbToDisk(db) {
+  const dbPath = findKumaDb();
+  if (!dbPath) throw new Error("No .kuma/kuma.db found");
+  const data = db.export();
+  const buffer = Buffer.from(data);
+  const tmpPath = `${dbPath}.tmp.${process.pid}.${Date.now()}`;
+  fs.writeFileSync(tmpPath, buffer);
+  try {
+    fs.renameSync(tmpPath, dbPath);
+  } catch {
+    fs.writeFileSync(dbPath, buffer);
+    try {
+      fs.unlinkSync(tmpPath);
+    } catch {
+    }
+  }
+}
+async function upsertStudioNode(data) {
+  const db = await openDb();
+  try {
+    const type = data.type || "feature_domain";
+    const name = (data.name || "").trim();
+    const filePath = (data.file_path || "").trim();
+    let id = data.id;
+    if (!id) {
+      if (type === "file" && filePath) {
+        id = `file::${filePath}`;
+      } else if (type === "function" && filePath) {
+        id = `function::${filePath}::${name}`;
+      } else {
+        id = `${type}::${name}`;
+      }
+    }
+    const meta = data.metadata || {};
+    if (data.description) {
+      meta.description = data.description;
+    }
+    const metaStr = JSON.stringify(meta);
+    db.run(
+      `INSERT INTO nodes (id, type, name, file_path, metadata, severity, confidence, updated_at)
+       VALUES (?, ?, ?, ?, ?, 'medium', 0.8, strftime('%s','now'))
+       ON CONFLICT(id) DO UPDATE SET
+         type = excluded.type,
+         name = excluded.name,
+         file_path = COALESCE(excluded.file_path, nodes.file_path),
+         metadata = excluded.metadata,
+         updated_at = strftime('%s','now')`,
+      [id, type, name, filePath || null, metaStr]
+    );
+    try {
+      const terms = `${name} ${filePath} ${metaStr}`.toLowerCase().split(/[\s,.;:!?()\[\]{}"'\/\\|@#$%^&*+=<>~`_-]+/).filter((t) => t.length > 2 && t.length < 40);
+      const uniqueTerms = Array.from(new Set(terms));
+      db.run(`DELETE FROM node_tokens WHERE node_id = ?`, [id]);
+      for (const term of uniqueTerms.slice(0, 30)) {
+        db.run(`INSERT OR IGNORE INTO node_tokens (token, node_id) VALUES (?, ?)`, [term, id]);
+      }
+    } catch {
+    }
+    saveDbToDisk(db);
+    return { id, type, name, file_path: filePath, metadata: meta };
+  } finally {
+    db.close();
+  }
+}
+async function deleteStudioNode(id) {
+  const db = await openDb();
+  try {
+    db.run(`DELETE FROM nodes WHERE id = ?`, [id]);
+    db.run(`DELETE FROM edges WHERE source_id = ? OR target_id = ?`, [id, id]);
+    try {
+      db.run(`DELETE FROM node_tokens WHERE node_id = ?`, [id]);
+    } catch {
+    }
+    saveDbToDisk(db);
+  } finally {
+    db.close();
+  }
+}
+async function createStudioEdge(edge) {
+  const db = await openDb();
+  try {
+    const weight = edge.weight ?? 1;
+    const metadata = JSON.stringify(edge.metadata ?? {});
+    db.run(
+      `INSERT INTO edges (source_id, target_id, type, weight, metadata)
+       VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(source_id, target_id, type) DO UPDATE SET
+         weight = excluded.weight,
+         metadata = excluded.metadata`,
+      [edge.source, edge.target, edge.type, weight, metadata]
+    );
+    saveDbToDisk(db);
+  } finally {
+    db.close();
+  }
+}
+async function deleteStudioEdge(source, target, type) {
+  const db = await openDb();
+  try {
+    db.run(
+      `DELETE FROM edges WHERE source_id = ? AND target_id = ? AND type = ?`,
+      [source, target, type]
+    );
+    saveDbToDisk(db);
   } finally {
     db.close();
   }
@@ -409,6 +568,52 @@ api.get("/node/:id", async (c) => {
     return c.json({ error: e.message }, 500);
   }
 });
+api.post("/node", async (c) => {
+  try {
+    const body = await c.req.json();
+    if (!body || !body.name || !body.type) {
+      return c.json({ error: "Missing required fields: name and type are required" }, 400);
+    }
+    const node = await upsertStudioNode(body);
+    return c.json({ ok: true, node });
+  } catch (e) {
+    return c.json({ error: e.message }, 500);
+  }
+});
+api.delete("/node/:id", async (c) => {
+  try {
+    const id = c.req.param("id");
+    if (!id) return c.json({ error: "Node id required" }, 400);
+    await deleteStudioNode(id);
+    return c.json({ ok: true, id });
+  } catch (e) {
+    return c.json({ error: e.message }, 500);
+  }
+});
+api.post("/edge", async (c) => {
+  try {
+    const body = await c.req.json();
+    if (!body || !body.source || !body.target || !body.type) {
+      return c.json({ error: "Missing required fields: source, target, and type are required" }, 400);
+    }
+    await createStudioEdge(body);
+    return c.json({ ok: true, edge: body });
+  } catch (e) {
+    return c.json({ error: e.message }, 500);
+  }
+});
+api.delete("/edge", async (c) => {
+  try {
+    const body = await c.req.json();
+    if (!body || !body.source || !body.target || !body.type) {
+      return c.json({ error: "Missing required fields: source, target, and type are required" }, 400);
+    }
+    await deleteStudioEdge(body.source, body.target, body.type);
+    return c.json({ ok: true, edge: body });
+  } catch (e) {
+    return c.json({ error: e.message }, 500);
+  }
+});
 api.post("/reset-db", (c) => {
   const blocked = confirmGuard(c);
   if (blocked) return blocked;