@a5c-ai/babysitter-sdk 0.0.187-staging.eb2fe8ce → 0.0.187-staging.fb5368f2

package/dist/api/index.d.ts

@@ -0,0 +1,3 @@
+export { apiCreateRun, apiIterate, apiCommitEffect, apiRunStatus, apiRunEvents, } from "./runs";
+export type { ApiResult, ApiCreateRunInput, ApiIterateOutput, RunStatusOutput, RunEventsOutput, } from "./runs";
+//# sourceMappingURL=index.d.ts.map

package/dist/api/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,UAAU,EACV,eAAe,EACf,YAAY,EACZ,YAAY,GACb,MAAM,QAAQ,CAAC;AAEhB,YAAY,EACV,SAAS,EACT,iBAAiB,EACjB,gBAAgB,EAChB,eAAe,EACf,eAAe,GAChB,MAAM,QAAQ,CAAC"}

package/dist/api/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiRunEvents = exports.apiRunStatus = exports.apiCommitEffect = exports.apiIterate = exports.apiCreateRun = void 0;
+var runs_1 = require("./runs");
+Object.defineProperty(exports, "apiCreateRun", { enumerable: true, get: function () { return runs_1.apiCreateRun; } });
+Object.defineProperty(exports, "apiIterate", { enumerable: true, get: function () { return runs_1.apiIterate; } });
+Object.defineProperty(exports, "apiCommitEffect", { enumerable: true, get: function () { return runs_1.apiCommitEffect; } });
+Object.defineProperty(exports, "apiRunStatus", { enumerable: true, get: function () { return runs_1.apiRunStatus; } });
+Object.defineProperty(exports, "apiRunEvents", { enumerable: true, get: function () { return runs_1.apiRunEvents; } });

package/dist/api/runs.d.ts

@@ -0,0 +1,79 @@
+/**
+ * GAP-JSON-001: Programmatic API for run lifecycle.
+ *
+ * Thin typed wrappers over existing runtime functions with validation,
+ * error handling, and ApiResult envelopes.  These functions never throw.
+ */
+import type { EffectAction, IterationResult } from "../runtime/types";
+import type { JsonRecord } from "../storage/types";
+export type ApiResult<T> = {
+    ok: true;
+    data: T;
+} | {
+    ok: false;
+    error: {
+        code: string;
+        message: string;
+    };
+};
+export interface ApiCreateRunInput {
+    processId: string;
+    entrypoint: string;
+    runsDir: string;
+    inputs?: unknown;
+    prompt?: string;
+    harness?: string;
+}
+export interface ApiIterateOutput {
+    status: IterationResult["status"];
+    output?: unknown;
+    error?: unknown;
+    nextActions?: EffectAction[];
+    metadata?: unknown;
+}
+export interface RunStatusOutput {
+    state: "created" | "running" | "waiting" | "completed" | "failed";
+    processId: string;
+    runId: string;
+    pendingEffects: Array<{
+        effectId: string;
+        kind?: string;
+    }>;
+}
+export interface RunEventsOutput {
+    events: Array<{
+        seq: number;
+        type: string;
+        recordedAt: string;
+        data: JsonRecord;
+    }>;
+}
+export declare function apiCreateRun(input: ApiCreateRunInput): Promise<ApiResult<{
+    runId: string;
+    runDir: string;
+}>>;
+export declare function apiIterate(input: {
+    runDir: string;
+}): Promise<ApiResult<ApiIterateOutput>>;
+export declare function apiCommitEffect(input: {
+    runDir: string;
+    effectId: string;
+    result: {
+        status: "ok" | "error";
+        value?: unknown;
+        error?: string;
+    };
+}): Promise<ApiResult<{
+    resultRef: string;
+}>>;
+export declare function apiRunStatus(input: {
+    runId: string;
+    runsDir: string;
+}): Promise<ApiResult<RunStatusOutput>>;
+export declare function apiRunEvents(input: {
+    runId: string;
+    runsDir: string;
+    limit?: number;
+    filterType?: string;
+}): Promise<ApiResult<RunEventsOutput>>;
+//# sourceMappingURL=runs.d.ts.map

