lynxprompt 1.2.12 → 1.2.14

package/dist/index.js

@@ -1545,6 +1545,251 @@ var JS_TOOL_PATTERNS = {
   webpack: ["webpack"],
   turbo: ["turbo"]
 };
+async function detectExtendedCommands(cwd) {
+  const cmds = {
+    test: [],
+    testCoverage: [],
+    install: [],
+    dev: [],
+    build: [],
+    lint: [],
+    format: [],
+    typecheck: [],
+    clean: [],
+    preCommit: [],
+    additional: []
+  };
+  const addCmd = (category, cmd, desc) => {
+    if (!cmds[category].some((c) => c.cmd === cmd)) {
+      cmds[category].push({ cmd, desc });
+    }
+  };
+  const packageJsonPath = join3(cwd, "package.json");
+  if (await fileExists(packageJsonPath)) {
+    try {
+      const content = await readFile3(packageJsonPath, "utf-8");
+      const pkg = JSON.parse(content);
+      if (pkg.scripts) {
+        for (const [name, script] of Object.entries(pkg.scripts)) {
+          const scriptStr = String(script);
+          const fullCmd = `npm run ${name}`;
+          if (name.match(/^test$|^test:/i) || scriptStr.includes("jest") || scriptStr.includes("vitest") || scriptStr.includes("mocha")) {
+            if (name.includes("cov") || scriptStr.includes("--coverage")) {
+              addCmd("testCoverage", fullCmd, `Run ${name}`);
+            } else {
+              addCmd("test", fullCmd, `Run ${name}`);
+            }
+          } else if (name.match(/^lint$|^lint:/i) || scriptStr.includes("eslint") || scriptStr.includes("biome")) {
+            addCmd("lint", fullCmd, `Run ${name}`);
+          } else if (name.match(/^format$|^fmt$|format:/i) || scriptStr.includes("prettier")) {
+            addCmd("format", fullCmd, `Run ${name}`);
+          } else if (name.match(/^build$|^build:/i) || scriptStr.includes("tsc") || scriptStr.includes("webpack") || scriptStr.includes("vite build")) {
+            addCmd("build", fullCmd, `Run ${name}`);
+          } else if (name.match(/^dev$|^start$|^serve$/i)) {
+            addCmd("dev", fullCmd, `Run ${name}`);
+          } else if (name.match(/^typecheck$|^type-check$|^types$|^check:types/i) || scriptStr.includes("tsc --noEmit")) {
+            addCmd("typecheck", fullCmd, `Run ${name}`);
+          } else if (name.match(/^clean$|^clean:/i) || scriptStr.includes("rimraf") || scriptStr.includes("rm -rf")) {
+            addCmd("clean", fullCmd, `Run ${name}`);
+          } else if (name.match(/^prepare$|^precommit$|^pre-commit$|^husky/i)) {
+            addCmd("preCommit", fullCmd, `Run ${name}`);
+          } else if (name === "install" || name === "postinstall") {
+            addCmd("install", fullCmd, `Run ${name}`);
+          } else if (!["publish", "prepublish", "prepublishOnly", "version", "postversion"].includes(name)) {
+            addCmd("additional", fullCmd, `Run ${name}`);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  const pyprojectPath = join3(cwd, "pyproject.toml");
+  if (await fileExists(pyprojectPath)) {
+    try {
+      const content = await readFile3(pyprojectPath, "utf-8");
+      if (content.includes("pytest") || content.includes("[tool.pytest")) {
+        addCmd("test", "python -m pytest tests/ -v --tb=short", "Run pytest");
+        addCmd("testCoverage", "python -m pytest tests/ --cov=src --cov-report=term-missing", "Run pytest with coverage");
+      }
+      if (content.includes("ruff")) {
+        addCmd("lint", "ruff check .", "Run ruff linter");
+        addCmd("format", "ruff format .", "Run ruff formatter");
+      }
+      if (content.includes("black")) {
+        addCmd("format", "black .", "Run black formatter");
+      }
+      if (content.includes("mypy")) {
+        addCmd("typecheck", "mypy .", "Run mypy type checker");
+      }
+      const poetryScriptsMatch = content.match(/\[tool\.poetry\.scripts\]([\s\S]*?)(?=\n\[|$)/);
+      if (poetryScriptsMatch) {
+        const scriptLines = poetryScriptsMatch[1].split("\n").filter((l) => l.includes("="));
+        for (const line of scriptLines) {
+          const match = line.match(/(\w+)\s*=\s*"([^"]+)"/);
+          if (match) {
+            const [, name, entry] = match;
+            addCmd("additional", `poetry run ${name}`, entry);
+          }
+        }
+      }
+      const poeMatch = content.match(/\[tool\.poe\.tasks\]([\s\S]*?)(?=\n\[tool\.|$)/);
+      if (poeMatch) {
+        const taskLines = poeMatch[1].split("\n").filter((l) => l.includes("="));
+        for (const line of taskLines) {
+          const match = line.match(/(\w+)\s*=\s*"([^"]+)"/);
+          if (match) {
+            const [, name, cmd] = match;
+            if (name.match(/test/i)) {
+              addCmd("test", `poe ${name}`, cmd);
+            } else if (name.match(/lint/i)) {
+              addCmd("lint", `poe ${name}`, cmd);
+            } else if (name.match(/format/i)) {
+              addCmd("format", `poe ${name}`, cmd);
+            } else {
+              addCmd("additional", `poe ${name}`, cmd);
+            }
+          }
+        }
+      }
+      if (content.includes("fastapi") || content.includes("uvicorn")) {
+        addCmd("dev", "uvicorn src.main:app --host 0.0.0.0 --port 8000 --reload", "Run FastAPI dev server");
+      }
+      if (content.includes("[tool.poetry]")) {
+        addCmd("install", "poetry install", "Install dependencies with Poetry");
+      } else if (await fileExists(join3(cwd, "uv.lock"))) {
+        addCmd("install", "uv sync", "Sync dependencies with uv");
+      } else {
+        addCmd("install", "pip install -r requirements.txt", "Install dependencies with pip");
+      }
+    } catch {
+    }
+  }
+  const requirementsPath = join3(cwd, "requirements.txt");
+  if (await fileExists(requirementsPath)) {
+    try {
+      const content = await readFile3(requirementsPath, "utf-8");
+      if (content.includes("pytest")) {
+        addCmd("test", "python -m pytest tests/ -v", "Run pytest");
+      }
+      addCmd("install", "pip install -r requirements.txt", "Install dependencies");
+    } catch {
+    }
+  }
+  const makefilePath = join3(cwd, "Makefile");
+  if (await fileExists(makefilePath)) {
+    try {
+      const content = await readFile3(makefilePath, "utf-8");
+      const targetMatches = content.matchAll(/^([a-zA-Z_][a-zA-Z0-9_-]*):\s*(?:[a-zA-Z0-9_\- ]*)?$/gm);
+      for (const match of targetMatches) {
+        const target = match[1];
+        const cmd = `make ${target}`;
+        if (target.match(/^test$|^tests$/i)) {
+          addCmd("test", cmd, `Make ${target}`);
+        } else if (target.match(/^test[-_]?cov|^coverage$/i)) {
+          addCmd("testCoverage", cmd, `Make ${target}`);
+        } else if (target.match(/^lint$/i)) {
+          addCmd("lint", cmd, `Make ${target}`);
+        } else if (target.match(/^format$|^fmt$/i)) {
+          addCmd("format", cmd, `Make ${target}`);
+        } else if (target.match(/^build$/i)) {
+          addCmd("build", cmd, `Make ${target}`);
+        } else if (target.match(/^dev$|^run$|^serve$/i)) {
+          addCmd("dev", cmd, `Make ${target}`);
+        } else if (target.match(/^typecheck$|^types$/i)) {
+          addCmd("typecheck", cmd, `Make ${target}`);
+        } else if (target.match(/^clean$/i)) {
+          addCmd("clean", cmd, `Make ${target}`);
+        } else if (target.match(/^install$|^deps$/i)) {
+          addCmd("install", cmd, `Make ${target}`);
+        } else if (!["all", "default", ".PHONY", ".DEFAULT_GOAL"].includes(target)) {
+          addCmd("additional", cmd, `Make ${target}`);
+        }
+      }
+    } catch {
+    }
+  }
+  const dockerComposePath = join3(cwd, "docker-compose.yml");
+  const dockerComposeYamlPath = join3(cwd, "docker-compose.yaml");
+  const composePath = await fileExists(dockerComposePath) ? dockerComposePath : await fileExists(dockerComposeYamlPath) ? dockerComposeYamlPath : null;
+  if (composePath) {
+    try {
+      const content = await readFile3(composePath, "utf-8");
+      const serviceMatches = content.matchAll(/^\s{2}([a-zA-Z_][a-zA-Z0-9_-]*):\s*$/gm);
+      for (const match of serviceMatches) {
+        const service = match[1];
+        addCmd("additional", `docker compose up ${service}`, `Run ${service} service`);
+      }
+      addCmd("dev", "docker compose up", "Start all services");
+      addCmd("build", "docker compose build", "Build all services");
+      addCmd("clean", "docker compose down -v", "Stop and remove volumes");
+    } catch {
+    }
+  }
+  const dockerfilePath = join3(cwd, "Dockerfile");
+  if (await fileExists(dockerfilePath)) {
+    try {
+      const content = await readFile3(dockerfilePath, "utf-8");
+      const fromMatch = content.match(/FROM\s+([^\s]+)/);
+      const imageName = fromMatch ? fromMatch[1].split(":")[0] : "app";
+      addCmd("build", `docker build -t ${imageName} .`, "Build Docker image");
+      addCmd("dev", `docker run -it --rm ${imageName}`, "Run Docker container");
+    } catch {
+    }
+  }
+  try {
+    const files = await readFile3(join3(cwd, "."), "utf-8").catch(() => "");
+    const dockerViewerPath = join3(cwd, "Dockerfile.viewer");
+    if (await fileExists(dockerViewerPath)) {
+      addCmd("build", "docker build -f Dockerfile.viewer -t app-viewer .", "Build viewer Docker image");
+    }
+  } catch {
+  }
+  const cargoPath = join3(cwd, "Cargo.toml");
+  if (await fileExists(cargoPath)) {
+    addCmd("build", "cargo build", "Build Rust project");
+    addCmd("build", "cargo build --release", "Build release");
+    addCmd("test", "cargo test", "Run Rust tests");
+    addCmd("lint", "cargo clippy", "Run Clippy linter");
+    addCmd("format", "cargo fmt", "Format Rust code");
+    addCmd("dev", "cargo run", "Run Rust binary");
+    addCmd("clean", "cargo clean", "Clean build artifacts");
+  }
+  const goModPath = join3(cwd, "go.mod");
+  if (await fileExists(goModPath)) {
+    addCmd("build", "go build", "Build Go project");
+    addCmd("test", "go test ./...", "Run Go tests");
+    addCmd("lint", "golangci-lint run", "Run golangci-lint");
+    addCmd("format", "go fmt ./...", "Format Go code");
+    addCmd("dev", "go run .", "Run Go binary");
+    addCmd("clean", "go clean", "Clean build cache");
+    addCmd("typecheck", "go vet ./...", "Run go vet");
+  }
+  const srcMainPath = join3(cwd, "src", "main.py");
+  const mainPath = join3(cwd, "main.py");
+  const appPath = join3(cwd, "app.py");
+  if (await fileExists(srcMainPath)) {
+    addCmd("dev", "python -m src.main", "Run main module");
+  }
+  if (await fileExists(mainPath)) {
+    addCmd("dev", "python main.py", "Run main.py");
+  }
+  if (await fileExists(appPath)) {
+    addCmd("dev", "python app.py", "Run app.py");
+  }
+  const schedulerPath = join3(cwd, "src", "scheduler.py");
+  if (await fileExists(schedulerPath)) {
+    addCmd("additional", "python -m src.scheduler", "Run scheduler");
+  }
+  const setupAuthPath = join3(cwd, "src", "setup_auth.py");
+  if (await fileExists(setupAuthPath)) {
+    addCmd("additional", "python -m src.setup_auth", "Setup authentication");
+  }
+  const webMainPath = join3(cwd, "src", "web", "main.py");
+  if (await fileExists(webMainPath)) {
+    addCmd("dev", "uvicorn src.web.main:app --host 0.0.0.0 --port 8080", "Run web viewer");
+  }
+  return cmds;
+}
 async function detectProject(cwd) {
   const detected = {
     name: null,
@@ -1831,6 +2076,7 @@ async function detectProject(cwd) {
       }
     }
   }
+  detected.detectedCommands = await detectExtendedCommands(cwd);
   return detected.stack.length > 0 || detected.name ? detected : null;
 }
 async function fileExists(path2) {
@@ -1881,7 +2127,7 @@ function parseGitLabUrl(url) {
   return null;
 }
 var OPEN_SOURCE_LICENSES = ["mit", "apache-2.0", "gpl-3.0", "lgpl-3.0", "agpl-3.0", "bsd-2-clause", "bsd-3-clause", "mpl-2.0", "unlicense", "cc0-1.0", "isc"];
-var STATIC_FILES = [".editorconfig", "CONTRIBUTING.md", "CODE_OF_CONDUCT.md", "SECURITY.md", "ROADMAP.md", ".gitignore", "LICENSE", "README.md", "ARCHITECTURE.md", "CHANGELOG.md"];
+var STATIC_FILES = [".editorconfig", "CONTRIBUTING.md", "CODE_OF_CONDUCT.md", "SECURITY.md", "ROADMAP.md", ".gitignore", ".github/FUNDING.yml", "LICENSE", "README.md", "ARCHITECTURE.md", "CHANGELOG.md"];
 async function detectFromGitHubApi(repoUrl) {
   const parsed = parseGitHubUrl(repoUrl);
   if (!parsed) return null;
@@ -1919,10 +2165,22 @@ async function detectFromGitHubApi(repoUrl) {
     const files = await filesRes.json();
     const fileNames = new Set(files.map((f) => f.name.toLowerCase()));
     for (const file of STATIC_FILES) {
+      if (file.includes("/")) continue;
       if (files.some((f) => f.name.toLowerCase() === file.toLowerCase())) {
         detected.existingFiles.push(file);
       }
     }
+    if (files.some((f) => f.name === ".github" && f.type === "dir")) {
+      const ghFilesRes = await fetch(`https://api.github.com/repos/${owner}/${repo}/contents/.github`, {
+        headers: { "User-Agent": "LynxPrompt-CLI" }
+      });
+      if (ghFilesRes.ok) {
+        const ghFiles = await ghFilesRes.json();
+        if (ghFiles.some((f) => f.name.toLowerCase() === "funding.yml")) {
+          detected.existingFiles.push(".github/FUNDING.yml");
+        }
+      }
+    }
     if (fileNames.has("dockerfile") || fileNames.has("docker-compose.yml") || fileNames.has("docker-compose.yaml")) {
       detected.hasDocker = true;
       detected.stack.push("docker");
@@ -2439,10 +2697,19 @@ var AI_BEHAVIOR_DESCRIPTIONS = {
 };
 var IMPORTANT_FILES_PATHS = {
   readme: "README.md",
-  package: "package.json or pyproject.toml",
-  tsconfig: "tsconfig.json or similar config",
-  architecture: "ARCHITECTURE.md",
-  contributing: "CONTRIBUTING.md"
+  package_json: "package.json",
+  changelog: "CHANGELOG.md",
+  contributing: "CONTRIBUTING.md",
+  makefile: "Makefile",
+  dockerfile: "Dockerfile",
+  docker_compose: "docker-compose.yml",
+  env_example: ".env.example",
+  openapi: "openapi.yaml / swagger.json",
+  architecture_md: "ARCHITECTURE.md",
+  // Legacy aliases for backwards compatibility
+  package: "package.json",
+  tsconfig: "tsconfig.json",
+  architecture: "ARCHITECTURE.md"
 };
 var BOUNDARIES = {
   conservative: {
@@ -3289,10 +3556,37 @@ function generateFileContent(options, platform2) {
     }
   }
   const security = options.security;
-  if (security && (security.secretsManagement?.length || security.securityTooling?.length || security.authPatterns?.length || security.dataHandling?.length || security.additionalNotes)) {
+  if (security && (security.authProviders?.length || security.secretsManagement?.length || security.securityTooling?.length || security.authPatterns?.length || security.dataHandling?.length || security.compliance?.length || security.analytics?.length || security.additionalNotes)) {
     if (isMarkdown || isMdc) {
       sections.push("## \u{1F510} Security Configuration");
       sections.push("");
+      if (security.authProviders?.length) {
+        sections.push("### Authentication Providers");
+        sections.push("");
+        const authProviderLabels = {
+          google: "Google",
+          github: "GitHub",
+          microsoft: "Microsoft",
+          apple: "Apple",
+          facebook: "Facebook",
+          twitter: "Twitter/X",
+          linkedin: "LinkedIn",
+          discord: "Discord",
+          slack: "Slack",
+          gitlab: "GitLab",
+          bitbucket: "Bitbucket",
+          email_password: "Email/Password",
+          phone_sms: "Phone/SMS",
+          magic_link: "Magic Link",
+          passkeys: "Passkeys/WebAuthn",
+          saml: "SAML SSO",
+          ldap: "LDAP/Active Directory"
+        };
+        for (const p of security.authProviders) {
+          sections.push(`- ${authProviderLabels[p] || p}`);
+        }
+        sections.push("");
+      }
       if (security.secretsManagement?.length) {
         sections.push("### Secrets Management");
         sections.push("");
@@ -3416,6 +3710,48 @@ function generateFileContent(options, platform2) {
         }
         sections.push("");
       }
+      if (security.compliance?.length) {
+        sections.push("### Compliance Standards");
+        sections.push("");
+        const complianceLabels = {
+          gdpr: "GDPR (EU)",
+          ccpa: "CCPA (California)",
+          hipaa: "HIPAA (Healthcare)",
+          soc2: "SOC 2",
+          pci_dss: "PCI-DSS (Payment)",
+          iso27001: "ISO 27001",
+          fedramp: "FedRAMP",
+          none: "No specific requirements"
+        };
+        for (const c of security.compliance) {
+          sections.push(`- ${complianceLabels[c] || c}`);
+        }
+        sections.push("");
+      }
+      if (security.analytics?.length) {
+        sections.push("### Analytics Tools");
+        sections.push("");
+        const analyticsLabels = {
+          none: "No analytics",
+          umami: "Umami",
+          plausible: "Plausible",
+          fathom: "Fathom",
+          posthog: "PostHog",
+          mixpanel: "Mixpanel",
+          amplitude: "Amplitude",
+          google_analytics: "Google Analytics",
+          segment: "Segment",
+          heap: "Heap",
+          matomo: "Matomo",
+          simple_analytics: "Simple Analytics",
+          pirsch: "Pirsch",
+          countly: "Countly"
+        };
+        for (const a of security.analytics) {
+          sections.push(`- ${analyticsLabels[a] || a}`);
+        }
+        sections.push("");
+      }
       if (security.additionalNotes) {
         sections.push("### Additional Security Notes");
         sections.push("");
@@ -3424,6 +3760,9 @@ function generateFileContent(options, platform2) {
       }
     } else {
       sections.push("Security Configuration:");
+      if (security.authProviders?.length) {
+        sections.push(`- Auth Providers: ${security.authProviders.join(", ")}`);
+      }
       if (security.secretsManagement?.length) {
         sections.push(`- Secrets: ${security.secretsManagement.join(", ")}`);
       }
@@ -3436,6 +3775,12 @@ function generateFileContent(options, platform2) {
       if (security.dataHandling?.length) {
         sections.push(`- Data: ${security.dataHandling.join(", ")}`);
       }
+      if (security.compliance?.length) {
+        sections.push(`- Compliance: ${security.compliance.join(", ")}`);
+      }
+      if (security.analytics?.length) {
+        sections.push(`- Analytics: ${security.analytics.join(", ")}`);
+      }
       sections.push("");
     }
   }
@@ -3587,7 +3932,7 @@ function generateYamlConfig(options, platform2) {
 
 // src/commands/wizard.ts
 var DRAFTS_DIR = ".lynxprompt/drafts";
-var CLI_VERSION = "1.2.12";
+var CLI_VERSION = "1.2.14";
 async function saveDraftLocally(name, config2, stepReached) {
   const draftsPath = join4(process.cwd(), DRAFTS_DIR);
   await mkdir3(draftsPath, { recursive: true });
@@ -3857,19 +4202,42 @@ var CICD_OPTIONS = [
   { id: "drone", label: "Drone", icon: "\u{1F681}" },
   { id: "buildkite", label: "Buildkite", icon: "\u{1F9F1}" }
 ];
-var DEPLOYMENT_TARGETS = [
+var CLOUD_TARGETS = [
   { id: "vercel", label: "Vercel", icon: "\u25B2 " },
   { id: "netlify", label: "Netlify", icon: "\u{1F310}" },
-  { id: "aws", label: "AWS", icon: "\u2601\uFE0F " },
-  { id: "gcp", label: "Google Cloud", icon: "\u{1F308}" },
-  { id: "azure", label: "Azure", icon: "\u{1F537}" },
-  { id: "docker", label: "Docker", icon: "\u{1F433}" },
-  { id: "kubernetes", label: "Kubernetes", icon: "\u2638\uFE0F " },
-  { id: "heroku", label: "Heroku", icon: "\u{1F7E3}" },
-  { id: "digitalocean", label: "DigitalOcean", icon: "\u{1F535}" },
+  { id: "cloudflare_pages", label: "Cloudflare Pages", icon: "\u{1F536}" },
+  { id: "cloudflare_workers", label: "Cloudflare Workers", icon: "\u{1F536}" },
+  { id: "aws_lambda", label: "AWS Lambda", icon: "\u2601\uFE0F " },
+  { id: "aws_ecs", label: "AWS ECS", icon: "\u2601\uFE0F " },
+  { id: "aws_ec2", label: "AWS EC2", icon: "\u2601\uFE0F " },
+  { id: "gcp_cloudrun", label: "GCP Cloud Run", icon: "\u{1F308}" },
+  { id: "gcp_appengine", label: "GCP App Engine", icon: "\u{1F308}" },
+  { id: "azure_appservice", label: "Azure App Service", icon: "\u{1F537}" },
+  { id: "azure_functions", label: "Azure Functions", icon: "\u{1F537}" },
   { id: "railway", label: "Railway", icon: "\u{1F682}" },
+  { id: "render", label: "Render", icon: "\u{1F3A8}" },
   { id: "fly", label: "Fly.io", icon: "\u2708\uFE0F " },
-  { id: "cloudflare", label: "Cloudflare", icon: "\u{1F536}" }
+  { id: "heroku", label: "Heroku", icon: "\u{1F7E3}" },
+  { id: "digitalocean_app", label: "DigitalOcean App Platform", icon: "\u{1F535}" },
+  { id: "deno_deploy", label: "Deno Deploy", icon: "\u{1F995}" }
+];
+var SELF_HOSTED_TARGETS = [
+  { id: "docker", label: "Docker", icon: "\u{1F433}" },
+  { id: "docker_compose", label: "Docker Compose", icon: "\u{1F433}" },
+  { id: "kubernetes", label: "Kubernetes", icon: "\u2638\uFE0F " },
+  { id: "k3s", label: "K3s", icon: "\u2638\uFE0F " },
+  { id: "podman", label: "Podman", icon: "\u{1F9AD}" },
+  { id: "bare_metal", label: "Bare Metal", icon: "\u{1F5A5}\uFE0F " },
+  { id: "vm", label: "Virtual Machine", icon: "\u{1F4BB}" },
+  { id: "proxmox", label: "Proxmox", icon: "\u{1F537}" },
+  { id: "unraid", label: "Unraid", icon: "\u{1F7E0}" },
+  { id: "truenas", label: "TrueNAS", icon: "\u{1F535}" },
+  { id: "synology", label: "Synology NAS", icon: "\u{1F4C1}" },
+  { id: "coolify", label: "Coolify", icon: "\u2744\uFE0F " },
+  { id: "dokku", label: "Dokku", icon: "\u{1F433}" },
+  { id: "caprover", label: "CapRover", icon: "\u{1F6A2}" },
+  { id: "portainer", label: "Portainer", icon: "\u{1F40B}" },
+  { id: "rancher", label: "Rancher", icon: "\u{1F404}" }
 ];
 var CONTAINER_REGISTRIES = [
   { id: "dockerhub", label: "Docker Hub", icon: "\u{1F433}" },
@@ -5446,14 +5814,14 @@ async function runInteractiveWizard(options, detected, userTier) {
       name: "changelogTool",
       message: chalk7.white("Changelog management:"),
       choices: [
-        { title: "Manual", value: "manual" },
-        { title: "Conventional Changelog", value: "conventional_changelog" },
-        { title: "Release Please", value: "release_please" },
-        { title: "Semantic Release", value: "semantic_release" },
-        { title: "Changesets", value: "changesets" },
-        { title: "GitHub Releases", value: "github_releases" },
-        { title: "Keep a Changelog", value: "keep_a_changelog" },
-        { title: "Other", value: "other" }
+        { title: "Manual - Write CHANGELOG.md by hand", value: "manual" },
+        { title: "Conventional Changelog - Auto-generate from commit messages", value: "conventional_changelog" },
+        { title: "Release Please - Google's automated release management", value: "release_please" },
+        { title: "Semantic Release - Fully automated versioning & publishing", value: "semantic_release" },
+        { title: "Changesets - Monorepo-friendly version management", value: "changesets" },
+        { title: "GitHub Releases - Use GitHub's built-in release notes", value: "github_releases" },
+        { title: "Keep a Changelog - Manual following keepachangelog.com format", value: "keep_a_changelog" },
+        { title: "Other - Custom changelog tooling", value: "other" }
       ],
       initial: 0
     }, promptConfig);
@@ -5473,13 +5841,15 @@ async function runInteractiveWizard(options, detected, userTier) {
     name: "branchStrategy",
     message: chalk7.white("Branch strategy:"),
     choices: [
+      { title: "\u{1F3AE} None (toy project) - No branching, commit directly to main", value: "none" },
       { title: "\u{1F30A} GitHub Flow - Simple: main + feature branches", value: "github_flow" },
       { title: "\u{1F333} Gitflow - develop, feature, release, hotfix branches", value: "gitflow" },
       { title: "\u{1F682} Trunk-Based - Short-lived branches, continuous integration", value: "trunk_based" },
       { title: "\u{1F98A} GitLab Flow - Environment branches (staging, production)", value: "gitlab_flow" },
       { title: "\u{1F680} Release Flow - main + release branches", value: "release_flow" }
     ],
-    initial: 0
+    initial: 1
+    // Default to GitHub Flow (index 1 after adding "none")
   }, promptConfig);
   answers.branchStrategy = branchStrategyResponse.branchStrategy || "github_flow";
   const defaultBranchResponse = await prompts3({
@@ -5495,18 +5865,7 @@ async function runInteractiveWizard(options, detected, userTier) {
     initial: 0
   }, promptConfig);
   answers.defaultBranch = defaultBranchResponse.defaultBranch || "main";
-  const commitWorkflowResponse = await prompts3({
-    type: "select",
-    name: "commitWorkflow",
-    message: chalk7.white("Commit workflow preference:"),
-    choices: [
-      { title: "\u{1F500} Branch + PR - Create branches and open pull requests", value: "branch_pr" },
-      { title: "\u2B06\uFE0F Direct to main - Commit directly to main/master branch", value: "direct_main" }
-    ],
-    initial: 0
-    // Default to branch + PR
-  }, promptConfig);
-  answers.commitWorkflow = commitWorkflowResponse.commitWorkflow || "branch_pr";
+  answers.commitWorkflow = answers.branchStrategy === "none" ? "direct_main" : "branch_pr";
   const cicdChoices = [
     { title: chalk7.gray("\u23ED Skip"), value: "" },
     ...CICD_OPTIONS.map((c) => ({
@@ -5523,27 +5882,61 @@ async function runInteractiveWizard(options, detected, userTier) {
     initial: detectedCicdIndex > 0 ? detectedCicdIndex : 0
   }, promptConfig);
   answers.cicd = cicdResponse.cicd || "";
-  const deployChoices = sortSelectedFirst(DEPLOYMENT_TARGETS.map((t) => ({
-    title: t.id === "docker" && detected?.hasDocker ? `${t.icon}${t.label} ${chalk7.green("(detected)")}` : `${t.icon}${t.label}`,
-    selected: t.id === "docker" && detected?.hasDocker,
-    value: t.id
-  })));
-  const deployResponse = await prompts3({
-    type: "autocompleteMultiselect",
-    name: "deploymentTargets",
-    message: chalk7.white("Deployment targets (type to search):"),
-    choices: deployChoices,
-    hint: chalk7.gray("type to filter \u2022 space select \u2022 enter confirm"),
-    instructions: false
+  const deployTypeResponse = await prompts3({
+    type: "select",
+    name: "deployType",
+    message: chalk7.white("Deployment environment:"),
+    choices: [
+      { title: "\u2601\uFE0F  Cloud only - PaaS, serverless, managed services", value: "cloud" },
+      { title: "\u{1F3E0} Self-hosted only - On-premise, homelab, VPS", value: "self_hosted" },
+      { title: "\u{1F504} Both cloud and self-hosted", value: "both" },
+      { title: chalk7.gray("\u23ED Skip"), value: "skip" }
+    ],
+    initial: 0
   }, promptConfig);
-  answers.deploymentTargets = deployResponse.deploymentTargets || [];
-  const dockerSelected = (answers.deploymentTargets || []).includes("docker");
+  const deployType = deployTypeResponse.deployType || "skip";
+  let allDeployTargets = [];
+  if (deployType === "cloud" || deployType === "both") {
+    const cloudChoices = CLOUD_TARGETS.map((t) => ({
+      title: `${t.icon}${t.label}`,
+      value: t.id
+    }));
+    const cloudResponse = await prompts3({
+      type: "autocompleteMultiselect",
+      name: "cloudTargets",
+      message: chalk7.white("Cloud deployment targets (type to search):"),
+      choices: cloudChoices,
+      hint: chalk7.gray("type to filter \u2022 space select \u2022 enter confirm"),
+      instructions: false
+    }, promptConfig);
+    allDeployTargets = [...cloudResponse.cloudTargets || []];
+  }
+  if (deployType === "self_hosted" || deployType === "both") {
+    const selfHostedChoices = sortSelectedFirst(SELF_HOSTED_TARGETS.map((t) => ({
+      title: t.id === "docker" && detected?.hasDocker ? `${t.icon}${t.label} ${chalk7.green("(detected)")}` : `${t.icon}${t.label}`,
+      selected: t.id === "docker" && detected?.hasDocker,
+      value: t.id
+    })));
+    const selfHostedResponse = await prompts3({
+      type: "autocompleteMultiselect",
+      name: "selfHostedTargets",
+      message: chalk7.white("Self-hosted deployment targets (type to search):"),
+      choices: selfHostedChoices,
+      hint: chalk7.gray("type to filter \u2022 space select \u2022 enter confirm"),
+      instructions: false
+    }, promptConfig);
+    allDeployTargets = [...allDeployTargets, ...selfHostedResponse.selfHostedTargets || []];
+  }
+  answers.deploymentTargets = allDeployTargets;
+  const dockerSelected = (answers.deploymentTargets || []).some(
+    (t) => ["docker", "docker_compose", "kubernetes", "k3s", "podman"].includes(t)
+  ) || detected?.hasDocker;
   const containerResponse = await prompts3({
     type: "toggle",
     name: "buildContainer",
     message: chalk7.white("Build container images (Docker)?"),
     initial: dockerSelected,
-    // Default Yes if Docker selected
+    // Default Yes if container platform selected
     active: "Yes",
     inactive: "No"
   }, promptConfig);
@@ -5814,16 +6207,36 @@ async function runInteractiveWizard(options, detected, userTier) {
   if (canAccessTier(userTier, "intermediate")) {
     const commandsStep = getCurrentStep("commands");
     showStep(currentStepNum, commandsStep, userTier);
-    console.log(chalk7.gray("  Select common commands for your project (type to search):"));
+    console.log(chalk7.gray("  Select commands for your project. Detected commands are pre-selected."));
     console.log();
-    const buildChoices = sortSelectedFirst(COMMON_COMMANDS.build.map((c) => {
-      const isDetected = detected?.commands?.build === c;
-      return {
-        title: isDetected ? `${chalk7.cyan(c)} ${chalk7.green("(detected)")}` : chalk7.cyan(c),
-        value: c,
-        selected: isDetected
-      };
-    }));
+    const buildCommandChoices = (category, commonCmds, color) => {
+      const detectedCmds2 = detected?.detectedCommands?.[category] || [];
+      const detectedSet = new Set(detectedCmds2.map((d) => d.cmd));
+      const choices = detectedCmds2.map((d) => ({
+        title: `${color(d.cmd)} ${chalk7.green("(detected)")}${d.desc ? chalk7.gray(` - ${d.desc}`) : ""}`,
+        value: d.cmd,
+        selected: true
+      }));
+      for (const cmd of commonCmds) {
+        if (!detectedSet.has(cmd)) {
+          choices.push({
+            title: color(cmd),
+            value: cmd,
+            selected: false
+          });
+        }
+      }
+      return choices;
+    };
+    const detectedCmds = detected?.detectedCommands;
+    if (detectedCmds) {
+      const totalDetected = Object.values(detectedCmds).reduce((sum, arr) => sum + (arr?.length || 0), 0);
+      if (totalDetected > 0) {
+        console.log(chalk7.green(`  \u2713 ${totalDetected} commands detected from your project`));
+        console.log();
+      }
+    }
+    const buildChoices = buildCommandChoices("build", COMMON_COMMANDS.build, chalk7.cyan);
     const buildResponse = await prompts3({
       type: "autocompleteMultiselect",
       name: "build",
@@ -5832,14 +6245,7 @@ async function runInteractiveWizard(options, detected, userTier) {
       hint: chalk7.gray("type to filter \u2022 space select \u2022 enter confirm"),
       instructions: false
     }, promptConfig);
-    const testChoices = sortSelectedFirst(COMMON_COMMANDS.test.map((c) => {
-      const isDetected = detected?.commands?.test === c;
-      return {
-        title: isDetected ? `${chalk7.yellow(c)} ${chalk7.green("(detected)")}` : chalk7.yellow(c),
-        value: c,
-        selected: isDetected
-      };
-    }));
+    const testChoices = buildCommandChoices("test", COMMON_COMMANDS.test, chalk7.yellow);
     const testResponse = await prompts3({
       type: "autocompleteMultiselect",
       name: "test",
@@ -5848,30 +6254,16 @@ async function runInteractiveWizard(options, detected, userTier) {
       hint: chalk7.gray("type to filter \u2022 space select \u2022 enter confirm"),
       instructions: false
     }, promptConfig);
-    const lintChoices = sortSelectedFirst(COMMON_COMMANDS.lint.map((c) => {
-      const isDetected = detected?.commands?.lint === c;
-      return {
-        title: isDetected ? `${chalk7.green(c)} ${chalk7.green("(detected)")}` : chalk7.green(c),
-        value: c,
-        selected: isDetected
-      };
-    }));
+    const lintChoices = buildCommandChoices("lint", COMMON_COMMANDS.lint, chalk7.green);
     const lintResponse = await prompts3({
       type: "autocompleteMultiselect",
       name: "lint",
-      message: chalk7.white("Lint/format commands (type to search):"),
+      message: chalk7.white("Lint commands (type to search):"),
       choices: lintChoices,
       hint: chalk7.gray("type to filter \u2022 space select \u2022 enter confirm"),
       instructions: false
     }, promptConfig);
-    const devChoices = sortSelectedFirst(COMMON_COMMANDS.dev.map((c) => {
-      const isDetected = detected?.commands?.dev === c;
-      return {
-        title: isDetected ? `${chalk7.magenta(c)} ${chalk7.green("(detected)")}` : chalk7.magenta(c),
-        value: c,
-        selected: isDetected
-      };
-    }));
+    const devChoices = buildCommandChoices("dev", COMMON_COMMANDS.dev, chalk7.magenta);
     const devResponse = await prompts3({
       type: "autocompleteMultiselect",
       name: "dev",
@@ -5880,58 +6272,48 @@ async function runInteractiveWizard(options, detected, userTier) {
       hint: chalk7.gray("type to filter \u2022 space select \u2022 enter confirm"),
       instructions: false
     }, promptConfig);
+    const formatChoices = buildCommandChoices("format", COMMON_COMMANDS.format, chalk7.blue);
     const formatResponse = await prompts3({
       type: "autocompleteMultiselect",
       name: "format",
       message: chalk7.white("Format commands (type to search):"),
-      choices: COMMON_COMMANDS.format.map((c) => ({
-        title: chalk7.blue(c),
-        value: c
-      })),
+      choices: formatChoices,
       hint: chalk7.gray("type to filter \u2022 space select \u2022 enter confirm"),
       instructions: false
     }, promptConfig);
+    const typecheckChoices = buildCommandChoices("typecheck", COMMON_COMMANDS.typecheck, chalk7.gray);
     const typecheckResponse = await prompts3({
       type: "autocompleteMultiselect",
       name: "typecheck",
       message: chalk7.white("Typecheck commands (type to search):"),
-      choices: COMMON_COMMANDS.typecheck.map((c) => ({
-        title: chalk7.gray(c),
-        value: c
-      })),
+      choices: typecheckChoices,
       hint: chalk7.gray("type to filter \u2022 space select \u2022 enter confirm"),
       instructions: false
     }, promptConfig);
+    const cleanChoices = buildCommandChoices("clean", COMMON_COMMANDS.clean, chalk7.red);
     const cleanResponse = await prompts3({
       type: "autocompleteMultiselect",
       name: "clean",
       message: chalk7.white("Clean commands (type to search):"),
-      choices: COMMON_COMMANDS.clean.map((c) => ({
-        title: chalk7.red(c),
-        value: c
-      })),
+      choices: cleanChoices,
       hint: chalk7.gray("type to filter \u2022 space select \u2022 enter confirm"),
       instructions: false
     }, promptConfig);
+    const preCommitChoices = buildCommandChoices("preCommit", COMMON_COMMANDS.preCommit, chalk7.yellow);
     const preCommitResponse = await prompts3({
       type: "autocompleteMultiselect",
       name: "preCommit",
       message: chalk7.white("Pre-commit hooks (type to search):"),
-      choices: COMMON_COMMANDS.preCommit.map((c) => ({
-        title: chalk7.yellow(c),
-        value: c
-      })),
+      choices: preCommitChoices,
       hint: chalk7.gray("type to filter \u2022 space select \u2022 enter confirm"),
       instructions: false
     }, promptConfig);
+    const additionalChoices = buildCommandChoices("additional", COMMON_COMMANDS.additional, chalk7.blue);
     const additionalResponse = await prompts3({
       type: "autocompleteMultiselect",
       name: "additional",
       message: chalk7.white("Additional commands (type to search):"),
-      choices: COMMON_COMMANDS.additional.map((c) => ({
-        title: chalk7.blue(c),
-        value: c
-      })),
+      choices: additionalChoices,
       hint: chalk7.gray("type to filter \u2022 space select \u2022 enter confirm"),
       instructions: false
     }, promptConfig);
@@ -6026,10 +6408,10 @@ async function runInteractiveWizard(options, detected, userTier) {
     const maxFileLengthResponse = await prompts3({
       type: "number",
       name: "maxFileLength",
-      message: chalk7.white("Max file length (lines, 100-1000):"),
+      message: chalk7.white("Max file length (lines, 100-10000):"),
       initial: 300,
       min: 100,
-      max: 1e3
+      max: 1e4
     }, promptConfig);
     answers.maxFileLength = maxFileLengthResponse.maxFileLength || 300;
     const importOrderResponse = await prompts3({
@@ -6037,25 +6419,85 @@ async function runInteractiveWizard(options, detected, userTier) {
       name: "importOrder",
       message: chalk7.white("Import order preference:"),
       choices: [
+        { title: chalk7.gray("\u23ED Skip"), value: "" },
         { title: "Grouped (external \u2192 internal \u2192 relative)", value: "grouped" },
         { title: "Alphabetical (sort A-Z)", value: "sorted" },
         { title: "Natural (leave as written)", value: "natural" }
       ],
       initial: 0
     }, promptConfig);
-    answers.importOrder = importOrderResponse.importOrder || "grouped";
+    answers.importOrder = importOrderResponse.importOrder || "";
     const commentLangResponse = await prompts3({
-      type: "select",
+      type: "autocomplete",
       name: "commentLanguage",
       message: chalk7.white("Comment language:"),
       choices: [
+        { title: chalk7.gray("\u23ED Skip"), value: "" },
         { title: "\u{1F1EC}\u{1F1E7} English", value: "english" },
-        { title: "\u{1F30D} Native language", value: "native" },
-        { title: "\u{1F5E3}\uFE0F Any (team preference)", value: "any" }
+        { title: "\u{1F1EA}\u{1F1F8} Spanish (Espa\xF1ol)", value: "spanish" },
+        { title: "\u{1F1EB}\u{1F1F7} French (Fran\xE7ais)", value: "french" },
+        { title: "\u{1F1E9}\u{1F1EA} German (Deutsch)", value: "german" },
+        { title: "\u{1F1EE}\u{1F1F9} Italian (Italiano)", value: "italian" },
+        { title: "\u{1F1F5}\u{1F1F9} Portuguese (Portugu\xEAs)", value: "portuguese" },
+        { title: "\u{1F1F3}\u{1F1F1} Dutch (Nederlands)", value: "dutch" },
+        { title: "\u{1F1F7}\u{1F1FA} Russian (\u0420\u0443\u0441\u0441\u043A\u0438\u0439)", value: "russian" },
+        { title: "\u{1F1E8}\u{1F1F3} Chinese Simplified (\u7B80\u4F53\u4E2D\u6587)", value: "chinese_simplified" },
+        { title: "\u{1F1F9}\u{1F1FC} Chinese Traditional (\u7E41\u9AD4\u4E2D\u6587)", value: "chinese_traditional" },
+        { title: "\u{1F1EF}\u{1F1F5} Japanese (\u65E5\u672C\u8A9E)", value: "japanese" },
+        { title: "\u{1F1F0}\u{1F1F7} Korean (\uD55C\uAD6D\uC5B4)", value: "korean" },
+        { title: "\u{1F1F8}\u{1F1E6} Arabic (\u0627\u0644\u0639\u0631\u0628\u064A\u0629)", value: "arabic" },
+        { title: "\u{1F1EE}\u{1F1F1} Hebrew (\u05E2\u05D1\u05E8\u05D9\u05EA)", value: "hebrew" },
+        { title: "\u{1F1EE}\u{1F1F3} Hindi (\u0939\u093F\u0928\u094D\u0926\u0940)", value: "hindi" },
+        { title: "\u{1F1E7}\u{1F1E9} Bengali (\u09AC\u09BE\u0982\u09B2\u09BE)", value: "bengali" },
+        { title: "\u{1F1F5}\u{1F1F0} Urdu (\u0627\u0631\u062F\u0648)", value: "urdu" },
+        { title: "\u{1F1F9}\u{1F1ED} Thai (\u0E44\u0E17\u0E22)", value: "thai" },
+        { title: "\u{1F1FB}\u{1F1F3} Vietnamese (Ti\u1EBFng Vi\u1EC7t)", value: "vietnamese" },
+        { title: "\u{1F1EE}\u{1F1E9} Indonesian (Bahasa Indonesia)", value: "indonesian" },
+        { title: "\u{1F1F2}\u{1F1FE} Malay (Bahasa Melayu)", value: "malay" },
+        { title: "\u{1F1F5}\u{1F1ED} Filipino (Tagalog)", value: "filipino" },
+        { title: "\u{1F1F5}\u{1F1F1} Polish (Polski)", value: "polish" },
+        { title: "\u{1F1E8}\u{1F1FF} Czech (\u010Ce\u0161tina)", value: "czech" },
+        { title: "\u{1F1F8}\u{1F1F0} Slovak (Sloven\u010Dina)", value: "slovak" },
+        { title: "\u{1F1ED}\u{1F1FA} Hungarian (Magyar)", value: "hungarian" },
+        { title: "\u{1F1F7}\u{1F1F4} Romanian (Rom\xE2n\u0103)", value: "romanian" },
+        { title: "\u{1F1E7}\u{1F1EC} Bulgarian (\u0411\u044A\u043B\u0433\u0430\u0440\u0441\u043A\u0438)", value: "bulgarian" },
+        { title: "\u{1F1FA}\u{1F1E6} Ukrainian (\u0423\u043A\u0440\u0430\u0457\u043D\u0441\u044C\u043A\u0430)", value: "ukrainian" },
+        { title: "\u{1F1EC}\u{1F1F7} Greek (\u0395\u03BB\u03BB\u03B7\u03BD\u03B9\u03BA\u03AC)", value: "greek" },
+        { title: "\u{1F1F9}\u{1F1F7} Turkish (T\xFCrk\xE7e)", value: "turkish" },
+        { title: "\u{1F1F8}\u{1F1EA} Swedish (Svenska)", value: "swedish" },
+        { title: "\u{1F1F3}\u{1F1F4} Norwegian (Norsk)", value: "norwegian" },
+        { title: "\u{1F1E9}\u{1F1F0} Danish (Dansk)", value: "danish" },
+        { title: "\u{1F1EB}\u{1F1EE} Finnish (Suomi)", value: "finnish" },
+        { title: "\u{1F1EA}\u{1F1EA} Estonian (Eesti)", value: "estonian" },
+        { title: "\u{1F1F1}\u{1F1FB} Latvian (Latvie\u0161u)", value: "latvian" },
+        { title: "\u{1F1F1}\u{1F1F9} Lithuanian (Lietuvi\u0173)", value: "lithuanian" },
+        { title: "\u{1F1F8}\u{1F1EE} Slovenian (Sloven\u0161\u010Dina)", value: "slovenian" },
+        { title: "\u{1F1ED}\u{1F1F7} Croatian (Hrvatski)", value: "croatian" },
+        { title: "\u{1F1F7}\u{1F1F8} Serbian (\u0421\u0440\u043F\u0441\u043A\u0438)", value: "serbian" },
+        { title: "\u{1F1EE}\u{1F1F7} Persian/Farsi (\u0641\u0627\u0631\u0633\u06CC)", value: "persian" },
+        { title: "\u{1F1FF}\u{1F1E6} Afrikaans", value: "afrikaans" },
+        { title: "\u{1F1F3}\u{1F1EC} Swahili (Kiswahili)", value: "swahili" },
+        { title: "\u{1F1EA}\u{1F1EC} Egyptian Arabic", value: "egyptian_arabic" },
+        { title: "\u{1F1F2}\u{1F1FD} Latin American Spanish", value: "latam_spanish" },
+        { title: "\u{1F1E7}\u{1F1F7} Brazilian Portuguese", value: "brazilian_portuguese" },
+        { title: "\u{1F1E8}\u{1F1E6} Canadian French", value: "canadian_french" },
+        { title: "\u{1F1E6}\u{1F1F9} Austrian German", value: "austrian_german" },
+        { title: "\u{1F1E8}\u{1F1ED} Swiss German", value: "swiss_german" },
+        { title: "\u{1F524} Other (specify)", value: "other" }
       ],
-      initial: 0
+      hint: chalk7.gray("type to filter"),
+      suggest: (input, choices) => choices.filter((c) => c.title.toLowerCase().includes(input.toLowerCase()))
     }, promptConfig);
-    answers.commentLanguage = commentLangResponse.commentLanguage || "english";
+    answers.commentLanguage = commentLangResponse.commentLanguage || "";
+    if (answers.commentLanguage === "other") {
+      const customLangResponse = await prompts3({
+        type: "text",
+        name: "customLanguage",
+        message: chalk7.white("Specify comment language:"),
+        validate: (v) => v.trim() ? true : "Please enter a language"
+      }, promptConfig);
+      answers.commentLanguage = customLangResponse.customLanguage || "english";
+    }
     const docStyleResponse = await prompts3({
       type: "select",
       name: "docStyle",
@@ -6304,23 +6746,40 @@ async function runInteractiveWizard(options, detected, userTier) {
     const boundariesStep = getCurrentStep("boundaries");
     showStep(currentStepNum, boundariesStep, userTier);
     console.log(chalk7.gray("  Define what AI should never do, ask first, or always do."));
-    console.log(chalk7.gray("  Each option can only be in one category."));
+    console.log(chalk7.gray("  Each option can only be in one category. Select 'Other' to add custom."));
     console.log();
     const usedOptions = /* @__PURE__ */ new Set();
+    const OTHER_MARKER = "__other__";
     console.log(chalk7.red.bold("  \u2717 NEVER ALLOW - AI will refuse to do"));
     const neverResponse = await prompts3({
       type: "autocompleteMultiselect",
       name: "never",
       message: chalk7.white("Never allow (type to filter):"),
-      choices: BOUNDARY_OPTIONS.map((o) => ({
-        title: chalk7.red(o),
-        value: o
-      })),
+      choices: [
+        ...BOUNDARY_OPTIONS.map((o) => ({
+          title: chalk7.red(o),
+          value: o
+        })),
+        { title: chalk7.magenta("\u270E Other (custom)"), value: OTHER_MARKER }
+      ],
       hint: chalk7.gray("space select \u2022 enter confirm"),
       instructions: false
     }, promptConfig);
-    answers.boundaryNever = neverResponse.never || [];
-    answers.boundaryNever.forEach((o) => usedOptions.add(o));
+    let neverList = (neverResponse.never || []).filter((o) => o !== OTHER_MARKER);
+    if ((neverResponse.never || []).includes(OTHER_MARKER)) {
+      const customNeverResponse = await prompts3({
+        type: "text",
+        name: "custom",
+        message: chalk7.white("Enter custom 'never allow' items (comma-separated):"),
+        hint: chalk7.gray("e.g., Push to production, Deploy without approval")
+      }, promptConfig);
+      if (customNeverResponse.custom) {
+        const customItems = customNeverResponse.custom.split(",").map((s) => s.trim()).filter(Boolean);
+        neverList = [...neverList, ...customItems];
+      }
+    }
+    answers.boundaryNever = neverList;
+    neverList.forEach((o) => usedOptions.add(o));
     console.log();
     console.log(chalk7.yellow.bold("  ? ASK FIRST - AI will ask before doing"));
     const availableForAsk = BOUNDARY_OPTIONS.filter((o) => !usedOptions.has(o));
@@ -6328,15 +6787,31 @@ async function runInteractiveWizard(options, detected, userTier) {
       type: "autocompleteMultiselect",
       name: "ask",
       message: chalk7.white("Ask first (type to filter):"),
-      choices: availableForAsk.map((o) => ({
-        title: chalk7.yellow(o),
-        value: o
-      })),
+      choices: [
+        ...availableForAsk.map((o) => ({
+          title: chalk7.yellow(o),
+          value: o
+        })),
+        { title: chalk7.magenta("\u270E Other (custom)"), value: OTHER_MARKER }
+      ],
       hint: chalk7.gray("space select \u2022 enter confirm"),
       instructions: false
     }, promptConfig);
-    answers.boundaryAsk = askResponse.ask || [];
-    answers.boundaryAsk.forEach((o) => usedOptions.add(o));
+    let askList = (askResponse.ask || []).filter((o) => o !== OTHER_MARKER);
+    if ((askResponse.ask || []).includes(OTHER_MARKER)) {
+      const customAskResponse = await prompts3({
+        type: "text",
+        name: "custom",
+        message: chalk7.white("Enter custom 'ask first' items (comma-separated):"),
+        hint: chalk7.gray("e.g., Change external API calls, Modify authentication")
+      }, promptConfig);
+      if (customAskResponse.custom) {
+        const customItems = customAskResponse.custom.split(",").map((s) => s.trim()).filter(Boolean);
+        askList = [...askList, ...customItems];
+      }
+    }
+    answers.boundaryAsk = askList;
+    askList.forEach((o) => usedOptions.add(o));
     console.log();
     console.log(chalk7.green.bold("  \u2713 ALWAYS ALLOW - AI will do these automatically"));
     const availableForAlways = BOUNDARY_OPTIONS.filter((o) => !usedOptions.has(o));
@@ -6344,24 +6819,40 @@ async function runInteractiveWizard(options, detected, userTier) {
       type: "autocompleteMultiselect",
       name: "always",
       message: chalk7.white("Always allow (type to filter):"),
-      choices: availableForAlways.map((o) => ({
-        title: chalk7.green(o),
-        value: o
-      })),
+      choices: [
+        ...availableForAlways.map((o) => ({
+          title: chalk7.green(o),
+          value: o
+        })),
+        { title: chalk7.magenta("\u270E Other (custom)"), value: OTHER_MARKER }
+      ],
       hint: chalk7.gray("space select \u2022 enter confirm"),
       instructions: false
     }, promptConfig);
-    answers.boundaryAlways = alwaysResponse.always || [];
+    let alwaysList = (alwaysResponse.always || []).filter((o) => o !== OTHER_MARKER);
+    if ((alwaysResponse.always || []).includes(OTHER_MARKER)) {
+      const customAlwaysResponse = await prompts3({
+        type: "text",
+        name: "custom",
+        message: chalk7.white("Enter custom 'always allow' items (comma-separated):"),
+        hint: chalk7.gray("e.g., Add comments, Format code")
+      }, promptConfig);
+      if (customAlwaysResponse.custom) {
+        const customItems = customAlwaysResponse.custom.split(",").map((s) => s.trim()).filter(Boolean);
+        alwaysList = [...alwaysList, ...customItems];
+      }
+    }
+    answers.boundaryAlways = alwaysList;
     console.log();
     console.log(chalk7.gray("  Boundary summary:"));
-    if (answers.boundaryAlways.length > 0) {
-      console.log(chalk7.green(`    \u2713 Always: ${answers.boundaryAlways.join(", ")}`));
+    if (alwaysList.length > 0) {
+      console.log(chalk7.green(`    \u2713 Always: ${alwaysList.join(", ")}`));
     }
-    if (answers.boundaryAsk.length > 0) {
-      console.log(chalk7.yellow(`    ? Ask: ${answers.boundaryAsk.join(", ")}`));
+    if (askList.length > 0) {
+      console.log(chalk7.yellow(`    ? Ask: ${askList.join(", ")}`));
     }
-    if (answers.boundaryNever.length > 0) {
-      console.log(chalk7.red(`    \u2717 Never: ${answers.boundaryNever.join(", ")}`));
+    if (neverList.length > 0) {
+      console.log(chalk7.red(`    \u2717 Never: ${neverList.join(", ")}`));
     }
   } else {
     answers.boundaries = options.boundaries || "standard";
@@ -6415,15 +6906,20 @@ async function runInteractiveWizard(options, detected, userTier) {
       inactive: "No"
     }, promptConfig);
     answers.tddPreference = tddResponse.tddPreference ?? false;
+    console.log(chalk7.gray("  Snapshot testing captures expected output (HTML, JSON, etc.) and compares"));
+    console.log(chalk7.gray("  future runs against it. Useful for UI components, API responses, serialization."));
     const snapshotResponse = await prompts3({
-      type: "toggle",
+      type: "select",
       name: "snapshotTesting",
       message: chalk7.white("Use snapshot testing?"),
-      initial: false,
-      active: "Yes",
-      inactive: "No"
+      choices: [
+        { title: chalk7.gray("\u23ED Skip"), value: "skip" },
+        { title: "Yes - Use snapshot testing for output validation", value: "yes" },
+        { title: "No - Avoid snapshot tests", value: "no" }
+      ],
+      initial: 0
     }, promptConfig);
-    answers.snapshotTesting = snapshotResponse.snapshotTesting ?? false;
+    answers.snapshotTesting = snapshotResponse.snapshotTesting === "yes";
     const mockResponse = await prompts3({
       type: "select",
       name: "mockStrategy",
@@ -6447,159 +6943,175 @@ async function runInteractiveWizard(options, detected, userTier) {
   if (canAccessTier(userTier, "advanced")) {
     const staticStep = getCurrentStep("static");
     showStep(currentStepNum, staticStep, userTier);
-    console.log(chalk7.gray("  How should static file content be handled?"));
-    console.log();
-    console.log(chalk7.gray("     \u{1F4C4} Config only: Content embedded in AI config file (AI has context, no local files)"));
-    console.log(chalk7.gray("     \u{1F4C1} Both: Create local files AND embed content in AI config file"));
-    console.log();
-    const staticFileHandlingResponse = await prompts3({
-      type: "select",
-      name: "handling",
-      message: chalk7.white("Where to add static file content?"),
-      choices: [
-        { title: "\u{1F4C4} Config file only (recommended)", value: "config_only", description: "Content goes in AI config, no separate files created" },
-        { title: "\u{1F4C1} Both local files AND config", value: "both", description: "Create files locally AND embed in AI config" }
-      ],
-      initial: 0
-    }, promptConfig);
-    answers.staticFileHandling = staticFileHandlingResponse.handling || "config_only";
-    console.log();
-    console.log(chalk7.gray("  Select project files to include:"));
-    console.log();
-    const STATIC_FILE_OPTIONS = [
-      { title: "\u{1F4DD} .editorconfig", value: "editorconfig", desc: "Consistent code formatting" },
-      { title: "\u{1F91D} CONTRIBUTING.md", value: "contributing", desc: "Contributor guidelines" },
-      { title: "\u{1F4DC} CODE_OF_CONDUCT.md", value: "codeOfConduct", desc: "Community standards" },
-      { title: "\u{1F512} SECURITY.md", value: "security", desc: "Vulnerability reporting" },
-      { title: "\u{1F5FA}\uFE0F  ROADMAP.md", value: "roadmap", desc: "Project roadmap" },
-      { title: "\u{1F4CB} .gitignore", value: "gitignore", desc: "Git ignore patterns" },
-      { title: "\u{1F4B0} FUNDING.yml", value: "funding", desc: "GitHub Sponsors config" },
-      { title: "\u{1F4C4} LICENSE", value: "license", desc: "License file" },
-      { title: "\u{1F4D6} README.md", value: "readme", desc: "Project readme" },
-      { title: "\u{1F3D7}\uFE0F  ARCHITECTURE.md", value: "architecture", desc: "Architecture docs" },
-      { title: "\u{1F4DD} CHANGELOG.md", value: "changelog", desc: "Version history" }
-    ];
-    const existingFiles = {};
-    for (const opt of STATIC_FILE_OPTIONS) {
-      const filePath = STATIC_FILE_PATHS2[opt.value];
-      if (filePath) {
-        const content = await readExistingFile(join4(process.cwd(), filePath));
-        if (content) {
-          existingFiles[opt.value] = content;
-        }
-      }
-    }
-    const existingCount = Object.keys(existingFiles).length;
-    if (existingCount > 0) {
-      console.log(chalk7.green(`  \u2713 Found ${existingCount} existing file(s) in your project`));
+    let skipStaticFiles = false;
+    if (detected) {
+      console.log(chalk7.gray("  Since you're working with an existing repository, you may already have these files."));
       console.log();
+      const skipResponse = await prompts3({
+        type: "toggle",
+        name: "skip",
+        message: chalk7.white("Skip static files configuration?"),
+        initial: true,
+        active: "Yes, skip",
+        inactive: "No, configure"
+      }, promptConfig);
+      skipStaticFiles = skipResponse.skip ?? true;
     }
-    const staticFilesResponse = await prompts3({
-      type: "autocompleteMultiselect",
-      name: "staticFiles",
-      message: chalk7.white("Include static files (type to search):"),
-      choices: STATIC_FILE_OPTIONS.map((f) => ({
-        title: existingFiles[f.value] ? `${f.title} ${chalk7.green("(exists)")}` : f.title,
-        value: f.value,
-        description: chalk7.gray(f.desc)
-      })),
-      hint: chalk7.gray("type to filter \u2022 space select \u2022 enter confirm"),
-      instructions: false
-    }, promptConfig);
-    answers.staticFiles = staticFilesResponse.staticFiles || [];
-    if (answers.staticFiles?.length > 0) {
+    if (!skipStaticFiles) {
+      console.log(chalk7.gray("  How should static file content be handled?"));
       console.log();
-      console.log(chalk7.cyan("  \u{1F4DD} Customize file contents:"));
-      console.log(chalk7.gray("  For each file, choose to use existing content, write new, or use defaults."));
-      if (canAccessAI(userTier)) {
-        console.log(chalk7.magenta(`  \u2728 Tip: Type 'ai:' followed by your request to use AI assistance`));
-      }
+      console.log(chalk7.gray("     \u{1F4C4} Config only: Content embedded in AI config file (AI has context, no local files)"));
+      console.log(chalk7.gray("     \u{1F4C1} Both: Create local files AND embed content in AI config file"));
       console.log();
-      answers.staticFileContents = {};
-      for (const fileKey of answers.staticFiles) {
-        const fileOpt = STATIC_FILE_OPTIONS.find((f) => f.value === fileKey);
-        if (!fileOpt) continue;
-        const filePath = STATIC_FILE_PATHS2[fileKey];
-        const existingContent = existingFiles[fileKey];
-        if (existingContent) {
-          const preview = existingContent.split("\n").slice(0, 3).join("\n");
-          console.log(chalk7.gray(`  \u2500\u2500\u2500 ${filePath} (existing) \u2500\u2500\u2500`));
-          console.log(chalk7.gray(preview.substring(0, 150) + (preview.length > 150 ? "..." : "")));
-          console.log();
-          const actionResponse = await prompts3({
-            type: "select",
-            name: "action",
-            message: chalk7.white(`${filePath}:`),
-            choices: [
-              { title: chalk7.green("\u2713 Use existing content"), value: "existing" },
-              { title: chalk7.yellow("\u270F\uFE0F  Write new content"), value: "new" },
-              { title: chalk7.gray("\u26A1 Generate default"), value: "default" }
-            ],
-            initial: 0
-          }, promptConfig);
-          if (actionResponse.action === "existing") {
-            answers.staticFileContents[fileKey] = existingContent;
-          } else if (actionResponse.action === "new") {
-            console.log();
-            const content = await readMultilineInput(`  Content for ${filePath}:`);
-            if (content.trim()) {
-              answers.staticFileContents[fileKey] = content;
-            }
+      const staticFileHandlingResponse = await prompts3({
+        type: "select",
+        name: "handling",
+        message: chalk7.white("Where to add static file content?"),
+        choices: [
+          { title: "\u{1F4C4} Config file only (recommended)", value: "config_only", description: "Content goes in AI config, no separate files created" },
+          { title: "\u{1F4C1} Both local files AND config", value: "both", description: "Create files locally AND embed in AI config" }
+        ],
+        initial: 0
+      }, promptConfig);
+      answers.staticFileHandling = staticFileHandlingResponse.handling || "config_only";
+      console.log();
+      console.log(chalk7.gray("  Select project files to include:"));
+      console.log();
+      const STATIC_FILE_OPTIONS = [
+        { title: "\u{1F4DD} .editorconfig", value: "editorconfig", desc: "Consistent code formatting" },
+        { title: "\u{1F91D} CONTRIBUTING.md", value: "contributing", desc: "Contributor guidelines" },
+        { title: "\u{1F4DC} CODE_OF_CONDUCT.md", value: "codeOfConduct", desc: "Community standards" },
+        { title: "\u{1F512} SECURITY.md", value: "security", desc: "Vulnerability reporting" },
+        { title: "\u{1F5FA}\uFE0F  ROADMAP.md", value: "roadmap", desc: "Project roadmap" },
+        { title: "\u{1F4CB} .gitignore", value: "gitignore", desc: "Git ignore patterns" },
+        { title: "\u{1F4B0} FUNDING.yml", value: "funding", desc: "GitHub Sponsors config" },
+        { title: "\u{1F4C4} LICENSE", value: "license", desc: "License file" },
+        { title: "\u{1F4D6} README.md", value: "readme", desc: "Project readme" },
+        { title: "\u{1F3D7}\uFE0F  ARCHITECTURE.md", value: "architecture", desc: "Architecture docs" },
+        { title: "\u{1F4DD} CHANGELOG.md", value: "changelog", desc: "Version history" }
+      ];
+      const existingFiles = {};
+      for (const opt of STATIC_FILE_OPTIONS) {
+        const filePath = STATIC_FILE_PATHS2[opt.value];
+        if (filePath) {
+          const content = await readExistingFile(join4(process.cwd(), filePath));
+          if (content) {
+            existingFiles[opt.value] = content;
           }
-        } else {
-          const actionResponse = await prompts3({
-            type: "select",
-            name: "action",
-            message: chalk7.white(`${filePath}:`),
-            choices: [
-              { title: chalk7.gray("\u26A1 Generate default"), value: "default" },
-              { title: chalk7.yellow("\u270F\uFE0F  Write custom content"), value: "new" }
-            ],
-            initial: 0
-          }, promptConfig);
-          if (actionResponse.action === "new") {
+        }
+      }
+      const existingCount = Object.keys(existingFiles).length;
+      if (existingCount > 0) {
+        console.log(chalk7.green(`  \u2713 Found ${existingCount} existing file(s) in your project`));
+        console.log();
+      }
+      const staticFilesResponse = await prompts3({
+        type: "autocompleteMultiselect",
+        name: "staticFiles",
+        message: chalk7.white("Include static files (type to search):"),
+        choices: STATIC_FILE_OPTIONS.map((f) => ({
+          title: existingFiles[f.value] ? `${f.title} ${chalk7.green("(exists)")}` : f.title,
+          value: f.value,
+          description: chalk7.gray(f.desc)
+        })),
+        hint: chalk7.gray("type to filter \u2022 space select \u2022 enter confirm"),
+        instructions: false
+      }, promptConfig);
+      answers.staticFiles = staticFilesResponse.staticFiles || [];
+      if (answers.staticFiles?.length > 0) {
+        console.log();
+        console.log(chalk7.cyan("  \u{1F4DD} Customize file contents:"));
+        console.log(chalk7.gray("  For each file, choose to use existing content, write new, or use defaults."));
+        if (canAccessAI(userTier)) {
+          console.log(chalk7.magenta(`  \u2728 Tip: Type 'ai:' followed by your request to use AI assistance`));
+        }
+        console.log();
+        answers.staticFileContents = {};
+        for (const fileKey of answers.staticFiles) {
+          const fileOpt = STATIC_FILE_OPTIONS.find((f) => f.value === fileKey);
+          if (!fileOpt) continue;
+          const filePath = STATIC_FILE_PATHS2[fileKey];
+          const existingContent = existingFiles[fileKey];
+          if (existingContent) {
+            const preview = existingContent.split("\n").slice(0, 3).join("\n");
+            console.log(chalk7.gray(`  \u2500\u2500\u2500 ${filePath} (existing) \u2500\u2500\u2500`));
+            console.log(chalk7.gray(preview.substring(0, 150) + (preview.length > 150 ? "..." : "")));
             console.log();
-            if (canAccessAI(userTier)) {
-              const aiPromptResponse = await prompts3({
-                type: "text",
-                name: "input",
-                message: chalk7.white(`Content for ${filePath}:`),
-                hint: chalk7.gray("Type 'ai:' + description OR paste content (press Enter twice to skip)")
-              }, promptConfig);
-              let content = aiPromptResponse.input || "";
-              if (content.toLowerCase().startsWith("ai:")) {
-                const aiInstruction = content.substring(3).trim();
-                if (aiInstruction) {
-                  const aiResult = await aiAssist(`Generate ${filePath} content: ${aiInstruction}`, existingContent);
-                  if (aiResult) {
-                    console.log(chalk7.cyan("  AI-generated content preview (first 200 chars):"));
-                    console.log(chalk7.gray("  " + aiResult.substring(0, 200) + (aiResult.length > 200 ? "..." : "")));
-                    const acceptAI = await prompts3({
-                      type: "confirm",
-                      name: "accept",
-                      message: chalk7.white("Use this AI-generated content?"),
-                      initial: true
-                    }, promptConfig);
-                    if (acceptAI.accept) {
-                      content = aiResult;
-                    } else {
-                      content = "";
-                    }
-                  }
-                }
-              }
-              if (content.trim()) {
-                answers.staticFileContents[fileKey] = content;
-              }
-            } else {
+            const actionResponse = await prompts3({
+              type: "select",
+              name: "action",
+              message: chalk7.white(`${filePath}:`),
+              choices: [
+                { title: chalk7.green("\u2713 Use existing content"), value: "existing" },
+                { title: chalk7.yellow("\u270F\uFE0F  Write new content"), value: "new" },
+                { title: chalk7.gray("\u26A1 Generate default"), value: "default" }
+              ],
+              initial: 0
+            }, promptConfig);
+            if (actionResponse.action === "existing") {
+              answers.staticFileContents[fileKey] = existingContent;
+            } else if (actionResponse.action === "new") {
+              console.log();
               const content = await readMultilineInput(`  Content for ${filePath}:`);
               if (content.trim()) {
                 answers.staticFileContents[fileKey] = content;
               }
             }
+          } else {
+            const actionResponse = await prompts3({
+              type: "select",
+              name: "action",
+              message: chalk7.white(`${filePath}:`),
+              choices: [
+                { title: chalk7.gray("\u26A1 Generate default"), value: "default" },
+                { title: chalk7.yellow("\u270F\uFE0F  Write custom content"), value: "new" }
+              ],
+              initial: 0
+            }, promptConfig);
+            if (actionResponse.action === "new") {
+              console.log();
+              if (canAccessAI(userTier)) {
+                const aiPromptResponse = await prompts3({
+                  type: "text",
+                  name: "input",
+                  message: chalk7.white(`Content for ${filePath}:`),
+                  hint: chalk7.gray("Type 'ai:' + description OR paste content (press Enter twice to skip)")
+                }, promptConfig);
+                let content = aiPromptResponse.input || "";
+                if (content.toLowerCase().startsWith("ai:")) {
+                  const aiInstruction = content.substring(3).trim();
+                  if (aiInstruction) {
+                    const aiResult = await aiAssist(`Generate ${filePath} content: ${aiInstruction}`, existingContent);
+                    if (aiResult) {
+                      console.log(chalk7.cyan("  AI-generated content preview (first 200 chars):"));
+                      console.log(chalk7.gray("  " + aiResult.substring(0, 200) + (aiResult.length > 200 ? "..." : "")));
+                      const acceptAI = await prompts3({
+                        type: "confirm",
+                        name: "accept",
+                        message: chalk7.white("Use this AI-generated content?"),
+                        initial: true
+                      }, promptConfig);
+                      if (acceptAI.accept) {
+                        content = aiResult;
+                      } else {
+                        content = "";
+                      }
+                    }
+                  }
+                }
+                if (content.trim()) {
+                  answers.staticFileContents[fileKey] = content;
+                }
+              } else {
+                const content = await readMultilineInput(`  Content for ${filePath}:`);
+                if (content.trim()) {
+                  answers.staticFileContents[fileKey] = content;
+                }
+              }
+            }
           }
+          console.log();
         }
-        console.log();
       }
     }
   }
@@ -8810,7 +9322,7 @@ function handleError2(error) {
 }
 
 // src/index.ts
-var CLI_VERSION2 = "1.2.12";
+var CLI_VERSION2 = "1.2.14";
 var program = new Command();
 program.name("lynxprompt").description("CLI for LynxPrompt - Generate AI IDE configuration files").version(CLI_VERSION2);
 program.command("wizard").description("Generate AI IDE configuration (recommended for most users)").option("-n, --name <name>", "Project name").option("-d, --description <description>", "Project description").option("-s, --stack <stack>", "Tech stack (comma-separated)").option("-f, --format <format>", "Output format: agents, cursor, or comma-separated for multiple").option("-p, --platforms <platforms>", "Alias for --format (deprecated)").option("--persona <persona>", "AI persona (fullstack, backend, frontend, devops, data, security)").option("--boundaries <level>", "Boundary preset (conservative, standard, permissive)").option("-y, --yes", "Skip prompts, use defaults (generates AGENTS.md)").option("-o, --output <dir>", "Output directory (default: current directory)").option("--repo-url <url>", "Analyze remote repository URL (GitHub/GitLab supported)").option("--blueprint", "Generate with [[VARIABLE|default]] placeholders for templates").option("--license <type>", "License type (mit, apache-2.0, gpl-3.0, etc.)").option("--ci-cd <platform>", "CI/CD platform (github_actions, gitlab_ci, jenkins, etc.)").option("--project-type <type>", "Project type (work, leisure, opensource, learning)").option("--detect-only", "Only detect project info, don't generate files").option("--load-draft <name>", "Load a saved wizard draft").option("--save-draft <name>", "Save wizard state as a draft (auto-saves at end)").option("--vars <values>", "Fill variables: VAR1=value1,VAR2=value2").action(wizardCommand);