@gaia-ai/addon-opencode 0.6.2 → 0.6.4

package/dist/src/footprint.d.ts

@@ -0,0 +1,19 @@
+import { type AgentFootprint } from '@gaia-ai/conductor/contract';
+/**
+ * Parse an opencode session bundle into an agent footprint (GAIA-221).
+ *
+ * opencode persists a session as separate JSON records: one `session`, N
+ * `message`s (an assistant message carries `tokens: { input, output, reasoning,
+ * cache: { read, write } }` and `providerID`/`modelID` — there is **no**
+ * pre-summed total), and per-message `part`s (`type: 'tool'` → a tool call,
+ * `type: 'text'` on a user message → prompt words). `getRunLog` bundles them as
+ * `{ session, messages, parts }`; this derives the footprint from that bundle.
+ *
+ * `tokens` sums every bucket incl. cache across assistant turns. `duration_s` is
+ * the run's wall-clock length: the span between the earliest and latest epoch-ms
+ * timestamp found across the session and message records (GAIA-151); fewer than
+ * two timestamps → 0. `model` is the last assistant turn's `providerID/modelID`.
+ * A parse error, a non-object, or a bundle with no `session` → an empty
+ * footprint. Malformed records are skipped — never throws.
+ */
+export declare function parseOpencodeTranscript(serialised: string): AgentFootprint;

package/dist/src/footprint.js