package/dist/api/runs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runs.d.ts","sourceRoot":"","sources":["../../src/api/runs.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAUH,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACtE,OAAO,KAAK,EAAgB,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAIjE,MAAM,MAAM,SAAS,CAAC,CAAC,IACnB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,CAAC,CAAA;CAAE,GACrB;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,CAAC;AAY5D,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC,CAAC;IAClC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,WAAW,CAAC,EAAE,YAAY,EAAE,CAAC;IAC7B,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,CAAC;IAClE,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC5D;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,KAAK,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;QACZ,IAAI,EAAE,MAAM,CAAC;QACb,UAAU,EAAE,MAAM,CAAC;QACnB,IAAI,EAAE,UAAU,CAAC;KAClB,CAAC,CAAC;CACJ;AAoCD,wBAAsB,YAAY,CAChC,KAAK,EAAE,iBAAiB,GACvB,OAAO,CAAC,SAAS,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CAgCvD;AAED,wBAAsB,UAAU,CAC9B,KAAK,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,GACxB,OAAO,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC,CA0BtC;AAED,wBAAsB,eAAe,CACnC,KAAK,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE;QAAE,MAAM,EAAE,IAAI,GAAG,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,GAC/G,OAAO,CAAC,SAAS,CAAC;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CAwB3C;AAED,wBAAsB,YAAY,CAChC,KAAK,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACxC,OAAO,CAAC,SAAS,CAAC,eAAe,CAAC,CAAC,CAwBrC;AAED,wBAAsB,YAAY,CAChC,KAAK,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,GAC7E,OAAO,CAAC,SAAS,CAAC,eAAe,CAAC,CAAC,CAkCrC"}

package/dist/api/runs.js

