@otto-assistant/otto 0.1.2 → 0.7.15

package/dist/markdown.test.js

@@ -0,0 +1,264 @@
+// Deterministic markdown export tests.
+// Uses the shared opencode server manager with the deterministic provider,
+// creates sessions with known content, and validates markdown output.
+// No dependency on machine-local session state.
+import fs from 'node:fs';
+import path from 'node:path';
+import url from 'node:url';
+import { test, expect, beforeAll, afterAll } from 'vitest';
+import * as errore from 'errore';
+import { buildDeterministicOpencodeConfig, } from 'opencode-deterministic-provider';
+import { ShareMarkdown, getCompactSessionContext } from './markdown.js';
+import { setDataDir } from './config.js';
+import { initializeOpencodeForDirectory, getOpencodeClient, stopOpencodeServer } from './opencode.js';
+import { cleanupTestSessions, initTestGitRepo } from './test-utils.js';
+const ROOT = path.resolve(process.cwd(), 'tmp', 'markdown-test');
+function createRunDirectories() {
+    fs.mkdirSync(ROOT, { recursive: true });
+    const dataDir = fs.mkdtempSync(path.join(ROOT, 'data-'));
+    const projectDirectory = path.join(ROOT, 'project');
+    fs.mkdirSync(projectDirectory, { recursive: true });
+    initTestGitRepo(projectDirectory);
+    return { dataDir, projectDirectory };
+}
+function createMatchers() {
+    const helloMatcher = {
+        id: 'hello-reply',
+        priority: 100,
+        when: { latestUserTextIncludes: 'hello markdown test' },
+        then: {
+            parts: [
+                { type: 'stream-start', warnings: [] },
+                { type: 'text-start', id: 'hello-text' },
+                { type: 'text-delta', id: 'hello-text', delta: 'Hello! This is a deterministic markdown test response.' },
+                { type: 'text-end', id: 'hello-text' },
+                { type: 'finish', finishReason: 'stop', usage: { inputTokens: 10, outputTokens: 8, totalTokens: 18 } },
+            ],
+        },
+    };
+    const defaultMatcher = {
+        id: 'default-reply',
+        priority: 1,
+        then: {
+            parts: [
+                { type: 'stream-start', warnings: [] },
+                { type: 'text-start', id: 'default-text' },
+                { type: 'text-delta', id: 'default-text', delta: 'ok' },
+                { type: 'text-end', id: 'default-text' },
+                { type: 'finish', finishReason: 'stop', usage: { inputTokens: 5, outputTokens: 1, totalTokens: 6 } },
+            ],
+        },
+    };
+    return [helloMatcher, defaultMatcher];
+}
+let client;
+let directories;
+let testStartTime;
+let sessionID;
+beforeAll(async () => {
+    testStartTime = Date.now();
+    directories = createRunDirectories();
+    setDataDir(directories.dataDir);
+    const providerNpm = url
+        .pathToFileURL(path.resolve(process.cwd(), '..', 'opencode-deterministic-provider', 'src', 'index.ts'))
+        .toString();
+    const opencodeConfig = buildDeterministicOpencodeConfig({
+        providerName: 'deterministic-provider',
+        providerNpm,
+        model: 'deterministic-v2',
+        smallModel: 'deterministic-v2',
+        settings: {
+            strict: false,
+            matchers: createMatchers(),
+        },
+    });
+    fs.writeFileSync(path.join(directories.projectDirectory, 'opencode.json'), JSON.stringify(opencodeConfig, null, 2));
+    // Start the shared opencode server via otto's server manager
+    const getClient = await initializeOpencodeForDirectory(directories.projectDirectory);
+    if (getClient instanceof Error) {
+        throw getClient;
+    }
+    client = getClient();
+    // Create a session and send a known prompt
+    const createResult = await client.session.create({
+        directory: directories.projectDirectory,
+        title: 'Markdown Test Session',
+    });
+    sessionID = createResult.data.id;
+    // Send prompt and wait for completion (promptAsync returns immediately)
+    await client.session.promptAsync({
+        sessionID,
+        directory: directories.projectDirectory,
+        parts: [{ type: 'text', text: 'hello markdown test' }],
+    });
+    // Wait for assistant text parts to be fully written (not just message existence).
+    // The deterministic provider responds instantly but opencode writes parts
+    // asynchronously, so we must poll until non-empty text content appears.
+    // Under parallel test load the server is slower, so use generous timeouts.
+    const maxWait = 15_000;
+    const pollStart = Date.now();
+    while (Date.now() - pollStart < maxWait) {
+        const msgs = await client.session.messages({
+            sessionID,
+            directory: directories.projectDirectory,
+        });
+        const assistantMsg = msgs.data?.find((m) => m.info.role === 'assistant');
+        const hasTextParts = assistantMsg?.parts?.some((p) => {
+            return p.type === 'text' && p.text && !p.synthetic;
+        });
+        if (hasTextParts) {
+            // Extra wait for step-start and other parts to be flushed
+            await new Promise((resolve) => {
+                setTimeout(resolve, 500);
+            });
+            break;
+        }
+        await new Promise((resolve) => {
+            setTimeout(resolve, 200);
+        });
+    }
+}, 20_000);
+afterAll(async () => {
+    if (directories) {
+        await cleanupTestSessions({
+            projectDirectory: directories.projectDirectory,
+            testStartTime,
+        });
+    }
+    await stopOpencodeServer();
+    if (directories) {
+        fs.rmSync(directories.dataDir, { recursive: true, force: true });
+    }
+}, 5_000);
+// Strip dynamic parts (timestamps, durations, branch names) for stable assertions
+function normalizeMarkdown(md) {
+    return md
+        // Normalize "Completed in Xs" to a fixed string
+        .replace(/\*Completed in [\d.]+[ms]+\*/g, '*Completed in Xs*')
+        // Normalize "Duration: Xs" tool timing
+        .replace(/\*Duration: [\d.]+[ms]+\*/g, '*Duration: Xs*')
+        // Normalize ISO dates in session info
+        .replace(/\*\*Created\*\*: .+/g, '**Created**: <date>')
+        .replace(/\*\*Updated\*\*: .+/g, '**Updated**: <date>')
+        // Normalize opencode version
+        .replace(/\*\*OpenCode Version\*\*: v[\d.]+.*/g, '**OpenCode Version**: v<version>')
+        // Strip git branch context injected by opencode into user messages
+        .replace(/\[Current branch: [^\]]+\]\n?\n?/g, '')
+        .replace(/\[current git branch is [^\]]+\]\n?\n?/g, '')
+        .replace(/\[warning: repository is in detached HEAD[^\]]*\]\n?\n?/g, '');
+}
+test('generate markdown with system info', async () => {
+    const exporter = new ShareMarkdown(client);
+    const markdownResult = await exporter.generate({
+        sessionID,
+        includeSystemInfo: true,
+    });
+    expect(errore.isOk(markdownResult)).toBe(true);
+    const markdown = errore.unwrap(markdownResult);
+    expect(markdown).toContain('# Markdown Test Session');
+    expect(markdown).toContain('## Session Information');
+    expect(markdown).toContain('## Conversation');
+    expect(markdown).toContain('### 👤 User');
+    expect(markdown).toContain('hello markdown test');
+    expect(markdown).toContain('### 🤖 Assistant');
+    expect(markdown).toContain('Hello! This is a deterministic markdown test response.');
+    expect(markdown).toContain('**Started using deterministic-provider/deterministic-v2**');
+    const normalized = normalizeMarkdown(markdown);
+    expect(normalized).toMatchInlineSnapshot(`
+    "# Markdown Test Session
+
+    ## Session Information
+
+    - **Created**: <date>
+    - **Updated**: <date>
+    - **OpenCode Version**: v<version>
+
+    ## Conversation
+
+    ### 👤 User
+
+    hello markdown test
+
+
+    ### 🤖 Assistant (deterministic-v2)
+
+    **Started using deterministic-provider/deterministic-v2**
+
+    Hello! This is a deterministic markdown test response.
+
+
+    *Completed in Xs*
+    "
+  `);
+});
+test('generate markdown without system info', async () => {
+    const exporter = new ShareMarkdown(client);
+    const markdown = await exporter.generate({
+        sessionID,
+        includeSystemInfo: false,
+    });
+    expect(errore.isOk(markdown)).toBe(true);
+    const md = errore.unwrap(markdown);
+    expect(md).toContain('# Markdown Test Session');
+    expect(md).not.toContain('## Session Information');
+    expect(md).toContain('## Conversation');
+    const normalized = normalizeMarkdown(md);
+    expect(normalized).toMatchInlineSnapshot(`
+    "# Markdown Test Session
+
+    ## Conversation
+
+    ### 👤 User
+
+    hello markdown test
+
+
+    ### 🤖 Assistant (deterministic-v2)
+
+    **Started using deterministic-provider/deterministic-v2**
+
+    Hello! This is a deterministic markdown test response.
+
+
+    *Completed in Xs*
+    "
+  `);
+});
+test('error handling for non-existent session', async () => {
+    const exporter = new ShareMarkdown(client);
+    const badSessionID = 'ses_nonexistent_' + Date.now();
+    const result = await exporter.generate({ sessionID: badSessionID });
+    expect(result).toBeInstanceOf(Error);
+    expect(result.message).toContain(`Session ${badSessionID} not found`);
+});
+test('getCompactSessionContext generates compact format', async () => {
+    const contextResult = await getCompactSessionContext({
+        client,
+        sessionId: sessionID,
+        includeSystemPrompt: false,
+        maxMessages: 10,
+    });
+    expect(errore.isOk(contextResult)).toBe(true);
+    const context = errore.unwrap(contextResult);
+    expect(context).toBeTruthy();
+    // User text may be prefixed with branch context injected by opencode
+    expect(context).toContain('hello markdown test');
+    expect(context).toContain('[User]:');
+    expect(context).toContain('[Assistant]:');
+    expect(context).toContain('Hello! This is a deterministic markdown test response.');
+    expect(context).not.toContain('[System Prompt]');
+});
+test('generate markdown with lastAssistantOnly', async () => {
+    const exporter = new ShareMarkdown(client);
+    const markdownResult = await exporter.generate({
+        sessionID,
+        lastAssistantOnly: true,
+    });
+    expect(errore.isOk(markdownResult)).toBe(true);
+    const markdown = errore.unwrap(markdownResult);
+    // lastAssistantOnly should NOT include title header or conversation section header
+    expect(markdown).not.toContain('# Markdown Test Session');
+    expect(markdown).not.toContain('## Conversation');
+    // Should contain the assistant response
+    expect(markdown).toContain('Hello! This is a deterministic markdown test response.');
+});

