@jmtrin/opencode-kevin 1.2.0 → 1.4.0

package/dist/plugin/perf.d.ts

@@ -1,35 +0,0 @@
-import type { Store } from "./Store.js";
-export type PerfScope = "tool.execute.before" | "tool.execute.after" | "chat.message" | "chat.system.transform" | "session.compacting" | "event" | "session.idle" | "dispose";
-export interface Budget {
-    readonly scope: PerfScope;
-    readonly p95Ms: number;
-    readonly maxMs: number;
-}
-export declare const BUDGETS: readonly Budget[];
-export interface PerfStat {
-    readonly scope: PerfScope;
-    readonly count: number;
-    readonly p50: number;
-    readonly p95: number;
-    readonly max: number;
-    readonly budget: Budget;
-    readonly withinBudget: boolean;
-}
-export declare class Perf {
-    private readonly enabled;
-    private readonly capacity;
-    private readonly rings;
-    private readonly cursors;
-    private readonly counts;
-    constructor(opts: {
-        enabled: boolean;
-        capacity?: number | string;
-    });
-    static fromSettings(settings: Record<string, string | null | undefined>): Perf;
-    measure<T>(scope: PerfScope, fn: () => T): T;
-    measureAsync<T>(scope: PerfScope, fn: () => Promise<T>): Promise<T>;
-    private record;
-    stats(): readonly PerfStat[];
-    flush(store: Store): void;
-    reset(): void;
-}

package/dist/plugin/perf.js

