mcp-fs-shell-windows 0.2.20 → 0.2.29

package/dist/git/handler.js

@@ -0,0 +1,209 @@
+// git/handler.ts — git CLI wrappers for the 6 git_* tools (MCP filesystem fork).
+//
+// Design: spawn the `git` binary directly (git is on PATH; no new dependency).
+// Every tool operates against the repo at the server process's current working
+// directory (process.cwd()) — the same "current working directory context" the
+// shell tools use — and takes NO working-directory parameter (matching the
+// reference Beledarian tools). Path arguments are resolved relative to that
+// directory. All argument values (messages, branch names, file paths) are passed
+// as individual argv elements (no shell), so quotes / Unicode / special
+// characters pass through verbatim.
+//
+// Return shape mirrors the reference implementation: each handler returns a JSON
+// text string carrying the reference's fields ({error} on failure, {diff},
+// {history}, {success, ...}) instead of throwing, so a working directory that is
+// not inside a git repository yields a clear error string rather than a crash.
+import { spawn } from "child_process";
+import nodePath from "path";
+/** Run `git <args>` with the given cwd. Never rejects; spawn failures resolve with code -1. */
+function runGit(args, cwd) {
+    return new Promise((resolve) => {
+        let child;
+        try {
+            child = spawn("git", args, { cwd });
+        }
+        catch (e) {
+            resolve({ code: -1, stdout: "", stderr: e instanceof Error ? e.message : String(e) });
+            return;
+        }
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        const finish = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve({ code, stdout, stderr });
+        };
+        if (child.stdout) {
+            child.stdout.on("data", (d) => {
+                stdout += d.toString("utf8");
+            });
+        }
+        if (child.stderr) {
+            child.stderr.on("data", (d) => {
+                stderr += d.toString("utf8");
+            });
+        }
+        child.on("error", (e) => {
+            // e.g. ENOENT when the git binary cannot be found on PATH
+            stderr += (stderr ? "\n" : "") + (e.message || String(e));
+            finish(-1);
+        });
+        child.on("close", (code) => finish(code === null ? -1 : code));
+    });
+}
+/** JSON error text matching the reference shape: {error: "Git <what> failed: <detail>"}. */
+function failText(out, what) {
+    const detail = out.stderr.trim() || out.stdout.trim() || `git exited with code ${out.code}`;
+    return JSON.stringify({ error: `Git ${what} failed: ${detail}` });
+}
+/** The repo context for all git_* tools: the server process's current working directory. */
+function gitCwd() {
+    return process.cwd();
+}
+export async function handleGitStatus() {
+    const dir = gitCwd();
+    const st = await runGit(["status", "--porcelain=v1", "--branch"], dir);
+    if (st.code !== 0) {
+        return failText(st, "status");
+    }
+    const lines = st.stdout.replace(/\r/g, "").split("\n");
+    let current = null;
+    let tracking = null;
+    let ahead = 0;
+    let behind = 0;
+    const staged = [];
+    const notStaged = [];
+    const untracked = [];
+    const files = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (i === 0 && line.startsWith("## ")) {
+            // Header: "## branch", "## branch...upstream", "## branch...upstream [ahead 1, behind 2]",
+            // or "## HEAD (no branch)" (detached HEAD).
+            let rest = line.slice(3);
+            const bracket = / \[([^\]]*)\]$/.exec(rest);
+            if (bracket) {
+                const am = /ahead (\d+)/.exec(bracket[1]);
+                const bm = /behind (\d+)/.exec(bracket[1]);
+                if (am)
+                    ahead = parseInt(am[1], 10);
+                if (bm)
+                    behind = parseInt(bm[1], 10);
+                rest = rest.slice(0, rest.length - bracket[0].length);
+            }
+            const sep = rest.indexOf("...");
+            if (sep >= 0) {
+                const left = rest.slice(0, sep);
+                current = left === "HEAD" ? null : left;
+                tracking = rest.slice(sep + 3) || null;
+            }
+            else if (rest.startsWith("HEAD (")) {
+                current = null;
+                tracking = null;
+            }
+            else {
+                current = rest || null;
+                tracking = null;
+            }
+            continue;
+        }
+        if (!line)
+            continue;
+        const index = line[0];
+        const working = line[1];
+        let p = line.slice(3);
+        // Rename/copy entries: "R  old -> new" / "C  old -> new" — report the destination.
+        if (index === "R" || index === "C") {
+            const arrow = p.indexOf(" -> ");
+            if (arrow >= 0)
+                p = p.slice(arrow + 4);
+        }
+        files.push({ path: p, index, working_dir: working });
+        if (index === "?" && working === "?") {
+            untracked.push(p);
+        }
+        else {
+            if (index !== " " && index !== "?")
+                staged.push(p);
+            if (working !== " " && working !== "?")
+                notStaged.push(p);
+        }
+    }
+    const isClean = staged.length === 0 && notStaged.length === 0 && untracked.length === 0;
+    return JSON.stringify({ current, tracking, ahead, behind, isClean, staged, notStaged, untracked, files });
+}
+export async function handleGitDiff(file_path, cached) {
+    const dir = gitCwd();
+    const args = ["diff"];
+    if (cached)
+        args.push("--cached");
+    if (file_path) {
+        args.push("--", nodePath.resolve(dir, file_path));
+    }
+    const d = await runGit(args, dir);
+    if (d.code !== 0) {
+        return failText(d, "diff");
+    }
+    const text = d.stdout.replace(/\n$/, "");
+    return JSON.stringify({ diff: text.length > 0 ? text : "No changes." });
+}
+export async function handleGitCommit(message) {
+    const dir = gitCwd();
+    // Pre-image stat of what is staged (mirrors the reference's {changed, insertions, deletions} summary).
+    const summary = { changed: 0, insertions: 0, deletions: 0 };
+    const pre = await runGit(["diff", "--cached", "--shortstat"], dir);
+    if (pre.code === 0 && pre.stdout.trim()) {
+        const mf = /(\d+) files? changed/.exec(pre.stdout);
+        if (mf)
+            summary.changed = parseInt(mf[1], 10);
+        const mi = /(\d+) insertions?\(\+\)/.exec(pre.stdout);
+        if (mi)
+            summary.insertions = parseInt(mi[1], 10);
+        const md = /(\d+) deletions?\(-\)/.exec(pre.stdout);
+        if (md)
+            summary.deletions = parseInt(md[1], 10);
+    }
+    // Standard git behavior: commit only what is staged.
+    const c = await runGit(["commit", "-m", message], dir);
+    if (c.code !== 0) {
+        return failText(c, "commit");
+    }
+    return JSON.stringify({ success: true, summary });
+}
+export async function handleGitLog(max_count) {
+    const dir = gitCwd();
+    const n = typeof max_count === "number" && Number.isFinite(max_count) && max_count > 0
+        ? Math.floor(max_count)
+        : 10;
+    const l = await runGit(["log", "-n", String(n), "--pretty=format:%h %s (%an, %ar)"], dir);
+    if (l.code !== 0) {
+        return failText(l, "log");
+    }
+    const history = l.stdout
+        .split("\n")
+        .map((s) => s.trimEnd())
+        .filter((s) => s.length > 0);
+    return JSON.stringify({ history });
+}
+export async function handleGitAdd(paths) {
+    const dir = gitCwd();
+    const args = paths && paths.length > 0
+        ? ["add", "--", ...paths.map((p) => nodePath.resolve(dir, p))]
+        : ["add", "."];
+    const a = await runGit(args, dir);
+    if (a.code !== 0) {
+        return failText(a, "add");
+    }
+    return JSON.stringify({ success: true, message: "Files staged successfully." });
+}
+export async function handleGitCheckout(branch_name, create_new) {
+    const dir = gitCwd();
+    const args = create_new ? ["checkout", "-b", branch_name] : ["checkout", branch_name];
+    const c = await runGit(args, dir);
+    if (c.code !== 0) {
+        return failText(c, "checkout");
+    }
+    return JSON.stringify({ success: true, message: `Switched to branch '${branch_name}'.` });
+}

