@llmtune/cli 0.1.0 → 0.1.2

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")
-}

package/src/utils/streaming.ts

@@ -1,63 +0,0 @@
-import { Ora } from "ora"
-
-export function createStreamingDisplay() {
-  let buffer = ""
-  let lastUpdateTime = 0
-  const UPDATE_INTERVAL_MS = 50
-
-  return {
-    onToken(token: string): void {
-      buffer += token
-      const now = Date.now()
-      if (now - lastUpdateTime > UPDATE_INTERVAL_MS) {
-        process.stdout.write(token)
-        lastUpdateTime = now
-      }
-    },
-    flush(): void {
-      if (buffer) {
-        process.stdout.write("\n")
-        buffer = ""
-      }
-    },
-    getBuffer(): string {
-      return buffer
-    },
-  }
-}
-
-export function showSpinner(text: string): Ora {
-  const ora = require("ora")
-  return ora({ text, color: "cyan" }).start()
-}
-
-export function formatToolCall(name: string, input: Record<string, unknown>): string {
-  const summary = summarizeToolInput(name, input)
-  return `  \x1b[33m*\x1b[0m ${name}${summary ? `(${summary})` : ""}`
-}
-
-function summarizeToolInput(name: string, input: Record<string, unknown>): string {
-  switch (name.toLowerCase()) {
-    case "bash": {
-      const cmd = String(input.command || "")
-      return cmd.length > 60 ? cmd.slice(0, 57) + "..." : cmd
-    }
-    case "read":
-    case "write":
-    case "edit":
-      return String(input.file_path || input.path || "")
-    case "glob":
-      return String(input.pattern || "")
-    case "grep":
-      return String(input.pattern || "")
-    default:
-      return ""
-  }
-}
-
-export function formatToolResult(name: string, output: unknown): string {
-  if (typeof output === "string") {
-    return output.length > 200 ? output.slice(0, 197) + "..." : output
-  }
-  return JSON.stringify(output).slice(0, 200)
-}

package/src/utils/tokens.ts

@@ -1,41 +0,0 @@
-/**
- * Token estimation utilities.
- * Uses ~4 chars per token heuristic (works well for English + code).
- */
-
-export function estimateTokens(text: string): number {
-  if (!text) return 0
-  return Math.ceil(text.length / 4)
-}
-
-export function estimateMessagesTokens(
-  messages: Array<{ role: string; content: unknown }>
-): number {
-  let total = 0
-  for (const msg of messages) {
-    const content =
-      typeof msg.content === "string"
-        ? msg.content
-        : JSON.stringify(msg.content ?? "")
-    total += estimateTokens(content)
-    // Overhead per message (~4 tokens for role, separators)
-    total += 4
-  }
-  return total
-}
-
-export function estimateToolSchemaTokens(schemas: Array<Record<string, unknown>>): number {
-  let total = 0
-  for (const schema of schemas) {
-    total += estimateTokens(String(schema.description ?? ""))
-    total += estimateTokens(String(schema.name ?? ""))
-    total += estimateTokens(JSON.stringify(schema.input_schema ?? {}))
-  }
-  return total
-}
-
-export function formatTokenCount(tokens: number): string {
-  if (tokens >= 1_000_000) return `${(tokens / 1_000_000).toFixed(1)}M`
-  if (tokens >= 1_000) return `${(tokens / 1_000).toFixed(1)}K`
-  return String(tokens)
-}

package/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "commonjs",
-    "lib": ["ES2022"],
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "moduleResolution": "node"
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}