@lythos/skill-deck 0.7.2 → 0.9.1

package/src/parse-deck.test.ts

@@ -0,0 +1,53 @@
+#!/usr/bin/env bun
+/**
+ * parse-deck.test.ts — unit tests for parse-deck.ts
+ *
+ * Run: bun test packages/lythoskill-deck/src/parse-deck.test.ts
+ */
+
+import { describe, it, expect } from 'bun:test'
+import { parseDeck } from './parse-deck.ts'
+
+describe('parseDeck', () => {
+  it('parses dict format entries', () => {
+    const raw = `[tool.skills.foo]\npath = "github.com/owner/repo"\n`
+    const result = parseDeck(raw)
+    expect(result.entries).toHaveLength(1)
+    expect(result.entries[0].alias).toBe('foo')
+    expect(result.entries[0].path).toBe('github.com/owner/repo')
+    expect(result.entries[0].type).toBe('tool')
+    expect(result.deprecated).toBe(false)
+    expect(result.errors).toHaveLength(0)
+  })
+
+  it('errors when dict entry lacks path', () => {
+    const raw = `[tool.skills.foo]\nname = "foo"\n`
+    const result = parseDeck(raw)
+    expect(result.errors.length).toBeGreaterThan(0)
+    expect(result.errors[0]).toContain('Missing path')
+  })
+
+  it('errors when dict entry has invalid schema', () => {
+    const raw = `[tool.skills.foo]\npath = ""\n`
+    const result = parseDeck(raw)
+    expect(result.errors.length).toBeGreaterThan(0)
+  })
+
+  it('parses legacy string-array format and marks deprecated', () => {
+    const raw = `[tool]\nskills = ["github.com/owner/repo"]\n`
+    const result = parseDeck(raw)
+    expect(result.deprecated).toBe(true)
+    expect(result.entries).toHaveLength(1)
+    expect(result.entries[0].alias).toBe('repo')
+    expect(result.entries[0].path).toBe('github.com/owner/repo')
+    expect(result.entries[0].type).toBe('tool')
+  })
+
+  it('returns empty for deck with no skill sections', () => {
+    const raw = `[deck]\nmax_cards = 10\n`
+    const result = parseDeck(raw)
+    expect(result.entries).toHaveLength(0)
+    expect(result.deprecated).toBe(false)
+    expect(result.errors).toHaveLength(0)
+  })
+})

package/src/parse-deck.ts

@@ -0,0 +1,78 @@
+import { parse as parseToml } from "@iarna/toml";
+import { SkillEntrySchema } from "./schema.js";
+
+export type SkillType = "innate" | "tool" | "combo";
+
+export interface ParsedSkillEntry {
+  alias: string; // working-set flat symlink name = role identity
+  path: string;  // FQ locator or local path
+  type: SkillType;
+  role?: string;
+  why_in_deck?: string;
+  [key: string]: unknown; // forward-compat: unknown fields pass through
+}
+
+export interface ParsedDeck {
+  entries: ParsedSkillEntry[];
+  deprecated: boolean; // true if any section used legacy string-array
+  errors: string[];
+}
+
+export function parseDeck(raw: string): ParsedDeck {
+  const parsed = parseToml(raw) as any;
+  const entries: ParsedSkillEntry[] = [];
+  const errors: string[] = [];
+  let deprecated = false;
+
+  for (const section of ["innate", "tool", "combo"] as const) {
+    const sectionData = parsed[section];
+    if (!sectionData) continue;
+
+    // ── New format: [<type>.skills.<alias>] with path in body ──
+    if (
+      sectionData.skills &&
+      typeof sectionData.skills === "object" &&
+      !Array.isArray(sectionData.skills)
+    ) {
+      for (const [alias, entry] of Object.entries(sectionData.skills)) {
+        const e = entry as Record<string, unknown>;
+        if (!e?.path || typeof e.path !== "string") {
+          errors.push(
+            `Missing path for skill "${alias}" in [${section}.skills.${alias}]`
+          );
+          continue;
+        }
+        const parsedEntry = SkillEntrySchema.safeParse(e);
+        if (!parsedEntry.success) {
+          errors.push(
+            `Invalid entry "${alias}" in [${section}.skills.${alias}]: ${parsedEntry.error.message}`
+          );
+          continue;
+        }
+        entries.push({
+          alias,
+          path: e.path as string,
+          type: section,
+          ...parsedEntry.data,
+        });
+      }
+      continue;
+    }
+
+    // ── Legacy format: [<type>] with skills = ["...", ...] ──
+    const skillsArray = sectionData?.skills;
+    if (Array.isArray(skillsArray)) {
+      deprecated = true;
+      for (const name of skillsArray) {
+        if (!name || typeof name !== "string") continue;
+        entries.push({
+          alias: name.split("/").pop() || name,
+          path: name,
+          type: section,
+        });
+      }
+    }
+  }
+
+  return { entries, deprecated, errors };
+}

