@justyork/repo-mind 0.3.0

package/dist/ab-demo/validate-corpus.d.ts

@@ -0,0 +1,3 @@
+import type { AbDryRunReport, AbQuestion } from './types.js';
+export declare function materializeCorpusRepo(corpusPath: string): string;
+export declare function validateCorpusAgainstQuestions(corpusPath: string, questions: AbQuestion[]): AbDryRunReport;

package/dist/ab-demo/validate-corpus.js

@@ -0,0 +1,38 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { DocIndex } from '../index/doc-index.js';
+export function materializeCorpusRepo(corpusPath) {
+    if (!fs.existsSync(corpusPath)) {
+        throw new Error(`corpus directory not found: ${corpusPath}`);
+    }
+    const workDir = fs.mkdtempSync(path.join(os.tmpdir(), 'repo-mind-ab-demo-'));
+    const docsDir = path.join(workDir, 'docs');
+    fs.cpSync(corpusPath, docsDir, { recursive: true });
+    return workDir;
+}
+export function validateCorpusAgainstQuestions(corpusPath, questions) {
+    const workDir = materializeCorpusRepo(corpusPath);
+    try {
+        const index = new DocIndex(workDir);
+        const docs = index.refresh();
+        const slugSet = new Set(docs.map((doc) => doc.slug));
+        const missingAnchors = [];
+        for (const question of questions) {
+            for (const slug of question.anchorSlugs) {
+                if (!slugSet.has(slug)) {
+                    missingAnchors.push({ questionId: question.id, slug });
+                }
+            }
+        }
+        return {
+            corpusPath,
+            docCount: docs.length,
+            questionCount: questions.length,
+            missingAnchors,
+        };
+    }
+    finally {
+        fs.rmSync(workDir, { recursive: true, force: true });
+    }
+}

package/dist/check/collect-violations.d.ts

@@ -0,0 +1,11 @@
+import type { DocIndex } from '../index/doc-index.js';
+export interface CheckViolation {
+    path: string;
+    message: string;
+}
+export interface CheckReport {
+    ok: boolean;
+    violations: CheckViolation[];
+    warnings: string[];
+}
+export declare function collectCheckReport(index: DocIndex): CheckReport | null;

package/dist/check/collect-violations.js

