@otto-assistant/bridge 0.4.92

package/dist/ipc-tools-plugin.js

@@ -0,0 +1,193 @@
+// OpenCode plugin that provides IPC-based tools for Discord interaction:
+// - kimaki_file_upload: prompts the Discord user to upload files via native picker
+// - kimaki_action_buttons: shows clickable action buttons in the Discord thread
+//
+// Tools communicate with the bot process via IPC rows in SQLite (the plugin
+// runs inside the OpenCode server process, not the bot process).
+//
+// Exported from kimaki-opencode-plugin.ts — each export is treated as a separate
+// plugin by OpenCode's plugin loader.
+import dedent from 'string-dedent';
+import { z } from 'zod';
+import { setDataDir } from './config.js';
+import { createPluginLogger, setPluginLogFilePath } from './plugin-logger.js';
+import { initSentry } from './sentry.js';
+// Inlined from '@opencode-ai/plugin/tool' because the subpath value import
+// fails at runtime in global npm installs (#35). Opencode loads this plugin
+// file in its own process and resolves modules from kimaki's install dir,
+// but the '/tool' subpath export isn't found by opencode's module resolver.
+// The type-only imports above are fine (erased at compile time).
+//
+// NOTE: @opencode-ai/plugin bundles its own zod 4.1.x as a hard dependency
+// while goke (used by cli.ts) requires zod 4.3.x. This version skew makes
+// the Plugin return type structurally incompatible with our local tool()
+// even though runtime behavior is identical. ipcToolsPlugin is cast to
+// Plugin via unknown to bypass this purely type-level incompatibility.
+function tool(input) {
+    return input;
+}
+const logger = createPluginLogger('OPENCODE');
+const FILE_UPLOAD_TIMEOUT_MS = 6 * 60 * 1000;
+const DEFAULT_FILE_UPLOAD_MAX_FILES = 5;
+const ACTION_BUTTON_TIMEOUT_MS = 30 * 1000;
+async function loadDatabaseModule() {
+    // The plugin-loading e2e test boots OpenCode directly without the bot-side
+    // Hrana env vars. Lazy-loading avoids pulling Prisma + libsql sqlite mode
+    // during plugin startup when no IPC tool is being executed yet.
+    return import('./database.js');
+}
+// @opencode-ai/plugin bundles zod 4.1.x as a hard dep; our code uses 4.3.x
+// (required by goke for ~standard.jsonSchema). The Plugin return type is
+// structurally incompatible due to _zod.version.minor skew even though
+// runtime behavior is identical. `any` bypasses the type-level mismatch —
+// opencode's plugin loader doesn't care about the zod version at runtime.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const ipcToolsPlugin = async () => {
+    initSentry();
+    const dataDir = process.env.KIMAKI_DATA_DIR;
+    if (dataDir) {
+        setDataDir(dataDir);
+        setPluginLogFilePath(dataDir);
+    }
+    return {
+        tool: {
+            kimaki_file_upload: tool({
+                description: 'Prompt the Discord user to upload files using a native file picker modal. ' +
+                    'The user sees a button, clicks it, and gets a file upload dialog. ' +
+                    'Returns the local file paths of downloaded files in the project directory. ' +
+                    'Use this when you need the user to provide files (images, documents, configs, etc.). ' +
+                    'IMPORTANT: Always call this tool last in your message, after all text parts.',
+                args: {
+                    prompt: z
+                        .string()
+                        .describe('Message shown to the user explaining what files to upload'),
+                    maxFiles: z
+                        .number()
+                        .min(1)
+                        .max(10)
+                        .optional()
+                        .describe('Maximum number of files the user can upload (1-10, default 5)'),
+                },
+                async execute({ prompt, maxFiles }, context) {
+                    const { getPrisma, createIpcRequest, getIpcRequestById } = await loadDatabaseModule();
+                    const prisma = await getPrisma();
+                    const row = await prisma.thread_sessions.findFirst({
+                        where: { session_id: context.sessionID },
+                        select: { thread_id: true },
+                    });
+                    if (!row?.thread_id) {
+                        return 'Could not find thread for current session';
+                    }
+                    const ipcRow = await createIpcRequest({
+                        type: 'file_upload',
+                        sessionId: context.sessionID,
+                        threadId: row.thread_id,
+                        payload: JSON.stringify({
+                            prompt,
+                            maxFiles: maxFiles || DEFAULT_FILE_UPLOAD_MAX_FILES,
+                            directory: context.directory,
+                        }),
+                    });
+                    const deadline = Date.now() + FILE_UPLOAD_TIMEOUT_MS;
+                    const POLL_INTERVAL_MS = 300;
+                    while (Date.now() < deadline) {
+                        await new Promise((resolve) => {
+                            setTimeout(resolve, POLL_INTERVAL_MS);
+                        });
+                        const updated = await getIpcRequestById({ id: ipcRow.id });
+                        if (!updated || updated.status === 'cancelled') {
+                            return 'File upload was cancelled';
+                        }
+                        if (updated.response) {
+                            const parsed = JSON.parse(updated.response);
+                            if (parsed.error) {
+                                return `File upload failed: ${parsed.error}`;
+                            }
+                            const filePaths = parsed.filePaths || [];
+                            if (filePaths.length === 0) {
+                                return 'No files were uploaded (user may have cancelled or sent a new message)';
+                            }
+                            return `Files uploaded successfully:\n${filePaths.join('\n')}`;
+                        }
+                    }
+                    return 'File upload timed out - user did not upload files within the time limit';
+                },
+            }),
+            kimaki_action_buttons: tool({
+                description: dedent `
+          Show action buttons in the current Discord thread for quick confirmations.
+          Use this when the user can respond by clicking one of up to 3 buttons.
+          Prefer a single button whenever possible.
+          Default color is white (same visual style as permission deny button).
+          If you need more than 3 options, use the question tool instead.
+          IMPORTANT: Always call this tool last in your message, after all text parts.
+
+          Examples:
+          - buttons: [{"label":"Yes, proceed"}]
+          - buttons: [{"label":"Approve","color":"green"}]
+          - buttons: [
+              {"label":"Confirm","color":"blue"},
+              {"label":"Cancel","color":"white"}
+            ]
+        `,
+                args: {
+                    buttons: z
+                        .array(z.object({
+                        label: z
+                            .string()
+                            .min(1)
+                            .max(80)
+                            .describe('Button label shown to the user (1-80 chars)'),
+                        color: z
+                            .enum(['white', 'blue', 'green', 'red'])
+                            .optional()
+                            .describe('Optional button color. white is default and preferred for most confirmations.'),
+                    }))
+                        .min(1)
+                        .max(3)
+                        .describe('Array of 1-3 action buttons. Prefer one button whenever possible.'),
+                },
+                async execute({ buttons }, context) {
+                    const { getPrisma, createIpcRequest, getIpcRequestById } = await loadDatabaseModule();
+                    const prisma = await getPrisma();
+                    const row = await prisma.thread_sessions.findFirst({
+                        where: { session_id: context.sessionID },
+                        select: { thread_id: true },
+                    });
+                    if (!row?.thread_id) {
+                        return 'Could not find thread for current session';
+                    }
+                    const ipcRow = await createIpcRequest({
+                        type: 'action_buttons',
+                        sessionId: context.sessionID,
+                        threadId: row.thread_id,
+                        payload: JSON.stringify({
+                            buttons,
+                            directory: context.directory,
+                        }),
+                    });
+                    const deadline = Date.now() + ACTION_BUTTON_TIMEOUT_MS;
+                    const POLL_INTERVAL_MS = 200;
+                    while (Date.now() < deadline) {
+                        await new Promise((resolve) => {
+                            setTimeout(resolve, POLL_INTERVAL_MS);
+                        });
+                        const updated = await getIpcRequestById({ id: ipcRow.id });
+                        if (!updated || updated.status === 'cancelled') {
+                            return 'Action button request was cancelled';
+                        }
+                        if (updated.response) {
+                            const parsed = JSON.parse(updated.response);
+                            if (parsed.error) {
+                                return `Action button request failed: ${parsed.error}`;
+                            }
+                            return `Action button(s) shown: ${buttons.map((button) => button.label).join(', ')}`;
+                        }
+                    }
+                    return 'Action button request timed out';
+                },
+            }),
+        },
+    };
+};
+export { ipcToolsPlugin };

