@llmtune/cli 0.1.0 → 0.1.2

package/src/repl/repl.ts

@@ -1,400 +0,0 @@
-import chalk from "chalk"
-import { createInterface } from "readline"
-import OpenAI from "openai"
-import { Conversation } from "../agent/conversation"
-import { ToolRegistry } from "../tools/registry"
-import { runAgentLoop } from "../agent/loop"
-import { estimateTokens } from "../utils/tokens"
-import { readTool } from "../tools/tools/read"
-import { writeTool } from "../tools/tools/write"
-import { editTool } from "../tools/tools/edit"
-import { bashTool } from "../tools/tools/bash"
-import { globTool } from "../tools/tools/glob"
-import { grepTool } from "../tools/tools/grep"
-import { webFetchTool } from "../tools/tools/web-fetch"
-import { askUserTool } from "../tools/tools/ask-user"
-import { compactConversation, uncompactConversation, type CompactResult } from "../compact/service"
-import { analyzeContextUsage, formatContextAnalysis } from "../context/analyzer"
-import { SkillRegistry, type TrustLevel } from "../skills/registry"
-import { loadAllSkills } from "../skills/loader"
-import { isToolAllowedForSkill, resolveTrustLevel } from "../skills/trust"
-import { initMemoryFiles, buildMemoryPrompt, readAllMemory, type MemoryEntry } from "../memory/service"
-import { startSessionLog, logEvent, endSessionLog, type TelemetryEvent } from "../telemetry/logger"
-import { loadConfig } from "../auth/config"
-import { getConfigDir } from "../auth/config"
-import * as fs from "fs"
-import * as path from "path"
-
-export interface ReplOptions {
-  client: OpenAI
-  model: string
-  stream: boolean
-}
-
-const HELP_TEXT = `
-${chalk.bold("LLMTune CLI - Commands:")}
-
-  ${chalk.cyan("/help")}            Show this help
-  ${chalk.cyan("/clear")}          Clear conversation history
-  ${chalk.cyan("/context")}        Show detailed context usage breakdown
-  ${chalk.cyan("/compact")}        Compact conversation (LLM summary)
-  ${chalk.cyan("/uncompact")}      Restore conversation from before compaction
-  ${chalk.cyan("/model <name>")}   Switch model
-  ${chalk.cyan("/stream")}         Toggle streaming mode
-  ${chalk.cyan("/verbose")}        Toggle verbose tool output
-  ${chalk.cyan("/trust <tool>")}   Trust a tool (skip confirmations)
-  ${chalk.cyan("/skills")}         List available skills
-  ${chalk.cyan("/memory")}         Show memory contents
-  ${chalk.cyan("/save")}           Save conversation to file
-  ${chalk.cyan("/exit")}           Exit REPL
-
-  ${chalk.gray("Type your message and press Enter to chat.")}
-  ${chalk.gray("Multi-line: end a line with '\\' to continue.")}
-`.trim()
-
-export async function startRepl(options: ReplOptions): Promise<void> {
-  const registry = new ToolRegistry()
-  const cwd = process.cwd()
-  const trustedTools = new Set<string>()
-
-  registry.register(readTool)
-  registry.register(writeTool)
-  registry.register(editTool)
-  registry.register(bashTool)
-  registry.register(globTool)
-  registry.register(grepTool)
-  registry.register(webFetchTool)
-  registry.register(askUserTool)
-
-  const conversation = new Conversation(options.model)
-
-  // Load skills
-  const skills = loadAllSkills(cwd)
-  const skillList = skills.listUserInvocable()
-
-  // Initialize memory
-  initMemoryFiles()
-
-  // Start telemetry
-  startSessionLog(conversation.id, {
-    model: options.model,
-    tools: registry.listSpecs().map((s) => s.name),
-    cwd,
-  })
-
-  let currentModel = options.model
-  let streamMode = options.stream
-  let verbose = false
-
-  console.log(chalk.cyan(`\nLLMTune CLI v0.1.0`))
-  console.log(chalk.dim(`Model: ${currentModel}`))
-  console.log(chalk.dim(`Tools: ${registry.listSpecs().map((s) => s.name).join(", ")}`))
-  if (skillList.length > 0) {
-    console.log(chalk.dim(`Skills: ${skillList.map((s) => s.name).join(", ")}`))
-  }
-  console.log(chalk.dim(`Type /help for commands, /exit to quit.\n`))
-
-  const rl = createInterface({
-    input: process.stdin,
-    output: process.stdout,
-    prompt: chalk.blue("> "),
-  })
-
-  rl.prompt()
-
-  let multiLineBuffer = ""
-
-  rl.on("line", async (line: string) => {
-    const trimmed = line.trim()
-
-    if (trimmed.endsWith("\\")) {
-      multiLineBuffer += trimmed.slice(0, -1) + "\n"
-      process.stdout.write(chalk.dim("... "))
-      return
-    }
-
-    const fullInput = multiLineBuffer + trimmed
-    multiLineBuffer = ""
-
-    if (!fullInput) {
-      rl.prompt()
-      return
-    }
-
-    // Check for skill execution: /skill-name [args]
-    if (fullInput.startsWith("/") && !fullInput.startsWith("/help") && !fullInput.startsWith("/exit") && !fullInput.startsWith("/quit") && !fullInput.startsWith("/clear") && !fullInput.startsWith("/context") && !fullInput.startsWith("/compact") && !fullInput.startsWith("/uncompact") && !fullInput.startsWith("/model") && !fullInput.startsWith("/stream") && !fullInput.startsWith("/verbose") && !fullInput.startsWith("/trust") && !fullInput.startsWith("/skills") && !fullInput.startsWith("/memory") && !fullInput.startsWith("/save")) {
-      const parts = fullInput.slice(1).split(/\s+/)
-      const skillName = parts[0]
-      const skillArgs = parts.slice(1)
-
-      const execution = skills.prepareExecution(skillName, skillArgs)
-      if (execution) {
-        const skill = skills.get(skillName)!
-        console.log(chalk.magenta(`Executing skill: ${skill.name}`))
-
-        const trustLevel = resolveTrustLevel(skill)
-        const toolNames = registry.listSpecs().map((s) => s.name)
-        for (const toolName of toolNames) {
-          if (!isToolAllowedForSkill(toolName, trustLevel)) {
-            console.log(chalk.yellow(`  Warning: tool "${toolName}" not allowed for skill trust level "${trustLevel}"`))
-          }
-        }
-
-        // Add skill system prompt and user message
-        conversation.addSystemMessage(execution.systemPrompt)
-        conversation.addUserMessage(execution.userMessage)
-
-        try {
-          const result = await runAgentLoop(options.client, conversation, registry, execution.userMessage, {
-            model: currentModel,
-            maxTurns: 50,
-            verbose,
-            cwd,
-            workspaceRoot: cwd,
-          })
-          logEvent({ event: "tool_call", tool: skillName, latency_ms: 0 })
-        } catch (err: unknown) {
-          const msg = err instanceof Error ? err.message : String(err)
-          console.log(chalk.red(`\nSkill error: ${msg}`))
-        }
-
-        console.log("")
-        rl.prompt()
-        return
-      }
-    }
-
-    if (fullInput.startsWith("/")) {
-      await handleCommand(fullInput, {
-        rl,
-        conversation,
-        registry,
-        skills,
-        trustedTools,
-        cwd,
-        client: options.client,
-        getModel: () => currentModel,
-        setModel: (m: string) => {
-          currentModel = m
-        },
-        getStream: () => streamMode,
-        setStream: (s: boolean) => {
-          streamMode = s
-        },
-        getVerbose: () => verbose,
-        setVerbose: (v: boolean) => {
-          verbose = v
-        },
-      })
-      rl.prompt()
-      return
-    }
-
-    // Normal chat
-    try {
-      const result = await runAgentLoop(options.client, conversation, registry, fullInput, {
-        model: currentModel,
-        maxTurns: 50,
-        verbose,
-        cwd,
-        workspaceRoot: cwd,
-      })
-
-      if (result.totalTokensIn > 0 || result.totalTokensOut > 0) {
-        const cost = estimateCostFromUsage(result.totalTokensIn, result.totalTokensOut)
-        console.log(
-          chalk.dim(
-            `  [${result.turns} turn${result.turns !== 1 ? "s" : ""} | ` +
-              `${result.totalToolCalls} tool calls | ` +
-              `${result.totalTokensIn + result.totalTokensOut} tokens | ` +
-              `~$${cost.toFixed(4)}]`,
-          ),
-        )
-        logEvent({
-          event: "llm_response",
-          model: currentModel,
-          tokens_in: result.totalTokensIn,
-          tokens_out: result.totalTokensOut,
-          cost,
-          latency_ms: 0,
-        })
-      }
-    } catch (err: unknown) {
-      const msg = err instanceof Error ? err.message : String(err)
-      console.log(chalk.red(`\nError: ${msg}`))
-      logEvent({ event: "error", source: "agent_loop", error: msg } as TelemetryEvent)
-    }
-
-    console.log("")
-    rl.prompt()
-  })
-
-  rl.on("close", () => {
-    endSessionLog({ totalToolCalls: 0, totalTokens: 0 })
-    console.log(chalk.dim("\nGoodbye!"))
-    process.exit(0)
-  })
-}
-
-interface CommandContext {
-  rl: ReturnType<typeof createInterface>
-  conversation: Conversation
-  registry: ToolRegistry
-  skills: SkillRegistry
-  trustedTools: Set<string>
-  cwd: string
-  client: OpenAI
-  getModel: () => string
-  setModel: (m: string) => void
-  getStream: () => boolean
-  setStream: (s: boolean) => void
-  getVerbose: () => boolean
-  setVerbose: (v: boolean) => void
-}
-
-async function handleCommand(input: string, ctx: CommandContext): Promise<void> {
-  const parts = input.split(/\s+/)
-  const cmd = parts[0].toLowerCase()
-  const args = parts.slice(1)
-
-  switch (cmd) {
-    case "/help":
-    case "/h":
-    case "/?":
-      console.log(HELP_TEXT)
-      break
-
-    case "/exit":
-    case "/quit":
-    case "/q":
-      console.log(chalk.dim("Goodbye!"))
-      process.exit(0)
-
-    case "/clear":
-      ctx.conversation.messages.length = 0
-      console.log(chalk.green("Conversation cleared."))
-      break
-
-    case "/context": {
-      const analysis = analyzeContextUsage({
-        systemPrompt: "LLMTune coding agent",
-        toolSpecs: ctx.registry.listSpecs(),
-        messages: ctx.conversation.getApiMessages().map((m) => ({
-          role: m.role,
-          content: m.content,
-        })),
-        skillsContent: ctx.skills.list().map((s) => s.content).join("\n") || undefined,
-        memoryContent: buildMemoryPrompt() || undefined,
-        model: ctx.getModel(),
-      })
-
-      console.log(formatContextAnalysis(analysis))
-      break
-    }
-
-    case "/compact": {
-      if (ctx.conversation.messages.length < 3) {
-        console.log(chalk.yellow("Not enough messages to compact (need at least 3)."))
-        break
-      }
-      console.log(chalk.dim("Compacting conversation..."))
-      try {
-        const result = await compactConversation(ctx.client, ctx.getModel(), ctx.conversation)
-        console.log(chalk.green(`\nCompacted: ${result.preCompactMessages} -> ${result.postCompactMessages} messages`))
-        console.log(chalk.dim(`  Tokens saved: ~${result.tokensSaved.toLocaleString()}`))
-        console.log(chalk.dim(`  Use /uncompact to restore full history.`))
-        logEvent({ event: "compaction", tokens_saved: result.tokensSaved, messages_before: result.preCompactMessages, messages_after: result.postCompactMessages, trigger: "manual" })
-      } catch (err: unknown) {
-        const msg = err instanceof Error ? err.message : String(err)
-        console.log(chalk.red(`Compaction failed: ${msg}`))
-      }
-      break
-    }
-
-    case "/uncompact": {
-      const restored = uncompactConversation(ctx.conversation)
-      if (restored) {
-        console.log(chalk.green(`Restored conversation from before compaction (${ctx.conversation.messages.length} messages).`))
-      } else {
-        console.log(chalk.yellow("No raw history found to restore."))
-      }
-      break
-    }
-
-    case "/model":
-      if (args[0]) {
-        ctx.setModel(args[0])
-        console.log(chalk.green(`Model set to: ${args[0]}`))
-      } else {
-        console.log(chalk.dim(`Current model: ${ctx.getModel()}`))
-      }
-      break
-
-    case "/stream":
-      ctx.setStream(!ctx.getStream())
-      console.log(chalk.green(`Streaming: ${ctx.getStream() ? "on" : "off"}`))
-      break
-
-    case "/verbose":
-      ctx.setVerbose(!ctx.getVerbose())
-      console.log(chalk.green(`Verbose: ${ctx.getVerbose() ? "on" : "off"}`))
-      break
-
-    case "/trust":
-      if (args[0]) {
-        ctx.trustedTools.add(args[0].toLowerCase())
-        console.log(chalk.green(`Trusting tool: ${args[0]} (no confirmation needed)`))
-      } else {
-        console.log(chalk.dim("Usage: /trust <tool-name>"))
-      }
-      break
-
-    case "/skills": {
-      const allSkills = ctx.skills.listUserInvocable()
-      if (allSkills.length === 0) {
-        console.log(chalk.dim("No skills loaded. Create skills in ~/.llmtune/skills/ or .llmtune/skills/"))
-        console.log(chalk.dim("Each skill is a directory with a SKILL.md file."))
-      } else {
-        console.log(chalk.bold("\nAvailable Skills:"))
-        for (const skill of allSkills) {
-          const trustLabel = skill.trustLevel
-          console.log(`  ${chalk.cyan(`/${skill.name}`)} - ${skill.description} ${chalk.dim(`[${trustLabel}]`)}`)
-        }
-        console.log("")
-      }
-      break
-    }
-
-    case "/memory": {
-      const entries = readAllMemory()
-      if (entries.length === 0) {
-        console.log(chalk.dim("\nNo memory entries. The agent will auto-populate memory as you chat."))
-        console.log(chalk.dim(`Memory directory: ${getConfigDir()}/memory/\n`))
-      } else {
-        console.log(chalk.bold("\nMemory:"))
-        for (const entry of entries) {
-          if (entry.content.trim()) {
-            const preview = entry.content.slice(0, 100).replace(/\n/g, " ")
-            console.log(`  ${chalk.cyan(entry.category)}: ${chalk.dim(preview)}${entry.content.length > 100 ? "..." : ""}`)
-          }
-        }
-        console.log("")
-      }
-      break
-    }
-
-    case "/save": {
-      const savePath = path.join(process.cwd(), `llmtune-session-${Date.now()}.json`)
-      fs.writeFileSync(savePath, JSON.stringify(ctx.conversation.getApiMessages(), null, 2), "utf-8")
-      console.log(chalk.green(`Session saved to: ${savePath}`))
-      break
-    }
-
-    default:
-      console.log(chalk.yellow(`Unknown command: ${cmd}. Type /help for available commands.`))
-  }
-}
-
-function estimateCostFromUsage(inputTokens: number, outputTokens: number): number {
-  return (inputTokens * 3 + outputTokens * 15) / 1_000_000
-}

