codesight 1.0.0

package/dist/detectors/tokens.js

@@ -0,0 +1,48 @@
+/**
+ * Estimates token counts using a simple heuristic:
+ * ~4 characters per token for English text/code (GPT/Claude average)
+ * This avoids requiring tiktoken as a dependency.
+ */
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+/**
+ * Calculates token stats: how many tokens the output uses
+ * vs. how many an AI would spend exploring the same info manually
+ */
+export function calculateTokenStats(result, outputContent, fileCount) {
+    const outputTokens = estimateTokens(outputContent);
+    // Estimate exploration cost:
+    // - Each file read costs ~150 tokens (path + content snippet)
+    // - Each route discovery requires reading the route file (~400 tokens avg)
+    // - Each schema model requires reading the schema file (~300 tokens avg)
+    // - Each component discovery requires reading the file (~250 tokens avg)
+    // - Each grep/glob operation costs ~50 tokens for the command + results
+    // - AI typically needs 3-5 exploration rounds to map a project
+    const routeExplorationTokens = result.routes.length * 400;
+    const schemaExplorationTokens = result.schemas.length * 300;
+    const componentExplorationTokens = result.components.length * 250;
+    const libExplorationTokens = result.libs.length * 200;
+    const configExplorationTokens = result.config.envVars.length * 100;
+    const middlewareExplorationTokens = result.middleware.length * 200;
+    const graphExplorationTokens = result.graph.hotFiles.length * 150;
+    // Add overhead for glob/grep operations to find files (typically 10-20 searches)
+    const searchOverhead = Math.min(fileCount, 50) * 80;
+    // Add overhead for multiple exploration rounds (AI often revisits files)
+    const revisitMultiplier = 1.3;
+    const estimatedExplorationTokens = Math.round((routeExplorationTokens +
+        schemaExplorationTokens +
+        componentExplorationTokens +
+        libExplorationTokens +
+        configExplorationTokens +
+        middlewareExplorationTokens +
+        graphExplorationTokens +
+        searchOverhead) *
+        revisitMultiplier);
+    return {
+        outputTokens,
+        estimatedExplorationTokens,
+        saved: Math.max(0, estimatedExplorationTokens - outputTokens),
+        fileCount,
+    };
+}

package/dist/formatter.d.ts

@@ -0,0 +1,2 @@
+import type { ScanResult } from "./types.js";
+export declare function writeOutput(result: ScanResult, outputDir: string): Promise<string>;

package/dist/formatter.js

