kibi-opencode 0.8.0 → 0.10.0

package/dist/init-kibi-alias.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Builds the canonical native alias for the Kibi MCP bootstrap workflow.
+ * This is a thin wrapper over the MCP-defined workflow, preserving all
+ * semantic markers while removing namespacing and keeping text concise.
+ *
+ * Markers (MUST PRESERVE):
+ * - "at most 4 bounded questions"
+ * - "kb_autopilot_generate"
+ * - "preview" or "approval"
+ * - "kb_upsert"
+ * - "kb_check"
+ * - "sequential" or similar ordering language
+ */
+export declare function buildInitKibiAlias(): string;

package/dist/init-kibi-alias.js

@@ -0,0 +1,38 @@
+/**
+ * Builds the canonical native alias for the Kibi MCP bootstrap workflow.
+ * This is a thin wrapper over the MCP-defined workflow, preserving all
+ * semantic markers while removing namespacing and keeping text concise.
+ *
+ * Markers (MUST PRESERVE):
+ * - "at most 4 bounded questions"
+ * - "kb_autopilot_generate"
+ * - "preview" or "approval"
+ * - "kb_upsert"
+ * - "kb_check"
+ * - "sequential" or similar ordering language
+ */
+// implements REQ-opencode-kibi-briefing-v2
+export function buildInitKibiAlias() {
+    const lines = [
+        "# /init-kibi: Interactive Activation",
+        "",
+        "Use this workflow to onboard a new or empty repository into Kibi through interactive discovery.",
+        "",
+        "## 1. Gather Declared Context",
+        "Ask at most 4 bounded questions to gather intent: Project Summary, Source of Truth, Priority Root, and Verification Anchors.",
+        "",
+        "## 2. Synthesize Candidates",
+        "Call `kb_autopilot_generate` with the gathered context to synthesize candidate entities. This tool is **read-only**.",
+        "",
+        "## 3. Preview and Approval",
+        "Present the `promptBlock` and a summary of synthesized `candidates` to the user. **Wait for explicit approval** before proceeding to writes.",
+        "",
+        "## 4. Apply Approved Candidates",
+        "Apply approved candidates sequentially using `kb_upsert` (following ascending phase order). Confirm success of each write before moving to the next. Run `kb_check` after the batch to verify KB integrity.",
+        "",
+        "## Rules",
+        "- Never apply changes without a user-facing preview and approval.",
+        "- Guidance must stay MCP-only; do not suggest `kibi` CLI commands.",
+    ];
+    return lines.join("\n");
+}

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

@@ -0,0 +1,32 @@
+export declare const INIT_KIBI_COMMAND_NAME = "init-kibi";
+export declare const INIT_KIBI_COMMAND_TEMPLATE: string;
+export declare const INIT_KIBI_COMMAND_DESCRIPTION = "Run the Kibi interactive activation workflow.";
+export interface OpenCodeCommandDefinition {
+    template: string;
+    description?: string;
+    agent?: string;
+    model?: string;
+    subtask?: boolean;
+}
+export interface OpenCodeConfigHookInput {
+    command?: Record<string, OpenCodeCommandDefinition>;
+    [key: string]: unknown;
+}
+export type InitKibiCommandCapability = {
+    supported: true;
+    pluginVersion: string;
+} | {
+    supported: false;
+    reason: string;
+    pluginVersion?: string;
+};
+interface InitKibiCapabilityDetectionInput {
+    pluginVersion?: string;
+    pluginHooksDts?: string;
+    sdkTypesDts?: string;
+}
+export declare function findSdkPackageJsonForPluginRoot(pluginRoot: string): string | undefined;
+export declare function detectInitKibiCommandCapability(input: InitKibiCapabilityDetectionInput): InitKibiCommandCapability;
+export declare function getInitKibiCommandCapability(): InitKibiCommandCapability;
+export declare function registerInitKibiCommand(configInput: unknown, capability?: InitKibiCommandCapability): InitKibiCommandCapability;
+export {};

package/dist/init-kibi-capability.js