@@ -0,0 +1,127 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { resolveAssetRelativePath } from '../index/resolve-asset-href.js';
+import { parseWikilinkTargets, resolveWikilinkTarget } from '../index/link-index.js';
+import { domainFromPath } from '../index/path-inference.js';
+import { assetExists } from '../ui/serve-asset.js';
+import { DOC_DOMAINS, DOC_STATUSES, DOC_TYPES, isDocDomain, isDocStatus, isDocType, } from '../index/types.js';
+const ORPHAN_WORKTREE_DAYS = 7;
+export function collectCheckReport(index) {
+    const knowledgeRoot = index.getKnowledgeRoot();
+    if (!knowledgeRoot) {
+        return null;
+    }
+    const violations = [];
+    const warnings = [];
+    const docs = index.refresh();
+    const slugCounts = new Map();
+    const slugSet = new Set(docs.map((doc) => doc.slug));
+    for (const doc of docs) {
+        slugCounts.set(doc.slug, (slugCounts.get(doc.slug) ?? 0) + 1);
+        if (!isDocType(doc.frontmatter.type)) {
+            violations.push({
+                path: doc.path,
+                message: `invalid type "${String(doc.frontmatter.type)}" — expected one of: ${DOC_TYPES.join(', ')}`,
+            });
+        }
+        if (!isDocStatus(doc.frontmatter.status)) {
+            violations.push({
+                path: doc.path,
+                message: `invalid status "${String(doc.frontmatter.status)}" — expected one of: ${DOC_STATUSES.join(', ')}`,
+            });
+        }
+        if (!doc.slug) {
+            violations.push({ path: doc.path, message: 'missing slug in frontmatter' });
+        }
+        if (doc.prepared && doc.frontmatter.domain !== undefined && !isDocDomain(doc.frontmatter.domain)) {
+            violations.push({
+                path: doc.path,
+                message: `invalid domain "${String(doc.frontmatter.domain)}" — expected one of: ${DOC_DOMAINS.join(', ')}`,
+            });
+        }
+        if (doc.prepared &&
+            doc.frontmatter.domain !== undefined &&
+            isDocDomain(doc.frontmatter.domain) &&
+            doc.frontmatter.domain !== domainFromPath(doc.relativePath) &&
+            domainFromPath(doc.relativePath) !== 'shared') {
+            warnings.push(`domain "${doc.frontmatter.domain}" in frontmatter does not match path domain "${domainFromPath(doc.relativePath)}" (${doc.relativePath})`);
+        }
+        for (const related of doc.related) {
+            if (!slugSet.has(related)) {
+                violations.push({
+                    path: doc.path,
+                    message: `broken related slug "${related}"`,
+                });
+            }
+        }
+        if (doc.contentKind !== 'markdown') {
+            if (doc.contentKind === 'json') {
+                try {
+                    JSON.parse(doc.body);
+                }
+                catch {
+                    warnings.push(`invalid JSON syntax in ${doc.relativePath}`);
+                }
+            }
+            continue;
+        }
+        const lookups = {
+            slugSet,
+            titleToSlug: new Map(docs.flatMap((item) => [
+                [item.slug.toLowerCase(), item.slug],
+                [item.title.toLowerCase(), item.slug],
+            ])),
+        };
+        for (const raw of parseWikilinkTargets(doc.body)) {
+            const resolved = resolveWikilinkTarget(raw, lookups);
+            if (resolved.broken) {
+                warnings.push(`broken wikilink [[${raw}]] in ${doc.relativePath}`);
+            }
+        }
+        const imagePattern = /!\[[^\]]*\]\(([^)]+)\)/g;
+        for (const match of doc.body.matchAll(imagePattern)) {
+            const href = match[1]?.trim() ?? '';
+            if (!href ||
+                href.startsWith('http://') ||
+                href.startsWith('https://') ||
+                href.startsWith('data:')) {
+                continue;
+            }
+            const relative = resolveAssetRelativePath(doc.relativePath, href);
+            if (!relative) {
+                warnings.push(`unresolved image path "${href}" in ${doc.relativePath}`);
+                continue;
+            }
+            if (!assetExists(knowledgeRoot, relative)) {
+                warnings.push(`missing image asset "${relative}" in ${doc.relativePath}`);
+            }
+        }
+    }
+    for (const [slug, count] of slugCounts) {
+        if (count > 1) {
+            violations.push({
+                path: knowledgeRoot,
+                message: `duplicate slug "${slug}" (${count} docs)`,
+            });
+        }
+    }
+    const worktreesDir = path.join(knowledgeRoot, '.worktrees');
+    if (fs.existsSync(worktreesDir)) {
+        const cutoff = Date.now() - ORPHAN_WORKTREE_DAYS * 24 * 60 * 60 * 1000;
+        for (const entry of fs.readdirSync(worktreesDir, { withFileTypes: true })) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            const entryPath = path.join(worktreesDir, entry.name);
+            const stat = fs.statSync(entryPath);
+            if (stat.mtimeMs < cutoff) {
+                warnings.push(`orphaned worktree older than ${ORPHAN_WORKTREE_DAYS} days: ${entryPath}`);
+            }
+        }
+    }
+    return {
+        ok: violations.length === 0,
+        violations,
+        warnings,
+    };
+}

package/dist/cli.d.ts

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