package/dist/memory-overview-plugin.js

@@ -0,0 +1,128 @@
+// OpenCode plugin that snapshots the MEMORY.md heading overview once per
+// session and injects that frozen snapshot on the first real user message.
+// The snapshot is cached by session ID so later MEMORY.md edits do not change
+// the prompt for the same session and do not invalidate OpenCode's cache.
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import * as errore from 'errore';
+import { createPluginLogger, formatPluginErrorWithStack, setPluginLogFilePath, } from './plugin-logger.js';
+import { condenseMemoryMd } from './condense-memory.js';
+import { initSentry, notifyError } from './sentry.js';
+const logger = createPluginLogger('OPENCODE');
+function createSessionState() {
+    return {
+        hasFrozenOverview: false,
+        frozenOverviewText: null,
+        injected: false,
+    };
+}
+function buildMemoryOverviewReminder({ condensed }) {
+    // Trailing newline so this synthetic part does not fuse with the next text
+    // part when the model concatenates message parts.
+    return `<system-reminder>Project memory from MEMORY.md (condensed table of contents, line numbers shown):\n${condensed}\nOnly headings are shown above — section bodies are hidden. Use Grep to search MEMORY.md for specific topics, or Read with offset and limit to read a section's content. When writing to MEMORY.md, keep titles concise (under 10 words) and content brief (2-3 sentences max). Only track non-obvious learnings that prevent future mistakes and are not already documented in code comments or AGENTS.md. Do not duplicate information that is self-evident from the code.</system-reminder>\n`;
+}
+async function freezeMemoryOverview({ directory, state, }) {
+    if (state.hasFrozenOverview) {
+        return state.frozenOverviewText;
+    }
+    const memoryPath = path.join(directory, 'MEMORY.md');
+    const memoryContentResult = await fs.promises.readFile(memoryPath, 'utf-8').catch(() => {
+        return null;
+    });
+    if (!memoryContentResult) {
+        state.hasFrozenOverview = true;
+        state.frozenOverviewText = null;
+        return null;
+    }
+    const condensed = condenseMemoryMd(memoryContentResult);
+    state.hasFrozenOverview = true;
+    state.frozenOverviewText = buildMemoryOverviewReminder({ condensed });
+    return state.frozenOverviewText;
+}
+const memoryOverviewPlugin = async ({ directory }) => {
+    initSentry();
+    const dataDir = process.env.OTTO_DATA_DIR;
+    if (dataDir) {
+        setPluginLogFilePath(dataDir);
+    }
+    const sessions = new Map();
+    function getOrCreateSessionState({ sessionID }) {
+        const existing = sessions.get(sessionID);
+        if (existing) {
+            return existing;
+        }
+        const state = createSessionState();
+        sessions.set(sessionID, state);
+        return state;
+    }
+    return {
+        'chat.message': async (input, output) => {
+            const result = await errore.tryAsync({
+                try: async () => {
+                    const state = getOrCreateSessionState({ sessionID: input.sessionID });
+                    if (state.injected) {
+                        return;
+                    }
+                    const firstPart = output.parts.find((part) => {
+                        if (part.type !== 'text') {
+                            return true;
+                        }
+                        return part.synthetic !== true;
+                    });
+                    if (!firstPart || firstPart.type !== 'text' || firstPart.text.trim().length === 0) {
+                        return;
+                    }
+                    const overviewText = await freezeMemoryOverview({ directory, state });
+                    state.injected = true;
+                    if (!overviewText) {
+                        return;
+                    }
+                    output.parts.push({
+                        id: `prt_${crypto.randomUUID()}`,
+                        sessionID: input.sessionID,
+                        messageID: firstPart.messageID,
+                        type: 'text',
+                        text: overviewText,
+                        synthetic: true,
+                    });
+                },
+                catch: (error) => {
+                    return new Error('memory overview chat.message hook failed', {
+                        cause: error,
+                    });
+                },
+            });
+            if (!(result instanceof Error)) {
+                return;
+            }
+            logger.warn(`[memory-overview-plugin] ${formatPluginErrorWithStack(result)}`);
+            void notifyError(result, 'memory overview plugin chat.message hook failed');
+        },
+        event: async ({ event }) => {
+            const result = await errore.tryAsync({
+                try: async () => {
+                    if (event.type !== 'session.deleted') {
+                        return;
+                    }
+                    const id = event.properties?.info?.id;
+                    if (!id) {
+                        return;
+                    }
+                    sessions.delete(id);
+                },
+                catch: (error) => {
+                    return new Error('memory overview event hook failed', {
+                        cause: error,
+                    });
+                },
+            });
+            if (!(result instanceof Error)) {
+                return;
+            }
+            logger.warn(`[memory-overview-plugin] ${formatPluginErrorWithStack(result)}`);
+            void notifyError(result, 'memory overview plugin event hook failed');
+        },
+    };
+};
+export { memoryOverviewPlugin };

