@otto-assistant/otto 0.1.2 → 0.7.16

package/dist/session-handler/model-utils.js

@@ -0,0 +1,147 @@
+// Model resolution utilities.
+// getDefaultModel resolves the default model from OpenCode when no user preference is set.
+import fs from 'node:fs';
+import path from 'node:path';
+import { xdgState } from 'xdg-basedir';
+import * as errore from 'errore';
+import {} from '../opencode.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const sessionLogger = createLogger(LogPrefix.SESSION);
+/**
+ * Read user's recent models from OpenCode TUI's state file.
+ * Uses same path as OpenCode: path.join(xdgState, "opencode", "model.json")
+ * Returns all recent models so we can iterate until finding a valid one.
+ * See: opensrc/repos/github.com/sst/opencode/packages/opencode/src/global/index.ts
+ */
+function getRecentModelsFromTuiState() {
+    if (!xdgState) {
+        return [];
+    }
+    // Same path as OpenCode TUI: path.join(Global.Path.state, "model.json")
+    const modelJsonPath = path.join(xdgState, 'opencode', 'model.json');
+    const result = errore.tryFn(() => {
+        const content = fs.readFileSync(modelJsonPath, 'utf-8');
+        const data = JSON.parse(content);
+        return data.recent ?? [];
+    });
+    if (result instanceof Error) {
+        // File doesn't exist or is invalid - this is normal for fresh installs
+        return [];
+    }
+    return result;
+}
+/**
+ * Parse a model string in format "provider/model" into providerID and modelID.
+ */
+function parseModelString(model) {
+    const [providerID, ...modelParts] = model.split('/');
+    const modelID = modelParts.join('/');
+    if (!providerID || !modelID) {
+        return undefined;
+    }
+    return { providerID, modelID };
+}
+function getModelFromProjectConfig({ directory, }) {
+    if (!directory) {
+        return undefined;
+    }
+    const result = errore.tryFn(() => {
+        const configPath = path.join(directory, 'opencode.json');
+        const raw = fs.readFileSync(configPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (!parsed.model) {
+            return undefined;
+        }
+        return parseModelString(parsed.model);
+    });
+    if (result instanceof Error) {
+        return undefined;
+    }
+    return result;
+}
+/**
+ * Validate that a model is available (provider connected + model exists).
+ */
+function isModelValid(model, connected, providers) {
+    const isConnected = connected.includes(model.providerID);
+    const provider = providers.find((p) => {
+        return p.id === model.providerID;
+    });
+    const modelExists = provider?.models && model.modelID in provider.models;
+    return isConnected && !!modelExists;
+}
+/**
+ * Get the default model from OpenCode when no user preference is set.
+ * Priority (matches OpenCode TUI behavior):
+ * 1. OpenCode config.model setting
+ * 2. User's recent models from TUI state (~/.local/state/opencode/model.json)
+ * 3. First connected provider's default model from API
+ * Returns the model and its source.
+ */
+export async function getDefaultModel({ getClient, directory, }) {
+    if (getClient instanceof Error) {
+        return undefined;
+    }
+    const configModel = getModelFromProjectConfig({ directory });
+    if (configModel) {
+        sessionLogger.log(`[MODEL] Using project config model: ${configModel.providerID}/${configModel.modelID}`);
+        return { ...configModel, source: 'opencode-config' };
+    }
+    // Fetch connected providers to validate any model we return
+    const providersResponse = await errore.tryAsync(() => {
+        return getClient().provider.list({ directory });
+    });
+    if (providersResponse instanceof Error) {
+        sessionLogger.log(`[MODEL] Failed to fetch providers for default model:`, providersResponse.message);
+        return undefined;
+    }
+    if (!providersResponse.data) {
+        return undefined;
+    }
+    const { connected, default: defaults, all: providers, } = providersResponse.data;
+    if (connected.length === 0) {
+        sessionLogger.log(`[MODEL] No connected providers found`);
+        return undefined;
+    }
+    // 1. Check OpenCode config.model setting (highest priority after user preference)
+    const configResponse = await errore.tryAsync(() => {
+        return getClient().config.get({ directory });
+    });
+    if (!(configResponse instanceof Error) && configResponse.data?.model) {
+        const configModel = parseModelString(configResponse.data.model);
+        if (configModel && isModelValid(configModel, connected, providers)) {
+            sessionLogger.log(`[MODEL] Using config model: ${configModel.providerID}/${configModel.modelID}`);
+            return { ...configModel, source: 'opencode-config' };
+        }
+        if (configModel) {
+            sessionLogger.log(`[MODEL] Config model ${configResponse.data.model} not available, checking recent`);
+        }
+    }
+    // 2. Try to use user's recent models from TUI state (iterate until finding valid one)
+    const recentModels = getRecentModelsFromTuiState();
+    for (const recentModel of recentModels) {
+        if (isModelValid(recentModel, connected, providers)) {
+            sessionLogger.log(`[MODEL] Using recent TUI model: ${recentModel.providerID}/${recentModel.modelID}`);
+            return { ...recentModel, source: 'opencode-recent' };
+        }
+    }
+    if (recentModels.length > 0) {
+        sessionLogger.log(`[MODEL] No valid recent TUI models found`);
+    }
+    // 3. Fall back to first connected provider's default model
+    const firstConnected = connected[0];
+    if (!firstConnected) {
+        return undefined;
+    }
+    const defaultModelId = defaults[firstConnected];
+    if (!defaultModelId) {
+        sessionLogger.log(`[MODEL] No default model for provider ${firstConnected}`);
+        return undefined;
+    }
+    sessionLogger.log(`[MODEL] Using provider default: ${firstConnected}/${defaultModelId}`);
+    return {
+        providerID: firstConnected,
+        modelID: defaultModelId,
+        source: 'opencode-provider-default',
+    };
+}

package/dist/session-handler/opencode-session-event-log.js

@@ -0,0 +1,94 @@
+// Debug helper for writing raw OpenCode event stream entries as JSONL.
+// When enabled, writes one file per session ID so event ordering and
+// lifecycle behavior can be analyzed with jq.
+import fs from 'node:fs';
+import path from 'node:path';
+import * as errore from 'errore';
+import { getDataDir } from '../config.js';
+let eventLogDirPromise = null;
+let eventLogWriteDisabled = false;
+export function isOpencodeSessionEventLogEnabled() {
+    return process.env['OTTO_LOG_OPENCODE_SESSION_EVENTS'] === '1';
+}
+export function getOpencodeEventSessionId(event) {
+    switch (event.type) {
+        case 'message.updated':
+            return event.properties.info.sessionID;
+        case 'message.part.updated':
+            return event.properties.part.sessionID;
+        case 'message.part.delta':
+        case 'message.part.removed':
+        case 'session.status':
+        case 'session.idle':
+        case 'session.diff':
+        case 'permission.asked':
+        case 'permission.replied':
+        case 'question.asked':
+        case 'question.replied':
+        case 'question.rejected':
+            return event.properties.sessionID;
+        case 'session.error':
+            return event.properties.sessionID;
+        case 'session.created':
+        case 'session.updated':
+        case 'session.deleted':
+            return event.properties.info.id;
+        default:
+            return undefined;
+    }
+}
+function sanitizeSessionIdForFilename(sessionId) {
+    return sessionId.replace(/[^a-zA-Z0-9._-]/g, '_');
+}
+async function resolveEventLogDirectory() {
+    if (!eventLogDirPromise) {
+        eventLogDirPromise = (async () => {
+            const configuredEventLogDir = process.env['OTTO_OPENCODE_SESSION_EVENTS_DIR'];
+            const baseDir = configuredEventLogDir || path.join(getDataDir(), 'opencode-session-events');
+            await fs.promises.mkdir(baseDir, { recursive: true });
+            return baseDir;
+        })();
+    }
+    return eventLogDirPromise;
+}
+export function buildOpencodeEventLogLine({ timestamp, threadId, projectDirectory, event, }) {
+    return {
+        timestamp,
+        threadId,
+        projectDirectory,
+        event,
+    };
+}
+export async function appendOpencodeSessionEventLog(entry) {
+    if (!isOpencodeSessionEventLogEnabled() || eventLogWriteDisabled) {
+        return null;
+    }
+    const sessionId = getOpencodeEventSessionId(entry.event);
+    if (!sessionId) {
+        return null;
+    }
+    const logDirResult = await errore.tryAsync(() => {
+        return resolveEventLogDirectory();
+    });
+    if (logDirResult instanceof Error) {
+        eventLogWriteDisabled = true;
+        return logDirResult;
+    }
+    const safeSessionId = sanitizeSessionIdForFilename(sessionId);
+    const logFilePath = path.join(logDirResult, `${safeSessionId}.jsonl`);
+    const now = Date.now();
+    const line = `${JSON.stringify(buildOpencodeEventLogLine({
+        timestamp: now,
+        threadId: entry.threadId,
+        projectDirectory: entry.projectDirectory,
+        event: entry.event,
+    }))}\n`;
+    const appendResult = await errore.tryAsync(() => {
+        return fs.promises.appendFile(logFilePath, line, 'utf8');
+    });
+    if (appendResult instanceof Error) {
+        eventLogWriteDisabled = true;
+        return appendResult;
+    }
+    return null;
+}

package/dist/session-handler/thread-runtime-state.js

@@ -0,0 +1,131 @@
+// Per-thread state type, transition functions, and selectors.
+// All transitions operate on the global store from ../store.js.
+//
+// ThreadRunState is a value-type: one entry per active thread in the
+// global store's `threads` Map. Transition functions produce new Map +
+// new ThreadRunState objects each time (immutable updates).
+//
+// Derived helpers (queue checks) compute from state and are never
+// stored — they are always re-derived from ThreadRunState.
+//
+// STATE DISCIPLINE: keep as little state as possible. Before adding any new
+// state field, ask if it can be derived from existing state instead.
+import { store } from '../store.js';
+// ── Initial state factory ────────────────────────────────────────
+export function initialThreadState() {
+    return {
+        sessionId: undefined,
+        sessionUsername: undefined,
+        queueItems: [],
+        listenerController: undefined,
+        sentPartIds: new Set(),
+    };
+}
+// ── Derived helpers (compute, never store) ───────────────────────
+export function hasQueue(t) {
+    return t.queueItems.length > 0;
+}
+// ── Pure transition helpers ──────────────────────────────────────
+// Immutable: produces new Map + new ThreadRunState object each time.
+export function updateThread(threadId, updater) {
+    store.setState((s) => {
+        const existing = s.threads.get(threadId);
+        if (!existing) {
+            return s;
+        }
+        const newThreads = new Map(s.threads);
+        newThreads.set(threadId, updater(existing));
+        return { threads: newThreads };
+    });
+}
+export function ensureThread(threadId) {
+    if (store.getState().threads.has(threadId)) {
+        return;
+    }
+    store.setState((s) => {
+        const newThreads = new Map(s.threads);
+        newThreads.set(threadId, initialThreadState());
+        return { threads: newThreads };
+    });
+}
+export function removeThread(threadId) {
+    store.setState((s) => {
+        if (!s.threads.has(threadId)) {
+            return s;
+        }
+        const newThreads = new Map(s.threads);
+        newThreads.delete(threadId);
+        return { threads: newThreads };
+    });
+}
+export function setSessionId(threadId, sessionId) {
+    updateThread(threadId, (t) => ({ ...t, sessionId }));
+}
+export function setSessionUsername(threadId, username) {
+    updateThread(threadId, (t) => {
+        if (t.sessionUsername) {
+            return t;
+        }
+        return { ...t, sessionUsername: username };
+    });
+}
+export function enqueueItem(threadId, item) {
+    updateThread(threadId, (t) => ({
+        ...t,
+        queueItems: [...t.queueItems, item],
+    }));
+}
+// Atomic dequeue: read + write in one setState call to prevent
+// a concurrent enqueue between read and write from losing items.
+export function dequeueItem(threadId) {
+    let next;
+    store.setState((s) => {
+        const t = s.threads.get(threadId);
+        if (!t || t.queueItems.length === 0) {
+            return s;
+        }
+        const [head, ...rest] = t.queueItems;
+        next = head;
+        const newThreads = new Map(s.threads);
+        newThreads.set(threadId, { ...t, queueItems: rest });
+        return { threads: newThreads };
+    });
+    return next;
+}
+export function clearQueueItems(threadId) {
+    updateThread(threadId, (t) => ({ ...t, queueItems: [] }));
+}
+export function removeQueueItemAtPosition(threadId, position) {
+    if (position < 1) {
+        return undefined;
+    }
+    let removedItem;
+    store.setState((s) => {
+        const t = s.threads.get(threadId);
+        if (!t) {
+            return s;
+        }
+        const index = position - 1;
+        const removed = t.queueItems[index];
+        if (!removed) {
+            return s;
+        }
+        removedItem = removed;
+        const newThreads = new Map(s.threads);
+        newThreads.set(threadId, {
+            ...t,
+            queueItems: t.queueItems.filter((_, itemIndex) => {
+                return itemIndex !== index;
+            }),
+        });
+        return { threads: newThreads };
+    });
+    return removedItem;
+}
+// ── Queries ──────────────────────────────────────────────────────
+export function getThreadState(threadId) {
+    return store.getState().threads.get(threadId);
+}
+export function getThreadIds() {
+    return [...store.getState().threads.keys()];
+}