@plumpslabs/kuma 2.2.4 → 2.2.6

package/dist/index.js

@@ -33,6 +33,7 @@ import { z } from "zod";
 import fg from "fast-glob";
 import fs from "fs";
 import path from "path";
+import { execSync } from "child_process";
 
 // src/utils/tokenCounter.ts
 function estimateTokens(text) {
@@ -86,94 +87,315 @@ var IGNORE_PATTERNS = [
 ];
 var grepCache = /* @__PURE__ */ new Map();
 var CACHE_TTL_MS = 3e4;
+var rgAvailable = null;
+function isRipgrepAvailable() {
+  if (process.env.KUMA_DISABLE_RG === "1" || process.env.KUMA_DISABLE_RG === "true") {
+    return false;
+  }
+  if (rgAvailable !== null) return rgAvailable;
+  try {
+    execSync("rg --version", { stdio: "ignore", timeout: 2e3 });
+    rgAvailable = true;
+  } catch {
+    rgAvailable = false;
+  }
+  return rgAvailable;
+}
+function quotePath(p) {
+  return `"${p.replace(/"/g, '\\"')}"`;
+}
 async function handleSmartGrep(params) {
-  const { query, targetFolder, maxResults = 30, extensions } = params;
-  if (!query || query.length < 1) {
-    return "Error: 'query' parameter is required.";
+  const {
+    query,
+    queries,
+    targetFolder,
+    maxResults = 30,
+    extensions,
+    contextLines = 1,
+    filenamesOnly = false,
+    countOnly = false,
+    outputMode = "rich",
+    compact = false
+  } = params;
+  const patterns = queries && queries.length > 0 ? queries : query ? [query] : [];
+  if (patterns.length === 0 || patterns[0].length < 1) {
+    return compact ? "ERR:query required" : "Error: 'query' or 'queries' parameter is required.";
   }
-  const cacheKey = `${query}:${targetFolder ?? "root"}:${maxResults}:${extensions ? extensions.join(",") : ""}`;
+  const cacheKey = `${patterns.join("||")}:${targetFolder ?? "root"}:${maxResults}:${contextLines}:${filenamesOnly}:${countOnly}:${outputMode}:${extensions ? extensions.join(",") : ""}`;
   const cached = grepCache.get(cacheKey);
   if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
-    sessionMemory.recordToolCall("smart_grep", { query, cached: true });
+    sessionMemory.recordToolCall("smart_grep", { query: patterns[0], cached: true });
     return cached.results;
   }
   const projectRoot = getProjectRoot();
+  let result;
+  if (isRipgrepAvailable()) {
+    result = await tryRipgrep(patterns, {
+      projectRoot,
+      targetFolder,
+      maxResults,
+      extensions,
+      contextLines,
+      filenamesOnly,
+      countOnly,
+      outputMode,
+      compact
+    });
+  } else {
+    result = await jsGrep(patterns, {
+      projectRoot,
+      targetFolder,
+      maxResults,
+      extensions,
+      contextLines,
+      filenamesOnly,
+      countOnly,
+      outputMode,
+      compact
+    });
+  }
+  grepCache.set(cacheKey, { results: result, timestamp: Date.now() });
+  sessionMemory.recordToolCall("smart_grep", {
+    query: patterns[0],
+    matchCount: result.length,
+    engine: rgAvailable ? "ripgrep" : "js"
+  });
+  return result;
+}
+async function tryRipgrep(patterns, opts) {
+  const args = [];
+  args.push("rg", "--no-heading", "--color", "never", "-i");
+  if (opts.extensions && opts.extensions.length > 0) {
+    for (const ext of opts.extensions) {
+      const clean = ext.startsWith(".") ? ext.slice(1) : ext;
+      args.push("--type-add", `kuma:*.${clean}`);
+      args.push("--type", "kuma");
+    }
+  }
+  if (opts.contextLines > 0 && !opts.filenamesOnly && !opts.countOnly) {
+    args.push("-C", String(opts.contextLines));
+  }
+  if (!opts.filenamesOnly && !opts.countOnly) {
+    const perFileLimit = Math.min(opts.maxResults, 50);
+    args.push("-m", String(perFileLimit));
+  }
+  if (opts.filenamesOnly) {
+    args.push("-l");
+  }
+  if (opts.countOnly) {
+    args.push("-c");
+  }
+  for (const p of patterns) {
+    args.push("-e", p);
+  }
+  const searchDir = opts.targetFolder ? path.join(opts.projectRoot, opts.targetFolder) : opts.projectRoot;
+  args.push(quotePath(searchDir));
   try {
-    const searchPattern = targetFolder ? path.join(targetFolder, "**/*").replace(/\\/g, "/") : "**/*";
-    const targetDepth = targetFolder ? targetFolder.split("/").filter(Boolean).length : 0;
-    const maxDepth = targetFolder ? Math.min(targetDepth + 5, 20) : 10;
-    let entries = await fg(searchPattern, {
-      cwd: projectRoot,
-      ignore: IGNORE_PATTERNS,
-      onlyFiles: true,
-      absolute: false,
-      deep: maxDepth,
-      dot: false
-      // Skip dotfiles
+    const output = execSync(args.join(" "), {
+      cwd: opts.projectRoot,
+      maxBuffer: 10 * 1024 * 1024,
+      // 10MB
+      timeout: 15e3,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"]
     });
-    if (extensions && extensions.length > 0) {
-      const normalizedExts = extensions.map(
-        (e) => e.startsWith(".") ? e.toLowerCase() : `.${e.toLowerCase()}`
-      );
-      entries = entries.filter((entry) => {
-        const ext = path.extname(entry).toLowerCase();
-        return normalizedExts.includes(ext);
-      });
+    if (!output || output.trim().length === 0) {
+      return formatEmpty(patterns[0], opts);
     }
-    if (entries.length === 0) {
-      const msg = `No files found${targetFolder ? ` in folder "${targetFolder}"` : ""}${extensions ? ` with extensions [${extensions.join(", ")}]` : ""}.`;
-      grepCache.set(cacheKey, { results: msg, timestamp: Date.now() });
-      return msg;
+    return formatRipgrepOutput(output, patterns, opts);
+  } catch (err) {
+    if (err.status === 1) {
+      return formatEmpty(patterns[0], opts);
     }
-    const regex = createRegex(query);
-    const results = [];
-    let filesScanned = 0;
-    for (const entry of entries) {
-      if (results.length >= maxResults) break;
-      filesScanned++;
-      try {
-        const fullPath = path.join(projectRoot, entry);
-        const stat = fs.statSync(fullPath);
-        if (stat.size > 5e5) continue;
-        if (isBinaryFile(fullPath)) continue;
-        const content = fs.readFileSync(fullPath, "utf-8");
-        const lines = content.split("\n");
-        for (let i = 0; i < lines.length; i++) {
-          if (results.length >= maxResults) break;
-          const line = lines[i];
-          if (regex.test(line)) {
-            const contextLines = [];
-            if (i > 0)
-              contextLines.push(`${i}: ${lines[i - 1].substring(0, 200)}`);
-            contextLines.push(`${i + 1}: ${line.substring(0, 200)}`);
-            if (i < lines.length - 1)
-              contextLines.push(`${i + 2}: ${lines[i + 1].substring(0, 200)}`);
-            results.push({
-              file: entry,
-              line: i + 1,
-              content: contextLines.join("\n")
-            });
-          }
+    return await jsGrep(patterns, opts);
+  }
+}
+function formatRipgrepOutput(output, patterns, opts) {
+  const lines = output.trim().split("\n");
+  if (opts.countOnly) {
+    const counts = lines.map((l) => {
+      const parts = l.split(":");
+      if (parts.length >= 2) {
+        const count = parts.pop();
+        return `${parts.join(":")}:${count}`;
+      }
+      return l;
+    });
+    if (opts.outputMode === "json") {
+      const obj = {};
+      for (const c of counts) {
+        const idx = c.lastIndexOf(":");
+        if (idx > 0) {
+          obj[c.slice(0, idx)] = parseInt(c.slice(idx + 1), 10);
         }
-      } catch {
-        continue;
       }
+      return JSON.stringify(obj);
     }
-    const formatted = formatResults(results, query, filesScanned);
-    grepCache.set(cacheKey, { results: formatted, timestamp: Date.now() });
-    sessionMemory.recordToolCall("smart_grep", {
-      query,
-      matchCount: results.length,
-      filesScanned
+    if (opts.compact) return counts.join("\n");
+    return `\u{1F4CA} Count results for "${patterns[0]}":
+${counts.join("\n")}`;
+  }
+  if (opts.filenamesOnly) {
+    if (opts.outputMode === "json") return JSON.stringify(lines);
+    if (opts.compact) return lines.join("\n");
+    return `\u{1F4C1} Files matching "${patterns[0]}":
+${lines.join("\n")}`;
+  }
+  const results = parseRipgrepOutput(output, opts.projectRoot).slice(0, opts.maxResults);
+  if (results.length === 0) {
+    return formatEmpty(patterns[0], opts);
+  }
+  if (opts.compact || opts.outputMode === "raw") {
+    return results.map((r) => `${r.file}:${r.line}:${r.content}`).join("\n");
+  }
+  if (opts.outputMode === "json") {
+    return JSON.stringify(results);
+  }
+  const header = `\u{1F50D} Smart Grep: "${patterns[0]}"
+\u{1F4C1} ${results.length} matches
+`;
+  const body = results.map((r, i) => `[${i + 1}] \u{1F4C4} ${r.file}:${r.line}
+    ${r.content}`).join("\n");
+  return limitLines(`${header}${body}`, 150);
+}
+function parseRipgrepOutput(output, projectRoot) {
+  const results = [];
+  const lines = output.trim().split("\n");
+  const rootPrefix = projectRoot ? projectRoot.replace(/\/+$/, "") + "/" : "";
+  for (const line of lines) {
+    const lastColonIdx = line.lastIndexOf(":");
+    if (lastColonIdx <= 0) continue;
+    const beforeLastColon = line.slice(0, lastColonIdx);
+    const afterLastColon = line.slice(lastColonIdx + 1);
+    if (!afterLastColon.trim()) continue;
+    const secondLastColonIdx = beforeLastColon.lastIndexOf(":");
+    if (secondLastColonIdx <= 0) continue;
+    let potentialFile = beforeLastColon.slice(0, secondLastColonIdx);
+    const potentialLineStr = beforeLastColon.slice(secondLastColonIdx + 1);
+    const potentialLine = parseInt(potentialLineStr, 10);
+    if (isNaN(potentialLine) || potentialLine <= 0) continue;
+    if (rootPrefix && potentialFile.startsWith(rootPrefix)) {
+      potentialFile = potentialFile.slice(rootPrefix.length);
+    }
+    results.push({
+      file: potentialFile,
+      line: potentialLine,
+      content: afterLastColon.trim()
     });
-    sessionMemory.addSearchResult(
-      query,
-      results.map((r) => r.file)
+  }
+  return results;
+}
+async function jsGrep(patterns, opts) {
+  const { projectRoot, targetFolder, maxResults, extensions, contextLines, filenamesOnly, countOnly, outputMode, compact } = opts;
+  const searchPattern = targetFolder ? path.join(targetFolder, "**/*").replace(/\\/g, "/") : "**/*";
+  const targetDepth = targetFolder ? targetFolder.split("/").filter(Boolean).length : 0;
+  const maxDepth = targetFolder ? Math.min(targetDepth + 5, 20) : 10;
+  let entries = await fg(searchPattern, {
+    cwd: projectRoot,
+    ignore: IGNORE_PATTERNS,
+    onlyFiles: true,
+    absolute: false,
+    deep: maxDepth,
+    dot: false
+  });
+  if (extensions && extensions.length > 0) {
+    const normalizedExts = extensions.map(
+      (e) => e.startsWith(".") ? e.toLowerCase() : `.${e.toLowerCase()}`
     );
-    return formatted;
-  } catch (err) {
-    return `Error searching "${query}": ${err instanceof Error ? err.message : String(err)}`;
+    entries = entries.filter((entry) => {
+      const ext = path.extname(entry).toLowerCase();
+      return normalizedExts.includes(ext);
+    });
+  }
+  if (entries.length === 0) {
+    return formatEmpty(patterns[0], opts);
   }
+  const regex = createCombinedRegex(patterns);
+  const results = [];
+  const fileCounts = /* @__PURE__ */ new Map();
+  const matchedFiles = /* @__PURE__ */ new Set();
+  let filesScanned = 0;
+  for (const entry of entries) {
+    if (!filenamesOnly && results.length >= maxResults) break;
+    filesScanned++;
+    try {
+      const fullPath = path.join(projectRoot, entry);
+      const stat = fs.statSync(fullPath);
+      if (stat.size > 5e5) continue;
+      if (isBinaryFile(fullPath)) continue;
+      const content = fs.readFileSync(fullPath, "utf-8");
+      const lines = content.split("\n");
+      let fileMatchCount = 0;
+      for (let i = 0; i < lines.length; i++) {
+        if (!filenamesOnly && results.length >= maxResults) break;
+        if (regex.test(lines[i])) {
+          fileMatchCount++;
+          matchedFiles.add(entry);
+          if (filenamesOnly) {
+            break;
+          }
+          if (countOnly) {
+            fileCounts.set(entry, (fileCounts.get(entry) || 0) + 1);
+            continue;
+          }
+          const contextLinesArr = [];
+          const startCtx = Math.max(0, i - contextLines);
+          const endCtx = Math.min(lines.length - 1, i + contextLines);
+          for (let ci = startCtx; ci <= endCtx; ci++) {
+            const prefix = ci === i ? ">" : " ";
+            contextLinesArr.push(`${prefix}${ci + 1}: ${lines[ci].substring(0, 200)}`);
+          }
+          results.push({
+            file: entry,
+            line: i + 1,
+            content: contextLinesArr.join("\n")
+          });
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  if (matchedFiles.size === 0) {
+    return formatEmpty(patterns[0], opts);
+  }
+  if (filenamesOnly) {
+    const files = Array.from(matchedFiles);
+    if (outputMode === "json") return JSON.stringify(files);
+    if (compact) return files.join("\n");
+    return `\u{1F4C1} Files matching "${patterns[0]}":
+${files.join("\n")}`;
+  }
+  if (countOnly) {
+    const counts = Array.from(fileCounts.entries()).map(([f, c]) => `${f}:${c}`);
+    if (outputMode === "json") return JSON.stringify(Object.fromEntries(fileCounts));
+    if (compact) return counts.join("\n");
+    return `\u{1F4CA} Count results for "${patterns[0]}":
+${counts.join("\n")}`;
+  }
+  if (compact || outputMode === "raw") {
+    return results.map((r) => `${r.file}:${r.line}:${r.content.split("\n")[0].replace(/^[>\s]+\d+:\s*/, "")}`).join("\n");
+  }
+  if (outputMode === "json") {
+    return JSON.stringify(results);
+  }
+  return formatResults(results, patterns[0], filesScanned);
+}
+function createCombinedRegex(patterns) {
+  if (patterns.length === 1) {
+    return createRegex(patterns[0]);
+  }
+  const combined = patterns.map((p) => {
+    try {
+      if (/[.\\+*?[\](){}^$|]/.test(p)) {
+        return `(?:${p})`;
+      }
+      return `(?:${p.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")})`;
+    } catch {
+      return p.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+  }).join("|");
+  return new RegExp(combined, "i");
 }
 function createRegex(query) {
   const normalized = query.replace(/\\\|/g, "|");
@@ -185,23 +407,27 @@ function createRegex(query) {
   }
   return new RegExp(normalized.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i");
 }
+function formatEmpty(pattern, opts) {
+  if (opts.outputMode === "json") return JSON.stringify({ query: pattern, matches: 0, results: [] });
+  if (opts.compact) return `0:${pattern}`;
+  return `\u{1F50D} No matches for "${pattern}".`;
+}
 function formatResults(results, query, filesScanned) {
   if (results.length === 0) {
     return `\u{1F50D} No matches for "${query}" (${filesScanned} files scanned).`;
   }
-  const lines = [
+  const lines_out = [
     `\u{1F50D} Smart Grep: "${query}"`,
     `\u{1F4C1} ${results.length} matches from ${filesScanned} files scanned`,
     "",
     ...results.map((r, i) => {
-      const filePath = r.file;
-      return `[${i + 1}] \u{1F4C4} ${filePath}:${r.line}
+      return `[${i + 1}] \u{1F4C4} ${r.file}:${r.line}
 ${r.content.split("\n").map((l) => `    ${l}`).join("\n")}`;
     }),
     "",
     `\u{1F4A1} Use smart_file_picker to open a specific file.`
   ];
-  return limitLines(lines.join("\n"), 150);
+  return limitLines(lines_out.join("\n"), 150);
 }
 function isBinaryFile(filePath) {
   try {
@@ -224,10 +450,54 @@ import path2 from "path";
 var MAX_FILE_SIZE = 1e6;
 var CHUNK_THRESHOLD = 300;
 async function handleSmartFilePicker(params) {
-  const { filePath, startLine, endLine, chunkStrategy = "smart" } = params;
+  const {
+    filePath,
+    files,
+    startLine,
+    endLine,
+    contextLines = 5,
+    chunkStrategy = "smart",
+    outputMode = "rich",
+    compact = false
+  } = params;
+  const filePaths = [];
+  if (files && files.length > 0) {
+    filePaths.push(...files);
+  } else if (filePath) {
+    filePaths.push(filePath);
+  } else {
+    return compact ? "ERR:filePath required" : "Error: 'filePath' or 'files' parameter is required.";
+  }
+  const results = [];
+  for (const fp of filePaths) {
+    const result = await readSingleFile(fp, {
+      startLine,
+      endLine,
+      contextLines,
+      chunkStrategy,
+      outputMode,
+      compact
+    });
+    results.push(result);
+  }
+  if (results.length === 1) return results[0];
+  if (compact || outputMode === "raw") {
+    return results.join("\n---\n");
+  }
+  return results.join("\n\n\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\u2501\u2501\u2501\u2501\n\n");
+}
+async function readSingleFile(filePath, opts) {
+  const {
+    startLine,
+    endLine,
+    contextLines,
+    chunkStrategy,
+    outputMode,
+    compact
+  } = opts;
   const validation = validateFilePath(filePath);
   if (!validation.valid) {
-    return "Error: " + validation.error.message;
+    return compact ? `ERR:${filePath} - ${validation.error.message}` : `Error: ${validation.error.message}`;
   }
   const resolvedPath = validation.resolvedPath;
   if (!fs2.existsSync(resolvedPath)) {
@@ -235,15 +505,21 @@ async function handleSmartFilePicker(params) {
     let suggestion;
     if (!path2.isAbsolute(filePath)) {
       const cwdPath = path2.resolve(process.cwd(), filePath);
-      suggestion = "Path resolved to: " + resolvedPath + "\nCWD: " + process.cwd() + "\nProject root: " + projectRoot + "\nHint: Try path relative to project root, or relative to CWD (" + cwdPath + ")\nTry smart_grep first to locate the correct file.";
+      suggestion = `Path resolved to: ${resolvedPath}
+CWD: ${process.cwd()}
+Project root: ${projectRoot}
+Hint: Try path relative to project root, or relative to CWD (${cwdPath})
+Try smart_grep first to locate the correct file.`;
     } else {
       suggestion = "File does not exist. Try smart_grep to locate it.";
     }
-    return 'Error: File not found: "' + filePath + '".\n' + suggestion;
+    return compact ? `ERR:not found "${filePath}"` : `Error: File not found: "${filePath}".
+${suggestion}`;
   }
   const stat = fs2.statSync(resolvedPath);
   if (stat.size > MAX_FILE_SIZE) {
-    return "Error: File too large (" + (stat.size / 1024 / 1024).toFixed(1) + "MB). Max 1MB.\nUse smart_grep to find specific content instead.";
+    return compact ? `ERR:too large ${filePath} (${(stat.size / 1024 / 1024).toFixed(1)}MB)` : `Error: File too large (${(stat.size / 1024 / 1024).toFixed(1)}MB). Max 1MB.
+Use smart_grep to find specific content instead.`;
   }
   try {
     const content = fs2.readFileSync(resolvedPath, "utf-8");
@@ -254,6 +530,26 @@ async function handleSmartFilePicker(params) {
       chunkStrategy,
       totalLines
     });
+    if (compact || outputMode === "raw") {
+      if (startLine !== void 0 || endLine !== void 0) {
+        const start = startLine ?? 1;
+        const end = endLine ?? totalLines;
+        return lines.slice(start - 1, end).join("\n");
+      }
+      if (totalLines <= CHUNK_THRESHOLD || chunkStrategy === "full") {
+        return content;
+      }
+      const tailStart = Math.max(totalLines - 50, 0);
+      return lines.slice(0, 50).join("\n") + `
+... ${totalLines - 100} lines hidden ...
+` + lines.slice(tailStart).join("\n");
+    }
+    if (startLine !== void 0 && endLine === void 0) {
+      const ctxStart = Math.max(0, startLine - 1 - contextLines);
+      const ctxEnd = Math.min(totalLines, startLine - 1 + contextLines);
+      const selectedLines = lines.slice(ctxStart, ctxEnd);
+      return formatJumpOutput(filePath, selectedLines, ctxStart + 1, startLine, totalLines);
+    }
     if (startLine !== void 0 || endLine !== void 0) {
       const start = startLine ?? 1;
       const end = endLine ?? totalLines;
@@ -278,30 +574,43 @@ async function handleSmartFilePicker(params) {
         );
     }
   } catch (err) {
-    return 'Error reading file "' + filePath + '": ' + (err instanceof Error ? err.message : String(err));
+    return compact ? `ERR:reading "${filePath}"` : `Error reading file "${filePath}": ${err instanceof Error ? err.message : String(err)}`;
   }
 }
+function formatJumpOutput(filePath, lines, startLine, targetLine, totalLines) {
+  const header = [
+    `File: ${filePath}`,
+    `${totalLines} total lines`,
+    `Jumped to line ${targetLine} (\xB1context)`,
+    ""
+  ].join("\n");
+  const body = lines.map((line, i) => {
+    const lineNum = startLine + i;
+    const marker = lineNum === targetLine ? ">" : " ";
+    return `${marker} ${String(lineNum).padStart(4, " ")} | ${line}`;
+  }).join("\n");
+  return header + "\n" + body;
+}
 function formatOutput(filePath, lines, startLine, totalLines, truncated) {
   const header = [
-    "File: " + filePath,
-    totalLines + " total lines",
-    truncated ? "Showing " + lines.length + " lines (file >" + CHUNK_THRESHOLD + " lines). Use startLine/endLine for a specific range." : "",
+    `File: ${filePath}`,
+    `${totalLines} total lines`,
+    truncated ? `Showing ${lines.length} lines (file >${CHUNK_THRESHOLD} lines). Use startLine/endLine for a specific range.` : "",
     ""
   ].filter(Boolean).join("\n");
   const body = lines.map((line, i) => {
     const lineNum = startLine + i;
-    return String(lineNum).padStart(4, " ") + " | " + line;
+    return `${String(lineNum).padStart(4, " ")} | ${line}`;
   }).join("\n");
-  const full = header + "\n" + body;
-  return truncateToTokenLimit(full, 2e3);
+  return truncateToTokenLimit(`${header}
+${body}`, 2e3);
 }
 async function handleOutlineStrategy(filePath, lines, totalLines) {
   const importLines = [];
   const exportLines = [];
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i].trim();
-    if (line.startsWith("//") || line.startsWith("#") || line.startsWith("/*") || line.startsWith("*"))
-      continue;
+    if (line.startsWith("//") || line.startsWith("#") || line.startsWith("/*") || line.startsWith("*")) continue;
     if (line.startsWith("import ") || line.startsWith("from ") || line.startsWith("require(")) {
       importLines.push(line);
       continue;
@@ -311,15 +620,15 @@ async function handleOutlineStrategy(filePath, lines, totalLines) {
     }
   }
   const result = [
-    "File: " + filePath,
-    totalLines + " total lines (OUTLINE MODE - signatures and imports only)",
+    `File: ${filePath}`,
+    `${totalLines} total lines (OUTLINE MODE - signatures and imports only)`,
     "",
     "Imports:",
-    ...importLines.slice(0, 30).map((l) => "  " + l.substring(0, 150)),
-    importLines.length > 30 ? "  ...and " + (importLines.length - 30) + " more imports" : "",
+    ...importLines.slice(0, 30).map((l) => `  ${l.substring(0, 150)}`),
+    importLines.length > 30 ? `  ...and ${importLines.length - 30} more imports` : "",
     "",
     "Exports & Declarations:",
-    ...exportLines.map((e) => "  [L" + e.line + "] " + e.text),
+    ...exportLines.map((e) => `  [L${e.line}] ${e.text}`),
     "",
     "Pass startLine/endLine to read a specific range.",
     'Or use chunkStrategy: "full" to read the entire file.'
@@ -337,7 +646,7 @@ async function handleSmartStrategy(filePath, lines, totalLines) {
     smartLines.push({ line: -1, text: "" });
     smartLines.push({
       line: -1,
-      text: "  ... " + (tailStart - headerEnd) + " lines hidden ..."
+      text: `  ... ${tailStart - headerEnd} lines hidden ...`
     });
     smartLines.push({ line: -1, text: "" });
   }
@@ -354,18 +663,18 @@ async function handleSmartStrategy(filePath, lines, totalLines) {
     smartLines.push({ line: i + 1, text: lines[i] });
   }
   const header = [
-    "File: " + filePath,
-    totalLines + " total lines (SMART MODE - header + signatures + tail)",
+    `File: ${filePath}`,
+    `${totalLines} total lines (SMART MODE - header + signatures + tail)`,
     "Pass startLine/endLine to read a specific range.",
     'Or use chunkStrategy: "full" to read the entire file.',
     ""
   ].join("\n");
   const body = smartLines.map((s) => {
     if (s.line === -1) return s.text;
-    return String(s.line).padStart(4, " ") + " | " + s.text;
+    return `${String(s.line).padStart(4, " ")} | ${s.text}`;
   }).join("\n");
-  const full = header + "\n" + body;
-  return truncateToTokenLimit(full, 3e3);
+  return truncateToTokenLimit(`${header}
+${body}`, 3e3);
 }
 function findHeaderEnd(lines) {
   let lastImportLine = 0;
@@ -386,9 +695,7 @@ function extractKeyDeclarations(lines) {
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i].trim();
     if (!line || line.startsWith("//") || line.startsWith("#")) continue;
-    if (/^(export\s+)?(async\s+)?(function|class|interface|type|enum|const|let|var|def)\s/.test(
-      line
-    )) {
+    if (/^(export\s+)?(async\s+)?(function|class|interface|type|enum|const|let|var|def)\s/.test(line)) {
       decls.push({ line: i, text: line.substring(0, 150) });
     }
   }
@@ -889,10 +1196,10 @@ File "${filePath}" restored from backup: "${relBackupPath}".`;
 }
 async function handleCommitRollback(filePath, version) {
   try {
-    const { execSync: execSync10 } = await import("child_process");
+    const { execSync: execSync11 } = await import("child_process");
     const root = getProjectRoot();
     if (version === "list") {
-      const log = execSync10("git log --oneline -20", { cwd: root, encoding: "utf-8" });
+      const log = execSync11("git log --oneline -20", { cwd: root, encoding: "utf-8" });
       const lines = log.trim().split("\n").map((l) => `  ${l}`).join("\n");
       return [
         `\u{1F4CB} **Recent Commits:**`,
@@ -902,7 +1209,7 @@ async function handleCommitRollback(filePath, version) {
         `\u{1F4A1} Use { action: "rollback", scope: "commit", version: <N> } to restore a specific commit.`
       ].join("\n");
     }
-    const status = execSync10("git status --porcelain", { cwd: root, encoding: "utf-8" }).trim();
+    const status = execSync11("git status --porcelain", { cwd: root, encoding: "utf-8" }).trim();
     if (status) {
       return [
         `\u26A0\uFE0F **Uncommitted changes detected.**`,
@@ -923,10 +1230,10 @@ async function handleCommitRollback(filePath, version) {
       target = "HEAD~1";
     }
     if (filePath) {
-      execSync10(`git checkout ${target} -- "${filePath}"`, { cwd: root, encoding: "utf-8" });
+      execSync11(`git checkout ${target} -- "${filePath}"`, { cwd: root, encoding: "utf-8" });
       return `\u2705 **Commit Rollback** \u2014 File "${filePath}" restored from ${target}.`;
     } else {
-      execSync10(`git checkout ${target}`, { cwd: root, encoding: "utf-8" });
+      execSync11(`git checkout ${target}`, { cwd: root, encoding: "utf-8" });
       return `\u2705 **Commit Rollback** \u2014 Project restored to ${target}.`;
     }
   } catch (err) {
@@ -2012,7 +2319,7 @@ function formatTimeoutResult(command, timeout) {
 // src/agents/codeReviewer.ts
 import fs7 from "fs";
 import path7 from "path";
-import { execSync } from "child_process";
+import { execSync as execSync2 } from "child_process";
 var CODE_EXTENSIONS = [
   ".ts",
   ".tsx",
@@ -2042,7 +2349,7 @@ var CONFIG_EXTENSIONS = [
 function getGitChangedFiles() {
   try {
     const root = getProjectRoot();
-    const stdout = execSync("git status --porcelain", {
+    const stdout = execSync2("git status --porcelain", {
       cwd: root,
       encoding: "utf-8"
     });
@@ -3146,10 +3453,10 @@ function formatConventionsOutput(conventions) {
 }
 
 // src/utils/gitUtils.ts
-import { execSync as execSync2 } from "child_process";
+import { execSync as execSync3 } from "child_process";
 function runGitCommand(command) {
   const root = getProjectRoot();
-  return execSync2(command, {
+  return execSync3(command, {
     cwd: root,
     encoding: "utf-8",
     maxBuffer: 2 * 1024 * 1024
@@ -3805,7 +4112,7 @@ function formatToolNotAvailable(requested, available) {
 }
 
 // src/utils/kumaShared.ts
-import { execSync as execSync3 } from "child_process";
+import { execSync as execSync4 } from "child_process";
 function getSessionStats(inputGoal) {
   const summary = sessionMemory.getSummary();
   const goal = inputGoal || summary.currentGoal || "";
@@ -3827,7 +4134,7 @@ function getSessionStats(inputGoal) {
 function getGitDiffStat(timeout = 3e3) {
   try {
     const root = getProjectRoot();
-    return execSync3("git diff --stat", {
+    return execSync4("git diff --stat", {
       cwd: root,
       encoding: "utf-8",
       timeout
@@ -4219,7 +4526,7 @@ function formatHealthDashboard(r) {
 // src/guards/antiPatternDetector.ts
 import fs11 from "fs";
 import path11 from "path";
-import { execSync as execSync4 } from "child_process";
+import { execSync as execSync5 } from "child_process";
 var SCRIPT_PATCH_PATTERNS = [
   "writeFileSync",
   "writeFile",
@@ -4313,7 +4620,7 @@ function scanRecentFiles(projectRoot) {
 function detectGitPatchScripts(projectRoot) {
   const warnings = [];
   try {
-    const statusStdout = execSync4("git status --porcelain", {
+    const statusStdout = execSync5("git status --porcelain", {
       cwd: projectRoot,
       encoding: "utf-8",
       timeout: 3e3
@@ -4346,7 +4653,7 @@ function detectGitPatchScripts(projectRoot) {
         }
       }
     }
-    const deletedStdout = execSync4("git diff --name-only --diff-filter=D HEAD", {
+    const deletedStdout = execSync5("git diff --name-only --diff-filter=D HEAD", {
       cwd: projectRoot,
       encoding: "utf-8",
       timeout: 3e3
@@ -4416,7 +4723,7 @@ function detectAllAntiPatterns() {
 // src/engine/contextSnapshot.ts
 import fs12 from "fs";
 import path12 from "path";
-import { execSync as execSync5 } from "child_process";
+import { execSync as execSync6 } from "child_process";
 var SNAPSHOT_DIR = "context-snapshots";
 function snapshotDir() {
   return path12.join(getProjectRoot(), ".kuma", SNAPSHOT_DIR);
@@ -4505,7 +4812,7 @@ function formatSnapshot(snapshot) {
 function getGitDiffStat2() {
   try {
     const root = getProjectRoot();
-    const stdout = execSync5("git diff --stat", {
+    const stdout = execSync6("git diff --stat", {
       cwd: root,
       encoding: "utf-8",
       timeout: 3e3
@@ -5804,7 +6111,7 @@ function createSchema(db) {
 }
 
 // src/engine/kumaSelfHeal.ts
-import { execSync as execSync6 } from "child_process";
+import { execSync as execSync7 } from "child_process";
 import fs19 from "fs";
 import path19 from "path";
 import crypto from "crypto";
@@ -5841,7 +6148,7 @@ function findByFingerprint(fingerprint, oldName) {
   try {
     const root = getProjectRoot();
     const ext = path19.extname(oldName);
-    const result = execSync6(
+    const result = execSync7(
       `find . -name "*${ext}" -type f -not -path "./node_modules/*" -not -path "./.git/*" -not -path "./dist/*" -not -path "./build/*" 2>/dev/null | head -200`,
       { cwd: root, encoding: "utf-8", maxBuffer: 1024 * 1024, timeout: 1e4 }
     ).trim();
@@ -5909,7 +6216,7 @@ async function detectStaleNodes() {
 function findRenamedPath(oldPath) {
   try {
     const root = getProjectRoot();
-    const output = execSync6(
+    const output = execSync7(
       `git log --follow --diff-filter=R --name-only --format="" -1 -- "${oldPath}"`,
       { cwd: root, encoding: "utf-8", maxBuffer: 1024 * 1024, timeout: 5e3 }
     ).trim();
@@ -7313,11 +7620,11 @@ Cannot find definition.`;
 }
 
 // src/engine/kumaTimeMachine.ts
-import { execSync as execSync7 } from "child_process";
+import { execSync as execSync8 } from "child_process";
 function getBlameForFile(filePath) {
   const root = getProjectRoot();
   try {
-    const output = execSync7(
+    const output = execSync8(
       `git blame --line-porcelain -- "${filePath}"`,
       { cwd: root, encoding: "utf-8", maxBuffer: 2 * 1024 * 1024, timeout: 1e4 }
     );
@@ -7363,7 +7670,7 @@ function getBlameForFile(filePath) {
 function getFileHistory(filePath, maxCount = 20) {
   const root = getProjectRoot();
   try {
-    const output = execSync7(
+    const output = execSync8(
       `git log --follow --format="%H||%an||%ai||%s" --shortstat -- "${filePath}"`,
       { cwd: root, encoding: "utf-8", maxBuffer: 2 * 1024 * 1024, timeout: 1e4 }
     );
@@ -7398,7 +7705,7 @@ async function getSymbolTimeline(symbolName, filePath, symbolType = "function")
     const blame = getBlameForFile(filePath);
     const pattern = getSymbolPattern(symbolName, symbolType);
     const root = getProjectRoot();
-    const content = execSync7(`git show HEAD:"${filePath}"`, {
+    const content = execSync8(`git show HEAD:"${filePath}"`, {
       cwd: root,
       encoding: "utf-8",
       maxBuffer: 2 * 1024 * 1024,
@@ -7425,7 +7732,7 @@ async function getSymbolTimeline(symbolName, filePath, symbolType = "function")
     const entries = [];
     for (const [hash, data] of commitMap) {
       try {
-        const msg = execSync7(
+        const msg = execSync8(
           `git log -1 --format="%s" ${hash}`,
           { cwd: root, encoding: "utf-8", maxBuffer: 1024 * 1024, timeout: 3e3 }
         ).trim();
@@ -8128,7 +8435,7 @@ function formatDecisionTemplate() {
 }
 
 // src/engine/kumaContextEngine.ts
-import { execSync as execSync8 } from "child_process";
+import { execSync as execSync9 } from "child_process";
 var STOP_WORDS = /* @__PURE__ */ new Set([
   "the",
   "this",
@@ -8245,7 +8552,7 @@ async function searchNodesFts(db, terms) {
 function getFileRecencySeconds(filePath) {
   try {
     const escapedPath = filePath.replace(/"/g, '\\"');
-    const result = execSync8(
+    const result = execSync9(
       'git log -1 --format=%ct -- "' + escapedPath + '" 2>/dev/null || echo 0',
       { encoding: "utf-8", timeout: 2e3 }
     );
@@ -11061,7 +11368,7 @@ function formatCollectivePatterns(patterns) {
 }
 
 // src/engine/kumaMarketplace.ts
-import { execSync as execSync9 } from "child_process";
+import { execSync as execSync10 } from "child_process";
 import fs27 from "fs";
 import path28 from "path";
 var BUILT_IN_TEMPLATES = [
@@ -11447,7 +11754,7 @@ async function tryInstallFromNpm(templateId) {
   try {
     const npmPackage = `@kuma-templates/${name}`;
     const root = getProjectRoot();
-    execSync9(`npm install --no-save ${npmPackage}`, {
+    execSync10(`npm install --no-save ${npmPackage}`, {
       cwd: root,
       encoding: "utf-8",
       timeout: 3e4,
@@ -11842,10 +12149,17 @@ async function handleInit(action, params) {
 }
 async function handleCore(action, params) {
   switch (action) {
-    case "grep":
-      return await handleSmartGrep(params);
-    case "read":
-      return await handleSmartFilePicker(params);
+    case "grep": {
+      const p = { ...params, outputMode: params.grepOutputMode || params.outputMode || "rich" };
+      return await handleSmartGrep(p);
+    }
+    case "read": {
+      const readParams = { ...params, outputMode: params.readOutputMode || params.outputMode || "rich" };
+      if (params.filePaths) {
+        readParams.files = params.filePaths;
+      }
+      return await handleSmartFilePicker(readParams);
+    }
     case "edit":
       return await handlePreciseDiffEditor(params);
     case "batch":
@@ -12242,14 +12556,21 @@ function registerAllTools(server) {
       action: z.enum(["grep", "read", "edit", "batch", "lsp"]).describe("Action: grep=search code, read=open file, edit=edit with safety, batch=create files, lsp=semantic analysis"),
       // grep params
       query: z.string().optional().describe("Regex pattern for grep action"),
+      queries: z.array(z.string()).optional().describe("Multiple regex patterns (OR'd together, single pass)"),
       targetFolder: z.string().optional().describe("Target folder for grep"),
       maxResults: z.number().min(1).max(100).optional().default(30).describe("Max results"),
       extensions: z.array(z.string()).optional().describe("File extensions filter"),
+      contextLines: z.number().min(0).max(20).optional().default(1).describe("Context lines around match (grep) or jump-to-line (read)"),
+      filenamesOnly: z.boolean().optional().default(false).describe("Only show matching filenames (like grep -l)"),
+      countOnly: z.boolean().optional().default(false).describe("Only show match count per file (like grep -c)"),
+      grepOutputMode: z.enum(["rich", "raw", "json"]).optional().default("rich").describe("Output format for grep: rich=emojis, raw=compact, json=parseable"),
       // read params
       filePath: z.string().optional().describe("File path for read/edit/batch actions"),
+      filePaths: z.array(z.string()).optional().describe("Multiple file paths to read in one call"),
       startLine: z.number().min(1).optional().describe("Start line (1-indexed) for read"),
       endLine: z.number().min(1).optional().describe("End line (1-indexed) for read"),
       chunkStrategy: z.enum(["full", "smart", "outline"]).optional().default("smart").describe("Read strategy"),
+      readOutputMode: z.enum(["rich", "raw"]).optional().default("rich").describe("Output format for read: rich=line numbers, raw=content only"),
       // edit params
       edits: z.array(z.object({
         searchBlock: z.string().min(1).describe("Code to replace"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plumpslabs/kuma",
-  "version": "2.2.4",
+  "version": "2.2.6",
   "description": "Zero-setup safety toolkit for AI coding agents. MCP server with code review, git analysis, file editing, session memory, and static analysis — works with Claude Code, Cursor, Gemini CLI.",
   "type": "module",
   "main": "dist/index.js",