package/dist/kimaki-digital-twin.e2e.test.js

@@ -0,0 +1,161 @@
+// End-to-end test using discord-digital-twin + real Kimaki bot runtime.
+// Verifies onboarding channel creation, message -> thread creation, and assistant reply.
+import fs from 'node:fs';
+import path from 'node:path';
+import { expect, test } from 'vitest';
+import { ChannelType, Client, GatewayIntentBits, Partials } from 'discord.js';
+import { DigitalDiscord } from 'discord-digital-twin/src';
+import { CachedOpencodeProviderProxy } from 'opencode-cached-provider';
+import { setDataDir } from './config.js';
+import { startDiscordBot } from './discord-bot.js';
+import { setBotToken, initDatabase, closeDatabase, setChannelDirectory, } from './database.js';
+import { startHranaServer, stopHranaServer } from './hrana-server.js';
+import { cleanupTestSessions, chooseLockPort, initTestGitRepo } from './test-utils.js';
+import { stopOpencodeServer } from './opencode.js';
+const geminiApiKey = process.env['GEMINI_API_KEY'] ||
+    process.env['GOOGLE_GENERATIVE_AI_API_KEY'] ||
+    '';
+const geminiModel = process.env['GEMINI_FLASH_MODEL'] || 'gemini-2.5-flash';
+const e2eTest = geminiApiKey.length > 0 ? test : test.skip;
+function createRunDirectories() {
+    const root = path.resolve(process.cwd(), 'tmp', 'kimaki-digital-twin-e2e');
+    fs.mkdirSync(root, { recursive: true });
+    const dataDir = fs.mkdtempSync(path.join(root, 'data-'));
+    const projectDirectory = path.join(root, 'project');
+    const providerCacheDbPath = path.join(root, 'provider-cache.db');
+    fs.mkdirSync(projectDirectory, { recursive: true });
+    initTestGitRepo(projectDirectory);
+    return {
+        root,
+        dataDir,
+        projectDirectory,
+        providerCacheDbPath,
+    };
+}
+function createDiscordJsClient({ restUrl }) {
+    return new Client({
+        intents: [
+            GatewayIntentBits.Guilds,
+            GatewayIntentBits.GuildMessages,
+            GatewayIntentBits.MessageContent,
+            GatewayIntentBits.GuildVoiceStates,
+        ],
+        partials: [
+            Partials.Channel,
+            Partials.Message,
+            Partials.User,
+            Partials.ThreadMember,
+        ],
+        rest: {
+            api: restUrl,
+            version: '10',
+        },
+    });
+}
+e2eTest('onboarding then message creates thread and assistant reply via digital twin', async () => {
+    const testStartTime = Date.now();
+    const directories = createRunDirectories();
+    const lockPort = chooseLockPort({ key: 'kimaki-digital-twin-e2e' });
+    process.env['KIMAKI_LOCK_PORT'] = String(lockPort);
+    setDataDir(directories.dataDir);
+    const proxy = new CachedOpencodeProviderProxy({
+        cacheDbPath: directories.providerCacheDbPath,
+        targetBaseUrl: 'https://generativelanguage.googleapis.com/v1beta',
+        apiKey: geminiApiKey,
+        cacheMethods: ['POST'],
+    });
+    const testUserId = '100000000000000777';
+    const textChannelId = '100000000000000778';
+    const digitalDiscordDbPath = path.join(directories.dataDir, 'digital-discord.db');
+    const discord = new DigitalDiscord({
+        guild: {
+            name: 'Kimaki E2E Guild',
+            ownerId: testUserId,
+        },
+        channels: [
+            {
+                id: textChannelId,
+                name: 'kimaki-e2e',
+                type: ChannelType.GuildText,
+            },
+        ],
+        users: [
+            {
+                id: testUserId,
+                username: 'e2e-user',
+            },
+        ],
+        dbUrl: `file:${digitalDiscordDbPath}`,
+    });
+    let botClient = null;
+    try {
+        await Promise.all([proxy.start(), discord.start()]);
+        const opencodeConfig = proxy.buildOpencodeConfig({
+            providerName: 'cached-google',
+            providerNpm: '@ai-sdk/google',
+            model: geminiModel,
+            smallModel: geminiModel,
+        });
+        fs.writeFileSync(path.join(directories.projectDirectory, 'opencode.json'), JSON.stringify(opencodeConfig, null, 2));
+        const dbPath = path.join(directories.dataDir, 'discord-sessions.db');
+        const hranaResult = await startHranaServer({ dbPath });
+        if (hranaResult instanceof Error) {
+            throw hranaResult;
+        }
+        process.env['KIMAKI_DB_URL'] = hranaResult;
+        await initDatabase();
+        await setBotToken(discord.botUserId, discord.botToken);
+        await setChannelDirectory({
+            channelId: textChannelId,
+            directory: directories.projectDirectory,
+            channelType: 'text',
+        });
+        botClient = createDiscordJsClient({ restUrl: discord.restUrl });
+        await startDiscordBot({
+            token: discord.botToken,
+            appId: discord.botUserId,
+            discordClient: botClient,
+        });
+        await discord.channel(textChannelId).user(testUserId).sendMessage({
+            content: 'Reply with exactly: kimaki digital twin ok',
+        });
+        const createdThread = await discord.channel(textChannelId).waitForThread({
+            timeout: 60_000,
+            predicate: (thread) => {
+                return thread.name === 'Reply with exactly: kimaki digital twin ok';
+            },
+        });
+        const botReply = await discord.thread(createdThread.id).waitForBotReply({
+            timeout: 120_000,
+        });
+        expect(createdThread.id.length).toBeGreaterThan(0);
+        expect(botReply.content.trim().length).toBeGreaterThan(0);
+    }
+    finally {
+        await cleanupTestSessions({
+            projectDirectory: directories.projectDirectory,
+            testStartTime,
+        });
+        if (botClient) {
+            botClient.destroy();
+        }
+        await stopOpencodeServer();
+        await Promise.all([
+            closeDatabase().catch(() => {
+                return;
+            }),
+            stopHranaServer().catch(() => {
+                return;
+            }),
+            proxy.stop().catch(() => {
+                return;
+            }),
+            discord.stop().catch(() => {
+                return;
+            }),
+        ]);
+        delete process.env['KIMAKI_LOCK_PORT'];
+        delete process.env['KIMAKI_DB_URL'];
+        fs.rmSync(directories.dataDir, { recursive: true, force: true });
+    }
+}, 360_000);