@@ -0,0 +1,246 @@
+"use strict";
+/**
+ * GAP-JSON-001: Programmatic API for run lifecycle.
+ *
+ * Thin typed wrappers over existing runtime functions with validation,
+ * error handling, and ApiResult envelopes.  These functions never throw.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiCreateRun = apiCreateRun;
+exports.apiIterate = apiIterate;
+exports.apiCommitEffect = apiCommitEffect;
+exports.apiRunStatus = apiRunStatus;
+exports.apiRunEvents = apiRunEvents;
+const fs_1 = require("fs");
+const createRun_1 = require("../runtime/createRun");
+const orchestrateIteration_1 = require("../runtime/orchestrateIteration");
+const commitEffectResult_1 = require("../runtime/commitEffectResult");
+const runFiles_1 = require("../storage/runFiles");
+const journal_1 = require("../storage/journal");
+const paths_1 = require("../storage/paths");
+const exceptions_1 = require("../runtime/exceptions");
+function ok(data) {
+    return { ok: true, data };
+}
+function fail(code, message) {
+    return { ok: false, error: { code, message } };
+}
+// ── Helpers ─────────────────────────────────────────────────────────────────
+function parseEntrypoint(entrypoint) {
+    const hashIndex = entrypoint.lastIndexOf("#");
+    if (hashIndex <= 0) {
+        return { importPath: entrypoint, exportName: undefined };
+    }
+    return {
+        importPath: entrypoint.slice(0, hashIndex),
+        exportName: entrypoint.slice(hashIndex + 1) || undefined,
+    };
+}
+async function pathExists(p) {
+    try {
+        await fs_1.promises.access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function classifyError(error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    if (error instanceof exceptions_1.RunFailedError && msg.startsWith("Unknown effectId")) {
+        return { code: "UNKNOWN_EFFECT", message: msg };
+    }
+    return { code: "INTERNAL_ERROR", message: msg };
+}
+// ── API functions ───────────────────────────────────────────────────────────
+async function apiCreateRun(input) {
+    try {
+        // Validate inputs
+        if (!input.processId || typeof input.processId !== "string") {
+            return fail("INVALID_INPUT", "processId must be a non-empty string");
+        }
+        if (!input.entrypoint || typeof input.entrypoint !== "string") {
+            return fail("INVALID_INPUT", "entrypoint must be a non-empty string");
+        }
+        if (!input.runsDir || typeof input.runsDir !== "string") {
+            return fail("INVALID_INPUT", "runsDir must be a non-empty string");
+        }
+        const { importPath, exportName } = parseEntrypoint(input.entrypoint);
+        const result = await (0, createRun_1.createRun)({
+            runsDir: input.runsDir,
+            process: {
+                processId: input.processId,
+                importPath,
+                exportName,
+            },
+            inputs: input.inputs,
+            prompt: input.prompt,
+            harness: input.harness,
+        });
+        return ok({ runId: result.runId, runDir: result.runDir });
+    }
+    catch (error) {
+        const classified = classifyError(error);
+        return fail(classified.code, classified.message);
+    }
+}
+async function apiIterate(input) {
+    try {
+        if (!(await pathExists(input.runDir))) {
+            return fail("RUN_NOT_FOUND", `Run directory not found: ${input.runDir}`);
+        }
+        const result = await (0, orchestrateIteration_1.orchestrateIteration)({ runDir: input.runDir });
+        const output = { status: result.status };
+        if (result.metadata !== undefined) {
+            output.metadata = result.metadata;
+        }
+        if (result.status === "completed") {
+            output.output = result.output;
+        }
+        else if (result.status === "waiting") {
+            output.nextActions = result.nextActions;
+        }
+        else if (result.status === "failed" || result.status === "process-error") {
+            output.error = result.error;
+        }
+        return ok(output);
+    }
+    catch (error) {
+        const classified = classifyError(error);
+        return fail(classified.code, classified.message);
+    }
+}
+async function apiCommitEffect(input) {
+    try {
+        if (input.result.status === "ok" && input.result.value === undefined) {
+            return fail("INVALID_INPUT", "value is required when status is 'ok'");
+        }
+        if (input.result.status === "error" && !input.result.error) {
+            return fail("INVALID_INPUT", "error is required when status is 'error'");
+        }
+        const commitResult = await (0, commitEffectResult_1.commitEffectResult)({
+            runDir: input.runDir,
+            effectId: input.effectId,
+            result: {
+                status: input.result.status,
+                value: input.result.status === "ok" ? input.result.value : undefined,
+                error: input.result.status === "error" ? input.result.error : undefined,
+            },
+        });
+        return ok({ resultRef: commitResult.resultRef });
+    }
+    catch (error) {
+        const classified = classifyError(error);
+        return fail(classified.code, classified.message);
+    }
+}
+async function apiRunStatus(input) {
+    try {
+        const runDir = (0, paths_1.getRunDir)(input.runsDir, input.runId);
+        if (!(await pathExists(runDir))) {
+            return fail("RUN_NOT_FOUND", `Run not found: ${input.runId}`);
+        }
+        const metadata = await (0, runFiles_1.readRunMetadata)(runDir);
+        const events = await (0, journal_1.loadJournal)(runDir);
+        const state = deriveRunState(events);
+        const pendingEffects = derivePendingEffects(events);
+        return ok({
+            state,
+            processId: metadata.processId,
+            runId: metadata.runId,
+            pendingEffects,
+        });
+    }
+    catch (error) {
+        const classified = classifyError(error);
+        return fail(classified.code, classified.message);
+    }
+}
+async function apiRunEvents(input) {
+    try {
+        if (input.limit !== undefined && input.limit < 0) {
+            return fail("INVALID_INPUT", "limit must be a non-negative number");
+        }
+        const runDir = (0, paths_1.getRunDir)(input.runsDir, input.runId);
+        if (!(await pathExists(runDir))) {
+            return fail("RUN_NOT_FOUND", `Run not found: ${input.runId}`);
+        }
+        let events = await (0, journal_1.loadJournal)(runDir);
+        if (input.filterType) {
+            events = events.filter((e) => e.type === input.filterType);
+        }
+        if (input.limit !== undefined) {
+            events = events.slice(0, input.limit);
+        }
+        return ok({
+            events: events.map((e) => ({
+                seq: e.seq,
+                type: e.type,
+                recordedAt: e.recordedAt,
+                data: e.data,
+            })),
+        });
+    }
+    catch (error) {
+        const classified = classifyError(error);
+        return fail(classified.code, classified.message);
+    }
+}
+// ── State derivation helpers ────────────────────────────────────────────────
+function deriveRunState(events) {
+    // Walk events in reverse to find the latest terminal or pending state.
+    for (let i = events.length - 1; i >= 0; i--) {
+        const type = events[i].type;
+        if (type === "RUN_COMPLETED")
+            return "completed";
+        if (type === "RUN_FAILED")
+            return "failed";
+    }
+    // Check if there are any unresolved EFFECT_REQUESTED events.
+    const requested = new Set();
+    const resolved = new Set();
+    for (const event of events) {
+        if (event.type === "EFFECT_REQUESTED") {
+            const effectId = event.data.effectId;
+            if (effectId)
+                requested.add(effectId);
+        }
+        else if (event.type === "EFFECT_RESOLVED" || event.type === "EFFECT_CANCELLED") {
+            const effectId = event.data.effectId;
+            if (effectId)
+                resolved.add(effectId);
+        }
+    }
+    const pending = [...requested].filter((id) => !resolved.has(id));
+    if (pending.length > 0)
+        return "waiting";
+    // Has any iteration happened?
+    const hasCreated = events.some((e) => e.type === "RUN_CREATED");
+    if (hasCreated && resolved.size > 0)
+        return "running";
+    return "created";
+}
+function derivePendingEffects(events) {
+    const requested = new Map();
+    const resolved = new Set();
+    for (const event of events) {
+        if (event.type === "EFFECT_REQUESTED") {
+            const data = event.data;
+            const effectId = data.effectId;
+            if (effectId) {
+                requested.set(effectId, {
+                    effectId,
+                    kind: typeof data.kind === "string" ? data.kind : undefined,
+                });
+            }
+        }
+        else if (event.type === "EFFECT_RESOLVED" || event.type === "EFFECT_CANCELLED") {
+            const effectId = event.data.effectId;
+            if (effectId)
+                resolved.add(effectId);
+        }
+    }
+    return [...requested.entries()]
+        .filter(([id]) => !resolved.has(id))
+        .map(([, info]) => info);
+}

package/dist/breakpoints/evaluator.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Auto-approval evaluator.
+ *
+ * Precedence (highest wins):
+ *   1. never-auto-approve rule match
+ *   2. alwaysBreakOn profile tags
+ *   3. auto-approve rule match
+ *   4. autoApproveAfterN threshold (consecutive approvals from journal history)
+ *   5. prompt (default — no auto-approval)
+ */
+import type { BreakpointRule, AutoApprovalResult } from "./types";
+import type { BreakpointConfig } from "../profiles/types";
+export interface EvaluateAutoApprovalOptions {
+    breakpointId: string;
+    tags?: string[];
+    expert?: string;
+    rules: BreakpointRule[];
+    profileConfig?: BreakpointConfig;
+    /** Number of consecutive past approvals for this breakpointId. */
+    consecutiveApprovals?: number;
+    /** autoApproveAfterN from breakpoint definition (-1 = disabled). */
+    autoApproveAfterN?: number;
+}
+export declare function evaluateAutoApproval(options: EvaluateAutoApprovalOptions): AutoApprovalResult;
+//# sourceMappingURL=evaluator.d.ts.map

