kibi-opencode 1.0.0 → 2.0.1

package/dist/auto-update.d.ts

@@ -23,9 +23,11 @@ export interface AutoUpdateRunnerDeps {
     log: (message: string, metadata?: Record<string, unknown>) => void;
 }
 export declare function findKibiOpencodePluginEntry(directory: string): KibiOpencodePluginEntry | null;
+export declare function findPackageJsonUp(startUrl: string): string | 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 function notifyAutoUpdate(message: string): Promise<void>;
 export declare const runKibiOpencodeAutoUpdate: (input: AutoUpdateInput) => Promise<AutoUpdateResult>;

package/dist/auto-update.js

@@ -188,7 +188,7 @@ function readVersionFromPackageJson(packageJsonPath) {
     const parsed = parseJsonObject(fs.readFileSync(packageJsonPath, "utf8"));
     return typeof parsed?.version === "string" ? parsed.version : null;
 }
-function findPackageJsonUp(startUrl) {
+export function findPackageJsonUp(startUrl) {
     let current = path.dirname(fileURLToPath(startUrl));
     while (true) {
         const packageJsonPath = path.join(current, "package.json");
@@ -384,13 +384,14 @@ export function createAutoUpdateRunner(deps) {
         return { status: "updated", currentVersion, latestVersion };
     };
 }
+export async function notifyAutoUpdate(message) {
+    logger.info("auto-update.notification", { message });
+}
 export const runKibiOpencodeAutoUpdate = createAutoUpdateRunner({
     getCurrentVersion: getCachedPluginVersion,
     getLatestVersion: getLatestPluginVersion,
     invalidatePackage: invalidateKibiOpencodePackage,
     runInstall: runBunInstallForOpenCodePlugin,
-    notify: async (message) => {
-        logger.info("auto-update.notification", { message });
-    },
+    notify: notifyAutoUpdate,
     log: (message, metadata) => logger.info(message, metadata),
 });

package/dist/enforcement-policy.d.ts

@@ -47,6 +47,11 @@ export interface EnforcementPolicyInput {
     /** Posture fallback when resolvedContext is unavailable. */
     posture?: RepoPosture | undefined;
 }
+export interface NormalizedPolicyEvent extends EnforcementLifecycleEvent {
+    pathKind: PathKind;
+    linkedEntityResult: PolicyLinkedEntityResult;
+    e2eSignal: E2eCoverageSignal;
+}
 interface EnforcementPolicyResultBase {
     affectedPaths: string[];
     dirtyFileCount: number;
@@ -70,4 +75,9 @@ export type EnforcementPolicyResult = (EnforcementPolicyResultBase & {
     text: null;
 });
 export declare function computeEnforcementPolicy(input: EnforcementPolicyInput): EnforcementPolicyResult;
+export declare function advisoryResultFromEvents(relevantEvents: readonly NormalizedPolicyEvent[], extras: {
+    affectedPaths: string[];
+    e2eReminder: string | null;
+    reminderKindsToMark: ReminderKind[];
+}): EnforcementPolicyResult;
 export {};

package/dist/enforcement-policy.js

@@ -266,23 +266,33 @@ export function computeEnforcementPolicy(input) {
             text: null,
         };
     }
+    return advisoryResultFromEvents(relevantEvents, {
+        affectedPaths,
+        e2eReminder,
+        reminderKindsToMark,
+    });
+}
+// Defensive empty-list checkpoint. `computeEnforcementPolicy` returns earlier
+// when `relevantEvents` is empty; tests call this helper directly so the
+// branch stays executable and covered.
+export function advisoryResultFromEvents(relevantEvents, extras) {
     const firstRelevantEvent = relevantEvents[0];
     if (!firstRelevantEvent) {
         return {
             kind: "checkpoint_passed",
-            affectedPaths,
+            affectedPaths: extras.affectedPaths,
             dirtyFileCount: 0,
-            e2eReminder,
-            reminderKindsToMark,
+            e2eReminder: extras.e2eReminder,
+            reminderKindsToMark: extras.reminderKindsToMark,
             text: null,
         };
     }
     return {
         kind: "advisory_guidance",
-        affectedPaths,
+        affectedPaths: extras.affectedPaths,
         dirtyFileCount: relevantEvents.length,
-        e2eReminder,
-        reminderKindsToMark,
+        e2eReminder: extras.e2eReminder,
+        reminderKindsToMark: extras.reminderKindsToMark,
         text: advisoryText(firstRelevantEvent),
     };
 }

package/dist/file-entity-links.d.ts

@@ -1,3 +1,7 @@
+export declare function emptyLinkedTargets(): {
+    ids: [];
+    source: "none";
+};
 export type SymbolsManifestRow = {
     id?: string;
     sourceFile?: string;

package/dist/file-entity-links.js

@@ -2,6 +2,10 @@
 import { existsSync, readFileSync } from "node:fs";
 import * as path from "node:path";
 import { loadKbSyncPaths } from "./file-filter.js";
+// ── Shared types ────────────────────────────────────────────────────
+export function emptyLinkedTargets() {
+    return { ids: [], source: "none" };
+}
 // ── Lightweight YAML parser (symbols.yaml subset) ───────────────────
 //
 // Handles:
@@ -218,7 +222,7 @@ export function getFileLinkedEntityIds(worktree, filePath) {
         return { ids: orderedIds.slice(0, 3), source: "symbols" };
     }
     catch {
-        return { ids: [], source: "none" };
+        return emptyLinkedTargets();
     }
 }
 // implements REQ-opencode-file-context-guidance-v1

package/dist/kibi-bootstrap-capability.d.ts

@@ -26,7 +26,9 @@ interface KibiBootstrapCapabilityDetectionInput {
     sdkTypesDts?: string;
 }
 export declare function findSdkPackageJsonForPluginRoot(pluginRoot: string): string | undefined;
+export declare function capabilityInputsOrEmpty<T extends object>(load: () => T): T | Record<string, never>;
 export declare function detectKibiBootstrapCommandCapability(input: KibiBootstrapCapabilityDetectionInput): KibiBootstrapCommandCapability;
 export declare function getKibiBootstrapCommandCapability(): KibiBootstrapCommandCapability;
+export declare function _resetKibiBootstrapCapabilityCacheForTests(): void;
 export declare function registerKibiBootstrapCommand(configInput: unknown, capability?: KibiBootstrapCommandCapability): KibiBootstrapCommandCapability;
 export {};

package/dist/kibi-bootstrap-capability.js

@@ -111,6 +111,14 @@ function hasConfigHook(pluginHooksDts) {
 function hasConfigCommandField(sdkTypesDts) {
     return /\bcommand\??:\s*\{[\s\S]*?\[key:\s*string\]:\s*\{[\s\S]*?\btemplate:\s*string\s*;/.test(sdkTypesDts);
 }
+export function capabilityInputsOrEmpty(load) {
+    try {
+        return load();
+    }
+    catch {
+        return {};
+    }
+}
 function resolveHostCapabilityInputs() {
     const moduleDir = path.dirname(fileURLToPath(import.meta.url));
     const dogfoodHost = resolveDogfoodHostCapabilityInputs([
@@ -125,7 +133,7 @@ function resolveHostCapabilityInputs() {
     if (dogfoodHost) {
         return dogfoodHost;
     }
-    try {
+    return capabilityInputsOrEmpty(() => {
         const pluginPackageJsonPath = require.resolve("@opencode-ai/plugin/package.json");
         const pluginRoot = path.dirname(pluginPackageJsonPath);
         const sdkPackageJsonPath = findSdkPackageJsonForPluginRoot(pluginRoot) ??
@@ -139,10 +147,7 @@ function resolveHostCapabilityInputs() {
             ...(pluginHooksDts ? { pluginHooksDts } : {}),
             ...(sdkTypesDts ? { sdkTypesDts } : {}),
         };
-    }
-    catch {
-        return {};
-    }
+    });
 }
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -177,6 +182,10 @@ export function getKibiBootstrapCommandCapability() {
     return cachedCapability;
 }
 // implements REQ-KIBI-BOOTSTRAP-PLAN
+export function _resetKibiBootstrapCapabilityCacheForTests() {
+    cachedCapability = null;
+}
+// implements REQ-KIBI-BOOTSTRAP-PLAN
 export function registerKibiBootstrapCommand(configInput, capability = getKibiBootstrapCommandCapability()) {
     if (!capability.supported) {
         return capability;

package/dist/meaningful-change-classifier.d.ts

@@ -10,6 +10,7 @@ import type { RiskClass } from "./risk-classifier.js";
  * - "ignored": The change is in a build artifact or third-party path — no KB
  *   impact.
  */
+export declare function isSafeDocsUnknownPath(riskClass: RiskClass, pathKind: PathKind): boolean;
 export type MeaningfulChangeClass = "requires-kb-evidence" | "advisory" | "ignored";
 /**
  * Classify whether a file change requires KB freshness evidence.

package/dist/meaningful-change-classifier.js

@@ -1,3 +1,15 @@
+/**
+ * Classification for whether a file change requires KB freshness evidence.
+ *
+ * - "requires-kb-evidence": The change is meaningful for KB freshness — the KB
+ *   snapshot should be considered stale and needs a re-sync.
+ * - "advisory": The change is low-risk (lockfiles, docs-only) — advisory only.
+ * - "ignored": The change is in a build artifact or third-party path — no KB
+ *   impact.
+ */
+export function isSafeDocsUnknownPath(riskClass, pathKind) {
+    return riskClass === "safe_docs_only" && pathKind === "unknown";
+}
 // Directories whose contents are always ignored for KB freshness.
 const IGNORED_DIRECTORIES = [
     ".git",
@@ -113,9 +125,8 @@ export function classifyMeaningfulChange(params) {
         if (UPGRADE_RISK_CLASSES.has(riskClass)) {
             return "requires-kb-evidence";
         }
-        if (riskClass === "safe_docs_only" && pathKind === "unknown") {
+        if (isSafeDocsUnknownPath(riskClass, pathKind))
             return "advisory";
-        }
     }
     // 5. DEFAULT — safety default for unknown paths
     return "requires-kb-evidence";

package/dist/plugin.d.ts

@@ -1,4 +1,7 @@
 import { type OpenCodeConfigHookInput } from "./kibi-bootstrap-capability.js";
+export declare function resetCommentSuggestion(): null;
+export declare function nextRecentCommentSuggestion<T>(inspectingCodeComments: boolean, suggestion: T | null | undefined): T | null;
+export declare function adoptPrecomputedSuggestion<T>(recent: T | null, precomputed: T | null | undefined): T | null;
 export interface PluginInput {
     worktree: string;
     directory: string;