vibe-splain 2.7.2 → 3.0.0

package/README.md

@@ -0,0 +1,237 @@
+<p align="center">
+  <strong>◈ VIBE-SPLAIN</strong>
+  <br />
+  <em>Map architectural DNA and behavioral call-chains in complex codebases.</em>
+</p>
+
+<p align="center">
+  <a href="#install">Install</a> ·
+  <a href="#how-it-works">How It Works</a> ·
+  <a href="#mcp-tools">MCP Tools</a> ·
+  <a href="#dossier-ui">Dossier UI</a> ·
+  <a href="#development">Development</a>
+</p>
+
+---
+
+VIBE-SPLAIN is a high-fidelity **static analysis engine** and MCP server. It uses [Tree-Sitter](https://tree-sitter.github.io/tree-sitter/) to extract the structural and behavioral patterns of a codebase—identifying high-gravity components, mapping semantic actions, and tracing call-chains between entrypoints and side effects.
+
+While VIBE-SPLAIN is built on a language-agnostic foundation, the current toolset is **highly optimized for TypeScript and JavaScript** (especially Next.js, Prisma, and tRPC environments).
+
+**Zero LLM calls. Zero API keys. Pure static analysis.**
+
+Your coding agent does all the thinking — VIBE-SPLAIN just gives it the right data.
+
+## Install
+
+```bash
+npx vibe-splain install
+```
+
+That's it. This patches your coding agent's MCP config so it can call VIBE-SPLAIN's tools. Restart your agent.
+
+### Running the Analysis
+
+You don't need to write a complex prompt. VIBE-SPLAIN provides a built-in MCP Prompt called `build_dossier` that automatically tells your agent exactly what to do.
+
+**In Claude Code / Gemini CLI:**
+Type `/prompt build_dossier` and press enter.
+
+**In Cursor / Windsurf:**
+Open the MCP panel or agent chat, select the `build_dossier` prompt from the VIBE-SPLAIN server, and run it.
+
+Your agent will loop through the high-gravity files, analyze each one, and build an **Architectural Dossier** — a structured set of **Decision Cards** explaining the technical rationale of the code.
+
+### Supported Agents
+
+| Agent | Config File |
+|-------|------------|
+| Claude Code | `~/.claude/claude_desktop_config.json` |
+| Gemini CLI | `~/.gemini/settings.json` |
+| Cursor | `~/.cursor/mcp.json` |
+| Windsurf | `~/.codeium/windsurf/mcp_config.json` |
+
+## How It Works
+
+```
+┌─────────────────────────────────────────────────────────┐
+│  Your Coding Agent (Claude / Gemini / Cursor)           │
+│                                                         │
+│  "Scan this project" ──► scan_project ──► get_file_ctx  │
+│                             │                  │        │
+│  Agent synthesizes  ◄──────┘   ◄──────────────┘        │
+│  narratives + diagrams                                  │
+│       │                                                 │
+│       ▼                                                 │
+│  write_decision_card ──► .vibe-splainer/dossier.json    │
+│                               │                         │
+│                               ▼                         │
+│                    file:// Dossier UI                    │
+└─────────────────────────────────────────────────────────┘
+```
+
+### Three Levels of Analysis
+
+1. **Level 0 — Semantic Classification**: Maps files to architectural "pillars" (Auth, Payments, Database, etc.) using import-path heuristics and library signatures.
+
+2. **Level 1 — Cognitive Complexity**: Tree-Sitter AST analysis computes a complexity score per file based on link density, nesting depth, and mutation counts. Files scoring ≥ 15 are identified as **High-Gravity**.
+
+3. **Level 2 — Behavioral Traceability**: Tree-Sitter powered call-graph analysis. It maps function-level dependencies and identifies **Critical Functions** (entrypoints, semantic actions, or high-outbound callers) so your agent can trace the exact ripple effect of a code change.
+
+## MCP Tools
+
+VIBE-SPLAIN exposes **8 tools** over MCP stdio:
+
+| Tool | Purpose |
+|------|---------|
+| `scan_project` | **Call first.** Scans the codebase, returns high-gravity files grouped by pillar. Starts file watcher. |
+| `get_file_context` | Returns full source + import graph neighbors for a specific file. |
+| `get_call_chain` | **New.** Traces function-level call chains (upstream/downstream) to map behavior paths. |
+| `write_decision_card` | Persists a Decision Card (narrative + evidence + optional Mermaid diagram). |
+| `get_strategic_overview` | Returns dossier state without evidence snippets (saves tokens). |
+| `inspect_pillar` | Returns all Decision Cards for a pillar with full evidence. |
+| `get_wild_discoveries` | Returns the most complex files that don't fit standard patterns. |
+| `mark_stale` | Marks cards as stale when you modify files during a session. |
+
+### Recommended Agent Workflow
+
+```
+1. scan_project → get high-gravity files
+2. For each file: get_file_context → read source + neighbors
+3. Trace: use get_call_chain to see what calls what
+4. Synthesize: "WHY does this code exist?"
+5. write_decision_card → persist the narrative
+6. Share the file:// UI link with the user
+```
+
+## How It Works
+
+### Deep Analysis Pipeline
+Unlike simple regex scanners, VIBE-SPLAIN runs a deterministic **13-stage pipeline**—from AST inventory and alias resolution to semantic classification and function-level scoring—to ensure every Decision Card is grounded in actual code paths.
+
+### Semantic Rulesets
+VIBE-SPLAIN uses specialized rulesets to understand framework-specific semantics. Current optimizations include:
+- **Next.js**: Server Actions, `cookies()`, `headers()`, and App Router conventions.
+- **Database**: Prisma model mutations and raw query patterns.
+- **API**: tRPC procedure calls (`mutate`/`query`) and standard `fetch`/`axios` patterns.
+- **Auth**: Clerk, NextAuth, and custom rate-limiting/validation logic.
+
+## Dossier UI
+
+After your agent writes Decision Cards, open the generated file in your browser:
+
+```
+file:///path/to/your/project/.vibe-splainer/ui/index.html
+```
+
+The UI features:
+- **Dark theme** with glassmorphism and subtle grid texture
+- **Pillar tabs** for navigating architectural areas
+- **Decision Cards** with fresh/stale status badges
+- **Mermaid diagrams** rendered inline as SVG
+- **Evidence sidebar** with Shiki syntax highlighting (tokyo-night)
+- **Wild Discoveries** tab for the most complex outlier files
+- Works entirely offline via `file://` — no server needed
+
+## Architecture
+
+```
+packages/
+├── brain/           # @vibe-splain/brain — analysis engine
+│   └── src/
+│       ├── scanner.ts    # Tree-Sitter AST analysis (L0 + L1 + L2)
+│       ├── dossier.ts    # Atomic persistence + UI regeneration
+│       ├── graph.ts      # Import graph read/write
+│       └── watcher.ts    # Chokidar file watcher
+├── cli/             # vibe-splain — MCP server + CLI
+│   └── src/
+│       ├── index.ts          # #!/usr/bin/env node entry
+│       ├── commands/
+│       │   ├── install.ts    # Agent config patcher
+│       │   └── serve.ts      # MCP server launcher
+│       └── mcp/
+│           ├── server.ts     # @modelcontextprotocol/sdk setup
+│           └── tools/        # 7 tool handlers
+└── ui/              # @vibe-splain/ui — React dossier viewer
+    └── src/
+        ├── App.tsx               # Main app (reads window.__VIBE_DOSSIER__)
+        ├── components/           # Header, PillarTabs, DecisionCard, etc.
+        └── index.css             # Design system
+```
+
+### Key Design Decisions
+
+- **No LLM calls**: VIBE-SPLAIN is a pure static analysis tool. The coding agent provides all synthesis.
+- **`async-mutex`**: All dossier writes are guarded by a mutex with atomic tmp+rename.
+- **`startOnLoad: false`**: Mermaid is initialized manually — never auto-scans the DOM.
+- **`base: './'`**: Vite builds with relative paths so the UI works from `file://` URLs.
+- **`console.log` banned**: Brain and CLI use only `console.error` to avoid corrupting MCP stdio.
+- **Tree-Sitter WASM**: Loaded from the `tree-sitter-wasms` npm package — no network calls.
+
+## Development
+
+### Prerequisites
+
+- Node.js ≥ 18
+- npm ≥ 9 (for workspaces)
+
+### Setup
+
+```bash
+git clone https://github.com/abp2204/vibe-splain.git
+cd vibe-splain
+npm install
+```
+
+### Build
+
+```bash
+npm run build
+```
+
+This runs in sequence: brain → cli → ui → bundle-ui (copies UI dist into CLI dist).
+
+### Dev UI
+
+```bash
+npm run dev:ui
+```
+
+Starts the Vite dev server for the UI package at `http://localhost:5173`.
+
+### Test Install Locally
+
+```bash
+node packages/cli/dist/index.js install
+```
+
+### Test MCP Server
+
+```bash
+node packages/cli/dist/index.js serve
+```
+
+Then send JSON-RPC messages over stdin (see [MCP specification](https://modelcontextprotocol.io)).
+
+### Publish
+
+```bash
+npm run release
+```
+
+Builds everything and publishes the `vibe-splain` CLI package to npm.
+
+## How the Dossier Stays Fresh
+
+When `scan_project` runs, it starts a [Chokidar](https://github.com/paulmillr/chokidar) file watcher. When source files change:
+
+1. The watcher detects the change
+2. Matching Decision Cards are marked **stale** (amber badge in UI)
+3. The `stalePaths` array in the dossier tracks which files need re-analysis
+4. Your agent can call `get_strategic_overview` to see what's stale, then re-scan
+
+You can also manually mark files stale with `mark_stale` if you modify code during a session.
+
+## License
+
+[MIT](LICENSE)

package/dist/commands/export.d.ts

@@ -0,0 +1 @@
+export declare function exportCommand(projectRoot: string, options: any): Promise<void>;

package/dist/commands/export.js

@@ -0,0 +1,19 @@
+import { readDossier } from '@vibe-splain/brain';
+import { ExportOrchestrator } from '../export/ExportOrchestrator.js';
+export async function exportCommand(projectRoot, options) {
+    const root = projectRoot || process.cwd();
+    console.error(`[vibe-splain] Exporting dossier for ${root}`);
+    const dossier = await readDossier(root);
+    if (!dossier) {
+        console.error('[vibe-splain] Dossier not found. Run scan first.');
+        process.exit(1);
+    }
+    const orchestrator = new ExportOrchestrator(root);
+    await orchestrator.writeBundle(dossier, {
+        format: options.format,
+        budget: options.budget ? parseInt(options.budget, 10) : undefined,
+        scope: options.scope,
+    });
+    console.error('[vibe-splain] Export complete.');
+}
+//# sourceMappingURL=export.js.map

package/dist/commands/serve.d.ts

@@ -1 +1 @@
-export declare function serveCommand(): Promise<void>;
+export declare function serveCommand(options?: any): Promise<void>;

package/dist/commands/serve.js

@@ -1,7 +1,7 @@
 import { startMCPServer } from '../mcp/server.js';
-export async function serveCommand() {
+export async function serveCommand(options) {
     console.error('[vibe-splain] Starting MCP server...');
-    await startMCPServer();
+    await startMCPServer(options);
     // Process stays alive — do NOT call process.exit() here
 }
 //# sourceMappingURL=serve.js.map

package/dist/export/ArtifactBundleWriter.d.ts

@@ -0,0 +1,22 @@
+export interface Artifact {
+    type: string;
+    path: string;
+    content: string | Buffer;
+}
+export interface ManifestArtifact {
+    type: string;
+    path: string;
+    checksum: string;
+    sizeBytes: number;
+}
+export interface ArtifactManifest {
+    schemaVersion: string;
+    generatedAt: string;
+    projectRoot: string;
+    artifacts: ManifestArtifact[];
+}
+export declare class ArtifactBundleWriter {
+    private projectRoot;
+    constructor(projectRoot: string);
+    writeBundle(artifacts: Artifact[]): Promise<void>;
+}

package/dist/export/ArtifactBundleWriter.js

@@ -0,0 +1,56 @@
+import { join } from 'path';
+import { writeFile, mkdir, rm, rename } from 'fs/promises';
+import { createHash } from 'crypto';
+export class ArtifactBundleWriter {
+    projectRoot;
+    constructor(projectRoot) {
+        this.projectRoot = projectRoot;
+    }
+    async writeBundle(artifacts) {
+        const outputDir = join(this.projectRoot, '.vibe-splainer');
+        const stagingDir = join(this.projectRoot, '.vibe-splainer.tmp');
+        try {
+            await rm(stagingDir, { recursive: true, force: true });
+            const { existsSync } = await import('fs');
+            const { cp } = await import('fs/promises');
+            if (existsSync(outputDir)) {
+                await cp(outputDir, stagingDir, { recursive: true });
+            }
+            else {
+                await mkdir(stagingDir, { recursive: true });
+            }
+            const manifestArtifacts = [];
+            for (const artifact of artifacts) {
+                const destPath = join(stagingDir, artifact.path);
+                await mkdir(join(destPath, '..'), { recursive: true });
+                await writeFile(destPath, artifact.content);
+                const contentStr = artifact.content;
+                const buffer = typeof contentStr === 'string' ? Buffer.from(contentStr, 'utf-8') : contentStr;
+                manifestArtifacts.push({
+                    type: artifact.type,
+                    path: artifact.path,
+                    checksum: 'sha256:' + createHash('sha256').update(buffer).digest('hex'),
+                    sizeBytes: buffer.length,
+                });
+            }
+            const manifest = {
+                schemaVersion: '1.0.0',
+                generatedAt: new Date().toISOString(),
+                projectRoot: this.projectRoot,
+                artifacts: manifestArtifacts,
+            };
+            await writeFile(join(stagingDir, 'artifact_manifest.json'), JSON.stringify(manifest, null, 2), 'utf8');
+            // Atomic rename.
+            // Rename fails if destination is a non-empty directory.
+            // So we first delete the existing outputDir.
+            // Since it's inside the project root, it's safe to do rm -rf .vibe-splainer
+            await rm(outputDir, { recursive: true, force: true });
+            await rename(stagingDir, outputDir);
+        }
+        catch (err) {
+            await rm(stagingDir, { recursive: true, force: true });
+            throw err;
+        }
+    }
+}
+//# sourceMappingURL=ArtifactBundleWriter.js.map

package/dist/export/ExportOrchestrator.d.ts

@@ -0,0 +1,12 @@
+import type { Dossier, AnalysisStore, ImportGraph } from '@vibe-splain/brain';
+export interface ExportOptions {
+    format?: 'json' | 'html' | 'markdown' | 'delta';
+    budget?: number;
+    scope?: string;
+}
+export declare class ExportOrchestrator {
+    private projectRoot;
+    constructor(projectRoot: string);
+    writeBundle(dossier: Dossier, options?: ExportOptions, store?: AnalysisStore, graph?: ImportGraph): Promise<void>;
+    private buildViewModel;
+}

package/dist/export/ExportOrchestrator.js

@@ -0,0 +1,72 @@
+import { readAnalysis, RecommendationEngine } from '@vibe-splain/brain';
+import { ArtifactBundleWriter } from './ArtifactBundleWriter.js';
+import { JsonRenderer } from './renderers/JsonRenderer.js';
+import { HtmlRenderer } from './renderers/HtmlRenderer.js';
+import { DeltaRenderer } from './renderers/DeltaRenderer.js';
+import { AgentMarkdownRenderer } from './renderers/AgentMarkdownRenderer.js';
+import { ValidationRenderer } from './renderers/ValidationRenderer.js';
+import { RawAnalysisRenderer } from './renderers/RawAnalysisRenderer.js';
+import { GraphRenderer } from './renderers/GraphRenderer.js';
+export class ExportOrchestrator {
+    projectRoot;
+    constructor(projectRoot) {
+        this.projectRoot = projectRoot;
+    }
+    async writeBundle(dossier, options = {}, store, graph) {
+        const finalStore = store || await readAnalysis(this.projectRoot);
+        if (!finalStore) {
+            throw new Error('Analysis store not found. Scan the project first.');
+        }
+        // Aggressive Boilerplate Culling
+        for (const p of dossier.pillars) {
+            p.decisions = p.decisions.filter(c => !(c.severity === 1 && c.category === 'Convention'));
+            p.cardCount = p.decisions.length;
+        }
+        const viewModel = this.buildViewModel(dossier, finalStore);
+        // Always render JSON, Delta, Validation, and Raw Analysis.
+        const artifacts = [];
+        artifacts.push(...await new JsonRenderer().render(viewModel, finalStore));
+        artifacts.push(...await new DeltaRenderer().render(viewModel, finalStore));
+        artifacts.push(...await new ValidationRenderer().render(viewModel, finalStore));
+        artifacts.push(...await new RawAnalysisRenderer().render(viewModel, finalStore));
+        if (graph) {
+            artifacts.push(...await new GraphRenderer(graph).render(viewModel, finalStore));
+        }
+        // Determine additional formats
+        const formats = ['html', 'markdown']; // default
+        if (options.format && options.format !== 'json' && options.format !== 'delta') {
+            formats.length = 0;
+            formats.push(options.format);
+        }
+        if (formats.includes('html')) {
+            artifacts.push(...await new HtmlRenderer().render(viewModel, finalStore));
+        }
+        if (formats.includes('markdown')) {
+            artifacts.push(...await new AgentMarkdownRenderer(options.budget).render(viewModel, finalStore));
+        }
+        const writer = new ArtifactBundleWriter(this.projectRoot);
+        await writer.writeBundle(artifacts);
+    }
+    buildViewModel(dossier, store) {
+        const recommendations = {};
+        for (const file of dossier.map.topGravity) {
+            const persisted = store.files[file];
+            if (persisted) {
+                recommendations[file] = RecommendationEngine.generateRecommendations(persisted);
+            }
+        }
+        for (const file of dossier.map.topHeat) {
+            if (!recommendations[file]) {
+                const persisted = store.files[file];
+                if (persisted) {
+                    recommendations[file] = RecommendationEngine.generateRecommendations(persisted);
+                }
+            }
+        }
+        return {
+            ...dossier,
+            recommendations,
+        };
+    }
+}
+//# sourceMappingURL=ExportOrchestrator.js.map

package/dist/export/Watcher.d.ts

@@ -0,0 +1 @@
+export declare function startWatcher(projectRoot: string, watchedPaths: string[]): void;

package/dist/export/Watcher.js

@@ -0,0 +1,47 @@
+import chokidar from 'chokidar';
+import { createHash } from 'crypto';
+import { readFile } from 'fs/promises';
+import { join } from 'path';
+import { readDossier } from '@vibe-splain/brain';
+import { ExportOrchestrator } from './ExportOrchestrator.js';
+export function startWatcher(projectRoot, watchedPaths) {
+    const watcher = chokidar.watch(watchedPaths.length > 0 ? watchedPaths : projectRoot, {
+        ignoreInitial: true,
+        ignored: ['**/node_modules/**', '**/dist/**', '**/build/**', '**/.vibe-splainer/**'],
+        persistent: true,
+    });
+    watcher.on('change', async (filepath) => {
+        try {
+            const dossier = await readDossier(projectRoot);
+            if (!dossier)
+                return;
+            const content = await readFile(filepath, 'utf8');
+            const newHash = createHash('sha256').update(content).digest('hex');
+            let mutated = false;
+            for (const pillar of dossier.pillars) {
+                for (const card of pillar.decisions) {
+                    if (!card.primaryFile)
+                        continue;
+                    const absMatch = filepath === join(projectRoot, card.primaryFile) || filepath.endsWith('/' + card.primaryFile);
+                    if (absMatch && card.lastScannedHash !== newHash) {
+                        card.status = 'stale';
+                        const rel = card.primaryFile;
+                        if (!dossier.stalePaths.includes(rel))
+                            dossier.stalePaths.push(rel);
+                        mutated = true;
+                    }
+                }
+            }
+            if (mutated) {
+                const orchestrator = new ExportOrchestrator(projectRoot);
+                await orchestrator.writeBundle(dossier);
+                console.error(`[vibe-splain] File changed: ${filepath}. Dossier artifacts updated.`);
+            }
+        }
+        catch (err) {
+            console.error('[vibe-splain] Watcher error:', err);
+        }
+    });
+    console.error('[vibe-splain] File watcher started');
+}
+//# sourceMappingURL=Watcher.js.map

package/dist/export/renderers/AgentMarkdownRenderer.d.ts

@@ -0,0 +1,8 @@
+import type { DossierViewModel, AnalysisStore } from '@vibe-splain/brain';
+import type { Renderer } from './Renderer.js';
+import type { Artifact } from '../ArtifactBundleWriter.js';
+export declare class AgentMarkdownRenderer implements Renderer {
+    private budget;
+    constructor(budget?: number);
+    render(viewModel: DossierViewModel, store: AnalysisStore): Artifact[];
+}

package/dist/export/renderers/AgentMarkdownRenderer.js

@@ -0,0 +1,90 @@
+export class AgentMarkdownRenderer {
+    budget;
+    constructor(budget = 8000) {
+        this.budget = budget;
+    }
+    render(viewModel, store) {
+        let md = `# Architectural Dossier: ${viewModel.projectRoot}\n\n`;
+        if (viewModel.map.brief) {
+            md += `## Project Brief\n${viewModel.map.brief}\n\n`;
+        }
+        md += `## Stack & Entrypoints\n`;
+        md += `- Stack: ${viewModel.map.stack.join(', ')}\n`;
+        md += `- Entrypoints: ${viewModel.map.entrypoints.join(', ')}\n\n`;
+        // Flatten decisions
+        const allDecisions = viewModel.pillars.flatMap(p => p.decisions).concat(viewModel.wildDiscoveries);
+        const uniqueDecisions = new Map();
+        for (const d of allDecisions) {
+            if (d.primaryFile && !uniqueDecisions.has(d.primaryFile)) {
+                uniqueDecisions.set(d.primaryFile, d);
+            }
+        }
+        const tier1 = [];
+        const tier2 = [];
+        const tier3 = [];
+        // Sort files by gravity
+        const sortedFiles = Object.values(store.files)
+            .filter(f => f.isRealSource)
+            .sort((a, b) => b.gravity - a.gravity);
+        for (const f of sortedFiles) {
+            const card = uniqueDecisions.get(f.relativePath);
+            const isCritical = card && card.severity >= 4;
+            if (f.gravity >= 70 || isCritical) {
+                tier1.push(f.relativePath);
+            }
+            else if (f.gravity >= 40 || card) {
+                tier2.push(f.relativePath);
+            }
+            else {
+                tier3.push(f.relativePath);
+            }
+        }
+        md += `## Tier 1: Critical Files & Risks\n\n`;
+        for (const path of tier1) {
+            const f = store.files[path];
+            const card = uniqueDecisions.get(path);
+            const recs = viewModel.recommendations[path] || [];
+            md += `### ${path}\n`;
+            md += `- Gravity: ${Math.round(f.gravity)} | Heat: ${Math.round(f.heat)}\n`;
+            md += `- Domain: ${f.productDomain} | Role: ${f.frameworkRole}\n`;
+            if (card) {
+                md += `\n**Verdict**: ${card.thesis}\n`;
+                md += `**Severity**: ${card.severity} | **Category**: ${card.category}\n`;
+                md += `**Narrative**: ${card.narrative}\n`;
+            }
+            if (recs.length > 0) {
+                md += `\n**Safe Patch Strategies**:\n`;
+                for (const r of recs) {
+                    md += `- **${r.strategy}**: ${r.description}\n`;
+                }
+            }
+            md += `\n---\n\n`;
+        }
+        md += `## Tier 2: Important Files\n\n`;
+        for (const path of tier2) {
+            const f = store.files[path];
+            const card = uniqueDecisions.get(path);
+            md += `- **${path}** (Gravity: ${Math.round(f.gravity)})`;
+            if (card) {
+                md += ` — ${card.thesis}`;
+            }
+            md += `\n`;
+        }
+        md += `\n`;
+        md += `## Tier 3: Index\n\n`;
+        for (const path of tier3) {
+            const f = store.files[path];
+            md += `- ${path} (Gravity: ${Math.round(f.gravity)})\n`;
+        }
+        // In a real robust implementation, we would truncate tiers starting from Tier 3 to fit the budget.
+        // Given the simplicity, we'll return the full markdown. 
+        return [
+            {
+                type: 'markdown',
+                path: 'dossier.agent.md',
+                content: md,
+            }
+        ];
+    }
+}
+//# sourceMappingURL=AgentMarkdownRenderer.js.map

package/dist/export/renderers/DeltaRenderer.d.ts

@@ -0,0 +1,6 @@
+import type { DossierViewModel, AnalysisStore } from '@vibe-splain/brain';
+import type { Renderer } from './Renderer.js';
+import type { Artifact } from '../ArtifactBundleWriter.js';
+export declare class DeltaRenderer implements Renderer {
+    render(_viewModel: DossierViewModel, store: AnalysisStore): Artifact[];
+}

package/dist/export/renderers/DeltaRenderer.js

@@ -0,0 +1,22 @@
+export class DeltaRenderer {
+    render(_viewModel, store) {
+        const deltaTargets = Object.values(store.files)
+            .filter(pf => pf.isRealSource)
+            .sort((a, b) => b.gravity - a.gravity)
+            .map(pf => ({
+            path: pf.relativePath,
+            gravity: Math.round(pf.gravity),
+            isLoadBearing: pf.canonicalLoadBearing,
+            blastRadius: pf.importedBy,
+            pillarHint: pf.pillarHint,
+        }));
+        return [
+            {
+                type: 'delta',
+                path: 'delta_targets.json',
+                content: JSON.stringify(deltaTargets, null, 2),
+            }
+        ];
+    }
+}
+//# sourceMappingURL=DeltaRenderer.js.map

package/dist/export/renderers/GraphRenderer.d.ts

@@ -0,0 +1,9 @@
+import { type ImportGraph } from '@vibe-splain/brain';
+import type { DossierViewModel, AnalysisStore } from '@vibe-splain/brain';
+import type { Renderer } from './Renderer.js';
+import type { Artifact } from '../ArtifactBundleWriter.js';
+export declare class GraphRenderer implements Renderer {
+    private graph?;
+    constructor(graph?: ImportGraph | undefined);
+    render(_viewModel: DossierViewModel, _store: AnalysisStore): Artifact[];
+}

package/dist/export/renderers/GraphRenderer.js

@@ -0,0 +1,18 @@
+export class GraphRenderer {
+    graph;
+    constructor(graph) {
+        this.graph = graph;
+    }
+    render(_viewModel, _store) {
+        if (!this.graph)
+            return [];
+        return [
+            {
+                type: 'graph',
+                path: 'graph.json',
+                content: JSON.stringify(this.graph, null, 2),
+            }
+        ];
+    }
+}
+//# sourceMappingURL=GraphRenderer.js.map

package/dist/export/renderers/HtmlRenderer.d.ts

@@ -0,0 +1,6 @@
+import type { DossierViewModel, AnalysisStore } from '@vibe-splain/brain';
+import type { Renderer } from './Renderer.js';
+import type { Artifact } from '../ArtifactBundleWriter.js';
+export declare class HtmlRenderer implements Renderer {
+    render(viewModel: DossierViewModel, _store: AnalysisStore): Artifact[];
+}