@llmtune/cli 0.1.0 → 0.1.2

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

package/src/memory/service.ts

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