sidekick-shared 0.27.6 → 0.28.0

package/dist/esm/watchers/sqliteWatcher.js

@@ -0,0 +1,285 @@
+/**
+ * SQLite session watcher for OpenCode.
+ * Polls for new messages/parts using timestamp cursor.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { OpenCodeDatabase } from '../providers/openCodeDatabase';
+import { normalizeToolName, detectPlanModeFromText } from '../parsers/openCodeParser';
+const DEBOUNCE_MS = 200;
+const POLL_INTERVAL_MS = 2_000;
+function truncate(text, maxLen) {
+    const clean = text.replace(/\s+/g, ' ').trim();
+    return clean.length > maxLen ? clean.substring(0, maxLen - 3) + '...' : clean;
+}
+function normalizeMessage(msg) {
+    const events = [];
+    const ts = new Date(msg.time_created).toISOString();
+    try {
+        const data = JSON.parse(msg.data);
+        const role = data.role;
+        const content = extractContent(data);
+        const msgTokens = data.tokens;
+        const tokens = msgTokens
+            ? { input: msgTokens.input || 0, output: msgTokens.output || 0 }
+            : undefined;
+        const cost = data.cost || undefined;
+        const model = data.modelID || undefined;
+        if (role === 'user') {
+            events.push({
+                providerId: 'opencode',
+                type: 'user',
+                timestamp: ts,
+                summary: content || '(user message)',
+                model,
+                raw: data,
+            });
+        }
+        else if (role === 'assistant') {
+            events.push({
+                providerId: 'opencode',
+                type: 'assistant',
+                timestamp: ts,
+                summary: content || '(thinking...)',
+                tokens,
+                cost,
+                model,
+                raw: data,
+            });
+        }
+    }
+    catch {
+        /* skip malformed */
+    }
+    return events;
+}
+function normalizePart(part) {
+    const events = [];
+    const ts = new Date(part.time_created).toISOString();
+    try {
+        const data = JSON.parse(part.data);
+        const type = data.type;
+        if (type === 'tool' || type === 'tool-invocation') {
+            const rawToolName = data.tool || 'unknown';
+            const toolName = normalizeToolName(rawToolName);
+            const state = data.state;
+            const stateStatus = state?.status;
+            // tool-invocation with state=result is a tool_result
+            const eventType = stateStatus === 'result' ? 'tool_result' : 'tool_use';
+            const toolInput = state?.input;
+            const input = data.args ? truncate(JSON.stringify(data.args), 80) : '';
+            // Include input in raw so PlanExtractor can access raw.input
+            const toolRaw = eventType === 'tool_use' ? { ...data, input: toolInput || {} } : data;
+            events.push({
+                providerId: 'opencode',
+                type: eventType,
+                timestamp: ts,
+                summary: input ? `${toolName} ${input}` : toolName,
+                toolName,
+                toolInput: input || undefined,
+                raw: toolRaw,
+            });
+        }
+        else if (type === 'text') {
+            const text = data.text || '';
+            if (text) {
+                // Wrap raw to include message.content for <proposed_plan> extraction
+                events.push({
+                    providerId: 'opencode',
+                    type: 'assistant',
+                    timestamp: ts,
+                    summary: truncate(text, 200),
+                    raw: { ...data, message: { content: [{ type: 'text', text }] } },
+                });
+                // Detect plan mode enter/exit from text heuristics
+                const direction = detectPlanModeFromText(text);
+                if (direction) {
+                    const syntheticToolName = direction === 'enter' ? 'EnterPlanMode' : 'ExitPlanMode';
+                    events.push({
+                        providerId: 'opencode',
+                        type: 'tool_use',
+                        timestamp: ts,
+                        summary: syntheticToolName,
+                        toolName: syntheticToolName,
+                        raw: { input: { source: 'opencode_text_heuristic' } },
+                    });
+                }
+            }
+        }
+    }
+    catch {
+        /* skip malformed */
+    }
+    return events;
+}
+function extractContent(data) {
+    const content = data.content;
+    if (typeof content === 'string')
+        return truncate(content, 200);
+    if (Array.isArray(content)) {
+        for (const part of content) {
+            if (typeof part.text === 'string')
+                return truncate(part.text, 200);
+        }
+    }
+    return '';
+}
+export class SqliteSessionWatcher {
+    _isActive = false;
+    lastMessageTime = 0;
+    lastPartTime = 0;
+    seenMessageVersions = new Map();
+    seenPartVersions = new Map();
+    fsWatcher = null;
+    walWatcher = null;
+    pollTimer = null;
+    debounceTimer = null;
+    db;
+    dbPath;
+    sessionId;
+    callbacks;
+    constructor(dbPath, sessionId, callbacks) {
+        this.dbPath = dbPath;
+        this.sessionId = sessionId;
+        this.callbacks = callbacks;
+        this.db = new OpenCodeDatabase(path.dirname(dbPath));
+    }
+    get isActive() {
+        return this._isActive;
+    }
+    /** Seek to a timestamp position. Must be called before start(). */
+    seekTo(position) {
+        this.lastMessageTime = position;
+        this.lastPartTime = position;
+        this.seenMessageVersions.clear();
+        this.seenPartVersions.clear();
+    }
+    /** Get the current cursor position (max timestamp seen). */
+    getPosition() {
+        return Math.max(this.lastMessageTime, this.lastPartTime);
+    }
+    start(replay) {
+        if (this._isActive)
+            return;
+        this._isActive = true;
+        if (!this.db.isAvailable() || !this.db.open()) {
+            this.callbacks.onError?.(new Error('SQLite database not available'));
+            this._isActive = false;
+            return;
+        }
+        if (replay) {
+            // Emit all existing events
+            this.pollNewData();
+        }
+        else {
+            // Skip to current timestamps
+            this.skipToEnd();
+        }
+        // Watch db and wal files for changes
+        this.watchFile(this.dbPath, (w) => {
+            this.fsWatcher = w;
+        });
+        this.watchFile(this.dbPath + '-wal', (w) => {
+            this.walWatcher = w;
+        });
+        // Fallback polling
+        this.pollTimer = setInterval(() => {
+            if (this._isActive)
+                this.pollNewData();
+        }, POLL_INTERVAL_MS);
+    }
+    stop() {
+        if (!this._isActive)
+            return;
+        this._isActive = false;
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        if (this.fsWatcher) {
+            this.fsWatcher.close();
+            this.fsWatcher = null;
+        }
+        if (this.walWatcher) {
+            this.walWatcher.close();
+            this.walWatcher = null;
+        }
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+        }
+        this.db.close();
+    }
+    watchFile(filePath, setter) {
+        try {
+            if (!fs.existsSync(filePath))
+                return;
+            const watcher = fs.watch(filePath, { persistent: false }, () => {
+                this.debouncedPoll();
+            });
+            watcher.on('error', () => {
+                /* ignore watch errors */
+            });
+            setter(watcher);
+        }
+        catch {
+            /* fs.watch not available */
+        }
+    }
+    debouncedPoll() {
+        if (this.debounceTimer)
+            clearTimeout(this.debounceTimer);
+        this.debounceTimer = setTimeout(() => {
+            this.pollNewData();
+        }, DEBOUNCE_MS);
+    }
+    skipToEnd() {
+        this.lastMessageTime = this.db.getLatestMessageTimeUpdated(this.sessionId);
+        this.lastPartTime = this.db.getLatestPartTimeUpdated(this.sessionId);
+        if (this.lastMessageTime > 0) {
+            for (const message of this.db.getMessagesNewerThan(this.sessionId, this.lastMessageTime - 1)) {
+                this.seenMessageVersions.set(message.id, `${message.time_updated}:${message.data}`);
+            }
+        }
+        if (this.lastPartTime > 0) {
+            for (const part of this.db.getPartsNewerThan(this.sessionId, this.lastPartTime - 1)) {
+                this.seenPartVersions.set(part.id, `${part.time_updated}:${part.data}`);
+            }
+        }
+    }
+    pollNewData() {
+        if (!this._isActive)
+            return;
+        try {
+            // Query incrementally by update time. Subtracting one millisecond lets us
+            // see distinct rows committed at the cursor timestamp; version maps
+            // suppress rows whose id/data have already been emitted.
+            const messages = this.db.getMessagesNewerThan(this.sessionId, Math.max(-1, this.lastMessageTime - 1));
+            const parts = this.db.getPartsNewerThan(this.sessionId, Math.max(-1, this.lastPartTime - 1));
+            // Emit new messages
+            const newMessages = messages.filter((message) => this.seenMessageVersions.get(message.id) !== `${message.time_updated}:${message.data}`);
+            for (const msg of newMessages) {
+                const events = normalizeMessage(msg);
+                for (const e of events)
+                    this.callbacks.onEvent(e);
+                this.seenMessageVersions.set(msg.id, `${msg.time_updated}:${msg.data}`);
+                if (msg.time_updated > this.lastMessageTime)
+                    this.lastMessageTime = msg.time_updated;
+            }
+            // Emit new parts
+            const newParts = parts.filter((part) => this.seenPartVersions.get(part.id) !== `${part.time_updated}:${part.data}`);
+            for (const part of newParts) {
+                const events = normalizePart(part);
+                for (const e of events)
+                    this.callbacks.onEvent(e);
+                this.seenPartVersions.set(part.id, `${part.time_updated}:${part.data}`);
+                if (part.time_updated > this.lastPartTime)
+                    this.lastPartTime = part.time_updated;
+            }
+            this.callbacks.onBatchComplete?.();
+        }
+        catch (err) {
+            this.callbacks.onError?.(err instanceof Error ? err : new Error(String(err)));
+        }
+    }
+}