@@ -0,0 +1,268 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+export async function writeOutput(result, outputDir) {
+    await mkdir(outputDir, { recursive: true });
+    const sections = [];
+    if (result.routes.length > 0) {
+        const content = formatRoutes(result);
+        sections.push({ name: "routes", content });
+        await writeFile(join(outputDir, "routes.md"), content);
+    }
+    if (result.schemas.length > 0) {
+        const content = formatSchema(result);
+        sections.push({ name: "schema", content });
+        await writeFile(join(outputDir, "schema.md"), content);
+    }
+    if (result.components.length > 0) {
+        const content = formatComponents(result);
+        sections.push({ name: "components", content });
+        await writeFile(join(outputDir, "components.md"), content);
+    }
+    if (result.libs.length > 0) {
+        const content = formatLibs(result);
+        sections.push({ name: "libs", content });
+        await writeFile(join(outputDir, "libs.md"), content);
+    }
+    const configContent = formatConfig(result);
+    if (configContent) {
+        sections.push({ name: "config", content: configContent });
+        await writeFile(join(outputDir, "config.md"), configContent);
+    }
+    if (result.middleware.length > 0) {
+        const content = formatMiddleware(result);
+        sections.push({ name: "middleware", content });
+        await writeFile(join(outputDir, "middleware.md"), content);
+    }
+    if (result.graph.hotFiles.length > 0) {
+        const content = formatGraph(result);
+        sections.push({ name: "graph", content });
+        await writeFile(join(outputDir, "graph.md"), content);
+    }
+    const combined = formatCombined(result, sections);
+    await writeFile(join(outputDir, "CODESIGHT.md"), combined);
+    return combined;
+}
+function formatRoutes(result) {
+    const lines = ["# Routes", ""];
+    const byFramework = new Map();
+    for (const route of result.routes) {
+        const fw = route.framework;
+        if (!byFramework.has(fw))
+            byFramework.set(fw, []);
+        byFramework.get(fw).push(route);
+    }
+    for (const [fw, routes] of byFramework) {
+        if (byFramework.size > 1) {
+            lines.push(`## ${fw}`, "");
+        }
+        for (const route of routes) {
+            const tags = route.tags.length > 0 ? ` [${route.tags.join(", ")}]` : "";
+            const params = route.params ? ` params(${route.params.join(", ")})` : "";
+            const contract = [];
+            if (route.requestType)
+                contract.push(`in: ${route.requestType}`);
+            if (route.responseType)
+                contract.push(`out: ${route.responseType}`);
+            const contractStr = contract.length > 0 ? ` → ${contract.join(", ")}` : "";
+            lines.push(`- \`${route.method}\` \`${route.path}\`${params}${contractStr}${tags}`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+function formatSchema(result) {
+    const lines = ["# Schema", ""];
+    const byOrm = new Map();
+    for (const model of result.schemas) {
+        if (!byOrm.has(model.orm))
+            byOrm.set(model.orm, []);
+        byOrm.get(model.orm).push(model);
+    }
+    for (const [orm, models] of byOrm) {
+        if (byOrm.size > 1)
+            lines.push(`## ${orm}`, "");
+        for (const model of models) {
+            if (model.name.startsWith("enum:")) {
+                const enumName = model.name.replace("enum:", "");
+                const values = model.fields.map((f) => f.name).join(" | ");
+                lines.push(`### enum ${enumName}: ${values}`, "");
+                continue;
+            }
+            lines.push(`### ${model.name}`);
+            for (const field of model.fields) {
+                const flags = field.flags.length > 0 ? ` (${field.flags.join(", ")})` : "";
+                lines.push(`- ${field.name}: ${field.type}${flags}`);
+            }
+            if (model.relations.length > 0) {
+                lines.push(`- _relations_: ${model.relations.join(", ")}`);
+            }
+            lines.push("");
+        }
+    }
+    return lines.join("\n");
+}
+function formatComponents(result) {
+    const lines = ["# Components", ""];
+    for (const comp of result.components) {
+        const markers = [];
+        if (comp.isClient)
+            markers.push("client");
+        if (comp.isServer)
+            markers.push("server");
+        const markerStr = markers.length > 0 ? ` [${markers.join(", ")}]` : "";
+        if (comp.props.length > 0) {
+            lines.push(`- **${comp.name}**${markerStr} — props: ${comp.props.join(", ")} — \`${comp.file}\``);
+        }
+        else {
+            lines.push(`- **${comp.name}**${markerStr} — \`${comp.file}\``);
+        }
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+function formatLibs(result) {
+    const lines = ["# Libraries", ""];
+    for (const lib of result.libs) {
+        const maxExports = 6;
+        const shown = lib.exports.slice(0, maxExports);
+        const remaining = lib.exports.length - maxExports;
+        if (lib.exports.length <= 2) {
+            const exps = shown
+                .map((e) => {
+                const sig = e.signature ? `: ${e.signature}` : "";
+                return `${e.kind} ${e.name}${sig}`;
+            })
+                .join(", ");
+            lines.push(`- \`${lib.file}\` — ${exps}`);
+        }
+        else {
+            lines.push(`- \`${lib.file}\``);
+            for (const exp of shown) {
+                const sig = exp.signature ? `: ${exp.signature}` : "";
+                lines.push(`  - ${exp.kind} ${exp.name}${sig}`);
+            }
+            if (remaining > 0)
+                lines.push(`  - _...${remaining} more_`);
+        }
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+function formatConfig(result) {
+    const lines = ["# Config", ""];
+    if (result.config.envVars.length > 0) {
+        lines.push("## Environment Variables", "");
+        for (const env of result.config.envVars) {
+            const status = env.hasDefault ? "(has default)" : "**required**";
+            lines.push(`- \`${env.name}\` ${status} — ${env.source}`);
+        }
+        lines.push("");
+    }
+    if (result.config.configFiles.length > 0) {
+        lines.push("## Config Files", "");
+        for (const f of result.config.configFiles) {
+            lines.push(`- \`${f}\``);
+        }
+        lines.push("");
+    }
+    const notableDeps = filterNotableDeps(result.config.dependencies);
+    if (notableDeps.length > 0) {
+        lines.push("## Key Dependencies", "");
+        for (const [name, version] of notableDeps) {
+            lines.push(`- ${name}: ${version}`);
+        }
+        lines.push("");
+    }
+    if (lines.length <= 2)
+        return null;
+    return lines.join("\n");
+}
+function formatMiddleware(result) {
+    const lines = ["# Middleware", ""];
+    const byType = new Map();
+    for (const mw of result.middleware) {
+        if (!byType.has(mw.type))
+            byType.set(mw.type, []);
+        byType.get(mw.type).push(mw);
+    }
+    for (const [type, mws] of byType) {
+        lines.push(`## ${type}`);
+        for (const mw of mws) {
+            lines.push(`- ${mw.name} — \`${mw.file}\``);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+function formatGraph(result) {
+    const lines = ["# Dependency Graph", ""];
+    lines.push("## Most Imported Files (change these carefully)", "");
+    for (const hf of result.graph.hotFiles) {
+        lines.push(`- \`${hf.file}\` — imported by **${hf.importedBy}** files`);
+    }
+    lines.push("");
+    // Show top import edges grouped by target
+    const edgesByTarget = new Map();
+    for (const edge of result.graph.edges) {
+        if (!edgesByTarget.has(edge.to))
+            edgesByTarget.set(edge.to, []);
+        edgesByTarget.get(edge.to).push(edge.from);
+    }
+    const topTargets = Array.from(edgesByTarget.entries())
+        .sort((a, b) => b[1].length - a[1].length)
+        .slice(0, 10);
+    if (topTargets.length > 0) {
+        lines.push("## Import Map (who imports what)", "");
+        for (const [target, importers] of topTargets) {
+            const shown = importers.slice(0, 5);
+            const more = importers.length > 5 ? ` +${importers.length - 5} more` : "";
+            lines.push(`- \`${target}\` ← ${shown.map((i) => `\`${i}\``).join(", ")}${more}`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+function formatCombined(result, sections) {
+    const lines = [];
+    lines.push(`# ${result.project.name} — AI Context Map`);
+    lines.push("");
+    const fw = result.project.frameworks.join(", ") || "unknown";
+    const orm = result.project.orms.join(", ") || "none";
+    const lang = result.project.language;
+    const compFw = result.project.componentFramework;
+    lines.push(`> **Stack:** ${fw} | ${orm} | ${compFw} | ${lang}`);
+    if (result.project.isMonorepo) {
+        const wsNames = result.project.workspaces.map((w) => w.name).join(", ");
+        lines.push(`> **Monorepo:** ${wsNames}`);
+    }
+    lines.push("");
+    // Token stats
+    const ts = result.tokenStats;
+    lines.push(`> ${result.routes.length} routes | ${result.schemas.length} models | ${result.components.length} components | ${result.libs.length} lib files | ${result.config.envVars.length} env vars | ${result.middleware.length} middleware | ${result.graph.edges.length} import links`);
+    lines.push(`> **Token savings:** this file is ~${ts.outputTokens.toLocaleString()} tokens. Without it, AI exploration would cost ~${ts.estimatedExplorationTokens.toLocaleString()} tokens. **Saves ~${ts.saved.toLocaleString()} tokens per conversation.**`);
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+    for (const section of sections) {
+        lines.push(section.content);
+        lines.push("---");
+        lines.push("");
+    }
+    lines.push(`_Generated by [codesight](https://github.com/Houseofmvps/codesight) — see your codebase clearly_`);
+    return lines.join("\n");
+}
+function filterNotableDeps(deps) {
+    const notable = new Set([
+        "next", "react", "vue", "svelte", "hono", "express", "fastify", "koa",
+        "drizzle-orm", "prisma", "@prisma/client", "typeorm", "tailwindcss",
+        "stripe", "@polar-sh/sdk", "resend", "bullmq", "redis", "ioredis",
+        "zod", "trpc", "@trpc/server", "better-auth", "@clerk/nextjs",
+        "next-auth", "lucia", "passport", "@anthropic-ai/sdk", "openai",
+        "ai", "langchain", "supabase", "@supabase/supabase-js", "mongoose",
+        "pg", "mysql2", "better-sqlite3", "playwright", "puppeteer",
+        "socket.io", "graphql", "@apollo/server",
+    ]);
+    return Object.entries(deps)
+        .filter(([name]) => notable.has(name))
+        .sort(([a], [b]) => a.localeCompare(b));
+}

package/dist/generators/ai-config.d.ts

@@ -0,0 +1,2 @@
+import type { ScanResult } from "../types.js";
+export declare function generateAIConfigs(result: ScanResult, root: string): Promise<string[]>;

package/dist/generators/ai-config.js

@@ -0,0 +1,137 @@
+import { writeFile, readFile, stat } from "node:fs/promises";
+import { join } from "node:path";
+async function fileExists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function generateContext(result) {
+    const { project, routes, schemas, components, middleware, config, graph } = result;
+    const lines = [];
+    // Stack overview
+    const fw = project.frameworks.join(", ") || "generic";
+    const orm = project.orms.join(", ") || "none";
+    lines.push(`This is a ${project.language} project using ${fw}${orm !== "none" ? ` with ${orm}` : ""}.`);
+    if (project.isMonorepo) {
+        lines.push(`It is a monorepo with workspaces: ${project.workspaces.map((w) => `${w.name} (${w.path})`).join(", ")}.`);
+    }
+    lines.push("");
+    // Key architecture facts
+    if (routes.length > 0) {
+        lines.push(`The API has ${routes.length} routes. See .codesight/routes.md for the full route map with methods, paths, and tags.`);
+    }
+    if (schemas.length > 0) {
+        lines.push(`The database has ${schemas.length} models. See .codesight/schema.md for the full schema with fields, types, and relations.`);
+    }
+    if (components.length > 0) {
+        lines.push(`The UI has ${components.length} components. See .codesight/components.md for the full list with props.`);
+    }
+    if (middleware.length > 0) {
+        const types = [...new Set(middleware.map((m) => m.type))].join(", ");
+        lines.push(`Middleware includes: ${types}.`);
+    }
+    lines.push("");
+    // Hot files (most imported = most impactful to change)
+    if (graph.hotFiles.length > 0) {
+        lines.push("High-impact files (most imported, changes here affect many other files):");
+        for (const hf of graph.hotFiles.slice(0, 8)) {
+            lines.push(`- ${hf.file} (imported by ${hf.importedBy} files)`);
+        }
+        lines.push("");
+    }
+    // Required env vars
+    const requiredEnvs = config.envVars.filter((e) => !e.hasDefault);
+    if (requiredEnvs.length > 0) {
+        lines.push("Required environment variables (no defaults):");
+        for (const env of requiredEnvs.slice(0, 15)) {
+            lines.push(`- ${env.name} (${env.source})`);
+        }
+        lines.push("");
+    }
+    lines.push("Read .codesight/CODESIGHT.md for the complete AI context map including all routes, schema, components, libraries, config, middleware, and dependency graph.");
+    return lines.join("\n");
+}
+export async function generateAIConfigs(result, root) {
+    const generated = [];
+    const context = generateContext(result);
+    // --- CLAUDE.md ---
+    const claudePath = join(root, "CLAUDE.md");
+    const claudeExists = await fileExists(claudePath);
+    if (!claudeExists) {
+        const claudeContent = `# Project Context
+
+${context}
+`;
+        await writeFile(claudePath, claudeContent);
+        generated.push("CLAUDE.md");
+    }
+    else {
+        // Check if it already references codesight
+        const existing = await readFile(claudePath, "utf-8");
+        if (!existing.includes("codesight") && !existing.includes("CODESIGHT")) {
+            // Append context section
+            const appendSection = `
+
+# AI Context (auto-generated by codesight)
+
+${context}
+`;
+            await writeFile(claudePath, existing + appendSection);
+            generated.push("CLAUDE.md (appended)");
+        }
+    }
+    // --- .cursorrules ---
+    const cursorPath = join(root, ".cursorrules");
+    const cursorExists = await fileExists(cursorPath);
+    if (!cursorExists) {
+        const cursorContent = `# Project Context
+
+${context}
+`;
+        await writeFile(cursorPath, cursorContent);
+        generated.push(".cursorrules");
+    }
+    // --- .github/copilot-instructions.md ---
+    const copilotDir = join(root, ".github");
+    const copilotPath = join(copilotDir, "copilot-instructions.md");
+    const copilotExists = await fileExists(copilotPath);
+    if (!copilotExists) {
+        // Only create if .github dir exists (don't create it for non-GitHub projects)
+        const ghDirExists = await fileExists(copilotDir);
+        if (ghDirExists) {
+            const copilotContent = `# Project Context
+
+${context}
+`;
+            await writeFile(copilotPath, copilotContent);
+            generated.push(".github/copilot-instructions.md");
+        }
+    }
+    // --- codex.md (OpenAI Codex CLI) ---
+    const codexPath = join(root, "codex.md");
+    const codexExists = await fileExists(codexPath);
+    if (!codexExists) {
+        const codexContent = `# Project Context
+
+${context}
+`;
+        await writeFile(codexPath, codexContent);
+        generated.push("codex.md");
+    }
+    // --- AGENTS.md (OpenAI Codex) ---
+    const agentsPath = join(root, "AGENTS.md");
+    const agentsExists = await fileExists(agentsPath);
+    if (!agentsExists) {
+        const agentsContent = `# Project Context
+
+${context}
+`;
+        await writeFile(agentsPath, agentsContent);
+        generated.push("AGENTS.md");
+    }
+    return generated;
+}

package/dist/generators/html-report.d.ts

@@ -0,0 +1,2 @@
+import type { ScanResult } from "../types.js";
+export declare function generateHtmlReport(result: ScanResult, outputDir: string): Promise<string>;

package/dist/generators/html-report.js

@@ -0,0 +1,200 @@
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+function escapeHtml(str) {
+    return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+export async function generateHtmlReport(result, outputDir) {
+    const filePath = join(outputDir, "report.html");
+    const html = buildHtml(result);
+    await writeFile(filePath, html);
+    return filePath;
+}
+function buildHtml(r) {
+    const { project, routes, schemas, components, libs, config, middleware, graph, tokenStats } = r;
+    const fw = project.frameworks.join(", ") || "generic";
+    const orm = project.orms.join(", ") || "none";
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>${escapeHtml(project.name)} — codesight report</title>
+<style>
+*{margin:0;padding:0;box-sizing:border-box}
+:root{--bg:#0a0a0f;--card:#12121a;--border:#1e1e2e;--text:#e0e0e8;--muted:#6b6b80;--accent:#6366f1;--accent2:#22d3ee;--green:#22c55e;--orange:#f59e0b;--red:#ef4444;--pink:#ec4899}
+body{background:var(--bg);color:var(--text);font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;padding:2rem;max-width:1400px;margin:0 auto;line-height:1.6}
+h1{font-size:2.5rem;font-weight:800;background:linear-gradient(135deg,var(--accent),var(--accent2));-webkit-background-clip:text;-webkit-text-fill-color:transparent;margin-bottom:.25rem}
+.subtitle{color:var(--muted);font-size:1rem;margin-bottom:2rem}
+.stack-badge{display:inline-block;background:var(--card);border:1px solid var(--border);border-radius:6px;padding:2px 10px;font-size:.85rem;color:var(--accent2);margin:0 4px 4px 0}
+.stats{display:grid;grid-template-columns:repeat(auto-fit,minmax(160px,1fr));gap:1rem;margin:2rem 0}
+.stat{background:var(--card);border:1px solid var(--border);border-radius:12px;padding:1.25rem;text-align:center}
+.stat-value{font-size:2rem;font-weight:800;background:linear-gradient(135deg,var(--accent),var(--accent2));-webkit-background-clip:text;-webkit-text-fill-color:transparent}
+.stat-label{color:var(--muted);font-size:.85rem;margin-top:.25rem}
+.token-hero{background:linear-gradient(135deg,#1a1a2e,#16213e);border:1px solid var(--accent);border-radius:16px;padding:2rem;margin:2rem 0;text-align:center}
+.token-saved{font-size:3rem;font-weight:900;color:var(--green)}
+.token-detail{color:var(--muted);font-size:.9rem;margin-top:.5rem}
+.section{margin:2.5rem 0}
+.section h2{font-size:1.4rem;font-weight:700;margin-bottom:1rem;padding-bottom:.5rem;border-bottom:1px solid var(--border)}
+.grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(320px,1fr));gap:1rem}
+.card{background:var(--card);border:1px solid var(--border);border-radius:10px;padding:1rem;transition:border-color .2s}
+.card:hover{border-color:var(--accent)}
+.card-title{font-weight:700;font-size:1rem;margin-bottom:.5rem}
+.card-meta{color:var(--muted);font-size:.8rem}
+.tag{display:inline-block;background:rgba(99,102,241,.15);color:var(--accent);border-radius:4px;padding:1px 6px;font-size:.75rem;margin:1px}
+.tag-auth{background:rgba(239,68,68,.15);color:var(--red)}
+.tag-db{background:rgba(34,211,238,.15);color:var(--accent2)}
+.tag-ai{background:rgba(236,72,153,.15);color:var(--pink)}
+.tag-payment{background:rgba(245,158,11,.15);color:var(--orange)}
+.tag-email{background:rgba(34,197,94,.15);color:var(--green)}
+.tag-queue{background:rgba(168,85,247,.15);color:#a855f7}
+.tag-cache{background:rgba(245,158,11,.15);color:var(--orange)}
+.method{font-weight:700;font-size:.8rem;padding:2px 6px;border-radius:4px;margin-right:6px}
+.method-GET{background:rgba(34,197,94,.2);color:var(--green)}
+.method-POST{background:rgba(99,102,241,.2);color:var(--accent)}
+.method-PUT{background:rgba(245,158,11,.2);color:var(--orange)}
+.method-PATCH{background:rgba(245,158,11,.2);color:var(--orange)}
+.method-DELETE{background:rgba(239,68,68,.2);color:var(--red)}
+.method-ALL{background:rgba(107,107,128,.2);color:var(--muted)}
+.route-path{font-family:'Fira Code',monospace;font-size:.9rem}
+.route-contract{color:var(--muted);font-size:.8rem;font-style:italic;margin-left:.5rem}
+.field{display:flex;gap:.5rem;padding:3px 0;font-size:.9rem}
+.field-name{font-family:monospace;color:var(--accent2)}
+.field-type{color:var(--muted);font-family:monospace}
+.field-flags{display:flex;gap:3px}
+.flag{font-size:.7rem;padding:0 4px;border-radius:3px;background:rgba(99,102,241,.1);color:var(--accent)}
+.flag-pk{background:rgba(245,158,11,.2);color:var(--orange)}
+.flag-fk{background:rgba(34,211,238,.2);color:var(--accent2)}
+.flag-unique{background:rgba(236,72,153,.2);color:var(--pink)}
+.hot-bar{height:8px;background:linear-gradient(90deg,var(--accent),var(--accent2));border-radius:4px;margin-top:4px}
+.component-props{color:var(--muted);font-size:.85rem}
+.badge-client{background:rgba(34,197,94,.15);color:var(--green);font-size:.75rem;padding:1px 6px;border-radius:4px}
+.badge-server{background:rgba(99,102,241,.15);color:var(--accent);font-size:.75rem;padding:1px 6px;border-radius:4px}
+.env-required{color:var(--red);font-weight:600;font-size:.8rem}
+.env-default{color:var(--green);font-size:.8rem}
+.footer{text-align:center;color:var(--muted);margin-top:4rem;padding-top:2rem;border-top:1px solid var(--border);font-size:.85rem}
+.footer a{color:var(--accent);text-decoration:none}
+table{width:100%;border-collapse:collapse}
+table td,table th{padding:8px 12px;text-align:left;border-bottom:1px solid var(--border);font-size:.9rem}
+table th{color:var(--muted);font-size:.8rem;font-weight:600;text-transform:uppercase}
+</style>
+</head>
+<body>
+
+<h1>${escapeHtml(project.name)}</h1>
+<div class="subtitle">AI Context Map — generated by codesight</div>
+
+<div>
+${project.frameworks.map((f) => `<span class="stack-badge">${escapeHtml(f)}</span>`).join("")}
+${project.orms.map((o) => `<span class="stack-badge">${escapeHtml(o)}</span>`).join("")}
+<span class="stack-badge">${escapeHtml(project.componentFramework)}</span>
+<span class="stack-badge">${escapeHtml(project.language)}</span>
+${project.isMonorepo ? '<span class="stack-badge">monorepo</span>' : ""}
+</div>
+
+<div class="token-hero">
+  <div class="token-saved">~${tokenStats.saved.toLocaleString()} tokens saved</div>
+  <div class="token-detail">
+    Output: ${tokenStats.outputTokens.toLocaleString()} tokens — Exploration cost without codesight: ~${tokenStats.estimatedExplorationTokens.toLocaleString()} tokens — ${tokenStats.fileCount} files scanned
+  </div>
+</div>
+
+<div class="stats">
+  <div class="stat"><div class="stat-value">${routes.length}</div><div class="stat-label">Routes</div></div>
+  <div class="stat"><div class="stat-value">${schemas.length}</div><div class="stat-label">Models</div></div>
+  <div class="stat"><div class="stat-value">${components.length}</div><div class="stat-label">Components</div></div>
+  <div class="stat"><div class="stat-value">${libs.length}</div><div class="stat-label">Libraries</div></div>
+  <div class="stat"><div class="stat-value">${config.envVars.length}</div><div class="stat-label">Env Vars</div></div>
+  <div class="stat"><div class="stat-value">${middleware.length}</div><div class="stat-label">Middleware</div></div>
+  <div class="stat"><div class="stat-value">${graph.edges.length}</div><div class="stat-label">Import Links</div></div>
+</div>
+
+${routes.length > 0 ? `
+<div class="section">
+<h2>Routes</h2>
+<table>
+<tr><th>Method</th><th>Path</th><th>Contract</th><th>Tags</th><th>File</th></tr>
+${routes.map((r) => `<tr>
+  <td><span class="method method-${escapeHtml(r.method)}">${escapeHtml(r.method)}</span></td>
+  <td class="route-path">${escapeHtml(r.path)}${r.params ? ` <span class="route-contract">params: ${escapeHtml(r.params.join(", "))}</span>` : ""}</td>
+  <td>${r.requestType ? `<span class="route-contract">in: ${escapeHtml(r.requestType)}</span>` : ""}${r.responseType ? `<span class="route-contract">out: ${escapeHtml(r.responseType)}</span>` : ""}</td>
+  <td>${r.tags.map((t) => `<span class="tag tag-${escapeHtml(t)}">${escapeHtml(t)}</span>`).join("")}</td>
+  <td class="card-meta">${escapeHtml(r.file)}</td>
+</tr>`).join("\n")}
+</table>
+</div>` : ""}
+
+${schemas.length > 0 ? `
+<div class="section">
+<h2>Schema</h2>
+<div class="grid">
+${schemas.map((m) => `<div class="card">
+  <div class="card-title">${escapeHtml(m.name)} <span class="card-meta">${escapeHtml(m.orm)}</span></div>
+  ${m.fields.map((f) => `<div class="field">
+    <span class="field-name">${escapeHtml(f.name)}</span>
+    <span class="field-type">${escapeHtml(f.type)}</span>
+    <span class="field-flags">${f.flags.map((fl) => `<span class="flag flag-${escapeHtml(fl)}">${escapeHtml(fl)}</span>`).join("")}</span>
+  </div>`).join("\n")}
+  ${m.relations.length > 0 ? `<div class="card-meta" style="margin-top:6px">Relations: ${escapeHtml(m.relations.join(", "))}</div>` : ""}
+</div>`).join("\n")}
+</div>
+</div>` : ""}
+
+${components.length > 0 ? `
+<div class="section">
+<h2>Components</h2>
+<div class="grid">
+${components.map((c) => `<div class="card">
+  <div class="card-title">${escapeHtml(c.name)} ${c.isClient ? '<span class="badge-client">client</span>' : ""}${c.isServer ? '<span class="badge-server">server</span>' : ""}</div>
+  ${c.props.length > 0 ? `<div class="component-props">props: ${escapeHtml(c.props.join(", "))}</div>` : ""}
+  <div class="card-meta">${escapeHtml(c.file)}</div>
+</div>`).join("\n")}
+</div>
+</div>` : ""}
+
+${graph.hotFiles.length > 0 ? `
+<div class="section">
+<h2>Dependency Hot Files</h2>
+<div class="grid">
+${graph.hotFiles.slice(0, 12).map((h) => {
+        const maxImports = graph.hotFiles[0]?.importedBy || 1;
+        const pct = Math.round((h.importedBy / maxImports) * 100);
+        return `<div class="card">
+  <div class="card-title" style="font-size:.9rem">${escapeHtml(h.file)}</div>
+  <div class="card-meta">imported by ${h.importedBy} files</div>
+  <div class="hot-bar" style="width:${pct}%"></div>
+</div>`;
+    }).join("\n")}
+</div>
+</div>` : ""}
+
+${config.envVars.length > 0 ? `
+<div class="section">
+<h2>Environment Variables</h2>
+<table>
+<tr><th>Variable</th><th>Status</th><th>Source</th></tr>
+${config.envVars.map((e) => `<tr>
+  <td><code>${escapeHtml(e.name)}</code></td>
+  <td>${e.hasDefault ? '<span class="env-default">has default</span>' : '<span class="env-required">required</span>'}</td>
+  <td class="card-meta">${escapeHtml(e.source)}</td>
+</tr>`).join("\n")}
+</table>
+</div>` : ""}
+
+${middleware.length > 0 ? `
+<div class="section">
+<h2>Middleware</h2>
+<div class="grid">
+${middleware.map((m) => `<div class="card">
+  <div class="card-title">${escapeHtml(m.name)} <span class="tag tag-${escapeHtml(m.type)}">${escapeHtml(m.type)}</span></div>
+  <div class="card-meta">${escapeHtml(m.file)}</div>
+</div>`).join("\n")}
+</div>
+</div>` : ""}
+
+<div class="footer">
+  Generated by <a href="https://github.com/Houseofmvps/codesight">codesight</a> — see your codebase clearly
+</div>
+
+</body>
+</html>`;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};