@llmtune/cli 0.1.0 → 0.1.1

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,
-    }
-  },
-}

package/src/tools/tools/web-fetch.ts

@@ -1,158 +0,0 @@
-import https from "https"
-import http from "http"
-import type { Tool, ToolSpec, ToolResult, ToolContext } from "../protocol"
-
-const MAX_RESPONSE_SIZE = 500_000
-const TIMEOUT_MS = 30_000
-
-export const webFetchTool: Tool = {
-  spec(): ToolSpec {
-    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: Record<string, unknown>, _ctx: ToolContext): Promise<ToolResult> {
-    const url = String(input.url ?? "")
-    const method = String(input.method ?? "GET").toUpperCase()
-    const headers = (input.headers as Record<string, string>) ?? {}
-
-    if (!url) {
-      return Promise.resolve({
-        name: "web-fetch",
-        output: { error: "url is required" },
-        isError: true,
-      })
-    }
-
-    let parsedUrl: URL
-    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 : http
-
-      const req = lib.request(
-        url,
-        {
-          method,
-          headers: {
-            "User-Agent": "LLMTune-CLI/0.1.0",
-            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(
-              webFetchTool.run({ ...input, url: redirectUrl }, _ctx),
-            ).then(resolve)
-          }
-
-          const chunks: Buffer[] = []
-          let size = 0
-
-          res.on("data", (chunk: Buffer) => {
-            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()
-    })
-  },
-}

package/src/tools/tools/write.ts

@@ -1,52 +0,0 @@
-import * as fs from "fs"
-import * as path from "path"
-import type { Tool, ToolSpec, ToolResult, ToolContext } from "../protocol"
-
-export const writeTool: Tool = {
-  spec(): ToolSpec {
-    return {
-      name: "write",
-      description:
-        "Create or overwrite a file with the given content. Path is relative to workspace root.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          file_path: { type: "string", description: "Path to write (relative to workspace)" },
-          content: { type: "string", description: "Content to write" },
-          create_dirs: { type: "boolean", description: "Create parent dirs (default: true)" },
-        },
-        required: ["file_path", "content"],
-      },
-      isDestructive: true,
-    }
-  },
-
-  run(input: Record<string, unknown>, ctx: ToolContext): ToolResult {
-    const filePath = String(input.file_path ?? "")
-    const content = String(input.content ?? "")
-    const createDirs = input.create_dirs !== false
-    const absPath = path.resolve(ctx.cwd, filePath)
-
-    if (!absPath.startsWith(path.resolve(ctx.cwd))) {
-      return { name: "write", output: { error: "Cannot write outside workspace" }, isError: true }
-    }
-
-    try {
-      if (createDirs) {
-        fs.mkdirSync(path.dirname(absPath), { recursive: true })
-      }
-      fs.writeFileSync(absPath, content, "utf-8")
-      return {
-        name: "write",
-        output: { type: "file_written", filePath, bytesWritten: Buffer.byteLength(content) },
-        isError: false,
-      }
-    } catch (err: unknown) {
-      return {
-        name: "write",
-        output: { error: `Write failed: ${(err as Error).message}` },
-        isError: true,
-      }
-    }
-  },
-}

package/src/tools/validation.ts