package/dist/esm/watchers/types.js

@@ -0,0 +1,4 @@
+/**
+ * Types for live session following / streaming.
+ */
+export {};

package/dist/esm/workspaceRoots.js

@@ -0,0 +1,56 @@
+/**
+ * Workspace-root expansion shared by the session readers: realpath each root
+ * and, optionally, add its git worktree siblings.
+ *
+ * @module workspaceRoots
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { discoverWorktreeSiblings, resolveWorktreeMainRepo } from './parsers/sessionPathResolver';
+/** Realpath of an absolute path, or null when it does not resolve. */
+export function realpathOrNull(input, cache = new Map()) {
+    const cached = cache.get(input);
+    if (cached !== undefined)
+        return cached;
+    let resolved = null;
+    try {
+        resolved = path.isAbsolute(input) ? fs.realpathSync.native(input) : null;
+    }
+    catch {
+        resolved = null;
+    }
+    cache.set(input, resolved);
+    return resolved;
+}
+/**
+ * Realpaths each absolute root and, by default, adds its main checkout and
+ * git worktree siblings. Relative and unresolvable roots are dropped.
+ */
+export function resolveWorkspaceRoots(workspacePaths, options = {}, realpaths = new Map()) {
+    const includeWorktrees = options.includeWorktrees !== false;
+    const roots = new Set();
+    const listingRoots = new Set();
+    const add = (candidate) => {
+        const real = realpathOrNull(candidate, realpaths);
+        if (!real)
+            return;
+        roots.add(real);
+        listingRoots.add(real);
+        listingRoots.add(path.resolve(candidate));
+    };
+    for (const workspacePath of workspacePaths) {
+        if (typeof workspacePath !== 'string' || !path.isAbsolute(workspacePath))
+            continue;
+        add(workspacePath);
+        if (!includeWorktrees)
+            continue;
+        const real = realpathOrNull(workspacePath, realpaths);
+        if (!real)
+            continue;
+        const mainRepo = resolveWorktreeMainRepo(real) ?? real;
+        add(mainRepo);
+        for (const sibling of discoverWorktreeSiblings(mainRepo))
+            add(sibling);
+    }
+    return { roots: [...roots], listingRoots: [...listingRoots] };
+}