@botdocs/cli 0.2.0 → 0.3.1

package/dist/index.js

@@ -10,6 +10,15 @@ import { init } from './commands/init.js';
 import { validate } from './commands/validate.js';
 import { diff } from './commands/diff.js';
 import { endorse } from './commands/endorse.js';
+import { installInstructions } from './commands/install-instructions.js';
+import { install } from './commands/install.js';
+import { list } from './commands/list.js';
+import { uninstall } from './commands/uninstall.js';
+import { sync } from './commands/sync.js';
+import { ingest } from './commands/ingest.js';
+import { checkUpdates } from './commands/check-updates.js';
+import { compile } from './commands/compile.js';
+import { edit } from './commands/edit.js';
 const program = new Command();
 program
     .name('botdocs')
@@ -21,6 +30,7 @@ program
     .description('Scaffold a new BotDoc directory with index.md template')
     .option('--title <title>', 'BotDoc title')
     .option('--category <category>', 'Category')
+    .option('--canonical', 'Scaffold a multi-ecosystem skill (claude-code source + ecosystems list)')
     .action(async (name, opts) => {
     await init(name, { ...opts, json: program.opts().json });
 });
@@ -50,6 +60,7 @@ program
     .option('--category <category>', 'Category (knowledge_management, dev_workflow, automation, agent_config, project_scaffold, other)')
     .option('--tags <tags>', 'Comma-separated tags')
     .option('--license <license>', 'License (MIT, CC_BY_4_0, CC_BY_SA_4_0, CC0, ALL_RIGHTS_RESERVED)')
+    .option('--no-compile', 'Skip auto-compile (publish whatever files are on disk as-is)')
     .action(async (source, options) => {
     await publish(source, { ...options, json: program.opts().json });
 });
@@ -76,8 +87,9 @@ program
 program
     .command('login')
     .description('Authenticate via GitHub device code flow')
