@otto-assistant/otto 0.1.2 → 0.7.16

package/dist/otto/branding.js

@@ -0,0 +1,22 @@
+/**
+ * Otto branding overrides
+ *
+ * These values can be used throughout the distribution
+ * to customize the CLI appearance and messaging.
+ */
+export const OTTO_BRANDING = {
+    /** Display name shown in UI */
+    name: "Otto",
+    /** Short description */
+    tagline: "AI agent distribution",
+    /** Organization URL */
+    homepage: "https://github.com/otto-assistant/otto",
+    /** Version of the otto distribution (updated by CI) */
+    ottoVersion: "0.1.0",
+};
+/**
+ * Check if running as Otto distribution
+ */
+export function isOttoDistribution() {
+    return true; // This file only exists in the Otto fork
+}

package/dist/otto/index.js

@@ -0,0 +1,21 @@
+/**
+ * Otto distribution extensions
+ *
+ * Custom branding, features, and integrations for the Otto AI distribution.
+ * This module is imported by the upstream entry point.
+ * Upstream code is NOT modified beyond a single import line at the end of cli.ts.
+ */
+export { OTTO_BRANDING } from "./branding.js";
+/**
+ * Otto-specific configuration for the distribution
+ */
+export const OTTO_CONFIG = {
+    /** GitHub organization */
+    org: "otto-assistant",
+    /** Upstream repository */
+    upstream: "otto-assistant/otto",
+    /** Distribution name */
+    distributionName: "Otto",
+    /** Homepage */
+    homepage: "https://github.com/otto-assistant/otto",
+};

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

@@ -0,0 +1,161 @@
+// End-to-end test using discord-digital-twin + real Otto 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', 'otto-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: 'otto-digital-twin-e2e' });
+    process.env['OTTO_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: 'Otto E2E Guild',
+            ownerId: testUserId,
+        },
+        channels: [
+            {
+                id: textChannelId,
+                name: 'otto-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['OTTO_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: otto digital twin ok',
+        });
+        const createdThread = await discord.channel(textChannelId).waitForThread({
+            timeout: 60_000,
+            predicate: (thread) => {
+                return thread.name === 'Reply with exactly: otto 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['OTTO_LOCK_PORT'];
+        delete process.env['OTTO_DB_URL'];
+        fs.rmSync(directories.dataDir, { recursive: true, force: true });
+    }
+}, 360_000);

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

@@ -0,0 +1,94 @@
+// 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/otto-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-otto'),
+        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'],
+    });
+    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,
+            ...xdgDirectories,
+        },
+    });
+    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/otto-opencode-plugin.js

@@ -0,0 +1,21 @@
+// OpenCode plugin entry point for Otto 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 reminder, onboarding tutorial
+// - memory-overview-plugin: frozen MEMORY.md heading overview per session
+// - opencode-interrupt-plugin: interrupt queued messages at step boundaries
+// - subagent-rate-limit-plugin: aborts only task subagents after rate limits
+// - 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 { memoryOverviewPlugin } from './memory-overview-plugin.js';
+export { interruptOpencodeSessionOnUserMessage } from './opencode-interrupt-plugin.js';
+export { anthropicAuthPlugin } from './anthropic-auth-plugin.js';
+export { imageOptimizerPlugin } from './image-optimizer-plugin.js';
+export { subagentRateLimitPlugin } from './subagent-rate-limit-plugin.js';
+export { kittyGraphicsPlugin } from 'kitty-graphics-agent';
+export { injectionGuardInternal as injectionGuard } from 'opencode-injection-guard';

package/dist/otto-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/parse-permission-rules.test.js

@@ -0,0 +1,117 @@
+// Tests for parsePermissionRules() from opencode.ts
+import { describe, test, expect } from 'vitest';
+import { parsePermissionRules } from './opencode.js';
+describe('parsePermissionRules', () => {
+    test('simple tool:action format', () => {
+        expect(parsePermissionRules(['bash:deny'])).toMatchInlineSnapshot(`
+      [
+        {
+          "action": "deny",
+          "pattern": "*",
+          "permission": "bash",
+        },
+      ]
+    `);
+    });
+    test('multiple rules', () => {
+        expect(parsePermissionRules(['bash:deny', 'edit:deny', 'read:allow'])).toMatchInlineSnapshot(`
+      [
+        {
+          "action": "deny",
+          "pattern": "*",
+          "permission": "bash",
+        },
+        {
+          "action": "deny",
+          "pattern": "*",
+          "permission": "edit",
+        },
+        {
+          "action": "allow",
+          "pattern": "*",
+          "permission": "read",
+        },
+      ]
+    `);
+    });
+    test('tool:pattern:action format', () => {
+        expect(parsePermissionRules(['bash:git *:allow'])).toMatchInlineSnapshot(`
+      [
+        {
+          "action": "allow",
+          "pattern": "git *",
+          "permission": "bash",
+        },
+      ]
+    `);
+    });
+    test('wildcard permission', () => {
+        expect(parsePermissionRules(['*:deny'])).toMatchInlineSnapshot(`
+      [
+        {
+          "action": "deny",
+          "pattern": "*",
+          "permission": "*",
+        },
+      ]
+    `);
+    });
+    test('case-insensitive action', () => {
+        expect(parsePermissionRules(['bash:DENY', 'edit:Allow'])).toMatchInlineSnapshot(`
+      [
+        {
+          "action": "deny",
+          "pattern": "*",
+          "permission": "bash",
+        },
+        {
+          "action": "allow",
+          "pattern": "*",
+          "permission": "edit",
+        },
+      ]
+    `);
+    });
+    test('trims whitespace', () => {
+        expect(parsePermissionRules([' bash : deny '])).toMatchInlineSnapshot(`
+      [
+        {
+          "action": "deny",
+          "pattern": "*",
+          "permission": "bash",
+        },
+      ]
+    `);
+    });
+    test('skips invalid entries', () => {
+        expect(parsePermissionRules(['', 'bash', 'bash:invalid', ':deny'])).toMatchInlineSnapshot(`[]`);
+    });
+    test('handles non-array input defensively', () => {
+        expect(parsePermissionRules(undefined)).toMatchInlineSnapshot(`[]`);
+        expect(parsePermissionRules(null)).toMatchInlineSnapshot(`[]`);
+        expect(parsePermissionRules('bash:deny')).toMatchInlineSnapshot(`[]`);
+        expect(parsePermissionRules(123)).toMatchInlineSnapshot(`[]`);
+    });
+    test('handles non-string array items', () => {
+        expect(parsePermissionRules([123, null, 'bash:deny'])).toMatchInlineSnapshot(`
+      [
+        {
+          "action": "deny",
+          "pattern": "*",
+          "permission": "bash",
+        },
+      ]
+    `);
+    });
+    test('ask action', () => {
+        expect(parsePermissionRules(['webfetch:ask'])).toMatchInlineSnapshot(`
+      [
+        {
+          "action": "ask",
+          "pattern": "*",
+          "permission": "webfetch",
+        },
+      ]
+    `);
+    });
+});