package/dist/breakpoints/evaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluator.d.ts","sourceRoot":"","sources":["../../src/breakpoints/evaluator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAClE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAG1D,MAAM,WAAW,2BAA2B;IAC1C,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,aAAa,CAAC,EAAE,gBAAgB,CAAC;IACjC,kEAAkE;IAClE,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,oEAAoE;IACpE,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,2BAA2B,GAAG,kBAAkB,CAqE7F"}

package/dist/breakpoints/evaluator.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * Auto-approval evaluator.
+ *
+ * Precedence (highest wins):
+ *   1. never-auto-approve rule match
+ *   2. alwaysBreakOn profile tags
+ *   3. auto-approve rule match
+ *   4. autoApproveAfterN threshold (consecutive approvals from journal history)
+ *   5. prompt (default — no auto-approval)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateAutoApproval = evaluateAutoApproval;
+const patterns_1 = require("./patterns");
+function evaluateAutoApproval(options) {
+    const { breakpointId, tags, expert, rules, profileConfig, consecutiveApprovals = 0, autoApproveAfterN = -1, } = options;
+    const attributes = { tags, expert };
+    // 1. Check never-auto-approve rules (highest precedence)
+    for (const rule of rules) {
+        if (rule.action !== "never-auto-approve")
+            continue;
+        const pattern = (0, patterns_1.parsePattern)(rule.pattern);
+        if ((0, patterns_1.matchPattern)(pattern, breakpointId, attributes)) {
+            return {
+                recommended: false,
+                reason: `Blocked by never-auto-approve rule: ${rule.id}`,
+                matchedRule: rule.id,
+                consecutiveApprovals,
+            };
+        }
+    }
+    // 2. Check alwaysBreakOn profile tags
+    if (profileConfig?.alwaysBreakOn && tags) {
+        for (const alwaysTag of profileConfig.alwaysBreakOn) {
+            if (tags.includes(alwaysTag)) {
+                return {
+                    recommended: false,
+                    reason: `Blocked by alwaysBreakOn tag: ${alwaysTag}`,
+                    consecutiveApprovals,
+                };
+            }
+        }
+    }
+    // 3. Check auto-approve rules
+    for (const rule of rules) {
+        if (rule.action !== "auto-approve")
+            continue;
+        const pattern = (0, patterns_1.parsePattern)(rule.pattern);
+        if ((0, patterns_1.matchPattern)(pattern, breakpointId, attributes)) {
+            return {
+                recommended: true,
+                reason: `Matched auto-approve rule: ${rule.id}`,
+                matchedRule: rule.id,
+                consecutiveApprovals,
+            };
+        }
+    }
+    // 4. Check autoApproveAfterN threshold
+    if (autoApproveAfterN > 0 && consecutiveApprovals >= autoApproveAfterN) {
+        return {
+            recommended: true,
+            reason: `Auto-approved after ${consecutiveApprovals} consecutive approvals (threshold: ${autoApproveAfterN})`,
+            consecutiveApprovals,
+        };
+    }
+    // 5. Default: prompt (no auto-approval)
+    return {
+        recommended: false,
+        reason: "No matching auto-approval rule",
+        consecutiveApprovals,
+    };
+}

