@otto-assistant/otto 0.1.2 → 0.7.15

package/dist/context-awareness-plugin.js

@@ -0,0 +1,340 @@
+// OpenCode plugin that injects synthetic message parts for context awareness:
+// - Git branch / detached HEAD changes
+// - Working directory (pwd) changes (e.g. after /new-worktree mid-session)
+// - MEMORY.md reminder after a large assistant reply
+// - Onboarding tutorial instructions (when TUTORIAL_WELCOME_TEXT detected)
+//
+// Synthetic parts are hidden from the TUI but sent to the model, keeping it
+// aware of context changes without cluttering the UI.
+//
+// State design: all per-session mutable state is encapsulated in a single
+// SessionState object per session ID. One Map, one delete() on cleanup.
+// Decision logic is extracted into pure functions that take state + input
+// and return whether to inject — making them testable without mocking.
+//
+// Exported from otto-opencode-plugin.ts — each export is treated as a separate
+// plugin by OpenCode's plugin loader.
+import crypto from 'node:crypto';
+import * as errore from 'errore';
+import { createPluginLogger, formatPluginErrorWithStack, setPluginLogFilePath, } from './plugin-logger.js';
+import { setDataDir } from './config.js';
+import { initSentry, notifyError } from './sentry.js';
+import { execAsync } from './exec-async.js';
+import { ONBOARDING_TUTORIAL_INSTRUCTIONS, TUTORIAL_WELCOME_TEXT, } from './onboarding-tutorial.js';
+const logger = createPluginLogger('OPENCODE');
+// ── Pure derivation functions ────────────────────────────────────
+// These take state + fresh input and return whether to inject.
+// No side effects, no mutations — easy to test with fixtures.
+export function shouldInjectBranch({ previousGitState, currentGitState, }) {
+    if (!currentGitState) {
+        return { inject: false };
+    }
+    if (previousGitState && previousGitState.key === currentGitState.key) {
+        return { inject: false };
+    }
+    // Trailing newline so this synthetic part does not fuse with the next text
+    // part when the model concatenates message parts.
+    const base = currentGitState.warning || `\n[current git branch is ${currentGitState.label}]`;
+    return { inject: true, text: `${base}\n` };
+}
+export function shouldInjectPwd({ currentDir, previousDir, announcedDir, }) {
+    if (announcedDir === currentDir) {
+        return { inject: false };
+    }
+    const priorDirectory = announcedDir || previousDir;
+    if (!priorDirectory || priorDirectory === currentDir) {
+        return { inject: false };
+    }
+    return {
+        inject: true,
+        // Trailing newline so this synthetic part does not fuse with the next text
+        // part when the model concatenates message parts.
+        text: `\n[working directory changed (cwd / pwd has changed). ` +
+            `The user expects you to edit files in the new cwd. ` +
+            `Previous folder (DO NOT TOUCH): ${priorDirectory}. ` +
+            `New folder (new cwd / pwd, edit files here): ${currentDir}. ` +
+            `You MUST read, write, and edit files only under the new folder ${currentDir}. ` +
+            `You MUST NOT read, write, or edit any files under the previous folder ${priorDirectory} — ` +
+            `that folder is a separate checkout and the user or another agent may be actively working there, ` +
+            `so writing to it would override their unrelated changes.]\n`,
+    };
+}
+const MEMORY_REMINDER_OUTPUT_TOKENS = 12_000;
+const GIT_STATE_CACHE_TTL_MS = 2_000;
+export function shouldInjectMemoryReminderFromLatestAssistant({ lastMemoryReminderAssistantMessageId, latestAssistantMessage, threshold = MEMORY_REMINDER_OUTPUT_TOKENS, }) {
+    if (!latestAssistantMessage) {
+        return { inject: false };
+    }
+    if (latestAssistantMessage.role !== 'assistant') {
+        return { inject: false };
+    }
+    if (typeof latestAssistantMessage.time?.completed !== 'number') {
+        return { inject: false };
+    }
+    if (!latestAssistantMessage.tokens) {
+        return { inject: false };
+    }
+    if (lastMemoryReminderAssistantMessageId === latestAssistantMessage.id) {
+        return { inject: false };
+    }
+    const outputTokens = Math.max(0, latestAssistantMessage.tokens.output + latestAssistantMessage.tokens.reasoning);
+    if (outputTokens < threshold) {
+        return { inject: false };
+    }
+    return { inject: true, assistantMessageId: latestAssistantMessage.id };
+}
+export function shouldInjectTutorial({ alreadyInjected, parts, }) {
+    if (alreadyInjected) {
+        return false;
+    }
+    return parts.some((part) => {
+        return part.type === 'text' && part.text?.includes(TUTORIAL_WELCOME_TEXT);
+    });
+}
+// ── Impure helpers (I/O) ─────────────────────────────────────────
+async function resolveGitState({ directory, }) {
+    const branchResult = await errore.tryAsync(() => {
+        return execAsync('git symbolic-ref --short HEAD', { cwd: directory });
+    });
+    if (!(branchResult instanceof Error)) {
+        const branch = branchResult.stdout.trim();
+        if (branch) {
+            return {
+                key: `branch:${branch}`,
+                kind: 'branch',
+                label: branch,
+                warning: null,
+            };
+        }
+    }
+    const shaResult = await errore.tryAsync(() => {
+        return execAsync('git rev-parse --short HEAD', { cwd: directory });
+    });
+    if (shaResult instanceof Error) {
+        return null;
+    }
+    const shortSha = shaResult.stdout.trim();
+    if (!shortSha) {
+        return null;
+    }
+    const superprojectResult = await errore.tryAsync(() => {
+        return execAsync('git rev-parse --show-superproject-working-tree', {
+            cwd: directory,
+        });
+    });
+    const superproject = superprojectResult instanceof Error ? '' : superprojectResult.stdout.trim();
+    if (superproject) {
+        return {
+            key: `detached-submodule:${shortSha}`,
+            kind: 'detached-submodule',
+            label: `detached submodule @ ${shortSha}`,
+            warning: `\n[warning: submodule is in detached HEAD at ${shortSha}. ` +
+                'create or switch to a branch before committing.]',
+        };
+    }
+    return {
+        key: `detached-head:${shortSha}`,
+        kind: 'detached-head',
+        label: `detached HEAD @ ${shortSha}`,
+        warning: `\n[warning: repository is in detached HEAD at ${shortSha}. ` +
+            'create or switch to a branch before committing.]',
+    };
+}
+// ── Plugin ───────────────────────────────────────────────────────
+const contextAwarenessPlugin = async ({ directory }) => {
+    initSentry();
+    const dataDir = process.env.OTTO_DATA_DIR;
+    if (dataDir) {
+        setDataDir(dataDir);
+        setPluginLogFilePath(dataDir);
+    }
+    // Single Map for all per-session state. One entry per session, one
+    // delete on cleanup — no parallel Maps that can drift out of sync.
+    const sessions = new Map();
+    function getOrCreateSession(sessionID) {
+        const existing = sessions.get(sessionID);
+        if (existing) {
+            return existing;
+        }
+        const state = {
+            gitState: undefined,
+            gitStateDirectory: undefined,
+            gitStateCheckedAtMs: 0,
+            lastMemoryReminderAssistantMessageId: undefined,
+            latestAssistantMessage: undefined,
+            tutorialInjected: false,
+            resolvedDirectory: undefined,
+            announcedDirectory: undefined,
+        };
+        sessions.set(sessionID, state);
+        return state;
+    }
+    return {
+        'chat.message': async (input, output) => {
+            const hookResult = await errore.tryAsync({
+                try: async () => {
+                    const { sessionID } = input;
+                    const state = getOrCreateSession(sessionID);
+                    // -- Onboarding tutorial injection --
+                    // Runs before the non-synthetic text guard because the tutorial
+                    // marker (TUTORIAL_WELCOME_TEXT) can appear in synthetic/system
+                    // parts prepended by message-preprocessing.ts. The old separate
+                    // plugin had no such guard, so this preserves that behavior.
+                    const firstTextPart = output.parts.find((part) => {
+                        return part.type === 'text';
+                    });
+                    if (firstTextPart && shouldInjectTutorial({ alreadyInjected: state.tutorialInjected, parts: output.parts })) {
+                        state.tutorialInjected = true;
+                        output.parts.push({
+                            id: `prt_${crypto.randomUUID()}`,
+                            sessionID,
+                            messageID: firstTextPart.messageID,
+                            type: 'text',
+                            text: `<system-reminder>\n${ONBOARDING_TUTORIAL_INSTRUCTIONS}\n</system-reminder>\n`,
+                            synthetic: true,
+                        });
+                    }
+                    // -- Find first non-synthetic user text part --
+                    // All remaining injections (branch, pwd, memory, time gap) only
+                    // apply to real user messages, not empty or synthetic-only messages.
+                    const first = output.parts.find((part) => {
+                        if (part.type !== 'text') {
+                            return true;
+                        }
+                        return part.synthetic !== true;
+                    });
+                    if (!first || first.type !== 'text' || first.text.trim().length === 0) {
+                        return;
+                    }
+                    const messageID = first.messageID;
+                    const latestAssistantMessage = state.latestAssistantMessage;
+                    // The plugin request directory is the current directory Otto asked
+                    // OpenCode to operate on for this message. Keep the previous observed
+                    // directory in session state to detect cwd changes without SDK calls.
+                    const effectiveDirectory = directory;
+                    const previousDirectory = state.resolvedDirectory;
+                    state.resolvedDirectory = effectiveDirectory;
+                    // -- Branch / detached HEAD detection --
+                    // Avoid spawning git subprocesses on every turn in the same directory.
+                    // Refresh only on directory change or after a short TTL.
+                    const previousGitState = state.gitState;
+                    const now = Date.now();
+                    const shouldRefreshGitState = !state.gitState ||
+                        state.gitStateDirectory !== effectiveDirectory ||
+                        now - state.gitStateCheckedAtMs >= GIT_STATE_CACHE_TTL_MS;
+                    const gitState = shouldRefreshGitState
+                        ? await resolveGitState({ directory: effectiveDirectory })
+                        : state.gitState || null;
+                    if (shouldRefreshGitState) {
+                        state.gitState = gitState || undefined;
+                        state.gitStateDirectory = effectiveDirectory;
+                        state.gitStateCheckedAtMs = now;
+                    }
+                    // -- Working directory change detection --
+                    const pwdResult = shouldInjectPwd({
+                        currentDir: effectiveDirectory,
+                        previousDir: previousDirectory && previousDirectory !== effectiveDirectory
+                            ? previousDirectory
+                            : undefined,
+                        announcedDir: state.announcedDirectory,
+                    });
+                    if (pwdResult.inject) {
+                        state.announcedDirectory = effectiveDirectory;
+                        output.parts.push({
+                            id: `prt_${crypto.randomUUID()}`,
+                            sessionID,
+                            messageID,
+                            type: 'text',
+                            text: pwdResult.text,
+                            synthetic: true,
+                        });
+                    }
+                    const memoryReminder = shouldInjectMemoryReminderFromLatestAssistant({
+                        lastMemoryReminderAssistantMessageId: state.lastMemoryReminderAssistantMessageId,
+                        latestAssistantMessage,
+                    });
+                    if (memoryReminder.inject) {
+                        output.parts.push({
+                            id: `prt_${crypto.randomUUID()}`,
+                            sessionID,
+                            messageID,
+                            type: 'text',
+                            text: '<system-reminder>The previous assistant message was large. If the conversation had non-obvious learnings that prevent future mistakes and are not already in code comments or AGENTS.md, add them to MEMORY.md with concise titles and brief content (2-3 sentences max).</system-reminder>\n',
+                            synthetic: true,
+                        });
+                        state.lastMemoryReminderAssistantMessageId =
+                            memoryReminder.assistantMessageId;
+                    }
+                    // -- Branch injection (last synthetic part) --
+                    const branchResult = shouldInjectBranch({
+                        previousGitState,
+                        currentGitState: gitState,
+                    });
+                    if (branchResult.inject) {
+                        state.gitState = gitState;
+                        output.parts.push({
+                            id: `prt_${crypto.randomUUID()}`,
+                            sessionID,
+                            messageID,
+                            type: 'text',
+                            text: branchResult.text,
+                            synthetic: true,
+                        });
+                    }
+                },
+                catch: (error) => {
+                    return new Error('context-awareness chat.message hook failed', { cause: error });
+                },
+            });
+            if (hookResult instanceof Error) {
+                logger.warn(`[context-awareness-plugin] ${formatPluginErrorWithStack(hookResult)}`);
+                void notifyError(hookResult, 'context-awareness plugin chat.message hook failed');
+            }
+        },
+        // Keep session-local assistant metadata updated from event stream and
+        // clean up state when sessions are deleted.
+        event: async ({ event }) => {
+            const eventResult = await errore.tryAsync({
+                try: async () => {
+                    if (event.type === 'message.updated') {
+                        const info = event.properties?.info;
+                        if (!info || info.role !== 'assistant' || typeof info.id !== 'string') {
+                            return;
+                        }
+                        const infoWithSession = info;
+                        const sessionID = typeof infoWithSession.sessionID === 'string'
+                            ? infoWithSession.sessionID
+                            : undefined;
+                        if (!sessionID) {
+                            return;
+                        }
+                        const state = getOrCreateSession(sessionID);
+                        state.latestAssistantMessage = {
+                            id: info.id,
+                            role: info.role,
+                            time: info.time,
+                            tokens: info.tokens,
+                        };
+                        return;
+                    }
+                    if (event.type !== 'session.deleted') {
+                        return;
+                    }
+                    const id = event.properties?.info?.id;
+                    if (!id) {
+                        return;
+                    }
+                    sessions.delete(id);
+                },
+                catch: (error) => {
+                    return new Error('context-awareness event hook failed', { cause: error });
+                },
+            });
+            if (eventResult instanceof Error) {
+                logger.warn(`[context-awareness-plugin] ${formatPluginErrorWithStack(eventResult)}`);
+                void notifyError(eventResult, 'context-awareness plugin event hook failed');
+            }
+        },
+    };
+};
+export { contextAwarenessPlugin };

