@llmtune/cli 0.1.0 → 0.1.2

package/dist/tools/tools/edit.js

@@ -0,0 +1,138 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.editTool = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+exports.editTool = {
+    spec() {
+        return {
+            name: "edit",
+            description: "Edit a file by replacing old text with new text. Supports replacing all occurrences.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    file_path: {
+                        type: "string",
+                        description: "Path to the file to edit",
+                    },
+                    old_string: {
+                        type: "string",
+                        description: "The text to find and replace",
+                    },
+                    new_string: {
+                        type: "string",
+                        description: "The replacement text",
+                    },
+                    replace_all: {
+                        type: "boolean",
+                        description: "Replace all occurrences (default: false)",
+                    },
+                },
+                required: ["file_path", "old_string", "new_string"],
+            },
+            isReadOnly: false,
+            isDestructive: true,
+        };
+    },
+    async run(input, ctx) {
+        const filePath = String(input.file_path ?? "");
+        const oldString = String(input.old_string ?? "");
+        const newString = String(input.new_string ?? "");
+        const replaceAll = Boolean(input.replace_all);
+        if (!filePath) {
+            return { name: "edit", output: { error: "file_path is required" }, isError: true };
+        }
+        if (!oldString) {
+            return { name: "edit", output: { error: "old_string is required" }, isError: true };
+        }
+        const resolved = path.resolve(ctx.cwd, filePath);
+        let content;
+        try {
+            content = await fs.readFile(resolved, "utf-8");
+        }
+        catch (err) {
+            return {
+                name: "edit",
+                output: { error: `Failed to read file: ${err.message}` },
+                isError: true,
+            };
+        }
+        if (!content.includes(oldString)) {
+            return {
+                name: "edit",
+                output: {
+                    error: `old_string not found in ${filePath}`,
+                    hint: "Make sure the old_string matches exactly, including whitespace.",
+                },
+                isError: true,
+            };
+        }
+        const occurrences = content.split(oldString).length - 1;
+        if (occurrences > 1 && !replaceAll) {
+            return {
+                name: "edit",
+                output: {
+                    error: `Found ${occurrences} occurrences. Use replace_all: true or provide more specific old_string.`,
+                    occurrences,
+                },
+                isError: true,
+            };
+        }
+        const newContent = replaceAll
+            ? content.split(oldString).join(newString)
+            : content.replace(oldString, newString);
+        try {
+            await fs.writeFile(resolved, newContent, "utf-8");
+        }
+        catch (err) {
+            return {
+                name: "edit",
+                output: { error: `Failed to write file: ${err.message}` },
+                isError: true,
+            };
+        }
+        return {
+            name: "edit",
+            output: {
+                file_path: filePath,
+                replacements: replaceAll ? occurrences : 1,
+                status: "edited",
+            },
+            isError: false,
+        };
+    },
+};
+//# sourceMappingURL=edit.js.map

package/dist/tools/tools/glob.d.ts

@@ -0,0 +1,3 @@
+import type { Tool } from "../protocol";
+export declare const globTool: Tool;
+//# sourceMappingURL=glob.d.ts.map

