@ckelsoe/prompt-architect 3.0.0

package/scripts/install.js

@@ -0,0 +1,490 @@
+#!/usr/bin/env node
+
+/**
+ * Prompt Architect — Multi-Agent Installer
+ *
+ * Detects installed AI agents and lets users choose where to install.
+ * Uses @clack/prompts for interactive UI, falls back to non-interactive
+ * for postinstall hooks and CI environments.
+ *
+ * Usage:
+ *   npx @ckelsoe/prompt-architect          # Interactive multi-agent install
+ *   npx @ckelsoe/prompt-architect --all    # Install to all detected agents
+ *   npx @ckelsoe/prompt-architect --claude # Install to Claude Code only
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+// Configuration
+const SKILL_NAME = 'prompt-architect';
+const PACKAGE_NAME = '@ckelsoe/prompt-architect';
+const SKILL_SOURCE_DIR = 'skills';
+
+// ─── Agent Registry ──────────────────────────────────────────────
+
+const AGENTS = [
+  {
+    id: 'claude',
+    name: 'Claude Code',
+    detect: () => fs.existsSync(path.join(os.homedir(), '.claude')),
+    installPath: (project) => project
+      ? path.join(process.cwd(), '.claude', 'skills', SKILL_NAME)
+      : path.join(os.homedir(), '.claude', 'skills', SKILL_NAME),
+    format: 'skill',
+    hint: (project) => project ? '.claude/skills/ (project)' : '~/.claude/skills/',
+  },
+  {
+    id: 'gemini',
+    name: 'Gemini CLI',
+    detect: () => {
+      if (fs.existsSync(path.join(os.homedir(), '.gemini'))) return true;
+      try {
+        execSync(process.platform === 'win32' ? 'where gemini' : 'which gemini', { stdio: 'ignore' });
+        return true;
+      } catch { return false; }
+    },
+    installPath: () => path.join(os.homedir(), '.gemini', 'skills', SKILL_NAME),
+    format: 'skill',
+    hint: () => '~/.gemini/skills/',
+  },
+  {
+    id: 'agents',
+    name: 'Agent Skills (universal)',
+    detect: () => true, // Always available
+    alwaysShow: true,
+    installPath: () => path.join(os.homedir(), '.agents', 'skills', SKILL_NAME),
+    format: 'skill',
+    hint: () => '~/.agents/skills/ (30+ compatible agents)',
+  },
+  {
+    id: 'cursor',
+    name: 'Cursor',
+    detect: () => {
+      return fs.existsSync(path.join(os.homedir(), '.cursor')) ||
+             fs.existsSync(path.join(process.cwd(), '.cursor'));
+    },
+    installPath: () => path.join(process.cwd(), '.cursor', 'rules', 'prompt-architect.mdc'),
+    format: 'adapter',
+    adapterFile: 'for-cursor.mdc',
+    hint: () => '.cursor/rules/ (project)',
+  },
+  {
+    id: 'copilot',
+    name: 'GitHub Copilot',
+    detect: () => {
+      try {
+        execSync(process.platform === 'win32' ? 'where code' : 'which code', { stdio: 'ignore' });
+        return true;
+      } catch {
+        return fs.existsSync(path.join(process.cwd(), '.vscode')) ||
+               fs.existsSync(path.join(process.cwd(), '.github'));
+      }
+    },
+    installPath: () => path.join(process.cwd(), '.github', 'copilot-instructions.md'),
+    format: 'adapter',
+    adapterFile: 'for-github-copilot.md',
+    appendMode: true,
+    hint: () => '.github/copilot-instructions.md (project)',
+  },
+  {
+    id: 'windsurf',
+    name: 'Windsurf',
+    detect: () => {
+      return fs.existsSync(path.join(process.cwd(), '.windsurfrules')) ||
+             fs.existsSync(path.join(os.homedir(), '.windsurf'));
+    },
+    installPath: () => path.join(process.cwd(), '.windsurfrules'),
+    format: 'adapter',
+    adapterFile: 'for-windsurf.md',
+    appendMode: true,
+    hint: () => '.windsurfrules (project)',
+  },
+  {
+    id: 'codex',
+    name: 'OpenAI Codex CLI',
+    detect: () => {
+      try {
+        execSync(process.platform === 'win32' ? 'where codex' : 'which codex', { stdio: 'ignore' });
+        return true;
+      } catch {
+        return fs.existsSync(path.join(process.cwd(), 'AGENTS.md'));
+      }
+    },
+    installPath: () => path.join(process.cwd(), 'AGENTS.md'),
+    format: 'adapter',
+    adapterFile: 'for-openai-codex-cli.md',
+    appendMode: true,
+    hint: () => 'AGENTS.md (project)',
+  },
+];
+
+// ─── Source Path Resolution ──────────────────────────────────────
+
+function findSourcePath() {
+  // Try relative to this script (development or npm package)
+  const fromScript = path.join(__dirname, '..', SKILL_SOURCE_DIR, SKILL_NAME);
+  if (fs.existsSync(fromScript)) return fromScript;
+
+  // Try local node_modules
+  const localPath = path.join(process.cwd(), 'node_modules', PACKAGE_NAME, SKILL_SOURCE_DIR, SKILL_NAME);
+  if (fs.existsSync(localPath)) return localPath;
+
+  // Try global node_modules
+  try {
+    const globalRoot = execSync('npm root -g', { encoding: 'utf8' }).trim();
+    const globalPath = path.join(globalRoot, PACKAGE_NAME, SKILL_SOURCE_DIR, SKILL_NAME);
+    if (fs.existsSync(globalPath)) return globalPath;
+  } catch { /* ignore */ }
+
+  return null;
+}
+
+function findAdaptersPath() {
+  const fromScript = path.join(__dirname, '..', 'adapters');
+  if (fs.existsSync(fromScript)) return fromScript;
+
+  const localPath = path.join(process.cwd(), 'node_modules', PACKAGE_NAME, 'adapters');
+  if (fs.existsSync(localPath)) return localPath;
+
+  try {
+    const globalRoot = execSync('npm root -g', { encoding: 'utf8' }).trim();
+    const globalPath = path.join(globalRoot, PACKAGE_NAME, 'adapters');
+    if (fs.existsSync(globalPath)) return globalPath;
+  } catch { /* ignore */ }
+
+  return null;
+}
+
+// ─── File Operations ─────────────────────────────────────────────
+
+function copyRecursive(src, dest) {
+  const stats = fs.statSync(src);
+  if (stats.isDirectory()) {
+    if (!fs.existsSync(dest)) fs.mkdirSync(dest, { recursive: true });
+    for (const entry of fs.readdirSync(src)) {
+      copyRecursive(path.join(src, entry), path.join(dest, entry));
+    }
+  } else {
+    fs.copyFileSync(src, dest);
+  }
+}
+
+const MARKER_START = '<!-- prompt-architect-start -->';
+const MARKER_END = '<!-- prompt-architect-end -->';
+
+function installSkillDir(sourcePath, destPath) {
+  const parentDir = path.dirname(destPath);
+  if (!fs.existsSync(parentDir)) fs.mkdirSync(parentDir, { recursive: true });
+
+  // Remove existing installation
+  if (fs.existsSync(destPath)) fs.rmSync(destPath, { recursive: true, force: true });
+
+  copyRecursive(sourcePath, destPath);
+
+  // Verify
+  if (!fs.existsSync(path.join(destPath, 'SKILL.md'))) {
+    throw new Error('SKILL.md not found after copy');
+  }
+}
+
+function installAdapter(adaptersPath, agent, destPath) {
+  const adapterSrc = path.join(adaptersPath, agent.adapterFile);
+  if (!fs.existsSync(adapterSrc)) {
+    throw new Error(`Adapter file not found: ${agent.adapterFile}`);
+  }
+
+  const adapterContent = fs.readFileSync(adapterSrc, 'utf8');
+  const markedContent = `\n${MARKER_START}\n${adapterContent}\n${MARKER_END}\n`;
+
+  if (agent.appendMode && fs.existsSync(destPath)) {
+    const existing = fs.readFileSync(destPath, 'utf8');
+    // Remove old content if present
+    const cleaned = existing.replace(
+      new RegExp(`\\n?${escapeRegex(MARKER_START)}[\\s\\S]*?${escapeRegex(MARKER_END)}\\n?`),
+      ''
+    );
+    fs.writeFileSync(destPath, cleaned + markedContent, 'utf8');
+  } else {
+    const parentDir = path.dirname(destPath);
+    if (!fs.existsSync(parentDir)) fs.mkdirSync(parentDir, { recursive: true });
+    fs.writeFileSync(destPath, adapterContent, 'utf8');
+  }
+}
+
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+// ─── Version ─────────────────────────────────────────────────────
+
+function getVersion() {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8'));
+    return pkg.version || 'unknown';
+  } catch { return 'unknown'; }
+}
+
+// ─── CLI Argument Parsing ────────────────────────────────────────
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const flags = {
+    help: args.includes('--help') || args.includes('-h'),
+    all: args.includes('--all') || args.includes('-a'),
+    yes: args.includes('--yes') || args.includes('-y'),
+    force: args.includes('--force') || args.includes('-f'),
+    project: args.includes('--project') || args.includes('-p'),
+    // Individual agent flags
+    claude: args.includes('--claude'),
+    gemini: args.includes('--gemini'),
+    agents: args.includes('--agents'),
+    cursor: args.includes('--cursor'),
+    copilot: args.includes('--copilot'),
+    windsurf: args.includes('--windsurf'),
+    codex: args.includes('--codex'),
+  };
+
+  const specificAgents = ['claude', 'gemini', 'agents', 'cursor', 'copilot', 'windsurf', 'codex']
+    .filter(a => flags[a]);
+
+  return { flags, specificAgents };
+}
+
+// ─── Help ────────────────────────────────────────────────────────
+
+function showHelp() {
+  const version = getVersion();
+  console.log(`
+  Prompt Architect v${version} — Multi-Agent Installer
+
+  Usage:
+    npx ${PACKAGE_NAME}                Interactive multi-agent install
+    npx ${PACKAGE_NAME} --all          Install to all detected agents
+    npx ${PACKAGE_NAME} --claude       Install to Claude Code only
+
+  Agent flags (skip interactive, install to specified targets):
+    --claude       Claude Code (~/.claude/skills/)
+    --gemini       Gemini CLI (~/.gemini/skills/)
+    --agents       Agent Skills universal (~/.agents/skills/)
+    --cursor       Cursor (.cursor/rules/)
+    --copilot      GitHub Copilot (.github/)
+    --windsurf     Windsurf (.windsurfrules)
+    --codex        OpenAI Codex CLI (AGENTS.md)
+
+  Options:
+    -a, --all      Install to all detected agents
+    -p, --project  Use project-local paths where applicable
+    -f, --force    Overwrite existing installations
+    -y, --yes      Accept defaults (all detected agents)
+    -h, --help     Show this help
+`);
+}
+
+// ─── Non-Interactive Install ─────────────────────────────────────
+
+function installNonInteractive(agentIds, sourcePath, adaptersPath, isProject) {
+  const version = getVersion();
+  const results = [];
+
+  for (const agent of AGENTS) {
+    if (!agentIds.includes(agent.id)) continue;
+
+    const destPath = agent.installPath(isProject);
+    try {
+      if (agent.format === 'skill') {
+        installSkillDir(sourcePath, destPath);
+      } else {
+        installAdapter(adaptersPath, agent, destPath);
+      }
+      results.push({ agent: agent.name, path: destPath, success: true });
+    } catch (err) {
+      results.push({ agent: agent.name, path: destPath, success: false, error: err.message });
+    }
+  }
+
+  // Print results
+  console.log(`\n  Prompt Architect v${version}\n`);
+  for (const r of results) {
+    if (r.success) {
+      console.log(`  \x1b[32m✓\x1b[0m ${r.agent} → ${r.path}`);
+    } else {
+      console.log(`  \x1b[31m✗\x1b[0m ${r.agent}: ${r.error}`);
+    }
+  }
+
+  const succeeded = results.filter(r => r.success).length;
+  const failed = results.filter(r => !r.success).length;
+  if (succeeded > 0) {
+    console.log(`\n  \x1b[32m${succeeded} installed successfully.\x1b[0m Restart your AI agent to load the skill.\n`);
+  }
+  if (failed > 0) {
+    console.log(`  \x1b[31m${failed} failed.\x1b[0m\n`);
+    process.exit(1);
+  }
+}
+
+// ─── Interactive Install ─────────────────────────────────────────
+
+async function installInteractive(sourcePath, adaptersPath, isProject) {
+  const p = require('@clack/prompts');
+  const version = getVersion();
+
+  p.intro(`Prompt Architect v${version}`);
+
+  // Detect agents
+  const detected = AGENTS.filter(a => a.detect());
+  const notDetected = AGENTS.filter(a => !a.detect());
+
+  if (detected.length === 0) {
+    p.log.warn('No AI agents detected on your system.');
+    p.log.info('You can still install to any location using the flags below.');
+    showHelp();
+    p.outro('No installation performed.');
+    return;
+  }
+
+  const detectedNames = detected
+    .filter(a => !a.alwaysShow)
+    .map(a => a.name)
+    .join(', ');
+  if (detectedNames) {
+    p.log.info(`Detected: ${detectedNames}`);
+  }
+
+  // Build options — detected first (pre-selected), then others
+  const options = [];
+
+  for (const agent of detected) {
+    options.push({
+      value: agent.id,
+      label: agent.name,
+      hint: agent.hint(isProject),
+    });
+  }
+
+  for (const agent of notDetected) {
+    options.push({
+      value: agent.id,
+      label: `${agent.name} (not detected)`,
+      hint: agent.hint(isProject),
+    });
+  }
+
+  const initialValues = detected
+    .filter(a => !a.alwaysShow) // Don't pre-select "universal" since it's always available
+    .map(a => a.id);
+
+  const selected = await p.multiselect({
+    message: 'Select agents to install for:',
+    options,
+    initialValues,
+    required: true,
+  });
+
+  if (p.isCancel(selected)) {
+    p.cancel('Installation cancelled.');
+    process.exit(0);
+  }
+
+  // Install to each selected agent
+  const s = p.spinner();
+  const results = [];
+
+  for (const agentId of selected) {
+    const agent = AGENTS.find(a => a.id === agentId);
+    if (!agent) continue;
+
+    const destPath = agent.installPath(isProject);
+    s.start(`Installing to ${agent.name}...`);
+
+    try {
+      if (agent.format === 'skill') {
+        installSkillDir(sourcePath, destPath);
+      } else {
+        installAdapter(adaptersPath, agent, destPath);
+      }
+      s.stop(`${agent.name} → ${destPath}`);
+      results.push({ agent: agent.name, success: true });
+    } catch (err) {
+      s.stop(`${agent.name}: ${err.message}`);
+      results.push({ agent: agent.name, success: false, error: err.message });
+    }
+  }
+
+  // Summary
+  const succeeded = results.filter(r => r.success).length;
+  const failed = results.filter(r => !r.success).length;
+
+  if (failed > 0) {
+    p.log.warn(`${failed} installation(s) failed.`);
+  }
+
+  if (succeeded > 0) {
+    p.outro(`${succeeded} agent(s) configured. Restart your AI agent to load the skill.`);
+  } else {
+    p.outro('No installations succeeded.');
+    process.exit(1);
+  }
+}
+
+// ─── Main ────────────────────────────────────────────────────────
+
+async function main() {
+  const { flags, specificAgents } = parseArgs();
+
+  if (flags.help) {
+    showHelp();
+    process.exit(0);
+  }
+
+  // Find source files
+  const sourcePath = findSourcePath();
+  const adaptersPath = findAdaptersPath();
+
+  if (!sourcePath) {
+    console.error(`\n  \x1b[31mError: Could not find ${SKILL_NAME} skill files.\x1b[0m`);
+    console.error(`  Try reinstalling: npm install -g ${PACKAGE_NAME}\n`);
+    process.exit(1);
+  }
+
+  const isProject = flags.project;
+  const isInteractive = process.stdin.isTTY && process.stdout.isTTY && !process.env.CI;
+
+  // Mode 1: Specific agent flags provided
+  if (specificAgents.length > 0) {
+    installNonInteractive(specificAgents, sourcePath, adaptersPath, isProject);
+    return;
+  }
+
+  // Mode 2: --all flag
+  if (flags.all) {
+    const detected = AGENTS.filter(a => a.detect()).map(a => a.id);
+    installNonInteractive(detected, sourcePath, adaptersPath, isProject);
+    return;
+  }
+
+  // Mode 3: --yes flag (accept defaults = all detected, non-interactive)
+  if (flags.yes) {
+    const detected = AGENTS.filter(a => a.detect() && !a.alwaysShow).map(a => a.id);
+    installNonInteractive(detected.length > 0 ? detected : ['claude'], sourcePath, adaptersPath, isProject);
+    return;
+  }
+
+  // Mode 4: Interactive
+  if (isInteractive) {
+    await installInteractive(sourcePath, adaptersPath, isProject);
+    return;
+  }
+
+  // Mode 5: Non-interactive fallback (postinstall, CI)
+  installNonInteractive(['claude'], sourcePath, adaptersPath, isProject);
+  console.log(`  Run \x1b[36mnpx ${PACKAGE_NAME}\x1b[0m for interactive multi-agent setup.\n`);
+}
+
+main().catch(err => {
+  console.error(`\n  \x1b[31mInstallation error: ${err.message}\x1b[0m\n`);
+  process.exit(1);
+});

