mcp-multitool 0.1.12 → 0.1.14

package/README.md

@@ -75,6 +75,8 @@ Search code using AST patterns. Matches code structure, not text. Use `$VAR` for
 
 **Response:** JSON object with `results` array (each with `file`, `range`, `text`) and `errors` array.
 
+**Pattern Validation:** Patterns are validated before search. Invalid patterns (e.g., `class X` without a body, `function foo` without parentheses) return an error explaining the issue. Patterns must be syntactically complete code fragments.
+
 **Examples:**
 
 ```
@@ -176,16 +178,17 @@ Compress a log file using semantic pattern extraction. Groups similar lines into
 
 **Content-hashed template IDs:** Template IDs are 12-character base64URL hashes derived from the pattern itself. The same pattern **always** gets the same ID, regardless of file order or when you call the tool. This means drill-down always works if the pattern still exists.
 
-| Parameter      | Type      | Required | Description                                                        |
-| -------------- | --------- | -------- | ------------------------------------------------------------------ |
-| `path`         | `string`  | ✅       | Path to the log file.                                              |
-| `simThreshold` | `number`  | ✅       | Similarity threshold (0-1). Lower values group more aggressively.  |
-| `tail`         | `integer` | —        | Last N lines.                                                      |
-| `head`         | `integer` | —        | First N lines.                                                     |
-| `grep`         | `string`  | —        | Regex filter for lines before compression.                         |
-| `templateId`   | `string`  | —        | Drill into a specific template by its hash ID for sample captures. |
+| Parameter      | Type      | Required | Description                                                                   |
+| -------------- | --------- | -------- | ----------------------------------------------------------------------------- |
+| `path`         | `string`  | ✅       | Path to the log file.                                                         |
+| `simThreshold` | `number`  | ✅       | Similarity threshold (0-1). Lower values group more aggressively.             |
+| `tail`         | `integer` | —        | Last N lines.                                                                 |
+| `head`         | `integer` | —        | First N lines.                                                                |
+| `grep`         | `string`  | —        | Regex filter for lines. Smart case: all-lowercase = case-insensitive.         |
+| `lineStart`    | `string`  | —        | Regex for entry start lines. Non-matching lines join previous entry with `⏎`. |
+| `templateId`   | `string`  | —        | Drill into a specific template by its hash ID for sample captures.            |
 
-**Response:** Compressed log summary showing template IDs, occurrence counts, and patterns with `<*>` wildcards.
+**Response:** Compressed log summary with header showing line reduction, character reduction, template IDs, occurrence counts, and patterns with `<*>` wildcards.
 
 **Examples:**
 
@@ -194,6 +197,7 @@ readLogFile  path="/var/log/app.log"  simThreshold=0.4
 readLogFile  path="./logs/server.log"  simThreshold=0.4  tail=1000
 readLogFile  path="app.log"  simThreshold=0.3  grep="ERROR|WARN"
 readLogFile  path="app.log"  simThreshold=0.4  templateId="aB3x_Yz7Q2Kf"
+readLogFile  path="tsserver.log"  simThreshold=0.5  lineStart="^(Info|Err|Perf)\\s+\\d+"
 ```
 
 <details>

package/dist/tools/astGrepSearch.js

@@ -1,5 +1,30 @@
 import { z } from "zod";