package/dist/git/schema.js

@@ -0,0 +1,23 @@
+// git/schema.ts — argument schemas for the 6 git_* tools.
+// (MCP filesystem fork; thin git CLI wrappers that operate against the repo at the
+// server process's current working directory — no working-directory parameter, same
+// "current working directory context" as the shell tools.)
+import { z } from "zod";
+export const GitStatusArgsSchema = z.object({});
+export const GitDiffArgsSchema = z.object({
+    file_path: z.string().optional().describe("Optional: Path to specific file to diff."),
+    cached: z.boolean().optional().describe("Optional: Show staged changes only (git diff --cached)."),
+});
+export const GitCommitArgsSchema = z.object({
+    message: z.string(),
+});
+export const GitLogArgsSchema = z.object({
+    max_count: z.number().optional().describe("Max number of commits to return (default: 10)"),
+});
+export const GitAddArgsSchema = z.object({
+    paths: z.array(z.string()).optional().describe("Optional: Specific file paths to stage. If omitted, stages all changes."),
+});
+export const GitCheckoutArgsSchema = z.object({
+    branch_name: z.string().describe("Name of the branch to checkout."),
+    create_new: z.boolean().optional().default(false).describe("If true, creates the branch if it doesn't exist (like git checkout -b)."),
+});

