@negikirin/repo-pattern 0.1.1

package/scripts/lib/audit.mjs

@@ -0,0 +1,127 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { exists, isTracked, readJson } from "./fs-utils.mjs";
+import { printBox, style } from "./prompt.mjs";
+import { expectedOptionalSkillDirs } from "./skills.mjs";
+
+const HARDCODED_PATH_RE = /"\/home\/|"\/Users\/|"[A-Za-z]:\\\\/;
+
+async function fileContains(file, regex) {
+  if (!exists(file)) return false;
+  const text = await fs.readFile(file, "utf8");
+  return regex.test(text);
+}
+
+async function isOnlyEccRulesDir(target) {
+  const rulesDir = path.join(target, ".claude", "rules");
+  if (!exists(rulesDir)) return false;
+  try {
+    const entries = await fs.readdir(rulesDir);
+    return entries.length === 1 && entries[0] === "ecc";
+  } catch {
+    return false;
+  }
+}
+
+function hasNonEmptyObject(value) {
+  return value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length > 0;
+}
+
+async function listDirNames(dir) {
+  if (!exists(dir)) return [];
+  try {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+  } catch {
+    return [];
+  }
+}
+
+export async function auditProject(target) {
+  const settings = await readJson(path.join(target, ".claude", "settings.json"), {});
+  const repoPattern = await readJson(path.join(target, ".repo-pattern.json"), null);
+
+  const actualSkillDirs = await listDirNames(path.join(target, ".claude", "skills"));
+  const expectedSkillDirs = expectedOptionalSkillDirs(repoPattern?.optionalSkills || []);
+  const hasOnlyManagedSkills = JSON.stringify(actualSkillDirs) === JSON.stringify(expectedSkillDirs);
+  const hasMcpJson = exists(path.join(target, ".mcp.json"));
+  const hasHardcodedMcpPath = hasMcpJson
+    ? await fileContains(path.join(target, ".mcp.json"), HARDCODED_PATH_RE)
+    : false;
+
+  const result = {
+    target,
+    hasClaudeDir: exists(path.join(target, ".claude")),
+    hasMcpJson,
+    hasHardcodedMcpPath,
+    hasSettingsLocalTracked: isTracked(target, ".claude/settings.local.json"),
+    hasSettingsHooks: hasNonEmptyObject(settings.hooks),
+    hasClaudeSkillsDir: exists(path.join(target, ".claude", "skills")),
+    actualSkillDirs,
+    expectedSkillDirs,
+    hasOnlyManagedSkills,
+    hasClaudeCommandsDir: exists(path.join(target, ".claude", "commands")),
+    hasClaudeHooksDir: exists(path.join(target, ".claude", "hooks")),
+    hasClaudeScriptsDir: exists(path.join(target, ".claude", "scripts")),
+    hasClaudeRulesDir: exists(path.join(target, ".claude", "rules")),
+    hasOnlyEccRulesDir: await isOnlyEccRulesDir(target),
+    hasRepoPatternJson: !!repoPattern,
+    repoPattern
+  };
+
+  const allowSourceSkills = repoPattern?.mode === "template";
+  const allowManagedSkills = repoPattern?.runtime?.localSkills === true && Array.isArray(repoPattern?.optionalSkills) && result.hasOnlyManagedSkills;
+  const legacy = (
+    result.hasSettingsHooks ||
+    (result.hasClaudeSkillsDir && !allowSourceSkills && !allowManagedSkills) ||
+    result.hasClaudeCommandsDir ||
+    result.hasClaudeHooksDir ||
+    result.hasClaudeScriptsDir ||
+    (result.hasClaudeRulesDir && !result.hasOnlyEccRulesDir)
+  );
+
+  if (!result.hasClaudeDir && !result.hasMcpJson && !result.hasRepoPatternJson) {
+    result.state = "EMPTY";
+  } else if (
+    result.hasRepoPatternJson &&
+    result.repoPattern?.workflow === "ecc-native" &&
+    !legacy
+  ) {
+    result.state = "ECC_NATIVE_MINIMAL";
+  } else if (legacy) {
+    result.state = "LEGACY_VENDOR";
+  } else {
+    result.state = "PARTIAL";
+  }
+
+  return result;
+}
+
+export function printAudit(audit) {
+  const warning = style("error", "⚠");
+  const rows = [
+    `Target  ${audit.target}`,
+    `State   ${audit.state}`
+  ];
+  const needsSetup = audit.state !== "EMPTY";
+  const issues = [
+    [needsSetup && !audit.hasClaudeDir, ".claude missing"],
+    [needsSetup && !audit.hasMcpJson, ".mcp.json missing"],
+    [needsSetup && !audit.hasRepoPatternJson, ".repo-pattern.json missing"],
+    [audit.hasHardcodedMcpPath, "hardcoded machine path in .mcp.json"],
+    [audit.hasSettingsLocalTracked, ".claude/settings.local.json tracked"],
+    [audit.hasSettingsHooks, ".claude/settings.json hooks not empty"],
+    [audit.repoPattern?.runtime?.localSkills === true && !audit.hasOnlyManagedSkills, ".claude/skills does not match managed optional skills"],
+    [audit.hasClaudeSkillsDir && !audit.hasOnlyManagedSkills, ".claude/skills contains unmanaged entries"],
+    [audit.hasClaudeCommandsDir, ".claude/commands present"],
+    [audit.hasClaudeHooksDir, ".claude/hooks present"],
+    [audit.hasClaudeScriptsDir, ".claude/scripts present"],
+    [audit.hasClaudeRulesDir && !audit.hasOnlyEccRulesDir, "non-ECC .claude/rules present"]
+  ].filter(([bad]) => bad);
+
+  if (issues.length > 0) {
+    rows.push("", ...issues.map(([, message]) => `${warning} ${message}`));
+  }
+
+  printBox("Audit", rows);
+}

