@lythos/skill-deck 0.9.0 → 0.9.2

package/src/validate.test.ts

@@ -0,0 +1,160 @@
+#!/usr/bin/env bun
+/**
+ * validate.test.ts — unit tests for validate.ts
+ *
+ * Run: bun test packages/lythoskill-deck/src/validate.test.ts
+ */
+
+import { describe, it, expect, afterEach } from 'bun:test'
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+import { spawnSync } from 'node:child_process'
+
+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-validate-'))
+  cleanup.push(dir)
+  return dir
+}
+
+function placeSkill(coldPool: string, relPath: string): string {
+  const skillDir = join(coldPool, relPath)
+  mkdirSync(skillDir, { recursive: true })
+  writeFileSync(join(skillDir, 'SKILL.md'), '---\nname: fixture\n---\n')
+  return skillDir
+}
+
+function runValidate(deckPath: string, workdir: string) {
+  return spawnSync('bun', [join(import.meta.dir, 'cli.ts'), 'validate', '--deck', deckPath, '--workdir', workdir], {
+    cwd: workdir,
+    encoding: 'utf-8',
+  })
+}
+
+describe('validateDeck', () => {
+  it('C1: valid deck passes validation', () => {
+    const projectDir = makeTmp()
+    const coldPoolRel = 'cold-pool'
+    const coldPool = join(projectDir, coldPoolRel)
+
+    placeSkill(coldPool, 'github.com/owner/repo/skill')
+
+    const deckContent = `[deck]\nmax_cards = 10\nworking_set = ".claude/skills"\ncold_pool = "${coldPoolRel}"\n\n[tool.skills.my-alias]\npath = "github.com/owner/repo/skill"\n`
+    const deckPath = join(projectDir, 'skill-deck.toml')
+    writeFileSync(deckPath, deckContent)
+
+    const result = runValidate(deckPath, projectDir)
+
+    expect(result.status).toBe(0)
+    expect(result.stdout).toContain('Validation passed')
+  })
+
+  it('C2: missing [deck] section errors', () => {
+    const projectDir = makeTmp()
+    const deckContent = `[tool.skills.foo]\npath = "github.com/owner/repo/skill"\n`
+    const deckPath = join(projectDir, 'skill-deck.toml')
+    writeFileSync(deckPath, deckContent)
+
+    const result = runValidate(deckPath, projectDir)
+
+    expect(result.status).toBe(1)
+    expect(result.stderr).toContain('[deck] section is required')
+  })
+
+  it('C3: invalid max_cards errors', () => {
+    const projectDir = makeTmp()
+    const coldPoolRel = 'cold-pool'
+    const coldPool = join(projectDir, coldPoolRel)
+    placeSkill(coldPool, 'github.com/owner/repo/skill')
+
+    const deckContent = `[deck]\nmax_cards = -1\nworking_set = ".claude/skills"\ncold_pool = "${coldPoolRel}"\n\n[tool.skills.foo]\npath = "github.com/owner/repo/skill"\n`
+    const deckPath = join(projectDir, 'skill-deck.toml')
+    writeFileSync(deckPath, deckContent)
+
+    const result = runValidate(deckPath, projectDir)
+
+    expect(result.status).toBe(1)
+    expect(result.stderr).toContain('deck.max_cards must be a positive integer')
+  })
+
+  it('C4: skill not found in cold pool errors', () => {
+    const projectDir = makeTmp()
+    const coldPoolRel = 'cold-pool'
+    const coldPool = join(projectDir, coldPoolRel)
+    mkdirSync(coldPool, { recursive: true })
+    // do NOT place the skill
+
+    const deckContent = `[deck]\nmax_cards = 10\nworking_set = ".claude/skills"\ncold_pool = "${coldPoolRel}"\n\n[tool.skills.foo]\npath = "github.com/owner/repo/nonexistent"\n`
+    const deckPath = join(projectDir, 'skill-deck.toml')
+    writeFileSync(deckPath, deckContent)
+
+    const result = runValidate(deckPath, projectDir)
+
+    expect(result.status).toBe(1)
+    expect(result.stderr).toContain('Skill not found')
+  })
+
+  it('C5: budget exceeded errors', () => {
+    const projectDir = makeTmp()
+    const coldPoolRel = 'cold-pool'
+    const coldPool = join(projectDir, coldPoolRel)
+    placeSkill(coldPool, 'github.com/owner/repo/skill-a')
+    placeSkill(coldPool, 'github.com/owner/repo/skill-b')
+
+    const deckContent = `[deck]\nmax_cards = 1\nworking_set = ".claude/skills"\ncold_pool = "${coldPoolRel}"\n\n[tool.skills.skill-a]\npath = "github.com/owner/repo/skill-a"\n\n[tool.skills.skill-b]\npath = "github.com/owner/repo/skill-b"\n`
+    const deckPath = join(projectDir, 'skill-deck.toml')
+    writeFileSync(deckPath, deckContent)
+
+    const result = runValidate(deckPath, projectDir)
+
+    expect(result.status).toBe(1)
+    expect(result.stderr).toContain('Budget exceeded')
+  })
+
+  it('C6: toml parse error exits', () => {
+    const projectDir = makeTmp()
+    const deckPath = join(projectDir, 'skill-deck.toml')
+    writeFileSync(deckPath, '[invalid toml\n')
+
+    const result = runValidate(deckPath, projectDir)
+
+    expect(result.status).toBe(1)
+    expect(result.stderr).toContain('TOML parse error')
+  })
+
+  it('C7: deprecated string-array format warns', () => {
+    const projectDir = makeTmp()
+    const coldPoolRel = 'cold-pool'
+    const coldPool = join(projectDir, coldPoolRel)
+    placeSkill(coldPool, 'github.com/owner/repo/skill')
+
+    const deckContent = `[deck]\nmax_cards = 10\nworking_set = ".claude/skills"\ncold_pool = "${coldPoolRel}"\n\n[tool]\nskills = ["github.com/owner/repo/skill"]\n`
+    const deckPath = join(projectDir, 'skill-deck.toml')
+    writeFileSync(deckPath, deckContent)
+
+    const result = runValidate(deckPath, projectDir)
+
+    expect(result.status).toBe(0)
+    expect(result.stderr).toContain('deprecated')
+  })
+
+  it('C8: invalid transient expires errors', () => {
+    const projectDir = makeTmp()
+    const deckPath = join(projectDir, 'skill-deck.toml')
+    writeFileSync(deckPath, `[deck]\nmax_cards = 10\n\n[transient.foo]\npath = "./nonexistent"\nexpires = "not-a-date"\n`)
+
+    const result = runValidate(deckPath, projectDir)
+
+    expect(result.status).toBe(1)
+    expect(result.stderr).toContain('invalid expires')
+  })
+})

