@llmtune/cli 0.1.0 → 0.1.2

package/src/tools/sandbox/index.ts

@@ -1,91 +0,0 @@
-/**
- * Sandbox manager: decides when to use Docker isolation vs local execution.
- *
- * Modes:
- * - "off"       — all tools run locally (default)
- * - "available" — use Docker when available, fall back to local
- * - "required"  — require Docker for destructive tools (enterprise mode)
- */
-import type { ToolResult } from "../protocol"
-import { runInSandbox } from "./docker"
-
-export type SandboxMode = "off" | "available" | "required"
-
-let sandboxMode: SandboxMode = "off"
-let dockerAvailable: boolean | null = null
-
-export function getSandboxMode(): SandboxMode {
-  return sandboxMode
-}
-
-export function setSandboxMode(mode: SandboxMode): void {
-  sandboxMode = mode
-  dockerAvailable = null // re-check on next use
-}
-
-export function isDockerAvailable(): boolean {
-  if (dockerAvailable !== null) return dockerAvailable
-  // Quick check: can we run `docker info`?
-  try {
-    const { execSync } = require("child_process") as typeof import("child_process")
-    execSync("docker info", { timeout: 3000, stdio: "pipe" })
-    dockerAvailable = true
-  } catch {
-    dockerAvailable = false
-  }
-  return dockerAvailable
-}
-
-/**
- * Execute a bash command, optionally in a Docker sandbox.
- */
-export async function sandboxedExec(
-  command: string,
-  cwd: string,
-  timeout: number,
-): Promise<ToolResult> {
-  if (sandboxMode === "off") {
-    return localExec(command, cwd, timeout)
-  }
-
-  if (sandboxMode === "available" && !isDockerAvailable()) {
-    return localExec(command, cwd, timeout)
-  }
-
-  if (sandboxMode === "required" && !isDockerAvailable()) {
-    return {
-      name: "bash",
-      output: {
-        error: "Enterprise mode requires Docker but Docker is not available. Install Docker or disable enterprise mode.",
-      },
-      isError: true,
-    }
-  }
-
-  return runInSandbox(command, cwd)
-}
-
-function localExec(command: string, cwd: string, timeout: number): ToolResult {
-  const { execSync } = require("child_process") as typeof import("child_process")
-  try {
-    const stdout = execSync(command, {
-      cwd,
-      timeout,
-      maxBuffer: 1024 * 1024 * 10,
-      encoding: "utf-8",
-      shell: process.platform === "win32" ? "cmd.exe" : "/bin/bash",
-    })
-    return { name: "bash", output: { stdout: stdout || "(no output)", exitCode: 0 }, isError: false }
-  } catch (err: unknown) {
-    const e = err as { stdout?: string; stderr?: string; status?: number; killed?: boolean }
-    let output = ""
-    if (e.stdout) output += String(e.stdout).slice(0, 50_000)
-    if (e.stderr) output += "\n--- stderr ---\n" + String(e.stderr).slice(0, 50_000)
-    if (e.killed) output += `\n--- Process timed out after ${timeout}ms ---`
-    return {
-      name: "bash",
-      output: { stdout: output.trim(), exitCode: e.status ?? 1 },
-      isError: true,
-    }
-  }
-}

package/src/tools/tools/ask-user.ts

@@ -1,60 +0,0 @@
-import { createInterface } from "readline"
-import type { Tool, ToolSpec, ToolResult, ToolContext } from "../protocol"
-
-export const askUserTool: Tool = {
-  spec(): ToolSpec {
-    return {
-      name: "ask_user",
-      description:
-        "Ask the user a question and wait for their response. Use when you need clarification, confirmation, or additional information before proceeding.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          question: {
-            type: "string",
-            description: "The question to ask the user",
-          },
-          options: {
-            type: "array",
-            items: { type: "string" },
-            description: "Optional list of choices for the user to pick from",
-          },
-        },
-        required: ["question"],
-      },
-      isReadOnly: true,
-    }
-  },
-
-  async run(input: Record<string, unknown>, _ctx: ToolContext): Promise<ToolResult> {
-    const question = String(input.question ?? "")
-    if (!question) {
-      return { name: "ask_user", output: { error: "question is required" }, isError: true }
-    }
-
-    const options = Array.isArray(input.options) ? input.options.map(String) : []
-
-    if (options.length > 0) {
-      console.log(`\n  ${question}`)
-      options.forEach((opt, i) => console.log(`    ${i + 1}. ${opt}`))
-      console.log()
-    } else {
-      console.log(`\n  ${question}\n`)
-    }
-
-    const rl = createInterface({ input: process.stdin, output: process.stdout })
-
-    const answer = await new Promise<string>((resolve) => {
-      rl.question("  > ", (ans) => {
-        rl.close()
-        resolve(ans.trim())
-      })
-    })
-
-    return {
-      name: "ask_user",
-      output: { question, answer, selectedOption: options.length > 0 ? parseInt(answer) || 0 : undefined },
-      isError: false,
-    }
-  },
-}

package/src/tools/tools/bash.ts