package/dist/breakpoints/index.d.ts

@@ -0,0 +1,7 @@
+export type { BreakpointRule, BreakpointRuleAction, BreakpointRulesFile, AutoApprovalResult, BreakpointPattern, AttributePredicate, PredicateOp, } from "./types";
+export { BREAKPOINT_RULES_SCHEMA_VERSION } from "./types";
+export { parsePattern, matchPattern } from "./patterns";
+export { readRules, writeRules, addRule, removeRule, listRules } from "./rules";
+export { evaluateAutoApproval } from "./evaluator";
+export type { EvaluateAutoApprovalOptions } from "./evaluator";
+//# sourceMappingURL=index.d.ts.map

package/dist/breakpoints/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/breakpoints/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,cAAc,EACd,oBAAoB,EACpB,mBAAmB,EACnB,kBAAkB,EAClB,iBAAiB,EACjB,kBAAkB,EAClB,WAAW,GACZ,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,+BAA+B,EAAE,MAAM,SAAS,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AACxD,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAChF,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACnD,YAAY,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAC"}

package/dist/breakpoints/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateAutoApproval = exports.listRules = exports.removeRule = exports.addRule = exports.writeRules = exports.readRules = exports.matchPattern = exports.parsePattern = exports.BREAKPOINT_RULES_SCHEMA_VERSION = void 0;
+var types_1 = require("./types");
+Object.defineProperty(exports, "BREAKPOINT_RULES_SCHEMA_VERSION", { enumerable: true, get: function () { return types_1.BREAKPOINT_RULES_SCHEMA_VERSION; } });
+var patterns_1 = require("./patterns");
+Object.defineProperty(exports, "parsePattern", { enumerable: true, get: function () { return patterns_1.parsePattern; } });
+Object.defineProperty(exports, "matchPattern", { enumerable: true, get: function () { return patterns_1.matchPattern; } });
+var rules_1 = require("./rules");
+Object.defineProperty(exports, "readRules", { enumerable: true, get: function () { return rules_1.readRules; } });
+Object.defineProperty(exports, "writeRules", { enumerable: true, get: function () { return rules_1.writeRules; } });
+Object.defineProperty(exports, "addRule", { enumerable: true, get: function () { return rules_1.addRule; } });
+Object.defineProperty(exports, "removeRule", { enumerable: true, get: function () { return rules_1.removeRule; } });
+Object.defineProperty(exports, "listRules", { enumerable: true, get: function () { return rules_1.listRules; } });
+var evaluator_1 = require("./evaluator");
+Object.defineProperty(exports, "evaluateAutoApproval", { enumerable: true, get: function () { return evaluator_1.evaluateAutoApproval; } });