package/src/prune.test.ts

@@ -0,0 +1,137 @@
+#!/usr/bin/env bun
+/**
+ * prune.test.ts — unit tests for prune.ts
+ *
+ * Run: bun test packages/lythoskill-deck/src/prune.test.ts
+ */
+
+import { describe, it, expect, afterEach, spyOn } from 'bun:test'
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, readFileSync, existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+
+let cleanup: string[] = []
+
+afterEach(() => {
+  for (const dir of cleanup) {
+    rmSync(dir, { recursive: true, force: true })
+  }
+  cleanup = []
+})
+
+function makeTmp(): string {
+  const dir = mkdtempSync(join(tmpdir(), 'deck-prune-'))
+  cleanup.push(dir)
+  return dir
+}
+
+function placeRepo(coldPool: string, host: string, owner: string, repo: string): string {
+  const repoDir = join(coldPool, host, owner, repo)
+  mkdirSync(repoDir, { recursive: true })
+  return repoDir
+}
+
+function placeSkillInRepo(repoDir: string, skillName: string): string {
+  const skillDir = join(repoDir, 'skills', skillName)
+  mkdirSync(skillDir, { recursive: true })
+  writeFileSync(join(skillDir, 'SKILL.md'), '---\nname: fixture\n---\n')
+  return skillDir
+}
+
+describe('pruneDeck', () => {
+  it('C15: prune with unreferenced repos deletes them when --yes is set', async () => {
+    const projectDir = makeTmp()
+    const coldPoolRel = 'cold-pool'
+    const coldPool = join(projectDir, coldPoolRel)
+
+    const repoA = placeRepo(coldPool, 'github.com', 'owner', 'repo-a')
+    placeSkillInRepo(repoA, 'skill-a')
+
+    const repoB = placeRepo(coldPool, 'github.com', 'owner', 'repo-b')
+    placeSkillInRepo(repoB, 'skill-b')
+
+    const deckContent = `[deck]\nmax_cards = 10\nworking_set = ".claude/skills"\ncold_pool = "${coldPoolRel}"\n\n[tool.skills.skill-a]\npath = "github.com/owner/repo-a/skill-a"\n`
+    const deckPath = join(projectDir, 'skill-deck.toml')
+    writeFileSync(deckPath, deckContent)
+
+    const { pruneDeck } = await import('./prune.ts')
+    await pruneDeck(deckPath, projectDir, true)
+
+    expect(existsSync(repoA)).toBe(true)
+    expect(existsSync(join(repoA, 'skills', 'skill-a', 'SKILL.md'))).toBe(true)
+
+    expect(existsSync(repoB)).toBe(false)
+  })
+
+  it('C16: prune with all referenced repos is a no-op', async () => {
+    const projectDir = makeTmp()
+    const coldPoolRel = 'cold-pool'
+    const coldPool = join(projectDir, coldPoolRel)
+
+    const repoA = placeRepo(coldPool, 'github.com', 'owner', 'repo-a')
+    placeSkillInRepo(repoA, 'skill-a')
+
+    const deckContent = `[deck]\nmax_cards = 10\nworking_set = ".claude/skills"\ncold_pool = "${coldPoolRel}"\n\n[tool.skills.skill-a]\npath = "github.com/owner/repo-a/skill-a"\n`
+    const deckPath = join(projectDir, 'skill-deck.toml')
+    writeFileSync(deckPath, deckContent)
+
+    const logs: string[] = []
+    const logSpy = spyOn(console, 'log').mockImplementation((msg: string) => {
+      logs.push(String(msg))
+    })
+
+    const originalExit = process.exit
+    let exitCode: number | undefined
+    process.exit = ((code?: number) => {
+      exitCode = code ?? 0
+      throw new Error(`EXIT:${code}`)
+    }) as typeof process.exit
+
+    try {
+      const { pruneDeck } = await import('./prune.ts')
+      await pruneDeck(deckPath, projectDir, true)
+      expect(false).toBe(true)
+    } catch (err: any) {
+      expect(exitCode).toBe(0)
+      expect(logs.some(l => l.includes('Nothing to prune'))).toBe(true)
+    } finally {
+      process.exit = originalExit
+      logSpy.mockRestore()
+    }
+  })
+
+  it('C17: prune with empty cold pool reports nothing to prune', async () => {
+    const projectDir = makeTmp()
+    const coldPoolRel = 'cold-pool'
+    const coldPool = join(projectDir, coldPoolRel)
+    mkdirSync(coldPool, { recursive: true })
+
+    const deckContent = `[deck]\nmax_cards = 10\nworking_set = ".claude/skills"\ncold_pool = "${coldPoolRel}"\n`
+    const deckPath = join(projectDir, 'skill-deck.toml')
+    writeFileSync(deckPath, deckContent)
+
+    const logs: string[] = []
+    const logSpy = spyOn(console, 'log').mockImplementation((msg: string) => {
+      logs.push(String(msg))
+    })
+
+    const originalExit = process.exit
+    let exitCode: number | undefined
+    process.exit = ((code?: number) => {
+      exitCode = code ?? 0
+      throw new Error(`EXIT:${code}`)
+    }) as typeof process.exit
+
+    try {
+      const { pruneDeck } = await import('./prune.ts')
+      await pruneDeck(deckPath, projectDir, true)
+      expect(false).toBe(true)
+    } catch (err: any) {
+      expect(exitCode).toBe(0)
+      expect(logs.some(l => l.includes('empty'))).toBe(true)
+    } finally {
+      process.exit = originalExit
+      logSpy.mockRestore()
+    }
+  })
+})