@@ -1,164 +0,0 @@
-/**
- * JSON Schema validation for tool inputs.
- * Ported from Clawd-Code's schema_validation.py.
- */
-
-export interface ValidationIssue {
-  path: string
-  message: string
-}
-
-function typeName(value: unknown): string {
-  if (value === null) return "null"
-  if (typeof value === "boolean") return "boolean"
-  if (typeof value === "number") {
-    if (Number.isInteger(value)) return "integer"
-    return "number"
-  }
-  if (typeof value === "string") return "string"
-  if (Array.isArray(value)) return "array"
-  if (typeof value === "object") return "object"
-  return typeof value
-}
-
-export class ToolInputError extends Error {
-  constructor(message: string) {
-    super(message)
-    this.name = "ToolInputError"
-  }
-}
-
-export function validateJsonSchema(
-  value: unknown,
-  schema: Record<string, unknown>,
-  rootName = "input"
-): void {
-  const issues: ValidationIssue[] = []
-  validateNode(value, schema, rootName, issues)
-  if (issues.length > 0) {
-    const rendered = issues
-      .slice(0, 5)
-      .map((i) => `${i.path}: ${i.message}`)
-      .join("; ")
-    const suffix = issues.length > 5 ? `; (+${issues.length - 5} more)` : ""
-    throw new ToolInputError(rendered + suffix)
-  }
-}
-
-function validateNode(
-  value: unknown,
-  schema: Record<string, unknown>,
-  path: string,
-  issues: ValidationIssue[]
-): void {
-  if ("oneOf" in schema) {
-    const options = (schema.oneOf as Record<string, unknown>[]) || []
-    if (options.some((opt) => isValid(value, opt))) return
-    issues.push({ path, message: "does not match any allowed schema (oneOf)" })
-    return
-  }
-
-  if ("anyOf" in schema) {
-    const options = (schema.anyOf as Record<string, unknown>[]) || []
-    if (options.some((opt) => isValid(value, opt))) return
-    issues.push({ path, message: "does not match any allowed schema (anyOf)" })
-    return
-  }
-
-  const expectedType = schema.type as string | undefined
-
-  if (expectedType === "object") {
-    if (typeof value !== "object" || value === null || Array.isArray(value)) {
-      issues.push({ path, message: `expected object, got ${typeName(value)}` })
-      return
-    }
-    validateObject(value as Record<string, unknown>, schema, path, issues)
-    return
-  }
-
-  if (expectedType === "array") {
-    if (!Array.isArray(value)) {
-      issues.push({ path, message: `expected array, got ${typeName(value)}` })
-      return
-    }
-    const itemSchema = schema.items as Record<string, unknown> | undefined
-    if (itemSchema) {
-      value.forEach((item, idx) => {
-        validateNode(item, itemSchema, `${path}[${idx}]`, issues)
-      })
-    }
-    return
-  }
-
-  if (expectedType === "string") {
-    if (typeof value !== "string") {
-      issues.push({ path, message: `expected string, got ${typeName(value)}` })
-    }
-    return
-  }
-
-  if (expectedType === "boolean") {
-    if (typeof value !== "boolean") {
-      issues.push({ path, message: `expected boolean, got ${typeName(value)}` })
-    }
-    return
-  }
-
-  if (expectedType === "number") {
-    if (typeof value !== "number") {
-      issues.push({ path, message: `expected number, got ${typeName(value)}` })
-    }
-    return
-  }
-
-  if (expectedType === "integer") {
-    if (typeof value !== "number" || !Number.isInteger(value)) {
-      issues.push({ path, message: `expected integer, got ${typeName(value)}` })
-    }
-    return
-  }
-
-  if ("enum" in schema) {
-    const allowed = (schema.enum as unknown[]) || []
-    if (!allowed.includes(value)) {
-      issues.push({
-        path,
-        message: `expected one of ${JSON.stringify(allowed)}, got ${JSON.stringify(value)}`,
-      })
-    }
-  }
-}
-
-function validateObject(
-  value: Record<string, unknown>,
-  schema: Record<string, unknown>,
-  path: string,
-  issues: ValidationIssue[]
-): void {
-  const required = new Set((schema.required as string[]) || [])
-  const properties = (schema.properties as Record<string, Record<string, unknown>>) || {}
-  const additional = schema.additionalProperties !== false
-
-  for (const req of required) {
-    if (!(req in value)) {
-      issues.push({ path, message: `missing required field '${req}'` })
-    }
-  }
-
-  for (const [key, val] of Object.entries(value)) {
-    const propSchema = properties[key]
-    if (!propSchema) {
-      if (!additional) {
-        issues.push({ path: `${path}.${key}`, message: "unexpected field" })
-      }
-      continue
-    }
-    validateNode(val, propSchema, `${path}.${key}`, issues)
-  }
-}
-
-function isValid(value: unknown, schema: Record<string, unknown>): boolean {
-  const issues: ValidationIssue[] = []
-  validateNode(value, schema, "$", issues)
-  return issues.length === 0
-}