package/scripts/lib/cleanup.mjs

@@ -0,0 +1,35 @@
+import path from "node:path";
+import { backupPaths, ensureDir, readJson, removePath, writeJson } from "./fs-utils.mjs";
+
+export async function cleanupProject({ sourceRoot, target, dryRun = false }) {
+  console.log(`Cleaning target: ${target}`);
+
+  await backupPaths(target, [
+    ".claude/skills",
+    ".claude/commands",
+    ".claude/hooks",
+    ".claude/scripts",
+    ".claude/rules",
+    ".claude/settings.json",
+    ".claude/settings.local.json",
+    ".mcp.json"
+  ], { dryRun });
+
+  const removeList = [
+    ".claude/skills",
+    ".claude/commands",
+    ".claude/hooks",
+    ".claude/scripts",
+    ".claude/rules"
+  ];
+
+  for (const rel of removeList) {
+    await removePath(path.join(target, rel), { dryRun });
+  }
+
+  const settings = await readJson(path.join(sourceRoot, ".claude", "settings.example.json"), {});
+  await ensureDir(path.join(target, ".claude"), { dryRun });
+  await writeJson(path.join(target, ".claude", "settings.json"), settings, { dryRun });
+
+  console.log("Cleanup complete.");
+}

package/scripts/lib/doctor.mjs

