@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/core/projection/projection-activity.js

@@ -1,273 +0,0 @@
-export const AGENT_ACTIVITY_WINDOW_SIZE = 10;
-function eventTime(value) {
-    const parsed = Date.parse(value);
-    return Number.isFinite(parsed) ? parsed : undefined;
-}
-function duration(first, last) {
-    if (first === undefined || last === undefined)
-        return undefined;
-    return Math.max(0, last - first);
-}
-function warningIdentity(warning) {
-    if (warning.reason === "rate-limit") {
-        return JSON.stringify(warning);
-    }
-    if (warning.reason === "retry") {
-        return JSON.stringify({
-            reason: warning.reason,
-            attempt: warning.attempt,
-            maxRetries: warning.maxRetries,
-            retryDelayMs: warning.retryDelayMs,
-            errorStatus: warning.errorStatus,
-        });
-    }
-    return JSON.stringify({
-        reason: warning.reason,
-        originalModel: warning.originalModel,
-        fallbackModel: warning.fallbackModel,
-        direction: warning.direction,
-        signerModel: warning.signerModel,
-    });
-}
-function sortEvents(events) {
-    return events
-        .map((event, index) => ({
-        event,
-        order: Number.isFinite(event.seq) ? event.seq : index,
-        sourceIndex: index,
-    }))
-        .sort((left, right) => left.order - right.order || left.sourceIndex - right.sourceIndex)
-        .map(({ event, order }) => ({ event, order }));
-}
-/** Fold the provider-neutral event ledger once into the bounded UI activity model. */
-export function foldAgentActivity(events, retentionOverride) {
-    const sorted = sortEvents(events);
-    const latestActivity = new Map();
-    const firstActivityCall = new Map();
-    const activityObservations = new Map();
-    const firstActivityAt = new Map();
-    const latestThought = new Map();
-    const firstThoughtAt = new Map();
-    const thoughtEventCount = new Map();
-    const latestMessage = new Map();
-    const warnings = new Map();
-    const usageByTurn = new Map();
-    const turns = [];
-    let latestPlan;
-    let diagnostic;
-    let failure;
-    let compacted = false;
-    for (const indexed of sorted) {
-        const event = indexed.event;
-        switch (event.type) {
-            case "message":
-                {
-                    const key = JSON.stringify([event.turn, event.id]);
-                    compacted ||= latestMessage.has(key);
-                    latestMessage.set(key, indexed);
-                }
-                break;
-            case "activity": {
-                compacted ||= latestActivity.has(event.id);
-                latestActivity.set(event.id, indexed);
-                if (event.phase !== "updated" && !firstActivityCall.has(event.id))
-                    firstActivityCall.set(event.id, event.call);
-                const observations = activityObservations.get(event.id) ?? [];
-                observations.push({
-                    order: indexed.order,
-                    at: event.at,
-                    phase: event.phase,
-                    ...(event.result === undefined ? {} : { result: event.result }),
-                });
-                activityObservations.set(event.id, observations);
-                const at = eventTime(event.at);
-                if (at !== undefined && !firstActivityAt.has(event.id))
-                    firstActivityAt.set(event.id, at);
-                break;
-            }
-            case "thought": {
-                compacted ||= latestThought.has(event.id);
-                latestThought.set(event.id, indexed);
-                thoughtEventCount.set(event.id, (thoughtEventCount.get(event.id) ?? 0) + 1);
-                const at = eventTime(event.at);
-                if (at !== undefined && !firstThoughtAt.has(event.id))
-                    firstThoughtAt.set(event.id, at);
-                break;
-            }
-            case "warning": {
-                const identity = `${event.historyExecutionId ?? ""}:${warningIdentity(event.warning)}`;
-                const prior = warnings.get(identity);
-                compacted ||= prior !== undefined;
-                warnings.set(identity, { latest: indexed, count: (prior?.count ?? 0) + 1 });
-                break;
-            }
-            case "usage":
-                usageByTurn.set(event.historyTurnKey ?? String(event.turn), event);
-                break;
-            case "plan":
-                latestPlan = indexed;
-                break;
-            case "diagnostic":
-                diagnostic = { at: event.at, text: event.text };
-                break;
-            case "fail":
-                failure = { at: event.at, message: event.message };
-                break;
-        }
-    }
-    const settled = [];
-    const pinned = [];
-    const ledgerActivities = [];
-    for (const indexed of sorted) {
-        const event = indexed.event;
-        if (event.type === "message" && latestMessage.get(JSON.stringify([event.turn, event.id])) === indexed) {
-            settled.push({
-                kind: "said",
-                order: indexed.order,
-                at: event.at,
-                turn: event.turn,
-                id: event.id,
-                text: event.text,
-                settled: true,
-            });
-            continue;
-        }
-        if (event.type === "activity" && latestActivity.get(event.id) === indexed) {
-            const startedAtMs = firstActivityAt.get(event.id);
-            const observations = activityObservations.get(event.id) ?? [];
-            const call = firstActivityCall.get(event.id) ?? event.call;
-            const elapsed = observations.some((observation) => observation.phase === "started")
-                && observations.some((observation) => observation.phase === "completed")
-                ? duration(startedAtMs, eventTime(event.at))
-                : undefined;
-            const row = {
-                kind: "ran",
-                order: indexed.order,
-                at: event.at,
-                turn: event.turn,
-                id: event.id,
-                tool: event.tool,
-                call,
-                ...(event.result === undefined ? {} : { result: event.result }),
-                truncated: event.truncated === true,
-                observations,
-                state: event.phase === "completed" ? "completed" : "running",
-                ...(startedAtMs !== undefined ? { startedAtMs } : {}),
-                ...(elapsed !== undefined ? { durationMs: elapsed } : {}),
-                settled: event.phase === "completed",
-            };
-            ledgerActivities.push(row);
-            (row.settled ? settled : pinned).push(row);
-            continue;
-        }
-        if (event.type === "thought" && latestThought.get(event.id) === indexed) {
-            const startedAtMs = firstThoughtAt.get(event.id);
-            const elapsed = thoughtEventCount.get(event.id) >= 2
-                ? duration(startedAtMs, eventTime(event.at))
-                : undefined;
-            const row = {
-                kind: "thought",
-                order: indexed.order,
-                at: event.at,
-                turn: event.turn,
-                id: event.id,
-                text: event.text,
-                final: event.final,
-                truncated: event.truncated === true,
-                ...(startedAtMs !== undefined ? { startedAtMs } : {}),
-                ...(elapsed !== undefined ? { durationMs: elapsed } : {}),
-                settled: event.final,
-            };
-            (row.settled ? settled : pinned).push(row);
-            continue;
-        }
-        if (event.type === "warning") {
-            const aggregate = warnings.get(`${event.historyExecutionId ?? ""}:${warningIdentity(event.warning)}`);
-            if (aggregate?.latest !== indexed)
-                continue;
-            settled.push({
-                kind: "warning",
-                order: indexed.order,
-                at: event.at,
-                turn: event.turn,
-                warning: event.warning,
-                count: aggregate.count,
-                settled: true,
-            });
-            continue;
-        }
-        if (event.type === "turn" && event.phase === "completed") {
-            const usage = usageByTurn.get(event.historyTurnKey ?? String(event.turn));
-            turns.push({
-                kind: "turn",
-                order: indexed.order,
-                at: event.at,
-                turn: event.turn,
-                ...(usage
-                    ? {
-                        inputTokens: usage.inputTokens,
-                        outputTokens: usage.outputTokens,
-                        ...(usage.cachedInputTokens !== undefined ? { cachedInputTokens: usage.cachedInputTokens } : {}),
-                        ...(usage.costUsd !== undefined ? { costUsd: usage.costUsd } : {}),
-                        ...(usage.model !== undefined ? { model: usage.model } : {}),
-                    }
-                    : {}),
-                settled: true,
-            });
-        }
-    }
-    settled.sort((left, right) => left.order - right.order);
-    pinned.sort((left, right) => left.order - right.order);
-    const window = settled.slice(-AGENT_ACTIVITY_WINDOW_SIZE);
-    const omittedSettledCount = Math.max(0, settled.length - window.length);
-    const visibleOrders = [...window, ...pinned].map((row) => row.order);
-    const relevantTurns = visibleOrders.length === 0
-        ? turns.slice(-1)
-        : turns.filter((row) => row.order >= Math.min(...visibleOrders));
-    const timeline = [...window, ...relevantTurns, ...pinned].sort((left, right) => left.order - right.order);
-    const retainedTimeline = [...settled, ...turns, ...pinned].sort((left, right) => left.order - right.order);
-    const truncated = retainedTimeline.some((row) => (row.kind === "ran" || row.kind === "thought") && row.truncated);
-    const bounded = sorted.some(({ event }) => event.type === "truncation");
-    let plan;
-    if (latestPlan?.event.type === "plan") {
-        const event = latestPlan.event;
-        const active = event.items.find((item) => item.active === true) ?? event.items.find((item) => !item.done);
-        plan = {
-            order: latestPlan.order,
-            at: event.at,
-            turn: event.turn,
-            id: event.id,
-            done: event.items.filter((item) => item.done).length,
-            total: event.items.length,
-            ...(active ? { activeItem: active.text } : {}),
-        };
-    }
-    return {
-        window,
-        omittedSettledCount,
-        pinned,
-        timeline,
-        retainedTimeline,
-        retention: {
-            state: retentionOverride ?? (bounded ? "bounded" : truncated ? "truncated" : compacted ? "compacted" : "complete"),
-            retainedCount: retainedTimeline.length,
-            range: retainedTimeline.length > 0
-                ? { first: retainedTimeline[0].order, last: retainedTimeline.at(-1).order }
-                : null,
-        },
-        ledgerActivities,
-        ledgerTurns: turns,
-        ...(plan ? { plan } : {}),
-        ...(diagnostic ? { diagnostic } : {}),
-        ...(failure ? { failure } : {}),
-    };
-}
-/**
- * Public wait/status activity deliberately excludes provider-origin terminal
- * prose. Diagnostic and fail-event text remains available to artifact/internal
- * consumers through the full fold, but has no JSON or human projection path.
- */
-export function foldPublicProjectionActivity(events, retentionOverride) {
-    const { diagnostic: _diagnostic, failure: _failure, ...activity } = foldAgentActivity(events, retentionOverride);
-    return activity;
-}

