mcp-multitool 0.1.6 → 0.1.7

package/README.md

@@ -4,19 +4,20 @@
 [![npm downloads](https://img.shields.io/npm/dm/mcp-multitool)](https://www.npmjs.com/package/mcp-multitool)
 [![license](https://img.shields.io/npm/l/mcp-multitool)](./LICENSE)
 
-A [Model Context Protocol (MCP)](https://modelcontextprotocol.io) server with basic **file operations** and **timing utilities**.
+A [Model Context Protocol (MCP)](https://modelcontextprotocol.io) server with **file operations**, **log compression**, and **timing utilities**.
 
 ## Tools
 
-| Tool         | Description                                   |
-| ------------ | --------------------------------------------- |
-| `deleteFile` | Delete files or directories (single or batch) |
-| `moveFile`   | Move/rename files or directories              |
-| `wait`       | Pause execution for rate limits or timing     |
+| Tool         | Description                                        |
+| ------------ | -------------------------------------------------- |
+| `deleteFile` | Delete files or directories (single or batch)      |
+| `moveFile`   | Move/rename files or directories                   |
+| `readLog`    | Read and compress logs with 60-90% token reduction |
+| `wait`       | Pause execution for rate limits or timing          |
 
 ## Why
 
-Some tasks need simple utilities that don't warrant a larger server — cleaning up temp files, pausing for rate limits. `mcp-multitool` gives any MCP-compatible client a small set of reliable tools.
+Some tasks need simple utilities that don't warrant a larger server — cleaning up temp files, compressing verbose logs before analysis, pausing for rate limits. `mcp-multitool` gives any MCP-compatible client a small set of reliable tools.
 
 ## Quick Start
 
@@ -101,6 +102,52 @@ moveFile  from="config.json"  to="dest/"  overwrite=true
 
 ---
 
+### `readLog`
+
+Compress a log file using semantic pattern extraction (60-90% token reduction). Creates stateful drains for incremental reads. Use `flushLog` to release.
+
+**Stateful drains:** On first call for a file, creates a stateful drain. Subsequent calls append only new lines to the existing drain, preserving template IDs. This enables incremental log analysis as files grow. When any drain is active, a dynamic `flushLog` tool appears to release drains.
+
+| Parameter      | Type      | Required | Description                                      |
+| -------------- | --------- | -------- | ------------------------------------------------ |
+| `path`         | `string`  | ✅       | Path to the log file.                            |
+| `format`       | `string`  | ✅       | Output format: `summary`, `detailed`, or `json`. |
+| `depth`        | `integer` | ✅       | Parse tree depth (2-8).                          |
+| `simThreshold` | `number`  | ✅       | Similarity threshold (0-1).                      |
+| `tail`         | `integer` | —        | Last N lines (first read only).                  |
+| `head`         | `integer` | —        | First N lines (first read only).                 |
+| `grep`         | `string`  | —        | Regex filter for lines.                          |
+
+**Response:** Compressed log summary showing unique templates and occurrence counts.
+
+**Examples:**
+
+```
+readLog  path="/var/log/app.log"  format="summary"  depth=4  simThreshold=0.4
+readLog  path="./logs/server.log"  format="detailed"  depth=4  simThreshold=0.4  tail=1000
+readLog  path="app.log"  format="json"  depth=6  simThreshold=0.3  grep="ERROR|WARN"
+```
+
+---
+
+### `flushLog` (dynamic)
+
+Release a log drain to free memory. Next `readLog` creates fresh drain. **This tool only appears when at least one drain is active.** When the last drain is flushed, the tool is automatically removed.
+
+| Parameter | Type     | Required | Description                    |
+| --------- | -------- | -------- | ------------------------------ |
+| `path`    | `string` | ✅       | Path to the log file to flush. |
+
+**Response:** `"Flushed {filename}. Released N templates from M lines."`
+
+**Example:**
+
+```
+flushLog  path="/var/log/app.log"
+```
+
+---
+
 ### `wait`
 
 Wait for a specified duration before continuing.
@@ -125,8 +172,10 @@ wait  durationSeconds=1  reason="animation to complete"
 | Variable                 | Default | Description                                                                                                    |
 | ------------------------ | ------- | -------------------------------------------------------------------------------------------------------------- |
 | `waitMaxDurationSeconds` | `300`   | Override the maximum allowed `durationSeconds`. Must be a positive number. Server refuses to start if invalid. |
+| `readLogTimeoutMs`       | `5000`  | Override the timeout for `readLog` processing in milliseconds. Server refuses to start if invalid.             |
 | `deleteFile`             | _(on)_  | Set to `"false"` to disable the `deleteFile` tool at startup.                                                  |
 | `moveFile`               | _(on)_  | Set to `"false"` to disable the `moveFile` tool at startup.                                                    |
+| `readLog`                | _(on)_  | Set to `"false"` to disable the `readLog` tool at startup.                                                     |
 | `wait`                   | _(on)_  | Set to `"false"` to disable the `wait` tool at startup.                                                        |
 
 ### Disabling Individual Tools

package/dist/index.js

@@ -4,6 +4,7 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { register as registerDeleteFile } from "./tools/deleteFile.js";
 import { register as registerMoveFile } from "./tools/moveFile.js";
+import { register as registerReadLog } from "./tools/readLog.js";
 import { register as registerWait } from "./tools/wait.js";
 const require = createRequire(import.meta.url);
 const { version } = require("../package.json");
@@ -13,6 +14,8 @@ if (isEnabled("deleteFile"))
     registerDeleteFile(server);
 if (isEnabled("moveFile"))
     registerMoveFile(server);
+if (isEnabled("readLog"))
+    registerReadLog(server);
 if (isEnabled("wait"))
     registerWait(server);
 await server.connect(new StdioServerTransport());

package/dist/tools/deleteFile.js

@@ -13,6 +13,10 @@ export function register(server) {
     server.registerTool("deleteFile", {
         description: "Delete one or more files or directories.",
         inputSchema: schema,
+        annotations: {
+            destructiveHint: true,
+            openWorldHint: false,
+        },
     }, async (input) => {
         try {
             const paths = Array.isArray(input.paths) ? input.paths : [input.paths];

package/dist/tools/moveFile.js

@@ -24,6 +24,10 @@ export function register(server) {
     server.registerTool("moveFile", {
         description: "Move one or more files or directories to a destination directory.",
         inputSchema: schema,
+        annotations: {
+            destructiveHint: true,
+            openWorldHint: false,
+        },
     }, async (input) => {
         try {
             const sources = Array.isArray(input.from) ? input.from : [input.from];

package/dist/tools/readLog.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function register(server: McpServer): void;

package/dist/tools/readLog.js

@@ -0,0 +1,152 @@
+import { readFile } from "node:fs/promises";
+import { resolve, basename } from "node:path";
+import { z } from "zod";
+import { createDrain } from "logpare";
+const timeoutMs = (() => {
+    const env = process.env.readLogTimeoutMs;
+    if (!env)
+        return 5000;
+    const n = Number(env);
+    if (!Number.isFinite(n) || n <= 0) {
+        process.stderr.write(`Invalid readLogTimeoutMs: "${env}".\n`);
+        process.exit(1);
+    }
+    return n;
+})();
+const drains = new Map();
+let flushTool = null;
+const schema = z
+    .object({
+    path: z.string().min(1).describe("Path to the log file."),
+    format: z.enum(["summary", "detailed", "json"]).describe("Output format."),
+    depth: z.number().int().min(2).max(8).describe("Parse tree depth (2-8)."),
+    simThreshold: z
+        .number()
+        .min(0)
+        .max(1)
+        .describe("Similarity threshold (0-1)."),
+    tail: z
+        .number()
+        .int()
+        .min(1)
+        .optional()
+        .describe("Last N lines (first read only)."),
+    head: z
+        .number()
+        .int()
+        .min(1)
+        .optional()
+        .describe("First N lines (first read only)."),
+    grep: z.string().optional().describe("Regex filter for lines."),
+})
+    .refine((d) => !(d.head && d.tail), {
+    message: "Cannot use both head and tail.",
+});
+const flushSchema = z.object({
+    path: z.string().min(1).describe("Path to the log file to flush."),
+});
+const ok = (text) => ({ content: [{ type: "text", text }] });
+const err = (text) => ({
+    isError: true,
+    content: [{ type: "text", text }],
+});
+export function register(server) {
+    server.registerTool("readLog", {
+        description: "Compress a log file using semantic pattern extraction (60-90% reduction). Creates stateful drains for incremental reads. Use flushLog to release.",
+        inputSchema: schema,
+        annotations: { readOnlyHint: true, openWorldHint: false },
+    }, async (input) => {
+        try {
+            return ok(await Promise.race([processLog(server, input), timeout()]));
+        }
+        catch (e) {
+            return err(String(e));
+        }
+    });
+}
+async function processLog(server, input) {
+    const path = resolve(process.cwd(), input.path);
+    let state = drains.get(path);
+    if (state &&
+        (state.depth !== input.depth || state.simThreshold !== input.simThreshold)) {
+        return `Error: Drain exists with depth=${state.depth}, simThreshold=${state.simThreshold}. Flush first.`;
+    }
+    const content = await readFile(path, "utf-8");
+    let lines = content.split(/\r?\n/).filter(Boolean);
+    if (!state) {
+        const wasEmpty = drains.size === 0;
+        if (input.head)
+            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 (!lines.length)
+            return "No log lines to process.";
+        const drain = createDrain({
+            depth: input.depth,
+            simThreshold: input.simThreshold,
+        });
+        drain.addLogLines(lines);
+        state = {
+            drain,
+            lastLine: lines.length,
+            depth: input.depth,
+            simThreshold: input.simThreshold,
+        };
+        drains.set(path, state);
+        if (wasEmpty)
+            registerFlush(server);
+        return `${state.drain.getResult(input.format).formatted}\n\n[New drain. ${state.lastLine} lines. Use flushLog when done.]`;
+    }
+    const newLines = lines.slice(state.lastLine);
+    if (!newLines.length) {
+        return `${state.drain.getResult(input.format).formatted}\n\n[No new lines. Total: ${state.lastLine}]`;
+    }
+    const filtered = input.grep ?
+        newLines.filter((l) => new RegExp(input.grep).test(l))
+        : newLines;
+    if (filtered.length)
+        state.drain.addLogLines(filtered);
+    state.lastLine = lines.length;
+    return `${state.drain.getResult(input.format).formatted}\n\n[+${newLines.length} lines. Total: ${state.lastLine}]`;
+}
+function registerFlush(server) {
+    if (flushTool)
+        return;
+    try {
+        flushTool = server.registerTool("flushLog", {
+            description: "Release a log drain to free memory. Next readLog creates fresh drain.",
+            inputSchema: flushSchema,
+            annotations: { destructiveHint: true, idempotentHint: true },
+        }, async (input) => {
+            try {
+                const path = resolve(process.cwd(), input.path);
+                const state = drains.get(path);
+                if (!state) {
+                    if (!drains.size)
+                        return ok("No active drains.");
+                    return ok(`No drain for "${basename(path)}". Active: ${[...drains.keys()].map((p) => basename(p)).join(", ")}`);
+                }
+                const { totalClusters, lastLine } = {
+                    totalClusters: state.drain.totalClusters,
+                    lastLine: state.lastLine,
+                };
+                drains.delete(path);
+                if (!drains.size && flushTool) {
+                    flushTool.remove();
+                    flushTool = null;
+                }
+                return ok(`Flushed ${basename(path)}. Released ${totalClusters} templates from ${lastLine} lines.`);
+            }
+            catch (e) {
+                return err(String(e));
+            }
+        });
+        server.sendToolListChanged();
+    }
+    catch { }
+}
+function timeout() {
+    return new Promise((_, rej) => setTimeout(() => rej(new Error(`Timeout: ${timeoutMs}ms`)), timeoutMs));
+}

package/dist/tools/wait.js

@@ -29,6 +29,10 @@ export function register(server) {
     server.registerTool("wait", {
         description: "Wait for a specified duration before continuing.",
         inputSchema: schema,
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true,
+        },
     }, async (input) => {
         try {
             const ms = Math.round(input.durationSeconds * 1000);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-multitool",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "MCP server with file operations (delete, move) and timing utilities.",
   "license": "MIT",
   "type": "module",
@@ -30,6 +30,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.29.0",
+    "logpare": "^0.1.0",
     "zod": "^3.24.0"
   },
   "devDependencies": {