@llmtune/cli 0.1.0 → 0.1.1

package/src/memory/service.ts

@@ -1,124 +0,0 @@
-import * as fs from "fs"
-import * as path from "path"
-import * as os from "os"
-
-const MEMORY_DIR = path.join(os.homedir(), ".llmtune", "memory")
-
-const MEMORY_FILES = {
-  preferences: "preferences.md",
-  "project-notes": "project-notes.md",
-  decisions: "decisions.md",
-  architecture: "architecture.md",
-} as const
-
-type MemoryCategory = keyof typeof MEMORY_FILES
-
-export interface MemoryEntry {
-  category: MemoryCategory
-  content: string
-  path: string
-}
-
-function ensureMemoryDir(): void {
-  if (!fs.existsSync(MEMORY_DIR)) {
-    fs.mkdirSync(MEMORY_DIR, { recursive: true })
-  }
-}
-
-function getMemoryPath(category: MemoryCategory): string {
-  return path.join(MEMORY_DIR, MEMORY_FILES[category])
-}
-
-export function readMemory(category: MemoryCategory): string {
-  const filePath = getMemoryPath(category)
-  try {
-    return fs.readFileSync(filePath, "utf-8").trim()
-  } catch {
-    return ""
-  }
-}
-
-export function writeMemory(category: MemoryCategory, content: string): void {
-  ensureMemoryDir()
-  const filePath = getMemoryPath(category)
-  fs.writeFileSync(filePath, content.trim() + "\n", "utf-8")
-}
-
-export function appendMemory(category: MemoryCategory, line: string): void {
-  ensureMemoryDir()
-  const existing = readMemory(category)
-  const updated = existing ? `${existing}\n${line}` : line
-  writeMemory(category, updated)
-}
-
-export function readAllMemory(): MemoryEntry[] {
-  ensureMemoryDir()
-  const entries: MemoryEntry[] = []
-  for (const [category, filename] of Object.entries(MEMORY_FILES)) {
-    const content = readMemory(category as MemoryCategory)
-    if (content) {
-      entries.push({
-        category: category as MemoryCategory,
-        content,
-        path: path.join(MEMORY_DIR, filename),
-      })
-    }
-  }
-  return entries
-}
-
-export function buildMemoryPrompt(): string {
-  const entries = readAllMemory()
-  if (entries.length === 0) return ""
-
-  const sections = entries.map((entry) => {
-    const label = entry.category.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase())
-    return `### ${label}\n${entry.content}`
-  })
-
-  return "## User Memory\n\n" + sections.join("\n\n")
-}
-
-export function clearMemory(category?: MemoryCategory): void {
-  if (category) {
-    const filePath = getMemoryPath(category)
-    try {
-      fs.unlinkSync(filePath)
-    } catch {
-      // file doesn't exist
-    }
-  } else {
-    for (const filename of Object.values(MEMORY_FILES)) {
-      try {
-        fs.unlinkSync(path.join(MEMORY_DIR, filename))
-      } catch {
-        // skip
-      }
-    }
-  }
-}
-
-export function getMemoryDir(): string {
-  return MEMORY_DIR
-}
-
-export function initMemoryFiles(): void {
-  ensureMemoryDir()
-  const defaults: Record<MemoryCategory, string> = {
-    preferences:
-      "# User Preferences\n# Add your coding preferences here (one per line)\n# Example: I prefer TypeScript over JavaScript\n# Example: I use 2-space indentation\n",
-    "project-notes":
-      "# Project Notes\n# Key facts about the current project\n# Example: Auth uses JWT + bcrypt\n# Example: Database is Neon PostgreSQL via Prisma\n",
-    decisions:
-      "# Architecture Decisions\n# Record important technical decisions\n# Example: Decided to use Prisma instead of Drizzle for ORM\n",
-    architecture:
-      "# Architecture Overview\n# Describe the project structure\n# Example: Frontend: Next.js 16, Backend: Express 5, DB: Neon\n",
-  }
-
-  for (const [category, defaultContent] of Object.entries(defaults)) {
-    const filePath = getMemoryPath(category as MemoryCategory)
-    if (!fs.existsSync(filePath)) {
-      fs.writeFileSync(filePath, defaultContent, "utf-8")
-    }
-  }
-}

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