@plumpslabs/kuma 2.3.6 → 2.3.8

package/dist/kumaVisualize-TECABHUY.js

@@ -0,0 +1,248 @@
+import {
+  getDb
+} from "./chunk-NAM7SCBT.js";
+import "./chunk-E2KFPEBT.js";
+
+// src/engine/kumaVisualize.ts
+async function visualizeGraph(options = {}) {
+  const {
+    type = "flowchart",
+    scope,
+    maxNodes = 30,
+    // depth unused: kept for API consistency
+    format = "mermaid"
+  } = options;
+  try {
+    const db = await getDb();
+    let nodeSql = `SELECT id, type, name, file_path FROM nodes WHERE 1=1`;
+    const nodeBind = [];
+    if (scope) {
+      nodeSql += ` AND (name LIKE ? OR file_path LIKE ? OR id LIKE ?)`;
+      nodeBind.push(`%${scope}%`, `%${scope}%`, `%${scope}%`);
+    }
+    nodeSql += ` ORDER BY updated_at DESC LIMIT ?`;
+    nodeBind.push(maxNodes);
+    const nodeStmt = db.prepare(nodeSql);
+    nodeStmt.bind(nodeBind);
+    const nodes = [];
+    while (nodeStmt.step()) {
+      nodes.push(nodeStmt.getAsObject());
+    }
+    nodeStmt.free();
+    if (nodes.length === 0) {
+      return format === "mermaid" ? "```mermaid\nflowchart TD\n  Start[Empty Graph \u2014 No nodes found]\n```" : "\u{1F4ED} **Empty Graph** \u2014 No nodes found to visualize.";
+    }
+    const nodeIds = nodes.map((n) => n.id);
+    const edgeSql = `
+      SELECT e.source_id, e.target_id, e.type, e.weight,
+        sn.name AS source_name, tn.name AS target_name
+      FROM edges e
+      JOIN nodes sn ON sn.id = e.source_id
+      JOIN nodes tn ON tn.id = e.target_id
+      WHERE (e.source_id IN (${nodeIds.map(() => "?").join(",")})
+         OR e.target_id IN (${nodeIds.map(() => "?").join(",")}))
+        AND e.source_id != e.target_id
+      ORDER BY e.weight DESC
+      LIMIT 100
+    `;
+    const edgeBind = [...nodeIds, ...nodeIds];
+    const edgeStmt = db.prepare(edgeSql);
+    edgeStmt.bind(edgeBind);
+    const edges = [];
+    while (edgeStmt.step()) {
+      edges.push(edgeStmt.getAsObject());
+    }
+    edgeStmt.free();
+    switch (type) {
+      case "flowchart":
+        return formatFlowchart(nodes, edges, format);
+      case "dependency":
+        return formatDependencyGraph(nodes, edges, format);
+      case "mindmap":
+        return formatMindMap(nodes, edges, format);
+      default:
+        return formatFlowchart(nodes, edges, format);
+    }
+  } catch (err) {
+    return `Error generating visualization: ${err}`;
+  }
+}
+function formatFlowchart(nodes, edges, _format) {
+  void _format;
+  const lines = ["```mermaid", "flowchart TD"];
+  for (const node of nodes) {
+    const id = sanitizeId(node.id);
+    const name = truncate(node.name, 30);
+    const nodeType = node.type;
+    const shape = getNodeShape(nodeType);
+    if (shape) {
+      lines.push(`  ${id}${shape}${name}${reverseShape(shape)}`);
+    } else {
+      lines.push(`  ${id}[${name}]`);
+    }
+  }
+  for (const edge of edges) {
+    const sourceId = sanitizeId(edge.source_id);
+    const targetId = sanitizeId(edge.target_id);
+    const edgeType = edge.type;
+    void edge.weight;
+    const label = truncate(edgeType, 15);
+    const edgeStyle = getEdgeStyle(edgeType);
+    lines.push(`  ${sourceId}${edgeStyle}|${label}|${targetId}`);
+  }
+  lines.push("```");
+  return lines.join("\n");
+}
+function formatDependencyGraph(nodes, edges, _format) {
+  void _format;
+  const lines = ["```mermaid", "flowchart LR"];
+  const grouped = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const type = node.type || "unknown";
+    if (!grouped.has(type)) grouped.set(type, []);
+    grouped.get(type).push(node);
+  }
+  let subgraphIndex = 0;
+  for (const [type, typeNodes] of grouped) {
+    if (typeNodes.length < 1) continue;
+    lines.push(`  subgraph ${type.toUpperCase()}[${type.toUpperCase()}]`);
+    for (const node of typeNodes) {
+      const id = sanitizeId(node.id);
+      const name = truncate(node.name, 25);
+      lines.push(`    ${id}(${name})`);
+    }
+    lines.push("  end");
+    subgraphIndex++;
+  }
+  for (const edge of edges) {
+    const sourceId = sanitizeId(edge.source_id);
+    const targetId = sanitizeId(edge.target_id);
+    const edgeType = edge.type;
+    const style = getEdgeStyle(edgeType);
+    lines.push(`  ${sourceId}${style}|${edgeType}|${targetId}`);
+  }
+  lines.push("```");
+  return lines.join("\n");
+}
+function formatMindMap(nodes, edges, _format) {
+  void _format;
+  const lines = ["```mermaid", "mindmap"];
+  const hasIncoming = /* @__PURE__ */ new Set();
+  for (const edge of edges) {
+    hasIncoming.add(edge.target_id);
+  }
+  const roots = nodes.filter((n) => !hasIncoming.has(n.id));
+  if (roots.length === 0 && nodes.length > 0) {
+    const root = nodes[0];
+    lines.push(`  root((${truncate(root.name, 25)}))`);
+    for (const node of nodes.slice(1)) {
+      lines.push(`    ${sanitizeId(node.id)}(${truncate(node.name, 25)})`);
+    }
+  } else {
+    for (const root of roots.slice(0, 3)) {
+      lines.push(`  root((${truncate(root.name, 25)}))`);
+    }
+    const others = nodes.filter((n) => !roots.includes(n));
+    for (const node of others.slice(0, 10)) {
+      const parent = edges.find((e) => e.source_id === node.id || e.target_id === node.id);
+      const indent = parent ? "    " : "  ";
+      lines.push(`${indent}${sanitizeId(node.id)}(${truncate(node.name, 25)})`);
+    }
+  }
+  lines.push("```");
+  return lines.join("\n");
+}
+function sanitizeId(id) {
+  const safe = id.replace(/[^a-zA-Z0-9_]/g, "_").replace(/^(\d)/, "n$1").substring(0, 40);
+  return safe || "n0";
+}
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.substring(0, maxLen - 3) + "...";
+}
+function getNodeShape(type) {
+  switch (type) {
+    case "function":
+      return "([";
+    case "file":
+      return "[";
+    case "test":
+      return "{";
+    case "api_route":
+      return "[[";
+    case "db_table":
+      return ">";
+    // database shape approximation
+    case "class":
+      return "[";
+    case "interface":
+      return "(";
+    case "module":
+      return "[";
+    case "variable":
+      return "(";
+    default:
+      return "[";
+  }
+}
+function reverseShape(shape) {
+  const map = {
+    "([": "])",
+    "[": "]",
+    "{": "}",
+    "[[": "]]",
+    ">": "<]",
+    "(": ")"
+  };
+  return map[shape] || "]";
+}
+function getEdgeStyle(type) {
+  switch (type) {
+    case "calls":
+      return " ==> ";
+    case "imports":
+      return " -.-> ";
+    case "defines":
+      return " --- ";
+    case "tests":
+      return " -.-> ";
+    case "routes":
+      return " ==> ";
+    case "implements":
+      return " -.-> ";
+    case "extends":
+      return " ==> ";
+    case "depends_on":
+      return " -.-> ";
+    case "owns":
+      return " --- ";
+    case "modified_by":
+      return " -.-> ";
+    default:
+      return " --- ";
+  }
+}
+async function generateVisualizeReport(options = {}) {
+  const diagram = await visualizeGraph(options);
+  const lines = [
+    "\u{1F3A8} **Knowledge Graph Visualization**",
+    "\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501",
+    "",
+    diagram,
+    "",
+    "\u{1F4CB} **Rendering Instructions:**",
+    "- Paste the Mermaid code above into any Mermaid-compatible viewer",
+    "- GitHub: Mermaid code blocks render automatically",
+    "- VS Code: Install 'Markdown Preview Mermaid Support' extension",
+    "- Online: https://mermaid.live",
+    "",
+    "\u{1F4A1} Use `kuma_visualize({ type: 'dependency' })` for clustered view",
+    "\u{1F4A1} Use `kuma_visualize({ type: 'mindmap' })` for overview",
+    "\u{1F4A1} Use `kuma_visualize({ scope: 'auth' })` to filter by topic"
+  ];
+  return lines.join("\n");
+}
+export {
+  generateVisualizeReport,
+  visualizeGraph
+};

