@llmtune/cli 0.1.0

package/src/auth/config.ts

@@ -0,0 +1,89 @@
+import fs from "fs"
+import path from "path"
+import os from "os"
+
+const CONFIG_DIR = path.join(os.homedir(), ".llmtune")
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json")
+
+export interface AuthConfig {
+  apiKey: string
+  apiBase: string
+  defaultModel?: string
+}
+
+export interface AppConfig {
+  defaultProvider?: string
+  providers?: Record<string, AuthConfig>
+  [key: string]: unknown
+}
+
+export function ensureConfigDir(): void {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true })
+  }
+  const memDir = path.join(CONFIG_DIR, "memory")
+  if (!fs.existsSync(memDir)) {
+    fs.mkdirSync(memDir, { recursive: true })
+  }
+  const sessionsDir = path.join(CONFIG_DIR, "sessions")
+  if (!fs.existsSync(sessionsDir)) {
+    fs.mkdirSync(sessionsDir, { recursive: true })
+  }
+  const logsDir = path.join(CONFIG_DIR, "logs")
+  if (!fs.existsSync(logsDir)) {
+    fs.mkdirSync(logsDir, { recursive: true })
+  }
+}
+
+export function loadConfig(): AppConfig {
+  ensureConfigDir()
+  if (!fs.existsSync(CONFIG_FILE)) {
+    return {}
+  }
+  try {
+    const raw = fs.readFileSync(CONFIG_FILE, "utf-8")
+    return JSON.parse(raw) as AppConfig
+  } catch {
+    return {}
+  }
+}
+
+export function saveConfig(config: AppConfig): void {
+  ensureConfigDir()
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8")
+}
+
+export function getApiKey(): string | null {
+  const config = loadConfig()
+  return (config.apiKey as string) ?? null
+}
+
+export function getApiBase(): string {
+  const config = loadConfig()
+  return (config.apiBase as string) ?? "https://api.llmtune.io/api/agent/v1"
+}
+
+export function getDefaultModel(): string {
+  const config = loadConfig()
+  return (config.defaultModel as string) ?? "z-ai/GLM-5.1"
+}
+
+export function isLoggedIn(): boolean {
+  return getApiKey() !== null
+}
+
+export function logout(): void {
+  const config = loadConfig()
+  delete config.apiKey
+  delete config.apiBase
+  delete config.defaultModel
+  saveConfig(config)
+}
+
+export function getConfigPath(): string {
+  return CONFIG_FILE
+}
+
+export function getConfigDir(): string {
+  return CONFIG_DIR
+}

package/src/commands/chat.ts

@@ -0,0 +1,28 @@
+import chalk from "chalk";
+import { loadConfig, getApiBase } from "../auth/config.js";
+import { createClient } from "../auth/client.js";
+import { startRepl } from "../repl/repl.js";
+
+export async function chatCommand(options: {
+  model?: string;
+  stream?: boolean;
+}) {
+  const config = loadConfig();
+
+  if (!config.apiKey) {
+    console.log(chalk.red('No API key configured. Run "llmtune login" first.'));
+    process.exit(1);
+  }
+
+  const client = createClient();
+  const model = options.model || (config.defaultModel as string) || "z-ai/GLM-5.1";
+  const stream = options.stream !== false;
+
+  console.log(chalk.cyan(`\nLLMTune CLI`));
+  console.log(chalk.dim(`Connected to ${getApiBase()}`));
+  console.log(chalk.dim(`Model: ${model}`));
+  console.log(chalk.dim(`Stream: ${stream}`));
+  console.log(chalk.dim(`Type /help for commands, /exit to quit\n`));
+
+  await startRepl({ client, model, stream });
+}

package/src/commands/config.ts