package/dist/kimaki-opencode-plugin-loading.e2e.test.js

@@ -0,0 +1,87 @@
+// E2e test for OpenCode plugin loading.
+// Spawns `opencode serve` directly with our plugin in OPENCODE_CONFIG_CONTENT,
+// waits for the health endpoint, then checks stderr for plugin errors.
+// No Discord infrastructure needed — just the OpenCode server process.
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { test, expect } from 'vitest';
+import { resolveOpencodeCommand } from './opencode.js';
+import { getSpawnCommandAndArgs } from './opencode-command.js';
+import { chooseLockPort } from './test-utils.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+async function waitForHealth({ port, maxAttempts = 30, }) {
+    for (let i = 0; i < maxAttempts; i++) {
+        try {
+            const response = await fetch(`http://127.0.0.1:${port}/api/health`);
+            if (response.status < 500) {
+                return true;
+            }
+        }
+        catch {
+            // connection refused, retry
+        }
+        await new Promise((resolve) => {
+            setTimeout(resolve, 1000);
+        });
+    }
+    return false;
+}
+test('opencode server loads plugin without errors', async () => {
+    const projectDir = path.resolve(process.cwd(), 'tmp', 'plugin-loading-e2e');
+    fs.mkdirSync(projectDir, { recursive: true });
+    const port = chooseLockPort({ key: 'opencode-plugin-loading-e2e' });
+    const pluginPath = new URL('../src/kimaki-opencode-plugin.ts', import.meta.url).href;
+    const stderrLines = [];
+    const isolatedOpencodeRoot = path.join(projectDir, 'opencode-test-home');
+    const { command, args, windowsVerbatimArguments, } = getSpawnCommandAndArgs({
+        resolvedCommand: resolveOpencodeCommand(),
+        baseArgs: ['serve', '--port', port.toString(), '--print-logs', '--log-level', 'DEBUG'],
+    });
+    const serverProcess = spawn(command, args, {
+        stdio: 'pipe',
+        cwd: projectDir,
+        windowsVerbatimArguments,
+        env: {
+            ...process.env,
+            OPENCODE_CONFIG_CONTENT: JSON.stringify({
+                $schema: 'https://opencode.ai/config.json',
+                lsp: false,
+                formatter: false,
+                plugin: [pluginPath],
+            }),
+            OPENCODE_TEST_HOME: isolatedOpencodeRoot,
+            OPENCODE_CONFIG_DIR: path.join(isolatedOpencodeRoot, '.opencode-kimaki'),
+            XDG_CONFIG_HOME: path.join(isolatedOpencodeRoot, '.config'),
+            XDG_DATA_HOME: path.join(isolatedOpencodeRoot, '.local', 'share'),
+            XDG_CACHE_HOME: path.join(isolatedOpencodeRoot, '.cache'),
+            XDG_STATE_HOME: path.join(isolatedOpencodeRoot, '.local', 'state'),
+        },
+    });
+    serverProcess.stderr?.on('data', (data) => {
+        stderrLines.push(...data.toString().split('\n').filter(Boolean));
+    });
+    try {
+        const healthy = await waitForHealth({ port });
+        expect(healthy).toBe(true);
+        // Check no plugin-related errors in stderr
+        const pluginErrorPatterns = [
+            /plugin.*error/i,
+            /failed to load plugin/i,
+            /cannot find module/i,
+            /ERR_MODULE_NOT_FOUND/i,
+            /plugin.*failed/i,
+            /plugin.*crash/i,
+        ];
+        const errorLines = stderrLines.filter((line) => {
+            return pluginErrorPatterns.some((pattern) => {
+                return pattern.test(line);
+            });
+        });
+        expect(errorLines).toEqual([]);
+    }
+    finally {
+        serverProcess.kill('SIGTERM');
+    }
+}, 60_000);