package/dist/context-awareness-plugin.test.js

@@ -0,0 +1,126 @@
+// Tests for context-awareness directory switch reminders.
+import { describe, expect, test } from 'vitest';
+import { shouldInjectPwd, shouldInjectMemoryReminderFromLatestAssistant, } from './context-awareness-plugin.js';
+describe('shouldInjectPwd', () => {
+    test('does not inject when current directory matches announced directory', () => {
+        const result = shouldInjectPwd({
+            currentDir: '/repo/worktree',
+            previousDir: '/repo/main',
+            announcedDir: '/repo/worktree',
+        });
+        expect(result).toMatchInlineSnapshot(`
+      {
+        "inject": false,
+      }
+    `);
+    });
+    test('does not inject without a previous directory to warn about', () => {
+        const result = shouldInjectPwd({
+            currentDir: '/repo/worktree',
+            previousDir: undefined,
+            announcedDir: undefined,
+        });
+        expect(result).toMatchInlineSnapshot(`
+      {
+        "inject": false,
+      }
+    `);
+    });
+    test('names previous and current directories in the correct order', () => {
+        const result = shouldInjectPwd({
+            currentDir: '/repo/worktree',
+            previousDir: '/repo/main',
+            announcedDir: undefined,
+        });
+        expect(result).toMatchInlineSnapshot(`
+      {
+        "inject": true,
+        "text": "
+      [working directory changed (cwd / pwd has changed). The user expects you to edit files in the new cwd. Previous folder (DO NOT TOUCH): /repo/main. New folder (new cwd / pwd, edit files here): /repo/worktree. You MUST read, write, and edit files only under the new folder /repo/worktree. You MUST NOT read, write, or edit any files under the previous folder /repo/main — that folder is a separate checkout and the user or another agent may be actively working there, so writing to it would override their unrelated changes.]
+      ",
+      }
+    `);
+    });
+    test('prefers the last announced directory as the previous directory', () => {
+        const result = shouldInjectPwd({
+            currentDir: '/repo/worktree-b',
+            previousDir: '/repo/main',
+            announcedDir: '/repo/worktree-a',
+        });
+        expect(result).toMatchInlineSnapshot(`
+      {
+        "inject": true,
+        "text": "
+      [working directory changed (cwd / pwd has changed). The user expects you to edit files in the new cwd. Previous folder (DO NOT TOUCH): /repo/worktree-a. New folder (new cwd / pwd, edit files here): /repo/worktree-b. You MUST read, write, and edit files only under the new folder /repo/worktree-b. You MUST NOT read, write, or edit any files under the previous folder /repo/worktree-a — that folder is a separate checkout and the user or another agent may be actively working there, so writing to it would override their unrelated changes.]
+      ",
+      }
+    `);
+    });
+});
+describe('shouldInjectMemoryReminderFromLatestAssistant', () => {
+    test('does not trigger before threshold', () => {
+        const result = shouldInjectMemoryReminderFromLatestAssistant({
+            latestAssistantMessage: {
+                id: 'msg_asst_1',
+                role: 'assistant',
+                time: { completed: 1 },
+                tokens: {
+                    input: 1_000,
+                    output: 3_000,
+                    reasoning: 500,
+                    cache: { read: 0, write: 0 },
+                },
+            },
+            threshold: 10_000,
+        });
+        expect(result).toMatchInlineSnapshot(`
+      {
+        "inject": false,
+      }
+    `);
+    });
+    test('triggers when latest assistant message exceeds threshold', () => {
+        const result = shouldInjectMemoryReminderFromLatestAssistant({
+            latestAssistantMessage: {
+                id: 'msg_asst_2',
+                role: 'assistant',
+                time: { completed: 2 },
+                tokens: {
+                    input: 2_000,
+                    output: 2_200,
+                    reasoning: 400,
+                    cache: { read: 0, write: 0 },
+                },
+            },
+            threshold: 2_000,
+        });
+        expect(result).toMatchInlineSnapshot(`
+      {
+        "assistantMessageId": "msg_asst_2",
+        "inject": true,
+      }
+    `);
+    });
+    test('does not trigger again for the same reminded assistant message', () => {
+        const result = shouldInjectMemoryReminderFromLatestAssistant({
+            lastMemoryReminderAssistantMessageId: 'msg_asst_3',
+            latestAssistantMessage: {
+                id: 'msg_asst_3',
+                role: 'assistant',
+                time: { completed: 3 },
+                tokens: {
+                    input: 2_000,
+                    output: 2_200,
+                    reasoning: 400,
+                    cache: { read: 0, write: 0 },
+                },
+            },
+            threshold: 10_000,
+        });
+        expect(result).toMatchInlineSnapshot(`
+      {
+        "inject": false,
+      }
+    `);
+    });
+});

