@llmtune/cli 0.1.0 → 0.1.1

package/src/commands/marketplace.ts

@@ -1,190 +0,0 @@
-import chalk from "chalk"
-import { createInterface } from "readline"
-import { listSkills, getSkillDetails, installSkill, publishSkill } from "../marketplace/client"
-import { loadConfig } from "../auth/config"
-import type { AppConfig } from "../auth/config"
-
-export async function marketplaceCommand(action: string, args: string[]): Promise<void> {
-  const config = loadConfig()
-  const apiKey = config.apiKey as string | undefined
-  if (!apiKey) {
-    console.log(chalk.red('Not logged in. Run "llmtune login" first.'))
-    process.exit(1)
-  }
-
-  switch (action) {
-    case "search":
-    case "list":
-      await searchSkills(config, args[0] ?? "")
-      break
-    case "info":
-      if (!args[0]) {
-        console.log(chalk.yellow("Usage: llmtune skills info <skill-name>"))
-        break
-      }
-      await showSkillInfo(config, args[0])
-      break
-    case "install":
-      if (!args[0]) {
-        console.log(chalk.yellow("Usage: llmtune skills install <skill-name>"))
-        break
-      }
-      await doInstallSkill(config, args[0])
-      break
-    case "publish":
-      if (!args[0]) {
-        console.log(chalk.yellow("Usage: llmtune skills publish <skill-dir>"))
-        break
-      }
-      await doPublishSkill(config, args[0])
-      break
-    default:
-      console.log(chalk.yellow(`Unknown action: ${action}`))
-      console.log(chalk.dim("Available: search, info, install, publish"))
-  }
-}
-
-async function searchSkills(config: AppConfig, query: string): Promise<void> {
-  console.log(chalk.cyan(`\nSearching skills${query ? `: ${query}` : ""}...\n`))
-
-  const result = await listSkills(config, { search: query || undefined })
-  const skills = result.skills
-
-  if (skills.length === 0) {
-    console.log(chalk.dim("No skills found."))
-    return
-  }
-
-  for (const skill of skills) {
-    const trust = chalk.dim(`[${skill.trustLevel}]`)
-    const installs = skill.installs ? chalk.dim(`(${skill.installs} installs)`) : ""
-    console.log(`  ${chalk.bold(skill.name)} ${trust} ${installs}`)
-    console.log(`    ${chalk.dim(skill.description)}`)
-    if (skill.author) {
-      console.log(`    ${chalk.dim(`by ${skill.author}`)}`)
-    }
-    console.log()
-  }
-
-  console.log(
-    chalk.dim(
-      `${skills.length} of ${result.total} skills shown. Use ${chalk.bold("llmtune skills install <name>")} to install.`,
-    ),
-  )
-}
-
-async function showSkillInfo(config: AppConfig, name: string): Promise<void> {
-  try {
-    const skill = await getSkillDetails(config, name)
-    console.log(chalk.bold(`\n${skill.name}`))
-    console.log(chalk.dim(skill.description))
-    console.log()
-    console.log(`  Trust:     ${skill.trustLevel}`)
-    console.log(`  Author:    ${skill.author ?? "unknown"}`)
-    if (skill.installs !== undefined) console.log(`  Installs:  ${skill.installs}`)
-    if (skill.rating !== undefined) {
-      const stars = "\u2605".repeat(Math.round(skill.rating)) + "\u2606".repeat(5 - Math.round(skill.rating))
-      console.log(`  Rating:    ${stars} (${skill.rating.toFixed(1)})`)
-    }
-    if (skill.allowedTools.length > 0) {
-      console.log(`  Tools:     ${skill.allowedTools.join(", ")}`)
-    }
-    if (skill.tags && skill.tags.length > 0) {
-      console.log(`  Tags:      ${skill.tags.join(", ")}`)
-    }
-    console.log()
-  } catch (err: unknown) {
-    const msg = err instanceof Error ? err.message : String(err)
-    console.log(chalk.red(`Error: ${msg}`))
-  }
-}
-
-async function doInstallSkill(config: AppConfig, name: string): Promise<void> {
-  console.log(chalk.cyan(`Installing skill: ${name}...`))
-
-  try {
-    const skillPath = await installSkill(config, name)
-    console.log(chalk.green(`\nSkill "${name}" installed to: ${skillPath}`))
-    console.log(chalk.dim(`Run /${name} in a chat session to use it.`))
-  } catch (err: unknown) {
-    const msg = err instanceof Error ? err.message : String(err)
-    console.log(chalk.red(`\nFailed to install: ${msg}`))
-  }
-}
-
-async function doPublishSkill(config: AppConfig, skillDir: string): Promise<void> {
-  const fs = await import("fs/promises")
-  const path = await import("path")
-
-  const mdPath = path.join(skillDir, "SKILL.md")
-  let content: string
-  try {
-    content = await fs.readFile(mdPath, "utf-8")
-  } catch {
-    console.log(chalk.red(`No SKILL.md found in: ${skillDir}`))
-    return
-  }
-
-  const name = path.basename(path.resolve(skillDir))
-  const description = content.split("\n").find((l) => l.trim() && !l.trim().startsWith("#") && !l.trim().startsWith("---"))?.trim() ?? `Skill: ${name}`
-
-  console.log(chalk.cyan(`\nPublishing skill: ${name}`))
-  console.log(chalk.dim(`Path: ${skillDir}`))
-  console.log(chalk.dim(`Description: ${description.slice(0, 80)}`))
-  console.log()
-
-  const rl = createInterface({ input: process.stdin, output: process.stdout })
-  const answer = await new Promise<string>((resolve) => {
-    rl.question(chalk.yellow("Publish this skill? [y/N] "), (ans) => {
-      rl.close()
-      resolve(ans.trim().toLowerCase())
-    })
-  })
-
-  if (answer !== "y" && answer !== "yes") {
-    console.log(chalk.dim("Cancelled."))
-    return
-  }
-
-  try {
-    const result = await publishSkill(config, {
-      name,
-      description,
-      content,
-      trustLevel: "community",
-      allowedTools: [],
-    })
-
-    if (result.published) {
-      console.log(chalk.green(`\nSkill "${result.skillName}" published successfully!`))
-      console.log(chalk.dim("It will appear in the marketplace after review."))
-    } else {
-      console.log(chalk.red(`\nFailed to publish skill "${name}".`))
-    }
-  } catch (err: unknown) {
-    const msg = err instanceof Error ? err.message : String(err)
-    console.log(chalk.red(`\nFailed to publish: ${msg}`))
-  }
-}
-
-export async function listSkillsCommand(): Promise<void> {
-  await marketplaceCommand("list", [])
-}
-
-export async function installSkillCommand(name: string): Promise<void> {
-  await marketplaceCommand("install", [name])
-}
-
-export async function publishSkillCommand(dir: string): Promise<void> {
-  await marketplaceCommand("publish", [dir])
-}
-
-export async function signSkillCommand(dir: string): Promise<void> {
-  const { signSkill, generateKeyPair } = await import("../skills/signing/signer")
-  const keys = generateKeyPair()
-  const result = signSkill(dir, keys.privateKey, keys.publicKey)
-  console.log(chalk.green(`\nSkill signed: ${dir}`))
-  console.log(chalk.dim(`Signature: ${result.signature}`))
-  console.log(chalk.dim(`Public key: ${result.publicKey}`))
-  console.log(chalk.yellow("\nSave your private key securely. You'll need it to sign future versions."))
-}

