@llmtune/cli 0.1.0 → 0.1.2

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

package/src/context/builder.ts

@@ -1,123 +0,0 @@
-import * as path from "path"
-import * as crypto from "crypto"
-import * as fs from "fs"
-import { collectGitContext, type GitContext } from "./git-context"
-import { buildWorkspaceSnapshot, renderWorkspaceSection, type WorkspaceSnapshot } from "./workspace"
-import { loadProjectInstructions } from "./llmtune-md"
-
-export interface ContextResult {
-  prompt: string
-  cacheKey: string
-  cacheHit: boolean
-  sections: string[]
-}
-
-const CACHE_DIR = () => {
-  const base = process.env.LLMTUNE_CACHE_DIR || path.join(process.env.HOME || process.env.USERPROFILE || "~", ".llmtune", "cache")
-  return base
-}
-
-function getCachePath(cacheKey: string): string {
-  return path.join(CACHE_DIR(), `${cacheKey}.json`)
-}
-
-export function computeCacheKey(workspaceRoot: string, cwd: string): string {
-  const git = collectGitContext(workspaceRoot)
-  const base = `${workspaceRoot}:${cwd}`
-  if (git.available && git.recentCommit) {
-    return crypto.createHash("sha256").update(`${base}:${git.recentCommit}`).digest("hex").slice(0, 16)
-  }
-  return crypto.createHash("sha256").update(base).digest("hex").slice(0, 16)
-}
-
-export function readCache(cacheKey: string): ContextResult | null {
-  try {
-    const cachePath = getCachePath(cacheKey)
-    if (fs.existsSync(cachePath)) {
-      const stat = fs.statSync(cachePath)
-      const ageMs = Date.now() - stat.mtimeMs
-      if (ageMs > 30 * 60 * 1000) return null
-      const data = JSON.parse(fs.readFileSync(cachePath, "utf-8"))
-      return { ...data, cacheHit: true }
-    }
-  } catch {}
-  return null
-}
-
-export function writeCache(cacheKey: string, result: ContextResult): void {
-  try {
-    const cacheDir = CACHE_DIR()
-    if (!fs.existsSync(cacheDir)) {
-      fs.mkdirSync(cacheDir, { recursive: true })
-    }
-    const cachePath = getCachePath(cacheKey)
-    fs.writeFileSync(cachePath, JSON.stringify({ ...result, cacheHit: false }, null, 2))
-  } catch {}
-}
-
-export async function buildContextPrompt(
-  workspaceRoot: string,
-  cwd: string,
-  options?: { useCache?: boolean }
-): Promise<ContextResult> {
-  const cacheKey = computeCacheKey(workspaceRoot, cwd)
-
-  if (options?.useCache !== false) {
-    const cached = readCache(cacheKey)
-    if (cached) return cached
-  }
-
-  const sections: string[] = []
-
-  // Workspace section (async)
-  const workspace = await buildWorkspaceSnapshot(workspaceRoot, cwd)
-  const workspaceSection = renderWorkspaceSection(workspace)
-  if (workspaceSection) sections.push(workspaceSection)
-
-  // Git section
-  const git = collectGitContext(workspaceRoot)
-  const gitSection = renderGitSection(git)
-  if (gitSection) sections.push(gitSection)
-
-  // LLMTUNE.md / CLAUDE.md section
-  const mdFiles = loadProjectInstructions(workspaceRoot, cwd)
-  const mdSection = renderMdSection(mdFiles, workspaceRoot)
-  if (mdSection) sections.push(mdSection)
-
-  const prompt = sections.join("\n\n")
-
-  const result: ContextResult = {
-    prompt,
-    cacheKey,
-    cacheHit: false,
-    sections,
-  }
-
-  writeCache(cacheKey, result)
-  return result
-}
-
-function renderGitSection(git: GitContext): string {
-  if (!git.available) return ""
-  const lines = ["## Git Context"]
-  if (git.branch) lines.push(`- Current branch: ${git.branch}`)
-  if (git.recentCommit) lines.push(`- Latest commit: ${git.recentCommit}`)
-  if (git.status) {
-    lines.push("- Git status snapshot:", "```text", git.status.slice(0, 2000), "```")
-  }
-  return lines.join("\n")
-}
-
-function renderMdSection(
-  files: Array<{ path: string; content: string }>,
-  workspaceRoot: string
-): string {
-  if (files.length === 0) return ""
-  const lines = ["## Project Instructions"]
-  for (const f of files) {
-    const relative = path.relative(workspaceRoot, f.path)
-    const label = relative ? `./${relative}` : f.path
-    lines.push(`### ${label}`, "```md", f.content.slice(0, 4000), "```")
-  }
-  return lines.join("\n")
-}

