@justyork/repo-mind 0.3.0

package/README.md

@@ -0,0 +1,110 @@
+# RepoMind
+
+**Unified project knowledge in `docs/`** — wiki, architecture, ADR, stack, and glossary live in your repository. Humans edit via a Confluence-style UI; AI agents query the same files through MCP. No Confluence or Notion required.
+
+## Status
+
+**v0.3.0** — keyboard nav, image upload, domain labels, yaml/json reader, `ab-demo` harness. Confluence-style UI, wikilinks, deep links (`?slug=`), prepare/sync-links.
+
+| Artifact | Location |
+|----------|----------|
+| **Product roadmap** | [`docs/product/wiki/roadmap.md`](docs/product/wiki/roadmap.md) |
+| Full product vision | [`idea.md`](idea.md) |
+| docs/ pivot spec | [`.gstack/projects/repo-mind/specs/2026-06-21-repomind-docs-root-pivot.md`](.gstack/projects/repo-mind/specs/2026-06-21-repomind-docs-root-pivot.md) |
+| Design system | [`DESIGN.md`](DESIGN.md) |
+
+## Install
+
+```bash
+npm install -g @justyork/repo-mind
+```
+
+CLI command remains **`repo-mind`** (bin alias unchanged).
+
+## Quick start
+
+```bash
+# From npm
+npx -y @justyork/repo-mind init
+npx -y @justyork/repo-mind setup
+
+# From this repo (local dev)
+npm install && npm run build
+node dist/cli.js init
+node dist/cli.js setup
+```
+
+Then ask your agent a project question — it should call `search_docs` / `get_doc` via MCP against the same `docs/` you edit in the UI.
+
+## CLI commands
+
+| Command | Description |
+|---------|-------------|
+| `repo-mind init` | Scaffold `docs/` with example structured pages |
+| `repo-mind setup` | Configure Cursor/Claude MCP + CLAUDE.md snippet |
+| `repo-mind check` | Validate frontmatter schema and `related:` links |
+| `repo-mind prepare` | Add frontmatter to legacy markdown (`--all` for batch) |
+| `repo-mind sync-links` | Convert markdown links to wikilinks; sync `related:` |
+| `repo-mind export` | Write `agents.md` to repo root |
+| `repo-mind mcp` | Start the MCP stdio server |
+| `repo-mind ui` | Confluence-style workspace over `docs/` (127.0.0.1:3847) |
+| `npm run ab-demo` | Validate A/B demo fixture (repo checkout only) |
+
+## Cursor skill
+
+Agent skill for authoring `docs/` — **domains** (product, technical, game-design, analytics, …), frontmatter, structure, wikilinks: [`.cursor/skills/repomind-docs/`](.cursor/skills/repomind-docs/) ([structure.md](.cursor/skills/repomind-docs/structure.md)). Copy to `~/.cursor/skills/repomind-docs/` for other projects.
+
+## Web UI
+
+Confluence-style workspace over **`docs/`**:
+
+```bash
+npm run build
+repo-mind ui              # http://127.0.0.1:3847
+repo-mind ui --port 4000 --cwd /path/to/project
+```
+
+- **Catalog tree** — docs by domain (`Product`, `Technical`, …) and type
+- **Prepare** — recursively find markdown without frontmatter; add schema in one click
+- **Drafts + Publish** — SQLite drafts, publish to `docs/*.md`
+- **Health** — schema check, publish queue, export `agents.md`
+- **Graph** — full-page view at `/graph.html`
+- **Theme** — light (default) / dark toggle
+
+Binds **127.0.0.1** only. MCP reads published files in `docs/` only (not SQLite drafts).
+
+## MCP tools
+
+- `list_docs` — filter by type, status, tag
+- `search_docs` — ranked full-text search
+- `get_doc` — fetch one doc by slug
+- `get_glossary_term` — resolve glossary entries
+- `explore_graph` — BFS over `related:` links
+
+## CI
+
+Add to GitHub Actions or pre-commit:
+
+```yaml
+- run: npx @justyork/repo-mind check
+```
+
+## Development
+
+```bash
+npm install
+npm run build
+npm test
+```
+
+## gstack workflow
+
+This repo is developed with [gstack](https://github.com/garrytan/gstack). Project artifacts live in `.gstack/projects/repo-mind/` (versioned in git). Set `GSTACK_HOME=.gstack` when working in this repo (see `.env`).
+
+## Roadmap
+
+See [`docs/product/wiki/roadmap.md`](docs/product/wiki/roadmap.md) for v4.0–v4.2 phases. Next: v4.1 keyboard nav and image upload; v4.2 agent write (gated on kill-switch).
+
+## License
+
+MIT

package/dist/ab-demo/arm-baseline.d.ts

@@ -0,0 +1,8 @@
+import type { DocIndex } from '../index/doc-index.js';
+import type { ArmBaselineResult } from './types.js';
+import type { AbQuestion } from './types.js';
+/**
+ * Arm A: plain markdown + minimal CLAUDE.md.
+ * Simulates grep-then-read; falls back to reading the full corpus when nothing matches.
+ */
+export declare function runArmBaseline(index: DocIndex, question: AbQuestion, sessionOverheadPerQuestion: number): ArmBaselineResult;

package/dist/ab-demo/arm-baseline.js

@@ -0,0 +1,40 @@
+import { estimateTokens } from './estimate-tokens.js';
+function queryTerms(prompt) {
+    return prompt
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((term) => term.length >= 3);
+}
+function docMatchesTerms(doc, terms) {
+    if (terms.length === 0) {
+        return true;
+    }
+    const haystack = `${doc.title}\n${doc.tags.join(' ')}\n${doc.body}`.toLowerCase();
+    return terms.some((term) => haystack.includes(term));
+}
+/**
+ * Arm A: plain markdown + minimal CLAUDE.md.
+ * Simulates grep-then-read; falls back to reading the full corpus when nothing matches.
+ */
+export function runArmBaseline(index, question, sessionOverheadPerQuestion) {
+    const docs = index.refresh();
+    const terms = queryTerms(question.prompt);
+    let matched = docs.filter((doc) => docMatchesTerms(doc, terms));
+    let strategy = 'grep-then-read';
+    if (matched.length === 0) {
+        matched = docs;
+        strategy = 'read-all';
+    }
+    let tokens = sessionOverheadPerQuestion;
+    for (const doc of matched) {
+        tokens += estimateTokens(doc.body);
+        tokens += estimateTokens(doc.relativePath);
+    }
+    return {
+        arm: 'baseline',
+        questionId: question.id,
+        tokens,
+        filesRead: matched.length,
+        strategy,
+    };
+}

package/dist/ab-demo/arm-repomind.d.ts

@@ -0,0 +1,7 @@
+import type { DocIndex } from '../index/doc-index.js';
+import type { ArmRepomindResult } from './types.js';
+import type { AbQuestion } from './types.js';
+/**
+ * Arm B: RepoMind MCP — search_docs then get_doc on top hits.
+ */
+export declare function runArmRepomind(index: DocIndex, question: AbQuestion, sessionOverheadPerQuestion: number): ArmRepomindResult;

package/dist/ab-demo/arm-repomind.js

@@ -0,0 +1,35 @@
+import { getDoc } from '../tools/get-doc.js';
+import { searchDocs } from '../tools/search-docs.js';
+import { estimateJsonTokens } from './estimate-tokens.js';
+const GET_DOC_LIMIT = 3;
+/**
+ * Arm B: RepoMind MCP — search_docs then get_doc on top hits.
+ */
+export function runArmRepomind(index, question, sessionOverheadPerQuestion) {
+    let tokens = sessionOverheadPerQuestion;
+    const searchInput = { query: question.prompt };
+    tokens += estimateJsonTokens({ tool: 'search_docs', input: searchInput });
+    const hits = searchDocs(index, searchInput);
+    tokens += estimateJsonTokens(hits);
+    const slugsToFetch = hits.slice(0, GET_DOC_LIMIT).map((hit) => hit.slug);
+    let docsFetched = 0;
+    for (const slug of slugsToFetch) {
+        tokens += estimateJsonTokens({ tool: 'get_doc', input: { slug } });
+        const doc = getDoc(index, slug);
+        if (doc.found && doc.body) {
+            tokens += estimateJsonTokens({
+                slug: doc.slug,
+                title: doc.frontmatter?.title,
+                body: doc.body,
+            });
+            docsFetched += 1;
+        }
+    }
+    return {
+        arm: 'repomind',
+        questionId: question.id,
+        tokens,
+        searchHits: hits.length,
+        docsFetched,
+    };
+}

package/dist/ab-demo/estimate-tokens.d.ts

@@ -0,0 +1,3 @@
+/** Rough token estimate (~4 chars per token) for reproducible A/B comparison. */
+export declare function estimateTokens(text: string): number;
+export declare function estimateJsonTokens(value: unknown): number;

package/dist/ab-demo/estimate-tokens.js

@@ -0,0 +1,10 @@
+/** Rough token estimate (~4 chars per token) for reproducible A/B comparison. */
+export function estimateTokens(text) {
+    if (text.length === 0) {
+        return 0;
+    }
+    return Math.ceil(text.length / 4);
+}
+export function estimateJsonTokens(value) {
+    return estimateTokens(JSON.stringify(value));
+}

package/dist/ab-demo/load-questions.d.ts

@@ -0,0 +1,2 @@
+import type { AbQuestionsFile } from './types.js';
+export declare function loadQuestions(filePath: string): AbQuestionsFile;

package/dist/ab-demo/load-questions.js

@@ -0,0 +1,65 @@
+import fs from 'node:fs';
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function parseQuestion(raw, index) {
+    if (!raw || typeof raw !== 'object') {
+        throw new Error(`questions[${index}] must be an object`);
+    }
+    const record = raw;
+    if (!isNonEmptyString(record.id)) {
+        throw new Error(`questions[${index}].id must be a non-empty string`);
+    }
+    if (!isNonEmptyString(record.prompt)) {
+        throw new Error(`questions[${index}].prompt must be a non-empty string`);
+    }
+    if (!Array.isArray(record.anchorSlugs) || record.anchorSlugs.length === 0) {
+        throw new Error(`questions[${index}].anchorSlugs must be a non-empty array`);
+    }
+    for (const slug of record.anchorSlugs) {
+        if (!isNonEmptyString(slug)) {
+            throw new Error(`questions[${index}].anchorSlugs must contain strings`);
+        }
+    }
+    const tags = Array.isArray(record.tags)
+        ? record.tags.filter((tag) => isNonEmptyString(tag))
+        : undefined;
+    return {
+        id: record.id,
+        prompt: record.prompt,
+        anchorSlugs: record.anchorSlugs,
+        tags,
+    };
+}
+export function loadQuestions(filePath) {
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`questions file not found: ${filePath}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`invalid JSON in ${filePath}: ${message}`);
+    }
+    if (!parsed || typeof parsed !== 'object') {
+        throw new Error(`questions file must be a JSON object: ${filePath}`);
+    }
+    const record = parsed;
+    if (record.version !== 1) {
+        throw new Error(`unsupported questions version (expected 1): ${filePath}`);
+    }
+    if (!Array.isArray(record.questions) || record.questions.length === 0) {
+        throw new Error(`questions array must be non-empty: ${filePath}`);
+    }
+    const questions = record.questions.map(parseQuestion);
+    const ids = new Set();
+    for (const question of questions) {
+        if (ids.has(question.id)) {
+            throw new Error(`duplicate question id: ${question.id}`);
+        }
+        ids.add(question.id);
+    }
+    return { version: 1, questions };
+}

package/dist/ab-demo/paths.d.ts

@@ -0,0 +1,5 @@
+export declare function resolveAbDemoRoot(startDir?: string): string;
+export declare function corpusPath(abDemoRoot: string): string;
+export declare function questionsPath(abDemoRoot: string): string;
+export declare function resultsDir(abDemoRoot: string): string;
+export declare function scoreRubricPath(abDemoRoot: string): string;

package/dist/ab-demo/paths.js

@@ -0,0 +1,31 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+export function resolveAbDemoRoot(startDir = process.cwd()) {
+    let current = path.resolve(startDir);
+    while (true) {
+        const candidate = path.join(current, 'ab-demo');
+        if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
+            return candidate;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    return path.join(PACKAGE_ROOT, 'ab-demo');
+}
+export function corpusPath(abDemoRoot) {
+    return path.join(abDemoRoot, 'corpus');
+}
+export function questionsPath(abDemoRoot) {
+    return path.join(abDemoRoot, 'questions.json');
+}
+export function resultsDir(abDemoRoot) {
+    return path.join(abDemoRoot, 'results');
+}
+export function scoreRubricPath(abDemoRoot) {
+    return path.join(abDemoRoot, 'score-hallucination.md');
+}

package/dist/ab-demo/run-ab.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+export interface RunAbOptions {
+    cwd?: string;
+    dryRun?: boolean;
+    outputPath?: string;
+}
+export declare function runAbDemo(options?: RunAbOptions): number;

package/dist/ab-demo/run-ab.js

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { DocIndex } from '../index/doc-index.js';
+import { loadQuestions } from './load-questions.js';
+import { corpusPath, questionsPath, resolveAbDemoRoot, resultsDir, scoreRubricPath, } from './paths.js';
+import { runArmsComparison } from './run-arms.js';
+import { materializeCorpusRepo, validateCorpusAgainstQuestions } from './validate-corpus.js';
+function printUsage() {
+    console.log(`repo-mind A/B demo harness (kill-switch eval)
+
+Usage:
+  npm run ab-demo -- [--dry-run] [--output <path>]
+
+Options:
+  --dry-run   Validate corpus + questions only (no agent runs)
+  --output    Write results JSON (default: ab-demo/results/latest.json)
+`);
+}
+function parseCliArgs(argv) {
+    const options = {};
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === '--help' || arg === '-h') {
+            printUsage();
+            process.exit(0);
+        }
+        if (arg === '--dry-run') {
+            options.dryRun = true;
+            continue;
+        }
+        if (arg === '--output') {
+            const value = argv[i + 1];
+            if (!value) {
+                throw new Error('--output requires a path');
+            }
+            options.outputPath = value;
+            i += 1;
+            continue;
+        }
+        throw new Error(`unknown argument: ${arg}`);
+    }
+    return options;
+}
+export function runAbDemo(options = {}) {
+    const abRoot = resolveAbDemoRoot(options.cwd);
+    const corpus = corpusPath(abRoot);
+    const questionsFile = questionsPath(abRoot);
+    const rubric = scoreRubricPath(abRoot);
+    if (!fs.existsSync(rubric)) {
+        console.error(`missing rubric: ${rubric}`);
+        return 1;
+    }
+    let questions;
+    try {
+        questions = loadQuestions(questionsFile);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(message);
+        return 1;
+    }
+    let report;
+    try {
+        report = validateCorpusAgainstQuestions(corpus, questions.questions);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(message);
+        return 1;
+    }
+    if (report.missingAnchors.length > 0) {
+        console.error('corpus missing anchor slugs:');
+        for (const missing of report.missingAnchors) {
+            console.error(`  ${missing.questionId}: ${missing.slug}`);
+        }
+        return 1;
+    }
+    console.log(`corpus ok: ${report.docCount} docs, ${report.questionCount} questions`);
+    if (options.dryRun) {
+        console.log('dry-run complete — agent arms not executed');
+        return 0;
+    }
+    const workDir = materializeCorpusRepo(corpus);
+    try {
+        const index = new DocIndex(workDir);
+        const arms = runArmsComparison(index, questions.questions);
+        const outDir = resultsDir(abRoot);
+        fs.mkdirSync(outDir, { recursive: true });
+        const outputPath = options.outputPath ?? path.join(outDir, 'latest.json');
+        const payload = {
+            runAt: new Date().toISOString(),
+            corpusPath: corpus,
+            questionsVersion: questions.version,
+            arms,
+            pass: arms.pass,
+        };
+        fs.writeFileSync(outputPath, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+        console.log(`baseline median tokens: ${arms.baseline.medianTokens} | repomind: ${arms.repomind.medianTokens}`);
+        console.log(`token wins: repomind ${arms.repomindTokenWins}/${questions.questions.length} (need ${arms.passThreshold})`);
+        console.log(`token pass: ${arms.tokenPass ? 'yes' : 'no'}`);
+        console.log(`wrote ${outputPath}`);
+        if (!arms.tokenPass) {
+            return 1;
+        }
+        return 0;
+    }
+    finally {
+        fs.rmSync(workDir, { recursive: true, force: true });
+    }
+}
+function main() {
+    try {
+        const code = runAbDemo(parseCliArgs(process.argv.slice(2)));
+        process.exit(code);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(message);
+        process.exit(1);
+    }
+}
+const isMain = process.argv[1] !== undefined &&
+    fileURLToPath(import.meta.url) === path.resolve(process.argv[1]);
+if (isMain) {
+    main();
+}

package/dist/ab-demo/run-arms.d.ts

@@ -0,0 +1,3 @@
+import type { DocIndex } from '../index/doc-index.js';
+import type { AbArmsRunResult, AbQuestion } from './types.js';
+export declare function runArmsComparison(index: DocIndex, questions: AbQuestion[]): AbArmsRunResult;

package/dist/ab-demo/run-arms.js

@@ -0,0 +1,67 @@
+import { runArmBaseline } from './arm-baseline.js';
+import { runArmRepomind } from './arm-repomind.js';
+import { BASELINE_CLAUDE_SNIPPET, mcpToolSchemaTokenEstimate, } from './session-overhead.js';
+import { estimateTokens } from './estimate-tokens.js';
+function median(values) {
+    if (values.length === 0) {
+        return 0;
+    }
+    const sorted = [...values].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    if (sorted.length % 2 === 0) {
+        return Math.round((sorted[mid - 1] + sorted[mid]) / 2);
+    }
+    return sorted[mid];
+}
+function summarizeArm(arm, perQuestion) {
+    const tokens = perQuestion.map((row) => arm === 'baseline' ? row.baseline.tokens : row.repomind.tokens);
+    return {
+        arm,
+        medianTokens: median(tokens),
+        perQuestionTokens: tokens,
+    };
+}
+export function runArmsComparison(index, questions) {
+    const n = questions.length;
+    const listing = index
+        .refresh()
+        .map((doc) => doc.relativePath)
+        .join('\n');
+    const baselineSession = estimateTokens(BASELINE_CLAUDE_SNIPPET) + estimateTokens(listing);
+    const repomindSession = mcpToolSchemaTokenEstimate();
+    const baselineOverhead = Math.ceil(baselineSession / n);
+    const repomindOverhead = Math.ceil(repomindSession / n);
+    const comparisons = questions.map((question) => {
+        const baseline = runArmBaseline(index, question, baselineOverhead);
+        const repomind = runArmRepomind(index, question, repomindOverhead);
+        return {
+            questionId: question.id,
+            prompt: question.prompt,
+            anchorSlugs: question.anchorSlugs,
+            baseline,
+            repomind,
+            tokenWinner: repomind.tokens < baseline.tokens
+                ? 'repomind'
+                : repomind.tokens > baseline.tokens
+                    ? 'baseline'
+                    : 'tie',
+        };
+    });
+    const baselineSummary = summarizeArm('baseline', comparisons);
+    const repomindSummary = summarizeArm('repomind', comparisons);
+    const repomindWins = comparisons.filter((row) => row.tokenWinner === 'repomind').length;
+    const passThreshold = Math.ceil((n * 2) / 3);
+    const tokenPass = repomindSummary.medianTokens < baselineSummary.medianTokens &&
+        repomindWins >= passThreshold;
+    return {
+        comparisons,
+        baseline: baselineSummary,
+        repomind: repomindSummary,
+        repomindTokenWins: repomindWins,
+        passThreshold,
+        tokenPass,
+        hallucinationPass: null,
+        pass: tokenPass ? null : false,
+        note: 'Automated token comparison only. Set humanScores in results JSON; pass becomes true when hallucination rubric also passes.',
+    };
+}

package/dist/ab-demo/session-overhead.d.ts

@@ -0,0 +1,3 @@
+/** Mirrors MCP ListTools payload shape for token budgeting. */
+export declare function mcpToolSchemaTokenEstimate(): number;
+export declare const BASELINE_CLAUDE_SNIPPET = "# Project knowledge\n\nRead markdown files under `docs/` to answer questions. Prefer grep or glob before reading entire files.\n";

package/dist/ab-demo/session-overhead.js

@@ -0,0 +1,68 @@
+import { DOC_DOMAINS, DOC_STATUSES, DOC_TYPES } from '../index/types.js';
+import { estimateJsonTokens } from './estimate-tokens.js';
+/** Mirrors MCP ListTools payload shape for token budgeting. */
+export function mcpToolSchemaTokenEstimate() {
+    const tools = [
+        {
+            name: 'list_docs',
+            description: 'List project knowledge documents with optional filters.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    type: { type: 'string', enum: [...DOC_TYPES] },
+                    status: { type: 'string', enum: [...DOC_STATUSES] },
+                    tag: { type: 'string' },
+                    domain: { type: 'string', enum: [...DOC_DOMAINS] },
+                },
+            },
+        },
+        {
+            name: 'search_docs',
+            description: 'Search project knowledge documents by query.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    query: { type: 'string' },
+                    type: { type: 'string', enum: [...DOC_TYPES] },
+                    domain: { type: 'string', enum: [...DOC_DOMAINS] },
+                },
+                required: ['query'],
+            },
+        },
+        {
+            name: 'get_doc',
+            description: 'Fetch a single document by slug.',
+            inputSchema: {
+                type: 'object',
+                properties: { slug: { type: 'string' } },
+                required: ['slug'],
+            },
+        },
+        {
+            name: 'get_glossary_term',
+            description: 'Resolve a glossary term by name.',
+            inputSchema: {
+                type: 'object',
+                properties: { name: { type: 'string' } },
+                required: ['name'],
+            },
+        },
+        {
+            name: 'explore_graph',
+            description: 'Explore related documents as a graph.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    slug: { type: 'string' },
+                    depth: { type: 'number' },
+                },
+                required: ['slug'],
+            },
+        },
+    ];
+    return estimateJsonTokens({ tools });
+}
+export const BASELINE_CLAUDE_SNIPPET = `# Project knowledge
+
+Read markdown files under \`docs/\` to answer questions. Prefer grep or glob before reading entire files.
+`;

package/dist/ab-demo/types.d.ts

@@ -0,0 +1,65 @@
+export interface AbQuestion {
+    id: string;
+    prompt: string;
+    /** Slugs that a grounded answer should cite or retrieve. */
+    anchorSlugs: string[];
+    tags?: string[];
+}
+export interface AbQuestionsFile {
+    version: number;
+    questions: AbQuestion[];
+}
+export interface AbDryRunReport {
+    corpusPath: string;
+    docCount: number;
+    questionCount: number;
+    missingAnchors: Array<{
+        questionId: string;
+        slug: string;
+    }>;
+}
+export interface ArmBaselineResult {
+    arm: 'baseline';
+    questionId: string;
+    tokens: number;
+    filesRead: number;
+    strategy: 'grep-then-read' | 'read-all';
+}
+export interface ArmRepomindResult {
+    arm: 'repomind';
+    questionId: string;
+    tokens: number;
+    searchHits: number;
+    docsFetched: number;
+}
+export interface AbQuestionComparison {
+    questionId: string;
+    prompt: string;
+    anchorSlugs: string[];
+    baseline: ArmBaselineResult;
+    repomind: ArmRepomindResult;
+    tokenWinner: 'baseline' | 'repomind' | 'tie';
+}
+export interface AbArmSummary {
+    arm: 'baseline' | 'repomind';
+    medianTokens: number;
+    perQuestionTokens: number[];
+}
+export interface AbArmsRunResult {
+    comparisons: AbQuestionComparison[];
+    baseline: AbArmSummary;
+    repomind: AbArmSummary;
+    repomindTokenWins: number;
+    passThreshold: number;
+    tokenPass: boolean;
+    hallucinationPass: boolean | null;
+    pass: boolean | null;
+    note: string;
+}
+export interface AbRunResult {
+    runAt: string;
+    corpusPath: string;
+    questionsVersion: number;
+    arms: AbArmsRunResult;
+    pass: boolean | null;
+}

package/dist/ab-demo/types.js

@@ -0,0 +1 @@
+export {};