kibi-opencode 0.3.1

package/README.md

@@ -0,0 +1,133 @@
+# kibi-opencode
+
+OpenCode plugin for Kibi - repo-local, per-branch, queryable knowledge base.
+
+## Installation
+
+```bash
+npm install kibi-opencode
+```
+
+Or via OpenCode's plugin system in `opencode.json`:
+
+```json
+{
+  "plugins": ["kibi-opencode"]
+}
+```
+
+## Features
+
+### Prompt Guidance Injection
+
+The plugin injects guidance into OpenCode sessions to improve agent grounding:
+
+```
+Query Kibi before design/implementation work. Prefer kb_query/kb_check for context. Update KB artifacts after relevant changes. Remember symbol traceability requirements.
+```
+
+- Uses `<!-- kibi-opencode -->` sentinel to prevent duplicate injections
+- Respects `prompt.enabled` and overall `enabled` config flags
+
+### Bootstrap Command
+
+OpenCode exposes Kibi MCP prompts as slash commands. The `/init-kibi` command runs the retroactive bootstrap workflow using only public MCP tools.
+
+### Debounced Sync
+
+Automatically runs `kibi sync` after relevant file edits:
+
+- Single-flight scheduler (no overlapping syncs)
+- Debounce window (default: 2000ms)
+- Dirty flag triggers one trailing rerun after active sync completes
+
+### Non-Blocking UX
+
+- Sync runs in background, never blocks OpenCode
+- Failures reported via console logs only, never as blocking UI elements
+
+## Configuration
+
+Config files (project overrides global):
+
+- Global: `~/.config/opencode/kibi.json`
+- Project: `.opencode/kibi.json`
+
+### Config Keys
+
+| Key | Type | Default | Description |
+|-----|------|---------|-------------|
+| `enabled` | boolean | `true` | Enable/disable all plugin features |
+| `prompt.enabled` | boolean | `true` | Enable prompt guidance injection |
+| `prompt.hookMode` | string | `"auto"` | Hook mode: `auto`, `chat-params`, `system-transform`, `compat` |
+| `sync.enabled` | boolean | `true` | Enable automatic sync |
+| `sync.debounceMs` | number | `2000` | Debounce window in milliseconds |
+| `sync.ignore` | string[] | `[]` | Additional paths to ignore |
+| `sync.relevant` | string[] | `[]` | Additional relevant paths |
+| `logLevel` | string | `"info"` | Log level: `debug`, `info`, `warn`, `error` |
+
+### Hook Policy
+
+Per ADR-016, prompt text injection uses only `experimental.chat.system.transform`. The `chat.params` hook is reserved for model option enrichment (temperature, topP, etc.) and never carries prompt text.
+
+### Hook Modes
+
+- `auto`: Use `experimental.chat.system.transform` (primary); `chat.params` is a no-op registration for host compatibility
+- `chat-params`: Disable prompt injection; `chat.params` hook is registered but does not modify prompt text
+- `system-transform`: Force `experimental.chat.system.transform` for prompt injection
+- `compat`: Disable prompt injection entirely, conservative sync only
+
+## Disablement
+
+### Project-Level Disablement
+
+Create `.opencode/kibi.json`:
+
+```json
+{
+  "enabled": false
+}
+```
+
+This disables all plugin features even if loaded globally.
+
+### Feature-Level Disablement
+
+Disable specific features while keeping others:
+
+```json
+{
+  "prompt": {
+    "enabled": false
+  },
+  "sync": {
+    "enabled": false
+  }
+}
+```
+
+## Dogfooding
+
+This repository uses a local shim at `.opencode/plugins/kibi.ts` for development. The npm package (`kibi-opencode`) is the public distribution artifact.
+
+## Architecture
+
+This is a thin bridge layer:
+
+- Reuses `kibi` CLI for sync operations
+- Reuses existing MCP tools (`kb_query`, `kb_check`, etc.)
+- Does NOT own KB storage, parsing, or validation
+
+### Future: File-Context Virtual Injection
+
+A proposed enhancement would inject Kibi context hints into file-read results (e.g., "This symbol has linked requirements"). This is **deferred** because:
+
+1. OpenCode's current plugin surface does not expose file-content interception hooks
+2. The `experimental.chat.system.transform` hook only supports system prompt injection
+3. Symbol metadata from `documentation/symbols.yaml` can inform this feature once host support exists
+
+Current workaround: static system prompt guidance directs agents to query Kibi explicitly.
+
+## License
+
+AGPL-3.0-or-later