@@ -0,0 +1,36 @@
+import chalk from "chalk";
+import { loadConfig, getConfigPath } from "../auth/config";
+
+export function showConfig(): void {
+  const configPath = getConfigPath();
+
+  try {
+    const config = loadConfig();
+    console.log(chalk.bold("\nConfiguration\n"));
+    console.log(`  Config file: ${chalk.cyan(configPath)}`);
+    const apiKey = config.apiKey as string | undefined
+    const apiBase = config.apiBase as string | undefined
+    const defaultModel = config.defaultModel as string | undefined
+    console.log(`  API base:    ${chalk.cyan(apiBase ?? "(not set)")}`);
+    console.log(`  Default model: ${chalk.cyan(defaultModel || "(not set)")}`);
+
+    if (apiKey) {
+      const masked =
+        apiKey.length > 12
+          ? `${apiKey.slice(0, 6)}...${apiKey.slice(-4)}`
+          : "(set)";
+      console.log(`  API key:     ${chalk.green(masked)}`);
+    } else {
+      console.log(`  API key:     ${chalk.red("(not set)")}`);
+      console.log(
+        chalk.dim(`\n  Run ${chalk.bold("llmtune login")} to configure your API key.`)
+      );
+    }
+    console.log();
+  } catch {
+    console.log(chalk.dim(`\n  No config found at ${configPath}`));
+    console.log(
+      chalk.dim(`  Run ${chalk.bold("llmtune login")} to get started.\n`)
+    );
+  }
+}

package/src/commands/login.ts

@@ -0,0 +1,63 @@
+import * as readline from "readline"
+import chalk from "chalk"
+import { saveConfig, loadConfig, getConfigPath } from "../auth/config"
+
+function ask(question: string, defaultValue?: string): Promise<string> {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+  const prompt = defaultValue ? `${question} (${defaultValue})` : question
+  return new Promise((resolve) => {
+    rl.question(`${prompt}: `, (answer) => {
+      rl.close()
+      resolve(answer.trim() || defaultValue || "")
+    })
+  })
+}
+
+function askPassword(question: string): Promise<string> {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+  return new Promise((resolve) => {
+    rl.question(`${question}: `, (answer) => {
+      rl.close()
+      resolve(answer.trim())
+    })
+  })
+}
+
+function maskKey(key: string): string {
+  if (key.length <= 12) return "sk_***"
+  return `${key.slice(0, 5)}...${key.slice(-4)}`
+}
+
+export async function loginCommand(): Promise<void> {
+  console.log(chalk.blue.bold("\nLLMTune CLI - API Configuration\n"))
+
+  const configPath = getConfigPath()
+  const existing = loadConfig()
+
+  const existingKey = (existing.apiKey as string) || ""
+  const existingUrl = (existing.apiBase as string) || "https://api.llmtune.io/api/agent/v1"
+  const existingModel = (existing.defaultModel as string) || ""
+
+  console.log(chalk.dim(`Config file: ${configPath}\n`))
+
+  const key = await askPassword("Enter your LLMTune API key (sk_...)")
+  if (!key) {
+    console.log(chalk.red("\nAPI key is required."))
+    process.exit(1)
+  }
+
+  const apiBase = await ask("API base URL", existingUrl)
+  const model = await ask("Default model (leave empty for auto)", existingModel || undefined)
+
+  saveConfig({
+    apiKey: key,
+    apiBase: apiBase.replace(/\/$/, ""),
+    defaultModel: model || undefined,
+  })
+
+  console.log(chalk.green("\nConfiguration saved!"))
+  console.log(`  API key: ${maskKey(key)}`)
+  console.log(`  API base: ${apiBase}`)
+  console.log(`  Model: ${model || "auto"}`)
+  console.log(chalk.dim(`\nRun ${chalk.bold("llmtune chat")} to start.\n`))
+}

package/src/commands/marketplace.ts

@@ -0,0 +1,190 @@
+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

@@ -0,0 +1,74 @@
+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

@@ -0,0 +1,101 @@
+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

@@ -0,0 +1,49 @@
+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}`
+}