package/dist/safetyAudit-55IVCG5B.js

@@ -0,0 +1,12 @@
+import {
+  auditStats,
+  queryAudit,
+  recordAudit
+} from "./chunk-PTEPJK6M.js";
+import "./chunk-NAM7SCBT.js";
+import "./chunk-E2KFPEBT.js";
+export {
+  auditStats,
+  queryAudit,
+  recordAudit
+};

package/dist/{safetyScore-PJGRRBWP.js → safetyScore-GR5N55CU.js}

@@ -2,10 +2,10 @@ import {
   getGitDiffStat,
   getSessionStats,
   getUnresolvedCount
-} from "./chunk-FOQQ2CSL.js";
+} from "./chunk-FL2TLLMX.js";
 import {
   sessionMemory
-} from "./chunk-BI7KD3SG.js";
+} from "./chunk-SLRRDKQ2.js";
 import "./chunk-E2KFPEBT.js";
 
 // src/engine/safetyScore.ts
@@ -60,7 +60,7 @@ async function computeSafetyScore(inputGoal) {
     totalScore += 20;
   }
   try {
-    const { getDb } = await import("./kumaDb-DJUDLYBJ.js");
+    const { getDb } = await import("./kumaDb-6D53ERFP.js");
     const db = await getDb();
     const nodeCount = db.exec("SELECT COUNT(*) as c FROM nodes")[0]?.values[0][0] ?? 0;
     const edgeCount = db.exec("SELECT COUNT(*) as c FROM edges")[0]?.values[0][0] ?? 0;
@@ -91,7 +91,7 @@ async function computeSafetyScore(inputGoal) {
     totalScore += 5;
   }
   try {
-    const { getDb } = await import("./kumaDb-DJUDLYBJ.js");
+    const { getDb } = await import("./kumaDb-6D53ERFP.js");
     const db = await getDb();
     const researchCount = db.exec("SELECT COUNT(*) as c FROM research_cache")[0]?.values[0][0] ?? 0;
     checks.push({
@@ -116,7 +116,7 @@ async function computeSafetyScore(inputGoal) {
   const hasRunTests = stats.hasRunTests;
   let latestVerif = null;
   try {
-    const { getLatestVerifications } = await import("./kumaDb-DJUDLYBJ.js");
+    const { getLatestVerifications } = await import("./kumaDb-6D53ERFP.js");
     const verifs = await getLatestVerifications(1);
     if (verifs.length > 0) latestVerif = verifs[0];
   } catch {

package/dist/{sessionMemory-HBBXUSIP.js → sessionMemory-CA34TCPF.js}

@@ -1,6 +1,6 @@
 import {
   sessionMemory
-} from "./chunk-BI7KD3SG.js";
+} from "./chunk-SLRRDKQ2.js";
 export {
   sessionMemory
 };

package/package.json

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