package/src/skills/args.ts

@@ -1,35 +0,0 @@
-/**
- * Parse argument names from a skill's frontmatter "arguments" field.
- * Supports: "arg1 arg2", "arg1, arg2", "$arg1 $arg2"
- */
-export function parseArgumentNames(raw: unknown): string[] {
-  if (!raw) return []
-  const str = String(raw).trim()
-  if (!str) return []
-
-  // Split by comma or space, strip $ prefixes
-  return str
-    .split(/[,\s]+/)
-    .map((s) => s.trim().replace(/^\$/, ""))
-    .filter(Boolean)
-}
-
-/**
- * Substitute {{arg}} placeholders in skill content with provided values.
- */
-export function substituteArguments(
-  content: string,
-  args: Record<string, string>
-): string {
-  let result = content
-  for (const [key, value] of Object.entries(args)) {
-    const patterns = [
-      new RegExp(`\\{\\{${key}\\}\\}`, "g"),
-      new RegExp(`\\$\\{${key}\\}`, "g"),
-    ]
-    for (const pattern of patterns) {
-      result = result.replace(pattern, value)
-    }
-  }
-  return result
-}

package/src/skills/builtin/explain-code/SKILL.md

@@ -1,30 +0,0 @@
----
-description: "Explain a code file or code snippet with clear analysis"
-user-invocable: true
-when_to_use: "Use when the user asks to explain, analyze, or understand code"
-allowed-tools:
-  - read
-  - glob
-  - grep
-arguments:
-  - file_path
----
-
-You are a code analysis expert. Your task is to explain the given code clearly and thoroughly.
-
-## Instructions
-
-1. If a `file_path` argument is provided, read the file first using the `read` tool
-2. Provide a structured explanation covering:
-   - **Purpose**: What does this code do?
-   - **Key Components**: Main functions, classes, or modules
-   - **Data Flow**: How data moves through the code
-   - **Dependencies**: What external modules or services are used
-   - **Notable Patterns**: Design patterns, architectural decisions
-3. Use clear, concise language
-4. Include relevant code snippets in your explanation
-5. If the code has potential issues or improvements, mention them
-
-## Output Format
-
-Provide the explanation in markdown format with proper headings and code blocks.

