reposentry 1.0.0

package/dist/chunk-I2CN2HU4.js

@@ -0,0 +1,2276 @@
+#!/usr/bin/env node
+import {
+  askCopilot,
+  getCopilotBackendName,
+  isCopilotAvailable,
+  logger,
+  setCopilotModel,
+  setVerbose
+} from "./chunk-ZW3DYU5Y.js";
+import {
+  createProgress
+} from "./chunk-RNKCNCJW.js";
+import {
+  buildDirectoryTree,
+  detectConfigs,
+  detectLanguages,
+  detectRoutes,
+  getContributors,
+  getGitTags,
+  getRecentCommits,
+  getRepoName,
+  gitCommand,
+  isGitRepo,
+  scanFiles
+} from "./chunk-NYYK2IZI.js";
+import {
+  ensureDir,
+  readFileContentSync,
+  readFileTruncated,
+  writeOutput
+} from "./chunk-JZB6VB4T.js";
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/core/orchestrator.ts
+import { resolve as resolve2 } from "path";
+import chalk from "chalk";
+import boxen from "boxen";
+
+// src/core/output-manager.ts
+import { join, extname } from "path";
+import { existsSync, readdirSync, rmSync, readFileSync as readFileSync2, writeFileSync, mkdirSync } from "fs";
+import { marked } from "marked";
+
+// src/utils/version.ts
+import { readFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+var cachedVersion = null;
+function getCliVersion() {
+  if (cachedVersion) return cachedVersion;
+  try {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const pkgPath = resolve(here, "../../package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    cachedVersion = pkg.version || "0.0.0";
+  } catch {
+    cachedVersion = "0.0.0";
+  }
+  return cachedVersion;
+}
+
+// src/core/output-manager.ts
+var RAW_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".yml",
+  ".yaml",
+  ".json",
+  ".toml",
+  ".ini",
+  ".cfg",
+  ".conf",
+  ".env",
+  ".sh",
+  ".bash",
+  ".ps1",
+  ".bat",
+  ".cmd",
+  ".tf",
+  ".hcl",
+  ".dockerfile",
+  ".mmd"
+]);
+function stripCodeFences(content, filename) {
+  const ext = extname(filename).toLowerCase();
+  const baseName = filename.toLowerCase();
+  const isRaw = RAW_EXTENSIONS.has(ext) || baseName.startsWith("dockerfile") || baseName === ".env.example" || baseName.endsWith(".suggested");
+  if (!isRaw) return content;
+  let result = content;
+  const fencePattern = /^```[\w.-]*\s*\n([\s\S]*?)^```\s*$/gm;
+  const blocks = [];
+  let match;
+  while ((match = fencePattern.exec(result)) !== null) {
+    blocks.push(match[1]);
+  }
+  if (blocks.length > 0) {
+    const mainBlock = blocks.reduce((a, b) => a.length >= b.length ? a : b);
+    result = mainBlock;
+  }
+  result = result.replace(/^```[\w.-]*\s*$/gm, "").replace(/^```\s*$/gm, "");
+  if ([".yml", ".yaml"].includes(ext) || baseName.startsWith("dockerfile") || baseName === ".env.example") {
+    result = result.replace(/^#\s+[A-Z].*\n+/gm, (match2, offset) => {
+      if (offset === 0 || result.slice(0, offset).trim() === "") return "";
+      return match2;
+    });
+  }
+  return result.trim() + "\n";
+}
+var OutputManager = class _OutputManager {
+  constructor(options) {
+    this.options = options;
+    this.baseDir = options.baseDir;
+  }
+  baseDir;
+  filesWritten = [];
+  contentByPath = /* @__PURE__ */ new Map();
+  htmlExports = [];
+  /** Files that must survive a --force wipe (persistent across runs) */
+  static PRESERVED_FILES = ["history.json"];
+  async init() {
+    const exists = existsSync(this.baseDir);
+    if (exists) {
+      const entries = readdirSync(this.baseDir, { withFileTypes: true });
+      const nonEmpty = entries.some((e) => e.name !== ".DS_Store");
+      if (nonEmpty && !this.options.force) {
+        throw new Error(
+          `Output directory is not empty: ${this.baseDir}. Use --force or choose a different --output directory.`
+        );
+      }
+      if (nonEmpty && this.options.force) {
+        const backups = /* @__PURE__ */ new Map();
+        for (const name of _OutputManager.PRESERVED_FILES) {
+          const fp = join(this.baseDir, name);
+          if (existsSync(fp)) {
+            try {
+              backups.set(name, readFileSync2(fp, "utf-8"));
+            } catch {
+            }
+          }
+        }
+        rmSync(this.baseDir, { recursive: true, force: true });
+        if (backups.size > 0) {
+          mkdirSync(this.baseDir, { recursive: true });
+          for (const [name, content] of backups) {
+            writeFileSync(join(this.baseDir, name), content, "utf-8");
+          }
+        }
+      }
+    }
+    await ensureDir(this.baseDir);
+  }
+  async write(relativePath, content) {
+    const fullPath = join(this.baseDir, relativePath);
+    const cleaned = stripCodeFences(content, relativePath);
+    await writeOutput(fullPath, cleaned);
+    this.filesWritten.push(relativePath);
+    logger.debug(`Written: ${relativePath}`);
+    if (this.options.format === "json") {
+      this.contentByPath.set(relativePath, cleaned);
+    }
+    if (this.options.format === "html") {
+      await this.writeHtmlExport(relativePath, cleaned);
+    }
+  }
+  async writeToSubdir(subdir, filename, content) {
+    await this.write(join(subdir, filename), content);
+  }
+  getFilesWritten() {
+    return [...this.filesWritten];
+  }
+  getFileCount() {
+    return this.filesWritten.length;
+  }
+  getBaseDir() {
+    return this.baseDir;
+  }
+  async finalize() {
+    if (this.options.format === "json") {
+      const bundle = {
+        tool: "reposentry",
+        version: getCliVersion(),
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        files: [...this.contentByPath.entries()].map(([path, content]) => ({ path, content }))
+      };
+      await writeOutput(join(this.baseDir, "bundle.json"), JSON.stringify(bundle, null, 2));
+    }
+    if (this.options.format === "html") {
+      await this.writeHtmlIndex();
+    }
+  }
+  async writeHtmlIndex() {
+    const items = this.htmlExports.map((e) => `<li><a href="./${escapeAttr(e.htmlPath)}">${escapeHtml(e.title)}</a> <span class="muted">(${escapeHtml(e.sourcePath)})</span></li>`).join("\n");
+    const html = `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>RepoSentry HTML Export</title>
+  <style>
+    body{font-family:system-ui,-apple-system,Segoe UI,Roboto,Ubuntu,Cantarell,Noto Sans,sans-serif;margin:32px;line-height:1.5}
+    h1{margin:0 0 8px 0}
+    .muted{color:#666;font-size:12px}
+    ul{padding-left:18px}
+    li{margin:6px 0}
+  </style>
+</head>
+<body>
+  <h1>RepoSentry HTML Export</h1>
+  <div class="muted">Generated by reposentry v${escapeHtml(getCliVersion())} on ${escapeHtml((/* @__PURE__ */ new Date()).toLocaleString())}</div>
+  <h2>Files</h2>
+  <ul>
+    ${items || '<li class="muted">No HTML exports generated.</li>'}
+  </ul>
+</body>
+</html>`;
+    await writeOutput(join(this.baseDir, "html", "index.html"), html);
+  }
+  async writeHtmlExport(relativePath, content) {
+    const ext = extname(relativePath).toLowerCase();
+    const outBase = join(this.baseDir, "html");
+    if (ext === ".md") {
+      const htmlPath2 = replaceExt(relativePath, ".html");
+      const fullOut2 = join(outBase, htmlPath2);
+      const rendered2 = renderMarkdownToHtml(content);
+      const page2 = wrapHtmlPage(relativePath, rendered2);
+      await writeOutput(fullOut2, page2);
+      this.htmlExports.push({ sourcePath: relativePath, htmlPath: htmlPath2.replace(/\\/g, "/"), title: relativePath });
+      return;
+    }
+    if (ext === ".mmd") {
+      const htmlPath2 = replaceExt(relativePath, ".html");
+      const fullOut2 = join(outBase, htmlPath2);
+      const rendered2 = `<div class="mermaid">${escapeHtml(content)}</div>`;
+      const page2 = wrapHtmlPage(relativePath, rendered2);
+      await writeOutput(fullOut2, page2);
+      this.htmlExports.push({ sourcePath: relativePath, htmlPath: htmlPath2.replace(/\\/g, "/"), title: relativePath });
+      return;
+    }
+    const htmlPath = `${relativePath}.html`;
+    const fullOut = join(outBase, htmlPath);
+    const rendered = `<pre><code>${escapeHtml(content)}</code></pre>`;
+    const page = wrapHtmlPage(relativePath, rendered);
+    await writeOutput(fullOut, page);
+    this.htmlExports.push({ sourcePath: relativePath, htmlPath: htmlPath.replace(/\\/g, "/"), title: relativePath });
+  }
+};
+function replaceExt(path, newExt) {
+  return path.replace(/\.[^.]+$/, newExt);
+}
+function escapeHtml(input) {
+  return input.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function escapeAttr(input) {
+  return escapeHtml(input).replace(/\n/g, "");
+}
+function renderMarkdownToHtml(markdown) {
+  const renderer = new marked.Renderer();
+  renderer.html = (token) => {
+    const raw = token?.text ?? token?.raw ?? "";
+    return escapeHtml(String(raw));
+  };
+  marked.use({ renderer });
+  const html = marked.parse(markdown);
+  return html.replace(
+    /<pre><code class="language-mermaid">([\s\S]*?)<\/code><\/pre>/g,
+    '<div class="mermaid">$1</div>'
+  );
+}
+function wrapHtmlPage(title, bodyHtml) {
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>${escapeHtml(title)} \u2014 RepoSentry Export</title>
+  <script src="https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.min.js"></script>
+  <style>
+    body{font-family:system-ui,-apple-system,Segoe UI,Roboto,Ubuntu,Cantarell,Noto Sans,sans-serif;margin:24px;line-height:1.55}
+    pre{background:#0b1020;color:#e6edf3;padding:14px;border-radius:10px;overflow:auto}
+    code{font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;font-size:12px}
+    .mermaid{background:#fff;border:1px solid #e5e7eb;border-radius:12px;padding:14px;overflow:auto}
+    h1,h2,h3{margin-top:18px}
+  </style>
+</head>
+<body>
+  ${bodyHtml}
+  <script>
+    try { mermaid.initialize({ startOnLoad: true, theme: 'default' }); } catch {}
+  </script>
+</body>
+</html>`;
+}
+
+// src/scanners/import-parser.ts
+import { join as join2 } from "path";
+function parseImports(rootDir, files) {
+  const jsFiles = files.filter(
+    (f) => f.endsWith(".ts") || f.endsWith(".tsx") || f.endsWith(".js") || f.endsWith(".jsx")
+  );
+  const results = [];
+  for (const file of jsFiles.slice(0, 100)) {
+    try {
+      const content = readFileContentSync(join2(rootDir, file));
+      const imports = [];
+      const esImports = content.matchAll(/import\s+(?:.*?\s+from\s+)?['"]([^'"]+)['"]/g);
+      for (const match of esImports) {
+        imports.push(match[1]);
+      }
+      const cjsRequires = content.matchAll(/require\s*\(\s*['"]([^'"]+)['"]\s*\)/g);
+      for (const match of cjsRequires) {
+        imports.push(match[1]);
+      }
+      if (file.endsWith(".py")) {
+        const pyImports = content.matchAll(/(?:from\s+(\S+)\s+import|import\s+(\S+))/g);
+        for (const match of pyImports) {
+          imports.push(match[1] || match[2]);
+        }
+      }
+      if (file.endsWith(".go")) {
+        const goImports = content.matchAll(/import\s+(?:\(\s*([\s\S]*?)\s*\)|"([^"]+)")/g);
+        for (const match of goImports) {
+          if (match[2]) {
+            imports.push(match[2]);
+          } else if (match[1]) {
+            const goLines = match[1].matchAll(/"([^"]+)"/g);
+            for (const l of goLines) imports.push(l[1]);
+          }
+        }
+      }
+      if (imports.length > 0) {
+        results.push({ file, imports });
+      }
+    } catch {
+    }
+  }
+  return results;
+}
+
+// src/scanners/model-detector.ts
+import { join as join3 } from "path";
+var ORM_PATTERNS = [
+  {
+    name: "Prisma",
+    filePattern: /\.prisma$/,
+    modelPatterns: [
+      /model\s+(\w+)\s*\{([^}]+)\}/g
+    ]
+  },
+  {
+    name: "Mongoose",
+    filePattern: /\.(ts|js)$/,
+    modelPatterns: [
+      /new\s+(?:mongoose\.)?Schema\s*\(\s*\{([^}]+)\}/g,
+      /mongoose\.model\s*\(\s*['"`](\w+)['"`]/g
+    ]
+  },
+  {
+    name: "Sequelize",
+    filePattern: /\.(ts|js)$/,
+    modelPatterns: [
+      /(?:sequelize\.define|Model\.init)\s*\(\s*['"`](\w+)['"`]\s*,\s*\{([^}]+)\}/g
+    ]
+  },
+  {
+    name: "TypeORM",
+    filePattern: /\.(ts|js)$/,
+    modelPatterns: [
+      /@Entity\s*\(\s*(?:['"`](\w+)['"`])?\s*\)/g,
+      /@Column\s*\(/g
+    ]
+  },
+  {
+    name: "Django ORM",
+    filePattern: /\.py$/,
+    modelPatterns: [
+      /class\s+(\w+)\s*\(\s*(?:models\.)?Model\s*\)\s*:/g
+    ]
+  },
+  {
+    name: "SQLAlchemy",
+    filePattern: /\.py$/,
+    modelPatterns: [
+      /class\s+(\w+)\s*\(\s*(?:Base|db\.Model)\s*\)\s*:/g
+    ]
+  },
+  {
+    name: "GORM",
+    filePattern: /\.go$/,
+    modelPatterns: [
+      /type\s+(\w+)\s+struct\s*\{[^}]*gorm/g
+    ]
+  },
+  {
+    name: "ActiveRecord",
+    filePattern: /\.rb$/,
+    modelPatterns: [
+      /class\s+(\w+)\s*<\s*(?:ApplicationRecord|ActiveRecord::Base)/g
+    ]
+  }
+];
+function detectModels(rootDir, files) {
+  const models = [];
+  for (const file of files.slice(0, 200)) {
+    for (const orm of ORM_PATTERNS) {
+      if (!orm.filePattern.test(file)) continue;
+      try {
+        const content = readFileContentSync(join3(rootDir, file));
+        for (const pattern of orm.modelPatterns) {
+          const regex = new RegExp(pattern.source, pattern.flags);
+          let match;
+          while ((match = regex.exec(content)) !== null) {
+            const name = match[1] || file.split(/[/\\]/).pop()?.replace(/\.\w+$/, "") || "Unknown";
+            const fieldsStr = match[2] || "";
+            const fields = fieldsStr.split(/[,\n]/).map((f) => f.trim()).filter((f) => f && !f.startsWith("//") && !f.startsWith("#"));
+            models.push({
+              name,
+              file,
+              orm: orm.name,
+              fields: fields.slice(0, 20)
+            });
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  return models;
+}
+
+// src/scanners/git-analyzer.ts
+function analyzeGitHistory(cwd) {
+  const contributors = getContributors(cwd);
+  const recentCommits = getRecentCommits(cwd, 30);
+  const tags = getGitTags(cwd);
+  const totalCommitsStr = gitCommand("rev-list --count HEAD", cwd);
+  const totalCommits = parseInt(totalCommitsStr, 10) || 0;
+  const branches = gitCommand("branch -r --no-merged", cwd).split("\n").map((b) => b.trim()).filter((b) => b && !b.includes("HEAD")).slice(0, 20);
+  const firstCommitDate = gitCommand("log --reverse --format=%ci --max-count=1", cwd);
+  const lastCommitDate = gitCommand("log -1 --format=%ci", cwd);
+  const directoryOwnership = /* @__PURE__ */ new Map();
+  const topDirs = gitCommand("ls-tree -d --name-only HEAD", cwd).split("\n").filter(Boolean).slice(0, 15);
+  for (const dir of topDirs) {
+    const ownerOutput = gitCommand(`shortlog -sn --no-merges HEAD -- "${dir}"`, cwd);
+    const firstLine = ownerOutput.split("\n")[0] || "";
+    const match = firstLine.match(/^\s*\d+\s+(.+)$/);
+    if (match) {
+      directoryOwnership.set(dir, match[1].trim());
+    }
+  }
+  return {
+    contributors,
+    recentCommits,
+    totalCommits,
+    tags,
+    activeBranches: branches,
+    firstCommitDate,
+    lastCommitDate,
+    directoryOwnership
+  };
+}
+
+// src/core/prompt-builder.ts
+function buildPrompt(task, context, outputFormat = "markdown") {
+  const parts = [];
+  parts.push(`You are analyzing a ${context.languages.join("/")} project called "${context.projectName}".`);
+  if (context.frameworks.length > 0) {
+    parts.push(`Frameworks/libraries: ${context.frameworks.join(", ")}.`);
+  }
+  if (context.packageManager) {
+    parts.push(`Package manager: ${context.packageManager}.`);
+  }
+  if (context.fileTree) {
+    parts.push(`Project structure:
+${context.fileTree}`);
+  }
+  if (context.codeContext) {
+    parts.push(`Relevant code:
+${context.codeContext}`);
+  }
+  if (context.additionalContext) {
+    parts.push(context.additionalContext);
+  }
+  parts.push(`Task: ${task}`);
+  if (outputFormat === "mermaid") {
+    parts.push("Output ONLY valid Mermaid diagram syntax. No markdown fences, no explanation.");
+  } else if (outputFormat === "json") {
+    parts.push("Output ONLY valid JSON. No markdown fences, no explanation.");
+  } else {
+    parts.push("Output in well-formatted Markdown.");
+  }
+  return parts.join("\n\n");
+}
+
+// src/prompts/docs.prompts.ts
+function readmePrompt(ctx) {
+  return buildPrompt(
+    "Generate a complete README.md for this project. Include: project description, features, installation instructions, usage examples, configuration options, and contributing section. Make it professional and comprehensive.",
+    ctx
+  );
+}
+function apiDocsPrompt(ctx) {
+  return buildPrompt(
+    "Generate API documentation (API.md). For each detected endpoint/function, document: method, path/signature, parameters, request body schema, response format, and example usage with curl commands or code snippets.",
+    ctx
+  );
+}
+function setupPrompt(ctx) {
+  return buildPrompt(
+    "Generate a SETUP.md development environment setup guide. Include step-by-step instructions for macOS, Linux, and Windows. Cover: prerequisites, dependency installation, environment variables, database setup (if applicable), and running the project locally.",
+    ctx
+  );
+}
+function contributingPrompt(ctx) {
+  return buildPrompt(
+    "Generate a CONTRIBUTING.md guide. Include: how to fork and clone, branch naming conventions, commit message format, code style guidelines, PR process, testing requirements, and code review expectations.",
+    ctx
+  );
+}
+function changelogPrompt(ctx) {
+  return buildPrompt(
+    "Generate a CHANGELOG.md from the git commit history provided. Group changes by version tags (if any) or by date. Categorize entries as: Features, Bug Fixes, Documentation, Refactoring, and Other. Use Keep a Changelog format.",
+    ctx
+  );
+}
+function faqPrompt(ctx) {
+  return buildPrompt(
+    "Generate an FAQ.md based on the codebase analysis. Infer common questions from: TODO/FIXME/HACK comments found in code, complex setup requirements, common pitfalls, and configuration options. Provide clear answers for each.",
+    ctx
+  );
+}
+
+// src/engines/docs-engine.ts
+async function runDocsEngine(input, output, progress) {
+  const steps = [
+    { key: "readme", label: "README.md", promptFn: readmePrompt, file: "README.md" },
+    { key: "api", label: "API.md", promptFn: apiDocsPrompt, file: "API.md" },
+    { key: "setup", label: "SETUP.md", promptFn: setupPrompt, file: "SETUP.md" },
+    { key: "contributing", label: "CONTRIBUTING.md", promptFn: contributingPrompt, file: "CONTRIBUTING.md" },
+    { key: "changelog", label: "CHANGELOG.md", promptFn: changelogPrompt, file: "CHANGELOG.md" },
+    { key: "faq", label: "FAQ.md", promptFn: faqPrompt, file: "FAQ.md" }
+  ];
+  progress.start("Documentation Engine", steps.length);
+  const ctx = { ...input.context };
+  if (input.routes.length > 0) {
+    ctx.additionalContext = (ctx.additionalContext || "") + `
+Detected API routes:
+${input.routes.map((r) => `${r.method} ${r.path} (${r.file})`).join("\n")}`;
+  }
+  if (input.recentCommits.length > 0) {
+    ctx.additionalContext = (ctx.additionalContext || "") + `
+Recent commits:
+${input.recentCommits.join("\n")}`;
+  }
+  if (input.tags.length > 0) {
+    ctx.additionalContext = (ctx.additionalContext || "") + `
+Version tags: ${input.tags.join(", ")}`;
+  }
+  let filesGenerated = 0;
+  for (const step of steps) {
+    progress.increment(step.label);
+    const prompt = step.promptFn(ctx);
+    const result = await askCopilot(prompt);
+    await output.write(step.file, result);
+    filesGenerated++;
+  }
+  progress.succeed("Documentation Engine");
+  let score = 20;
+  if (input.hasReadme) score += 25;
+  if (input.routes.length > 0) score += 10;
+  if (input.recentCommits.length > 3) score += 10;
+  if (input.tags.length > 0) score += 15;
+  if (!input.hasReadme) score -= 10;
+  if (input.recentCommits.length === 0) score -= 5;
+  score = Math.max(0, Math.min(100, score));
+  return {
+    score,
+    details: `README: ${input.hasReadme ? "yes" : "missing"}, ${input.routes.length} routes, ${input.tags.length} tags, ${input.recentCommits.length} recent commits`
+  };
+}
+
+// src/utils/mermaid.ts
+function embedMermaidInMarkdown(title, diagram) {
+  return `## ${title}
+
+\`\`\`mermaid
+${diagram}
+\`\`\`
+`;
+}
+
+// src/prompts/architecture.prompts.ts
+function systemArchitecturePrompt(ctx) {
+  return buildPrompt(
+    'Generate ONLY a Mermaid flowchart diagram (flowchart TD syntax) showing the high-level system architecture. Show major components (frontend, backend services, databases, external APIs) and their connections with labeled arrows. Output the raw mermaid code starting with "flowchart TD". No text before or after the diagram.',
+    ctx,
+    "mermaid"
+  );
+}
+function dataFlowPrompt(ctx) {
+  return buildPrompt(
+    'Generate ONLY a Mermaid sequence diagram (sequenceDiagram syntax) showing how data flows through the system. Show the request lifecycle: Client, Frontend, API/Backend, Auth, Database. Output the raw mermaid code starting with "sequenceDiagram". No text before or after the diagram.',
+    ctx,
+    "mermaid"
+  );
+}
+function dependencyGraphPrompt(ctx) {
+  return buildPrompt(
+    'Generate ONLY a Mermaid flowchart (flowchart LR syntax) showing the module/package dependency graph based on the import structure. Show which modules import from which other modules. Group related modules. Output the raw mermaid code starting with "flowchart LR". No text before or after the diagram.',
+    ctx,
+    "mermaid"
+  );
+}
+function erDiagramPrompt(ctx) {
+  return buildPrompt(
+    'Generate ONLY a Mermaid ER diagram (erDiagram syntax) showing database tables/models, their columns with types, and relationships (one-to-many, many-to-many). Output the raw mermaid code starting with "erDiagram". No text before or after the diagram.',
+    ctx,
+    "mermaid"
+  );
+}
+function apiFlowPrompt(ctx) {
+  return buildPrompt(
+    'Generate ONLY a Mermaid sequence diagram (sequenceDiagram syntax) showing the API request flow: Client ->> API Gateway ->> Auth Middleware ->> Route Handler ->> Service Layer ->> Database. Show success and error paths. Output the raw mermaid code starting with "sequenceDiagram". No text before or after the diagram.',
+    ctx,
+    "mermaid"
+  );
+}
+function architectureDocPrompt(ctx) {
+  return buildPrompt(
+    "Generate an ARCHITECTURE.md document explaining the system architecture. Include: overview, component descriptions, data flow explanation, key design decisions, and where to find each component in the codebase.",
+    ctx
+  );
+}
+
+// src/engines/architecture-engine.ts
+async function runArchitectureEngine(input, output, progress) {
+  progress.start("Architecture Engine", 6);
+  const ctx = { ...input.context };
+  if (input.imports.length > 0) {
+    const depSummary = input.imports.slice(0, 30).map((i) => `${i.file} \u2192 ${i.imports.join(", ")}`).join("\n");
+    ctx.additionalContext = (ctx.additionalContext || "") + `
+Import graph:
+${depSummary}`;
+  }
+  if (input.models.length > 0) {
+    ctx.additionalContext = (ctx.additionalContext || "") + `
+Database models:
+${input.models.map((m) => `${m.name} (${m.orm}) in ${m.file}: ${m.fields.slice(0, 5).join(", ")}`).join("\n")}`;
+  }
+  if (input.routes.length > 0) {
+    ctx.additionalContext = (ctx.additionalContext || "") + `
+API routes:
+${input.routes.map((r) => `${r.method} ${r.path}`).join("\n")}`;
+  }
+  const diagrams = [
+    { key: "arch", label: "System Architecture", promptFn: systemArchitecturePrompt, file: "diagrams/architecture.mmd", title: "System Architecture" },
+    { key: "dataflow", label: "Data Flow", promptFn: dataFlowPrompt, file: "diagrams/data-flow.mmd", title: "Data Flow" },
+    { key: "deps", label: "Dependency Graph", promptFn: dependencyGraphPrompt, file: "diagrams/dependency-graph.mmd", title: "Dependency Graph" },
+    { key: "er", label: "Database Schema", promptFn: erDiagramPrompt, file: "diagrams/database-schema.mmd", title: "Database Schema" },
+    { key: "apiflow", label: "API Flow", promptFn: apiFlowPrompt, file: "diagrams/api-flow.mmd", title: "API Request Flow" }
+  ];
+  const mermaidSections = [];
+  for (const diag of diagrams) {
+    progress.increment(diag.label);
+    const prompt = diag.promptFn(ctx);
+    const result = await askCopilot(prompt);
+    await output.write(diag.file, result);
+    mermaidSections.push(embedMermaidInMarkdown(diag.title, result));
+  }
+  progress.increment("ARCHITECTURE.md");
+  const archDocPrompt = architectureDocPrompt(ctx);
+  const archDoc = await askCopilot(archDocPrompt);
+  const fullArchDoc = archDoc + "\n\n---\n\n" + mermaidSections.join("\n---\n\n");
+  await output.write("ARCHITECTURE.md", fullArchDoc);
+  progress.succeed("Architecture Engine");
+  let score = 30;
+  if (input.imports.length > 0) score += 15;
+  if (input.models.length > 0) score += 15;
+  if (input.routes.length > 0) score += 15;
+  const uniqueDirs = new Set(input.imports.map((i) => i.file.split("/")[0]));
+  if (uniqueDirs.size >= 3) score += 10;
+  if (uniqueDirs.size >= 5) score += 5;
+  if (input.imports.length === 0 && input.routes.length === 0) score -= 10;
+  score = Math.max(0, Math.min(100, score));
+  return {
+    score,
+    details: `${input.imports.length} imports, ${input.models.length} models, ${input.routes.length} routes, ${uniqueDirs.size} top-level dirs`
+  };
+}
+
+// src/engines/security-engine.ts
+import { join as join4 } from "path";
+
+// src/prompts/security.prompts.ts
+function securityAuditPrompt(ctx) {
+  return buildPrompt(
+    "Perform a comprehensive security audit of this codebase. For each finding, provide: severity (Critical/High/Medium/Low), category (OWASP Top 10 mapping), description, exact location, and recommended fix. Include an overall risk grade (A-F). Check for: hardcoded secrets, SQL injection, XSS, path traversal, command injection, insecure crypto, authentication issues, authorization gaps, input validation, CORS misconfiguration, sensitive data exposure.",
+    ctx
+  );
+}
+function vulnerabilityReportPrompt(ctx) {
+  return buildPrompt(
+    "Generate a vulnerability report analyzing: 1) Known vulnerabilities in dependencies (based on package versions). 2) Code-level security issues found through pattern analysis. For each vulnerability, provide: CVE (if applicable), severity, affected component, description, and remediation steps.",
+    ctx
+  );
+}
+function secretsScanPrompt(ctx) {
+  return buildPrompt(
+    "Scan for hardcoded secrets in the codebase. Look for: API keys, passwords, tokens, private keys, connection strings, and other sensitive data in source code and config files. For each finding, provide the file, line pattern, type of secret, and risk level.",
+    ctx,
+    "json"
+  );
+}
+function threatModelPrompt(ctx) {
+  return buildPrompt(
+    "Generate a Mermaid threat model diagram. Show: trust boundaries, data flows across boundaries, potential attack surfaces, threat actors, and data stores. Use flowchart TD syntax with subgraphs for trust boundaries.",
+    ctx,
+    "mermaid"
+  );
+}
+function remediationPrompt(ctx) {
+  return buildPrompt(
+    "Generate a step-by-step remediation guide for the security issues found. For each issue, provide: the problem, why it matters, the exact fix (with code examples), and how to verify the fix works. Prioritize by severity.",
+    ctx
+  );
+}
+
+// src/engines/security-engine.ts
+function quickSecurityScan(rootDir, files) {
+  const findings = [];
+  const patterns = [
+    { name: "Hardcoded password", pattern: /(?:password|passwd|pwd)\s*[:=]\s*['"][^'"]{3,}['"]/gi, severity: "High" },
+    { name: "Hardcoded API key", pattern: /(?:api[_-]?key|apikey)\s*[:=]\s*['"][^'"]{8,}['"]/gi, severity: "High" },
+    { name: "Hardcoded token", pattern: /(?:token|secret)\s*[:=]\s*['"][^'"]{8,}['"]/gi, severity: "High" },
+    { name: "SQL injection risk", pattern: /(?:query|execute)\s*\(\s*['"`].*?\$\{/gi, severity: "High" },
+    { name: "eval() usage", pattern: /\beval\s*\(/g, severity: "Medium" },
+    { name: "exec() with string", pattern: /\bexec(?:Sync)?\s*\(\s*['"`].*?\$\{/gi, severity: "High" },
+    { name: "MD5 usage", pattern: /\bmd5\b/gi, severity: "Medium" },
+    { name: "console.log in production", pattern: /console\.log\s*\(/g, severity: "Low" },
+    { name: "CORS wildcard", pattern: /cors\s*\(\s*\{[^}]*origin\s*:\s*['"]\*['"]/gi, severity: "Medium" },
+    { name: "Disabled SSL verification", pattern: /rejectUnauthorized\s*:\s*false/g, severity: "High" }
+  ];
+  const codeFiles = files.filter(
+    (f) => f.endsWith(".ts") || f.endsWith(".js") || f.endsWith(".py") || f.endsWith(".go") || f.endsWith(".java") || f.endsWith(".rb")
+  ).slice(0, 100);
+  for (const file of codeFiles) {
+    try {
+      const content = readFileContentSync(join4(rootDir, file));
+      for (const { name, pattern, severity } of patterns) {
+        const regex = new RegExp(pattern.source, pattern.flags);
+        if (regex.test(content)) {
+          findings.push(`[${severity}] ${name} in ${file}`);
+        }
+      }
+    } catch {
+    }
+  }
+  return findings;
+}
+async function runSecurityEngine(input, output, progress) {
+  progress.start("Security Engine", 6);
+  progress.increment("Pattern scanning");
+  const quickFindings = quickSecurityScan(input.rootDir, input.files);
+  const ctx = { ...input.context };
+  if (quickFindings.length > 0) {
+    ctx.additionalContext = (ctx.additionalContext || "") + `
+Quick security scan findings:
+${quickFindings.join("\n")}`;
+  }
+  progress.increment("Security audit");
+  const auditResult = await askCopilot(securityAuditPrompt(ctx));
+  await output.writeToSubdir("security", "SECURITY_AUDIT.md", auditResult);
+  progress.increment("Vulnerability analysis");
+  const vulnResult = await askCopilot(vulnerabilityReportPrompt(ctx));
+  await output.writeToSubdir("security", "VULNERABILITY_REPORT.md", vulnResult);
+  progress.increment("Secrets scan");
+  const secretsResult = await askCopilot(secretsScanPrompt(ctx));
+  await output.writeToSubdir("security", "secrets-scan.json", secretsResult);
+  progress.increment("Threat model");
+  const threatResult = await askCopilot(threatModelPrompt(ctx));
+  await output.writeToSubdir("security", "threat-model.mmd", threatResult);
+  progress.increment("Remediation guide");
+  const remResult = await askCopilot(remediationPrompt(ctx));
+  await output.writeToSubdir("security", "REMEDIATION.md", remResult);
+  progress.succeed("Security Engine");
+  const highCount = quickFindings.filter((f) => f.startsWith("[High]")).length;
+  const medCount = quickFindings.filter((f) => f.startsWith("[Medium]")).length;
+  const lowCount = quickFindings.filter((f) => f.startsWith("[Low]")).length;
+  let score = 100;
+  score -= highCount * 20;
+  score -= medCount * 10;
+  score -= lowCount * 3;
+  if (!input.hasGitignore) score -= 15;
+  if (input.hasEnvFile) score -= 10;
+  const vulnLower = vulnResult.toLowerCase();
+  const aiHighMatches = (vulnLower.match(/\bcritical\b|\bhigh\s*severity\b|\bhigh\s*risk\b/g) || []).length;
+  const aiMedMatches = (vulnLower.match(/\bmedium\s*severity\b|\bmedium\s*risk\b|\bmoderate\b/g) || []).length;
+  score -= aiHighMatches * 5;
+  score -= aiMedMatches * 2;
+  score = Math.max(0, Math.min(100, score));
+  const totalFindings = quickFindings.length + aiHighMatches + aiMedMatches;
+  return {
+    score,
+    details: `${quickFindings.length} pattern findings (${highCount}H/${medCount}M/${lowCount}L) + ${aiHighMatches + aiMedMatches} AI findings | .gitignore: ${input.hasGitignore ? "yes" : "NO"} | .env committed: ${input.hasEnvFile ? "YES" : "no"}`
+  };
+}
+
+// src/engines/ci-engine.ts
+import { join as join5 } from "path";
+
+// src/prompts/ci.prompts.ts
+function ciPipelinePrompt(ctx) {
+  return buildPrompt(
+    "Generate a complete GitHub Actions CI/CD workflow (ci.yml). Include: trigger on push to main and PRs, install dependencies with correct package manager, run linting, run tests, build the project, cache dependencies, and use appropriate Node.js/Python/Go version matrix. Make it production-ready.",
+    ctx
+  );
+}
+function dockerfileAuditPrompt(ctx) {
+  return buildPrompt(
+    "Audit this Dockerfile against best practices. Check for: running as root, missing multi-stage build, large base image, missing .dockerignore, no health check, exposed unnecessary ports, secrets in build args, layer optimization issues. For each finding, provide the issue, risk level, and corrected Dockerfile line.",
+    ctx
+  );
+}
+function dockerfileGeneratePrompt(ctx) {
+  return buildPrompt(
+    "Generate an optimized, production-ready Dockerfile for this project. Use multi-stage build, run as non-root user, use alpine base where possible, include health check, optimize layer caching, and add appropriate labels.",
+    ctx
+  );
+}
+function dockerComposePrompt(ctx) {
+  return buildPrompt(
+    "Generate a docker-compose.yml for local development. Include: the application service, database service (if detected), any required infrastructure (Redis, RabbitMQ, etc.), proper networking, volume mounts for live reload, environment variables, and health checks.",
+    ctx
+  );
+}
+function envExamplePrompt(ctx) {
+  return buildPrompt(
+    "Generate a .env.example file based on environment variables used in the codebase. For each variable, include a comment explaining its purpose and a placeholder value. Group by category (database, auth, external services, etc.).",
+    ctx
+  );
+}
+function takeItToProdPrompt(ctx) {
+  return buildPrompt(
+    `Generate a comprehensive production deployment guide called "Take It To Production". Include: 1) Pre-deployment checklist (environment variables, secrets, database migrations, build verification), 2) Deployment options with step-by-step instructions (cloud platforms like AWS/GCP/Azure, VPS, containerized with Docker/Kubernetes, static hosting if applicable), 3) DNS and SSL/TLS setup, 4) Monitoring and logging setup (health checks, APM, error tracking), 5) Scaling considerations (horizontal/vertical, load balancing, CDN), 6) Rollback strategy, 7) Post-deployment verification steps. Tailor specifically to this project's tech stack.`,
+    ctx
+  );
+}
+
+// src/engines/ci-engine.ts
+async function runCIEngine(input, output, progress) {
+  const totalSteps = 4 + (input.hasDockerfile ? 1 : 1) + (input.hasDockerCompose ? 0 : 1);
+  progress.start("CI/CD Engine", totalSteps);
+  const ctx = { ...input.context };
+  const generated = [];
+  if (!input.hasCIConfig) {
+    progress.increment("Generating CI pipeline");
+    const ciResult = await askCopilot(ciPipelinePrompt(ctx));
+    await output.writeToSubdir("infrastructure", "ci.yml", ciResult);
+    generated.push("ci.yml");
+  } else {
+    progress.increment("CI config exists");
+    generated.push("CI config already present");
+  }
+  if (input.hasDockerfile) {
+    progress.increment("Auditing Dockerfile");
+    try {
+      const dockerContent = await readFileTruncated(join5(input.rootDir, "Dockerfile"));
+      ctx.codeContext = dockerContent;
+      const auditResult = await askCopilot(dockerfileAuditPrompt(ctx));
+      await output.writeToSubdir("infrastructure", "DOCKER_AUDIT.md", auditResult);
+      generated.push("DOCKER_AUDIT.md");
+    } catch {
+      progress.increment("Dockerfile read failed");
+    }
+  } else {
+    progress.increment("Generating Dockerfile");
+    const dockerResult = await askCopilot(dockerfileGeneratePrompt(ctx));
+    await output.writeToSubdir("infrastructure", "Dockerfile.suggested", dockerResult);
+    generated.push("Dockerfile.suggested");
+  }
+  if (!input.hasDockerCompose) {
+    progress.increment("Generating Docker Compose");
+    const composeResult = await askCopilot(dockerComposePrompt(ctx));
+    await output.writeToSubdir("infrastructure", "docker-compose.suggested.yml", composeResult);
+    generated.push("docker-compose.suggested.yml");
+  }
+  if (!input.hasEnvExample) {
+    progress.increment("Generating .env.example");
+    const envResult = await askCopilot(envExamplePrompt(ctx));
+    await output.writeToSubdir("infrastructure", ".env.example", envResult);
+    generated.push(".env.example");
+  } else {
+    progress.increment(".env.example exists");
+  }
+  progress.increment("Generating production guide");
+  const prodGuide = await askCopilot(takeItToProdPrompt(ctx));
+  await output.writeToSubdir("infrastructure", "take-it-to-prod.md", prodGuide);
+  generated.push("take-it-to-prod.md");
+  progress.succeed("CI/CD Engine");
+  let score = 15;
+  if (input.hasCIConfig) score += 35;
+  if (input.hasDockerfile) score += 20;
+  if (input.hasEnvExample) score += 15;
+  if (input.hasDockerCompose) score += 15;
+  score = Math.max(0, Math.min(100, score));
+  const missing = [];
+  if (!input.hasCIConfig) missing.push("CI pipeline");
+  if (!input.hasDockerfile) missing.push("Dockerfile");
+  if (!input.hasEnvExample) missing.push(".env.example");
+  if (!input.hasDockerCompose) missing.push("docker-compose");
+  return {
+    score,
+    details: missing.length > 0 ? `Missing: ${missing.join(", ")}` : "All CI/CD infrastructure present"
+  };
+}
+
+// src/prompts/api-test.prompts.ts
+function apiTestsMarkdownPrompt(ctx) {
+  return buildPrompt(
+    "Generate API test documentation (API_TESTS.md). For each detected endpoint, provide: method, path, description, example request (curl command), expected response, and edge case tests (missing fields, invalid types, unauthorized access).",
+    ctx
+  );
+}
+function postmanCollectionPrompt(ctx) {
+  return buildPrompt(
+    "Generate a Postman collection JSON (v2.1 format) for all detected API endpoints. Include: request method, URL, headers, request body examples, and test scripts for response validation. Use {{baseUrl}} variable.",
+    ctx,
+    "json"
+  );
+}
+function testCoveragePrompt(ctx) {
+  return buildPrompt(
+    "Analyze the existing test coverage of this project. Report: which files/functions have tests, which ones are missing tests, overall estimated coverage percentage, and the test-to-code ratio. Identify the most critical untested areas.",
+    ctx
+  );
+}
+function missingTestsPrompt(ctx) {
+  return buildPrompt(
+    "Generate a list of missing tests for this project. For each untested function/route/component, provide: the file and function name, why it should be tested, a suggested test case description, and a code skeleton for the test.",
+    ctx
+  );
+}
+function shellTestsPrompt(ctx) {
+  return buildPrompt(
+    "Generate a shell script (api-tests.sh) that tests all detected API endpoints sequentially. Use curl commands with proper headers. Include success/failure checking, colored output, and a summary at the end.",
+    ctx
+  );
+}
+
+// src/engines/api-test-engine.ts
+async function runAPITestEngine(input, output, progress) {
+  progress.start("API Testing Engine", 5);
+  const ctx = { ...input.context };
+  if (input.routes.length > 0) {
+    ctx.additionalContext = (ctx.additionalContext || "") + `
+Detected API routes:
+${input.routes.map((r) => `${r.method} ${r.path} (${r.file})`).join("\n")}`;
+  }
+  const testFiles = input.files.filter(
+    (f) => f.includes(".test.") || f.includes(".spec.") || f.includes("__tests__") || f.includes("test_")
+  );
+  ctx.additionalContext = (ctx.additionalContext || "") + `
+Existing test files (${testFiles.length}): ${testFiles.slice(0, 20).join(", ")}`;
+  progress.increment("API test documentation");
+  const testsDoc = await askCopilot(apiTestsMarkdownPrompt(ctx));
+  await output.writeToSubdir("testing", "API_TESTS.md", testsDoc);
+  progress.increment("Postman collection");
+  const postmanResult = await askCopilot(postmanCollectionPrompt(ctx));
+  await output.writeToSubdir("testing", "api-collection.json", postmanResult);
+  progress.increment("Shell test script");
+  const shellResult = await askCopilot(shellTestsPrompt(ctx));
+  await output.writeToSubdir("testing", "api-tests.sh", shellResult);
+  progress.increment("Test coverage analysis");
+  const coverageResult = await askCopilot(testCoveragePrompt(ctx));
+  await output.writeToSubdir("testing", "TEST_COVERAGE_REPORT.md", coverageResult);
+  progress.increment("Missing tests analysis");
+  const missingResult = await askCopilot(missingTestsPrompt(ctx));
+  await output.writeToSubdir("testing", "MISSING_TESTS.md", missingResult);
+  progress.succeed("API Testing Engine");
+  let score = 10;
+  if (testFiles.length > 0) score += 20;
+  if (testFiles.length > 5) score += 10;
+  if (testFiles.length > 10) score += 10;
+  if (testFiles.length > 20) score += 10;
+  if (input.routes.length > 0) {
+    const ratio = Math.min(testFiles.length / input.routes.length, 1);
+    score += Math.round(ratio * 30);
+    if (ratio < 0.3) score -= 10;
+  } else {
+    score += Math.min(testFiles.length * 3, 20);
+  }
+  if (testFiles.length === 0) score -= 5;
+  score = Math.max(0, Math.min(100, score));
+  return {
+    score,
+    details: `${testFiles.length} test files, ${input.routes.length} routes, coverage ratio: ${input.routes.length > 0 ? Math.round(testFiles.length / input.routes.length * 100) + "%" : "N/A"}`
+  };
+}
+
+// src/engines/performance-engine.ts
+import { join as join6 } from "path";
+
+// src/prompts/performance.prompts.ts
+function performanceAuditPrompt(ctx) {
+  return buildPrompt(
+    "Perform a performance audit of this codebase. Detect anti-patterns: N+1 queries, missing database indexes, blocking I/O in async code, memory leak patterns, unbounded queries, missing caching, inefficient algorithms, large payload responses, missing compression, bundle size issues. For each finding: describe the issue, its performance impact, location, and provide an optimized solution.",
+    ctx
+  );
+}
+function performanceScorePrompt(ctx) {
+  return buildPrompt(
+    "Generate a performance score (0-100) for this codebase as JSON. Include scores for: backend performance, frontend performance (if applicable), database efficiency, caching strategy, and infrastructure optimization. Provide an overall weighted score.",
+    ctx,
+    "json"
+  );
+}
+
+// src/engines/performance-engine.ts
+function quickPerformanceScan(rootDir, files) {
+  const findings = [];
+  const patterns = [
+    { name: "Sync file I/O in async context", pattern: /readFileSync|writeFileSync/g, impact: "Blocks event loop" },
+    { name: "SELECT * query", pattern: /SELECT\s+\*/gi, impact: "Fetches unnecessary data" },
+    { name: "Missing LIMIT clause", pattern: /\.find\(\s*\{[^}]*\}\s*\)(?!.*\.limit)/g, impact: "Unbounded query results" },
+    { name: "Nested await in loop", pattern: /for\s*\([^)]*\)\s*\{[^}]*await\s/g, impact: "Sequential async operations" },
+    { name: "console.log in hot path", pattern: /console\.log/g, impact: "I/O overhead in production" },
+    { name: "Large JSON.stringify", pattern: /JSON\.stringify\s*\([^)]*\)/g, impact: "CPU-intensive for large objects" },
+    { name: "No compression middleware", pattern: /compression/g, impact: "Check: compression middleware" }
+  ];
+  const codeFiles = files.filter(
+    (f) => f.endsWith(".ts") || f.endsWith(".js") || f.endsWith(".py") || f.endsWith(".go")
+  ).slice(0, 80);
+  for (const file of codeFiles) {
+    try {
+      const content = readFileContentSync(join6(rootDir, file));
+      for (const { name, pattern, impact } of patterns) {
+        const regex = new RegExp(pattern.source, pattern.flags);
+        const matches = content.match(regex);
+        if (matches && matches.length > 0) {
+          findings.push(`${name} in ${file} (${matches.length} occurrence(s)) \u2014 ${impact}`);
+        }
+      }
+    } catch {
+    }
+  }
+  return findings;
+}
+async function runPerformanceEngine(input, output, progress) {
+  progress.start("Performance Engine", 3);
+  progress.increment("Pattern scanning");
+  const quickFindings = quickPerformanceScan(input.rootDir, input.files);
+  const ctx = { ...input.context };
+  if (quickFindings.length > 0) {
+    ctx.additionalContext = (ctx.additionalContext || "") + `
+Performance scan findings:
+${quickFindings.join("\n")}`;
+  }
+  progress.increment("Performance audit");
+  const auditResult = await askCopilot(performanceAuditPrompt(ctx));
+  await output.writeToSubdir("performance", "PERFORMANCE_AUDIT.md", auditResult);
+  progress.increment("Performance scoring");
+  const scoreResult = await askCopilot(performanceScorePrompt(ctx));
+  await output.writeToSubdir("performance", "performance-score.json", scoreResult);
+  progress.succeed("Performance Engine");
+  let score = 70;
+  score -= quickFindings.length * 5;
+  if (quickFindings.length === 0) score = 95;
+  score = Math.max(10, Math.min(100, score));
+  return {
+    score,
+    details: `${quickFindings.length} performance anti-patterns detected`
+  };
+}
+
+// src/prompts/team.prompts.ts
+function prTemplatePrompt(ctx) {
+  return buildPrompt(
+    'Generate a pull request template (PULL_REQUEST_TEMPLATE.md) tailored to this project. Include: description section, type of change checkboxes, checklist specific to the tech stack (e.g., "Did you run tests?", "Did you update types?"), screenshots section for UI changes, and related issues section.',
+    ctx
+  );
+}
+function bugReportPrompt(ctx) {
+  return buildPrompt(
+    "Generate a GitHub issue template for bug reports (bug_report.md) in YAML frontmatter format. Include fields: description, steps to reproduce, expected behavior, actual behavior, environment (with options detected from the project), screenshots, and additional context.",
+    ctx
+  );
+}
+function featureRequestPrompt(ctx) {
+  return buildPrompt(
+    "Generate a GitHub issue template for feature requests (feature_request.md) in YAML frontmatter format. Include fields: feature description, problem it solves, proposed solution, alternatives considered, and additional context.",
+    ctx
+  );
+}
+function codeReviewChecklistPrompt(ctx) {
+  return buildPrompt(
+    "Generate a code review checklist (CODE_REVIEW_CHECKLIST.md) specific to this project stack. Include checks for: code quality, type safety, error handling, testing, security, performance, accessibility (if frontend), database (if applicable), and documentation.",
+    ctx
+  );
+}
+function onboardingPrompt(ctx) {
+  return buildPrompt(
+    'Generate an ONBOARDING.md guide for new contributors. Include: architecture overview, key files and what they do, development workflow, how to run/test locally, common tasks walkthrough, coding conventions, and a "start here" path for first contributions.',
+    ctx
+  );
+}
+function developmentWorkflowPrompt(ctx) {
+  return buildPrompt(
+    "Generate a DEVELOPMENT_WORKFLOW.md describing the recommended Git workflow. Include: branching strategy (feature branches, release branches), commit conventions, PR process, code review expectations, release process, and hotfix procedure.",
+    ctx
+  );
+}
+
+// src/engines/team-engine.ts
+async function runTeamEngine(input, output, progress) {
+  progress.start("Team Engine", 7);
+  const ctx = { ...input.context };
+  if (input.gitAnalysis.contributors.length > 0) {
+    ctx.additionalContext = (ctx.additionalContext || "") + `
+Contributors:
+${input.gitAnalysis.contributors.map((c) => `${c.name} (${c.commits} commits)`).join("\n")}`;
+  }
+  progress.increment("PR template");
+  const prResult = await askCopilot(prTemplatePrompt(ctx));
+  await output.writeToSubdir("team", "PULL_REQUEST_TEMPLATE.md", prResult);
+  progress.increment("Bug report template");
+  const bugResult = await askCopilot(bugReportPrompt(ctx));
+  await output.writeToSubdir("team/ISSUE_TEMPLATE", "bug_report.md", bugResult);
+  progress.increment("Feature request template");
+  const featureResult = await askCopilot(featureRequestPrompt(ctx));
+  await output.writeToSubdir("team/ISSUE_TEMPLATE", "feature_request.md", featureResult);
+  progress.increment("Issue template config");
+  const configYml = `blank_issues_enabled: true
+contact_links:
+  - name: Documentation
+    url: ./README.md
+    about: Check the documentation before filing an issue
+`;
+  await output.writeToSubdir("team/ISSUE_TEMPLATE", "config.yml", configYml);
+  progress.increment("CODEOWNERS");
+  const codeownersLines = ["# Auto-generated by RepoSentry", ""];
+  for (const [dir, owner] of input.gitAnalysis.directoryOwnership) {
+    codeownersLines.push(`/${dir}/ @${owner.replace(/\s+/g, "-").toLowerCase()}`);
+  }
+  if (codeownersLines.length <= 2) {
+    codeownersLines.push("* @" + (input.gitAnalysis.contributors[0]?.name.replace(/\s+/g, "-").toLowerCase() || "owner"));
+  }
+  await output.writeToSubdir("team", "CODEOWNERS", codeownersLines.join("\n"));
+  progress.increment("Code review checklist");
+  const reviewResult = await askCopilot(codeReviewChecklistPrompt(ctx));
+  await output.writeToSubdir("team", "CODE_REVIEW_CHECKLIST.md", reviewResult);
+  progress.increment("Onboarding guide");
+  const onboardResult = await askCopilot(onboardingPrompt(ctx));
+  await output.writeToSubdir("team", "ONBOARDING.md", onboardResult);
+  const workflowResult = await askCopilot(developmentWorkflowPrompt(ctx));
+  await output.writeToSubdir("team", "DEVELOPMENT_WORKFLOW.md", workflowResult);
+  progress.succeed("Team Engine");
+  let score = 15;
+  if (input.hasPRTemplate) score += 25;
+  if (input.hasIssueTemplates) score += 20;
+  if (input.hasCodeowners) score += 20;
+  if (input.gitAnalysis.contributors.length > 1) score += 10;
+  if (input.gitAnalysis.contributors.length > 3) score += 10;
+  const missing = [];
+  if (!input.hasPRTemplate) missing.push("PR template");
+  if (!input.hasIssueTemplates) missing.push("issue templates");
+  if (!input.hasCodeowners) missing.push("CODEOWNERS");
+  score = Math.max(0, Math.min(100, score));
+  return {
+    score,
+    details: missing.length > 0 ? `Missing: ${missing.join(", ")} | ${input.gitAnalysis.contributors.length} contributors` : `All collaboration files present | ${input.gitAnalysis.contributors.length} contributors`
+  };
+}
+
+// src/utils/scoring.ts
+function calculateGrade(score) {
+  if (score >= 97) return "A+";
+  if (score >= 93) return "A";
+  if (score >= 90) return "A-";
+  if (score >= 87) return "B+";
+  if (score >= 83) return "B";
+  if (score >= 80) return "B-";
+  if (score >= 77) return "C+";
+  if (score >= 73) return "C";
+  if (score >= 70) return "C-";
+  if (score >= 67) return "D+";
+  if (score >= 63) return "D";
+  if (score >= 60) return "D-";
+  return "F";
+}
+function calculateOverallScore(categories) {
+  if (categories.length === 0) return 0;
+  const weights = {
+    "Security": 2,
+    "Testing": 1.5,
+    "CI/CD": 1.2,
+    "Documentation": 1,
+    "Architecture": 1,
+    "Performance": 1.2,
+    "Collaboration": 0.8
+  };
+  let weightedSum = 0;
+  let totalWeight = 0;
+  for (const c of categories) {
+    const w = weights[c.name] ?? 1;
+    weightedSum += c.score * w;
+    totalWeight += w;
+  }
+  return Math.round(weightedSum / totalWeight);
+}
+
+// src/prompts/health.prompts.ts
+function healthSummaryPrompt(ctx) {
+  return buildPrompt(
+    "Generate a concise health report summary for this project. Based on the analysis results provided in the additional context, create a markdown health dashboard showing: overall grade (A-F), per-category grades and scores, top 3 priority actions, and key statistics (files scanned, languages, contributors).",
+    ctx
+  );
+}
+
+// src/engines/health-engine.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, existsSync as existsSync2 } from "fs";
+import { join as join7 } from "path";
+function loadHistory(outputDir) {
+  const historyPath = join7(outputDir, "history.json");
+  if (!existsSync2(historyPath)) return [];
+  try {
+    const raw = readFileSync3(historyPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function saveHistory(outputDir, history) {
+  const historyPath = join7(outputDir, "history.json");
+  writeFileSync2(historyPath, JSON.stringify(history, null, 2), "utf-8");
+}
+function buildMethodologyDoc(categories) {
+  const weights = {
+    "Security": 2,
+    "Testing": 1.5,
+    "CI/CD": 1.2,
+    "Documentation": 1,
+    "Architecture": 1,
+    "Performance": 1.2,
+    "Collaboration": 0.8
+  };
+  const lines = [
+    "# Scoring Methodology",
+    "",
+    "> **Transparency note:** RepoSentry scores are based on what your project *already has*, not on what RepoSentry generates. Generated files do not inflate your score.",
+    "",
+    "---",
+    "",
+    "## Grade Scale",
+    "",
+    "| Grade | Score Range |",
+    "|-------|------------|",
+    "| A+    | 97 \u2013 100   |",
+    "| A     | 93 \u2013 96    |",
+    "| A-    | 90 \u2013 92    |",
+    "| B+    | 87 \u2013 89    |",
+    "| B     | 83 \u2013 86    |",
+    "| B-    | 80 \u2013 82    |",
+    "| C+    | 77 \u2013 79    |",
+    "| C     | 73 \u2013 76    |",
+    "| C-    | 70 \u2013 72    |",
+    "| D+    | 67 \u2013 69    |",
+    "| D     | 63 \u2013 66    |",
+    "| D-    | 60 \u2013 62    |",
+    "| F     | 0 \u2013 59     |",
+    "",
+    "---",
+    "",
+    "## Overall Score = Weighted Average",
+    "",
+    "Not all categories weigh equally. Security and Testing carry more weight because they directly affect production readiness.",
+    "",
+    "| Category | Weight | Reason |",
+    "|----------|--------|--------|",
+    "| Security | 2.0\xD7 | Vulnerabilities directly impact production safety |",
+    "| Testing | 1.5\xD7 | Test coverage is critical for reliability |",
+    "| CI/CD | 1.2\xD7 | Automation reduces human error |",
+    "| Performance | 1.2\xD7 | Anti-patterns affect user experience |",
+    "| Documentation | 1.0\xD7 | Standard weight |",
+    "| Architecture | 1.0\xD7 | Standard weight |",
+    "| Collaboration | 0.8\xD7 | Important but less urgent than code quality |",
+    "",
+    "**Formula:** `Overall = \u03A3(category_score \xD7 weight) / \u03A3(weight)`",
+    "",
+    "---",
+    "",
+    "## Per-Category Scoring",
+    "",
+    "### Documentation (weight: 1.0\xD7)",
+    "- Base: 20 points",
+    "- Has existing README: +25",
+    "- Has API routes documented: +10",
+    "- Active development (>3 recent commits): +10",
+    "- Has version tags: +15",
+    "- No README: \u221210",
+    "- No commits: \u22125",
+    "",
+    "### Architecture (weight: 1.0\xD7)",
+    "- Base: 30 points",
+    "- Has module imports (structured codebase): +15",
+    "- Has data models: +15",
+    "- Has API routes: +15",
+    "- 3+ top-level directories (separation of concerns): +10",
+    "- 5+ top-level directories: +5",
+    "- No imports and no routes (monolithic): \u221210",
+    "",
+    "### Security (weight: 2.0\xD7)",
+    "- Starts at 100 (clean baseline)",
+    "- Per High-severity finding (hardcoded secrets, SQL injection, etc.): \u221220",
+    "- Per Medium-severity finding (eval, CORS, MD5): \u221210",
+    "- Per Low-severity finding (console.log, etc.): \u22123",
+    "- No .gitignore: \u221215",
+    "- .env file committed: \u221210",
+    "- AI-identified critical/high-risk findings: \u22125 each",
+    "- AI-identified medium-risk findings: \u22122 each",
+    "",
+    "### CI/CD (weight: 1.2\xD7)",
+    "- Base: 15 points",
+    "- Has CI/CD pipeline config: +35",
+    "- Has Dockerfile: +20",
+    "- Has .env.example: +15",
+    "- Has docker-compose: +15",
+    "",
+    "### Testing (weight: 1.5\xD7)",
+    "- Base: 10 points",
+    "- Has any test files: +20",
+    "- Has >5 test files: +10",
+    "- Has >10 test files: +10",
+    "- Has >20 test files: +10",
+    "- Route coverage ratio \xD7 30 (if routes exist)",
+    "- Very low test-to-route ratio (<30%): \u221210",
+    "- Zero test files: \u22125",
+    "",
+    "### Performance (weight: 1.2\xD7)",
+    "- Base: 70 points (if anti-patterns found) / 95 (if clean)",
+    "- Per anti-pattern detected: \u22125",
+    "- Scans for: sync I/O, SELECT *, unbounded queries, nested awaits, console.log in hot paths, uncompressed payloads",
+    "",
+    "### Collaboration (weight: 0.8\xD7)",
+    "- Base: 15 points",
+    "- Has PR template: +25",
+    "- Has issue templates: +20",
+    "- Has CODEOWNERS: +20",
+    "- Multi-contributor (>1): +10",
+    "- Active team (>3 contributors): +10",
+    "",
+    "---",
+    "",
+    "*Scoring is deterministic and reproducible. Run the same analysis twice on an unchanged codebase and you will get the same score.*",
+    ""
+  ];
+  return lines.join("\n");
+}
+function buildHistorySection(history) {
+  if (history.length <= 1) return "";
+  const lines = [
+    "",
+    "---",
+    "",
+    "## Score History",
+    "",
+    "| # | Date | Overall | Grade | Documentation | Architecture | Security | CI/CD | Testing | Performance | Collaboration |",
+    "|---|------|---------|-------|---------------|--------------|----------|-------|---------|-------------|---------------|"
+  ];
+  const recent = history.slice(-10).reverse();
+  recent.forEach((entry, i) => {
+    const date = new Date(entry.analyzedAt).toLocaleDateString("en-US", { year: "numeric", month: "short", day: "numeric" });
+    const catMap = new Map(entry.categories.map((c) => [c.name, c]));
+    const cats = ["Documentation", "Architecture", "Security", "CI/CD", "Testing", "Performance", "Collaboration"];
+    const scores = cats.map((name) => {
+      const c = catMap.get(name);
+      return c ? `${c.score}` : "\u2014";
+    });
+    lines.push(`| ${i + 1} | ${date} | **${entry.overallScore}** | ${entry.overallGrade} | ${scores.join(" | ")} |`);
+  });
+  if (history.length >= 2) {
+    const prev = history[history.length - 2];
+    const curr = history[history.length - 1];
+    const diff = curr.overallScore - prev.overallScore;
+    const arrow = diff > 0 ? "\u{1F4C8}" : diff < 0 ? "\u{1F4C9}" : "\u27A1\uFE0F";
+    const sign = diff > 0 ? "+" : "";
+    lines.push("");
+    lines.push(`**Trend:** ${arrow} ${sign}${diff} points since last analysis`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+async function runHealthEngine(input, output, progress) {
+  progress.start("Health Report", 5);
+  const overallScore = calculateOverallScore(input.categories);
+  const overallGrade = calculateGrade(overallScore);
+  const ctx = { ...input.context };
+  ctx.additionalContext = (ctx.additionalContext || "") + `
+Analysis Results:
+Overall Score: ${overallScore}/100 (${overallGrade})
+` + input.categories.map((c) => `${c.name}: ${c.score}/100 (${c.grade}) \u2014 ${c.details}`).join("\n");
+  progress.increment("Health report");
+  const reportResult = await askCopilot(healthSummaryPrompt(ctx));
+  progress.increment("Score history");
+  const outputDir = output.getBaseDir();
+  const history = loadHistory(outputDir);
+  const now = (/* @__PURE__ */ new Date()).toUTCString();
+  const currentEntry = {
+    analyzedAt: now,
+    overallScore,
+    overallGrade,
+    categories: input.categories.map((c) => ({ name: c.name, score: c.score, grade: c.grade, details: c.details }))
+  };
+  history.push(currentEntry);
+  saveHistory(outputDir, history);
+  const historySection = buildHistorySection(history);
+  const header = `# RepoSentry Health Report \u2014 ${input.context.projectName}
+
+**Overall Grade: ${overallGrade}** (${overallScore}/100)
+**Analyzed:** ${now}
+**Files Scanned:** ${input.filesScanned} | **Languages:** ${input.context.languages.join(", ")}
+
+| Category | Grade | Score | Details |
+|----------|-------|-------|---------|
+${input.categories.map((c) => `| ${c.name} | ${c.grade} | ${c.score} | ${c.details} |`).join("\n")}
+
+> \u{1F4CA} See [SCORING_METHODOLOGY.md](./SCORING_METHODOLOGY.md) for how these scores are calculated.
+${historySection}
+---
+
+`;
+  await output.write("HEALTH_REPORT.md", header + reportResult);
+  progress.increment("analysis.json");
+  const analysisJson = JSON.stringify({
+    project: input.context.projectName,
+    analyzedAt: now,
+    overallScore,
+    overallGrade,
+    languages: input.context.languages,
+    frameworks: input.context.frameworks,
+    filesScanned: input.filesScanned,
+    totalFiles: input.totalFiles,
+    categories: input.categories.map((c) => ({
+      name: c.name,
+      score: c.score,
+      grade: c.grade,
+      details: c.details
+    })),
+    historyEntries: history.length
+  }, null, 2);
+  await output.write("analysis.json", analysisJson);
+  progress.increment("Scoring methodology");
+  const methodology = buildMethodologyDoc(input.categories);
+  await output.write("SCORING_METHODOLOGY.md", methodology);
+  progress.increment("Badge");
+  const badgeColor = overallScore >= 80 ? "brightgreen" : overallScore >= 60 ? "yellow" : "red";
+  const badgeUrl = `https://img.shields.io/badge/RepoSentry-${overallGrade}%20(${overallScore}%25)-${badgeColor}`;
+  const badgeMd = `# RepoSentry Badge
+
+[![RepoSentry Score: ${overallGrade}](${badgeUrl})](./HEALTH_REPORT.md)
+
+Add this to your README:
+\`\`\`markdown
+[![RepoSentry Score: ${overallGrade}](${badgeUrl})](./HEALTH_REPORT.md)
+\`\`\`
+`;
+  await output.write("badge.md", badgeMd);
+  progress.succeed("Health Report");
+  return { overallScore, overallGrade };
+}
+
+// src/core/orchestrator.ts
+function shouldRunAll(opts) {
+  return !opts.docs && !opts.architecture && !opts.security && !opts.ci && !opts.apiTests && !opts.performance && !opts.team && !opts.health;
+}
+async function runAnalysis(opts) {
+  const cwd = process.cwd();
+  const runAll = shouldRunAll(opts);
+  if (opts.verbose) setVerbose(true);
+  const banner = boxen(
+    `${chalk.bold.cyan("RepoSentry")} ${chalk.dim(`v${getCliVersion()}`)}
+${chalk.dim("AI-Powered Codebase Intelligence Platform")}`,
+    { padding: 1, borderColor: "cyan", borderStyle: "round" }
+  );
+  console.log(banner);
+  logger.blank();
+  const isGit = isGitRepo(cwd);
+  if (!isGit) {
+    logger.warn("Not a Git repository \u2014 git-related analysis will be limited.");
+  }
+  if (opts.model) {
+    setCopilotModel(opts.model);
+    logger.info(`\u{1F9E0} Model: ${opts.model}`);
+  }
+  if (!isCopilotAvailable()) {
+    logger.warn("No Copilot CLI detected. Install: npm i -g @github/copilot  OR  winget install GitHub.Copilot");
+    logger.warn("Continuing \u2014 Copilot-powered analysis will return placeholder results.");
+  } else {
+    logger.info(`\u{1F916} Copilot backend: ${getCopilotBackendName()}`);
+  }
+  logger.info("\u{1F4C2} Scanning repository...");
+  const scanResult = await scanFiles(cwd, opts.ignore);
+  const langInfo = detectLanguages(cwd, scanResult.files);
+  const configInfo = detectConfigs(cwd, scanResult.files);
+  const projectName = getRepoName(cwd);
+  logger.info(`   Detected: ${langInfo.runtime || langInfo.languages[0] || "Unknown"} (${langInfo.languages.join(", ")}) | ${langInfo.frameworks.join(", ") || "No frameworks detected"}`);
+  logger.info(`   Files: ${scanResult.totalFiles} | Package Manager: ${langInfo.packageManager || "unknown"}`);
+  logger.blank();
+  logger.info("\u{1F50D} Running deep analysis...");
+  const imports = parseImports(cwd, scanResult.files);
+  const routes = detectRoutes(cwd, scanResult.files);
+  const models = detectModels(cwd, scanResult.files);
+  const gitAnalysis = analyzeGitHistory(cwd);
+  if (routes.length > 0) logger.dim(`   ${routes.length} API routes detected`);
+  if (models.length > 0) logger.dim(`   ${models.length} database models detected`);
+  if (gitAnalysis.contributors.length > 0) logger.dim(`   ${gitAnalysis.contributors.length} contributors found`);
+  logger.blank();
+  const fileTree = buildDirectoryTree(scanResult.files, 3);
+  const context = {
+    projectName,
+    languages: langInfo.languages,
+    frameworks: langInfo.frameworks,
+    packageManager: langInfo.packageManager,
+    fileTree
+  };
+  const outputDir = resolve2(cwd, opts.output);
+  const outputManager = new OutputManager({
+    baseDir: outputDir,
+    format: opts.format,
+    force: opts.force
+  });
+  await outputManager.init();
+  const categories = [];
+  const skipTeam = (runAll || opts.team) && !isGit;
+  const engines = [
+    runAll || opts.docs,
+    runAll || opts.architecture,
+    runAll || opts.security,
+    runAll || opts.ci,
+    runAll || opts.apiTests,
+    runAll || opts.performance,
+    (runAll || opts.team) && !skipTeam,
+    runAll || opts.health
+  ].filter(Boolean).length;
+  const progress = createProgress();
+  progress.setTotalSteps(engines);
+  console.log(chalk.dim("  \u23F3 Each AI analysis step may take 30-60s \u2014 this is normal.\n"));
+  if (runAll || opts.docs) {
+    const result = await runDocsEngine(
+      { context, routes, recentCommits: gitAnalysis.recentCommits, tags: gitAnalysis.tags, hasReadme: configInfo.hasReadme },
+      outputManager,
+      progress
+    );
+    categories.push({ name: "Documentation", score: result.score, grade: calculateGrade(result.score), details: result.details });
+  }
+  if (runAll || opts.architecture) {
+    const result = await runArchitectureEngine(
+      { context, imports, models, routes },
+      outputManager,
+      progress
+    );
+    categories.push({ name: "Architecture", score: result.score, grade: calculateGrade(result.score), details: result.details });
+  }
+  if (runAll || opts.security) {
+    const result = await runSecurityEngine(
+      { context, rootDir: cwd, files: scanResult.files, hasEnvFile: configInfo.hasEnvFile, hasGitignore: configInfo.hasGitignore, hasDockerfile: configInfo.hasDockerfile },
+      outputManager,
+      progress
+    );
+    categories.push({ name: "Security", score: result.score, grade: calculateGrade(result.score), details: result.details });
+  }
+  if (runAll || opts.ci) {
+    const result = await runCIEngine(
+      { context, rootDir: cwd, hasDockerfile: configInfo.hasDockerfile, hasDockerCompose: configInfo.hasDockerCompose, hasCIConfig: configInfo.hasCIConfig, hasEnvExample: configInfo.hasEnvExample },
+      outputManager,
+      progress
+    );
+    categories.push({ name: "CI/CD", score: result.score, grade: calculateGrade(result.score), details: result.details });
+  }
+  if (runAll || opts.apiTests) {
+    const result = await runAPITestEngine(
+      { context, routes, files: scanResult.files },
+      outputManager,
+      progress
+    );
+    categories.push({ name: "Testing", score: result.score, grade: calculateGrade(result.score), details: result.details });
+  }
+  if (runAll || opts.performance) {
+    const result = await runPerformanceEngine(
+      { context, rootDir: cwd, files: scanResult.files },
+      outputManager,
+      progress
+    );
+    categories.push({ name: "Performance", score: result.score, grade: calculateGrade(result.score), details: result.details });
+  }
+  if (runAll || opts.team) {
+    if (!isGit) {
+      logger.warn("Skipping Collaboration engine \u2014 not a Git repository.");
+    } else {
+      const result = await runTeamEngine(
+        { context, gitAnalysis, hasPRTemplate: configInfo.hasPRTemplate, hasIssueTemplates: configInfo.hasIssueTemplates, hasCodeowners: configInfo.hasCodeowners },
+        outputManager,
+        progress
+      );
+      categories.push({ name: "Collaboration", score: result.score, grade: calculateGrade(result.score), details: result.details });
+    }
+  }
+  if (runAll || opts.health) {
+    const healthResult = await runHealthEngine(
+      { context, categories, filesScanned: scanResult.files.length, totalFiles: scanResult.totalFiles },
+      outputManager,
+      progress
+    );
+    logger.blank();
+    const emojiMap = {
+      "Documentation": "\u{1F4DD}",
+      "Architecture": "\u{1F3D7}\uFE0F",
+      "Security": "\u{1F512}",
+      "CI/CD": "\u{1F504}",
+      "Testing": "\u{1F9EA}",
+      "Performance": "\u26A1",
+      "Infrastructure": "\u{1F3E2}",
+      "Collaboration": "\u{1F91D}"
+    };
+    const summaryLines = categories.map((c) => {
+      const emoji = emojiMap[c.name] || "\u{1F4CA}";
+      return `   ${emoji} ${c.name.padEnd(16)} ${c.grade.padEnd(4)} (${c.score}/100)`;
+    });
+    const summaryBox = boxen(
+      [
+        `${chalk.bold("Analysis Complete!")}`,
+        "",
+        `${chalk.bold("Overall Grade:")} ${chalk.bold.cyan(healthResult.overallGrade)} (${healthResult.overallScore}/100)`,
+        "",
+        ...summaryLines,
+        "",
+        `${chalk.dim(`Output: ${opts.output}/ (${outputManager.getFileCount()} files generated)`)}`,
+        `${chalk.dim("Run `reposentry serve` to preview")}`
+      ].join("\n"),
+      { padding: 1, borderColor: "green", borderStyle: "round" }
+    );
+    console.log(summaryBox);
+  }
+  await outputManager.finalize();
+}
+
+// src/cli.ts
+import chalk2 from "chalk";
+
+// src/config.ts
+import { cosmiconfig } from "cosmiconfig";
+var DEFAULT_CONFIG = {
+  output: ".reposentry",
+  format: "markdown",
+  depth: "standard",
+  engines: {
+    docs: true,
+    architecture: true,
+    security: true,
+    ci: true,
+    apiTests: true,
+    performance: true,
+    team: true,
+    health: true
+  },
+  ignore: ["node_modules", "dist", "*.test.ts"],
+  security: {
+    severityThreshold: "medium",
+    ignorePatterns: ["*.test.*"]
+  },
+  ci: {
+    provider: "github-actions",
+    nodeVersions: ["18", "20"]
+  }
+};
+function mergeConfig(userConfig) {
+  return {
+    ...DEFAULT_CONFIG,
+    ...userConfig,
+    engines: {
+      ...DEFAULT_CONFIG.engines,
+      ...userConfig.engines || {}
+    },
+    security: {
+      ...DEFAULT_CONFIG.security,
+      ...userConfig.security || {}
+    },
+    ci: {
+      ...DEFAULT_CONFIG.ci,
+      ...userConfig.ci || {}
+    },
+    ignore: Array.isArray(userConfig.ignore) ? userConfig.ignore : DEFAULT_CONFIG.ignore
+  };
+}
+async function loadConfig() {
+  const explorer = cosmiconfig("reposentry");
+  try {
+    const result = await explorer.search();
+    if (result && result.config) {
+      return mergeConfig(result.config);
+    }
+  } catch {
+  }
+  return DEFAULT_CONFIG;
+}
+
+// src/cli.ts
+function createCLI() {
+  const program = new Command();
+  program.name("reposentry").description("RepoSentry \u2014 AI-powered codebase intelligence platform").version(getCliVersion());
+  const analyze = program.command("analyze").description("Analyze the current repository and generate reports").option("--all", "Run all engines (overrides config engine selection)", false).option("-o, --output <dir>", "Output directory (default: from config or .reposentry)").option("-f, --format <type>", "Output format: markdown | html | json (default: from config or markdown)").option("--depth <level>", "Analysis depth: quick | standard | deep (default: from config or standard)").option("--ignore <patterns...>", "Glob patterns to ignore").option("--force", "Overwrite existing output", false).option("-v, --verbose", "Show detailed analysis progress", false).option("-m, --model <model>", "AI model to use (backend-specific)").option("--docs", "Generate documentation suite only").option("--architecture", "Generate architecture diagrams only").option("--security", "Run security audit + threat model only").option("--ci", "Generate CI/CD pipeline + infrastructure only").option("--api-tests", "Generate API test collection only").option("--performance", "Run performance anti-pattern detection only").option("--team", "Generate collaboration templates only").option("--health", "Generate health report + grade only").option("--no-color", "Disable colored output").addHelpText("after", `
+${chalk2.bold("Engine Flags:")}
+  Run specific engines instead of the full analysis:
+    --docs          README, API docs, SETUP, CONTRIBUTING, CHANGELOG, FAQ
+    --architecture  Mermaid diagrams + ARCHITECTURE.md
+    --security      Vulnerability scan, threat model, security report
+    --ci            GitHub Actions, Dockerfile, Docker Compose, .env
+    --api-tests     API test docs, Postman collection, test scripts
+    --performance   Anti-pattern detection + performance audit
+    --team          PR templates, issue templates, CODEOWNERS, onboarding
+    --health        Aggregate health score + grade badge
+
+${chalk2.bold("Examples:")}
+  $ reposentry analyze                    Full analysis with all engines
+  $ reposentry analyze --docs --ci        Only docs + CI/CD
+  $ reposentry analyze --model <name>     Use a specific model (if supported)
+  $ reposentry analyze --security -v      Security audit with verbose output
+`).action(async (options) => {
+    const config = await loadConfig();
+    const hasAnyEngineFlag = Boolean(
+      options.docs || options.architecture || options.security || options.ci || options.apiTests || options.performance || options.team || options.health
+    );
+    const useConfigEngines = !options.all && !hasAnyEngineFlag;
+    const opts = {
+      output: options.output ?? config.output,
+      format: options.format ?? config.format,
+      depth: options.depth ?? config.depth,
+      ignore: options.ignore && options.ignore.length > 0 ? options.ignore : config.ignore,
+      force: options.force,
+      verbose: options.verbose,
+      model: options.model,
+      ...useConfigEngines ? {
+        docs: config.engines.docs,
+        architecture: config.engines.architecture,
+        security: config.engines.security,
+        ci: config.engines.ci,
+        apiTests: config.engines.apiTests,
+        performance: config.engines.performance,
+        team: config.engines.team,
+        health: config.engines.health
+      } : {
+        docs: options.docs,
+        architecture: options.architecture,
+        security: options.security,
+        ci: options.ci,
+        apiTests: options.apiTests,
+        performance: options.performance,
+        team: options.team,
+        health: options.health
+      }
+    };
+    try {
+      await runAnalysis(opts);
+    } catch (err) {
+      console.error(`
+\u274C Analysis failed: ${err.message}`);
+      if (options.verbose) console.error(err.stack);
+      process.exit(1);
+    }
+  });
+  program.command("serve").description("Preview generated reports in browser").option("--port <port>", "Port to listen on", "3000").option("-o, --output <dir>", "Output directory to serve (default: from config or .reposentry)").action(async (options) => {
+    const { startServer } = await import("./server-UJNM6VUZ.js");
+    const config = await loadConfig();
+    await startServer({
+      port: parseInt(options.port, 10),
+      outputDir: options.output ?? config.output
+    });
+  });
+  program.command("badge").description("Generate health/security badge for README").option("-o, --output <dir>", "Output directory (default: from config or .reposentry)").action(async (options) => {
+    const { resolve: resolve3 } = await import("path");
+    const { readFileContent } = await import("./fs-GEDK6OCC.js");
+    try {
+      const config = await loadConfig();
+      const outputDir = options.output ?? config.output;
+      const analysisPath = resolve3(process.cwd(), outputDir, "analysis.json");
+      const data = JSON.parse(await readFileContent(analysisPath));
+      console.log(`
+\u{1F4DB} RepoSentry Badge for ${data.project}:`);
+      console.log(`   Grade: ${data.overallGrade} (${data.overallScore}/100)`);
+      const color = data.overallScore >= 80 ? "brightgreen" : data.overallScore >= 60 ? "yellow" : "red";
+      const url = `https://img.shields.io/badge/RepoSentry-${data.overallGrade}%20(${data.overallScore}%25)-${color}`;
+      console.log(`
+   Markdown:
+   [![RepoSentry Score: ${data.overallGrade}](${url})](./HEALTH_REPORT.md)
+`);
+    } catch {
+      console.error("\u274C No analysis found. Run `reposentry analyze` first.");
+    }
+  });
+  program.command("compare").description("Compare current score against a previous analysis run").option("-o, --output <dir>", "Output directory (default: from config or .reposentry)").action(async (options) => {
+    const { resolve: resolve3 } = await import("path");
+    const { readFileSync: readFS, existsSync: existsFS } = await import("fs");
+    const readline = await import("readline");
+    const config = await loadConfig();
+    const outputDir = options.output ?? config.output;
+    const historyPath = resolve3(process.cwd(), outputDir, "history.json");
+    if (!existsFS(historyPath)) {
+      console.error("\u274C No scoring history found. Run `reposentry analyze` first.");
+      process.exit(1);
+    }
+    let history;
+    try {
+      history = JSON.parse(readFS(historyPath, "utf-8"));
+    } catch {
+      console.error("\u274C Could not parse history.json.");
+      process.exit(1);
+    }
+    if (history.length < 2) {
+      console.error("\u274C Need at least 2 analysis runs to compare. Run `reposentry analyze` again after making changes.");
+      process.exit(1);
+    }
+    const latest = history[history.length - 1];
+    const latestId = history.length;
+    console.log(`
+${chalk2.bold.cyan("\u{1F6E1}\uFE0F  RepoSentry Score History")}
+`);
+    console.log(chalk2.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(`  ${chalk2.bold("ID".padEnd(5))}${chalk2.bold("Date".padEnd(28))}${chalk2.bold("Grade".padEnd(8))}${chalk2.bold("Score".padEnd(8))}${chalk2.bold("Categories")}`);
+    console.log(chalk2.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    for (let i = 0; i < history.length; i++) {
+      const entry = history[i];
+      const id = (i + 1).toString();
+      const date = new Date(entry.analyzedAt).toLocaleString();
+      const isLatest = i === history.length - 1;
+      const label = isLatest ? chalk2.dim(" (latest)") : "";
+      const catSummary = entry.categories.map((c) => `${c.name.substring(0, 3)}:${c.score}`).join(" ");
+      const gradeColor = entry.overallScore >= 80 ? chalk2.green : entry.overallScore >= 60 ? chalk2.yellow : chalk2.red;
+      console.log(
+        `  ${chalk2.cyan(id.padEnd(5))}${date.padEnd(28)}${gradeColor(entry.overallGrade.padEnd(8))}${gradeColor(entry.overallScore.toString().padEnd(8))}${chalk2.dim(catSummary)}${label}`
+      );
+    }
+    console.log(chalk2.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(chalk2.dim(`
+  Latest run: #${latestId}. Select an older run to compare against.
+`));
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise((resolve4) => rl.question(q, resolve4));
+    const input = (await ask(chalk2.cyan(`  Enter ID to compare (1-${latestId - 1}): `))).trim();
+    rl.close();
+    const selectedId = parseInt(input, 10);
+    if (isNaN(selectedId) || selectedId < 1 || selectedId >= latestId) {
+      console.error(chalk2.red(`
+  \u274C Invalid ID. Must be between 1 and ${latestId - 1}.
+`));
+      process.exit(1);
+    }
+    const older = history[selectedId - 1];
+    console.log(`
+${chalk2.bold("  Comparing Run #" + selectedId + " \u2192 Run #" + latestId + " (latest)")}
+`);
+    console.log(chalk2.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(`  ${chalk2.bold("Category".padEnd(20))}${chalk2.bold("Before".padEnd(14))}${chalk2.bold("After".padEnd(14))}${chalk2.bold("Change")}`);
+    console.log(chalk2.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    const olderMap = new Map(older.categories.map((c) => [c.name, c]));
+    const latestMap = new Map(latest.categories.map((c) => [c.name, c]));
+    const allCats = [.../* @__PURE__ */ new Set([...olderMap.keys(), ...latestMap.keys()])];
+    for (const cat of allCats) {
+      const o = olderMap.get(cat);
+      const l = latestMap.get(cat);
+      const before = o ? `${o.grade} (${o.score})` : "\u2014";
+      const after = l ? `${l.grade} (${l.score})` : "\u2014";
+      const diff = (l?.score ?? 0) - (o?.score ?? 0);
+      const arrow = diff > 0 ? chalk2.green(`+${diff}`) : diff < 0 ? chalk2.red(`${diff}`) : chalk2.dim(" 0");
+      console.log(`  ${cat.padEnd(20)}${before.padEnd(14)}${after.padEnd(14)}${arrow}`);
+    }
+    console.log(chalk2.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    const overallDiff = latest.overallScore - older.overallScore;
+    const overallArrow = overallDiff > 0 ? chalk2.green(`+${overallDiff}`) : overallDiff < 0 ? chalk2.red(`${overallDiff}`) : chalk2.dim(" 0");
+    const overallBefore = `${older.overallGrade} (${older.overallScore})`;
+    const overallAfter = `${latest.overallGrade} (${latest.overallScore})`;
+    console.log(`  ${chalk2.bold("OVERALL".padEnd(20))}${overallBefore.padEnd(14)}${overallAfter.padEnd(14)}${overallArrow}`);
+    console.log(chalk2.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n"));
+    if (overallDiff > 0) {
+      console.log(chalk2.green.bold("  \u{1F4C8} Great progress! Your codebase health improved.\n"));
+    } else if (overallDiff < 0) {
+      console.log(chalk2.red.bold("  \u{1F4C9} Score decreased. Check the category breakdown above.\n"));
+    } else {
+      console.log(chalk2.dim("  \u27A1\uFE0F  No change in overall score.\n"));
+    }
+  });
+  program.command("fix").description("Auto-fix detected issues in your project (creates missing files)").option("-o, --output <dir>", "RepoSentry output directory", ".reposentry").option("-m, --model <model>", "AI model to use").option("--all", "Fix all issues without prompting", false).option("--dry-run", "Show what would be fixed without making changes", false).action(async (options) => {
+    const { resolve: resolvePath } = await import("path");
+    const readline = await import("readline");
+    const { scanForFixableIssues, CI_PROVIDERS, buildDeployGuidePrompt } = await import("./fix-engine-W5U2J3IJ.js");
+    const { askCopilotWithWrite, isCopilotAvailable: isCopilotAvailable2, setCopilotModel: setCopilotModel2 } = await import("./copilot-OO6B2LU3.js");
+    const { createProgress: createProgress2 } = await import("./progress-EQXHBUOU.js");
+    const cwd = process.cwd();
+    console.log(`
+${chalk2.bold.cyan("\u{1F6E1}\uFE0F  RepoSentry Fix")} ${chalk2.dim("\u2014 Auto-fix detected issues")}
+`);
+    if (!isCopilotAvailable2()) {
+      console.error(chalk2.red("  \u274C Copilot CLI not found. Install: npm i -g @github/copilot"));
+      process.exit(1);
+    }
+    if (options.model) setCopilotModel2(options.model);
+    console.log(chalk2.dim("  Scanning project for fixable issues...\n"));
+    const { issues, context } = await scanForFixableIssues(cwd, ["node_modules", "dist", ".git"]);
+    if (issues.length === 0) {
+      console.log(chalk2.green("  \u2705 No fixable issues found! Your project looks great.\n"));
+      return;
+    }
+    const priorityColors = {
+      P0: chalk2.red.bold,
+      P1: chalk2.yellow.bold,
+      P2: chalk2.dim
+    };
+    const priorityLabels = {
+      P0: "\u{1F534} Critical",
+      P1: "\u{1F7E1} Important",
+      P2: "\u{1F535} Nice-to-have"
+    };
+    console.log(chalk2.bold(`  Found ${issues.length} fixable issue${issues.length > 1 ? "s" : ""}:
+`));
+    console.log(chalk2.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(`  ${chalk2.bold("#".padEnd(4))}${chalk2.bold("Pri".padEnd(6))}${chalk2.bold("Category".padEnd(18))}${chalk2.bold("Issue")}`);
+    console.log(chalk2.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    for (let i = 0; i < issues.length; i++) {
+      const issue = issues[i];
+      const color = priorityColors[issue.priority] || chalk2.dim;
+      const num = (i + 1).toString().padEnd(4);
+      console.log(`  ${chalk2.cyan(num)}${color(issue.priority.padEnd(6))}${issue.category.padEnd(18)}${issue.title}`);
+      console.log(chalk2.dim(`      ${issue.description}`));
+    }
+    console.log(chalk2.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    const p0Count = issues.filter((i) => i.priority === "P0").length;
+    const p1Count = issues.filter((i) => i.priority === "P1").length;
+    const p2Count = issues.filter((i) => i.priority === "P2").length;
+    console.log(chalk2.dim(`
+  ${priorityLabels.P0}: ${p0Count}  ${priorityLabels.P1}: ${p1Count}  ${priorityLabels.P2}: ${p2Count}
+`));
+    if (options.dryRun) {
+      console.log(chalk2.dim("  --dry-run: No changes made.\n"));
+      return;
+    }
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise((r) => rl.question(q, r));
+    let mode = "step";
+    if (options.all) {
+      mode = "all";
+    } else {
+      console.log(chalk2.bold("  How would you like to proceed?\n"));
+      console.log("  1. \u{1F680} Fix all issues automatically");
+      console.log("  2. \u{1F504} Step-by-step (confirm each fix)");
+      console.log("  3. \u{1F3AF} Select specific issues to fix");
+      console.log("  0. \u274C Cancel\n");
+      const choice = (await ask(chalk2.cyan("  Select mode (0-3): "))).trim();
+      if (choice === "0") {
+        console.log(chalk2.dim("\n  Cancelled.\n"));
+        rl.close();
+        return;
+      }
+      mode = choice === "1" ? "all" : choice === "3" ? "select" : "step";
+    }
+    let toFix = [...issues];
+    if (mode === "select") {
+      const input = (await ask(chalk2.cyan(`  Enter issue numbers to fix (e.g., 1,3,5): `))).trim();
+      const nums = input.split(",").map((s) => parseInt(s.trim(), 10)).filter((n) => !isNaN(n) && n >= 1 && n <= issues.length);
+      if (nums.length === 0) {
+        console.log(chalk2.red("\n  No valid issues selected.\n"));
+        rl.close();
+        return;
+      }
+      toFix = nums.map((n) => issues[n - 1]);
+    }
+    const ciIssue = toFix.find((i) => i.id === "ci-pipeline");
+    if (ciIssue) {
+      console.log(chalk2.bold("\n  \u{1F527} CI/CD Provider Selection\n"));
+      for (let i = 0; i < CI_PROVIDERS.length; i++) {
+        const rec = i === 0 ? chalk2.dim(" (Recommended)") : "";
+        console.log(`  ${chalk2.cyan((i + 1).toString().padStart(2))}. ${CI_PROVIDERS[i].name}${rec}`);
+      }
+      const ciChoice = (await ask(chalk2.cyan(`
+  Select CI provider (1-${CI_PROVIDERS.length}): `))).trim();
+      const ciIdx = parseInt(ciChoice, 10) - 1;
+      const provider = CI_PROVIDERS[ciIdx >= 0 && ciIdx < CI_PROVIDERS.length ? ciIdx : 0];
+      context.ciProvider = provider.name;
+      ciIssue.files = [provider.file];
+      console.log(chalk2.green(`  \u2713 Selected: ${provider.name}
+`));
+    }
+    rl.close();
+    console.log(chalk2.bold(`
+  Fixing ${toFix.length} issue${toFix.length > 1 ? "s" : ""}...
+`));
+    console.log(chalk2.dim("  \u23F3 Each fix may take 30-60s \u2014 Copilot is generating project-aware files.\n"));
+    const progress = createProgress2();
+    progress.setTotalSteps(toFix.length);
+    let fixed = 0;
+    let failed = 0;
+    const fixResults = [];
+    for (const issue of toFix) {
+      if (mode === "step") {
+        const rl2 = readline.createInterface({ input: process.stdin, output: process.stdout });
+        const answer = await new Promise((r) => rl2.question(
+          chalk2.cyan(`  Fix "${issue.title}"? (y/n/skip): `),
+          r
+        ));
+        rl2.close();
+        if (answer.trim().toLowerCase() !== "y") {
+          progress.increment(`Skipped: ${issue.title}`);
+          fixResults.push({ issue, success: false, output: "Skipped by user", filesCreated: [] });
+          continue;
+        }
+      }
+      progress.increment(issue.title);
+      const prompt = issue.promptBuilder(context);
+      console.log(chalk2.dim(`
+     \u{1F916} Asking Copilot to fix: ${issue.title}`));
+      console.log(chalk2.dim(`     \u{1F4C1} Expected files: ${issue.files.length > 0 ? issue.files.join(", ") : "(Copilot decides)"}`));
+      try {
+        const { existsSync: checkExists } = await import("fs");
+        const { join: joinPath } = await import("path");
+        const result = await askCopilotWithWrite(prompt, { projectDir: cwd, timeoutMs: 24e4 });
+        const isFailed = result.startsWith("[Fix failed");
+        const filesCreated = [];
+        for (const f of issue.files) {
+          const fullPath = joinPath(cwd, f);
+          if (checkExists(fullPath)) {
+            filesCreated.push(f);
+          }
+        }
+        const mentionedPaths = result.match(/(?:created|wrote|written|writing)\s+[`"']?([^\s`"']+\.\w+)/gi) || [];
+        for (const match of mentionedPaths) {
+          const pathMatch = match.match(/[`"']?([^\s`"']+\.\w+)/);
+          if (pathMatch) {
+            const mentioned = pathMatch[1];
+            const fullPath = joinPath(cwd, mentioned);
+            if (checkExists(fullPath) && !filesCreated.includes(mentioned)) {
+              filesCreated.push(mentioned);
+            }
+          }
+        }
+        if (isFailed) {
+          failed++;
+          console.log(chalk2.red(`     \u274C Failed: ${result.slice(0, 120)}`));
+          fixResults.push({ issue, success: false, output: result.slice(0, 200), filesCreated });
+        } else if (filesCreated.length > 0) {
+          fixed++;
+          for (const f of filesCreated) {
+            console.log(chalk2.green(`     \u2705 Created: ${f}`));
+          }
+          fixResults.push({ issue, success: true, output: result.slice(0, 200), filesCreated });
+        } else if (issue.files.length === 0) {
+          fixed++;
+          console.log(chalk2.green(`     \u2705 Copilot applied fix`));
+          console.log(chalk2.dim(`     \u{1F4DD} ${result.slice(0, 150)}`));
+          fixResults.push({ issue, success: true, output: result.slice(0, 200), filesCreated });
+        } else {
+          failed++;
+          console.log(chalk2.yellow(`     \u26A0\uFE0F  Copilot responded but files not found on disk`));
+          console.log(chalk2.dim(`     \u{1F4DD} ${result.slice(0, 200)}`));
+          fixResults.push({ issue, success: false, output: "Files not created on disk", filesCreated });
+        }
+      } catch (err) {
+        failed++;
+        console.log(chalk2.red(`     \u274C Error: ${err?.message?.slice(0, 120) || "Unknown error"}`));
+        fixResults.push({ issue, success: false, output: err?.message?.slice(0, 200) || "Unknown error", filesCreated: [] });
+      }
+    }
+    progress.succeed("All fixes");
+    console.log(`
+${chalk2.bold("  Fix Summary")}
+`);
+    console.log(chalk2.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    for (const r of fixResults) {
+      const icon = r.success ? chalk2.green("\u2705") : r.output === "Skipped by user" ? chalk2.dim("\u23ED\uFE0F") : chalk2.red("\u274C");
+      const fileInfo = r.filesCreated.length > 0 ? chalk2.dim(` \u2192 ${r.filesCreated.join(", ")}`) : "";
+      const failReason = !r.success && r.output !== "Skipped by user" ? chalk2.dim(` (${r.output.slice(0, 60)})`) : "";
+      console.log(`  ${icon} ${r.issue.title}${fileInfo}${failReason}`);
+    }
+    console.log(chalk2.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(`  ${chalk2.green.bold(`${fixed} fixed`)} | ${chalk2.red(`${failed} failed`)} | ${chalk2.dim(`${toFix.length - fixed - failed} skipped`)}
+`);
+    if (ciIssue && fixResults.find((r) => r.issue.id === "ci-pipeline" && r.success)) {
+      const rl3 = readline.createInterface({ input: process.stdin, output: process.stdout });
+      const wantDeploy = await new Promise(
+        (r) => rl3.question(chalk2.cyan("  Generate production deployment guide? (y/n): "), r)
+      );
+      rl3.close();
+      if (wantDeploy.trim().toLowerCase() === "y") {
+        console.log(chalk2.dim("\n  Generating take-it-to-prod.md...\n"));
+        const deployPrompt = buildDeployGuidePrompt(context);
+        await askCopilotWithWrite(deployPrompt, { projectDir: cwd, timeoutMs: 24e4 });
+        console.log(chalk2.green("  \u2705 take-it-to-prod.md created!\n"));
+      }
+    }
+    if (ciIssue && context.ciProvider) {
+      console.log(chalk2.bold.yellow("  \u26A0\uFE0F  CI/CD Setup Reminders:\n"));
+      const envHints = {
+        "GitHub Actions": [
+          "Go to Settings \u2192 Secrets and variables \u2192 Actions",
+          "Add required secrets (API keys, deploy tokens, etc.)",
+          "Review the generated workflow file before pushing"
+        ],
+        "GitLab CI": [
+          "Go to Settings \u2192 CI/CD \u2192 Variables",
+          "Add required CI/CD variables",
+          "Review .gitlab-ci.yml before committing"
+        ],
+        "CircleCI": [
+          "Go to Project Settings \u2192 Environment Variables",
+          "Add required environment variables",
+          "Review .circleci/config.yml before pushing"
+        ],
+        "Jenkins": [
+          "Configure credentials in Jenkins \u2192 Manage Credentials",
+          "Set up the pipeline in Jenkins dashboard",
+          "Review Jenkinsfile before committing"
+        ],
+        "Travis CI": [
+          "Go to Travis CI settings for this repo",
+          "Add required environment variables",
+          "Review .travis.yml before pushing"
+        ],
+        "Azure Pipelines": [
+          "Go to Azure DevOps \u2192 Pipelines \u2192 Library",
+          "Add required variable groups and secrets",
+          "Review azure-pipelines.yml before committing"
+        ]
+      };
+      const hints = envHints[context.ciProvider] || envHints["GitHub Actions"];
+      for (const hint of hints) {
+        console.log(chalk2.dim(`     \u2192 ${hint}`));
+      }
+      console.log("");
+    }
+    if (fixed > 0) {
+      console.log(chalk2.green.bold("  \u{1F4C8} Run `reposentry analyze` again to see your improved scores!\n"));
+    }
+  });
+  program.command("init").description("Interactive setup \u2014 choose what to generate").action(async () => {
+    await runInteractiveMode();
+  });
+  program.action(async () => {
+    await runInteractiveMode();
+  });
+  return program;
+}
+async function runInteractiveMode() {
+  const readline = await import("readline");
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const ask = (q) => new Promise((resolve3) => rl.question(q, resolve3));
+  console.log(`
+${chalk2.bold.cyan("\u{1F6E1}\uFE0F  RepoSentry")} ${chalk2.dim("\u2014 AI-Powered Codebase Intelligence")}
+`);
+  console.log(chalk2.bold("  What would you like to do?\n"));
+  console.log("  1. \u{1F680} Full Analysis          Run all engines");
+  console.log("  2. \u{1F4DD} Documentation           README, API, Setup, Changelog");
+  console.log("  3. \u{1F3D7}\uFE0F  Architecture            Mermaid diagrams + docs");
+  console.log("  4. \u{1F512} Security Audit          Vulnerability scan + threat model");
+  console.log("  5. \u{1F527} CI/CD & Infrastructure  Pipelines, Docker, deploy guide");
+  console.log("  6. \u{1F9EA} API Testing             Test docs + Postman collection");
+  console.log("  7. \u26A1 Performance             Anti-pattern detection");
+  console.log("  8. \u{1F91D} Team & Collaboration    Templates + onboarding");
+  console.log("  9. \u2764\uFE0F  Health Report           Score + grade badge");
+  console.log(" 10. \u{1F9E0} Change AI Model         Select model for analysis");
+  console.log(" 11. \u{1F4C1} Preview Reports          Start preview server");
+  console.log(" 12. \u{1F528} Fix Issues              Auto-fix detected project issues");
+  console.log("  0. \u274C Exit\n");
+  const choice = (await ask(chalk2.cyan("  Select option (0-12): "))).trim();
+  const engineMap = {
+    "1": {},
+    "2": { docs: true },
+    "3": { architecture: true },
+    "4": { security: true },
+    "5": { ci: true },
+    "6": { apiTests: true },
+    "7": { performance: true },
+    "8": { team: true },
+    "9": { health: true }
+  };
+  if (choice === "0") {
+    console.log(chalk2.dim("\n  Goodbye! \u{1F44B}\n"));
+    rl.close();
+    return;
+  }
+  if (choice === "10") {
+    const { getAvailableModels, isCopilotAvailable: isCopilotAvailable2 } = await import("./copilot-OO6B2LU3.js");
+    if (!isCopilotAvailable2()) {
+      console.log(chalk2.red("\n  \u274C No Copilot CLI detected. Install via: npm i -g @github/copilot\n"));
+      rl.close();
+      return;
+    }
+    console.log(chalk2.bold("\n  \u{1F9E0} Fetching available models from Copilot CLI...\n"));
+    const models = getAvailableModels();
+    if (models.length === 0) {
+      console.log(chalk2.yellow("  Could not fetch models. Enter a model name manually."));
+      const selectedModel2 = (await ask(chalk2.cyan("\n  Enter model name (or blank for default): "))).trim();
+      if (selectedModel2) {
+        console.log(chalk2.green(`
+  \u2713 Model set to: ${selectedModel2}`));
+        console.log(chalk2.dim(`  Run: reposentry analyze --model ${selectedModel2}
+`));
+      } else {
+        console.log(chalk2.dim("\n  Using backend default model.\n"));
+      }
+      rl.close();
+      return;
+    }
+    console.log(chalk2.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    for (let i = 0; i < models.length; i++) {
+      const num = (i + 1).toString().padStart(2, " ");
+      const current = models[i] === "claude-haiku-4.5" ? chalk2.dim(" (current default)") : "";
+      console.log(`  ${chalk2.cyan(num)}. ${models[i]}${current}`);
+    }
+    console.log(chalk2.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(chalk2.dim(`
+  ${models.length} models available.`));
+    const input = (await ask(chalk2.cyan(`
+  Select model (1-${models.length}) or name: `))).trim();
+    const idx = parseInt(input, 10);
+    let selectedModel;
+    if (!isNaN(idx) && idx >= 1 && idx <= models.length) {
+      selectedModel = models[idx - 1];
+    } else if (input) {
+      selectedModel = input;
+    } else {
+      console.log(chalk2.dim("\n  Using backend default model.\n"));
+      rl.close();
+      return;
+    }
+    console.log(chalk2.green(`
+  \u2713 Model set to: ${selectedModel}`));
+    console.log(chalk2.dim(`  Run: reposentry analyze --model ${selectedModel}
+`));
+    rl.close();
+    return;
+  }
+  if (choice === "11") {
+    rl.close();
+    const { startServer } = await import("./server-UJNM6VUZ.js");
+    const config2 = await loadConfig();
+    await startServer({ port: 3e3, outputDir: config2.output });
+    return;
+  }
+  if (choice === "12") {
+    rl.close();
+    const { createCLI: createCLI2 } = await Promise.resolve().then(() => require_cli());
+    const fixProgram = createCLI2();
+    await fixProgram.parseAsync(["node", "reposentry", "fix"]);
+    return;
+  }
+  const engineOpts = engineMap[choice];
+  if (!engineOpts) {
+    console.log(chalk2.red("\n  Invalid selection.\n"));
+    rl.close();
+    return;
+  }
+  rl.close();
+  const config = await loadConfig();
+  const opts = {
+    output: config.output,
+    format: config.format,
+    depth: config.depth,
+    ignore: config.ignore,
+    force: false,
+    verbose: false,
+    // Choice #1 is full analysis: omit engine flags so orchestrator runs everything
+    ...choice === "1" ? {} : engineOpts
+  };
+  await runAnalysis(opts);
+}
+
+export {
+  createCLI
+};
+//# sourceMappingURL=chunk-I2CN2HU4.js.map