package/build/core/projection/projection-alias.js

@@ -1,131 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { isErrnoException } from "../../errno.js";
-import { syncDirectorySync } from "../../fs/durability.js";
-import { ProjectionStateError, randomHex8 } from "../atomic-publish.js";
-import { resolveProjectionCoordinate } from "./projection-coordinate.js";
-import { isProjectionId } from "./projection-core.js";
-export const PROJECTION_ALIAS_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/;
-const MAX_ALIAS_REF_BYTES = 1024;
-export function isProjectionAlias(value) {
-    return PROJECTION_ALIAS_PATTERN.test(value);
-}
-export function assertProjectionAlias(value) {
-    if (!isProjectionAlias(value)) {
-        throw new ProjectionStateError("projection alias must match ^[a-z0-9][a-z0-9-]{0,63}$");
-    }
-    return value;
-}
-export function projectionAliasRootAtCoordinate(coordinate) {
-    return path.join(coordinate.physicalRoot, ".keiyaku", "projection-alias");
-}
-export async function projectionAliasRoot(cwd) {
-    return projectionAliasRootAtCoordinate(await resolveProjectionCoordinate(cwd));
-}
-function projectionAliasPathAtRoot(root, alias) {
-    assertProjectionAlias(alias);
-    return path.join(root, alias);
-}
-export async function projectionAliasPath(cwd, alias) {
-    return projectionAliasPathAtRoot(await projectionAliasRoot(cwd), alias);
-}
-function invalidAliasRef(filePath) {
-    return new ProjectionStateError(`invalid projection alias ref: ${filePath}`);
-}
-function readBoundedRegularAliasRef(filePath) {
-    let before;
-    try {
-        before = fs.lstatSync(filePath);
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT")
-            return undefined;
-        throw error;
-    }
-    if (!before.isFile() || before.size > MAX_ALIAS_REF_BYTES)
-        throw invalidAliasRef(filePath);
-    let fd;
-    try {
-        fd = fs.openSync(filePath, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ELOOP")
-            throw invalidAliasRef(filePath);
-        throw error;
-    }
-    try {
-        const opened = fs.fstatSync(fd);
-        if (!opened.isFile() || opened.size > MAX_ALIAS_REF_BYTES)
-            throw invalidAliasRef(filePath);
-        const bytes = Buffer.alloc(opened.size);
-        const count = fs.readSync(fd, bytes, 0, bytes.length, 0);
-        if (count !== bytes.length)
-            throw invalidAliasRef(filePath);
-        return bytes.toString("utf8");
-    }
-    finally {
-        fs.closeSync(fd);
-    }
-}
-/** Undefined means no ref; malformed refs fail closed with their exact sidecar path. */
-export async function readProjectionAliasAtRoot(root, alias) {
-    const filePath = projectionAliasPathAtRoot(root, alias);
-    const content = readBoundedRegularAliasRef(filePath);
-    if (content === undefined)
-        return undefined;
-    if (!content.endsWith("\n") || content.indexOf("\n") !== content.length - 1)
-        throw invalidAliasRef(filePath);
-    const id = content.slice(0, -1);
-    if (!isProjectionId(id))
-        throw invalidAliasRef(filePath);
-    return id;
-}
-/** Cwd-facing compatibility entry point; multi-alias callers should reuse a resolved root. */
-export async function readProjectionAlias(cwd, alias) {
-    return readProjectionAliasAtRoot(await projectionAliasRoot(cwd), alias);
-}
-/** Atomically replace one alias ref. Aliases intentionally have no multi-ref transaction. */
-async function moveProjectionAliasAtRoot(root, alias, id) {
-    assertProjectionAlias(alias);
-    if (!isProjectionId(id))
-        throw new ProjectionStateError(`invalid projection id: ${id}`);
-    const previous = await readProjectionAliasAtRoot(root, alias);
-    fs.mkdirSync(root, { recursive: true });
-    const target = projectionAliasPathAtRoot(root, alias);
-    let temp;
-    try {
-        for (let attempt = 0; attempt < 16; attempt += 1) {
-            const candidate = path.join(root, `.tmp.${randomHex8()}`);
-            try {
-                const fd = fs.openSync(candidate, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL, 0o600);
-                temp = candidate;
-                try {
-                    fs.writeFileSync(fd, `${id}\n`, "utf8");
-                    fs.fsyncSync(fd);
-                }
-                finally {
-                    fs.closeSync(fd);
-                }
-                break;
-            }
-            catch (error) {
-                if (isErrnoException(error) && error.code === "EEXIST")
-                    continue;
-                throw error;
-            }
-        }
-        if (!temp)
-            throw new ProjectionStateError(`failed to create projection alias temp: ${target}`);
-        fs.renameSync(temp, target);
-        syncDirectorySync(root);
-    }
-    finally {
-        if (temp)
-            fs.rmSync(temp, { force: true });
-    }
-    return previous;
-}
-/** Cwd-facing compatibility entry point; writers with a resolved root avoid rediscovery. */
-export async function moveProjectionAlias(cwd, alias, id) {
-    return moveProjectionAliasAtRoot(await projectionAliasRoot(cwd), alias, id);
-}

package/build/core/projection/projection-coordinate.js

@@ -1,61 +0,0 @@
-import * as path from "node:path";
-import { ProjectionStateError } from "../atomic-publish.js";
-import { createGit, isGitExecutableUnavailable, NOT_GIT_REPOSITORY_PATTERNS, } from "../../git/core.js";
-import { normalizeFilesystemCoordinate } from "../../fs/path-coordinate.js";
-import { gitCommonRootPath, resolveGitCommonRoot } from "../../git/path-coordinate.js";
-/**
- * Resolve projection storage root and authority from one Git probe.
- *
- * A non-bare repository uses the parent of its absolute common Git directory,
- * so every linked worktree shares one coordinate. Repo-free callers retain the
- * existing cwd-local authority until its replacement is legislated.
- */
-export async function resolveProjectionCoordinate(cwd) {
-    cwd = normalizeFilesystemCoordinate(cwd);
-    const git = createGit(cwd);
-    let response;
-    try {
-        response = await git.raw([
-            "rev-parse",
-            "--is-bare-repository",
-            "--path-format=absolute",
-            "--git-common-dir",
-        ]);
-    }
-    catch (error) {
-        if (isGitExecutableUnavailable(error)) {
-            return { physicalRoot: cwd, authority: { kind: "user" } };
-        }
-        const message = error instanceof Error ? error.message : String(error);
-        if (NOT_GIT_REPOSITORY_PATTERNS.some((pattern) => message.includes(pattern))) {
-            return { physicalRoot: cwd, authority: { kind: "user" } };
-        }
-        throw new ProjectionStateError(`cannot resolve projection repository coordinate: ${message}`);
-    }
-    const [bare, commonDir] = response.trim().split(/\r?\n/);
-    const stableRoot = commonDir === undefined ? undefined : gitCommonRootPath(commonDir);
-    if (bare !== "false" || !commonDir || !stableRoot || !path.isAbsolute(stableRoot)) {
-        return { physicalRoot: cwd, authority: { kind: "user" } };
-    }
-    let physicalRoot;
-    try {
-        physicalRoot = await resolveGitCommonRoot(commonDir);
-    }
-    catch (error) {
-        throw new ProjectionStateError(`cannot resolve projection repository root ${stableRoot}`, { cause: error });
-    }
-    return {
-        physicalRoot,
-        authority: { kind: "repository", stableRoot: physicalRoot },
-    };
-}
-/**
- * Select the filesystem authority for repository projection state.
- *
- * A non-bare repository uses the parent of its absolute common Git directory,
- * so every linked worktree shares one coordinate. Repo-free callers retain the
- * existing cwd-local authority until its replacement is legislated.
- */
-export async function projectionCoordinateRoot(cwd) {
-    return (await resolveProjectionCoordinate(cwd)).physicalRoot;
-}

package/build/core/projection/projection-core.js

@@ -1,127 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { isErrnoException } from "../../errno.js";
-import { resolveProjectionCoordinate } from "./projection-coordinate.js";
-import { ProjectionStateError, } from "../atomic-publish.js";
-import { isAkumaName } from "./akuma-name.js";
-export { atomicPublishFile, ProjectionStateError, randomHex8 } from "../atomic-publish.js";
-export { isTellCausallyConsumed, } from "./tell/model.js";
-export { bindTellLaunchReservation, claimAllInbox, claimAndReserveFencedTells, claimFencedTells, listTellLaunchBatch, listTellLaunchAdmissions, isTellLaunchAdmissionMember, claimTellToInflight, listTellIds, markTellSubmitted, recordTellReceiptCapabilities, recordTellReceipt, readTellReceiptCapabilities, readTellOriginal, readTellSubmitted, snapshotPendingTells, writeInboxTell, } from "./tell/store.js";
-/** Relative segments for `.keiyaku/projection`. */
-export const PROJECTION_ROOT_SEGMENTS = [".keiyaku", "projection"];
-const PROJECTION_HEX_PATTERN = /^[0-9a-f]{8}$/;
-export function isProjectionId(value) {
-    const slash = value.indexOf("/");
-    if (slash <= 0 || slash !== value.lastIndexOf("/"))
-        return false;
-    return isAkumaName(value.slice(0, slash)) && PROJECTION_HEX_PATTERN.test(value.slice(slash + 1));
-}
-/** Derive one projection storage root from already-resolved repository authority. */
-export function projectionRootAtCoordinate(coordinate) {
-    return path.join(coordinate.physicalRoot, ...PROJECTION_ROOT_SEGMENTS);
-}
-export async function projectionRoot(cwd) {
-    return projectionRootAtCoordinate(await resolveProjectionCoordinate(cwd));
-}
-/** Derive one projection directory from already-resolved repository authority. */
-export function projectionDirAtCoordinate(coordinate, id) {
-    if (!isProjectionId(id))
-        throw new ProjectionStateError(`invalid projection id: ${id}`);
-    const [akuma, hex] = id.split("/");
-    return path.join(projectionRootAtCoordinate(coordinate), akuma, hex);
-}
-export async function projectionDir(cwd, id) {
-    if (!isProjectionId(id))
-        throw new ProjectionStateError(`invalid projection id: ${id}`);
-    return projectionDirAtCoordinate(await resolveProjectionCoordinate(cwd), id);
-}
-export function encodeProjectionJson(value) {
-    return `${JSON.stringify(value)}\n`;
-}
-export function isoFromNowMs(nowMs) {
-    if (!Number.isSafeInteger(nowMs) || nowMs < 0) {
-        throw new ProjectionStateError("nowMs must be a safe non-negative integer");
-    }
-    return new Date(nowMs).toISOString();
-}
-/** A published projection is any visible non-dot real directory under the projection root. */
-export function isPublishedProjection(dir) {
-    try {
-        return !path.basename(dir).startsWith(".") && fs.lstatSync(dir).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-const PROJECTION_EXECUTION_ID_PATTERN = /^[0-9A-HJKMNP-TV-Z]{26}$/;
-function assertProjectionExecutionId(executionId) {
-    if (!PROJECTION_EXECUTION_ID_PATTERN.test(executionId)) {
-        throw new ProjectionStateError(`invalid projection execution id: ${executionId}`);
-    }
-}
-export function executionEventsPath(projectionDirectory, executionId) {
-    assertProjectionExecutionId(executionId);
-    return path.join(projectionDirectory, `${executionId}.events.jsonl`);
-}
-export function appendGenerationEvent(projectionDirectory, executionId, event) {
-    const filePath = executionEventsPath(projectionDirectory, executionId);
-    fs.appendFileSync(filePath, encodeProjectionJson(event), "utf8");
-}
-/**
- * Read one generation's event ledger. A writer may be interrupted while
- * appending its final line, so only an unterminated final residue is ignored.
- * Earlier complete lines remain strict ledger records.
- */
-export function readGenerationEvents(projectionDirectory, executionId) {
-    return readGenerationEventsWithRetention(projectionDirectory, executionId).events;
-}
-/** Distinguishes a deliberately empty ledger from an absent generation ledger. */
-export function readGenerationEventsWithRetention(projectionDirectory, executionId) {
-    let content;
-    try {
-        content = fs.readFileSync(executionEventsPath(projectionDirectory, executionId), "utf8");
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT")
-            return { events: [], retention: "unavailable" };
-        throw error;
-    }
-    const lines = content.split("\n");
-    const terminated = content.endsWith("\n");
-    const completeLines = lines.slice(0, -1);
-    const events = [];
-    for (const line of completeLines) {
-        events.push(JSON.parse(line));
-    }
-    if (!terminated && lines.at(-1)) {
-        try {
-            events.push(JSON.parse(lines.at(-1)));
-        }
-        catch {
-            // A concurrent append can leave only this final record incomplete.
-        }
-    }
-    return { events, retention: "available" };
-}
-export function readProjectionEvents(projectionDirectory) {
-    let entries;
-    try {
-        entries = fs.readdirSync(projectionDirectory, { withFileTypes: true });
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT")
-            return [];
-        throw error;
-    }
-    const names = entries
-        .filter((entry) => (entry.isFile()
-        && /^[0-9A-HJKMNP-TV-Z]{26}\.events\.jsonl$/.test(entry.name)))
-        .map((entry) => entry.name)
-        .sort();
-    const events = [];
-    for (const name of names) {
-        const executionId = name.slice(0, -".events.jsonl".length);
-        events.push(...readGenerationEvents(projectionDirectory, executionId));
-    }
-    return events;
-}