package/dist/kimaki-opencode-plugin.js

@@ -0,0 +1,17 @@
+// OpenCode plugin entry point for Kimaki Discord bot.
+// Each export is treated as a separate plugin by OpenCode's plugin loader.
+// CRITICAL: never export utility functions from this file — only plugin
+// initializer functions. OpenCode calls every export as a plugin.
+//
+// Plugins are split into focused modules:
+// - ipc-tools-plugin: file upload + action buttons (IPC-based Discord tools)
+// - context-awareness-plugin: branch, pwd, memory, time gap, onboarding tutorial
+// - opencode-interrupt-plugin: interrupt queued messages at step boundaries
+// - kitty-graphics-plugin: extract Kitty Graphics Protocol images from bash output
+export { ipcToolsPlugin } from './ipc-tools-plugin.js';
+export { contextAwarenessPlugin } from './context-awareness-plugin.js';
+export { interruptOpencodeSessionOnUserMessage } from './opencode-interrupt-plugin.js';
+export { anthropicAuthPlugin } from './anthropic-auth-plugin.js';
+export { imageOptimizerPlugin } from './image-optimizer-plugin.js';
+export { kittyGraphicsPlugin } from 'kitty-graphics-agent';
+export { injectionGuardInternal as injectionGuard } from 'opencode-injection-guard';

