@otto-assistant/bridge 0.4.92

package/dist/commands/worktrees.js

@@ -0,0 +1,410 @@
+// /worktrees command — list worktree sessions for the current channel's project.
+// Renders a markdown table that the CV2 pipeline auto-formats for Discord,
+// including HTML-backed action buttons for deletable worktrees.
+import { ButtonInteraction, ChatInputCommandInteraction, ChannelType, ComponentType, MessageFlags, } from 'discord.js';
+import { deleteThreadWorktree, getThreadWorktree, } from '../database.js';
+import { getPrisma } from '../db.js';
+import { splitTablesFromMarkdown } from '../format-tables.js';
+import { buildHtmlActionCustomId, cancelHtmlActionsForOwner, registerHtmlAction, } from '../html-actions.js';
+import * as errore from 'errore';
+import { GitCommandError } from '../errors.js';
+import { resolveWorkingDirectory } from '../discord-utils.js';
+import { deleteWorktree, git, getDefaultBranch } from '../worktrees.js';
+// Extracts the git stderr from a deleteWorktree error via errore.findCause.
+// Chain: Error { cause: GitCommandError { cause: CommandError { stderr } } }.
+export function extractGitStderr(error) {
+    const gitErr = errore.findCause(error, GitCommandError);
+    const stderr = gitErr?.cause?.stderr?.trim();
+    if (stderr && stderr.length > 0) {
+        return stderr;
+    }
+    return undefined;
+}
+export function formatTimeAgo(date) {
+    const diffMs = Date.now() - date.getTime();
+    if (diffMs < 0) {
+        return 'just now';
+    }
+    const totalSeconds = Math.floor(diffMs / 1000);
+    if (totalSeconds < 60) {
+        return `${totalSeconds}s ago`;
+    }
+    const totalMinutes = Math.floor(totalSeconds / 60);
+    if (totalMinutes < 60) {
+        return `${totalMinutes}m ago`;
+    }
+    const hours = Math.floor(totalMinutes / 60);
+    const minutes = totalMinutes % 60;
+    if (hours < 24) {
+        return minutes > 0 ? `${hours}h ${minutes}m ago` : `${hours}h ago`;
+    }
+    const days = Math.floor(hours / 24);
+    const remainingHours = hours % 24;
+    return remainingHours > 0 ? `${days}d ${remainingHours}h ago` : `${days}d ago`;
+}
+function statusLabel(wt) {
+    if (wt.status === 'ready') {
+        return 'ready';
+    }
+    if (wt.status === 'error') {
+        return 'error';
+    }
+    return 'pending';
+}
+// 5s timeout per git call — prevents hangs from deleted dirs, git locks, slow disks.
+// Returns null on timeout/error so the table shows "unknown" for that worktree.
+const GIT_CMD_TIMEOUT = 5_000;
+const GLOBAL_TIMEOUT = 10_000;
+// Checks dirty state and commits ahead of default branch in parallel.
+// Returns null for worktrees that aren't ready or when the directory is
+// missing / git commands fail / timeout (e.g. deleted worktree folder).
+async function getWorktreeGitStatus({ wt, defaultBranch, }) {
+    if (wt.status !== 'ready' || !wt.worktree_directory) {
+        return null;
+    }
+    try {
+        const dir = wt.worktree_directory;
+        // Use raw git calls so errors/timeouts are visible — isDirty() swallows
+        // errors and returns false, which would render "merged" instead of "unknown".
+        const [statusResult, aheadResult] = await Promise.all([
+            git(dir, 'status --porcelain', { timeout: GIT_CMD_TIMEOUT }),
+            git(dir, `rev-list --count "${defaultBranch}..HEAD"`, {
+                timeout: GIT_CMD_TIMEOUT,
+            }),
+        ]);
+        if (statusResult instanceof Error || aheadResult instanceof Error) {
+            return null;
+        }
+        const aheadCount = parseInt(aheadResult, 10);
+        if (!Number.isFinite(aheadCount)) {
+            return null;
+        }
+        return { dirty: statusResult.length > 0, aheadCount };
+    }
+    catch {
+        return null;
+    }
+}
+function buildWorktreeTable({ worktrees, gitStatuses, guildId, }) {
+    const header = '| Thread | Name | Status | Created | Folder | Action |';
+    const separator = '|---|---|---|---|---|---|';
+    const rows = worktrees.map((wt, i) => {
+        const threadLink = `[thread](https://discord.com/channels/${guildId}/${wt.thread_id})`;
+        const name = wt.worktree_name;
+        const gs = gitStatuses[i] ?? null;
+        const status = (() => {
+            if (wt.status !== 'ready') {
+                return statusLabel(wt);
+            }
+            if (!gs) {
+                return 'unknown';
+            }
+            const parts = [];
+            if (gs.dirty) {
+                parts.push('dirty');
+            }
+            if (gs.aheadCount > 0) {
+                parts.push(`${gs.aheadCount} ahead`);
+            }
+            else {
+                parts.push('merged');
+            }
+            return parts.join(', ');
+        })();
+        const created = wt.created_at ? formatTimeAgo(wt.created_at) : 'unknown';
+        const folder = wt.worktree_directory ?? wt.project_directory;
+        const action = buildActionCell({ wt, gitStatus: gs });
+        return `| ${threadLink} | ${name} | ${status} | ${created} | ${folder} | ${action} |`;
+    });
+    return [header, separator, ...rows].join('\n');
+}
+function buildActionCell({ wt, gitStatus, }) {
+    if (!canDeleteWorktree({ wt, gitStatus })) {
+        return '-';
+    }
+    return buildDeleteButtonHtml({
+        buttonId: `delete-worktree-${wt.thread_id}`,
+    });
+}
+function buildDeleteButtonHtml({ buttonId, }) {
+    return `<button id="${buttonId}" variant="secondary">Delete</button>`;
+}
+function canDeleteWorktree({ wt, gitStatus, }) {
+    if (wt.status !== 'ready' || !wt.worktree_directory) {
+        return false;
+    }
+    if (!gitStatus) {
+        return false;
+    }
+    if (gitStatus.dirty) {
+        return false;
+    }
+    return gitStatus.aheadCount === 0;
+}
+// Resolves git statuses for all worktrees within a single global deadline.
+// Caches getDefaultBranch per project_directory to avoid redundant spawns.
+// Returns null for any worktree whose git calls fail, timeout, or exceed
+// the global deadline — the table renders those as "unknown".
+async function resolveGitStatuses({ worktrees, timeout, }) {
+    const nullFallback = worktrees.map(() => null);
+    let timer;
+    const deadline = new Promise((resolve) => {
+        timer = setTimeout(() => {
+            resolve(nullFallback);
+        }, timeout);
+    });
+    const work = (async () => {
+        // Resolve default branch once per unique project directory (avoids
+        // redundant git subprocess spawns when multiple worktrees share a project).
+        const uniqueProjectDirs = [
+            ...new Set(worktrees.map((wt) => wt.project_directory)),
+        ];
+        const defaultBranchEntries = await Promise.all(uniqueProjectDirs.map(async (dir) => {
+            const branch = await getDefaultBranch(dir, { timeout: GIT_CMD_TIMEOUT });
+            return [dir, branch];
+        }));
+        const defaultBranchByProject = new Map(defaultBranchEntries);
+        return Promise.all(worktrees.map((wt) => {
+            const defaultBranch = defaultBranchByProject.get(wt.project_directory) ?? 'main';
+            return getWorktreeGitStatus({ wt, defaultBranch });
+        }));
+    })();
+    try {
+        return await Promise.race([work, deadline]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function getRecentWorktrees({ projectDirectory, }) {
+    const prisma = await getPrisma();
+    return await prisma.thread_worktrees.findMany({
+        where: {
+            project_directory: projectDirectory,
+        },
+        orderBy: { created_at: 'desc' },
+        take: 10,
+    });
+}
+function getWorktreesActionOwnerKey({ userId, channelId, }) {
+    return `worktrees:${userId}:${channelId}`;
+}
+function isProjectChannel(channel) {
+    if (!channel) {
+        return false;
+    }
+    return [
+        ChannelType.GuildText,
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+}
+async function renderWorktreesReply({ guildId, userId, channelId, projectDirectory, notice, editReply, }) {
+    const ownerKey = getWorktreesActionOwnerKey({ userId, channelId });
+    cancelHtmlActionsForOwner(ownerKey);
+    const worktrees = await getRecentWorktrees({ projectDirectory });
+    if (worktrees.length === 0) {
+        const message = notice ? `${notice}\n\nNo worktrees found.` : 'No worktrees found.';
+        const textDisplay = {
+            type: ComponentType.TextDisplay,
+            content: message,
+        };
+        await editReply({
+            components: [textDisplay],
+            flags: MessageFlags.IsComponentsV2,
+        });
+        return;
+    }
+    const gitStatuses = await resolveGitStatuses({
+        worktrees,
+        timeout: GLOBAL_TIMEOUT,
+    });
+    const deletableWorktreesByButtonId = new Map();
+    worktrees.forEach((wt, index) => {
+        const gitStatus = gitStatuses[index] ?? null;
+        if (!canDeleteWorktree({ wt, gitStatus })) {
+            return;
+        }
+        deletableWorktreesByButtonId.set(`delete-worktree-${wt.thread_id}`, wt);
+    });
+    const tableMarkdown = buildWorktreeTable({
+        worktrees,
+        gitStatuses,
+        guildId,
+    });
+    const markdown = notice ? `${notice}\n\n${tableMarkdown}` : tableMarkdown;
+    const segments = splitTablesFromMarkdown(markdown, {
+        resolveButtonCustomId: ({ button }) => {
+            const worktree = deletableWorktreesByButtonId.get(button.id);
+            if (!worktree) {
+                return new Error(`No worktree registered for button ${button.id}`);
+            }
+            const actionId = registerHtmlAction({
+                ownerKey,
+                threadId: worktree.thread_id,
+                run: async ({ interaction }) => {
+                    await handleDeleteWorktreeAction({
+                        interaction,
+                        threadId: worktree.thread_id,
+                    });
+                },
+            });
+            return buildHtmlActionCustomId(actionId);
+        },
+    });
+    const components = segments.flatMap((segment) => {
+        if (segment.type === 'components') {
+            return segment.components;
+        }
+        const textDisplay = {
+            type: ComponentType.TextDisplay,
+            content: segment.text,
+        };
+        return [textDisplay];
+    });
+    await editReply({
+        components,
+        flags: MessageFlags.IsComponentsV2,
+    });
+}
+async function handleDeleteWorktreeAction({ interaction, threadId, }) {
+    const guildId = interaction.guildId;
+    if (!guildId) {
+        await interaction.editReply({
+            components: [
+                {
+                    type: ComponentType.TextDisplay,
+                    content: 'This action can only be used in a server.',
+                },
+            ],
+            flags: MessageFlags.IsComponentsV2,
+        });
+        return;
+    }
+    const worktree = await getThreadWorktree(threadId);
+    if (!worktree) {
+        if (!isProjectChannel(interaction.channel)) {
+            await interaction.editReply({
+                components: [
+                    {
+                        type: ComponentType.TextDisplay,
+                        content: 'This action can only be used in a project channel or thread.',
+                    },
+                ],
+                flags: MessageFlags.IsComponentsV2,
+            });
+            return;
+        }
+        const resolved = await resolveWorkingDirectory({
+            channel: interaction.channel,
+        });
+        if (!resolved) {
+            await interaction.editReply({
+                components: [
+                    {
+                        type: ComponentType.TextDisplay,
+                        content: 'Could not determine the project folder for this channel.',
+                    },
+                ],
+                flags: MessageFlags.IsComponentsV2,
+            });
+            return;
+        }
+        await renderWorktreesReply({
+            guildId,
+            userId: interaction.user.id,
+            channelId: interaction.channelId,
+            projectDirectory: resolved.projectDirectory,
+            notice: 'Worktree was already removed.',
+            editReply: (options) => {
+                return interaction.editReply(options);
+            },
+        });
+        return;
+    }
+    if (worktree.status !== 'ready' || !worktree.worktree_directory) {
+        await renderWorktreesReply({
+            guildId,
+            userId: interaction.user.id,
+            channelId: interaction.channelId,
+            projectDirectory: worktree.project_directory,
+            notice: `Cannot delete \`${worktree.worktree_name}\` because it is ${worktree.status}.`,
+            editReply: (options) => {
+                return interaction.editReply(options);
+            },
+        });
+        return;
+    }
+    const deleteResult = await deleteWorktree({
+        projectDirectory: worktree.project_directory,
+        worktreeDirectory: worktree.worktree_directory,
+        worktreeName: worktree.worktree_name,
+    });
+    if (deleteResult instanceof Error) {
+        // Send error as a separate ephemeral follow-up so the table stays intact.
+        // Dig into cause chain to surface the actual git stderr when available.
+        const gitStderr = extractGitStderr(deleteResult);
+        const detail = gitStderr
+            ? `\`\`\`\n${gitStderr}\n\`\`\``
+            : deleteResult.message;
+        await interaction
+            .followUp({
+            content: `Failed to delete \`${worktree.worktree_name}\`\n${detail}`,
+            flags: MessageFlags.Ephemeral,
+        })
+            .catch(() => {
+            return undefined;
+        });
+        return;
+    }
+    await deleteThreadWorktree(threadId);
+    await renderWorktreesReply({
+        guildId,
+        userId: interaction.user.id,
+        channelId: interaction.channelId,
+        projectDirectory: worktree.project_directory,
+        notice: `Deleted \`${worktree.worktree_name}\`.`,
+        editReply: (options) => {
+            return interaction.editReply(options);
+        },
+    });
+}
+export async function handleWorktreesCommand({ command, }) {
+    const channel = command.channel;
+    const guildId = command.guildId;
+    if (!guildId || !channel) {
+        await command.reply({
+            content: 'This command can only be used in a server channel.',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    if (!isProjectChannel(channel)) {
+        await command.reply({
+            content: 'This command can only be used in a project channel or thread.',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const resolved = await resolveWorkingDirectory({
+        channel: channel,
+    });
+    if (!resolved) {
+        await command.reply({
+            content: 'Could not determine the project folder for this channel.',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    await command.deferReply({ flags: MessageFlags.Ephemeral });
+    await renderWorktreesReply({
+        guildId,
+        userId: command.user.id,
+        channelId: command.channelId,
+        projectDirectory: resolved.projectDirectory,
+        editReply: (options) => {
+            return command.editReply(options);
+        },
+    });
+}

package/dist/condense-memory.js

@@ -0,0 +1,33 @@
+// Utility to condense MEMORY.md into a line-numbered table of contents.
+// Separated from kimaki-opencode-plugin.ts because OpenCode's plugin loader calls
+// every exported function in the module as a plugin initializer — exporting
+// this utility from the plugin entry file caused it to be invoked with a
+// PluginInput object instead of a string, crashing inside marked's Lexer.
+import { Lexer } from 'marked';
+/**
+ * Condense MEMORY.md into a line-numbered table of contents.
+ * Parses markdown AST with marked's Lexer, emits each heading prefixed by
+ * its source line number, and collapses non-heading content to `...`.
+ * The agent can then use Read with offset/limit to read specific sections.
+ */
+export function condenseMemoryMd(content) {
+    const tokens = new Lexer().lex(content);
+    const lines = [];
+    let charOffset = 0;
+    let lastWasEllipsis = false;
+    for (const token of tokens) {
+        // Compute 1-based line number from character offset
+        const lineNumber = content.slice(0, charOffset).split('\n').length;
+        if (token.type === 'heading') {
+            const prefix = '#'.repeat(token.depth);
+            lines.push(`${lineNumber}: ${prefix} ${token.text}`);
+            lastWasEllipsis = false;
+        }
+        else if (!lastWasEllipsis) {
+            lines.push('...');
+            lastWasEllipsis = true;
+        }
+        charOffset += token.raw.length;
+    }
+    return lines.join('\n');
+}

package/dist/config.js

@@ -0,0 +1,94 @@
+// Runtime configuration for Kimaki bot.
+// Thin re-export layer over the centralized zustand store (store.ts).
+// Getter/setter functions are kept for backwards compatibility so existing
+// import sites don't need to change. They delegate to store.getState() and
+// store.setState() under the hood.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { store } from './store.js';
+const DEFAULT_DATA_DIR = path.join(os.homedir(), '.kimaki');
+/**
+ * Get the data directory path.
+ * Falls back to ~/.kimaki if not explicitly set.
+ * Under vitest (KIMAKI_VITEST env var), auto-creates an isolated temp dir so
+ * tests never touch the real ~/.kimaki/ database. Tests that need a specific
+ * dir can still call setDataDir() before any DB access to override this.
+ */
+export function getDataDir() {
+    const current = store.getState().dataDir;
+    if (current) {
+        return current;
+    }
+    if (process.env.KIMAKI_VITEST) {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kimaki-test-'));
+        store.setState({ dataDir: tmpDir });
+        return tmpDir;
+    }
+    store.setState({ dataDir: DEFAULT_DATA_DIR });
+    return DEFAULT_DATA_DIR;
+}
+/**
+ * Set the data directory path.
+ * Creates the directory if it doesn't exist.
+ * Must be called before any database or path-dependent operations.
+ */
+export function setDataDir(dir) {
+    const resolvedDir = path.resolve(dir);
+    if (!fs.existsSync(resolvedDir)) {
+        fs.mkdirSync(resolvedDir, { recursive: true });
+    }
+    store.setState({ dataDir: resolvedDir });
+}
+/**
+ * Get the projects directory path (for /create-new-project command).
+ * Returns the custom --projects-dir if set, otherwise <dataDir>/projects.
+ */
+export function getProjectsDir() {
+    const custom = store.getState().projectsDir;
+    if (custom) {
+        return custom;
+    }
+    return path.join(getDataDir(), 'projects');
+}
+/**
+ * Set a custom projects directory path (from --projects-dir CLI flag).
+ * Creates the directory if it doesn't exist.
+ */
+export function setProjectsDir(dir) {
+    const resolvedDir = path.resolve(dir);
+    if (!fs.existsSync(resolvedDir)) {
+        fs.mkdirSync(resolvedDir, { recursive: true });
+    }
+    store.setState({ projectsDir: resolvedDir });
+}
+const DEFAULT_LOCK_PORT = 29988;
+/**
+ * Derive a lock port from the data directory path.
+ * If KIMAKI_LOCK_PORT is set to a valid TCP port, it takes precedence.
+ * Returns 29988 for the default ~/.kimaki directory (backwards compatible).
+ * For custom data dirs, uses a hash to generate a port in the range 30000-39999.
+ */
+export function getLockPort() {
+    const envPortRaw = process.env['KIMAKI_LOCK_PORT'];
+    if (envPortRaw) {
+        const envPort = Number.parseInt(envPortRaw, 10);
+        if (Number.isInteger(envPort) && envPort >= 1 && envPort <= 65535) {
+            return envPort;
+        }
+    }
+    const dir = getDataDir();
+    // Use original port for default data dir (backwards compatible)
+    if (dir === DEFAULT_DATA_DIR) {
+        return DEFAULT_LOCK_PORT;
+    }
+    // Hash-based port for custom data dirs
+    let hash = 0;
+    for (let i = 0; i < dir.length; i++) {
+        const char = dir.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash = hash & hash; // Convert to 32bit integer
+    }
+    // Map to port range 30000-39999
+    return 30000 + (Math.abs(hash) % 10000);
+}