package/src/context/cache.ts

@@ -1,11 +0,0 @@
-import { buildContextPrompt, type ContextResult } from "./builder"
-
-export type { ContextResult }
-
-export async function getContext(
-  workspaceRoot: string,
-  cwd: string,
-  options?: { useCache?: boolean }
-): Promise<ContextResult> {
-  return buildContextPrompt(workspaceRoot, cwd, options)
-}

package/src/context/git-context.ts

@@ -1,58 +0,0 @@
-import { execSync } from "child_process";
-import { join } from "path";
-
-export interface GitContext {
-  available: boolean;
-  repoRoot: string | null;
-  branch: string | null;
-  recentCommit: string | null;
-  status: string | null;
-}
-
-export function collectGitContext(workspaceRoot: string): GitContext {
-  try {
-    const gitDir = execSync("git rev-parse --show-toplevel 2>/dev/null", {
-      cwd: workspaceRoot,
-      encoding: "utf-8",
-      timeout: 5000,
-    }).trim();
-
-    if (!gitDir) {
-      return { available: false, repoRoot: null, branch: null, recentCommit: null, status: null };
-    }
-
-    const branch = execSync("git rev-parse --abbrev-ref HEAD 2>/dev/null", {
-      cwd: gitDir,
-      encoding: "utf-8",
-      timeout: 5000,
-    }).trim();
-
-    const recentCommit = execSync("git log -1 --oneline 2>/dev/null", {
-      cwd: gitDir,
-      encoding: "utf-8",
-      timeout: 5000,
-    }).trim();
-
-    let status: string | null = null;
-    try {
-      const raw = execSync("git status --short 2>/dev/null", {
-        cwd: gitDir,
-        encoding: "utf-8",
-        timeout: 5000,
-      }).trim();
-      if (raw) {
-        const lines = raw.split("\n").slice(0, 30);
-        status = lines.join("\n");
-        if (raw.split("\n").length > 30) {
-          status += `\n... ${raw.split("\n").length - 30} more files`;
-        }
-      }
-    } catch {
-      // status unavailable, non-critical
-    }
-
-    return { available: true, repoRoot: gitDir, branch, recentCommit, status };
-  } catch {
-    return { available: false, repoRoot: null, branch: null, recentCommit: null, status: null };
-  }
-}

package/src/context/llmtune-md.ts

@@ -1,48 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-
-export interface MarkdownFile {
-  path: string;
-  content: string;
-}
-
-const FILENAMES = ["LLMTUNE.md", "CLAUDE.md", ".llmtune", ".claude"];
-
-export function loadProjectInstructions(
-  workspaceRoot: string,
-  cwd: string
-): MarkdownFile[] {
-  const files: MarkdownFile[] = [];
-  const seen = new Set<string>();
-
-  const dirsToCheck = [cwd];
-  let current = cwd;
-  while (current !== workspaceRoot && current !== path.dirname(current)) {
-    current = path.dirname(current);
-    dirsToCheck.push(current);
-  }
-  dirsToCheck.push(workspaceRoot);
-
-  for (const dir of dirsToCheck) {
-    for (const filename of FILENAMES) {
-      const filePath = path.join(dir, filename);
-      const resolved = path.resolve(filePath);
-      if (seen.has(resolved)) continue;
-
-      try {
-        const stat = fs.statSync(filePath);
-        if (stat.isFile()) {
-          const content = fs.readFileSync(filePath, "utf-8");
-          if (content.trim()) {
-            seen.add(resolved);
-            files.push({ path: resolved, content: content.trim() });
-          }
-        }
-      } catch {
-        // file doesn't exist, skip
-      }
-    }
-  }
-
-  return files;
-}