@@ -0,0 +1,202 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { buildInitKibiAlias } from "./init-kibi-alias.js";
+export const INIT_KIBI_COMMAND_NAME = "init-kibi";
+export const INIT_KIBI_COMMAND_TEMPLATE = buildInitKibiAlias();
+export const INIT_KIBI_COMMAND_DESCRIPTION = "Run the Kibi interactive activation workflow."; // implements REQ-001
+const require = createRequire(import.meta.url);
+let cachedCapability = null;
+const initialProcessCwd = process.cwd();
+const initialEnvPwd = process.env.PWD;
+const initialGithubWorkspace = process.env.GITHUB_WORKSPACE;
+function* candidateHostRoots(startDir) {
+    let current = path.resolve(startDir);
+    while (true) {
+        yield current;
+        const parent = path.dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+}
+function resolveDogfoodHostCapabilityInputs(startDirs) {
+    const seenRoots = new Set();
+    for (const startDir of startDirs) {
+        for (const root of candidateHostRoots(startDir)) {
+            if (seenRoots.has(root)) {
+                continue;
+            }
+            seenRoots.add(root);
+            const pluginPackageJsonPath = path.join(root, ".opencode", "node_modules", "@opencode-ai", "plugin", "package.json");
+            if (!fs.existsSync(pluginPackageJsonPath)) {
+                continue;
+            }
+            const pluginRoot = path.dirname(pluginPackageJsonPath);
+            const sdkPackageJsonCandidates = [
+                path.join(root, ".opencode", "node_modules", "@opencode-ai", "sdk", "package.json"),
+                path.join(pluginRoot, "node_modules", "@opencode-ai", "sdk", "package.json"),
+            ];
+            const sdkPackageJsonPath = sdkPackageJsonCandidates.find((candidate) => fs.existsSync(candidate));
+            if (!sdkPackageJsonPath) {
+                continue;
+            }
+            const sdkRoot = path.dirname(sdkPackageJsonPath);
+            const pluginVersion = readPackageVersion(pluginPackageJsonPath);
+            const pluginHooksDts = readTextIfExists(path.join(pluginRoot, "dist", "index.d.ts"));
+            const sdkTypesDts = readTextIfExists(path.join(sdkRoot, "dist", "v2", "gen", "types.gen.d.ts"));
+            // Dogfood host artifacts can be partially installed (package.json present, dist d.ts absent).
+            // In that case we should keep probing/fallback instead of hard-failing capability detection.
+            if (typeof pluginHooksDts !== "string" ||
+                pluginHooksDts.length === 0 ||
+                typeof sdkTypesDts !== "string" ||
+                sdkTypesDts.length === 0) {
+                continue;
+            }
+            return {
+                ...(pluginVersion ? { pluginVersion } : {}),
+                pluginHooksDts,
+                sdkTypesDts,
+            };
+        }
+    }
+    return null;
+}
+function buildUnsupportedReason(pluginVersion, detail) {
+    const prefix = pluginVersion
+        ? `@opencode-ai/plugin@${pluginVersion}`
+        : "@opencode-ai/plugin";
+    return pluginVersion
+        ? {
+            supported: false,
+            pluginVersion,
+            reason: `${prefix} ${detail}`,
+        }
+        : {
+            supported: false,
+            reason: `${prefix} ${detail}`,
+        };
+}
+function readTextIfExists(filePath) {
+    try {
+        return fs.readFileSync(filePath, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+function readPackageVersion(filePath) {
+    try {
+        const raw = fs.readFileSync(filePath, "utf8");
+        const parsed = JSON.parse(raw);
+        return typeof parsed.version === "string" ? parsed.version : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+// implements REQ-opencode-kibi-briefing-v2
+export function findSdkPackageJsonForPluginRoot(pluginRoot) {
+    const scopeRoot = path.dirname(pluginRoot);
+    const candidates = [
+        path.join(pluginRoot, "node_modules", "@opencode-ai", "sdk", "package.json"),
+        path.join(scopeRoot, "sdk", "package.json"),
+    ];
+    return candidates.find((candidate) => fs.existsSync(candidate));
+}
+function hasConfigHook(pluginHooksDts) {
+    return /\bconfig\??:\s*\(input:\s*Config\)\s*=>\s*Promise<void>\s*;/.test(pluginHooksDts);
+}
+function hasConfigCommandField(sdkTypesDts) {
+    return /\bcommand\??:\s*\{[\s\S]*?\[key:\s*string\]:\s*\{[\s\S]*?\btemplate:\s*string\s*;/.test(sdkTypesDts);
+}
+function resolveHostCapabilityInputs() {
+    const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+    const dogfoodHost = resolveDogfoodHostCapabilityInputs([
+        process.cwd(),
+        process.env.PWD,
+        process.env.GITHUB_WORKSPACE,
+        initialProcessCwd,
+        initialEnvPwd,
+        initialGithubWorkspace,
+        moduleDir,
+    ].filter((value) => typeof value === "string" && value.length > 0));
+    if (dogfoodHost) {
+        return dogfoodHost;
+    }
+    try {
+        const pluginPackageJsonPath = require.resolve("@opencode-ai/plugin/package.json");
+        const pluginRoot = path.dirname(pluginPackageJsonPath);
+        const sdkPackageJsonPath = findSdkPackageJsonForPluginRoot(pluginRoot) ??
+            require.resolve("@opencode-ai/sdk/package.json");
+        const sdkRoot = path.dirname(sdkPackageJsonPath);
+        const pluginVersion = readPackageVersion(pluginPackageJsonPath);
+        const pluginHooksDts = readTextIfExists(path.join(pluginRoot, "dist", "index.d.ts"));
+        const sdkTypesDts = readTextIfExists(path.join(sdkRoot, "dist", "v2", "gen", "types.gen.d.ts"));
+        return {
+            ...(pluginVersion ? { pluginVersion } : {}),
+            ...(pluginHooksDts ? { pluginHooksDts } : {}),
+            ...(sdkTypesDts ? { sdkTypesDts } : {}),
+        };
+    }
+    catch {
+        return {};
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isCommandMap(value) {
+    return isRecord(value);
+}
+// implements REQ-opencode-kibi-briefing-v2
+export function detectInitKibiCommandCapability(input) {
+    const { pluginVersion, pluginHooksDts, sdkTypesDts } = input;
+    if (typeof pluginHooksDts !== "string" || pluginHooksDts.length === 0) {
+        return buildUnsupportedReason(pluginVersion, "host Hooks definition is unavailable for config hook inspection.");
+    }
+    if (!hasConfigHook(pluginHooksDts)) {
+        return buildUnsupportedReason(pluginVersion, "Hooks interface does not expose the config hook needed for native command injection.");
+    }
+    if (typeof sdkTypesDts !== "string" || sdkTypesDts.length === 0) {
+        return buildUnsupportedReason(pluginVersion, "SDK Config definition is unavailable for command surface inspection.");
+    }
+    if (!hasConfigCommandField(sdkTypesDts)) {
+        return buildUnsupportedReason(pluginVersion, "SDK Config type does not expose the command field needed for native command injection.");
+    }
+    return {
+        supported: true,
+        pluginVersion: pluginVersion ?? "unknown",
+    };
+}
+// implements REQ-opencode-kibi-briefing-v2
+export function getInitKibiCommandCapability() {
+    if (cachedCapability?.supported) {
+        return cachedCapability;
+    }
+    cachedCapability = detectInitKibiCommandCapability(resolveHostCapabilityInputs());
+    return cachedCapability;
+}
+// implements REQ-opencode-kibi-briefing-v2
+export function registerInitKibiCommand(configInput, capability = getInitKibiCommandCapability()) {
+    if (!capability.supported) {
+        return capability;
+    }
+    if (!isRecord(configInput)) {
+        return buildUnsupportedReason(capability.pluginVersion, "config hook input is not an object.");
+    }
+    const existingCommands = configInput.command;
+    if (existingCommands !== undefined && !isCommandMap(existingCommands)) {
+        return buildUnsupportedReason(capability.pluginVersion, "config hook input.command is not an object.");
+    }
+    configInput.command = {
+        ...(existingCommands ?? {}),
+        [INIT_KIBI_COMMAND_NAME]: {
+            template: INIT_KIBI_COMMAND_TEMPLATE,
+            description: INIT_KIBI_COMMAND_DESCRIPTION,
+        },
+    };
+    return capability;
+}

package/dist/logger.js

@@ -23,7 +23,9 @@ export function info(msg, metadata) {
             .log({
             body: buildBody("info", msg, metadata),
         })
-            .catch(console.error);
+            .catch(() => {
+            // Advisory logging stays silent even on transport failure
+        });
         return;
     }
     // Fallback when no client is available (e.g. during tests or early init)
@@ -35,7 +37,9 @@ export function warn(msg, metadata) {
             .log({
             body: buildBody("warn", msg, metadata),
         })
-            .catch(console.error);
+            .catch(() => {
+            // Advisory logging stays silent even on transport failure
+        });
         return;
     }
     // Fallback when no client is available
@@ -66,6 +70,8 @@ export function error(msg, metadata) {
             .log({
             body: buildBody("error", msg, metadata),
         })
-            .catch(console.error);
+            .catch(() => {
+            // Structured log rejection is silent; operational error already reported above
+        });
     }
 }

package/dist/plugin-startup.d.ts

@@ -24,5 +24,6 @@ export interface PluginStartupContext {
     getEffectiveMode: () => EffectiveMode;
     latchRuntimeDegraded: (cause: NonNullable<RuntimeDegradedOverlay["primaryCause"]>) => void;
 }
+export declare function resolveCurrentBranch(cwd: string): string;
 export declare function runPluginStartup(input: PluginInput): Promise<PluginStartupContext | null>;
 export {};

package/dist/plugin-startup.js

@@ -19,13 +19,22 @@ function isSmartEnforcementSyncReason(reason) {
     return normalizedReason.startsWith("smart-enforcement.");
 }
 const workspaceCacheState = new Map();
-function resolveCurrentBranch(cwd) {
+export function resolveCurrentBranch(cwd) {
+    // implements REQ-opencode-kibi-briefing-v3
+    // 1. Check KIBI_BRANCH env var first (highest precedence)
+    const envBranch = process.env.KIBI_BRANCH?.trim();
+    if (envBranch && envBranch.length > 0) {
+        return envBranch === "master" ? "main" : envBranch;
+    }
+    // 2. Fall back to git branch
     try {
-        return execSync("git rev-parse --abbrev-ref HEAD", {
+        const branch = execSync("git branch --show-current", {
             cwd,
             encoding: "utf8",
             stdio: ["ignore", "pipe", "ignore"],
+            timeout: 5000,
         }).trim();
+        return branch === "master" ? "main" : branch;
     }
     catch {
         return "unknown";

package/dist/prompt.d.ts

@@ -1,16 +1,23 @@
 import type { CommentAnalysisResult } from "./comment-analysis.js";
+import type { BriefingRuntimeResult } from "./briefing-runtime.js";
 import type { KibiConfig } from "./config.js";
+import { type InitKibiCommandCapability } from "./init-kibi-capability.js";
 import type { GuidanceCache } from "./guidance-cache.js";
 import type { PathKind } from "./path-kind.js";
 import type { RepoPosture } from "./repo-posture.js";
 import type { RiskClass } from "./risk-classifier.js";
 import type { WorkspaceHealth } from "./workspace-health.js";
 declare const SENTINEL = "<!-- kibi-opencode -->";
+export declare function buildAutoBriefingGuidance(autoBriefResult: BriefingRuntimeResult | undefined, completionReminder: boolean): string | null;
 export interface PromptContext {
     recentEdits: Array<{
         path: string;
         kind: PathKind;
     }>;
+    focusEdit?: {
+        path: string;
+        kind: PathKind;
+    } | null;
     workspaceHealth?: WorkspaceHealth;
     hasRecentKbEdit?: boolean;
     recentCommentSuggestion?: CommentAnalysisResult | null;
@@ -32,14 +39,22 @@ export interface PromptContext {
     degradedMode?: "warn-once" | "structured-only";
     /** Whether to show the degraded advisory block this invocation */
     showDegradedAdvisory?: boolean;
+    /** Stored auto-brief runtime result for the current fingerprint */
+    autoBriefResult?: BriefingRuntimeResult;
+    /** File-operation reminder from lifecycle and e2e coverage signals */
+    fileOperationReminder?: {
+        path: string;
+        lifecycleReminder: string | null;
+        e2eReminder: string | null;
+    };
 }
-export declare function postureGuidance(posture: RepoPosture): string | null;
+export declare function postureGuidance(posture: RepoPosture, capability?: InitKibiCommandCapability): string | null;
 /**
  * Build prompt with contextual guidance based on posture, risk class, and cache state.
  */
-export declare function buildPrompt(context?: PromptContext): string;
+export declare function buildPrompt(context?: PromptContext, capability?: InitKibiCommandCapability): string;
 /**
  * Inject prompt guidance if not already present.
  */
-export declare function injectPrompt(current: string, config: KibiConfig, context?: PromptContext): string;
+export declare function injectPrompt(current: string, config: KibiConfig, context?: PromptContext, capability?: InitKibiCommandCapability): string;
 export { SENTINEL };