codebrief 1.1.7 → 1.1.9

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "codebrief",
-  "version": "1.1.7",
+  "version": "1.1.9",
   "description": "Generate AI context files for your project in seconds",
   "main": "src/index.js",
   "bin": {
-    "codebrief": "./src/index.js"
+    "codebrief": "src/index.js"
   },
   "scripts": {
     "start": "node src/index.js",

package/src/ai.js

@@ -108,77 +108,86 @@ function buildPrompt(analysis, fileTree, fileSamples) {
       .map(([k, v]) => `  ${k}: ${v}`)
       .join("\n") || "  (none)";
 
-  return `You are a senior software architect. A developer ran \`codebrief\` on their project and you must write a comprehensive, deeply detailed CONTEXT.md file that will help AI assistants (like GitHub Copilot or Cursor) understand this project perfectly.
+  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.
 
-## Auto-detected project info
+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.
+
+## Project metadata
 - Name: ${analysis.name}
-- Type / Framework: ${analysis.type}
+- 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: ${analysis.database || "none detected"}
+- Database / ORM: ${analysis.database || "none detected"}
 - Test framework: ${analysis.testFramework || "none detected"}
-- Deployment: ${analysis.deployment || "unknown"}
+- Deployment target: ${analysis.deployment || "unknown"}
 - Monorepo: ${analysis.isMonorepo}
 
 ## Scripts
 ${scripts}
 
-## File tree (first 80 entries)
+## File tree (up to 80 entries)
 ${fileList}
 
-## Key source file samples
+## Source file samples
 ${samplesText}
 
 ---
 
-Now produce a CONTEXT.md file in this exact Markdown structure. Be as specific and detailed as possible — infer architecture from the actual code, don't be generic:
+Produce the CONTEXT.md in exactly this structure:
 
 # Project Context: ${analysis.name}
-> Auto-generated and AI-enhanced by **codebrief**
-> Generated: ${new Date().toISOString().split("T")[0]}
+> AI-enhanced by **codebrief** · ${new Date().toISOString().split("T")[0]}
 
 ---
 
 ## 🧱 Tech Stack
-(bullet list of every detected technology with brief description of its role in THIS project)
+- List each technology and its specific role in this project (e.g. "Prisma — ORM used in \`src/db/\` for all database queries").
+
+## 🚀 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.
 
-## 📁 Folder Conventions
-(bullet list explaining what each main folder/directory is responsible for, inferred from the file tree and source)
+## 📁 Folder Structure
+- Explain what each top-level folder is responsible for, inferred from the actual file tree.
 
-## 🔧 Available Scripts
-(bullet list of scripts and what they actually do in context)
+## 🔧 Scripts
+- Explain what each script actually does in the context of this project.
 
-## 🗂️ Project Structure
+## 🗂️ Project Tree
 \`\`\`
-(the file tree, neatly formatted)
+${fileList}
 \`\`\`
 
 ## 🏗️ Architecture Notes
-(this is the most valuable section — write 8-15 detailed bullet points explaining:
-  - how data flows through the app
-  - where auth/session logic lives
-  - how the database/ORM is used
-  - how routing works
-  - key patterns or abstractions in the codebase
-  - anything a new developer MUST know before coding)
+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
 
 ## 🤖 Rules for AI
-(bullet list of 8-12 concrete rules the AI assistant must follow when generating code for THIS specific project — based on the actual patterns observed in the source)
+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\`"
 
 ## 🚫 Never Do
-(bullet list of 6-10 things an AI must NEVER do in this project — inferred from the stack and code style)
+Write 6–10 prohibitions inferred from the stack and code style. Be specific, not generic.
 
-## 🔐 Security & Environment
-(notes about environment variables, secrets, auth patterns seen in the code)
+## 🔐 Environment & Security
+- List environment variables referenced in the code (exact names if found).
+- Note any auth patterns, token handling, or secrets management observed.
 
 ---
-*Re-run \`codebrief\` after major refactors to keep this file current.*
+*Re-run \`codebrief --ai\` after major refactors to keep this file current.*
 
-Respond with ONLY the Markdown content. No explanations, no code fences around the whole output.`;
+Respond with ONLY the Markdown. No preamble, no code fences wrapping the entire output.`;
 }
 
 // ── HTTP helper (native, no deps) ────────────────────────────

package/src/index.js

@@ -30,7 +30,10 @@ function loadEnvFile(filePath) {
     const eq = line.indexOf("=");
     if (eq === -1) continue;
     const key = line.slice(0, eq).trim();
-    const val = line.slice(eq + 1).trim().replace(/^['"]|['"]$/g, "");
+    const val = line
+      .slice(eq + 1)
+      .trim()
+      .replace(/^['"]|['"]$/g, "");
     if (key && !(key in process.env)) process.env[key] = val;
   }
 }
@@ -275,19 +278,16 @@ async function runInitPrompts(contextPath) {
 async function main() {
   print("");
   print(bold(cyan("⚡ codebrief") + " — AI Context Generator"));
-  print(dim("  Scanning: " + rootDir));
   print("");
 
   // Step 1: Scan
-  startSpinner("Scanning project files...");
+  startSpinner("Scanning project...");
   const fileTree = scanDirectory(rootDir, maxDepth);
-  stopSpinner(`Found ${fileTree.length} files and folders`);
 
   // Step 2: Analyze
-  startSpinner("Analyzing stack and conventions...");
   const analysis = analyzeProject(rootDir);
   stopSpinner(
-    `Detected: ${analysis.stack.join(", ") || "Unknown project type"}`,
+    `${fileTree.length} files · ${analysis.stack.join(", ") || "unknown stack"}`,
   );
 
   // Step 3: Generate files
@@ -429,63 +429,12 @@ async function main() {
 
   // ── Summary ───────────────────────────────────────────────
   print("");
-  print(bold("  📄 Files Created:"));
-  filesCreated.forEach((f) => {
-    print(`     ${green("✅")} ${bold(f.label)}`);
-  });
-
-  print("");
-  print(bold("  🧱 Detected Stack:"));
-  if (analysis.stack.length > 0) {
-    analysis.stack.forEach((s) => print(`     ${cyan("→")} ${s}`));
-  } else {
-    print(
-      `     ${c.yellow}Could not auto-detect stack — check CONTEXT.md${c.reset}`,
-    );
-  }
-
-  if (analysis.conventions.length > 0) {
-    print("");
-    print(bold("  📁 Detected Conventions:"));
-    analysis.conventions.forEach((s) => print(`     ${cyan("→")} ${s}`));
-  }
+  filesCreated.forEach((f) => print(`  ${green("✔")} ${bold(f.label)}`));
 
-  if (analysis.isMonorepo && analysis.packages.length > 0) {
+  if (!aiMode) {
     print("");
-    print(bold("  📦 Monorepo Packages:"));
-    analysis.packages.forEach((p) =>
-      print(`     ${cyan("→")} ${bold(p.name)} ${dim("(" + p.path + ")")}`),
-    );
-  }
-
-  print("");
-  print(bold("  ✏️  Next Steps:"));
-  if (!initMode) {
-    print(
-      `     1. Open ${cyan("CONTEXT.md")} and fill in the ${bold("Architecture Notes")} section`,
-    );
-    print(`     2. Add your own rules to the ${bold("Never Do")} section`);
+    print(dim(`  Tip: use ${cyan("--ai")} for an AI-enhanced CONTEXT.md.`));
   }
-  if (!skipCursor) {
-    print(
-      `     3. In Cursor, open the Notepads panel and reference ${cyan("CONTEXT.md")}`,
-    );
-    print(
-      `     4. Your ${cyan(".cursor/rules/project.mdc")} is already active automatically`,
-    );
-  }
-  print(
-    dim(
-      `     Tip: use ${cyan("--update")} next time to preserve your notes on re-run.`,
-    ),
-  );
-  print(
-    dim(
-      `     Tip: use ${cyan("--ai")} for a deeply detailed AI-enhanced CONTEXT.md.`,
-    ),
-  );
-  print("");
-  print(dim("  Re-run codebrief after major refactors to keep context fresh."));
   print("");
 
   // ── Interactive --init prompts ───────────────────────────────