@plumpslabs/kuma 2.3.6 → 2.3.8

package/dist/kumaAstValidator-CNM7FHYA.js

@@ -0,0 +1,150 @@
+import {
+  getProjectRoot
+} from "./chunk-E2KFPEBT.js";
+
+// src/engine/kumaAstValidator.ts
+import fs from "fs";
+import path from "path";
+function loadImportWhitelist() {
+  try {
+    const root = getProjectRoot();
+    const whitelistPath = path.join(root, ".kuma", "import-whitelist.json");
+    if (fs.existsSync(whitelistPath)) {
+      return JSON.parse(fs.readFileSync(whitelistPath, "utf-8"));
+    }
+  } catch {
+  }
+  return {
+    allowed: [],
+    blocked: ["sql.js", "better-sqlite3", "mysql", "mssql"]
+    // dangerous native deps
+  };
+}
+function validateCodeContent(code, filePath) {
+  const findings = [];
+  const lines = code.split("\n");
+  const whitelist = loadImportWhitelist();
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNum = i + 1;
+    if (/\/\/\s*(expect|assert|should|test|it\.)\s*\(/.test(line) || /(\/\*[\s\S]*?\*\/)/.test(line) && /(expect|assert|should|test)/.test(line)) {
+      findings.push({
+        line: lineNum,
+        severity: "error",
+        category: "assertion-deletion",
+        message: `Test assertion appears to be commented out on line ${lineNum}`,
+        suggestion: "Restore the assertion or write an equivalent test for the new behavior"
+      });
+    }
+    if (/catch\s*\([^)]*\)\s*\{\s*\}/.test(line) || /catch\s*\([^)]*\)\s*\{/.test(line) && lines[i + 1]?.trim() === "}") {
+      findings.push({
+        line: lineNum,
+        severity: "error",
+        category: "exception-swallowing",
+        message: `Empty catch block on line ${lineNum} \u2014 exceptions are being swallowed`,
+        suggestion: "Handle the error: log it, throw a meaningful error, or add a comment explaining why it's safe to ignore"
+      });
+    }
+    if (filePath?.includes(".test.") || filePath?.includes(".spec.")) {
+      if (/\breturn\s+(true|false|null|undefined|0|""|'')\s*;/.test(line) || /\breturn\s+\d+\s*;/.test(line) || /\bPromise\.resolve\s*\(\s*(true|false|null|undefined|0|""|'')\s*\)/.test(line)) {
+        findings.push({
+          line: lineNum,
+          severity: "warning",
+          category: "reward-hacking",
+          message: `Possible hardcoded return in test file on line ${lineNum}: ${line.trim().substring(0, 60)}`,
+          suggestion: "Implement the actual logic instead of returning a hardcoded value to pass tests"
+        });
+      }
+    }
+    if (!filePath?.includes(".test.") && !filePath?.includes(".spec.") && /\breturn\s+(true|false|null)\s*;/.test(line) && ((lines[i - 1] || "").includes("TODO") || (lines[i - 1] || "").includes("FIXME") || (lines[i - 1] || "").includes("HACK"))) {
+      findings.push({
+        line: lineNum,
+        severity: "warning",
+        category: "hardcoded-return",
+        message: `Hardcoded return value on line ${lineNum} (possibly temporary/hack)`,
+        suggestion: "Implement proper logic or add a clear comment explaining why this is correct"
+      });
+    }
+    const importMatch = line.match(/import\s+(?:\{[^}]*\}\s+from\s+)?['"]([^'"]+)['"]/);
+    if (importMatch) {
+      const imported = importMatch[1];
+      if (whitelist.blocked.some((b) => imported.includes(b))) {
+        findings.push({
+          line: lineNum,
+          severity: "error",
+          category: "import-violation",
+          message: `Blocked import: "${imported}" is not allowed per security whitelist`,
+          suggestion: `Remove or replace the import. Allowed packages: ${whitelist.allowed.slice(0, 5).join(", ") || "(none specified)"}`
+        });
+      }
+    }
+  }
+  return findings;
+}
+function validateFile(filePath) {
+  try {
+    const root = getProjectRoot();
+    const fullPath = path.resolve(root, filePath);
+    if (!fs.existsSync(fullPath)) return [];
+    const content = fs.readFileSync(fullPath, "utf-8");
+    return validateCodeContent(content, filePath);
+  } catch {
+    return [];
+  }
+}
+function formatValidationFindings(findings, filePath) {
+  if (findings.length === 0) {
+    return "\u2705 **AST Validation** \u2014 No structural issues found.";
+  }
+  const errors = findings.filter((f) => f.severity === "error");
+  const warnings = findings.filter((f) => f.severity === "warning");
+  const lines = [
+    "\u{1F52C} **AST Code Validation Report**",
+    "\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",
+    "",
+    `${findings.length} finding(s): ${errors.length} errors, ${warnings.length} warnings`,
+    filePath ? `\u{1F4C4} ${filePath}` : "",
+    ""
+  ];
+  for (const f of findings) {
+    const icon = f.severity === "error" ? "\u{1F534}" : f.severity === "warning" ? "\u{1F7E1}" : "\u{1F7E2}";
+    lines.push(`${icon} L${f.line} [${f.category}]`);
+    lines.push(`   ${f.message}`);
+    lines.push(`   \u{1F4A1} ${f.suggestion}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function validateDiff(oldContent, newContent, filePath) {
+  const findings = [];
+  const oldFindings = validateCodeContent(oldContent, filePath);
+  const newFindings = validateCodeContent(newContent, filePath);
+  const oldAssertions = oldFindings.filter((f) => f.category === "assertion-deletion");
+  const newAssertions = newFindings.filter((f) => f.category === "assertion-deletion");
+  for (const oldAssertion of oldAssertions) {
+    if (!newAssertions.some((f) => f.line === oldAssertion.line && f.message === oldAssertion.message)) {
+      continue;
+    }
+  }
+  const oldLines = oldContent.split("\n");
+  const newLines = newContent.split("\n");
+  for (let i = 0; i < newLines.length; i++) {
+    if (i >= oldLines.length || newLines[i] !== oldLines[i]) {
+      const changedLineFindings = validateCodeContent(newLines[i], filePath);
+      for (const f of changedLineFindings) {
+        findings.push({
+          ...f,
+          line: i + 1,
+          message: `[NEW] ${f.message}`
+        });
+      }
+    }
+  }
+  return findings;
+}
+export {
+  formatValidationFindings,
+  validateCodeContent,
+  validateDiff,
+  validateFile
+};

package/dist/{kumaDb-DJUDLYBJ.js → kumaDb-6D53ERFP.js}

@@ -28,7 +28,7 @@ import {
   saveVerification,
   updateDecisionStatus,
   updateTodoStatus
-} from "./chunk-GDNAWLHF.js";
+} from "./chunk-NAM7SCBT.js";
 import "./chunk-E2KFPEBT.js";
 export {
   addContextNote,

package/dist/kumaDriftDetector-OESI5GTC.js

@@ -0,0 +1,237 @@
+import {
+  getDb,
+  saveDb
+} from "./chunk-NAM7SCBT.js";
+import {
+  getProjectRoot
+} from "./chunk-E2KFPEBT.js";
+
+// src/engine/kumaDriftDetector.ts
+import fs from "fs";
+import path from "path";
+import crypto from "crypto";
+function hashFile(filePath) {
+  try {
+    const root = getProjectRoot();
+    const fullPath = path.resolve(root, filePath);
+    if (!fs.existsSync(fullPath)) return null;
+    const content = fs.readFileSync(fullPath, "utf-8");
+    return crypto.createHash("sha256").update(content).digest("hex");
+  } catch {
+    return null;
+  }
+}
+async function detectDrift() {
+  const records = [];
+  const now = Math.floor(Date.now() / 1e3);
+  try {
+    const db = await getDb();
+    const rcStmt = db.prepare(
+      "SELECT id, scope, content_hash, updated_at FROM research_cache WHERE content_hash IS NOT NULL AND length(content_hash) > 0 LIMIT 100"
+    );
+    while (rcStmt.step()) {
+      const row = rcStmt.getAsObject();
+      const scope = row.scope;
+      const storedHash = row.content_hash;
+      const updatedAt = row.updated_at;
+      const age = Math.floor((now - updatedAt) / 86400);
+      const currentHash = computeScopeHash(scope);
+      const stale = currentHash && currentHash !== storedHash;
+      records.push({
+        id: row.id,
+        source: "research_cache",
+        description: scope,
+        filePath: null,
+        oldHash: storedHash,
+        currentHash: currentHash || "",
+        age: `${age}d`,
+        severity: !currentHash ? "fresh" : stale ? "stale" : age > 30 ? "warning" : "fresh"
+      });
+    }
+    rcStmt.free();
+    const fsStmt = db.prepare(
+      "SELECT id, file_path, content_hash FROM file_summaries WHERE content_hash IS NOT NULL AND length(content_hash) > 0 LIMIT 100"
+    );
+    while (fsStmt.step()) {
+      const row = fsStmt.getAsObject();
+      const filePath = row.file_path;
+      const storedHash = row.content_hash;
+      const currentHash = hashFile(filePath);
+      if (currentHash === null) {
+        records.push({
+          id: row.id,
+          source: "file_summaries",
+          description: filePath,
+          filePath,
+          oldHash: storedHash,
+          currentHash: "",
+          age: "\u2014",
+          severity: "missing"
+        });
+      } else if (currentHash !== storedHash) {
+        records.push({
+          id: row.id,
+          source: "file_summaries",
+          description: filePath,
+          filePath,
+          oldHash: storedHash,
+          currentHash,
+          age: "\u2014",
+          severity: "stale"
+        });
+      }
+    }
+    fsStmt.free();
+    const dlStmt = db.prepare(
+      "SELECT id, title, file_paths, created_at FROM decision_log WHERE file_paths IS NOT NULL ORDER BY created_at DESC LIMIT 50"
+    );
+    while (dlStmt.step()) {
+      const row = dlStmt.getAsObject();
+      const filePaths = [];
+      try {
+        filePaths.push(...JSON.parse(row.file_paths));
+      } catch {
+      }
+      let hasStaleFile = false;
+      for (const fp of filePaths) {
+        if (!fp) continue;
+        const fullPath = path.resolve(getProjectRoot(), fp);
+        if (!fs.existsSync(fullPath)) {
+          hasStaleFile = true;
+          break;
+        }
+      }
+      if (hasStaleFile) {
+        records.push({
+          id: row.id,
+          source: "decision_log",
+          description: row.title,
+          filePath: filePaths[0] || null,
+          oldHash: "",
+          currentHash: "",
+          age: "\u2014",
+          severity: "stale"
+        });
+      }
+    }
+    dlStmt.free();
+  } catch (err) {
+    console.error(`[DriftDetector] Error: ${err}`);
+  }
+  return records;
+}
+function computeScopeHash(scope) {
+  try {
+    const hash = crypto.createHash("sha256");
+    const root = getProjectRoot();
+    hash.update(scope);
+    let found = false;
+    try {
+      const files = fs.readdirSync(root);
+      for (const file of files) {
+        if (file.toLowerCase().includes(scope.toLowerCase())) {
+          try {
+            if (fs.statSync(path.join(root, file)).isFile()) {
+              const content = fs.readFileSync(path.join(root, file), "utf-8");
+              hash.update(file);
+              hash.update(content.substring(0, 1e4));
+              found = true;
+            }
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+    const researchDir = path.join(root, ".kuma", "research");
+    if (fs.existsSync(researchDir)) {
+      const scopeFile = path.join(researchDir, `${scope}.json`);
+      if (fs.existsSync(scopeFile)) {
+        const content = fs.readFileSync(scopeFile, "utf-8");
+        hash.update(content);
+        found = true;
+      }
+    }
+    if (!found) return null;
+    return hash.digest("hex").substring(0, 16);
+  } catch {
+    return null;
+  }
+}
+async function flagStaleRecords() {
+  const staleRecords = await detectDrift();
+  let flagged = 0;
+  try {
+    const db = await getDb();
+    for (const record of staleRecords) {
+      if (record.severity !== "stale" && record.severity !== "missing") continue;
+      if (record.source === "research_cache") {
+        db.run(
+          `UPDATE research_cache SET confidence = MAX(confidence * 0.5, 0.1) WHERE id = ?`,
+          [record.id]
+        );
+        flagged++;
+      } else if (record.source === "file_summaries") {
+        db.run(
+          `UPDATE file_summaries SET content_hash = '' WHERE id = ?`,
+          [record.id]
+        );
+        flagged++;
+      } else if (record.source === "decision_log") {
+        db.run(
+          `UPDATE decision_log SET status = 'deprecated' WHERE id = ?`,
+          [record.id]
+        );
+        flagged++;
+      }
+    }
+    saveDb();
+  } catch (err) {
+    console.error(`[DriftDetector] Flag error: ${err}`);
+  }
+  return { flagged, total: staleRecords.length };
+}
+function formatDriftReport(records) {
+  if (records.length === 0) {
+    return "\u2705 **Drift Detection** \u2014 All memory records are fresh. No code drift detected.";
+  }
+  const fresh = records.filter((r) => r.severity === "fresh").length;
+  const warning = records.filter((r) => r.severity === "warning").length;
+  const stale = records.filter((r) => r.severity === "stale").length;
+  const missing = records.filter((r) => r.severity === "missing").length;
+  const lines = [
+    "\u{1F50D} **Code Drift Detection Report**",
+    "\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",
+    "",
+    `\u{1F4CA} ${records.length} total records checked: ${fresh} fresh, ${warning} aging, ${stale} stale, ${missing} missing`,
+    ""
+  ];
+  if (stale > 0 || missing > 0) {
+    lines.push("**Stale/Missing Records:**");
+    for (const r of records) {
+      if (r.severity === "stale" || r.severity === "missing") {
+        const icon = r.severity === "missing" ? "\u274C" : "\u26A0\uFE0F";
+        lines.push(`  ${icon} [${r.source}] ${r.description}`);
+        if (r.filePath) lines.push(`     \u{1F4CD} ${r.filePath}`);
+      }
+    }
+    lines.push("");
+    lines.push("\u{1F4A1} Run kuma_memory({ action: 'heal' }) to repair stale graph entries.");
+    lines.push("\u{1F4A1} Run kuma_context({ action: 'research', scope: '<stale-scope>' }) to refresh.");
+  }
+  return lines.join("\n");
+}
+async function getDriftSummary() {
+  const records = await detectDrift();
+  if (records.length === 0) return "\u2705 No code drift detected";
+  const staleCount = records.filter((r) => r.severity === "stale" || r.severity === "missing").length;
+  if (staleCount === 0) return "\u2705 All records fresh";
+  return `\u26A0\uFE0F ${staleCount} stale record(s) detected. Use kuma_memory({ action: 'heal' }) to repair.`;
+}
+export {
+  detectDrift,
+  flagStaleRecords,
+  formatDriftReport,
+  getDriftSummary,
+  hashFile
+};

package/dist/kumaGotchas-DU5H6N7X.js

@@ -0,0 +1,151 @@
+import {
+  appendToLayer,
+  checkFileGotchas,
+  getActiveGotchas
+} from "./chunk-53J56QCQ.js";
+import {
+  sessionMemory
+} from "./chunk-SLRRDKQ2.js";
+import {
+  getDb,
+  saveDb
+} from "./chunk-NAM7SCBT.js";
+import "./chunk-E2KFPEBT.js";
+
+// src/engine/kumaGotchas.ts
+async function ensureGotchasSchema() {
+  const db = await getDb();
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS known_gotchas (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      file_path TEXT NOT NULL,
+      description TEXT NOT NULL,
+      severity TEXT NOT NULL DEFAULT 'medium'
+        CHECK(severity IN ('low','medium','high','critical')),
+      workaround TEXT,
+      added_by TEXT DEFAULT 'agent',
+      created_at INTEGER NOT NULL DEFAULT (strftime('%s','now')),
+      updated_at INTEGER NOT NULL DEFAULT (strftime('%s','now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_gotchas_file ON known_gotchas(file_path);
+    CREATE INDEX IF NOT EXISTS idx_gotchas_severity ON known_gotchas(severity);
+  `);
+  saveDb();
+}
+async function addGotcha(entry) {
+  try {
+    await ensureGotchasSchema();
+    const db = await getDb();
+    const severity = entry.severity || "medium";
+    const formatted = [
+      `### ${entry.filePath} \u2014 ${entry.description}`,
+      `- **Issue**: ${entry.description}`,
+      `- **Severity**: ${severity}`,
+      entry.workaround ? `- **Workaround**: ${entry.workaround}` : "",
+      `- **Added**: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`
+    ].filter(Boolean).join("\n");
+    db.run(
+      `INSERT INTO known_gotchas (file_path, description, severity, workaround) VALUES (?, ?, ?, ?)`,
+      [entry.filePath, entry.description, severity, entry.workaround || null]
+    );
+    const mdResult = appendToLayer("gotcha", formatted);
+    saveDb();
+    sessionMemory.recordToolCall("kuma_gotcha_add", {
+      filePath: entry.filePath,
+      severity
+    });
+    return `\u2705 **Gotcha recorded**: ${entry.filePath} \u2014 ${entry.description}
+${mdResult}`;
+  } catch (err) {
+    return `\u274C Failed to add gotcha: ${err}`;
+  }
+}
+async function listGotchas(params) {
+  try {
+    await ensureGotchasSchema();
+    const db = await getDb();
+    let sql = "SELECT * FROM known_gotchas WHERE 1=1";
+    const bind = [];
+    if (params.filePath) {
+      sql += " AND file_path LIKE ?";
+      bind.push(`%${params.filePath}%`);
+    }
+    if (params.severity) {
+      sql += " AND severity = ?";
+      bind.push(params.severity);
+    }
+    sql += " ORDER BY severity DESC, created_at DESC LIMIT 50";
+    const stmt = db.prepare(sql);
+    stmt.bind(bind);
+    const results = [];
+    while (stmt.step()) results.push(stmt.getAsObject());
+    stmt.free();
+    if (results.length === 0) {
+      return "\u2705 **No gotchas recorded** \u2014 legacy codebase looks clean.";
+    }
+    const lines = [
+      `\u26A0\uFE0F **Known Gotchas** \u2014 ${results.length} recorded`,
+      "\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",
+      ""
+    ];
+    for (const g of results) {
+      const icon = g.severity === "critical" ? "\u{1F534}" : g.severity === "high" ? "\u{1F7E0}" : g.severity === "medium" ? "\u{1F7E1}" : "\u{1F7E2}";
+      lines.push(`${icon} [${g.severity}] ${g.file_path}`);
+      lines.push(`   \u{1F4DD} ${g.description?.toString().substring(0, 100)}`);
+      if (g.workaround) lines.push(`   \u{1F4A1} ${g.workaround.substring(0, 100)}`);
+      lines.push("");
+    }
+    return lines.join("\n");
+  } catch (err) {
+    return `Error: ${err}`;
+  }
+}
+function checkGotchasForFile(filePath) {
+  const warnings = [];
+  const markdownWarnings = checkFileGotchas(filePath);
+  try {
+    const gotchas = getActiveGotchas();
+    for (const g of gotchas) {
+      if (filePath.includes(g.filePath) || g.filePath.includes(filePath)) {
+        if (!markdownWarnings.some((w) => w.includes(g.description))) {
+          const icon = g.severity === "critical" ? "\u{1F534}" : g.severity === "high" ? "\u{1F7E0}" : g.severity === "medium" ? "\u{1F7E1}" : "\u{1F7E2}";
+          warnings.push(`${icon} **Known Gotcha**: ${g.description} (${g.severity})`);
+        }
+      }
+    }
+  } catch {
+  }
+  return [.../* @__PURE__ */ new Set([...markdownWarnings, ...warnings])];
+}
+async function syncGotchasToDb() {
+  try {
+    await ensureGotchasSchema();
+    const db = await getDb();
+    const gotchas = getActiveGotchas();
+    let synced = 0;
+    for (const g of gotchas) {
+      const checkStmt = db.prepare(
+        `SELECT id FROM known_gotchas WHERE file_path = ? AND description = ?`
+      );
+      checkStmt.bind([g.filePath, g.description]);
+      const exists = checkStmt.step();
+      checkStmt.free();
+      if (exists) continue;
+      db.run(
+        `INSERT INTO known_gotchas (file_path, description, severity) VALUES (?, ?, ?)`,
+        [g.filePath, g.description, g.severity]
+      );
+      synced++;
+    }
+    saveDb();
+    return { synced };
+  } catch {
+    return { synced: 0 };
+  }
+}
+export {
+  addGotcha,
+  checkGotchasForFile,
+  listGotchas,
+  syncGotchasToDb
+};

package/dist/{kumaGraph-35TAIBWD.js → kumaGraph-AWP743TJ.js}

@@ -14,8 +14,8 @@ import {
   searchGraph,
   traceFlow,
   upsertNode
-} from "./chunk-K64NSHBR.js";
-import "./chunk-GDNAWLHF.js";
+} from "./chunk-4OB3XMHT.js";
+import "./chunk-NAM7SCBT.js";
 import "./chunk-E2KFPEBT.js";
 export {
   addEdge,

package/dist/{kumaMemory-5SR3TGRL.js → kumaMemory-7TCUDVZX.js}

@@ -4,8 +4,8 @@ import {
   recordDecision,
   scoreMemoryRelevance,
   shouldRecordDecision
-} from "./chunk-X5TPBDKO.js";
-import "./chunk-BI7KD3SG.js";
+} from "./chunk-RTGLQDMI.js";
+import "./chunk-SLRRDKQ2.js";
 import "./chunk-E2KFPEBT.js";
 export {
   formatDecisionTemplate,

package/dist/{kumaMiner-BIDSZE3Q.js → kumaMiner-FFXSRHAO.js}

@@ -1,10 +1,10 @@
-import {
-  recordDecisionLog
-} from "./chunk-GDNAWLHF.js";
 import {
   recordDecision
-} from "./chunk-X5TPBDKO.js";
-import "./chunk-BI7KD3SG.js";
+} from "./chunk-RTGLQDMI.js";
+import "./chunk-SLRRDKQ2.js";
+import {
+  recordDecisionLog
+} from "./chunk-NAM7SCBT.js";
 import "./chunk-E2KFPEBT.js";
 
 // src/engine/kumaMiner.ts