kibi-opencode 0.15.4 → 0.16.0

package/README.md

@@ -22,6 +22,23 @@ Or via OpenCode's plugin system in `opencode.json`:
 }
 ```
 
+By default, the plugin checks npm on OpenCode startup and refreshes only the
+cached `kibi-opencode` plugin package when a newer version is available. The
+base `kibi-cli`, `kibi-mcp`, and `kibi-core` project dependencies are never
+updated by this plugin updater.
+
+Use an exact semver entry when you want a fixed plugin version:
+
+```json
+{
+  "plugin": ["kibi-opencode@0.15.0"]
+}
+```
+
+Exact semver pins are respected: the updater will notify that a newer plugin is
+available, but it will not replace the pinned version until you change the
+plugin array. Dist-tags such as `kibi-opencode@latest` remain auto-updatable.
+
 Configure the MCP server separately with the project-local `kibi-mcp` binary.
 The plugin may run internal maintenance commands such as `kibi sync` and
 `kibi check`, so the project-local `kibi` CLI should resolve from the OpenCode
@@ -177,6 +194,7 @@ Config files (project overrides global):
 | Key | Type | Default | Description |
 |-----|------|---------|-------------|
 | `enabled` | boolean | `true` | Enable/disable all plugin features |
+| `autoUpdate` | boolean | `true` | Automatically refresh the cached `kibi-opencode` plugin package on OpenCode startup unless the plugin array uses an exact semver pin |
 | `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 |
@@ -187,7 +205,6 @@ Config files (project overrides global):
 | `ux.toastFailures` | boolean | `true` | Show failure toasts for sync/check issues |
 | `ux.toastSuccesses` | boolean | `false` | Show success toasts for sync/check completion |
 | `ux.toastCooldownMs` | number | `10000` | Cooldown between repeated UX toasts |
