@llmtune/cli 0.1.0 → 0.1.1

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()

package/src/marketplace/client.ts

@@ -1,118 +0,0 @@
-/**
- * Skill marketplace client.
- * Interacts with the infra's skill registry API to list, search, install, and publish skills.
- */
-import type { AppConfig } from "../auth/config"
-
-export interface MarketplaceSkill {
-  name: string
-  description: string
-  trustLevel: "local" | "community" | "verified" | "signed"
-  allowedTools: string[]
-  author?: string
-  version?: string
-  installs?: number
-  rating?: number
-  tags?: string[]
-}
-
-export interface SearchResult {
-  skills: MarketplaceSkill[]
-  total: number
-  page: number
-}
-
-function getApiBase(config: AppConfig): string {
-  return String(config.apiBase ?? "https://api.llmtune.io/api/agent/v1").replace(/\/$/, "")
-}
-
-function getHeaders(config: AppConfig): Record<string, string> {
-  return {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${config.apiKey}`,
-  }
-}
-
-/**
- * List all skills in the marketplace.
- */
-export async function listSkills(
-  config: AppConfig,
-  options?: { search?: string; tag?: string; page?: number; limit?: number },
-): Promise<SearchResult> {
-  const base = getApiBase(config)
-  const params = new URLSearchParams()
-  if (options?.search) params.set("search", options.search)
-  if (options?.tag) params.set("tag", options.tag)
-  if (options?.page) params.set("page", String(options.page))
-  if (options?.limit) params.set("limit", String(options.limit))
-
-  const url = `${base}/skills?${params.toString()}`
-  const response = await fetch(url, { headers: getHeaders(config) })
-
-  if (!response.ok) {
-    throw new Error(`Failed to list skills: HTTP ${response.status}`)
-  }
-
-  return (await response.json()) as SearchResult
-}
-
-/**
- * Get details for a specific skill.
- */
-export async function getSkillDetails(config: AppConfig, name: string): Promise<MarketplaceSkill> {
-  const base = getApiBase(config)
-  const url = `${base}/skills/${encodeURIComponent(name)}`
-  const response = await fetch(url, { headers: getHeaders(config) })
-
-  if (!response.ok) {
-    if (response.status === 404) throw new Error(`Skill not found: ${name}`)
-    throw new Error(`Failed to get skill: HTTP ${response.status}`)
-  }
-
-  return (await response.json()) as MarketplaceSkill
-}
-
-/**
- * Install a skill from the marketplace to the local skills directory.
- */
-export async function installSkill(config: AppConfig, name: string): Promise<string> {
-  const base = getApiBase(config)
-  const url = `${base}/skills/install`
-  const response = await fetch(url, {
-    method: "POST",
-    headers: getHeaders(config),
-    body: JSON.stringify({ skillName: name }),
-  })
-
-  if (!response.ok) {
-    const body = await response.text()
-    throw new Error(`Failed to install skill: ${body}`)
-  }
-
-  const data = (await response.json()) as { installPath: string; skillName: string }
-  return data.installPath
-}
-
-/**
- * Publish a local skill to the marketplace.
- */
-export async function publishSkill(
-  config: AppConfig,
-  skill: { name: string; description: string; content: string; trustLevel: string; allowedTools: string[] },
-): Promise<{ published: boolean; skillName: string }> {
-  const base = getApiBase(config)
-  const url = `${base}/skills`
-  const response = await fetch(url, {
-    method: "POST",
-    headers: getHeaders(config),
-    body: JSON.stringify(skill),
-  })
-
-  if (!response.ok) {
-    const body = await response.text()
-    throw new Error(`Failed to publish skill: ${body}`)
-  }
-
-  return (await response.json()) as { published: boolean; skillName: string }
-}

package/src/memory/files.ts

@@ -1,81 +0,0 @@
-import * as fs from "fs"
-import * as path from "path"
-import { getConfigDir } from "../auth/config"
-
-export interface MemoryCategory {
-  key: string
-  filename: string
-  description: string
-}
-
-export const MEMORY_CATEGORIES: MemoryCategory[] = [
-  { key: "preferences", filename: "preferences.md", description: "User preferences (language, style, conventions)" },
-  { key: "project", filename: "project-notes.md", description: "Project knowledge (architecture, patterns, key decisions)" },
-  { key: "decisions", filename: "decisions.md", description: "Past decisions and rationale" },
-  { key: "architecture", filename: "architecture.md", description: "System architecture notes" },
-]
-
-export function getMemoryDir(): string {
-  return path.join(getConfigDir(), "memory")
-}
-
-export function ensureMemoryDir(): void {
-  const dir = getMemoryDir()
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true })
-  }
-  for (const cat of MEMORY_CATEGORIES) {
-    const filePath = path.join(dir, cat.filename)
-    if (!fs.existsSync(filePath)) {
-      fs.writeFileSync(filePath, `# ${cat.description}\n\n`, "utf-8")
-    }
-  }
-}
-
-export function readMemory(key: string): string {
-  const cat = MEMORY_CATEGORIES.find((c) => c.key === key)
-  if (!cat) return ""
-  const filePath = path.join(getMemoryDir(), cat.filename)
-  try {
-    return fs.readFileSync(filePath, "utf-8").trim()
-  } catch {
-    return ""
-  }
-}
-
-export function writeMemory(key: string, content: string): void {
-  const cat = MEMORY_CATEGORIES.find((c) => c.key === key)
-  if (!cat) return
-  ensureMemoryDir()
-  const filePath = path.join(getMemoryDir(), cat.filename)
-  fs.writeFileSync(filePath, content, "utf-8")
-}
-
-export function appendMemory(key: string, line: string): void {
-  const current = readMemory(key)
-  writeMemory(key, current + "\n" + line)
-}
-
-export function readAllMemory(): Record<string, string> {
-  const result: Record<string, string> = {}
-  for (const cat of MEMORY_CATEGORIES) {
-    const content = readMemory(cat.key)
-    if (content) result[cat.key] = content
-  }
-  return result
-}
-
-export function buildMemoryPrompt(): string {
-  const memories = readAllMemory()
-  const entries = Object.entries(memories)
-  if (entries.length === 0) return ""
-  const lines = ["## User Memory"]
-  for (const [key, content] of entries) {
-    const cat = MEMORY_CATEGORIES.find((c) => c.key === key)
-    if (cat && content.trim()) {
-      lines.push(`### ${cat.description}`)
-      lines.push(content)
-    }
-  }
-  return lines.join("\n")
-}