@@ -1,97 +0,0 @@
-import { exec } from "child_process"
-import { promisify } from "util"
-import type { Tool, ToolSpec, ToolResult, ToolContext } from "../protocol"
-
-const execAsync = promisify(exec)
-
-const MAX_OUTPUT = 50_000
-const TIMEOUT_MS = 120_000
-
-export const bashTool: Tool = {
-  spec(): ToolSpec {
-    return {
-      name: "bash",
-      description:
-        "Execute a shell command. Returns stdout, stderr, and exit code. Use for running builds, tests, git commands, and other shell operations.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          command: {
-            type: "string",
-            description: "The command to execute",
-          },
-          timeout: {
-            type: "number",
-            description: "Optional timeout in ms (default 120000, max 300000)",
-          },
-        },
-        required: ["command"],
-      },
-      isReadOnly: false,
-      isDestructive: true,
-    }
-  },
-
-  async run(
-    input: Record<string, unknown>,
-    _ctx: ToolContext
-  ): Promise<ToolResult> {
-    const command = String(input.command ?? "")
-    const timeout = Math.min(
-      typeof input.timeout === "number" ? input.timeout : TIMEOUT_MS,
-      300_000
-    )
-
-    if (!command.trim()) {
-      return { name: "bash", output: { error: "command is required" }, isError: true }
-    }
-
-    try {
-      const { stdout, stderr } = await execAsync(command, {
-        maxBuffer: 1024 * 1024 * 10,
-        timeout,
-        shell: process.platform === "win32" ? "cmd" : "/bin/bash",
-      })
-
-      let output = ""
-      if (stdout) {
-        output += stdout.length > MAX_OUTPUT
-          ? stdout.slice(0, MAX_OUTPUT) + "\n... (truncated)"
-          : stdout
-      }
-      if (stderr) {
-        output += "\n--- stderr ---\n"
-        output += stderr.length > MAX_OUTPUT
-          ? stderr.slice(0, MAX_OUTPUT) + "\n... (truncated)"
-          : stderr
-      }
-
-      return {
-        name: "bash",
-        output: { stdout: output.trim(), exit_code: 0 },
-        isError: false,
-      }
-    } catch (err: unknown) {
-      const e = err as { stdout?: string; stderr?: string; code?: number | string; killed?: boolean }
-      const stdout = e.stdout || ""
-      const stderr = e.stderr || ""
-      const exitCode = typeof e.code === "number" ? e.code : 1
-
-      let output = ""
-      if (stdout) output += stdout.slice(0, MAX_OUTPUT)
-      if (stderr) {
-        output += "\n--- stderr ---\n"
-        output += stderr.slice(0, MAX_OUTPUT)
-      }
-      if (e.killed) {
-        output += `\n--- Process timed out after ${timeout}ms ---`
-      }
-
-      return {
-        name: "bash",
-        output: { stdout: output.trim(), exit_code: exitCode },
-        isError: true,
-      }
-    }
-  },
-}

package/src/tools/tools/edit.ts

@@ -1,111 +0,0 @@
-import * as fs from "fs/promises"
-import * as path from "path"
-import type { Tool, ToolResult, ToolContext } from "../protocol"
-
-export const editTool: Tool = {
-  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: Record<string, unknown>, ctx: ToolContext): Promise<ToolResult> {
-    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: string
-    try {
-      content = await fs.readFile(resolved, "utf-8")
-    } catch (err: unknown) {
-      return {
-        name: "edit",
-        output: { error: `Failed to read file: ${(err as Error).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: unknown) {
-      return {
-        name: "edit",
-        output: { error: `Failed to write file: ${(err as Error).message}` },
-        isError: true,
-      }
-    }
-
-    return {
-      name: "edit",
-      output: {
-        file_path: filePath,
-        replacements: replaceAll ? occurrences : 1,
-        status: "edited",
-      },
-      isError: false,
-    }
-  },
-}

package/src/tools/tools/glob.ts

@@ -1,68 +0,0 @@
-import * as fs from "fs"
-import * as path from "path"
-import { glob } from "glob"
-import type { Tool, ToolSpec, ToolResult, ToolContext } from "../protocol"
-
-export const globTool: Tool = {
-  spec(): ToolSpec {
-    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: Record<string, unknown>, ctx: ToolContext): Promise<ToolResult> {
-    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 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: unknown) {
-      return {
-        name: "glob",
-        output: { error: String((err as Error).message ?? err) },
-        isError: true,
-      }
-    }
-  },
-}

package/src/tools/tools/grep.ts

@@ -1,121 +0,0 @@
-import { exec } from "child_process"
-import * as path from "path"
-import type { Tool, ToolSpec, ToolResult, ToolContext } from "../protocol"
-
-export const grepTool: Tool = {
-  spec(): ToolSpec {
-    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: Record<string, unknown>, ctx: ToolContext): ToolResult {
-    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: string
-      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: any) {
-      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: string, opts: { maxBuffer: number; timeout: number }): Buffer {
-  const { execSync: _execSync } = require("child_process")
-  return _execSync(cmd, opts)
-}

package/src/tools/tools/read.ts

@@ -1,57 +0,0 @@
-import * as fs from "fs"
-import * as path from "path"
-import type { Tool, ToolSpec, ToolResult, ToolContext } from "../protocol"
-
-export const readTool: Tool = {
-  spec(): ToolSpec {
-    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: Record<string, unknown>, ctx: ToolContext): ToolResult {
-    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,
-    }
-  },
-}