kibi-opencode 0.8.0 → 0.10.0

package/dist/session-edit-state.js

@@ -0,0 +1,177 @@
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const SENTINEL_HASH = "<deleted>";
+// ---------------------------------------------------------------------------
+// Implementation
+// ---------------------------------------------------------------------------
+export function createSessionEditState(opts) {
+    const worktree = opts.worktree;
+    const now = opts.now ?? Date.now;
+    // ---- Per-instance state (no module globals) ----
+    /**
+     * Tracked files keyed by relative path.
+     * Undefined baselineHash means we haven't taken a snapshot yet.
+     */
+    const tracked = new Map();
+    // ---- Internal helpers ----
+    function resolveToRelative(filePath) {
+        if (path.isAbsolute(filePath)) {
+            const rel = path.relative(worktree, filePath);
+            // Normalise away any leading ./ or ../ that escapes worktree
+            return rel.startsWith("..") ? filePath : rel;
+        }
+        return filePath;
+    }
+    function resolveToAbsolute(relPath) {
+        return path.join(worktree, relPath);
+    }
+    function hashContent(content) {
+        return crypto.createHash("sha256").update(content).digest("hex");
+    }
+    function hashFile(absPath) {
+        try {
+            const content = fs.readFileSync(absPath, "utf-8");
+            return hashContent(content);
+        }
+        catch {
+            return SENTINEL_HASH;
+        }
+    }
+    /**
+     * Take a baseline snapshot if we haven't yet.
+     * Returns the baseline hash.
+     */
+    function ensureBaseline(entry, relPath) {
+        if (entry.baselineHash !== undefined) {
+            return entry.baselineHash;
+        }
+        const abs = resolveToAbsolute(relPath);
+        const h = hashFile(abs);
+        entry.baselineHash = h;
+        return h;
+    }
+    // ---- Public API ----
+    function recordEventHint(filePath, kind, timestamp) {
+        const rel = resolveToRelative(filePath);
+        let entry = tracked.get(rel);
+        if (!entry) {
+            entry = {
+                baselineHash: undefined,
+                currentHash: undefined,
+                lastReconciledAt: 0,
+                eventHints: [],
+            };
+            tracked.set(rel, entry);
+        }
+        entry.eventHints.push({ kind, timestamp: timestamp ?? now() });
+    }
+    function reconcilePath(filePath) {
+        const rel = resolveToRelative(filePath);
+        let entry = tracked.get(rel);
+        if (!entry) {
+            entry = {
+                baselineHash: undefined,
+                currentHash: undefined,
+                lastReconciledAt: 0,
+                eventHints: [],
+            };
+            tracked.set(rel, entry);
+        }
+        // Lazy baseline snapshot
+        ensureBaseline(entry, rel);
+        // Current hash
+        const abs = resolveToAbsolute(rel);
+        const current = hashFile(abs);
+        entry.currentHash = current;
+        entry.lastReconciledAt = now();
+    }
+    function reconcileKnownPaths() {
+        for (const relPath of tracked.keys()) {
+            reconcilePath(relPath);
+        }
+    }
+    /**
+     * Return surviving session edits: files whose current hash differs from baseline.
+     * Sorted by lastReconciledAt ascending (oldest first).
+     */
+    function getSessionEdits() {
+        const results = [];
+        for (const [relPath, entry] of tracked) {
+            if (entry.baselineHash === undefined || entry.currentHash === undefined) {
+                // Not yet reconciled
+                continue;
+            }
+            if (entry.currentHash !== entry.baselineHash) {
+                results.push({
+                    filePath: relPath,
+                    baselineHash: entry.baselineHash,
+                    currentHash: entry.currentHash,
+                    lastReconciledAt: entry.lastReconciledAt,
+                });
+            }
+        }
+        results.sort((a, b) => a.lastReconciledAt - b.lastReconciledAt);
+        return results;
+    }
+    /**
+     * Focus edit = the last reconciled surviving edit (highest lastReconciledAt).
+     */
+    function getFocusEdit() {
+        const edits = getSessionEdits();
+        if (edits.length === 0)
+            return null;
+        // edits are sorted ascending by lastReconciledAt, so last = most recent
+        return edits[edits.length - 1];
+    }
+    function hasSessionEdits() {
+        for (const [, entry] of tracked) {
+            if (entry.baselineHash !== undefined &&
+                entry.currentHash !== undefined &&
+                entry.currentHash !== entry.baselineHash) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Force a file to be treated as a session edit without requiring a prior baseline.
+     * Used for eventless edits where the host signals a change via transform hook
+     * but no file.edited event was emitted to establish a pre-change baseline.
+     */
+    function forceEdit(filePath, kind, timestamp) {
+        const rel = resolveToRelative(filePath);
+        let entry = tracked.get(rel);
+        if (!entry) {
+            entry = {
+                baselineHash: undefined,
+                currentHash: undefined,
+                lastReconciledAt: 0,
+                eventHints: [],
+            };
+            tracked.set(rel, entry);
+        }
+        // Set a synthetic baseline that will never match real file content
+        if (entry.baselineHash === undefined) {
+            entry.baselineHash = hashContent(`__FORCED_BASELINE__${rel}`);
+        }
+        const abs = resolveToAbsolute(rel);
+        entry.currentHash = hashFile(abs);
+        entry.lastReconciledAt = timestamp ?? now();
+        if (kind) {
+            entry.eventHints.push({ kind, timestamp: timestamp ?? now() });
+        }
+    }
+    return {
+        recordEventHint,
+        reconcilePath,
+        reconcileKnownPaths,
+        getSessionEdits,
+        getFocusEdit,
+        hasSessionEdits,
+        forceEdit,
+    };
+}

package/dist/session-fingerprint.d.ts

@@ -0,0 +1,11 @@
+export interface SessionFingerprintInput {
+    sessionId?: string | undefined;
+    branch: string;
+    worktree: string;
+}
+export interface SessionBaselineState<Cursor> {
+    fingerprint: string | null;
+    cursor: Cursor | null;
+}
+export declare function buildSessionFingerprint(input: SessionFingerprintInput): string;
+export declare function syncSessionBaselineState<Cursor>(state: SessionBaselineState<Cursor>, input: SessionFingerprintInput, captureBaseline: () => Cursor | null): SessionBaselineState<Cursor>;

package/dist/session-fingerprint.js

@@ -0,0 +1,21 @@
+export function buildSessionFingerprint(
+// implements REQ-opencode-kibi-briefing-v6
+input) {
+    return [
+        input.sessionId?.trim() || "unknown",
+        input.branch,
+        input.worktree,
+    ].join("\0");
+}
+export function syncSessionBaselineState(
+// implements REQ-opencode-kibi-briefing-v6
+state, input, captureBaseline) {
+    const fingerprint = buildSessionFingerprint(input);
+    if (state.fingerprint === fingerprint) {
+        return state;
+    }
+    return {
+        fingerprint,
+        cursor: captureBaseline(),
+    };
+}

package/dist/source-linked-guidance.d.ts

@@ -1,8 +1,7 @@
 /**
  * Resolve the configured symbols manifest path using loadKbSyncPaths(worktree),
  * read the YAML synchronously, and return up to 3 deduped REQ IDs linked to
- * the edited file path. Preference is given to relationships[type=implements].target
- * (in file order) then static links as a fallback, preserving file order.
+ * the edited file path via implements relationships.
  *
  * Supports both YAML formats: top-level array and { symbols: [...] } object.
  * This function is purely synchronous and makes no runtime KB queries.

package/dist/source-linked-guidance.js

@@ -1,179 +1,16 @@
 // implements REQ-opencode-smart-enforcement-v1
-import { existsSync, readFileSync } from "node:fs";
-import * as path from "node:path";
-import { loadKbSyncPaths } from "./file-filter.js";
+import { getFileLinkedTargetsByType } from "./file-entity-links.js";
 /**
  * Resolve the configured symbols manifest path using loadKbSyncPaths(worktree),
  * read the YAML synchronously, and return up to 3 deduped REQ IDs linked to
- * the edited file path. Preference is given to relationships[type=implements].target
- * (in file order) then static links as a fallback, preserving file order.
+ * the edited file path via implements relationships.
  *
  * Supports both YAML formats: top-level array and { symbols: [...] } object.
  * This function is purely synchronous and makes no runtime KB queries.
  */
 // implements REQ-opencode-smart-enforcement-v1
 export function getSourceLinkedRequirementIds(worktree, editedAbsolutePath) {
-    try {
-        const paths = loadKbSyncPaths(worktree);
-        const symbolsPathRaw = paths.symbols;
-        if (!symbolsPathRaw)
-            return [];
-        const symbolsPath = path.isAbsolute(symbolsPathRaw)
-            ? symbolsPathRaw
-            : path.join(worktree, symbolsPathRaw);
-        if (!existsSync(symbolsPath))
-            return [];
-        const content = readFileSync(symbolsPath, "utf8");
-        const symbols = parseSymbolsYaml(content);
-        const relEdited = path
-            .relative(worktree, editedAbsolutePath)
-            .split(path.sep)
-            .join("/");
-        const matchedRows = symbols.filter((s) => s.sourceFile === relEdited);
-        if (matchedRows.length === 0)
-            return [];
-        const seen = new Set();
-        const orderedIds = [];
-        // First pass: collect implements relationships in file order
-        for (const row of matchedRows) {
-            for (const r of row.relationships ?? []) {
-                if (r.type === "implements") {
-                    const id = r.target;
-                    if (!seen.has(id)) {
-                        seen.add(id);
-                        orderedIds.push(id);
-                        if (orderedIds.length >= 3)
-                            return orderedIds.slice(0, 3);
-                    }
-                }
-            }
-        }
-        // Second pass: fall back to static links, preserving file order
-        for (const row of matchedRows) {
-            for (const l of row.links ?? []) {
-                if (!seen.has(l)) {
-                    seen.add(l);
-                    orderedIds.push(l);
-                    if (orderedIds.length >= 3)
-                        return orderedIds.slice(0, 3);
-                }
-            }
-        }
-        return orderedIds.slice(0, 3);
-    }
-    catch {
-        return [];
-    }
-}
-// ── Lightweight YAML parser (symbols.yaml subset) ────────────────────
-//
-// Handles:
-//   symbols:
-//     - id: SYM-xxx
-//       sourceFile: path/to/file
-//       links:
-//         - REQ-xxx
-//       relationships:
-//         - type: implements
-//           target: REQ-xxx
-//
-// And bare array format (no wrapping `symbols:` key):
-//     - id: SYM-xxx
-//       ...
-function parseSymbolsYaml(content) {
-    const entries = [];
-    const lines = content.split("\n");
-    let current = null;
-    let section = "none";
-    let pendingRel = null;
-    function flushRel() {
-        if (pendingRel?.type && pendingRel.target && current?.relationships) {
-            current.relationships.push({
-                type: pendingRel.type,
-                target: pendingRel.target,
-            });
-        }
-        pendingRel = null;
-    }
-    function flushEntry() {
-        flushRel();
-        if (current?.id && current?.sourceFile) {
-            entries.push(current);
-        }
-        current = null;
-        section = "none";
-    }
-    for (const raw of lines) {
-        if (raw.trim().startsWith("#"))
-            continue;
-        // New entry: "  - id: ..."
-        const entryMatch = raw.match(/^\s+-\s+id:\s*(.+)$/);
-        if (entryMatch) {
-            flushEntry();
-            const entryId = entryMatch[1];
-            if (entryId === undefined)
-                continue;
-            current = { id: entryId.trim(), links: [], relationships: [] };
-            section = "none";
-            continue;
-        }
-        if (!current)
-            continue;
-        // sourceFile
-        const srcMatch = raw.match(/^\s+sourceFile:\s*(.+)$/);
-        if (srcMatch) {
-            const sourceFile = srcMatch[1];
-            if (sourceFile === undefined)
-                continue;
-            current.sourceFile = sourceFile.trim();
-            section = "none";
-            continue;
-        }
-        // links section header
-        if (/^\s+links:\s*$/.test(raw)) {
-            flushRel();
-            section = "links";
-            continue;
-        }
-        // relationships section header
-        if (/^\s+relationships:\s*$/.test(raw)) {
-            flushRel();
-            section = "relationships";
-            continue;
-        }
-        // Link item: "      - REQ-xxx"
-        if (section === "links") {
-            const linkMatch = raw.match(/^\s+-\s+(REQ-[A-Za-z0-9_-]+)\s*$/);
-            if (linkMatch) {
-                const linkId = linkMatch[1];
-                if (linkId !== undefined && current.links) {
-                    current.links.push(linkId);
-                }
-                continue;
-            }
-        }
-        // Relationship type: "      - type: implements"
-        if (section === "relationships") {
-            const relTypeMatch = raw.match(/^\s+-\s+type:\s*(.+)$/);
-            if (relTypeMatch) {
-                flushRel();
-                const relationType = relTypeMatch[1];
-                if (relationType === undefined)
-                    continue;
-                pendingRel = { type: relationType.trim() };
-                continue;
-            }
-            // Relationship target: "        target: REQ-..."
-            const relTargetMatch = raw.match(/^\s+target:\s*(.+)$/);
-            if (relTargetMatch && pendingRel) {
-                const target = relTargetMatch[1];
-                if (target === undefined)
-                    continue;
-                pendingRel.target = target.trim();
-                continue;
-            }
-        }
-    }
-    flushEntry();
-    return entries;
+    // Delegate to the shared file-entity-links resolver with implements-only filter.
+    // implements relationships always target REQ- IDs, so no additional filtering needed.
+    return getFileLinkedTargetsByType(worktree, editedAbsolutePath, ["implements"]).slice(0, 3);
 }

package/dist/startup-notifier.d.ts

@@ -1,21 +1,6 @@
-export type ToastPayload = {
-    variant?: "info" | "success" | "warning" | "error";
-    title?: string;
-    message: string;
-    duration?: number;
-};
-export type StartupNotifierClient = {
-    tui?: {
-        showToast?: (payload: {
-            body: {
-                title?: string;
-                message: string;
-                variant?: "info" | "success" | "warning" | "error";
-                duration?: number;
-            };
-        }) => void | Promise<void>;
-        toast?: (payload: ToastPayload) => void | Promise<void>;
-    };
+import { type ToastCapableClient } from "./toast.js";
+export type { ToastPayload } from "./toast.js";
+export type StartupNotifierClient = ToastCapableClient & {
     app: {
         log: (payload: Record<string, unknown>) => Promise<void>;
     };

package/dist/startup-notifier.js

@@ -1,9 +1,4 @@
-function hasShowToast(client) {
-    return typeof client.tui?.showToast === "function";
-}
-function hasLegacyToast(client) {
-    return typeof client.tui?.toast === "function";
-}
+import { sendToast, } from "./toast.js";
 // implements REQ-opencode-kibi-plugin-v1
 export function notifyStartup(client, cfg) {
     const message = "kibi-opencode started";
@@ -14,39 +9,50 @@ export function notifyStartup(client, cfg) {
         duration: 4000,
     };
     if (!cfg.suppressToast) {
-        if (hasShowToast(client)) {
-            void Promise.resolve(client.tui.showToast({ body: toastPayload }))
-                .then((result) => void Promise.resolve(client.app.log({
-                body: {
-                    service: "kibi-opencode",
-                    level: "info",
-                    message: "startup toast result",
-                    result: String(result),
-                    ...(cfg.directory ? { directory: cfg.directory } : {}),
-                },
-            })).catch((logErr) => {
-                console.error("[kibi-opencode] startup toast result log failed:", logErr);
-            }))
-                .catch((err) => {
-                console.error("[kibi-opencode] startup toast failed:", err);
-                void Promise.resolve(client.app.log({
+        void sendToast(client, toastPayload).then((result) => {
+            const base = {
+                service: "kibi-opencode",
+                ...(cfg.directory ? { directory: cfg.directory } : {}),
+            };
+            if (result.status === "delivered") {
+                void client.app.log({
+                    body: {
+                        ...base,
+                        level: "info",
+                        message: "startup toast delivered",
+                        transport: result.transport,
+                    },
+                }).catch(() => {
+                    // Advisory log failure stays silent
+                });
+            }
+            else if (result.status === "unavailable") {
+                void client.app.log({
+                    body: {
+                        ...base,
+                        level: "info",
+                        message: "startup toast unavailable",
+                        reason: result.reason,
+                    },
+                }).catch(() => {
+                    // Advisory log failure stays silent
+                });
+            }
+            else if (result.status === "failed") {
+                void client.app.log({
                     body: {
-                        service: "kibi-opencode",
+                        ...base,
                         level: "warn",
-                        message: "startup toast failed",
-                        error: String(err),
-                        ...(cfg.directory ? { directory: cfg.directory } : {}),
+                        message: "startup toast delivery failed",
+                        transport: result.transport,
+                        reason: result.reason,
+                        ...(result.error ? { error: result.error } : {}),
                     },
-                })).catch((logErr) => {
-                    console.error("[kibi-opencode] startup toast log failed:", logErr);
+                }).catch(() => {
+                    // Advisory log failure stays silent
                 });
-            });
-        }
-        else if (hasLegacyToast(client)) {
-            void Promise.resolve(client.tui.toast(toastPayload)).catch((err) => {
-                console.error("[kibi-opencode] startup toast failed:", err);
-            });
-        }
+            }
+        });
     }
     void Promise.resolve(client.app.log({
         body: {
@@ -57,6 +63,6 @@ export function notifyStartup(client, cfg) {
             ...(cfg.directory ? { directory: cfg.directory } : {}),
         },
     })).catch((err) => {
-        console.error("[kibi-opencode] startup log failed:", err);
+        // Advisory log failure stays silent
     });
 }

package/dist/toast.d.ts

@@ -0,0 +1,31 @@
+export type ToastPayload = {
+    variant?: "info" | "success" | "warning" | "error";
+    title?: string;
+    message: string;
+    duration?: number;
+};
+export type SendToastResult = {
+    status: "delivered";
+    transport: "legacy" | "sdk";
+} | {
+    status: "unavailable";
+    reason: "missing-capability";
+} | {
+    status: "failed";
+    transport: "legacy" | "sdk";
+    reason: string;
+    error?: string;
+};
+export type ToastCapableClient = {
+    tui?: {
+        /** Legacy direct TUI toast (works in plugin context) */
+        toast?: (payload: ToastPayload) => void | Promise<void>;
+        /** SDK toast - receives { body: ToastPayload } */
+        showToast?: (payload: {
+            body: ToastPayload;
+        }) => void | Promise<void>;
+        clearPrompt?: () => void | Promise<void>;
+        submitPrompt?: () => void | Promise<void>;
+    };
+};
+export declare function sendToast(client: ToastCapableClient, payload: ToastPayload): Promise<SendToastResult>;

package/dist/toast.js

@@ -0,0 +1,40 @@
+// implements REQ-opencode-kibi-plugin-v1
+export async function sendToast(client, payload) {
+    if (typeof client.tui?.toast === "function") {
+        try {
+            await client.tui.toast(payload);
+            return { status: "delivered", transport: "legacy" };
+        }
+        catch (err) {
+            return {
+                status: "failed",
+                transport: "legacy",
+                reason: "rejected",
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+    if (typeof client.tui?.showToast === "function") {
+        try {
+            const result = client.tui.showToast({ body: payload });
+            if (result && typeof result.then === "function") {
+                const timeout = new Promise((_, reject) => {
+                    setTimeout(() => reject(new Error("showToast timed out")), 3000);
+                });
+                await Promise.race([result, timeout]);
+            }
+            return { status: "delivered", transport: "sdk" };
+        }
+        catch (err) {
+            return {
+                status: "failed",
+                transport: "sdk",
+                reason: err instanceof Error && err.message === "showToast timed out"
+                    ? "timed-out"
+                    : "rejected",
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+    return { status: "unavailable", reason: "missing-capability" };
+}

package/dist/tui-brief-delivery.d.ts

@@ -0,0 +1,47 @@
+import type { IdleBriefEnvelope } from "./idle-brief-store.js";
+export type ToastPayload = {
+    variant?: "info" | "success" | "warning" | "error";
+    title?: string;
+    message: string;
+    duration?: number;
+};
+export type ToastCapableClient = {
+    tui?: {
+        showToast?: (payload: {
+            body: ToastPayload;
+        }) => void | Promise<void>;
+    };
+};
+export type SharedBriefPolicy = {
+    briefs: {
+        enabled: boolean;
+        channels: {
+            tui: boolean;
+            vscode: boolean;
+        };
+        tui: {
+            toast: boolean;
+        };
+    };
+};
+export type LocalBriefConfig = {
+    autoSubmit: boolean;
+};
+export type DeliverResult = {
+    delivered: boolean;
+};
+/**
+ * Delivers a Kibi briefing to the TUI via toast notification.
+ *
+ * Uses the REAL OpenCode plugin API:
+ * - client.tui.showToast(payload) — primary (and only) delivery mechanism
+ *
+ * The toast contains a rich summary from the envelope and is displayed
+ * for 8 seconds so users can read the content.
+ *
+ * @param client - OpenCode client with optional TUI capabilities
+ * @param envelope - Idle brief envelope containing briefing content
+ * @param sharedPolicy - Shared brief policy from `.kb/config.json`
+ * @param localConfig - Local OpenCode config
+ */
+export declare function deliverBriefTui(client: ToastCapableClient, envelope: IdleBriefEnvelope, sharedPolicy: SharedBriefPolicy, _localConfig: LocalBriefConfig): Promise<DeliverResult>;