sourcebook 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 maroond
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,111 @@
+# sourcebook
+
+Generate AI context files from your codebase's actual conventions. Not what agents already know — what they keep missing.
+
+```bash
+npx sourcebook init
+```
+
+One command. Analyzes your codebase. Outputs a `CLAUDE.md` tuned for how your project actually works.
+
+<p align="center">
+  <img src="demo.svg" alt="sourcebook demo" width="820" />
+</p>
+
+## Why
+
+AI coding agents spend most of their context window just orienting — reading files to build a mental model before doing real work. Developers manually write context files (`CLAUDE.md`, `.cursorrules`, `copilot-instructions.md`), but most are generic and go stale fast.
+
+Research shows auto-generated context that restates obvious information (tech stack, directory structure) actually makes agents [worse by 2-3%](https://arxiv.org/abs/2502.09601). The only context that helps is **non-discoverable information** — things agents can't figure out by reading the code alone.
+
+sourcebook inverts the typical approach: instead of dumping everything, it extracts only what agents keep missing, filtered through a discoverability test.
+
+## What It Finds
+
+- **Import graph + PageRank** — ranks files by structural importance, identifies hub files with the widest blast radius
+- **Git history forensics** — reverted commits (literal "don't do this" signals), co-change coupling (invisible dependencies), rapid re-edits (code that was hard to get right)
+- **Convention detection** — naming patterns, export style, import organization, barrel exports, path aliases
+- **Framework detection** — Next.js, Expo, Supabase, Tailwind, Express, TypeScript configs
+- **Context-rot-aware formatting** — critical constraints at the top, reference info in the middle, action prompts at the bottom (optimized for LLM attention patterns)
+
+## Quick Start
+
+```bash
+# Generate CLAUDE.md for your project
+npx sourcebook init
+
+# Specify output format
+npx sourcebook init --format claude    # CLAUDE.md (default)
+npx sourcebook init --format cursor    # .cursor/rules/sourcebook.mdc + .cursorrules
+npx sourcebook init --format copilot   # .github/copilot-instructions.md
+npx sourcebook init --format all       # All of the above
+```
+
+## Example Output
+
+Running `npx sourcebook init` on a real Expo + Supabase project (3,467 files):
+
+```
+sourcebook v0.1.0
+
+Scanning project...
+  Detected: Expo, Supabase, TypeScript, EAS Build
+  Files: 3,467 across 847 directories
+  Build: npx expo start | eas build
+
+Analyzing import graph...
+  Hub files: ThemeContext.tsx (684 importers), brain-api.ts (42 importers)
+  Circular: brain-api.ts ↔ chat.ts
+  Orphans: 23 potentially dead files
+
+Mining git history (287 commits)...
+  Reverts: 2 found
+  Co-change coupling: useTodayBrain.ts ↔ brain-api.ts (89% correlation)
+  Rapid edits: profile.tsx (18 edits in one week)
+  Active areas: src/ (265 changes in 30 days)
+
+Detecting conventions...
+  Barrel exports: 35 index files
+  Path aliases: @/ prefix
+  Named exports preferred (25:6 ratio)
+  Conventional Commits: yes
+
+Generated: CLAUDE.md (15 findings, 1.2K tokens)
+Done in 2.8s
+```
+
+## How It Works
+
+sourcebook runs four analysis passes, all deterministic and local — no LLM, no API keys, no network calls:
+
+1. **Static analysis** — framework detection, build commands, project structure, environment variables
+2. **Import graph** — builds a directed graph of all imports, runs PageRank to find the most structurally important files
+3. **Git forensics** — mines commit history for reverts, co-change patterns, churn hotspots, and development velocity
+4. **Convention inference** — samples source files to detect naming, import, export, and error handling patterns
+
+Then applies a **discoverability filter**: for every finding, asks "can an agent figure this out by reading the code?" If yes, drops it. Only non-discoverable information makes it to the output.
+
+Output is formatted for **context-rot resistance** — critical constraints go at the top and bottom of the file (where LLMs pay the most attention), lightweight reference info goes in the middle.
+
+## Roadmap
+
+- [x] `.cursor/rules/sourcebook.mdc` + legacy `.cursorrules` output format
+- [x] `.github/copilot-instructions.md` output format
+- [ ] `sourcebook update` — re-analyze while preserving manual edits
+- [ ] `--budget <tokens>` — PageRank-based prioritization within a token limit
+- [ ] Framework knowledge packs (community-contributed)
+- [ ] Tree-sitter AST parsing for deeper convention detection
+- [ ] GitHub Action for CI (auto-update context on merge)
+- [ ] `sourcebook serve` — MCP server mode
+
+## Research Foundation
+
+Built on findings from:
+- [ETH Zurich AGENTS.md study](https://arxiv.org/abs/2502.09601) — auto-generated obvious context hurts agent performance
+- [Karpathy's autoresearch](https://github.com/karpathy/autoresearch) — curated context (`program.md`) is the #1 lever for agent effectiveness
+- [Aider's repo-map](https://aider.chat/docs/repomap.html) — PageRank on import graphs for structural importance
+- Chroma's context-rot research — LLMs show 30%+ accuracy drops for middle-of-context information
+
+## License
+
+MIT

package/dist/cli.d.ts

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

package/dist/cli.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { init } from "./commands/init.js";
+const program = new Command();
+program
+    .name("sourcebook")
+    .description("Extract the conventions, constraints, and architectural truths your AI coding agents keep missing.")
+    .version("0.1.0");
+program
+    .command("init")
+    .description("Analyze a codebase and generate agent context files")
+    .option("-d, --dir <path>", "Target directory to analyze", ".")
+    .option("-f, --format <formats>", "Output formats (claude,cursor,copilot,agents,json)", "claude")
+    .option("--budget <tokens>", "Max token budget for generated context", "4000")
+    .option("--dry-run", "Preview findings without writing files")
+    .action(init);
+program.parse();

package/dist/commands/init.d.ts

@@ -0,0 +1,8 @@
+interface InitOptions {
+    dir: string;
+    format: string;
+    budget: string;
+    dryRun?: boolean;
+}
+export declare function init(options: InitOptions): Promise<void>;
+export {};

package/dist/commands/init.js

@@ -0,0 +1,91 @@
+import path from "node:path";
+import chalk from "chalk";
+import { scanProject } from "../scanner/index.js";
+import { generateClaude } from "../generators/claude.js";
+import { generateCursor, generateCursorLegacy } from "../generators/cursor.js";
+import { generateCopilot } from "../generators/copilot.js";
+import { writeOutput } from "../utils/output.js";
+export async function init(options) {
+    const targetDir = path.resolve(options.dir);
+    const formats = options.format.split(",").map((f) => f.trim());
+    const budget = parseInt(options.budget, 10);
+    console.log(chalk.bold("\nsourcebook"));
+    console.log(chalk.dim("Extracting repo truths...\n"));
+    // Phase 1: Scan the project
+    const scan = await scanProject(targetDir);
+    console.log(chalk.green("✓") + " Scanned project structure");
+    console.log(chalk.dim(`  ${scan.files.length} files, ${scan.frameworks.length} frameworks detected`));
+    // Phase 2: Generate findings
+    const findings = scan.findings;
+    if (findings.length === 0) {
+        console.log(chalk.yellow("\n⚠ No non-obvious findings detected.") +
+            chalk.dim("\n  This may mean the project is small or follows standard conventions."));
+    }
+    else {
+        console.log(chalk.green("✓") +
+            ` Extracted ${findings.length} findings\n`);
+        // Show findings preview
+        for (const finding of findings) {
+            const icon = finding.confidence === "high"
+                ? chalk.green("●")
+                : finding.confidence === "medium"
+                    ? chalk.yellow("●")
+                    : chalk.dim("●");
+            console.log(`  ${icon} ${chalk.bold(finding.category)}: ${finding.description}`);
+            if (finding.evidence) {
+                console.log(chalk.dim(`    evidence: ${finding.evidence}`));
+            }
+        }
+    }
+    // Phase 3: Generate output
+    if (options.dryRun) {
+        console.log(chalk.dim("\n--dry-run: no files written."));
+        return;
+    }
+    console.log("");
+    for (const format of formats) {
+        switch (format) {
+            case "claude": {
+                const content = generateClaude(scan, budget);
+                await writeOutput(targetDir, "CLAUDE.md", content);
+                console.log(chalk.green("✓") + " Wrote CLAUDE.md");
+                break;
+            }
+            case "cursor": {
+                const cursorContent = generateCursor(scan, budget);
+                await writeOutput(targetDir, ".cursor/rules/sourcebook.mdc", cursorContent);
+                console.log(chalk.green("✓") + " Wrote .cursor/rules/sourcebook.mdc");
+                // Also write legacy .cursorrules for older Cursor versions
+                const legacyContent = generateCursorLegacy(scan, budget);
+                await writeOutput(targetDir, ".cursorrules", legacyContent);
+                console.log(chalk.green("✓") + " Wrote .cursorrules (legacy)");
+                break;
+            }
+            case "copilot": {
+                const copilotContent = generateCopilot(scan, budget);
+                await writeOutput(targetDir, ".github/copilot-instructions.md", copilotContent);
+                console.log(chalk.green("✓") + " Wrote .github/copilot-instructions.md");
+                break;
+            }
+            case "all": {
+                const claudeAll = generateClaude(scan, budget);
+                await writeOutput(targetDir, "CLAUDE.md", claudeAll);
+                console.log(chalk.green("✓") + " Wrote CLAUDE.md");
+                const cursorAll = generateCursor(scan, budget);
+                await writeOutput(targetDir, ".cursor/rules/sourcebook.mdc", cursorAll);
+                console.log(chalk.green("✓") + " Wrote .cursor/rules/sourcebook.mdc");
+                const legacyAll = generateCursorLegacy(scan, budget);
+                await writeOutput(targetDir, ".cursorrules", legacyAll);
+                console.log(chalk.green("✓") + " Wrote .cursorrules (legacy)");
+                const copilotAll = generateCopilot(scan, budget);
+                await writeOutput(targetDir, ".github/copilot-instructions.md", copilotAll);
+                console.log(chalk.green("✓") + " Wrote .github/copilot-instructions.md");
+                break;
+            }
+            default:
+                console.log(chalk.yellow(`⚠ Format "${format}" not yet supported`));
+        }
+    }
+    console.log(chalk.dim("\nReview the generated files and edit to add context only you know."));
+    console.log(chalk.dim("The best repo truths come from human + machine together.\n"));
+}

package/dist/generators/claude.d.ts

@@ -0,0 +1,11 @@
+import type { ProjectScan } from "../types.js";
+/**
+ * Generate a CLAUDE.md file from scan results.
+ *
+ * Design principles (from research):
+ * 1. ONLY non-discoverable information (ETH Zurich: auto-generated obvious context hurts by 2-3%)
+ * 2. Context-rot-aware formatting (Chroma Research: 30%+ accuracy drop for info in the middle)
+ *    → Critical info at BEGINNING and END of file
+ * 3. Karpathy's program.md pattern: constraints, gotchas, and autonomy boundaries
+ */
+export declare function generateClaude(scan: ProjectScan, budget: number): string;

package/dist/generators/claude.js

@@ -0,0 +1,191 @@
+/**
+ * Generate a CLAUDE.md file from scan results.
+ *
+ * Design principles (from research):
+ * 1. ONLY non-discoverable information (ETH Zurich: auto-generated obvious context hurts by 2-3%)
+ * 2. Context-rot-aware formatting (Chroma Research: 30%+ accuracy drop for info in the middle)
+ *    → Critical info at BEGINNING and END of file
+ * 3. Karpathy's program.md pattern: constraints, gotchas, and autonomy boundaries
+ */
+export function generateClaude(scan, budget) {
+    // Separate findings by importance for context-rot-aware placement
+    const critical = scan.findings.filter((f) => f.confidence === "high" && isCritical(f));
+    const important = scan.findings.filter((f) => f.confidence === "high" && !isCritical(f));
+    const supplementary = scan.findings.filter((f) => f.confidence === "medium");
+    const sections = [];
+    // ============================================
+    // BEGINNING: Most critical info goes here
+    // (LLMs retain start of context best)
+    // ============================================
+    sections.push("# CLAUDE.md");
+    sections.push("");
+    sections.push("This file provides guidance to Claude Code when working with this codebase.");
+    sections.push("Generated by [sourcebook](https://github.com/maroondlabs/sourcebook). Review and edit — the best context comes from human + machine together.");
+    sections.push("");
+    // Commands first -- most immediately actionable
+    if (hasCommands(scan.commands)) {
+        sections.push("## Commands");
+        sections.push("");
+        if (scan.commands.dev)
+            sections.push(`- **Dev:** \`${scan.commands.dev}\``);
+        if (scan.commands.build)
+            sections.push(`- **Build:** \`${scan.commands.build}\``);
+        if (scan.commands.test)
+            sections.push(`- **Test:** \`${scan.commands.test}\``);
+        if (scan.commands.lint)
+            sections.push(`- **Lint:** \`${scan.commands.lint}\``);
+        for (const [name, cmd] of Object.entries(scan.commands)) {
+            if (cmd && !["dev", "build", "test", "lint", "start"].includes(name)) {
+                sections.push(`- **${name}:** \`${cmd}\``);
+            }
+        }
+        sections.push("");
+    }
+    // Critical warnings/constraints near the top (danger zone, fragile code, hidden deps)
+    if (critical.length > 0) {
+        sections.push("## Critical Constraints");
+        sections.push("");
+        for (const finding of critical) {
+            sections.push(`- **${finding.category}:** ${finding.description}`);
+        }
+        sections.push("");
+    }
+    // ============================================
+    // MIDDLE: Less critical but useful info
+    // (LLMs retain this worst -- keep it short)
+    // ============================================
+    // Stack (brief)
+    if (scan.frameworks.length > 0) {
+        sections.push("## Stack");
+        sections.push("");
+        sections.push(scan.frameworks.join(", "));
+        sections.push("");
+    }
+    // Key directories (only non-obvious ones)
+    if (Object.keys(scan.structure.directories).length > 0) {
+        const nonObvious = Object.entries(scan.structure.directories).filter(([dir]) => !["src", "public", "node_modules", "dist", "build"].includes(dir));
+        if (nonObvious.length > 0) {
+            sections.push("## Project Structure");
+            sections.push("");
+            for (const [dir, purpose] of nonObvious) {
+                sections.push(`- \`${dir}/\` — ${purpose}`);
+            }
+            sections.push("");
+        }
+    }
+    // Core modules (from PageRank)
+    if (scan.rankedFiles && scan.rankedFiles.length > 0) {
+        const top5 = scan.rankedFiles.slice(0, 5);
+        sections.push("## Core Modules (by structural importance)");
+        sections.push("");
+        for (const { file } of top5) {
+            sections.push(`- \`${file}\``);
+        }
+        sections.push("");
+    }
+    // Important findings (high confidence, non-critical)
+    if (important.length > 0) {
+        sections.push("## Conventions & Patterns");
+        sections.push("");
+        const grouped = groupByCategory(important);
+        for (const [category, findings] of grouped) {
+            if (findings.length === 1) {
+                sections.push(`- **${category}:** ${findings[0].description}`);
+            }
+            else {
+                sections.push(`- **${category}:**`);
+                for (const f of findings) {
+                    sections.push(`  - ${f.description}`);
+                }
+            }
+        }
+        sections.push("");
+    }
+    // Supplementary findings (medium confidence)
+    if (supplementary.length > 0) {
+        sections.push("## Additional Context");
+        sections.push("");
+        const grouped = groupByCategory(supplementary);
+        for (const [category, findings] of grouped) {
+            if (findings.length === 1) {
+                sections.push(`- **${category}:** ${findings[0].description}`);
+            }
+            else {
+                sections.push(`- **${category}:**`);
+                for (const f of findings) {
+                    sections.push(`  - ${f.description}`);
+                }
+            }
+        }
+        sections.push("");
+    }
+    // ============================================
+    // END: Important reminders go here
+    // (LLMs retain end of context second-best)
+    // ============================================
+    // "What to add" section -- prompts human to add non-discoverable context
+    sections.push("## What to Add Manually");
+    sections.push("");
+    sections.push("The most valuable context is what only you know. Add:");
+    sections.push("");
+    sections.push("- Architectural decisions and why they were made");
+    sections.push("- Past incidents that shaped current conventions");
+    sections.push("- Deprecated patterns to avoid in new code");
+    sections.push("- Domain-specific rules or terminology");
+    sections.push("- Environment setup beyond what .env.example shows");
+    sections.push("");
+    let output = sections.join("\n");
+    // Token budget enforcement (rough: 1 token ≈ 4 chars)
+    const charBudget = budget * 4;
+    if (output.length > charBudget) {
+        output = output.slice(0, charBudget);
+        const lastNewline = output.lastIndexOf("\n");
+        output =
+            output.slice(0, lastNewline) +
+                "\n\n<!-- truncated to fit token budget -->\n";
+    }
+    return output;
+}
+/**
+ * Determine if a finding is "critical" -- things that can cause real damage
+ * if an agent gets them wrong. These go at the TOP of the file.
+ */
+function isCritical(finding) {
+    const criticalCategories = new Set([
+        "Hidden dependencies",
+        "Circular dependencies",
+        "Core modules",
+        "Fragile code",
+        "Git history",
+        "Commit conventions",
+    ]);
+    const criticalKeywords = [
+        "breaking",
+        "blast radius",
+        "deprecated",
+        "don't",
+        "must",
+        "never",
+        "revert",
+        "fragile",
+        "hidden",
+        "invisible",
+        "coupling",
+    ];
+    if (criticalCategories.has(finding.category))
+        return true;
+    const desc = finding.description.toLowerCase();
+    return criticalKeywords.some((kw) => desc.includes(kw));
+}
+function groupByCategory(findings) {
+    const grouped = new Map();
+    for (const finding of findings) {
+        const existing = grouped.get(finding.category) || [];
+        existing.push(finding);
+        grouped.set(finding.category, existing);
+    }
+    return grouped;
+}
+function hasCommands(commands) {
+    return Object.values(commands).some((v) => v !== undefined);
+}

package/dist/generators/copilot.d.ts

@@ -0,0 +1,12 @@
+import type { ProjectScan } from "../types.js";
+/**
+ * Generate GitHub Copilot instructions from scan results.
+ *
+ * Copilot supports:
+ * - `.github/copilot-instructions.md` — repo-level instructions (always loaded)
+ * - `.instructions.md` — per-directory instructions (loaded when files in that dir are referenced)
+ *
+ * We generate the repo-level file. Copilot's format is plain markdown with
+ * natural language instructions — more conversational than Cursor's directive style.
+ */
+export declare function generateCopilot(scan: ProjectScan, budget: number): string;

package/dist/generators/copilot.js

@@ -0,0 +1,119 @@
+/**
+ * Generate GitHub Copilot instructions from scan results.
+ *
+ * Copilot supports:
+ * - `.github/copilot-instructions.md` — repo-level instructions (always loaded)
+ * - `.instructions.md` — per-directory instructions (loaded when files in that dir are referenced)
+ *
+ * We generate the repo-level file. Copilot's format is plain markdown with
+ * natural language instructions — more conversational than Cursor's directive style.
+ */
+export function generateCopilot(scan, budget) {
+    const critical = scan.findings.filter((f) => f.confidence === "high" && isCritical(f));
+    const important = scan.findings.filter((f) => f.confidence === "high" && !isCritical(f));
+    const supplementary = scan.findings.filter((f) => f.confidence === "medium");
+    const sections = [];
+    sections.push("# Copilot Instructions");
+    sections.push("");
+    sections.push("These instructions were generated by [sourcebook](https://github.com/maroondlabs/sourcebook). Review and edit — the best context comes from human + machine together.");
+    sections.push("");
+    // Commands
+    if (hasCommands(scan.commands)) {
+        sections.push("## Development Commands");
+        sections.push("");
+        if (scan.commands.dev)
+            sections.push(`- Dev server: \`${scan.commands.dev}\``);
+        if (scan.commands.build)
+            sections.push(`- Build: \`${scan.commands.build}\``);
+        if (scan.commands.test)
+            sections.push(`- Tests: \`${scan.commands.test}\``);
+        if (scan.commands.lint)
+            sections.push(`- Lint: \`${scan.commands.lint}\``);
+        for (const [name, cmd] of Object.entries(scan.commands)) {
+            if (cmd && !["dev", "build", "test", "lint", "start"].includes(name)) {
+                sections.push(`- ${name}: \`${cmd}\``);
+            }
+        }
+        sections.push("");
+    }
+    // Critical constraints
+    if (critical.length > 0) {
+        sections.push("## Important Constraints");
+        sections.push("");
+        sections.push("Follow these rules when modifying this codebase:");
+        sections.push("");
+        for (const finding of critical) {
+            sections.push(`- ${finding.description}`);
+        }
+        sections.push("");
+    }
+    // Stack
+    if (scan.frameworks.length > 0) {
+        sections.push("## Technology Stack");
+        sections.push("");
+        sections.push(`This project uses: ${scan.frameworks.join(", ")}.`);
+        sections.push("");
+    }
+    // Core modules
+    if (scan.rankedFiles && scan.rankedFiles.length > 0) {
+        const top5 = scan.rankedFiles.slice(0, 5);
+        sections.push("## High-Impact Files");
+        sections.push("");
+        sections.push("These files are imported by many others. Changes here have wide blast radius:");
+        sections.push("");
+        for (const { file } of top5) {
+            sections.push(`- \`${file}\``);
+        }
+        sections.push("");
+    }
+    // Conventions
+    if (important.length > 0) {
+        sections.push("## Code Conventions");
+        sections.push("");
+        sections.push("This project follows these patterns:");
+        sections.push("");
+        for (const finding of important) {
+            sections.push(`- ${finding.description}`);
+        }
+        sections.push("");
+    }
+    // Additional context
+    if (supplementary.length > 0) {
+        sections.push("## Additional Notes");
+        sections.push("");
+        for (const finding of supplementary) {
+            sections.push(`- ${finding.description}`);
+        }
+        sections.push("");
+    }
+    let output = sections.join("\n");
+    // Token budget enforcement
+    const charBudget = budget * 4;
+    if (output.length > charBudget) {
+        output = output.slice(0, charBudget);
+        const lastNewline = output.lastIndexOf("\n");
+        output = output.slice(0, lastNewline) + "\n";
+    }
+    return output;
+}
+function isCritical(finding) {
+    const criticalCategories = new Set([
+        "Hidden dependencies",
+        "Circular dependencies",
+        "Core modules",
+        "Fragile code",
+        "Git history",
+        "Commit conventions",
+    ]);
+    const criticalKeywords = [
+        "breaking", "blast radius", "deprecated", "don't", "must",
+        "never", "revert", "fragile", "hidden", "invisible", "coupling",
+    ];
+    if (criticalCategories.has(finding.category))
+        return true;
+    const desc = finding.description.toLowerCase();
+    return criticalKeywords.some((kw) => desc.includes(kw));
+}
+function hasCommands(commands) {
+    return Object.values(commands).some((v) => v !== undefined);
+}

package/dist/generators/cursor.d.ts

@@ -0,0 +1,17 @@
+import type { ProjectScan } from "../types.js";
+/**
+ * Generate Cursor rules from scan results.
+ *
+ * Cursor deprecated `.cursorrules` in favor of modular `.cursor/rules/*.mdc` files.
+ * Each .mdc file has YAML frontmatter (description, globs, alwaysApply) + markdown body.
+ *
+ * We generate a single `sourcebook.mdc` with alwaysApply: true containing
+ * the same non-discoverable findings as the Claude generator, formatted for
+ * Cursor's conventions (shorter, more directive).
+ */
+export declare function generateCursor(scan: ProjectScan, budget: number): string;
+/**
+ * Also generate the legacy .cursorrules format for backwards compatibility.
+ * Same content as the .mdc but without the frontmatter.
+ */
+export declare function generateCursorLegacy(scan: ProjectScan, budget: number): string;