@raftlabs/raftstack 1.0.0

package/dist/cli.js

@@ -0,0 +1,2009 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import * as p2 from "@clack/prompts";
+import pc2 from "picocolors";
+
+// src/prompts/index.ts
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+
+// src/utils/detect-project.ts
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import { join } from "path";
+var INDICATORS = [
+  { file: "nx.json", type: "nx", confidence: "high" },
+  { file: "turbo.json", type: "turbo", confidence: "high" },
+  { file: "pnpm-workspace.yaml", type: "pnpm-workspace", confidence: "high" },
+  { file: "lerna.json", type: "pnpm-workspace", confidence: "medium" }
+];
+async function detectProjectType(targetDir = process.cwd()) {
+  const foundIndicators = [];
+  let detectedType = "single";
+  let confidence = "low";
+  for (const indicator of INDICATORS) {
+    const filePath = join(targetDir, indicator.file);
+    if (existsSync(filePath)) {
+      foundIndicators.push(indicator.file);
+      if (confidence === "low" || confidence === "medium" && indicator.confidence === "high") {
+        detectedType = indicator.type;
+        confidence = indicator.confidence;
+      }
+    }
+  }
+  if (foundIndicators.length > 0 && confidence === "low") {
+    confidence = "medium";
+  }
+  return {
+    type: detectedType,
+    confidence,
+    indicators: foundIndicators
+  };
+}
+async function hasTypeScript(targetDir = process.cwd()) {
+  const tsConfigPath = join(targetDir, "tsconfig.json");
+  return existsSync(tsConfigPath);
+}
+async function hasEslint(targetDir = process.cwd()) {
+  const eslintFiles = [
+    ".eslintrc",
+    ".eslintrc.js",
+    ".eslintrc.cjs",
+    ".eslintrc.json",
+    ".eslintrc.yaml",
+    ".eslintrc.yml",
+    "eslint.config.js",
+    "eslint.config.mjs",
+    "eslint.config.cjs"
+  ];
+  for (const file of eslintFiles) {
+    if (existsSync(join(targetDir, file))) {
+      return true;
+    }
+  }
+  try {
+    const pkgPath = join(targetDir, "package.json");
+    if (existsSync(pkgPath)) {
+      const content = await readFile(pkgPath, "utf-8");
+      const pkg = JSON.parse(content);
+      if (pkg.eslintConfig) {
+        return true;
+      }
+    }
+  } catch {
+  }
+  return false;
+}
+async function hasPrettier(targetDir = process.cwd()) {
+  const prettierFiles = [
+    ".prettierrc",
+    ".prettierrc.js",
+    ".prettierrc.cjs",
+    ".prettierrc.json",
+    ".prettierrc.yaml",
+    ".prettierrc.yml",
+    ".prettierrc.toml",
+    "prettier.config.js",
+    "prettier.config.cjs",
+    "prettier.config.mjs"
+  ];
+  for (const file of prettierFiles) {
+    if (existsSync(join(targetDir, file))) {
+      return true;
+    }
+  }
+  try {
+    const pkgPath = join(targetDir, "package.json");
+    if (existsSync(pkgPath)) {
+      const content = await readFile(pkgPath, "utf-8");
+      const pkg = JSON.parse(content);
+      if (pkg.prettier) {
+        return true;
+      }
+    }
+  } catch {
+  }
+  return false;
+}
+function getProjectTypeDescription(type) {
+  switch (type) {
+    case "nx":
+      return "NX Monorepo";
+    case "turbo":
+      return "Turborepo";
+    case "pnpm-workspace":
+      return "pnpm Workspace";
+    case "single":
+      return "Single Package";
+  }
+}
+
+// src/prompts/index.ts
+function showWelcome() {
+  console.log();
+  p.intro(pc.bgCyan(pc.black(" RaftStack ")));
+  console.log(
+    pc.dim("  Setting up Git hooks, commit conventions, and GitHub integration\n")
+  );
+}
+async function promptProjectType(detection) {
+  const description = getProjectTypeDescription(detection.type);
+  const confidenceText = detection.confidence === "high" ? pc.green("high confidence") : detection.confidence === "medium" ? pc.yellow("medium confidence") : pc.red("low confidence");
+  const confirmed = await p.confirm({
+    message: `Detected ${pc.cyan(description)} (${confidenceText}). Is this correct?`,
+    initialValue: true
+  });
+  if (p.isCancel(confirmed)) {
+    p.cancel("Setup cancelled.");
+    process.exit(0);
+  }
+  if (confirmed) {
+    return detection.type;
+  }
+  const selected = await p.select({
+    message: "Select your project type:",
+    options: [
+      { value: "nx", label: "NX Monorepo" },
+      { value: "turbo", label: "Turborepo" },
+      { value: "pnpm-workspace", label: "pnpm Workspace" },
+      { value: "single", label: "Single Package" }
+    ]
+  });
+  if (p.isCancel(selected)) {
+    p.cancel("Setup cancelled.");
+    process.exit(0);
+  }
+  return selected;
+}
+async function promptAsanaConfig() {
+  const useAsana = await p.confirm({
+    message: "Do you want to link commits to Asana tasks?",
+    initialValue: true
+  });
+  if (p.isCancel(useAsana)) {
+    p.cancel("Setup cancelled.");
+    process.exit(0);
+  }
+  if (!useAsana) {
+    return void 0;
+  }
+  const baseUrl = await p.text({
+    message: "Enter your Asana workspace URL:",
+    placeholder: "https://app.asana.com/0/workspace-id",
+    validate: (value) => {
+      if (!value) return "URL is required";
+      if (!value.startsWith("https://app.asana.com/")) {
+        return "URL must start with https://app.asana.com/";
+      }
+      return void 0;
+    }
+  });
+  if (p.isCancel(baseUrl)) {
+    p.cancel("Setup cancelled.");
+    process.exit(0);
+  }
+  return baseUrl;
+}
+async function promptAIReview() {
+  const selected = await p.select({
+    message: "Select an AI code review tool (optional):",
+    options: [
+      {
+        value: "none",
+        label: "None",
+        hint: "Skip AI review setup"
+      },
+      {
+        value: "coderabbit",
+        label: "CodeRabbit",
+        hint: "AI-powered code review"
+      },
+      {
+        value: "copilot",
+        label: "GitHub Copilot",
+        hint: "GitHub's AI code review"
+      }
+    ]
+  });
+  if (p.isCancel(selected)) {
+    p.cancel("Setup cancelled.");
+    process.exit(0);
+  }
+  return selected;
+}
+async function promptCodeowners() {
+  const addOwners = await p.confirm({
+    message: "Do you want to set up CODEOWNERS for automatic PR reviewers?",
+    initialValue: true
+  });
+  if (p.isCancel(addOwners)) {
+    p.cancel("Setup cancelled.");
+    process.exit(0);
+  }
+  if (!addOwners) {
+    return [];
+  }
+  const owners = await p.text({
+    message: "Enter GitHub usernames (comma-separated):",
+    placeholder: "@username1, @username2",
+    validate: (value) => {
+      if (!value.trim()) return "At least one username is required";
+      return void 0;
+    }
+  });
+  if (p.isCancel(owners)) {
+    p.cancel("Setup cancelled.");
+    process.exit(0);
+  }
+  return owners.split(",").map((u) => u.trim()).filter(Boolean).map((u) => u.startsWith("@") ? u : `@${u}`);
+}
+async function promptConfirmation(config) {
+  console.log();
+  p.note(
+    [
+      `${pc.cyan("Project Type:")} ${getProjectTypeDescription(config.projectType)}`,
+      `${pc.cyan("TypeScript:")} ${config.usesTypeScript ? "Yes" : "No"}`,
+      `${pc.cyan("ESLint:")} ${config.usesEslint ? "Yes" : "No"}`,
+      `${pc.cyan("Prettier:")} ${config.usesPrettier ? "Yes" : "No"}`,
+      `${pc.cyan("Asana Integration:")} ${config.asanaBaseUrl ? "Yes" : "No"}`,
+      `${pc.cyan("AI Review:")} ${config.aiReviewTool === "none" ? "None" : config.aiReviewTool}`,
+      `${pc.cyan("CODEOWNERS:")} ${config.codeowners.length > 0 ? config.codeowners.join(", ") : "None"}`
+    ].join("\n"),
+    "Configuration Summary"
+  );
+  const confirmed = await p.confirm({
+    message: "Generate configuration files?",
+    initialValue: true
+  });
+  if (p.isCancel(confirmed)) {
+    p.cancel("Setup cancelled.");
+    process.exit(0);
+  }
+  return confirmed;
+}
+async function collectConfig(targetDir = process.cwd()) {
+  showWelcome();
+  const detection = await detectProjectType(targetDir);
+  const projectType = await promptProjectType(detection);
+  const usesTypeScript = await hasTypeScript(targetDir);
+  const usesEslint = await hasEslint(targetDir);
+  const usesPrettier = await hasPrettier(targetDir);
+  const asanaBaseUrl = await promptAsanaConfig();
+  const aiReviewTool = await promptAIReview();
+  const codeowners = await promptCodeowners();
+  const config = {
+    projectType,
+    asanaBaseUrl,
+    aiReviewTool,
+    codeowners,
+    usesTypeScript,
+    usesEslint,
+    usesPrettier
+  };
+  const confirmed = await promptConfirmation(config);
+  if (!confirmed) {
+    p.cancel("Setup cancelled.");
+    return null;
+  }
+  return config;
+}
+
+// src/generators/husky.ts
+import { join as join3 } from "path";
+
+// src/utils/file-system.ts
+import { existsSync as existsSync2 } from "fs";
+import {
+  mkdir,
+  readFile as readFile2,
+  writeFile,
+  copyFile,
+  chmod
+} from "fs/promises";
+import { dirname, join as join2 } from "path";
+async function ensureDir(dirPath) {
+  if (!existsSync2(dirPath)) {
+    await mkdir(dirPath, { recursive: true });
+  }
+}
+async function backupFile(filePath) {
+  if (!existsSync2(filePath)) {
+    return null;
+  }
+  const backupPath = `${filePath}.backup`;
+  await copyFile(filePath, backupPath);
+  return backupPath;
+}
+async function writeFileSafe(filePath, content, options = {}) {
+  const { backup = true, overwrite = true, executable = false } = options;
+  const exists = existsSync2(filePath);
+  if (exists && !overwrite) {
+    return { created: false, backedUp: null };
+  }
+  let backedUp = null;
+  if (exists && backup) {
+    backedUp = await backupFile(filePath);
+  }
+  await ensureDir(dirname(filePath));
+  await writeFile(filePath, content, "utf-8");
+  if (executable) {
+    await chmod(filePath, 493);
+  }
+  return { created: true, backedUp };
+}
+function fileExists(filePath) {
+  return existsSync2(filePath);
+}
+
+// src/generators/husky.ts
+function getPreCommitHook(projectType) {
+  if (projectType === "nx") {
+    return `#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+npx lint-staged
+`;
+  }
+  return `#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+npx lint-staged
+`;
+}
+function getCommitMsgHook() {
+  return `#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+npx --no -- commitlint --edit "$1"
+`;
+}
+function getPrePushHook() {
+  return `#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+npx validate-branch-name
+`;
+}
+async function generateHuskyHooks(targetDir, projectType) {
+  const result = {
+    created: [],
+    modified: [],
+    skipped: [],
+    backedUp: []
+  };
+  const huskyDir = join3(targetDir, ".husky");
+  await ensureDir(huskyDir);
+  const preCommitPath = join3(huskyDir, "pre-commit");
+  const preCommitResult = await writeFileSafe(
+    preCommitPath,
+    getPreCommitHook(projectType),
+    { executable: true, backup: true }
+  );
+  if (preCommitResult.created) {
+    result.created.push(".husky/pre-commit");
+    if (preCommitResult.backedUp) {
+      result.backedUp.push(preCommitResult.backedUp);
+    }
+  }
+  const commitMsgPath = join3(huskyDir, "commit-msg");
+  const commitMsgResult = await writeFileSafe(
+    commitMsgPath,
+    getCommitMsgHook(),
+    { executable: true, backup: true }
+  );
+  if (commitMsgResult.created) {
+    result.created.push(".husky/commit-msg");
+    if (commitMsgResult.backedUp) {
+      result.backedUp.push(commitMsgResult.backedUp);
+    }
+  }
+  const prePushPath = join3(huskyDir, "pre-push");
+  const prePushResult = await writeFileSafe(prePushPath, getPrePushHook(), {
+    executable: true,
+    backup: true
+  });
+  if (prePushResult.created) {
+    result.created.push(".husky/pre-push");
+    if (prePushResult.backedUp) {
+      result.backedUp.push(prePushResult.backedUp);
+    }
+  }
+  return result;
+}
+
+// src/generators/commitlint.ts
+import { join as join4 } from "path";
+function getCommitlintConfig(asanaBaseUrl) {
+  const baseConfig = `// @ts-check
+
+/** @type {import('@commitlint/types').UserConfig} */
+const config = {
+  extends: ['@commitlint/config-conventional'],
+  rules: {
+    // Type must be one of the conventional types
+    'type-enum': [
+      2,
+      'always',
+      [
+        'feat',     // New feature
+        'fix',      // Bug fix
+        'docs',     // Documentation changes
+        'style',    // Code style changes (formatting, etc.)
+        'refactor', // Code refactoring
+        'perf',     // Performance improvements
+        'test',     // Adding or updating tests
+        'build',    // Build system changes
+        'ci',       // CI configuration changes
+        'chore',    // Other changes (maintenance, etc.)
+        'revert',   // Reverting changes
+      ],
+    ],
+    // Subject should not be empty
+    'subject-empty': [2, 'never'],
+    // Type should not be empty
+    'type-empty': [2, 'never'],
+    // Subject should be lowercase
+    'subject-case': [2, 'always', 'lower-case'],
+    // Header max length
+    'header-max-length': [2, 'always', 100],
+  },`;
+  if (asanaBaseUrl) {
+    return `${baseConfig}
+  plugins: [
+    {
+      rules: {
+        'asana-task-link': ({ body, footer }) => {
+          const fullMessage = [body, footer].filter(Boolean).join('\\n');
+          const asanaPattern = /https:\\/\\/app\\.asana\\.com\\/\\d+\\/\\d+\\/\\d+/;
+          const hasAsanaLink = asanaPattern.test(fullMessage);
+          return [
+            hasAsanaLink,
+            hasAsanaLink
+              ? null
+              : 'Consider adding an Asana task link in the commit body or footer (e.g., Task: https://app.asana.com/0/...)',
+          ];
+        },
+      },
+    },
+  ],
+};
+
+// Enable the Asana task link rule as a WARNING (level 1)
+// Change to level 2 if you want to BLOCK commits without Asana links
+config.rules['asana-task-link'] = [1, 'always'];
+
+module.exports = config;
+`;
+  }
+  return `${baseConfig}
+};
+
+module.exports = config;
+`;
+}
+async function generateCommitlint(targetDir, asanaBaseUrl) {
+  const result = {
+    created: [],
+    modified: [],
+    skipped: [],
+    backedUp: []
+  };
+  const configPath = join4(targetDir, "commitlint.config.js");
+  const writeResult = await writeFileSafe(
+    configPath,
+    getCommitlintConfig(asanaBaseUrl),
+    { backup: true }
+  );
+  if (writeResult.created) {
+    result.created.push("commitlint.config.js");
+    if (writeResult.backedUp) {
+      result.backedUp.push(writeResult.backedUp);
+    }
+  }
+  return result;
+}
+
+// src/generators/cz-git.ts
+import { join as join5 } from "path";
+function getCzGitConfig(asanaBaseUrl) {
+  const asanaSection = asanaBaseUrl ? `
+  // Asana task reference settings
+  allowCustomIssuePrefix: true,
+  allowEmptyIssuePrefix: true,
+  issuePrefixes: [
+    { value: 'asana', name: 'asana: Link to Asana task' },
+    { value: 'closes', name: 'closes: Close an issue' },
+    { value: 'fixes', name: 'fixes:  Fix an issue' },
+  ],
+  customIssuePrefixAlign: 'top',` : `
+  allowCustomIssuePrefix: false,
+  allowEmptyIssuePrefix: true,`;
+  return `// @ts-check
+
+/** @type {import('cz-git').UserConfig} */
+module.exports = {
+  extends: ['@commitlint/config-conventional'],
+  prompt: {
+    alias: {
+      fd: 'docs: fix typos',
+      ur: 'docs: update README',
+    },
+    messages: {
+      type: "Select the type of change you're committing:",
+      scope: 'Denote the scope of this change (optional):',
+      customScope: 'Denote the scope of this change:',
+      subject: 'Write a short, imperative description of the change:\\n',
+      body: 'Provide a longer description of the change (optional). Use "|" to break new line:\\n',
+      breaking: 'List any BREAKING CHANGES (optional). Use "|" to break new line:\\n',
+      footerPrefixSelect: 'Select the ISSUES type of change (optional):',
+      customFooterPrefix: 'Input ISSUES prefix:',
+      footer: 'List any ISSUES affected by this change (optional). E.g.: #31, #34:\\n',
+      confirmCommit: 'Are you sure you want to proceed with the commit above?',
+    },
+    types: [
+      { value: 'feat', name: 'feat:     \u2728 A new feature', emoji: ':sparkles:' },
+      { value: 'fix', name: 'fix:      \u{1F41B} A bug fix', emoji: ':bug:' },
+      { value: 'docs', name: 'docs:     \u{1F4DD} Documentation changes', emoji: ':memo:' },
+      { value: 'style', name: 'style:    \u{1F484} Code style changes', emoji: ':lipstick:' },
+      { value: 'refactor', name: 'refactor: \u267B\uFE0F  Code refactoring', emoji: ':recycle:' },
+      { value: 'perf', name: 'perf:     \u26A1\uFE0F Performance improvements', emoji: ':zap:' },
+      { value: 'test', name: 'test:     \u2705 Adding or updating tests', emoji: ':white_check_mark:' },
+      { value: 'build', name: 'build:    \u{1F4E6} Build system changes', emoji: ':package:' },
+      { value: 'ci', name: 'ci:       \u{1F3A1} CI configuration changes', emoji: ':ferris_wheel:' },
+      { value: 'chore', name: 'chore:    \u{1F527} Other changes', emoji: ':wrench:' },
+      { value: 'revert', name: 'revert:   \u23EA Reverting changes', emoji: ':rewind:' },
+    ],
+    useEmoji: true,
+    emojiAlign: 'center',
+    useAI: false,
+    aiNumber: 1,
+    themeColorCode: '',
+    scopes: [],
+    allowCustomScopes: true,
+    allowEmptyScopes: true,
+    customScopesAlign: 'bottom',
+    customScopesAlias: 'custom',
+    emptyScopesAlias: 'empty',
+    upperCaseSubject: false,
+    markBreakingChangeMode: false,
+    allowBreakingChanges: ['feat', 'fix'],
+    breaklineNumber: 100,
+    breaklineChar: '|',
+    skipQuestions: [],${asanaSection}
+    confirmColorize: true,
+    minSubjectLength: 0,
+    defaultBody: '',
+    defaultIssues: '',
+    defaultScope: '',
+    defaultSubject: '',
+  },
+};
+`;
+}
+async function generateCzGit(targetDir, asanaBaseUrl) {
+  const result = {
+    created: [],
+    modified: [],
+    skipped: [],
+    backedUp: []
+  };
+  const configPath = join5(targetDir, ".czrc");
+  const writeResult = await writeFileSafe(
+    configPath,
+    JSON.stringify({ path: "node_modules/cz-git" }, null, 2) + "\n",
+    { backup: true }
+  );
+  if (writeResult.created) {
+    result.created.push(".czrc");
+    if (writeResult.backedUp) {
+      result.backedUp.push(writeResult.backedUp);
+    }
+  }
+  const czConfigPath = join5(targetDir, "cz.config.js");
+  const czConfigResult = await writeFileSafe(
+    czConfigPath,
+    getCzGitConfig(asanaBaseUrl),
+    { backup: true }
+  );
+  if (czConfigResult.created) {
+    result.created.push("cz.config.js");
+    if (czConfigResult.backedUp) {
+      result.backedUp.push(czConfigResult.backedUp);
+    }
+  }
+  return result;
+}
+
+// src/generators/lint-staged.ts
+import { join as join6 } from "path";
+function getLintStagedConfig(projectType, usesEslint, usesPrettier, usesTypeScript) {
+  const rules = {};
+  if (usesTypeScript) {
+    const tsCommands = [];
+    if (usesEslint) {
+      tsCommands.push("eslint --fix");
+    }
+    if (usesPrettier) {
+      tsCommands.push("prettier --write");
+    }
+    if (tsCommands.length > 0) {
+      rules["*.{ts,tsx}"] = tsCommands;
+    }
+  }
+  const jsCommands = [];
+  if (usesEslint) {
+    jsCommands.push("eslint --fix");
+  }
+  if (usesPrettier) {
+    jsCommands.push("prettier --write");
+  }
+  if (jsCommands.length > 0) {
+    rules["*.{js,jsx,mjs,cjs}"] = jsCommands;
+  }
+  if (usesPrettier) {
+    rules["*.{json,md,yaml,yml}"] = "prettier --write";
+  }
+  if (usesPrettier) {
+    rules["*.{css,scss,less}"] = "prettier --write";
+  }
+  if (projectType === "nx") {
+    return `// @ts-check
+
+/**
+ * @type {import('lint-staged').Config}
+ */
+module.exports = {
+${Object.entries(rules).map(([pattern, commands]) => {
+      const cmdStr = Array.isArray(commands) ? JSON.stringify(commands) : JSON.stringify([commands]);
+      return `  '${pattern}': ${cmdStr},`;
+    }).join("\n")}
+};
+`;
+  }
+  return `// @ts-check
+
+/**
+ * @type {import('lint-staged').Config}
+ */
+module.exports = {
+${Object.entries(rules).map(([pattern, commands]) => {
+    const cmdStr = Array.isArray(commands) ? JSON.stringify(commands) : JSON.stringify([commands]);
+    return `  '${pattern}': ${cmdStr},`;
+  }).join("\n")}
+};
+`;
+}
+async function generateLintStaged(targetDir, projectType, usesEslint, usesPrettier, usesTypeScript) {
+  const result = {
+    created: [],
+    modified: [],
+    skipped: [],
+    backedUp: []
+  };
+  const configPath = join6(targetDir, ".lintstagedrc.js");
+  const writeResult = await writeFileSafe(
+    configPath,
+    getLintStagedConfig(projectType, usesEslint, usesPrettier, usesTypeScript),
+    { backup: true }
+  );
+  if (writeResult.created) {
+    result.created.push(".lintstagedrc.js");
+    if (writeResult.backedUp) {
+      result.backedUp.push(writeResult.backedUp);
+    }
+  }
+  return result;
+}
+
+// src/utils/package-json.ts
+import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { join as join7 } from "path";
+async function readPackageJson(targetDir = process.cwd()) {
+  const pkgPath = join7(targetDir, "package.json");
+  if (!existsSync3(pkgPath)) {
+    throw new Error(`No package.json found in ${targetDir}`);
+  }
+  const content = await readFile3(pkgPath, "utf-8");
+  return JSON.parse(content);
+}
+async function writePackageJson(pkg, targetDir = process.cwd()) {
+  const pkgPath = join7(targetDir, "package.json");
+  const content = JSON.stringify(pkg, null, 2) + "\n";
+  await writeFile2(pkgPath, content, "utf-8");
+}
+function mergeScripts(pkg, scripts, overwrite = false) {
+  const existingScripts = pkg.scripts || {};
+  const newScripts = { ...existingScripts };
+  for (const [name, command] of Object.entries(scripts)) {
+    if (overwrite || !existingScripts[name]) {
+      newScripts[name] = command;
+    }
+  }
+  return {
+    ...pkg,
+    scripts: newScripts
+  };
+}
+function mergeDevDependencies(pkg, deps) {
+  const existingDeps = pkg.devDependencies || {};
+  return {
+    ...pkg,
+    devDependencies: {
+      ...existingDeps,
+      ...deps
+    }
+  };
+}
+function addPackageJsonConfig(pkg, key, config, overwrite = false) {
+  if (!overwrite && pkg[key]) {
+    return pkg;
+  }
+  return {
+    ...pkg,
+    [key]: config
+  };
+}
+var RAFTSTACK_DEV_DEPENDENCIES = {
+  "@commitlint/cli": "^18.0.0",
+  "@commitlint/config-conventional": "^18.0.0",
+  "cz-git": "^1.8.0",
+  czg: "^1.8.0",
+  husky: "^9.0.0",
+  "lint-staged": "^15.0.0",
+  "validate-branch-name": "^1.3.0"
+};
+
+// src/generators/branch-validation.ts
+function getBranchValidationConfig() {
+  return {
+    pattern: "^(main|master|develop|staging|production)$|^(feature|fix|hotfix|bugfix|release|chore|docs|refactor|test|ci)\\/[a-z0-9._-]+$",
+    errorMsg: "Branch name must follow pattern: feature/*, fix/*, hotfix/*, bugfix/*, release/*, chore/*, docs/*, refactor/*, test/*, ci/* or be main/master/develop/staging/production"
+  };
+}
+async function generateBranchValidation(targetDir) {
+  const result = {
+    created: [],
+    modified: [],
+    skipped: [],
+    backedUp: []
+  };
+  try {
+    const pkg = await readPackageJson(targetDir);
+    const config = getBranchValidationConfig();
+    const updatedPkg = addPackageJsonConfig(
+      pkg,
+      "validate-branch-name",
+      config,
+      false
+      // Don't overwrite if exists
+    );
+    if (JSON.stringify(pkg) !== JSON.stringify(updatedPkg)) {
+      await writePackageJson(updatedPkg, targetDir);
+      result.modified.push("package.json (validate-branch-name)");
+    } else {
+      result.skipped.push("validate-branch-name config (already exists)");
+    }
+  } catch (error) {
+    result.skipped.push("validate-branch-name config (no package.json)");
+  }
+  return result;
+}
+
+// src/generators/pr-template.ts
+import { join as join8 } from "path";
+function getPRTemplate(hasAsana) {
+  const asanaSection = hasAsana ? `## Asana Task
+<!-- Link to the Asana task -->
+- [ ] https://app.asana.com/0/...
+
+` : "";
+  return `## Description
+<!-- Provide a brief description of the changes in this PR -->
+
+## Type of Change
+<!-- Mark the appropriate option with an "x" -->
+- [ ] \u{1F41B} Bug fix (non-breaking change that fixes an issue)
+- [ ] \u2728 New feature (non-breaking change that adds functionality)
+- [ ] \u{1F4A5} Breaking change (fix or feature that would cause existing functionality to not work as expected)
+- [ ] \u{1F4DD} Documentation update
+- [ ] \u{1F527} Configuration change
+- [ ] \u267B\uFE0F Refactoring (no functional changes)
+- [ ] \u2705 Test update
+
+${asanaSection}## Changes Made
+<!-- List the specific changes made in this PR -->
+-
+
+## Testing
+<!-- Describe how you tested your changes -->
+- [ ] Unit tests added/updated
+- [ ] Integration tests added/updated
+- [ ] Manual testing performed
+
+## Screenshots (if applicable)
+<!-- Add screenshots to help explain your changes -->
+
+## Checklist
+- [ ] My code follows the project's coding standards
+- [ ] I have performed a self-review of my code
+- [ ] I have commented my code, particularly in hard-to-understand areas
+- [ ] I have made corresponding changes to the documentation
+- [ ] My changes generate no new warnings
+- [ ] Any dependent changes have been merged and published
+
+## Additional Notes
+<!-- Add any additional information that reviewers should know -->
+`;
+}
+async function generatePRTemplate(targetDir, hasAsana) {
+  const result = {
+    created: [],
+    modified: [],
+    skipped: [],
+    backedUp: []
+  };
+  const githubDir = join8(targetDir, ".github");
+  await ensureDir(githubDir);
+  const templatePath = join8(githubDir, "PULL_REQUEST_TEMPLATE.md");
+  const writeResult = await writeFileSafe(
+    templatePath,
+    getPRTemplate(hasAsana),
+    { backup: true }
+  );
+  if (writeResult.created) {
+    result.created.push(".github/PULL_REQUEST_TEMPLATE.md");
+    if (writeResult.backedUp) {
+      result.backedUp.push(writeResult.backedUp);
+    }
+  }
+  return result;
+}
+
+// src/generators/github-workflows.ts
+import { join as join9 } from "path";
+function getPRChecksWorkflow(projectType, usesTypeScript, usesEslint) {
+  const steps = [];
+  steps.push(`      - name: Checkout
+        uses: actions/checkout@v4`);
+  steps.push(`
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'`);
+  steps.push(`
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v3
+        with:
+          version: 9`);
+  steps.push(`
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile`);
+  if (usesTypeScript) {
+    steps.push(`
+      - name: Type check
+        run: pnpm typecheck`);
+  }
+  if (usesEslint) {
+    steps.push(`
+      - name: Lint
+        run: pnpm lint`);
+  }
+  if (projectType === "nx") {
+    steps.push(`
+      - name: Build
+        run: pnpm nx affected --target=build --parallel=3`);
+  } else if (projectType === "turbo") {
+    steps.push(`
+      - name: Build
+        run: pnpm turbo build`);
+  } else {
+    steps.push(`
+      - name: Build
+        run: pnpm build`);
+  }
+  if (projectType === "nx") {
+    steps.push(`
+      - name: Test
+        run: pnpm nx affected --target=test --parallel=3`);
+  } else if (projectType === "turbo") {
+    steps.push(`
+      - name: Test
+        run: pnpm turbo test`);
+  } else {
+    steps.push(`
+      - name: Test
+        run: pnpm test`);
+  }
+  return `name: PR Checks
+
+on:
+  pull_request:
+    branches: [main, master, develop]
+
+concurrency:
+  group: \${{ github.workflow }}-\${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  check:
+    name: Check
+    runs-on: ubuntu-latest
+    steps:
+${steps.join("\n")}
+`;
+}
+async function generateGitHubWorkflows(targetDir, projectType, usesTypeScript, usesEslint) {
+  const result = {
+    created: [],
+    modified: [],
+    skipped: [],
+    backedUp: []
+  };
+  const workflowsDir = join9(targetDir, ".github", "workflows");
+  await ensureDir(workflowsDir);
+  const prChecksPath = join9(workflowsDir, "pr-checks.yml");
+  const writeResult = await writeFileSafe(
+    prChecksPath,
+    getPRChecksWorkflow(projectType, usesTypeScript, usesEslint),
+    { backup: true }
+  );
+  if (writeResult.created) {
+    result.created.push(".github/workflows/pr-checks.yml");
+    if (writeResult.backedUp) {
+      result.backedUp.push(writeResult.backedUp);
+    }
+  }
+  return result;
+}
+
+// src/generators/codeowners.ts
+import { join as join10 } from "path";
+function getCodeownersContent(owners) {
+  if (owners.length === 0) {
+    return `# CODEOWNERS file
+# Learn about CODEOWNERS: https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-code-owners
+
+# Default owners for everything in the repo
+# Uncomment and modify the line below to set default owners
+# * @owner1 @owner2
+`;
+  }
+  const ownersList = owners.join(" ");
+  return `# CODEOWNERS file
+# Learn about CODEOWNERS: https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-code-owners
+
+# Default owners for everything in the repo
+* ${ownersList}
+
+# You can also specify owners for specific paths:
+# /docs/ @docs-team
+# /src/api/ @backend-team
+# /src/ui/ @frontend-team
+# *.ts @typescript-team
+`;
+}
+async function generateCodeowners(targetDir, owners) {
+  const result = {
+    created: [],
+    modified: [],
+    skipped: [],
+    backedUp: []
+  };
+  const githubDir = join10(targetDir, ".github");
+  await ensureDir(githubDir);
+  const codeownersPath = join10(githubDir, "CODEOWNERS");
+  const writeResult = await writeFileSafe(
+    codeownersPath,
+    getCodeownersContent(owners),
+    { backup: true }
+  );
+  if (writeResult.created) {
+    result.created.push(".github/CODEOWNERS");
+    if (writeResult.backedUp) {
+      result.backedUp.push(writeResult.backedUp);
+    }
+  }
+  return result;
+}
+
+// src/generators/ai-review.ts
+import { join as join11 } from "path";
+function getCodeRabbitConfig() {
+  return `# CodeRabbit Configuration
+# Learn more: https://docs.coderabbit.ai/guides/configure-coderabbit
+
+language: "en-US"
+
+reviews:
+  request_changes_workflow: true
+  high_level_summary: true
+  poem: false
+  review_status: true
+  collapse_walkthrough: false
+  auto_review:
+    enabled: true
+    drafts: false
+
+chat:
+  auto_reply: true
+`;
+}
+function getCopilotWorkflow() {
+  return `name: Copilot Code Review
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+
+permissions:
+  contents: read
+  pull-requests: write
+
+jobs:
+  review:
+    name: Copilot Review
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      # Note: GitHub Copilot code review is automatically enabled
+      # when you have Copilot Enterprise. This workflow is a placeholder
+      # for any additional AI review configuration you might need.
+
+      - name: Add review comment
+        uses: actions/github-script@v7
+        with:
+          script: |
+            // GitHub Copilot will automatically review PRs if enabled
+            // This is a placeholder for additional review logic
+            console.log('Copilot review enabled for this repository');
+`;
+}
+async function generateAIReview(targetDir, tool) {
+  const result = {
+    created: [],
+    modified: [],
+    skipped: [],
+    backedUp: []
+  };
+  if (tool === "none") {
+    return result;
+  }
+  if (tool === "coderabbit") {
+    const configPath = join11(targetDir, ".coderabbit.yaml");
+    const writeResult = await writeFileSafe(configPath, getCodeRabbitConfig(), {
+      backup: true
+    });
+    if (writeResult.created) {
+      result.created.push(".coderabbit.yaml");
+      if (writeResult.backedUp) {
+        result.backedUp.push(writeResult.backedUp);
+      }
+    }
+  }
+  if (tool === "copilot") {
+    const workflowsDir = join11(targetDir, ".github", "workflows");
+    await ensureDir(workflowsDir);
+    const workflowPath = join11(workflowsDir, "copilot-review.yml");
+    const writeResult = await writeFileSafe(workflowPath, getCopilotWorkflow(), {
+      backup: true
+    });
+    if (writeResult.created) {
+      result.created.push(".github/workflows/copilot-review.yml");
+      if (writeResult.backedUp) {
+        result.backedUp.push(writeResult.backedUp);
+      }
+    }
+  }
+  return result;
+}
+
+// src/generators/branch-protection.ts
+import { join as join12 } from "path";
+function getBranchProtectionDocs() {
+  return `# Branch Protection Setup Guide
+
+This guide explains how to configure branch protection rules for your repository.
+
+## Quick Setup
+
+Run the automated setup command:
+
+\`\`\`bash
+raftstack setup-protection
+\`\`\`
+
+This command supports:
+- **Multiple branches**: main, staging, production, development, etc.
+- **Merge strategies**: Rebase (recommended), squash, or merge commits
+- **Review requirements**: Configurable number of required approvals
+
+## Recommended Settings
+
+### For \`main\` / \`master\` branch:
+
+1. **Require a pull request before merging**
+   - \u2705 Require approvals: 1 (or more for larger teams)
+   - \u2705 Dismiss stale pull request approvals when new commits are pushed
+   - \u2705 Require review from Code Owners
+
+2. **Require status checks to pass before merging**
+   - \u2705 Require branches to be up to date before merging
+   - Select required status checks:
+     - \`check\` (from pr-checks.yml workflow)
+
+3. **Require conversation resolution before merging**
+   - \u2705 All conversations on code must be resolved
+
+4. **Do not allow bypassing the above settings**
+   - \u2705 Apply rules to administrators
+
+5. **Restrict who can push to matching branches**
+   - Only allow merges through pull requests
+
+6. **Block force pushes**
+   - \u2705 Do not allow force pushes
+
+7. **Block deletions**
+   - \u2705 Do not allow this branch to be deleted
+
+## Manual Setup via GitHub UI
+
+1. Go to your repository on GitHub
+2. Click **Settings** > **Branches**
+3. Click **Add branch protection rule**
+4. Enter \`main\` (or \`master\`) as the branch name pattern
+5. Configure the settings as described above
+6. Click **Create** or **Save changes**
+
+## Automated Setup (Recommended)
+
+Use the \`raftstack setup-protection\` command to configure
+branch protection rules automatically using the GitHub CLI.
+
+Requirements:
+- GitHub CLI (\`gh\`) installed and authenticated
+- Admin access to the repository
+
+\`\`\`bash
+raftstack setup-protection
+\`\`\`
+
+### Features
+
+The setup command will:
+1. Prompt you to select branches to protect (main, staging, production, etc.)
+2. Let you choose a merge strategy (rebase, squash, or merge commits)
+3. Configure required review count
+4. Apply branch protection rules to all selected branches
+5. Set repository merge settings
+
+### Merge Strategy Recommendations
+
+| Strategy | Use Case |
+|----------|----------|
+| **Rebase** (recommended) | Clean linear history, easy to follow |
+| **Squash** | Single commit per PR, cleaner history |
+| **Merge commit** | Preserve all commits, show PR merge points |
+
+## Branch Naming Convention
+
+This project enforces branch naming conventions via \`validate-branch-name\`.
+
+Allowed patterns:
+- \`main\`, \`master\`, \`develop\`, \`staging\`, \`production\`
+- \`feature/*\` - New features
+- \`fix/*\` or \`bugfix/*\` - Bug fixes
+- \`hotfix/*\` - Urgent fixes
+- \`release/*\` - Release preparation
+- \`chore/*\` - Maintenance tasks
+- \`docs/*\` - Documentation updates
+- \`refactor/*\` - Code refactoring
+- \`test/*\` - Test additions/updates
+- \`ci/*\` - CI/CD changes
+
+Examples:
+- \`feature/user-authentication\`
+- \`fix/login-validation\`
+- \`hotfix/security-patch\`
+- \`release/v1.2.0\`
+`;
+}
+async function generateBranchProtectionDocs(targetDir) {
+  const result = {
+    created: [],
+    modified: [],
+    skipped: [],
+    backedUp: []
+  };
+  const docsDir = join12(targetDir, ".github");
+  await ensureDir(docsDir);
+  const docsPath = join12(docsDir, "BRANCH_PROTECTION_SETUP.md");
+  const writeResult = await writeFileSafe(docsPath, getBranchProtectionDocs(), {
+    backup: true
+  });
+  if (writeResult.created) {
+    result.created.push(".github/BRANCH_PROTECTION_SETUP.md");
+    if (writeResult.backedUp) {
+      result.backedUp.push(writeResult.backedUp);
+    }
+  }
+  return result;
+}
+
+// src/generators/contributing.ts
+import { join as join13 } from "path";
+function getContributingContent(hasAsana) {
+  const asanaSection = hasAsana ? `
+## Linking to Asana
+
+When working on a task:
+1. Create a branch following the naming convention (e.g., \`feature/task-description\`)
+2. Include the Asana task link in your commit body or footer
+3. Reference the Asana task in your PR description
+
+Example commit:
+\`\`\`
+feat(auth): add password reset functionality
+
+Implement password reset flow with email verification.
+
+Asana: https://app.asana.com/0/workspace/task-id
+\`\`\`
+` : "";
+  return `# Contributing Guide
+
+Thank you for your interest in contributing! This document outlines our development workflow and standards.
+
+## Getting Started
+
+1. Clone the repository
+2. Install dependencies: \`pnpm install\`
+3. Create a new branch following our naming convention
+
+## Branch Naming Convention
+
+We use structured branch names to keep our repository organized:
+
+| Prefix | Purpose | Example |
+|--------|---------|---------|
+| \`feature/\` | New features | \`feature/user-authentication\` |
+| \`fix/\` | Bug fixes | \`fix/login-validation\` |
+| \`hotfix/\` | Urgent fixes | \`hotfix/security-patch\` |
+| \`bugfix/\` | Bug fixes (alternative) | \`bugfix/form-submission\` |
+| \`release/\` | Release preparation | \`release/v1.2.0\` |
+| \`chore/\` | Maintenance tasks | \`chore/update-dependencies\` |
+| \`docs/\` | Documentation | \`docs/api-reference\` |
+| \`refactor/\` | Code refactoring | \`refactor/auth-module\` |
+| \`test/\` | Test additions | \`test/user-service\` |
+| \`ci/\` | CI/CD changes | \`ci/github-actions\` |
+
+## Commit Convention
+
+We follow [Conventional Commits](https://www.conventionalcommits.org/). Use the interactive commit tool:
+
+\`\`\`bash
+pnpm commit
+\`\`\`
+
+### Commit Types
+
+| Type | Description |
+|------|-------------|
+| \`feat\` | New feature |
+| \`fix\` | Bug fix |
+| \`docs\` | Documentation changes |
+| \`style\` | Code style changes (formatting, etc.) |
+| \`refactor\` | Code refactoring |
+| \`perf\` | Performance improvements |
+| \`test\` | Adding or updating tests |
+| \`build\` | Build system changes |
+| \`ci\` | CI configuration changes |
+| \`chore\` | Other changes |
+| \`revert\` | Reverting changes |
+
+### Commit Message Format
+
+\`\`\`
+<type>(<scope>): <subject>
+
+<body>
+
+<footer>
+\`\`\`
+
+Example:
+\`\`\`
+feat(auth): add social login support
+
+Implement OAuth2 login for Google and GitHub providers.
+Includes user profile sync and token refresh.
+
+Closes #123
+\`\`\`
+${asanaSection}
+## Pull Request Process
+
+1. Ensure your branch is up to date with \`main\`/\`master\`
+2. Run tests and linting locally
+3. Create a pull request using the provided template
+4. Request review from code owners
+5. Address any feedback
+6. Merge once approved and all checks pass
+
+### PR Size Guidelines
+
+Keep pull requests small and focused for faster reviews:
+
+| Size | Lines Changed | Review Time |
+|------|---------------|-------------|
+| XS | 0-10 lines | Minutes |
+| S | 11-50 lines | < 30 min |
+| M | 51-200 lines | < 1 hour |
+| L | 201-400 lines | 1-2 hours |
+| XL | 400+ lines | Needs justification |
+
+**Target: < 400 lines per PR**
+
+If your PR is large:
+- Consider splitting it into smaller, logical PRs
+- Explain in the description why it can't be split
+
+## Code Quality
+
+Before committing, the following checks run automatically:
+
+- **Linting**: ESLint checks for code quality
+- **Formatting**: Prettier ensures consistent style
+- **Type checking**: TypeScript validates types
+- **Commit messages**: Commitlint validates format
+- **Branch names**: validate-branch-name checks naming
+
+## Questions?
+
+If you have questions, please open an issue or reach out to the maintainers.
+`;
+}
+async function generateContributing(targetDir, hasAsana) {
+  const result = {
+    created: [],
+    modified: [],
+    skipped: [],
+    backedUp: []
+  };
+  const contributingPath = join13(targetDir, "CONTRIBUTING.md");
+  const writeResult = await writeFileSafe(
+    contributingPath,
+    getContributingContent(hasAsana),
+    { backup: true }
+  );
+  if (writeResult.created) {
+    result.created.push("CONTRIBUTING.md");
+    if (writeResult.backedUp) {
+      result.backedUp.push(writeResult.backedUp);
+    }
+  }
+  return result;
+}
+
+// src/generators/prettier.ts
+import { join as join14 } from "path";
+function getPrettierConfig() {
+  return JSON.stringify(
+    {
+      semi: true,
+      singleQuote: true,
+      tabWidth: 2,
+      trailingComma: "es5",
+      printWidth: 100,
+      bracketSpacing: true,
+      arrowParens: "always",
+      endOfLine: "lf"
+    },
+    null,
+    2
+  ) + "\n";
+}
+function getPrettierIgnore() {
+  return `# Dependencies
+node_modules/
+
+# Build output
+dist/
+build/
+.next/
+out/
+
+# Coverage
+coverage/
+
+# IDE
+.idea/
+.vscode/
+
+# Generated files
+*.min.js
+*.min.css
+package-lock.json
+pnpm-lock.yaml
+yarn.lock
+
+# Other
+.git/
+`;
+}
+function hasPrettierConfig(targetDir) {
+  const prettierFiles = [
+    ".prettierrc",
+    ".prettierrc.js",
+    ".prettierrc.cjs",
+    ".prettierrc.json",
+    ".prettierrc.yaml",
+    ".prettierrc.yml",
+    ".prettierrc.toml",
+    "prettier.config.js",
+    "prettier.config.cjs",
+    "prettier.config.mjs"
+  ];
+  return prettierFiles.some((file) => fileExists(join14(targetDir, file)));
+}
+async function generatePrettier(targetDir) {
+  const result = {
+    created: [],
+    modified: [],
+    skipped: [],
+    backedUp: []
+  };
+  if (hasPrettierConfig(targetDir)) {
+    result.skipped.push(".prettierrc (already exists)");
+    return result;
+  }
+  const configPath = join14(targetDir, ".prettierrc");
+  const configResult = await writeFileSafe(configPath, getPrettierConfig(), {
+    backup: true
+  });
+  if (configResult.created) {
+    result.created.push(".prettierrc");
+    if (configResult.backedUp) {
+      result.backedUp.push(configResult.backedUp);
+    }
+  }
+  const ignorePath = join14(targetDir, ".prettierignore");
+  const ignoreResult = await writeFileSafe(ignorePath, getPrettierIgnore(), {
+    backup: true,
+    overwrite: false
+    // Don't overwrite existing ignore file
+  });
+  if (ignoreResult.created) {
+    result.created.push(".prettierignore");
+    if (ignoreResult.backedUp) {
+      result.backedUp.push(ignoreResult.backedUp);
+    }
+  } else {
+    result.skipped.push(".prettierignore (already exists)");
+  }
+  return result;
+}
+
+// src/generators/claude-skills.ts
+import { existsSync as existsSync4 } from "fs";
+import { readdir, copyFile as copyFile2 } from "fs/promises";
+import { join as join15, dirname as dirname2 } from "path";
+import { fileURLToPath } from "url";
+function getPackageSkillsDir() {
+  const currentFilePath = fileURLToPath(import.meta.url);
+  const packageRoot = join15(dirname2(currentFilePath), "..", "..");
+  return join15(packageRoot, ".claude", "skills");
+}
+async function copyDirectory(srcDir, destDir, result, baseDir) {
+  await ensureDir(destDir);
+  const entries = await readdir(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = join15(srcDir, entry.name);
+    const destPath = join15(destDir, entry.name);
+    const relativePath = destPath.replace(baseDir + "/", "");
+    if (entry.isDirectory()) {
+      await copyDirectory(srcPath, destPath, result, baseDir);
+    } else {
+      if (existsSync4(destPath)) {
+        const backupPath = await backupFile(destPath);
+        if (backupPath) {
+          result.backedUp.push(relativePath);
+        }
+      }
+      await copyFile2(srcPath, destPath);
+      result.created.push(relativePath);
+    }
+  }
+}
+async function generateClaudeSkills(targetDir) {
+  const result = {
+    created: [],
+    modified: [],
+    skipped: [],
+    backedUp: []
+  };
+  const packageSkillsDir = getPackageSkillsDir();
+  const targetSkillsDir = join15(targetDir, ".claude", "skills");
+  if (!existsSync4(packageSkillsDir)) {
+    console.warn(
+      "Warning: Skills directory not found in package. Skipping skills generation."
+    );
+    return result;
+  }
+  await ensureDir(join15(targetDir, ".claude"));
+  await copyDirectory(packageSkillsDir, targetSkillsDir, result, targetDir);
+  return result;
+}
+
+// src/generators/eslint.ts
+import { existsSync as existsSync5 } from "fs";
+import { readFile as readFile4 } from "fs/promises";
+import { join as join16 } from "path";
+
+// src/utils/git.ts
+import { execa } from "execa";
+import { existsSync as existsSync6 } from "fs";
+import { join as join17 } from "path";
+async function isGitRepo(targetDir = process.cwd()) {
+  if (existsSync6(join17(targetDir, ".git"))) {
+    return true;
+  }
+  try {
+    await execa("git", ["rev-parse", "--git-dir"], { cwd: targetDir });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isGhCliAvailable() {
+  try {
+    await execa("gh", ["auth", "status"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getGitHubRepoInfo(targetDir = process.cwd()) {
+  try {
+    const { stdout } = await execa("gh", ["repo", "view", "--json", "owner,name"], {
+      cwd: targetDir
+    });
+    const data = JSON.parse(stdout);
+    return {
+      owner: data.owner.login,
+      repo: data.name
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/init.ts
+function mergeResults(results) {
+  return results.reduce(
+    (acc, result) => ({
+      created: [...acc.created, ...result.created],
+      modified: [...acc.modified, ...result.modified],
+      skipped: [...acc.skipped, ...result.skipped],
+      backedUp: [...acc.backedUp, ...result.backedUp]
+    }),
+    { created: [], modified: [], skipped: [], backedUp: [] }
+  );
+}
+async function updateProjectPackageJson(targetDir, _config) {
+  const result = {
+    created: [],
+    modified: [],
+    skipped: [],
+    backedUp: []
+  };
+  try {
+    let pkg = await readPackageJson(targetDir);
+    const scripts = {
+      prepare: "husky",
+      commit: "czg"
+    };
+    pkg = mergeScripts(pkg, scripts, false);
+    pkg = mergeDevDependencies(pkg, RAFTSTACK_DEV_DEPENDENCIES);
+    await writePackageJson(pkg, targetDir);
+    result.modified.push("package.json");
+  } catch (error) {
+    result.skipped.push("package.json (error updating)");
+  }
+  return result;
+}
+async function runInit(targetDir = process.cwd()) {
+  const isRepo = await isGitRepo(targetDir);
+  if (!isRepo) {
+    p2.log.warn(
+      pc2.yellow(
+        "This directory is not a git repository. Some features may not work correctly."
+      )
+    );
+    const proceed = await p2.confirm({
+      message: "Continue anyway?",
+      initialValue: false
+    });
+    if (p2.isCancel(proceed) || !proceed) {
+      p2.cancel("Setup cancelled.");
+      process.exit(0);
+    }
+  }
+  const config = await collectConfig(targetDir);
+  if (!config) {
+    return;
+  }
+  const spinner3 = p2.spinner();
+  spinner3.start("Generating configuration files...");
+  const results = [];
+  try {
+    results.push(await generateHuskyHooks(targetDir, config.projectType));
+    results.push(await generateCommitlint(targetDir, config.asanaBaseUrl));
+    results.push(await generateCzGit(targetDir, config.asanaBaseUrl));
+    results.push(
+      await generateLintStaged(
+        targetDir,
+        config.projectType,
+        config.usesEslint,
+        config.usesPrettier,
+        config.usesTypeScript
+      )
+    );
+    results.push(await generateBranchValidation(targetDir));
+    if (!config.usesPrettier) {
+      results.push(await generatePrettier(targetDir));
+    }
+    results.push(await generatePRTemplate(targetDir, !!config.asanaBaseUrl));
+    results.push(
+      await generateGitHubWorkflows(
+        targetDir,
+        config.projectType,
+        config.usesTypeScript,
+        config.usesEslint
+      )
+    );
+    results.push(await generateCodeowners(targetDir, config.codeowners));
+    results.push(await generateAIReview(targetDir, config.aiReviewTool));
+    results.push(await generateBranchProtectionDocs(targetDir));
+    results.push(await generateContributing(targetDir, !!config.asanaBaseUrl));
+    results.push(await generateClaudeSkills(targetDir));
+    results.push(await updateProjectPackageJson(targetDir, config));
+    spinner3.stop("Configuration files generated!");
+  } catch (error) {
+    spinner3.stop("Error generating files");
+    p2.log.error(
+      pc2.red(
+        `Error: ${error instanceof Error ? error.message : "Unknown error"}`
+      )
+    );
+    process.exit(1);
+  }
+  const finalResult = mergeResults(results);
+  console.log();
+  if (finalResult.created.length > 0) {
+    p2.log.success(pc2.green("Created files:"));
+    for (const file of finalResult.created) {
+      console.log(`  ${pc2.dim("+")} ${file}`);
+    }
+  }
+  if (finalResult.modified.length > 0) {
+    console.log();
+    p2.log.info(pc2.blue("Modified files:"));
+    for (const file of finalResult.modified) {
+      console.log(`  ${pc2.dim("~")} ${file}`);
+    }
+  }
+  if (finalResult.skipped.length > 0) {
+    console.log();
+    p2.log.warn(pc2.yellow("Skipped (already exist):"));
+    for (const file of finalResult.skipped) {
+      console.log(`  ${pc2.dim("-")} ${file}`);
+    }
+  }
+  if (finalResult.backedUp.length > 0) {
+    console.log();
+    p2.log.info(pc2.dim("Backed up files:"));
+    for (const file of finalResult.backedUp) {
+      console.log(`  ${pc2.dim("\u2192")} ${file}`);
+    }
+  }
+  console.log();
+  p2.note(
+    [
+      `${pc2.cyan("1.")} Run ${pc2.yellow("pnpm install")} to install dependencies`,
+      `${pc2.cyan("2.")} Review the generated configuration files`,
+      `${pc2.cyan("3.")} Use ${pc2.yellow("pnpm commit")} for interactive commits`,
+      `${pc2.cyan("4.")} Set up branch protection rules (see .github/BRANCH_PROTECTION_SETUP.md)`
+    ].join("\n"),
+    "Next Steps"
+  );
+  p2.outro(pc2.green("RaftStack setup complete! Happy coding! \u{1F680}"));
+}
+
+// src/commands/setup-protection.ts
+import * as p3 from "@clack/prompts";
+import pc3 from "picocolors";
+import { execa as execa2 } from "execa";
+function getDefaultSettings(branch) {
+  return {
+    branch,
+    requiredReviews: 1,
+    dismissStaleReviews: true,
+    requireCodeOwners: true,
+    requireStatusChecks: true,
+    statusChecks: ["check"],
+    requireConversationResolution: true,
+    restrictPushes: false,
+    blockForcePushes: true,
+    blockDeletions: true
+  };
+}
+function getMergeStrategySettings(strategy) {
+  switch (strategy) {
+    case "rebase":
+      return {
+        allowMergeCommit: false,
+        allowSquashMerge: false,
+        allowRebaseMerge: true,
+        deleteBranchOnMerge: true
+      };
+    case "squash":
+      return {
+        allowMergeCommit: false,
+        allowSquashMerge: true,
+        allowRebaseMerge: false,
+        deleteBranchOnMerge: true
+      };
+    case "merge":
+      return {
+        allowMergeCommit: true,
+        allowSquashMerge: false,
+        allowRebaseMerge: false,
+        deleteBranchOnMerge: true
+      };
+  }
+}
+async function applyBranchProtection(owner, repo, settings) {
+  const args = [
+    "api",
+    "-X",
+    "PUT",
+    `/repos/${owner}/${repo}/branches/${settings.branch}/protection`,
+    "-f",
+    `required_pull_request_reviews[required_approving_review_count]=${settings.requiredReviews}`,
+    "-f",
+    `required_pull_request_reviews[dismiss_stale_reviews]=${settings.dismissStaleReviews}`,
+    "-f",
+    `required_pull_request_reviews[require_code_owner_reviews]=${settings.requireCodeOwners}`,
+    "-f",
+    `required_status_checks[strict]=true`,
+    "-f",
+    `enforce_admins=true`,
+    "-f",
+    `allow_force_pushes=${!settings.blockForcePushes}`,
+    "-f",
+    `allow_deletions=${!settings.blockDeletions}`,
+    "-f",
+    `required_conversation_resolution=${settings.requireConversationResolution}`
+  ];
+  if (settings.requireStatusChecks && settings.statusChecks.length > 0) {
+    for (const check of settings.statusChecks) {
+      args.push("-f", `required_status_checks[contexts][]=${check}`);
+    }
+  } else {
+    args.push("-F", "required_status_checks=null");
+  }
+  args.push("-F", "restrictions=null");
+  await execa2("gh", args);
+}
+async function applyMergeStrategy(owner, repo, settings) {
+  const args = [
+    "api",
+    "-X",
+    "PATCH",
+    `/repos/${owner}/${repo}`,
+    "-f",
+    `allow_merge_commit=${settings.allowMergeCommit}`,
+    "-f",
+    `allow_squash_merge=${settings.allowSquashMerge}`,
+    "-f",
+    `allow_rebase_merge=${settings.allowRebaseMerge}`,
+    "-f",
+    `delete_branch_on_merge=${settings.deleteBranchOnMerge}`
+  ];
+  await execa2("gh", args);
+}
+async function runSetupProtection(targetDir = process.cwd()) {
+  console.log();
+  p3.intro(pc3.bgCyan(pc3.black(" Branch Protection Setup ")));
+  const spinner3 = p3.spinner();
+  spinner3.start("Checking GitHub CLI...");
+  const ghAvailable = await isGhCliAvailable();
+  if (!ghAvailable) {
+    spinner3.stop("GitHub CLI not found or not authenticated");
+    console.log();
+    p3.log.error(pc3.red("The GitHub CLI (gh) is required for this command."));
+    p3.log.info("Install it from: https://cli.github.com/");
+    p3.log.info("Then run: gh auth login");
+    console.log();
+    p3.log.info(
+      pc3.dim(
+        "Alternatively, see .github/BRANCH_PROTECTION_SETUP.md for manual instructions."
+      )
+    );
+    process.exit(1);
+  }
+  spinner3.stop("GitHub CLI ready");
+  spinner3.start("Getting repository info...");
+  const repoInfo = await getGitHubRepoInfo(targetDir);
+  if (!repoInfo) {
+    spinner3.stop("Could not determine repository");
+    p3.log.error(
+      pc3.red("Could not determine the GitHub repository for this directory.")
+    );
+    p3.log.info("Make sure you're in a git repository with a GitHub remote.");
+    process.exit(1);
+  }
+  spinner3.stop(`Repository: ${pc3.cyan(`${repoInfo.owner}/${repoInfo.repo}`)}`);
+  const branches = await p3.multiselect({
+    message: "Which branches need protection?",
+    options: [
+      { value: "main", label: "main", hint: "recommended" },
+      { value: "master", label: "master", hint: "legacy default" },
+      { value: "staging", label: "staging", hint: "staging environment" },
+      { value: "production", label: "production", hint: "production environment" },
+      { value: "development", label: "development", hint: "development branch" },
+      { value: "develop", label: "develop", hint: "alternative dev branch" }
+    ],
+    required: true,
+    initialValues: ["main"]
+  });
+  if (p3.isCancel(branches)) {
+    p3.cancel("Setup cancelled.");
+    process.exit(0);
+  }
+  const mergeStrategy = await p3.select({
+    message: "Default merge strategy for PRs?",
+    options: [
+      {
+        value: "rebase",
+        label: "Rebase merge",
+        hint: "recommended - clean linear history"
+      },
+      {
+        value: "squash",
+        label: "Squash merge",
+        hint: "single commit per PR"
+      },
+      {
+        value: "merge",
+        label: "Merge commit",
+        hint: "preserve all commits with merge commit"
+      }
+    ],
+    initialValue: "rebase"
+  });
+  if (p3.isCancel(mergeStrategy)) {
+    p3.cancel("Setup cancelled.");
+    process.exit(0);
+  }
+  const reviews = await p3.text({
+    message: "How many approving reviews are required?",
+    placeholder: "1",
+    initialValue: "1",
+    validate: (value) => {
+      const num = parseInt(value, 10);
+      if (isNaN(num) || num < 0 || num > 6) {
+        return "Must be a number between 0 and 6";
+      }
+      return void 0;
+    }
+  });
+  if (p3.isCancel(reviews)) {
+    p3.cancel("Setup cancelled.");
+    process.exit(0);
+  }
+  const requiredReviews = parseInt(reviews, 10);
+  const mergeStrategyLabels = {
+    rebase: "Rebase merge",
+    squash: "Squash merge",
+    merge: "Merge commit"
+  };
+  console.log();
+  p3.note(
+    [
+      `${pc3.cyan("Repository:")} ${repoInfo.owner}/${repoInfo.repo}`,
+      `${pc3.cyan("Protected branches:")} ${branches.join(", ")}`,
+      `${pc3.cyan("Merge strategy:")} ${mergeStrategyLabels[mergeStrategy]}`,
+      `${pc3.cyan("Required reviews:")} ${requiredReviews}`,
+      `${pc3.cyan("Dismiss stale reviews:")} Yes`,
+      `${pc3.cyan("Require code owners:")} Yes`,
+      `${pc3.cyan("Require status checks:")} Yes`,
+      `${pc3.cyan("Block force pushes:")} Yes`,
+      `${pc3.cyan("Block deletions:")} Yes`,
+      `${pc3.cyan("Delete branch on merge:")} Yes`
+    ].join("\n"),
+    "Branch Protection Settings"
+  );
+  const confirmed = await p3.confirm({
+    message: "Apply these branch protection rules?",
+    initialValue: true
+  });
+  if (p3.isCancel(confirmed) || !confirmed) {
+    p3.cancel("Setup cancelled.");
+    process.exit(0);
+  }
+  spinner3.start("Configuring merge strategy...");
+  try {
+    const repoSettings = getMergeStrategySettings(mergeStrategy);
+    await applyMergeStrategy(repoInfo.owner, repoInfo.repo, repoSettings);
+    spinner3.stop("Merge strategy configured!");
+  } catch (error) {
+    spinner3.stop("Failed to configure merge strategy");
+    const errorMsg = error instanceof Error ? error.message : "Unknown error";
+    p3.log.warn(pc3.yellow(`Warning: Could not set merge strategy: ${errorMsg}`));
+    p3.log.info(pc3.dim("Continuing with branch protection..."));
+  }
+  const protectedBranches = [];
+  const failedBranches = [];
+  for (const branch of branches) {
+    spinner3.start(`Protecting branch: ${branch}...`);
+    try {
+      const settings = getDefaultSettings(branch);
+      settings.requiredReviews = requiredReviews;
+      await applyBranchProtection(repoInfo.owner, repoInfo.repo, settings);
+      protectedBranches.push(branch);
+      spinner3.stop(`Protected: ${pc3.green(branch)}`);
+    } catch (error) {
+      failedBranches.push(branch);
+      spinner3.stop(`Failed: ${pc3.red(branch)}`);
+      const errorMsg = error instanceof Error ? error.message : "Unknown error";
+      p3.log.warn(
+        pc3.yellow(
+          `Could not protect ${branch}: ${errorMsg.includes("Branch not found") ? "branch does not exist" : errorMsg}`
+        )
+      );
+    }
+  }
+  console.log();
+  if (protectedBranches.length > 0) {
+    p3.log.success(
+      pc3.green(`Branch protection enabled for: ${pc3.cyan(protectedBranches.join(", "))}`)
+    );
+  }
+  if (failedBranches.length > 0) {
+    p3.log.warn(
+      pc3.yellow(
+        `Could not protect: ${pc3.red(failedBranches.join(", "))} (branches may not exist yet)`
+      )
+    );
+    p3.log.info(pc3.dim("Create these branches first, then run this command again."));
+  }
+  if (protectedBranches.length > 0) {
+    p3.outro(pc3.green("Setup complete!"));
+  } else {
+    p3.outro(pc3.yellow("No branches were protected."));
+    process.exit(1);
+  }
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("raftstack").description(
+  "CLI tool for setting up Git hooks, commit conventions, and GitHub integration"
+).version("1.0.0");
+program.command("init").description("Initialize RaftStack configuration in your project").action(async () => {
+  await runInit(process.cwd());
+});
+program.command("setup-protection").description("Configure GitHub branch protection rules via API").action(async () => {
+  await runSetupProtection(process.cwd());
+});
+program.parse();
+//# sourceMappingURL=cli.js.map