kibi-opencode 0.14.0 → 0.15.1

package/dist/idle-brief-paths.js

@@ -1,120 +0,0 @@
-import * as path from "node:path";
-import * as fs from "node:fs";
-import { loadBriefConfig } from "kibi-cli/brief-config";
-const TUI_SEEN_FILE = ".tui-seen.json";
-export function resolveBriefsDir(workspaceRoot) {
-    return path.join(workspaceRoot, ".kb", "briefs");
-}
-export function resolveAuditLogPath(workspaceRoot, branch) {
-    return path.join(workspaceRoot, ".kb", "branches", branch, "audit.log");
-}
-export function resolveBriefFilePath(workspaceRoot, timestamp) {
-    return path.join(resolveBriefsDir(workspaceRoot), `${timestamp}_brief.json`);
-}
-export function resolveTempBriefPath(workspaceRoot, timestamp) {
-    return path.join(resolveBriefsDir(workspaceRoot), `${timestamp}_brief.json.tmp`);
-}
-export function atomicWriteBrief(workspaceRoot, timestamp, content) {
-    const briefsDir = resolveBriefsDir(workspaceRoot);
-    if (!fs.existsSync(briefsDir)) {
-        fs.mkdirSync(briefsDir, { recursive: true });
-    }
-    const tempPath = resolveTempBriefPath(workspaceRoot, timestamp);
-    const finalPath = resolveBriefFilePath(workspaceRoot, timestamp);
-    fs.writeFileSync(tempPath, content, "utf-8");
-    fs.renameSync(tempPath, finalPath);
-}
-function extractTimestamp(fileName) {
-    const match = /^(\d+)_brief\.json$/.exec(fileName);
-    if (!match)
-        return null;
-    const n = Number(match[1]);
-    return Number.isFinite(n) ? n : null;
-}
-export function pruneOldBriefs(workspaceRoot, branch) {
-    const briefsDir = resolveBriefsDir(workspaceRoot);
-    if (!fs.existsSync(briefsDir))
-        return;
-    const shared = loadBriefConfig(workspaceRoot);
-    const maxPerBranch = Math.max(1, Number(shared.retention?.maxPerBranch ?? 200));
-    const maxAgeDays = Math.max(1, Number(shared.retention?.maxAgeDays ?? 14));
-    const keepUnread = shared.retention?.keepUnread ?? true;
-    const maxAgeMs = maxAgeDays * 24 * 60 * 60 * 1000;
-    const now = Date.now();
-    const branchFiles = [];
-    for (const file of fs.readdirSync(briefsDir)) {
-        if (!file.endsWith("_brief.json") || file.endsWith(".tmp"))
-            continue;
-        const ts = extractTimestamp(file);
-        if (ts === null)
-            continue;
-        const fullPath = path.join(briefsDir, file);
-        let parsed = {};
-        try {
-            parsed = JSON.parse(fs.readFileSync(fullPath, "utf-8"));
-        }
-        catch {
-            continue;
-        }
-        if (parsed.branch !== branch)
-            continue;
-        const nextItem = {
-            fullPath,
-            timestamp: ts,
-            unread: parsed.unread === true,
-        };
-        if (typeof parsed.contentHash === "string") {
-            nextItem.contentHash = parsed.contentHash;
-        }
-        branchFiles.push(nextItem);
-    }
-    branchFiles.sort((a, b) => b.timestamp - a.timestamp);
-    const keepSet = new Set();
-    for (const item of branchFiles.slice(0, maxPerBranch)) {
-        keepSet.add(item.fullPath);
-    }
-    if (keepUnread) {
-        for (const item of branchFiles) {
-            if (item.unread)
-                keepSet.add(item.fullPath);
-        }
-    }
-    for (const item of branchFiles) {
-        const olderThanThreshold = now - item.timestamp > maxAgeMs;
-        if (olderThanThreshold && !(keepUnread && item.unread)) {
-            keepSet.delete(item.fullPath);
-        }
-    }
-    for (const item of branchFiles) {
-        const shouldDelete = !keepSet.has(item.fullPath);
-        if (!shouldDelete)
-            continue;
-        try {
-            fs.unlinkSync(item.fullPath);
-        }
-        catch {
-            // best-effort cleanup
-        }
-    }
-    const remainingHashes = new Set(branchFiles
-        .filter((item) => keepSet.has(item.fullPath))
-        .map((item) => item.contentHash)
-        .filter((hash) => typeof hash === "string"));
-    const seenPath = path.join(briefsDir, TUI_SEEN_FILE);
-    try {
-        const parsed = JSON.parse(fs.readFileSync(seenPath, "utf-8"));
-        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
-            return;
-        const byBranch = parsed;
-        const existing = byBranch[branch];
-        if (!Array.isArray(existing))
-            return;
-        byBranch[branch] = existing.filter((entry) => typeof entry === "string" && remainingHashes.has(entry));
-        const tempPath = `${seenPath}.tmp`;
-        fs.writeFileSync(tempPath, JSON.stringify(byBranch, null, 2), "utf-8");
-        fs.renameSync(tempPath, seenPath);
-    }
-    catch {
-        // best-effort cleanup
-    }
-}

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