package/dist/critique-utils.js

@@ -0,0 +1,95 @@
+// Shared utilities for invoking the critique CLI and parsing its JSON output.
+// Used by /diff command and footer diff link uploads.
+import { execAsync } from './worktrees.js';
+import { createLogger, LogPrefix } from './logger.js';
+const logger = createLogger(LogPrefix.DIFF);
+const CRITIQUE_TIMEOUT_MS = 30_000;
+/**
+ * Shell-quote a string by wrapping in single quotes and escaping embedded
+ * single quotes. Prevents injection when interpolating into shell commands.
+ */
+function shellQuote(s) {
+    return `'${s.replace(/'/g, "'\\''")}'`;
+}
+/**
+ * Parse critique --json output. Critique prints progress to stderr and JSON
+ * to stdout. The JSON line contains { url, id } on success or { error } on
+ * failure. We scan all lines for the first valid JSON object with a url or
+ * error field, falling back to searching for a critique.work URL in the raw
+ * output.
+ */
+export function parseCritiqueOutput(output) {
+    const lines = output.trim().split('\n');
+    for (const line of lines) {
+        if (!line.startsWith('{')) {
+            continue;
+        }
+        try {
+            const parsed = JSON.parse(line);
+            if (parsed.error) {
+                return { error: parsed.error };
+            }
+            if (parsed.url && parsed.id) {
+                return { url: parsed.url, id: parsed.id };
+            }
+        }
+        catch {
+            // not valid JSON, try next line
+        }
+    }
+    // Fallback: try to find a URL in the raw output
+    const urlMatch = output.match(/https?:\/\/critique\.work\/[^\s]+/);
+    if (urlMatch) {
+        const url = urlMatch[0];
+        // Extract ID from URL path: /v/{id}
+        const idMatch = url.match(/\/v\/([a-f0-9]+)/);
+        const id = idMatch?.[1];
+        if (id) {
+            return { url, id };
+        }
+        // URL without parseable id — return as error so callers don't build
+        // broken OG image URLs from an empty id
+        return { error: url };
+    }
+    return undefined;
+}
+/**
+ * Run critique on the current git working tree diff and return the result.
+ * Used by the /diff slash command.
+ */
+export async function uploadGitDiffViaCritique({ title, cwd, }) {
+    try {
+        const { stdout, stderr } = await execAsync(`critique --web ${shellQuote(title)} --json`, { cwd, timeout: CRITIQUE_TIMEOUT_MS });
+        return parseCritiqueOutput(stdout || stderr);
+    }
+    catch (error) {
+        // exec error includes stdout/stderr — try to parse JSON from it
+        const execError = error;
+        const output = execError.stdout || execError.stderr || '';
+        const parsed = parseCritiqueOutput(output);
+        if (parsed) {
+            return parsed;
+        }
+        const message = execError.message || 'Unknown error';
+        if (message.includes('command not found') || message.includes('ENOENT')) {
+            return { error: 'critique not available' };
+        }
+        return { error: `Failed to generate diff: ${message.slice(0, 200)}` };
+    }
+}
+/**
+ * Upload a .patch file to critique.work via critique --stdin.
+ * Returns the critique URL on success, undefined on failure.
+ * Default timeout is 10s since this runs in the background (footer edit).
+ */
+export async function uploadPatchViaCritique({ patchPath, title, cwd, timeoutMs = 10_000, }) {
+    try {
+        const { stdout } = await execAsync(`critique --stdin --web ${shellQuote(title)} --json < ${shellQuote(patchPath)}`, { cwd, timeout: timeoutMs });
+        const result = parseCritiqueOutput(stdout);
+        return result?.url;
+    }
+    catch (error) {
+        logger.error('critique upload failed:', error);
+        return undefined;
+    }
+}