@negikirin/repo-pattern 0.1.1

package/scripts/lib/skills.mjs

@@ -0,0 +1,249 @@
+import { execFile, execFileSync } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+import { appendGitignoreLine, backupPaths, copyRecursive, ensureDir, exists, readJson, removePath, writeJson } from "./fs-utils.mjs";
+import { isInteractive, printSummary, withSpinner } from "./prompt.mjs";
+
+const execFileAsync = promisify(execFile);
+
+export const OPTIONAL_SKILLS = [
+  {
+    value: "taste",
+    label: "taste",
+    description: "UI taste/design skills (MIT)",
+    source: "https://github.com/Leonxlnx/taste-skill.git",
+    revision: "b17742737e796305d829b3ad39eda3add0d79060",
+    license: "MIT",
+    installedDirs: ["brandkit", "brutalist-skill", "gpt-tasteskill", "imagegen-frontend-mobile", "imagegen-frontend-web", "image-to-code-skill", "minimalist-skill", "output-skill", "redesign-skill", "soft-skill", "stitch-skill", "taste-skill", "taste-skill-v1"],
+    sourceDir: "skills"
+  },
+  {
+    value: "document-specialist",
+    label: "document-specialist",
+    description: "documentation specialist skill (license not declared; user opt-in only)",
+    source: "https://github.com/SpillwaveSolutions/document-specialist-skill.git",
+    revision: "4d50d302b9f40e8eafec72d78a86676cdd9511ac",
+    license: "NOASSERTION",
+    installedDirs: ["document-specialist-skill"],
+    destName: "document-specialist-skill"
+  },
+  {
+    value: "ui-ux-pro-max",
+    label: "ui-ux-pro-max",
+    description: "UI/UX design intelligence skill (MIT; requires Python 3.x)",
+    source: "https://github.com/nextlevelbuilder/ui-ux-pro-max-skill.git",
+    revision: "4baa399d00da806f83ed93652172f66943205153",
+    license: "MIT",
+    installedDirs: ["ui-ux-pro-max"],
+    sourceSubdir: ".claude/skills/ui-ux-pro-max",
+    destName: "ui-ux-pro-max"
+  },
+  {
+    value: "impeccable",
+    label: "impeccable",
+    description: "visual design QA skill-only install (Apache-2.0; scripts require Node >=24)",
+    source: "https://github.com/pbakaus/impeccable.git",
+    revision: "88f52ac4e6a5ce99d39a0f5d89e7ac3a168910f5",
+    license: "Apache-2.0",
+    installedDirs: ["impeccable"],
+    sourceSubdir: ".claude/skills/impeccable",
+    destName: "impeccable",
+    partialClone: true
+  },
+  {
+    value: "huashu-design",
+    label: "huashu-design",
+    description: "multimedia design skill (MIT; may require Node, Playwright, Python, ffmpeg)",
+    source: "https://github.com/alchaincyf/huashu-design.git",
+    revision: "0e7ec8aca0058184c1a9e06e57697e84f68a3f0f",
+    license: "MIT",
+    installedDirs: ["huashu-design"],
+    includePaths: ["SKILL.md", "assets", "references", "scripts", "demos", "package.json", "package-lock.json", "README.md", "README.en.md", "LICENSE"],
+    destName: "huashu-design",
+    partialClone: true
+  }
+];
+
+function knownSkill(value) {
+  return OPTIONAL_SKILLS.find((skill) => skill.value === value);
+}
+
+export function normalizeOptionalSkills(skills = []) {
+  return [...new Set((skills || []).filter(Boolean))];
+}
+
+export function invalidOptionalSkills(skills = []) {
+  return normalizeOptionalSkills(skills).filter((skill) => !knownSkill(skill));
+}
+
+export function expectedOptionalSkillDirs(optionalSkills = []) {
+  return [...new Set(optionalSkills.flatMap((entry) => {
+    const skill = knownSkill(entry?.name);
+    if (!skill || skill.source !== entry?.source || skill.revision !== entry?.revision) return [];
+    return skill.installedDirs;
+  }))].sort();
+}
+
+function runGit(args, cwd, { quiet = false } = {}) {
+  execFileSync("git", args, {
+    cwd,
+    stdio: quiet ? "ignore" : "inherit"
+  });
+}
+
+function gitOutput(args, cwd) {
+  return execFileSync("git", args, { cwd, encoding: "utf8" }).trim();
+}
+
+async function runGitAsync(args, cwd) {
+  await execFileAsync("git", args, { cwd });
+}
+
+function verifyRevision(cacheDir, skill) {
+  const actual = gitOutput(["rev-parse", "HEAD"], cacheDir);
+  if (actual !== skill.revision) throw new Error(`${skill.value} cache revision mismatch: expected ${skill.revision}, got ${actual}`);
+}
+
+async function rejectSymlinks(root) {
+  const stat = await fs.lstat(root);
+  if (stat.isSymbolicLink()) throw new Error(`Optional skill source contains symlink: ${root}`);
+  if (!stat.isDirectory()) return;
+
+  const entries = await fs.readdir(root, { withFileTypes: true });
+  for (const entry of entries) {
+    await rejectSymlinks(path.join(root, entry.name));
+  }
+}
+
+async function syncSkillCache(target, skill, { dryRun = false } = {}) {
+  const cacheRoot = path.join(target, ".repo-pattern", "cache", "skills");
+  const cacheDir = path.join(cacheRoot, skill.value);
+  const cloneArgs = ["clone", ...(skill.partialClone ? ["--filter=blob:none"] : []), skill.source, cacheDir];
+
+  if (exists(path.join(cacheDir, ".git"))) {
+    if (!dryRun) {
+      runGit(["fetch", "--quiet", "origin", skill.revision], cacheDir);
+      runGit(["checkout", "--quiet", skill.revision], cacheDir);
+      verifyRevision(cacheDir, skill);
+    }
+    return cacheDir;
+  }
+
+  if (dryRun) {
+    console.log(`[dry-run] git ${cloneArgs.join(" ")}`);
+    console.log(`[dry-run] git -C ${cacheDir} checkout ${skill.revision}`);
+    return cacheDir;
+  }
+
+  await ensureDir(cacheRoot);
+  if (isInteractive()) {
+    await withSpinner(`Syncing ${skill.value}`, async () => {
+      await runGitAsync(["clone", "--quiet", ...cloneArgs.slice(1)], target);
+      await runGitAsync(["checkout", "--quiet", skill.revision], cacheDir);
+    });
+  } else {
+    console.log(`Syncing ${skill.value} from ${skill.source}`);
+    runGit(cloneArgs, target);
+    runGit(["checkout", "--quiet", skill.revision], cacheDir);
+  }
+  verifyRevision(cacheDir, skill);
+  return cacheDir;
+}
+
+async function copySkill(skill, cacheDir, destRoot, { dryRun = false } = {}) {
+  if (skill.includePaths) {
+    const dest = path.join(destRoot, skill.destName);
+    for (const relPath of skill.includePaths) {
+      const sourcePath = path.join(cacheDir, relPath);
+      if (!dryRun && !exists(sourcePath)) throw new Error(`${skill.value} source path not found: ${relPath}`);
+      if (!dryRun) await rejectSymlinks(sourcePath);
+      await copyRecursive(sourcePath, path.join(dest, relPath), { dryRun });
+    }
+    return [skill.destName];
+  }
+
+  if (skill.sourceSubdir) {
+    const sourceDir = path.join(cacheDir, skill.sourceSubdir);
+    if (!dryRun && !exists(sourceDir)) throw new Error(`${skill.value} source dir not found: ${skill.sourceSubdir}`);
+    if (!dryRun) await rejectSymlinks(sourceDir);
+    const dest = path.join(destRoot, skill.destName);
+    await copyRecursive(sourceDir, dest, { dryRun });
+    return [skill.destName];
+  }
+
+  if (skill.sourceDir) {
+    const sourceDir = path.join(cacheDir, skill.sourceDir);
+    if (!dryRun && !exists(sourceDir)) throw new Error(`${skill.value} source dir not found: ${skill.sourceDir}`);
+    if (dryRun) {
+      await copyRecursive(sourceDir, destRoot, { dryRun });
+      return [skill.sourceDir];
+    }
+    await rejectSymlinks(sourceDir);
+    const installedDirs = [];
+    const entries = await fs.readdir(sourceDir, { withFileTypes: true });
+    for (const entry of entries.filter((item) => item.isDirectory())) {
+      await copyRecursive(path.join(sourceDir, entry.name), path.join(destRoot, entry.name), { dryRun });
+      installedDirs.push(entry.name);
+    }
+    return installedDirs;
+  }
+
+  await rejectSymlinks(cacheDir);
+  const dest = path.join(destRoot, skill.destName);
+  await copyRecursive(cacheDir, dest, { dryRun });
+  await removePath(path.join(dest, ".git"), { dryRun });
+  return [skill.destName];
+}
+
+export async function applyOptionalSkills({ target, skills = [], dryRun = false }) {
+  const selected = normalizeOptionalSkills(skills);
+  const invalid = invalidOptionalSkills(selected);
+  if (invalid.length > 0) throw new Error(`Unknown optional skill(s): ${invalid.join(", ")}`);
+  if (selected.length === 0) return { selectedSkills: [], appliedSkills: [] };
+
+  const chosen = selected.map(knownSkill);
+  const destRoot = path.join(target, ".claude", "skills");
+  await backupPaths(target, [".claude/skills"], { dryRun });
+  await removePath(destRoot, { dryRun });
+  await ensureDir(destRoot, { dryRun });
+  await appendGitignoreLine(target, ".repo-pattern/", { dryRun });
+
+  const appliedSkills = [];
+  for (const skill of chosen) {
+    const cacheDir = await syncSkillCache(target, skill, { dryRun });
+    const installedDirs = await copySkill(skill, cacheDir, destRoot, { dryRun });
+    appliedSkills.push({ name: skill.value, source: skill.source, revision: skill.revision, license: skill.license, installedDirs });
+  }
+
+  const repoPatternDir = path.join(target, ".repo-pattern");
+  if (dryRun) {
+    console.log(`[dry-run] rm -rf ${path.join(repoPatternDir, "cache")}`);
+    console.log(`[dry-run] rmdir ${repoPatternDir} if empty`);
+  } else {
+    await removePath(path.join(repoPatternDir, "cache"));
+    try {
+      await fs.rmdir(repoPatternDir);
+    } catch (error) {
+      if (!["ENOENT", "ENOTEMPTY", "EEXIST"].includes(error.code)) throw error;
+    }
+  }
+
+  const repoConfigPath = path.join(target, ".repo-pattern.json");
+  const repoConfig = await readJson(repoConfigPath, {});
+  repoConfig.runtime = { ...(repoConfig.runtime || {}), localSkills: true };
+  repoConfig.optionalSkills = appliedSkills.map(({ name, source, revision, license, installedDirs }) => ({ name, source, revision, license, installedDirs }));
+  await writeJson(repoConfigPath, repoConfig, { dryRun });
+
+  const lockPath = path.join(target, ".repo-pattern.lock.json");
+  const lock = await readJson(lockPath, {});
+  lock.optionalSkills = { appliedSkills, appliedAt: new Date().toISOString() };
+  await writeJson(lockPath, lock, { dryRun });
+
+  printSummary("Applied optional skills", [
+    ["Path", path.relative(target, destRoot)],
+    ["Skills", selected.join(", ")]
+  ]);
+
+  return { selectedSkills: selected, appliedSkills };
+}

