mcp-multitool 0.1.6 → 0.1.8

package/README.md

@@ -4,19 +4,22 @@
 [![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                                             |
+| ----------------- | ------------------------------------------------------- |
+| `checkFileOrDir`  | Check if a file or directory exists and return metadata |
+| `deleteFileOrDir` | Delete one or more files or directories                 |
+| `moveFileOrDir`   | Move one or more files or directories to a new location |
+| `readLogFile`     | Read and compress logs with 60-90% token reduction      |
+| `renameFileOrDir` | Rename a single file or directory                       |
+| `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
 
@@ -58,45 +61,131 @@ npx mcp-multitool
 
 ## Tool Reference
 
-### `deleteFile`
+### `checkFileOrDir`
+
+Check if a file or directory exists and return its metadata (type, size, timestamps, permissions). Returns an error if the path does not exist.
+
+| Parameter | Type     | Required | Description                             |
+| --------- | -------- | -------- | --------------------------------------- |
+| `path`    | `string` | ✅       | Path to the file or directory to check. |
+
+**Response:** JSON object with raw `fs.Stats` properties plus computed `name`, `path`, and `type` fields.
+
+**Examples:**
+
+```
+checkFileOrDir  path="config.json"
+checkFileOrDir  path="/var/log/"
+checkFileOrDir  path="./src/index.ts"
+```
+
+---
+
+### `deleteFileOrDir`
 
 Delete one or more files or directories.
 
-| Parameter   | Type                 | Required | Default | Description                                           |
-| ----------- | -------------------- | -------- | ------- | ----------------------------------------------------- |
-| `paths`     | `string \| string[]` | ✅       | —       | File or directory path(s) to delete.                  |
-| `recursive` | `boolean`            | —        | `false` | If true, delete directories and contents recursively. |
+| Parameter   | Type                 | Required | Description                                           |
+| ----------- | -------------------- | -------- | ----------------------------------------------------- |
+| `paths`     | `string \| string[]` | ✅       | File or directory path(s) to delete.                  |
+| `recursive` | `boolean`            | ✅       | If true, delete directories and contents recursively. |
 
 **Response:** `"Deleted N path(s)."`
 
 **Examples:**
 
 ```
-deleteFile  paths="temp.txt"
-deleteFile  paths=["a.txt", "b.txt"]
-deleteFile  paths="build/"  recursive=true
+deleteFileOrDir  paths="temp.txt"  recursive=false
+deleteFileOrDir  paths=["a.txt", "b.txt"]  recursive=false
+deleteFileOrDir  paths="build/"  recursive=true
 ```
 
 ---
 
-### `moveFile`
+### `moveFileOrDir`
 
 Move one or more files or directories to a destination directory.
 
-| Parameter   | Type                 | Required | Default | Description                        |
-| ----------- | -------------------- | -------- | ------- | ---------------------------------- |
-| `from`      | `string \| string[]` | ✅       | —       | Source path(s) to move.            |
-| `to`        | `string`             | ✅       | —       | Destination directory.             |
-| `overwrite` | `boolean`            | —        | `false` | If true, overwrite existing files. |
+| Parameter   | Type                 | Required | Description                        |
+| ----------- | -------------------- | -------- | ---------------------------------- |
+| `from`      | `string \| string[]` | ✅       | Source path(s) to move.            |
+| `to`        | `string`             | ✅       | Destination directory.             |
+| `overwrite` | `boolean`            | ✅       | If true, overwrite existing files. |
 
 **Response:** `"Moved N path(s)."`
 
 **Examples:**
 
 ```
-moveFile  from="old.txt"  to="archive/"
-moveFile  from=["a.txt", "b.txt"]  to="backup/"
-moveFile  from="config.json"  to="dest/"  overwrite=true
+moveFileOrDir  from="old.txt"  to="archive/"  overwrite=false
+moveFileOrDir  from=["a.txt", "b.txt"]  to="backup/"  overwrite=false
+moveFileOrDir  from="config.json"  to="dest/"  overwrite=true
+```
+
+---
+
+### `readLogFile`
+
+Compress a log file using semantic pattern extraction (60-90% token reduction). Creates stateful drains for incremental reads. Use `flushLogFile` 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 `flushLogFile` 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:**
+
+```
+readLogFile  path="/var/log/app.log"  format="summary"  depth=4  simThreshold=0.4
+readLogFile  path="./logs/server.log"  format="detailed"  depth=4  simThreshold=0.4  tail=1000
+readLogFile  path="app.log"  format="json"  depth=6  simThreshold=0.3  grep="ERROR|WARN"
+```
+
+---
+
+### `flushLogFile` (dynamic)
+
+Release a log drain to free memory. Next `readLogFile` 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:**
+
+```
+flushLogFile  path="/var/log/app.log"
+```
+
+---
+
+### `renameFileOrDir`
+
+Rename a single file or directory. Only the name can change — the parent directory must stay the same. Use `moveFileOrDir` to change directories.
+
+| Parameter | Type     | Required | Description                                  |
+| --------- | -------- | -------- | -------------------------------------------- |
+| `oldPath` | `string` | ✅       | Current path to the file or directory.       |
+| `newPath` | `string` | ✅       | New path with the renamed file or directory. |
+
+**Response:** `"Renamed "{oldName}" to "{newName}"."`
+
+**Examples:**
+
+```
+renameFileOrDir  oldPath="config.json"  newPath="config.backup.json"
+renameFileOrDir  oldPath="/app/src"  newPath="/app/source"
 ```
 
 ---
@@ -125,8 +214,12 @@ 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. |
-| `deleteFile`             | _(on)_  | Set to `"false"` to disable the `deleteFile` tool at startup.                                                  |
-| `moveFile`               | _(on)_  | Set to `"false"` to disable the `moveFile` tool at startup.                                                    |
+| `readLogFileTimeoutMs`   | `5000`  | Override the timeout for `readLogFile` processing in milliseconds. Server refuses to start if invalid.         |
+| `checkFileOrDir`         | _(on)_  | Set to `"false"` to disable the `checkFileOrDir` tool at startup.                                              |
+| `deleteFileOrDir`        | _(on)_  | Set to `"false"` to disable the `deleteFileOrDir` tool at startup.                                             |
+| `moveFileOrDir`          | _(on)_  | Set to `"false"` to disable the `moveFileOrDir` tool at startup.                                               |
+| `readLogFile`            | _(on)_  | Set to `"false"` to disable the `readLogFile` tool at startup.                                                 |
+| `renameFileOrDir`        | _(on)_  | Set to `"false"` to disable the `renameFileOrDir` tool at startup.                                             |
 | `wait`                   | _(on)_  | Set to `"false"` to disable the `wait` tool at startup.                                                        |
 
 ### Disabling Individual Tools

package/dist/index.js

@@ -2,17 +2,26 @@
 import { createRequire } from "node:module";
 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 registerCheckFileOrDir } from "./tools/checkFileOrDir.js";
+import { register as registerDeleteFileOrDir } from "./tools/deleteFileOrDir.js";
+import { register as registerMoveFileOrDir } from "./tools/moveFileOrDir.js";
+import { register as registerReadLogFile } from "./tools/readLogFile.js";
+import { register as registerRenameFileOrDir } from "./tools/renameFileOrDir.js";
 import { register as registerWait } from "./tools/wait.js";
 const require = createRequire(import.meta.url);
 const { version } = require("../package.json");
 const isEnabled = (name) => process.env[name] !== "false";
 const server = new McpServer({ name: "mcp-multitool", version });
-if (isEnabled("deleteFile"))
-    registerDeleteFile(server);
-if (isEnabled("moveFile"))
-    registerMoveFile(server);
+if (isEnabled("checkFileOrDir"))
+    registerCheckFileOrDir(server);
+if (isEnabled("deleteFileOrDir"))
+    registerDeleteFileOrDir(server);
+if (isEnabled("moveFileOrDir"))
+    registerMoveFileOrDir(server);
+if (isEnabled("readLogFile"))
+    registerReadLogFile(server);
+if (isEnabled("renameFileOrDir"))
+    registerRenameFileOrDir(server);
 if (isEnabled("wait"))
     registerWait(server);
 await server.connect(new StdioServerTransport());

package/dist/tools/checkFile.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/checkFile.js

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import { lstat } from "node:fs/promises";
+import { basename, resolve } from "node:path";
+const schema = z.object({
+    path: z.string().min(1).describe("Path to the file or folder to check."),
+});
+export function register(server) {
+    server.registerTool("checkFile", {
+        description: "Check if a file or folder exists and return its metadata (type, size, timestamps, permissions). Returns an error if the path does not exist.",
+        inputSchema: schema,
+        annotations: {
+            readOnlyHint: true,
+            openWorldHint: false,
+        },
+    }, async (input) => {
+        try {
+            const fullPath = resolve(process.cwd(), input.path);
+            const stats = await lstat(fullPath);
+            const type = stats.isFile() ? "file"
+                : stats.isDirectory() ? "directory"
+                    : stats.isSymbolicLink() ? "symlink"
+                        : stats.isBlockDevice() ? "block-device"
+                            : stats.isCharacterDevice() ? "character-device"
+                                : stats.isFIFO() ? "fifo"
+                                    : stats.isSocket() ? "socket"
+                                        : "unknown";
+            // Build output from raw stats, adding computed fields
+            const meta = {
+                name: basename(fullPath),
+                path: fullPath,
+                type,
+                ...stats,
+            };
+            return {
+                content: [{ type: "text", text: JSON.stringify(meta, null, 2) }],
+            };
+        }
+        catch (err) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: String(err) }],
+            };
+        }
+    });
+}

package/dist/tools/checkFileOrDir.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/checkFileOrDir.js

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import { lstat } from "node:fs/promises";
+import { basename, resolve } from "node:path";
+const schema = z.object({
+    path: z.string().min(1).describe("Path to the file or folder to check."),
+});
+export function register(server) {
+    server.registerTool("checkFileOrDir", {
+        description: "Check if a file or directory exists and return its metadata (type, size, timestamps, permissions). Returns an error if the path does not exist.",
+        inputSchema: schema,
+        annotations: {
+            readOnlyHint: true,
+            openWorldHint: false,
+        },
+    }, async (input) => {
+        try {
+            const fullPath = resolve(process.cwd(), input.path);
+            const stats = await lstat(fullPath);
+            const type = stats.isFile() ? "file"
+                : stats.isDirectory() ? "directory"
+                    : stats.isSymbolicLink() ? "symlink"
+                        : stats.isBlockDevice() ? "block-device"
+                            : stats.isCharacterDevice() ? "character-device"
+                                : stats.isFIFO() ? "fifo"
+                                    : stats.isSocket() ? "socket"
+                                        : "unknown";
+            // Build output from raw stats, adding computed fields
+            const meta = {
+                name: basename(fullPath),
+                path: fullPath,
+                type,
+                ...stats,
+            };
+            return {
+                content: [{ type: "text", text: JSON.stringify(meta, null, 2) }],
+            };
+        }
+        catch (err) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: String(err) }],
+            };
+        }
+    });
+}

package/dist/tools/deleteFile.js

@@ -6,13 +6,16 @@ const schema = z.object({
         .describe("File or directory path(s) to delete."),
     recursive: z
         .boolean()
-        .default(false)
         .describe("If true, delete directories and contents recursively."),
 });
 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/deleteFileOrDir.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/deleteFileOrDir.js

@@ -0,0 +1,34 @@
+import { rm } from "node:fs/promises";
+import { z } from "zod";
+const schema = z.object({
+    paths: z
+        .union([z.string(), z.array(z.string())])
+        .describe("File or directory path(s) to delete."),
+    recursive: z
+        .boolean()
+        .describe("If true, delete directories and contents recursively."),
+});
+export function register(server) {
+    server.registerTool("deleteFileOrDir", {
+        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];
+            await Promise.all(paths.map((p) => rm(p, { recursive: input.recursive })));
+            return {
+                content: [{ type: "text", text: `Deleted ${paths.length} path(s).` }],
+            };
+        }
+        catch (err) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: String(err) }],
+            };
+        }
+    });
+}

package/dist/tools/moveFile.js

@@ -8,7 +8,6 @@ const schema = z.object({
     to: z.string().describe("Destination directory."),
     overwrite: z
         .boolean()
-        .default(false)
         .describe("If true, overwrite existing files."),
 });
 async function exists(path) {
@@ -24,6 +23,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/moveFileOrDir.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/moveFileOrDir.js

@@ -0,0 +1,49 @@
+import { access, rename } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { z } from "zod";
+const schema = z.object({
+    from: z
+        .union([z.string(), z.array(z.string())])
+        .describe("Source path(s) to move."),
+    to: z.string().describe("Destination directory."),
+    overwrite: z.boolean().describe("If true, overwrite existing files."),
+});
+async function exists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function register(server) {
+    server.registerTool("moveFileOrDir", {
+        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];
+            for (const src of sources) {
+                const dest = join(input.to, basename(src));
+                if (!input.overwrite && (await exists(dest))) {
+                    throw new Error(`Destination exists: ${dest}. Set overwrite=true to replace.`);
+                }
+                await rename(src, dest);
+            }
+            return {
+                content: [{ type: "text", text: `Moved ${sources.length} path(s).` }],
+            };
+        }
+        catch (err) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: String(err) }],
+            };
+        }
+    });
+}

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/readLogFile.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/readLogFile.js

@@ -0,0 +1,151 @@
+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.readLogFileTimeoutMs;
+    if (!env)
+        return 5000;
+    const n = Number(env);
+    if (!Number.isFinite(n) || n <= 0) {
+        process.stderr.write(`Invalid readLogFileTimeoutMs: "${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."),
+});
+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("readLogFile", {
+        description: "Compress a log file using semantic pattern extraction (60-90% reduction). Creates stateful drains for incremental reads. Use flushLogFile 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 (input.head && input.tail) {
+        return "Cannot use both head and tail.";
+    }
+    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 flushLogFile 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("flushLogFile", {
+            description: "Release a log drain to free memory. Next readLogFile 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/renameFile.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/renameFile.js

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import { rename, stat } from "node:fs/promises";
+import { dirname, basename } from "node:path";
+const schema = z
+    .object({
+    oldPath: z.string().min(1).describe("Current path to the file or folder."),
+    newPath: z
+        .string()
+        .min(1)
+        .describe("New path with the renamed file or folder."),
+})
+    .refine((d) => dirname(d.oldPath) === dirname(d.newPath), {
+    message: "Parent directory must match. Use moveFile to change directories.",
+});
+export function register(server) {
+    server.registerTool("renameFile", {
+        description: "Rename a single file or folder. Only the name can change — the parent directory must stay the same. Use moveFile to change directories.",
+        inputSchema: schema,
+        annotations: {
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
+    }, async (input) => {
+        try {
+            const oldName = basename(input.oldPath);
+            const newName = basename(input.newPath);
+            if (oldName === newName) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Nothing to rename — names are identical.`,
+                        },
+                    ],
+                };
+            }
+            await stat(input.oldPath); // Verify exists
+            await rename(input.oldPath, input.newPath);
+            return {
+                content: [
+                    { type: "text", text: `Renamed "${oldName}" to "${newName}".` },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: String(err) }],
+            };
+        }
+    });
+}

package/dist/tools/renameFileOrDir.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/renameFileOrDir.js

@@ -0,0 +1,60 @@
+import { z } from "zod";
+import { rename, stat } from "node:fs/promises";
+import { dirname, basename } from "node:path";
+const schema = z.object({
+    oldPath: z.string().min(1).describe("Current path to the file or directory."),
+    newPath: z
+        .string()
+        .min(1)
+        .describe("New path with the renamed file or directory."),
+});
+export function register(server) {
+    server.registerTool("renameFileOrDir", {
+        description: "Rename a single file or directory. Only the name can change — the parent directory must stay the same. Use moveFileOrDir to change directories.",
+        inputSchema: schema,
+        annotations: {
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
+    }, async (input) => {
+        try {
+            if (dirname(input.oldPath) !== dirname(input.newPath)) {
+                return {
+                    isError: true,
+                    content: [
+                        {
+                            type: "text",
+                            text: "Parent directory must match. Use moveFileOrDir to change directories.",
+                        },
+                    ],
+                };
+            }
+            const oldName = basename(input.oldPath);
+            const newName = basename(input.newPath);
+            if (oldName === newName) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Nothing to rename — names are identical.`,
+                        },
+                    ],
+                };
+            }
+            await stat(input.oldPath); // Verify exists
+            await rename(input.oldPath, input.newPath);
+            return {
+                content: [
+                    { type: "text", text: `Renamed "${oldName}" to "${newName}".` },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: String(err) }],
+            };
+        }
+    });
+}

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.8",
   "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": {