@otto-assistant/otto 0.1.2 → 0.7.15

package/src/context-awareness-plugin.ts

@@ -0,0 +1,469 @@
+// 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 type { Plugin } from '@opencode-ai/plugin'
+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')
+
+// ── Types ────────────────────────────────────────────────────────
+
+type GitState = {
+  key: string
+  kind: 'branch' | 'detached-head' | 'detached-submodule'
+  label: string
+  warning: string | null
+}
+
+// All per-session mutable state in one place. One Map entry, one delete.
+type SessionState = {
+  gitState: GitState | undefined
+  gitStateDirectory: string | undefined
+  gitStateCheckedAtMs: number
+  lastMemoryReminderAssistantMessageId: string | undefined
+  latestAssistantMessage: AssistantMessageInfo | undefined
+  tutorialInjected: boolean
+
+  // Last directory observed from plugin input.directory.
+  // Updated on each real user message to detect cwd switches.
+  resolvedDirectory: string | undefined
+  // Last directory we announced via pwd injection.
+  announcedDirectory: string | undefined
+}
+
+// ── 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,
+}: {
+  previousGitState: GitState | undefined
+  currentGitState: GitState | null
+}): { inject: false } | { inject: true; text: string } {
+  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,
+}: {
+  currentDir: string
+  previousDir: string | undefined
+  announcedDir: string | undefined
+}): { inject: false } | { inject: true; text: string } {
+  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
+
+type AssistantTokenUsage = {
+  input: number
+  output: number
+  reasoning: number
+  cache: { read: number; write: number }
+}
+
+type AssistantMessageInfo = {
+  id: string
+  role: string
+  time?: { completed?: number; created?: number }
+  tokens?: AssistantTokenUsage
+}
+
+export function shouldInjectMemoryReminderFromLatestAssistant({
+  lastMemoryReminderAssistantMessageId,
+  latestAssistantMessage,
+  threshold = MEMORY_REMINDER_OUTPUT_TOKENS,
+}: {
+  lastMemoryReminderAssistantMessageId?: string
+  latestAssistantMessage: AssistantMessageInfo | undefined
+  threshold?: number
+}): { inject: false } | { inject: true; assistantMessageId: string } {
+  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,
+}: {
+  alreadyInjected: boolean
+  parts: Array<{ type: string; text?: string }>
+}): boolean {
+  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,
+}: {
+  directory: string
+}): Promise<GitState | null> {
+  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: Plugin = 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<string, SessionState>()
+
+  function getOrCreateSession(sessionID: string): SessionState {
+    const existing = sessions.get(sessionID)
+    if (existing) {
+      return existing
+    }
+    const state: SessionState = {
+      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' as const,
+              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' as const,
+              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' as const,
+              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' as const,
+              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 as { sessionID?: unknown }
+            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/src/critique-utils.ts

@@ -0,0 +1,139 @@
+// 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: string): string {
+  return `'${s.replace(/'/g, "'\\''")}'`
+}
+
+export type CritiqueResult = {
+  url: string
+  id: string
+  error?: undefined
+} | {
+  url?: undefined
+  id?: undefined
+  error: string
+}
+
+/**
+ * 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: string): CritiqueResult | undefined {
+  const lines = output.trim().split('\n')
+  for (const line of lines) {
+    if (!line.startsWith('{')) {
+      continue
+    }
+    try {
+      const parsed = JSON.parse(line) as {
+        url?: string
+        id?: string
+        error?: string
+      }
+      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,
+}: {
+  title: string
+  cwd: string
+}): Promise<CritiqueResult | undefined> {
+  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 as {
+      stdout?: string
+      stderr?: string
+      message?: string
+    }
+    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,
+}: {
+  patchPath: string
+  title: string
+  cwd: string
+  timeoutMs?: number
+}): Promise<string | undefined> {
+  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
+  }
+}