package/src/utils/markdown.ts

@@ -1,96 +0,0 @@
-/**
- * Terminal markdown renderer.
- * Converts markdown text to chalk-formatted terminal output.
- */
-import chalk from "chalk"
-
-interface RenderOptions {
-  maxWidth?: number
-  indent?: string
-}
-
-export function renderMarkdown(text: string, options?: RenderOptions): string {
-  const lines = text.split("\n")
-  const result: string[] = []
-
-  for (const line of lines) {
-    result.push(renderLine(line, options))
-  }
-
-  return result.join("\n")
-}
-
-function renderLine(line: string, options?: RenderOptions): string {
-  const trimmed = line.trimStart()
-
-  // Headings
-  if (trimmed.startsWith("###### ")) return chalk.bold.cyan(trimmed.slice(7))
-  if (trimmed.startsWith("##### "))  return chalk.bold.cyan(trimmed.slice(6))
-  if (trimmed.startsWith("#### "))   return chalk.bold.cyan(trimmed.slice(5))
-  if (trimmed.startsWith("### "))    return chalk.bold.cyan(trimmed.slice(4))
-  if (trimmed.startsWith("## "))     return chalk.bold.blue(trimmed.slice(3))
-  if (trimmed.startsWith("# "))      return chalk.bold.white(trimmed.slice(2))
-
-  // Code blocks
-  if (trimmed.startsWith("```")) {
-    return chalk.dim(trimmed)
-  }
-
-  // Blockquotes
-  if (trimmed.startsWith("> ")) {
-    return chalk.dim("│ " + renderInline(trimmed.slice(2)))
-  }
-
-  // Lists
-  if (/^[-*+]\s/.test(trimmed)) {
-    return chalk.cyan("•") + " " + renderInline(trimmed.slice(2))
-  }
-  if (/^\d+\.\s/.test(trimmed)) {
-    const match = trimmed.match(/^(\d+\.)\s(.*)$/)
-    if (match) return chalk.cyan(match[1]) + " " + renderInline(match[2])
-  }
-
-  // Horizontal rule
-  if (/^[-*_]{3,}\s*$/.test(trimmed)) {
-    return chalk.dim("─".repeat(options?.maxWidth ?? 60))
-  }
-
-  return renderInline(line)
-}
-
-function renderInline(text: string): string {
-  // Bold
-  text = text.replace(/\*\*(.+?)\*\*/g, (_, content) => chalk.bold(content))
-  // Italic
-  text = text.replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, (_, content) => chalk.italic(content))
-  // Inline code
-  text = text.replace(/`([^`]+)`/g, (_, content) => chalk.bgBlackBright(content))
-  // Links
-  text = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, label, url) => chalk.blue.underline(label) + chalk.dim(` (${url})`))
-
-  return text
-}
-
-export function renderCodeBlock(code: string, language?: string): string {
-  const header = language ? chalk.dim(`─ ${language} ─`) : ""
-  const lines = code.split("\n").map((line, i) => {
-    const num = String(i + 1).padStart(4)
-    return chalk.dim(`${num} │`) + ` ${line}`
-  })
-  return header + (header ? "\n" : "") + lines.join("\n")
-}
-
-export function renderTable(headers: string[], rows: string[][]): string {
-  const colWidths = headers.map((h, i) => {
-    const maxDataLen = Math.max(...rows.map((r) => (r[i] ?? "").length))
-    return Math.max(h.length, maxDataLen) + 2
-  })
-
-  const headerLine = headers.map((h, i) => chalk.bold(h.padEnd(colWidths[i]))).join("")
-  const separator = colWidths.map((w) => chalk.dim("─".repeat(w))).join(chalk.dim("─"))
-  const dataLines = rows.map((row) =>
-    row.map((cell, i) => (cell ?? "").padEnd(colWidths[i])).join(""),
-  )
-
-  return [headerLine, separator, ...dataLines].join("\n")
-}