@otto-assistant/bridge 0.4.92

package/dist/discord-utils.test.js

@@ -0,0 +1,134 @@
+import { PermissionsBitField } from 'discord.js';
+import { describe, expect, test } from 'vitest';
+import { hasKimakiBotPermission, splitMarkdownForDiscord } from './discord-utils.js';
+describe('splitMarkdownForDiscord', () => {
+    test('never returns chunks over the max length with code fences', () => {
+        const maxLength = 2000;
+        const header = '## Summary of Current Architecture\n\n';
+        const codeFenceStart = '```\n';
+        const codeFenceEnd = '\n```\n';
+        const codeLine = 'x'.repeat(180);
+        const codeBlock = Array.from({ length: 20 })
+            .map(() => codeLine)
+            .join('\n');
+        const markdown = `${header}${codeFenceStart}${codeBlock}${codeFenceEnd}`;
+        const chunks = splitMarkdownForDiscord({ content: markdown, maxLength });
+        expect(chunks.length).toBeGreaterThan(1);
+        for (const chunk of chunks) {
+            expect(chunk.length).toBeLessThanOrEqual(maxLength);
+        }
+    });
+    // Without the lineLength fix for opening fences on non-empty chunks, the opening
+    // fence text "```\n" gets appended without being counted in the overflow check.
+    // When the chunk is later flushed with a closing fence, it exceeds maxLength.
+    test('opening fence on non-empty chunk is counted in overflow check', () => {
+        const maxLength = 60;
+        // 55 chars of text + paragraph break, then a code block.
+        // The text fills the chunk to ~57 chars. The opening fence "```\n" (4 chars)
+        // would push to 61 if not counted, then flushing adds "```\n" (4 more) = 65.
+        const markdown = 'a'.repeat(55) + '\n\n```\nshort code\n```\n';
+        const chunks = splitMarkdownForDiscord({ content: markdown, maxLength });
+        for (const chunk of chunks) {
+            expect(chunk.length).toBeLessThanOrEqual(maxLength);
+        }
+    });
+    test('list item code block keeps newline before fence when splitting', () => {
+        const content = `- File: playwriter/src/aria-snapshot.ts
+- Add helper function (~line 477, after isTextRole):
+  \`\`\`ts
+  function isSubstringOfAny(needle: string, haystack: Set<string>): boolean {
+    for (const str of haystack) {
+      if (str.includes(needle)) {
+        return true
+      }
+    }
+    return false
+  }
+  \`\`\`
+`;
+        const result = splitMarkdownForDiscord({ content, maxLength: 80 });
+        expect(result).toMatchInlineSnapshot(`
+      [
+        "- File: playwriter/src/aria-snapshot.ts
+      ",
+        "- Add helper function (~line 477, after isTextRole):
+        \`\`\`ts
+      ",
+        "  function isSubstringOfAny(needle: string, haystack: Set<string>): boolean {
+      ",
+        "    for (const str of haystack) {
+            if (str.includes(needle)) {
+      ",
+        "        return true
+            }
+          }
+          return false
+        }
+        \`\`\`
+      ",
+      ]
+    `);
+    });
+    test('task list code block does not duplicate checkbox marker when splitting', () => {
+        const content = `- [ ] Do thing
+  \`\`\`sh
+  echo hi
+  \`\`\`
+`;
+        const result = splitMarkdownForDiscord({ content, maxLength: 80 });
+        expect(result.join('')).toContain('- [ ] Do thing\n');
+        expect(result.join('')).not.toContain('- [ ] [ ] Do thing');
+        expect(result).toMatchInlineSnapshot(`
+      [
+        "- [ ] Do thing
+        \`\`\`sh
+        echo hi
+        \`\`\`
+      ",
+      ]
+    `);
+    });
+});
+describe('hasKimakiBotPermission', () => {
+    test('allows API interaction member when kimaki role exists', () => {
+        const kimakiRoleId = '111';
+        const guild = {
+            ownerId: 'owner-id',
+            roles: {
+                cache: new Map([
+                    [kimakiRoleId, { id: kimakiRoleId, name: 'Kimaki' }],
+                ]),
+            },
+        };
+        const member = {
+            user: { id: 'member-id' },
+            permissions: '0',
+            roles: [kimakiRoleId],
+        };
+        expect(hasKimakiBotPermission(member, guild)).toBe(true);
+    });
+    test('allows API interaction member with ManageGuild permission', () => {
+        const guild = {
+            ownerId: 'owner-id',
+            roles: { cache: new Map() },
+        };
+        const member = {
+            user: { id: 'member-id' },
+            permissions: PermissionsBitField.Flags.ManageGuild.toString(),
+            roles: [],
+        };
+        expect(hasKimakiBotPermission(member, guild)).toBe(true);
+    });
+    test('denies API interaction member with no role, owner, or admin rights', () => {
+        const guild = {
+            ownerId: 'owner-id',
+            roles: { cache: new Map() },
+        };
+        const member = {
+            user: { id: 'member-id' },
+            permissions: '0',
+            roles: [],
+        };
+        expect(hasKimakiBotPermission(member, guild)).toBe(false);
+    });
+});

package/dist/errors.js

