@plumpslabs/kuma 2.3.7 → 2.3.8

package/dist/kumaPolicyEngine-S2PXN3C7.js

@@ -0,0 +1,311 @@
+import {
+  sessionMemory
+} from "./chunk-SLRRDKQ2.js";
+import {
+  getProjectRoot
+} from "./chunk-E2KFPEBT.js";
+
+// src/engine/kumaPolicyEngine.ts
+import fs from "fs";
+import path from "path";
+var DEFAULT_POLICY_CONFIG = {
+  version: 1,
+  name: "Kuma Default Security Policy",
+  description: "Default safety policy for AI coding agents",
+  rules: [
+    {
+      id: "block-rm-rf",
+      description: "Block recursive force deletion",
+      severity: "error",
+      patterns: ["rm -rf", "rm -fr", "rm --recursive --force"],
+      action: "block",
+      requireOverride: true
+    },
+    {
+      id: "block-git-force-push",
+      description: "Block force push to git",
+      severity: "error",
+      patterns: ["git push --force", "git push -f"],
+      action: "block",
+      requireOverride: true
+    },
+    {
+      id: "block-npm-publish",
+      description: "Block package publishing",
+      severity: "error",
+      patterns: ["npm publish", "yarn publish", "pnpm publish"],
+      action: "block",
+      requireOverride: true
+    },
+    {
+      id: "block-pipe-to-shell",
+      description: "Block curl/wget pipe to shell",
+      severity: "error",
+      patterns: ["curl | bash", "curl | sh", "wget -O - | bash", "curl | sudo"],
+      action: "block",
+      requireOverride: true
+    },
+    {
+      id: "warn-destructive-db",
+      description: "Warn about destructive database operations",
+      severity: "warning",
+      patterns: ["DROP DATABASE", "DROP TABLE", "TRUNCATE", "DELETE FROM"],
+      action: "warn"
+    },
+    {
+      id: "block-prod-deploy",
+      description: "Block production deployments without override",
+      severity: "error",
+      patterns: ["deploy --production", "deploy --prod", "deploy:production"],
+      action: "block",
+      requireOverride: true
+    }
+  ],
+  block_commands: [
+    "rm -rf",
+    "rm -fr",
+    "git push --force",
+    "git push -f",
+    "npm publish",
+    "yarn publish",
+    "pnpm publish",
+    "curl | bash",
+    "curl | sh"
+  ],
+  never_touch: [
+    ".env",
+    ".env.local",
+    ".env.production",
+    ".env.development",
+    "package-lock.json",
+    "yarn.lock",
+    "pnpm-lock.yaml",
+    "node_modules/**"
+  ]
+};
+function loadPolicyConfig() {
+  try {
+    const root = getProjectRoot();
+    const policyPath = path.join(root, ".kuma", "POLICY.json");
+    if (fs.existsSync(policyPath)) {
+      const content = fs.readFileSync(policyPath, "utf-8");
+      const config = JSON.parse(content);
+      return { ...DEFAULT_POLICY_CONFIG, ...config };
+    }
+    const ymlPath = path.join(root, ".kuma", "policy.yml");
+    if (fs.existsSync(ymlPath)) {
+      console.error("[PolicyEngine] Found legacy policy.yml \u2014 consider migrating to POLICY.json");
+    }
+  } catch (err) {
+    console.error(`[PolicyEngine] Failed to load policy config: ${err}`);
+  }
+  return DEFAULT_POLICY_CONFIG;
+}
+function savePolicyConfig(config) {
+  try {
+    const root = getProjectRoot();
+    const policyPath = path.join(root, ".kuma", "POLICY.json");
+    const dir = path.dirname(policyPath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(policyPath, JSON.stringify(config, null, 2), "utf-8");
+    return `\u2705 Policy config saved to .kuma/POLICY.json (${config.rules.length} rules)`;
+  } catch (err) {
+    return `\u274C Failed to save policy: ${err}`;
+  }
+}
+function evaluateCommand(command) {
+  const config = loadPolicyConfig();
+  const warnings = [];
+  const cmdLower = command.toLowerCase();
+  for (const rule of config.rules) {
+    const matches = rule.patterns.some((p) => cmdLower.includes(p.toLowerCase()));
+    if (!matches) continue;
+    if (rule.action === "block" || rule.severity === "error") {
+      return {
+        allowed: false,
+        blockedBy: rule,
+        warnings,
+        requiresOverride: rule.requireOverride ?? false,
+        message: `\u26D4 Policy violation: "${rule.description}" (rule: ${rule.id})`
+      };
+    }
+    if (rule.action === "warn") {
+      warnings.push(rule);
+    }
+  }
+  for (const cmd of config.block_commands || []) {
+    if (cmdLower.includes(cmd.toLowerCase())) {
+      return {
+        allowed: false,
+        blockedBy: {
+          id: "block-command",
+          description: `Blocked command: ${cmd}`,
+          severity: "error",
+          patterns: [cmd],
+          action: "block",
+          requireOverride: true
+        },
+        warnings,
+        requiresOverride: true,
+        message: `\u26D4 Command matches blocked pattern: "${cmd}"`
+      };
+    }
+  }
+  return {
+    allowed: true,
+    blockedBy: null,
+    warnings,
+    requiresOverride: false,
+    message: warnings.length > 0 ? `\u26A0\uFE0F Command allowed with ${warnings.length} warning(s)` : "\u2705 Command allowed by policy"
+  };
+}
+function evaluateFilePath(filePath) {
+  const config = loadPolicyConfig();
+  const filesToCheck = config.never_touch || DEFAULT_POLICY_CONFIG.never_touch || [];
+  for (const pattern of filesToCheck) {
+    if (matchesGlob(pattern, filePath)) {
+      return {
+        allowed: false,
+        blockedBy: {
+          id: "never-touch",
+          description: `File matches never_touch pattern: ${pattern}`,
+          severity: "error",
+          patterns: [pattern],
+          action: "block",
+          requireOverride: true
+        },
+        warnings: [],
+        requiresOverride: true,
+        message: `\u26D4 File "${filePath}" is protected by never_touch policy (pattern: ${pattern}). Use kuma_safety({ action: 'override' }) to bypass.`
+      };
+    }
+  }
+  return {
+    allowed: true,
+    blockedBy: null,
+    warnings: [],
+    requiresOverride: false,
+    message: "\u2705 File allowed by policy"
+  };
+}
+function evaluateDatabaseAction(action) {
+  const cmdLower = action.toLowerCase();
+  if ((cmdLower.includes("drop") || cmdLower.includes("truncate")) && (cmdLower.includes("database") || cmdLower.includes("table") || cmdLower.includes("schema"))) {
+    return {
+      allowed: false,
+      blockedBy: {
+        id: "block-destructive-db",
+        description: "Destructive database operation blocked",
+        severity: "error",
+        patterns: ["DROP DATABASE", "DROP TABLE", "TRUNCATE", "DELETE FROM"],
+        action: "block",
+        requireOverride: true
+      },
+      warnings: [],
+      requiresOverride: true,
+      message: `\u26D4 Destructive database action blocked: "${action}". Use kuma_safety({ action: 'override' }) with a clear reason.`
+    };
+  }
+  return {
+    allowed: true,
+    blockedBy: null,
+    warnings: [],
+    requiresOverride: false,
+    message: "\u2705 Database action allowed by policy"
+  };
+}
+async function processOverride(request) {
+  const { recordAudit } = await import("./safetyAudit-55IVCG5B.js");
+  await recordAudit({
+    timestamp: Math.floor(Date.now() / 1e3),
+    toolName: request.toolName,
+    action: "policy_override",
+    filePath: request.filePath,
+    riskLevel: "high",
+    policyViolations: 1,
+    allowed: true,
+    durationMs: 0,
+    metadata: {
+      override: true,
+      reason: request.reason,
+      command: request.command
+    }
+  });
+  sessionMemory.recordToolCall("kuma_policy_override", {
+    toolName: request.toolName,
+    reason: request.reason,
+    filePath: request.filePath,
+    command: request.command
+  });
+  return [
+    `\u26A0\uFE0F **Policy Override** \u2014 ${request.toolName}`,
+    `\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\u2501`,
+    "",
+    `\u{1F4DD} Reason: ${request.reason}`,
+    request.filePath ? `\u{1F4C4} File: ${request.filePath}` : "",
+    request.command ? `\u{1F4BB} Command: ${request.command}` : "",
+    "",
+    "\u{1F534} This override is recorded in the safety audit trail.",
+    "\u{1F534} Overrides reduce project safety \u2014 use sparingly."
+  ].filter(Boolean).join("\n");
+}
+function formatPolicyStatus() {
+  const config = loadPolicyConfig();
+  const lines = [
+    "\u{1F4DC} **Policy-as-Code Engine**",
+    "\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{1F4CB} Policy: ${config.name}`,
+    `\u{1F522} Version: ${config.version}`,
+    `\u{1F4DD} Rules: ${config.rules.length}`,
+    "",
+    "**Rules:**"
+  ];
+  for (const rule of config.rules) {
+    const icon = rule.action === "block" ? "\u{1F534}" : rule.action === "warn" ? "\u{1F7E1}" : "\u{1F7E2}";
+    const override = rule.requireOverride ? " \u{1F511} override" : "";
+    lines.push(`  ${icon} [${rule.action}] ${rule.description}${override}`);
+    lines.push(`     Patterns: ${rule.patterns.slice(0, 3).join(", ")}`);
+  }
+  const neverTouch = config.never_touch || [];
+  if (neverTouch.length > 0) {
+    lines.push("", "**Protected Files (never_touch):**");
+    for (const p of neverTouch) {
+      lines.push(`  \u{1F6E1}\uFE0F ${p}`);
+    }
+  }
+  return lines.join("\n");
+}
+function matchesGlob(pattern, filePath) {
+  const normalizedPattern = pattern.replace(/\\/g, "/");
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  let regexStr = "^";
+  for (let i = 0; i < normalizedPattern.length; i++) {
+    const ch = normalizedPattern[i];
+    if (ch === "*" && normalizedPattern[i + 1] === "*" && normalizedPattern[i + 2] === "/") {
+      regexStr += "(.+/)?";
+      i += 2;
+    } else if (ch === "*") {
+      regexStr += "[^/]*";
+    } else if (ch === "?") {
+      regexStr += "[^/]";
+    } else {
+      regexStr += ch.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    }
+  }
+  regexStr += "$";
+  try {
+    return new RegExp(regexStr).test(normalizedPath);
+  } catch {
+    return false;
+  }
+}
+export {
+  evaluateCommand,
+  evaluateDatabaseAction,
+  evaluateFilePath,
+  formatPolicyStatus,
+  loadPolicyConfig,
+  processOverride,
+  savePolicyConfig
+};

package/dist/{kumaSearch-LG2OYEJY.js → kumaSearch-QGB4QVXS.js}

@@ -1,6 +1,6 @@
 import {
   getDb
-} from "./chunk-GDNAWLHF.js";
+} from "./chunk-NAM7SCBT.js";
 import {
   getProjectRoot
 } from "./chunk-E2KFPEBT.js";