package/dist/config.d.ts

@@ -0,0 +1,23 @@
+export interface KibiConfig {
+    enabled: boolean;
+    prompt: {
+        enabled: boolean;
+        hookMode: "auto" | "chat-params" | "system-transform" | "compat";
+    };
+    sync: {
+        enabled: boolean;
+        debounceMs: number;
+        ignore: string[];
+        relevant: string[];
+    };
+    ux: {
+        toastFailures: boolean;
+        toastSuccesses: boolean;
+        toastCooldownMs: number;
+    };
+    logLevel: string;
+}
+declare const DEFAULTS: KibiConfig;
+export declare function loadConfig(projectDir?: string): KibiConfig;
+export declare function isPluginEnabled(cfg?: KibiConfig): boolean;
+export { DEFAULTS };

package/dist/config.js

@@ -0,0 +1,98 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import * as logger from "./logger";
+const DEFAULTS = {
+    enabled: true,
+    prompt: { enabled: true, hookMode: "auto" },
+    sync: { enabled: true, debounceMs: 2000, ignore: [], relevant: [] },
+    ux: { toastFailures: true, toastSuccesses: false, toastCooldownMs: 10000 },
+    logLevel: "info",
+};
+function readJsonIfExists(filePath) {
+    try {
+        if (!fs.existsSync(filePath))
+            return null;
+        const raw = fs.readFileSync(filePath, "utf8");
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        const msg = err && typeof err === "object" && "message" in err
+            ? err.message
+            : String(err);
+        logger.warn(`Failed to read/parse config ${filePath}: ${msg}`);
+        return null;
+    }
+}
+function validateAndMerge(obj) {
+    if (!obj || typeof obj !== "object") {
+        logger.warn("Config is not an object, using defaults");
+        return DEFAULTS;
+    }
+    const src = obj;
+    const out = { ...DEFAULTS };
+    if (typeof src.enabled === "boolean")
+        out.enabled = src.enabled;
+    if (src.prompt && typeof src.prompt === "object") {
+        const p = src.prompt;
+        out.prompt = { ...DEFAULTS.prompt };
+        if (typeof p.enabled === "boolean")
+            out.prompt.enabled = p.enabled;
+        if (typeof p.hookMode === "string") {
+            const modes = ["auto", "chat-params", "system-transform", "compat"];
+            if (modes.includes(p.hookMode))
+                out.prompt.hookMode = p.hookMode;
+            else
+                logger.warn(`Invalid prompt.hookMode '${p.hookMode}', using default`);
+        }
+    }
+    if (src.sync && typeof src.sync === "object") {
+        const s = src.sync;
+        out.sync = { ...DEFAULTS.sync };
+        if (typeof s.enabled === "boolean")
+            out.sync.enabled = s.enabled;
+        if (typeof s.debounceMs === "number")
+            out.sync.debounceMs = s.debounceMs;
+        if (Array.isArray(s.ignore))
+            out.sync.ignore = s.ignore.map(String);
+        if (Array.isArray(s.relevant))
+            out.sync.relevant = s.relevant.map(String);
+    }
+    if (src.ux && typeof src.ux === "object") {
+        const u = src.ux;
+        out.ux = { ...DEFAULTS.ux };
+        if (typeof u.toastFailures === "boolean")
+            out.ux.toastFailures = u.toastFailures;
+        if (typeof u.toastSuccesses === "boolean")
+            out.ux.toastSuccesses = u.toastSuccesses;
+        if (typeof u.toastCooldownMs === "number")
+            out.ux.toastCooldownMs = u.toastCooldownMs;
+    }
+    if (typeof src.logLevel === "string")
+        out.logLevel = src.logLevel;
+    return out;
+}
+// implements REQ-opencode-kibi-plugin-v1
+export function loadConfig(projectDir = process.cwd()) {
+    const homeConfig = path.join(os.homedir(), ".config", "opencode", "kibi.json");
+    const projectConfig = path.join(projectDir, ".opencode", "kibi.json");
+    const globalObj = readJsonIfExists(homeConfig);
+    const projectObj = readJsonIfExists(projectConfig);
+    let merged = {};
+    if (globalObj)
+        merged = { ...merged, ...globalObj };
+    if (projectObj)
+        merged = { ...merged, ...projectObj };
+    const validated = validateAndMerge(merged);
+    if (!validated) {
+        logger.warn("Configuration invalid, falling back to defaults");
+        return DEFAULTS;
+    }
+    return validated;
+}
+// implements REQ-opencode-kibi-plugin-v1
+export function isPluginEnabled(cfg) {
+    const effective = cfg || loadConfig();
+    return Boolean(effective.enabled);
+}
+export { DEFAULTS };