package/src/commands/models.ts

@@ -1,74 +0,0 @@
-import chalk from "chalk";
-import Table from "cli-table3";
-import { loadConfig, getApiBase, getApiKey } from "../auth/config";
-
-export async function modelsCommand(): Promise<void> {
-  const apiKey = getApiKey();
-  if (!apiKey) {
-    console.log(chalk.red('Not authenticated. Run "llmtune login" first.'));
-    process.exit(1);
-  }
-
-  const apiBase = getApiBase();
-
-  try {
-    const modelsUrl = apiBase.replace(/\/$/, "") + "/models";
-    const response = await fetch(modelsUrl, {
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-      },
-    });
-
-    if (!response.ok) {
-      const body = await response.text();
-      console.log(chalk.red(`Failed to fetch models: ${response.status}`));
-      console.log(chalk.dim(body.slice(0, 200)));
-      process.exit(1);
-    }
-
-    const data = (await response.json()) as {
-      data: Array<{
-        id: string;
-        object: string;
-        created: number;
-        owned_by: string;
-      }>;
-      subscription?: {
-        planName: string;
-        planModels: string[];
-        quotaDaily: number;
-      };
-    };
-
-    if (data.subscription) {
-      console.log(
-        chalk.cyan(`\nSubscription: ${data.subscription.planName}`)
-      );
-      console.log(
-        chalk.dim(
-          `Daily quota: ${data.subscription.quotaDaily} requests\n`
-        )
-      );
-    }
-
-    const table = new Table({
-      head: [
-        chalk.cyan("Model ID"),
-        chalk.cyan("Provider"),
-      ],
-      colWidths: [50, 20],
-    });
-
-    for (const model of data.data) {
-      table.push([model.id, model.owned_by]);
-    }
-
-    console.log(table.toString());
-    console.log(chalk.dim(`\n${data.data.length} models available`));
-  } catch (err) {
-    console.log(
-      chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`)
-    );
-    process.exit(1);
-  }
-}

package/src/compact/history-store.ts

@@ -1,101 +0,0 @@
-import * as fs from "fs"
-import * as path from "path"
-import * as os from "os"
-import type { Message } from "../agent/conversation"
-
-export interface HistorySnapshot {
-  sessionId: string
-  timestamp: string
-  reason: "manual" | "auto"
-  messageCount: number
-  tokenEstimate: number
-  messages: Message[]
-}
-
-const SESSIONS_DIR = () => {
-  const dir = path.join(os.homedir(), ".llmtune", "sessions")
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
-  return dir
-}
-
-export function getHistoryDir(sessionId: string): string {
-  const dir = path.join(SESSIONS_DIR(), sessionId)
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
-  return dir
-}
-
-export function saveRawHistory(
-  sessionId: string,
-  messages: Message[],
-  reason: "manual" | "auto" = "manual"
-): string {
-  const dir = getHistoryDir(sessionId)
-  const filePath = path.join(dir, "history.json")
-
-  const tokenEstimate = messages.reduce((total, msg) => {
-    const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
-    return total + Math.ceil(content.length / 4)
-  }, 0)
-
-  const snapshot: HistorySnapshot = {
-    sessionId,
-    timestamp: new Date().toISOString(),
-    reason,
-    messageCount: messages.length,
-    tokenEstimate,
-    messages,
-  }
-
-  fs.writeFileSync(filePath, JSON.stringify(snapshot, null, 2), "utf-8")
-  return filePath
-}
-
-export function loadRawHistory(sessionId: string): HistorySnapshot | null {
-  const filePath = path.join(getHistoryDir(sessionId), "history.json")
-  if (!fs.existsSync(filePath)) return null
-  try {
-    return JSON.parse(fs.readFileSync(filePath, "utf-8")) as HistorySnapshot
-  } catch {
-    return null
-  }
-}
-
-export function saveCompactionMeta(
-  sessionId: string,
-  meta: {
-    compactedAt: string
-    tokensBefore: number
-    tokensAfter: number
-    tokensSaved: number
-    messagesBefore: number
-    messagesAfter: number
-  }
-): void {
-  const filePath = path.join(getHistoryDir(sessionId), "compaction-meta.json")
-  const history: typeof meta[] = []
-  if (fs.existsSync(filePath)) {
-    try {
-      const existing = JSON.parse(fs.readFileSync(filePath, "utf-8"))
-      if (Array.isArray(existing)) history.push(...existing)
-    } catch { /* ignore */ }
-  }
-  history.push(meta)
-  fs.writeFileSync(filePath, JSON.stringify(history, null, 2), "utf-8")
-}
-
-export function loadCompactionHistory(sessionId: string): Array<{
-  compactedAt: string
-  tokensBefore: number
-  tokensAfter: number
-  tokensSaved: number
-  messagesBefore: number
-  messagesAfter: number
-}> {
-  const filePath = path.join(getHistoryDir(sessionId), "compaction-meta.json")
-  if (!fs.existsSync(filePath)) return []
-  try {
-    return JSON.parse(fs.readFileSync(filePath, "utf-8"))
-  } catch {
-    return []
-  }
-}

package/src/compact/microcompact.ts

@@ -1,49 +0,0 @@
-import type { Message } from "../agent/conversation"
-
-/**
- * Microcompact: reduce token usage by stripping verbose tool results
- * and compressing old messages. Ported from Clawd-Code compact_service/microcompact.py.
- */
-
-export function microcompactMessages(messages: Message[]): {
-  compacted: Message[]
-  tokensSaved: number
-} {
-  let tokensSaved = 0
-  const compacted: Message[] = []
-
-  for (const msg of messages) {
-    if (msg.role === "tool") {
-      const text = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
-      if (text.length > 2000) {
-        const compressed = compressToolResult(text)
-        tokensSaved += Math.ceil((text.length - compressed.length) / 4)
-        compacted.push({ ...msg, content: compressed })
-        continue
-      }
-    }
-
-    if (msg.role === "assistant" && msg.content) {
-      const text = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
-      if (text.length > 10000) {
-        const truncated = text.slice(0, 5000) + "\n... [truncated for compaction]"
-        tokensSaved += Math.ceil((text.length - truncated.length) / 4)
-        compacted.push({ ...msg, content: truncated })
-        continue
-      }
-    }
-
-    compacted.push(msg)
-  }
-
-  return { compacted, tokensSaved }
-}
-
-function compressToolResult(text: string): string {
-  // Keep first 500 chars and last 500 chars of large tool results
-  if (text.length <= 2000) return text
-  const head = text.slice(0, 500)
-  const tail = text.slice(-500)
-  const lines = text.split("\n").length
-  return `${head}\n\n... [${lines} lines compressed, ${text.length} chars total] ...\n\n${tail}`
-}

package/src/compact/service.ts

@@ -1,154 +0,0 @@
-import OpenAI from "openai"
-import { Conversation, type Message } from "../agent/conversation"
-import { estimateTokens } from "../utils/tokens"
-import * as fs from "fs"
-import * as path from "path"
-import * as os from "os"
-
-export interface CompactResult {
-  tokensSaved: number
-  preCompactTokens: number
-  postCompactTokens: number
-  preCompactMessages: number
-  postCompactMessages: number
-  summary: string
-}
-
-const COMPACT_SYSTEM_PROMPT = `CRITICAL: Respond with TEXT ONLY. Do NOT call any tools.
-
-Your task is to create a detailed summary of the conversation so far.
-
-Include:
-1. Primary Request and Intent: What the user asked for
-2. Key Technical Concepts: Technologies, frameworks, patterns discussed
-3. Files and Code Sections: Files examined, modified, or created (with key snippets)
-4. Errors and Fixes: Problems encountered and how they were resolved
-5. Problem Solving: What was accomplished
-6. All User Messages: Summarize all non-tool-result user messages
-7. Pending Tasks: Tasks explicitly requested but not yet done
-8. Current Work: What was being worked on immediately before this summary
-
-Respond ONLY with plain text. No XML tags. No tool calls.`
-
-export async function compactConversation(
-  client: OpenAI,
-  model: string,
-  conversation: Conversation,
-  sessionsDir?: string,
-): Promise<CompactResult> {
-  const messages = conversation.messages
-  const preCompactTokens = estimateTokens(
-    messages.map((m) => (typeof m.content === "string" ? m.content : JSON.stringify(m.content))).join(" "),
-  )
-  const preCompactCount = messages.length
-
-  // Save raw history before compacting
-  saveRawHistory(conversation, sessionsDir)
-
-  // Build context for summary: last N messages
-  const contextMessages = messages.slice(-20)
-  const summaryRequestMessages = contextMessages
-    .filter((m) => m.role !== "system")
-    .map(
-      (m): OpenAI.ChatCompletionMessageParam => ({
-        role: m.role as "user" | "assistant",
-        content: typeof m.content === "string" ? m.content : JSON.stringify(m.content),
-      }),
-    )
-  summaryRequestMessages.push({ role: "user", content: COMPACT_SYSTEM_PROMPT })
-
-  let summary = ""
-  try {
-    const response = await client.chat.completions.create({
-      model,
-      messages: summaryRequestMessages,
-      max_tokens: 4096,
-      temperature: 0,
-    })
-    summary = response.choices[0]?.message?.content?.trim() ?? ""
-  } catch {
-    summary = buildFallbackSummary(messages)
-  }
-
-  if (!summary) {
-    summary = buildFallbackSummary(messages)
-  }
-
-  // Replace conversation with boundary marker + summary
-  const boundaryMsg: Message = {
-    role: "system",
-    content: `[COMPACT BOUNDARY] Compacted at ${new Date().toISOString()}. ${preCompactCount} messages summarized. Raw history preserved.`,
-  }
-  const summaryMsg: Message = {
-    role: "system",
-    content: `## Conversation Summary\n\n${summary}`,
-  }
-
-  // Keep system messages + boundary + summary
-  const systemMessages = messages.filter((m) => m.role === "system" && m === messages[0])
-  conversation.messages.length = 0
-  conversation.messages.push(...systemMessages, boundaryMsg, summaryMsg)
-
-  const postCompactTokens = estimateTokens(
-    conversation.messages.map((m) => (typeof m.content === "string" ? m.content : JSON.stringify(m.content))).join(" "),
-  )
-  const postCompactCount = conversation.messages.length
-
-  return {
-    tokensSaved: Math.max(0, preCompactTokens - postCompactTokens),
-    preCompactTokens,
-    postCompactTokens,
-    preCompactMessages: preCompactCount,
-    postCompactMessages: postCompactCount,
-    summary,
-  }
-}
-
-export function uncompactConversation(conversation: Conversation, sessionsDir?: string): boolean {
-  const dir = sessionsDir ?? path.join(os.homedir(), ".llmtune", "sessions")
-  const rawPath = path.join(dir, `${conversation.id}.raw.json`)
-
-  if (!fs.existsSync(rawPath)) {
-    return false
-  }
-
-  try {
-    const raw = JSON.parse(fs.readFileSync(rawPath, "utf-8")) as { messages: Message[] }
-    conversation.messages.length = 0
-    conversation.messages.push(...raw.messages)
-    return true
-  } catch {
-    return false
-  }
-}
-
-function saveRawHistory(conversation: Conversation, sessionsDir?: string): void {
-  const dir = sessionsDir ?? path.join(os.homedir(), ".llmtune", "sessions")
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true })
-  }
-  const rawPath = path.join(dir, `${conversation.id}.raw.json`)
-  if (!fs.existsSync(rawPath)) {
-    fs.writeFileSync(rawPath, JSON.stringify({ messages: conversation.messages }, null, 2), "utf-8")
-  }
-}
-
-function buildFallbackSummary(messages: Message[]): string {
-  const userMsgs = messages
-    .filter((m) => m.role === "user")
-    .map((m) => (typeof m.content === "string" ? m.content.slice(0, 200) : ""))
-    .filter(Boolean)
-  const toolNames = messages
-    .filter((m) => m.role === "assistant" && m.toolCalls)
-    .flatMap((m) => m.toolCalls?.map((tc) => tc.function.name) ?? [])
-
-  const parts = [`Conversation had ${messages.length} messages.`]
-  if (toolNames.length > 0) {
-    const unique = [...new Set(toolNames)]
-    parts.push(`Tools used: ${unique.join(", ")}`)
-  }
-  if (userMsgs.length > 0) {
-    parts.push(`Last user message: ${userMsgs[userMsgs.length - 1].slice(0, 150)}`)
-  }
-  return parts.join("\n")
-}