package/src/context/workspace.ts

@@ -1,139 +0,0 @@
-import { readdir, stat } from "fs/promises";
-import { join, relative, extname } from "path";
-
-export interface WorkspaceSnapshot {
-  workspace_root: string;
-  current_directory: string;
-  top_level_entries: string[];
-  key_files: string[];
-  total_files: number;
-  file_type_counts: Record<string, number>;
-}
-
-const KEY_FILE_NAMES = new Set([
-  "package.json",
-  "tsconfig.json",
-  "Cargo.toml",
-  "go.mod",
-  "pyproject.toml",
-  "requirements.txt",
-  "Makefile",
-  "Dockerfile",
-  "docker-compose.yml",
-  "README.md",
-  "CLAUDE.md",
-  "LLMTUNE.md",
-  ".env.example",
-  ".gitignore",
-  "prisma",
-  "schema.prisma",
-]);
-
-const IGNORED_DIRS = new Set([
-  "node_modules",
-  ".git",
-  "__pycache__",
-  ".next",
-  "dist",
-  "build",
-  ".venv",
-  "venv",
-  ".tox",
-  "target",
-  ".cache",
-  ".turbo",
-  "coverage",
-]);
-
-export async function buildWorkspaceSnapshot(
-  workspaceRoot: string,
-  cwd?: string,
-): Promise<WorkspaceSnapshot> {
-  const root = workspaceRoot;
-  const current = cwd ?? workspaceRoot;
-
-  const topEntries = await safeReaddir(root);
-  const topLevelEntries = topEntries.map((e) => e.name);
-
-  const keyFiles: string[] = [];
-  const fileTypeCounts: Record<string, number> = {};
-  let totalFiles = 0;
-
-  await walkDir(root, "", async (name, relPath, isDir) => {
-    if (isDir) return;
-    totalFiles++;
-    const ext = extname(name).toLowerCase();
-    fileTypeCounts[ext] = (fileTypeCounts[ext] ?? 0) + 1;
-    if (KEY_FILE_NAMES.has(name)) {
-      keyFiles.push(relative(root, join(root, relPath, name)));
-    }
-  });
-
-  return {
-    workspace_root: root,
-    current_directory: current,
-    top_level_entries: topLevelEntries.slice(0, 30),
-    key_files: keyFiles.slice(0, 20),
-    total_files: totalFiles,
-    file_type_counts: fileTypeCounts,
-  };
-}
-
-export function renderWorkspaceSection(snapshot: WorkspaceSnapshot): string {
-  const today = new Date().toISOString().split("T")[0];
-  const lines = [
-    "## Runtime Context",
-    `- Today's date: ${today}`,
-    `- Workspace root: ${snapshot.workspace_root}`,
-    `- Current directory: ${snapshot.current_directory}`,
-    `- Total files: ${snapshot.total_files}`,
-  ];
-
-  const topExts = Object.entries(snapshot.file_type_counts)
-    .sort((a, b) => b[1] - a[1])
-    .slice(0, 5)
-    .map(([ext, count]) => `${ext || "none"}: ${count}`);
-  if (topExts.length > 0) {
-    lines.push(`- Top file types: ${topExts.join(", ")}`);
-  }
-
-  if (snapshot.key_files.length > 0) {
-    lines.push(`- Key files: ${snapshot.key_files.join(", ")}`);
-  }
-
-  if (snapshot.top_level_entries.length > 0) {
-    lines.push(
-      `- Top-level entries: ${snapshot.top_level_entries.slice(0, 15).join(", ")}`,
-    );
-  }
-
-  return lines.join("\n");
-}
-
-async function walkDir(
-  root: string,
-  relDir: string,
-  visitor: (name: string, relPath: string, isDir: boolean) => Promise<void>,
-  depth = 0,
-): Promise<void> {
-  if (depth > 3) return;
-  const entries = await safeReaddir(join(root, relDir));
-  for (const entry of entries) {
-    if (IGNORED_DIRS.has(entry.name)) continue;
-    const relPath = relDir ? `${relDir}/${entry.name}` : entry.name;
-    const isDir = entry.isDirectory();
-    await visitor(entry.name, relDir, isDir);
-    if (isDir && depth < 3) {
-      await walkDir(root, relPath, visitor, depth + 1);
-    }
-  }
-}
-
-async function safeReaddir(dirPath: string) {
-  try {
-    const entries = await readdir(dirPath, { withFileTypes: true });
-    return entries;
-  } catch {
-    return [];
-  }
-}

