@qazuor/claude-code-config 0.4.0 → 0.5.0

package/dist/bin.cjs

@@ -230,7 +230,7 @@ var import_node_module = require("module");
 
 // src/cli/index.ts
 init_cjs_shims();
-var import_commander8 = require("commander");
+var import_commander9 = require("commander");
 
 // src/cli/commands/index.ts
 init_cjs_shims();
@@ -2594,7 +2594,7 @@ init_cjs_shims();
 // src/lib/config/reader.ts
 init_cjs_shims();
 init_fs();
-var CONFIG_FILE = "config.json";
+var CONFIG_FILE = "qazuor-claude-config.json";
 var CLAUDE_DIR = ".claude";
 async function readConfig(projectPath) {
   const configPath = joinPath(projectPath, CLAUDE_DIR, CONFIG_FILE);
@@ -2616,7 +2616,7 @@ async function hasClaudeDir(projectPath) {
 // src/lib/config/writer.ts
 init_cjs_shims();
 init_fs();
-var CONFIG_FILE2 = "config.json";
+var CONFIG_FILE2 = "qazuor-claude-config.json";
 var CLAUDE_DIR2 = ".claude";
 async function writeConfig(projectPath, config, options) {
   const claudePath = joinPath(projectPath, CLAUDE_DIR2);
@@ -3258,21 +3258,333 @@ init_cjs_shims();
 // src/lib/git-hooks/husky-installer.ts
 init_cjs_shims();
 init_fs();
-function generateCommitMsgHook() {
+
+// src/lib/git-hooks/precommit-generator.ts
+init_cjs_shims();
+function generatePreCommitScript(config) {
+  if (!config.enabled) {
+    return generateDisabledScript();
+  }
+  const sections = [];
+  sections.push(generateHeader());
+  if (config.showTiming) {
+    sections.push(generateTimingSetup());
+  }
+  sections.push(generateErrorHandling(config.continueOnFailure));
+  if (config.lint.enabled) {
+    sections.push(generateLintSection(config));
+  }
+  if (config.typecheck.enabled) {
+    sections.push(generateTypecheckSection(config));
+  }
+  if (config.formatCheck.enabled) {
+    sections.push(generateFormatCheckSection(config));
+  }
+  if (config.tests.enabled && config.tests.mode !== "none") {
+    sections.push(generateTestSection(config));
+  }
+  const sortedCustom = [...config.customCommands].sort(
+    (a, b) => (a.order ?? 100) - (b.order ?? 100)
+  );
+  for (const cmd of sortedCustom) {
+    sections.push(generateCustomCommandSection(cmd, config));
+  }
+  sections.push(generateFooter(config));
+  return sections.join("\n\n");
+}
+function generateDisabledScript() {
   return `#!/usr/bin/env sh
 . "$(dirname -- "$0")/_/husky.sh"
 
-npx --no -- commitlint --edit "\${1}"
-`;
+# Pre-commit hook disabled
+exit 0`;
 }
-function generatePreCommitHook(lintCommand) {
-  const command = lintCommand || "pnpm lint-staged";
+function generateHeader() {
   return `#!/usr/bin/env sh
 . "$(dirname -- "$0")/_/husky.sh"
 
-${command}
+# Pre-commit hook - Generated by @qazuor/claude-code-config
+# Bypass with: git commit --no-verify -m "message"
+
+echo "\u{1F50D} Running pre-commit checks..."`;
+}
+function generateTimingSetup() {
+  return `# Timing setup
+START_TIME=$(date +%s)
+step_start() { STEP_START=$(date +%s); }
+step_end() {
+  STEP_END=$(date +%s)
+  ELAPSED_TIME=$((STEP_END - STEP_START))
+  echo "  \u23F1\uFE0F  Completed in \${ELAPSED_TIME}s"
+}`;
+}
+function generateErrorHandling(continueOnFailure) {
+  if (continueOnFailure) {
+    return `# Error tracking (continue on failure mode)
+ERRORS=0
+track_error() {
+  ERRORS=$((ERRORS + 1))
+}`;
+  }
+  return `# Fail fast mode - exit on first error
+set -e`;
+}
+function generateLintSection(config) {
+  const lint = config.lint;
+  let command;
+  if (lint.command) {
+    command = lint.command;
+  } else if (lint.stagedOnly) {
+    command = getLintStagedCommand(lint.tool);
+  } else {
+    command = getLintCommand(lint.tool);
+  }
+  const lines = [];
+  lines.push("# Linting");
+  lines.push('echo ""');
+  lines.push('echo "\u{1F4DD} Linting..."');
+  if (config.showTiming) {
+    lines.push("step_start");
+  }
+  if (lint.allowFailure) {
+    lines.push(`if ${command}; then`);
+    lines.push('  echo "  \u2705 Lint passed"');
+    lines.push("else");
+    lines.push('  echo "  \u26A0\uFE0F  Lint warnings (non-blocking)"');
+    lines.push("fi");
+  } else if (config.continueOnFailure) {
+    lines.push(`if ${command}; then`);
+    lines.push('  echo "  \u2705 Lint passed"');
+    lines.push("else");
+    lines.push('  echo "  \u274C Lint failed"');
+    lines.push("  track_error");
+    lines.push("fi");
+  } else {
+    lines.push(`${command} || { echo "  \u274C Lint failed"; exit 1; }`);
+    lines.push('echo "  \u2705 Lint passed"');
+  }
+  if (config.showTiming) {
+    lines.push("step_end");
+  }
+  return lines.join("\n");
+}
+function getLintStagedCommand(tool) {
+  switch (tool) {
+    case "biome":
+      return "pnpm biome check --staged --no-errors-on-unmatched";
+    case "eslint":
+      return "pnpm lint-staged";
+    default:
+      return "pnpm lint-staged";
+  }
+}
+function getLintCommand(tool) {
+  switch (tool) {
+    case "biome":
+      return "pnpm biome check .";
+    case "eslint":
+      return "pnpm eslint .";
+    default:
+      return "pnpm lint";
+  }
+}
+function generateTypecheckSection(config) {
+  const typecheck = config.typecheck;
+  const command = typecheck.command ?? "pnpm typecheck";
+  const lines = [];
+  lines.push("# Type checking");
+  lines.push('echo ""');
+  lines.push('echo "\u{1F537} Type checking..."');
+  if (config.showTiming) {
+    lines.push("step_start");
+  }
+  if (typecheck.allowFailure) {
+    lines.push(`if ${command}; then`);
+    lines.push('  echo "  \u2705 Types OK"');
+    lines.push("else");
+    lines.push('  echo "  \u26A0\uFE0F  Type warnings (non-blocking)"');
+    lines.push("fi");
+  } else if (config.continueOnFailure) {
+    lines.push(`if ${command}; then`);
+    lines.push('  echo "  \u2705 Types OK"');
+    lines.push("else");
+    lines.push('  echo "  \u274C Type check failed"');
+    lines.push("  track_error");
+    lines.push("fi");
+  } else {
+    lines.push(`${command} || { echo "  \u274C Type check failed"; exit 1; }`);
+    lines.push('echo "  \u2705 Types OK"');
+  }
+  if (config.showTiming) {
+    lines.push("step_end");
+  }
+  return lines.join("\n");
+}
+function generateFormatCheckSection(config) {
+  const format = config.formatCheck;
+  let command;
+  if (format.command) {
+    command = format.command;
+  } else {
+    command = getFormatCheckCommand(format.tool);
+  }
+  const lines = [];
+  lines.push("# Format check");
+  lines.push('echo ""');
+  lines.push('echo "\u2728 Format check..."');
+  if (config.showTiming) {
+    lines.push("step_start");
+  }
+  if (format.allowFailure) {
+    lines.push(`if ${command}; then`);
+    lines.push('  echo "  \u2705 Format OK"');
+    lines.push("else");
+    lines.push('  echo "  \u26A0\uFE0F  Format warnings (non-blocking)"');
+    lines.push("fi");
+  } else if (config.continueOnFailure) {
+    lines.push(`if ${command}; then`);
+    lines.push('  echo "  \u2705 Format OK"');
+    lines.push("else");
+    lines.push('  echo "  \u274C Format check failed"');
+    lines.push("  track_error");
+    lines.push("fi");
+  } else {
+    lines.push(`${command} || { echo "  \u274C Format check failed"; exit 1; }`);
+    lines.push('echo "  \u2705 Format OK"');
+  }
+  if (config.showTiming) {
+    lines.push("step_end");
+  }
+  return lines.join("\n");
+}
+function getFormatCheckCommand(tool) {
+  switch (tool) {
+    case "biome":
+      return "pnpm biome format --check .";
+    case "prettier":
+      return "pnpm prettier --check .";
+    default:
+      return "pnpm format:check";
+  }
+}
+function generateTestSection(config) {
+  const tests = config.tests;
+  let command;
+  if (tests.command) {
+    command = tests.command;
+  } else if (tests.mode === "affected") {
+    command = "pnpm vitest related --run";
+  } else {
+    command = "pnpm test";
+  }
+  if (tests.coverageThreshold > 0) {
+    command = `${command} --coverage --coverage.thresholds.lines=${tests.coverageThreshold}`;
+  }
+  const lines = [];
+  lines.push("# Tests");
+  lines.push('echo ""');
+  lines.push(`echo "\u{1F9EA} Running ${tests.mode === "affected" ? "affected" : "all"} tests..."`);
+  if (config.showTiming) {
+    lines.push("step_start");
+  }
+  if (tests.allowFailure) {
+    lines.push(`if ${command}; then`);
+    lines.push('  echo "  \u2705 Tests passed"');
+    lines.push("else");
+    lines.push('  echo "  \u26A0\uFE0F  Test warnings (non-blocking)"');
+    lines.push("fi");
+  } else if (config.continueOnFailure) {
+    lines.push(`if ${command}; then`);
+    lines.push('  echo "  \u2705 Tests passed"');
+    lines.push("else");
+    lines.push('  echo "  \u274C Tests failed"');
+    lines.push("  track_error");
+    lines.push("fi");
+  } else {
+    lines.push(`${command} || { echo "  \u274C Tests failed"; exit 1; }`);
+    lines.push('echo "  \u2705 Tests passed"');
+  }
+  if (config.showTiming) {
+    lines.push("step_end");
+  }
+  return lines.join("\n");
+}
+function generateCustomCommandSection(cmd, config) {
+  const lines = [];
+  lines.push(`# Custom: ${cmd.name}`);
+  lines.push('echo ""');
+  lines.push(`echo "\u{1F527} ${cmd.name}..."`);
+  if (config.showTiming) {
+    lines.push("step_start");
+  }
+  if (cmd.allowFailure) {
+    lines.push(`if ${cmd.command}; then`);
+    lines.push(`  echo "  \u2705 ${cmd.name} passed"`);
+    lines.push("else");
+    lines.push(`  echo "  \u26A0\uFE0F  ${cmd.name} warnings (non-blocking)"`);
+    lines.push("fi");
+  } else if (config.continueOnFailure) {
+    lines.push(`if ${cmd.command}; then`);
+    lines.push(`  echo "  \u2705 ${cmd.name} passed"`);
+    lines.push("else");
+    lines.push(`  echo "  \u274C ${cmd.name} failed"`);
+    lines.push("  track_error");
+    lines.push("fi");
+  } else {
+    lines.push(`${cmd.command} || { echo "  \u274C ${cmd.name} failed"; exit 1; }`);
+    lines.push(`echo "  \u2705 ${cmd.name} passed"`);
+  }
+  if (config.showTiming) {
+    lines.push("step_end");
+  }
+  return lines.join("\n");
+}
+function generateFooter(config) {
+  const lines = [];
+  lines.push("# Final status");
+  lines.push('echo ""');
+  if (config.showTiming) {
+    lines.push("END_TIME=$(date +%s)");
+    lines.push("TOTAL_TIME=$((END_TIME - START_TIME))");
+  }
+  if (config.continueOnFailure) {
+    lines.push("if [ $ERRORS -gt 0 ]; then");
+    lines.push('  echo "\u274C Pre-commit failed with $ERRORS error(s)"');
+    if (config.showTiming) {
+      lines.push('  echo "\u23F1\uFE0F  Total time: ${TOTAL_TIME}s"');
+    }
+    lines.push("  exit 1");
+    lines.push("fi");
+  }
+  if (config.showTiming) {
+    lines.push('echo "\u2728 All checks passed! (${TOTAL_TIME}s)"');
+  } else {
+    lines.push('echo "\u2728 All checks passed!"');
+  }
+  return lines.join("\n");
+}
+function generateSimplePreCommitHook(command) {
+  return `#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+${command}`;
+}
+
+// src/lib/git-hooks/husky-installer.ts
+function generateCommitMsgHook() {
+  return `#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+npx --no -- commitlint --edit "\${1}"
 `;
 }
+function generatePreCommitHook(lintCommand, preCommitConfig) {
+  if (preCommitConfig) {
+    return generatePreCommitScript(preCommitConfig);
+  }
+  const command = lintCommand || "pnpm lint-staged";
+  return generateSimplePreCommitHook(command);
+}
 function generatePrePushHook(testCommand) {
   const command = testCommand || "pnpm test";
   return `#!/usr/bin/env sh
@@ -3363,7 +3675,10 @@ async function installHusky(projectPath, config, options) {
     if (config.preCommit) {
       const preCommitPath = joinPath(huskyDir, "pre-commit");
       if (!await pathExists(preCommitPath) || options?.overwrite) {
-        await writeFile(preCommitPath, generatePreCommitHook(config.lintCommand));
+        await writeFile(
+          preCommitPath,
+          generatePreCommitHook(config.lintCommand, config.preCommitConfig)
+        );
         await makeExecutable(preCommitPath);
         result.created.push("pre-commit");
       } else {
@@ -3595,8 +3910,8 @@ async function getHooksStatus(projectPath) {
     let executable = false;
     if (exists) {
       try {
-        const fs6 = await import("fs/promises");
-        const stats = await fs6.stat(filePath);
+        const fs9 = await import("fs/promises");
+        const stats = await fs9.stat(filePath);
         executable = (stats.mode & 73) !== 0;
       } catch {
       }
@@ -10626,27 +10941,27 @@ async function buildConfigContext(projectPath) {
     values: {}
   };
   try {
-    const fs6 = await import("fs/promises");
-    const path7 = await import("path");
-    const pkgPath = path7.join(projectPath, "package.json");
-    const pkgContent = await fs6.readFile(pkgPath, "utf-8");
+    const fs9 = await import("fs/promises");
+    const path10 = await import("path");
+    const pkgPath = path10.join(projectPath, "package.json");
+    const pkgContent = await fs9.readFile(pkgPath, "utf-8");
     const pkg = JSON.parse(pkgContent);
     context.scripts = pkg.scripts || {};
     context.dependencies = {
       ...pkg.dependencies || {},
       ...pkg.devDependencies || {}
     };
-    context.hasTypeScript = Boolean(context.dependencies.typescript) || await fileExists(path7.join(projectPath, "tsconfig.json"));
-    if (await fileExists(path7.join(projectPath, "pnpm-lock.yaml"))) {
+    context.hasTypeScript = Boolean(context.dependencies.typescript) || await fileExists(path10.join(projectPath, "tsconfig.json"));
+    if (await fileExists(path10.join(projectPath, "pnpm-lock.yaml"))) {
       context.packageManager = "pnpm";
-    } else if (await fileExists(path7.join(projectPath, "yarn.lock"))) {
+    } else if (await fileExists(path10.join(projectPath, "yarn.lock"))) {
       context.packageManager = "yarn";
-    } else if (await fileExists(path7.join(projectPath, "bun.lockb"))) {
+    } else if (await fileExists(path10.join(projectPath, "bun.lockb"))) {
       context.packageManager = "bun";
     } else {
       context.packageManager = "npm";
     }
-    context.isGitRepo = await fileExists(path7.join(projectPath, ".git"));
+    context.isGitRepo = await fileExists(path10.join(projectPath, ".git"));
     if (context.isGitRepo) {
       try {
         const { execSync } = await import("child_process");
@@ -10665,8 +10980,8 @@ async function buildConfigContext(projectPath) {
 }
 async function fileExists(filePath) {
   try {
-    const fs6 = await import("fs/promises");
-    await fs6.access(filePath);
+    const fs9 = await import("fs/promises");
+    await fs9.access(filePath);
     return true;
   } catch {
     return false;
@@ -11700,8 +12015,8 @@ function createInitCommand() {
   ).option("-t, --template <url>", "Remote git repo for templates").option("--branch <name>", "Branch/tag for remote template").option("-y, --yes", "Accept defaults, skip prompts").option("-f, --force", "Overwrite existing .claude/").option("--dry-run", "Show what would happen without making changes").option("--claude-only", "Only Claude config, no project scaffold").option("--no-placeholders", "Skip placeholder replacement").option("--no-mcp", "Skip MCP configuration").option("-v, --verbose", "Detailed output").action(runInit);
   return cmd;
 }
-async function runInit(path7, options) {
-  const projectPath = resolvePath(path7 || ".");
+async function runInit(path10, options) {
+  const projectPath = resolvePath(path10 || ".");
   logger.configure({ verbose: options.verbose, silent: false });
   logger.title("@qazuor/claude-code-config");
   logger.info(`Initializing Claude configuration in ${colors.primary(projectPath)}`);
@@ -11710,6 +12025,7 @@ async function runInit(path7, options) {
     showCancelHint();
   }
   try {
+    let existingConfig = null;
     if (await hasExistingClaudeConfig(projectPath)) {
       if (!options.force) {
         const action = await promptExistingProjectAction();
@@ -11720,6 +12036,10 @@ async function runInit(path7, options) {
         if (action !== "overwrite" && action !== "merge") {
           return;
         }
+        existingConfig = await readConfig(projectPath);
+        if (existingConfig) {
+          logger.info("Using existing configuration as defaults");
+        }
       }
     }
     const detection = await detectProject(projectPath);
@@ -11736,7 +12056,7 @@ async function runInit(path7, options) {
       () => loadRegistry(templatesPath),
       { silent: options.dryRun }
     );
-    const buildResult = options.yes ? await buildDefaultConfig(projectPath, detection, options) : await buildInteractiveConfig(projectPath, detection, registry, options);
+    const buildResult = options.yes ? await buildDefaultConfig(projectPath, detection, options) : await buildInteractiveConfig(projectPath, detection, registry, options, existingConfig);
     if (!buildResult) {
       logger.warn("Configuration cancelled");
       return;
@@ -11902,7 +12222,7 @@ async function buildDefaultConfig(projectPath, detection, options) {
     // No MCP servers in default mode
   };
 }
-async function buildInteractiveConfig(projectPath, detection, registry, options) {
+async function buildInteractiveConfig(projectPath, detection, registry, options, existingConfig) {
   const projectName = await getProjectName(projectPath);
   const projectDesc = await getProjectDescription(projectPath);
   const wizardConfig = createInitWizardConfig(
@@ -11916,24 +12236,45 @@ async function buildInteractiveConfig(projectPath, detection, registry, options)
     },
     registry
   );
+  const existingProject = existingConfig?.project;
+  const existingPrefs = existingConfig?.preferences;
   const initialContext = {
     projectPath,
     registry,
     detection: {
       detected: detection.detected,
       projectType: detection.projectType,
-      packageManager: detection.packageManager,
+      packageManager: existingPrefs?.packageManager || detection.packageManager,
       suggestedBundles: detection.suggestedBundles,
       detectedTechnologies: detection.detectedTechnologies
     },
+    // Use existing project info as defaults, fallback to detected values
     projectInfo: {
-      name: projectName || "",
-      description: projectDesc || "",
-      org: "",
-      repo: projectName?.toLowerCase().replace(/\s+/g, "-") || "",
-      entityType: "item",
-      entityTypePlural: "items"
-    }
+      name: existingProject?.name || projectName || "",
+      description: existingProject?.description || projectDesc || "",
+      org: existingProject?.org || "",
+      repo: existingProject?.repo || projectName?.toLowerCase().replace(/\s+/g, "-") || "",
+      entityType: existingProject?.entityType || "item",
+      entityTypePlural: existingProject?.entityTypePlural || "items",
+      domain: existingProject?.domain,
+      location: existingProject?.location,
+      author: existingProject?.author
+    },
+    // Use existing preferences as defaults
+    preferences: existingPrefs ? {
+      language: existingPrefs.language,
+      responseLanguage: existingPrefs.responseLanguage,
+      includeCoAuthor: existingPrefs.includeCoAuthor,
+      packageManager: existingPrefs.packageManager
+    } : void 0,
+    // Use existing hook config as defaults
+    hookConfig: existingConfig?.extras?.hooks,
+    // Use existing code style config as defaults
+    codeStyleConfig: existingConfig?.extras?.codeStyle,
+    // Use existing folder preferences as defaults
+    folderPreferences: existingConfig?.extras?.folderPreferences,
+    // Use existing permissions config as defaults
+    permissionsConfig: existingConfig?.customizations?.permissions
   };
   const wizardResult = await runWizard(
     wizardConfig,
@@ -12659,7 +13000,7 @@ async function runStatus(options) {
     }
     const config = await readConfig(projectPath);
     if (!config) {
-      logger.warn(".claude directory exists but config.json is missing");
+      logger.warn(".claude directory exists but qazuor-claude-config.json is missing");
       logger.info('Run "claude-config init" to initialize properly');
       process.exit(0);
     }
@@ -13159,8 +13500,8 @@ function createConfigureCommand() {
   ).option("--preview", "Preview changes without applying").option("--show-defaults", "Show global defaults").option("-v, --verbose", "Detailed output").action(runConfigure);
   return cmd;
 }
-async function runConfigure(path7, options) {
-  const projectPath = resolvePath(path7 || ".");
+async function runConfigure(path10, options) {
+  const projectPath = resolvePath(path10 || ".");
   const claudePath = joinPath(projectPath, ".claude");
   logger.configure({ verbose: options.verbose, silent: false });
   logger.title("Template Configuration");
@@ -13291,16 +13632,1837 @@ async function interactiveMode(claudePath, projectPath, options) {
     };
     existingConfig.customizations.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
     await writeConfig(projectPath, existingConfig);
-    logger.success("Configuration saved to .claude/config.json");
+    logger.success("Configuration saved to .claude/qazuor-claude-config.json");
   }
   await promptSaveGlobalDefaults(templateConfig);
   logger.newline();
   logger.success("Template configuration complete!");
 }
 
+// src/cli/commands/standards.ts
+init_cjs_shims();
+var import_commander8 = require("commander");
+
+// src/constants/standards-defaults.ts
+init_cjs_shims();
+var DEFAULT_CODE_STANDARDS = {
+  indentStyle: "space",
+  indentSize: 2,
+  maxLineLength: 100,
+  maxFileLines: 500,
+  quoteStyle: "single",
+  semicolons: true,
+  trailingCommas: "es5",
+  allowAny: false,
+  namedExportsOnly: true,
+  roroPattern: true,
+  jsDocRequired: true
+};
+var DEFAULT_TESTING_STANDARDS = {
+  coverageTarget: 80,
+  tddRequired: true,
+  testPattern: "aaa",
+  testLocation: "separate",
+  unitTestMaxMs: 100,
+  integrationTestMaxMs: 1e3
+};
+var DEFAULT_DOCUMENTATION_STANDARDS = {
+  jsDocLevel: "standard",
+  requireExamples: false,
+  changelogFormat: "conventional",
+  inlineCommentPolicy: "why-not-what"
+};
+var DEFAULT_DESIGN_STANDARDS = {
+  cssFramework: "tailwind",
+  componentLibrary: "shadcn",
+  accessibilityLevel: "AA",
+  darkModeSupport: true
+};
+var DEFAULT_SECURITY_STANDARDS = {
+  authPattern: "jwt",
+  inputValidation: "zod",
+  csrfProtection: true,
+  rateLimiting: true
+};
+var DEFAULT_PERFORMANCE_STANDARDS = {
+  lcpTarget: 2500,
+  fidTarget: 100,
+  clsTarget: 0.1,
+  bundleSizeTargetKb: 250,
+  apiResponseTargetMs: 300
+};
+var DEFAULT_STANDARDS_CONFIG = {
+  code: DEFAULT_CODE_STANDARDS,
+  testing: DEFAULT_TESTING_STANDARDS,
+  documentation: DEFAULT_DOCUMENTATION_STANDARDS,
+  design: DEFAULT_DESIGN_STANDARDS,
+  security: DEFAULT_SECURITY_STANDARDS,
+  performance: DEFAULT_PERFORMANCE_STANDARDS
+};
+var STANDARDS_PRESETS = {
+  strict: {
+    name: "Strict",
+    description: "High quality standards with strict enforcement (90%+ coverage, TDD required)",
+    config: {
+      code: {
+        ...DEFAULT_CODE_STANDARDS,
+        allowAny: false,
+        jsDocRequired: true
+      },
+      testing: {
+        ...DEFAULT_TESTING_STANDARDS,
+        coverageTarget: 90,
+        tddRequired: true
+      },
+      documentation: {
+        ...DEFAULT_DOCUMENTATION_STANDARDS,
+        jsDocLevel: "comprehensive",
+        requireExamples: true
+      },
+      design: {
+        ...DEFAULT_DESIGN_STANDARDS,
+        accessibilityLevel: "AAA"
+      },
+      security: {
+        ...DEFAULT_SECURITY_STANDARDS,
+        csrfProtection: true,
+        rateLimiting: true
+      },
+      performance: {
+        ...DEFAULT_PERFORMANCE_STANDARDS,
+        lcpTarget: 2e3,
+        apiResponseTargetMs: 200
+      }
+    }
+  },
+  balanced: {
+    name: "Balanced",
+    description: "Good balance between quality and pragmatism (80% coverage)",
+    config: DEFAULT_STANDARDS_CONFIG
+  },
+  relaxed: {
+    name: "Relaxed",
+    description: "More flexible standards for rapid development (70% coverage)",
+    config: {
+      code: {
+        ...DEFAULT_CODE_STANDARDS,
+        maxFileLines: 800,
+        jsDocRequired: false
+      },
+      testing: {
+        ...DEFAULT_TESTING_STANDARDS,
+        coverageTarget: 70,
+        tddRequired: false
+      },
+      documentation: {
+        ...DEFAULT_DOCUMENTATION_STANDARDS,
+        jsDocLevel: "minimal",
+        requireExamples: false
+      },
+      design: {
+        ...DEFAULT_DESIGN_STANDARDS,
+        accessibilityLevel: "A"
+      },
+      security: {
+        ...DEFAULT_SECURITY_STANDARDS
+      },
+      performance: {
+        ...DEFAULT_PERFORMANCE_STANDARDS,
+        lcpTarget: 4e3,
+        apiResponseTargetMs: 500
+      }
+    }
+  },
+  startup: {
+    name: "Startup",
+    description: "Fast iteration with minimum viable standards (60% coverage)",
+    config: {
+      code: {
+        ...DEFAULT_CODE_STANDARDS,
+        maxFileLines: 1e3,
+        jsDocRequired: false,
+        roroPattern: false
+      },
+      testing: {
+        coverageTarget: 60,
+        tddRequired: false,
+        testPattern: "aaa",
+        testLocation: "colocated",
+        unitTestMaxMs: 200,
+        integrationTestMaxMs: 2e3
+      },
+      documentation: {
+        jsDocLevel: "minimal",
+        requireExamples: false,
+        changelogFormat: "conventional",
+        inlineCommentPolicy: "minimal"
+      },
+      design: {
+        cssFramework: "tailwind",
+        componentLibrary: "shadcn",
+        accessibilityLevel: "A",
+        darkModeSupport: false
+      },
+      security: {
+        authPattern: "jwt",
+        inputValidation: "zod",
+        csrfProtection: false,
+        rateLimiting: false
+      },
+      performance: {
+        lcpTarget: 4e3,
+        fidTarget: 300,
+        clsTarget: 0.25,
+        bundleSizeTargetKb: 500,
+        apiResponseTargetMs: 500
+      }
+    }
+  },
+  enterprise: {
+    name: "Enterprise",
+    description: "Enterprise-grade standards with full compliance (95%+ coverage)",
+    config: {
+      code: {
+        indentStyle: "space",
+        indentSize: 2,
+        maxLineLength: 120,
+        maxFileLines: 400,
+        quoteStyle: "single",
+        semicolons: true,
+        trailingCommas: "all",
+        allowAny: false,
+        namedExportsOnly: true,
+        roroPattern: true,
+        jsDocRequired: true
+      },
+      testing: {
+        coverageTarget: 95,
+        tddRequired: true,
+        testPattern: "aaa",
+        testLocation: "separate",
+        unitTestMaxMs: 50,
+        integrationTestMaxMs: 500
+      },
+      documentation: {
+        jsDocLevel: "comprehensive",
+        requireExamples: true,
+        changelogFormat: "keepachangelog",
+        inlineCommentPolicy: "why-not-what"
+      },
+      design: {
+        cssFramework: "tailwind",
+        componentLibrary: "radix",
+        accessibilityLevel: "AAA",
+        darkModeSupport: true
+      },
+      security: {
+        authPattern: "oauth",
+        inputValidation: "zod",
+        csrfProtection: true,
+        rateLimiting: true
+      },
+      performance: {
+        lcpTarget: 1500,
+        fidTarget: 50,
+        clsTarget: 0.05,
+        bundleSizeTargetKb: 150,
+        apiResponseTargetMs: 150
+      }
+    }
+  },
+  custom: {
+    name: "Custom",
+    description: "Configure each standard manually",
+    config: DEFAULT_STANDARDS_CONFIG
+  }
+};
+
+// src/lib/standards/index.ts
+init_cjs_shims();
+
+// src/lib/standards/definitions.ts
+init_cjs_shims();
+var CODE_STANDARDS_DEFINITION = {
+  id: "code",
+  name: "Code Standards",
+  description: "Code style, formatting, and TypeScript conventions",
+  icon: "\u{1F4DD}",
+  options: [
+    {
+      id: "indentStyle",
+      label: "Indent Style",
+      description: "Use spaces or tabs for indentation",
+      type: "select",
+      choices: [
+        { name: "Spaces", value: "space", description: "Standard for most projects" },
+        { name: "Tabs", value: "tab", description: "Better for accessibility" }
+      ],
+      affectsPlaceholders: ["{{INDENT_STYLE}}"]
+    },
+    {
+      id: "indentSize",
+      label: "Indent Size",
+      description: "Number of spaces/tab width",
+      type: "select",
+      choices: [
+        { name: "2 spaces", value: "2", description: "Most common in JS/TS" },
+        { name: "4 spaces", value: "4", description: "More readable for some" }
+      ],
+      affectsPlaceholders: ["{{INDENT_SIZE}}"]
+    },
+    {
+      id: "maxLineLength",
+      label: "Max Line Length",
+      description: "Maximum characters per line",
+      type: "select",
+      choices: [
+        { name: "80 characters", value: "80", description: "Classic terminal width" },
+        { name: "100 characters", value: "100", description: "Modern balance" },
+        { name: "120 characters", value: "120", description: "Wide screens" }
+      ],
+      affectsPlaceholders: ["{{MAX_LINE_LENGTH}}"]
+    },
+    {
+      id: "maxFileLines",
+      label: "Max File Lines",
+      description: "Maximum lines per file (excluding tests, docs, JSON)",
+      type: "select",
+      choices: [
+        { name: "300 lines", value: "300", description: "Very strict" },
+        { name: "500 lines", value: "500", description: "Recommended" },
+        { name: "800 lines", value: "800", description: "Relaxed" },
+        { name: "1000 lines", value: "1000", description: "Very relaxed" }
+      ],
+      affectsPlaceholders: ["{{MAX_FILE_LINES}}"]
+    },
+    {
+      id: "quoteStyle",
+      label: "Quote Style",
+      description: "Single or double quotes for strings",
+      type: "select",
+      choices: [
+        { name: "Single quotes", value: "single", description: "const x = 'hello'" },
+        { name: "Double quotes", value: "double", description: 'const x = "hello"' }
+      ],
+      affectsPlaceholders: ["{{QUOTE_STYLE}}"]
+    },
+    {
+      id: "semicolons",
+      label: "Semicolons",
+      description: "Use semicolons at end of statements",
+      type: "boolean",
+      affectsPlaceholders: ["{{USE_SEMICOLONS}}"]
+    },
+    {
+      id: "trailingCommas",
+      label: "Trailing Commas",
+      description: "Add trailing commas in multiline constructs",
+      type: "select",
+      choices: [
+        { name: "ES5", value: "es5", description: "Where valid in ES5 (objects, arrays)" },
+        { name: "All", value: "all", description: "Everywhere possible" },
+        { name: "None", value: "none", description: "No trailing commas" }
+      ],
+      affectsPlaceholders: ["{{TRAILING_COMMAS}}"]
+    },
+    {
+      id: "allowAny",
+      label: 'Allow "any" Type',
+      description: 'Allow the "any" type in TypeScript',
+      type: "boolean",
+      affectsPlaceholders: ["{{ALLOW_ANY}}"]
+    },
+    {
+      id: "namedExportsOnly",
+      label: "Named Exports Only",
+      description: "Require named exports (no default exports)",
+      type: "boolean",
+      affectsPlaceholders: ["{{NAMED_EXPORTS_ONLY}}"]
+    },
+    {
+      id: "roroPattern",
+      label: "RO-RO Pattern",
+      description: "Require Receive Object, Return Object pattern",
+      type: "boolean",
+      affectsPlaceholders: ["{{RORO_PATTERN}}"]
+    },
+    {
+      id: "jsDocRequired",
+      label: "JSDoc Required",
+      description: "Require JSDoc for all exports",
+      type: "boolean",
+      affectsPlaceholders: ["{{JSDOC_REQUIRED}}"]
+    }
+  ],
+  targetFiles: ["code-standards.md", "architecture-patterns.md"]
+};
+var TESTING_STANDARDS_DEFINITION = {
+  id: "testing",
+  name: "Testing Standards",
+  description: "Test coverage, TDD, and testing methodology",
+  icon: "\u{1F9EA}",
+  options: [
+    {
+      id: "coverageTarget",
+      label: "Coverage Target",
+      description: "Minimum code coverage percentage",
+      type: "select",
+      choices: [
+        { name: "60%", value: "60", description: "Minimum viable" },
+        { name: "70%", value: "70", description: "Relaxed" },
+        { name: "80%", value: "80", description: "Standard" },
+        { name: "90%", value: "90", description: "Strict" },
+        { name: "95%", value: "95", description: "Enterprise" }
+      ],
+      affectsPlaceholders: ["{{COVERAGE_TARGET}}"]
+    },
+    {
+      id: "tddRequired",
+      label: "TDD Required",
+      description: "Require Test-Driven Development (Red-Green-Refactor)",
+      type: "boolean",
+      affectsPlaceholders: ["{{TDD_REQUIRED}}"]
+    },
+    {
+      id: "testPattern",
+      label: "Test Pattern",
+      description: "Test structure pattern",
+      type: "select",
+      choices: [
+        { name: "AAA", value: "aaa", description: "Arrange-Act-Assert" },
+        { name: "GWT", value: "gwt", description: "Given-When-Then" }
+      ],
+      affectsPlaceholders: ["{{TEST_PATTERN}}"]
+    },
+    {
+      id: "testLocation",
+      label: "Test Location",
+      description: "Where to place test files",
+      type: "select",
+      choices: [
+        { name: "Separate", value: "separate", description: "test/ folder at root" },
+        { name: "Colocated", value: "colocated", description: "__tests__ near source" }
+      ],
+      affectsPlaceholders: ["{{TEST_LOCATION}}"]
+    },
+    {
+      id: "unitTestMaxMs",
+      label: "Unit Test Max (ms)",
+      description: "Maximum milliseconds per unit test",
+      type: "select",
+      choices: [
+        { name: "50ms", value: "50", description: "Very fast" },
+        { name: "100ms", value: "100", description: "Standard" },
+        { name: "200ms", value: "200", description: "Relaxed" }
+      ],
+      affectsPlaceholders: ["{{UNIT_TEST_MAX_MS}}"]
+    },
+    {
+      id: "integrationTestMaxMs",
+      label: "Integration Test Max (ms)",
+      description: "Maximum milliseconds per integration test",
+      type: "select",
+      choices: [
+        { name: "500ms", value: "500", description: "Fast" },
+        { name: "1000ms", value: "1000", description: "Standard" },
+        { name: "2000ms", value: "2000", description: "Relaxed" }
+      ],
+      affectsPlaceholders: ["{{INTEGRATION_TEST_MAX_MS}}"]
+    }
+  ],
+  targetFiles: ["testing-standards.md"]
+};
+var DOCUMENTATION_STANDARDS_DEFINITION = {
+  id: "documentation",
+  name: "Documentation Standards",
+  description: "JSDoc, comments, and changelog conventions",
+  icon: "\u{1F4DA}",
+  options: [
+    {
+      id: "jsDocLevel",
+      label: "JSDoc Level",
+      description: "Level of detail in JSDoc comments",
+      type: "select",
+      choices: [
+        { name: "Minimal", value: "minimal", description: "Brief description only" },
+        { name: "Standard", value: "standard", description: "Description + params + returns" },
+        { name: "Comprehensive", value: "comprehensive", description: "Full docs with examples" }
+      ],
+      affectsPlaceholders: ["{{JSDOC_LEVEL}}"]
+    },
+    {
+      id: "requireExamples",
+      label: "Require Examples",
+      description: "Require @example in JSDoc",
+      type: "boolean",
+      affectsPlaceholders: ["{{REQUIRE_EXAMPLES}}"]
+    },
+    {
+      id: "changelogFormat",
+      label: "Changelog Format",
+      description: "Changelog format to follow",
+      type: "select",
+      choices: [
+        { name: "Conventional", value: "conventional", description: "Auto-generated from commits" },
+        { name: "Keep a Changelog", value: "keepachangelog", description: "Manual, semantic" }
+      ],
+      affectsPlaceholders: ["{{CHANGELOG_FORMAT}}"]
+    },
+    {
+      id: "inlineCommentPolicy",
+      label: "Inline Comment Policy",
+      description: "Policy for inline code comments",
+      type: "select",
+      choices: [
+        {
+          name: "Why not What",
+          value: "why-not-what",
+          description: "Explain reasoning, not obvious"
+        },
+        { name: "Minimal", value: "minimal", description: "Only when necessary" },
+        { name: "Extensive", value: "extensive", description: "Comment thoroughly" }
+      ],
+      affectsPlaceholders: ["{{INLINE_COMMENT_POLICY}}"]
+    }
+  ],
+  targetFiles: ["documentation-standards.md"]
+};
+var DESIGN_STANDARDS_DEFINITION = {
+  id: "design",
+  name: "Design Standards",
+  description: "UI/UX, CSS, and accessibility standards",
+  icon: "\u{1F3A8}",
+  options: [
+    {
+      id: "cssFramework",
+      label: "CSS Framework",
+      description: "CSS/styling approach",
+      type: "select",
+      choices: [
+        { name: "Tailwind CSS", value: "tailwind", description: "Utility-first CSS" },
+        { name: "CSS Modules", value: "css-modules", description: "Scoped CSS" },
+        { name: "Styled Components", value: "styled-components", description: "CSS-in-JS" },
+        { name: "Vanilla CSS", value: "vanilla", description: "Plain CSS" }
+      ],
+      affectsPlaceholders: ["{{CSS_FRAMEWORK}}"]
+    },
+    {
+      id: "componentLibrary",
+      label: "Component Library",
+      description: "UI component library",
+      type: "select",
+      choices: [
+        { name: "shadcn/ui", value: "shadcn", description: "Copy-paste components" },
+        { name: "Radix UI", value: "radix", description: "Unstyled primitives" },
+        { name: "Headless UI", value: "headless", description: "Unstyled, accessible" },
+        { name: "None", value: "none", description: "Build from scratch" }
+      ],
+      affectsPlaceholders: ["{{COMPONENT_LIBRARY}}"]
+    },
+    {
+      id: "accessibilityLevel",
+      label: "Accessibility Level",
+      description: "WCAG accessibility compliance level",
+      type: "select",
+      choices: [
+        { name: "Level A", value: "A", description: "Minimum" },
+        { name: "Level AA", value: "AA", description: "Standard (recommended)" },
+        { name: "Level AAA", value: "AAA", description: "Highest" }
+      ],
+      affectsPlaceholders: ["{{WCAG_LEVEL}}", "{{ACCESSIBILITY_LEVEL}}"]
+    },
+    {
+      id: "darkModeSupport",
+      label: "Dark Mode Support",
+      description: "Support dark mode theme",
+      type: "boolean",
+      affectsPlaceholders: ["{{DARK_MODE_SUPPORT}}"]
+    }
+  ],
+  targetFiles: ["design-standards.md"]
+};
+var SECURITY_STANDARDS_DEFINITION = {
+  id: "security",
+  name: "Security Standards",
+  description: "Authentication, validation, and security practices",
+  icon: "\u{1F512}",
+  options: [
+    {
+      id: "authPattern",
+      label: "Auth Pattern",
+      description: "Authentication approach",
+      type: "select",
+      choices: [
+        { name: "JWT", value: "jwt", description: "JSON Web Tokens" },
+        { name: "Session", value: "session", description: "Server-side sessions" },
+        { name: "OAuth", value: "oauth", description: "OAuth 2.0 / OIDC" },
+        { name: "None", value: "none", description: "No authentication" }
+      ],
+      affectsPlaceholders: ["{{AUTH_PATTERN}}"]
+    },
+    {
+      id: "inputValidation",
+      label: "Input Validation",
+      description: "Validation library",
+      type: "select",
+      choices: [
+        { name: "Zod", value: "zod", description: "TypeScript-first validation" },
+        { name: "Yup", value: "yup", description: "Schema builder" },
+        { name: "Joi", value: "joi", description: "Data validation" },
+        { name: "Manual", value: "manual", description: "Custom validation" }
+      ],
+      affectsPlaceholders: ["{{VALIDATION_LIBRARY}}", "{{INPUT_VALIDATION}}"]
+    },
+    {
+      id: "csrfProtection",
+      label: "CSRF Protection",
+      description: "Enable Cross-Site Request Forgery protection",
+      type: "boolean",
+      affectsPlaceholders: ["{{CSRF_PROTECTION}}"]
+    },
+    {
+      id: "rateLimiting",
+      label: "Rate Limiting",
+      description: "Enable API rate limiting",
+      type: "boolean",
+      affectsPlaceholders: ["{{RATE_LIMITING}}"]
+    }
+  ],
+  targetFiles: ["security-standards.md"]
+};
+var PERFORMANCE_STANDARDS_DEFINITION = {
+  id: "performance",
+  name: "Performance Standards",
+  description: "Core Web Vitals and performance targets",
+  icon: "\u26A1",
+  options: [
+    {
+      id: "lcpTarget",
+      label: "LCP Target (ms)",
+      description: "Largest Contentful Paint target",
+      type: "select",
+      choices: [
+        { name: "1500ms", value: "1500", description: "Excellent" },
+        { name: "2000ms", value: "2000", description: "Good" },
+        { name: "2500ms", value: "2500", description: "Standard" },
+        { name: "4000ms", value: "4000", description: "Needs improvement" }
+      ],
+      affectsPlaceholders: ["{{LCP_TARGET}}"]
+    },
+    {
+      id: "fidTarget",
+      label: "FID Target (ms)",
+      description: "First Input Delay target",
+      type: "select",
+      choices: [
+        { name: "50ms", value: "50", description: "Excellent" },
+        { name: "100ms", value: "100", description: "Good" },
+        { name: "200ms", value: "200", description: "Standard" },
+        { name: "300ms", value: "300", description: "Needs improvement" }
+      ],
+      affectsPlaceholders: ["{{FID_TARGET}}"]
+    },
+    {
+      id: "clsTarget",
+      label: "CLS Target",
+      description: "Cumulative Layout Shift target",
+      type: "select",
+      choices: [
+        { name: "0.05", value: "0.05", description: "Excellent" },
+        { name: "0.1", value: "0.1", description: "Good" },
+        { name: "0.15", value: "0.15", description: "Standard" },
+        { name: "0.25", value: "0.25", description: "Needs improvement" }
+      ],
+      affectsPlaceholders: ["{{CLS_TARGET}}"]
+    },
+    {
+      id: "bundleSizeTargetKb",
+      label: "Bundle Size (KB)",
+      description: "Maximum initial bundle size",
+      type: "select",
+      choices: [
+        { name: "100KB", value: "100", description: "Very strict" },
+        { name: "150KB", value: "150", description: "Strict" },
+        { name: "250KB", value: "250", description: "Standard" },
+        { name: "500KB", value: "500", description: "Relaxed" }
+      ],
+      affectsPlaceholders: ["{{BUNDLE_SIZE_TARGET}}"]
+    },
+    {
+      id: "apiResponseTargetMs",
+      label: "API Response (ms)",
+      description: "Maximum API response time",
+      type: "select",
+      choices: [
+        { name: "100ms", value: "100", description: "Very fast" },
+        { name: "200ms", value: "200", description: "Fast" },
+        { name: "300ms", value: "300", description: "Standard" },
+        { name: "500ms", value: "500", description: "Relaxed" }
+      ],
+      affectsPlaceholders: ["{{API_RESPONSE_TARGET}}"]
+    }
+  ],
+  targetFiles: ["performance-standards.md"]
+};
+var STANDARDS_DEFINITIONS = {
+  code: CODE_STANDARDS_DEFINITION,
+  testing: TESTING_STANDARDS_DEFINITION,
+  documentation: DOCUMENTATION_STANDARDS_DEFINITION,
+  design: DESIGN_STANDARDS_DEFINITION,
+  security: SECURITY_STANDARDS_DEFINITION,
+  performance: PERFORMANCE_STANDARDS_DEFINITION
+};
+
+// src/lib/standards/replacer.ts
+init_cjs_shims();
+var fs6 = __toESM(require("fs/promises"), 1);
+var path7 = __toESM(require("path"), 1);
+var import_ora3 = __toESM(require("ora"), 1);
+var PROCESSABLE_EXTENSIONS2 = [".md", ".json", ".yaml", ".yml", ".txt"];
+var SKIP_DIRECTORIES3 = ["node_modules", ".git", "dist", "build", ".next", ".turbo"];
+function flattenStandardsConfig(config) {
+  const flattened = {};
+  if (config.code) {
+    flattened["{{INDENT_STYLE}}"] = config.code.indentStyle;
+    flattened["{{INDENT_SIZE}}"] = String(config.code.indentSize);
+    flattened["{{MAX_LINE_LENGTH}}"] = String(config.code.maxLineLength);
+    flattened["{{MAX_FILE_LINES}}"] = String(config.code.maxFileLines);
+    flattened["{{QUOTE_STYLE}}"] = config.code.quoteStyle;
+    flattened["{{USE_SEMICOLONS}}"] = config.code.semicolons ? "yes" : "no";
+    flattened["{{TRAILING_COMMAS}}"] = config.code.trailingCommas;
+    flattened["{{ALLOW_ANY}}"] = config.code.allowAny ? "yes" : "no";
+    flattened["{{NAMED_EXPORTS_ONLY}}"] = config.code.namedExportsOnly ? "yes" : "no";
+    flattened["{{RORO_PATTERN}}"] = config.code.roroPattern ? "yes" : "no";
+    flattened["{{JSDOC_REQUIRED}}"] = config.code.jsDocRequired ? "yes" : "no";
+  }
+  if (config.testing) {
+    flattened["{{COVERAGE_TARGET}}"] = String(config.testing.coverageTarget);
+    flattened["{{TDD_REQUIRED}}"] = config.testing.tddRequired ? "yes" : "no";
+    flattened["{{TEST_PATTERN}}"] = config.testing.testPattern.toUpperCase();
+    flattened["{{TEST_LOCATION}}"] = config.testing.testLocation;
+    flattened["{{UNIT_TEST_MAX_MS}}"] = String(config.testing.unitTestMaxMs);
+    flattened["{{INTEGRATION_TEST_MAX_MS}}"] = String(config.testing.integrationTestMaxMs);
+  }
+  if (config.documentation) {
+    flattened["{{JSDOC_LEVEL}}"] = config.documentation.jsDocLevel;
+    flattened["{{REQUIRE_EXAMPLES}}"] = config.documentation.requireExamples ? "yes" : "no";
+    flattened["{{CHANGELOG_FORMAT}}"] = config.documentation.changelogFormat;
+    flattened["{{INLINE_COMMENT_POLICY}}"] = config.documentation.inlineCommentPolicy;
+  }
+  if (config.design) {
+    flattened["{{CSS_FRAMEWORK}}"] = config.design.cssFramework;
+    flattened["{{COMPONENT_LIBRARY}}"] = config.design.componentLibrary;
+    flattened["{{WCAG_LEVEL}}"] = config.design.accessibilityLevel;
+    flattened["{{ACCESSIBILITY_LEVEL}}"] = config.design.accessibilityLevel;
+    flattened["{{DARK_MODE_SUPPORT}}"] = config.design.darkModeSupport ? "yes" : "no";
+  }
+  if (config.security) {
+    flattened["{{AUTH_PATTERN}}"] = config.security.authPattern;
+    flattened["{{VALIDATION_LIBRARY}}"] = config.security.inputValidation;
+    flattened["{{INPUT_VALIDATION}}"] = config.security.inputValidation;
+    flattened["{{CSRF_PROTECTION}}"] = config.security.csrfProtection ? "yes" : "no";
+    flattened["{{RATE_LIMITING}}"] = config.security.rateLimiting ? "yes" : "no";
+  }
+  if (config.performance) {
+    flattened["{{LCP_TARGET}}"] = String(config.performance.lcpTarget);
+    flattened["{{FID_TARGET}}"] = String(config.performance.fidTarget);
+    flattened["{{CLS_TARGET}}"] = String(config.performance.clsTarget);
+    flattened["{{BUNDLE_SIZE_TARGET}}"] = String(config.performance.bundleSizeTargetKb);
+    flattened["{{API_RESPONSE_TARGET}}"] = String(config.performance.apiResponseTargetMs);
+  }
+  return flattened;
+}
+function shouldProcessFile2(filePath) {
+  const ext = path7.extname(filePath).toLowerCase();
+  return PROCESSABLE_EXTENSIONS2.includes(ext);
+}
+function shouldSkipDirectory3(dirName) {
+  return SKIP_DIRECTORIES3.includes(dirName) || dirName.startsWith(".");
+}
+async function getAllFiles3(dir) {
+  const files = [];
+  try {
+    const entries = await fs6.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path7.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!shouldSkipDirectory3(entry.name)) {
+          const subFiles = await getAllFiles3(fullPath);
+          files.push(...subFiles);
+        }
+      } else if (entry.isFile() && shouldProcessFile2(entry.name)) {
+        files.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+async function replaceInFile3(filePath, replacements) {
+  const changes = [];
+  try {
+    let content = await fs6.readFile(filePath, "utf-8");
+    let modified = false;
+    for (const [placeholder, value] of Object.entries(replacements)) {
+      if (content.includes(placeholder)) {
+        content = content.split(placeholder).join(value);
+        changes.push({ placeholder, value });
+        modified = true;
+      }
+    }
+    if (modified) {
+      await fs6.writeFile(filePath, content, "utf-8");
+    }
+  } catch {
+  }
+  return changes;
+}
+async function replaceStandardsPlaceholders(claudePath, config) {
+  const replacements = flattenStandardsConfig(config);
+  const standardsDir = path7.join(claudePath, "docs", "standards");
+  const files = await getAllFiles3(standardsDir);
+  const report = {
+    modifiedFiles: [],
+    replacedPlaceholders: [],
+    unusedPlaceholders: [],
+    errors: []
+  };
+  const usedPlaceholders = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    try {
+      const changes = await replaceInFile3(file, replacements);
+      if (changes.length > 0) {
+        report.modifiedFiles.push(path7.relative(claudePath, file));
+        for (const change of changes) {
+          if (!report.replacedPlaceholders.includes(change.placeholder)) {
+            report.replacedPlaceholders.push(change.placeholder);
+          }
+          usedPlaceholders.add(change.placeholder);
+        }
+      }
+    } catch (error) {
+      report.errors.push(`Error processing ${file}: ${String(error)}`);
+    }
+  }
+  for (const placeholder of Object.keys(replacements)) {
+    if (!usedPlaceholders.has(placeholder)) {
+      report.unusedPlaceholders.push(placeholder);
+    }
+  }
+  return report;
+}
+async function replaceStandardsWithSpinner(claudePath, config) {
+  const spinner2 = (0, import_ora3.default)("Applying standards configuration...").start();
+  try {
+    const report = await replaceStandardsPlaceholders(claudePath, config);
+    if (report.modifiedFiles.length > 0) {
+      spinner2.succeed(
+        `Applied ${report.replacedPlaceholders.length} standards to ${report.modifiedFiles.length} files`
+      );
+    } else {
+      spinner2.info("No standards placeholders found to replace");
+    }
+    return report;
+  } catch (error) {
+    spinner2.fail("Failed to apply standards configuration");
+    throw error;
+  }
+}
+async function previewStandardsReplacements(claudePath, config) {
+  const replacements = flattenStandardsConfig(config);
+  const standardsDir = path7.join(claudePath, "docs", "standards");
+  const files = await getAllFiles3(standardsDir);
+  const preview = [];
+  for (const file of files) {
+    try {
+      const content = await fs6.readFile(file, "utf-8");
+      for (const [placeholder, value] of Object.entries(replacements)) {
+        if (content.includes(placeholder)) {
+          preview.push({
+            file: path7.relative(claudePath, file),
+            placeholder,
+            value
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  return preview;
+}
+function formatStandardsReport(report) {
+  const lines = [];
+  lines.push("Standards Configuration Applied");
+  lines.push("\u2500".repeat(40));
+  lines.push(`Files modified: ${report.modifiedFiles.length}`);
+  lines.push(`Placeholders replaced: ${report.replacedPlaceholders.length}`);
+  if (report.modifiedFiles.length > 0) {
+    lines.push("");
+    lines.push("Modified files:");
+    for (const file of report.modifiedFiles) {
+      lines.push(`  \u2713 ${file}`);
+    }
+  }
+  if (report.unusedPlaceholders.length > 0) {
+    lines.push("");
+    lines.push("Unused placeholders (no matching templates):");
+    for (const p of report.unusedPlaceholders.slice(0, 5)) {
+      lines.push(`  - ${p}`);
+    }
+    if (report.unusedPlaceholders.length > 5) {
+      lines.push(`  ... and ${report.unusedPlaceholders.length - 5} more`);
+    }
+  }
+  if (report.errors.length > 0) {
+    lines.push("");
+    lines.push("Errors:");
+    for (const error of report.errors) {
+      lines.push(`  \u2717 ${error}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/lib/standards/scanner.ts
+init_cjs_shims();
+var fs7 = __toESM(require("fs/promises"), 1);
+var path8 = __toESM(require("path"), 1);
+var SCANNABLE_EXTENSIONS2 = [".md", ".json", ".yaml", ".yml", ".txt"];
+var PLACEHOLDER_PATTERN = /\{\{([A-Z_]+)\}\}/g;
+async function getScanableFiles(dir) {
+  const files = [];
+  try {
+    const entries = await fs7.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path8.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        const subFiles = await getScanableFiles(fullPath);
+        files.push(...subFiles);
+      } else if (entry.isFile()) {
+        const ext = path8.extname(entry.name).toLowerCase();
+        if (SCANNABLE_EXTENSIONS2.includes(ext)) {
+          files.push(fullPath);
+        }
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+function extractPlaceholders2(content) {
+  const matches = content.match(PLACEHOLDER_PATTERN);
+  return matches ? [...new Set(matches)] : [];
+}
+async function scanStandardsPlaceholders(claudePath, config) {
+  const standardsDir = path8.join(claudePath, "docs", "standards");
+  const files = await getScanableFiles(standardsDir);
+  const placeholdersByFile = /* @__PURE__ */ new Map();
+  const allPlaceholders = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    try {
+      const content = await fs7.readFile(file, "utf-8");
+      const placeholders = extractPlaceholders2(content);
+      if (placeholders.length > 0) {
+        const relPath = path8.relative(claudePath, file);
+        placeholdersByFile.set(relPath, placeholders);
+        for (const p of placeholders) {
+          allPlaceholders.add(p);
+        }
+      }
+    } catch {
+    }
+  }
+  const configuredPlaceholders = config ? new Set(Object.keys(flattenStandardsConfig(config))) : /* @__PURE__ */ new Set();
+  const unconfigured = /* @__PURE__ */ new Map();
+  for (const placeholder of allPlaceholders) {
+    if (!configuredPlaceholders.has(placeholder)) {
+      const filesWithPlaceholder = [];
+      for (const [file, placeholders] of placeholdersByFile) {
+        if (placeholders.includes(placeholder)) {
+          filesWithPlaceholder.push(file);
+        }
+      }
+      unconfigured.set(placeholder, filesWithPlaceholder);
+    }
+  }
+  return {
+    unconfiguredPlaceholders: Array.from(unconfigured.entries()).map(([placeholder, files2]) => ({
+      placeholder,
+      files: files2
+    })),
+    totalPlaceholders: allPlaceholders.size,
+    configuredPlaceholders: configuredPlaceholders.size
+  };
+}
+function formatScanResult(result) {
+  const lines = [];
+  lines.push("Standards Placeholder Scan");
+  lines.push("\u2500".repeat(40));
+  lines.push(`Total placeholders found: ${result.totalPlaceholders}`);
+  lines.push(`Already configured: ${result.configuredPlaceholders}`);
+  lines.push(`Unconfigured: ${result.unconfiguredPlaceholders.length}`);
+  if (result.unconfiguredPlaceholders.length > 0) {
+    lines.push("");
+    lines.push("Unconfigured placeholders:");
+    for (const { placeholder, files } of result.unconfiguredPlaceholders) {
+      lines.push(`  ${placeholder}`);
+      for (const file of files.slice(0, 3)) {
+        lines.push(`    \u2514\u2500 ${file}`);
+      }
+      if (files.length > 3) {
+        lines.push(`    \u2514\u2500 ... and ${files.length - 3} more files`);
+      }
+    }
+  } else {
+    lines.push("");
+    lines.push("\u2713 All placeholders are configured!");
+  }
+  return lines.join("\n");
+}
+
+// src/lib/standards/template-sync.ts
+init_cjs_shims();
+var fs8 = __toESM(require("fs/promises"), 1);
+var path9 = __toESM(require("path"), 1);
+var import_ora4 = __toESM(require("ora"), 1);
+var STANDARDS_TEMPLATES = [
+  "code-standards.md",
+  "testing-standards.md",
+  "documentation-standards.md",
+  "design-standards.md",
+  "security-standards.md",
+  "performance-standards.md"
+];
+async function fileExists2(filePath) {
+  try {
+    await fs8.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function createBackup(filePath) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backupPath = `${filePath}.backup-${timestamp}`;
+  await fs8.copyFile(filePath, backupPath);
+  return backupPath;
+}
+async function hasPlaceholders(filePath) {
+  try {
+    const content = await fs8.readFile(filePath, "utf-8");
+    return content.includes("AUTO-GENERATED: Configured values") || /\{\{[A-Z_]+\}\}/.test(content);
+  } catch {
+    return false;
+  }
+}
+async function syncTemplate(templateName, sourcePath, targetPath, options) {
+  const sourceFile = path9.join(sourcePath, templateName);
+  const targetFile = path9.join(targetPath, templateName);
+  if (!await fileExists2(sourceFile)) {
+    return { status: "skipped" };
+  }
+  const targetExists = await fileExists2(targetFile);
+  if (targetExists) {
+    const alreadyHasPlaceholders = await hasPlaceholders(targetFile);
+    if (alreadyHasPlaceholders && !options.overwrite) {
+      return { status: "skipped" };
+    }
+    let backupPath;
+    if (options.backup) {
+      backupPath = await createBackup(targetFile);
+    }
+    await fs8.copyFile(sourceFile, targetFile);
+    return { status: "updated", backup: backupPath };
+  }
+  await fs8.mkdir(path9.dirname(targetFile), { recursive: true });
+  await fs8.copyFile(sourceFile, targetFile);
+  return { status: "created" };
+}
+async function syncStandardsTemplates(claudePath, options = {}) {
+  const result = {
+    created: [],
+    updated: [],
+    skipped: [],
+    errors: []
+  };
+  const packagesTemplatesPath = path9.join(getTemplatesPath(), "docs", "standards");
+  const projectTemplatesPath = path9.join(claudePath, "docs", "standards");
+  await fs8.mkdir(projectTemplatesPath, { recursive: true });
+  for (const template of STANDARDS_TEMPLATES) {
+    try {
+      const syncResult = await syncTemplate(
+        template,
+        packagesTemplatesPath,
+        projectTemplatesPath,
+        options
+      );
+      switch (syncResult.status) {
+        case "created":
+          result.created.push(template);
+          break;
+        case "updated":
+          result.updated.push(template);
+          break;
+        case "skipped":
+          result.skipped.push(template);
+          break;
+      }
+    } catch (error) {
+      result.errors.push(`${template}: ${String(error)}`);
+    }
+  }
+  return result;
+}
+async function syncStandardsTemplatesWithSpinner(claudePath, options = {}) {
+  const spinner2 = (0, import_ora4.default)("Syncing standards templates...").start();
+  try {
+    const result = await syncStandardsTemplates(claudePath, options);
+    const total = result.created.length + result.updated.length;
+    if (total > 0) {
+      spinner2.succeed(
+        `Synced ${total} template${total !== 1 ? "s" : ""} (${result.created.length} created, ${result.updated.length} updated)`
+      );
+    } else if (result.skipped.length > 0) {
+      spinner2.info("All templates already up to date");
+    } else {
+      spinner2.warn("No templates to sync");
+    }
+    return result;
+  } catch (error) {
+    spinner2.fail("Failed to sync templates");
+    throw error;
+  }
+}
+async function checkTemplatesNeedUpdate(claudePath) {
+  const projectTemplatesPath = path9.join(claudePath, "docs", "standards");
+  const missing = [];
+  const outdated = [];
+  for (const template of STANDARDS_TEMPLATES) {
+    const targetFile = path9.join(projectTemplatesPath, template);
+    if (!await fileExists2(targetFile)) {
+      missing.push(template);
+    } else if (!await hasPlaceholders(targetFile)) {
+      outdated.push(template);
+    }
+  }
+  return {
+    needsUpdate: missing.length > 0 || outdated.length > 0,
+    missing,
+    outdated
+  };
+}
+function formatSyncResult(result) {
+  const lines = [];
+  lines.push("Template Sync Results");
+  lines.push("\u2500".repeat(40));
+  if (result.created.length > 0) {
+    lines.push(`Created: ${result.created.length}`);
+    for (const f of result.created) {
+      lines.push(`  \u2713 ${f}`);
+    }
+  }
+  if (result.updated.length > 0) {
+    lines.push(`Updated: ${result.updated.length}`);
+    for (const f of result.updated) {
+      lines.push(`  \u2713 ${f}`);
+    }
+  }
+  if (result.skipped.length > 0) {
+    lines.push(`Skipped (already up to date): ${result.skipped.length}`);
+  }
+  if (result.errors.length > 0) {
+    lines.push(`Errors: ${result.errors.length}`);
+    for (const e of result.errors) {
+      lines.push(`  \u2717 ${e}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/cli/commands/standards.ts
+init_fs();
+
+// src/cli/prompts/standards.ts
+init_cjs_shims();
+async function promptStandardsConfig(options) {
+  logger.section("Project Standards", "\u{1F4D0}");
+  logger.info("Configure quality standards for your project");
+  logger.newline();
+  if (options?.category) {
+    const existingConfig = options.defaults ?? DEFAULT_STANDARDS_CONFIG;
+    const categoryConfig = await promptCategoryConfig(options.category, existingConfig);
+    return {
+      ...existingConfig,
+      [options.category]: categoryConfig
+    };
+  }
+  const enableStandards = await confirm({
+    message: "Would you like to configure project standards?",
+    default: true
+  });
+  if (!enableStandards) {
+    return DEFAULT_STANDARDS_CONFIG;
+  }
+  const preset = await promptStandardsPreset();
+  if (preset !== "custom") {
+    const presetConfig = STANDARDS_PRESETS[preset];
+    logger.success(`Using "${presetConfig.name}" preset`);
+    return presetConfig.config;
+  }
+  logger.newline();
+  logger.info("Configure each standards category:");
+  const codeConfig = await promptCodeStandards(options?.defaults?.code);
+  const testingConfig = await promptTestingStandards(options?.defaults?.testing);
+  const documentationConfig = await promptDocumentationStandards(options?.defaults?.documentation);
+  const designConfig = await promptDesignStandards(options?.defaults?.design);
+  const securityConfig = await promptSecurityStandards(options?.defaults?.security);
+  const performanceConfig = await promptPerformanceStandards(options?.defaults?.performance);
+  return {
+    code: codeConfig,
+    testing: testingConfig,
+    documentation: documentationConfig,
+    design: designConfig,
+    security: securityConfig,
+    performance: performanceConfig
+  };
+}
+async function promptStandardsPreset() {
+  return select({
+    message: "Choose a standards preset:",
+    choices: Object.entries(STANDARDS_PRESETS).map(([key, preset]) => ({
+      name: `${preset.name} - ${preset.description}`,
+      value: key
+    })),
+    default: "balanced"
+  });
+}
+async function promptCategoryConfig(category, existingConfig) {
+  switch (category) {
+    case "code":
+      return promptCodeStandards(existingConfig.code);
+    case "testing":
+      return promptTestingStandards(existingConfig.testing);
+    case "documentation":
+      return promptDocumentationStandards(existingConfig.documentation);
+    case "design":
+      return promptDesignStandards(existingConfig.design);
+    case "security":
+      return promptSecurityStandards(existingConfig.security);
+    case "performance":
+      return promptPerformanceStandards(existingConfig.performance);
+  }
+}
+async function promptCodeStandards(defaults) {
+  const def = STANDARDS_DEFINITIONS.code;
+  logger.newline();
+  logger.subtitle(`${def.icon} ${def.name}`);
+  const indentStyle = await select({
+    message: "Indent style:",
+    choices: [
+      { name: "Spaces", value: "space" },
+      { name: "Tabs", value: "tab" }
+    ],
+    default: defaults?.indentStyle ?? DEFAULT_STANDARDS_CONFIG.code.indentStyle
+  });
+  const indentSize = await select({
+    message: "Indent size:",
+    choices: [
+      { name: "2 spaces", value: 2 },
+      { name: "4 spaces", value: 4 }
+    ],
+    default: defaults?.indentSize ?? DEFAULT_STANDARDS_CONFIG.code.indentSize
+  });
+  const maxLineLength = await select({
+    message: "Max line length:",
+    choices: [
+      { name: "80 characters", value: 80 },
+      { name: "100 characters", value: 100 },
+      { name: "120 characters", value: 120 }
+    ],
+    default: defaults?.maxLineLength ?? DEFAULT_STANDARDS_CONFIG.code.maxLineLength
+  });
+  const maxFileLines = await select({
+    message: "Max file lines:",
+    choices: [
+      { name: "300 lines (strict)", value: 300 },
+      { name: "500 lines (standard)", value: 500 },
+      { name: "800 lines (relaxed)", value: 800 }
+    ],
+    default: defaults?.maxFileLines ?? DEFAULT_STANDARDS_CONFIG.code.maxFileLines
+  });
+  const quoteStyle = await select({
+    message: "Quote style:",
+    choices: [
+      { name: "Single quotes", value: "single" },
+      { name: "Double quotes", value: "double" }
+    ],
+    default: defaults?.quoteStyle ?? DEFAULT_STANDARDS_CONFIG.code.quoteStyle
+  });
+  const semicolons = await confirm({
+    message: "Use semicolons?",
+    default: defaults?.semicolons ?? DEFAULT_STANDARDS_CONFIG.code.semicolons
+  });
+  const trailingCommas = await select({
+    message: "Trailing commas:",
+    choices: [
+      { name: "ES5 (recommended)", value: "es5" },
+      { name: "All", value: "all" },
+      { name: "None", value: "none" }
+    ],
+    default: defaults?.trailingCommas ?? DEFAULT_STANDARDS_CONFIG.code.trailingCommas
+  });
+  const allowAny = await confirm({
+    message: 'Allow "any" type in TypeScript?',
+    default: defaults?.allowAny ?? DEFAULT_STANDARDS_CONFIG.code.allowAny
+  });
+  const namedExportsOnly = await confirm({
+    message: "Require named exports only (no default exports)?",
+    default: defaults?.namedExportsOnly ?? DEFAULT_STANDARDS_CONFIG.code.namedExportsOnly
+  });
+  const roroPattern = await confirm({
+    message: "Require RO-RO pattern (Receive Object, Return Object)?",
+    default: defaults?.roroPattern ?? DEFAULT_STANDARDS_CONFIG.code.roroPattern
+  });
+  const jsDocRequired = await confirm({
+    message: "Require JSDoc for all exports?",
+    default: defaults?.jsDocRequired ?? DEFAULT_STANDARDS_CONFIG.code.jsDocRequired
+  });
+  return {
+    indentStyle,
+    indentSize,
+    maxLineLength,
+    maxFileLines,
+    quoteStyle,
+    semicolons,
+    trailingCommas,
+    allowAny,
+    namedExportsOnly,
+    roroPattern,
+    jsDocRequired
+  };
+}
+async function promptTestingStandards(defaults) {
+  const def = STANDARDS_DEFINITIONS.testing;
+  logger.newline();
+  logger.subtitle(`${def.icon} ${def.name}`);
+  const coverageTarget = await select({
+    message: "Minimum code coverage:",
+    choices: [
+      { name: "60% (startup)", value: 60 },
+      { name: "70% (relaxed)", value: 70 },
+      { name: "80% (standard)", value: 80 },
+      { name: "90% (strict)", value: 90 },
+      { name: "95% (enterprise)", value: 95 }
+    ],
+    default: defaults?.coverageTarget ?? DEFAULT_STANDARDS_CONFIG.testing.coverageTarget
+  });
+  const tddRequired = await confirm({
+    message: "Require TDD methodology (Red-Green-Refactor)?",
+    default: defaults?.tddRequired ?? DEFAULT_STANDARDS_CONFIG.testing.tddRequired
+  });
+  const testPattern = await select({
+    message: "Test pattern:",
+    choices: [
+      { name: "AAA (Arrange-Act-Assert)", value: "aaa" },
+      { name: "GWT (Given-When-Then)", value: "gwt" }
+    ],
+    default: defaults?.testPattern ?? DEFAULT_STANDARDS_CONFIG.testing.testPattern
+  });
+  const testLocation = await select({
+    message: "Test file location:",
+    choices: [
+      { name: "Separate (test/ folder)", value: "separate" },
+      { name: "Colocated (__tests__ near source)", value: "colocated" }
+    ],
+    default: defaults?.testLocation ?? DEFAULT_STANDARDS_CONFIG.testing.testLocation
+  });
+  const unitTestMaxMs = await select({
+    message: "Max time per unit test:",
+    choices: [
+      { name: "50ms (fast)", value: 50 },
+      { name: "100ms (standard)", value: 100 },
+      { name: "200ms (relaxed)", value: 200 }
+    ],
+    default: defaults?.unitTestMaxMs ?? DEFAULT_STANDARDS_CONFIG.testing.unitTestMaxMs
+  });
+  const integrationTestMaxMs = await select({
+    message: "Max time per integration test:",
+    choices: [
+      { name: "500ms (fast)", value: 500 },
+      { name: "1000ms (standard)", value: 1e3 },
+      { name: "2000ms (relaxed)", value: 2e3 }
+    ],
+    default: defaults?.integrationTestMaxMs ?? DEFAULT_STANDARDS_CONFIG.testing.integrationTestMaxMs
+  });
+  return {
+    coverageTarget,
+    tddRequired,
+    testPattern,
+    testLocation,
+    unitTestMaxMs,
+    integrationTestMaxMs
+  };
+}
+async function promptDocumentationStandards(defaults) {
+  const def = STANDARDS_DEFINITIONS.documentation;
+  logger.newline();
+  logger.subtitle(`${def.icon} ${def.name}`);
+  const jsDocLevel = await select({
+    message: "JSDoc detail level:",
+    choices: [
+      { name: "Minimal (brief description)", value: "minimal" },
+      { name: "Standard (description + params + returns)", value: "standard" },
+      { name: "Comprehensive (full docs with examples)", value: "comprehensive" }
+    ],
+    default: defaults?.jsDocLevel ?? DEFAULT_STANDARDS_CONFIG.documentation.jsDocLevel
+  });
+  const requireExamples = await confirm({
+    message: "Require @example in JSDoc?",
+    default: defaults?.requireExamples ?? DEFAULT_STANDARDS_CONFIG.documentation.requireExamples
+  });
+  const changelogFormat = await select({
+    message: "Changelog format:",
+    choices: [
+      { name: "Conventional (auto-generated from commits)", value: "conventional" },
+      { name: "Keep a Changelog (manual, semantic)", value: "keepachangelog" }
+    ],
+    default: defaults?.changelogFormat ?? DEFAULT_STANDARDS_CONFIG.documentation.changelogFormat
+  });
+  const inlineCommentPolicy = await select({
+    message: "Inline comment policy:",
+    choices: [
+      { name: "Why not What (explain reasoning)", value: "why-not-what" },
+      { name: "Minimal (only when necessary)", value: "minimal" },
+      { name: "Extensive (comment thoroughly)", value: "extensive" }
+    ],
+    default: defaults?.inlineCommentPolicy ?? DEFAULT_STANDARDS_CONFIG.documentation.inlineCommentPolicy
+  });
+  return {
+    jsDocLevel,
+    requireExamples,
+    changelogFormat,
+    inlineCommentPolicy
+  };
+}
+async function promptDesignStandards(defaults) {
+  const def = STANDARDS_DEFINITIONS.design;
+  logger.newline();
+  logger.subtitle(`${def.icon} ${def.name}`);
+  const cssFramework = await select({
+    message: "CSS framework:",
+    choices: [
+      { name: "Tailwind CSS", value: "tailwind" },
+      { name: "CSS Modules", value: "css-modules" },
+      { name: "Styled Components", value: "styled-components" },
+      { name: "Vanilla CSS", value: "vanilla" }
+    ],
+    default: defaults?.cssFramework ?? DEFAULT_STANDARDS_CONFIG.design.cssFramework
+  });
+  const componentLibrary = await select({
+    message: "Component library:",
+    choices: [
+      { name: "shadcn/ui", value: "shadcn" },
+      { name: "Radix UI", value: "radix" },
+      { name: "Headless UI", value: "headless" },
+      { name: "None", value: "none" }
+    ],
+    default: defaults?.componentLibrary ?? DEFAULT_STANDARDS_CONFIG.design.componentLibrary
+  });
+  const accessibilityLevel = await select({
+    message: "WCAG accessibility level:",
+    choices: [
+      { name: "Level A (minimum)", value: "A" },
+      { name: "Level AA (recommended)", value: "AA" },
+      { name: "Level AAA (highest)", value: "AAA" }
+    ],
+    default: defaults?.accessibilityLevel ?? DEFAULT_STANDARDS_CONFIG.design.accessibilityLevel
+  });
+  const darkModeSupport = await confirm({
+    message: "Support dark mode?",
+    default: defaults?.darkModeSupport ?? DEFAULT_STANDARDS_CONFIG.design.darkModeSupport
+  });
+  return {
+    cssFramework,
+    componentLibrary,
+    accessibilityLevel,
+    darkModeSupport
+  };
+}
+async function promptSecurityStandards(defaults) {
+  const def = STANDARDS_DEFINITIONS.security;
+  logger.newline();
+  logger.subtitle(`${def.icon} ${def.name}`);
+  const authPattern = await select({
+    message: "Authentication pattern:",
+    choices: [
+      { name: "JWT (JSON Web Tokens)", value: "jwt" },
+      { name: "Session (server-side)", value: "session" },
+      { name: "OAuth 2.0 / OIDC", value: "oauth" },
+      { name: "None", value: "none" }
+    ],
+    default: defaults?.authPattern ?? DEFAULT_STANDARDS_CONFIG.security.authPattern
+  });
+  const inputValidation = await select({
+    message: "Input validation library:",
+    choices: [
+      { name: "Zod (TypeScript-first)", value: "zod" },
+      { name: "Yup (schema builder)", value: "yup" },
+      { name: "Joi (data validation)", value: "joi" },
+      { name: "Manual (custom)", value: "manual" }
+    ],
+    default: defaults?.inputValidation ?? DEFAULT_STANDARDS_CONFIG.security.inputValidation
+  });
+  const csrfProtection = await confirm({
+    message: "Enable CSRF protection?",
+    default: defaults?.csrfProtection ?? DEFAULT_STANDARDS_CONFIG.security.csrfProtection
+  });
+  const rateLimiting = await confirm({
+    message: "Enable rate limiting?",
+    default: defaults?.rateLimiting ?? DEFAULT_STANDARDS_CONFIG.security.rateLimiting
+  });
+  return {
+    authPattern,
+    inputValidation,
+    csrfProtection,
+    rateLimiting
+  };
+}
+async function promptPerformanceStandards(defaults) {
+  const def = STANDARDS_DEFINITIONS.performance;
+  logger.newline();
+  logger.subtitle(`${def.icon} ${def.name}`);
+  const lcpTarget = await select({
+    message: "LCP target (Largest Contentful Paint):",
+    choices: [
+      { name: "1500ms (excellent)", value: 1500 },
+      { name: "2000ms (good)", value: 2e3 },
+      { name: "2500ms (standard)", value: 2500 },
+      { name: "4000ms (needs improvement)", value: 4e3 }
+    ],
+    default: defaults?.lcpTarget ?? DEFAULT_STANDARDS_CONFIG.performance.lcpTarget
+  });
+  const fidTarget = await select({
+    message: "FID target (First Input Delay):",
+    choices: [
+      { name: "50ms (excellent)", value: 50 },
+      { name: "100ms (good)", value: 100 },
+      { name: "200ms (standard)", value: 200 },
+      { name: "300ms (needs improvement)", value: 300 }
+    ],
+    default: defaults?.fidTarget ?? DEFAULT_STANDARDS_CONFIG.performance.fidTarget
+  });
+  const clsTarget = await select({
+    message: "CLS target (Cumulative Layout Shift):",
+    choices: [
+      { name: "0.05 (excellent)", value: 0.05 },
+      { name: "0.1 (good)", value: 0.1 },
+      { name: "0.15 (standard)", value: 0.15 },
+      { name: "0.25 (needs improvement)", value: 0.25 }
+    ],
+    default: defaults?.clsTarget ?? DEFAULT_STANDARDS_CONFIG.performance.clsTarget
+  });
+  const bundleSizeTargetKb = await select({
+    message: "Bundle size target (KB):",
+    choices: [
+      { name: "100KB (strict)", value: 100 },
+      { name: "150KB (good)", value: 150 },
+      { name: "250KB (standard)", value: 250 },
+      { name: "500KB (relaxed)", value: 500 }
+    ],
+    default: defaults?.bundleSizeTargetKb ?? DEFAULT_STANDARDS_CONFIG.performance.bundleSizeTargetKb
+  });
+  const apiResponseTargetMs = await select({
+    message: "API response time target (ms):",
+    choices: [
+      { name: "100ms (fast)", value: 100 },
+      { name: "200ms (good)", value: 200 },
+      { name: "300ms (standard)", value: 300 },
+      { name: "500ms (relaxed)", value: 500 }
+    ],
+    default: defaults?.apiResponseTargetMs ?? DEFAULT_STANDARDS_CONFIG.performance.apiResponseTargetMs
+  });
+  return {
+    lcpTarget,
+    fidTarget,
+    clsTarget,
+    bundleSizeTargetKb,
+    apiResponseTargetMs
+  };
+}
+function showStandardsSummary(config) {
+  logger.newline();
+  logger.subtitle("Standards Summary");
+  logger.item(
+    `Code: ${config.code.indentSize} ${config.code.indentStyle}s, ${config.code.quoteStyle} quotes`
+  );
+  logger.info(
+    colors.muted(
+      `  Max: ${config.code.maxLineLength} chars/line, ${config.code.maxFileLines} lines/file`
+    )
+  );
+  logger.info(
+    colors.muted(
+      `  Rules: ${config.code.allowAny ? "any allowed" : "no any"}, ${config.code.namedExportsOnly ? "named exports" : "default exports"}`
+    )
+  );
+  logger.item(
+    `Testing: ${config.testing.coverageTarget}% coverage, ${config.testing.tddRequired ? "TDD required" : "TDD optional"}`
+  );
+  logger.info(
+    colors.muted(
+      `  Pattern: ${config.testing.testPattern.toUpperCase()}, Location: ${config.testing.testLocation}`
+    )
+  );
+  logger.item(`Documentation: ${config.documentation.jsDocLevel} JSDoc`);
+  logger.info(colors.muted(`  Comments: ${config.documentation.inlineCommentPolicy}`));
+  logger.item(`Design: ${config.design.cssFramework}, ${config.design.componentLibrary}`);
+  logger.info(
+    colors.muted(
+      `  A11y: WCAG ${config.design.accessibilityLevel}, ${config.design.darkModeSupport ? "dark mode" : "no dark mode"}`
+    )
+  );
+  logger.item(`Security: ${config.security.authPattern}, ${config.security.inputValidation}`);
+  logger.info(
+    colors.muted(
+      `  ${config.security.csrfProtection ? "CSRF" : "no CSRF"}, ${config.security.rateLimiting ? "rate limiting" : "no rate limiting"}`
+    )
+  );
+  logger.item(
+    `Performance: LCP ${config.performance.lcpTarget}ms, FID ${config.performance.fidTarget}ms`
+  );
+  logger.info(
+    colors.muted(
+      `  Bundle: ${config.performance.bundleSizeTargetKb}KB, API: ${config.performance.apiResponseTargetMs}ms`
+    )
+  );
+}
+async function confirmStandardsConfig(config) {
+  showStandardsSummary(config);
+  logger.newline();
+  return confirm({
+    message: "Apply these standards?",
+    default: true
+  });
+}
+
+// src/cli/commands/standards.ts
+function createStandardsCommand() {
+  const cmd = new import_commander8.Command("standards").description("Configure project standards interactively").argument("[path]", "Project path (default: current directory)").option("--scan", "Scan for unconfigured standard placeholders").option(
+    "-c, --category <name>",
+    "Configure specific category (code|testing|documentation|design|security|performance)"
+  ).option("--preview", "Preview changes without applying").option("-y, --yes", "Accept defaults without prompts").option("-v, --verbose", "Detailed output").option("--update-templates", "Update/sync templates from package to project").action(runStandards);
+  return cmd;
+}
+async function runStandards(path10, options) {
+  const projectPath = resolvePath(path10 || ".");
+  const claudePath = joinPath(projectPath, ".claude");
+  logger.configure({ verbose: options.verbose, silent: false });
+  logger.title("Project Standards Configuration");
+  try {
+    if (options.scan) {
+      await scanMode2(claudePath, projectPath);
+      return;
+    }
+    if (options.updateTemplates) {
+      await updateTemplatesMode(claudePath, options);
+      return;
+    }
+    if (options.preview) {
+      await previewMode2(claudePath, projectPath);
+      return;
+    }
+    if (options.yes) {
+      await defaultsMode(claudePath, projectPath, options);
+      return;
+    }
+    await interactiveMode2(claudePath, projectPath, options);
+  } catch (error) {
+    logger.error(
+      `Standards configuration failed: ${error instanceof Error ? error.message : error}`
+    );
+    process.exit(1);
+  }
+}
+async function scanMode2(claudePath, projectPath) {
+  logger.info(`Scanning ${colors.primary(claudePath)} for standard placeholders...`);
+  logger.newline();
+  const existingConfig = await readConfig(projectPath);
+  const standardsConfig = existingConfig?.extras?.standards;
+  const scanResult = await scanStandardsPlaceholders(claudePath, standardsConfig);
+  logger.info(formatScanResult(scanResult));
+  if (scanResult.unconfiguredPlaceholders.length > 0) {
+    logger.newline();
+    logger.info("Run `claude-config standards` to configure them");
+  }
+}
+async function updateTemplatesMode(claudePath, options) {
+  logger.info("Checking for template updates...");
+  logger.newline();
+  const status = await checkTemplatesNeedUpdate(claudePath);
+  if (!status.needsUpdate) {
+    logger.success("All templates are up to date!");
+    return;
+  }
+  if (status.missing.length > 0) {
+    logger.info(`Missing templates (${status.missing.length}):`);
+    for (const template of status.missing) {
+      logger.info(`  ${colors.warning("+")} ${template}`);
+    }
+    logger.newline();
+  }
+  if (status.outdated.length > 0) {
+    logger.info(`Outdated templates (${status.outdated.length}):`);
+    for (const template of status.outdated) {
+      logger.info(`  ${colors.primary("~")} ${template}`);
+    }
+    logger.newline();
+  }
+  const result = await syncStandardsTemplatesWithSpinner(claudePath, {
+    overwrite: true,
+    backup: true
+  });
+  if (options.verbose) {
+    logger.newline();
+    logger.info(formatSyncResult(result));
+  }
+  logger.newline();
+  logger.success("Templates updated successfully!");
+  logger.info("Run `claude-config standards` to configure the new placeholders");
+}
+async function previewMode2(claudePath, projectPath) {
+  const existingConfig = await readConfig(projectPath);
+  if (!existingConfig?.extras?.standards) {
+    logger.warn("No standards configuration found");
+    logger.info("Run `claude-config standards` first to set up configuration");
+    return;
+  }
+  logger.info("Preview of replacements:");
+  logger.newline();
+  const replacements = await previewStandardsReplacements(
+    claudePath,
+    existingConfig.extras.standards
+  );
+  if (replacements.length === 0) {
+    logger.info("No standard placeholders to replace");
+    return;
+  }
+  const byFile = {};
+  for (const r of replacements) {
+    if (!byFile[r.file]) {
+      byFile[r.file] = [];
+    }
+    byFile[r.file].push({ placeholder: r.placeholder, value: r.value });
+  }
+  for (const [file, changes] of Object.entries(byFile)) {
+    logger.subtitle(file);
+    for (const change of changes) {
+      logger.info(`  ${change.placeholder} \u2192 ${colors.primary(change.value)}`);
+    }
+    logger.newline();
+  }
+  logger.success(
+    `Total: ${replacements.length} replacements in ${Object.keys(byFile).length} files`
+  );
+}
+async function defaultsMode(claudePath, projectPath, options) {
+  const templateStatus = await checkTemplatesNeedUpdate(claudePath);
+  if (templateStatus.needsUpdate) {
+    logger.warn("Some templates are missing or outdated:");
+    if (templateStatus.missing.length > 0) {
+      logger.info(`  Missing: ${templateStatus.missing.length} template(s)`);
+    }
+    if (templateStatus.outdated.length > 0) {
+      logger.info(`  Outdated: ${templateStatus.outdated.length} template(s)`);
+    }
+    logger.newline();
+    logger.info(
+      `Run ${colors.primary("qazuor-claude-config standards --update-templates")} first to sync templates`
+    );
+    logger.newline();
+  }
+  logger.info("Applying default standards configuration...");
+  logger.newline();
+  const standardsConfig = DEFAULT_STANDARDS_CONFIG;
+  showStandardsSummary(standardsConfig);
+  logger.newline();
+  const report = await replaceStandardsWithSpinner(claudePath, standardsConfig);
+  if (options.verbose) {
+    logger.newline();
+    logger.info(formatStandardsReport(report));
+  }
+  if (report.modifiedFiles.length === 0 && report.unusedPlaceholders.length > 0) {
+    logger.newline();
+    logger.warn("No placeholders were replaced in templates.");
+    logger.info(
+      `Your templates might be outdated. Run ${colors.primary("--update-templates")} to sync them.`
+    );
+  }
+  await saveStandardsConfig(projectPath, standardsConfig);
+  logger.newline();
+  logger.success("Standards configuration complete!");
+}
+async function interactiveMode2(claudePath, projectPath, options) {
+  const templateStatus = await checkTemplatesNeedUpdate(claudePath);
+  if (templateStatus.needsUpdate) {
+    logger.warn("Some templates are missing or outdated:");
+    if (templateStatus.missing.length > 0) {
+      logger.info(`  Missing: ${templateStatus.missing.length} template(s)`);
+    }
+    if (templateStatus.outdated.length > 0) {
+      logger.info(`  Outdated: ${templateStatus.outdated.length} template(s)`);
+    }
+    logger.newline();
+    logger.info(
+      `Run ${colors.primary("qazuor-claude-config standards --update-templates")} first to sync templates`
+    );
+    logger.newline();
+  }
+  const existingConfig = await readConfig(projectPath);
+  const existingStandards = existingConfig?.extras?.standards;
+  const standardsConfig = await promptStandardsConfig({
+    defaults: existingStandards,
+    category: options.category
+  });
+  const confirmed = await confirmStandardsConfig(standardsConfig);
+  if (!confirmed) {
+    logger.warn("Configuration cancelled");
+    return;
+  }
+  const report = await replaceStandardsWithSpinner(claudePath, standardsConfig);
+  if (options.verbose) {
+    logger.newline();
+    logger.info(formatStandardsReport(report));
+  }
+  if (report.modifiedFiles.length === 0 && report.unusedPlaceholders.length > 0) {
+    logger.newline();
+    logger.warn("No placeholders were replaced in templates.");
+    logger.info(
+      `Your templates might be outdated. Run ${colors.primary("--update-templates")} to sync them.`
+    );
+  }
+  await saveStandardsConfig(projectPath, standardsConfig);
+  logger.newline();
+  logger.success("Standards configuration complete!");
+}
+async function saveStandardsConfig(projectPath, standardsConfig) {
+  const existingConfig = await readConfig(projectPath);
+  if (existingConfig) {
+    existingConfig.extras = {
+      ...existingConfig.extras,
+      standards: standardsConfig
+    };
+    existingConfig.customizations.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+    await writeConfig(projectPath, existingConfig);
+    logger.success("Configuration saved to .claude/qazuor-claude-config.json");
+  } else {
+    logger.warn("No existing config found - standards not saved");
+    logger.info("Run `claude-config init` first to initialize the project");
+  }
+}
+
 // src/cli/index.ts
 var VERSION2 = "0.1.0";
-var program = new import_commander8.Command().name("qazuor-claude-config").description("CLI tool to install and manage Claude Code configurations").version(VERSION2);
+var program = new import_commander9.Command().name("qazuor-claude-config").description("CLI tool to install and manage Claude Code configurations").version(VERSION2);
 program.addCommand(createInitCommand());
 program.addCommand(createListCommand());
 program.addCommand(createAddCommand());
@@ -13308,6 +15470,7 @@ program.addCommand(createRemoveCommand());
 program.addCommand(createStatusCommand());
 program.addCommand(createUpdateCommand());
 program.addCommand(createConfigureCommand());
+program.addCommand(createStandardsCommand());
 
 // src/lib/utils/banner.ts
 init_cjs_shims();