@@ -0,0 +1,86 @@
+import path from "node:path";
+import { auditProject } from "./audit.mjs";
+import { isTracked, readJson, writeJson } from "./fs-utils.mjs";
+import { printBox, style } from "./prompt.mjs";
+
+function renderDoctor(target, checks, infoRows) {
+  const failed = checks.filter((row) => !row.ok);
+  const visibleChecks = checks.filter((row) => !row.silent);
+
+  printBox("Doctor", [
+    `Target  ${target}`,
+    `Checks  ${checks.length - failed.length}/${checks.length} ${style("success", "passed")}${failed.length ? `, ${failed.length} ${style("error", "failed")}` : ""}`,
+    "",
+    ...visibleChecks.map((row) => `${row.ok ? style("success", "✓") : style("error", "✗")} ${row.label}`),
+    ...infoRows.map((row) => `${style("info", "i")} ${row}`)
+  ]);
+}
+
+export async function doctorProject(target, { updateLock = false, dryRun = false } = {}) {
+  const audit = await auditProject(target);
+  const checks = [];
+  const infoRows = [];
+
+  const check = (condition, label, { silentPass = false } = {}) => {
+    checks.push({ ok: Boolean(condition), label, silent: Boolean(condition && silentPass) });
+  };
+
+  const lockPath = path.join(target, ".repo-pattern.lock.json");
+  const lock = await readJson(lockPath, {});
+  const allowSourceSkills = audit.repoPattern?.mode === "template";
+  const managedSkills = audit.repoPattern?.runtime?.localSkills === true && Array.isArray(audit.repoPattern?.optionalSkills) && audit.hasOnlyManagedSkills;
+  check(!audit.hasClaudeSkillsDir || allowSourceSkills || managedSkills, ".claude/skills does not exist unless repo-pattern-managed optional skills are enabled");
+  check(!audit.hasClaudeCommandsDir, ".claude/commands does not exist");
+  check(!audit.hasClaudeHooksDir, ".claude/hooks does not exist");
+  check(!audit.hasClaudeScriptsDir, ".claude/scripts does not exist");
+  check(!audit.hasClaudeRulesDir || audit.hasOnlyEccRulesDir, "no non-ECC .claude/rules");
+  check(audit.hasClaudeDir, ".claude exists");
+  check(!audit.hasSettingsHooks, ".claude/settings.json hooks is {}");
+  check(!isTracked(target, ".claude/settings.json"), ".claude/settings.json is not tracked");
+  check(!isTracked(target, ".claude/settings.local.json"), ".claude/settings.local.json is not tracked");
+  check(!isTracked(target, ".mcp.json"), ".mcp.json is not tracked");
+  check(!audit.hasHardcodedMcpPath, ".mcp.json has no absolute machine path");
+  check(audit.hasRepoPatternJson, ".repo-pattern.json exists");
+
+  const repoPattern = audit.repoPattern || {};
+  check(repoPattern.workflow === "ecc-native", ".repo-pattern.json workflow=ecc-native");
+  check(repoPattern.runtime?.localSkills === false || managedSkills, ".repo-pattern.json runtime.localSkills=false unless optional skills are managed");
+  if (managedSkills) check(audit.hasClaudeSkillsDir, ".claude/skills exists for managed optional skills");
+  check(repoPattern.runtime?.localCommands === false, ".repo-pattern.json runtime.localCommands=false");
+  check(repoPattern.runtime?.localHooks === false, ".repo-pattern.json runtime.localHooks=false");
+  check(repoPattern.runtime?.localScripts === false, ".repo-pattern.json runtime.localScripts=false");
+  check(repoPattern.runtime?.localRules === false, ".repo-pattern.json runtime.localRules=false");
+
+  const settings = await readJson(path.join(target, ".claude", "settings.json"), {});
+  const expectedMcpServers = lock.mcp?.enabledServers || [];
+  if (expectedMcpServers.length > 0) {
+    const actualMcpServers = settings.enabledMcpjsonServers || [];
+    check(
+      JSON.stringify(actualMcpServers) === JSON.stringify(expectedMcpServers),
+      ".claude/settings.json enabledMcpjsonServers matches MCP profile"
+    );
+  }
+  const appliedRules = lock.ecc?.appliedRules || [];
+  if (appliedRules.length > 0) {
+    check(audit.hasOnlyEccRulesDir, ".claude/rules/ecc contains ECC-managed project rules");
+  }
+  infoRows.push(`ECC setup status: ${lock.ecc?.status || "unknown"}`);
+  if (lock.ecc?.status === "manual-plugin-install-required") {
+    infoRows.push("Open Claude Code and run:");
+    infoRows.push("/plugin marketplace add https://github.com/affaan-m/ECC");
+    infoRows.push("/plugin install ecc@ecc");
+  }
+
+  if (updateLock) {
+    lock.repoPattern = lock.repoPattern || {};
+    lock.repoPattern.lastDoctorRun = new Date().toISOString();
+    await writeJson(lockPath, lock, { dryRun });
+  }
+
+  renderDoctor(target, checks, infoRows);
+
+  const failures = checks.filter((row) => !row.ok);
+  if (failures.length > 0) {
+    throw new Error(`Doctor failed with ${failures.length} failure(s).`);
+  }
+}

package/scripts/lib/ecc-rules.mjs