package/dist/breakpoints/patterns.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Pattern parsing and matching for breakpoint auto-approval rules.
+ *
+ * Pattern syntax:
+ *   <id-glob>                          — e.g., "confirm.*"
+ *   <id-glob>(<predicate> [AND ...])   — e.g., "*.review(tags contains 'design')"
+ *
+ * Id-glob supports * as a wildcard matching any segment(s).
+ * Attribute predicates: "tags contains '<value>'" or "expert = '<value>'"
+ * Multiple predicates joined with AND.
+ */
+import type { BreakpointPattern } from "./types";
+/**
+ * Parse a pattern string into a structured BreakpointPattern.
+ */
+export declare function parsePattern(raw: string): BreakpointPattern;
+/**
+ * Match a breakpointId and attributes against a parsed pattern.
+ */
+export declare function matchPattern(pattern: BreakpointPattern, breakpointId: string, attributes: {
+    tags?: string[];
+    expert?: string;
+}): boolean;
+//# sourceMappingURL=patterns.d.ts.map

package/dist/breakpoints/patterns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patterns.d.ts","sourceRoot":"","sources":["../../src/breakpoints/patterns.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAsB,iBAAiB,EAAe,MAAM,SAAS,CAAC;AAElF;;GAEG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,CAsB3D;AAwBD;;GAEG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,iBAAiB,EAC1B,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAC/C,OAAO,CAYT"}

package/dist/breakpoints/patterns.js