package/dist/cli.js

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+import { runCheck } from './commands/check.js';
+import { runExport } from './commands/export.js';
+import { runInit } from './commands/init.js';
+import { runPrepare } from './commands/prepare.js';
+import { runSetup } from './commands/setup.js';
+import { runSyncLinks } from './commands/sync-links.js';
+import { runUi } from './commands/ui.js';
+import { startMcpServer } from './mcp/server.js';
+function printHelp() {
+    console.log(`repo-mind — unified docs workspace for humans and AI agents
+
+Usage:
+  repo-mind init [--cwd <dir>]
+  repo-mind setup [--cursor] [--claude] [--force]
+  repo-mind check [--cwd <dir>]
+  repo-mind export [--force] [--cwd <dir>]
+  repo-mind prepare [--all] [--dry-run] [--cwd <dir>] [relative-path]
+  repo-mind sync-links [--dry-run] [--no-convert-body] [--no-sync-related] [--cwd <dir>]
+  repo-mind mcp
+  repo-mind ui [--port <n>] [--cwd <dir>]
+
+Commands:
+  init    Scaffold docs/ with example structured pages
+  setup   Configure Cursor/Claude MCP and CLAUDE.md snippet
+  check   Validate frontmatter schema and related links
+  export  Write agents.md export to repo root
+  prepare Add RepoMind frontmatter to markdown files (--all for batch)
+  sync-links Convert markdown links to wikilinks and sync related frontmatter
+  mcp     Start the MCP stdio server
+  ui      Confluence-style workspace over docs/ (127.0.0.1)
+`);
+}
+function parseArgs(argv) {
+    const [command, ...rest] = argv;
+    const flags = {};
+    for (let i = 0; i < rest.length; i += 1) {
+        const arg = rest[i];
+        if (arg === '--all') {
+            flags.all = true;
+            continue;
+        }
+        if (arg === '--dry-run') {
+            flags.dryRun = true;
+            continue;
+        }
+        if (arg === '--no-convert-body') {
+            flags.noConvertBody = true;
+            continue;
+        }
+        if (arg === '--no-sync-related') {
+            flags.noSyncRelated = true;
+            continue;
+        }
+        if (arg === '--force') {
+            flags.force = true;
+            continue;
+        }
+        if (arg === '--cursor') {
+            flags.cursor = true;
+            continue;
+        }
+        if (arg === '--claude') {
+            flags.claude = true;
+            continue;
+        }
+        if (arg === '--cwd' && rest[i + 1]) {
+            flags.cwd = rest[i + 1];
+            i += 1;
+            continue;
+        }
+        if (arg === '--port' && rest[i + 1]) {
+            flags.port = rest[i + 1];
+            i += 1;
+            continue;
+        }
+        if (arg === '--help' || arg === '-h') {
+            flags.help = true;
+        }
+    }
+    return { command, flags };
+}
+async function main() {
+    const { command, flags } = parseArgs(process.argv.slice(2));
+    if (!command || flags.help) {
+        printHelp();
+        process.exit(command ? 0 : 1);
+    }
+    const cwd = typeof flags.cwd === 'string' ? flags.cwd : undefined;
+    const positionalPath = process.argv.slice(2).find((arg, index, argv) => index > 0 &&
+        !arg.startsWith('-') &&
+        argv[index - 1] !== '--cwd' &&
+        argv[index - 1] !== '--port' &&
+        arg !== argv[1]);
+    switch (command) {
+        case 'init':
+            process.exit(runInit({ cwd }));
+            break;
+        case 'setup':
+            process.exit(runSetup({
+                cwd,
+                cursor: flags.cursor === true,
+                claude: flags.claude === true,
+                force: flags.force === true,
+            }));
+            break;
+        case 'check':
+            process.exit(runCheck({ cwd }));
+            break;
+        case 'export':
+            process.exit(runExport({ cwd, force: flags.force === true }));
+            break;
+        case 'prepare':
+            process.exit(runPrepare({
+                cwd,
+                dryRun: flags.dryRun === true,
+                all: flags.all === true,
+                path: positionalPath,
+            }));
+            break;
+        case 'sync-links':
+            process.exit(runSyncLinks({
+                cwd,
+                dryRun: flags.dryRun === true,
+                convertBody: flags.noConvertBody !== true,
+                syncRelated: flags.noSyncRelated !== true,
+            }));
+            break;
+        case 'mcp':
+            await startMcpServer();
+            break;
+        case 'ui': {
+            const portRaw = typeof flags.port === 'string' ? Number.parseInt(flags.port, 10) : undefined;
+            const port = portRaw && !Number.isNaN(portRaw) ? portRaw : undefined;
+            process.exit(await runUi({ cwd, port }));
+            break;
+        }
+        default:
+            console.error(`Unknown command: ${command}`);
+            printHelp();
+            process.exit(1);
+    }
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/dist/commands/check.d.ts

@@ -0,0 +1,6 @@
+import { type CheckViolation } from '../check/collect-violations.js';
+export type { CheckViolation };
+export interface CheckOptions {
+    cwd?: string;
+}
+export declare function runCheck(options?: CheckOptions): number;

package/dist/commands/check.js

@@ -0,0 +1,19 @@
+import path from 'node:path';
+import { collectCheckReport } from '../check/collect-violations.js';
+import { DocIndex } from '../index/doc-index.js';
+export function runCheck(options = {}) {
+    const cwd = path.resolve(options.cwd ?? process.cwd());
+    const index = new DocIndex(cwd);
+    const report = collectCheckReport(index);
+    if (!report) {
+        console.error('no docs/ found — run `repo-mind init` or create a docs/ directory');
+        return 1;
+    }
+    for (const violation of report.violations) {
+        console.error(`${violation.path}: ${violation.message}`);
+    }
+    for (const warning of report.warnings) {
+        console.warn(`warning: ${warning}`);
+    }
+    return report.ok ? 0 : 1;
+}

package/dist/commands/export.d.ts

@@ -0,0 +1,8 @@
+import { type DocType } from '../index/types.js';
+export interface ExportOptions {
+    cwd?: string;
+    force?: boolean;
+}
+export declare function runExport(options?: ExportOptions): number;
+export declare function resolveExportPath(cwd: string): string;
+export declare function typeDirFor(type: DocType): string;

package/dist/commands/export.js

@@ -0,0 +1,80 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { DocIndex } from '../index/doc-index.js';
+import { DOC_TYPES, TYPE_TO_DIR } from '../index/types.js';
+const TYPE_SECTIONS = {
+    adr: 'ADRs',
+    'feature-spec': 'Feature Specs',
+    'glossary-term': 'Glossary',
+    'open-question': 'Open Questions',
+    'agent-instruction': 'Agent Instructions',
+    'wiki-page': 'Wiki',
+};
+export function runExport(options = {}) {
+    const cwd = path.resolve(options.cwd ?? process.cwd());
+    const index = new DocIndex(cwd);
+    const knowledgeRoot = index.getKnowledgeRoot();
+    if (!knowledgeRoot) {
+        console.error('no docs/ found — run `repo-mind init` or create a docs/ directory');
+        return 1;
+    }
+    const repoRoot = path.dirname(knowledgeRoot);
+    const outputPath = path.join(repoRoot, 'agents.md');
+    if (fs.existsSync(outputPath) && !options.force) {
+        console.error('agents.md already exists — pass --force to overwrite');
+        return 1;
+    }
+    const docs = index.refresh();
+    const lines = ['# Project Knowledge Export', ''];
+    for (const type of DOC_TYPES) {
+        lines.push(`## ${TYPE_SECTIONS[type]}`, '');
+        const typeDocs = docs
+            .filter((doc) => doc.type === type)
+            .sort((a, b) => a.slug.localeCompare(b.slug));
+        if (typeDocs.length === 0) {
+            lines.push('_No documents._', '');
+            continue;
+        }
+        for (const doc of typeDocs) {
+            lines.push(`### ${doc.title}`, '');
+            lines.push(`- slug: ${doc.slug}`);
+            lines.push(`- status: ${doc.status}`);
+            lines.push('');
+            lines.push('```yaml');
+            lines.push(renderFrontmatter(doc.frontmatter));
+            lines.push('```', '');
+            lines.push(doc.body, '');
+        }
+    }
+    fs.writeFileSync(outputPath, `${lines.join('\n').trim()}\n`, 'utf8');
+    console.log(`Wrote ${outputPath}`);
+    return 0;
+}
+function renderFrontmatter(frontmatter) {
+    const lines = [];
+    for (const [key, value] of Object.entries(frontmatter)) {
+        if (value === undefined) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            lines.push(`${key}:`);
+            for (const item of value) {
+                lines.push(`  - ${item}`);
+            }
+            continue;
+        }
+        lines.push(`${key}: ${value}`);
+    }
+    return lines.join('\n');
+}
+export function resolveExportPath(cwd) {
+    const index = new DocIndex(cwd);
+    const knowledgeRoot = index.getKnowledgeRoot();
+    if (!knowledgeRoot) {
+        return path.join(cwd, 'agents.md');
+    }
+    return path.join(path.dirname(knowledgeRoot), 'agents.md');
+}
+export function typeDirFor(type) {
+    return TYPE_TO_DIR[type];
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,4 @@
+export interface InitOptions {
+    cwd?: string;
+}
+export declare function runInit(options?: InitOptions): number;

package/dist/commands/init.js

@@ -0,0 +1,86 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { KNOWLEDGE_DIR } from '../index/doc-index.js';
+import { DOC_DOMAINS, DOMAIN_LABELS, DOMAIN_TYPE_DIRS } from '../index/types.js';
+const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+const TEMPLATE_FILES = [
+    { template: 'adr-example.md', target: 'technical/adr/use-plain-markdown.md' },
+    { template: 'feature-spec-example.md', target: 'technical/specs/user-authentication.md' },
+    { template: 'glossary-term-example.md', target: 'shared/glossary/mcp.md' },
+    { template: 'open-question-example.md', target: 'product/open-questions/search-ranking.md' },
+    { template: 'agent-instruction-example.md', target: 'shared/agents/query-first.md' },
+    { template: 'combat-system-example.md', target: 'game-design/specs/combat-system.md' },
+];
+const KNOWLEDGE_README = `# Project documentation
+
+This \`docs/\` directory is the single source of truth for project knowledge.
+
+## Domains
+
+| Domain | Purpose |
+|--------|---------|
+| \`product/\` | PRD, roadmap, user value, open product questions |
+| \`technical/\` | Architecture, ADR, API, infrastructure |
+| \`game-design/\` | Mechanics, balance, systems design |
+| \`analytics/\` | Metrics, events, dashboards, experiments |
+| \`art/\` | Visual style, assets, UI art guidelines |
+| \`narrative/\` | Story, lore, dialogue, quests |
+| \`ops/\` | Liveops, release, support runbooks |
+| \`shared/\` | Cross-domain glossary, agent rules |
+
+Each domain contains type subfolders (\`specs/\`, \`adr/\`, \`wiki/\`, …). See \`.cursor/skills/repomind-docs/structure.md\` for the full taxonomy.
+
+Humans edit via \`repo-mind ui\`; agents query via MCP (\`search_docs\`, \`get_doc\`).
+
+Run \`npx @justyork/repo-mind check\` to validate frontmatter, domains, and links.
+`;
+function domainReadme(domain) {
+    const label = DOMAIN_LABELS[domain];
+    const subdirs = DOMAIN_TYPE_DIRS[domain].map((d) => `- \`${d}/\``).join('\n');
+    return `# ${label}
+
+Documentation domain: **${domain}**.
+
+## Subfolders
+
+${subdirs}
+
+Add a \`README.md\` in each subfolder when it grows beyond a few pages.
+`;
+}
+const KNOWLEDGE_GITIGNORE = `.worktrees/
+.repo-mind/
+`;
+export function runInit(options = {}) {
+    const cwd = path.resolve(options.cwd ?? process.cwd());
+    const knowledgeRoot = path.join(cwd, KNOWLEDGE_DIR);
+    if (!fs.existsSync(path.join(cwd, '.git'))) {
+        console.warn('warning: no .git directory found — initialize git for version control');
+    }
+    fs.mkdirSync(knowledgeRoot, { recursive: true });
+    fs.mkdirSync(path.join(knowledgeRoot, 'assets'), { recursive: true });
+    for (const domain of DOC_DOMAINS) {
+        const domainRoot = path.join(knowledgeRoot, domain);
+        fs.mkdirSync(domainRoot, { recursive: true });
+        writeIfMissing(path.join(domainRoot, 'README.md'), domainReadme(domain));
+        for (const subdir of DOMAIN_TYPE_DIRS[domain]) {
+            fs.mkdirSync(path.join(domainRoot, subdir), { recursive: true });
+        }
+    }
+    writeIfMissing(path.join(knowledgeRoot, 'README.md'), KNOWLEDGE_README);
+    writeIfMissing(path.join(knowledgeRoot, '.gitignore'), KNOWLEDGE_GITIGNORE);
+    for (const { template, target } of TEMPLATE_FILES) {
+        const source = path.join(PACKAGE_ROOT, 'templates', template);
+        const dest = path.join(knowledgeRoot, target);
+        writeIfMissing(dest, fs.readFileSync(source, 'utf8'));
+    }
+    console.log(`Initialized ${KNOWLEDGE_DIR}/ with domain-based example docs.`);
+    return 0;
+}
+function writeIfMissing(filePath, content) {
+    if (!fs.existsSync(filePath)) {
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, content, 'utf8');
+    }
+}

