kibi-opencode 0.9.0 → 0.11.0

package/dist/idle-brief-store.js

@@ -0,0 +1,262 @@
+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) &&
+        (value.deliveryReasons === undefined ||
+            isDeliveryReasons(value.deliveryReasons)));
+}
+function isReasonItem(value) {
+    return (isRecord(value) &&
+        typeof value.kind === "string" &&
+        typeof value.text === "string" &&
+        isStringArray(value.entityIds) &&
+        (value.citationIds === undefined || isStringArray(value.citationIds)) &&
+        (value.severity === undefined ||
+            value.severity === "info" ||
+            value.severity === "warning" ||
+            value.severity === "error"));
+}
+function isDeliveryReasons(value) {
+    return (isRecord(value) &&
+        value.version === 1 &&
+        isRecord(value.toast) &&
+        typeof value.toast.title === "string" &&
+        typeof value.toast.summary === "string" &&
+        typeof value.toast.whyItMatters === "string" &&
+        Array.isArray(value.items) &&
+        value.items.every(isReasonItem));
+}
+function isChangeItem(value) {
+    return (isRecord(value) &&
+        typeof value.id === "string" &&
+        typeof value.type === "string");
+}
+function hasRenderableText(value) {
+    return value.trim().replace(/\s+/g, " ").length > 0;
+}
+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 normalizeReasonItems = (items = []) => items
+        .map((item) => ({
+        kind: item.kind,
+        text: norm(item.text),
+        entityIds: [...item.entityIds].sort(),
+        ...(item.citationIds ? { citationIds: [...item.citationIds].sort() } : {}),
+        ...(item.severity ? { severity: item.severity } : {}),
+    }))
+        .filter((item) => hasRenderableText(item.text));
+    const normalizeDeliveryReasons = (deliveryReasons) => {
+        if (!deliveryReasons)
+            return undefined;
+        const items = normalizeReasonItems(deliveryReasons.items);
+        if (items.length === 0)
+            return undefined;
+        return {
+            version: deliveryReasons.version,
+            toast: {
+                title: norm(deliveryReasons.toast.title),
+                summary: norm(deliveryReasons.toast.summary),
+                whyItMatters: norm(deliveryReasons.toast.whyItMatters),
+            },
+            items,
+        };
+    };
+    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)),
+                deliveryReasons: normalizeDeliveryReasons(env.briefing.deliveryReasons),
+                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,
+                })),
+                deliveryReasons: normalizeDeliveryReasons(env.briefing.deliveryReasons),
+            },
+            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,39 +1,2 @@
-export interface PluginInput {
-    worktree: string;
-    directory: string;
-    workspace?: string;
-    project?: unknown;
-    serverUrl?: unknown;
-    $?: unknown;
-    client?: {
-        tui?: {
-            toast?: (payload: {
-                variant?: "info" | "success" | "warning" | "error";
-                title?: string;
-                message: string;
-                duration?: number;
-            }) => void | Promise<void>;
-        };
-        app: {
-            log: (payload: Record<string, unknown>) => Promise<void>;
-        };
-    };
-}
-interface OpencodeEventPayload {
-    type: string;
-    properties?: Record<string, unknown>;
-}
-interface EventHookInput {
-    event: OpencodeEventPayload;
-}
-interface SystemTransformOutput {
-    system: string[];
-}
-export interface Hooks {
-    event?: (input: EventHookInput) => void | Promise<void>;
-    "experimental.chat.system.transform"?: (input: unknown, output: SystemTransformOutput) => void | Promise<void>;
-    "chat.params"?: (input: unknown, output: unknown) => void | Promise<void>;
-}
-export type Plugin = (input: PluginInput) => Hooks | Promise<Hooks>;
-declare const kibiOpencodePlugin: Plugin;
-export default kibiOpencodePlugin;
+export { default } from "./plugin.js";
+export type { Hooks, Plugin, PluginInput } from "./plugin.js";