package/scripts/repo-pattern.mjs

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { auditProject, printAudit } from "./lib/audit.mjs";
+import { cleanupProject } from "./lib/cleanup.mjs";
+import { generateMcp } from "./lib/mcp.mjs";
+import { setupEcc } from "./lib/ecc.mjs";
+import { doctorProject } from "./lib/doctor.mjs";
+import { applyEccRules } from "./lib/rules.mjs";
+import { setupProject } from "./lib/setup.mjs";
+import { invalidOptionalSkills } from "./lib/skills.mjs";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const sourceRoot = path.resolve(__dirname, "..");
+
+function requiredOptionValue(rest, index, arg) {
+  const value = rest[index + 1];
+  if (!value || value.startsWith("--")) {
+    console.error(`Missing value for ${arg}`);
+    process.exit(2);
+  }
+  return value;
+}
+
+function parseArgs(argv) {
+  let [command, ...rest] = argv;
+  if (command === "-h" || command === "--help") {
+    command = "help";
+    rest = [];
+  }
+  const options = {
+    command: command || "help",
+    target: ".",
+    profile: "web",
+    dryRun: false,
+    force: false,
+    migrate: false,
+    applyRules: false,
+    optionalSkills: [],
+    yes: false
+  };
+
+  for (let i = 0; i < rest.length; i++) {
+    const arg = rest[i];
+    if (arg === "--target") options.target = requiredOptionValue(rest, i++, arg);
+    else if (arg === "--profile") options.profile = requiredOptionValue(rest, i++, arg);
+    else if (arg === "--dry-run") options.dryRun = true;
+    else if (arg === "--force") options.force = true;
+    else if (arg === "--migrate") options.migrate = true;
+    else if (arg === "--with-rules") options.applyRules = true;
+    else if (arg === "--with-skill") options.optionalSkills.push(requiredOptionValue(rest, i++, arg));
+    else if (arg === "--with-skills") options.optionalSkills.push(...requiredOptionValue(rest, i++, arg).split(",").map((value) => value.trim()).filter(Boolean));
+    else if (arg === "--yes") options.yes = true;
+    else if (arg === "-h" || arg === "--help") options.command = "help";
+    else {
+      console.error(`Unknown argument: ${arg}`);
+      process.exit(2);
+    }
+  }
+
+  if (options.force && options.migrate) {
+    console.error("Use either --force or --migrate, not both.");
+    process.exit(2);
+  }
+
+  const invalidSkills = invalidOptionalSkills(options.optionalSkills);
+  if (invalidSkills.length > 0) {
+    console.error(`Unknown optional skill(s): ${invalidSkills.join(", ")}. Available: taste, document-specialist, ui-ux-pro-max, impeccable, huashu-design`);
+    process.exit(2);
+  }
+
+  options.target = path.resolve(process.cwd(), options.target);
+  return options;
+}
+
+function help() {
+  console.log(`repo-pattern — minimal ECC-first Claude Code setup
+
+Usage:
+  repo-pattern help
+  repo-pattern setup
+  repo-pattern setup --profile web --yes
+  repo-pattern setup --profile web --migrate --yes
+  repo-pattern setup --with-skill taste --yes
+  repo-pattern setup --with-skill ui-ux-pro-max --yes  # requires Python 3.x
+  repo-pattern setup --with-skills impeccable,huashu-design --yes
+
+Advanced:
+  repo-pattern mcp --profile web
+  repo-pattern ecc
+  repo-pattern rules
+  repo-pattern audit
+  repo-pattern doctor
+  repo-pattern cleanup
+
+Options:
+  --target <path>   Target project path. Default: .
+  --profile <name>  MCP profile for scriptable commands. Default: web
+
+Setup UI:
+  setup uses ↑/↓ to move, Space to toggle MCP/rules choices, Enter to confirm, Esc/Ctrl+C to cancel
+  --dry-run      Print actions without writing
+  --migrate      Take over legacy/local Claude runtime surfaces
+  --force        Reapply setup over repo-pattern-managed state
+  --with-rules               Opt in to repo-pattern-managed .claude/rules/ecc
+  --with-skill <name>        Opt in to external .claude/skills (taste, document-specialist, ui-ux-pro-max, impeccable, huashu-design)
+  --with-skills <a,b>        Comma-separated optional skills
+  --yes                      Run setup non-interactively
+`);
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+
+  try {
+    switch (options.command) {
+      case "help":
+        help();
+        break;
+      case "audit": {
+        const audit = await auditProject(options.target);
+        printAudit(audit);
+        break;
+      }
+      case "setup":
+        await setupProject({ sourceRoot, ...options });
+        break;
+      case "cleanup":
+        await cleanupProject({ sourceRoot, ...options });
+        break;
+      case "mcp":
+        await generateMcp({ sourceRoot, target: options.target, profile: options.profile, yes: options.yes, dryRun: options.dryRun });
+        break;
+      case "ecc":
+        await setupEcc({ sourceRoot, target: options.target, dryRun: options.dryRun });
+        break;
+      case "rules":
+        await applyEccRules({ target: options.target, dryRun: options.dryRun });
+        break;
+      case "doctor":
+        await doctorProject(options.target);
+        break;
+      default:
+        console.error(`Unknown command: ${options.command}`);
+        help();
+        process.exit(2);
+    }
+  } catch (error) {
+    console.error(`\nERROR: ${error.message}`);
+    if (process.env.DEBUG) console.error(error.stack);
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/self-check.mjs

@@ -0,0 +1,175 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { printAudit } from "./lib/audit.mjs";
+import { applyMcpValues, mcpSecretPrompt, validateRelativeMcpPath } from "./lib/mcp.mjs";
+import { applyAttributionSetting } from "./lib/provision.mjs";
+import { printSummary, renderLogo, style } from "./lib/prompt.mjs";
+import { expectedOptionalSkillDirs, invalidOptionalSkills, normalizeOptionalSkills } from "./lib/skills.mjs";
+
+const cliDir = path.dirname(fileURLToPath(import.meta.url));
+const cliPath = path.join(cliDir, "repo-pattern.mjs");
+const repoRoot = path.dirname(cliDir);
+
+const mcpServers = {
+  context7: {
+    command: "npx",
+    args: ["-y", "@upstash/context7-mcp"],
+    env: { CONTEXT7_API_KEY: "${CONTEXT7_API_KEY}" }
+  },
+  filesystem: {
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-filesystem", "."]
+  }
+};
+
+assert.equal(validateRelativeMcpPath("src"), true);
+assert.equal(validateRelativeMcpPath("."), true);
+assert.equal(validateRelativeMcpPath("/home/user/project"), "Use a relative path, not an absolute machine path.");
+assert.equal(validateRelativeMcpPath("C:\\Users\\me\\project"), "Use a relative path, not an absolute machine path.");
+assert.equal(validateRelativeMcpPath("~/project"), "Use a relative path, not an absolute machine path.");
+assert.equal(validateRelativeMcpPath("../secrets"), "Path must not contain '..'.");
+assert.equal(
+  mcpSecretPrompt({ name: "CONTEXT7_API_KEY", label: "context7: CONTEXT7_API_KEY" }),
+  "MCP secret — context7: CONTEXT7_API_KEY (get key: https://context7.com/dashboard)"
+);
+assert.equal(
+  mcpSecretPrompt({ name: "TAVILY_API_KEY", label: "tavily: TAVILY_API_KEY" }),
+  "MCP secret — tavily: TAVILY_API_KEY (get key: https://app.tavily.com/home)"
+);
+
+assert.deepEqual(applyMcpValues(mcpServers, {
+  CONTEXT7_API_KEY: "redacted-key"
+}), {
+  context7: {
+    command: "npx",
+    args: ["-y", "@upstash/context7-mcp"],
+    env: { CONTEXT7_API_KEY: "redacted-key" }
+  },
+  filesystem: {
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-filesystem", "."]
+  }
+});
+
+assert.equal(applyMcpValues(mcpServers).filesystem.args[2], ".");
+assert.deepEqual(applyAttributionSetting({ hooks: {} }, { mode: "off" }), { hooks: {}, attribution: { commit: "" } });
+assert.deepEqual(applyAttributionSetting({ attribution: { commit: "" } }, { mode: "on" }), {});
+assert.deepEqual(applyAttributionSetting({ attribution: { pr: "PR" } }, { mode: "custom", commit: "Custom" }), { attribution: { pr: "PR", commit: "Custom" } });
+assert.deepEqual(normalizeOptionalSkills(["taste", "taste", "document-specialist", "ui-ux-pro-max", "impeccable", "huashu-design"]), ["taste", "document-specialist", "ui-ux-pro-max", "impeccable", "huashu-design"]);
+assert.deepEqual(invalidOptionalSkills(["taste", "ui-ux-pro-max", "impeccable", "huashu-design", "nope"]), ["nope"]);
+assert.deepEqual(expectedOptionalSkillDirs([
+  {
+    name: "ui-ux-pro-max",
+    source: "https://github.com/nextlevelbuilder/ui-ux-pro-max-skill.git",
+    revision: "4baa399d00da806f83ed93652172f66943205153"
+  },
+  {
+    name: "impeccable",
+    source: "https://github.com/pbakaus/impeccable.git",
+    revision: "88f52ac4e6a5ce99d39a0f5d89e7ac3a168910f5"
+  },
+  {
+    name: "huashu-design",
+    source: "https://github.com/alchaincyf/huashu-design.git",
+    revision: "0e7ec8aca0058184c1a9e06e57697e84f68a3f0f"
+  }
+]), ["huashu-design", "impeccable", "ui-ux-pro-max"]);
+
+const auditLogs = [];
+const originalAuditLog = console.log;
+const originalAuditStdinIsTty = process.stdin.isTTY;
+const originalAuditStdoutIsTty = process.stdout.isTTY;
+console.log = (message = "") => auditLogs.push(String(message));
+process.stdin.isTTY = false;
+process.stdout.isTTY = false;
+try {
+  printAudit({ target: "/tmp/project", state: "EMPTY" });
+  printAudit({ target: "/tmp/project", state: "PARTIAL", hasSettingsHooks: true });
+} finally {
+  console.log = originalAuditLog;
+  process.stdin.isTTY = originalAuditStdinIsTty;
+  process.stdout.isTTY = originalAuditStdoutIsTty;
+}
+assert(auditLogs.includes("Target  /tmp/project"));
+assert(auditLogs.includes("State   EMPTY"));
+assert(!auditLogs.some((line) => line.includes(".claude present")));
+assert(auditLogs.some((line) => line.includes("⚠ .mcp.json missing")));
+assert(auditLogs.some((line) => line.includes("⚠ .claude/settings.json hooks not empty")));
+
+const logs = [];
+const originalLog = console.log;
+const originalStdinIsTty = process.stdin.isTTY;
+const originalStdoutIsTty = process.stdout.isTTY;
+console.log = (message = "") => logs.push(String(message));
+process.stdin.isTTY = false;
+process.stdout.isTTY = false;
+try {
+  printSummary("MCP generated", [
+    ["Enabled servers", "context7, filesystem, playwright, chrome-devtools, gitnexus, tavily, sequential-thinking"]
+  ]);
+} finally {
+  console.log = originalLog;
+  process.stdin.isTTY = originalStdinIsTty;
+  process.stdout.isTTY = originalStdoutIsTty;
+}
+assert(logs.some((line) => line.includes("sequential-thinking")));
+assert(!logs.some((line) => line.length > 100));
+
+assert(renderLogo().includes("repo-pattern"));
+assert(renderLogo({ color: true }).some((line) => line.includes("\x1b[38;5;")));
+
+process.stdin.isTTY = true;
+process.stdout.isTTY = true;
+process.env.NO_COLOR = "1";
+try {
+  assert.equal(style("success", "ready"), "ready");
+} finally {
+  delete process.env.NO_COLOR;
+  process.stdin.isTTY = originalStdinIsTty;
+  process.stdout.isTTY = originalStdoutIsTty;
+}
+
+function runCli(args) {
+  return spawnSync(process.execPath, [cliPath, ...args], { cwd: repoRoot, encoding: "utf8" });
+}
+
+let result = runCli(["help"]);
+assert.equal(result.status, 0);
+assert.match(result.stdout, /repo-pattern help/);
+
+result = runCli(["doctor", "--bogus"]);
+assert.equal(result.status, 2);
+assert.match(result.stderr, /Unknown argument: --bogus/);
+
+result = runCli(["setup", "--target"]);
+assert.equal(result.status, 2);
+assert.match(result.stderr, /Missing value for --target/);
+
+result = runCli(["setup", "--with-skill", "nope"]);
+assert.equal(result.status, 2);
+assert.match(result.stderr, /Unknown optional skill\(s\): nope/);
+
+result = runCli(["help"]);
+assert.equal(result.status, 0);
+assert.match(result.stdout, /--with-skill <name>/);
+assert.match(result.stdout, /ui-ux-pro-max/);
+assert.match(result.stdout, /impeccable/);
+assert.match(result.stdout, /huashu-design/);
+
+result = runCli(["audit"]);
+assert.equal(result.status, 0);
+assert.match(result.stdout, /Target\s+.*repo-pattern/);
+
+result = runCli(["mcp", "--profile", "minimal", "--yes", "--dry-run"]);
+assert.equal(result.status, 0);
+assert.match(result.stdout, /MCP generated/);
+
+result = runCli(["mcp", "--profile", "nope", "--yes"]);
+assert.equal(result.status, 1);
+assert.match(result.stderr, /MCP profile not found: nope\. Available profiles: /);
+assert.match(result.stderr, /minimal/);
+assert.match(result.stderr, /web/);
+
+console.log("self-check passed");