-    .action(async () => {
-    await login();
+    .option('--sync-library', 'Enable personalized Library page (uploads sanitized lockfile after install/sync/uninstall)')
+    .action(async (opts) => {
+    await login(opts);
 });
 program
     .command('whoami')
@@ -85,4 +97,76 @@ program
     .action(async () => {
     await whoami({ json: program.opts().json });
 });
+program
+    .command('install-instructions [target]')
+    .description('Write AGENTS.md (default) or install a shell hook for update notifications')
+    .option('--print', 'Print the instruction block to stdout instead of writing a file')
+    .option('--shell-hook', 'Install a shell hook to print update notices on new terminals')
+    .option('--remove-shell-hook', 'Remove a previously-installed shell hook')
+    .action(async (target, opts) => {
+    await installInstructions(target, { ...opts, json: program.opts().json });
+});
+program
+    .command('install <ref>')
+    .description('Install a skill or bundle locally (skills go to ~/.claude/skills/, project files to .cursor/rules/, etc.)')
+    .option('--project <dir>', 'Override the project root used for project-local files')
+    .option('--flat', 'Skip the {scope} subdirectory in install paths (collision-prone, not recommended)')
+    .option('--clean', 'Wipe-and-reinstall instead of additive')
+    .action(async (ref, opts) => {
+    await install(ref, { ...opts, json: program.opts().json });
+});
+program
+    .command('list')
+    .description('List installed skills and bundles')
+    .option('--outdated', 'Show only refs with available updates')
+    .action(async (opts) => {
+    await list({ ...opts, json: program.opts().json });
+});
+program
+    .command('uninstall <ref>')
+    .description('Remove an installed skill or bundle (deletes installed files locally)')
+    .action(async (ref, opts) => {
+    await uninstall(ref, { ...opts, json: program.opts().json });
+});
+program
+    .command('sync [ref]')
+    .description('Check installed skills/bundles for updates and apply')
+    .option('--yes', 'Auto-accept clean updates; skip files with local edits')
+    .option('--dry-run', 'Show what would change without applying')
+    .action(async (ref, opts) => {
+    await sync(ref, { ...opts, json: program.opts().json });
+});
+program
+    .command('check-updates')
+    .description('Check installed skills/bundles for available updates (1-hour cached)')
+    .option('--quiet', 'Print a one-liner only when there are updates (used by the shell hook)')
+    .action(async (opts) => {
+    await checkUpdates({ ...opts, json: program.opts().json });
+});
+program
+    .command('ingest <path>')
+    .description('Walk a directory of existing skill files and create drafts in your BotDocs account for review')
+    .option('--bundle <name>', 'Group all detected skills into a single bundle draft')
+    .option('--dry-run', 'Show what would be detected without uploading')
+    .action(async (sourcePath, opts) => {
+    await ingest(sourcePath, { ...opts, json: program.opts().json });
+});
+program
+    .command('compile <path>')
+    .description('Generate per-ecosystem drafts from a canonical source (BYOK LLM, local-only)')
+    .option('--source <path>', 'Override auto-detected source ecosystem path')
+    .option('--ecosystems <list>', 'Comma-separated list of ecosystems to generate (e.g. claude,cursor)')
+    .option('--regenerate <ecosystem>', 'Re-generate just one ecosystem')
+    .option('--key-env <name>', 'Env var name to use for the API key (e.g. BOTDOCS_OPENAI_KEY)')
+    .action(async (skillPath, opts) => {
+    await compile(skillPath, { ...opts, json: program.opts().json });
+});
+program
+    .command('edit <ref>')
+    .description('LLM-assisted revision of a published skill ecosystem file (BYOK; pushes a draft)')
+    .requiredOption('--ecosystem <name>', 'Which ecosystem file to edit (claude, claude-code, cursor, chatgpt, codex)')
+    .option('--key-env <name>', 'Override the env var used for the API key')
+    .action(async (ref, opts) => {
+    await edit(ref, { ...opts, json: program.opts().json });
+});
 program.parse();

package/dist/lib/auto-detect.d.ts

@@ -0,0 +1,13 @@
+export interface DetectContext {
+    scope: string;
+    slug: string;
+    homeDir: string;
+    projectDir: string;
+    flatScope: boolean;
+}
+export type DetectKind = 'global' | 'project' | 'manual' | 'skip';
+export interface Detection {
+    kind: DetectKind;
+    dest: string;
+}
+export declare function detectDestination(srcRelative: string, ctx: DetectContext): Detection;

package/dist/lib/auto-detect.js

@@ -0,0 +1,34 @@
+import path from 'node:path';
+const NORMALIZE = (p) => p.replace(/\\/g, '/');
+export function detectDestination(srcRelative, ctx) {
+    const src = NORMALIZE(srcRelative);
+    if (src.startsWith('claude/')) {
+        const remainder = src.slice('claude/'.length);
+        // claude/SKILL.md → keep the leaf filename
+        // claude/<inner>/SKILL.md → strip the inner-name segment, keep the leaf
+        const finalName = remainder.includes('/')
+            ? remainder.replace(/^[^/]+\//, '')
+            : remainder;
+        const skillPath = ctx.flatScope ? ctx.slug : path.join(ctx.scope, ctx.slug);
+        return {
+            kind: 'global',
+            dest: path.join(ctx.homeDir, '.claude', 'skills', skillPath, finalName),
+        };
+    }
+    if (src.startsWith('claude-code/commands/')) {
+        return {
+            kind: 'project',
+            dest: path.join(ctx.projectDir, '.claude', 'commands', path.basename(src)),
+        };
+    }
+    if (src.startsWith('cursor/rules/')) {
+        return {
+            kind: 'project',
+            dest: path.join(ctx.projectDir, '.cursor', 'rules', path.basename(src)),
+        };
+    }
+    if (src.startsWith('chatgpt/')) {
+        return { kind: 'manual', dest: src };
+    }
+    return { kind: 'skip', dest: src };
+}

package/dist/lib/auto-detect.test.d.ts

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

package/dist/lib/auto-detect.test.js

@@ -0,0 +1,58 @@
+import { describe, it, expect } from 'vitest';
+import { detectDestination } from './auto-detect.js';
+const ctx = {
+    scope: 'teamco',
+    slug: 'code-review',
+    homeDir: '/home/u',
+    projectDir: '/work/proj',
+    flatScope: false,
+};
+describe('detectDestination', () => {
+    it('routes claude/SKILL.md to ~/.claude/skills/{scope}/{slug}/SKILL.md', () => {
+        expect(detectDestination('claude/SKILL.md', ctx)).toEqual({
+            kind: 'global',
+            dest: '/home/u/.claude/skills/teamco/code-review/SKILL.md',
+        });
+    });
+    it('routes nested claude/<name>/SKILL.md keeping the inner filename', () => {
+        expect(detectDestination('claude/code-review/SKILL.md', ctx)).toEqual({
+            kind: 'global',
+            dest: '/home/u/.claude/skills/teamco/code-review/SKILL.md',
+        });
+    });
+    it('routes cursor rules to project local', () => {
+        expect(detectDestination('cursor/rules/style-guide.mdc', ctx)).toEqual({
+            kind: 'project',
+            dest: '/work/proj/.cursor/rules/style-guide.mdc',
+        });
+    });
+    it('routes claude-code commands to project local', () => {
+        expect(detectDestination('claude-code/commands/code-review.md', ctx)).toEqual({
+            kind: 'project',
+            dest: '/work/proj/.claude/commands/code-review.md',
+        });
+    });
+    it('routes chatgpt files to "manual" with a path hint', () => {
+        expect(detectDestination('chatgpt/code-review.md', ctx)).toEqual({
+            kind: 'manual',
+            dest: 'chatgpt/code-review.md',
+        });
+    });
+    it('honors flatScope by skipping the scope subdir', () => {
+        const flat = { ...ctx, flatScope: true };
+        expect(detectDestination('claude/SKILL.md', flat).dest).toBe('/home/u/.claude/skills/code-review/SKILL.md');
+    });
+    it('returns "skip" for unknown ecosystem files', () => {
+        expect(detectDestination('docs/notes.md', ctx).kind).toBe('skip');
+    });
+    it('handles claude/<inner>/<deeper>/SKILL.md without losing the leaf filename', () => {
+        // Documents the current behavior: the regex strips only the first inner
+        // segment. If we ever support arbitrary nesting, this test must update.
+        const result = detectDestination('claude/alpha/beta/SKILL.md', ctx);
+        expect(result.kind).toBe('global');
+        // Confirms that the leaf "SKILL.md" survives the inner-segment strip; we
+        // don't lose it. The current implementation produces "beta/SKILL.md" as
+        // the leaf — pin that behavior so we know what we have.
+        expect(result.dest.endsWith('SKILL.md')).toBe(true);
+    });
+});

package/dist/lib/canonical.d.ts

@@ -0,0 +1,5 @@
+export type Ecosystem = 'claude' | 'claude-code' | 'cursor' | 'chatgpt' | 'codex';
+export declare const SUPPORTED_ECOSYSTEMS: Ecosystem[];
+export declare function autoDetectSourceEcosystem(skillRoot: string): Ecosystem | null;
+export declare function ecosystemDestination(eco: Ecosystem, slug: string): string;
+export declare function readSourceContent(skillRoot: string, sourceEcosystem: Ecosystem, slug: string): string;

package/dist/lib/canonical.js

@@ -0,0 +1,68 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export const SUPPORTED_ECOSYSTEMS = ['claude', 'claude-code', 'cursor', 'chatgpt', 'codex'];
+const ECOSYSTEM_FILE_GLOB = {
+    claude: ['claude/SKILL.md'],
+    'claude-code': ['claude-code/commands'],
+    cursor: ['cursor/rules'],
+    chatgpt: ['chatgpt'],
+    codex: ['codex'],
+};
+function readSize(filePath) {
+    if (!fs.existsSync(filePath))
+        return 0;
+    const stat = fs.statSync(filePath);
+    if (stat.isFile())
+        return stat.size;
+    if (stat.isDirectory()) {
+        let total = 0;
+        for (const entry of fs.readdirSync(filePath, { withFileTypes: true })) {
+            if (entry.isFile())
+                total += fs.statSync(path.join(filePath, entry.name)).size;
+        }
+        return total;
+    }
+    return 0;
+}
+export function autoDetectSourceEcosystem(skillRoot) {
+    const sizes = SUPPORTED_ECOSYSTEMS.map((eco) => {
+        const totalSize = ECOSYSTEM_FILE_GLOB[eco].reduce((sum, rel) => sum + readSize(path.join(skillRoot, rel)), 0);
+        return { eco, size: totalSize };
+    }).filter((entry) => entry.size > 0);
+    if (sizes.length === 0)
+        return null;
+    sizes.sort((a, b) => {
+        if (b.size !== a.size)
+            return b.size - a.size;
+        return a.eco.localeCompare(b.eco);
+    });
+    return sizes[0].eco;
+}
+export function ecosystemDestination(eco, slug) {
+    switch (eco) {
+        case 'claude':
+            return 'claude/SKILL.md';
+        case 'claude-code':
+            return `claude-code/commands/${slug}.md`;
+        case 'cursor':
+            return `cursor/rules/${slug}.mdc`;
+        case 'chatgpt':
+            return `chatgpt/${slug}.md`;
+        case 'codex':
+            return `codex/${slug}.md`;
+    }
+}
+export function readSourceContent(skillRoot, sourceEcosystem, slug) {
+    const dest = ecosystemDestination(sourceEcosystem, slug);
+    const candidate = path.join(skillRoot, dest);
+    if (fs.existsSync(candidate))
+        return fs.readFileSync(candidate, 'utf-8');
+    // Fallback for ecosystems that store as a directory (claude-code/commands)
+    const dir = path.join(skillRoot, ECOSYSTEM_FILE_GLOB[sourceEcosystem][0]);
+    if (fs.existsSync(dir) && fs.statSync(dir).isDirectory()) {
+        const entries = fs.readdirSync(dir).filter((f) => f.endsWith('.md') || f.endsWith('.mdc'));
+        if (entries[0])
+            return fs.readFileSync(path.join(dir, entries[0]), 'utf-8');
+    }
+    throw new Error(`No source content found for ecosystem "${sourceEcosystem}" in ${skillRoot}`);
+}

package/dist/lib/canonical.test.d.ts

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

package/dist/lib/canonical.test.js

@@ -0,0 +1,48 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { autoDetectSourceEcosystem, ecosystemDestination } from './canonical.js';
+describe('autoDetectSourceEcosystem', () => {
+    let tmp;
+    beforeEach(() => {
+        tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'canon-'));
+    });
+    afterEach(() => {
+        fs.rmSync(tmp, { recursive: true, force: true });
+    });
+    function write(rel, body) {
+        const full = path.join(tmp, rel);
+        fs.mkdirSync(path.dirname(full), { recursive: true });
+        fs.writeFileSync(full, body);
+    }
+    it('picks the ecosystem with the longest content', () => {
+        write('claude/SKILL.md', 'short');
+        write('claude-code/commands/x.md', 'a much longer body that beats Claude in size');
+        write('cursor/rules/x.mdc', 'tiny');
+        expect(autoDetectSourceEcosystem(tmp)).toBe('claude-code');
+    });
+    it('tie-breaks alphabetically when sizes are equal', () => {
+        write('claude/SKILL.md', 'samesize');
+        write('cursor/rules/x.mdc', 'samesize');
+        expect(autoDetectSourceEcosystem(tmp)).toBe('claude');
+    });
+    it('returns null when no ecosystem files are present', () => {
+        write('README.md', 'just docs');
+        expect(autoDetectSourceEcosystem(tmp)).toBeNull();
+    });
+});
+describe('ecosystemDestination', () => {
+    it('returns the conventional file path for each ecosystem', () => {
+        const cases = [
+            ['claude', 'claude/SKILL.md'],
+            ['claude-code', 'claude-code/commands/code-review.md'],
+            ['cursor', 'cursor/rules/code-review.mdc'],
+            ['chatgpt', 'chatgpt/code-review.md'],
+            ['codex', 'codex/code-review.md'],
+        ];
+        for (const [eco, expected] of cases) {
+            expect(ecosystemDestination(eco, 'code-review')).toBe(expected);
+        }
+    });
+});

package/dist/lib/config.d.ts

@@ -2,6 +2,7 @@ interface AuthConfig {
     githubToken: string;
     username: string;
     displayName: string;
+    syncLibrary?: boolean;
 }
 export declare function saveAuth(config: AuthConfig): void;
 export declare function loadAuth(): AuthConfig | null;

package/dist/lib/diff.d.ts

@@ -0,0 +1,2 @@
+export declare function hasChanges(a: string, b: string): boolean;
+export declare function renderDiff(before: string, after: string): string;

package/dist/lib/diff.js

@@ -0,0 +1,36 @@
+import { diffLines } from 'diff';
+const DIM = '\x1b[2m';
+const RED = '\x1b[31m';
+const GREEN = '\x1b[32m';
+const RESET = '\x1b[0m';
+function normalize(s) {
+    return s.replace(/\r\n/g, '\n');
+}
+export function hasChanges(a, b) {
+    return normalize(a) !== normalize(b);
+}
+export function renderDiff(before, after) {
+    if (!hasChanges(before, after))
+        return `${DIM}no changes${RESET}`;
+    const parts = diffLines(normalize(before), normalize(after));
+    let out = '';
+    for (const p of parts) {
+        const lines = p.value.split('\n');
+        if (lines[lines.length - 1] === '')
+            lines.pop();
+        if (p.added) {
+            for (const l of lines)
+                out += `${GREEN}+${l}${RESET}\n`;
+        }
+        else if (p.removed) {
+            for (const l of lines)
+                out += `${RED}-${l}${RESET}\n`;
+        }
+        else {
+            const trimmed = lines.length > 4 ? [...lines.slice(0, 2), '  ...', ...lines.slice(-2)] : lines;
+            for (const l of trimmed)
+                out += `${DIM} ${l}${RESET}\n`;
+        }
+    }
+    return out;
+}

package/dist/lib/diff.test.d.ts

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

package/dist/lib/diff.test.js

@@ -0,0 +1,28 @@
+import { describe, it, expect } from 'vitest';
+import { renderDiff, hasChanges } from './diff.js';
+describe('renderDiff', () => {
+    it('marks added lines with + and removed lines with -', () => {
+        const out = renderDiff('one\ntwo\nthree\n', 'one\ntwo-modified\nthree\n');
+        expect(out).toContain('-two');
+        expect(out).toContain('+two-modified');
+    });
+    it('returns "no changes" when inputs are identical', () => {
+        expect(renderDiff('a\nb\n', 'a\nb\n')).toMatch(/no changes/i);
+    });
+    it('truncates context blocks longer than 4 lines with an ellipsis', () => {
+        const before = 'l1\nl2\nl3\nl4\nl5\nl6\nl7\nl8\nMODIFY\nl10\nl11\nl12\nl13\n';
+        const after = 'l1\nl2\nl3\nl4\nl5\nl6\nl7\nl8\nCHANGED\nl10\nl11\nl12\nl13\n';
+        const out = renderDiff(before, after);
+        // The unchanged context blocks before and after the modification should
+        // include the literal "..." truncation marker.
+        expect(out).toContain('...');
+    });
+});
+describe('hasChanges', () => {
+    it('returns false when normalized contents match', () => {
+        expect(hasChanges('a\r\nb\r\n', 'a\nb\n')).toBe(false);
+    });
+    it('returns true when contents differ', () => {
+        expect(hasChanges('a\nb\n', 'a\nc\n')).toBe(true);
+    });
+});

package/dist/lib/library-sync.d.ts

@@ -0,0 +1,8 @@
+/** Posts a sanitized snapshot of the lockfile to BotDocs if the user has
+ * opted-in via `botdocs login --sync-library`. Sanitization strips:
+ * - file contents (lockfile never contained them, but the route also rejects them)
+ * - install destinations (private to the user's machine)
+ * - fingerprints (not useful server-side; minimize what we send)
+ * Only refs + versions + types remain. Failures are silent so install
+ * and sync flows never break on telemetry hiccups. */
+export declare function syncLibrary(): Promise<void>;

package/dist/lib/library-sync.js

@@ -0,0 +1,30 @@
+import { apiFetch } from './api.js';
+import { loadLockfile } from './lockfile.js';
+import { loadAuth } from './config.js';
+/** Posts a sanitized snapshot of the lockfile to BotDocs if the user has
+ * opted-in via `botdocs login --sync-library`. Sanitization strips:
+ * - file contents (lockfile never contained them, but the route also rejects them)
+ * - install destinations (private to the user's machine)
+ * - fingerprints (not useful server-side; minimize what we send)
+ * Only refs + versions + types remain. Failures are silent so install
+ * and sync flows never break on telemetry hiccups. */
+export async function syncLibrary() {
+    const auth = loadAuth();
+    if (!auth?.syncLibrary)
+        return;
+    const lf = loadLockfile();
+    const sanitized = {
+        version: 1,
+        installs: lf.installs.map((i) => ({ ref: i.ref, type: i.type, version: i.version })),
+    };
+    try {
+        await apiFetch('/api/library/lockfile-sync', {
+            method: 'POST',
+            auth: true,
+            body: sanitized,
+        });
+    }
+    catch {
+        // Silent — never break user flows
+    }
+}

package/dist/lib/library-sync.test.d.ts

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

package/dist/lib/library-sync.test.js

@@ -0,0 +1,63 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { mockFetch } from '../test-utils.js';
+import { saveLockfile } from './lockfile.js';
+import { saveAuth } from './config.js';
+import { syncLibrary } from './library-sync.js';
+describe('syncLibrary', () => {
+    let restoreFetch = () => { };
+    const origHome = os.homedir;
+    let homeTmp;
+    beforeEach(() => {
+        homeTmp = fs.mkdtempSync(path.join(os.tmpdir(), 'libsync-'));
+        os.homedir = () => homeTmp;
+        process.env.BOTDOCS_API_URL = 'http://test.local';
+    });
+    afterEach(() => {
+        restoreFetch();
+        fs.rmSync(homeTmp, { recursive: true, force: true });
+        os.homedir = origHome;
+        vi.restoreAllMocks();
+    });
+    it('is a no-op when sync_library is not enabled', async () => {
+        saveAuth({ githubToken: 't', username: 'u', displayName: 'U' });
+        const fm = mockFetch([]);
+        restoreFetch = fm.restore;
+        await syncLibrary();
+        expect(fm.calls).toHaveLength(0);
+    });
+    it('POSTs sanitized lockfile (refs + versions only) when enabled', async () => {
+        saveAuth({ githubToken: 't', username: 'u', displayName: 'U', syncLibrary: true });
+        saveLockfile({
+            version: 1,
+            installs: [{
+                    ref: '@a/b',
+                    type: 'SKILL',
+                    version: '1.0.0',
+                    installedAt: 't',
+                    files: [{ src: 's', dest: '/some/path', fingerprint: 'fp' }],
+                }],
+        });
+        const fm = mockFetch([
+            { method: 'POST', url: '/api/library/lockfile-sync', response: { body: { ok: true } } },
+        ]);
+        restoreFetch = fm.restore;
+        await syncLibrary();
+        expect(fm.calls).toHaveLength(1);
+        const body = fm.calls[0].body;
+        expect(body.installs[0]).toEqual({ ref: '@a/b', type: 'SKILL', version: '1.0.0' });
+        // Sanitization: no files / fingerprints / dest
+        expect(body.installs[0].files).toBeUndefined();
+    });
+    it('swallows errors so install/sync flows never break on telemetry failures', async () => {
+        saveAuth({ githubToken: 't', username: 'u', displayName: 'U', syncLibrary: true });
+        saveLockfile({ version: 1, installs: [] });
+        const fm = mockFetch([
+            { method: 'POST', url: '/api/library/lockfile-sync', response: { status: 500, body: { error: 'boom' } } },
+        ]);
+        restoreFetch = fm.restore;
+        await expect(syncLibrary()).resolves.toBeUndefined();
+    });
+});

package/dist/lib/llm.d.ts

@@ -0,0 +1,26 @@
+export declare class LlmError extends Error {
+    constructor(message: string);
+}
+export type Provider = 'anthropic' | 'openai';
+export interface DetectOptions {
+    keyEnv?: string;
+}
+export interface ProviderInfo {
+    provider: Provider;
+    keyEnv: string;
+}
+export declare function detectProvider(options?: DetectOptions): ProviderInfo;
+export interface CompleteRequest {
+    system: string;
+    prompt: string;
+    keyEnv?: string;
+}
+export interface CompleteResponse {
+    text: string;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+    provider: Provider;
+}
+export declare function complete(req: CompleteRequest): Promise<CompleteResponse>;

package/dist/lib/llm.js

@@ -0,0 +1,61 @@
+import Anthropic from '@anthropic-ai/sdk';
+import OpenAI from 'openai';
+export class LlmError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'LlmError';
+    }
+}
+export function detectProvider(options = {}) {
+    if (options.keyEnv) {
+        const value = process.env[options.keyEnv];
+        if (!value)
+            throw new LlmError(`Env var ${options.keyEnv} is not set`);
+        if (options.keyEnv.includes('OPENAI'))
+            return { provider: 'openai', keyEnv: options.keyEnv };
+        return { provider: 'anthropic', keyEnv: options.keyEnv };
+    }
+    if (process.env.BOTDOCS_ANTHROPIC_KEY)
+        return { provider: 'anthropic', keyEnv: 'BOTDOCS_ANTHROPIC_KEY' };
+    if (process.env.BOTDOCS_OPENAI_KEY)
+        return { provider: 'openai', keyEnv: 'BOTDOCS_OPENAI_KEY' };
+    throw new LlmError('No LLM key found. Set BOTDOCS_ANTHROPIC_KEY (recommended) or BOTDOCS_OPENAI_KEY in your env.');
+}
+export async function complete(req) {
+    const info = detectProvider({ keyEnv: req.keyEnv });
+    if (info.provider === 'anthropic') {
+        const client = new Anthropic({ apiKey: process.env[info.keyEnv] });
+        const resp = await client.messages.create({
+            model: 'claude-haiku-4-5',
+            max_tokens: 4096,
+            system: req.system,
+            messages: [{ role: 'user', content: req.prompt }],
+        });
+        const blocks = resp.content;
+        const text = blocks
+            .filter((b) => b.type === 'text')
+            .map((b) => b.text ?? '')
+            .join('');
+        return {
+            text,
+            usage: { inputTokens: resp.usage.input_tokens, outputTokens: resp.usage.output_tokens },
+            provider: 'anthropic',
+        };
+    }
+    const client = new OpenAI({ apiKey: process.env[info.keyEnv] });
+    const resp = await client.chat.completions.create({
+        model: 'gpt-4o-mini',
+        messages: [
+            { role: 'system', content: req.system },
+            { role: 'user', content: req.prompt },
+        ],
+    });
+    return {
+        text: resp.choices[0]?.message?.content ?? '',
+        usage: {
+            inputTokens: resp.usage?.prompt_tokens ?? 0,
+            outputTokens: resp.usage?.completion_tokens ?? 0,
+        },
+        provider: 'openai',
+    };
+}

package/dist/lib/llm.test.d.ts

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