@sean.holung/minicode 0.1.1 → 0.2.1

package/dist/src/tools/search.js

@@ -1,153 +0,0 @@
-import { spawn } from "node:child_process";
-import path from "node:path";
-import { resolveWorkspacePath } from "../safety/guardrails.js";
-import { expectNonEmptyString } from "./helpers.js";
-function runCommand(command, args, cwd, timeoutMs) {
-    return new Promise((resolve, reject) => {
-        const child = spawn(command, args, { cwd });
-        let stdout = "";
-        let stderr = "";
-        let timedOut = false;
-        const timeout = setTimeout(() => {
-            timedOut = true;
-            child.kill("SIGTERM");
-        }, timeoutMs);
-        child.stdout.on("data", (chunk) => {
-            stdout += chunk.toString();
-        });
-        child.stderr.on("data", (chunk) => {
-            stderr += chunk.toString();
-        });
-        child.on("error", (error) => {
-            clearTimeout(timeout);
-            reject(error);
-        });
-        child.on("close", (code) => {
-            clearTimeout(timeout);
-            if (timedOut) {
-                reject(new Error(`Search command timed out after ${timeoutMs} ms.`));
-                return;
-            }
-            resolve({
-                stdout,
-                stderr,
-                code,
-            });
-        });
-    });
-}
-function getOptionalString(input, key) {
-    const value = input[key];
-    if (value === undefined) {
-        return undefined;
-    }
-    if (typeof value !== "string" || value.trim().length === 0) {
-        throw new Error(`Input "${key}" must be a non-empty string.`);
-    }
-    return value;
-}
-export function createSearchTool(config) {
-    return {
-        name: "search",
-        description: "Search file contents using ripgrep. Use when you don't know the symbol name. When results show a function/class name, use read_symbol next (not read_file).",
-        inputSchema: {
-            type: "object",
-            properties: {
-                pattern: {
-                    type: "string",
-                    description: "Regex pattern to search for.",
-                },
-                path: {
-                    type: "string",
-                    description: "Optional path to search under, relative to workspace root.",
-                },
-                include: {
-                    type: "string",
-                    description: "Optional glob include filter, e.g. *.ts",
-                },
-            },
-            required: ["pattern"],
-            additionalProperties: false,
-        },
-        execute: async (input) => {
-            const maxOutputChars = 12_000;
-            const pattern = expectNonEmptyString(input, "pattern");
-            const requestedPath = getOptionalString(input, "path") ?? ".";
-            const include = getOptionalString(input, "include");
-            const targetPath = resolveWorkspacePath(requestedPath, config.workspaceRoot);
-            const relativeTarget = path.relative(config.workspaceRoot, targetPath) || ".";
-            const rgArgs = [
-                "--line-number",
-                "--color",
-                "never",
-                "--no-heading",
-                "--binary-files",
-                "without-match",
-                "--glob",
-                "!.minicode/**",
-                "--glob",
-                "!node_modules/**",
-                "--glob",
-                "!package-lock.json",
-                "--glob",
-                "!yarn.lock",
-                "--glob",
-                "!pnpm-lock.yaml",
-                "--glob",
-                "!*.min.js",
-                "-m",
-                "50",
-            ];
-            if (include) {
-                rgArgs.push("--glob", include);
-            }
-            rgArgs.push(pattern, relativeTarget);
-            try {
-                const result = await runCommand("rg", rgArgs, config.workspaceRoot, config.commandTimeoutMs);
-                if (result.code === 1 || result.stdout.trim().length === 0) {
-                    return "No matches found.";
-                }
-                if (result.code !== 0) {
-                    throw new Error(result.stderr || "ripgrep search failed.");
-                }
-                const output = result.stdout.trimEnd();
-                if (output.length > maxOutputChars) {
-                    return `${output.slice(0, maxOutputChars)}\n\n[... output truncated, ${output.length - maxOutputChars} more chars ...]`;
-                }
-                return output;
-            }
-            catch (error) {
-                const commandError = error;
-                if (commandError.code !== "ENOENT") {
-                    throw error;
-                }
-            }
-            // Minimal fallback for systems without rg installed.
-            const grepArgs = [
-                "-RIn",
-                "--exclude-dir=.minicode",
-                "--exclude-dir=node_modules",
-                "--exclude-dir=.git",
-                "--exclude=package-lock.json",
-                "--exclude=yarn.lock",
-                "--exclude=pnpm-lock.yaml",
-                "-m",
-                "50",
-                pattern,
-                relativeTarget,
-            ];
-            const fallbackResult = await runCommand("grep", grepArgs, config.workspaceRoot, config.commandTimeoutMs);
-            if (fallbackResult.code === 1 || fallbackResult.stdout.trim().length === 0) {
-                return "No matches found.";
-            }
-            if (fallbackResult.code !== 0) {
-                throw new Error(fallbackResult.stderr || "grep search failed.");
-            }
-            const fallbackOutput = fallbackResult.stdout.trimEnd();
-            if (fallbackOutput.length > maxOutputChars) {
-                return `${fallbackOutput.slice(0, maxOutputChars)}\n\n[... output truncated, ${fallbackOutput.length - maxOutputChars} more chars ...]`;
-            }
-            return fallbackOutput;
-        },
-    };
-}

package/dist/src/tools/write-file.js

@@ -1,44 +0,0 @@
-import { mkdir, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { resolveWorkspacePath } from "../safety/guardrails.js";
-import { expectNonEmptyString } from "./helpers.js";
-function expectString(input, key) {
-    const value = input[key];
-    if (typeof value !== "string") {
-        throw new Error(`Input "${key}" must be a string.`);
-    }
-    return value;
-}
-export function createWriteFileTool(config, projectIndex) {
-    return {
-        name: "write_file",
-        description: "Create or overwrite a file with the provided content.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                path: {
-                    type: "string",
-                    description: "Path to the file relative to workspace root.",
-                },
-                content: {
-                    type: "string",
-                    description: "The full file content to write.",
-                },
-            },
-            required: ["path", "content"],
-            additionalProperties: false,
-        },
-        execute: async (input) => {
-            const requestedPath = expectNonEmptyString(input, "path");
-            const content = expectString(input, "content");
-            const filePath = resolveWorkspacePath(requestedPath, config.workspaceRoot);
-            await mkdir(path.dirname(filePath), { recursive: true });
-            await writeFile(filePath, content, "utf8");
-            if (projectIndex) {
-                const relPath = path.relative(config.workspaceRoot, filePath);
-                projectIndex.reindexFile(relPath, content);
-            }
-            return `Wrote ${content.length} characters to "${requestedPath}".`;
-        },
-    };
-}