@raftlabs/raftstack 1.7.2 → 1.9.1

package/dist/cli.js

@@ -496,8 +496,26 @@ function getCommitMsgHook() {
   return `commitlint --edit "$1"
 `;
 }
-function getPrePushHook() {
-  return `validate-branch-name
+function getBuildCommand(projectType) {
+  switch (projectType) {
+    case "turbo":
+      return "pnpm turbo build";
+    case "nx":
+      return "pnpm nx affected --target=build --parallel=3";
+    case "pnpm-workspace":
+      return "pnpm -r build";
+    default:
+      return "pnpm build";
+  }
+}
+function getPrePushHook(projectType) {
+  const buildCommand = getBuildCommand(projectType);
+  return `# Validate branch naming convention
+validate-branch-name
+
+# Build all packages - push only succeeds if builds pass
+echo "\u{1F528} Building..."
+${buildCommand}
 `;
 }
 async function generateHuskyHooks(targetDir, projectType, _pm) {
@@ -534,7 +552,7 @@ async function generateHuskyHooks(targetDir, projectType, _pm) {
     }
   }
   const prePushPath = join4(huskyDir, "pre-push");
-  const prePushResult = await writeFileSafe(prePushPath, getPrePushHook(), {
+  const prePushResult = await writeFileSafe(prePushPath, getPrePushHook(projectType), {
     executable: true,
     backup: true
   });
@@ -550,41 +568,15 @@ async function generateHuskyHooks(targetDir, projectType, _pm) {
 // src/generators/commitlint.ts
 import { join as join5 } from "path";
 function getCommitlintConfig(asanaBaseUrl) {
-  const baseConfig = `/** @type {import('@commitlint/types').UserConfig} */
-export default {
-  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}
-    // Asana task link (warning only - won't block commits)
-    'asana-task-link': [1, 'always'],
-  },
+  const asanaIssueSection = asanaBaseUrl ? `
+    allowCustomIssuePrefix: true,
+    issuePrefixes: [
+      { value: 'asana', name: 'asana: Link to Asana task' },
+      { value: 'closes', name: 'closes: Close an issue' },
+      { value: 'fixes', name: 'fixes:  Fix an issue' },
+    ],` : `
+    allowCustomIssuePrefix: false,`;
+  const asanaPluginSection = asanaBaseUrl ? `
   plugins: [
     {
       rules: {
@@ -601,57 +593,22 @@ export default {
         },
       },
     },
-  ],
-};
-`;
-  }
-  return `${baseConfig}
-  },
-};
-`;
-}
-async function generateCommitlint(targetDir, asanaBaseUrl) {
-  const result = {
-    created: [],
-    modified: [],
-    skipped: [],
-    backedUp: []
-  };
-  const configPath = join5(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 join6 } 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 = {
+  ],` : "";
+  const asanaRule = asanaBaseUrl ? `
+    // Asana task link (warning only - won't block commits)
+    'asana-task-link': [1, 'always'],` : "";
+  return `/** @type {import('cz-git').UserConfig} */
+export default {
   extends: ['@commitlint/config-conventional'],
+  // Parser preset to support emoji prefixes in commit messages
+  parserPreset: {
+    parserOpts: {
+      headerPattern:
+        /^(?:(?:\\p{Emoji_Presentation}|\\p{Emoji}\\uFE0F?)|:[a-z_]+:)?\\s*(\\w+)(?:\\(([^)]*)\\))?:\\s*(.+)$/u,
+      headerCorrespondence: ['type', 'scope', 'subject'],
+    },
+  },
+  // cz-git prompt configuration (read directly from commitlint config)
   prompt: {
     alias: {
       fd: 'docs: fix typos',
@@ -683,61 +640,87 @@ module.exports = {
       { value: 'revert', name: 'revert:   \u23EA Reverting changes', emoji: ':rewind:' },
     ],
     useEmoji: true,
-    emojiAlign: 'center',
+    emojiAlign: 'left',
     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: '',
+    breaklineNumber: 100,${asanaIssueSection}
+    allowEmptyIssuePrefix: true,
   },
+  rules: {
+    // Type must be one of the conventional types
+    'type-enum': [
+      2,
+      'always',
+      [
+        'feat',
+        'fix',
+        'docs',
+        'style',
+        'refactor',
+        'perf',
+        'test',
+        'build',
+        'ci',
+        'chore',
+        'revert',
+      ],
+    ],
+    // 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],${asanaRule}
+  },${asanaPluginSection}
 };
 `;
 }
-async function generateCzGit(targetDir, asanaBaseUrl) {
+async function generateCommitlint(targetDir, asanaBaseUrl) {
   const result = {
     created: [],
     modified: [],
     skipped: [],
     backedUp: []
   };
-  const configPath = join6(targetDir, ".czrc");
+  const configPath = join5(targetDir, "commitlint.config.js");
   const writeResult = await writeFileSafe(
     configPath,
-    JSON.stringify({ path: "node_modules/cz-git" }, null, 2) + "\n",
+    getCommitlintConfig(asanaBaseUrl),
     { backup: true }
   );
   if (writeResult.created) {
-    result.created.push(".czrc");
+    result.created.push("commitlint.config.js");
     if (writeResult.backedUp) {
       result.backedUp.push(writeResult.backedUp);
     }
   }
-  const czConfigPath = join6(targetDir, "cz.config.js");
-  const czConfigResult = await writeFileSafe(
-    czConfigPath,
-    getCzGitConfig(asanaBaseUrl),
+  return result;
+}
+
+// src/generators/cz-git.ts
+import { join as join6 } from "path";
+async function generateCzGit(targetDir, _asanaBaseUrl) {
+  const result = {
+    created: [],
+    modified: [],
+    skipped: [],
+    backedUp: []
+  };
+  const configPath = join6(targetDir, ".czrc");
+  const writeResult = await writeFileSafe(
+    configPath,
+    JSON.stringify({ path: "node_modules/cz-git" }, null, 2) + "\n",
     { backup: true }
   );
-  if (czConfigResult.created) {
-    result.created.push("cz.config.js");
-    if (czConfigResult.backedUp) {
-      result.backedUp.push(czConfigResult.backedUp);
+  if (writeResult.created) {
+    result.created.push(".czrc");
+    if (writeResult.backedUp) {
+      result.backedUp.push(writeResult.backedUp);
     }
   }
   return result;
@@ -811,23 +794,42 @@ function addPackageJsonConfig(pkg, key, config, overwrite = false) {
 var RAFTSTACK_PACKAGES = [
   // Commit tooling
   "@commitlint/cli",
+  // ^20.3.0
   "@commitlint/config-conventional",
+  // ^20.3.0
   "cz-git",
+  // ^1.12.0
   "czg",
+  // ^1.12.0
   "husky",
+  // ^9.1.7
   "lint-staged",
+  // ^16.2.0
   "validate-branch-name",
+  // ^1.3.2
   // Linting & formatting
   "eslint",
+  // ^9.39.0
   "@eslint/js",
+  // ^9.39.0
   "typescript-eslint",
+  // ^8.39.0
   "eslint-config-prettier",
+  // ^10.1.0
   "prettier",
+  // ^3.8.0
   "globals"
+  // ^17.0.0
 ];
 var REACT_ESLINT_PACKAGES = [
   "eslint-plugin-react",
+  // ^7.37.0
   "eslint-plugin-react-hooks"
+  // ^5.2.0
+];
+var NEXTJS_ESLINT_PACKAGES = [
+  "eslint-config-next"
+  // ^16.1.0
 ];
 function isPnpmWorkspace(targetDir) {
   return existsSync4(join7(targetDir, "pnpm-workspace.yaml"));
@@ -1533,6 +1535,8 @@ build
 *.lock
 pnpm-lock.yaml
 coverage
+# Generated files
+**/routeTree.gen.ts
 `;
 }
 function hasPrettierConfig(targetDir) {
@@ -1646,14 +1650,65 @@ async function generateClaudeSkills(targetDir, options) {
   return result;
 }
 
-// src/generators/eslint.ts
+// src/generators/claude-commands.ts
 import { existsSync as existsSync6 } from "fs";
+import { readdir as readdir2, copyFile as copyFile3 } from "fs/promises";
+import { join as join16, dirname as dirname3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function getPackageCommandsDir() {
+  const currentFilePath = fileURLToPath2(import.meta.url);
+  const packageRoot = join16(dirname3(currentFilePath), "..");
+  return join16(packageRoot, ".claude", "commands");
+}
+async function copyDirectory2(srcDir, destDir, result, baseDir) {
+  await ensureDir(destDir);
+  const entries = await readdir2(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = join16(srcDir, entry.name);
+    const destPath = join16(destDir, entry.name);
+    const relativePath = destPath.replace(baseDir + "/", "");
+    if (entry.isDirectory()) {
+      await copyDirectory2(srcPath, destPath, result, baseDir);
+    } else {
+      if (existsSync6(destPath)) {
+        const backupPath = await backupFile(destPath);
+        if (backupPath) {
+          result.backedUp.push(relativePath);
+        }
+      }
+      await copyFile3(srcPath, destPath);
+      result.created.push(relativePath);
+    }
+  }
+}
+async function generateClaudeCommands(targetDir) {
+  const result = {
+    created: [],
+    modified: [],
+    skipped: [],
+    backedUp: []
+  };
+  const packageCommandsDir = getPackageCommandsDir();
+  const targetCommandsDir = join16(targetDir, ".claude", "commands");
+  if (!existsSync6(packageCommandsDir)) {
+    console.warn(
+      "Warning: Commands directory not found in package. Skipping commands generation."
+    );
+    return result;
+  }
+  await ensureDir(join16(targetDir, ".claude"));
+  await copyDirectory2(packageCommandsDir, targetCommandsDir, result, targetDir);
+  return result;
+}
+
+// src/generators/eslint.ts
+import { existsSync as existsSync7 } from "fs";
 import { readFile as readFile4 } from "fs/promises";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 async function hasReact(targetDir) {
   try {
-    const pkgPath = join16(targetDir, "package.json");
-    if (existsSync6(pkgPath)) {
+    const pkgPath = join17(targetDir, "package.json");
+    if (existsSync7(pkgPath)) {
       const content = await readFile4(pkgPath, "utf-8");
       const pkg = JSON.parse(content);
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
@@ -1663,9 +1718,37 @@ async function hasReact(targetDir) {
   }
   return false;
 }
-function generateTsConfig(hasReactDep) {
-  if (hasReactDep) {
-    return `import eslint from "@eslint/js";
+async function hasNextJs(targetDir) {
+  try {
+    const pkgPath = join17(targetDir, "package.json");
+    if (existsSync7(pkgPath)) {
+      const content = await readFile4(pkgPath, "utf-8");
+      const pkg = JSON.parse(content);
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      return "next" in deps;
+    }
+  } catch {
+  }
+  return false;
+}
+function generateNextJsConfig() {
+  return `import { defineConfig, globalIgnores } from "eslint/config";
+import nextVitals from "eslint-config-next/core-web-vitals";
+import nextTs from "eslint-config-next/typescript";
+import prettier from "eslint-config-prettier";
+
+const eslintConfig = defineConfig([
+  ...nextVitals,
+  ...nextTs,
+  prettier,
+  globalIgnores([".next/**", "out/**", "build/**", "next-env.d.ts"]),
+]);
+
+export default eslintConfig;
+`;
+}
+function generateReactTsConfig() {
+  return `import eslint from "@eslint/js";
 import tseslint from "typescript-eslint";
 import eslintConfigPrettier from "eslint-config-prettier";
 import reactPlugin from "eslint-plugin-react";
@@ -1721,7 +1804,7 @@ export default tseslint.config(
     },
   },
   {
-    // CommonJS config files (cz.config.js, commitlint.config.js, etc.)
+    // CommonJS config files (commitlint.config.js, etc.)
     files: ["*.config.js", "*.config.cjs"],
     languageOptions: {
       globals: {
@@ -1735,7 +1818,8 @@ export default tseslint.config(
   }
 );
 `;
-  }
+}
+function generateTsConfig() {
   return `import eslint from "@eslint/js";
 import tseslint from "typescript-eslint";
 import eslintConfigPrettier from "eslint-config-prettier";
@@ -1769,7 +1853,7 @@ export default tseslint.config(
     },
   },
   {
-    // CommonJS config files (cz.config.js, commitlint.config.js, etc.)
+    // CommonJS config files (commitlint.config.js, etc.)
     files: ["*.config.js", "*.config.cjs"],
     languageOptions: {
       globals: {
@@ -1784,9 +1868,8 @@ export default tseslint.config(
 );
 `;
 }
-function generateJsConfig(hasReactDep) {
-  if (hasReactDep) {
-    return `import eslint from "@eslint/js";
+function generateReactJsConfig() {
+  return `import eslint from "@eslint/js";
 import eslintConfigPrettier from "eslint-config-prettier";
 import reactPlugin from "eslint-plugin-react";
 import reactHooksPlugin from "eslint-plugin-react-hooks";
@@ -1832,7 +1915,7 @@ export default [
     },
   },
   {
-    // CommonJS config files (cz.config.js, commitlint.config.js, etc.)
+    // CommonJS config files (commitlint.config.js, etc.)
     files: ["*.config.js", "*.config.cjs"],
     languageOptions: {
       globals: {
@@ -1846,7 +1929,8 @@ export default [
   },
 ];
 `;
-  }
+}
+function generateJsConfig() {
   return `import eslint from "@eslint/js";
 import eslintConfigPrettier from "eslint-config-prettier";
 import globals from "globals";
@@ -1870,7 +1954,7 @@ export default [
     },
   },
   {
-    // CommonJS config files (cz.config.js, commitlint.config.js, etc.)
+    // CommonJS config files (commitlint.config.js, etc.)
     files: ["*.config.js", "*.config.cjs"],
     languageOptions: {
       globals: {
@@ -1888,6 +1972,9 @@ export default [
 async function detectReact(targetDir) {
   return hasReact(targetDir);
 }
+async function detectNextJs(targetDir) {
+  return hasNextJs(targetDir);
+}
 async function generateEslint(targetDir, usesTypeScript, force = false) {
   const result = {
     created: [],
@@ -1896,22 +1983,34 @@ async function generateEslint(targetDir, usesTypeScript, force = false) {
     backedUp: []
   };
   if (!force && await hasEslint(targetDir)) {
-    result.skipped.push("eslint.config.js (ESLint already configured)");
+    result.skipped.push("eslint.config.mjs (ESLint already configured)");
     return result;
   }
+  const usesNextJs = await hasNextJs(targetDir);
   const usesReact = await hasReact(targetDir);
-  const config = usesTypeScript ? generateTsConfig(usesReact) : generateJsConfig(usesReact);
-  const configPath = join16(targetDir, "eslint.config.js");
+  let config;
+  if (usesNextJs && usesTypeScript) {
+    config = generateNextJsConfig();
+  } else if (usesReact && usesTypeScript) {
+    config = generateReactTsConfig();
+  } else if (usesTypeScript) {
+    config = generateTsConfig();
+  } else if (usesReact) {
+    config = generateReactJsConfig();
+  } else {
+    config = generateJsConfig();
+  }
+  const configPath = join17(targetDir, "eslint.config.mjs");
   const writeResult = await writeFileSafe(configPath, config);
   if (writeResult.backedUp) {
-    result.backedUp.push("eslint.config.js");
+    result.backedUp.push("eslint.config.mjs");
   }
-  result.created.push("eslint.config.js");
+  result.created.push("eslint.config.mjs");
   return result;
 }
 
 // src/generators/quick-reference.ts
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 async function generateQuickReference(targetDir, pm) {
   const result = {
     created: [],
@@ -1919,7 +2018,7 @@ async function generateQuickReference(targetDir, pm) {
     skipped: [],
     backedUp: []
   };
-  const quickRefPath = join17(targetDir, ".github", "QUICK_REFERENCE.md");
+  const quickRefPath = join18(targetDir, ".github", "QUICK_REFERENCE.md");
   const content = `# RaftStack Quick Reference
 
 > One-page guide for the RaftStack Git workflow
@@ -2052,12 +2151,319 @@ ${pm.run} test
   return result;
 }
 
+// src/generators/shared-configs.ts
+import { join as join19 } from "path";
+function getEslintConfigPackageJson() {
+  return JSON.stringify(
+    {
+      name: "@workspace/eslint-config",
+      version: "0.0.0",
+      type: "module",
+      private: true,
+      exports: {
+        "./base": "./base.js",
+        "./next-js": "./next.js",
+        "./react-internal": "./react-internal.js",
+        "./vite": "./vite.js"
+      },
+      devDependencies: {
+        "@eslint/js": "^9.39.0",
+        "@next/eslint-plugin-next": "^16.1.0",
+        eslint: "^9.39.0",
+        "eslint-config-prettier": "^10.1.0",
+        "eslint-plugin-only-warn": "^1.1.0",
+        "eslint-plugin-react": "^7.37.0",
+        "eslint-plugin-react-hooks": "^5.2.0",
+        "eslint-plugin-turbo": "^2.6.0",
+        globals: "^17.0.0",
+        "typescript-eslint": "^8.39.0"
+      }
+    },
+    null,
+    2
+  ) + "\n";
+}
+function getBaseEslintConfig() {
+  return `import js from "@eslint/js";
+import eslintConfigPrettier from "eslint-config-prettier";
+import onlyWarn from "eslint-plugin-only-warn";
+import turboPlugin from "eslint-plugin-turbo";
+import tseslint from "typescript-eslint";
+
+/**
+ * Base ESLint configuration for all packages
+ * Includes TypeScript, Prettier, and Turborepo rules
+ */
+export const config = [
+  js.configs.recommended,
+  eslintConfigPrettier,
+  ...tseslint.configs.recommended,
+  {
+    plugins: { turbo: turboPlugin },
+    rules: { "turbo/no-undeclared-env-vars": "warn" },
+  },
+  { plugins: { onlyWarn } },
+  { ignores: ["dist/**"] },
+];
+`;
+}
+function getNextJsEslintConfig() {
+  return `import { defineConfig, globalIgnores } from "eslint/config";
+import nextVitals from "eslint-config-next/core-web-vitals";
+import nextTs from "eslint-config-next/typescript";
+import prettier from "eslint-config-prettier";
+import { config as baseConfig } from "./base.js";
+
+/**
+ * ESLint configuration for Next.js applications
+ * Extends base config with Next.js specific rules
+ */
+export const nextJsConfig = defineConfig([
+  ...baseConfig,
+  ...nextVitals,
+  ...nextTs,
+  prettier,
+  globalIgnores([".next/**", "out/**", "build/**", "next-env.d.ts"]),
+]);
+
+export default nextJsConfig;
+`;
+}
+function getReactInternalEslintConfig() {
+  return `import eslintConfigPrettier from "eslint-config-prettier";
+import reactPlugin from "eslint-plugin-react";
+import reactHooksPlugin from "eslint-plugin-react-hooks";
+import globals from "globals";
+import { config as baseConfig } from "./base.js";
+
+/**
+ * ESLint configuration for internal React libraries/packages
+ * Extends base config with React-specific rules
+ */
+export const reactInternalConfig = [
+  ...baseConfig,
+  eslintConfigPrettier,
+  {
+    languageOptions: {
+      parserOptions: {
+        ecmaFeatures: { jsx: true },
+      },
+      globals: {
+        ...globals.browser,
+      },
+    },
+    plugins: {
+      react: reactPlugin,
+      "react-hooks": reactHooksPlugin,
+    },
+    rules: {
+      "react/react-in-jsx-scope": "off",
+      "react/prop-types": "off",
+      "react-hooks/rules-of-hooks": "error",
+      "react-hooks/exhaustive-deps": "warn",
+    },
+    settings: {
+      react: { version: "detect" },
+    },
+  },
+  { ignores: ["dist/**", "node_modules/**"] },
+];
+
+export default reactInternalConfig;
+`;
+}
+function getViteEslintConfig() {
+  return `import eslintConfigPrettier from "eslint-config-prettier";
+import reactPlugin from "eslint-plugin-react";
+import reactHooksPlugin from "eslint-plugin-react-hooks";
+import globals from "globals";
+import { config as baseConfig } from "./base.js";
+
+/**
+ * ESLint configuration for Vite-based applications
+ * Extends base config with React and browser globals
+ */
+export const viteConfig = [
+  ...baseConfig,
+  eslintConfigPrettier,
+  {
+    languageOptions: {
+      parserOptions: {
+        ecmaFeatures: { jsx: true },
+      },
+      globals: {
+        ...globals.browser,
+        ...globals.node,
+      },
+    },
+    plugins: {
+      react: reactPlugin,
+      "react-hooks": reactHooksPlugin,
+    },
+    rules: {
+      "react/react-in-jsx-scope": "off",
+      "react/prop-types": "off",
+      "react-hooks/rules-of-hooks": "error",
+      "react-hooks/exhaustive-deps": "warn",
+    },
+    settings: {
+      react: { version: "detect" },
+    },
+  },
+  { ignores: ["dist/**", "node_modules/**"] },
+];
+
+export default viteConfig;
+`;
+}
+function getTsConfigPackageJson() {
+  return JSON.stringify(
+    {
+      name: "@workspace/typescript-config",
+      version: "0.0.0",
+      private: true
+    },
+    null,
+    2
+  ) + "\n";
+}
+function getBaseTsConfig() {
+  return JSON.stringify(
+    {
+      $schema: "https://json.schemastore.org/tsconfig",
+      display: "Default",
+      compilerOptions: {
+        declaration: true,
+        declarationMap: true,
+        esModuleInterop: true,
+        incremental: false,
+        isolatedModules: true,
+        lib: ["es2022", "DOM", "DOM.Iterable"],
+        module: "NodeNext",
+        moduleDetection: "force",
+        moduleResolution: "NodeNext",
+        noUncheckedIndexedAccess: true,
+        resolveJsonModule: true,
+        skipLibCheck: true,
+        strict: true,
+        target: "ES2022"
+      }
+    },
+    null,
+    2
+  ) + "\n";
+}
+function getNextJsTsConfig() {
+  return JSON.stringify(
+    {
+      $schema: "https://json.schemastore.org/tsconfig",
+      display: "Next.js",
+      extends: "./base.json",
+      compilerOptions: {
+        plugins: [{ name: "next" }],
+        module: "ESNext",
+        moduleResolution: "Bundler",
+        allowJs: true,
+        jsx: "preserve",
+        noEmit: true
+      }
+    },
+    null,
+    2
+  ) + "\n";
+}
+function getReactLibraryTsConfig() {
+  return JSON.stringify(
+    {
+      $schema: "https://json.schemastore.org/tsconfig",
+      display: "React Library",
+      extends: "./base.json",
+      compilerOptions: {
+        jsx: "react-jsx",
+        lib: ["ES2022", "DOM", "DOM.Iterable"],
+        module: "ESNext",
+        moduleResolution: "Bundler"
+      }
+    },
+    null,
+    2
+  ) + "\n";
+}
+function getNodeLibraryTsConfig() {
+  return JSON.stringify(
+    {
+      $schema: "https://json.schemastore.org/tsconfig",
+      display: "Node Library",
+      extends: "./base.json",
+      compilerOptions: {
+        lib: ["ES2022"],
+        module: "NodeNext",
+        moduleResolution: "NodeNext"
+      }
+    },
+    null,
+    2
+  ) + "\n";
+}
+function isMonorepo(projectType) {
+  return projectType === "turbo" || projectType === "nx" || projectType === "pnpm-workspace";
+}
+async function generateSharedConfigs(targetDir, projectType) {
+  const result = {
+    created: [],
+    modified: [],
+    skipped: [],
+    backedUp: []
+  };
+  if (!isMonorepo(projectType)) {
+    return result;
+  }
+  const packagesDir = join19(targetDir, "packages");
+  const eslintConfigDir = join19(packagesDir, "eslint-config");
+  await ensureDir(eslintConfigDir);
+  const eslintFiles = [
+    { path: join19(eslintConfigDir, "package.json"), content: getEslintConfigPackageJson(), name: "packages/eslint-config/package.json" },
+    { path: join19(eslintConfigDir, "base.js"), content: getBaseEslintConfig(), name: "packages/eslint-config/base.js" },
+    { path: join19(eslintConfigDir, "next.js"), content: getNextJsEslintConfig(), name: "packages/eslint-config/next.js" },
+    { path: join19(eslintConfigDir, "react-internal.js"), content: getReactInternalEslintConfig(), name: "packages/eslint-config/react-internal.js" },
+    { path: join19(eslintConfigDir, "vite.js"), content: getViteEslintConfig(), name: "packages/eslint-config/vite.js" }
+  ];
+  for (const file of eslintFiles) {
+    const writeResult = await writeFileSafe(file.path, file.content, { backup: true });
+    if (writeResult.created) {
+      result.created.push(file.name);
+      if (writeResult.backedUp) {
+        result.backedUp.push(file.name);
+      }
+    }
+  }
+  const tsConfigDir = join19(packagesDir, "typescript-config");
+  await ensureDir(tsConfigDir);
+  const tsFiles = [
+    { path: join19(tsConfigDir, "package.json"), content: getTsConfigPackageJson(), name: "packages/typescript-config/package.json" },
+    { path: join19(tsConfigDir, "base.json"), content: getBaseTsConfig(), name: "packages/typescript-config/base.json" },
+    { path: join19(tsConfigDir, "nextjs.json"), content: getNextJsTsConfig(), name: "packages/typescript-config/nextjs.json" },
+    { path: join19(tsConfigDir, "react-library.json"), content: getReactLibraryTsConfig(), name: "packages/typescript-config/react-library.json" },
+    { path: join19(tsConfigDir, "node-library.json"), content: getNodeLibraryTsConfig(), name: "packages/typescript-config/node-library.json" }
+  ];
+  for (const file of tsFiles) {
+    const writeResult = await writeFileSafe(file.path, file.content, { backup: true });
+    if (writeResult.created) {
+      result.created.push(file.name);
+      if (writeResult.backedUp) {
+        result.backedUp.push(file.name);
+      }
+    }
+  }
+  return result;
+}
+
 // src/utils/git.ts
 import { execa } from "execa";
-import { existsSync as existsSync7 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { join as join20 } from "path";
 async function isGitRepo(targetDir = process.cwd()) {
-  if (existsSync7(join18(targetDir, ".git"))) {
+  if (existsSync8(join20(targetDir, ".git"))) {
     return true;
   }
   try {
@@ -2162,8 +2568,14 @@ async function runInit(targetDir = process.cwd()) {
     return;
   }
   const usesReact = await detectReact(targetDir);
+  const usesNextJs = await detectNextJs(targetDir);
   const installSpinner = p2.spinner();
-  const packagesToInstall = usesReact ? [...RAFTSTACK_PACKAGES, ...REACT_ESLINT_PACKAGES] : RAFTSTACK_PACKAGES;
+  let packagesToInstall = [...RAFTSTACK_PACKAGES];
+  if (usesNextJs) {
+    packagesToInstall = [...packagesToInstall, ...NEXTJS_ESLINT_PACKAGES];
+  } else if (usesReact) {
+    packagesToInstall = [...packagesToInstall, ...REACT_ESLINT_PACKAGES];
+  }
   installSpinner.start("Installing dependencies...");
   const installResult = await installPackages(
     config.packageManager,
@@ -2187,8 +2599,8 @@ async function runInit(targetDir = process.cwd()) {
     );
     installFailed = true;
   }
-  const spinner4 = p2.spinner();
-  spinner4.start("Generating configuration files...");
+  const spinner5 = p2.spinner();
+  spinner5.start("Generating configuration files...");
   const results = [];
   try {
     results.push(
@@ -2199,6 +2611,9 @@ async function runInit(targetDir = process.cwd()) {
     results.push(await generateBranchValidation(targetDir));
     results.push(await generateEslint(targetDir, config.usesTypeScript, false));
     results.push(await generatePrettier(targetDir));
+    if (isMonorepo(config.projectType)) {
+      results.push(await generateSharedConfigs(targetDir, config.projectType));
+    }
     results.push(await generatePRTemplate(targetDir, !!config.asanaBaseUrl));
     results.push(
       await generateGitHubWorkflows(
@@ -2220,10 +2635,11 @@ async function runInit(targetDir = process.cwd()) {
     results.push(await generateClaudeSkills(targetDir, {
       includeAsana: !!config.asanaBaseUrl
     }));
+    results.push(await generateClaudeCommands(targetDir));
     results.push(await updateProjectPackageJson(targetDir, config));
-    spinner4.stop("Configuration files generated!");
+    spinner5.stop("Configuration files generated!");
   } catch (error) {
-    spinner4.stop("Error generating files");
+    spinner5.stop("Error generating files");
     p2.log.error(
       pc2.red(
         `Error: ${error instanceof Error ? error.message : "Unknown error"}`
@@ -2371,11 +2787,11 @@ async function applyMergeStrategy(owner, repo, settings) {
 async function runSetupProtection(targetDir = process.cwd()) {
   console.log();
   p3.intro(pc3.bgCyan(pc3.black(" Branch Protection Setup ")));
-  const spinner4 = p3.spinner();
-  spinner4.start("Checking GitHub CLI...");
+  const spinner5 = p3.spinner();
+  spinner5.start("Checking GitHub CLI...");
   const ghAvailable = await isGhCliAvailable();
   if (!ghAvailable) {
-    spinner4.stop("GitHub CLI not found or not authenticated");
+    spinner5.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/");
@@ -2388,18 +2804,18 @@ async function runSetupProtection(targetDir = process.cwd()) {
     );
     process.exit(1);
   }
-  spinner4.stop("GitHub CLI ready");
-  spinner4.start("Getting repository info...");
+  spinner5.stop("GitHub CLI ready");
+  spinner5.start("Getting repository info...");
   const repoInfo = await getGitHubRepoInfo(targetDir);
   if (!repoInfo) {
-    spinner4.stop("Could not determine repository");
+    spinner5.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);
   }
-  spinner4.stop(`Repository: ${pc3.cyan(`${repoInfo.owner}/${repoInfo.repo}`)}`);
+  spinner5.stop(`Repository: ${pc3.cyan(`${repoInfo.owner}/${repoInfo.repo}`)}`);
   const branches = await p3.multiselect({
     message: "Which branches need protection?",
     options: [
@@ -2488,13 +2904,13 @@ async function runSetupProtection(targetDir = process.cwd()) {
     p3.cancel("Setup cancelled.");
     process.exit(0);
   }
-  spinner4.start("Configuring merge strategy...");
+  spinner5.start("Configuring merge strategy...");
   try {
     const repoSettings = getMergeStrategySettings(mergeStrategy);
     await applyMergeStrategy(repoInfo.owner, repoInfo.repo, repoSettings);
-    spinner4.stop("Merge strategy configured!");
+    spinner5.stop("Merge strategy configured!");
   } catch (error) {
-    spinner4.stop("Failed to configure merge strategy");
+    spinner5.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..."));
@@ -2502,16 +2918,16 @@ async function runSetupProtection(targetDir = process.cwd()) {
   const protectedBranches = [];
   const failedBranches = [];
   for (const branch of branches) {
-    spinner4.start(`Protecting branch: ${branch}...`);
+    spinner5.start(`Protecting branch: ${branch}...`);
     try {
       const settings = getDefaultSettings(branch);
       settings.requiredReviews = requiredReviews;
       await applyBranchProtection(repoInfo.owner, repoInfo.repo, settings);
       protectedBranches.push(branch);
-      spinner4.stop(`Protected: ${pc3.green(branch)}`);
+      spinner5.stop(`Protected: ${pc3.green(branch)}`);
     } catch (error) {
       failedBranches.push(branch);
-      spinner4.stop(`Failed: ${pc3.red(branch)}`);
+      spinner5.stop(`Failed: ${pc3.red(branch)}`);
       const errorMsg = error instanceof Error ? error.message : "Unknown error";
       p3.log.warn(
         pc3.yellow(
@@ -2543,41 +2959,380 @@ async function runSetupProtection(targetDir = process.cwd()) {
 }
 
 // src/commands/metrics.ts
-import { execa as execa3 } from "execa";
+import { execa as execa4 } from "execa";
 import * as p4 from "@clack/prompts";
 import pc4 from "picocolors";
-async function getRecentCommits(targetDir, days) {
+
+// src/utils/code-analyzer.ts
+import { execa as execa3 } from "execa";
+import { readFileSync as readFileSync2 } from "fs";
+var THRESHOLDS = {
+  "file-length": 300,
+  "function-length": 30,
+  "max-params": 3,
+  "cyclomatic-complexity": 10
+};
+async function findSourceFiles(targetDir) {
   try {
     const { stdout } = await execa3(
       "git",
-      ["log", `--since=${days} days ago`, "--oneline", "--no-merges"],
+      ["ls-files", "*.ts", "*.tsx", "*.js", "*.jsx"],
       { cwd: targetDir }
     );
-    return stdout.trim().split("\n").filter(Boolean);
+    return stdout.trim().split("\n").filter(Boolean).filter(
+      (f) => !f.includes("node_modules") && !f.includes("dist/") && !f.includes("build/") && !f.includes(".min.") && !f.endsWith(".d.ts")
+    );
   } catch {
     return [];
   }
 }
-async function getCommitMessages(targetDir, days) {
+function extractFunctions(source, _filePath) {
+  const functions = [];
+  const lines = source.split("\n");
+  const functionPatterns = [
+    // function name(params) or async function name(params)
+    /^(\s*)(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/,
+    // const name = (params) => or const name = async (params) =>
+    /^(\s*)(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?\(([^)]*)\)\s*(?::\s*[^=]+)?\s*=>/,
+    // const name = function(params)
+    /^(\s*)(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?function\s*\(([^)]*)\)/,
+    // class method: name(params) { or async name(params) {
+    /^(\s*)(?:async\s+)?(\w+)\s*\(([^)]*)\)\s*(?::\s*[^{]+)?\s*\{/
+  ];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    for (const pattern of functionPatterns) {
+      const match = line.match(pattern);
+      if (match) {
+        const [, indent, name, params] = match;
+        if (name === "constructor" || name === "if" || name === "for" || name === "while" || name === "switch" || name === "catch") {
+          continue;
+        }
+        const paramCount = countParameters(params);
+        const endLine = findFunctionEnd(lines, i, indent.length);
+        if (endLine > i) {
+          const body = lines.slice(i, endLine + 1).join("\n");
+          functions.push({
+            name,
+            startLine: i + 1,
+            // 1-indexed
+            endLine: endLine + 1,
+            paramCount,
+            body
+          });
+        }
+        break;
+      }
+    }
+  }
+  return functions;
+}
+function countParameters(params) {
+  const trimmed = params.trim();
+  if (!trimmed) return 0;
+  let depth = 0;
+  let count = 1;
+  for (const char of trimmed) {
+    if (char === "(" || char === "{" || char === "[" || char === "<") {
+      depth++;
+    } else if (char === ")" || char === "}" || char === "]" || char === ">") {
+      depth--;
+    } else if (char === "," && depth === 0) {
+      count++;
+    }
+  }
+  return count;
+}
+function findFunctionEnd(lines, startLine, _baseIndent) {
+  let braceDepth = 0;
+  let foundOpenBrace = false;
+  for (let i = startLine; i < lines.length; i++) {
+    const line = lines[i];
+    for (const char of line) {
+      if (char === "{") {
+        braceDepth++;
+        foundOpenBrace = true;
+      } else if (char === "}") {
+        braceDepth--;
+        if (foundOpenBrace && braceDepth === 0) {
+          return i;
+        }
+      }
+    }
+  }
+  return startLine;
+}
+function countComplexity(code) {
+  let complexity = 1;
+  const patterns = [
+    /\bif\s*\(/g,
+    /\belse\s+if\s*\(/g,
+    /\bcase\s+/g,
+    /\bfor\s*\(/g,
+    /\bwhile\s*\(/g,
+    /\bdo\s*\{/g,
+    /\bcatch\s*\(/g,
+    /&&/g,
+    /\|\|/g,
+    /\?\?/g
+    // nullish coalescing
+  ];
+  const ternaryPattern = /\?[^:?]+:/g;
+  for (const pattern of patterns) {
+    const matches = code.match(pattern);
+    if (matches) {
+      complexity += matches.length;
+    }
+  }
+  const ternaryMatches = code.match(ternaryPattern);
+  if (ternaryMatches) {
+    complexity += ternaryMatches.length;
+  }
+  return complexity;
+}
+function findMagicNumbers(source, filePath) {
+  const violations = [];
+  const lines = source.split("\n");
+  const allowedNumbers = /* @__PURE__ */ new Set([
+    "0",
+    "1",
+    "-1",
+    "2",
+    "100",
+    "1000",
+    "0.5",
+    "0.1"
+  ]);
+  const numberPattern = /-?\d+\.?\d*/g;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmedLine = line.trim();
+    if (/^\s*(?:export\s+)?const\s+\w+\s*[:=]/.test(line)) {
+      continue;
+    }
+    if (trimmedLine.startsWith("import ")) {
+      continue;
+    }
+    if (trimmedLine.startsWith("//") || trimmedLine.startsWith("*")) {
+      continue;
+    }
+    const cleanedLine = line.replace(/\[\d+\]/g, "").replace(/\.length\s*[<>=]+\s*\d+/g, "").replace(/:\s*number/g, "").replace(/[<>=]+\s*0\b/g, "").replace(/\+\+|--/g, "");
+    const matches = cleanedLine.match(numberPattern);
+    if (matches) {
+      for (const match of matches) {
+        if (allowedNumbers.has(match)) continue;
+        if (/0[xXbBoO]/.test(match)) continue;
+        if (line.includes(`"${match}`) || line.includes(`'${match}`)) continue;
+        violations.push({
+          filePath,
+          rule: "magic-number",
+          line: i + 1,
+          message: `Magic number ${match} should be a named constant`
+        });
+      }
+    }
+  }
+  return violations;
+}
+function analyzeFile(filePath, source) {
+  const violations = [];
+  const lines = source.split("\n");
+  const lineCount = lines.length;
+  if (lineCount > THRESHOLDS["file-length"]) {
+    violations.push({
+      filePath,
+      rule: "file-length",
+      line: 1,
+      message: `File has ${lineCount} lines (max: ${THRESHOLDS["file-length"]})`
+    });
+  }
+  const functions = extractFunctions(source, filePath);
+  for (const fn of functions) {
+    const fnLineCount = fn.endLine - fn.startLine + 1;
+    if (fnLineCount > THRESHOLDS["function-length"]) {
+      violations.push({
+        filePath,
+        rule: "function-length",
+        line: fn.startLine,
+        message: `Function '${fn.name}' has ${fnLineCount} lines (max: ${THRESHOLDS["function-length"]})`
+      });
+    }
+    if (fn.paramCount > THRESHOLDS["max-params"]) {
+      violations.push({
+        filePath,
+        rule: "max-params",
+        line: fn.startLine,
+        message: `Function '${fn.name}' has ${fn.paramCount} parameters (max: ${THRESHOLDS["max-params"]})`
+      });
+    }
+    const complexity = countComplexity(fn.body);
+    if (complexity > THRESHOLDS["cyclomatic-complexity"]) {
+      violations.push({
+        filePath,
+        rule: "cyclomatic-complexity",
+        line: fn.startLine,
+        message: `Function '${fn.name}' has complexity ${complexity} (max: ${THRESHOLDS["cyclomatic-complexity"]})`
+      });
+    }
+  }
+  const magicViolations = findMagicNumbers(source, filePath);
+  violations.push(...magicViolations);
+  return violations;
+}
+async function analyzeCodebase(targetDir) {
+  const files = await findSourceFiles(targetDir);
+  const allViolations = [];
+  let totalLines = 0;
+  const violationsByRule = {
+    "file-length": 0,
+    "function-length": 0,
+    "max-params": 0,
+    "cyclomatic-complexity": 0,
+    "magic-number": 0
+  };
+  const violationsByFile = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    try {
+      const fullPath = `${targetDir}/${file}`;
+      const source = readFileSync2(fullPath, "utf-8");
+      totalLines += source.split("\n").length;
+      const violations = analyzeFile(file, source);
+      for (const v of violations) {
+        violationsByRule[v.rule]++;
+        violationsByFile.set(file, (violationsByFile.get(file) || 0) + 1);
+      }
+      allViolations.push(...violations);
+    } catch {
+    }
+  }
+  const filesWithoutFileLengthViolation = files.length - violationsByRule["file-length"];
+  const fileLengthCompliance = files.length > 0 ? Math.round(filesWithoutFileLengthViolation / files.length * 100) : 100;
+  const calculateRuleCompliance = (violations, fileCount) => {
+    if (fileCount === 0) return 100;
+    const expectedMax = Math.max(1, Math.floor(fileCount / 5));
+    const ratio = Math.min(1, violations / expectedMax);
+    return Math.round((1 - ratio * 0.5) * 100);
+  };
+  const complianceByRule = {
+    "file-length": fileLengthCompliance,
+    "function-length": calculateRuleCompliance(
+      violationsByRule["function-length"],
+      files.length
+    ),
+    "max-params": calculateRuleCompliance(
+      violationsByRule["max-params"],
+      files.length
+    ),
+    "cyclomatic-complexity": calculateRuleCompliance(
+      violationsByRule["cyclomatic-complexity"],
+      files.length
+    ),
+    "magic-number": calculateRuleCompliance(
+      violationsByRule["magic-number"],
+      files.length
+    )
+  };
+  const overallCompliance = Math.round(
+    Object.values(complianceByRule).reduce((a, b) => a + b, 0) / 5
+  );
+  const worstFiles = Array.from(violationsByFile.entries()).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([path, count]) => ({ path, count }));
+  return {
+    filesAnalyzed: files.length,
+    totalLines,
+    violations: allViolations,
+    complianceByRule,
+    overallCompliance,
+    worstFiles
+  };
+}
+
+// src/commands/metrics.ts
+var CONVENTIONAL_COMMIT_PATTERN = /^(✨|🐛|📝|💄|♻️|⚡|✅|📦|👷|🔧|⏪)\s+(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\([a-z0-9-]+\))?:\s.+/;
+async function getCommitsWithAuthors(targetDir, days) {
   try {
-    const { stdout } = await execa3(
+    const { stdout } = await execa4(
       "git",
       [
         "log",
         `--since=${days} days ago`,
-        "--format=%B---COMMIT_SEPARATOR---",
+        "--format=%H|%an|%ae|%s---BODY---%B---END---",
         "--no-merges"
       ],
       { cwd: targetDir }
     );
-    return stdout.split("---COMMIT_SEPARATOR---").filter((m) => m.trim());
+    const commits = [];
+    const entries = stdout.split("---END---").filter((e) => e.trim());
+    for (const entry of entries) {
+      const bodyMarker = entry.indexOf("---BODY---");
+      if (bodyMarker === -1) continue;
+      const headerPart = entry.substring(0, bodyMarker).trim();
+      const bodyPart = entry.substring(bodyMarker + 10).trim();
+      const parts = headerPart.split("|");
+      if (parts.length >= 4) {
+        commits.push({
+          hash: parts[0],
+          authorName: parts[1],
+          authorEmail: parts[2],
+          subject: parts.slice(3).join("|"),
+          // Subject might contain |
+          body: bodyPart
+        });
+      }
+    }
+    return commits;
   } catch {
     return [];
   }
 }
+function isConventionalCommit(subject) {
+  return CONVENTIONAL_COMMIT_PATTERN.test(subject);
+}
+function hasTaskLink(commit) {
+  const fullMessage = `${commit.subject}
+${commit.body}`;
+  return fullMessage.includes("app.asana.com") || fullMessage.includes("Task:") || fullMessage.includes("task:") || fullMessage.includes("Closes #") || fullMessage.includes("Fixes #") || fullMessage.includes("Resolves #") || /https:\/\/github\.com\/[^/]+\/[^/]+\/issues\/\d+/.test(fullMessage);
+}
+function calculateAuthorMetrics(commits) {
+  const authorMap = /* @__PURE__ */ new Map();
+  for (const commit of commits) {
+    const existing = authorMap.get(commit.authorEmail);
+    if (existing) {
+      existing.commits.push(commit);
+      existing.name = commit.authorName;
+    } else {
+      authorMap.set(commit.authorEmail, {
+        name: commit.authorName,
+        email: commit.authorEmail,
+        commits: [commit]
+      });
+    }
+  }
+  const authorMetrics = [];
+  for (const [, author] of authorMap) {
+    const totalCommits = author.commits.length;
+    const withTaskLinks = author.commits.filter(hasTaskLink).length;
+    const conventional = author.commits.filter(
+      (c) => isConventionalCommit(c.subject)
+    ).length;
+    const taskLinkCompliance = totalCommits > 0 ? Math.round(withTaskLinks / totalCommits * 100) : 100;
+    const conventionalCompliance = totalCommits > 0 ? Math.round(conventional / totalCommits * 100) : 100;
+    const overallScore = Math.round(
+      taskLinkCompliance * 0.4 + conventionalCompliance * 0.6
+    );
+    authorMetrics.push({
+      name: author.name,
+      email: author.email,
+      totalCommits,
+      taskLinkCompliance,
+      conventionalCompliance,
+      overallScore
+    });
+  }
+  return authorMetrics.sort((a, b) => b.overallScore - a.overallScore);
+}
 async function getBranchNames(targetDir) {
   try {
-    const { stdout } = await execa3(
+    const { stdout } = await execa4(
       "git",
       ["branch", "-a", "--format=%(refname:short)"],
       { cwd: targetDir }
@@ -2591,22 +3346,11 @@ function isValidBranchName(name) {
   const pattern = /^(main|staging|development|master)$|^(feature|bugfix|hotfix|chore|refactor)\/[a-z0-9-]+$/;
   return pattern.test(name);
 }
-function hasTaskLink(message) {
-  return message.includes("app.asana.com") || message.includes("Task:") || message.includes("task:") || message.includes("Closes #") || message.includes("Fixes #");
-}
-async function calculateMetrics(targetDir, days) {
-  const [commits, commitMessages, branches] = await Promise.all([
-    getRecentCommits(targetDir, days),
-    getCommitMessages(targetDir, days),
-    getBranchNames(targetDir)
-  ]);
-  const commitsWithTaskLinks = commitMessages.filter(hasTaskLink).length;
+async function calculateBranchMetrics(targetDir) {
+  const branches = await getBranchNames(targetDir);
   const validBranches = branches.filter(isValidBranchName);
   const invalidBranches = branches.filter((b) => !isValidBranchName(b));
   return {
-    totalCommits: commits.length,
-    commitsWithTaskLinks,
-    taskLinkCompliance: commits.length > 0 ? Math.round(commitsWithTaskLinks / commits.length * 100) : 100,
     branchNames: branches,
     validBranches: validBranches.length,
     invalidBranches: invalidBranches.length,
@@ -2618,56 +3362,215 @@ function formatCompliance(percentage) {
   if (percentage >= 70) return pc4.yellow(`${percentage}%`);
   return pc4.red(`${percentage}%`);
 }
-async function runMetrics(targetDir) {
-  p4.intro(pc4.bgCyan(pc4.black(" RaftStack Metrics ")));
+function formatLeaderboard(authors, title, limit) {
+  if (authors.length === 0) return "";
+  const lines = [pc4.bold(title)];
+  const displayed = authors.slice(0, limit);
+  displayed.forEach((author, index) => {
+    const score = formatCompliance(author.overallScore);
+    const truncatedEmail = author.email.length > 25 ? author.email.substring(0, 22) + "..." : author.email;
+    lines.push(
+      `  ${index + 1}. ${author.name} (${truncatedEmail}) - ${score} - ${author.totalCommits} commits`
+    );
+  });
+  return lines.join("\n");
+}
+function formatCodebaseMetrics(metrics) {
+  const ruleNames = {
+    "file-length": `File length (\u2264300)`,
+    "function-length": `Function length (\u226430)`,
+    "max-params": `Max parameters (\u22643)`,
+    "cyclomatic-complexity": `Cyclomatic complexity`,
+    "magic-number": `Magic numbers`
+  };
+  const lines = [
+    pc4.bold("CODEBASE COMPLIANCE"),
+    `  Files analyzed: ${metrics.filesAnalyzed}`,
+    `  Total lines: ${metrics.totalLines.toLocaleString()}`,
+    "",
+    pc4.bold("  RULE COMPLIANCE")
+  ];
+  for (const rule of Object.keys(ruleNames)) {
+    const compliance = metrics.complianceByRule[rule];
+    const label = ruleNames[rule].padEnd(28);
+    lines.push(`    ${label}${formatCompliance(compliance)}`);
+  }
+  lines.push("");
+  lines.push(`  ${pc4.bold("OVERALL:")} ${formatCompliance(metrics.overallCompliance)}`);
+  if (metrics.worstFiles.length > 0) {
+    lines.push("");
+    lines.push(pc4.bold("  TOP VIOLATIONS"));
+    for (const file of metrics.worstFiles.slice(0, 5)) {
+      lines.push(`    ${file.path} (${file.count} violations)`);
+      const fileViolations = metrics.violations.filter(
+        (v) => v.filePath === file.path
+      );
+      const byRule = /* @__PURE__ */ new Map();
+      for (const v of fileViolations) {
+        byRule.set(v.rule, (byRule.get(v.rule) || 0) + 1);
+      }
+      for (const [rule, count] of byRule) {
+        lines.push(`      - ${count}x ${rule}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+async function runMetrics(targetDir, options = {}) {
+  const { git: gitOnly, code: codeOnly, ci: ciMode, threshold = 70 } = options;
+  const showGit = !codeOnly;
+  const showCode = !gitOnly;
+  const days = options.days || (ciMode ? 30 : null);
+  if (!ciMode) {
+    p4.intro(pc4.bgCyan(pc4.black(" RaftStack Metrics ")));
+  }
   if (!await isGitRepo(targetDir)) {
+    if (ciMode) {
+      console.error("Error: Not a git repository");
+      process.exit(1);
+    }
     p4.cancel("Not a git repository");
     process.exit(1);
   }
-  const daysOption = await p4.select({
-    message: "Time period to analyze:",
-    options: [
-      { value: 7, label: "Last 7 days" },
-      { value: 14, label: "Last 14 days" },
-      { value: 30, label: "Last 30 days" },
-      { value: 90, label: "Last 90 days" }
-    ]
-  });
-  if (p4.isCancel(daysOption)) {
-    p4.cancel("Operation cancelled");
-    process.exit(0);
-  }
-  const days = daysOption;
-  const spinner4 = p4.spinner();
-  spinner4.start("Analyzing repository...");
-  const metrics = await calculateMetrics(targetDir, days);
-  spinner4.stop("Analysis complete");
-  p4.note(
-    `${pc4.bold("Commits")} (last ${days} days)
-  Total: ${metrics.totalCommits}
-  With task links: ${metrics.commitsWithTaskLinks}
-  Compliance: ${formatCompliance(metrics.taskLinkCompliance)}
+  let selectedDays = days;
+  if (!selectedDays && !ciMode) {
+    const daysOption = await p4.select({
+      message: "Time period to analyze:",
+      options: [
+        { value: 7, label: "Last 7 days" },
+        { value: 14, label: "Last 14 days" },
+        { value: 30, label: "Last 30 days" },
+        { value: 90, label: "Last 90 days" }
+      ]
+    });
+    if (p4.isCancel(daysOption)) {
+      p4.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    selectedDays = daysOption;
+  }
+  const analyzeDays = selectedDays || 30;
+  const spinner5 = ciMode ? null : p4.spinner();
+  spinner5?.start("Analyzing repository...");
+  let overallCompliance = 100;
+  const complianceScores = [];
+  if (showGit) {
+    const [commits, branchMetrics] = await Promise.all([
+      getCommitsWithAuthors(targetDir, analyzeDays),
+      calculateBranchMetrics(targetDir)
+    ]);
+    const authorMetrics = calculateAuthorMetrics(commits);
+    const totalCommits = commits.length;
+    const withTaskLinks = commits.filter(hasTaskLink).length;
+    const conventional = commits.filter(
+      (c) => isConventionalCommit(c.subject)
+    ).length;
+    const taskLinkCompliance = totalCommits > 0 ? Math.round(withTaskLinks / totalCommits * 100) : 100;
+    const conventionalCompliance = totalCommits > 0 ? Math.round(conventional / totalCommits * 100) : 100;
+    complianceScores.push(
+      taskLinkCompliance,
+      conventionalCompliance,
+      branchMetrics.branchCompliance
+    );
+    spinner5?.stop("Git analysis complete");
+    if (ciMode) {
+      console.log("\n=== GIT METRICS ===");
+      console.log(`Commits (last ${analyzeDays} days): ${totalCommits}`);
+      console.log(`Task link compliance: ${taskLinkCompliance}%`);
+      console.log(`Conventional commit compliance: ${conventionalCompliance}%`);
+      console.log(`Branch compliance: ${branchMetrics.branchCompliance}%`);
+    } else {
+      p4.note(
+        `${pc4.bold("Commits")} (last ${analyzeDays} days)
+  Total: ${totalCommits}
+  With task links: ${withTaskLinks} (${formatCompliance(taskLinkCompliance)})
+  Conventional format: ${conventional} (${formatCompliance(conventionalCompliance)})
 
 ${pc4.bold("Branches")}
-  Total: ${metrics.branchNames.length}
-  Valid naming: ${metrics.validBranches}
-  Invalid naming: ${metrics.invalidBranches}
-  Compliance: ${formatCompliance(metrics.branchCompliance)}`,
-    "Repository Metrics"
-  );
-  if (metrics.invalidBranches > 0) {
-    const invalidBranches = metrics.branchNames.filter(
-      (b) => !isValidBranchName(b)
-    );
-    p4.log.warn(
-      `Invalid branch names:
+  Total: ${branchMetrics.branchNames.length}
+  Valid naming: ${branchMetrics.validBranches}
+  Invalid naming: ${branchMetrics.invalidBranches}
+  Compliance: ${formatCompliance(branchMetrics.branchCompliance)}`,
+        "Git Metrics"
+      );
+      if (authorMetrics.length > 0) {
+        const topPerformers = authorMetrics.filter((a) => a.overallScore >= 70);
+        const needsImprovement = authorMetrics.filter((a) => a.overallScore < 70).reverse();
+        let leaderboardText = "";
+        if (topPerformers.length > 0) {
+          leaderboardText += formatLeaderboard(
+            topPerformers,
+            "TOP PERFORMERS",
+            5
+          );
+        }
+        if (needsImprovement.length > 0) {
+          if (leaderboardText) leaderboardText += "\n\n";
+          leaderboardText += formatLeaderboard(
+            needsImprovement,
+            "NEEDS IMPROVEMENT",
+            5
+          );
+        }
+        if (leaderboardText) {
+          p4.note(leaderboardText, "Author Leaderboard");
+        }
+      }
+      if (branchMetrics.invalidBranches > 0) {
+        const invalidBranches = branchMetrics.branchNames.filter(
+          (b) => !isValidBranchName(b)
+        );
+        p4.log.warn(
+          `Invalid branch names:
   ${invalidBranches.slice(0, 10).join("\n  ")}${invalidBranches.length > 10 ? `
   ... and ${invalidBranches.length - 10} more` : ""}`
+        );
+      }
+    }
+  }
+  if (showCode) {
+    if (!ciMode && showGit) {
+      spinner5?.start("Analyzing codebase...");
+    } else if (!ciMode) {
+      spinner5?.start("Analyzing codebase...");
+    }
+    const codebaseMetrics = await analyzeCodebase(targetDir);
+    complianceScores.push(codebaseMetrics.overallCompliance);
+    spinner5?.stop("Codebase analysis complete");
+    if (ciMode) {
+      console.log("\n=== CODEBASE METRICS ===");
+      console.log(`Files analyzed: ${codebaseMetrics.filesAnalyzed}`);
+      console.log(`Overall compliance: ${codebaseMetrics.overallCompliance}%`);
+      for (const [rule, compliance] of Object.entries(
+        codebaseMetrics.complianceByRule
+      )) {
+        console.log(`  ${rule}: ${compliance}%`);
+      }
+    } else {
+      p4.note(formatCodebaseMetrics(codebaseMetrics), "Codebase Analysis");
+    }
+  }
+  if (complianceScores.length > 0) {
+    overallCompliance = Math.round(
+      complianceScores.reduce((a, b) => a + b, 0) / complianceScores.length
     );
   }
-  const overallCompliance = Math.round(
-    (metrics.taskLinkCompliance + metrics.branchCompliance) / 2
-  );
+  if (ciMode) {
+    console.log(`
+OVERALL COMPLIANCE: ${overallCompliance}%`);
+    console.log(`THRESHOLD: ${threshold}%`);
+    if (overallCompliance < threshold) {
+      console.log(
+        `
+FAILED: Compliance ${overallCompliance}% is below threshold ${threshold}%`
+      );
+      process.exit(1);
+    } else {
+      console.log(`
+PASSED: Compliance meets threshold`);
+      process.exit(0);
+    }
+  }
   if (overallCompliance >= 90) {
     p4.outro(pc4.green("\u2713 Excellent compliance! Keep up the good work."));
   } else if (overallCompliance >= 70) {
@@ -2677,10 +3580,60 @@ ${pc4.bold("Branches")}
   }
 }
 
+// src/commands/install-commands.ts
+import * as p5 from "@clack/prompts";
+import pc5 from "picocolors";
+async function runInstallCommands(targetDir = process.cwd()) {
+  p5.intro(pc5.cyan("RaftStack: Install Claude Code commands and skills"));
+  const spinner5 = p5.spinner();
+  spinner5.start("Installing Claude Code commands and skills...");
+  try {
+    const commandsResult = await generateClaudeCommands(targetDir);
+    const skillsResult = await generateClaudeSkills(targetDir);
+    spinner5.stop("Claude Code commands and skills installed!");
+    const created = [...commandsResult.created, ...skillsResult.created];
+    const backedUp = [...commandsResult.backedUp, ...skillsResult.backedUp];
+    console.log();
+    if (created.length > 0) {
+      p5.log.success(pc5.green("Installed files:"));
+      for (const file of created) {
+        console.log(`  ${pc5.dim("+")} ${file}`);
+      }
+    }
+    if (backedUp.length > 0) {
+      console.log();
+      p5.log.info(pc5.dim("Backed up existing files:"));
+      for (const file of backedUp) {
+        console.log(`  ${pc5.dim("\u2192")} ${file}.backup`);
+      }
+    }
+    console.log();
+    p5.note(
+      [
+        `${pc5.cyan("/raftstack/init-context")} - Analyze codebase, generate constitution`,
+        `${pc5.cyan("/raftstack/shape")} - Plan features with adaptive depth`,
+        `${pc5.cyan("/raftstack/discover")} - Extract patterns into standards`,
+        `${pc5.cyan("/raftstack/inject")} - Surface relevant context for tasks`,
+        `${pc5.cyan("/raftstack/index")} - Maintain standards registry`
+      ].join("\n"),
+      "Available Commands"
+    );
+    p5.outro(pc5.green("Ready to use! Try /raftstack/init-context to get started."));
+  } catch (error) {
+    spinner5.stop("Error installing commands");
+    p5.log.error(
+      pc5.red(
+        `Error: ${error instanceof Error ? error.message : "Unknown error"}`
+      )
+    );
+    process.exit(1);
+  }
+}
+
 // package.json
 var package_default = {
   name: "@raftlabs/raftstack",
-  version: "1.7.2",
+  version: "1.9.1",
   description: "CLI tool for setting up Git hooks, commit conventions, and GitHub integration",
   type: "module",
   main: "./dist/index.js",
@@ -2697,7 +3650,8 @@ var package_default = {
   files: [
     "dist",
     "templates",
-    ".claude/skills"
+    ".claude/skills",
+    ".claude/commands"
   ],
   scripts: {
     build: "tsup",
@@ -2770,8 +3724,23 @@ program.command("init").description("Initialize RaftStack configuration in your
 program.command("setup-protection").description("Configure GitHub branch protection rules via API").action(async () => {
   await runSetupProtection(process.cwd());
 });
-program.command("metrics").description("Analyze repository compliance with RaftStack conventions").action(async () => {
-  await runMetrics(process.cwd());
+program.command("metrics").description("Analyze repository compliance with RaftStack conventions").option("--git", "Only show Git metrics (commits, branches, authors)").option("--code", "Only show codebase compliance metrics").option("--ci", "CI mode: exit 1 if below threshold").option(
+  "--threshold <n>",
+  "Minimum compliance percentage (default: 70)",
+  "70"
+).option("--days <n>", "Time period in days (default: 30 in CI mode)").action(
+  async (options) => {
+    await runMetrics(process.cwd(), {
+      git: options.git,
+      code: options.code,
+      ci: options.ci,
+      threshold: options.threshold ? parseInt(options.threshold, 10) : 70,
+      days: options.days ? parseInt(options.days, 10) : void 0
+    });
+  }
+);
+program.command("install-commands").description("Install or update Claude Code commands and skills").action(async () => {
+  await runInstallCommands(process.cwd());
 });
 program.parse();
 //# sourceMappingURL=cli.js.map