@@ -0,0 +1,120 @@
+import { emptyAgentFootprint, } from '@gaia-ai/conductor/contract';
+function num(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+function countWords(text) {
+    const trimmed = text.trim();
+    return trimmed === '' ? 0 : trimmed.split(/\s+/).length;
+}
+function isObject(value) {
+    return typeof value === 'object' && value !== null;
+}
+/** Every token bucket of an assistant turn, incl. cache read/write (GAIA-220 parity). */
+function messageTokens(tokens) {
+    if (!tokens) {
+        return 0;
+    }
+    return (num(tokens.input) +
+        num(tokens.output) +
+        num(tokens.reasoning) +
+        num(tokens.cache?.read) +
+        num(tokens.cache?.write));
+}
+/**
+ * Parse an opencode session bundle into an agent footprint (GAIA-221).
+ *
+ * opencode persists a session as separate JSON records: one `session`, N
+ * `message`s (an assistant message carries `tokens: { input, output, reasoning,
+ * cache: { read, write } }` and `providerID`/`modelID` — there is **no**
+ * pre-summed total), and per-message `part`s (`type: 'tool'` → a tool call,
+ * `type: 'text'` on a user message → prompt words). `getRunLog` bundles them as
+ * `{ session, messages, parts }`; this derives the footprint from that bundle.
+ *
+ * `tokens` sums every bucket incl. cache across assistant turns. `duration_s` is
+ * the run's wall-clock length: the span between the earliest and latest epoch-ms
+ * timestamp found across the session and message records (GAIA-151); fewer than
+ * two timestamps → 0. `model` is the last assistant turn's `providerID/modelID`.
+ * A parse error, a non-object, or a bundle with no `session` → an empty
+ * footprint. Malformed records are skipped — never throws.
+ */
+export function parseOpencodeTranscript(serialised) {
+    const footprint = emptyAgentFootprint();
+    let bundle;
+    try {
+        const parsed = JSON.parse(serialised);
+        if (!isObject(parsed) || !isObject(parsed.session)) {
+            return footprint;
+        }
+        bundle = parsed;
+    }
+    catch {
+        return footprint;
+    }
+    const messages = Array.isArray(bundle.messages) ? bundle.messages : [];
+    const parts = Array.isArray(bundle.parts) ? bundle.parts : [];
+    let minTs = Number.POSITIVE_INFINITY;
+    let maxTs = Number.NEGATIVE_INFINITY;
+    const track = (value) => {
+        if (typeof value === 'number' && Number.isFinite(value)) {
+            if (value < minTs)
+                minTs = value;
+            if (value > maxTs)
+                maxTs = value;
+        }
+    };
+    track(bundle.session?.time?.created);
+    track(bundle.session?.time?.updated);
+    // messageID → role, so a text part's words are attributed to user turns only.
+    const roleOf = new Map();
+    let lastAssistant;
+    for (const raw of messages) {
+        if (!isObject(raw)) {
+            continue;
+        }
+        const message = raw;
+        if (typeof message.id === 'string' && typeof message.role === 'string') {
+            roleOf.set(message.id, message.role);
+        }
+        track(message.time?.created);
+        track(message.time?.completed);
+        if (message.role === 'assistant') {
+            footprint.agent_turns += 1;
+            footprint.tokens += messageTokens(message.tokens);
+            if (typeof message.providerID === 'string' &&
+                typeof message.modelID === 'string') {
+                const created = num(message.time?.created);
+                if (!lastAssistant || created >= lastAssistant.created) {
+                    lastAssistant = {
+                        created,
+                        model: `${message.providerID}/${message.modelID}`,
+                    };
+                }
+            }
+        }
+        else if (message.role === 'user') {
+            footprint.user_prompts += 1;
+        }
+    }
+    for (const raw of parts) {
+        if (!isObject(raw)) {
+            continue;
+        }
+        const part = raw;
+        if (part.type === 'tool') {
+            footprint.tool_calls += 1;
+        }
+        else if (part.type === 'text' &&
+            typeof part.text === 'string' &&
+            typeof part.messageID === 'string' &&
+            roleOf.get(part.messageID) === 'user') {
+            footprint.user_prompt_words += countWords(part.text);
+        }
+    }
+    if (Number.isFinite(minTs) && Number.isFinite(maxTs) && maxTs > minTs) {
+        footprint.duration_s = Math.floor((maxTs - minTs) / 1000);
+    }
+    if (lastAssistant) {
+        footprint.model = lastAssistant.model;
+    }
+    return footprint;
+}

package/dist/src/index.d.ts

@@ -1,14 +1,29 @@
-import { type AgentFootprint, type AgentPlugin, type GaiaAgent } from '@gaia-ai/conductor/contract';
+import type { AgentFootprint, AgentPlugin, GaiaAgent } from '@gaia-ai/conductor/contract';
+export { parseOpencodeTranscript } from './footprint.js';
 export interface OpencodeAgentOptions {
     model?: string;
 }
+/**
+ * opencode's local storage root: `${XDG_DATA_HOME:-~/.local/share}/opencode/storage`
+ * (AC-1). Injected into `OpencodeAgent` so unit tests can point at a fixture tree.
+ */
+export declare function defaultOpencodeStorageRoot(): string;
 export declare class OpencodeAgent implements GaiaAgent {
     private readonly options;
+    private readonly storageRoot;
     readonly id = "opencode";
-    constructor(options: OpencodeAgentOptions);
+    constructor(options: OpencodeAgentOptions, storageRoot?: string);
     launchCommand(prompt: string): string;
-    getRunLog(): Promise<string>;
-    parseFootprint(_log: string): AgentFootprint;
+    /**
+     * Resolve the run's opencode session deterministically and return its raw
+     * records serialised (GAIA-221). opencode has no `--session-dir`-style pin, so
+     * the session is discovered by matching `session.directory` against the run's
+     * worktree path (the worktree is per-run-unique) and picking the newest by
+     * `time.created`. Returns a `{ session, messages, parts }` JSON bundle, or `''`
+     * when no session matches. Every fs/JSON step is guarded — never throws.
+     */
+    getRunLog(worktreePath: string): Promise<string>;
+    parseFootprint(log: string): AgentFootprint;
 }
 /** Config-facing factory: `opencodeAgent({ model: 'provider/model' })`. */
 export declare function opencodeAgent(options?: OpencodeAgentOptions): AgentPlugin;

package/dist/src/index.js

@@ -1,10 +1,45 @@
-import { emptyAgentFootprint, } from '@gaia-ai/conductor/contract';
+import { readdir, readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
 import { shellQuote } from '@gaia-ai/core';
+import { parseOpencodeTranscript } from './footprint.js';
+export { parseOpencodeTranscript } from './footprint.js';
+/**
+ * opencode's local storage root: `${XDG_DATA_HOME:-~/.local/share}/opencode/storage`
+ * (AC-1). Injected into `OpencodeAgent` so unit tests can point at a fixture tree.
+ */
+export function defaultOpencodeStorageRoot() {
+    const dataHome = process.env.XDG_DATA_HOME || join(homedir(), '.local', 'share');
+    return join(dataHome, 'opencode', 'storage');
+}
+function isObject(value) {
+    return typeof value === 'object' && value !== null;
+}
+/** Read + JSON.parse a file, swallowing every error → `null`. */
+async function readJson(path) {
+    try {
+        return JSON.parse(await readFile(path, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+/** Entries of `dir` starting with `prefix` and ending `.json`, or `[]`. */
+async function listJson(dir, prefix) {
+    try {
+        return (await readdir(dir)).filter((name) => name.startsWith(prefix) && name.endsWith('.json'));
+    }
+    catch {
+        return [];
+    }
+}
 export class OpencodeAgent {
     options;
+    storageRoot;
     id = 'opencode';
-    constructor(options) {
+    constructor(options, storageRoot = defaultOpencodeStorageRoot()) {
         this.options = options;
+        this.storageRoot = storageRoot;
     }
     launchCommand(prompt) {
         if (prompt === '') {
@@ -21,11 +56,70 @@ export class OpencodeAgent {
         parts.push('--auto');
         return parts.join(' ');
     }
-    async getRunLog() {
-        return '';
+    /**
+     * Resolve the run's opencode session deterministically and return its raw
+     * records serialised (GAIA-221). opencode has no `--session-dir`-style pin, so
+     * the session is discovered by matching `session.directory` against the run's
+     * worktree path (the worktree is per-run-unique) and picking the newest by
+     * `time.created`. Returns a `{ session, messages, parts }` JSON bundle, or `''`
+     * when no session matches. Every fs/JSON step is guarded — never throws.
+     */
+    async getRunLog(worktreePath) {
+        const sessionRoot = join(this.storageRoot, 'session');
+        let projectDirs;
+        try {
+            projectDirs = await readdir(sessionRoot);
+        }
+        catch {
+            return '';
+        }
+        let newest = null;
+        for (const projectDir of projectDirs) {
+            const dir = join(sessionRoot, projectDir);
+            for (const name of await listJson(dir, 'ses_')) {
+                const record = await readJson(join(dir, name));
+                if (!isObject(record) || record.directory !== worktreePath) {
+                    continue;
+                }
+                const time = isObject(record.time) ? record.time : undefined;
+                const created = typeof time?.created === 'number'
+                    ? time.created
+                    : Number.NEGATIVE_INFINITY;
+                if (!newest || created > newest.created) {
+                    newest = { session: record, created };
+                }
+            }
+        }
+        if (!newest) {
+            return '';
+        }
+        const sessionId = newest.session.id;
+        const messages = [];
+        const parts = [];
+        if (typeof sessionId === 'string') {
+            const messageDir = join(this.storageRoot, 'message', sessionId);
+            for (const name of await listJson(messageDir, 'msg_')) {
+                const message = await readJson(join(messageDir, name));
+                if (message === null) {
+                    continue;
+                }
+                messages.push(message);
+                const messageId = isObject(message) ? message.id : undefined;
+                if (typeof messageId === 'string') {
+                    const partDir = join(this.storageRoot, 'part', messageId);
+                    for (const partName of await listJson(partDir, 'prt_')) {
+                        const part = await readJson(join(partDir, partName));
+                        if (part !== null) {
+                            parts.push(part);
+                        }
+                    }
+                }
+            }
+        }
+        return JSON.stringify({ session: newest.session, messages, parts });
     }
-    parseFootprint(_log) {
-        return emptyAgentFootprint();
+    parseFootprint(log) {
+        return parseOpencodeTranscript(log);
     }
 }
 /** Config-facing factory: `opencodeAgent({ model: 'provider/model' })`. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gaia-ai/addon-opencode",
-  "version": "0.6.2",
+  "version": "0.6.4",
   "description": "GAIA agent plugin for the OpenCode CLI.",
   "type": "module",
   "license": "MIT",
@@ -20,7 +20,7 @@
     "directory": "gaia-cli/addons/opencode"
   },
   "peerDependencies": {
-    "@gaia-ai/conductor": "^0.6.2",
-    "@gaia-ai/core": "^0.6.2"
+    "@gaia-ai/conductor": "^0.6.4",
+    "@gaia-ai/core": "^0.6.4"
   }
 }