package/src/index.ts

@@ -1,100 +0,0 @@
-#!/usr/bin/env node
-import { Command } from "commander"
-import chalk from "chalk"
-import { loadConfig, isLoggedIn } from "./auth/config"
-import { createClient } from "./auth/client"
-import { startRepl } from "./repl/repl"
-
-const program = new Command()
-
-program
-  .name("llmtune")
-  .description("LLMTune CLI - AI coding agent powered by api.llmtune.io")
-  .version("0.1.0")
-
-program
-  .command("login")
-  .description("Configure API key and settings")
-  .action(async () => {
-    const { loginCommand } = await import("./commands/login")
-    await loginCommand()
-  })
-
-program
-  .command("chat")
-  .description("Start interactive coding session")
-  .option("-m, --model <model>", "Model to use")
-  .option("--no-stream", "Disable streaming")
-  .action(async (options: { model?: string; stream?: boolean }) => {
-    if (!isLoggedIn()) {
-      console.log(chalk.red('Not logged in. Run "llmtune login" first.'))
-      process.exit(1)
-    }
-    const config = loadConfig()
-    const client = createClient()
-    const model = options.model ?? (config.defaultModel as string) ?? "z-ai/GLM-5.1"
-    const apiBase = (config.apiBase as string) ?? "https://api.llmtune.io/api/agent/v1"
-
-    console.log(chalk.cyan("\nLLMTune CLI"))
-    console.log(chalk.dim(`Connected to ${apiBase}`))
-    console.log(chalk.dim(`Model: ${model}`))
-    console.log(chalk.dim("Type /help for commands, /exit to quit\n"))
-
-    await startRepl({ client, model, stream: options.stream !== false })
-  })
-
-program
-  .command("models")
-  .description("List available models")
-  .action(async () => {
-    const { modelsCommand } = await import("./commands/models")
-    await modelsCommand()
-  })
-
-program
-  .command("config")
-  .description("Show current configuration")
-  .action(async () => {
-    const { showConfig } = await import("./commands/config")
-    showConfig()
-  })
-
-// Skills marketplace commands
-const skillsCmd = program.command("skills").description("Manage skills (list, install, publish, sign)")
-
-skillsCmd
-  .command("list")
-  .description("List available skills from marketplace")
-  .action(async () => {
-    const { listSkillsCommand } = await import("./commands/marketplace")
-    await listSkillsCommand()
-  })
-
-skillsCmd
-  .command("install")
-  .description("Install a skill from the marketplace")
-  .argument("<name>", "Skill name to install")
-  .action(async (name: string) => {
-    const { installSkillCommand } = await import("./commands/marketplace")
-    await installSkillCommand(name)
-  })
-
-skillsCmd
-  .command("publish")
-  .description("Publish a local skill to the marketplace")
-  .argument("<path>", "Path to skill directory")
-  .action(async (skillPath: string) => {
-    const { publishSkillCommand } = await import("./commands/marketplace")
-    await publishSkillCommand(skillPath)
-  })
-
-skillsCmd
-  .command("sign")
-  .description("Cryptographically sign a skill")
-  .argument("<path>", "Path to skill directory")
-  .action(async (skillPath: string) => {
-    const { signSkillCommand } = await import("./commands/marketplace")
-    await signSkillCommand(skillPath)
-  })
-
-program.parse()