package/dist/tools/tools/glob.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globTool = void 0;
+const glob_1 = require("glob");
+exports.globTool = {
+    spec() {
+        return {
+            name: "glob",
+            description: "Search for files matching a glob pattern. Returns matching file paths relative to the workspace root.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    pattern: {
+                        type: "string",
+                        description: "Glob pattern (e.g. '**/*.ts', 'src/**/*.py')",
+                    },
+                    path: {
+                        type: "string",
+                        description: "Base directory for the search (default: workspace root)",
+                    },
+                },
+                required: ["pattern"],
+            },
+            isReadOnly: true,
+        };
+    },
+    async run(input, ctx) {
+        const pattern = String(input.pattern ?? "");
+        const baseDir = String(input.path ?? ctx.workspaceRoot);
+        if (!pattern) {
+            return { name: "glob", output: { error: "pattern is required" }, isError: true };
+        }
+        try {
+            const matches = await (0, glob_1.glob)(pattern, {
+                cwd: baseDir,
+                nodir: true,
+                absolute: false,
+                ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/.next/**"],
+            });
+            const truncated = matches.length > 500;
+            const limited = truncated ? matches.slice(0, 500) : matches;
+            return {
+                name: "glob",
+                output: {
+                    pattern,
+                    baseDir,
+                    matches: limited,
+                    numFiles: matches.length,
+                    truncated,
+                },
+                isError: false,
+            };
+        }
+        catch (err) {
+            return {
+                name: "glob",
+                output: { error: String(err.message ?? err) },
+                isError: true,
+            };
+        }
+    },
+};
+//# sourceMappingURL=glob.js.map

package/dist/tools/tools/grep.d.ts

@@ -0,0 +1,3 @@
+import type { Tool } from "../protocol";
+export declare const grepTool: Tool;
+//# sourceMappingURL=grep.d.ts.map

package/dist/tools/tools/grep.js

@@ -0,0 +1,148 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grepTool = void 0;
+const path = __importStar(require("path"));
+exports.grepTool = {
+    spec() {
+        return {
+            name: "grep",
+            description: 'Search for a pattern in files. Returns matching file paths and lines. Supports regex patterns.',
+            inputSchema: {
+                type: "object",
+                properties: {
+                    pattern: {
+                        type: "string",
+                        description: "The pattern to search for (regex supported)",
+                    },
+                    path: {
+                        type: "string",
+                        description: "Directory to search in (default: workspace root)",
+                    },
+                    include: {
+                        type: "string",
+                        description: 'File glob to include (e.g. "*.ts", "*.{js,ts}")',
+                    },
+                    max_results: {
+                        type: "number",
+                        description: "Maximum number of results (default: 50)",
+                    },
+                },
+                required: ["pattern"],
+            },
+            isReadOnly: true,
+        };
+    },
+    run(input, ctx) {
+        const pattern = String(input.pattern ?? "");
+        if (!pattern) {
+            return { name: "grep", output: { error: "pattern is required" }, isError: true };
+        }
+        const searchPath = input.path
+            ? path.resolve(ctx.cwd, String(input.path))
+            : ctx.cwd;
+        const maxResults = typeof input.max_results === "number" ? input.max_results : 50;
+        const include = input.include ? String(input.include) : undefined;
+        try {
+            const isWin = process.platform === "win32";
+            let cmd;
+            if (isWin) {
+                const includeOpt = include ? ` /include:${include.replace(/"/g, "")}` : "";
+                cmd = `findstr /s /n /r ${includeOpt} "${pattern.replace(/"/g, "")}" "${searchPath}\\*"`;
+            }
+            else {
+                const includeOpt = include ? ` --include="${include}"` : "";
+                cmd = `grep -r -n -E${includeOpt} "${pattern.replace(/"/g, "")}" "${searchPath}" 2>/dev/null | head -${maxResults}`;
+            }
+            const result = execSync(cmd, { maxBuffer: 1024 * 1024, timeout: 30000 });
+            const output = result.toString().trim();
+            const lines = output.split("\n").filter(Boolean);
+            const matches = lines.slice(0, maxResults).map((line) => {
+                const colonIdx = line.indexOf(":");
+                if (colonIdx === -1)
+                    return { file: "", line: 0, text: line };
+                const fileAndLine = line.slice(0, colonIdx);
+                const lastColon = fileAndLine.lastIndexOf(":");
+                if (lastColon === -1) {
+                    return { file: fileAndLine, line: 0, text: line.slice(colonIdx + 1) };
+                }
+                return {
+                    file: fileAndLine.slice(0, lastColon),
+                    line: parseInt(fileAndLine.slice(lastColon + 1), 10) || 0,
+                    text: line.slice(colonIdx + 1),
+                };
+            });
+            const files = [...new Set(matches.map((m) => m.file))];
+            return {
+                name: "grep",
+                output: {
+                    pattern,
+                    path: searchPath,
+                    matches: matches,
+                    numFiles: files.length,
+                    numMatches: matches.length,
+                    truncated: matches.length >= maxResults,
+                },
+                isError: false,
+            };
+        }
+        catch (err) {
+            if (err.status === 1 || err.status === 2) {
+                return {
+                    name: "grep",
+                    output: {
+                        pattern,
+                        path: searchPath,
+                        matches: [],
+                        numFiles: 0,
+                        numMatches: 0,
+                        truncated: false,
+                    },
+                    isError: false,
+                };
+            }
+            return {
+                name: "grep",
+                output: { error: `grep failed: ${err.message}` },
+                isError: true,
+            };
+        }
+    },
+};
+function execSync(cmd, opts) {
+    const { execSync: _execSync } = require("child_process");
+    return _execSync(cmd, opts);
+}
+//# sourceMappingURL=grep.js.map

package/dist/tools/tools/read.d.ts

@@ -0,0 +1,3 @@
+import type { Tool } from "../protocol";
+export declare const readTool: Tool;
+//# sourceMappingURL=read.d.ts.map

package/dist/tools/tools/read.js

@@ -0,0 +1,85 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readTool = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+exports.readTool = {
+    spec() {
+        return {
+            name: "read",
+            description: "Read the contents of a file. Returns the file content with line numbers. Supports offset and limit for partial reads.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    file_path: { type: "string", description: "Path to the file to read" },
+                    offset: { type: "number", description: "Line number to start reading from (1-based)" },
+                    limit: { type: "number", description: "Maximum number of lines to read" },
+                },
+                required: ["file_path"],
+            },
+            isReadOnly: true,
+        };
+    },
+    run(input, ctx) {
+        const filePath = path.resolve(ctx.cwd, String(input.file_path ?? ""));
+        if (!filePath.startsWith(ctx.cwd)) {
+            return { name: "read", output: { error: "Path is outside the workspace" }, isError: true };
+        }
+        if (!fs.existsSync(filePath)) {
+            return { name: "read", output: { error: `File not found: ${input.file_path}` }, isError: true };
+        }
+        const stat = fs.statSync(filePath);
+        if (stat.isDirectory()) {
+            return { name: "read", output: { error: `Path is a directory: ${input.file_path}` }, isError: true };
+        }
+        if (stat.size > 1_000_000) {
+            return { name: "read", output: { error: `File too large (${(stat.size / 1024).toFixed(0)}KB). Use offset/limit.` }, isError: true };
+        }
+        const raw = fs.readFileSync(filePath, "utf-8");
+        const lines = raw.split("\n");
+        const totalLines = lines.length;
+        const offset = typeof input.offset === "number" ? Math.max(1, input.offset) : 1;
+        const limit = typeof input.limit === "number" ? input.limit : Math.min(totalLines - offset + 1, 2000);
+        const sliced = lines.slice(offset - 1, offset - 1 + limit);
+        const numbered = sliced.map((line, i) => `${String(offset + i).padStart(6)}|${line}`).join("\n");
+        return {
+            name: "read",
+            output: { type: "text", file: { filePath: String(input.file_path), startLine: offset, numLines: sliced.length, totalLines }, content: numbered },
+            isError: false,
+        };
+    },
+};
+//# sourceMappingURL=read.js.map

package/dist/tools/tools/web-fetch.d.ts

@@ -0,0 +1,3 @@
+import type { Tool } from "../protocol";
+export declare const webFetchTool: Tool;
+//# sourceMappingURL=web-fetch.d.ts.map

package/dist/tools/tools/web-fetch.js

@@ -0,0 +1,143 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webFetchTool = void 0;
+const https_1 = __importDefault(require("https"));
+const http_1 = __importDefault(require("http"));
+const version_1 = require("../../version");
+const MAX_RESPONSE_SIZE = 500_000;
+const TIMEOUT_MS = 30_000;
+exports.webFetchTool = {
+    spec() {
+        return {
+            name: "web-fetch",
+            description: "Fetch content from a URL. Returns the response body as text. Supports HTTP and HTTPS. Use for reading web pages, API responses, or documentation.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    url: {
+                        type: "string",
+                        description: "The URL to fetch (http:// or https://)",
+                    },
+                    method: {
+                        type: "string",
+                        description: "HTTP method (default: GET)",
+                    },
+                    headers: {
+                        type: "object",
+                        description: "Optional request headers as key-value pairs",
+                    },
+                },
+                required: ["url"],
+            },
+            isReadOnly: true,
+        };
+    },
+    run(input, _ctx) {
+        const url = String(input.url ?? "");
+        const method = String(input.method ?? "GET").toUpperCase();
+        const headers = input.headers ?? {};
+        if (!url) {
+            return Promise.resolve({
+                name: "web-fetch",
+                output: { error: "url is required" },
+                isError: true,
+            });
+        }
+        let parsedUrl;
+        try {
+            parsedUrl = new URL(url);
+        }
+        catch {
+            return Promise.resolve({
+                name: "web-fetch",
+                output: { error: `Invalid URL: ${url}` },
+                isError: true,
+            });
+        }
+        if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
+            return Promise.resolve({
+                name: "web-fetch",
+                output: { error: `Unsupported protocol: ${parsedUrl.protocol}. Use http:// or https://` },
+                isError: true,
+            });
+        }
+        return new Promise((resolve) => {
+            const lib = parsedUrl.protocol === "https:" ? https_1.default : http_1.default;
+            const req = lib.request(url, {
+                method,
+                headers: {
+                    "User-Agent": `LLMTune-CLI/${version_1.CLI_VERSION}`,
+                    Accept: "text/html,application/json,text/plain,*/*",
+                    ...headers,
+                },
+                timeout: TIMEOUT_MS,
+            }, (res) => {
+                // Follow redirects (up to 5)
+                if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                    const redirectUrl = new URL(res.headers.location, url).toString();
+                    return Promise.resolve(exports.webFetchTool.run({ ...input, url: redirectUrl }, _ctx)).then(resolve);
+                }
+                const chunks = [];
+                let size = 0;
+                res.on("data", (chunk) => {
+                    size += chunk.length;
+                    if (size > MAX_RESPONSE_SIZE) {
+                        req.destroy();
+                        resolve({
+                            name: "web-fetch",
+                            output: {
+                                error: `Response too large (${(size / 1024).toFixed(0)}KB). Maximum is ${MAX_RESPONSE_SIZE / 1024}KB.`,
+                            },
+                            isError: true,
+                        });
+                        return;
+                    }
+                    chunks.push(chunk);
+                });
+                res.on("end", () => {
+                    const body = Buffer.concat(chunks).toString("utf-8");
+                    const truncated = body.length > 50_000;
+                    const content = truncated ? body.slice(0, 50_000) + "\n... (truncated)" : body;
+                    resolve({
+                        name: "web-fetch",
+                        output: {
+                            url,
+                            status: res.statusCode ?? 0,
+                            contentType: res.headers["content-type"] ?? "unknown",
+                            content,
+                            truncated,
+                        },
+                        isError: false,
+                    });
+                });
+                res.on("error", (err) => {
+                    resolve({
+                        name: "web-fetch",
+                        output: { error: `Response error: ${err.message}` },
+                        isError: true,
+                    });
+                });
+            });
+            req.on("error", (err) => {
+                resolve({
+                    name: "web-fetch",
+                    output: { error: `Request failed: ${err.message}` },
+                    isError: true,
+                });
+            });
+            req.on("timeout", () => {
+                req.destroy();
+                resolve({
+                    name: "web-fetch",
+                    output: { error: `Request timed out after ${TIMEOUT_MS / 1000}s` },
+                    isError: true,
+                });
+            });
+            req.end();
+        });
+    },
+};
+//# sourceMappingURL=web-fetch.js.map

package/dist/tools/tools/write.d.ts

@@ -0,0 +1,3 @@
+import type { Tool } from "../protocol";
+export declare const writeTool: Tool;
+//# sourceMappingURL=write.d.ts.map