kibi-opencode 0.9.0 → 0.10.0

package/dist/idle-brief-store.js

@@ -0,0 +1,209 @@
+import * as crypto from "node:crypto";
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function isStringArray(value) {
+    return (Array.isArray(value) && value.every((entry) => typeof entry === "string"));
+}
+function isCitation(value) {
+    return isRecord(value) && typeof value.id === "string";
+}
+function isStatement(value) {
+    return (isRecord(value) &&
+        typeof value.statement === "string" &&
+        isStringArray(value.citationIds));
+}
+function isValidationViolation(value) {
+    return (isRecord(value) &&
+        typeof value.rule === "string" &&
+        typeof value.entityId === "string" &&
+        typeof value.description === "string");
+}
+function isValidationDiagnostic(value) {
+    return (isRecord(value) &&
+        typeof value.category === "string" &&
+        typeof value.severity === "string" &&
+        typeof value.message === "string");
+}
+function isAuditCursor(value) {
+    return (isRecord(value) &&
+        typeof value.lastTimestamp === "string" &&
+        typeof value.lastOperation === "string" &&
+        typeof value.entryCount === "number" &&
+        typeof value.fileSize === "number");
+}
+function isValidation(value) {
+    return (isRecord(value) &&
+        Array.isArray(value.violations) &&
+        value.violations.every(isValidationViolation) &&
+        typeof value.count === "number" &&
+        Array.isArray(value.diagnostics) &&
+        value.diagnostics.every(isValidationDiagnostic));
+}
+function isBriefingBase(value) {
+    return (isRecord(value) &&
+        typeof value.tldr === "string" &&
+        typeof value.promptBlock === "string" &&
+        Array.isArray(value.citations) &&
+        value.citations.every(isCitation) &&
+        (value.constraints === undefined ||
+            (Array.isArray(value.constraints) &&
+                value.constraints.every(isStatement))) &&
+        (value.regressionRisks === undefined ||
+            (Array.isArray(value.regressionRisks) &&
+                value.regressionRisks.every(isStatement))) &&
+        (value.missingEvidence === undefined ||
+            (Array.isArray(value.missingEvidence) &&
+                value.missingEvidence.every(isStatement))));
+}
+function isBriefingV2(value) {
+    return (isBriefingBase(value) &&
+        isStringArray(value.changeNarrative));
+}
+function isChangeItem(value) {
+    return (isRecord(value) &&
+        typeof value.id === "string" &&
+        typeof value.type === "string");
+}
+export function isIdleBriefEnvelope(
+// implements REQ-opencode-kibi-briefing-v4
+value) {
+    if (!isRecord(value))
+        return false;
+    const hasBaseFields = (value.schemaVersion === "1.0" || value.schemaVersion === "2.0") &&
+        typeof value.briefId === "string" &&
+        (value.type === "success" || value.type === "warning") &&
+        typeof value.sessionId === "string" &&
+        typeof value.branch === "string" &&
+        typeof value.createdAt === "string" &&
+        typeof value.unread === "boolean" &&
+        isAuditCursor(value.auditCursor) &&
+        typeof value.summary === "string" &&
+        isValidation(value.validation) &&
+        typeof value.contentHash === "string";
+    if (!hasBaseFields)
+        return false;
+    if (value.schemaVersion === "1.0") {
+        return (isRecord(value.counts) &&
+            typeof value.counts.requirementsAdded === "number" &&
+            typeof value.counts.relationshipsAdded === "number" &&
+            typeof value.counts.entitiesDeleted === "number" &&
+            isBriefingBase(value.briefing));
+    }
+    return (isRecord(value.counts) &&
+        typeof value.counts.entitiesAdded === "number" &&
+        typeof value.counts.entitiesModified === "number" &&
+        typeof value.counts.entitiesRemoved === "number" &&
+        typeof value.counts.relationshipsChanged === "number" &&
+        isRecord(value.changes) &&
+        isRecord(value.changes.entities) &&
+        Array.isArray(value.changes.entities.added) &&
+        value.changes.entities.added.every(isChangeItem) &&
+        Array.isArray(value.changes.entities.modified) &&
+        value.changes.entities.modified.every(isChangeItem) &&
+        Array.isArray(value.changes.entities.removed) &&
+        value.changes.entities.removed.every(isChangeItem) &&
+        isRecord(value.changes.relationships) &&
+        typeof value.changes.relationships.changed === "number" &&
+        isBriefingV2(value.briefing));
+}
+export function createBriefId() {
+    // implements REQ-opencode-kibi-briefing-v4
+    return `brief-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+export function computeContentHash(payload) {
+    // implements REQ-opencode-kibi-briefing-v4
+    const env = payload;
+    // Normalize string: trim and collapse internal whitespace
+    const norm = (s) => s.trim().replace(/\s+/g, " ");
+    const normalizeCitations = (citations) => citations.map((c) => ({
+        id: c.id,
+        ...(c.type ? { type: norm(c.type) } : {}),
+        ...(c.title ? { title: norm(c.title) } : {}),
+        ...(c.source ? { source: norm(c.source) } : {}),
+        ...(c.textRef ? { textRef: norm(c.textRef) } : {}),
+    }));
+    const normalizeStatements = (statements = []) => statements.map((statement) => ({
+        statement: norm(statement.statement),
+        citationIds: statement.citationIds,
+    }));
+    const normalizeChangeItems = (items) => items.map((item) => ({
+        id: item.id,
+        type: norm(item.type),
+        ...(item.title ? { title: norm(item.title) } : {}),
+        ...(item.source ? { source: norm(item.source) } : {}),
+        ...(item.textRef ? { textRef: norm(item.textRef) } : {}),
+    }));
+    // Build canonical visible-content projection (ignoring volatile fields)
+    const projection = env.schemaVersion === "2.0"
+        ? {
+            schemaVersion: "2.0",
+            type: env.type,
+            summary: norm(env.summary),
+            counts: env.counts,
+            changes: {
+                entities: {
+                    added: normalizeChangeItems(env.changes.entities.added),
+                    modified: normalizeChangeItems(env.changes.entities.modified),
+                    removed: normalizeChangeItems(env.changes.entities.removed),
+                },
+                relationships: {
+                    changed: env.changes.relationships.changed,
+                },
+            },
+            briefing: {
+                tldr: norm(env.briefing.tldr),
+                normalizedPromptBlock: norm(env.briefing.promptBlock),
+                citations: normalizeCitations(env.briefing.citations ?? []),
+                changeNarrative: env.briefing.changeNarrative.map((line) => norm(line)),
+                constraints: normalizeStatements(env.briefing.constraints),
+                regressionRisks: normalizeStatements(env.briefing.regressionRisks),
+                missingEvidence: normalizeStatements(env.briefing.missingEvidence),
+            },
+            validation: {
+                count: env.validation.count,
+                violations: env.validation.violations.map((v) => ({
+                    rule: v.rule,
+                    entityId: v.entityId,
+                    description: norm(v.description),
+                })),
+            },
+        }
+        : {
+            type: env.type,
+            summary: norm(env.summary),
+            counts: env.counts,
+            briefing: {
+                tldr: norm(env.briefing.tldr),
+                normalizedPromptBlock: norm(env.briefing.promptBlock),
+                citations: (env.briefing.citations ?? []).map((c) => ({
+                    id: c.id,
+                    title: c.title ?? "",
+                })),
+                constraints: (env.briefing.constraints ?? []).map((c) => ({
+                    statement: norm(c.statement),
+                    citationIds: c.citationIds,
+                })),
+                regressionRisks: (env.briefing.regressionRisks ?? []).map((r) => ({
+                    statement: norm(r.statement),
+                    citationIds: r.citationIds,
+                })),
+                missingEvidence: (env.briefing.missingEvidence ?? []).map((m) => ({
+                    statement: norm(m.statement),
+                    citationIds: m.citationIds,
+                })),
+            },
+            validation: {
+                count: env.validation.count,
+                violations: env.validation.violations.map((v) => ({
+                    rule: v.rule,
+                    entityId: v.entityId,
+                    description: norm(v.description),
+                })),
+            },
+        };
+    return crypto
+        .createHash("sha256")
+        .update(JSON.stringify(projection))
+        .digest("hex");
+}

package/dist/index.d.ts

@@ -1,9 +1,11 @@
+import { type OpenCodeConfigHookInput } from "./init-kibi-capability.js";
 export interface PluginInput {
     worktree: string;
     directory: string;
+    sessionId?: string;
+    serverUrl?: unknown;
     workspace?: string;
     project?: unknown;
-    serverUrl?: unknown;
     $?: unknown;
     client?: {
         tui?: {
@@ -13,6 +15,16 @@ export interface PluginInput {
                 message: string;
                 duration?: number;
             }) => void | Promise<void>;
+            showToast?: (payload: {
+                body: {
+                    variant?: "info" | "success" | "warning" | "error";
+                    title?: string;
+                    message: string;
+                    duration?: number;
+                };
+            }) => void | Promise<void>;
+            clearPrompt?: () => void | Promise<void>;
+            submitPrompt?: () => void | Promise<void>;
         };
         app: {
             log: (payload: Record<string, unknown>) => Promise<void>;
@@ -31,6 +43,7 @@ interface SystemTransformOutput {
 }
 export interface Hooks {
     event?: (input: EventHookInput) => void | Promise<void>;
+    config?: (input: OpenCodeConfigHookInput) => void | Promise<void>;
     "experimental.chat.system.transform"?: (input: unknown, output: SystemTransformOutput) => void | Promise<void>;
     "chat.params"?: (input: unknown, output: unknown) => void | Promise<void>;
 }