package/dist/kimaki-opencode-plugin.test.js

@@ -0,0 +1,98 @@
+import { test, expect, describe } from 'vitest';
+import { condenseMemoryMd } from './condense-memory.js';
+describe('condenseMemoryMd', () => {
+    test('multiple headings with body content', () => {
+        const content = [
+            '# Project Overview',
+            '',
+            'This is a big project with many things.',
+            'It does X, Y, and Z.',
+            '',
+            '## Auth Architecture',
+            '',
+            'JWT tokens with 15min expiry.',
+            'Refresh tokens in httpOnly cookies.',
+            'Session stored in Redis.',
+            '',
+            '## User Preferences',
+            '',
+            '- kebab-case filenames',
+            '- errore-style errors',
+            '- no emojis',
+            '',
+            '### API Conventions',
+            '',
+            'All routes return { data, error }.',
+            'Use spiceflow for the server.',
+            '',
+        ].join('\n');
+        expect(condenseMemoryMd(content)).toMatchInlineSnapshot(`
+      "1: # Project Overview
+      ...
+      6: ## Auth Architecture
+      ...
+      12: ## User Preferences
+      ...
+      18: ### API Conventions
+      ..."
+    `);
+    });
+    test('body text before first heading', () => {
+        const content = [
+            'Some preamble notes.',
+            '',
+            '# First Heading',
+            '',
+            'Content here.',
+            '',
+        ].join('\n');
+        expect(condenseMemoryMd(content)).toMatchInlineSnapshot(`
+      "...
+      3: # First Heading
+      ..."
+    `);
+    });
+    test('no headings at all', () => {
+        const content = 'Just some notes.\nMore notes.\n';
+        expect(condenseMemoryMd(content)).toMatchInlineSnapshot(`"..."`);
+    });
+    test('empty content', () => {
+        expect(condenseMemoryMd('')).toMatchInlineSnapshot(`""`);
+    });
+    test('consecutive headings without body', () => {
+        const content = [
+            '# H1',
+            '## H2',
+            '### H3',
+            '',
+            'Some body.',
+            '',
+        ].join('\n');
+        expect(condenseMemoryMd(content)).toMatchInlineSnapshot(`
+      "1: # H1
+      2: ## H2
+      3: ### H3
+      ..."
+    `);
+    });
+    test('heading with code block body', () => {
+        const content = [
+            '# Config',
+            '',
+            '```json',
+            '{ "key": "value" }',
+            '```',
+            '',
+            '## Notes',
+            '',
+            'Some text.',
+            '',
+        ].join('\n');
+        expect(condenseMemoryMd(content)).toMatchInlineSnapshot(`
+      "1: # Config
+      ...
+      7: ## Notes
+      ..."
+    `);
+    });
+});

