@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/core/stored-agent-event.js

@@ -1,129 +0,0 @@
-import { activityEventBodySchema, AGENT_EVENT_TEXT_MAX_CHARS, AGENT_UNKNOWN_PAYLOAD_MAX_CHARS, EXEC_EVENT_BUFFER_HARD_CAP, } from "../agents/harness/index.js";
-import { isSubagentProvider } from "../keiyaku.js";
-const FAIL_CODES = new Set(["SUBAGENT_TIMEOUT", "SUBAGENT_TRANSPORT_ERROR", "SUBAGENT_POLICY_BUDGET", "SUBAGENT_NON_ZERO_EXIT", "SUBAGENT_SPAWN_ERROR", "SUBAGENT_EXEC_ERROR", "SUBAGENT_PROVIDER_UNAVAILABLE", "PROJECTION_STATE_ERROR"]);
-const KNOWN = new Set(["message", "unknown", "activity", "thought", "plan", "turn", "usage", "warning", "diagnostic", "truncation", "done", "fail"]);
-const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
-const finite = (value) => typeof value === "number" && Number.isFinite(value);
-const nonNegativeFinite = (value) => finite(value) && value >= 0;
-const optionalString = (value, key) => value[key] === undefined || typeof value[key] === "string";
-const nonNegativeSafeInteger = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
-const safeIntegerOrNull = (value) => value === null || (typeof value === "number" && Number.isSafeInteger(value));
-function isValidStoredWarning(warning) {
-    if (warning.reason === "rate-limit") {
-        return warning.state === "exhausted" && Object.keys(warning).length === 2;
-    }
-    if (warning.reason === "retry") {
-        return nonNegativeSafeInteger(warning.attempt)
-            && nonNegativeSafeInteger(warning.maxRetries)
-            && nonNegativeFinite(warning.retryDelayMs)
-            && safeIntegerOrNull(warning.errorStatus);
-    }
-    if (warning.reason === "refusal" || warning.reason === "overload") {
-        return optionalString(warning, "originalModel")
-            && optionalString(warning, "fallbackModel")
-            && optionalString(warning, "direction")
-            && (warning.requestId === undefined || warning.requestId === null || typeof warning.requestId === "string")
-            && optionalString(warning, "signerModel");
-    }
-    return false;
-}
-export function classifyStoredAgentEvent(value) {
-    if (!record(value) || typeof value.type !== "string")
-        return "malformed";
-    if (value.type === "action")
-        return "malformed";
-    if (!KNOWN.has(value.type))
-        return "unknown";
-    if (typeof value.at !== "string"
-        || !Number.isFinite(Date.parse(value.at))
-        || !Number.isInteger(value.seq)
-        || !Number.isSafeInteger(value.turn)
-        || value.turn < 0)
-        return "malformed";
-    switch (value.type) {
-        case "message":
-            return typeof value.id === "string"
-                && value.id.length > 0
-                && value.id.length <= AGENT_EVENT_TEXT_MAX_CHARS
-                && typeof value.text === "string"
-                && value.text.length <= AGENT_EVENT_TEXT_MAX_CHARS
-                ? "valid"
-                : "malformed";
-        case "unknown": {
-            if (typeof value.provider !== "string" || value.provider.length > AGENT_EVENT_TEXT_MAX_CHARS ||
-                typeof value.nativeType !== "string" || value.nativeType.length > AGENT_EVENT_TEXT_MAX_CHARS ||
-                typeof value.payload !== "string" || value.payload.length > AGENT_UNKNOWN_PAYLOAD_MAX_CHARS ||
-                (value.truncated !== undefined && value.truncated !== true))
-                return "malformed";
-            if (value.elided === undefined)
-                return "valid";
-            if (!record(value.elided))
-                return "malformed";
-            if (value.elided.reason !== "truncated" && value.elided.reason !== "unserializable")
-                return "malformed";
-            if (!Number.isInteger(value.elided.retainedChars) || value.elided.retainedChars < 0)
-                return "malformed";
-            if (value.elided.retainedChars !== value.payload.length)
-                return "malformed";
-            if (value.elided.originalChars !== undefined && (!Number.isInteger(value.elided.originalChars) || value.elided.originalChars < 0))
-                return "malformed";
-            if (value.elided.reason === "truncated" && (!Number.isInteger(value.elided.originalChars) || value.elided.originalChars <= value.payload.length))
-                return "malformed";
-            return "valid";
-        }
-        case "activity": {
-            const { seq: _seq, at: _at, turn: _turn, ...body } = value;
-            return activityEventBodySchema.safeParse(body).success ? "valid" : "malformed";
-        }
-        case "thought": return typeof value.id === "string" && typeof value.text === "string" && typeof value.final === "boolean" && (value.truncated === undefined || value.truncated === true) ? "valid" : "malformed";
-        case "plan": return typeof value.id === "string" && Array.isArray(value.items) && value.items.every((item) => record(item) && typeof item.text === "string" && typeof item.done === "boolean" && (item.active === undefined || item.active === true)) ? "valid" : "malformed";
-        case "turn": return value.phase === "started" || value.phase === "completed" ? "valid" : "malformed";
-        case "usage": return finite(value.inputTokens) && finite(value.outputTokens) && (value.cachedInputTokens === undefined || finite(value.cachedInputTokens)) && (value.costUsd === undefined || finite(value.costUsd)) && optionalString(value, "model") ? "valid" : "malformed";
-        case "warning": return record(value.warning) && isValidStoredWarning(value.warning) ? "valid" : "malformed";
-        case "diagnostic": return typeof value.text === "string" ? "valid" : "malformed";
-        case "truncation": {
-            return Number.isInteger(value.limit)
-                && Number.isInteger(value.admitted)
-                && value.limit >= 0
-                && value.admitted >= 0
-                && value.limit === EXEC_EVENT_BUFFER_HARD_CAP
-                && value.admitted === EXEC_EVENT_BUFFER_HARD_CAP
-                ? "valid"
-                : "malformed";
-        }
-        case "done": return optionalString(value, "finalMessage") && record(value.session) && typeof value.session.provider === "string" && isSubagentProvider(value.session.provider) && finite(value.session.version) && Number.isInteger(value.session.version) && value.session.version > 0 && "handle" in value.session ? "valid" : "malformed";
-        case "fail": return typeof value.message === "string" && (value.code === undefined || (typeof value.code === "string" && FAIL_CODES.has(value.code))) && (value.exitCode === undefined || value.exitCode === null || finite(value.exitCode)) && optionalString(value, "diagnostics") ? "valid" : "malformed";
-    }
-    return "unknown";
-}
-export function selectValidStoredAgentEvents(values) {
-    const events = [];
-    const activityTools = new Map();
-    let malformed = 0;
-    for (const value of values) {
-        const shape = classifyStoredAgentEvent(value);
-        if (shape === "valid") {
-            const event = value;
-            if (event.type === "activity") {
-                const priorTool = activityTools.get(event.id);
-                if (priorTool !== undefined && priorTool !== event.tool) {
-                    malformed += 1;
-                    continue;
-                }
-                activityTools.set(event.id, event.tool);
-            }
-            events.push(event);
-        }
-        if (shape === "malformed")
-            malformed += 1;
-    }
-    return { events, malformed };
-}
-export function invalidActivityEventDiagnostic(malformed) {
-    return malformed > 0
-        ? {
-            kind: "invalid-activity-event",
-            detail: `${malformed} persisted activity event${malformed === 1 ? "" : "s"} malformed`,
-        }
-        : undefined;
-}