-import { findInFiles } from "@ast-grep/napi";
+import { findInFiles, parse } from "@ast-grep/napi";
+function validatePattern(lang, pattern) {
+    const tree = parse(lang, pattern);
+    const root = tree.root();
+    function findErrors(node) {
+        const errors = [];
+        if (node.kind() === "ERROR") {
+            errors.push(`"${node.text().slice(0, 50)}"`);
+        }
+        for (const child of node.children()) {
+            errors.push(...findErrors(child));
+        }
+        return errors;
+    }
+    const errors = findErrors(root);
+    if (errors.length > 0) {
+        return {
+            valid: false,
+            error: `Pattern "${pattern}" is not valid ${lang} syntax.\n` +
+                `Invalid syntax near: ${errors.join(", ")}\n\n` +
+                `Tip: Patterns must be syntactically complete code fragments. ` +
+                `For example, "class X" is invalid (needs body), use "class X { $$$BODY }" instead.`,
+        };
+    }
+    return { valid: true };
+}
 const builtinLangs = [
     "javascript",
     "typescript",
@@ -38,6 +63,13 @@ export function register(server) {
         try {
             const lang = langMap[input.lang];
             const paths = Array.isArray(input.paths) ? input.paths : [input.paths];
+            const validation = validatePattern(lang, input.pattern);
+            if (!validation.valid) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: validation.error }],
+                };
+            }
             const results = [];
             const errors = [];
             await findInFiles(lang, {

package/dist/tools/readLogFile.js

@@ -174,6 +174,24 @@ function compress(lines, simThreshold) {
 function hashTemplateId(pattern) {
     return createHash("sha256").update(pattern).digest("base64url").slice(0, 12);
 }
+const CONTINUATION_MARKER = " \u23CE ";
+function joinMultilineEntries(lines, lineStartPattern) {
+    const result = [];
+    let current = "";
+    for (const line of lines) {
+        if (lineStartPattern.test(line)) {
+            if (current)
+                result.push(current);
+            current = line;
+        }
+        else {
+            current += CONTINUATION_MARKER + line;
+        }
+    }
+    if (current)
+        result.push(current);
+    return result;
+}
 const schema = z.object({
     path: z.string().min(1).describe("Path to the log file."),
     simThreshold: z
@@ -183,7 +201,14 @@ const schema = z.object({
         .describe("Similarity threshold (0-1). Lower = more aggressive grouping."),
     tail: z.number().int().min(1).optional().describe("Last N lines."),
     head: z.number().int().min(1).optional().describe("First N lines."),
-    grep: z.string().optional().describe("Regex filter for lines."),
+    grep: z
+        .string()
+        .optional()
+        .describe("Regex filter for lines. Smart case: all-lowercase pattern = case-insensitive, any uppercase = exact case."),
+    lineStart: z
+        .string()
+        .optional()
+        .describe("Regex identifying log entry start lines. Lines not matching are joined to previous entry with \u23CE. For tsserver: ^(Info|Err|Perf)\\s+\\d+"),
     templateId: z
         .string()
         .optional()
@@ -219,10 +244,31 @@ async function processLog(input) {
         lines = lines.slice(0, input.head);
     else if (input.tail)
         lines = lines.slice(-input.tail);
-    if (input.grep)
-        lines = lines.filter((l) => new RegExp(input.grep).test(l));
+    if (input.lineStart) {
+        let lineStartRe;
+        try {
+            lineStartRe = new RegExp(input.lineStart);
+        }
+        catch {
+            return `Invalid lineStart regex: "${input.lineStart}"`;
+        }
+        lines = joinMultilineEntries(lines, lineStartRe);
+    }
+    if (input.grep) {
+        let re;
+        try {
+            // Smart case: all-lowercase pattern → case-insensitive (like ripgrep --smart-case)
+            const flags = /[A-Z]/.test(input.grep) ? "" : "i";
+            re = new RegExp(input.grep, flags);
+        }
+        catch {
+            return `Invalid grep regex: "${input.grep}"`;
+        }
+        lines = lines.filter((l) => re.test(l));
+    }
     if (!lines.length)
         return "No log lines to process.";
+    const inputLength = lines.reduce((sum, l) => sum + l.length, 0);
     const templates = compress(lines, input.simThreshold);
     const templateMap = buildTemplateMap(templates);
     if (input.templateId) {
@@ -233,7 +279,7 @@ async function processLog(input) {
         }
         return formatDrillDown(template);
     }
-    return formatOverview(templateMap, lines.length);
+    return formatOverview(templateMap, lines.length, inputLength);
 }
 function buildTemplateMap(templates) {
     const map = new Map();
@@ -248,17 +294,22 @@ function buildTemplateMap(templates) {
     }
     return map;
 }
-function formatOverview(templateMap, lineCount) {
+function formatOverview(templateMap, lineCount, inputLength) {
     const sorted = [...templateMap.values()].sort((a, b) => b.count - a.count);
-    const reduction = Math.round((1 - templateMap.size / lineCount) * 100);
-    const header = `=== Log Compression ===\n${lineCount} lines → ${templateMap.size} templates (${reduction}% reduction)\n`;
+    const lineReduction = Math.round((1 - templateMap.size / lineCount) * 100);
     const top20 = sorted.slice(0, 20);
     const topLines = top20
         .map((t) => `${t.id} [${t.count}x] ${t.pattern}`)
         .join("\n");
     const remaining = sorted.length - 20;
     const footer = remaining > 0 ? `\n... and ${remaining} more templates` : "";
-    return `${header}\n${topLines}${footer}`;
+    const body = `${topLines}${footer}`;
+    const outputLength = body.length;
+    const charReduction = Math.round((1 - outputLength / inputLength) * 100);
+    const header = `=== Log Compression ===\n` +
+        `${lineCount} lines → ${templateMap.size} templates (${lineReduction}% reduction)\n` +
+        `${inputLength.toLocaleString()} chars → ${outputLength.toLocaleString()} chars (${charReduction}% reduction)\n`;
+    return `${header}\n${body}`;
 }
 function formatDrillDown(template) {
     const header = `Template: ${template.id}\nPattern: ${template.pattern}\nMatches: ${template.count}\n`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-multitool",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "MCP server with file operations (delete, move) and timing utilities.",
   "license": "MIT",
   "type": "module",