package/dist/commands/prepare.d.ts

@@ -0,0 +1,7 @@
+export interface PrepareCommandOptions {
+    cwd?: string;
+    dryRun?: boolean;
+    all?: boolean;
+    path?: string;
+}
+export declare function runPrepare(options?: PrepareCommandOptions): number;

package/dist/commands/prepare.js

@@ -0,0 +1,61 @@
+import path from 'node:path';
+import { DocIndex } from '../index/doc-index.js';
+import { listUnpreparedFiles, prepareAllDocs, prepareDocFile, } from '../prepare/prepare-docs.js';
+function printPrepareAllResult(result, dryRun) {
+    const verb = dryRun ? 'Would prepare' : 'Prepared';
+    for (const item of result.prepared) {
+        console.log(`${verb}: ${item.relativePath} → ${item.slug} (${item.type})`);
+    }
+    for (const item of result.skipped) {
+        console.error(`Skipped ${item.relativePath}: ${item.reason}`);
+    }
+    console.log(`${verb} ${result.prepared.length} file(s), skipped ${result.skipped.length}`);
+}
+export function runPrepare(options = {}) {
+    const cwd = path.resolve(options.cwd ?? process.cwd());
+    const index = new DocIndex(cwd);
+    if (!index.getKnowledgeRoot()) {
+        console.error('no docs/ found — run `repo-mind init` or create a docs/ directory');
+        return 1;
+    }
+    if (options.all) {
+        const result = prepareAllDocs(index, { dryRun: options.dryRun });
+        printPrepareAllResult(result, options.dryRun === true);
+        return result.skipped.length > 0 ? 1 : 0;
+    }
+    if (options.path) {
+        const relativePath = options.path.replace(/\\/g, '/').replace(/^\.\//, '');
+        if (options.dryRun) {
+            const match = listUnpreparedFiles(index).find((file) => file.relativePath === relativePath);
+            if (!match) {
+                console.error(`not unprepared or not found: ${relativePath}`);
+                return 1;
+            }
+            console.log(`Would prepare: ${match.relativePath} → ${match.suggestedSlug} (${match.suggestedType})`);
+            return 0;
+        }
+        try {
+            const result = prepareDocFile(index, relativePath);
+            console.log(`Prepared: ${result.relativePath} → ${result.slug} (${result.type})`);
+            return 0;
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            return 1;
+        }
+    }
+    const unprepared = listUnpreparedFiles(index);
+    if (unprepared.length === 0) {
+        console.log('All markdown docs already have frontmatter.');
+        return 0;
+    }
+    console.log(`${unprepared.length} unprepared markdown file(s).`);
+    console.log('Run with --all to add frontmatter, or pass a relative path under docs/.');
+    for (const file of unprepared.slice(0, 10)) {
+        console.log(`  ${file.relativePath} → ${file.suggestedSlug} (${file.suggestedType})`);
+    }
+    if (unprepared.length > 10) {
+        console.log(`  … and ${unprepared.length - 10} more`);
+    }
+    return 0;
+}

package/dist/commands/setup.d.ts

@@ -0,0 +1,11 @@
+declare const NPM_PACKAGE_NAME = "@justyork/repo-mind";
+declare const MCP_SERVER_NAME = "repo-mind";
+declare const CLAUDE_SNIPPET = "\n<!-- repo-mind -->\nProject knowledge lives in `docs/`. Use repo-mind MCP (`search_docs`, `get_doc`, `get_glossary_term`) \u2014 the same files humans edit in `repo-mind ui`.\n<!-- /repo-mind -->\n";
+export interface SetupOptions {
+    cwd?: string;
+    cursor?: boolean;
+    claude?: boolean;
+    force?: boolean;
+}
+export declare function runSetup(options?: SetupOptions): number;
+export { CLAUDE_SNIPPET, MCP_SERVER_NAME, NPM_PACKAGE_NAME };