codebrief 1.1.9 → 1.1.11

package/README.md

@@ -325,19 +325,30 @@ Now help me with: ...
 
 ## Detected Stacks
 
-| Category            | Detected                                                                                                     |
-| ------------------- | ------------------------------------------------------------------------------------------------------------ |
-| **Frameworks**      | Next.js, Remix, SvelteKit, Astro, Nuxt.js, React, Vue.js, Svelte, Angular, NestJS, Express.js, Fastify, Hono |
-| **Language**        | TypeScript (via `tsconfig.json` or dep), Python                                                              |
-| **CSS**             | Tailwind CSS, styled-components, Emotion, SASS                                                               |
-| **UI Libraries**    | shadcn/ui, Material UI, Ant Design, Chakra UI, Mantine                                                       |
-| **State**           | TanStack Query, Zustand, Jotai, Redux Toolkit, MobX                                                          |
-| **Database/ORM**    | Prisma, Drizzle, Mongoose, Supabase, Firebase                                                                |
-| **Testing**         | Vitest, Jest, Playwright, Cypress                                                                            |
-| **Deployment**      | Vercel, Netlify, Railway, Docker                                                                             |
-| **Package Manager** | npm, pnpm, yarn, bun                                                                                         |
-| **Python**          | Django, FastAPI, Flask                                                                                       |
-| **Monorepo**        | pnpm workspaces, Turborepo, Lerna, npm workspaces                                                            |
+| Category            | Detected                                                                                                                                                                            |
+| ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Frameworks**      | Next.js, Remix, SvelteKit, Astro, Nuxt.js, Gatsby, SolidJS, Qwik, Eleventy, React, Vue.js, Svelte, Angular, NestJS, Express, Fastify, Hono, Koa, tRPC, Electron, React Native, Expo |
+| **Languages**       | TypeScript, JavaScript, Python, Go, Rust, Java, Kotlin, Ruby, PHP, C#                                                                                                               |
+| **CSS**             | Tailwind CSS, styled-components, Emotion, SASS/SCSS, Vanilla Extract, UnoCSS                                                                                                        |
+| **UI Libraries**    | shadcn/ui, Material UI, Ant Design, Chakra UI, Mantine, Headless UI, NextUI, DaisyUI                                                                                                |
+| **State**           | TanStack Query, Zustand, Jotai, Redux Toolkit, MobX, Pinia, Vuex, Recoil, Valtio                                                                                                    |
+| **Database/ORM**    | Prisma, Drizzle, TypeORM, Sequelize, Knex, Mongoose, PostgreSQL, MySQL, SQLite, Supabase, Firebase, Redis, Elasticsearch, DynamoDB                                                  |
+| **Auth**            | NextAuth.js, Clerk, Supabase Auth, Passport.js, Lucia Auth, JWT                                                                                                                     |
+| **API / Data**      | tRPC, Axios, GraphQL (Apollo), SWR                                                                                                                                                  |
+| **Validation**      | Zod, Yup, Joi, TypeBox                                                                                                                                                              |
+| **Testing**         | Vitest, Jest, Playwright, Cypress, React Testing Library, Mocha, AVA                                                                                                                |
+| **Bundlers**        | Vite, Webpack, esbuild, Rollup, Turbopack, tsup, SWC                                                                                                                                |
+| **Linting**         | ESLint, Biome, Prettier                                                                                                                                                             |
+| **Deployment**      | Vercel, Netlify, Railway, Fly.io, Render, Google Cloud, Serverless (AWS), Docker, Docker Compose                                                                                    |
+| **Package Manager** | npm, pnpm, yarn, bun, cargo, go modules, pip/poetry, Maven, Gradle, bundler, composer, dotnet/NuGet                                                                                 |
+| **Python**          | Django, FastAPI, Flask, Streamlit                                                                                                                                                   |
+| **Go**              | Gin, Fiber, Echo, Chi                                                                                                                                                               |
+| **Rust**            | Actix Web, Axum, Rocket, Tauri                                                                                                                                                      |
+| **Java/Kotlin**     | Spring Boot, Quarkus, Ktor, Android                                                                                                                                                 |
+| **Ruby**            | Ruby on Rails, Sinatra                                                                                                                                                              |
+| **PHP**             | Laravel, Symfony, Slim                                                                                                                                                              |
+| **C# / .NET**       | ASP.NET Core, Blazor                                                                                                                                                                |
+| **Monorepo**        | pnpm workspaces, Turborepo, Lerna, npm workspaces                                                                                                                                   |
 
 ---
 
@@ -359,9 +370,9 @@ codebrief/
   src/
     index.js      ← CLI entry point, argument parsing, orchestration
     scanner.js    ← Directory walker (respects .gitignore + .codebriefignore)
-    analyzer.js   ← Stack detection from package.json, lock files, config files
+    analyzer.js   ← Stack detection: 10 languages, 50+ frameworks/tools
     generator.js  ← Markdown/MDC generators + section parser for --update
-    ai.js         ← AI enhancement: file sampling, prompt builder, provider calls
+    ai.js         ← AI enhancement: file sampling, prompt builder, 6 providers
     models.js     ← All provider model lists — edit here to update/add models
   package.json
   README.md

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "codebrief",
-  "version": "1.1.9",
-  "description": "Generate AI context files for your project in seconds",
+  "version": "1.1.11",
+  "description": "Generate AI context files for your project in seconds — supports 10 languages, 50+ frameworks, Cursor rules & Copilot instructions",
   "main": "src/index.js",
   "bin": {
     "codebrief": "src/index.js"
@@ -13,11 +13,26 @@
   "keywords": [
     "ai",
     "cursor",
+    "copilot",
     "context",
     "developer-tools",
-    "cli"
+    "cli",
+    "code-analysis",
+    "project-context",
+    "llm",
+    "openai",
+    "anthropic",
+    "groq",
+    "gemini",
+    "ollama"
   ],
+  "author": "Murat Hüdavendigâr Öncü",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/murathudavendigar/codebrief"
+  },
+  "homepage": "https://www.npmjs.com/package/codebrief",
   "files": [
     "src/"
   ]

package/src/ai.js

