@llmtune/cli 0.1.0

package/src/compact/service.ts

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

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

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

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

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

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

@@ -0,0 +1,139 @@
+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 [];
+  }
+}