@plumpslabs/kuma 2.2.7 → 2.2.8

package/dist/index.js

@@ -104,12 +104,89 @@ function isRipgrepAvailable() {
 function quotePath(p) {
   return `"${p.replace(/"/g, '\\"')}"`;
 }
+async function searchInSingleFile(filePath, patterns, opts) {
+  const { maxResults, contextLines, filenamesOnly, countOnly, outputMode, compact } = opts;
+  const validation = validateFilePath(filePath);
+  if (!validation.valid) {
+    return compact ? `ERR:${filePath} - invalid path` : `Error: ${validation.error.message}`;
+  }
+  const resolvedPath = validation.resolvedPath;
+  if (!fs.existsSync(resolvedPath)) {
+    return compact ? `ERR:not found ${filePath}` : `Error: File not found: ${filePath}`;
+  }
+  const stat = fs.statSync(resolvedPath);
+  if (stat.size > 5e5) {
+    return compact ? `ERR:too large ${filePath}` : `Error: File too large (${(stat.size / 1024).toFixed(0)}KB). Use a more specific query.`;
+  }
+  if (isBinaryFile(resolvedPath)) {
+    return compact ? `ERR:binary ${filePath}` : `Error: Cannot search binary file: ${filePath}`;
+  }
+  const projectRoot = getProjectRoot();
+  const relativePath = resolvedPath.startsWith(projectRoot + "/") ? resolvedPath.slice(projectRoot.length + 1) : resolvedPath;
+  try {
+    const content = fs.readFileSync(resolvedPath, "utf-8");
+    const lines = content.split("\n");
+    const regex = createCombinedRegex(patterns);
+    const results = [];
+    const maxFileResults = Math.min(maxResults, 100);
+    let matchCount = 0;
+    for (let i = 0; i < lines.length; i++) {
+      if (results.length >= maxFileResults) break;
+      if (regex.test(lines[i])) {
+        matchCount++;
+        if (filenamesOnly) {
+          return relativePath;
+        }
+        if (countOnly) continue;
+        const ctxLines = [];
+        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 ? ">" : " ";
+          ctxLines.push(`${prefix}${ci + 1}: ${lines[ci].substring(0, 200)}`);
+        }
+        results.push({
+          file: relativePath,
+          line: i + 1,
+          content: ctxLines.join("\n")
+        });
+      }
+    }
+    if (countOnly) {
+      const counts = `${filePath}:${matchCount}`;
+      if (outputMode === "json") return JSON.stringify({ [filePath]: matchCount });
+      if (compact) return counts;
+      return `\u{1F4CA} Count results for "${patterns[0]}":
+${counts}`;
+    }
+    if (matchCount === 0) {
+      if (outputMode === "json") return JSON.stringify({ query: patterns[0], matches: 0 });
+      if (compact) return `0:${patterns[0]}`;
+      return `\u{1F50D} No matches for "${patterns[0]}" in ${filePath}.`;
+    }
+    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);
+    }
+    const header = `\u{1F50D} Smart Grep: "${patterns[0]}" \u2014 ${filePath}
+\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);
+  } catch (err) {
+    return compact ? `ERR:reading ${filePath}` : `Error reading file "${filePath}": ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
 async function handleSmartGrep(params) {
   const {
     query,
     queries,
     targetFolder,
     maxResults = 30,
+    filePath,
     extensions,
     contextLines = 1,
     filenamesOnly = false,
@@ -121,7 +198,7 @@ async function handleSmartGrep(params) {
   if (patterns.length === 0 || patterns[0].length < 1) {
     return compact ? "ERR:query required" : "Error: 'query' or 'queries' parameter is required.";
   }
-  const cacheKey = `${patterns.join("||")}:${targetFolder ?? "root"}:${maxResults}:${contextLines}:${filenamesOnly}:${countOnly}:${outputMode}:${extensions ? extensions.join(",") : ""}`;
+  const cacheKey = `${patterns.join("||")}:${filePath ?? ""}:${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: patterns[0], cached: true });
@@ -129,7 +206,16 @@ async function handleSmartGrep(params) {
   }
   const projectRoot = getProjectRoot();
   let result;
-  if (isRipgrepAvailable()) {
+  if (filePath) {
+    result = await searchInSingleFile(filePath, patterns, {
+      maxResults,
+      contextLines,
+      filenamesOnly,
+      countOnly,
+      outputMode,
+      compact
+    });
+  } else if (isRipgrepAvailable()) {
     result = await tryRipgrep(patterns, {
       projectRoot,
       targetFolder,

package/package.json

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