kibi-opencode 0.14.0 → 0.15.1

package/dist/graph-narrator.js

@@ -1,408 +0,0 @@
-// implements REQ-opencode-kibi-briefing-v6
-function asRecord(value) {
-    return typeof value === "object" && value !== null
-        ? value
-        : null;
-}
-function asString(value) {
-    return typeof value === "string" ? value : "";
-}
-function asStringArray(value) {
-    return Array.isArray(value)
-        ? value.filter((entry) => typeof entry === "string")
-        : [];
-}
-function getSessionApi(client) {
-    const root = asRecord(client);
-    const session = asRecord(root?.session);
-    if (!session) {
-        return null;
-    }
-    const create = session.create;
-    const prompt = session.prompt;
-    if (typeof create !== "function" || typeof prompt !== "function") {
-        return null;
-    }
-    return {
-        create: create,
-        prompt: prompt,
-    };
-}
-function extractSessionId(response) {
-    const root = asRecord(response);
-    if (!root) {
-        return null;
-    }
-    const directId = asString(root.id).trim();
-    if (directId) {
-        return directId;
-    }
-    const data = asRecord(root.data);
-    return asString(data?.id).trim() || null;
-}
-function extractPromptResponseJson(response) {
-    const root = asRecord(response);
-    if (!root)
-        return null;
-    const data = asRecord(root.data);
-    const parts = Array.isArray(data?.parts)
-        ? data.parts
-        : Array.isArray(root.parts)
-            ? root.parts
-            : null;
-    if (!parts)
-        return null;
-    for (const part of parts) {
-        const record = asRecord(part);
-        if (record?.type !== "text") {
-            continue;
-        }
-        const text = asString(record.text);
-        if (!text) {
-            continue;
-        }
-        try {
-            return JSON.parse(text);
-        }
-        catch {
-            return null;
-        }
-    }
-    return null;
-}
-async function invokeTool(sessionApi, sessionID, tool, args) {
-    const response = await sessionApi.prompt({
-        sessionID,
-        parts: [{ type: "text", text: JSON.stringify({ tool, args }) }],
-        tools: { [tool]: true },
-        format: {
-            type: "json_schema",
-            schema: {
-                type: ["object", "array"],
-            },
-        },
-    });
-    return extractPromptResponseJson(response);
-}
-function inferTypeFromId(id) {
-    const prefix = id.split("-")[0]?.toLowerCase() ?? "entity";
-    switch (prefix) {
-        case "req":
-        case "scenario":
-        case "test":
-        case "adr":
-        case "flag":
-        case "event":
-        case "symbol":
-        case "fact":
-            return prefix;
-        case "scen":
-            return "scenario";
-        case "sym":
-            return "symbol";
-        default:
-            return prefix;
-    }
-}
-function humanizeType(type, count = 1) {
-    const singular = {
-        req: "requirement",
-        scenario: "scenario",
-        test: "test",
-        adr: "ADR",
-        flag: "flag",
-        event: "event",
-        symbol: "symbol",
-        fact: "fact",
-    }[type] ?? type;
-    if (count === 1) {
-        return singular;
-    }
-    if (singular === "ADR") {
-        return "ADRs";
-    }
-    return singular.endsWith("s") ? singular : `${singular}s`;
-}
-function humanizeDomain(domain) {
-    const normalized = domain.trim().toLowerCase();
-    switch (normalized) {
-        case "opencode":
-            return "OpenCode";
-        case "mcp":
-            return "MCP";
-        case "cli":
-            return "CLI";
-        case "vscode":
-            return "VSCode";
-        case "core":
-            return "Core";
-        case "requirements":
-            return "Requirements";
-        default:
-            return normalized ? normalized.charAt(0).toUpperCase() + normalized.slice(1) : "Changes";
-    }
-}
-function formatList(items) {
-    if (items.length === 0)
-        return "";
-    if (items.length === 1)
-        return items[0] ?? "";
-    if (items.length === 2)
-        return `${items[0]} and ${items[1]}`;
-    return `${items.slice(0, -1).join(", ")}, and ${items[items.length - 1]}`;
-}
-function normalizeEntity(record, idFallback) {
-    const properties = asRecord(record.properties) ?? {};
-    const id = asString(record.id || properties.id).trim() || idFallback;
-    const type = asString(record.type).trim() ||
-        asString(record.entityType).trim() ||
-        inferTypeFromId(id);
-    const title = asString(record.title).trim() ||
-        asString(properties.title).trim() ||
-        id;
-    const status = asString(record.status).trim() ||
-        asString(properties.status).trim() ||
-        asString(properties.change_kind).trim();
-    const source = asString(record.source).trim() ||
-        asString(properties.source).trim();
-    const tags = [
-        ...asStringArray(record.tags),
-        ...asStringArray(properties.tags),
-    ];
-    const factKind = asString(record.fact_kind).trim() ||
-        asString(properties.fact_kind).trim();
-    return {
-        id,
-        type,
-        title,
-        status,
-        source,
-        tags,
-        factKind,
-        removed: false,
-    };
-}
-function normalizeGraph(value) {
-    const root = asRecord(value);
-    if (!root) {
-        return null;
-    }
-    const edges = Array.isArray(root.edges)
-        ? root.edges
-            .map((edge) => {
-            const record = asRecord(edge);
-            if (!record)
-                return null;
-            const from = asString(record.from).trim();
-            const to = asString(record.to).trim();
-            const type = asString(record.type).trim();
-            return from && to && type ? { from, to, type } : null;
-        })
-            .filter((edge) => edge !== null)
-        : [];
-    return { edges };
-}
-function describeEntity(entity, id) {
-    if (!entity) {
-        return id;
-    }
-    return `${entity.title} (${entity.id})`;
-}
-function inferDomain(entity) {
-    const source = entity.source.replaceAll("\\", "/");
-    const packageMatch = source.match(/packages\/([^/]+)\//);
-    if (packageMatch?.[1]) {
-        return humanizeDomain(packageMatch[1]);
-    }
-    const tagDomain = entity.tags.find((tag) => ["cli", "mcp", "vscode", "opencode", "core"].includes(tag.toLowerCase()));
-    if (tagDomain) {
-        return humanizeDomain(tagDomain);
-    }
-    if (["req", "scenario", "test"].includes(entity.type)) {
-        return "Requirements";
-    }
-    return humanizeDomain(entity.type);
-}
-function classifyRelationship(relationship, entities) {
-    const fromEntity = entities.get(relationship.from);
-    const toEntity = entities.get(relationship.to);
-    const fromText = describeEntity(fromEntity, relationship.from);
-    const toText = describeEntity(toEntity, relationship.to);
-    switch (relationship.type) {
-        case "supersedes":
-            return `${toText} was superseded by ${fromText}`;
-        case "implements":
-            return `${fromText} now implements ${toText}`;
-        case "covered_by":
-            return `${fromText} gained test coverage via ${toText}`;
-        case "verified_by":
-            return `${fromText} is verified by ${toText}`;
-        case "specified_by":
-            return `${fromText} is specified by ${toText}`;
-        case "requires_property":
-            return `${fromText} constrains property ${toText}`;
-        case "constrains":
-            if (toEntity?.type === "fact" && toEntity.factKind === "subject") {
-                return `${fromText} is linked to fact ${toText}`;
-            }
-            return `${fromText} is linked to ${toText}`;
-        default:
-            return null;
-    }
-}
-function uniqueStrings(items) {
-    return [...new Set(items.filter(Boolean))];
-}
-function buildEntityChange(entity, relationships, graph) {
-    const label = describeEntity(entity, entity.id);
-    if (entity.removed) {
-        return `${label} was removed`;
-    }
-    if (entity.status === "superseded") {
-        return `${label} was marked superseded`;
-    }
-    const hasRelationshipChange = relationships.some((relationship) => relationship.from === entity.id || relationship.to === entity.id);
-    const hasGraphEdges = (graph?.edges.length ?? 0) > 0;
-    if (!hasRelationshipChange && !hasGraphEdges) {
-        return `${label} was created`;
-    }
-    return `${label} was updated`;
-}
-function summarizeTypes(entities) {
-    const counts = new Map();
-    for (const entity of entities) {
-        counts.set(entity.type, (counts.get(entity.type) ?? 0) + 1);
-    }
-    return formatList([...counts.entries()].map(([type, count]) => `${count} ${humanizeType(type, count)}`));
-}
-function summarizeTopChanges(domainChanges, relationshipChanges) {
-    const focus = relationshipChanges.length > 0 ? relationshipChanges : domainChanges;
-    const selected = focus.slice(0, 2);
-    return selected.length > 0 ? `Key changes: ${selected.join("; ")}.` : "";
-}
-function validationStatusText(checkResult) {
-    if (checkResult.count <= 0) {
-        return "All checks pass";
-    }
-    return `${checkResult.count} validation issue${checkResult.count === 1 ? "" : "s"}`;
-}
-async function loadEntity(sessionApi, sessionID, id) {
-    const response = await invokeTool(sessionApi, sessionID, "kb_query", { id, limit: 1 });
-    if (!Array.isArray(response)) {
-        throw new Error(`kb_query returned unsupported payload for ${id}`);
-    }
-    if (response.length === 0) {
-        return {
-            id,
-            type: inferTypeFromId(id),
-            title: id,
-            status: "removed",
-            source: "",
-            tags: [],
-            factKind: "",
-            removed: true,
-        };
-    }
-    const record = asRecord(response[0]);
-    if (!record) {
-        throw new Error(`kb_query returned invalid entity for ${id}`);
-    }
-    return normalizeEntity(record, id);
-}
-async function loadGraph(sessionApi, sessionID, id) {
-    const response = await invokeTool(sessionApi, sessionID, "kb_graph", {
-        seedIds: [id],
-        direction: "both",
-        depth: 2,
-        maxNodes: 100,
-        maxEdges: 200,
-    });
-    return normalizeGraph(response);
-}
-// implements REQ-opencode-kibi-briefing-v2
-export async function generateGraphNarrative(client, workspaceCtx, changedEntityIds, changedRelationships, checkResult) {
-    const uniqueIds = uniqueStrings(changedEntityIds);
-    if (uniqueIds.length === 0) {
-        return null;
-    }
-    const sessionApi = getSessionApi(client);
-    if (!sessionApi) {
-        return null;
-    }
-    let sessionID = null;
-    try {
-        const worker = await sessionApi.create({
-            directory: workspaceCtx.workspaceRoot,
-            title: `Kibi Graph Narrator (${workspaceCtx.branch})`,
-        });
-        sessionID = extractSessionId(worker);
-    }
-    catch {
-        return null;
-    }
-    if (!sessionID) {
-        return null;
-    }
-    const entities = new Map();
-    const graphs = new Map();
-    for (const id of uniqueIds) {
-        let entity;
-        try {
-            entity = await loadEntity(sessionApi, sessionID, id);
-        }
-        catch {
-            continue;
-        }
-        if (!entity) {
-            continue;
-        }
-        entities.set(id, entity);
-        if (entity.removed) {
-            graphs.set(id, null);
-            continue;
-        }
-        try {
-            graphs.set(id, await loadGraph(sessionApi, sessionID, id));
-        }
-        catch {
-            graphs.set(id, null);
-        }
-    }
-    const entityList = [...entities.values()];
-    if (entityList.length === 0) {
-        return null;
-    }
-    const relationshipChanges = uniqueStrings(changedRelationships
-        .map((relationship) => classifyRelationship(relationship, entities))
-        .filter((sentence) => !!sentence));
-    const domainMap = new Map();
-    for (const entity of entityList) {
-        const domain = inferDomain(entity);
-        const changes = domainMap.get(domain) ?? [];
-        changes.push(buildEntityChange(entity, changedRelationships, graphs.get(entity.id) ?? null));
-        domainMap.set(domain, changes);
-    }
-    const domains = [...domainMap.entries()]
-        .map(([name, changes]) => ({ name, changes: uniqueStrings(changes) }))
-        .sort((left, right) => left.name.localeCompare(right.name));
-    const domainNames = domains.map((domain) => domain.name);
-    const headline = `${summarizeTypes(entityList)} changed${domainNames.length > 1 ? ` across ${formatList(domainNames)} domains` : ""}.`;
-    const allDomainChanges = domains.flatMap((domain) => domain.changes);
-    const validationStatus = validationStatusText(checkResult);
-    const tldr = [
-        headline,
-        summarizeTopChanges(allDomainChanges, relationshipChanges),
-        validationStatus === "All checks pass"
-            ? "Validation remains clean."
-            : `${validationStatus}.`,
-    ]
-        .filter(Boolean)
-        .join(" ");
-    return {
-        headline,
-        tldr,
-        domains,
-        relationshipChanges,
-        validationStatus,
-    };
-}

package/dist/idle-brief-audit.d.ts

@@ -1,36 +0,0 @@
-export interface AuditCursor {
-    lastTimestamp: string;
-    lastOperation: string;
-    entryCount: number;
-    fileSize: number;
-}
-export interface AuditDelta {
-    hasChanges: boolean;
-    entries: AuditEntry[];
-    newCursor: AuditCursor;
-    contentHash: string;
-}
-export interface AuditEntry {
-    timestamp: string;
-    operation: string;
-    entityId: string;
-    payload?: AuditEntityPayload | AuditRelationshipPayload | null;
-}
-export interface AuditEntityPayload {
-    kind: "entity";
-    entityType: string;
-    changeKind?: "created" | "updated";
-    title?: string;
-    source?: string;
-    textRef?: string;
-    properties: Record<string, unknown>;
-}
-export interface AuditRelationshipPayload {
-    kind: "relationship";
-    relationshipType: string;
-    properties: Record<string, unknown>;
-}
-export declare function computeAuditDelta(workspaceRoot: string, branch: string, previousCursor: AuditCursor | null): AuditDelta;
-export declare function getLatestAuditCursor(workspaceRoot: string, branch: string): AuditCursor | null;
-export declare function getAuditTailCursor(workspaceRoot: string, branch: string): AuditCursor | null;
-export declare function guardBranchChanged(startBranch: string, currentBranch: string): boolean;

package/dist/idle-brief-audit.js

@@ -1,186 +0,0 @@
-import * as crypto from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { parsePrologValue, parsePropertyList, splitTopLevelGeneral, } from "kibi-cli/prolog/codec";
-import { resolveAuditLogPath } from "./idle-brief-paths.js";
-function asOptionalString(value) {
-    return typeof value === "string" ? value : undefined;
-}
-// Parse a single changeset line from the audit log
-function parseChangesetLine(line) {
-    const trimmedLine = line.trim();
-    if (!trimmedLine.startsWith("changeset(") || !trimmedLine.endsWith(").")) {
-        return null;
-    }
-    const argsLiteral = trimmedLine.slice("changeset(".length, -2);
-    const parts = splitTopLevelGeneral(argsLiteral, ",").map((part) => part.trim());
-    if (parts.length < 4) {
-        return null;
-    }
-    const timestamp = parsePrologValue(parts[0] ?? "");
-    const operation = parsePrologValue(parts[1] ?? "");
-    const entityId = parsePrologValue(parts[2] ?? "");
-    if (typeof timestamp !== "string" ||
-        typeof operation !== "string" ||
-        typeof entityId !== "string") {
-        return null;
-    }
-    const rawPayload = parts.slice(3).join(",");
-    const payload = parsePayload(rawPayload.trim());
-    return {
-        timestamp,
-        operation,
-        entityId,
-        ...(payload === undefined ? {} : { payload }),
-    };
-}
-function parsePayload(rawPayload) {
-    if (rawPayload === "null")
-        return null;
-    const match = rawPayload.match(/^([A-Za-z0-9_]+)-(.+)$/s);
-    if (!match)
-        return null;
-    const [, payloadType = "unknown", rawProps = ""] = match;
-    const properties = parsePropertyList(rawProps);
-    if (payloadType === "rel") {
-        return {
-            kind: "relationship",
-            relationshipType: payloadType,
-            properties,
-        };
-    }
-    const title = asOptionalString(properties.title);
-    const source = asOptionalString(properties.source);
-    const textRef = asOptionalString(properties.text_ref);
-    const changeKindRaw = properties.change_kind;
-    const changeKind = changeKindRaw === "created" || changeKindRaw === "updated"
-        ? changeKindRaw
-        : undefined;
-    return {
-        kind: "entity",
-        entityType: payloadType,
-        ...(changeKind ? { changeKind } : {}),
-        ...(title ? { title } : {}),
-        ...(source ? { source } : {}),
-        ...(textRef ? { textRef } : {}),
-        properties,
-    };
-}
-// implements REQ-opencode-kibi-briefing-v4
-// Read audit log and compute delta since last cursor
-export function computeAuditDelta(workspaceRoot, branch, previousCursor) {
-    const auditPath = resolveAuditLogPath(workspaceRoot, branch);
-    if (!fs.existsSync(auditPath)) {
-        return {
-            hasChanges: false,
-            entries: [],
-            newCursor: previousCursor ?? {
-                lastTimestamp: "",
-                lastOperation: "",
-                entryCount: 0,
-                fileSize: 0,
-            },
-            contentHash: "",
-        };
-    }
-    const content = fs.readFileSync(auditPath, "utf-8");
-    const lines = content
-        .split("\n")
-        .filter((l) => l.trim().includes("changeset("));
-    const fileSize = Buffer.byteLength(content, "utf-8");
-    // If no previous cursor or file hasn't grown, check if content changed
-    if (previousCursor &&
-        fileSize === previousCursor.fileSize &&
-        lines.length === previousCursor.entryCount) {
-        return {
-            hasChanges: false,
-            entries: [],
-            newCursor: previousCursor,
-            contentHash: computeSimpleHash(lines),
-        };
-    }
-    // Parse all entries
-    const entries = lines
-        .map(parseChangesetLine)
-        .filter((e) => e !== null)
-        .filter((e) => ["upsert", "upsert_rel", "delete"].includes(e.operation));
-    // If we have a previous cursor, filter to only new entries
-    let newEntries = entries;
-    if (previousCursor?.lastTimestamp) {
-        const lastIdx = entries.findIndex((e) => e.timestamp === previousCursor.lastTimestamp &&
-            e.operation === previousCursor.lastOperation);
-        if (lastIdx >= 0) {
-            newEntries = entries.slice(lastIdx + 1);
-        }
-    }
-    const lastEntry = entries[entries.length - 1];
-    const newCursor = {
-        lastTimestamp: lastEntry?.timestamp ?? "",
-        lastOperation: lastEntry?.operation ?? "",
-        entryCount: lines.length,
-        fileSize,
-    };
-    return {
-        hasChanges: newEntries.length > 0,
-        entries: newEntries,
-        newCursor,
-        contentHash: computeSimpleHash(lines),
-    };
-}
-function computeSimpleHash(lines) {
-    return crypto
-        .createHash("sha256")
-        .update(lines.join("\n"))
-        .digest("hex")
-        .slice(0, 16);
-}
-// implements REQ-opencode-kibi-briefing-v4
-// Extract the latest audit cursor from the most recent brief for this branch
-export function getLatestAuditCursor(workspaceRoot, branch) {
-    // Read .kb/briefs/ directory and find the latest brief for this branch
-    const briefsDir = path.join(workspaceRoot, ".kb", "briefs");
-    if (!fs.existsSync(briefsDir))
-        return null;
-    const files = fs
-        .readdirSync(briefsDir)
-        .filter((f) => f.endsWith("_brief.json") && !f.endsWith(".tmp"))
-        .map((f) => {
-        const fullPath = path.join(briefsDir, f);
-        const [rawTimestamp = "0"] = f.split("_");
-        const timestamp = Number.parseInt(rawTimestamp, 10);
-        return {
-            path: fullPath,
-            timestamp: Number.isNaN(timestamp) ? 0 : timestamp,
-        };
-    })
-        .sort((a, b) => b.timestamp - a.timestamp);
-    for (const file of files) {
-        try {
-            const brief = JSON.parse(fs.readFileSync(file.path, "utf-8"));
-            if (brief.branch === branch && brief.auditCursor) {
-                return brief.auditCursor;
-            }
-        }
-        catch {
-            // skip invalid JSON
-        }
-    }
-    return null;
-}
-export function getAuditTailCursor(
-// implements REQ-opencode-kibi-briefing-v6
-workspaceRoot, branch) {
-    const auditPath = resolveAuditLogPath(workspaceRoot, branch);
-    if (!fs.existsSync(auditPath)) {
-        return null;
-    }
-    const delta = computeAuditDelta(workspaceRoot, branch, null);
-    return delta.newCursor.entryCount > 0 || delta.newCursor.fileSize > 0
-        ? delta.newCursor
-        : null;
-}
-// implements REQ-opencode-kibi-briefing-v4
-// Guard: abort if branch changed since idle-start
-export function guardBranchChanged(startBranch, currentBranch) {
-    return startBranch !== currentBranch;
-}

package/dist/idle-brief-paths.d.ts

@@ -1,6 +0,0 @@
-export declare function resolveBriefsDir(workspaceRoot: string): string;
-export declare function resolveAuditLogPath(workspaceRoot: string, branch: string): string;
-export declare function resolveBriefFilePath(workspaceRoot: string, timestamp: number): string;
-export declare function resolveTempBriefPath(workspaceRoot: string, timestamp: number): string;
-export declare function atomicWriteBrief(workspaceRoot: string, timestamp: number, content: string): void;
-export declare function pruneOldBriefs(workspaceRoot: string, branch: string): void;