prizmkit 1.0.16 → 1.0.18

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.0.16",
-  "bundledAt": "2026-03-15T13:35:03.135Z",
-  "bundledFrom": "d609245"
+  "frameworkVersion": "1.0.18",
+  "bundledAt": "2026-03-15T15:11:59.897Z",
+  "bundledFrom": "fed9f20"
 }

package/bundled/dev-pipeline/lib/common.sh

@@ -32,9 +32,10 @@ log_success() { echo -e "${GREEN}[SUCCESS]${NC} $(date '+%Y-%m-%d %H:%M:%S') $*"
 #   PLATFORM
 #   PRIZMKIT_PLATFORM
 prizm_detect_cli_and_platform() {
+    local _raw_cli=""
+
     if [[ -n "${AI_CLI:-}" ]]; then
-        CLI_CMD="$AI_CLI"
-    # Read from .prizmkit/config.json if present
+        _raw_cli="$AI_CLI"
     elif [[ -f ".prizmkit/config.json" ]]; then
         _config_ai_cli=$(python3 -c "
 import json, sys
@@ -46,31 +47,33 @@ try:
 except: pass
 " 2>/dev/null || true)
         if [[ -n "$_config_ai_cli" ]]; then
-            CLI_CMD="$_config_ai_cli"
+            _raw_cli="$_config_ai_cli"
         elif [[ -n "${CODEBUDDY_CLI:-}" ]]; then
-            CLI_CMD="$CODEBUDDY_CLI"
+            _raw_cli="$CODEBUDDY_CLI"
         elif command -v cbc &>/dev/null; then
-            CLI_CMD="cbc"
+            _raw_cli="cbc"
         elif command -v claude &>/dev/null; then
-            CLI_CMD="claude"
+            _raw_cli="claude"
         else
             echo "ERROR: No AI CLI found. Install CodeBuddy (cbc) or Claude Code (claude)." >&2
             exit 1
         fi
     elif [[ -n "${CODEBUDDY_CLI:-}" ]]; then
-        CLI_CMD="$CODEBUDDY_CLI"
+        _raw_cli="$CODEBUDDY_CLI"
     elif command -v cbc &>/dev/null; then
-        CLI_CMD="cbc"
+        _raw_cli="cbc"
     elif command -v claude &>/dev/null; then
-        CLI_CMD="claude"
+        _raw_cli="claude"
     else
         echo "ERROR: No AI CLI found. Install CodeBuddy (cbc) or Claude Code (claude)." >&2
         exit 1
     fi
 
+    CLI_CMD="$_raw_cli"
+
     if [[ -n "${PRIZMKIT_PLATFORM:-}" ]]; then
         PLATFORM="$PRIZMKIT_PLATFORM"
-    elif [[ "$CLI_CMD" == *"claude"* ]]; then
+    elif [[ "$_raw_cli" == *"claude"* ]]; then
         PLATFORM="claude"
     else
         PLATFORM="codebuddy"

package/bundled/skills/_metadata.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.0.16",
+  "version": "1.0.18",
   "skills": {
     "prizm-kit": {
       "description": "Full-lifecycle dev toolkit. Covers spec-driven development, Prizm context docs, code quality, debugging, deployment, and knowledge management.",
@@ -335,43 +335,24 @@
     }
   },
   "external_skills": {
-    "registries": [
-      {
-        "name": "skills.sh",
-        "url": "https://skills.sh/registry.json",
-        "description": "Community skill registry"
-      }
-    ],
     "known": [
       {
-        "name": "find-skill",
-        "description": "Intelligent file and code search skill",
-        "source": "https://skills.sh/skills/find-skill/SKILL.md",
-        "registry": "skills.sh",
+        "name": "find-skills",
+        "description": "Helps discover and install agent skills by capability",
+        "repo": "https://github.com/vercel-labs/skills",
         "tags": [
           "search",
           "utility"
         ]
       },
       {
-        "name": "uiuxpromax",
+        "name": "ui-ux-pro-max",
         "description": "UI/UX design review and suggestions",
-        "source": "https://skills.sh/skills/uiuxpromax/SKILL.md",
-        "registry": "skills.sh",
+        "repo": "https://github.com/nextlevelbuilder/ui-ux-pro-max-skill",
         "tags": [
           "design",
           "frontend"
         ]
-      },
-      {
-        "name": "thinkthought",
-        "description": "Structured reasoning and problem decomposition",
-        "source": "https://skills.sh/skills/thinkthought/SKILL.md",
-        "registry": "skills.sh",
-        "tags": [
-          "reasoning",
-          "universal"
-        ]
       }
     ]
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prizmkit",
-  "version": "1.0.16",
+  "version": "1.0.18",
   "description": "Create a new PrizmKit-powered project with clean initialization — no framework dev files, just what you need.",
   "type": "module",
   "bin": {

package/src/clean.js

@@ -1,6 +1,7 @@
 import chalk from 'chalk';
 import path from 'path';
 import fs from 'fs-extra';
+import { loadMetadata, loadRulesMetadata } from './metadata.js';
 
 async function removePath(targetPath, dryRun) {
   if (!await fs.pathExists(targetPath)) {
@@ -13,6 +14,38 @@ async function removePath(targetPath, dryRun) {
   return { path: targetPath, removed: true };
 }
 
+/**
+ * Remove known PrizmKit files from a shared directory (skills, agents, rules, commands).
+ * Leaves user-created files untouched. Removes the parent dir if it becomes empty.
+ */
+async function removeKnownEntries(parentDir, entries, dryRun) {
+  const results = [];
+
+  for (const entry of entries) {
+    const abs = path.join(parentDir, entry);
+    if (!await fs.pathExists(abs)) continue;
+
+    if (dryRun) {
+      results.push({ path: abs, removed: false, reason: 'dry_run' });
+      continue;
+    }
+
+    await fs.remove(abs);
+    results.push({ path: abs, removed: true });
+  }
+
+  // Remove parent dir only if it now exists and is empty
+  if (!dryRun && await fs.pathExists(parentDir)) {
+    const remaining = await fs.readdir(parentDir);
+    if (remaining.length === 0) {
+      await fs.remove(parentDir);
+      results.push({ path: parentDir, removed: true, note: '(empty dir)' });
+    }
+  }
+
+  return results;
+}
+
 async function cleanGitignore(projectRoot, dryRun) {
   const gitignorePath = path.join(projectRoot, '.gitignore');
   if (!await fs.pathExists(gitignorePath)) {
@@ -48,30 +81,78 @@ export async function runClean(directory, options = {}) {
   console.log(`  预览模式: ${dryRun ? chalk.yellow('是') : chalk.green('否')}`);
   console.log('');
 
-  const targets = [
+  // Load metadata to know exactly which files PrizmKit owns
+  const [metadata, rulesMeta] = await Promise.all([
+    loadMetadata().catch(() => ({ skills: {}, external_skills: { known: [] } })),
+    loadRulesMetadata().catch(() => ({ rules: {} })),
+  ]);
+
+  const skillNames = Object.keys(metadata.skills);
+  const externalSkillNames = (metadata.external_skills?.known || []).map(s => s.name);
+  const allSkillNames = [...new Set([...skillNames, ...externalSkillNames])];
+
+  // Agent file names installed by PrizmKit
+  const agentFiles = [
+    'prizm-dev-team-coordinator.md',
+    'prizm-dev-team-dev.md',
+    'prizm-dev-team-pm.md',
+    'prizm-dev-team-reviewer.md',
+  ];
+
+  // Rule file names installed by PrizmKit (basename without category prefix)
+  const ruleFileNames = Object.keys(metadata_rules_to_filenames(rulesMeta));
+
+  const results = [];
+
+  // ── Full removes (100% PrizmKit-owned paths) ──────────────────────────────
+  const fullRemoveTargets = [
     '.prizmkit',
     '.dev-team',
     'dev-pipeline',
+    '.prizm-docs',        // AI-generated project context docs
     'CODEBUDDY.md',
     'CLAUDE.md',
-    path.join('.codebuddy', 'skills'),
-    path.join('.codebuddy', 'agents'),
     path.join('.codebuddy', 'settings.json'),
-    path.join('.claude', 'commands'),
-    path.join('.claude', 'agents'),
-    path.join('.claude', 'rules'),
     path.join('.claude', 'settings.json'),
     path.join('.claude', 'team-info.json'),
   ];
 
-  const results = [];
-  for (const rel of targets) {
+  for (const rel of fullRemoveTargets) {
     const abs = path.join(projectRoot, rel);
     results.push(await removePath(abs, dryRun));
   }
 
+  // ── Selective removes (shared dirs — only remove PrizmKit-known entries) ──
+
+  // .claude/commands/ — skills installed as .md files or subdirs
+  const claudeCommandsDir = path.join(projectRoot, '.claude', 'commands');
+  const claudeCommandEntries = allSkillNames.flatMap(name => [name, `${name}.md`]);
+  results.push(...await removeKnownEntries(claudeCommandsDir, claudeCommandEntries, dryRun));
+
+  // .codebuddy/skills/ — skills installed as subdirectories
+  const cbSkillsDir = path.join(projectRoot, '.codebuddy', 'skills');
+  results.push(...await removeKnownEntries(cbSkillsDir, allSkillNames, dryRun));
+
+  // .claude/agents/ — PrizmKit agent files
+  const claudeAgentsDir = path.join(projectRoot, '.claude', 'agents');
+  results.push(...await removeKnownEntries(claudeAgentsDir, agentFiles, dryRun));
+
+  // .codebuddy/agents/ — same agent files
+  const cbAgentsDir = path.join(projectRoot, '.codebuddy', 'agents');
+  results.push(...await removeKnownEntries(cbAgentsDir, agentFiles, dryRun));
+
+  // .claude/rules/ — PrizmKit rule .md files
+  const claudeRulesDir = path.join(projectRoot, '.claude', 'rules');
+  results.push(...await removeKnownEntries(claudeRulesDir, ruleFileNames.map(n => `${n}.md`), dryRun));
+
+  // .codebuddy/rules/ — PrizmKit rule .mdc files
+  const cbRulesDir = path.join(projectRoot, '.codebuddy', 'rules');
+  results.push(...await removeKnownEntries(cbRulesDir, ruleFileNames.map(n => `${n}.mdc`), dryRun));
+
+  // ── .gitignore cleanup ────────────────────────────────────────────────────
   const gitignoreResult = await cleanGitignore(projectRoot, dryRun);
 
+  // ── Global team (optional) ────────────────────────────────────────────────
   if (cleanGlobalTeam) {
     const homeDir = process.env.HOME || process.env.USERPROFILE;
     if (homeDir) {
@@ -80,13 +161,15 @@ export async function runClean(directory, options = {}) {
     }
   }
 
+  // ── Output ────────────────────────────────────────────────────────────────
   const removed = results.filter(r => r.removed).length;
   const found = results.filter(r => r.reason !== 'not_found').length;
 
   console.log(chalk.bold('  清理结果:'));
   for (const item of results) {
     if (item.removed) {
-      console.log(chalk.green(`    ✓ 已删除: ${item.path}`));
+      const note = item.note ? chalk.gray(` ${item.note}`) : '';
+      console.log(chalk.green(`    ✓ 已删除: ${item.path}`) + note);
     } else if (item.reason === 'dry_run') {
       console.log(chalk.gray(`    [dry-run] ${item.path}`));
     }
@@ -107,4 +190,20 @@ export async function runClean(directory, options = {}) {
     console.log(chalk.green(`  清理完成：已删除 ${removed} 项。`));
   }
   console.log('');
+  console.log(chalk.gray('  注意：.prizm-docs/ 为 AI 生成的项目上下文文档，已一并清理。'));
+  console.log(chalk.gray('        用户自定义的 agent/skill/rule 文件未受影响。'));
+  console.log('');
+}
+
+/**
+ * Extract base file names from rules metadata (strip category prefix).
+ * e.g. "prizm/prizm-documentation" -> "prizm-documentation"
+ */
+function metadata_rules_to_filenames(rulesMeta) {
+  const names = {};
+  for (const key of Object.keys(rulesMeta.rules || {})) {
+    const basename = key.split('/').pop();
+    names[basename] = true;
+  }
+  return names;
 }

package/src/external-skills.js

@@ -1,71 +1,139 @@
 /**
  * External Skills Installer
- * Fetches and installs third-party skills from remote URLs.
+ *
+ * Delegates to `npx skills add <repo> --skill <name> --yes` to fetch the skill.
+ * When run non-interactively (stdio: 'pipe'), npx skills only writes the canonical
+ * .agents/skills/<name>/SKILL.md without creating any platform symlinks.
+ * We read that file, copy it to the selected platform dir(s), then clean up
+ * .agents/ and skills-lock.json.
  */
 
-import https from 'node:https';
-import http from 'node:http';
+import { execSync } from 'node:child_process';
 import path from 'path';
 import fs from 'fs-extra';
 
 /**
- * Fetch content from a remote URL (supports http and https)
- * @param {string} url - Remote URL to fetch
- * @returns {Promise<string>} - Content string
+ * @param {Object} skill        - Skill definition from external_skills.known
+ *   skill.repo  {string}       - GitHub URL
+ *   skill.name  {string}       - Skill name as listed in the repo
+ * @param {string} platform     - 'claude' | 'codebuddy' | 'both'
+ * @param {string} projectRoot  - Target project root
+ * @param {boolean} dryRun
  */
-export function fetchRemoteSkill(skill) {
-  return new Promise((resolve, reject) => {
-    const url = skill.source;
-    const protocol = url.startsWith('https://') ? https : http;
-
-    const request = protocol.get(url, (res) => {
-      if (res.statusCode === 301 || res.statusCode === 302) {
-        // Follow redirect
-        const redirectSkill = { ...skill, source: res.headers.location };
-        resolve(fetchRemoteSkill(redirectSkill));
-        return;
-      }
+export async function installExternalSkill(skill, platform, projectRoot, dryRun) {
+  if (!skill.repo) {
+    throw new Error(`Skill "${skill.name}" has no repo URL defined`);
+  }
 
-      if (res.statusCode !== 200) {
-        reject(new Error(`HTTP ${res.statusCode}: ${url}`));
-        return;
-      }
+  const cmd = `npx skills add ${skill.repo} --skill ${skill.name} --yes`;
+
+  if (dryRun) {
+    const targets = getTargetDirs(platform, projectRoot)
+      .map(d => path.relative(projectRoot, path.join(d, skill.name, 'SKILL.md')));
+    console.log(`      [dry-run] ${cmd}`);
+    for (const t of targets) console.log(`      [dry-run] → ${t}`);
+    return;
+  }
+
+  // stdio: 'pipe' → npx skills runs non-interactively, writes only .agents/skills/<name>/SKILL.md
+  execSync(cmd, { cwd: projectRoot, stdio: 'pipe', timeout: 60000 });
+
+  const canonicalSkillMd = path.join(projectRoot, '.agents', 'skills', skill.name, 'SKILL.md');
+  if (!await fs.pathExists(canonicalSkillMd)) {
+    throw new Error(`npx skills did not produce .agents/skills/${skill.name}/SKILL.md`);
+  }
+
+  const content = await fs.readFile(canonicalSkillMd, 'utf8');
+
+  // Copy to selected platform dir(s)
+  // npx skills may have created symlinks (e.g. .claude/skills/<name> -> ../../.agents/skills/<name>)
+  // We must remove those symlinks first so we can write a real directory with the actual content.
+  for (const targetDir of getTargetDirs(platform, projectRoot)) {
+    const skillDir = path.join(targetDir, skill.name);
+    // Remove any existing symlink or directory at this path before creating a real dir
+    await fs.remove(skillDir).catch(() => {});
+    await fs.ensureDir(skillDir);
+    await fs.writeFile(path.join(skillDir, 'SKILL.md'), content);
+  }
 
-      const chunks = [];
-      res.on('data', chunk => chunks.push(chunk));
-      res.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
-      res.on('error', reject);
-    });
-
-    request.on('error', reject);
-    request.setTimeout(15000, () => {
-      request.destroy();
-      reject(new Error(`Timeout fetching ${url}`));
-    });
-  });
+  // Clean up npx skills artifacts after copying
+  await fs.remove(path.join(projectRoot, '.agents')).catch(() => {});
+  await fs.remove(path.join(projectRoot, 'skills-lock.json')).catch(() => {});
 }
 
 /**
- * Install an external skill to the target platform directory.
- * @param {Object} skill - Skill definition from external_skills.known
- * @param {string} platform - 'codebuddy' | 'claude'
- * @param {string} projectRoot - Target project root
- * @param {boolean} dryRun - If true, don't write files
+ * Remove all artifacts created by `npx skills` that are not needed by PrizmKit.
+ * Call this once after all external skills have been installed.
+ *
+ * @param {string} projectRoot
+ * @param {string} platform - 'claude' | 'codebuddy' | 'both'
  */
-export async function installExternalSkill(skill, platform, projectRoot, dryRun) {
-  const content = await fetchRemoteSkill(skill);
+export async function cleanExternalSkillArtifacts(projectRoot, platform) {
+  const keepDirs = new Set(
+    getTargetDirs(platform, projectRoot).map(d => path.resolve(d))
+  );
 
-  if (dryRun) {
-    return;
+  const dirsToCheck = [
+    '.agents',
+    '.agent',
+    '.trae',
+    'skills',
+    '.claude/skills',
+    '.codebuddy/skills',
+  ];
+
+  for (const dir of dirsToCheck) {
+    const abs = path.join(projectRoot, dir);
+    if (keepDirs.has(path.resolve(abs))) continue;
+    await fs.remove(abs).catch(() => {});
+  }
+
+  // Remove any dangling symlinks inside kept platform skill dirs
+  // (npx skills creates symlinks like .claude/skills/<name> -> ../../.agents/skills/<name>)
+  for (const keepDir of keepDirs) {
+    if (!await fs.pathExists(keepDir)) continue;
+    let entries;
+    try { entries = await fs.readdir(keepDir); } catch { continue; }
+    for (const entry of entries) {
+      const entryPath = path.join(keepDir, entry);
+      try {
+        const stat = await fs.lstat(entryPath);
+        if (stat.isSymbolicLink()) {
+          await fs.remove(entryPath);
+        }
+      } catch { /* ignore */ }
+    }
   }
 
+  // Remove empty parent dirs left behind (e.g. .codebuddy/ after removing .codebuddy/skills)
+  const parentDirs = ['.claude', '.codebuddy', '.trae', '.agent'];
+  for (const dir of parentDirs) {
+    const abs = path.join(projectRoot, dir);
+    if (!await fs.pathExists(abs)) continue;
+    // Only remove if this platform dir is entirely unneeded
+    const isKept = getTargetDirs(platform, projectRoot)
+      .some(d => path.resolve(d).startsWith(path.resolve(abs) + path.sep));
+    if (isKept) continue;
+    try {
+      const entries = await fs.readdir(abs);
+      if (entries.length === 0) {
+        await fs.remove(abs);
+      }
+    } catch { /* ignore */ }
+  }
+
+  await fs.remove(path.join(projectRoot, 'skills-lock.json')).catch(() => {});
+}
+
+function getTargetDirs(platform, projectRoot) {
+  if (platform === 'both') {
+    return [
+      path.join(projectRoot, '.claude', 'skills'),
+      path.join(projectRoot, '.codebuddy', 'skills'),
+    ];
+  }
   if (platform === 'codebuddy') {
-    const targetDir = path.join(projectRoot, '.codebuddy', 'skills', skill.name);
-    await fs.ensureDir(targetDir);
-    await fs.writeFile(path.join(targetDir, 'SKILL.md'), content);
-  } else if (platform === 'claude') {
-    const targetDir = path.join(projectRoot, '.claude', 'commands');
-    await fs.ensureDir(targetDir);
-    await fs.writeFile(path.join(targetDir, `${skill.name}.md`), content);
+    return [path.join(projectRoot, '.codebuddy', 'skills')];
   }
+  return [path.join(projectRoot, '.claude', 'skills')];
 }

package/src/scaffold.js

@@ -697,23 +697,24 @@ export async function scaffold(config) {
 
   // 9. 安装外部 Skills（如果选择了）
   if (externalSkills?.length) {
-    const { installExternalSkill } = await import('./external-skills.js');
+    const { installExternalSkill, cleanExternalSkillArtifacts } = await import('./external-skills.js');
     const metadata = await loadMetadata();
     const knownSkills = metadata.external_skills?.known || [];
     console.log(chalk.blue('\n    外部技能:'));
     for (const name of externalSkills) {
       const skillDef = knownSkills.find(s => s.name === name);
       if (skillDef) {
-        for (const p of platforms) {
-          try {
-            await installExternalSkill(skillDef, p, projectRoot, dryRun);
-            console.log(chalk.green(`      ✓ ${name} (external)`));
-          } catch (e) {
-            console.log(chalk.yellow(`      ⚠ ${name} 拉取失败，跳过: ${e.message}`));
-          }
+        try {
+          await installExternalSkill(skillDef, platform, projectRoot, dryRun);
+          console.log(chalk.green(`      ✓ ${name} (external)`));
+        } catch (e) {
+          console.log(chalk.yellow(`      ⚠ ${name} 安装失败，跳过: ${e.message}`));
         }
       }
     }
+    if (!dryRun) {
+      await cleanExternalSkillArtifacts(projectRoot, platform);
+    }
   }
 
   // 10. Git pre-commit hook