package/src/skills/frontmatter.ts

@@ -1,47 +0,0 @@
-export interface FrontmatterResult {
-  frontmatter: Record<string, unknown>
-  body: string
-}
-
-export function parseFrontmatter(content: string): FrontmatterResult {
-  const trimmed = content.trimStart()
-
-  if (!trimmed.startsWith("---")) {
-    return { frontmatter: {}, body: content }
-  }
-
-  const endMatch = trimmed.indexOf("---", 3)
-  if (endMatch === -1 || endMatch < 4) {
-    return { frontmatter: {}, body: content }
-  }
-
-  const frontmatterStr = trimmed.slice(3, endMatch).trim()
-  const body = trimmed.slice(endMatch + 3).trimStart()
-
-  const frontmatter: Record<string, unknown> = {}
-  for (const line of frontmatterStr.split("\n")) {
-    const colonIdx = line.indexOf(":")
-    if (colonIdx === -1) continue
-    const key = line.slice(0, colonIdx).trim()
-    let value: unknown = line.slice(colonIdx + 1).trim()
-
-    if (typeof value === "string") {
-      if (value === "true") value = true
-      else if (value === "false") value = false
-      else if (/^\d+$/.test(value)) value = Number(value)
-      else if (value.startsWith("[") && value.endsWith("]")) {
-        value = value
-          .slice(1, -1)
-          .split(",")
-          .map((s) => s.trim())
-          .filter(Boolean)
-      } else {
-        value = value.replace(/^["']|["']$/g, "")
-      }
-    }
-
-    frontmatter[key] = value
-  }
-
-  return { frontmatter, body }
-}

package/src/skills/loader.ts

@@ -1,25 +0,0 @@
-import * as path from "path"
-import * as os from "os"
-import { SkillRegistry } from "./registry"
-
-export function loadAllSkills(projectRoot?: string): SkillRegistry {
-  const registry = new SkillRegistry()
-  registry.loadAll(projectRoot)
-  return registry
-}
-
-export function getDefaultSkillsDirs(): string[] {
-  const dirs: string[] = []
-  const home = os.homedir()
-
-  const envDir = process.env.LLMTUNE_SKILLS_DIR
-  if (envDir) dirs.push(path.resolve(envDir))
-
-  dirs.push(path.join(home, ".llmtune", "skills"))
-
-  return dirs
-}
-
-export function getProjectSkillsDir(projectRoot: string): string {
-  return path.join(projectRoot, ".llmtune", "skills")
-}

package/src/skills/registry.ts

@@ -1,155 +0,0 @@
-import * as fs from "fs"
-import * as path from "path"
-import * as os from "os"
-import { parseFrontmatter } from "./frontmatter"
-import { substituteArguments } from "./args"
-
-export interface Skill {
-  name: string
-  description: string
-  content: string
-  loadedFrom: "user" | "project" | "managed"
-  userInvocable: boolean
-  allowedTools: string[]
-  argNames: string[]
-  trustLevel: TrustLevel
-  skillRoot: string
-}
-
-export type TrustLevel = "local" | "community" | "verified" | "signed"
-
-export interface SkillExecution {
-  systemPrompt: string
-  userMessage: string
-  allowedTools?: string[]
-}
-
-const SKILL_DIRS = () => {
-  const dirs: string[] = []
-  const primary = path.join(os.homedir(), ".llmtune", "skills")
-  dirs.push(primary)
-  return dirs
-}
-
-export class SkillRegistry {
-  private skills: Map<string, Skill> = new Map()
-
-  loadAll(projectRoot?: string): void {
-    this.skills.clear()
-
-    for (const dir of SKILL_DIRS()) {
-      this.loadFromDir(dir, "user")
-    }
-
-    const managedEnv = process.env.LLMTUNE_MANAGED_SKILLS_DIR
-    if (managedEnv) {
-      this.loadFromDir(managedEnv, "managed")
-    }
-
-    if (projectRoot) {
-      const projectDir = path.join(projectRoot, ".llmtune", "skills")
-      this.loadFromDir(projectDir, "project")
-      const compatDir = path.join(projectRoot, ".claude", "skills")
-      this.loadFromDir(compatDir, "project")
-    }
-  }
-
-  private loadFromDir(baseDir: string, loadedFrom: Skill["loadedFrom"]): void {
-    const resolved = path.resolve(baseDir)
-    if (!fs.existsSync(resolved) || !fs.statSync(resolved).isDirectory()) return
-
-    for (const entry of fs.readdirSync(resolved).sort()) {
-      const skillPath = path.join(resolved, entry)
-      if (!fs.statSync(skillPath).isDirectory()) continue
-
-      const mdPath = path.join(skillPath, "SKILL.md")
-      if (!fs.existsSync(mdPath)) continue
-
-      const raw = fs.readFileSync(mdPath, "utf-8")
-      const { frontmatter, body } = parseFrontmatter(raw)
-
-      const description = String(frontmatter.description ?? extractFirstLine(body) ?? `Skill: ${entry}`)
-      const userInvocable = frontmatter["user-invocable"] !== false
-      const allowedTools = asStrList(frontmatter["allowed-tools"])
-      const argNames = parseArgNames(frontmatter.arguments)
-      const trustLevel = resolveTrustLevel(frontmatter.trust, loadedFrom)
-
-      const skill: Skill = {
-        name: entry,
-        description,
-        content: body,
-        loadedFrom,
-        userInvocable,
-        allowedTools,
-        argNames,
-        trustLevel,
-        skillRoot: skillPath,
-      }
-
-      if (!this.skills.has(entry.toLowerCase())) {
-        this.skills.set(entry.toLowerCase(), skill)
-      }
-    }
-  }
-
-  get(name: string): Skill | undefined {
-    return this.skills.get(name.toLowerCase())
-  }
-
-  list(): Skill[] {
-    return Array.from(this.skills.values())
-  }
-
-  listUserInvocable(): Skill[] {
-    return this.list().filter((s) => s.userInvocable)
-  }
-
-  prepareExecution(name: string, args: string[]): SkillExecution | null {
-    const skill = this.get(name)
-    if (!skill) return null
-
-    const argMap: Record<string, string> = {}
-    for (let i = 0; i < Math.min(args.length, skill.argNames.length); i++) {
-      argMap[skill.argNames[i]] = args[i]
-    }
-
-    const userMessage = substituteArguments(skill.content, argMap)
-
-    return {
-      systemPrompt: `You are executing the "${skill.name}" skill. ${skill.description}`,
-      userMessage,
-      allowedTools: skill.allowedTools.length > 0 ? skill.allowedTools : undefined,
-    }
-  }
-}
-
-function resolveTrustLevel(raw: unknown, loadedFrom: Skill["loadedFrom"]): TrustLevel {
-  const str = String(raw ?? "").toLowerCase().trim()
-  if (str === "signed") return "signed"
-  if (str === "verified") return "verified"
-  if (str === "community") return "community"
-  if (loadedFrom === "user" || loadedFrom === "project") return "local"
-  return "community"
-}
-
-function extractFirstLine(body: string): string | null {
-  for (const line of body.split("\n")) {
-    const stripped = line.trim()
-    if (!stripped || stripped.startsWith("#")) continue
-    return stripped.slice(0, 200)
-  }
-  return null
-}
-
-function parseArgNames(raw: unknown): string[] {
-  return asStrList(raw)
-}
-
-function asStrList(val: unknown): string[] {
-  if (val == null) return []
-  if (Array.isArray(val)) return val.map(String).filter(Boolean)
-  const s = String(val).trim()
-  if (!s) return []
-  if (s.includes(",")) return s.split(",").map((x) => x.trim()).filter(Boolean)
-  return [s]
-}