package/dist/file-filter.d.ts

@@ -0,0 +1,2 @@
+export declare function shouldHandleFile(filePath: string, cwd?: string): boolean;
+export default shouldHandleFile;

package/dist/file-filter.js

@@ -0,0 +1,123 @@
+// implements REQ-opencode-kibi-plugin-v1
+import { createRequire } from "node:module";
+import { existsSync, readFileSync } from "node:fs";
+import * as path from "node:path";
+const _require = createRequire(import.meta.url);
+// Lightweight fallback matcher if picomatch isn't installed.
+let picomatch;
+try {
+    picomatch = _require("picomatch");
+}
+catch {
+    picomatch = {
+        isMatch: (str, pattern) => {
+            // very small subset: handle simple **/*.md and exact matches
+            if (pattern === "**/*.md")
+                return str.endsWith(".md");
+            if (pattern.endsWith("/**/*.md")) {
+                const base = pattern.replace(/\/\*\*\/.+$/, "");
+                return str.startsWith(base) && str.endsWith(".md");
+            }
+            return str === pattern;
+        },
+    };
+}
+// Local copy of DEFAULT_SYNC_PATHS to avoid cross-package TS rootDir issues
+const DEFAULT_SYNC_PATHS = {
+    requirements: "requirements/**/*.md",
+    scenarios: "scenarios/**/*.md",
+    tests: "tests/**/*.md",
+    adr: "adr/**/*.md",
+    flags: "flags/**/*.md",
+    events: "events/**/*.md",
+    facts: "facts/**/*.md",
+    symbols: "symbols.yaml",
+};
+function loadSyncConfigLocal(cwd = process.cwd()) {
+    const configPath = path.join(cwd, ".kb/config.json");
+    let userConfig = {};
+    if (existsSync(configPath)) {
+        try {
+            userConfig = JSON.parse(readFileSync(configPath, "utf8")) || {};
+        }
+        catch {
+            userConfig = {};
+        }
+    }
+    return {
+        paths: {
+            ...DEFAULT_SYNC_PATHS,
+            ...(userConfig.paths ?? {}),
+        },
+        defaultBranch: userConfig.defaultBranch,
+    };
+}
+function loadKbSyncPaths(cwd = process.cwd()) {
+    const cfg = loadSyncConfigLocal(cwd);
+    return cfg.paths ?? DEFAULT_SYNC_PATHS;
+}
+function normalizePattern(p) {
+    if (!p)
+        return null;
+    // preserve explicit globs containing '*' or '/**'
+    if (p.includes("*"))
+        return p;
+    // symbols manifest is typically a file (yaml) - keep as-is
+    if (p.endsWith(".yaml") || p.endsWith(".yml") || path.extname(p))
+        return p;
+    // otherwise treat directory as markdown collection
+    return `${p.replace(/\/+$/, "")}/**/*.md`;
+}
+const DEFAULT_IGNORES = [
+    ".kb/**",
+    ".git/**",
+    "node_modules/**",
+    "dist/**",
+    "coverage/**",
+    ".opencode/**",
+    "**/*~",
+    "**/~*",
+    "**/.#*",
+    "**/*.swp",
+    "**/*.swo",
+    "**/.DS_Store",
+];
+// implements REQ-opencode-kibi-plugin-v1
+export function shouldHandleFile(filePath, cwd = process.cwd()) {
+    const rel = path.isAbsolute(filePath)
+        ? path.relative(cwd, filePath).split(path.sep).join("/")
+        : filePath.split(path.sep).join("/");
+    const paths = loadKbSyncPaths(cwd);
+    // Build include patterns from kibi paths
+    const includeCandidates = [
+        paths.requirements,
+        paths.scenarios,
+        paths.tests,
+        paths.adr,
+        paths.flags,
+        paths.events,
+        paths.facts,
+        paths.symbols,
+    ];
+    const includePatterns = includeCandidates
+        .map(normalizePattern)
+        .filter((p) => Boolean(p));
+    // default ignores then allow extension by .kb/config.json -> sync.ignore (not implemented here)
+    const ignorePatterns = DEFAULT_IGNORES;
+    // Compile matchers
+    const isIgnored = ignorePatterns.some((ig) => picomatch.isMatch(rel, ig));
+    if (isIgnored)
+        return false;
+    // If any include pattern matches, accept
+    const included = includePatterns.some((pat) => picomatch.isMatch(rel, pat));
+    if (included)
+        return true;
+    // If symbols path is configured as exact file and matches exactly, accept
+    if (paths.symbols) {
+        const sym = paths.symbols;
+        if (sym === rel || picomatch.isMatch(rel, sym))
+            return true;
+    }
+    return false;
+}
+export default shouldHandleFile;

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import * as config from "./config";
+import * as fileFilter from "./file-filter";
+import { SENTINEL, injectPrompt } from "./prompt";
+import { createSyncScheduler } from "./scheduler";
+import type { Hooks, Plugin, PluginInput } from "@opencode-ai/plugin";
+export type { Plugin, PluginInput, Hooks };
+declare const kibiOpencodePlugin: Plugin;
+export default kibiOpencodePlugin;
+export { config, fileFilter, createSyncScheduler, injectPrompt, SENTINEL };