@@ -1,174 +0,0 @@
-export const BUDGETS = [
-    { scope: "tool.execute.before", p95Ms: 2, maxMs: 10 },
-    { scope: "tool.execute.after", p95Ms: 5, maxMs: 25 },
-    { scope: "chat.message", p95Ms: 2, maxMs: 10 },
-    { scope: "chat.system.transform", p95Ms: 15, maxMs: 50 },
-    { scope: "session.compacting", p95Ms: 15, maxMs: 50 },
-    { scope: "event", p95Ms: 5, maxMs: 25 },
-    { scope: "session.idle", p95Ms: 150, maxMs: 600 },
-    { scope: "dispose", p95Ms: 50, maxMs: 250 },
-];
-function clampCapacity(raw) {
-    if (raw === null || raw === undefined || raw === "")
-        return 512;
-    const n = Number.parseInt(raw, 10);
-    if (Number.isNaN(n))
-        return 512;
-    return Math.min(8192, Math.max(64, n));
-}
-export class Perf {
-    enabled;
-    capacity;
-    rings;
-    cursors;
-    counts;
-    constructor(opts) {
-        this.enabled = opts.enabled;
-        if (typeof opts.capacity === "string") {
-            this.capacity = clampCapacity(opts.capacity);
-        }
-        else if (typeof opts.capacity === "number") {
-            this.capacity = Math.min(8192, Math.max(64, Math.floor(opts.capacity)));
-        }
-        else {
-            this.capacity = 512;
-        }
-        this.rings = new Map();
-        this.cursors = new Map();
-        this.counts = new Map();
-        const scopes = BUDGETS.map((b) => b.scope);
-        for (const s of scopes) {
-            this.rings.set(s, new Float64Array(this.capacity));
-            this.cursors.set(s, 0);
-            this.counts.set(s, 0);
-        }
-    }
-    static fromSettings(settings) {
-        const enabled = settings.perf_enabled === "1";
-        const cap = clampCapacity(settings.perf_ring_capacity);
-        return new Perf({ enabled, capacity: cap });
-    }
-    measure(scope, fn) {
-        if (!this.enabled)
-            return fn();
-        const start = performance.now();
-        try {
-            return fn();
-        }
-        finally {
-            const dur = performance.now() - start;
-            this.record(scope, dur);
-        }
-    }
-    async measureAsync(scope, fn) {
-        if (!this.enabled)
-            return fn();
-        const start = performance.now();
-        try {
-            return await fn();
-        }
-        finally {
-            const dur = performance.now() - start;
-            this.record(scope, dur);
-        }
-    }
-    record(scope, ms) {
-        const ring = this.rings.get(scope);
-        if (!ring)
-            return;
-        const cur = this.cursors.get(scope) ?? 0;
-        ring[cur % this.capacity] = ms;
-        this.cursors.set(scope, (cur + 1) % this.capacity);
-        this.counts.set(scope, (this.counts.get(scope) ?? 0) + 1);
-    }
-    stats() {
-        const out = [];
-        for (const b of BUDGETS) {
-            const ring = this.rings.get(b.scope);
-            if (!ring)
-                continue;
-            const count = this.counts.get(b.scope) ?? 0;
-            if (count === 0) {
-                out.push({
-                    scope: b.scope,
-                    count: 0,
-                    p50: 0,
-                    p95: 0,
-                    max: 0,
-                    budget: b,
-                    withinBudget: true,
-                });
-                continue;
-            }
-            const n = Math.min(count, this.capacity);
-            // Copy live samples: need to reconstruct in insertion order but for percentiles order doesn't matter.
-            // Take last n entries from ring (wrap-aware).
-            const samples = [];
-            const cur = this.cursors.get(b.scope) ?? 0;
-            // If count < capacity, samples are ring[0..count-1]; else ring[0..capacity-1] all valid but order is cur..cur+cap
-            if (count < this.capacity) {
-                for (let i = 0; i < count; i++)
-                    samples.push(ring[i]);
-            }
-            else {
-                for (let i = 0; i < this.capacity; i++)
-                    samples.push(ring[i]);
-            }
-            const sorted = [...samples].sort((a, b) => a - b);
-            // Percentile method: nearest-rank — p is the value at index ceil(p/100 * n) - 1
-            // of the ascending-sorted copy. Stated here so an implementer comparing against
-            // another percentile definition can see which one was chosen.
-            const p50 = sorted[Math.max(0, Math.ceil(sorted.length * 0.5) - 1)];
-            const p95 = sorted[Math.max(0, Math.ceil(sorted.length * 0.95) - 1)];
-            const max = sorted[sorted.length - 1];
-            out.push({
-                scope: b.scope,
-                count,
-                p50,
-                p95,
-                max,
-                budget: b,
-                withinBudget: p95 <= b.p95Ms,
-            });
-        }
-        return out;
-    }
-    flush(store) {
-        if (!this.enabled)
-            return;
-        const stats = this.stats();
-        let recorded = 0;
-        let breaches = 0;
-        for (const s of stats) {
-            if (s.count === 0)
-                continue;
-            store
-                .prepare("INSERT INTO perf_samples (scope, sample_count, p50_ms, p95_ms, max_ms, budget_p95_ms, within_budget) VALUES (?, ?, ?, ?, ?, ?, ?)")
-                .run(s.scope, s.count, s.p50, s.p95, s.max, s.budget.p95Ms, s.withinBudget ? 1 : 0);
-            recorded++;
-            if (!s.withinBudget)
-                breaches++;
-        }
-        if (recorded > 0) {
-            store
-                .prepare(`UPDATE kevin_metrics SET value = value + ? WHERE key = 'perf_samples_recorded'`)
-                .run(recorded);
-        }
-        if (breaches > 0) {
-            store
-                .prepare(`UPDATE kevin_metrics SET value = value + ? WHERE key = 'perf_budget_breaches'`)
-                .run(breaches);
-        }
-        this.reset();
-    }
-    reset() {
-        for (const b of BUDGETS) {
-            // Zero the ring too: cursors and counts alone would let the next
-            // period's stats() read stale pre-reset samples whenever
-            // count < capacity (review fix, v1.0.0).
-            this.rings.get(b.scope)?.fill(0);
-            this.cursors.set(b.scope, 0);
-            this.counts.set(b.scope, 0);
-        }
-    }
-}

package/dist/plugin/query-tokenizer.d.ts

@@ -1,13 +0,0 @@
-/**
- * K4-013 — shared FTS5 query tokenizer.
- *
- * Injection recall ORs the quoted tokens (`"t1" OR "t2"`) while
- * `kevin_why` ANDs them (`"t1" AND "t2"`).
- */
-export declare const STOP_WORDS: Set<string>;
-/** Lowercase, split on whitespace, drop stopwords. Returns raw tokens. */
-export declare function tokenizeQuery(query: string): string[];
-/** Quote a token for an FTS5 MATCH clause, escaping embedded quotes. */
-export declare function quoteToken(token: string): string;
-/** Join quoted tokens into a MATCH clause with the given separator. */
-export declare function toMatchClause(tokens: string[], separator: " OR " | " AND "): string;

