project-context-ai 1.3.0 → 2.0.0

package/dist/generators/template.js

@@ -1,119 +1,169 @@
+// ─── High-Signal Format: Rules → Stack → Patterns → Details → Pointers ───
 export function buildProjectOverview(ctx) {
     const lines = [];
     lines.push(`# ${ctx.meta.name}`);
     if (ctx.meta.description)
         lines.push(`\n${ctx.meta.description}`);
     lines.push("");
-    // Tech stack summary
-    lines.push("## Tech Stack");
-    lines.push("");
-    lines.push(`- **Type:** ${ctx.meta.type}`);
-    lines.push(`- **Language(s):** ${ctx.meta.languages.join(", ")}`);
-    if (ctx.dependencies.packageManager !== "unknown") {
-        lines.push(`- **Package Manager:** ${ctx.dependencies.packageManager}`);
-    }
+    // Compact tech stack (one-liners)
     const categories = groupFrameworksByCategory(ctx);
-    // Track which categories are already covered by frameworks
     const coveredCategories = new Set(Object.keys(categories));
-    for (const [category, fws] of Object.entries(categories)) {
-        const label = capitalize(category);
-        const names = fws.map((f) => `${f.name} (${f.version})`).join(", ");
-        lines.push(`- **${label}:** ${names}`);
-    }
-    // Only add conventions that aren't already covered by frameworks
+    const stackParts = [];
+    stackParts.push(ctx.meta.languages.join(", "));
+    if (ctx.dependencies.packageManager !== "unknown")
+        stackParts.push(ctx.dependencies.packageManager);
+    const fwParts = [];
+    for (const [, fws] of Object.entries(categories)) {
+        for (const fw of fws)
+            fwParts.push(`${fw.name} ${fw.version.replace(/^\^/, "")}`);
+    }
+    if (fwParts.length > 0)
+        stackParts.push(fwParts.join(", "));
+    if (ctx.conventions.api)
+        stackParts.push(ctx.conventions.api);
+    lines.push(`## Tech Stack`);
+    lines.push(`${stackParts.join(" | ")}`);
+    // Extra lines only for non-covered info
     if (ctx.conventions.styling !== "CSS" && !coveredCategories.has("styling")) {
-        lines.push(`- **Styling:** ${ctx.conventions.styling}`);
+        lines.push(`Styling: ${ctx.conventions.styling}`);
     }
     if (ctx.conventions.stateManagement !== "None detected" && !coveredCategories.has("state")) {
-        lines.push(`- **State:** ${ctx.conventions.stateManagement}`);
-    }
-    if (ctx.conventions.api) {
-        lines.push(`- **API Pattern:** ${ctx.conventions.api}`);
-    }
-    if (ctx.conventions.testing !== "No testing framework detected" && !coveredCategories.has("testing")) {
-        lines.push(`- **Testing:** ${ctx.conventions.testing}`);
+        lines.push(`State: ${ctx.conventions.stateManagement}`);
     }
     lines.push("");
     return lines.join("\n");
 }