package/dist/patch-text-parser.js

@@ -0,0 +1,97 @@
+// Shared apply_patch text parsing utilities.
+// Used by diff-patch-plugin.ts (file path extraction for snapshots) and
+// message-formatting.ts (per-file addition/deletion counts for Discord display).
+//
+// The apply_patch tool uses three path header formats:
+//   *** Add File: path    — new file
+//   *** Update File: path — existing file edit
+//   *** Delete File: path — file removal
+//   *** Move to: path     — rename destination
+//   --- a/path / +++ b/path — unified diff headers (fallback)
+/**
+ * Extract all file paths referenced in a patchText string.
+ * Handles custom apply_patch headers, move targets, and unified diff headers.
+ * Returns deduplicated paths.
+ */
+export function extractPatchFilePaths(patchText) {
+    const custom = [
+        ...patchText.matchAll(/^\*\*\* (?:Add|Update|Delete) File:\s+(.+)$/gm),
+    ].map((m) => {
+        return (m[1] ?? '').trim();
+    });
+    const moved = [
+        ...patchText.matchAll(/^\*\*\* Move to:\s+(.+)$/gm),
+    ].map((m) => {
+        return (m[1] ?? '').trim();
+    });
+    const unified = [
+        ...patchText.matchAll(/^(?:---|\+\+\+) [ab]\/(.+)$/gm),
+    ].map((m) => {
+        return (m[1] ?? '').trim();
+    });
+    const all = [...custom, ...moved, ...unified].filter(Boolean);
+    return all.filter((v, i, a) => {
+        return a.indexOf(v) === i;
+    });
+}
+/**
+ * Parse a patchText string and count additions/deletions per file.
+ * Patch format uses `*** Add File:`, `*** Update File:`, `*** Delete File:` headers,
+ * with diff lines prefixed by `+` (addition) or `-` (deletion) inside `@@` hunks.
+ */
+export function parsePatchFileCounts(patchText) {
+    const counts = new Map();
+    const lines = patchText.split('\n');
+    let currentFile = '';
+    let currentType = '';
+    let inHunk = false;
+    for (const line of lines) {
+        const addMatch = line.match(/^\*\*\* Add File:\s*(.+)/);
+        const updateMatch = line.match(/^\*\*\* Update File:\s*(.+)/);
+        const deleteMatch = line.match(/^\*\*\* Delete File:\s*(.+)/);
+        if (addMatch || updateMatch || deleteMatch) {
+            const match = addMatch || updateMatch || deleteMatch;
+            currentFile = (match?.[1] ?? '').trim();
+            currentType = addMatch ? 'add' : updateMatch ? 'update' : 'delete';
+            counts.set(currentFile, { additions: 0, deletions: 0 });
+            inHunk = false;
+            continue;
+        }
+        if (line.startsWith('@@')) {
+            inHunk = true;
+            continue;
+        }
+        if (line.startsWith('*** ')) {
+            inHunk = false;
+            continue;
+        }
+        if (!currentFile) {
+            continue;
+        }
+        const entry = counts.get(currentFile);
+        if (!entry) {
+            continue;
+        }
+        if (currentType === 'add') {
+            // all content lines in Add File are additions
+            if (line.length > 0 && !line.startsWith('*** ')) {
+                entry.additions++;
+            }
+        }
+        else if (currentType === 'delete') {
+            // all content lines in Delete File are deletions
+            if (line.length > 0 && !line.startsWith('*** ')) {
+                entry.deletions++;
+            }
+        }
+        else if (inHunk) {
+            if (line.startsWith('+')) {
+                entry.additions++;
+            }
+            else if (line.startsWith('-')) {
+                entry.deletions++;
+            }
+        }
+    }
+    return counts;
+}