package/dist/plugin/query-tokenizer.js

@@ -1,133 +0,0 @@
-/**
- * K4-013 — shared FTS5 query tokenizer.
- *
- * Injection recall ORs the quoted tokens (`"t1" OR "t2"`) while
- * `kevin_why` ANDs them (`"t1" AND "t2"`).
- */
-// v1.1.0 (K11-012 / plan §5.5, D11-05) — single source for STOP_WORDS (union of three lists)
-export const STOP_WORDS = new Set([
-    "a",
-    "about",
-    "after",
-    "again",
-    "all",
-    "also",
-    "an",
-    "and",
-    "any",
-    "are",
-    "as",
-    "at",
-    "be",
-    "been",
-    "before",
-    "being",
-    "but",
-    "by",
-    "can",
-    "como",
-    "con",
-    "could",
-    "de",
-    "did",
-    "do",
-    "does",
-    "el",
-    "en",
-    "eso",
-    "for",
-    "from",
-    "had",
-    "has",
-    "have",
-    "he",
-    "her",
-    "his",
-    "how",
-    "i",
-    "if",
-    "in",
-    "into",
-    "is",
-    "it",
-    "its",
-    "la",
-    "las",
-    "los",
-    "may",
-    "mi",
-    "might",
-    "more",
-    "most",
-    "must",
-    "my",
-    "not",
-    "o",
-    "of",
-    "on",
-    "one",
-    "or",
-    "our",
-    "para",
-    "per",
-    "por",
-    "que",
-    "shall",
-    "she",
-    "sin",
-    "so",
-    "su",
-    "than",
-    "that",
-    "the",
-    "their",
-    "them",
-    "then",
-    "there",
-    "these",
-    "they",
-    "this",
-    "those",
-    "through",
-    "to",
-    "too",
-    "tu",
-    "un",
-    "una",
-    "under",
-    "up",
-    "us",
-    "via",
-    "was",
-    "we",
-    "were",
-    "what",
-    "when",
-    "where",
-    "which",
-    "while",
-    "who",
-    "why",
-    "will",
-    "with",
-    "would",
-    "y",
-    "you",
-    "your",
-]);
-/** Lowercase, split on whitespace, drop stopwords. Returns raw tokens. */
-export function tokenizeQuery(query) {
-    return query
-        .trim()
-        .toLowerCase()
-        .split(/\s+/)
-        .filter((t) => t.length > 0 && !STOP_WORDS.has(t));
-}
-/** Quote a token for an FTS5 MATCH clause, escaping embedded quotes. */
-export function quoteToken(token) {
-    return `"${token.replace(/"/g, '""')}"`;
-}
-/** Join quoted tokens into a MATCH clause with the given separator. */
-export function toMatchClause(tokens, separator) {
-    return tokens.map(quoteToken).join(separator);
-}

package/dist/plugin/redact.d.ts

@@ -1,2 +0,0 @@
-export declare function redactPaths(text: string): string;
-export declare function stripPrivate(text: string): string;

package/dist/plugin/redact.js