package/dist/index.js

@@ -0,0 +1,64 @@
+import * as config from "./config";
+import * as fileFilter from "./file-filter";
+import * as logger from "./logger";
+import { SENTINEL, injectPrompt } from "./prompt";
+import { createSyncScheduler } from "./scheduler";
+let scheduler = null;
+let cfg = null;
+// implements REQ-opencode-kibi-plugin-v1
+const kibiOpencodePlugin = async (input) => {
+    // Load config
+    cfg = config.loadConfig(input.directory);
+    if (!cfg.enabled) {
+        logger.info("kibi-opencode: disabled via config");
+        return {};
+    }
+    logger.info("kibi-opencode: setting up hooks");
+    const hooks = {};
+    // Setup file-edit triggered sync via event hook
+    if (cfg.sync.enabled) {
+        const schedulerOpts = {
+            worktree: input.worktree,
+            config: cfg,
+        };
+        scheduler = createSyncScheduler(schedulerOpts);
+        hooks.event = async ({ event }) => {
+            if (event.type !== "file.edited")
+                return;
+            const filePath = event.properties.file;
+            if (!filePath)
+                return;
+            if (!fileFilter.shouldHandleFile(filePath, input.worktree))
+                return;
+            logger.info(`kibi-opencode: scheduling sync for ${filePath}`);
+            scheduler.scheduleSync("file.edited", filePath);
+        };
+    }
+    // Setup prompt injection hook
+    if (cfg.prompt.enabled) {
+        const hookMode = cfg.prompt.hookMode;
+        if (hookMode === "system-transform" || hookMode === "auto") {
+            hooks["experimental.chat.system.transform"] = async (_input, output) => {
+                const currentSystem = output.system.join("\n");
+                const injected = injectPrompt(currentSystem, cfg);
+                output.system.length = 0;
+                output.system.push(injected);
+            };
+        }
+        if (hookMode === "chat-params" || hookMode === "auto") {
+            hooks["chat.params"] = async (_input, _output) => {
+                // chat.params only exposes model options, not prompt text.
+                // In auto mode the system.transform hook handles injection;
+                // this hook is a no-op but kept registered so OpenCode knows
+                // the plugin is active.
+                if (hookMode === "auto") {
+                    logger.info("kibi-opencode: chat.params hook active (prompt injection via system.transform)");
+                }
+            };
+        }
+    }
+    logger.info("kibi-opencode: setup complete");
+    return hooks;
+};
+export default kibiOpencodePlugin;
+export { config, fileFilter, createSyncScheduler, injectPrompt, SENTINEL };

package/dist/logger.d.ts

@@ -0,0 +1,3 @@
+export declare function info(msg: string): void;
+export declare function warn(msg: string): void;
+export declare function error(msg: string): void;

package/dist/logger.js

@@ -0,0 +1,11 @@
+// implements REQ-opencode-kibi-plugin-v1
+export function info(msg) {
+    console.log("[kibi-opencode]", msg);
+}
+export function warn(msg) {
+    console.warn("[kibi-opencode]", msg);
+}
+// implements REQ-opencode-kibi-plugin-v1
+export function error(msg) {
+    console.error("[kibi-opencode]", msg);
+}

package/dist/prompt.d.ts

@@ -0,0 +1,5 @@
+import type { KibiConfig } from "./config";
+declare const SENTINEL = "<!-- kibi-opencode -->";
+export declare function buildPrompt(): string;
+export declare function injectPrompt(current: string, config: KibiConfig): string;
+export { SENTINEL };

