kimaki 0.6.0 → 0.7.0

package/dist/format-tables.js

@@ -15,12 +15,75 @@ const MAX_COMPONENTS = 40;
  * pairs. Large tables are split across multiple component segments.
  */
 export function splitTablesFromMarkdown(markdown, options = {}) {
+    const blocks = splitMarkdownByCallouts({ markdown });
+    return blocks.flatMap((block) => {
+        if (block.type === 'callout') {
+            const innerSegments = splitTablesFromMarkdown(block.content, options);
+            return buildCalloutSegments({
+                segments: innerSegments,
+                callout: block.callout,
+            });
+        }
+        return splitTableSegmentsFromText({
+            markdown: block.text,
+            options,
+        });
+    });
+}
+function splitMarkdownByCallouts({ markdown, }) {
+    const lines = markdown.match(/.*(?:\n|$)/g)?.filter((line) => {
+        return line.length > 0;
+    }) ?? [markdown];
+    const blocks = [];
+    let textBuffer = '';
+    for (let index = 0; index < lines.length; index++) {
+        const line = lines[index];
+        const callout = parseCalloutOpenLine({ line });
+        if (!callout) {
+            textBuffer += line;
+            continue;
+        }
+        if (textBuffer.length > 0) {
+            blocks.push({ type: 'text', text: textBuffer });
+            textBuffer = '';
+        }
+        const body = collectCalloutBodyFromLines({
+            lines,
+            startIndex: index,
+        });
+        if (body instanceof Error) {
+            textBuffer += line;
+            continue;
+        }
+        blocks.push({
+            type: 'callout',
+            content: body.content,
+            callout,
+        });
+        index = body.endIndex;
+    }
+    if (textBuffer.length > 0) {
+        blocks.push({ type: 'text', text: textBuffer });
+    }
+    return blocks;
+}
+function splitTableSegmentsFromText({ markdown, options, }) {
     const lexer = new Lexer();
-    const tokens = lexer.lex(markdown);
+    return splitTokensIntoSegments({
+        tokens: lexer.lex(markdown),
+        options,
+    });
+}
+function splitTokensIntoSegments({ tokens, options, }) {
     const segments = [];
     let textBuffer = '';
+    const isTableToken = (token) => {
+        return (token.type === 'table' &&
+            Object.hasOwn(token, 'header') &&
+            Object.hasOwn(token, 'rows'));
+    };
     for (const token of tokens) {
-        if (token.type === 'table') {
+        if (isTableToken(token)) {
             if (textBuffer.trim()) {
                 segments.push({ type: 'text', text: textBuffer });
                 textBuffer = '';
@@ -37,6 +100,126 @@ export function splitTablesFromMarkdown(markdown, options = {}) {
     }
     return segments;
 }
+function buildCalloutSegments({ segments, callout, }) {
+    const children = flattenCalloutChildren({ segments });
+    if (children.length === 0) {
+        return [];
+    }
+    const chunks = chunkCalloutChildrenByComponentLimit({ children });
+    return chunks.map((chunk) => {
+        const container = {
+            type: ComponentType.Container,
+            ...(callout.accentColor !== undefined
+                ? { accent_color: callout.accentColor }
+                : {}),
+            components: chunk,
+        };
+        const components = [container];
+        return {
+            type: 'components',
+            components,
+        };
+    });
+}
+function flattenCalloutChildren({ segments, }) {
+    return segments.flatMap((segment) => {
+        if (segment.type === 'text') {
+            if (!segment.text.trim()) {
+                return [];
+            }
+            return [
+                {
+                    type: ComponentType.TextDisplay,
+                    content: segment.text.trim(),
+                },
+            ];
+        }
+        return segment.components.flatMap((component) => {
+            if (component.type !== ComponentType.Container) {
+                return [];
+            }
+            return component.components;
+        });
+    });
+}
+function chunkCalloutChildrenByComponentLimit({ children, }) {
+    const chunks = [];
+    let currentChunk = [];
+    for (const child of children) {
+        if (currentChunk.length > 0 && currentChunk.length + 2 > MAX_COMPONENTS) {
+            chunks.push(currentChunk);
+            currentChunk = [];
+        }
+        currentChunk.push(child);
+    }
+    if (currentChunk.length > 0) {
+        chunks.push(currentChunk);
+    }
+    return chunks;
+}
+function collectCalloutBodyFromLines({ lines, startIndex, }) {
+    let depth = 0;
+    const contentLines = [];
+    for (let index = startIndex; index < lines.length; index++) {
+        const line = lines[index];
+        const nestedCallout = parseCalloutOpenLine({ line });
+        if (nestedCallout) {
+            if (depth > 0) {
+                contentLines.push(line);
+            }
+            depth += 1;
+            continue;
+        }
+        if (/^<\/callout>$/i.test(line.trim())) {
+            depth -= 1;
+            if (depth === 0) {
+                return {
+                    content: contentLines.join(''),
+                    endIndex: index,
+                };
+            }
+            contentLines.push(line);
+            continue;
+        }
+        if (depth > 0) {
+            contentLines.push(line);
+        }
+    }
+    return new Error('Unclosed <callout> block');
+}
+function parseCalloutOpenLine({ line, }) {
+    const match = line.trim().match(/^<callout(?:\s+[^>]*)?>$/i);
+    if (!match) {
+        return null;
+    }
+    const accentValue = line.match(/\baccent=(['"])(.*?)\1/i)?.[2]?.trim();
+    const accentColor = accentValue
+        ? parseAccentColor({ value: accentValue })
+        : undefined;
+    return {
+        accentColor: accentColor instanceof Error ? undefined : accentColor,
+    };
+}
+function parseAccentColor({ value, }) {
+    const hex = value.trim().toLowerCase();
+    if (/^#[0-9a-f]{6}$/.test(hex)) {
+        return Number.parseInt(hex.slice(1), 16);
+    }
+    if (/^#[0-9a-f]{3}$/.test(hex)) {
+        const expanded = hex
+            .slice(1)
+            .split('')
+            .map((char) => {
+            return `${char}${char}`;
+        })
+            .join('');
+        return Number.parseInt(expanded, 16);
+    }
+    if (/^\d+$/.test(hex)) {
+        return Number.parseInt(hex, 10);
+    }
+    return new Error(`Unsupported callout accent color: ${value}`);
+}
 /**
  * Build CV2 components for a table. Plain rows render as one TextDisplay with
  * bold key-value lines. Rows with resolved button cells render as a TextDisplay
@@ -72,9 +255,10 @@ export function buildTableComponents(table, options = {}) {
             type: ComponentType.Container,
             components: children,
         };
+        const components = [container];
         return {
             type: 'components',
-            components: [container],
+            components,
         };
     });
 }
@@ -289,12 +473,17 @@ function extractTokenText(token) {
         case 'br':
             return ' ';
         default: {
-            const tokenAny = token;
-            if (tokenAny.tokens && Array.isArray(tokenAny.tokens)) {
-                return extractCellText(tokenAny.tokens);
+            const nestedTokens = Reflect.get(token, 'tokens');
+            if (Array.isArray(nestedTokens)) {
+                return extractCellText(nestedTokens.filter((value) => {
+                    return (typeof value === 'object' &&
+                        value !== null &&
+                        typeof Reflect.get(value, 'type') === 'string');
+                }));
             }
-            if (typeof tokenAny.text === 'string') {
-                return tokenAny.text;
+            const text = Reflect.get(token, 'text');
+            if (typeof text === 'string') {
+                return text;
             }
             return '';
         }

package/dist/format-tables.test.js

@@ -1,10 +1,22 @@
 import { test, expect, describe } from 'vitest';
 import { splitTablesFromMarkdown, buildTableComponents, } from './format-tables.js';
 import { Lexer } from 'marked';
+import { ComponentType } from 'discord.js';
+function isTableToken(token) {
+    return (token.type === 'table' &&
+        Object.hasOwn(token, 'header') &&
+        Object.hasOwn(token, 'rows'));
+}
 function parseTable(markdown) {
     const lexer = new Lexer();
     const tokens = lexer.lex(markdown);
-    return tokens.find((t) => t.type === 'table');
+    const table = tokens.find((token) => {
+        return isTableToken(token);
+    });
+    if (!table || !isTableToken(table)) {
+        throw new Error('Expected markdown to contain a table token');
+    }
+    return table;
 }
 /** Extract the first container's children from buildTableComponents result */
 function getContainerChildren(segments) {
@@ -13,7 +25,20 @@ function getContainerChildren(segments) {
         throw new Error('Expected components segment');
     }
     const container = seg.components[0];
-    return container.components;
+    if (!container || container.type !== ComponentType.Container) {
+        throw new Error('Expected first top-level component to be a container');
+    }
+    return container.components.map((component) => {
+        const content = component.type === ComponentType.TextDisplay ? component.content : undefined;
+        const divider = component.type === ComponentType.Separator ? component.divider : undefined;
+        const spacing = component.type === ComponentType.Separator ? component.spacing : undefined;
+        return {
+            type: component.type,
+            content,
+            divider,
+            spacing,
+        };
+    });
 }
 describe('buildTableComponents', () => {
     test('builds container with key-value TextDisplays', () => {
@@ -305,4 +330,130 @@ Done.`);
       ]
     `);
     });
+    test('renders callout text inside an accented container', () => {
+        const result = splitTablesFromMarkdown(`<callout accent="#2b7fff">
+## Important
+
+Read this first.
+</callout>`);
+        expect(result).toMatchInlineSnapshot(`
+      [
+        {
+          "components": [
+            {
+              "accent_color": 2850815,
+              "components": [
+                {
+                  "content": "## Important
+
+      Read this first.",
+                  "type": 10,
+                },
+              ],
+              "type": 17,
+            },
+          ],
+          "type": "components",
+        },
+      ]
+    `);
+    });
+    test('renders tables inside callouts recursively', () => {
+        const result = splitTablesFromMarkdown(`<callout accent="#2b7fff">
+## Important
+
+| Key | Value |
+| --- | --- |
+| a | 1 |
+</callout>`);
+        expect(result).toMatchInlineSnapshot(`
+      [
+        {
+          "components": [
+            {
+              "accent_color": 2850815,
+              "components": [
+                {
+                  "content": "## Important",
+                  "type": 10,
+                },
+                {
+                  "content": "**Key** a
+      **Value** 1",
+                  "type": 10,
+                },
+              ],
+              "type": 17,
+            },
+          ],
+          "type": "components",
+        },
+      ]
+    `);
+    });
+    test('renders button rows inside callouts recursively', () => {
+        const result = splitTablesFromMarkdown(`<callout accent="#2b7fff">
+## Actions
+
+| Name | Action |
+| --- | --- |
+| feature-a | <button id="delete-a" variant="secondary">Delete</button> |
+</callout>`, {
+            resolveButtonCustomId: ({ button }) => {
+                return `html_action:${button.id}`;
+            },
+        });
+        expect(result).toMatchInlineSnapshot(`
+      [
+        {
+          "components": [
+            {
+              "accent_color": 2850815,
+              "components": [
+                {
+                  "content": "## Actions",
+                  "type": 10,
+                },
+                {
+                  "content": "**Name** feature-a",
+                  "type": 10,
+                },
+                {
+                  "components": [
+                    {
+                      "custom_id": "html_action:delete-a",
+                      "disabled": false,
+                      "label": "Delete",
+                      "style": 2,
+                      "type": 2,
+                    },
+                  ],
+                  "type": 1,
+                },
+              ],
+              "type": 17,
+            },
+          ],
+          "type": "components",
+        },
+      ]
+    `);
+    });
+    test('falls back to plain text when a callout is not closed', () => {
+        const result = splitTablesFromMarkdown(`<callout accent="#2b7fff">
+## Important
+
+Still open`);
+        expect(result).toMatchInlineSnapshot(`
+      [
+        {
+          "text": "<callout accent="#2b7fff">
+      ## Important
+
+      Still open",
+          "type": "text",
+        },
+      ]
+    `);
+    });
 });

package/dist/hrana-server.js

@@ -235,29 +235,17 @@ export async function evictExistingInstance({ port }) {
         hranaLogger.log(`Failed to kill PID ${targetPid}: ${killResult.message}`);
         return;
     }
-    await new Promise((resolve) => {
-        setTimeout(resolve, 1000);
-    });
-    // Verify it's gone — if still alive, escalate to SIGKILL
-    const secondProbe = await fetch(url, {
-        signal: AbortSignal.timeout(500),
-    }).catch((e) => new FetchError({ url, cause: e }));
-    if (secondProbe instanceof Error)
-        return;
-    hranaLogger.log(`PID ${targetPid} still alive after SIGTERM, sending SIGKILL`);
-    const forceKillResult = errore.try({
-        try: () => {
-            process.kill(targetPid, 'SIGKILL');
-        },
-        catch: (e) => new Error('Failed to send SIGKILL to existing kimaki process', {
-            cause: e,
-        }),
-    });
-    if (forceKillResult instanceof Error) {
-        hranaLogger.log(`Failed to force-kill PID ${targetPid}: ${forceKillResult.message}`);
-        return;
+    for (let attempt = 0; attempt < 10; attempt += 1) {
+        await new Promise((resolve) => {
+            setTimeout(resolve, 1000);
+        });
+        // Verify it's gone. Some shutdown paths need a few seconds to run cleanup,
+        // so we avoid SIGKILL and just poll for up to 10 seconds.
+        const secondProbe = await fetch(url, {
+            signal: AbortSignal.timeout(2000),
+        }).catch((e) => new FetchError({ url, cause: e }));
+        if (secondProbe instanceof Error)
+            return;
     }
-    await new Promise((resolve) => {
-        setTimeout(resolve, 1000);
-    });
+    hranaLogger.log(`PID ${targetPid} still alive after 10s SIGTERM grace period`);
 }

package/dist/interaction-handler.js

@@ -18,7 +18,8 @@ import { handleAddDirCommand } from './commands/add-dir.js';
 import { handleCompactCommand } from './commands/compact.js';
 import { handleShareCommand } from './commands/share.js';
 import { handleDiffCommand } from './commands/diff.js';
-import { handleForkCommand, handleForkSelectMenu } from './commands/fork.js';
+import { handleForkCommand, handleForkSelectMenu, } from './commands/fork.js';
+import { handleForkSubagentCommand, handleForkSubagentSelectMenu, } from './commands/fork-subagent.js';
 import { handleBtwCommand } from './commands/btw.js';
 import { handleModelCommand, handleProviderSelectMenu, handleModelSelectMenu, handleModelScopeSelectMenu, } from './commands/model.js';
 import { handleUnsetModelCommand } from './commands/unset-model.js';
@@ -154,6 +155,9 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                     case 'fork':
                         await handleForkCommand(interaction);
                         return;
+                    case 'fork-subagent':
+                        await handleForkSubagentCommand(interaction);
+                        return;
                     case 'btw':
                         await handleBtwCommand({ command: interaction, appId });
                         return;
@@ -306,6 +310,10 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                     await handleForkSelectMenu(interaction);
                     return;
                 }
+                if (customId.startsWith('fork_subagent_select:')) {
+                    await handleForkSubagentSelectMenu(interaction);
+                    return;
+                }
                 if (customId.startsWith('model_provider:')) {
                     await handleProviderSelectMenu(interaction);
                     return;

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

@@ -35,6 +35,17 @@ test('opencode server loads plugin without errors', async () => {
     const pluginPath = new URL('../src/kimaki-opencode-plugin.ts', import.meta.url).href;
     const stderrLines = [];
     const isolatedOpencodeRoot = path.join(projectDir, 'opencode-test-home');
+    const xdgDirectories = {
+        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'),
+    };
+    fs.mkdirSync(isolatedOpencodeRoot, { recursive: true });
+    Object.values(xdgDirectories).forEach((directory) => {
+        fs.mkdirSync(directory, { recursive: true });
+    });
     const { command, args, windowsVerbatimArguments, } = getSpawnCommandAndArgs({
         resolvedCommand: resolveOpencodeCommand(),
         baseArgs: ['serve', '--port', port.toString(), '--print-logs', '--log-level', 'DEBUG'],
@@ -52,11 +63,7 @@ test('opencode server loads plugin without errors', async () => {
                 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'),
+            ...xdgDirectories,
         },
     });
     serverProcess.stderr?.on('data', (data) => {

package/dist/kimaki-opencode-plugin.js

@@ -14,7 +14,6 @@ export { ipcToolsPlugin } from './ipc-tools-plugin.js';
 export { contextAwarenessPlugin } from './context-awareness-plugin.js';
 export { memoryOverviewPlugin } from './memory-overview-plugin.js';
 export { interruptOpencodeSessionOnUserMessage } from './opencode-interrupt-plugin.js';
-export { systemPromptDriftPlugin } from './system-prompt-drift-plugin.js';
 export { anthropicAuthPlugin } from './anthropic-auth-plugin.js';
 export { imageOptimizerPlugin } from './image-optimizer-plugin.js';
 export { subagentRateLimitPlugin } from './subagent-rate-limit-plugin.js';

package/dist/message-preprocessing.js

@@ -37,12 +37,13 @@ async function fetchAvailableAgents(getClient, directory) {
         return { name: a.name, description: a.description };
     });
 }
-// Matches punctuation + "queue" at the end of a message (case-insensitive).
-// Supports any common punctuation before "queue" (. ! ? , ; :) and an optional
-// trailing period: ". queue", "! queue", ". queue.", "!queue." etc.
+// Matches explicit queue markers at the end of a message (case-insensitive).
+// Supported forms:
+// - punctuation + queue: ". queue", "! queue", ". queue.", "!queue."
+// - queue as its own final line: "text\nqueue" or just "queue"
 // When present the suffix is stripped and the message is routed through
 // kimaki's local queue (same as /queue command).
-const QUEUE_SUFFIX_RE = /[.!?,;:]\s*queue\.?\s*$/i;
+const QUEUE_SUFFIX_RE = /(?:[.!?,;:]|^)\s*queue\.?\s*$|\n\s*queue\.?\s*$/i;
 const REPLIED_MESSAGE_TEXT_LIMIT = 1_000;
 function extractQueueSuffix(prompt) {
     if (!QUEUE_SUFFIX_RE.test(prompt)) {

package/dist/message-preprocessing.test.js

@@ -0,0 +1,35 @@
+// Tests queue suffix parsing for incoming Discord messages.
+import { describe, expect, test } from 'vitest';
+import { extractQueueSuffix } from './message-preprocessing.js';
+describe('extractQueueSuffix', () => {
+    test('supports queue as its own final line', () => {
+        expect([
+            extractQueueSuffix('Fix the bug\nqueue'),
+            extractQueueSuffix('Fix the bug\n queue.'),
+            extractQueueSuffix('queue'),
+        ]).toMatchInlineSnapshot(`
+      [
+        {
+          "forceQueue": true,
+          "prompt": "Fix the bug",
+        },
+        {
+          "forceQueue": true,
+          "prompt": "Fix the bug",
+        },
+        {
+          "forceQueue": true,
+          "prompt": "",
+        },
+      ]
+    `);
+    });
+    test('does not treat plain trailing queue word on same line as a queue marker', () => {
+        expect(extractQueueSuffix('Tell me about queue')).toMatchInlineSnapshot(`
+      {
+        "forceQueue": false,
+        "prompt": "Tell me about queue",
+      }
+    `);
+    });
+});

package/dist/onboarding-tutorial.js

@@ -29,21 +29,13 @@ ${backticks}bash
 curl -fsSL https://bun.sh/install | bash
 ${backticks}
 
-**tmux** — needed to run the dev server in the background with kimaki tunnel:
+**tuistory** — needed to run the dev server in the background with kimaki tunnel:
 
 ${backticks}bash
-tmux -V
+bunx tuistory --help
 ${backticks}
 
-If missing, tell the user to install it: https://github.com/tmux/tmux/wiki/Installing — or:
-
-${backticks}bash
-# macOS
-brew install tmux
-
-# Ubuntu/Debian
-sudo apt-get install tmux
-${backticks}
+This works without installing it globally because \`bunx\` can run it on demand.
 
 Do NOT use Node.js, npm, or npx. Use Bun for everything.
 
@@ -140,15 +132,14 @@ Pick a random port between 3000-9000 to avoid conflicts:
 
 ${backticks}bash
 PORT=$((RANDOM % 6000 + 3000))
-tmux kill-session -t game-dev 2>/dev/null
-tmux new-session -d -s game-dev -c "$PWD"
-tmux send-keys -t game-dev "PORT=$PORT kimaki tunnel -p $PORT -- bun run server.ts" Enter
+bunx tuistory launch "PORT=$PORT kimaki tunnel -p $PORT -- bun run server.ts" -s game-dev --cwd "$PWD"
 ${backticks}
 
 Wait a moment, then get the tunnel URL:
 
 ${backticks}bash
-sleep 1 && tmux capture-pane -t game-dev -p
+bunx tuistory -s game-dev wait "/tunnel|https?:\/\//i" --timeout 30000
+bunx tuistory read -s game-dev
 ${backticks}
 
 If the tunnel URL is not visible yet, run the capture command again — it usually appears within a few seconds.

package/dist/opencode.js

@@ -337,6 +337,11 @@ async function waitForServer({ port, directory, maxAttempts = 300, startupStderr
 // In-flight promise to prevent concurrent startups from racing
 let startingServer = null;
 let preferredStartupDirectory = null;
+function ensureOpencodeHomeDirectories({ directories, }) {
+    Object.values(directories).map((directory) => {
+        fs.mkdirSync(directory, { recursive: true });
+    });
+}
 async function ensureSingleServer({ directory, } = {}) {
     const startupDirectory = directory || preferredStartupDirectory || undefined;
     if (singleServer && !singleServer.process.killed) {
@@ -422,7 +427,7 @@ async function startSingleServer({ directory, } = {}) {
             return {};
         }
         const root = path.join(getDataDir(), 'opencode-vitest-home');
-        return {
+        const directories = {
             OPENCODE_TEST_HOME: root,
             OPENCODE_CONFIG_DIR: path.join(root, '.opencode-kimaki'),
             XDG_CONFIG_HOME: path.join(root, '.config'),
@@ -430,6 +435,13 @@ async function startSingleServer({ directory, } = {}) {
             XDG_CACHE_HOME: path.join(root, '.cache'),
             XDG_STATE_HOME: path.join(root, '.local', 'state'),
         };
+        // OpenCode writes state/config files into these XDG locations during boot.
+        // In CI, a fresh temp data dir means the parent folders may not exist yet,
+        // and some writes fail closed with NotFound before OpenCode has a chance to
+        // create them lazily. Pre-create the directories so startup-time tests do
+        // not flap based on process scheduling.
+        ensureOpencodeHomeDirectories({ directories });
+        return directories;
     })();
     // Write config to a file instead of passing via OPENCODE_CONFIG_CONTENT env var.
     // OPENCODE_CONFIG (file path) is loaded before project config in opencode's