@@ -0,0 +1,98 @@
+export const ECC_RULE_PACKS = [
+  "common",
+  "angular",
+  "arkts",
+  "cpp",
+  "csharp",
+  "dart",
+  "fsharp",
+  "golang",
+  "java",
+  "kotlin",
+  "nuxt",
+  "perl",
+  "php",
+  "python",
+  "react",
+  "react-native",
+  "ruby",
+  "rust",
+  "swift",
+  "typescript",
+  "vue",
+  "web"
+];
+
+const RULE_PACKS = new Set(ECC_RULE_PACKS);
+
+export function normalizeEccRules(rules = []) {
+  return [...new Set(rules)].filter((name) => RULE_PACKS.has(name));
+}
+
+export function invalidEccRules(rules = []) {
+  return [...new Set(rules)].filter((name) => !RULE_PACKS.has(name));
+}
+
+export function selectEccRules(detection) {
+  const languages = new Set(detection.languages || []);
+  const frameworks = new Set(detection.frameworks || []);
+  const tools = new Set(detection.tools || []);
+  const selected = new Set(["common"]);
+
+  const hasNode = languages.has("javascript") || languages.has("typescript");
+  const hasFrontend = (
+    frameworks.has("nextjs") ||
+    frameworks.has("react") ||
+    frameworks.has("react-native") ||
+    frameworks.has("angular") ||
+    frameworks.has("vue") ||
+    frameworks.has("nuxt") ||
+    tools.has("frontend-tooling") ||
+    detection.repoType === "frontend" ||
+    detection.repoType === "fullstack"
+  );
+
+  if (hasNode || hasFrontend) selected.add("typescript");
+  if (hasFrontend) selected.add("web");
+
+  if (frameworks.has("react")) selected.add("react");
+  if (frameworks.has("react-native")) selected.add("react-native");
+  if (frameworks.has("angular")) selected.add("angular");
+  if (frameworks.has("vue")) selected.add("vue");
+  if (frameworks.has("nuxt")) {
+    selected.add("nuxt");
+    selected.add("vue");
+  }
+
+  if (languages.has("python")) selected.add("python");
+  if (languages.has("go")) selected.add("golang");
+  if (languages.has("java")) selected.add("java");
+  if (languages.has("kotlin")) selected.add("kotlin");
+  if (languages.has("rust")) selected.add("rust");
+  if (languages.has("dart")) selected.add("dart");
+  if (languages.has("cpp")) selected.add("cpp");
+  if (languages.has("csharp")) selected.add("csharp");
+  if (languages.has("fsharp")) selected.add("fsharp");
+  if (languages.has("perl")) selected.add("perl");
+  if (languages.has("php")) selected.add("php");
+  if (languages.has("ruby")) selected.add("ruby");
+  if (languages.has("swift")) selected.add("swift");
+  if (languages.has("arkts")) selected.add("arkts");
+
+  return normalizeEccRules(selected);
+}
+
+export function explainRules(detection, rules) {
+  const lines = [];
+  lines.push("Detected stack:");
+  lines.push(`- repo type: ${detection.repoType || "generic"}`);
+  lines.push(`- languages: ${(detection.languages || []).join(", ") || "none detected"}`);
+  lines.push(`- frameworks: ${(detection.frameworks || []).join(", ") || "none detected"}`);
+  lines.push(`- tools: ${(detection.tools || []).join(", ") || "none detected"}`);
+  lines.push(`- package manager: ${detection.packageManager || "unknown"}`);
+  lines.push(`- monorepo: ${detection.monorepo ? "yes" : "no"}`);
+  lines.push("");
+  lines.push("Selected ECC rules:");
+  for (const rule of rules) lines.push(`- ${rule}`);
+  return lines.join("\n");
+}

package/scripts/lib/ecc.mjs