package/dist/prompt.js

@@ -0,0 +1,35 @@
+import { isPluginEnabled } from "./config";
+const SENTINEL = "<!-- kibi-opencode -->";
+const GUIDANCE = `${SENTINEL}
+This project uses Kibi (via MCP). Prefer storing durable knowledge in Kibi over code comments.
+
+Before changing behavior: query Kibi by sourceFile, id, type, or tags; do not rely on undocumented tools.
+
+Keep changed symbols traceable: add \`// implements REQ-xxx\` to every new or modified function/class so the pre-commit hook can verify coverage.
+
+Run kb_check after KB mutations.
+
+**Kibi-first workflow:**
+1. **Discover**: Run kb_query with filters (sourceFile, type, tags) to find related requirements, ADRs, tests, and symbols.
+2. **Document intent**: If you are about to explain code, STOP. Route that explanation to kb_upsert instead of inline comments.
+3. **Link during work**: When creating KB entities, include relationship rows: specified_by (req→scenario), verified_by (req→test), implements (symbol→req), covered_by (symbol→test).
+4. **Validate**: Run kb_check after KB mutations to catch violations early.
+
+**Public Kibi tools only:** kb_query, kb_upsert, kb_delete, kb_check.
+
+Bootstrap existing repos: use \`/init-kibi\` to run the retroactive initialization workflow.`;
+// implements REQ-opencode-kibi-plugin-v1
+export function buildPrompt() {
+    return GUIDANCE.trim();
+}
+// implements REQ-opencode-kibi-plugin-v1
+export function injectPrompt(current, config) {
+    if (!config.prompt.enabled || !isPluginEnabled(config)) {
+        return current;
+    }
+    if (current.includes(SENTINEL)) {
+        return current;
+    }
+    return `${current}\n\n${buildPrompt()}`;
+}
+export { SENTINEL };

package/dist/scheduler.d.ts

@@ -0,0 +1,31 @@
+import type { KibiConfig } from "./config";
+type TimeoutHandle = ReturnType<typeof setTimeout>;
+export interface SyncRunMetadata {
+    reason: string;
+    worktree: string;
+    filePath?: string;
+    debounceWindowMs: number;
+    durationMs: number;
+    exitCode: number;
+}
+type SyncRunner = (worktree: string) => Promise<{
+    exitCode: number;
+}>;
+export interface SchedulerOptions {
+    worktree: string;
+    config: KibiConfig;
+    runSync?: SyncRunner;
+    now?: () => number;
+    setTimeoutFn?: (fn: () => void, ms: number) => TimeoutHandle;
+    clearTimeoutFn?: (handle: TimeoutHandle) => void;
+    onRunComplete?: (meta: SyncRunMetadata) => void;
+    enableToolExecuteAfterHint?: boolean;
+}
+export interface SyncScheduler {
+    scheduleSync(reason: string, filePath?: string): void;
+    onFileEdited(filePath: string): void;
+    onToolExecuteAfter(reason?: string): void;
+    dispose(): void;
+}
+export declare function createSyncScheduler(opts: SchedulerOptions): SyncScheduler;
+export {};

package/dist/scheduler.js