package/build/core/structured-query.js

@@ -1,23 +0,0 @@
-export const STRUCTURED_QUERY_GRAMMAR = "FIELD OP VALUE[,VALUE...] [| FIELD OP VALUE[,VALUE...]]...";
-export const STRUCTURED_QUERY_COMPLETION = "FIELD OP VALUE[,VALUE...]|FIELD OP VALUE[,VALUE...]";
-export const STRUCTURED_QUERY_OPERATORS = ["=", "!=", "~", "<", "<=", ">", ">="];
-export function parseStructuredQuery(input) {
-    const parsed = [];
-    for (const rawTerm of input.expression.split("|")) {
-        if (!rawTerm)
-            input.invalid(`'${input.expression}' must use ${STRUCTURED_QUERY_GRAMMAR}`, parsed);
-        const match = /^([a-z][a-z0-9_-]*)(!=|<=|>=|~|=|<|>)(.*)$/.exec(rawTerm);
-        if (!match)
-            input.invalid(`'${input.expression}' must use ${STRUCTURED_QUERY_GRAMMAR}`, parsed);
-        const field = match[1];
-        const operator = match[2];
-        if (!input.fields.has(field))
-            input.invalid(`unknown field '${field}'`, parsed);
-        const values = match[3].split(",");
-        if (values.some((value) => !value))
-            input.invalid(`field '${field}' has an empty value`, parsed);
-        input.validate(field, operator, values, parsed);
-        parsed.push({ field, operator, values });
-    }
-    return parsed;
-}

package/build/core/target-ref.js

@@ -1,10 +0,0 @@
-import { FlowError } from "../flow-error.js";
-import { fullBranchRefSchema } from "./repository-ledger/codec.js";
-/** Prefix bare branch names and validate the full ref. Sole status/bind normalizer. */
-export function normalizeTargetRef(raw) {
-    const ref = raw.startsWith("refs/heads/") ? raw : `refs/heads/${raw}`;
-    if (!fullBranchRefSchema.safeParse(ref).success) {
-        throw new FlowError("INVALID_TARGET", `invalid target ref '${raw}' — pass a branch name or refs/heads/<name>`);
-    }
-    return ref;
-}