package/dist/message-finish-field.e2e.test.js

@@ -0,0 +1,168 @@
+// E2e test verifying that the opencode server populates the `finish` field
+// on assistant messages. This field is critical for otto's footer logic:
+// isAssistantMessageNaturalCompletion checks `message.finish !== 'tool-calls'`
+// to suppress footers on intermediate tool-call steps.
+// When `finish` is missing/null, every completed assistant message gets a
+// spurious footer, breaking multi-step tool chains (16 test failures).
+//
+// Direct SDK test — no Discord layer needed since this is a server-level bug.
+import fs from 'node:fs';
+import path from 'node:path';
+import url from 'node:url';
+import { test, expect, beforeAll, afterAll } from 'vitest';
+import { buildDeterministicOpencodeConfig, } from 'opencode-deterministic-provider';
+import { setDataDir } from './config.js';
+import { initializeOpencodeForDirectory, stopOpencodeServer } from './opencode.js';
+import { cleanupTestSessions, initTestGitRepo } from './test-utils.js';
+const ROOT = path.resolve(process.cwd(), 'tmp', 'finish-field-e2e');
+function createRunDirectories() {
+    fs.mkdirSync(ROOT, { recursive: true });
+    const dataDir = fs.mkdtempSync(path.join(ROOT, 'data-'));
+    const projectDirectory = path.join(ROOT, 'project');
+    fs.mkdirSync(projectDirectory, { recursive: true });
+    initTestGitRepo(projectDirectory);
+    return { dataDir, projectDirectory };
+}
+function createMatchers() {
+    // Tool-call step: finish="tool-calls"
+    const toolCallMatcher = {
+        id: 'finish-tool-call',
+        priority: 20,
+        when: {
+            lastMessageRole: 'user',
+            latestUserTextIncludes: 'FINISH_FIELD_TOOLCALL',
+        },
+        then: {
+            parts: [
+                { type: 'stream-start', warnings: [] },
+                { type: 'text-start', id: 'ft' },
+                { type: 'text-delta', id: 'ft', delta: 'calling tool' },
+                { type: 'text-end', id: 'ft' },
+                {
+                    type: 'tool-call',
+                    toolCallId: 'finish-bash',
+                    toolName: 'bash',
+                    input: JSON.stringify({ command: 'echo ok', description: 'test' }),
+                },
+                {
+                    type: 'finish',
+                    finishReason: 'tool-calls',
+                    usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+                },
+            ],
+        },
+    };
+    // Follow-up after tool result: finish="stop"
+    const followupMatcher = {
+        id: 'finish-followup',
+        priority: 21,
+        when: {
+            lastMessageRole: 'tool',
+            latestUserTextIncludes: 'FINISH_FIELD_TOOLCALL',
+        },
+        then: {
+            parts: [
+                { type: 'stream-start', warnings: [] },
+                { type: 'text-start', id: 'ff' },
+                { type: 'text-delta', id: 'ff', delta: 'tool done' },
+                { type: 'text-end', id: 'ff' },
+                {
+                    type: 'finish',
+                    finishReason: 'stop',
+                    usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+                },
+            ],
+        },
+    };
+    return [toolCallMatcher, followupMatcher];
+}
+let client;
+let directories;
+let testStartTime;
+beforeAll(async () => {
+    testStartTime = Date.now();
+    directories = createRunDirectories();
+    setDataDir(directories.dataDir);
+    const providerNpm = url
+        .pathToFileURL(path.resolve(process.cwd(), '..', 'opencode-deterministic-provider', 'src', 'index.ts'))
+        .toString();
+    const opencodeConfig = buildDeterministicOpencodeConfig({
+        providerName: 'deterministic-provider',
+        providerNpm,
+        model: 'deterministic-v2',
+        smallModel: 'deterministic-v2',
+        settings: { strict: false, matchers: createMatchers() },
+    });
+    fs.writeFileSync(path.join(directories.projectDirectory, 'opencode.json'), JSON.stringify(opencodeConfig, null, 2));
+    const getClient = await initializeOpencodeForDirectory(directories.projectDirectory);
+    if (getClient instanceof Error) {
+        throw getClient;
+    }
+    client = getClient();
+}, 20_000);
+afterAll(async () => {
+    await cleanupTestSessions({
+        projectDirectory: directories.projectDirectory,
+        testStartTime,
+    });
+    await stopOpencodeServer();
+}, 5_000);
+test('tool-call step has finish="tool-calls", follow-up has finish="stop"', async () => {
+    const session = await client.session.create({
+        directory: directories.projectDirectory,
+        title: 'finish-field-test',
+    });
+    const sessionID = session.data.id;
+    await client.session.promptAsync({
+        sessionID,
+        directory: directories.projectDirectory,
+        parts: [{ type: 'text', text: 'FINISH_FIELD_TOOLCALL' }],
+    });
+    // Poll until we have 2 completed assistant messages (tool-call + follow-up)
+    const maxWait = 8_000;
+    const pollStart = Date.now();
+    let completedAssistants = [];
+    while (Date.now() - pollStart < maxWait) {
+        const msgs = await client.session.messages({
+            sessionID,
+            directory: directories.projectDirectory,
+        });
+        completedAssistants = (msgs.data || [])
+            .filter((m) => {
+            return m.info.role === 'assistant' && m.info.time.completed;
+        })
+            .map((m) => {
+            return {
+                finish: m.info.finish ?? null,
+                partTypes: m.parts.map((p) => { return p.type; }),
+            };
+        });
+        if (completedAssistants.length >= 2) {
+            break;
+        }
+        await new Promise((resolve) => { setTimeout(resolve, 100); });
+    }
+    // Snapshot completed assistant messages — finish should NOT be null
+    expect(completedAssistants).toMatchInlineSnapshot(`
+    [
+      {
+        "finish": "tool-calls",
+        "partTypes": [
+          "step-start",
+          "text",
+          "step-finish",
+        ],
+      },
+      {
+        "finish": "stop",
+        "partTypes": [
+          "step-start",
+          "text",
+          "step-finish",
+        ],
+      },
+    ]
+  `);
+    const finishes = completedAssistants.map((m) => { return m.finish; });
+    expect(finishes).toEqual(['tool-calls', 'stop']);
+}, 5_000);