@@ -1,37 +0,0 @@
-import { type IdleBriefEnvelope } from "./idle-brief-store.js";
-export declare function hasTuiSeenBrief(workspaceRoot: string, branch: string, contentHash: string): boolean;
-export declare function markBriefTuiSeen(workspaceRoot: string, branch: string, contentHash: string): void;
-/**
- * Select the latest unread brief for the given branch.
- *
- * Scans `.kb/briefs/` for `{timestamp}_brief.json` files, ignoring `.tmp` files
- * and invalid JSON. Filters by `branch`, supported schema version, and
- * `unread === true`. Returns the brief with the highest filename timestamp,
- * or null if no unread briefs exist.
- */
-export declare function selectLatestUnreadBrief(workspaceRoot: string, branch: string): {
-    envelope: IdleBriefEnvelope;
-    filePath: string;
-} | null;
-/**
- * Select the latest persisted brief for the given branch, regardless of read status.
- *
- * Same scanning logic as `selectLatestUnreadBrief` but returns the latest brief
- * even if all briefs have been read. Useful for route rendering where the user
- * wants to review the most recent brief.
- */
-export declare function selectLatestPersistedBrief(// implements REQ-opencode-kibi-briefing-v6
-workspaceRoot: string, branch: string): {
-    envelope: IdleBriefEnvelope;
-    filePath: string;
-} | null;
-/**
- * Atomically mark a brief as read by setting `unread` to false.
- *
- * Uses the write-to-temp-then-rename pattern to ensure atomicity.
- * Preserves ALL other envelope fields (contentHash, auditCursor, etc.).
- *
- * @param workspaceRoot - The root of the workspace
- * @param briefPath - Absolute path to the brief file to mark as read
- */
-export declare function markBriefRead(workspaceRoot: string, briefPath: string): void;

package/dist/idle-brief-reader.js

