@bakers-build/addon-opencode 0.0.0-stage → 0.1.0-next.42

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 keytec GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,5 @@
-# Temporary Holding Version
+# @bakers-build/addon-opencode
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+bakers.build agent plugin for the OpenCode CLI.
+
+Part of the bakers.build CLI. Install the meta package `@bakers-build/bakers` to get the `bakers` CLI with all addons. Source: https://git.key-tec.de/bakers-build/bakers-build (bakers-cli/).

package/dist/src/footprint.d.ts

@@ -0,0 +1,19 @@
+import { type AgentFootprint } from '@bakers-build/conductor/contract';
+/**
+ * Parse an opencode session bundle into an agent footprint (BB-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 (BB-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 '@bakers-build/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 (BB-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 (BB-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 (BB-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

@@ -0,0 +1,35 @@
+import { type AgentFootprint, type AgentPlugin, type AgentRunIdentity, type BbAgent } from '@bakers-build/conductor/contract';
+export { parseOpencodeTranscript } from './footprint.js';
+export interface OpencodeAgentOptions {
+    model?: string;
+    effort?: string;
+    args?: 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 BbAgent {
+    private readonly storageRoot;
+    readonly id = "opencode";
+    readonly launchWarnings?: readonly string[];
+    private readonly args;
+    private readonly model;
+    private readonly overrides;
+    constructor(options?: OpencodeAgentOptions, storageRoot?: string);
+    launchCommand(prompt: string, _run?: AgentRunIdentity): string;
+    /**
+     * Resolve the run's opencode session deterministically and return its raw
+     * records serialised (BB-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, run?: AgentRunIdentity): Promise<string>;
+    parseFootprint(log: string): AgentFootprint;
+}
+/** Config-facing factory: `opencodeAgent({ model: 'provider/model' })`. */
+export declare function opencodeAgent(options?: OpencodeAgentOptions): AgentPlugin;
+export default opencodeAgent;

package/dist/src/index.js

@@ -0,0 +1,162 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { resolveAgentCliOptions, } from '@bakers-build/conductor/contract';
+import { shellQuote } from '@bakers-build/core';
+import { parseOpencodeTranscript } from './footprint.js';
+export { parseOpencodeTranscript } from './footprint.js';
+const OPENCODE_RESERVED = ['--prompt', '--auto'];
+const OPENCODE_KNOWN = [
+    { kind: 'model', flags: ['--model', '-m'] },
+];
+/**
+ * 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 {
+    storageRoot;
+    id = 'opencode';
+    launchWarnings;
+    args;
+    model;
+    overrides;
+    constructor(options = {}, storageRoot = defaultOpencodeStorageRoot()) {
+        this.storageRoot = storageRoot;
+        const cli = resolveAgentCliOptions(options, OPENCODE_RESERVED, OPENCODE_KNOWN);
+        this.args = cli.args;
+        this.model = cli.model;
+        this.overrides = cli.overrides;
+        if (cli.effort !== undefined) {
+            this.launchWarnings = ['effort is unsupported and ignored'];
+        }
+    }
+    launchCommand(prompt, _run) {
+        if (prompt === '') {
+            return 'opencode';
+        }
+        // Interactive TUI with the initial prompt — mirrors the claude plugin
+        // (`claude '<prompt>' … --dangerously-skip-permissions`). `opencode run`
+        // would be the non-interactive print mode, which leaves the herdr pane
+        // without an attachable session.
+        const parts = ['opencode', '--prompt', shellQuote(prompt)];
+        if (this.model !== undefined && !this.overrides.model) {
+            parts.push('--model', shellQuote(this.model));
+        }
+        parts.push('--auto');
+        parts.push(...this.args.map(shellQuote));
+        return parts.join(' ');
+    }
+    /**
+     * Resolve the run's opencode session deterministically and return its raw
+     * records serialised (BB-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, run) {
+        const sessionRoot = join(this.storageRoot, 'session');
+        let projectDirs;
+        try {
+            projectDirs = await readdir(sessionRoot);
+        }
+        catch {
+            return '';
+        }
+        // opencode has no session-id pin (BB-473): the lower bound below is the
+        // only available defence, so a session from a PRIOR run left in the same
+        // (reused) worktree can never be selected for THIS run even when it is
+        // the only/newest directory-matching session around.
+        const startedAtMs = run?.startedAt !== undefined ? new Date(run.startedAt).getTime() : null;
+        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 (startedAtMs !== null &&
+                    Number.isFinite(startedAtMs) &&
+                    created < startedAtMs) {
+                    continue;
+                }
+                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 parseOpencodeTranscript(log);
+    }
+}
+/** Config-facing factory: `opencodeAgent({ model: 'provider/model' })`. */
+export function opencodeAgent(options = {}) {
+    const agent = new OpencodeAgent(options);
+    return {
+        kind: 'agent',
+        id: 'opencode',
+        requiredModules: [],
+        async createAgent() {
+            return agent;
+        },
+    };
+}
+export default opencodeAgent;

package/dist/src/preset.d.ts

@@ -0,0 +1,4 @@
+import type { Preset } from '@bakers-build/conductor/contract';
+import { type OpencodeAgentOptions } from './index.js';
+export declare const agents: Preset<Partial<OpencodeAgentOptions> | undefined>['agents'];
+export declare const scopes: Preset['scopes'];

package/dist/src/preset.js

@@ -0,0 +1,15 @@
+import opencodeAgent from './index.js';
+export const agents = (acc, opts) => {
+    const model = opts?.model;
+    return [
+        ...acc,
+        {
+            alias: 'opencode',
+            description: 'General coding with the locally configured Opencode model.',
+            ...(model !== undefined ? { model } : {}),
+            agent: opencodeAgent(opts),
+        },
+    ];
+};
+// Agents are per machine: list this addon in ~/.bakers/machine.config.js addons[].
+export const scopes = ['machine'];

package/package.json

@@ -1,6 +1,26 @@
 {
   "name": "@bakers-build/addon-opencode",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-next.42",
+  "description": "bakers.build agent plugin for the OpenCode CLI.",
+  "type": "module",
+  "license": "MIT",
+  "exports": {
+    ".": "./dist/src/index.js",
+    "./preset": "./dist/src/preset.js"
+  },
+  "files": [
+    "dist/src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://git.key-tec.de/bakers-build/bakers-build.git",
+    "directory": "bakers-cli/addons/opencode"
+  },
+  "peerDependencies": {
+    "@bakers-build/conductor": "^0.1.0-next.42",
+    "@bakers-build/core": "^0.1.0-next.42"
+  }
+}