@@ -0,0 +1,157 @@
+// TaggedError definitions for type-safe error handling with errore.
+// Errors are grouped by category: infrastructure, domain, and validation.
+// Use errore.matchError() for exhaustive error handling in command handlers.
+import { AbortError, createTaggedError } from 'errore';
+// ═══════════════════════════════════════════════════════════════════════════
+// INFRASTRUCTURE ERRORS - Server, filesystem, external services
+// ═══════════════════════════════════════════════════════════════════════════
+export class DirectoryNotAccessibleError extends createTaggedError({
+    name: 'DirectoryNotAccessibleError',
+    message: 'Directory does not exist or is not accessible: $directory',
+}) {
+}
+export class ServerStartError extends createTaggedError({
+    name: 'ServerStartError',
+    message: 'Server failed to start on port $port: $reason',
+}) {
+}
+export class ServerNotReadyError extends createTaggedError({
+    name: 'ServerNotReadyError',
+    message: 'OpenCode client for directory "$directory" is not available because the shared server is not ready',
+}) {
+}
+export class ApiKeyMissingError extends createTaggedError({
+    name: 'ApiKeyMissingError',
+    message: '$service API key is required',
+}) {
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// ABORT ERRORS - Session cancellation with typed reasons
+// ═══════════════════════════════════════════════════════════════════════════
+// Extends errore.AbortError so errore.isAbortError() detects it in cause chains.
+// Use reason field instead of string matching to identify abort cause.
+export class SessionAbortError extends createTaggedError({
+    name: 'SessionAbortError',
+    message: 'Session aborted: $reason',
+    extends: AbortError,
+}) {
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// DOMAIN ERRORS - Sessions, messages, transcription
+// ═══════════════════════════════════════════════════════════════════════════
+export class SessionNotFoundError extends createTaggedError({
+    name: 'SessionNotFoundError',
+    message: 'Session $sessionId not found',
+}) {
+}
+export class SessionCreateError extends createTaggedError({
+    name: 'SessionCreateError',
+}) {
+}
+export class MessagesNotFoundError extends createTaggedError({
+    name: 'MessagesNotFoundError',
+    message: 'No messages found for session $sessionId',
+}) {
+}
+export class TranscriptionError extends createTaggedError({
+    name: 'TranscriptionError',
+    message: 'Transcription failed: $reason',
+}) {
+}
+export class GrepSearchError extends createTaggedError({
+    name: 'GrepSearchError',
+    message: 'Grep search failed for pattern: $pattern',
+}) {
+}
+export class GlobSearchError extends createTaggedError({
+    name: 'GlobSearchError',
+    message: 'Glob search failed for pattern: $pattern',
+}) {
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// VALIDATION ERRORS - Input validation, format checks
+// ═══════════════════════════════════════════════════════════════════════════
+export class InvalidAudioFormatError extends createTaggedError({
+    name: 'InvalidAudioFormatError',
+    message: 'Invalid audio format',
+}) {
+}
+export class EmptyTranscriptionError extends createTaggedError({
+    name: 'EmptyTranscriptionError',
+    message: 'Model returned empty transcription',
+}) {
+}
+export class NoResponseContentError extends createTaggedError({
+    name: 'NoResponseContentError',
+    message: 'No response content from model',
+}) {
+}
+export class NoToolResponseError extends createTaggedError({
+    name: 'NoToolResponseError',
+    message: 'No valid tool responses',
+}) {
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// NETWORK ERRORS - Fetch and HTTP
+// ═══════════════════════════════════════════════════════════════════════════
+export class FetchError extends createTaggedError({
+    name: 'FetchError',
+    message: 'Fetch failed for $url',
+}) {
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// API ERRORS - External service responses
+// ═══════════════════════════════════════════════════════════════════════════
+export class DiscordApiError extends createTaggedError({
+    name: 'DiscordApiError',
+    message: 'Discord API error: $status $body',
+}) {
+}
+export class OpenCodeApiError extends createTaggedError({
+    name: 'OpenCodeApiError',
+    message: 'OpenCode API error ($status): $body',
+}) {
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// MERGE/WORKTREE ERRORS
+// ═══════════════════════════════════════════════════════════════════════════
+export class DirtyWorktreeError extends createTaggedError({
+    name: 'DirtyWorktreeError',
+    message: 'Uncommitted changes in worktree. Commit all changes before merging.',
+}) {
+}
+export class NothingToMergeError extends createTaggedError({
+    name: 'NothingToMergeError',
+    message: 'No commits to merge -- branch is already up to date with $target',
+}) {
+}
+export class RebaseConflictError extends createTaggedError({
+    name: 'RebaseConflictError',
+    message: 'Rebase conflict while rebasing onto $target. Resolve conflicts, then run merge again.',
+}) {
+}
+export class RebaseError extends createTaggedError({
+    name: 'RebaseError',
+    message: 'Rebase onto $target failed',
+}) {
+}
+export class NotFastForwardError extends createTaggedError({
+    name: 'NotFastForwardError',
+    message: 'Cannot fast-forward: $target has commits not in this branch',
+}) {
+}
+export class ConflictingFilesError extends createTaggedError({
+    name: 'ConflictingFilesError',
+    message: 'Cannot merge: $target worktree has uncommitted changes in overlapping files. Commit changes in main worktree first, then run `/merge-worktree` again.',
+}) {
+}
+export class PushError extends createTaggedError({
+    name: 'PushError',
+    message: 'Push to $target failed',
+}) {
+}
+export class GitCommandError extends createTaggedError({
+    name: 'GitCommandError',
+    message: 'Git command failed: $command',
+}) {
+}