@plumpslabs/kuma 2.3.8 → 2.3.10

package/dist/kumaContractEngine-KX27T4N7.js

@@ -0,0 +1,305 @@
+import {
+  getProjectRoot
+} from "./chunk-E2KFPEBT.js";
+
+// src/engine/kumaContractEngine.ts
+import fs from "fs";
+import path from "path";
+var DEFAULT_CONTRACTS = {
+  version: 1,
+  contracts: [
+    {
+      id: "no-delete-tests-without-replacement",
+      description: "Test files should not be deleted without replacement",
+      appliesTo: ["*"],
+      preConditions: [],
+      postConditions: [
+        {
+          type: "not_contains",
+          target: "*/.test.*",
+          value: "test.skip",
+          description: "Tests should not be skipped without reason"
+        }
+      ],
+      severity: "warning"
+    },
+    {
+      id: "no-silent-empty-catch",
+      description: "Catch blocks must not be empty",
+      appliesTo: ["*"],
+      preConditions: [],
+      postConditions: [
+        {
+          type: "not_contains",
+          target: "*.ts",
+          value: "catch {}",
+          description: "Empty catch blocks suppress errors silently"
+        },
+        {
+          type: "not_contains",
+          target: "*.ts",
+          value: "catch (e) {}",
+          description: "Empty catch (e) {} suppresses errors silently"
+        }
+      ],
+      severity: "error"
+    },
+    {
+      id: "api-response-shape",
+      description: "API response shape must be preserved",
+      appliesTo: ["src/api/*", "src/routes/*"],
+      preConditions: [],
+      postConditions: [],
+      severity: "warning"
+    }
+  ]
+};
+function contractsDir() {
+  return path.join(getProjectRoot(), ".kuma", "contracts");
+}
+function ensureContractsDir() {
+  const dir = contractsDir();
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+    const defaultPath = path.join(dir, "default.json");
+    if (!fs.existsSync(defaultPath)) {
+      fs.writeFileSync(
+        defaultPath,
+        JSON.stringify(DEFAULT_CONTRACTS, null, 2),
+        "utf-8"
+      );
+    }
+  }
+}
+function loadContracts() {
+  ensureContractsDir();
+  const dir = contractsDir();
+  const contracts = [];
+  try {
+    const files = fs.readdirSync(dir).filter((f) => f.endsWith(".json"));
+    for (const file of files) {
+      try {
+        const content = fs.readFileSync(path.join(dir, file), "utf-8");
+        const config = JSON.parse(content);
+        contracts.push(config);
+      } catch (err) {
+        console.error(`[ContractEngine] Failed to load ${file}: ${err}`);
+      }
+    }
+  } catch {
+  }
+  if (contracts.length === 0) {
+    contracts.push(DEFAULT_CONTRACTS);
+  }
+  return contracts;
+}
+function evaluatePreConditions(toolName, filePath) {
+  const contracts = loadContracts();
+  const verdicts = [];
+  for (const config of contracts) {
+    for (const contract of config.contracts) {
+      if (!appliesToContract(contract, toolName, filePath)) continue;
+      const violations = [];
+      for (const condition of contract.preConditions) {
+        const result = evaluateCondition(condition, filePath);
+        if (!result.passed) {
+          violations.push({
+            condition,
+            message: result.message,
+            severity: contract.severity
+          });
+        }
+      }
+      verdicts.push({
+        contractId: contract.id,
+        description: contract.description,
+        passed: violations.length === 0,
+        violations
+      });
+    }
+  }
+  return verdicts;
+}
+function evaluatePostConditions(toolName, filePath) {
+  const contracts = loadContracts();
+  const verdicts = [];
+  for (const config of contracts) {
+    for (const contract of config.contracts) {
+      if (!appliesToContract(contract, toolName, filePath)) continue;
+      const violations = [];
+      for (const condition of contract.postConditions) {
+        const result = evaluateCondition(condition, filePath);
+        if (!result.passed) {
+          violations.push({
+            condition,
+            message: result.message,
+            severity: contract.severity
+          });
+        }
+      }
+      verdicts.push({
+        contractId: contract.id,
+        description: contract.description,
+        passed: violations.length === 0,
+        violations
+      });
+    }
+  }
+  return verdicts;
+}
+function evaluateCondition(condition, contextPath) {
+  const root = getProjectRoot();
+  switch (condition.type) {
+    case "file_exists": {
+      const targetPath = resolveTarget(condition.target, contextPath, root);
+      const exists = targetPath.some((p) => fs.existsSync(p));
+      return {
+        passed: exists,
+        message: exists ? `\u2705 File exists: ${condition.target}` : `\u274C Required file not found: ${condition.target} (${condition.description})`
+      };
+    }
+    case "file_not_exists": {
+      const targetPath = resolveTarget(condition.target, contextPath, root);
+      const exists = targetPath.some((p) => fs.existsSync(p));
+      return {
+        passed: !exists,
+        message: !exists ? `\u2705 File does not exist: ${condition.target}` : `\u274C File should not exist: ${condition.target} (${condition.description})`
+      };
+    }
+    case "contains": {
+      if (!contextPath) return { passed: true, message: "\u26A0\uFE0F No file to check" };
+      const fullPath = path.resolve(root, contextPath);
+      if (!fs.existsSync(fullPath)) return { passed: true, message: "\u26A0\uFE0F File not found" };
+      const content = fs.readFileSync(fullPath, "utf-8");
+      const hasContent = condition.value ? content.includes(condition.value) : false;
+      return {
+        passed: hasContent,
+        message: hasContent ? `\u2705 Contains expected content` : `\u274C Missing expected content: "${condition.value}" (${condition.description})`
+      };
+    }
+    case "not_contains": {
+      if (!contextPath) return { passed: true, message: "\u26A0\uFE0F No file to check" };
+      const root2 = getProjectRoot();
+      const targets = resolveTarget(condition.target, contextPath, root2);
+      for (const t of targets) {
+        if (fs.existsSync(t)) {
+          const content = fs.readFileSync(t, "utf-8");
+          if (condition.value && content.includes(condition.value)) {
+            return {
+              passed: false,
+              message: `\u274C Found forbidden pattern "${condition.value}" in ${path.relative(root2, t)} (${condition.description})`
+            };
+          }
+        }
+      }
+      return { passed: true, message: "\u2705 No forbidden patterns found" };
+    }
+    case "has_test_file": {
+      if (!contextPath) return { passed: true, message: "\u26A0\uFE0F No file to check" };
+      const basename = path.basename(contextPath, path.extname(contextPath));
+      const dir = path.dirname(contextPath);
+      const possibleTests = [
+        path.join(dir, `${basename}.test.ts`),
+        path.join(dir, `${basename}.spec.ts`),
+        path.join(dir, `__tests__/${basename}.test.ts`),
+        path.join(dir, `__tests__/${basename}.spec.ts`)
+      ];
+      const hasTest = possibleTests.some((t) => fs.existsSync(t));
+      return {
+        passed: hasTest,
+        message: hasTest ? `\u2705 Test file exists` : `\u274C No test file found for ${contextPath} (${condition.description})`
+      };
+    }
+    default:
+      return { passed: true, message: `\u26A0\uFE0F Unknown condition type: ${condition.type}` };
+  }
+}
+function appliesToContract(contract, toolName, filePath) {
+  if (contract.appliesTo.includes("*")) return true;
+  if (contract.appliesTo.includes(toolName)) return true;
+  if (filePath) {
+    return contract.appliesTo.some((pattern) => {
+      return filePath.includes(pattern.replace("*", ""));
+    });
+  }
+  return false;
+}
+function resolveTarget(pattern, contextPath, root) {
+  const r = root || getProjectRoot();
+  if (pattern.startsWith("*")) {
+    if (contextPath) {
+      const dir = path.dirname(path.resolve(r, contextPath));
+      const suffix = pattern.replace("*", "");
+      try {
+        const files = fs.readdirSync(dir);
+        return files.filter((f) => f.endsWith(suffix) || f.includes(suffix)).map((f) => path.join(dir, f));
+      } catch {
+        return [path.join(dir, pattern.replace("*", ""))];
+      }
+    }
+    return [];
+  }
+  return [path.resolve(r, pattern)];
+}
+async function runContractChecks(toolName, filePath, phase = "pre") {
+  const verdicts = phase === "pre" ? evaluatePreConditions(toolName, filePath) : evaluatePostConditions(toolName, filePath);
+  if (verdicts.length === 0) {
+    return "\u2705 **No applicable contracts** for this action.";
+  }
+  const lines = [
+    `\u{1F4DC} **Contract Check** (${phase}-conditions)`,
+    `\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\u2501`,
+    ``
+  ];
+  let totalViolations = 0;
+  let errors = 0;
+  for (const v of verdicts) {
+    if (v.passed) {
+      lines.push(`  \u2705 **${v.description}** \u2014 passed`);
+    } else {
+      totalViolations += v.violations.length;
+      const errorCount = v.violations.filter((x) => x.severity === "error").length;
+      errors += errorCount;
+      lines.push(`  ${errorCount > 0 ? "\u{1F534}" : "\u{1F7E1}"} **${v.description}** \u2014 ${v.violations.length} violation(s)`);
+      for (const violation of v.violations) {
+        lines.push(`     ${violation.severity === "error" ? "\u{1F534}" : "\u{1F7E1}"} ${violation.message.substring(0, 120)}`);
+      }
+    }
+  }
+  lines.push("");
+  if (errors > 0) {
+    lines.push(`\u{1F534} **${errors} error(s)** \u2014 blocking. Resolve before proceeding.`);
+  } else if (totalViolations > 0) {
+    lines.push(`\u{1F7E1} **${totalViolations} warning(s)** \u2014 review recommended.`);
+  } else {
+    lines.push("\u2705 All contract checks passed.");
+  }
+  return lines.join("\n");
+}
+function listContracts() {
+  const configs = loadContracts();
+  const lines = [
+    "\u{1F4DC} **Active Contracts**",
+    "\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 config of configs) {
+    for (const contract of config.contracts) {
+      const appliesTo = contract.appliesTo.join(", ");
+      lines.push(`  \u{1F4CC} **${contract.id}**`);
+      lines.push(`     ${contract.description}`);
+      lines.push(`     Applies to: ${appliesTo}`);
+      lines.push(`     Pre-conditions: ${contract.preConditions.length}`);
+      lines.push(`     Post-conditions: ${contract.postConditions.length}`);
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+export {
+  evaluatePostConditions,
+  evaluatePreConditions,
+  listContracts,
+  loadContracts,
+  runContractChecks
+};

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

@@ -17,6 +17,7 @@ import {
   listTodos,
   recordChange,
   recordDecisionLog,
+  resetDbInstance,
   rollbackChange,
   runDoctor,
   runGarbageCollection,
@@ -28,7 +29,7 @@ import {
   saveVerification,
   updateDecisionStatus,
   updateTodoStatus
-} from "./chunk-NAM7SCBT.js";
+} from "./chunk-3TX6Q37T.js";
 import "./chunk-E2KFPEBT.js";
 export {
   addContextNote,
@@ -49,6 +50,7 @@ export {
   listTodos,
   recordChange,
   recordDecisionLog,
+  resetDbInstance,
   rollbackChange,
   runDoctor,
   runGarbageCollection,

package/dist/{kumaDriftDetector-OESI5GTC.js → kumaDriftDetector-QBY6OJOO.js}

@@ -1,7 +1,7 @@
 import {
   getDb,
   saveDb
-} from "./chunk-NAM7SCBT.js";
+} from "./chunk-3TX6Q37T.js";
 import {
   getProjectRoot
 } from "./chunk-E2KFPEBT.js";

package/dist/{kumaGotchas-DU5H6N7X.js → kumaGotchas-5HODT5RI.js}

@@ -2,14 +2,14 @@ import {
   appendToLayer,
   checkFileGotchas,
   getActiveGotchas
-} from "./chunk-53J56QCQ.js";
+} from "./chunk-Q2444HWO.js";
 import {
   sessionMemory
-} from "./chunk-SLRRDKQ2.js";
+} from "./chunk-R6B3VUSB.js";
 import {
   getDb,
   saveDb
-} from "./chunk-NAM7SCBT.js";
+} from "./chunk-3TX6Q37T.js";
 import "./chunk-E2KFPEBT.js";
 
 // src/engine/kumaGotchas.ts

package/dist/{kumaGraph-AWP743TJ.js → kumaGraph-GUQM75WL.js}

@@ -5,17 +5,20 @@ import {
   formatFlow,
   formatImpact,
   getGraphStats,
+  listFederatedReferences,
+  nodeId,
   queryGraph,
   recordApiRoute,
   recordFileDefinition,
   recordFunctionCall,
   recordImport,
   recordTestRelation,
+  resolveFederatedNode,
   searchGraph,
   traceFlow,
   upsertNode
-} from "./chunk-4OB3XMHT.js";
-import "./chunk-NAM7SCBT.js";
+} from "./chunk-ZKDYTYMS.js";
+import "./chunk-3TX6Q37T.js";
 import "./chunk-E2KFPEBT.js";
 export {
   addEdge,
@@ -24,12 +27,15 @@ export {
   formatFlow,
   formatImpact,
   getGraphStats,
+  listFederatedReferences,
+  nodeId,
   queryGraph,
   recordApiRoute,
   recordFileDefinition,
   recordFunctionCall,
   recordImport,
   recordTestRelation,
+  resolveFederatedNode,
   searchGraph,
   traceFlow,
   upsertNode

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

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

package/dist/{kumaMiner-FFXSRHAO.js → kumaMiner-3RXEOCBP.js}

@@ -1,10 +1,10 @@
 import {
   recordDecision
-} from "./chunk-RTGLQDMI.js";
-import "./chunk-SLRRDKQ2.js";
+} from "./chunk-OJALFQ4H.js";
+import "./chunk-R6B3VUSB.js";
 import {
   recordDecisionLog
-} from "./chunk-NAM7SCBT.js";
+} from "./chunk-3TX6Q37T.js";
 import "./chunk-E2KFPEBT.js";
 
 // src/engine/kumaMiner.ts