package/build/core/task/board.js

@@ -1,248 +0,0 @@
-import { FlowError } from "../../flow-error.js";
-import { formatTaskCoordinate, parseTaskCoordinate } from "./coordinate.js";
-function compareText(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}
-function diseaseSort(left, right) {
-    return compareText(left.code, right.code)
-        || compareText(left.id ?? "", right.id ?? "")
-        || compareText(left.message, right.message);
-}
-function taskSort(left, right) {
-    const leftTerminal = left.state === "done" || left.state === "drop" ? 1 : 0;
-    const rightTerminal = right.state === "done" || right.state === "drop" ? 1 : 0;
-    return leftTerminal - rightTerminal
-        || left.pri - right.pri
-        || compareText(left.createdAt, right.createdAt)
-        || compareText(left.coordinate ?? left.id, right.coordinate ?? right.id);
-}
-function normalizeDocument(task) {
-    const namespace = task.namespace ?? null;
-    const coordinate = task.coordinate ?? formatTaskCoordinate(namespace, task.id);
-    const parsed = parseTaskCoordinate(coordinate);
-    if (parsed.namespace !== namespace || parsed.localId !== task.id) {
-        throw new FlowError("INVALID_TARGET", `task coordinate ${coordinate} does not match its namespace and local id`);
-    }
-    return { ...task, namespace, coordinate };
-}
-function cycleComponents(tasks) {
-    let nextIndex = 0;
-    const indexes = new Map();
-    const low = new Map();
-    const stack = [];
-    const onStack = new Set();
-    const cycles = [];
-    const visit = (id) => {
-        indexes.set(id, nextIndex);
-        low.set(id, nextIndex);
-        nextIndex += 1;
-        stack.push(id);
-        onStack.add(id);
-        for (const need of tasks.get(id).needs) {
-            if (!tasks.has(need))
-                continue;
-            if (!indexes.has(need)) {
-                visit(need);
-                low.set(id, Math.min(low.get(id), low.get(need)));
-            }
-            else if (onStack.has(need)) {
-                low.set(id, Math.min(low.get(id), indexes.get(need)));
-            }
-        }
-        if (low.get(id) !== indexes.get(id))
-            return;
-        const component = [];
-        while (stack.length > 0) {
-            const member = stack.pop();
-            onStack.delete(member);
-            component.push(member);
-            if (member === id)
-                break;
-        }
-        if (component.length > 1 || tasks.get(id).needs.includes(id)) {
-            cycles.push(new Set(component));
-        }
-    };
-    for (const id of [...tasks.keys()].sort())
-        if (!indexes.has(id))
-            visit(id);
-    return cycles;
-}
-function supersedesCycleComponents(tasks) {
-    return cycleComponents(new Map([...tasks].map(([id, task]) => [id, { ...task, needs: task.supersedes }])));
-}
-function parentCycleComponents(tasks) {
-    const cycles = [];
-    const visited = new Set();
-    for (const start of [...tasks.keys()].sort()) {
-        if (visited.has(start))
-            continue;
-        const path = [];
-        const positions = new Map();
-        let current = start;
-        while (current !== null && tasks.has(current) && !visited.has(current)) {
-            const prior = positions.get(current);
-            if (prior !== undefined) {
-                cycles.push(new Set(path.slice(prior)));
-                break;
-            }
-            positions.set(current, path.length);
-            path.push(current);
-            current = tasks.get(current).parent;
-        }
-        for (const id of path)
-            visited.add(id);
-    }
-    return cycles;
-}
-/** Derive the complete storage-neutral board from domain records. */
-export function buildTaskBoardFromDocuments(documents) {
-    documents = documents.map(normalizeDocument);
-    const diseases = [];
-    const counts = new Map();
-    for (const task of documents)
-        counts.set(task.coordinate, (counts.get(task.coordinate) ?? 0) + 1);
-    const candidates = new Map();
-    for (const task of documents) {
-        const coordinate = task.coordinate;
-        if (counts.get(coordinate) > 1) {
-            diseases.push({
-                code: "duplicate_id",
-                message: `duplicate authoritative task coordinate ${coordinate}`,
-                id: coordinate,
-            });
-        }
-        else {
-            candidates.set(coordinate, task);
-        }
-    }
-    for (const component of cycleComponents(candidates)) {
-        const relatedIds = [...component].sort();
-        for (const id of relatedIds) {
-            diseases.push({
-                code: "needs_cycle",
-                message: `task ${id} participates in a needs cycle`,
-                id,
-                relatedIds,
-            });
-            candidates.delete(id);
-        }
-    }
-    for (const component of supersedesCycleComponents(candidates)) {
-        const relatedIds = [...component].sort();
-        for (const id of relatedIds) {
-            diseases.push({
-                code: "supersedes_cycle",
-                message: `task ${id} participates in a supersedes cycle`,
-                id,
-                relatedIds,
-            });
-            candidates.delete(id);
-        }
-    }
-    for (const component of parentCycleComponents(candidates)) {
-        const relatedIds = [...component].sort();
-        for (const id of relatedIds) {
-            diseases.push({
-                code: "parent_cycle",
-                message: `task ${id} participates in a parent cycle`,
-                id,
-                relatedIds,
-            });
-        }
-    }
-    let changed = true;
-    while (changed) {
-        changed = false;
-        for (const [id, task] of [...candidates].sort(([a], [b]) => compareText(a, b))) {
-            const missing = [...task.needs, ...(task.parent ? [task.parent] : []), ...task.from, ...task.supersedes, ...task.relatesTo]
-                .filter((related) => !candidates.has(related));
-            if (missing.length === 0)
-                continue;
-            const relatedIds = [...new Set(missing)].sort();
-            diseases.push({
-                code: "missing_reference",
-                message: `task ${id} references missing task(s): ${relatedIds.join(", ")}`,
-                id,
-                relatedIds,
-            });
-            candidates.delete(id);
-            changed = true;
-        }
-    }
-    const blocks = new Map();
-    const supersededBy = new Map();
-    const relatedTasks = new Map();
-    for (const task of candidates.values()) {
-        for (const need of task.needs)
-            blocks.set(need, [...(blocks.get(need) ?? []), task.coordinate]);
-        for (const superseded of task.supersedes)
-            supersededBy.set(superseded, [...(supersededBy.get(superseded) ?? []), task.coordinate]);
-        for (const related of task.relatesTo)
-            relatedTasks.set(related, [...(relatedTasks.get(related) ?? []), task.coordinate]);
-    }
-    const tasks = [...candidates.values()].sort(taskSort).map((task) => {
-        const blockingNeeds = task.needs.filter((id) => {
-            const state = candidates.get(id).state;
-            return state === "open" || state === "in_progress" || state === "on_hold";
-        });
-        return {
-            id: task.id,
-            namespace: task.namespace ?? null,
-            coordinate: task.coordinate,
-            title: task.title,
-            state: task.state,
-            pri: task.pri,
-            needs: [...task.needs],
-            parent: task.parent,
-            from: [...task.from],
-            supersedes: [...task.supersedes],
-            relatesTo: [...task.relatesTo],
-            notes: task.notes.map((note) => ({ ...note })),
-            createdAt: task.createdAt,
-            ...(task.updatedAt === undefined ? {} : { updatedAt: task.updatedAt }),
-            creator: task.creator,
-            ...(task.startedAt === undefined ? {} : { startedAt: task.startedAt }),
-            ...(task.contractId === undefined ? {} : { contractId: task.contractId }),
-            body: task.body,
-            blocks: [...(blocks.get(task.coordinate) ?? [])].sort(),
-            blocked: task.state === "open" && blockingNeeds.length > 0,
-            releasedNeeds: task.needs.filter((id) => candidates.get(id).state === "drop").sort(),
-            supersededBy: [...(supersededBy.get(task.coordinate) ?? [])].sort(),
-            relatedTasks: [...new Set([...task.relatesTo, ...(relatedTasks.get(task.coordinate) ?? [])])].sort(),
-        };
-    });
-    return {
-        tasks,
-        diseases: diseases.sort(diseaseSort),
-        byId: new Map(tasks.map((task) => [task.coordinate, task])),
-    };
-}
-export function resolveTaskReadId(board, input) {
-    return resolveTaskId(board, input);
-}
-export function resolveTaskId(board, input) {
-    const requested = parseTaskCoordinate(input);
-    if (board.byId.has(requested.coordinate))
-        return requested.coordinate;
-    const matches = board.tasks
-        .filter((task) => task.namespace === requested.namespace && task.id.startsWith(requested.localId))
-        .map((task) => task.coordinate)
-        .sort();
-    if (matches.length === 0)
-        throw new FlowError("INVALID_TARGET", `task '${input}' not found`);
-    if (matches.length > 1) {
-        throw Object.assign(new FlowError("TASK_AMBIGUOUS", `task prefix '${input}' is ambiguous: ${matches.join(", ")}`, {
-            facts: { kind: "task_ambiguous", candidates: matches },
-        }), { candidates: matches });
-    }
-    return matches[0];
-}
-export function requireCanonicalTaskId(input) {
-    return parseTaskCoordinate(input, "task mutation coordinate").coordinate;
-}
-export function requireHealthy(board) {
-    if (board.diseases.length > 0) {
-        throw new FlowError("INTERNAL_STATE", `authoritative task board is diseased: ${board.diseases.map((item) => item.message).join("; ")}`);
-    }
-}