package/dist/{kumaVerifier-LFRNIGSL.js → kumaVerifier-ARSGPZAM.js}

@@ -1,10 +1,10 @@
 import {
   sessionMemory
-} from "./chunk-BI7KD3SG.js";
+} from "./chunk-SLRRDKQ2.js";
 import {
   getLatestVerifications,
   saveVerification
-} from "./chunk-GDNAWLHF.js";
+} from "./chunk-NAM7SCBT.js";
 import "./chunk-E2KFPEBT.js";
 
 // src/engine/kumaVerifier.ts
@@ -56,6 +56,24 @@ var _localRunning = false;
 var _currentProcess = null;
 var STALE_RESULT_MS = 3e5;
 var DEFAULT_TIMEOUT_MS = 3e4;
+var RUNAWAY_WINDOW_MS = 3e5;
+var RUNAWAY_MAX_CALLS = 3;
+var _verifyCallTimestamps = [];
+function checkRunaway() {
+  const now = Date.now();
+  while (_verifyCallTimestamps.length > 0 && _verifyCallTimestamps[0] < now - RUNAWAY_WINDOW_MS) {
+    _verifyCallTimestamps.shift();
+  }
+  if (_verifyCallTimestamps.length >= RUNAWAY_MAX_CALLS) {
+    const oldestInWindow = _verifyCallTimestamps[0];
+    const waitMs = RUNAWAY_WINDOW_MS - (now - oldestInWindow);
+    const waitSec = Math.ceil(waitMs / 1e3);
+    return `\u26D4 **Runaway protection active** \u2014 ${RUNAWAY_MAX_CALLS}+ verify calls in the last 5 minutes. Please wait ${waitSec}s before trying again.
+\u{1F4A1} This prevents resource exhaustion (CPU/RAM) from uncontrolled test spawning.`;
+  }
+  _verifyCallTimestamps.push(now);
+  return null;
+}
 function getRunningVerificationPid() {
   return _currentProcess?.pid ?? null;
 }
@@ -126,6 +144,11 @@ async function runAutoVerification(options = {}) {
   const timeoutMs = options.timeoutMs || DEFAULT_TIMEOUT_MS;
   const denial = checkAllowed(root);
   if (denial) return denial;
+  const runawayBlock = checkRunaway();
+  if (runawayBlock) {
+    releaseFileLock(root);
+    return runawayBlock;
+  }
   try {
     if (!options.force) {
       const cached = await checkStaleness(scope);

package/dist/{kumaVisualize-ODCWFSUY.js → kumaVisualize-TECABHUY.js}

@@ -1,6 +1,6 @@
 import {
   getDb
-} from "./chunk-GDNAWLHF.js";
+} from "./chunk-NAM7SCBT.js";
 import "./chunk-E2KFPEBT.js";
 
 // src/engine/kumaVisualize.ts

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.7",
+  "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",