package/src/validate.ts

@@ -10,6 +10,7 @@ import { parse as parseToml } from "@iarna/toml";
 import { existsSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { findDeckToml, expandHome, findSource } from "./link.js";
+import { parseDeck } from "./parse-deck.js";
 
 export function validateDeck(cliDeckPath?: string, cliWorkdir?: string): void {
   const PROJECT_DIR = cliWorkdir ? resolve(cliWorkdir) : process.cwd();
@@ -52,33 +53,27 @@ export function validateDeck(cliDeckPath?: string, cliWorkdir?: string): void {
 
   // ── Validate skill declarations ────────────────────────────
 
+  const { entries: parsedEntries, deprecated: isDeprecated, errors: parseErrors } = parseDeck(deckRaw);
+  if (isDeprecated) {
+    warnings.push("string-array skill entries are deprecated. Run `deck migrate-schema` to upgrade.");
+  }
+  errors.push(...parseErrors);
+
   const declaredNames = new Set<string>();
   let declaredCount = 0;
 
-  for (const section of ["innate", "tool", "combo"] as const) {
-    const skills = deck[section]?.skills;
-    if (skills === undefined) continue;
-    if (!Array.isArray(skills)) {
-      errors.push(`[${section}].skills must be an array`);
-      continue;
+  for (const entry of parsedEntries) {
+    declaredCount++;
+    if (declaredNames.has(entry.path)) {
+      warnings.push(`Skill "${entry.path}" is declared in multiple sections`);
     }
-    for (const name of skills) {
-      if (!name || typeof name !== "string") {
-        errors.push(`[${section}] contains invalid skill name`);
-        continue;
-      }
-      declaredCount++;
-      if (declaredNames.has(name)) {
-        warnings.push(`Skill "${name}" is declared in multiple sections`);
-      }
-      declaredNames.add(name);
+    declaredNames.add(entry.path);
 
-      const result = findSource(name, COLD_POOL, PROJECT_DIR);
-      if (result.error) {
-        errors.push(result.error);
-      } else if (!result.path) {
-        errors.push(`Skill not found: ${name} (${section})`);
-      }
+    const result = findSource(entry.path, COLD_POOL, PROJECT_DIR);
+    if (result.error) {
+      errors.push(result.error);
+    } else if (!result.path) {
+      errors.push(`Skill not found: ${entry.path} (${entry.type})`);
     }
   }