@plumpslabs/kuma 2.4.9 → 2.4.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plumpslabs/kuma",
-  "version": "2.4.9",
+  "version": "2.4.11",
   "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

@@ -182,11 +182,31 @@ async function getDashboardData() {
         const pkg = JSON.parse(fs.readFileSync(rootPkgPath, "utf-8"));
         const pnpmWs = path.join(root, "pnpm-workspace.yaml");
         const isWs = Boolean(pkg.workspaces || fs.existsSync(pnpmWs));
+        const packages = [];
+        if (isWs) {
+          for (const dirName of ["packages", "apps", "libs", "services", "crates"]) {
+            const dirPath = path.join(root, dirName);
+            if (fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory()) {
+              for (const sub of fs.readdirSync(dirPath)) {
+                const subPkg = path.join(dirPath, sub, "package.json");
+                if (fs.existsSync(subPkg)) {
+                  try {
+                    const sp = JSON.parse(fs.readFileSync(subPkg, "utf-8"));
+                    packages.push({ name: sp.name || sub, path: `${dirName}/${sub}` });
+                  } catch {
+                    packages.push({ name: sub, path: `${dirName}/${sub}` });
+                  }
+                }
+              }
+            }
+          }
+        }
         workspace = {
           isWorkspace: isWs,
           name: pkg.name || path.basename(root),
           version: pkg.version || "1.0.0",
-          type: isWs ? fs.existsSync(pnpmWs) ? "pnpm" : "npm/yarn" : "single-package"
+          type: isWs ? fs.existsSync(pnpmWs) ? "pnpm" : "npm/yarn" : "single-package",
+          packages
         };
       }
     } catch {
@@ -323,7 +343,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();
   }
@@ -389,6 +520,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;
@@ -440,10 +617,13 @@ try {
 } catch {
 }
 app.get("/", (c) => {
-  if (!htmlCache) {
+  try {
+    const html = readFileSync(htmlPath, "utf-8");
+    return c.html(html);
+  } catch {
+    if (htmlCache) return c.html(htmlCache);
     return c.text("index.html not found. Run from packages/ide/studio/", 500);
   }
-  return c.html(htmlCache);
 });
 serve({ fetch: app.fetch, port: PORT }, (info) => {
   const dbPath = findKumaDb();