@otto-assistant/otto 0.1.2 → 0.7.16

package/dist/commands/worktrees.js

@@ -0,0 +1,468 @@
+// /worktrees command — list all git worktrees for the current channel's project.
+// Uses `git worktree list --porcelain` as source of truth, enriched with
+// DB metadata (thread link, created_at) when available. Shows otto-created,
+// opencode-created, and manually created worktrees in a single table.
+// 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, } 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 crypto from 'node:crypto';
+import { GitCommandError } from '../errors.js';
+import { resolveWorkingDirectory } from '../discord-utils.js';
+import { deleteWorktree, git, getDefaultBranch, listGitWorktrees, } from '../worktrees.js';
+import path from 'node:path';
+// 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`;
+}
+// Stable button ID derived from directory path via sha1 hash.
+// Avoids collisions that truncated path suffixes can cause.
+function worktreeButtonKey(directory) {
+    return crypto.createHash('sha1').update(directory).digest('hex').slice(0, 12);
+}
+// 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;
+// Detect worktree source from branch name and directory path.
+// opencode/otto-* and legacy opencode/otto-* branches → otto,
+// opencode worktree paths → opencode, else manual.
+function detectWorktreeSource({ branch, directory, }) {
+    if (branch?.startsWith('opencode/otto-') || branch?.startsWith('opencode/otto-')) {
+        return 'otto';
+    }
+    // opencode stores worktrees under ~/.local/share/opencode/worktree/
+    if (directory.includes('/opencode/worktree/')) {
+        return 'opencode';
+    }
+    return 'manual';
+}
+// Checks dirty state and commits ahead of default branch in parallel.
+// Returns null when the directory is missing / git commands fail / timeout.
+async function getWorktreeGitStatus({ directory, defaultBranch, }) {
+    try {
+        // 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(directory, 'status --porcelain', { timeout: GIT_CMD_TIMEOUT }),
+            git(directory, `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({ rows, gitStatuses, guildId, }) {
+    const header = '| Source | Name | Status | Created | Folder | Action |';
+    const separator = '|---|---|---|---|---|---|';
+    const tableRows = rows.map((row, i) => {
+        const sourceCell = (() => {
+            if (row.threadId && row.guildId) {
+                const threadLink = `[${row.source}](https://discord.com/channels/${row.guildId}/${row.threadId})`;
+                return threadLink;
+            }
+            return row.source;
+        })();
+        const name = row.name;
+        const gs = gitStatuses[i] ?? null;
+        const status = (() => {
+            if (row.dbStatus !== 'ready') {
+                return row.dbStatus;
+            }
+            if (row.locked) {
+                return 'locked';
+            }
+            if (row.prunable) {
+                return 'prunable';
+            }
+            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 = row.createdAt ? formatTimeAgo(row.createdAt) : '-';
+        const folder = row.directory;
+        const action = buildActionCell({ row, gitStatus: gs });
+        return `| ${sourceCell} | ${name} | ${status} | ${created} | ${folder} | ${action} |`;
+    });
+    return [header, separator, ...tableRows].join('\n');
+}
+function buildActionCell({ row, gitStatus, }) {
+    if (!canDeleteWorktree({ row, gitStatus })) {
+        return '-';
+    }
+    return buildDeleteButtonHtml({
+        buttonId: `del-wt-${worktreeButtonKey(row.directory)}`,
+    });
+}
+function buildDeleteButtonHtml({ buttonId, }) {
+    return `<button id="${buttonId}" variant="secondary">Delete</button>`;
+}
+function canDeleteWorktree({ row, gitStatus, }) {
+    if (row.dbStatus !== 'ready') {
+        return false;
+    }
+    if (row.locked) {
+        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.
+async function resolveGitStatuses({ rows, projectDirectory, timeout, }) {
+    const nullFallback = rows.map(() => null);
+    let timer;
+    const deadline = new Promise((resolve) => {
+        timer = setTimeout(() => {
+            resolve(nullFallback);
+        }, timeout);
+    });
+    const work = (async () => {
+        const defaultBranch = await getDefaultBranch(projectDirectory, {
+            timeout: GIT_CMD_TIMEOUT,
+        });
+        return Promise.all(rows.map((row) => {
+            if (row.dbStatus !== 'ready' || row.locked || row.prunable) {
+                return null;
+            }
+            return getWorktreeGitStatus({ directory: row.directory, defaultBranch });
+        }));
+    })();
+    try {
+        return await Promise.race([work, deadline]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+// Merge git worktrees with DB metadata into unified WorktreeRows.
+// Git is the source of truth for what exists on disk. DB rows that aren't
+// in the git list (pending/error) are appended at the end.
+async function buildWorktreeRows({ projectDirectory, gitWorktrees, }) {
+    const prisma = await getPrisma();
+    const dbWorktrees = await prisma.thread_worktrees.findMany({
+        where: { project_directory: projectDirectory },
+    });
+    // Index DB worktrees by directory for fast lookup
+    const dbByDirectory = new Map();
+    for (const dbWt of dbWorktrees) {
+        if (dbWt.worktree_directory) {
+            dbByDirectory.set(dbWt.worktree_directory, dbWt);
+        }
+    }
+    // Track which DB rows got matched so we can append unmatched ones
+    const matchedDbThreadIds = new Set();
+    // Build rows from git worktrees (the source of truth for on-disk state).
+    // Use real DB status when available — a git-visible worktree whose DB row
+    // is still 'pending' means setup hasn't finished (race window).
+    const gitRows = gitWorktrees.map((gw) => {
+        const dbMatch = dbByDirectory.get(gw.directory);
+        if (dbMatch) {
+            matchedDbThreadIds.add(dbMatch.thread_id);
+        }
+        const source = detectWorktreeSource({
+            branch: gw.branch,
+            directory: gw.directory,
+        });
+        const name = gw.branch ?? path.basename(gw.directory);
+        const dbStatus = (() => {
+            if (!dbMatch) {
+                return 'ready';
+            }
+            if (dbMatch.status === 'error') {
+                return 'error';
+            }
+            if (dbMatch.status === 'pending') {
+                return 'pending';
+            }
+            return 'ready';
+        })();
+        return {
+            directory: gw.directory,
+            branch: gw.branch,
+            name,
+            threadId: dbMatch?.thread_id ?? null,
+            guildId: null, // filled in by caller
+            createdAt: dbMatch?.created_at ?? null,
+            source,
+            dbStatus,
+            locked: gw.locked,
+            prunable: gw.prunable,
+        };
+    });
+    // Append DB-only worktrees (pending/error/stale — not visible to git).
+    // Preserve actual DB status so stale 'ready' rows show as 'ready' (missing).
+    const dbOnlyRows = dbWorktrees
+        .filter((dbWt) => {
+        return !matchedDbThreadIds.has(dbWt.thread_id);
+    })
+        .map((dbWt) => {
+        const dbStatus = (() => {
+            if (dbWt.status === 'error') {
+                return 'error';
+            }
+            if (dbWt.status === 'pending') {
+                return 'pending';
+            }
+            return 'ready';
+        })();
+        return {
+            directory: dbWt.worktree_directory ?? dbWt.project_directory,
+            branch: null,
+            name: dbWt.worktree_name,
+            threadId: dbWt.thread_id,
+            guildId: null,
+            createdAt: dbWt.created_at,
+            source: 'otto',
+            dbStatus,
+            locked: false,
+            prunable: false,
+        };
+    });
+    return [...gitRows, ...dbOnlyRows];
+}
+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 gitWorktrees = await listGitWorktrees({
+        projectDirectory,
+        timeout: GIT_CMD_TIMEOUT,
+    });
+    // On git failure, fall back to empty list (DB-only rows still shown)
+    const gitList = gitWorktrees instanceof Error ? [] : gitWorktrees;
+    const rows = await buildWorktreeRows({ projectDirectory, gitWorktrees: gitList });
+    // Inject guildId into all rows for thread link rendering
+    for (const row of rows) {
+        row.guildId = guildId;
+    }
+    if (rows.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({
+        rows,
+        projectDirectory,
+        timeout: GLOBAL_TIMEOUT,
+    });
+    // Map deletable worktrees by button ID for the HTML action resolver.
+    // Uses the same worktreeButtonKey() as buildActionCell.
+    const deletableRowsByButtonId = new Map();
+    rows.forEach((row, index) => {
+        const gitStatus = gitStatuses[index] ?? null;
+        if (!canDeleteWorktree({ row, gitStatus })) {
+            return;
+        }
+        deletableRowsByButtonId.set(`del-wt-${worktreeButtonKey(row.directory)}`, row);
+    });
+    const tableMarkdown = buildWorktreeTable({
+        rows,
+        gitStatuses,
+        guildId,
+    });
+    const markdown = notice ? `${notice}\n\n${tableMarkdown}` : tableMarkdown;
+    const segments = splitTablesFromMarkdown(markdown, {
+        resolveButtonCustomId: ({ button }) => {
+            const row = deletableRowsByButtonId.get(button.id);
+            if (!row) {
+                return new Error(`No worktree registered for button ${button.id}`);
+            }
+            const actionId = registerHtmlAction({
+                ownerKey,
+                threadId: row.threadId ?? row.directory,
+                run: async ({ interaction }) => {
+                    await handleDeleteWorktreeAction({
+                        interaction,
+                        row,
+                        projectDirectory,
+                    });
+                },
+            });
+            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, row, projectDirectory, }) {
+    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;
+    }
+    // Pass branch name for branch cleanup. Empty string for detached HEAD
+    // worktrees so deleteWorktree skips the `git branch -d` step.
+    const displayName = row.branch ?? row.name;
+    const deleteResult = await deleteWorktree({
+        projectDirectory,
+        worktreeDirectory: row.directory,
+        worktreeName: row.branch ?? '',
+    });
+    if (deleteResult instanceof Error) {
+        const gitStderr = extractGitStderr(deleteResult);
+        const detail = gitStderr
+            ? `\`\`\`\n${gitStderr}\n\`\`\``
+            : deleteResult.message;
+        await interaction
+            .followUp({
+            content: `Failed to delete \`${displayName}\`\n${detail}`,
+            flags: MessageFlags.Ephemeral,
+        })
+            .catch(() => {
+            return undefined;
+        });
+        return;
+    }
+    // Clean up DB row if this was an otto-tracked worktree
+    if (row.threadId) {
+        await deleteThreadWorktree(row.threadId);
+    }
+    await renderWorktreesReply({
+        guildId,
+        userId: interaction.user.id,
+        channelId: interaction.channelId,
+        projectDirectory,
+        notice: `Deleted \`${displayName}\`.`,
+        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 otto-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');
+}