@astrosheep/keiyaku 1.0.0 → 1.0.2

package/build/core/projection-activity.js

@@ -0,0 +1,219 @@
+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) {
+    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) {
+    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 warnings = new Map();
+    const usageByTurn = new Map();
+    const turns = [];
+    let latestPlan;
+    let diagnostic;
+    let failure;
+    for (const indexed of sorted) {
+        const event = indexed.event;
+        switch (event.type) {
+            case "activity": {
+                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": {
+                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 = warningIdentity(event.warning);
+                const prior = warnings.get(identity);
+                warnings.set(identity, { latest: indexed, count: (prior?.count ?? 0) + 1 });
+                break;
+            }
+            case "usage":
+                usageByTurn.set(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") {
+            settled.push({ kind: "said", order: indexed.order, at: event.at, turn: event.turn, 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(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.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 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);
+    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,
+        pinned,
+        timeline,
+        ledgerActivities,
+        ledgerTurns: turns,
+        ...(plan ? { plan } : {}),
+        ...(diagnostic ? { diagnostic } : {}),
+        ...(failure ? { failure } : {}),
+    };
+}

package/build/core/projection-coordinate.js

@@ -0,0 +1,35 @@
+import { spawnSync } from "node:child_process";
+import * as path from "node:path";
+import { ProjectionStateError } from "./atomic-publish.js";
+/**
+ * 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 function projectionCoordinateRoot(cwd) {
+    const result = spawnSync("git", ["rev-parse", "--is-bare-repository", "--path-format=absolute", "--git-common-dir"], {
+        cwd,
+        encoding: "utf8",
+        env: {
+            ...process.env,
+            GIT_TERMINAL_PROMPT: "0",
+            LC_ALL: "C",
+        },
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    if (result.error) {
+        throw new ProjectionStateError(`cannot resolve projection repository coordinate: ${result.error.message}`);
+    }
+    if (result.status !== 0) {
+        const detail = result.stderr.trim();
+        if (detail.includes("not a git repository"))
+            return cwd;
+        throw new ProjectionStateError(`cannot resolve projection repository coordinate${detail ? `: ${detail}` : ` (git exited ${String(result.status)})`}`);
+    }
+    const [bare, commonDir] = result.stdout.trim().split(/\r?\n/);
+    if (bare !== "false" || !commonDir || !path.isAbsolute(commonDir))
+        return cwd;
+    return path.dirname(commonDir);
+}