-export function buildStructureSection(ctx) {
+export function buildRulesSection(ctx) {
+    if (!ctx.rules?.length)
+        return "";
     const lines = [];
-    lines.push("## Project Structure");
+    lines.push("## Critical Rules");
     lines.push("");
-    lines.push("```");
-    // Group by top-level directory
-    const topLevel = ctx.structure.filter((d) => !d.path.includes("/"));
-    const nested = ctx.structure.filter((d) => d.path.includes("/"));
-    for (const dir of topLevel) {
-        lines.push(`${dir.path}/  — ${dir.description} (${dir.fileCount} files)`);
-        const children = nested.filter((d) => d.path.startsWith(dir.path + "/") && d.path.split("/").length === 2);
-        for (const child of children) {
-            const childName = child.path.split("/").pop();
-            lines.push(`  ${childName}/  — ${child.description} (${child.fileCount} files)`);
-        }
+    const nevers = ctx.rules.filter((r) => r.type === "never");
+    const always = ctx.rules.filter((r) => r.type === "always");
+    for (const r of nevers) {
+        lines.push(`- ⛔ NEVER ${r.rule}`);
+    }
+    for (const r of always) {
+        lines.push(`- ✅ ALWAYS ${r.rule}`);
     }
-    lines.push("```");
     lines.push("");
     return lines.join("\n");
 }
-export function buildKeyFilesSection(ctx) {
+export function buildPatternsSection(ctx) {
+    if (!ctx.patterns)
+        return "";
+    const p = ctx.patterns;
     const lines = [];
-    if (ctx.keyFiles.length > 0) {
-        lines.push("## Key Files");
+    lines.push("## Code Patterns");
+    lines.push("");
+    // DI
+    if (p.di) {
+        lines.push(`**DI:** ${p.di}`);
+        const diEx = p.codeExamples.find((e) => e.category === "di");
+        if (diEx) {
+            lines.push("```typescript");
+            lines.push(diEx.code);
+            lines.push("```");
+        }
         lines.push("");
-        for (const kf of ctx.keyFiles) {
-            lines.push(`- \`${kf.path}\` — ${kf.role}`);
+    }
+    // Imports
+    if (p.imports.length > 0) {
+        lines.push("**Imports:**");
+        for (const imp of p.imports) {
+            const icon = imp.toLowerCase().includes("no ") || imp.toLowerCase().includes("never") ? "❌" : "✅";
+            lines.push(`- ${icon} ${imp}`);
         }
         lines.push("");
     }
-    return lines.join("\n");
-}
-export function buildEntryPointsSection(ctx) {
-    const lines = [];
-    if (ctx.entryPoints.length > 0) {
-        lines.push("## Entry Points");
+    // Error handling
+    if (p.errorHandling.length > 0) {
+        const bases = [...new Set(p.errorHandling.map((e) => e.extendsFrom))];
+        lines.push(`**Errors:** Custom classes extending ${bases.join(", ")}`);
+        for (const err of p.errorHandling.slice(0, 8)) {
+            lines.push(`- \`${err.className}\` → \`${err.file}\``);
+        }
+        const errEx = p.codeExamples.find((e) => e.category === "error-handling");
+        if (errEx) {
+            lines.push("```typescript");
+            lines.push(errEx.code);
+            lines.push("```");
+        }
         lines.push("");
-        for (const ep of ctx.entryPoints) {
-            lines.push(`- \`${ep}\``);
+    }
+    // Testing
+    if (p.testPatterns) {
+        const t = p.testPatterns;
+        const parts = [`**Testing:** ${t.framework}`];
+        if (t.coverageThreshold !== null)
+            parts.push(`${t.coverageThreshold}% coverage`);
+        parts.push(`\`${t.unitFilePattern}\``);
+        if (t.integrationFilePattern)
+            parts.push(`integration: \`${t.integrationFilePattern}\``);
+        if (t.assertionStyle)
+            parts.push(t.assertionStyle);
+        lines.push(parts.join(" | "));
+        lines.push("");
+    }
+    // Architecture rules
+    if (p.architecturalRules.length > 0) {
+        lines.push("**Architecture Rules:**");
+        for (const rule of p.architecturalRules) {
+            const icon = rule.toLowerCase().includes("not") || rule.toLowerCase().includes("forbidden") ? "❌" : "✅";
+            lines.push(`- ${icon} ${rule}`);
         }
         lines.push("");
     }
-    return lines.join("\n");
-}
-export function buildScriptsSection(ctx) {
-    const lines = [];
-    if (Object.keys(ctx.scripts).length > 0) {
-        lines.push("## Available Scripts");
+    // Naming (compact)
+    const namingParts = [`Files: ${p.naming.files}`, `Vars: ${p.naming.variables}`];
+    if (p.naming.dbColumns !== "unknown")
+        namingParts.push(`DB: ${p.naming.dbColumns}`);
+    lines.push(`**Naming:** ${namingParts.join(" | ")}`);
+    lines.push("");
+    // Code conventions
+    if (p.codeConventions.length > 0) {
+        for (const conv of p.codeConventions)
+            lines.push(`- ${conv}`);
         lines.push("");
-        for (const [name, cmd] of Object.entries(ctx.scripts)) {
-            lines.push(`- \`${ctx.dependencies.packageManager} run ${name}\` — \`${cmd}\``);
+    }
+    // Code examples (non-DI, non-error)
+    const otherExamples = p.codeExamples.filter((e) => !["di", "error-handling"].includes(e.category));
+    if (otherExamples.length > 0) {
+        lines.push("### Code Examples");
+        for (const ex of otherExamples) {
+            lines.push(`**${ex.label}** (\`${ex.file}\`):`);
+            lines.push("```typescript");
+            lines.push(ex.code);
+            lines.push("```");
+            lines.push("");
         }
+    }
+    // Workflows
+    if (p.workflows.length > 0) {
+        lines.push("### Workflows");
+        for (const wf of p.workflows)
+            lines.push(`- ${wf}`);
         lines.push("");
     }
-    return lines.join("\n");
-}
-export function buildDependenciesSection(ctx) {
-    const lines = [];
-    const importantDeps = ctx.dependencies.runtime.filter((d) => d.purpose);
-    if (importantDeps.length > 0) {
-        lines.push("## Key Dependencies");
+    // IDE Skills table
+    if (p.ideSkills.length > 0) {
+        lines.push("### IDE Skills");
         lines.push("");
-        for (const dep of importantDeps) {
-            lines.push(`- **${dep.name}** (${dep.version}) — ${dep.purpose}`);
+        lines.push("| Skill | File | Activates On |");
+        lines.push("|-------|------|-------------|");
+        for (const s of p.ideSkills) {
+            lines.push(`| ${s.name} | \`${s.file}\` | ${s.activatesOn || "manual"} |`);
         }
         lines.push("");
     }
-    return lines.join("\n");
-}
-export function buildArchitectureSection(ctx) {
-    const lines = [];
-    lines.push("## Architecture");
-    lines.push("");
-    lines.push(`- **Pattern:** ${ctx.conventions.architecture}`);
-    if (ctx.conventions.api) {
-        lines.push(`- **API:** ${ctx.conventions.api}`);
+    // IDE Commands
+    if (p.ideCommands.length > 0) {
+        lines.push("### IDE Commands");
+        for (const c of p.ideCommands)
+            lines.push(`- \`/${c.name}\` — ${c.description}`);
+        lines.push("");
     }
-    lines.push("");
     return lines.join("\n");
 }
 export function buildRoutesSection(ctx) {
@@ -122,15 +172,23 @@ export function buildRoutesSection(ctx) {
     const lines = [];
     lines.push("## API Routes");
     lines.push("");
-    lines.push("| Method | Path | File | Auth |");
-    lines.push("|--------|------|------|------|");
-    const routes = ctx.routes.slice(0, 30);
-    for (const r of routes) {
-        lines.push(`| ${r.method} | ${r.path} | \`${r.file}\` | ${r.auth ? "Yes" : "No"} |`);
+    const hasHandlers = ctx.routes.some((r) => r.handler);
+    let header = "| Method | Path | File | Auth |";
+    let sep = "|--------|------|------|------|";
+    if (hasHandlers) {
+        header += " Handler |";
+        sep += "---------|";
+    }
+    lines.push(header);
+    lines.push(sep);
+    for (const r of ctx.routes.slice(0, 30)) {
+        let row = `| ${r.method} | ${r.path} | \`${r.file}\` | ${r.auth ? "✓" : "—"} |`;
+        if (hasHandlers)
+            row += ` ${r.handler || "—"} |`;
+        lines.push(row);
     }
     if (ctx.routes.length > 30) {
-        lines.push("");
-        lines.push(`> ${ctx.routes.length} routes total (showing first 30)`);
+        lines.push(`\n> ${ctx.routes.length} routes total`);
     }
     lines.push("");
     return lines.join("\n");
@@ -141,107 +199,102 @@ export function buildDatabaseSection(ctx) {
     const lines = [];
     lines.push("## Database Schema");
     lines.push("");
-    const models = ctx.database.slice(0, 15);
-    for (const model of models) {
+    for (const model of ctx.database.slice(0, 15)) {
         lines.push(`### ${model.name} (${model.source})`);
-        for (const field of model.fields) {
+        for (const f of model.fields) {
             const tags = [];
-            if (field.primary)
-                tags.push("primary");
-            if (field.unique)
+            if (f.primary)
+                tags.push("PK");
+            if (f.unique)
                 tags.push("unique");
-            if (field.required === false)
+            if (f.required === false)
                 tags.push("optional");
-            const tagStr = tags.length ? ` (${tags.join(", ")})` : "";
-            lines.push(`- **${field.name}** — ${field.type}${tagStr}`);
+            if (f.defaultValue)
+                tags.push(`default: ${f.defaultValue}`);
+            const t = tags.length ? ` (${tags.join(", ")})` : "";
+            lines.push(`- **${f.name}** ${f.type}${t}`);
         }
-        for (const rel of model.relations) {
-            lines.push(`- **${rel.name}** → ${rel.target} (${rel.type})`);
+        for (const r of model.relations) {
+            lines.push(`- **${r.name}** → ${r.target} (${r.type})`);
+        }
+        if (model.indexes?.length) {
+            for (const idx of model.indexes) {
+                lines.push(`- 📇 ${idx.unique ? "unique" : "index"}(${idx.fields.join(", ")})`);
+            }
+        }
+        if (model.enums?.length) {
+            for (const en of model.enums) {
+                lines.push(`- 📋 \`${en.name}\`: ${en.values.join(" | ")}`);
+            }
         }
         lines.push("");
     }
-    if (ctx.database.length > 15) {
-        lines.push(`> ... and ${ctx.database.length - 15} more models`);
-        lines.push("");
-    }
-    return lines.join("\n");
-}
-export function buildEnvVarsSection(ctx) {
-    if (!ctx.envVars?.length)
-        return "";
-    const lines = [];
-    lines.push("## Environment Variables");
-    lines.push("");
-    // Group by category
-    const groups = new Map();
-    for (const v of ctx.envVars) {
-        if (!groups.has(v.category))
-            groups.set(v.category, []);
-        groups.get(v.category).push(v);
-    }
-    const categoryLabels = {
-        database: "Database",
-        auth: "Auth",
-        "api-key": "API Keys",
-        service: "Services",
-        "feature-flag": "Feature Flags",
-        config: "Config",
-        other: "Other",
-    };
-    for (const [category, vars] of groups) {
-        const label = categoryLabels[category] || capitalize(category);
-        const varList = vars.map((v) => `\`${v.name}\`${v.required ? " (required)" : ""}`).join(", ");
-        lines.push(`**${label}:** ${varList}`);
-        lines.push("");
-    }
+    if (ctx.database.length > 15)
+        lines.push(`> ... and ${ctx.database.length - 15} more models\n`);
     return lines.join("\n");
 }
-export function buildServicesSection(ctx) {
-    if (!ctx.services?.length)
+export function buildModulesSection(ctx) {
+    if (!ctx.modules?.length)
         return "";
     const lines = [];
-    lines.push("## External Services");
+    lines.push("## Modules");
     lines.push("");
-    for (const svc of ctx.services) {
-        lines.push(`- **${svc.name}** — ${svc.type} (${svc.source})`);
+    for (const m of ctx.modules) {
+        const deps = m.dependsOn.length > 0 ? `→ ${m.dependsOn.join(", ")}` : "(no deps)";
+        lines.push(`- **${m.name}** (${m.files} files) ${deps}`);
     }
     lines.push("");
     return lines.join("\n");
 }
-export function buildModulesSection(ctx) {
-    if (!ctx.modules?.length)
-        return "";
+export function buildEnvServicesSection(ctx) {
     const lines = [];
-    lines.push("## Modules");
-    lines.push("");
-    for (const mod of ctx.modules) {
-        const deps = mod.dependsOn.length > 0
-            ? `depends on: ${mod.dependsOn.join(", ")}`
-            : "no dependencies";
-        lines.push(`- **${mod.name}** (${mod.files} files) → ${deps}`);
+    // Services (compact)
+    if (ctx.services?.length) {
+        lines.push("## External Services");
+        lines.push(ctx.services.map((s) => `**${s.name}** (${s.type})`).join(" · "));
+        lines.push("");
+    }
+    // Env vars (compact by category)
+    if (ctx.envVars?.length) {
+        lines.push("## Environment Variables");
+        lines.push("");
+        const groups = new Map();
+        for (const v of ctx.envVars) {
+            if (!groups.has(v.category))
+                groups.set(v.category, []);
+            groups.get(v.category).push(v);
+        }
+        const labels = {
+            database: "DB", auth: "Auth", "api-key": "API Keys",
+            service: "Services", "feature-flag": "Flags", config: "Config", other: "Other",
+        };
+        for (const [cat, vars] of groups) {
+            const label = labels[cat] || cat;
+            const required = vars.filter((v) => v.required).map((v) => `\`${v.name}\``);
+            const optional = vars.filter((v) => !v.required).map((v) => `\`${v.name}\``);
+            const parts = [];
+            if (required.length)
+                parts.push(required.join(", "));
+            if (optional.length)
+                parts.push(`optional: ${optional.join(", ")}`);
+            lines.push(`**${label}:** ${parts.join(" | ")}`);
+        }
+        lines.push("");
     }
-    lines.push("");
     return lines.join("\n");
 }
 export function buildBusinessSection(ctx) {
     if (!ctx.business)
         return "";
-    const lines = [];
     const biz = ctx.business;
-    lines.push("## Business Context");
-    lines.push("");
-    if (biz.description) {
-        lines.push(biz.description);
-        lines.push("");
-    }
+    const lines = [];
+    // Features
     if (biz.features.length > 0) {
-        lines.push("### Features");
+        lines.push("## Features");
         lines.push("");
         for (const f of biz.features) {
-            // Category markers from extractAllBullets start with [
             if (f.startsWith("[") && f.endsWith("]")) {
-                lines.push("");
-                lines.push(`**${f.slice(1, -1)}:**`);
+                lines.push(`\n**${f.slice(1, -1)}:**`);
             }
             else {
                 lines.push(`- ${f}`);
@@ -249,111 +302,84 @@ export function buildBusinessSection(ctx) {
         }
         lines.push("");
     }
+    // Skills
     if (biz.skills.length > 0) {
-        lines.push("### Skills / Plugins");
+        lines.push("## Skills / Plugins");
         lines.push("");
-        // Group by interface if available
         const interfaces = new Set(biz.skills.map((s) => s.interface).filter(Boolean));
         if (interfaces.size === 1) {
             lines.push(`> ${biz.skills.length} skills implementing \`${[...interfaces][0]}\``);
             lines.push("");
         }
         for (const skill of biz.skills) {
-            lines.push(`- **${skill.name}** — \`${skill.file}\``);
-        }
-        lines.push("");
-    }
-    if (biz.documentation.length > 0) {
-        lines.push("### Documentation");
-        lines.push("");
-        for (const doc of biz.documentation) {
-            lines.push(`- **${doc.title}** (\`${doc.file}\`) — ${doc.summary}`);
+            const tools = skill.toolCount ? ` (${skill.toolCount} tools)` : "";
+            lines.push(`- **${skill.name}**${tools} — \`${skill.file}\``);
+            if (skill.methods?.length) {
+                for (const m of skill.methods.slice(0, 4))
+                    lines.push(`  - \`${m}\``);
+            }
         }
         lines.push("");
     }
+    // Validation rules
     if (biz.validationRules.length > 0) {
-        lines.push("### Validation Rules");
+        lines.push("## Validation");
         lines.push("");
-        for (const rule of biz.validationRules) {
-            const fields = rule.fields.length > 0 ? ` — ${rule.fields.join(", ")}` : "";
-            lines.push(`- \`${rule.schema}\` (${rule.library})${fields}`);
+        for (const r of biz.validationRules) {
+            const fields = r.fields.length > 0 ? ` — ${r.fields.join(", ")}` : "";
+            lines.push(`- \`${r.schema}\` (${r.library})${fields}`);
         }
         lines.push("");
     }
+    // Auth
     if (biz.authPatterns.length > 0) {
-        lines.push("### Auth & Permissions");
+        lines.push("## Auth & Permissions");
         lines.push("");
-        for (const pattern of biz.authPatterns) {
-            lines.push(`- ${pattern}`);
-        }
+        for (const p of biz.authPatterns)
+            lines.push(`- ${p}`);
         lines.push("");
     }
+    // Domain entities
     if (biz.domainEntities.length > 0) {
-        lines.push("### Domain Entities");
-        lines.push("");
+        lines.push("## Domain Entities");
         lines.push(biz.domainEntities.join(", "));
         lines.push("");
     }
     return lines.join("\n");
 }
-export function buildPatternsSection(ctx) {
-    if (!ctx.patterns)
+export function buildDocIndexSection(ctx) {
+    if (!ctx.business?.documentation?.length && !ctx.patterns?.ideSkills?.length)
         return "";
-    const p = ctx.patterns;
     const lines = [];
-    lines.push("## Code Patterns & Conventions");
+    lines.push("## Documentation Index");
+    lines.push("Read these files for detailed context:");
     lines.push("");
-    if (p.di) {
-        lines.push(`**Dependency Injection:** ${p.di}`);
-        lines.push("");
-    }
-    if (p.imports.length > 0) {
-        lines.push("**Import Conventions:**");
-        for (const imp of p.imports) {
-            lines.push(`- ${imp}`);
-        }
-        lines.push("");
-    }
-    lines.push("**Naming:**");
-    lines.push(`- Files: ${p.naming.files}`);
-    if (p.naming.dbColumns !== "unknown") {
-        lines.push(`- DB columns: ${p.naming.dbColumns}`);
-    }
-    lines.push("");
-    if (p.codeConventions.length > 0) {
-        lines.push("**Conventions:**");
-        for (const conv of p.codeConventions) {
-            lines.push(`- ${conv}`);
-        }
-        lines.push("");
-    }
-    if (p.workflows.length > 0) {
-        lines.push("**Workflows:**");
-        for (const wf of p.workflows) {
-            lines.push(`- ${wf}`);
-        }
-        lines.push("");
-    }
-    if (p.ideSkills.length > 0) {
-        lines.push("**IDE Skills:**");
-        lines.push("");
-        lines.push("| Skill | File | Activates On |");
-        lines.push("|-------|------|-------------|");
-        for (const skill of p.ideSkills) {
-            const activates = skill.activatesOn || "manual";
-            lines.push(`| ${skill.name} | \`${skill.file}\` | ${activates} |`);
+    if (ctx.business?.documentation) {
+        for (const doc of ctx.business.documentation) {
+            lines.push(`- \`${doc.file}\` — ${doc.title}`);
+            if (doc.keyRules?.length) {
+                for (const rule of doc.keyRules)
+                    lines.push(`  - ⚠️ ${rule}`);
+            }
         }
-        lines.push("");
     }
-    if (p.ideCommands.length > 0) {
-        lines.push("**IDE Commands:**");
-        for (const cmd of p.ideCommands) {
-            lines.push(`- \`/${cmd.name}\` — ${cmd.description} (\`${cmd.file}\`)`);
+    if (ctx.patterns?.ideSkills?.length) {
+        for (const skill of ctx.patterns.ideSkills) {
+            const when = skill.activatesOn ? ` (read when editing ${skill.activatesOn})` : "";
+            lines.push(`- \`${skill.file}\` — ${skill.description || skill.name}${when}`);
         }
-        lines.push("");
     }
+    lines.push("");
     return lines.join("\n");
 }
+// ─── Legacy exports (kept for backward compat but now unused by generators) ───
+export function buildStructureSection(_ctx) { return ""; }
+export function buildKeyFilesSection(_ctx) { return ""; }
+export function buildEntryPointsSection(_ctx) { return ""; }
+export function buildScriptsSection(_ctx) { return ""; }
+export function buildDependenciesSection(_ctx) { return ""; }
+export function buildArchitectureSection(_ctx) { return ""; }
+// ─── Helpers ──────────────────────────────────────────────
 function groupFrameworksByCategory(ctx) {
     const groups = {};
     for (const fw of ctx.frameworks) {