package/scripts/test.js

@@ -0,0 +1,213 @@
+#!/usr/bin/env node
+
+/**
+ * Test Script
+ * 
+ * Runs basic tests to verify the skill package is properly configured.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const colors = {
+  reset: '\x1b[0m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+};
+
+function log(message, color = 'reset') {
+  console.log(`${colors[color]}${message}${colors.reset}`);
+}
+
+log('\n🧪 Running tests for Prompt Architect skill...\n', 'blue');
+
+let passed = 0;
+let failed = 0;
+
+function test(description, fn) {
+  try {
+    fn();
+    log(`✅ ${description}`, 'green');
+    passed++;
+  } catch (error) {
+    log(`❌ ${description}`, 'red');
+    log(`   ${error.message}`, 'red');
+    failed++;
+  }
+}
+
+// Tests
+test('package.json exists', () => {
+  if (!fs.existsSync('package.json')) throw new Error('Not found');
+});
+
+test('package.json is valid JSON', () => {
+  JSON.parse(fs.readFileSync('package.json', 'utf8'));
+});
+
+test('SKILL.md exists', () => {
+  if (!fs.existsSync('skills/prompt-architect/SKILL.md')) throw new Error('Not found');
+});
+
+test('LICENSE exists', () => {
+  if (!fs.existsSync('LICENSE')) throw new Error('Not found');
+});
+
+test('README.md exists', () => {
+  if (!fs.existsSync('README.md')) throw new Error('Not found');
+});
+
+test('CHANGELOG.md exists', () => {
+  if (!fs.existsSync('CHANGELOG.md')) throw new Error('Not found');
+});
+
+test('All framework files exist', () => {
+  const frameworks = [
+    'co-star.md',
+    'risen.md',
+    'rise.md',
+    'tidd-ec.md',
+    'rtf.md',
+    'chain-of-thought.md',
+    'chain-of-density.md',
+  ];
+  frameworks.forEach(f => {
+    const fpath = path.join('skills', 'prompt-architect', 'references', 'frameworks', f);
+    if (!fs.existsSync(fpath)) {
+      throw new Error(`Framework ${f} not found`);
+    }
+  });
+});
+
+test('All templates exist', () => {
+  const templates = [
+    'co-star_template.txt',
+    'risen_template.txt',
+    'rise-ie_template.txt',
+    'rise-ix_template.txt',
+    'tidd-ec_template.txt',
+    'rtf_template.txt',
+    'hybrid_template.txt',
+  ];
+  templates.forEach(t => {
+    const tpath = path.join('skills', 'prompt-architect', 'assets', 'templates', t);
+    if (!fs.existsSync(tpath)) {
+      throw new Error(`Template ${t} not found`);
+    }
+  });
+});
+
+test('Python scripts exist', () => {
+  const scripts = ['framework_analyzer.py', 'prompt_evaluator.py'];
+  scripts.forEach(s => {
+    const spath = path.join('skills', 'prompt-architect', 'scripts', s);
+    if (!fs.existsSync(spath)) {
+      throw new Error(`Script ${s} not found`);
+    }
+  });
+});
+
+test('package.json has required fields', () => {
+  const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+  const required = ['name', 'version', 'description', 'main', 'keywords', 'license'];
+  required.forEach(field => {
+    if (!pkg[field]) throw new Error(`Missing field: ${field}`);
+  });
+});
+
+test('package.json keywords include "claude-code"', () => {
+  const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+  if (!pkg.keywords || !pkg.keywords.includes('claude-code')) {
+    throw new Error('Missing "claude-code" keyword');
+  }
+});
+
+// Plugin manifest tests
+test('.claude-plugin/plugin.json exists and is valid', () => {
+  const pluginPath = '.claude-plugin/plugin.json';
+  if (!fs.existsSync(pluginPath)) throw new Error('Not found');
+  const plugin = JSON.parse(fs.readFileSync(pluginPath, 'utf8'));
+  if (!plugin.name) throw new Error('Missing name');
+  if (!plugin.description) throw new Error('Missing description');
+  if (!plugin.version) throw new Error('Missing version');
+});
+
+test('.claude-plugin/marketplace.json exists and is valid', () => {
+  const mktPath = '.claude-plugin/marketplace.json';
+  if (!fs.existsSync(mktPath)) throw new Error('Not found');
+  const mkt = JSON.parse(fs.readFileSync(mktPath, 'utf8'));
+  if (!mkt.name) throw new Error('Missing name');
+  if (!mkt.owner) throw new Error('Missing owner');
+  if (!mkt.plugins || mkt.plugins.length === 0) throw new Error('No plugins defined');
+});
+
+test('plugin.json version matches package.json version', () => {
+  const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+  const plugin = JSON.parse(fs.readFileSync('.claude-plugin/plugin.json', 'utf8'));
+  if (pkg.version !== plugin.version) {
+    throw new Error(`Version mismatch: package.json=${pkg.version}, plugin.json=${plugin.version}`);
+  }
+});
+
+// Adapter tests
+test('Gemini CLI adapter exists', () => {
+  if (!fs.existsSync('adapters/for-gemini-cli.md')) throw new Error('Not found');
+});
+
+test('All adapter files exist', () => {
+  const adapters = [
+    'system-prompt.md',
+    'for-openai-codex-cli.md',
+    'for-cursor.mdc',
+    'for-github-copilot.md',
+    'for-windsurf.md',
+    'for-gemini-cli.md',
+    'README.md',
+  ];
+  adapters.forEach(a => {
+    if (!fs.existsSync(path.join('adapters', a))) throw new Error(`Adapter ${a} not found`);
+  });
+});
+
+// Agent Skills compliance tests
+test('SKILL.md has Agent Skills required fields', () => {
+  const content = fs.readFileSync('skills/prompt-architect/SKILL.md', 'utf8');
+  const fm = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!fm) throw new Error('No frontmatter');
+  if (!fm[1].includes('name:')) throw new Error('Missing name');
+  if (!fm[1].includes('description:')) throw new Error('Missing description');
+});
+
+test('SKILL.md has optional Agent Skills fields', () => {
+  const content = fs.readFileSync('skills/prompt-architect/SKILL.md', 'utf8');
+  const fm = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!fm) throw new Error('No frontmatter');
+  if (!fm[1].includes('license:')) throw new Error('Missing license');
+  if (!fm[1].includes('compatibility:')) throw new Error('Missing compatibility');
+  if (!fm[1].includes('metadata:')) throw new Error('Missing metadata');
+});
+
+test('SKILL.md name matches directory name', () => {
+  const content = fs.readFileSync('skills/prompt-architect/SKILL.md', 'utf8');
+  const nameMatch = content.match(/name:\s*([^\n\r]+)/);
+  if (!nameMatch) throw new Error('No name field');
+  if (nameMatch[1].trim() !== 'prompt-architect') {
+    throw new Error(`Name "${nameMatch[1].trim()}" does not match directory "prompt-architect"`);
+  }
+});
+
+// Summary
+log('\n' + '='.repeat(50), 'blue');
+log(`Tests completed: ${passed + failed} total`, 'blue');
+log(`✅ Passed: ${passed}`, 'green');
+if (failed > 0) {
+  log(`❌ Failed: ${failed}`, 'red');
+  log('='.repeat(50) + '\n', 'blue');
+  process.exit(1);
+} else {
+  log('='.repeat(50), 'blue');
+  log('\n✨ All tests passed!\n', 'green');
+  process.exit(0);
+}