@@ -1,163 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { resolveBriefsDir } from "./idle-brief-paths.js";
-import { isIdleBriefEnvelope, } from "./idle-brief-store.js";
-const BRIEF_FILENAME_RE = /^(\d+)_brief\.json$/;
-const TUI_SEEN_FILE = ".tui-seen.json";
-function resolveTuiSeenPath(workspaceRoot) {
-    return path.join(resolveBriefsDir(workspaceRoot), TUI_SEEN_FILE);
-}
-function readTuiSeenHashes(workspaceRoot, branch) {
-    const seenPath = resolveTuiSeenPath(workspaceRoot);
-    try {
-        const parsed = JSON.parse(fs.readFileSync(seenPath, "utf-8"));
-        if (!parsed || typeof parsed !== "object")
-            return new Set();
-        const byBranch = parsed;
-        const values = byBranch[branch];
-        if (!Array.isArray(values))
-            return new Set();
-        return new Set(values.filter((entry) => typeof entry === "string"));
-    }
-    catch {
-        return new Set();
-    }
-}
-export function hasTuiSeenBrief(workspaceRoot, branch, contentHash) {
-    return readTuiSeenHashes(workspaceRoot, branch).has(contentHash);
-}
-export function markBriefTuiSeen(workspaceRoot, branch, contentHash) {
-    const briefsDir = resolveBriefsDir(workspaceRoot);
-    fs.mkdirSync(briefsDir, { recursive: true });
-    const seenPath = resolveTuiSeenPath(workspaceRoot);
-    let parsed = {};
-    try {
-        const raw = JSON.parse(fs.readFileSync(seenPath, "utf-8"));
-        if (raw && typeof raw === "object" && !Array.isArray(raw)) {
-            parsed = raw;
-        }
-    }
-    catch { }
-    const existing = Array.isArray(parsed[branch]) ? parsed[branch] : [];
-    const next = [contentHash, ...existing.filter((entry) => entry !== contentHash)].slice(0, 100);
-    parsed[branch] = next;
-    const tempPath = `${seenPath}.tmp`;
-    fs.writeFileSync(tempPath, JSON.stringify(parsed, null, 2), "utf-8");
-    fs.renameSync(tempPath, seenPath);
-}
-/**
- * Extract the numeric timestamp prefix from a brief filename.
- * Returns null if the filename does not match the expected pattern.
- */
-function extractTimestamp(filename) {
-    const match = filename.match(BRIEF_FILENAME_RE);
-    if (!match)
-        return null;
-    return Number(match[1]);
-}
-/**
- * Internal shared scanner for brief files.
- *
- * @param workspaceRoot - The root of the workspace
- * @param branch - Branch name to filter by
- * @param filterUnread - If true, only return briefs with unread === true
- */
-function scanBriefs(workspaceRoot, branch, filterUnread) {
-    const briefsDir = resolveBriefsDir(workspaceRoot);
-    if (!fs.existsSync(briefsDir)) {
-        return null;
-    }
-    const files = fs.readdirSync(briefsDir);
-    const candidates = [];
-    for (const file of files) {
-        // Ignore .tmp files
-        if (file.endsWith(".tmp"))
-            continue;
-        const timestamp = extractTimestamp(file);
-        if (timestamp === null)
-            continue;
-        const filePath = path.join(briefsDir, file);
-        let envelope;
-        try {
-            const raw = fs.readFileSync(filePath, "utf-8");
-            const parsed = JSON.parse(raw);
-            if (!isIdleBriefEnvelope(parsed)) {
-                continue;
-            }
-            envelope = parsed;
-        }
-        catch {
-            // Skip invalid JSON
-            continue;
-        }
-        // Filter by branch, schemaVersion, and optionally unread status
-        if (envelope.branch === branch &&
-            (envelope.schemaVersion === "1.0" || envelope.schemaVersion === "2.0") &&
-            (!filterUnread || envelope.unread === true)) {
-            candidates.push({ timestamp, envelope, filePath });
-        }
-    }
-    if (candidates.length === 0) {
-        return null;
-    }
-    // Sort by filename timestamp descending — latest first
-    candidates.sort((a, b) => b.timestamp - a.timestamp);
-    const latest = candidates[0];
-    if (!latest) {
-        return null;
-    }
-    return {
-        envelope: latest.envelope,
-        filePath: latest.filePath,
-    };
-}
-/**
- * Select the latest unread brief for the given branch.
- *
- * Scans `.kb/briefs/` for `{timestamp}_brief.json` files, ignoring `.tmp` files
- * and invalid JSON. Filters by `branch`, supported schema version, and
- * `unread === true`. Returns the brief with the highest filename timestamp,
- * or null if no unread briefs exist.
- */
-export function selectLatestUnreadBrief(
-// implements REQ-opencode-kibi-briefing-v4
-workspaceRoot, branch) {
-    return scanBriefs(workspaceRoot, branch, true);
-}
-/**
- * Select the latest persisted brief for the given branch, regardless of read status.
- *
- * Same scanning logic as `selectLatestUnreadBrief` but returns the latest brief
- * even if all briefs have been read. Useful for route rendering where the user
- * wants to review the most recent brief.
- */
-export function selectLatestPersistedBrief(// implements REQ-opencode-kibi-briefing-v6
-workspaceRoot, branch) {
-    return scanBriefs(workspaceRoot, branch, false);
-}
-/**
- * Atomically mark a brief as read by setting `unread` to false.
- *
- * Uses the write-to-temp-then-rename pattern to ensure atomicity.
- * Preserves ALL other envelope fields (contentHash, auditCursor, etc.).
- *
- * @param workspaceRoot - The root of the workspace
- * @param briefPath - Absolute path to the brief file to mark as read
- */
-export function markBriefRead(
-// implements REQ-opencode-kibi-briefing-v4
-workspaceRoot, briefPath) {
-    const briefsDir = resolveBriefsDir(workspaceRoot);
-    const resolvedBriefPath = path.resolve(briefPath);
-    const resolvedBriefsDir = path.resolve(briefsDir);
-    // Security: ensure the brief path is within the expected briefs directory
-    if (!resolvedBriefPath.startsWith(resolvedBriefsDir + path.sep)) {
-        throw new Error(`Invalid brief path: ${briefPath} is not inside ${briefsDir}`);
-    }
-    const raw = fs.readFileSync(briefPath, "utf-8");
-    const brief = JSON.parse(raw);
-    brief.unread = false;
-    const tempPath = `${briefPath}.tmp`;
-    fs.writeFileSync(tempPath, JSON.stringify(brief, null, 2), "utf-8");
-    fs.renameSync(tempPath, briefPath);
-}

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

@@ -1,55 +0,0 @@
-import type { BriefingWorkspaceCtx } from "./briefing-runtime.js";
-import type { AuditDelta } from "./idle-brief-audit.js";
-import { type IdleBriefEnvelope } from "./idle-brief-store.js";
-export interface IdleBriefResult {
-    success: boolean;
-    briefPath: string | null;
-    envelope: IdleBriefEnvelope | null;
-}
-export interface CheckResult {
-    violations: Array<{
-        rule: string;
-        entityId: string;
-        description: string;
-        suggestion?: string;
-        source?: string;
-    }>;
-    count: number;
-    diagnostics: Array<{
-        category: string;
-        severity: string;
-        message: string;
-        file?: string;
-        suggestion?: string;
-    }>;
-}
-export interface IdleBriefStatement {
-    statement: string;
-    citationIds: string[];
-}
-export interface IdleBriefingResult {
-    briefingState: string;
-    tldr: string;
-    promptBlock: string;
-    citations: Array<{
-        id: string;
-        type?: string;
-        title?: string;
-        source?: string;
-        textRef?: string;
-    }>;
-    constraints?: IdleBriefStatement[];
-    regressionRisks?: IdleBriefStatement[];
-    missingEvidence?: IdleBriefStatement[];
-}
-type IdleBriefRelationship = {
-    from: string;
-    to: string;
-    type: string;
-};
-export declare function generateIdleBrief(client: unknown, workspaceCtx: BriefingWorkspaceCtx, auditDelta: AuditDelta, sessionId: string, options?: {
-    sourceFiles?: string[];
-    changedEntityIds?: string[];
-    relationships?: IdleBriefRelationship[];
-}): Promise<IdleBriefResult>;
-export {};