@llmtune/cli 0.1.0

package/src/index.ts

@@ -0,0 +1,100 @@
+#!/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

@@ -0,0 +1,118 @@
+/**
+ * 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

@@ -0,0 +1,81 @@
+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")
+}

package/src/memory/service.ts

@@ -0,0 +1,124 @@
+import * as fs from "fs"
+import * as path from "path"
+import * as os from "os"
+
+const MEMORY_DIR = path.join(os.homedir(), ".llmtune", "memory")
+
+const MEMORY_FILES = {
+  preferences: "preferences.md",
+  "project-notes": "project-notes.md",
+  decisions: "decisions.md",
+  architecture: "architecture.md",
+} as const
+
+type MemoryCategory = keyof typeof MEMORY_FILES
+
+export interface MemoryEntry {
+  category: MemoryCategory
+  content: string
+  path: string
+}
+
+function ensureMemoryDir(): void {
+  if (!fs.existsSync(MEMORY_DIR)) {
+    fs.mkdirSync(MEMORY_DIR, { recursive: true })
+  }
+}
+
+function getMemoryPath(category: MemoryCategory): string {
+  return path.join(MEMORY_DIR, MEMORY_FILES[category])
+}
+
+export function readMemory(category: MemoryCategory): string {
+  const filePath = getMemoryPath(category)
+  try {
+    return fs.readFileSync(filePath, "utf-8").trim()
+  } catch {
+    return ""
+  }
+}
+
+export function writeMemory(category: MemoryCategory, content: string): void {
+  ensureMemoryDir()
+  const filePath = getMemoryPath(category)
+  fs.writeFileSync(filePath, content.trim() + "\n", "utf-8")
+}
+
+export function appendMemory(category: MemoryCategory, line: string): void {
+  ensureMemoryDir()
+  const existing = readMemory(category)
+  const updated = existing ? `${existing}\n${line}` : line
+  writeMemory(category, updated)
+}
+
+export function readAllMemory(): MemoryEntry[] {
+  ensureMemoryDir()
+  const entries: MemoryEntry[] = []
+  for (const [category, filename] of Object.entries(MEMORY_FILES)) {
+    const content = readMemory(category as MemoryCategory)
+    if (content) {
+      entries.push({
+        category: category as MemoryCategory,
+        content,
+        path: path.join(MEMORY_DIR, filename),
+      })
+    }
+  }
+  return entries
+}
+
+export function buildMemoryPrompt(): string {
+  const entries = readAllMemory()
+  if (entries.length === 0) return ""
+
+  const sections = entries.map((entry) => {
+    const label = entry.category.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase())
+    return `### ${label}\n${entry.content}`
+  })
+
+  return "## User Memory\n\n" + sections.join("\n\n")
+}
+
+export function clearMemory(category?: MemoryCategory): void {
+  if (category) {
+    const filePath = getMemoryPath(category)
+    try {
+      fs.unlinkSync(filePath)
+    } catch {
+      // file doesn't exist
+    }
+  } else {
+    for (const filename of Object.values(MEMORY_FILES)) {
+      try {
+        fs.unlinkSync(path.join(MEMORY_DIR, filename))
+      } catch {
+        // skip
+      }
+    }
+  }
+}
+
+export function getMemoryDir(): string {
+  return MEMORY_DIR
+}
+
+export function initMemoryFiles(): void {
+  ensureMemoryDir()
+  const defaults: Record<MemoryCategory, string> = {
+    preferences:
+      "# User Preferences\n# Add your coding preferences here (one per line)\n# Example: I prefer TypeScript over JavaScript\n# Example: I use 2-space indentation\n",
+    "project-notes":
+      "# Project Notes\n# Key facts about the current project\n# Example: Auth uses JWT + bcrypt\n# Example: Database is Neon PostgreSQL via Prisma\n",
+    decisions:
+      "# Architecture Decisions\n# Record important technical decisions\n# Example: Decided to use Prisma instead of Drizzle for ORM\n",
+    architecture:
+      "# Architecture Overview\n# Describe the project structure\n# Example: Frontend: Next.js 16, Backend: Express 5, DB: Neon\n",
+  }
+
+  for (const [category, defaultContent] of Object.entries(defaults)) {
+    const filePath = getMemoryPath(category as MemoryCategory)
+    if (!fs.existsSync(filePath)) {
+      fs.writeFileSync(filePath, defaultContent, "utf-8")
+    }
+  }
+}