@@ -0,0 +1,88 @@
+"use strict";
+/**
+ * Pattern parsing and matching for breakpoint auto-approval rules.
+ *
+ * Pattern syntax:
+ *   <id-glob>                          — e.g., "confirm.*"
+ *   <id-glob>(<predicate> [AND ...])   — e.g., "*.review(tags contains 'design')"
+ *
+ * Id-glob supports * as a wildcard matching any segment(s).
+ * Attribute predicates: "tags contains '<value>'" or "expert = '<value>'"
+ * Multiple predicates joined with AND.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePattern = parsePattern;
+exports.matchPattern = matchPattern;
+/**
+ * Parse a pattern string into a structured BreakpointPattern.
+ */
+function parsePattern(raw) {
+    const trimmed = raw.trim();
+    const parenOpen = trimmed.indexOf("(");
+    if (parenOpen === -1) {
+        return { idGlob: trimmed, predicates: [] };
+    }
+    const parenClose = trimmed.lastIndexOf(")");
+    if (parenClose === -1 || parenClose <= parenOpen) {
+        throw new Error(`Invalid pattern: unmatched parenthesis in "${raw}"`);
+    }
+    const idGlob = trimmed.slice(0, parenOpen).trim();
+    const predicateStr = trimmed.slice(parenOpen + 1, parenClose).trim();
+    if (!predicateStr) {
+        return { idGlob, predicates: [] };
+    }
+    const predicates = parsePredicates(predicateStr);
+    return { idGlob, predicates };
+}
+function parsePredicates(str) {
+    // Split on " AND " (case-insensitive)
+    const parts = str.split(/\s+AND\s+/i);
+    return parts.map(parseSinglePredicate);
+}
+function parseSinglePredicate(str) {
+    const trimmed = str.trim();
+    // Match: attr contains 'value' or attr = 'value'
+    const match = trimmed.match(/^(\w+)\s+(contains|=)\s+'([^']*)'$/);
+    if (!match) {
+        throw new Error(`Invalid predicate: "${trimmed}". Expected: attr contains 'value' or attr = 'value'`);
+    }
+    return {
+        attr: match[1],
+        op: match[2],
+        value: match[3],
+    };
+}
+/**
+ * Match a breakpointId and attributes against a parsed pattern.
+ */
+function matchPattern(pattern, breakpointId, attributes) {
+    if (!matchGlob(pattern.idGlob, breakpointId)) {
+        return false;
+    }
+    for (const pred of pattern.predicates) {
+        if (!matchPredicate(pred, attributes)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Simple glob matching with * wildcards.
+ * Each * matches zero or more characters (including dots).
+ */
+function matchGlob(glob, value) {
+    // Escape regex special chars except *, then replace * with .*
+    const escaped = glob.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+    const regexStr = "^" + escaped.replace(/\*/g, ".*") + "$";
+    return new RegExp(regexStr).test(value);
+}
+function matchPredicate(pred, attributes) {
+    if (pred.attr === "tags" && pred.op === "contains") {
+        return Array.isArray(attributes.tags) && attributes.tags.includes(pred.value);
+    }
+    if (pred.attr === "expert" && pred.op === "=") {
+        return attributes.expert === pred.value;
+    }
+    // Unknown attribute — no match
+    return false;
+}

package/dist/breakpoints/rules.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Rules CRUD for breakpoint auto-approval.
+ * Rules stored at ~/.a5c/breakpoint-approvals/rules.json with atomic writes.
+ */
+import type { BreakpointRule } from "./types";
+/**
+ * Read rules from the rules file. Returns empty array if file doesn't exist.
+ */
+export declare function readRules(rulesPath?: string): Promise<BreakpointRule[]>;
+/**
+ * Write rules to the rules file atomically.
+ */
+export declare function writeRules(rules: BreakpointRule[], rulesPath?: string): Promise<void>;
+/**
+ * Add a rule. Deduplicates by rule id.
+ */
+export declare function addRule(rule: BreakpointRule, rulesPath?: string): Promise<BreakpointRule[]>;
+/**
+ * Remove a rule by id. Returns the updated list.
+ */
+export declare function removeRule(ruleId: string, rulesPath?: string): Promise<BreakpointRule[]>;
+/**
+ * List all rules.
+ */
+export declare function listRules(rulesPath?: string): Promise<BreakpointRule[]>;
+//# sourceMappingURL=rules.d.ts.map

package/dist/breakpoints/rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.d.ts","sourceRoot":"","sources":["../../src/breakpoints/rules.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,OAAO,KAAK,EAAE,cAAc,EAAuB,MAAM,SAAS,CAAC;AAOnE;;GAEG;AACH,wBAAsB,SAAS,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAe7E;AAED;;GAEG;AACH,wBAAsB,UAAU,CAAC,KAAK,EAAE,cAAc,EAAE,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAS3F;AAED;;GAEG;AACH,wBAAsB,OAAO,CAAC,IAAI,EAAE,cAAc,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAMjG;AAED;;GAEG;AACH,wBAAsB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAK9F;AAED;;GAEG;AACH,wBAAsB,SAAS,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAE7E"}