@@ -1,18 +0,0 @@
-const PATH_PATTERNS = [
-    /[a-z]:\\[^\s"'<>|*?:]+/gi,
-    /\/(?:home|users|var|tmp|opt|etc|root|usr|app|work|workspace|code|repo|project|src|build|dist|packages|services|api|web|client|server|lib|node_modules)(?:\/[^\s"'<>|*?:]+)*/gi,
-];
-export function redactPaths(text) {
-    let out = text;
-    for (const pat of PATH_PATTERNS) {
-        out = out.replace(pat, "<path>");
-    }
-    return out;
-}
-const PRIVATE_BLOCK_RE = /<private\b[^>]*>([\s\S]*?)<\/private>/gi;
-export function stripPrivate(text) {
-    return text.replace(PRIVATE_BLOCK_RE, (_match, inner) => {
-        const n = inner.length;
-        return `<private: redacted ${n} chars>`;
-    });
-}

package/dist/plugin/replay-types.d.ts

@@ -1,69 +0,0 @@
-/**
- * v0.5.0 (K5-018 / plan §5.8) — replay transcript format.
- *
- * A hermetic, deterministic way to run a recorded session through the
- * plugin's components and read the outcome distribution. `at` is an
- * ISO-8601 string and is the ONLY source of time during replay:
- * `Date.now()` must not be called anywhere in the replay path.
- *
- * v0.7.0 — hand-rolled validation: the zod dependency was removed
- * (docs/Kevin_v0.9.0_Plan.md D9-05). This module has no zod import.
- */
-export type ReplayEvent = {
-    kind: "session.created";
-    at: string;
-    sessionId: string;
-} | {
-    kind: "chat.message";
-    at: string;
-    sessionId: string;
-    text: string;
-} | {
-    kind: "tool.before";
-    at: string;
-    sessionId: string;
-    callId: string;
-    tool: string;
-    args: Record<string, unknown>;
-} | {
-    kind: "tool.after";
-    at: string;
-    sessionId: string;
-    callId: string;
-    success: boolean;
-    stdout?: string;
-    stderr?: string;
-    exitCode?: number;
-} | {
-    kind: "system.transform";
-    at: string;
-    sessionId: string;
-} | {
-    kind: "compacting";
-    at: string;
-    sessionId: string;
-} | {
-    kind: "session.idle";
-    at: string;
-    sessionId: string;
-};
-export interface ReplayTranscript {
-    readonly version: 1;
-    readonly name: string;
-    readonly events: readonly ReplayEvent[];
-}
-/** Validates an unknown payload (e.g. a parsed JSON file) as a transcript. */
-export declare function parseTranscript(json: unknown): ReplayTranscript;
-interface SchemaLike<T> {
-    parse(value: unknown): T;
-    safeParse(value: unknown): {
-        success: true;
-        data: T;
-    } | {
-        success: false;
-        error: Error;
-    };
-}
-export declare const replayEventSchema: SchemaLike<ReplayEvent>;
-export declare const replayTranscriptSchema: SchemaLike<ReplayTranscript>;
-export {};

package/dist/plugin/replay-types.js

@@ -1,156 +0,0 @@
-/**
- * v0.5.0 (K5-018 / plan §5.8) — replay transcript format.
- *
- * A hermetic, deterministic way to run a recorded session through the
- * plugin's components and read the outcome distribution. `at` is an
- * ISO-8601 string and is the ONLY source of time during replay:
- * `Date.now()` must not be called anywhere in the replay path.
- *
- * v0.7.0 — hand-rolled validation: the zod dependency was removed
- * (docs/Kevin_v0.9.0_Plan.md D9-05). This module has no zod import.
- */
-const EVENT_KINDS = [
-    "session.created",
-    "chat.message",
-    "tool.before",
-    "tool.after",
-    "system.transform",
-    "compacting",
-    "session.idle",
-];
-const ISO_DATETIME_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/;
-function isObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isIsoDatetime(value) {
-    return (typeof value === "string" &&
-        ISO_DATETIME_RE.test(value) &&
-        !Number.isNaN(Date.parse(value)));
-}
-function isNonEmptyString(value) {
-    return typeof value === "string" && value.length > 0;
-}
-function isInteger(value) {
-    return typeof value === "number" && Number.isInteger(value);
-}
-function parseEvent(value) {
-    if (!isObject(value)) {
-        throw new Error("replay event must be an object");
-    }
-    const kind = value.kind;
-    if (typeof kind !== "string" ||
-        !EVENT_KINDS.includes(kind)) {
-        throw new Error(`unknown replay event kind: ${String(kind)}`);
-    }
-    const at = value.at;
-    if (!isIsoDatetime(at)) {
-        throw new Error("replay event `at` must be an ISO-8601 datetime string");
-    }
-    const sessionId = value.sessionId;
-    if (!isNonEmptyString(sessionId)) {
-        throw new Error("replay event `sessionId` must be a non-empty string");
-    }
-    switch (kind) {
-        case "session.created":
-        case "system.transform":
-        case "compacting":
-        case "session.idle":
-            return { kind, at, sessionId };
-        case "chat.message": {
-            const text = value.text;
-            if (!isNonEmptyString(text)) {
-                throw new Error("chat.message `text` must be a non-empty string");
-            }
-            return { kind, at, sessionId, text };
-        }
-        case "tool.before": {
-            const callId = value.callId;
-            if (!isNonEmptyString(callId)) {
-                throw new Error("tool.before `callId` must be a non-empty string");
-            }
-            const tool = value.tool;
-            if (!isNonEmptyString(tool)) {
-                throw new Error("tool.before `tool` must be a non-empty string");
-            }
-            if (!isObject(value.args)) {
-                throw new Error("tool.before `args` must be an object");
-            }
-            return { kind, at, sessionId, callId, tool, args: value.args };
-        }
-        case "tool.after": {
-            const callId = value.callId;
-            if (!isNonEmptyString(callId)) {
-                throw new Error("tool.after `callId` must be a non-empty string");
-            }
-            if (typeof value.success !== "boolean") {
-                throw new Error("tool.after `success` must be a boolean");
-            }
-            const event = {
-                kind,
-                at,
-                sessionId,
-                callId,
-                success: value.success,
-            };
-            if (value.stdout !== undefined) {
-                if (!isNonEmptyString(value.stdout)) {
-                    throw new Error("tool.after `stdout` must be a non-empty string");
-                }
-                event.stdout = value.stdout;
-            }
-            if (value.stderr !== undefined) {
-                if (!isNonEmptyString(value.stderr)) {
-                    throw new Error("tool.after `stderr` must be a non-empty string");
-                }
-                event.stderr = value.stderr;
-            }
-            if (value.exitCode !== undefined) {
-                if (!isInteger(value.exitCode)) {
-                    throw new Error("tool.after `exitCode` must be an integer");
-                }
-                event.exitCode = value.exitCode;
-            }
-            return event;
-        }
-    }
-    throw new Error(`unhandled replay event kind: ${String(kind)}`);
-}
-/** Validates an unknown payload (e.g. a parsed JSON file) as a transcript. */
-export function parseTranscript(json) {
-    if (!isObject(json)) {
-        throw new Error("replay transcript must be an object");
-    }
-    if (json.version !== 1) {
-        throw new Error("replay transcript `version` must be 1");
-    }
-    const name = json.name;
-    if (!isNonEmptyString(name)) {
-        throw new Error("replay transcript `name` must be a non-empty string");
-    }
-    if (!Array.isArray(json.events) || json.events.length === 0) {
-        throw new Error("replay transcript `events` must be a non-empty array");
-    }
-    return {
-        version: 1,
-        name,
-        events: json.events.map(parseEvent),
-    };
-}
-function toSchema(parse) {
-    return {
-        parse,
-        safeParse(value) {
-            try {
-                return { success: true, data: parse(value) };
-            }
-            catch (error) {
-                return {
-                    success: false,
-                    error: error instanceof Error ? error : new Error(String(error)),
-                };
-            }
-        },
-    };
-}
-export const replayEventSchema = toSchema(parseEvent);
-export const replayTranscriptSchema = toSchema(parseTranscript);

package/dist/plugin/replay.d.ts

@@ -1,36 +0,0 @@
-import type { ReplayTranscript } from "./replay-types.js";
-/**
- * v0.5.0 (K5-019 / plan §5.8, D5-12) — replay harness.
- *
- * Hermetic, deterministic driver: runs a recorded transcript through the
- * plugin's components against an in-memory database with a frozen clock,
- * then reports the outcome distribution. This is an artifact, not a
- * release gate.
- *
- * The components are instantiated directly — NOT through `KevinPlugin`,
- * which resolves a home-directory database path and registers tools.
- * `Date.now()` must never be called in this path; every clock need is
- * satisfied by the event's `at` timestamp (retrieval is frozen by the
- * `deterministic_retrieval` setting; the Archiver clock is injected).
- */
-export interface ReplayResult {
-    readonly transcript: string;
-    readonly memoriesCreated: number;
-    readonly injections: {
-        total: number;
-        effective: number;
-        ineffective: number;
-        inconclusive: number;
-        unmeasured: number;
-    };
-    readonly precisionRate: number;
-    readonly coverageRate: number;
-    readonly tokensInjected: {
-        prePrompt: number;
-        compacting: number;
-    };
-    readonly blocked: Record<string, number>;
-}
-export declare function replay(transcript: ReplayTranscript, opts?: {
-    dbPath?: string;
-}): Promise<ReplayResult>;