package/src/context/analyzer.ts

@@ -1,127 +0,0 @@
-import type { ToolSpec } from "../tools/protocol"
-import { estimateTokens } from "../utils/tokens"
-
-export interface ContextCategory {
-  name: string
-  tokens: number
-}
-
-export interface ContextAnalysis {
-  categories: ContextCategory[]
-  totalTokens: number
-  maxTokens: number
-  percentage: number
-  model: string
-}
-
-const MODEL_CONTEXT_WINDOWS: Record<string, number> = {
-  "gpt-4o": 128_000,
-  "gpt-4o-mini": 128_000,
-  "gpt-4-turbo": 128_000,
-  "glm-5.1": 128_000,
-  "glm-5-turbo": 128_000,
-  "glm-4.7-flash": 128_000,
-  "claude-sonnet": 200_000,
-  "claude-opus": 200_000,
-  "deepseek-r1": 128_000,
-  "qwen3": 128_000,
-}
-
-const DEFAULT_CONTEXT_WINDOW = 128_000
-
-export function getContextWindowForModel(model: string): number {
-  const lower = model.toLowerCase()
-  for (const [name, window] of Object.entries(MODEL_CONTEXT_WINDOWS)) {
-    if (lower.includes(name)) return window
-  }
-  const kMatch = lower.match(/(\d+)k/)
-  if (kMatch) return parseInt(kMatch[1], 10) * 1_000
-  if (lower.includes("1m") || lower.includes("million")) return 1_000_000
-  return DEFAULT_CONTEXT_WINDOW
-}
-
-export function analyzeContextUsage(options: {
-  systemPrompt: string
-  toolSpecs: ToolSpec[]
-  messages: Array<{ role: string; content: unknown }>
-  skillsContent?: string
-  memoryContent?: string
-  model: string
-}): ContextAnalysis {
-  const categories: ContextCategory[] = []
-
-  const systemTokens = estimateTokens(options.systemPrompt)
-  if (systemTokens > 0) {
-    categories.push({ name: "System prompt", tokens: systemTokens })
-  }
-
-  let toolTokens = 0
-  for (const spec of options.toolSpecs) {
-    toolTokens += estimateTokens(spec.description)
-    toolTokens += estimateTokens(JSON.stringify(spec.inputSchema))
-  }
-  if (toolTokens > 0) {
-    categories.push({ name: "Tool definitions", tokens: toolTokens })
-  }
-
-  if (options.skillsContent) {
-    const skillsTokens = estimateTokens(options.skillsContent)
-    if (skillsTokens > 0) {
-      categories.push({ name: "Skills", tokens: skillsTokens })
-    }
-  }
-
-  if (options.memoryContent) {
-    const memTokens = estimateTokens(options.memoryContent)
-    if (memTokens > 0) {
-      categories.push({ name: "Memory", tokens: memTokens })
-    }
-  }
-
-  let messageTokens = 0
-  for (const msg of options.messages) {
-    const text = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content ?? "")
-    messageTokens += estimateTokens(text)
-  }
-  if (messageTokens > 0) {
-    categories.push({ name: "Messages", tokens: messageTokens })
-  }
-
-  const totalTokens = categories.reduce((sum, c) => sum + c.tokens, 0)
-  const maxTokens = getContextWindowForModel(options.model)
-  const percentage = maxTokens > 0 ? Math.round((totalTokens / maxTokens) * 1000) / 10 : 0
-
-  const freeTokens = Math.max(0, maxTokens - totalTokens)
-  categories.push({ name: "Free space", tokens: freeTokens })
-
-  return { categories, totalTokens, maxTokens, percentage, model: options.model }
-}
-
-export function formatContextAnalysis(analysis: ContextAnalysis): string {
-  const lines: string[] = [
-    "## Context Usage",
-    "",
-    `**Model:** ${analysis.model}`,
-    `**Tokens:** ${analysis.totalTokens.toLocaleString()} / ${analysis.maxTokens.toLocaleString()} (${analysis.percentage}%)`,
-    "",
-  ]
-
-  const visible = analysis.categories.filter((c) => c.tokens > 0 && c.name !== "Free space")
-
-  if (visible.length > 0) {
-    lines.push("| Category | Tokens | Percentage |")
-    lines.push("|----------|--------|------------|")
-    for (const cat of visible) {
-      const pct = analysis.maxTokens > 0 ? ((cat.tokens / analysis.maxTokens) * 100).toFixed(1) : "0.0"
-      lines.push(`| ${cat.name} | ${cat.tokens.toLocaleString()} | ${pct}% |`)
-    }
-    const free = analysis.categories.find((c) => c.name === "Free space")
-    if (free && free.tokens > 0) {
-      const pct = analysis.maxTokens > 0 ? ((free.tokens / analysis.maxTokens) * 100).toFixed(1) : "0.0"
-      lines.push(`| Free space | ${free.tokens.toLocaleString()} | ${pct}% |`)
-    }
-    lines.push("")
-  }
-
-  return lines.join("\n")
-}