package/src/prune.ts

@@ -0,0 +1,196 @@
+#!/usr/bin/env bun
+/**
+ * deck-prune.ts — Cold pool garbage collection
+ *
+ * Scans the cold pool for repositories no longer referenced by any
+ * skill-deck.toml declaration and offers to delete them.
+ * Does NOT modify deck.toml or the working set.
+ */
+
+import { parse as parseToml } from "@iarna/toml";
+import { existsSync, readFileSync, readdirSync, statSync, rmSync } from "node:fs";
+import { resolve, dirname, join, relative } from "node:path";
+import { createInterface } from "node:readline";
+import { findDeckToml, expandHome, findSource } from "./link.js";
+import { parseDeck } from "./parse-deck.js";
+
+interface PruneCandidate {
+  repoPath: string;
+  repoRel: string;
+  size: number;
+}
+
+function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}GB`;
+}
+
+function calculateDirSize(dir: string): number {
+  let total = 0;
+  try {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const p = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        total += calculateDirSize(p);
+      } else if (entry.isFile()) {
+        total += statSync(p).size;
+      }
+    }
+  } catch {}
+  return total;
+}
+
+function scanColdPoolRepos(coldPool: string): string[] {
+  const repos: string[] = [];
+  try {
+    for (const host of readdirSync(coldPool, { withFileTypes: true })) {
+      if (!host.isDirectory() || host.name.startsWith(".")) continue;
+      const hostPath = join(coldPool, host.name);
+      for (const owner of readdirSync(hostPath, { withFileTypes: true })) {
+        if (!owner.isDirectory() || owner.name.startsWith(".")) continue;
+        const ownerPath = join(hostPath, owner.name);
+        for (const repo of readdirSync(ownerPath, { withFileTypes: true })) {
+          if (!repo.isDirectory() || repo.name.startsWith(".")) continue;
+          repos.push(join(ownerPath, repo.name));
+        }
+      }
+    }
+  } catch {}
+  return repos;
+}
+
+function isRepoReferenced(repoPath: string, declaredPaths: string[], coldPool: string, projectDir: string): boolean {
+  for (const path of declaredPaths) {
+    const result = findSource(path, coldPool, projectDir);
+    if (result.path) {
+      // Check if the resolved skill path is inside this repo
+      const rel = relative(repoPath, result.path);
+      if (!rel.startsWith("..") && rel !== "") {
+        return true;
+      }
+      if (result.path === repoPath) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+async function confirm(message: string): Promise<boolean> {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(`${message} (y/N) `, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase() === "y");
+    });
+  });
+}
+
+export async function pruneDeck(cliDeckPath?: string, cliWorkdir?: string, yes?: boolean): Promise<void> {
+  const cliDeck = cliDeckPath || process.argv.find((_, i, a) => a[i - 1] === "--deck");
+  const DECK_PATH = cliDeck
+    ? resolve(cliDeck)
+    : findDeckToml(process.cwd()) || resolve("skill-deck.toml");
+
+  if (!existsSync(DECK_PATH)) {
+    console.error(`❌ skill-deck.toml not found in ${process.cwd()}`);
+    console.error(`\nCreate one or specify a path: bunx @lythos/skill-deck link --deck /path/to/deck.toml`);
+    process.exit(1);
+  }
+
+  const PROJECT_DIR = cliWorkdir ? resolve(cliWorkdir) : dirname(DECK_PATH);
+  const deckRaw = readFileSync(DECK_PATH, "utf-8");
+  const deck = parseToml(deckRaw) as any;
+
+  const COLD_POOL = expandHome(deck.deck?.cold_pool || "~/.agents/skill-repos", PROJECT_DIR);
+
+  // ── 收集声明 ────────────────────────────────────────────────
+
+  const { entries: parsedEntries } = parseDeck(deckRaw);
+  const declaredPaths = parsedEntries.map(e => e.path);
+
+  // Legacy string-array fallback
+  for (const section of ["innate", "tool", "combo"] as const) {
+    const skills = deck[section]?.skills;
+    if (Array.isArray(skills)) {
+      for (const name of skills) {
+        if (name && typeof name === "string" && !declaredPaths.includes(name)) {
+          declaredPaths.push(name);
+        }
+      }
+    }
+  }
+
+  // ── 扫描 cold pool ──────────────────────────────────────────
+
+  if (!existsSync(COLD_POOL)) {
+    console.log("📭 Cold pool does not exist. Nothing to prune.");
+    process.exit(0);
+  }
+
+  const allRepos = scanColdPoolRepos(COLD_POOL);
+  if (allRepos.length === 0) {
+    console.log("📭 Cold pool is empty. Nothing to prune.");
+    process.exit(0);
+  }
+
+  // ── 求差集 ──────────────────────────────────────────────────
+
+  const candidates: PruneCandidate[] = [];
+  for (const repoPath of allRepos) {
+    if (isRepoReferenced(repoPath, declaredPaths, COLD_POOL, PROJECT_DIR)) continue;
+    const size = calculateDirSize(repoPath);
+    candidates.push({ repoPath, repoRel: relative(COLD_POOL, repoPath), size });
+  }
+
+  if (candidates.length === 0) {
+    console.log("✅ All cold pool repositories are referenced. Nothing to prune.");
+    process.exit(0);
+  }
+
+  // ── 报告 ────────────────────────────────────────────────────
+
+  const totalSize = candidates.reduce((sum, c) => sum + c.size, 0);
+  console.log(`\n🧹 Prune candidates — ${candidates.length} repo(s), ${formatSize(totalSize)} total:\n`);
+  for (const c of candidates) {
+    console.log(`   ${c.repoRel} (${formatSize(c.size)})`);
+  }
+
+  // ── 确认 ────────────────────────────────────────────────────
+
+  let shouldDelete = false;
+  if (yes) {
+    shouldDelete = true;
+    console.log("\n⚠️  --yes flag set: deleting without confirmation.");
+  } else {
+    shouldDelete = await confirm(`\nDelete ${candidates.length} unreferenced repo(s)?`);
+  }
+
+  if (!shouldDelete) {
+    console.log("❎ Prune cancelled.");
+    process.exit(0);
+  }
+
+  // ── 执行删除 ────────────────────────────────────────────────
+
+  let deleted = 0;
+  let failed = 0;
+  for (const c of candidates) {
+    try {
+      rmSync(c.repoPath, { recursive: true, force: true });
+      console.log(`  🗑️  Deleted: ${c.repoRel}`);
+      deleted++;
+    } catch (err: any) {
+      console.error(`  ❌ Failed to delete ${c.repoRel}: ${err.message}`);
+      failed++;
+    }
+  }
+
+  console.log(`\n📦 Prune complete: ${deleted} deleted, ${failed} failed`);
+
+  if (failed > 0) {
+    process.exit(1);
+  }
+}