package/dist/limit-heading-depth.js

@@ -0,0 +1,25 @@
+// Limit heading depth for Discord.
+// Discord only supports headings up to ### (h3), so this converts
+// ####, #####, etc. to ### to maintain consistent rendering.
+import { Lexer } from 'marked';
+export function limitHeadingDepth(markdown, maxDepth = 3) {
+    const lexer = new Lexer();
+    const tokens = lexer.lex(markdown);
+    let result = '';
+    for (const token of tokens) {
+        if (token.type === 'heading') {
+            const heading = token;
+            if (heading.depth > maxDepth) {
+                const hashes = '#'.repeat(maxDepth);
+                result += hashes + ' ' + heading.text + '\n';
+            }
+            else {
+                result += token.raw;
+            }
+        }
+        else {
+            result += token.raw;
+        }
+    }
+    return result;
+}

package/dist/limit-heading-depth.test.js

@@ -0,0 +1,105 @@
+import { expect, test } from 'vitest';
+import { limitHeadingDepth } from './limit-heading-depth.js';
+test('converts h4 to h3', () => {
+    const input = '#### Fourth level heading';
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`
+    "### Fourth level heading
+    "
+  `);
+});
+test('converts h5 to h3', () => {
+    const input = '##### Fifth level heading';
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`
+    "### Fifth level heading
+    "
+  `);
+});
+test('converts h6 to h3', () => {
+    const input = '###### Sixth level heading';
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`
+    "### Sixth level heading
+    "
+  `);
+});
+test('preserves h3 unchanged', () => {
+    const input = '### Third level heading';
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`"### Third level heading"`);
+});
+test('preserves h2 unchanged', () => {
+    const input = '## Second level heading';
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`"## Second level heading"`);
+});
+test('preserves h1 unchanged', () => {
+    const input = '# First level heading';
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`"# First level heading"`);
+});
+test('handles multiple headings in document', () => {
+    const input = `# Title
+
+Some text
+
+## Section
+
+### Subsection
+
+#### Too deep
+
+##### Even deeper
+
+Regular paragraph
+
+### Back to normal
+`;
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`
+    "# Title
+
+    Some text
+
+    ## Section
+
+    ### Subsection
+
+    ### Too deep
+    ### Even deeper
+    Regular paragraph
+
+    ### Back to normal
+    "
+  `);
+});
+test('preserves heading with inline formatting', () => {
+    const input = '#### Heading with **bold** and `code`';
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`
+    "### Heading with **bold** and \`code\`
+    "
+  `);
+});
+test('handles empty markdown', () => {
+    const result = limitHeadingDepth('');
+    expect(result).toMatchInlineSnapshot(`""`);
+});
+test('handles markdown with no headings', () => {
+    const input = 'Just some text\n\nAnd more text';
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`
+    "Just some text
+
+    And more text"
+  `);
+});
+test('allows custom maxDepth', () => {
+    const input = '### Third level';
+    const result = limitHeadingDepth(input, 2);
+    expect(result).toMatchInlineSnapshot(`
+    "## Third level
+    "
+  `);
+});