@@ -0,0 +1,151 @@
+import { exec } from "node:child_process";
+import path from "node:path";
+import { shouldHandleFile } from "./file-filter";
+import * as logger from "./logger";
+class WorktreeSyncScheduler {
+    worktree;
+    now;
+    setTimeoutFn;
+    clearTimeoutFn;
+    runSync;
+    config;
+    onRunComplete;
+    explicitToolAfterHint;
+    timer = null;
+    inFlight = false;
+    dirty = false;
+    pending = null;
+    trailing = null;
+    lastFileEditedAt = 0;
+    constructor(opts) {
+        this.worktree = path.resolve(opts.worktree);
+        this.config = opts.config;
+        this.now = opts.now ?? Date.now;
+        this.setTimeoutFn = opts.setTimeoutFn ?? setTimeout;
+        this.clearTimeoutFn = opts.clearTimeoutFn ?? clearTimeout;
+        this.runSync = opts.runSync ?? runKibiSync;
+        this.onRunComplete = opts.onRunComplete;
+        this.explicitToolAfterHint = Boolean(opts.enableToolExecuteAfterHint);
+    }
+    scheduleSync(reason, filePath) {
+        if (!this.config.sync.enabled)
+            return;
+        if (reason === "file.edited") {
+            if (!filePath)
+                return;
+            if (!shouldHandleFile(filePath, this.worktree))
+                return;
+            this.lastFileEditedAt = this.now();
+        }
+        this.pending = { reason, filePath };
+        if (this.timer)
+            this.clearTimeoutFn(this.timer);
+        this.timer = this.setTimeoutFn(() => {
+            this.timer = null;
+            this.flushPending();
+        }, this.config.sync.debounceMs);
+    }
+    onFileEdited(filePath) {
+        this.scheduleSync("file.edited", filePath);
+    }
+    onToolExecuteAfter(reason = "tool.execute.after") {
+        // Only proceed if tool.after notifications are enabled
+        if (!this.isToolExecuteAfterEnabled())
+            return;
+        // Reset debounce window by setting lastFileEditedAt to now
+        // This ensures the check at lines 97-100 won't allow sync through
+        const now = this.now();
+        this.lastFileEditedAt = now;
+        // Debounce check - if we just reset lastFileEditedAt, it will fail
+        if (now - this.lastFileEditedAt <= this.config.sync.debounceMs) {
+            return;
+        }
+        // Tool.after hint takes priority - skip sync scheduling when explicitly set to false
+        if (!this.explicitToolAfterHint) {
+            this.scheduleSync(reason);
+        }
+    }
+    dispose() {
+        if (this.timer) {
+            this.clearTimeoutFn(this.timer);
+            this.timer = null;
+        }
+    }
+    isToolExecuteAfterEnabled() {
+        if (this.explicitToolAfterHint)
+            return true;
+        return this.config.prompt.hookMode === "compat";
+    }
+    flushPending() {
+        if (!this.pending)
+            return;
+        const trigger = this.pending;
+        this.pending = null;
+        if (this.inFlight) {
+            this.dirty = true;
+            this.trailing = trigger;
+            return;
+        }
+        this.startRun(trigger);
+    }
+    startRun(trigger) {
+        this.inFlight = true;
+        const startedAt = this.now();
+        logger.info(`sync.started ${JSON.stringify({
+            reason: trigger.reason,
+            worktree: this.worktree,
+            filePath: trigger.filePath,
+            debounceWindowMs: this.config.sync.debounceMs,
+        })}`);
+        void this.runSync(this.worktree)
+            .then(({ exitCode }) => {
+            this.emitCompletion(trigger, startedAt, exitCode);
+        })
+            .catch((err) => {
+            const message = err instanceof Error ? err.message : String(err);
+            logger.error(`sync.failed ${message}`);
+            this.emitCompletion(trigger, startedAt, 1);
+        })
+            .finally(() => {
+            this.inFlight = false;
+            if (!this.dirty)
+                return;
+            const trailing = this.trailing ?? { reason: "sync.trailing" };
+            this.dirty = false;
+            this.trailing = null;
+            this.startRun({
+                reason: `${trailing.reason}.trailing`,
+                filePath: trailing.filePath,
+            });
+        });
+    }
+    emitCompletion(trigger, startedAt, exitCode) {
+        const durationMs = Math.max(0, this.now() - startedAt);
+        const meta = {
+            reason: trigger.reason,
+            worktree: this.worktree,
+            filePath: trigger.filePath,
+            debounceWindowMs: this.config.sync.debounceMs,
+            durationMs,
+            exitCode,
+        };
+        if (exitCode === 0) {
+            logger.info(`sync.succeeded ${JSON.stringify(meta)}`);
+        }
+        else {
+            logger.warn(`sync.failed ${JSON.stringify(meta)}`);
+        }
+        this.onRunComplete?.(meta);
+    }
+}
+async function runKibiSync(worktree) {
+    return new Promise((resolve) => {
+        exec("kibi sync", { cwd: worktree }, (error) => {
+            resolve({ exitCode: error ? (error.code ?? 1) : 0 });
+        });
+    });
+}
+// implements REQ-opencode-kibi-plugin-v1
+export function createSyncScheduler(opts) {
+    return new WorktreeSyncScheduler(opts);
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "kibi-opencode",
+  "version": "0.3.1",
+  "description": "Kibi OpenCode plugin - thin adapter to integrate Kibi with OpenCode sessions",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "AGPL-3.0-or-later",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Looted/kibi.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsc -p tsconfig.json --watch",
+    "clean": "rm -rf dist",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "^1.2.26"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  }
+}