@plumpslabs/kuma 2.3.16 → 2.3.17

package/dist/{chunk-S7BQGNHQ.js → chunk-AJ7HHUDW.js}

@@ -474,6 +474,78 @@ function generateInitMdContent() {
     "  kuma_memory \u2192 mine           \u2014 Historical context",
     "```",
     "",
+    "## \u{1F9E0} How the Scanner Works",
+    "",
+    "Kuma's code scanner (`kumaCodeScanner.ts`) uses **regex-based pattern matching**",
+    "to detect code structure. It is NOT a full AST parser (no Babel/TypeScript compiler dependency).",
+    "",
+    "**What it detects (line-by-line regex):**",
+    "- `function` declarations (named + async + generator)",
+    "- Arrow function assignments (`const foo = (...) => ...`)",
+    "- Typed arrow functions (`const foo: Type = (...) => ...`)",
+    "- Class declarations (includes extends/implements)",
+    "- React/Vue components (functions returning JSX)",
+    "- API route handlers (Express + Hono patterns)",
+    "- Import statements (local file imports only)",
+    "- Function calls cross-file (`calls` edges)",
+    "- Test files (`.test.`, `.spec.`, `__tests__/`)",
+    "",
+    "**Known limitations:**",
+    "- Regex-based = can miss multi-line constructs or non-standard patterns",
+    "- Complex generics or deeply nested syntax may not match",
+    "- TypeScript advanced types may be partially parsed",
+    "- Scanner runs automatically during `kuma_context research` step 3",
+    "- If scanner returns 0 structural nodes, the regex patterns didn't match your code style",
+    "",
+    "**For richer code analysis:**",
+    "- Record findings INLINE as you read/grep \u2014 this builds the graph manually",
+    "- Call `research_save` after exploring files to persist function/class/import nodes",
+    "- The more you use Kuma, the richer the graph becomes (persistent across sessions)",
+    "",
+    "---",
+    "",
+    "## \u{1F4BE} How to Read Memory & Search the Graph",
+    "",
+    "Kuma stores knowledge in two places:",
+    "",
+    "**1. Knowledge Graph (SQLite - `.kuma/kuma.db`)**",
+    "- Nodes: files, functions, classes, components, routes, tests, gotchas, decisions",
+    "- Edges: imports, calls, extends, contains, composes, routes",
+    '- Query: `kuma_memory({ action: "search", query: "<term>" })`',
+    "- Falls back to codebase grep if graph is empty",
+    "",
+    "**2. Research Cache (SQLite - `.kuma/kuma.db`)**",
+    '- Saved via `kuma_memory({ action: "research_save", scope: "<area>", confidence: 0.8 })`',
+    '- List: `kuma_context({ action: "researches" })`',
+    '- Auto-loaded during `kuma_context({ action: "research", scope: "<area>" })`',
+    "",
+    "**Quick memory reading tips:**",
+    '- `kuma_context({ action: "init" })` \u2014 shows graph stats + recent research + health score',
+    '- `kuma_context({ action: "research", scope: "<area>" })` \u2014 deep research with graph query',
+    '- `kuma_memory({ action: "search", query: "<term>" })` \u2014 search all memories + graph',
+    '- `kuma_context({ action: "visualize" })` \u2014 Mermaid diagram of the graph',
+    '- `kuma_context({ action: "drift" })` \u2014 check if memories are stale vs actual code',
+    '- `kuma_context({ action: "changes" })` \u2014 view session activity log',
+    "",
+    "---",
+    "",
+    "## \u{1F52C} How Verification Works",
+    "",
+    '`kuma_safety({ action: "verify", scope: "<area>" })` \u2014 STEP 9',
+    "",
+    "**Auto-detection logic:**",
+    "1. Checks `package.json` \u2192 `scripts.test` \u2192 uses npm/pnpm/yarn test",
+    "2. If no test script, checks for Makefile with `test:` target",
+    "3. Falls back to Python (pytest), Rust (cargo test), Go (go test)",
+    "4. Last resort: `npx tsc --noEmit` (TypeScript syntax check) or `node -c`",
+    "5. If nothing found: returns informative message instead of failing",
+    "",
+    "**Important:** Verification is NEVER auto-triggered. You must call it explicitly.",
+    "The 5-layer safety guard (concurrency lock, rate limiting, staleness cache,",
+    "runaway detection, hard timeout) prevents resource exhaustion.",
+    "",
+    "---",
+    "",
     "## \u{1F6AB} What Kuma Does NOT Do (Use Agent Native Tools)",
     "",
     "| Function | Correct Tool |",

package/dist/index.js

@@ -8,7 +8,7 @@ import {
   ALL_CONFIG_TYPES,
   formatInitResults,
   runInit
-} from "./chunk-S7BQGNHQ.js";
+} from "./chunk-AJ7HHUDW.js";
 import {
   formatDecisionTemplate,
   getProactiveMemories,
@@ -336,7 +336,7 @@ async function handleResearch(params) {
     lines.push("  \u26A0\uFE0F Graph query failed");
   }
   try {
-    const { scanCodebase } = await import("./kumaCodeScanner-LFJGPJNH.js");
+    const { scanCodebase } = await import("./kumaCodeScanner-QYQUL4W6.js");
     const scanResult = await scanCodebase({ scope, maxFiles: 100 });
     if (scanResult.nodeCount > 0 || scanResult.edgeCount > 0) {
       lines.push(`  \u{1F52C} Auto-scanned ${scanResult.filesScanned} files \u2192 ${scanResult.nodeCount} nodes, ${scanResult.edgeCount} edges`);
@@ -2149,7 +2149,7 @@ async function handleVerify(params) {
   }
   _lastVerifyCall = now;
   sessionMemory.recordToolCall("kuma_safety_verify", { scope: params.scope || params.filePath });
-  const { runAutoVerification } = await import("./kumaVerifier-KAYJHR5K.js");
+  const { runAutoVerification } = await import("./kumaVerifier-6NTJQU7B.js");
   return await runAutoVerification({
     scope: params.scope || params.filePath,
     force: params.force,
@@ -2362,7 +2362,7 @@ async function main() {
     console.error("");
     let killedCount = 0;
     try {
-      const { getRunningVerificationPid } = await import("./kumaVerifier-KAYJHR5K.js");
+      const { getRunningVerificationPid } = await import("./kumaVerifier-6NTJQU7B.js");
       const pid = getRunningVerificationPid();
       if (pid) {
         try {
@@ -2571,7 +2571,7 @@ async function main() {
   });
   (async () => {
     try {
-      const { generateInitMdContent } = await import("./init-P3DAC23E.js");
+      const { generateInitMdContent } = await import("./init-BC7FG4C2.js");
       const fs7 = await import("fs");
       const path7 = await import("path");
       const initMdPath = path7.resolve(process.cwd(), ".kuma/init.md");

package/dist/{init-P3DAC23E.js → init-BC7FG4C2.js}

@@ -4,7 +4,7 @@ import {
   formatInitResults,
   generateInitMdContent,
   runInit
-} from "./chunk-S7BQGNHQ.js";
+} from "./chunk-AJ7HHUDW.js";
 import "./chunk-E2KFPEBT.js";
 export {
   ALL_CONFIG_TYPES,

package/dist/{kumaCodeScanner-LFJGPJNH.js → kumaCodeScanner-QYQUL4W6.js}

@@ -21,8 +21,8 @@ function getRoot() {
   return _cachedRoot;
 }
 var FUNCTION_DECL_RE = /(?:export\s+)?(?:async\s+)?function\s*(?:\*\s*)?(\w+)\s*\(/g;
-var ARROW_FN_RE = /(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s*)?\([^)]*\)\s*(?::\s*\w+(?:<[^>]*>)?)?\s*=>/g;
-var TYPED_ARROW_RE = /(?:export\s+)?(?:const|let|var)\s+(\w+)\s*:\s*(?:\w+(?:<[^>]*>)?)?\s*=\s*(?:async\s*)?\(/g;
+var ARROW_FN_RE = /(?:export\s+)?(?:const|let|var)\s+(\w+)\s*[=:]\s*(?:async\s*)?(?:<[^>]+>\s*)?(?:\([\s\S]*?\)|\w+)\s*(?::\s*\w+(?:<[^>]*>)?)?\s*=>/g;
+var TYPED_ARROW_RE = /(?:export\s+)?(?:const|let|var)\s+(\w+)\s*:\s*(?:\w+(?:<[^>]*>)?)?\s*=\s*(?:async\s*)?(?:<[^>]+>\s*)?\(/g;
 var CLASS_RE = /(?:export\s+)?(?:abstract\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?(?:\s+implements\s+([\w,\s]+))?/g;
 var IMPORT_RE = /import\s+(?:\{([^}]*)\}\s+from\s+)?(?:\w+\s+from\s+)?(?:\*\s+as\s+\w+\s+from\s+)?['"]([^'"]+)['"]/g;
 var JSX_RETURN_RE = /return\s*\(?\s*</;

package/dist/{kumaVerifier-KAYJHR5K.js → kumaVerifier-6NTJQU7B.js}

@@ -93,7 +93,14 @@ function detectTestRunner(root = process.cwd()) {
   if (fs.existsSync(path.join(root, "pytest.ini")) || fs.existsSync(path.join(root, "pyproject.toml"))) return { runner: "pytest", baseCommand: "pytest" };
   if (fs.existsSync(path.join(root, "Cargo.toml"))) return { runner: "cargo", baseCommand: "cargo test" };
   if (fs.existsSync(path.join(root, "go.mod"))) return { runner: "go", baseCommand: "go test ./..." };
-  if (fs.existsSync(path.join(root, "Makefile"))) return { runner: "make", baseCommand: "make test" };
+  if (fs.existsSync(path.join(root, "Makefile"))) {
+    try {
+      const makefileContent = fs.readFileSync(path.join(root, "Makefile"), "utf-8");
+      const hasTestTarget = /^test:/m.test(makefileContent) || /^\s+test:/.test(makefileContent);
+      if (hasTestTarget) return { runner: "make", baseCommand: "make test" };
+    } catch {
+    }
+  }
   if (fs.existsSync(path.join(root, "package.json"))) {
     try {
       const pkg = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf-8"));

package/package.json

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