@@ -0,0 +1,61 @@
+import { execSync } from "node:child_process";
+import path from "node:path";
+import { readJson, writeJson } from "./fs-utils.mjs";
+import { printSummary } from "./prompt.mjs";
+
+function hasEccPlugin() {
+  try {
+    return execSync("claude plugin list", { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).includes("ecc@ecc");
+  } catch {
+    return false;
+  }
+}
+
+export async function setupEcc({ target, dryRun = false }) {
+  let status = hasEccPlugin() ? "installed" : "manual-plugin-install-required";
+
+  if (status === "installed") {
+    printSummary("ECC", [["Status", "plugin detected in Claude Code"]]);
+  } else if (process.env.REPO_PATTERN_ECC_SETUP_CMD) {
+    printSummary("ECC", [["Status", "using REPO_PATTERN_ECC_SETUP_CMD"]]);
+    if (dryRun) {
+      console.log(`[dry-run] REPO_PATTERN_TARGET=${target} ${process.env.REPO_PATTERN_ECC_SETUP_CMD}`);
+      status = "dry-run";
+    } else {
+      execSync(process.env.REPO_PATTERN_ECC_SETUP_CMD, {
+        cwd: target,
+        stdio: "inherit",
+        env: {
+          ...process.env,
+          REPO_PATTERN_TARGET: target
+        },
+        shell: true
+      });
+      status = "installed";
+    }
+  } else {
+    console.log(`
+Install ECC inside Claude Code:
+
+/plugin marketplace add https://github.com/affaan-m/ECC
+/plugin install ecc@ecc
+
+repo-pattern does not vendor ECC skills, commands, hooks, scripts, or rules.
+ECC runtime surfaces are plugin-managed.
+`);
+  }
+
+  const lockPath = path.join(target, ".repo-pattern.lock.json");
+  const lock = await readJson(lockPath, {});
+  lock.ecc = {
+    ...(lock.ecc || {}),
+    installMode: "plugin",
+    status,
+    rulesSyncedBy: lock.ecc?.rulesSyncedBy || null,
+    hooks: "plugin-managed",
+    syncedAt: status === "installed" ? new Date().toISOString() : lock.ecc?.syncedAt || null
+  };
+  await writeJson(lockPath, lock, { dryRun });
+
+  return status;
+}

package/scripts/lib/fs-utils.mjs

@@ -0,0 +1,133 @@
+import { execFileSync } from "node:child_process";
+import fs from "node:fs/promises";
+import fsSync from "node:fs";
+import path from "node:path";
+
+export function exists(p) {
+  return fsSync.existsSync(p);
+}
+
+export function isTracked(root, relPath) {
+  try {
+    const output = execFileSync("git", ["ls-files", relPath], {
+      cwd: root,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return output.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+
+export async function ensureDir(dir, { dryRun = false } = {}) {
+  if (dryRun) {
+    console.log(`[dry-run] mkdir -p ${dir}`);
+    return;
+  }
+  await fs.mkdir(dir, { recursive: true });
+}
+
+export async function readJson(file, fallback = null) {
+  if (!exists(file)) return fallback;
+  const text = await fs.readFile(file, "utf8");
+  return JSON.parse(text);
+}
+
+export async function writeJson(file, data, { dryRun = false } = {}) {
+  if (dryRun) {
+    console.log(`[dry-run] write JSON ${file}`);
+    return;
+  }
+  await ensureDir(path.dirname(file));
+  await fs.writeFile(file, `${JSON.stringify(data, null, 2)}\n`, "utf8");
+}
+
+export async function copyRecursive(src, dest, { dryRun = false } = {}) {
+  if (!exists(src)) return;
+  if (dryRun) {
+    console.log(`[dry-run] copy ${src} -> ${dest}`);
+    return;
+  }
+  await ensureDir(path.dirname(dest));
+  await fs.cp(src, dest, { recursive: true, force: true });
+}
+
+export async function removePath(p, { dryRun = false } = {}) {
+  if (!exists(p)) return;
+  if (dryRun) {
+    console.log(`[dry-run] rm -rf ${p}`);
+    return;
+  }
+  await fs.rm(p, { recursive: true, force: true });
+}
+
+export async function writeIfMissing(file, content, { dryRun = false } = {}) {
+  if (exists(file)) return false;
+  if (dryRun) {
+    console.log(`[dry-run] write if missing ${file}`);
+    return true;
+  }
+  await ensureDir(path.dirname(file));
+  await fs.writeFile(file, content, "utf8");
+  return true;
+}
+
+export async function replaceFile(file, content, { dryRun = false } = {}) {
+  if (dryRun) {
+    console.log(`[dry-run] replace ${file}`);
+    return;
+  }
+  await ensureDir(path.dirname(file));
+  await fs.writeFile(file, content, "utf8");
+}
+
+export async function appendGitignoreLine(target, line, { dryRun = false } = {}) {
+  const file = path.join(target, ".gitignore");
+  let content = "";
+  try {
+    content = await fs.readFile(file, "utf8");
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  if (content.split(/\r?\n/).includes(line)) return;
+  const next = `${content}${content && !content.endsWith("\n") ? "\n" : ""}${line}\n`;
+  if (dryRun) {
+    console.log(`[dry-run] append ${line} to ${file}`);
+    return;
+  }
+  await fs.writeFile(file, next, "utf8");
+}
+
+export function timestamp() {
+  return new Date().toISOString().replace(/[-:]/g, "").replace(/\..+/, "").replace("T", "-");
+}
+
+export async function backupPaths(targetRoot, relativePaths, { dryRun = false } = {}) {
+  const backupRoot = path.join(targetRoot, ".repo-pattern", "backups", timestamp());
+  let copied = 0;
+
+  for (const rel of relativePaths) {
+    const src = path.join(targetRoot, rel);
+    if (!exists(src)) continue;
+    const dest = path.join(backupRoot, rel);
+
+    if (dryRun) {
+      console.log(`[dry-run] backup ${src} -> ${dest}`);
+      copied++;
+      continue;
+    }
+
+    await ensureDir(path.dirname(dest));
+    const stat = await fs.stat(src);
+    if (stat.isDirectory()) {
+      await fs.cp(src, dest, { recursive: true, force: true });
+    } else {
+      await fs.copyFile(src, dest);
+    }
+    copied++;
+  }
+
+  if (copied > 0) console.log(`Backup created: ${backupRoot}`);
+  return copied > 0 ? backupRoot : null;
+}