@@ -11,31 +11,57 @@ const IMPORTANT_PATTERNS = [
   "package.json",
   "tsconfig.json",
   "next.config.*",
+  "nuxt.config.*",
   "vite.config.*",
+  "webpack.config.*",
   "tailwind.config.*",
+  "postcss.config.*",
   "prisma/schema.prisma",
   "drizzle.config.*",
-  "README.md",
+  ".env.example",
+  "docker-compose.*",
+  "Dockerfile",
   "src/index.*",
   "src/main.*",
   "src/app.*",
   "src/server.*",
+  "src/config.*",
+  "src/routes.*",
+  "src/middleware.*",
   "lib/db.*",
   "lib/auth.*",
+  "lib/utils.*",
   "app/layout.*",
   "app/page.*",
+  "app/api/**/route.*",
+  "pages/_app.*",
+  "pages/index.*",
+  "server/index.*",
+  "server/api/**",
+  "controllers/*",
+  "models/*",
+  "services/*",
 ];
 
-function sampleSourceFiles(rootDir, fileTree, charBudget = 18000) {
+function sampleSourceFiles(rootDir, fileTree, charBudget = 32000) {
   const samples = [];
   let budget = charBudget;
 
-  // First pass: prioritised files
+  // Smart read: for large files, take head + tail to capture imports AND exports/env vars
+  function smartRead(filePath, maxChars) {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    if (raw.length <= maxChars) return raw;
+    const head = Math.floor(maxChars * 0.6);
+    const tail = maxChars - head - 20; // 20 for separator
+    return raw.slice(0, head) + "\n// ... (truncated) ...\n" + raw.slice(-tail);
+  }
+
+  // First pass: prioritised files (generous budget — these are the most important)
   for (const pattern of IMPORTANT_PATTERNS) {
     const full = path.join(rootDir, pattern);
     if (fs.existsSync(full)) {
       try {
-        const content = fs.readFileSync(full, "utf-8").slice(0, 3000);
+        const content = smartRead(full, 6000);
         samples.push({ file: pattern, content });
         budget -= content.length;
         if (budget <= 0) break;
@@ -68,18 +94,17 @@ function sampleSourceFiles(rootDir, fileTree, charBudget = 18000) {
     const ext = path.extname(entry.name).toLowerCase();
     if (!sourceExts.has(ext)) continue;
 
-    const full = path.join(rootDir, entry.relativePath || entry.name);
+    const full = path.join(rootDir, entry.path || entry.name);
     // Skip already-read files
     if (samples.some((s) => full.endsWith(s.file))) continue;
 
     try {
-      const raw = fs.readFileSync(full, "utf-8");
-      const snippet = raw.slice(0, 1500);
+      const content = smartRead(full, 4000);
       samples.push({
-        file: entry.relativePath || entry.name,
-        content: snippet,
+        file: entry.path || entry.name,
+        content,
       });
-      budget -= snippet.length;
+      budget -= content.length;
     } catch {
       /* skip */
     }
@@ -88,14 +113,95 @@ function sampleSourceFiles(rootDir, fileTree, charBudget = 18000) {
   return samples;
 }
 
+// ── Env var extractor ────────────────────────────────────────
+// Scans all source files for process.env.XXX references
+function extractEnvVars(rootDir, fileTree) {
+  const envVars = new Map(); // name → [files]
+  const sourceExts = new Set([
+    ".js",
+    ".ts",
+    ".jsx",
+    ".tsx",
+    ".vue",
+    ".svelte",
+    ".py",
+    ".go",
+    ".rs",
+    ".rb",
+    ".php",
+  ]);
+  const envRegex = /process\.env\.([A-Z_][A-Z0-9_]*)/g;
+  const dotenvRegex = /^([A-Z_][A-Z0-9_]*)=/gm;
+
+  for (const entry of fileTree) {
+    if (entry.type !== "file") continue;
+    const ext = path.extname(entry.name).toLowerCase();
+    const name = entry.name.toLowerCase();
+    if (!sourceExts.has(ext) && !name.startsWith(".env")) continue;
+
+    const full = path.join(rootDir, entry.path || entry.name);
+    try {
+      const raw = fs.readFileSync(full, "utf-8");
+      const regex = name.startsWith(".env") ? dotenvRegex : envRegex;
+      let match;
+      while ((match = regex.exec(raw)) !== null) {
+        const varName = match[1];
+        // Skip generic placeholder names
+        if (varName === "XXX" || varName.length < 3) continue;
+        if (!envVars.has(varName)) envVars.set(varName, []);
+        const file = entry.path || entry.name;
+        if (!envVars.get(varName).includes(file))
+          envVars.get(varName).push(file);
+      }
+    } catch {
+      /* skip */
+    }
+  }
+
+  return envVars;
+}
+
+// ── Export extractor ─────────────────────────────────────────
+// Scans all source files for key function/class exports
+function extractExports(rootDir, fileTree) {
+  const exports = [];
+  const sourceExts = new Set([".js", ".ts", ".jsx", ".tsx"]);
+  const patterns = [
+    /(?:module\.exports\s*=\s*\{([^}]+)\})/g,
+    /(?:exports\.(\w+)\s*=)/g,
+    /(?:export\s+(?:default\s+)?(?:function|class|const|let|var)\s+(\w+))/g,
+  ];
+
+  for (const entry of fileTree) {
+    if (entry.type !== "file") continue;
+    const ext = path.extname(entry.name).toLowerCase();
+    if (!sourceExts.has(ext)) continue;
+
+    const full = path.join(rootDir, entry.path || entry.name);
+    try {
+      const raw = fs.readFileSync(full, "utf-8");
+      const file = entry.path || entry.name;
+      for (const regex of patterns) {
+        let match;
+        regex.lastIndex = 0;
+        while ((match = regex.exec(raw)) !== null) {
+          exports.push({ file, exports: match[1] || match[0] });
+        }
+      }
+    } catch {
+      /* skip */
+    }
+  }
+
+  return exports;
+}
+
 // ── Prompt builder ───────────────────────────────────────────
-function buildPrompt(analysis, fileTree, fileSamples) {
+function buildPrompt(analysis, fileTree, fileSamples, envVars, fileExports) {
   const fileList = fileTree
-    .slice(0, 80)
+    .slice(0, 120)
     .map((e) =>
-      e.type === "dir"
-        ? `  ${e.relativePath || e.name}/`
-        : `  ${e.relativePath || e.name}`,
+      e.type === "dir" ? `  ${e.path || e.name}/` : `  ${e.path || e.name}`,
     )
     .join("\n");
 
@@ -108,41 +214,79 @@ function buildPrompt(analysis, fileTree, fileSamples) {
       .map(([k, v]) => `  ${k}: ${v}`)
       .join("\n") || "  (none)";
 
-  return `You are a senior software architect performing a deep code review. A developer ran \`codebrief\` on their project. Your job is to write a CONTEXT.md that gives an AI coding assistant (Cursor, Copilot, etc.) enough knowledge to contribute code as if it had written the project itself.
+  const envVarsText =
+    envVars.size > 0
+      ? Array.from(envVars.entries())
+          .map(
+            ([name, files]) =>
+              `- \`${name}\` — used in ${files.map((f) => "`" + f + "`").join(", ")}`,
+          )
+          .join("\n")
+      : "(none found)";
 
-CRITICAL RULES:
-- Every claim must be grounded in the actual files and code samples provided. No generic filler.
-- Reference specific file paths (e.g. \`src/lib/auth.ts\`, \`app/api/users/route.ts\`) wherever possible.
-- If you cannot infer something from the provided code, omit that bullet entirely — do NOT guess or write placeholders.
-- Architecture Notes must name real functions, classes, modules, or patterns you actually observed, not vague descriptions.
-- Rules for AI must reflect patterns actually present in the source — not generic best practices.
+  const exportsText =
+    fileExports.length > 0
+      ? fileExports
+          .slice(0, 30)
+          .map((e) => `- \`${e.file}\`: ${e.exports}`)
+          .join("\n")
+      : "(none found)";
+
+  const systemMessage = `You are a world-class software architect. You read source code and produce extremely precise, file-grounded documentation. You NEVER write generic advice. Every sentence you write must cite a real file path, function name, or pattern visible in the code you are given. If you cannot ground a claim in the actual source, you omit it entirely.`;
+
+  const userMessage = `I ran \`codebrief\` and need you to write a CONTEXT.md that lets an AI code assistant (Cursor, Copilot) understand this project so well it can write production code immediately.
+
+---
+## HARD RULES (violating these = failure)
+
+1. **File-path grounding**: Every bullet in Architecture Notes, Rules for AI, and Never Do MUST reference at least one real file path or function/export name from the code samples. No exceptions.
+2. **No negatives**: NEVER write "X is not used", "the project does not have Y", "no database detected". If something doesn't exist, simply don't mention it.
+3. **No generic advice**: NEVER write vague statements like "follow best practices", "maintain code quality", "adhere to coding standards", "ensure security". These are worthless.
+4. **Omit, don't guess**: If you can't infer something from the actual code samples, omit that section/bullet entirely. Empty sections should be removed.
+5. **Specific > exhaustive**: 5 deeply specific bullets beat 15 vague ones.
+
+## BAD (never write like this)
+- "Authentication and session logic are not explicitly handled within the project"
+- "Adhere to the project's coding standards and best practices"
+- "Regular security audits are essential"
+- "Error handling mechanisms are crucial for a robust application"
+- "The project follows a modular structure, enhancing maintainability"
+
+## GOOD (write like this)
+- "CLI entry point is \`src/index.js:main()\` — parses flags via \`hasFlag()\`/\`getFlagValue()\`, calls \`scanDirectory()\` → \`analyzeProject()\` → \`generateContextFile()\` in sequence"
+- "AI enhancement in \`src/ai.js:enhanceWithAI()\` samples up to 32k chars of source via \`sampleSourceFiles()\`, builds a structured prompt, dispatches to the selected provider (Groq/OpenAI/Anthropic/Gemini/Grok/Ollama)"
+- "Never add npm dependencies — this project uses zero deps (native \`https\`, \`fs\`, \`path\` only). See \`package.json\` dependencies field is empty."
+- "All color output uses the \`c\` object from \`src/index.js\` (ANSI escape codes) — never use chalk or other color libraries"
 
+---
 ## Project metadata
 - Name: ${analysis.name}
 - Framework / Type: ${analysis.type}
 - Language: ${analysis.language}
 - Package manager: ${analysis.packageManager}
 - Stack: ${analysis.stack.join(", ") || "unknown"}
-- CSS framework: ${analysis.cssFramework || "none detected"}
-- UI library: ${analysis.uiLibrary || "none detected"}
-- State management: ${analysis.stateManagement || "none detected"}
-- Database / ORM: ${analysis.database || "none detected"}
-- Test framework: ${analysis.testFramework || "none detected"}
-- Deployment target: ${analysis.deployment || "unknown"}
+- CSS: ${analysis.cssFramework || "none"} · UI: ${analysis.uiLibrary || "none"} · State: ${analysis.stateManagement || "none"}
+- DB: ${analysis.database || "none"} · Tests: ${analysis.testFramework || "none"} · Deploy: ${analysis.deployment || "unknown"}
 - Monorepo: ${analysis.isMonorepo}
 
 ## Scripts
 ${scripts}
 
-## File tree (up to 80 entries)
+## File tree
 ${fileList}
 
-## Source file samples
+## Source code samples (READ CAREFULLY — this is your evidence)
 ${samplesText}
 
+## Environment variables found in code
+${envVarsText}
+
+## Module exports detected
+${exportsText}
+
 ---
 
-Produce the CONTEXT.md in exactly this structure:
+Now produce the CONTEXT.md in EXACTLY this structure. Remove any section where you have nothing concrete to say. Keep the emoji in every section header EXACTLY as shown.
 
 # Project Context: ${analysis.name}
 > AI-enhanced by **codebrief** · ${new Date().toISOString().split("T")[0]}
@@ -150,44 +294,40 @@ Produce the CONTEXT.md in exactly this structure:
 ---
 
 ## 🧱 Tech Stack
-- List each technology and its specific role in this project (e.g. "Prisma — ORM used in \`src/db/\` for all database queries").
+Bullet list. Each bullet: technology name + its specific role citing where it's used.
+Example: "Node.js — runtime; entry point at \`src/index.js\`, all code is CommonJS with \`require()\`"
 
 ## 🚀 Key Files
-- List the 5–8 most important files a new developer should read first, with one sentence explaining what each does. Use exact paths from the file tree.
+The 5–8 most important files to read first. Exact paths. One sentence each explaining what the file does and its key exports/functions.
 
 ## 📁 Folder Structure
-- Explain what each top-level folder is responsible for, inferred from the actual file tree.
+One bullet per top-level directory, explaining its responsibility based on the actual files inside.
 
 ## 🔧 Scripts
-- Explain what each script actually does in the context of this project.
-
-## 🗂️ Project Tree
-\`\`\`
-${fileList}
-\`\`\`
+One bullet per script. Say what it actually does, not just its command.
 
 ## 🏗️ Architecture Notes
-Write 8–15 bullet points. Each bullet must:
-- Name the specific file(s) or function(s) involved (e.g. "Auth flow starts in \`middleware.ts\`, validates JWT via \`src/lib/auth.ts:verifyToken()\`")
-- Describe a concrete data flow, pattern, or constraint — not a vague summary
-- Cover: request lifecycle, data access layer, auth/session, key abstractions, inter-module dependencies, anything surprising
+8–15 bullets. Each MUST:
+- Name specific file(s), function(s), or export(s)
+- Describe a concrete data flow, dependency, or design decision
+- Be something useful for an AI about to write code in this project
 
 ## 🤖 Rules for AI
-Write 8–12 rules based on patterns you actually observed in the code. Example format:
-- "Always use the \`db\` instance from \`src/lib/db.ts\` — never import Prisma directly"
-- "API routes live in \`app/api/\` and must use the response helper from \`src/lib/response.ts\`"
+8–12 rules extracted from the actual code patterns. Format:
+- "Always/Never [specific action] — [file or pattern reference]"
 
 ## 🚫 Never Do
-Write 6–10 prohibitions inferred from the stack and code style. Be specific, not generic.
+6–10 prohibitions grounded in the codebase. Each must cite WHY (a file, pattern, or convention).
 
-## 🔐 Environment & Security
-- List environment variables referenced in the code (exact names if found).
-- Note any auth patterns, token handling, or secrets management observed.
+## 🔐 Environment & Secrets
+List actual env var names found in the code (e.g. \`GROQ_API_KEY\`, \`OPENAI_API_KEY\`). Describe how they're loaded and used. If none found, omit this section.
 
 ---
 *Re-run \`codebrief --ai\` after major refactors to keep this file current.*
 
-Respond with ONLY the Markdown. No preamble, no code fences wrapping the entire output.`;
+Respond with ONLY the Markdown. No preamble, no wrapping code fences.`;
+
+  return { systemMessage, userMessage };
 }
 
 // ── HTTP helper (native, no deps) ────────────────────────────
@@ -233,6 +373,14 @@ async function callGroq(prompt, model) {
         "  Get a free key in ~30s at https://console.groq.com",
     );
 
+  const messages =
+    typeof prompt === "string"
+      ? [{ role: "user", content: prompt }]
+      : [
+          { role: "system", content: prompt.systemMessage },
+          { role: "user", content: prompt.userMessage },
+        ];
+
   const res = await httpsPost(
     "api.groq.com",
     "/openai/v1/chat/completions",
@@ -242,9 +390,9 @@ async function callGroq(prompt, model) {
     },
     {
       model,
-      messages: [{ role: "user", content: prompt }],
-      temperature: 0.3,
-      max_tokens: 4096,
+      messages,
+      temperature: 0.2,
+      max_tokens: 8192,
     },
   );
   return res.choices?.[0]?.message?.content || "";
@@ -256,6 +404,14 @@ async function callOpenAI(prompt, model) {
   if (!apiKey)
     throw new Error("OPENAI_API_KEY environment variable is not set.");
 
+  const messages =
+    typeof prompt === "string"
+      ? [{ role: "user", content: prompt }]
+      : [
+          { role: "system", content: prompt.systemMessage },
+          { role: "user", content: prompt.userMessage },
+        ];
+
   const res = await httpsPost(
     "api.openai.com",
     "/v1/chat/completions",
@@ -265,9 +421,9 @@ async function callOpenAI(prompt, model) {
     },
     {
       model,
-      messages: [{ role: "user", content: prompt }],
-      temperature: 0.3,
-      max_tokens: 4096,
+      messages,
+      temperature: 0.2,
+      max_tokens: 8192,
     },
   );
   return res.choices?.[0]?.message?.content || "";
@@ -279,6 +435,20 @@ async function callAnthropic(prompt, model) {
   if (!apiKey)
     throw new Error("ANTHROPIC_API_KEY environment variable is not set.");
 
+  const messages =
+    typeof prompt === "string"
+      ? [{ role: "user", content: prompt }]
+      : [{ role: "user", content: prompt.userMessage }];
+
+  const system = typeof prompt === "string" ? undefined : prompt.systemMessage;
+
+  const body = {
+    model,
+    max_tokens: 8192,
+    messages,
+  };
+  if (system) body.system = system;
+
   const res = await httpsPost(
     "api.anthropic.com",
     "/v1/messages",
@@ -287,11 +457,7 @@ async function callAnthropic(prompt, model) {
       "x-api-key": apiKey,
       "anthropic-version": "2023-06-01",
     },
-    {
-      model,
-      max_tokens: 4096,
-      messages: [{ role: "user", content: prompt }],
-    },
+    body,
   );
   return res.content?.[0]?.text || "";
 }
@@ -305,13 +471,18 @@ async function callGemini(prompt, model) {
         "  Get a free key at https://aistudio.google.com/app/apikey",
     );
 
+  const fullText =
+    typeof prompt === "string"
+      ? prompt
+      : `${prompt.systemMessage}\n\n${prompt.userMessage}`;
+
   const res = await httpsPost(
     "generativelanguage.googleapis.com",
     `/v1beta/models/${model}:generateContent?key=${apiKey}`,
     { "Content-Type": "application/json" },
     {
-      contents: [{ parts: [{ text: prompt }] }],
-      generationConfig: { temperature: 0.3, maxOutputTokens: 4096 },
+      contents: [{ parts: [{ text: fullText }] }],
+      generationConfig: { temperature: 0.2, maxOutputTokens: 8192 },
     },
   );
   return res.candidates?.[0]?.content?.parts?.[0]?.text || "";
@@ -326,6 +497,14 @@ async function callGrok(prompt, model) {
         "  Get a key at https://console.x.ai",
     );
 
+  const messages =
+    typeof prompt === "string"
+      ? [{ role: "user", content: prompt }]
+      : [
+          { role: "system", content: prompt.systemMessage },
+          { role: "user", content: prompt.userMessage },
+        ];
+
   const res = await httpsPost(
     "api.x.ai",
     "/v1/chat/completions",
@@ -335,9 +514,9 @@ async function callGrok(prompt, model) {
     },
     {
       model,
-      messages: [{ role: "user", content: prompt }],
-      temperature: 0.3,
-      max_tokens: 4096,
+      messages,
+      temperature: 0.2,
+      max_tokens: 8192,
     },
   );
   return res.choices?.[0]?.message?.content || "";
@@ -347,7 +526,11 @@ async function callOllama(prompt, model) {
   model = model || getDefaultModel("ollama");
   // Ollama runs locally on port 11434 — use http
   const http = require("http");
-  const body = JSON.stringify({ model, prompt, stream: false });
+  const fullText =
+    typeof prompt === "string"
+      ? prompt
+      : `${prompt.systemMessage}\n\n${prompt.userMessage}`;
+  const body = JSON.stringify({ model, prompt: fullText, stream: false });
 
   return new Promise((resolve, reject) => {
     const req = http.request(
@@ -396,7 +579,15 @@ async function enhanceWithAI(analysis, fileTree, rootDir, options = {}) {
   const { provider = "openai", model } = options;
 
   const fileSamples = sampleSourceFiles(rootDir, fileTree);
-  const prompt = buildPrompt(analysis, fileTree, fileSamples);
+  const envVars = extractEnvVars(rootDir, fileTree);
+  const fileExports = extractExports(rootDir, fileTree);
+  const prompt = buildPrompt(
+    analysis,
+    fileTree,
+    fileSamples,
+    envVars,
+    fileExports,
+  );
 
   switch (provider.toLowerCase()) {
     case "groq":

package/src/analyzer.js

@@ -29,6 +29,12 @@ function analyzeProject(rootDir) {
     stateManagement: null,
     database: null,
     deployment: null,
+    auth: null,
+    api: null,
+    bundler: null,
+    linter: null,
+    formatter: null,
+    validation: null,
     extraRules: [],
     isMonorepo: false,
     packages: [],
@@ -47,12 +53,17 @@ function analyzeProject(rootDir) {
         ...pkg.devDependencies,
       };
 
-      // Framework detection
+      // Framework detection (order: full-stack first, then SPA, then backend)
       if (deps["next"]) result.type = "Next.js";
       else if (deps["@remix-run/react"]) result.type = "Remix";
       else if (deps["@sveltejs/kit"]) result.type = "SvelteKit";
       else if (deps["astro"]) result.type = "Astro";
       else if (deps["nuxt"]) result.type = "Nuxt.js";
+      else if (deps["gatsby"]) result.type = "Gatsby";
+      else if (deps["solid-js"]) result.type = "SolidJS";
+      else if (deps["@builder.io/qwik"]) result.type = "Qwik";
+      else if (deps["@eleventy/eleventy"] || deps["@11ty/eleventy"])
+        result.type = "Eleventy";
       else if (deps["react"]) result.type = "React";
       else if (deps["vue"]) result.type = "Vue.js";
       else if (deps["svelte"]) result.type = "Svelte";
@@ -61,6 +72,11 @@ function analyzeProject(rootDir) {
       else if (deps["express"]) result.type = "Express.js API";
       else if (deps["fastify"]) result.type = "Fastify API";
       else if (deps["hono"]) result.type = "Hono API";
+      else if (deps["koa"]) result.type = "Koa API";
+      else if (deps["@trpc/server"]) result.type = "tRPC API";
+      else if (deps["electron"]) result.type = "Electron";
+      else if (deps["react-native"]) result.type = "React Native";
+      else if (deps["expo"]) result.type = "Expo (React Native)";
 
       // Language
       if (deps["typescript"] || fileExists(rootDir, "tsconfig.json")) {
@@ -80,6 +96,10 @@ function analyzeProject(rootDir) {
         result.cssFramework = "Emotion CSS-in-JS";
       } else if (deps["sass"] || deps["node-sass"]) {
         result.cssFramework = "SASS/SCSS";
+      } else if (deps["@vanilla-extract/css"]) {
+        result.cssFramework = "Vanilla Extract";
+      } else if (deps["unocss"]) {
+        result.cssFramework = "UnoCSS";
       }
 
       // UI Library
@@ -99,6 +119,12 @@ function analyzeProject(rootDir) {
         result.uiLibrary = "Chakra UI";
       } else if (deps["@mantine/core"]) {
         result.uiLibrary = "Mantine";
+      } else if (deps["@headlessui/react"]) {
+        result.uiLibrary = "Headless UI";
+      } else if (deps["@nextui-org/react"]) {
+        result.uiLibrary = "NextUI";
+      } else if (deps["daisyui"]) {
+        result.uiLibrary = "DaisyUI";
       }
 
       // State management
@@ -115,6 +141,14 @@ function analyzeProject(rootDir) {
         result.stateManagement = "Redux Toolkit";
       } else if (deps["mobx"]) {
         result.stateManagement = "MobX";
+      } else if (deps["pinia"]) {
+        result.stateManagement = "Pinia (Vue)";
+      } else if (deps["vuex"]) {
+        result.stateManagement = "Vuex (Vue)";
+      } else if (deps["recoil"]) {
+        result.stateManagement = "Recoil";
+      } else if (deps["valtio"]) {
+        result.stateManagement = "Valtio";
       }
 
       // Test framework
@@ -122,6 +156,10 @@ function analyzeProject(rootDir) {
       else if (deps["jest"]) result.testFramework = "Jest";
       else if (deps["@playwright/test"]) result.testFramework = "Playwright";
       else if (deps["cypress"]) result.testFramework = "Cypress";
+      else if (deps["@testing-library/react"])
+        result.testFramework = "React Testing Library";
+      else if (deps["mocha"]) result.testFramework = "Mocha";
+      else if (deps["ava"]) result.testFramework = "AVA";
 
       // Database / ORM
       if (deps["prisma"] || deps["@prisma/client"]) {
@@ -137,7 +175,87 @@ function analyzeProject(rootDir) {
         result.database = "Supabase";
       } else if (deps["firebase"] || deps["firebase-admin"]) {
         result.database = "Firebase";
+      } else if (deps["typeorm"]) {
+        result.database = "TypeORM";
+      } else if (deps["sequelize"]) {
+        result.database = "Sequelize";
+      } else if (deps["knex"]) {
+        result.database = "Knex.js";
+      } else if (deps["pg"] || deps["mysql2"] || deps["better-sqlite3"]) {
+        result.database = deps["pg"]
+          ? "PostgreSQL (pg)"
+          : deps["mysql2"]
+            ? "MySQL"
+            : "SQLite";
+      } else if (deps["redis"] || deps["ioredis"]) {
+        result.database = "Redis";
+      } else if (deps["@elastic/elasticsearch"]) {
+        result.database = "Elasticsearch";
+      } else if (deps["dynamoose"] || deps["@aws-sdk/client-dynamodb"]) {
+        result.database = "DynamoDB";
       }
+
+      // Auth
+      if (deps["next-auth"] || deps["@auth/core"]) {
+        result.auth = "NextAuth.js (Auth.js)";
+        result.extraRules.push(
+          "Auth is managed by NextAuth.js. Use getServerSession() on the server.",
+        );
+      } else if (deps["@clerk/nextjs"] || deps["@clerk/clerk-react"]) {
+        result.auth = "Clerk";
+      } else if (deps["@supabase/auth-helpers-nextjs"]) {
+        result.auth = "Supabase Auth";
+      } else if (deps["passport"]) {
+        result.auth = "Passport.js";
+      } else if (deps["@lucia-auth/lucia"] || deps["lucia"]) {
+        result.auth = "Lucia Auth";
+      } else if (deps["jsonwebtoken"]) {
+        result.auth = "JWT (jsonwebtoken)";
+      }
+
+      // API / Data fetching
+      if (deps["@trpc/client"] || deps["@trpc/server"]) {
+        result.api = "tRPC";
+        result.extraRules.push(
+          "Use tRPC for all API communication. Never use raw fetch for internal APIs.",
+        );
+      } else if (deps["axios"]) {
+        result.api = "Axios";
+      } else if (deps["graphql"] || deps["@apollo/client"]) {
+        result.api = "GraphQL" + (deps["@apollo/client"] ? " (Apollo)" : "");
+      } else if (deps["swr"]) {
+        result.api = "SWR";
+      }
+
+      // Validation
+      if (deps["zod"]) {
+        result.validation = "Zod";
+        result.extraRules.push(
+          "Use Zod for all input validation and type inference.",
+        );
+      } else if (deps["yup"]) {
+        result.validation = "Yup";
+      } else if (deps["joi"]) {
+        result.validation = "Joi";
+      } else if (deps["@sinclair/typebox"]) {
+        result.validation = "TypeBox";
+      }
+
+      // Bundler / Build tool
+      if (deps["vite"]) result.bundler = "Vite";
+      else if (deps["webpack"]) result.bundler = "Webpack";
+      else if (deps["esbuild"]) result.bundler = "esbuild";
+      else if (deps["rollup"]) result.bundler = "Rollup";
+      else if (deps["turbopack"]) result.bundler = "Turbopack";
+      else if (deps["tsup"]) result.bundler = "tsup";
+      else if (deps["swc"]) result.bundler = "SWC";
+
+      // Linter / Formatter
+      if (deps["eslint"]) result.linter = "ESLint";
+      if (deps["@biomejs/biome"]) result.linter = "Biome";
+      if (deps["prettier"]) result.formatter = "Prettier";
+      if (deps["@biomejs/biome"] && !deps["prettier"])
+        result.formatter = "Biome";
     }
   }
 
@@ -157,28 +275,186 @@ function analyzeProject(rootDir) {
     fileExists(rootDir, "railway.toml")
   ) {
     result.deployment = "Railway";
+  } else if (fileExists(rootDir, "fly.toml")) {
+    result.deployment = "Fly.io";
+  } else if (fileExists(rootDir, "render.yaml")) {
+    result.deployment = "Render";
+  } else if (
+    fileExists(rootDir, "app.yaml") ||
+    fileExists(rootDir, "app.yml")
+  ) {
+    result.deployment = "Google Cloud (App Engine)";
+  } else if (
+    fileExists(rootDir, "serverless.yml") ||
+    fileExists(rootDir, "serverless.yaml")
+  ) {
+    result.deployment = "Serverless Framework (AWS)";
   } else if (fileExists(rootDir, "Dockerfile")) {
     result.deployment = "Docker";
+  } else if (
+    fileExists(rootDir, "docker-compose.yml") ||
+    fileExists(rootDir, "docker-compose.yaml")
+  ) {
+    result.deployment = "Docker Compose";
   }
 
   // ── Python project ────────────────────────────────────────────
   if (
     fileExists(rootDir, "requirements.txt") ||
-    fileExists(rootDir, "pyproject.toml")
+    fileExists(rootDir, "pyproject.toml") ||
+    fileExists(rootDir, "setup.py") ||
+    fileExists(rootDir, "Pipfile")
   ) {
     result.language = "Python";
     if (fileExists(rootDir, "manage.py")) result.type = "Django";
-    else if (fileExists(rootDir, "main.py")) {
-      // try to detect fastapi
+    else if (fileExists(rootDir, "main.py") || fileExists(rootDir, "app.py")) {
       try {
-        const req = fs.readFileSync(
-          path.join(rootDir, "requirements.txt"),
+        const reqPath = fileExists(rootDir, "requirements.txt")
+          ? path.join(rootDir, "requirements.txt")
+          : null;
+        const pyprojectPath = fileExists(rootDir, "pyproject.toml")
+          ? path.join(rootDir, "pyproject.toml")
+          : null;
+        const content = reqPath
+          ? fs.readFileSync(reqPath, "utf-8")
+          : pyprojectPath
+            ? fs.readFileSync(pyprojectPath, "utf-8")
+            : "";
+        if (content.includes("fastapi")) result.type = "FastAPI";
+        else if (content.includes("flask")) result.type = "Flask";
+        else if (content.includes("streamlit")) result.type = "Streamlit";
+      } catch {}
+    }
+    if (fileExists(rootDir, "pyproject.toml"))
+      result.packageManager = "pip/poetry";
+  }
+
+  // ── Go project ──────────────────────────────────────────────
+  if (fileExists(rootDir, "go.mod")) {
+    result.language = "Go";
+    result.packageManager = "go modules";
+    try {
+      const goMod = fs.readFileSync(path.join(rootDir, "go.mod"), "utf-8");
+      if (goMod.includes("gin-gonic/gin")) result.type = "Gin (Go)";
+      else if (goMod.includes("gofiber/fiber")) result.type = "Fiber (Go)";
+      else if (goMod.includes("labstack/echo")) result.type = "Echo (Go)";
+      else if (goMod.includes("go-chi/chi")) result.type = "Chi (Go)";
+      else result.type = "Go application";
+    } catch {
+      result.type = "Go application";
+    }
+  }
+
+  // ── Rust project ────────────────────────────────────────────
+  if (fileExists(rootDir, "Cargo.toml")) {
+    result.language = "Rust";
+    result.packageManager = "cargo";
+    try {
+      const cargo = fs.readFileSync(path.join(rootDir, "Cargo.toml"), "utf-8");
+      if (cargo.includes("actix-web")) result.type = "Actix Web (Rust)";
+      else if (cargo.includes("axum")) result.type = "Axum (Rust)";
+      else if (cargo.includes("rocket")) result.type = "Rocket (Rust)";
+      else if (cargo.includes("tauri")) result.type = "Tauri (Rust)";
+      else result.type = "Rust application";
+    } catch {
+      result.type = "Rust application";
+    }
+  }
+
+  // ── Java / Kotlin project ───────────────────────────────────
+  if (
+    fileExists(rootDir, "pom.xml") ||
+    fileExists(rootDir, "build.gradle") ||
+    fileExists(rootDir, "build.gradle.kts")
+  ) {
+    result.language = fileExists(rootDir, "build.gradle.kts")
+      ? "Kotlin"
+      : "Java";
+    result.packageManager = fileExists(rootDir, "pom.xml") ? "Maven" : "Gradle";
+    if (fileExists(rootDir, "pom.xml")) {
+      try {
+        const pom = fs.readFileSync(path.join(rootDir, "pom.xml"), "utf-8");
+        if (pom.includes("spring-boot")) result.type = "Spring Boot";
+        else if (pom.includes("quarkus")) result.type = "Quarkus";
+      } catch {}
+    } else {
+      try {
+        const gradle = fs.readFileSync(
+          path.join(
+            rootDir,
+            fileExists(rootDir, "build.gradle.kts")
+              ? "build.gradle.kts"
+              : "build.gradle",
+          ),
           "utf-8",
         );
-        if (req.includes("fastapi")) result.type = "FastAPI";
-        else if (req.includes("flask")) result.type = "Flask";
+        if (gradle.includes("spring-boot")) result.type = "Spring Boot";
+        else if (gradle.includes("ktor")) result.type = "Ktor (Kotlin)";
+        else if (gradle.includes("android")) result.type = "Android";
       } catch {}
     }
+    if (result.type === "unknown")
+      result.type = `${result.language} application`;
+  }
+
+  // ── Ruby project ────────────────────────────────────────────
+  if (fileExists(rootDir, "Gemfile")) {
+    result.language = "Ruby";
+    result.packageManager = "bundler";
+    try {
+      const gemfile = fs.readFileSync(path.join(rootDir, "Gemfile"), "utf-8");
+      if (gemfile.includes("rails")) result.type = "Ruby on Rails";
+      else if (gemfile.includes("sinatra")) result.type = "Sinatra";
+      else result.type = "Ruby application";
+    } catch {
+      result.type = "Ruby application";
+    }
+  }
+
+  // ── PHP project ─────────────────────────────────────────────
+  if (fileExists(rootDir, "composer.json")) {
+    result.language = "PHP";
+    result.packageManager = "composer";
+    try {
+      const composer = readJson(path.join(rootDir, "composer.json"));
+      const req = {
+        ...(composer?.require || {}),
+        ...(composer?.["require-dev"] || {}),
+      };
+      if (req["laravel/framework"]) result.type = "Laravel";
+      else if (req["symfony/framework-bundle"]) result.type = "Symfony";
+      else if (req["slim/slim"]) result.type = "Slim (PHP)";
+      else result.type = "PHP application";
+    } catch {
+      result.type = "PHP application";
+    }
+  }
+
+  // ── C# / .NET project ──────────────────────────────────────
+  const csprojFiles = (() => {
+    try {
+      return fs
+        .readdirSync(rootDir)
+        .filter((f) => f.endsWith(".csproj") || f.endsWith(".sln"));
+    } catch {
+      return [];
+    }
+  })();
+  if (csprojFiles.length > 0) {
+    result.language = "C#";
+    result.packageManager = "dotnet / NuGet";
+    if (fileExists(rootDir, "Program.cs")) {
+      try {
+        const prog = fs.readFileSync(path.join(rootDir, "Program.cs"), "utf-8");
+        if (prog.includes("WebApplication")) result.type = "ASP.NET Core";
+        else if (prog.includes("Blazor")) result.type = "Blazor";
+        else result.type = ".NET application";
+      } catch {
+        result.type = ".NET application";
+      }
+    } else {
+      result.type = ".NET application";
+    }
   }
 
   // ── Folder conventions ────────────────────────────────────────
@@ -212,6 +488,32 @@ function analyzeProject(rootDir) {
     result.conventions.push("Middleware → /middleware");
   if (topDirs.includes("prisma"))
     result.conventions.push("Database schema → /prisma");
+  if (topDirs.includes("config"))
+    result.conventions.push("Configuration files → /config");
+  if (topDirs.includes("constants"))
+    result.conventions.push("Constants & enums → /constants");
+  if (topDirs.includes("layouts"))
+    result.conventions.push("Page layouts → /layouts");
+  if (topDirs.includes("features"))
+    result.conventions.push("Feature-based modules → /features");
+  if (topDirs.includes("modules"))
+    result.conventions.push("Domain modules → /modules");
+  if (topDirs.includes("pages"))
+    result.conventions.push("Page components → /pages");
+  if (topDirs.includes("routes"))
+    result.conventions.push("Route definitions → /routes");
+  if (topDirs.includes("controllers"))
+    result.conventions.push("Controllers → /controllers");
+  if (topDirs.includes("models"))
+    result.conventions.push("Data models → /models");
+  if (topDirs.includes("helpers"))
+    result.conventions.push("Helper functions → /helpers");
+  if (topDirs.includes("tests") || topDirs.includes("__tests__"))
+    result.conventions.push("Tests → /tests");
+  if (topDirs.includes("public") || topDirs.includes("static"))
+    result.conventions.push("Static assets → /public");
+  if (topDirs.includes("assets"))
+    result.conventions.push("Assets (images, fonts) → /assets");
 
   // ── Monorepo detection ──────────────────────────────────────
   const pkgJsonMonorepo = (() => {
@@ -256,8 +558,14 @@ function analyzeProject(rootDir) {
     result.cssFramework,
     result.uiLibrary,
     result.stateManagement,
+    result.auth,
+    result.api,
+    result.validation,
     result.testFramework,
     result.database,
+    result.bundler,
+    result.linter ? `Linter: ${result.linter}` : null,
+    result.formatter ? `Formatter: ${result.formatter}` : null,
     result.deployment ? `Deployed on ${result.deployment}` : null,
   ].filter(Boolean);
 

package/src/generator.js

@@ -57,7 +57,9 @@ function generateContextMd(analysis, fileTree, preserved = null) {
   const scriptLines =
     Object.entries(analysis.scripts).length > 0
       ? Object.entries(analysis.scripts)
-          .map(([k, v]) => `- \`${analysis.packageManager} run ${k}\` → ${v}`)
+          .map(
+            ([k, v]) => `- \`${analysis.packageManager} run ${k}\` → \`${v}\``,
+          )
           .join("\n")
       : "- No scripts found";
 
@@ -66,23 +68,46 @@ function generateContextMd(analysis, fileTree, preserved = null) {
       ? analysis.extraRules.map((r) => `- ${r}`).join("\n")
       : "- No auto-detected rules";
 
+  // Key info section (only show detected items)
+  const keyInfo = [
+    analysis.auth ? `- **Auth**: ${analysis.auth}` : null,
+    analysis.api ? `- **API**: ${analysis.api}` : null,
+    analysis.validation ? `- **Validation**: ${analysis.validation}` : null,
+    analysis.bundler ? `- **Bundler**: ${analysis.bundler}` : null,
+    analysis.linter ? `- **Linter**: ${analysis.linter}` : null,
+    analysis.formatter ? `- **Formatter**: ${analysis.formatter}` : null,
+  ]
+    .filter(Boolean)
+    .join("\n");
+
+  const keyInfoSection = keyInfo
+    ? `\n## 🔧 Tooling & Libraries\n${keyInfo}\n`
+    : "";
+
   const archSection = preserved?.architectureNotes
     ? preserved.architectureNotes
-    : `<!-- FILL THIS IN — this is the most valuable part for AI context -->
-<!-- Examples:
-- "Auth is handled by NextAuth.js. Session is available in all server components."
-- "All API calls go through /lib/api.ts — never use fetch directly in components."
-- "We use the repository pattern. Data access only through /services files."
-- "Forms use react-hook-form + zod for validation everywhere."
+    : `<!-- FILL THIS IN — this is the MOST VALUABLE part of this file -->
+<!-- Describe your app in 5–15 bullet points. Think about:
+  - How does data flow? (request → controller → service → DB → response)
+  - Where does auth live? How are sessions/tokens handled?
+  - What patterns are used? (repository pattern, factory, etc.)
+  - What are the main entry points?
+  - What would surprise a new developer?
+Example:
+  - "Auth is handled by NextAuth.js. Session available via getServerSession()."
+  - "All API calls route through /lib/api.ts — never use fetch() directly."
+  - "We use the repository pattern. Data access only through /services."
 -->`;
 
   const neverSection = preserved?.neverDo
     ? preserved.neverDo
-    : `<!-- Add things the AI should never do in this project -->
-<!-- Examples:
-- "Never use class components"
-- "Never commit .env files"
-- "Never use useState for server data — use TanStack Query"
+    : `<!-- Add 5–10 rules the AI must NEVER break in this project -->
+<!-- Be specific to YOUR codebase, not generic advice.
+Example:
+  - "Never use class components — we only use function components with hooks"
+  - "Never commit .env files — all secrets are in Vercel env settings"  
+  - "Never use useState for server data — use TanStack Query"
+  - "Never import from @/utils/old — that directory is deprecated"
 -->`;
 
   const monorepoSection =
@@ -92,13 +117,13 @@ function generateContextMd(analysis, fileTree, preserved = null) {
 
   return `# Project Context: ${analysis.name}
 > Auto-generated by **codebrief** on ${now}
-> Edit this file freely — especially the Architecture Notes section.
+> Edit this file freely — especially the Architecture Notes and Never Do sections.
 
 ---
 
 ## 🧱 Tech Stack
 ${stackLines}
-${monorepoSection}
+${monorepoSection}${keyInfoSection}
 ## 📁 Folder Conventions
 ${conventionLines}
 
@@ -120,7 +145,7 @@ ${rulesLines}
 ${neverSection}
 
 ---
-*Re-run \`codebrief\` after major refactors to keep this file current.*
+*Auto-generated by [codebrief](https://www.npmjs.com/package/codebrief). Re-run \`codebrief --update\` after major refactors.*
 `;
 }
 
@@ -128,19 +153,27 @@ function generateCursorRule(analysis) {
   const stackLines = analysis.stack.map((s) => `- ${s}`).join("\n");
   const rulesLines = analysis.extraRules.map((r) => `- ${r}`).join("\n");
 
+  const authLine = analysis.auth
+    ? `\n## Auth\n- Authentication: ${analysis.auth}\n`
+    : "";
+  const dbLine = analysis.database
+    ? `\n## Database\n- ${analysis.database}\n`
+    : "";
+
   return `---
 description: Auto-generated project rules for ${analysis.name}
 alwaysApply: true
 ---
 
 # ${analysis.name} — Cursor Project Rules
+> Auto-generated by [codebrief](https://www.npmjs.com/package/codebrief)
 
 ## Tech Stack
 ${stackLines}
 
 ## Package Manager
 Always use \`${analysis.packageManager}\`. Never suggest a different package manager.
-
+${authLine}${dbLine}
 ## Code Conventions
 ${rulesLines || "- Follow existing patterns in the codebase"}
 
@@ -151,27 +184,35 @@ ${analysis.conventions.map((c) => `- ${c}`).join("\n") || "- See CONTEXT.md for
 - Read CONTEXT.md in the project root for full architecture context
 - Never modify files in node_modules, dist, or build directories
 - Ask before adding new dependencies
+- Match the existing code style and patterns
 `;
 }
 
 function generateVSCodeInstructions(analysis) {
-  // For VS Code / GitHub Copilot users (.github/copilot-instructions.md)
   const stackLines = analysis.stack.join(", ");
+  const authLine = analysis.auth ? `\n## Auth\n- ${analysis.auth}\n` : "";
+  const dbLine = analysis.database
+    ? `\n## Database\n- ${analysis.database}\n`
+    : "";
+
   return `# Copilot Instructions: ${analysis.name}
+> Auto-generated by [codebrief](https://www.npmjs.com/package/codebrief)
 
 ## Stack
 ${stackLines}
 
 ## Package Manager
 Use \`${analysis.packageManager}\` for all commands.
-
+${authLine}${dbLine}
 ## Conventions
-${analysis.conventions.map((c) => `- ${c}`).join("\n")}
+${analysis.conventions.map((c) => `- ${c}`).join("\n") || "- No conventions detected"}
 
 ## Rules
-${analysis.extraRules.map((r) => `- ${r}`).join("\n")}
+${analysis.extraRules.map((r) => `- ${r}`).join("\n") || "- Follow existing patterns"}
 
-For full project context, see CONTEXT.md in the project root.
+## Important
+- Read CONTEXT.md in the project root for full architecture context
+- Match the existing code style and patterns
 `;
 }