package/dist/{kumaPolicyEngine-S2PXN3C7.js → kumaPolicyEngine-ORBWL5PT.js}

@@ -1,6 +1,6 @@
 import {
   sessionMemory
-} from "./chunk-SLRRDKQ2.js";
+} from "./chunk-R6B3VUSB.js";
 import {
   getProjectRoot
 } from "./chunk-E2KFPEBT.js";
@@ -215,7 +215,7 @@ function evaluateDatabaseAction(action) {
   };
 }
 async function processOverride(request) {
-  const { recordAudit } = await import("./safetyAudit-55IVCG5B.js");
+  const { recordAudit } = await import("./safetyAudit-32WSA4Z5.js");
   await recordAudit({
     timestamp: Math.floor(Date.now() / 1e3),
     toolName: request.toolName,

package/dist/kumaProgressiveContext-CVSNPY3W.js

@@ -0,0 +1,231 @@
+import {
+  getActiveGotchas,
+  readLayer
+} from "./chunk-Q2444HWO.js";
+import "./chunk-R6B3VUSB.js";
+import {
+  getDb
+} from "./chunk-3TX6Q37T.js";
+import {
+  getProjectRoot
+} from "./chunk-E2KFPEBT.js";
+
+// src/engine/kumaProgressiveContext.ts
+import fs from "fs";
+import path from "path";
+async function getProjectMeta() {
+  const root = getProjectRoot();
+  const name = root.split("/").pop() || "unknown";
+  const stack = [];
+  if (fs.existsSync(path.join(root, "package.json"))) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf-8"));
+      if (pkg.dependencies?.next) stack.push("Next.js");
+      else if (pkg.dependencies?.react) stack.push("React");
+      if (pkg.devDependencies?.typescript) stack.push("TypeScript");
+      if (fs.existsSync(path.join(root, "pnpm-lock.yaml"))) stack.push("pnpm");
+      else if (fs.existsSync(path.join(root, "yarn.lock"))) stack.push("yarn");
+    } catch {
+    }
+  }
+  if (fs.existsSync(path.join(root, "go.mod"))) stack.push("Go");
+  if (fs.existsSync(path.join(root, "Cargo.toml"))) stack.push("Rust");
+  if (fs.existsSync(path.join(root, "pyproject.toml"))) stack.push("Python");
+  let nodeCount = 0;
+  let edgeCount = 0;
+  try {
+    const db = await getDb();
+    const nodeRes = db.exec("SELECT COUNT(*) as c FROM nodes");
+    nodeCount = nodeRes[0]?.values[0]?.[0] ?? 0;
+    const edgeRes = db.exec("SELECT COUNT(*) as c FROM edges");
+    edgeCount = edgeRes[0]?.values[0]?.[0] ?? 0;
+  } catch {
+  }
+  const kumaDir = path.join(root, ".kuma");
+  const layerStatus = {
+    domainRules: fs.existsSync(path.join(kumaDir, "DOMAIN_RULES.md")),
+    archFlow: fs.existsSync(path.join(kumaDir, "ARCHITECTURE_FLOW.md")),
+    gotchas: getActiveGotchas().length
+  };
+  let hasDecisions = false;
+  let hasTodos = false;
+  try {
+    const db = await getDb();
+    const decRes = db.exec("SELECT COUNT(*) as c FROM decision_log");
+    hasDecisions = (decRes[0]?.values[0]?.[0] ?? 0) > 0;
+    const todoRes = db.exec("SELECT COUNT(*) as c FROM todos WHERE status != 'done'");
+    hasTodos = (todoRes[0]?.values[0]?.[0] ?? 0) > 0;
+  } catch {
+  }
+  return { name, stack, entryPoints: [], nodeCount, edgeCount, layerStatus, hasDecisions, hasTodos };
+}
+function formatProjectMeta(meta) {
+  const parts = [
+    `\u{1F4C1} ${meta.name}`,
+    meta.stack.length > 0 ? `\u26A1 ${meta.stack.join("/")}` : "",
+    `\u{1F4CA} ${meta.nodeCount}n/${meta.edgeCount}e`,
+    meta.layerStatus.domainRules ? "\u{1F4CB}R" : "",
+    meta.layerStatus.archFlow ? "\u{1F3D7}\uFE0FA" : "",
+    meta.layerStatus.gotchas > 0 ? `\u26A0\uFE0F${meta.layerStatus.gotchas}g` : "",
+    meta.hasDecisions ? "\u{1F4DD}D" : "",
+    meta.hasTodos ? "\u{1F4CC}T" : ""
+  ].filter(Boolean);
+  return parts.join(" | ");
+}
+async function loadSection(section, scope) {
+  switch (section) {
+    case "domain_rules": {
+      try {
+        const content = readLayer("domain_rules");
+        const lines = content.split("\n").filter((l) => l.trim() && !l.startsWith("<!--"));
+        return `\u{1F4CB} **Domain Rules**
+${lines.slice(0, 20).join("\n")}`;
+      } catch {
+        return "\u{1F4CB} **Domain Rules**: not configured";
+      }
+    }
+    case "architecture": {
+      try {
+        const content = readLayer("arch_flow");
+        const relevant = scope ? content.split("\n").filter((l) => l.toLowerCase().includes(scope.toLowerCase())).slice(0, 15) : content.split("\n").filter((l) => l.trim() && !l.startsWith("<!--")).slice(0, 20);
+        return `\u{1F3D7}\uFE0F **Architecture${scope ? `: ${scope}` : ""}**
+${relevant.join("\n")}`;
+      } catch {
+        return "\u{1F3D7}\uFE0F **Architecture**: not documented";
+      }
+    }
+    case "gotchas": {
+      const gotchas = getActiveGotchas();
+      if (gotchas.length === 0) return "\u26A0\uFE0F **Gotchas**: none recorded";
+      const filtered = scope ? gotchas.filter((g) => g.filePath.toLowerCase().includes(scope.toLowerCase())) : gotchas;
+      const lines = filtered.slice(0, 5).map((g) => {
+        const icon = g.severity === "critical" ? "\u{1F534}" : g.severity === "high" ? "\u{1F7E0}" : "\u{1F7E1}";
+        return `${icon} ${g.filePath}: ${g.description.substring(0, 80)}`;
+      });
+      return `\u26A0\uFE0F **Gotchas** (${filtered.length} active)
+${lines.join("\n")}`;
+    }
+    case "decisions": {
+      try {
+        const db = await getDb();
+        const stmt = db.prepare(
+          `SELECT title, status, created_at FROM decision_log ORDER BY created_at DESC LIMIT 10`
+        );
+        const results = [];
+        while (stmt.step()) results.push(stmt.getAsObject());
+        stmt.free();
+        if (results.length === 0) return "\u{1F4DD} **Decisions**: none recorded";
+        const lines = results.map(
+          (d) => `  ${d.status === "active" ? "\u2705" : "\u{1F4DD}"} ${d.title} (${d.status})`
+        );
+        return `\u{1F4DD} **Decisions** (${results.length})
+${lines.join("\n")}`;
+      } catch {
+        return "\u{1F4DD} **Decisions**: unavailable";
+      }
+    }
+    case "graph": {
+      try {
+        const db = await getDb();
+        const nodeRes = db.exec("SELECT type, COUNT(*) as cnt FROM nodes GROUP BY type ORDER BY cnt DESC LIMIT 8");
+        if (!nodeRes[0]?.values) return "\u{1F4CA} **Graph**: empty";
+        const lines = nodeRes[0].values.map((r) => `  ${r[0]}: ${r[1]}`);
+        return `\u{1F4CA} **Knowledge Graph**
+${lines.join("\n")}`;
+      } catch {
+        return "\u{1F4CA} **Graph**: unavailable";
+      }
+    }
+    case "changes": {
+      try {
+        const db = await getDb();
+        const stmt = db.prepare("SELECT file_path, change_type FROM change_log ORDER BY id DESC LIMIT 8");
+        const results = [];
+        while (stmt.step()) results.push(stmt.getAsObject());
+        stmt.free();
+        if (results.length === 0) return "\u{1F4DD} **Changes**: none in this session";
+        const lines = results.map(
+          (r) => `  ${r.change_type === "modified" ? "\u{1F4DD}" : r.change_type === "created" ? "\u2728" : "\u274C"} ${r.file_path}`
+        );
+        return `\u{1F4DD} **Recent Changes** (${results.length})
+${lines.join("\n")}`;
+      } catch {
+        return "\u{1F4DD} **Changes**: unavailable";
+      }
+    }
+    case "health": {
+      try {
+        const { computeSafetyScore } = await import("./safetyScore-WU27EOG4.js");
+        const score = await computeSafetyScore();
+        return `\u{1F3E5} **Health**: ${score.score}/100 (${score.risk})`;
+      } catch {
+        return "\u{1F3E5} **Health**: unavailable";
+      }
+    }
+    default:
+      return `Unknown section: ${section}`;
+  }
+}
+function getSkillBoundary(skillArea) {
+  const area = skillArea.toLowerCase();
+  if (area.includes("auth") || area.includes("login") || area.includes("security")) {
+    return {
+      name: "auth",
+      relatedSections: ["domain_rules", "architecture", "gotchas", "decisions"],
+      relatedPaths: ["src/auth", "src/middleware", "src/guards"],
+      description: "Authentication & authorization context"
+    };
+  }
+  if (area.includes("test") || area.includes("spec")) {
+    return {
+      name: "testing",
+      relatedSections: ["gotchas", "health"],
+      relatedPaths: ["__tests__", "*.test.*", "*.spec.*"],
+      description: "Testing & verification context"
+    };
+  }
+  if (area.includes("db") || area.includes("database") || area.includes("schema")) {
+    return {
+      name: "database",
+      relatedSections: ["architecture", "gotchas", "decisions"],
+      relatedPaths: ["prisma", "src/db", "schema", "migrations"],
+      description: "Database & schema context"
+    };
+  }
+  if (area.includes("api") || area.includes("route") || area.includes("endpoint")) {
+    return {
+      name: "api",
+      relatedSections: ["architecture", "gotchas", "decisions", "changes"],
+      relatedPaths: ["src/api", "src/routes", "src/controllers"],
+      description: "API & routing context"
+    };
+  }
+  return {
+    name: "general",
+    relatedSections: ["domain_rules", "gotchas"],
+    relatedPaths: [],
+    description: "General project context"
+  };
+}
+async function getProgressiveContext(skillArea) {
+  const meta = await getProjectMeta();
+  const boundary = getSkillBoundary(skillArea || "general");
+  const sections = await Promise.all(
+    boundary.relatedSections.map(async (section) => ({
+      name: section,
+      content: await loadSection(section, skillArea)
+    }))
+  );
+  return {
+    meta: formatProjectMeta(meta),
+    sections,
+    boundary
+  };
+}
+export {
+  formatProjectMeta,
+  getProgressiveContext,
+  getProjectMeta,
+  getSkillBoundary,
+  loadSection
+};

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

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