-PP|| `guidance.dynamic` | boolean | `true` | Enable dynamic contextual guidance |
 | `guidance.dynamic` | boolean | `true` | Enable dynamic contextual guidance |
 | `guidance.warnOnKbEdits` | boolean | `true` | Enable loud warnings for .kb/** edits |
 | `guidance.factFirstDomainRouting` | boolean | `true` | Enable FACT-first domain routing suggestions |

package/dist/auto-update.d.ts

@@ -0,0 +1,31 @@
+export interface KibiOpencodePluginEntry {
+    entry: string;
+    isPinned: boolean;
+    requestedVersion: string | null;
+    configPath: string;
+}
+export type AutoUpdateStatus = "disabled" | "plugin-not-found" | "current-version-unknown" | "latest-version-unknown" | "up-to-date" | "pinned" | "updated" | "install-failed";
+export interface AutoUpdateResult {
+    status: AutoUpdateStatus;
+    currentVersion?: string;
+    latestVersion?: string;
+}
+export interface AutoUpdateInput {
+    directory: string;
+    enabled: boolean;
+}
+export interface AutoUpdateRunnerDeps {
+    getCurrentVersion: () => string | null;
+    getLatestVersion: (channel?: string) => Promise<string | null>;
+    invalidatePackage: () => boolean;
+    runInstall: () => Promise<boolean>;
+    notify: (message: string) => Promise<void>;
+    log: (message: string, metadata?: Record<string, unknown>) => void;
+}
+export declare function findKibiOpencodePluginEntry(directory: string): KibiOpencodePluginEntry | null;
+export declare function getCachedPluginVersion(): string | null;
+export declare function getLatestPluginVersion(channel?: string): Promise<string | null>;
+export declare function invalidateKibiOpencodePackage(): boolean;
+export declare function runBunInstallForOpenCodePlugin(): Promise<boolean>;
+export declare function createAutoUpdateRunner(deps: AutoUpdateRunnerDeps): (input: AutoUpdateInput) => Promise<AutoUpdateResult>;
+export declare const runKibiOpencodeAutoUpdate: (input: AutoUpdateInput) => Promise<AutoUpdateResult>;

package/dist/auto-update.js

@@ -0,0 +1,396 @@
+import { execFile } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import * as logger from "./logger.js";
+const PACKAGE_NAME = "kibi-opencode";
+const NPM_DIST_TAGS_URL = `https://registry.npmjs.org/-/package/${PACKAGE_NAME}/dist-tags`;
+const NPM_FETCH_TIMEOUT_MS = 5000;
+const EXACT_SEMVER_REGEX = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+function parseJsonObject(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+        return null;
+    }
+    catch (err) {
+        logger.info("auto-update: failed to parse JSON", {
+            error: err instanceof Error ? err.message : String(err),
+        });
+        return null;
+    }
+}
+function stripJsonComments(raw) {
+    return raw.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|\s)\/\/.*$/gm, "$1");
+}
+function configPaths(directory) {
+    const home = os.homedir();
+    return [
+        path.join(directory, "opencode.json"),
+        path.join(directory, "opencode.jsonc"),
+        path.join(directory, ".opencode", "opencode.json"),
+        path.join(directory, ".opencode", "opencode.jsonc"),
+        path.join(home, ".config", "opencode", "opencode.json"),
+        path.join(home, ".config", "opencode", "opencode.jsonc"),
+    ];
+}
+export function findKibiOpencodePluginEntry(directory) {
+    for (const configPath of configPaths(directory)) {
+        if (!fs.existsSync(configPath)) {
+            continue;
+        }
+        const parsed = parseJsonObject(stripJsonComments(fs.readFileSync(configPath, "utf8")));
+        const plugins = parsed?.plugin;
+        if (!Array.isArray(plugins)) {
+            continue;
+        }
+        for (const candidate of plugins) {
+            if (typeof candidate !== "string") {
+                continue;
+            }
+            if (candidate === PACKAGE_NAME) {
+                return {
+                    entry: candidate,
+                    isPinned: false,
+                    requestedVersion: null,
+                    configPath,
+                };
+            }
+            if (candidate.startsWith(`${PACKAGE_NAME}@`)) {
+                const requestedVersion = candidate
+                    .slice(PACKAGE_NAME.length + 1)
+                    .trim();
+                return {
+                    entry: candidate,
+                    isPinned: EXACT_SEMVER_REGEX.test(requestedVersion),
+                    requestedVersion,
+                    configPath,
+                };
+            }
+            if (candidate.startsWith("file://") && candidate.includes(PACKAGE_NAME)) {
+                return {
+                    entry: candidate,
+                    isPinned: true,
+                    requestedVersion: null,
+                    configPath,
+                };
+            }
+        }
+    }
+    return null;
+}
+function getOpenCodeConfigDir() {
+    if (process.platform === "win32") {
+        const appData = process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming");
+        return path.join(appData, "opencode");
+    }
+    return path.join(os.homedir(), ".config", "opencode");
+}
+function getOpenCodeCacheRoot() {
+    if (process.platform === "win32") {
+        const localAppData = process.env.LOCALAPPDATA ?? path.join(os.homedir(), "AppData", "Local");
+        return path.join(localAppData, "opencode");
+    }
+    if (process.platform === "darwin") {
+        return path.join(os.homedir(), "Library", "Caches", "opencode");
+    }
+    return path.join(process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), ".cache"), "opencode");
+}
+function getOpenCodePackagesCacheDir() {
+    return path.join(getOpenCodeCacheRoot(), "packages");
+}
+function parseSemver(version) {
+    const match = version.match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/);
+    if (!match) {
+        return null;
+    }
+    const major = Number(match[1]);
+    const minor = Number(match[2]);
+    const patch = Number(match[3]);
+    if (!Number.isInteger(major) ||
+        !Number.isInteger(minor) ||
+        !Number.isInteger(patch)) {
+        return null;
+    }
+    return {
+        core: [major, minor, patch],
+        prerelease: match[4]?.split(".") ?? [],
+    };
+}
+function isNumericPrereleaseIdentifier(value) {
+    return /^(0|[1-9]\d*)$/.test(value);
+}
+function comparePrereleaseIdentifiers(left, right) {
+    const leftIsNumeric = isNumericPrereleaseIdentifier(left);
+    const rightIsNumeric = isNumericPrereleaseIdentifier(right);
+    if (leftIsNumeric && rightIsNumeric) {
+        return Number(left) - Number(right);
+    }
+    if (leftIsNumeric) {
+        return -1;
+    }
+    if (rightIsNumeric) {
+        return 1;
+    }
+    return left.localeCompare(right, "en", { sensitivity: "variant" });
+}
+function comparePrerelease(left, right) {
+    if (left.length === 0 && right.length === 0) {
+        return 0;
+    }
+    if (left.length === 0) {
+        return 1;
+    }
+    if (right.length === 0) {
+        return -1;
+    }
+    const maxLength = Math.max(left.length, right.length);
+    for (let index = 0; index < maxLength; index += 1) {
+        const leftPart = left[index];
+        const rightPart = right[index];
+        if (leftPart === undefined) {
+            return -1;
+        }
+        if (rightPart === undefined) {
+            return 1;
+        }
+        const comparison = comparePrereleaseIdentifiers(leftPart, rightPart);
+        if (comparison !== 0) {
+            return comparison;
+        }
+    }
+    return 0;
+}
+function isSemverGreaterThan(candidate, current) {
+    const candidateVersion = parseSemver(candidate);
+    const currentVersion = parseSemver(current);
+    if (!candidateVersion || !currentVersion) {
+        return false;
+    }
+    for (const index of [0, 1, 2]) {
+        if (candidateVersion.core[index] > currentVersion.core[index]) {
+            return true;
+        }
+        if (candidateVersion.core[index] < currentVersion.core[index]) {
+            return false;
+        }
+    }
+    return (comparePrerelease(candidateVersion.prerelease, currentVersion.prerelease) >
+        0);
+}
+function readVersionFromPackageJson(packageJsonPath) {
+    if (!fs.existsSync(packageJsonPath)) {
+        return null;
+    }
+    const parsed = parseJsonObject(fs.readFileSync(packageJsonPath, "utf8"));
+    return typeof parsed?.version === "string" ? parsed.version : null;
+}
+function findPackageJsonUp(startUrl) {
+    let current = path.dirname(fileURLToPath(startUrl));
+    while (true) {
+        const packageJsonPath = path.join(current, "package.json");
+        if (fs.existsSync(packageJsonPath)) {
+            const parsed = parseJsonObject(fs.readFileSync(packageJsonPath, "utf8"));
+            if (parsed?.name === PACKAGE_NAME) {
+                return packageJsonPath;
+            }
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return null;
+        }
+        current = parent;
+    }
+}
+export function getCachedPluginVersion() {
+    const packageJsonCandidates = [
+        path.join(getOpenCodeConfigDir(), "node_modules", PACKAGE_NAME, "package.json"),
+        path.join(getOpenCodeCacheRoot(), "node_modules", PACKAGE_NAME, "package.json"),
+        path.join(getOpenCodePackagesCacheDir(), "node_modules", PACKAGE_NAME, "package.json"),
+    ];
+    for (const candidate of packageJsonCandidates) {
+        const version = readVersionFromPackageJson(candidate);
+        if (version) {
+            return version;
+        }
+    }
+    const runningPackageJson = findPackageJsonUp(import.meta.url);
+    return runningPackageJson
+        ? readVersionFromPackageJson(runningPackageJson)
+        : null;
+}
+export async function getLatestPluginVersion(channel = "latest") {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), NPM_FETCH_TIMEOUT_MS);
+    try {
+        const response = await fetch(NPM_DIST_TAGS_URL, {
+            signal: controller.signal,
+            headers: { Accept: "application/json" },
+        });
+        if (!response.ok) {
+            return null;
+        }
+        const tags = (await response.json());
+        const selected = tags[channel] ?? tags.latest;
+        return typeof selected === "string" ? selected : null;
+    }
+    catch (err) {
+        logger.info("auto-update: failed to fetch latest version", {
+            error: err instanceof Error ? err.message : String(err),
+        });
+        return null;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function removePackageDir(dir) {
+    if (!fs.existsSync(dir)) {
+        return false;
+    }
+    fs.rmSync(dir, { recursive: true, force: true });
+    return true;
+}
+function removeSpecifierCacheDirs(cacheDir) {
+    if (!fs.existsSync(cacheDir)) {
+        return false;
+    }
+    let removed = false;
+    for (const entry of fs.readdirSync(cacheDir, { withFileTypes: true })) {
+        if (entry.isDirectory() && entry.name.startsWith(`${PACKAGE_NAME}@`)) {
+            fs.rmSync(path.join(cacheDir, entry.name), {
+                recursive: true,
+                force: true,
+            });
+            removed = true;
+        }
+    }
+    return removed;
+}
+function removeEveryPath(paths) {
+    let removed = false;
+    for (const targetPath of paths) {
+        if (removePackageDir(targetPath)) {
+            removed = true;
+        }
+    }
+    return removed;
+}
+function removeSpecifiersFromEveryDir(dirs) {
+    let removed = false;
+    for (const dir of dirs) {
+        if (removeSpecifierCacheDirs(dir)) {
+            removed = true;
+        }
+    }
+    return removed;
+}
+export function invalidateKibiOpencodePackage() {
+    const configDir = getOpenCodeConfigDir();
+    const cacheRoot = getOpenCodeCacheRoot();
+    const packagesCacheDir = getOpenCodePackagesCacheDir();
+    const removedPackageDirs = removeEveryPath([
+        path.join(configDir, "node_modules", PACKAGE_NAME),
+        path.join(cacheRoot, "node_modules", PACKAGE_NAME),
+        path.join(packagesCacheDir, "node_modules", PACKAGE_NAME),
+    ]);
+    const removedSpecifierDirs = removeSpecifiersFromEveryDir([
+        cacheRoot,
+        packagesCacheDir,
+    ]);
+    const removedLock = removeEveryPath([
+        path.join(cacheRoot, "bun.lock"),
+        path.join(cacheRoot, "bun.lockb"),
+        path.join(packagesCacheDir, "bun.lock"),
+        path.join(packagesCacheDir, "bun.lockb"),
+    ]);
+    return removedPackageDirs || removedSpecifierDirs || removedLock;
+}
+function activeInstallWorkspace() {
+    const configDir = getOpenCodeConfigDir();
+    const cacheRoot = getOpenCodeCacheRoot();
+    const packagesCacheDir = getOpenCodePackagesCacheDir();
+    if (fs.existsSync(path.join(configDir, "node_modules", PACKAGE_NAME, "package.json"))) {
+        return configDir;
+    }
+    if (fs.existsSync(path.join(cacheRoot, "node_modules", PACKAGE_NAME, "package.json"))) {
+        return cacheRoot;
+    }
+    return packagesCacheDir;
+}
+export function runBunInstallForOpenCodePlugin() {
+    return new Promise((resolve) => {
+        const workspace = activeInstallWorkspace();
+        fs.mkdirSync(workspace, { recursive: true });
+        execFile("bun", ["install"], { cwd: workspace }, (error) => {
+            resolve(error === null);
+        });
+    });
+}
+function channelForEntry(entry) {
+    if (!entry.requestedVersion || entry.isPinned) {
+        return "latest";
+    }
+    return entry.requestedVersion;
+}
+export function createAutoUpdateRunner(deps) {
+    return async function runAutoUpdate(input) {
+        if (!input.enabled) {
+            deps.log("auto-update: disabled");
+            return { status: "disabled" };
+        }
+        const pluginEntry = findKibiOpencodePluginEntry(input.directory);
+        if (!pluginEntry) {
+            deps.log("auto-update: kibi-opencode plugin entry not found");
+            return { status: "plugin-not-found" };
+        }
+        const currentVersion = deps.getCurrentVersion() ?? pluginEntry.requestedVersion;
+        if (!currentVersion) {
+            deps.log("auto-update: current version unknown");
+            return { status: "current-version-unknown" };
+        }
+        const latestVersion = await deps.getLatestVersion(channelForEntry(pluginEntry));
+        if (!latestVersion) {
+            deps.log("auto-update: latest version unknown");
+            return { status: "latest-version-unknown", currentVersion };
+        }
+        if (currentVersion === latestVersion ||
+            !isSemverGreaterThan(latestVersion, currentVersion)) {
+            deps.log("auto-update: plugin already up to date", {
+                currentVersion,
+                latestVersion,
+            });
+            return { status: "up-to-date", currentVersion, latestVersion };
+        }
+        if (pluginEntry.isPinned) {
+            await deps.notify(`${PACKAGE_NAME} ${latestVersion} is available; current plugin entry is pinned to ${currentVersion}.`);
+            deps.log("auto-update: exact semver pin detected, skipping install", {
+                currentVersion,
+                latestVersion,
+                entry: pluginEntry.entry,
+            });
+            return { status: "pinned", currentVersion, latestVersion };
+        }
+        deps.invalidatePackage();
+        const installed = await deps.runInstall();
+        if (!installed) {
+            await deps.notify(`${PACKAGE_NAME} ${latestVersion} is available, but automatic install failed.`);
+            return { status: "install-failed", currentVersion, latestVersion };
+        }
+        await deps.notify(`${PACKAGE_NAME} updated from ${currentVersion} to ${latestVersion}. Restart OpenCode to apply.`);
+        return { status: "updated", currentVersion, latestVersion };
+    };
+}
+export const runKibiOpencodeAutoUpdate = createAutoUpdateRunner({
+    getCurrentVersion: getCachedPluginVersion,
+    getLatestVersion: getLatestPluginVersion,
+    invalidatePackage: invalidateKibiOpencodePackage,
+    runInstall: runBunInstallForOpenCodePlugin,
+    notify: async (message) => {
+        logger.info("auto-update.notification", { message });
+    },
+    log: (message, metadata) => logger.info(message, metadata),
+});

package/dist/config.d.ts

@@ -1,5 +1,6 @@
 export interface KibiConfig {
     enabled: boolean;
+    autoUpdate: boolean;
     prompt: {
         enabled: boolean;
         hookMode: "auto" | "chat-params" | "system-transform" | "compat";

package/dist/config.js

@@ -4,6 +4,7 @@ import path from "node:path";
 import * as logger from "./logger.js";
 const DEFAULTS = {
     enabled: true,
+    autoUpdate: true,
     prompt: { enabled: true, hookMode: "auto" },
     sync: { enabled: true, debounceMs: 2000, ignore: [], relevant: [] },
     ux: {
@@ -64,6 +65,8 @@ export function validateAndMerge(obj) {
     const out = { ...DEFAULTS };
     if (typeof src.enabled === "boolean")
         out.enabled = src.enabled;
+    if (typeof src.autoUpdate === "boolean")
+        out.autoUpdate = src.autoUpdate;
     if (src.prompt && typeof src.prompt === "object") {
         const p = src.prompt;
         out.prompt = { ...DEFAULTS.prompt };

package/dist/plugin.js

@@ -1,4 +1,5 @@
 import * as path from "node:path";
+import { createAutoUpdateRunner, getLatestPluginVersion, invalidateKibiOpencodePackage, runBunInstallForOpenCodePlugin, } from "./auto-update.js";
 import { analyzeCodeFile, } from "./comment-analysis.js";
 import { getE2eCoverageSignal } from "./e2e-coverage-signals.js"; // implements REQ-opencode-file-context-guidance-v1
 import { buildDirtyRelevantFingerprint, buildEnforcementScopeKey, } from "./enforcement-scope.js";
@@ -20,6 +21,7 @@ import { createSyncScheduler } from "./scheduler.js";
 import { createSessionEditState, } from "./session-edit-state.js";
 import { getSessionTracker } from "./session-tracker.js";
 import { notifyStartup, } from "./startup-notifier.js";
+import { sendToast, } from "./toast.js";
 import { readKibiPackageVersions } from "./version-metadata.js";
 import { resolveWorkContext, } from "./work-context-resolver.js";
 import * as fs from "node:fs";
@@ -1044,7 +1046,7 @@ const kibiOpencodePlugin = async (input) => {
         }
     }
     logger.info("kibi-opencode: setup complete");
-    if (input.client && !maintenanceDegraded) {
+    if (input.client) {
         const client = input.client;
         const scheduleStartupNotify = startupNotifyGlobals.__kibi_test_schedule_startup_notify ??
             ((callback, delayMs) => {
@@ -1057,11 +1059,40 @@ const kibiOpencodePlugin = async (input) => {
                 if (meta[key] !== "unknown")
                     versions[key] = meta[key];
             }
-            notifyStartup(makeStartupClient(client), {
-                suppressToast: cfg.ux.toastStartup === false,
+            if (!maintenanceDegraded) {
+                notifyStartup(makeStartupClient(client), {
+                    suppressToast: cfg.ux.toastStartup === false,
+                    directory: input.directory,
+                    ...(Object.keys(versions).length > 0 ? { versions } : {}),
+                    versionMetadataSource: meta.source,
+                });
+            }
+            const autoUpdateRunner = createAutoUpdateRunner({
+                getCurrentVersion: () => meta.opencode === "unknown" ? null : meta.opencode,
+                getLatestVersion: getLatestPluginVersion,
+                invalidatePackage: invalidateKibiOpencodePackage,
+                runInstall: runBunInstallForOpenCodePlugin,
+                notify: async (message) => {
+                    if (cfg.ux.toastStartup !== false) {
+                        await sendToast(makeToastClient(client), {
+                            variant: "info",
+                            title: "Kibi OpenCode",
+                            message,
+                            duration: 8000,
+                        });
+                    }
+                    logger.info("auto-update.notification", { message });
+                },
+                log: (message, metadata) => logger.info(message, metadata),
+            });
+            const runAutoUpdate = startupNotifyGlobals.__kibi_test_auto_update_runner ?? autoUpdateRunner;
+            void runAutoUpdate({
                 directory: input.directory,
-                ...(Object.keys(versions).length > 0 ? { versions } : {}),
-                versionMetadataSource: meta.source,
+                enabled: cfg.autoUpdate,
+            }).catch((err) => {
+                logger.info("auto-update: background update check failed", {
+                    error: err instanceof Error ? err.message : String(err),
+                });
             });
         }, 2000);
     }

package/dist/version-metadata.json

@@ -1 +1 @@
-{"opencode":"0.15.4","mcp":"0.15.3","cli":"0.12.3","core":"0.6.0"}
+{"opencode":"0.16.0","mcp":"0.16.0","cli":"0.12.4","core":"0.6.0"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-opencode",
-  "version": "0.15.4",
+  "version": "0.16.0",
   "description": "Kibi OpenCode plugin - thin adapter to integrate Kibi with OpenCode sessions",
   "type": "module",
   "main": "dist/index.js",
@@ -37,7 +37,9 @@
       "default": "./dist/tui.js"
     }
   },
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "engines": {
     "node": ">=18"
   },