package/dist/launch_file/handler.js

@@ -51,7 +51,9 @@ const URI_SCHEME = /^[A-Za-z][A-Za-z0-9+.-]+:/;
  * Only the opener executable changes; the target still passes the full
  * URL/path policy below.
  */
-function openerPath() {
+// Exported (v0.2.23) so the system tools (preview_html) can reuse the exact
+// same opener resolution — no behavior change.
+export function openerPath() {
     if (process.platform !== "win32") {
         throw new Error("launch_file is supported only on Windows");
     }

package/dist/query_database/handler.js

@@ -0,0 +1,27 @@
+// query_database/handler.ts — read-only SQLite queries (MCP filesystem fork).
+//
+// Port of the Beledarian query_database tool (beledarians-lm-studio-tools
+// src/toolsProvider.ts), with one substitution: the reference uses the native
+// better-sqlite3 module; this fork runs on system Node which ships the built-in
+// node:sqlite module (DatabaseSync), so no native dependency is added. Same
+// behavior: naive write-statement block, open READONLY, prepare + all(), close,
+// return { results } or { error }.
+import { DatabaseSync } from "node:sqlite";
+import { validatePath } from "../helpers/path.js";
+export async function handleQueryDatabase(dbPath, query, allowedDirectories) {
+    const fpath = await validatePath(dbPath, allowedDirectories);
+    // Safety: Attempt to block write operations (naive check)
+    if (/^\s*(INSERT|UPDATE|DELETE|DROP|ALTER|CREATE|REPLACE)\b/i.test(query)) {
+        return JSON.stringify({ error: "Only SELECT/read queries are allowed for safety." });
+    }
+    try {
+        const db = new DatabaseSync(fpath, { readOnly: true });
+        const stmt = db.prepare(query);
+        const results = stmt.all();
+        db.close();
+        return JSON.stringify({ results });
+    }
+    catch (e) {
+        return JSON.stringify({ error: `Database query failed: ${e instanceof Error ? e.message : String(e)}` });
+    }
+}

package/dist/query_database/schema.js

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export const QueryDatabaseArgsSchema = z.object({
+    db_path: z.string(),
+    query: z.string(),
+});

package/dist/rag/handler.js

@@ -0,0 +1,103 @@
+// rag/handler.ts — RAG tools (MCP filesystem fork).
+//
+// Port of the Beledarian rag_local_files (beledarians-lm-studio-tools
+// src/toolsProvider.ts L2389-2463) and rag_web_content (L1706-1754) tools.
+// Same behavior throughout: rag_local_files recursively scans up to 50 text
+// files, chunks on blank lines (>20 chars), keeps chunks scoring above
+// cosine similarity 0.4, and returns the top 10 with {file, score, content}
+// (score as a 3-decimal string, exactly like the reference). rag_web_content
+// fetches the URL, converts to plain text with html-to-text (the same
+// options the fork's fetch_web_content tool uses), and returns the top 5
+// chunks from performRagOnText. Embedding goes through the LM Studio
+// /v1/embeddings endpoint (see helpers.ts) instead of the SDK client.
+import fs from "fs/promises";
+import path from "path";
+import { validatePath } from "../helpers/path.js";
+import { chunkText, cosineSimilarity, embedStrings, performRagOnText } from "./helpers.js";
+export async function handleRagLocalFiles(query, searchPath, filePattern, allowedDirectories) {
+    try {
+        const targetDir = await validatePath(searchPath ?? ".", allowedDirectories);
+        const entries = await fs.readdir(targetDir, { recursive: true, withFileTypes: true });
+        const textFiles = entries.filter((e) => e.isFile() && !e.name.match(/\.(png|jpg|jpeg|gif|ico|exe|dll|bin)$/i));
+        // Filter by pattern if provided
+        const filteredFiles = filePattern
+            ? textFiles.filter((e) => e.name.includes(filePattern) || path.join(e.parentPath, e.name).includes(filePattern))
+            : textFiles;
+        // Limit to avoid massive reads. In a real 'Gemini Flow' robust
+        // implementation, we'd use an index. Here we'll read top 50 files max to be safe.
+        const filesToScan = filteredFiles.slice(0, 50);
+        let allChunks = [];
+        const [queryEmbedding] = await embedStrings([query]);
+        for (const file of filesToScan) {
+            try {
+                const fullPath = path.join(file.parentPath, file.name);
+                const content = await fs.readFile(fullPath, "utf-8");
+                // reuse chunking logic
+                const chunks = chunkText(content);
+                if (chunks.length === 0)
+                    continue;
+                // Batch embed chunks for this file
+                const chunkEmbeddings = await embedStrings(chunks);
+                chunks.forEach((chunk, i) => {
+                    const score = cosineSimilarity(queryEmbedding, chunkEmbeddings[i]);
+                    if (score > 0.4) { // Threshold
+                        allChunks.push({ chunk, score, file: file.name });
+                    }
+                });
+            }
+            catch {
+                // ignore read errors
+            }
+        }
+        // Sort all chunks
+        allChunks.sort((a, b) => b.score - a.score);
+        return JSON.stringify({
+            query,
+            results: allChunks.slice(0, 10).map((c) => ({
+                file: c.file,
+                score: c.score.toFixed(3),
+                content: c.chunk,
+            })),
+        });
+    }
+    catch (error) {
+        return JSON.stringify({
+            error: `Local RAG failed: ${error instanceof Error ? error.message : String(error)}`,
+        });
+    }
+}
+export async function handleRagWebContent(url, query) {
+    try {
+        // 1. Fetch content
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        let text = await response.text();
+        // Same text extraction the fork's fetch_web_content tool uses
+        const { compile } = await import("html-to-text");
+        const compiledConvert = compile({
+            wordwrap: false,
+            selectors: [
+                { selector: "a", options: { ignoreHref: true } },
+                { selector: "img", format: "skip" },
+            ],
+        });
+        text = compiledConvert(text);
+        if (text.length === 0) {
+            return JSON.stringify({ error: "Could not extract any text from the URL." });
+        }
+        // 2. Perform RAG
+        const ragResults = await performRagOnText(text, query);
+        return JSON.stringify({
+            url: url,
+            query: query,
+            relevant_chunks: ragResults,
+        });
+    }
+    catch (error) {
+        return JSON.stringify({
+            error: `Failed during RAG web search: ${error instanceof Error ? error.message : String(error)}`,
+        });
+    }
+}

package/dist/rag/helpers.js

@@ -0,0 +1,126 @@
+// rag/helpers.ts — shared RAG helpers (MCP filesystem fork).
+//
+// Port of the Beledarian RAG core (beledarians-lm-studio-tools
+// src/toolsProvider.ts: cosineSimilarity L76-84, performRagOnText L86-110),
+// with one substitution: the reference embeds through the LM Studio SDK
+// client; this fork runs on plain Node, so embedding is a fetch against
+// LM Studio's OpenAI-compatible API: POST http://127.0.0.1:1234/v1/embeddings
+// with JSON { model, input: [strings] } and (when a token is available)
+// Authorization: Bearer <token>. The token is read from MCP_API_TOKEN_FILE
+// (or, when unset, the reference machine's overnight pipeline token file);
+// if that file is missing or empty the request is sent keyless. The endpoint
+// is MCP_RAG_EMBED_URL when set. All thresholds, chunking, and top-N
+// behavior are identical
+// to the reference.
+import fs from "fs";
+const DEFAULT_EMBEDDINGS_URL = "http://127.0.0.1:1234/v1/embeddings";
+// Reference machine's overnight pipeline token file (kept for back-compat;
+// on other machines the file is simply absent -> keyless request).
+const LEGACY_TOKEN_FILE = "C:/Users/Gerar/.beledarians-llm-toolbox/workspace/overnight/lm_api_token.txt";
+// Env overrides (v0.2.29 publish portability). When unset, behavior on the
+// reference machine is unchanged.
+function getEmbeddingsUrl() {
+    const o = process.env.MCP_RAG_EMBED_URL;
+    return o && o.trim() ? o.trim() : DEFAULT_EMBEDDINGS_URL;
+}
+function getTokenFile() {
+    const o = process.env.MCP_API_TOKEN_FILE;
+    return o && o.trim() ? o.trim() : LEGACY_TOKEN_FILE;
+}
+const DEFAULT_EMBED_MODEL = "text-embedding-nomic-embed-text-v1.5";
+// Read the API token fresh on every call (small file; rotation stays live).
+function readApiKey() {
+    try {
+        const token = fs.readFileSync(getTokenFile(), "utf-8").trim();
+        return token.length > 0 ? token : null;
+    }
+    catch {
+        return null;
+    }
+}
+// Env override for the embedding model id (LM Studio resolves model ids the
+// same way for the /v1/embeddings endpoint).
+function getEmbedModel() {
+    const override = process.env.MCP_RAG_EMBED_MODEL;
+    return override && override.trim().length > 0 ? override.trim() : DEFAULT_EMBED_MODEL;
+}
+// Embed a batch of strings. Response shape: {data: [{embedding: number[], index}]}.
+// Results are mapped back to input order by `index`. One retry (2 attempts)
+// on transient network/API errors with a short backoff — the first embedding
+// call of a session can trigger an auto-load of the embedding model on its
+// own llama-server, which takes a few seconds.
+export async function embedStrings(strings) {
+    if (strings.length === 0)
+        return [];
+    let lastError = null;
+    for (let attempt = 0; attempt < 2; attempt++) {
+        try {
+            const headers = {
+                "Content-Type": "application/json",
+            };
+            const token = readApiKey();
+            if (token)
+                headers["Authorization"] = `Bearer ${token}`;
+            const res = await fetch(getEmbeddingsUrl(), {
+                method: "POST",
+                headers,
+                body: JSON.stringify({ model: getEmbedModel(), input: strings }),
+            });
+            if (!res.ok) {
+                const body = await res.text().catch(() => "");
+                throw new Error(`embeddings HTTP ${res.status}: ${body.slice(0, 300)}`);
+            }
+            const data = await res.json();
+            if (!data || !Array.isArray(data.data)) {
+                throw new Error("embeddings response missing data array");
+            }
+            const byIndex = new Map();
+            for (const item of data.data) {
+                byIndex.set(item.index, item.embedding);
+            }
+            return strings.map((_, i) => {
+                const e = byIndex.get(i);
+                if (!Array.isArray(e) || e.length === 0) {
+                    throw new Error(`embeddings response missing embedding for index ${i}`);
+                }
+                return e;
+            });
+        }
+        catch (e) {
+            lastError = e;
+            await new Promise((r) => setTimeout(r, 2000));
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+// Helper function for cosine similarity (identical to the reference).
+export function cosineSimilarity(vecA, vecB) {
+    const dotProduct = vecA.reduce((acc, val, i) => acc + val * vecB[i], 0);
+    const magA = Math.sqrt(vecA.reduce((acc, val) => acc + val * val, 0));
+    const magB = Math.sqrt(vecB.reduce((acc, val) => acc + val * val, 0));
+    if (magA === 0 || magB === 0) {
+        return 0;
+    }
+    return dotProduct / (magA * magB);
+}
+// Paragraph-based chunking (identical to the reference): split on blank
+// lines, keep chunks with more than 20 non-whitespace characters.
+export function chunkText(text) {
+    return text.split(/\n\s*\n/).filter((chunk) => chunk.trim().length > 20);
+}
+// Main RAG-on-text helper (identical behavior to the reference:
+// chunk, embed query + chunks, cosine similarity, sort, top 5).
+export async function performRagOnText(text, query) {
+    const chunks = chunkText(text);
+    if (chunks.length === 0) {
+        return [{ chunk: text.substring(0, 4000), score: 1 }];
+    }
+    const [queryEmbedding] = await embedStrings([query]);
+    const chunkEmbeddings = await embedStrings(chunks);
+    const similarities = chunkEmbeddings.map((chunkEmb, i) => ({
+        chunk: chunks[i],
+        score: cosineSimilarity(queryEmbedding, chunkEmb),
+    }));
+    similarities.sort((a, b) => b.score - a.score);
+    return similarities.slice(0, 5); // Return top 5
+}

package/dist/rag/schema.js

@@ -0,0 +1,16 @@
+import { z } from "zod";
+export const RagLocalFilesArgsSchema = z.object({
+    query: z.string().describe("The search query to match file contents against"),
+    path: z
+        .string()
+        .optional()
+        .describe("Root directory to search (default: the server process's working directory). Must be within an allowed directory."),
+    file_pattern: z
+        .string()
+        .optional()
+        .describe("File pattern to include (e.g. '.ts', 'src/'). Default: all text files."),
+});
+export const RagWebContentArgsSchema = z.object({
+    url: z.string().describe("The URL to fetch"),
+    query: z.string().describe("The query to find relevant content for"),
+});

package/dist/read_document/handler.js

@@ -0,0 +1,61 @@
+// read_document/handler.ts — read content from PDF or DOCX files (MCP filesystem fork).
+//
+// Port of the Beledarian read_document tool (beledarians-lm-studio-tools
+// src/toolsProvider.ts). PDF via pdf-parse v2 class-based API
+// (new PDFParse({ data }) -> getText() / getInfo() / destroy()); DOCX via
+// mammoth extractRawText. The DOMMatrix polyfill is required by pdf-parse v2
+// (pdfjs) in a bare Node environment and is ported VERBATIM from the reference.
+import { readFile } from "fs/promises";
+import { validatePath } from "../helpers/path.js";
+// Polyfill DOMMatrix for pdf-parse v2 (required for node environment)
+function ensureDomMatrix() {
+    if (typeof global.DOMMatrix === "undefined") {
+        global.DOMMatrix = class DOMMatrix {
+            constructor(arg) {
+                this.a = 1;
+                this.b = 0;
+                this.c = 0;
+                this.d = 1;
+                this.e = 0;
+                this.f = 0;
+                if (Array.isArray(arg)) {
+                    this.a = arg[0];
+                    this.b = arg[1];
+                    this.c = arg[2];
+                    this.d = arg[3];
+                    this.e = arg[4];
+                    this.f = arg[5];
+                }
+            }
+        };
+    }
+}
+export async function handleReadDocument(filePath, allowedDirectories) {
+    const fpath = await validatePath(filePath, allowedDirectories);
+    const ext = fpath.split('.').pop()?.toLowerCase();
+    try {
+        if (ext === 'pdf') {
+            ensureDomMatrix();
+            // Dynamically import pdf-parse v2 (ESM equivalent of the reference's require)
+            const { PDFParse } = await import("pdf-parse");
+            const dataBuffer = await readFile(fpath);
+            // Use new class-based API
+            const parser = new PDFParse({ data: dataBuffer });
+            const textResult = await parser.getText();
+            const infoResult = await parser.getInfo(); // Optional: get metadata
+            await parser.destroy(); // Cleanup
+            return JSON.stringify({ content: textResult.text, metadata: infoResult.info });
+        }
+        else if (ext === 'docx') {
+            const mammoth = await import("mammoth");
+            const result = await mammoth.extractRawText({ path: fpath });
+            return JSON.stringify({ content: result.value, messages: result.messages });
+        }
+        else {
+            return JSON.stringify({ error: "Unsupported document format. Use read_file for text files." });
+        }
+    }
+    catch (e) {
+        return JSON.stringify({ error: `Failed to read document: ${e instanceof Error ? e.message : String(e)}` });
+    }
+}

package/dist/read_document/schema.js

@@ -0,0 +1,4 @@
+import { z } from "zod";
+export const ReadDocumentArgsSchema = z.object({
+    file_path: z.string(),
+});