@astrosheep/square 0.3.11 → 0.3.13

package/codex-plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "square",
-  "version": "0.3.11",
+  "version": "0.3.13",
   "description": "Shared Square activity with reliable participant attention at Codex boundaries.",
   "author": {
     "name": "Square"

package/codex-plugin/hooks/hooks.json

@@ -1,5 +1,14 @@
 {
   "hooks": {
+    "SessionStart": [
+      { "hooks": [{ "type": "command", "command": "square codex-hook", "timeout": 5 }] }
+    ],
+    "SessionResume": [
+      { "hooks": [{ "type": "command", "command": "square codex-hook", "timeout": 5 }] }
+    ],
+    "SessionEnd": [
+      { "hooks": [{ "type": "command", "command": "square codex-hook", "timeout": 5 }] }
+    ],
     "PostToolUse": [
       {
         "hooks": [

package/dist/activity-feed.d.ts

@@ -0,0 +1,14 @@
+import { type StoredAct, type SquareState, type PublicAct, type RoomChangeAct } from './model.js';
+export interface ActivityFeedFilter {
+    participants?: string[];
+    mention?: string;
+}
+export declare function actDelta(acts: StoredAct[], cursor: number): StoredAct[];
+/** Public cursor changes plus directed receipts that remain pending behind it. */
+export declare function deliveryDelta(squareState: SquareState, name: string): StoredAct[];
+export declare function peerRoomChanges(delta: StoredAct[], name: string): RoomChangeAct[];
+export declare function peerPublicActs(delta: StoredAct[], name: string): PublicAct[];
+export declare function matchesFeedFilter(act: StoredAct, filter: ActivityFeedFilter): boolean;
+export declare function filteredPeerActivities(delta: StoredAct[], name: string, filter: ActivityFeedFilter): PublicAct[];
+export declare function filteredRoomChanges(delta: StoredAct[], name: string, filter: ActivityFeedFilter): RoomChangeAct[];
+export declare function ackPeerDelta(squareState: SquareState, name: string, delta: StoredAct[], at?: number): boolean;

package/dist/activity-feed.js

@@ -5,10 +5,10 @@ export function actDelta(acts, cursor) {
     return acts.filter((act) => act.index > cursor);
 }
 /** Public cursor changes plus directed receipts that remain pending behind it. */
-export function deliveryDelta(doc, name) {
-    const items = actDelta(doc.acts, readCursor(doc, name));
+export function deliveryDelta(squareState, name) {
+    const items = actDelta(squareState.acts, readCursor(squareState, name));
     const seen = new Set(items.map((act) => act.index));
-    for (const notification of deriveDeliveryModel(doc).pendingFor(name)) {
+    for (const notification of deriveDeliveryModel(squareState).pendingFor(name)) {
         if (!seen.has(notification.item.index))
             items.push(notification.item);
     }
@@ -39,6 +39,6 @@ export function filteredRoomChanges(delta, name, filter) {
         return [];
     return peerRoomChanges(delta, name).filter((act) => matchesParticipants(act, filter.participants));
 }
-export function ackPeerDelta(doc, name, delta) {
-    return advanceCursor(doc, name, latestActIndex([...peerPublicActs(delta, name), ...peerRoomChanges(delta, name)]));
+export function ackPeerDelta(squareState, name, delta, at) {
+    return advanceCursor(squareState, name, latestActIndex([...peerPublicActs(delta, name), ...peerRoomChanges(delta, name)]), at);
 }

package/dist/activity.d.ts

@@ -0,0 +1,9 @@
+export interface ActivityOptions {
+    force?: boolean;
+    forceCommand: string;
+    noWait?: boolean;
+    reach?: import('./model.js').Reach;
+    reply?: number;
+}
+export declare function saveActivityDraft(squarePath: string, name: string, body: string): string;
+export declare function cmdActivity(squarePath: string, name: string, activity: string, resolveBody: (arg: string) => string, opts: ActivityOptions): Promise<void>;

package/dist/activity.js

@@ -2,13 +2,15 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { setTimeout as sleep } from 'node:timers/promises';
-import { loadSquare } from './artifact.js';
-import { SquareError, validateName } from './model.js';
+import { SquareError, isSquareError, validateName } from './model.js';
 import { expressHintLine, renderActivityBlocked, renderActivityLimit, renderExpressNoWait, renderExpressWaiting, renderPendingFeed, withPathOutput, } from './presentation.js';
-import { currentHold, inSquareCount, nowMs, SLEEP_MS, resolveRosterName } from './runtime.js';
-import { resolveKnownName } from './decisions.js';
-import { dispatchActNotifications } from './notifications.js';
-import { execute } from './square-application.js';
+import { nowMs, SLEEP_MS } from './runtime.js';
+import { wakeNotifierForSquare } from './notifications.js';
+import { openSquare } from './square-file-adapter.js';
+import { closeOpenSquare } from './open-square.js';
+import { Square } from './square-wiring.js';
+import { activityPresentation, resolveParticipant } from './views.js';
+import { formatActivityId } from './square-core.js';
 import { formatTimestamp } from './time.js';
 function draftDirFor(squarePath) {
     return path.join(path.dirname(squarePath), 'drafts');
@@ -40,118 +42,132 @@ export function saveActivityDraft(squarePath, name, body) {
 export async function cmdActivity(squarePath, name, activity, resolveBody, opts) {
     validateName(name);
     const rawInput = String(resolveBody(activity)).replace(/\r\n/g, '\n');
-    let doc;
+    const reader = await openSquare(squarePath, { clock: nowMs });
+    let knownName;
     try {
-        doc = loadSquare(squarePath);
+        knownName = (await resolveParticipant(reader, name)).name;
     }
     catch (err) {
-        if (err instanceof SquareError) {
+        await closeOpenSquare(reader);
+        if (isSquareError(err)) {
+            if (err.code === 'unknown_participant' || err.code === 'invalid_args') {
+                const draftPath = saveActivityDraft(squarePath, name, rawInput);
+                process.stderr.write(err.message + '\n');
+                process.stderr.write(`draft kept: ${draftPath}\n`);
+                process.exit(2);
+            }
             process.stderr.write(err.message + '\n');
             process.exit(err.code === 'not_found' ? 1 : 2);
         }
         throw err;
     }
-    const knownName = resolveRosterName(doc, name);
-    if (knownName === undefined) {
-        const draftPath = saveActivityDraft(squarePath, name, rawInput);
-        const expected = doc.acts.filter((act) => act.kind === 'join').map((act) => act.actor);
-        process.stderr.write(`Unknown participant "${name}". Expected one of: ${expected.join(', ')}.\n`);
-        process.stderr.write(`draft kept: ${draftPath}\n`);
-        process.exit(2);
-    }
+    await closeOpenSquare(reader);
     const body = rawInput.trim();
     const force = opts.force ?? false;
     const noWait = opts.noWait ?? false;
-    const reach = opts.reach === undefined
-        ? undefined
-        : opts.reach === 'bell'
-            ? 'bell'
-            : { beside: resolveKnownName(doc, opts.reach.beside) };
+    const reach = opts.reach === 'bell' ? 'bell' : undefined;
     let announcedWait;
-    while (true) {
-        const committed = await execute(squarePath, {
-            type: 'say',
-            name,
-            body,
-            force,
-            now: nowMs(),
-            ...(reach === undefined ? {} : { reach }),
-            ...(opts.reply === undefined ? {} : { reply: opts.reply }),
-        });
-        const decision = committed.result;
-        const freshDoc = loadSquare(squarePath);
-        const headerCount = inSquareCount(freshDoc);
-        const held = currentHold(freshDoc.acts).active;
-        switch (decision.type) {
-            case 'sent': {
-                const sayAct = committed.acts.find((act) => act.kind === 'say');
-                if (sayAct !== undefined)
-                    await dispatchActNotifications(squarePath, sayAct);
-                const hasPending = decision.pendingPublic.length > 0 || decision.pendingRoomChanges.length > 0;
-                const pending = hasPending ? `\n\n${renderPendingFeed(freshDoc.acts, decision.pendingPublic, decision.pendingRoomChanges)}` : '';
-                const hint = expressHintLine(decision.ownActCount);
-                const withHint = hint ? `${decision.confirmation}\n${hint}` : decision.confirmation;
+    const square = await Square.at({ path: squarePath, clock: nowMs, notifier: wakeNotifierForSquare(squarePath) });
+    try {
+        const participant = await square.join(name);
+        while (true) {
+            const beforeSquare = await openSquare(squarePath, { clock: nowMs });
+            const before = await activityPresentation(beforeSquare, knownName).finally(() => closeOpenSquare(beforeSquare));
+            const pendingPublic = before.pendingPublic;
+            const pendingRoomChanges = before.pendingRoomChanges;
+            try {
+                await participant.express(body, {
+                    force,
+                    ...(reach === undefined ? {} : { reach }),
+                    ...(opts.reply === undefined ? {} : { reply: formatActivityId(opts.reply) }),
+                });
+                const freshSquare = await openSquare(squarePath, { clock: nowMs });
+                const fresh = await activityPresentation(freshSquare, knownName).finally(() => closeOpenSquare(freshSquare));
+                const headerCount = fresh.participantCount;
+                const held = fresh.held;
+                const ownActCount = fresh.ownActivityCount;
+                const hasPending = pendingPublic.length > 0 || pendingRoomChanges.length > 0;
+                const pending = hasPending ? `\n\n${renderPendingFeed([...fresh.activities], [...pendingPublic], [...pendingRoomChanges], knownName)}` : '';
+                const hint = expressHintLine(ownActCount);
+                const confirmation = `● heads turn your way — #${ownActCount}`;
+                const withHint = hint ? `${confirmation}\n${hint}` : confirmation;
                 process.stdout.write(withPathOutput(squarePath, withHint + pending, { participantCount: headerCount, held }));
                 return;
             }
-            case 'blocked': {
-                const draftPath = saveActivityDraft(squarePath, name, rawInput);
-                process.stdout.write(renderActivityBlocked({
-                    squarePath,
-                    name: knownName,
-                    forceCommand: opts.forceCommand,
-                    activitySummaries: decision.activitySummaries,
-                    unreadRoomChanges: decision.unreadRoomChanges,
-                    draftPath,
-                    participantCount: headerCount,
-                    held,
-                }));
-                process.exit(1);
-                break;
-            }
-            case 'capped': {
-                process.stdout.write(renderActivityLimit({
-                    squarePath,
-                    name: knownName,
-                    count: decision.count,
-                    hardCap: decision.hardCap,
-                    draftPath: saveActivityDraft(squarePath, name, rawInput),
-                    participantCount: headerCount,
-                    held,
-                }));
-                process.exit(1);
-                break;
-            }
-            case 'throttled': {
-                if (noWait) {
+            catch (error) {
+                if (!(error instanceof SquareError))
+                    throw error;
+                const freshSquare = await openSquare(squarePath, { clock: nowMs });
+                const fresh = await activityPresentation(freshSquare, knownName).finally(() => closeOpenSquare(freshSquare));
+                const headerCount = fresh.participantCount;
+                const held = fresh.held;
+                if (error.code === 'behind') {
                     const draftPath = saveActivityDraft(squarePath, name, rawInput);
-                    process.stdout.write(renderExpressNoWait({ squarePath, name: knownName, reason: 'throttled', delayMs: decision.delayMs, draftPath, participantCount: headerCount, held }));
+                    process.stdout.write(renderActivityBlocked({
+                        squarePath,
+                        name: knownName,
+                        forceCommand: opts.forceCommand,
+                        activitySummaries: [],
+                        unreadRoomChanges: [...pendingRoomChanges],
+                        draftPath,
+                        participantCount: headerCount,
+                        held,
+                    }));
                     process.exit(1);
+                    return;
                 }
-                if (announcedWait !== 'throttled') {
-                    process.stdout.write(renderExpressWaiting({ reason: 'throttled', delayMs: decision.delayMs }) + '\n');
-                    announcedWait = 'throttled';
-                }
-                await sleep(decision.delayMs);
-                break;
-            }
-            case 'held': {
-                if (noWait) {
-                    const draftPath = saveActivityDraft(squarePath, name, rawInput);
-                    process.stdout.write(renderExpressNoWait({ squarePath, name: knownName, reason: 'held', holdReason: decision.reason, draftPath, participantCount: headerCount, held }));
+                if (error.code === 'capped') {
+                    process.stdout.write(renderActivityLimit({
+                        squarePath,
+                        name: knownName,
+                        count: fresh.ownActivityCount,
+                        ...(fresh.hardCap === null ? {} : { hardCap: fresh.hardCap }),
+                        draftPath: saveActivityDraft(squarePath, name, rawInput),
+                        participantCount: headerCount,
+                        held,
+                    }));
                     process.exit(1);
+                    return;
                 }
-                if (announcedWait !== 'held') {
-                    process.stdout.write(renderExpressWaiting({ reason: 'held' }) + '\n');
-                    announcedWait = 'held';
+                if (error.code === 'throttled') {
+                    const delayMs = error.facts?.retryAfterMs ?? SLEEP_MS;
+                    if (noWait) {
+                        const draftPath = saveActivityDraft(squarePath, name, rawInput);
+                        process.stdout.write(renderExpressNoWait({ squarePath, name: knownName, reason: 'throttled', delayMs, draftPath, participantCount: headerCount, held }));
+                        process.exit(1);
+                    }
+                    if (announcedWait !== 'throttled') {
+                        process.stdout.write(renderExpressWaiting({ reason: 'throttled', delayMs }) + '\n');
+                        announcedWait = 'throttled';
+                    }
+                    await sleep(delayMs);
+                    continue;
                 }
-                await sleep(SLEEP_MS);
-                break;
-            }
-            case 'bell_quota': {
-                process.stdout.write(withPathOutput(squarePath, [`✕ the bell stays quiet for now`, `  · you can ring it again at ${formatTimestamp(decision.nextAt)}`].join('\n'), { participantCount: headerCount, held }));
-                process.exit(1);
+                if (error.code === 'held') {
+                    const holdReason = fresh.holdReason;
+                    if (noWait) {
+                        const draftPath = saveActivityDraft(squarePath, name, rawInput);
+                        process.stdout.write(renderExpressNoWait({ squarePath, name: knownName, reason: 'held', holdReason, draftPath, participantCount: headerCount, held }));
+                        process.exit(1);
+                    }
+                    if (announcedWait !== 'held') {
+                        process.stdout.write(renderExpressWaiting({ reason: 'held' }) + '\n');
+                        announcedWait = 'held';
+                    }
+                    await sleep(SLEEP_MS);
+                    continue;
+                }
+                if (error.code === 'bell_quota') {
+                    const nextAt = nowMs() + (error.facts?.retryAfterMs ?? 1);
+                    process.stdout.write(withPathOutput(squarePath, [`✕ the bell stays quiet for now`, `  · you can ring it again at ${formatTimestamp(nextAt)}`].join('\n'), { participantCount: headerCount, held }));
+                    process.exit(1);
+                    return;
+                }
+                throw error;
             }
         }
     }
+    finally {
+        await square.close();
+    }
 }

package/dist/artifact.d.ts

@@ -0,0 +1,20 @@
+import { type BuildOptions, type HardCap, type SquareState, type SquareRuntimeState } from './model.js';
+export interface DoctorProblem {
+    kind: string;
+    message: string;
+}
+export interface DiagnoseResult {
+    unfixable?: string;
+    problems: DoctorProblem[];
+    state?: SquareState;
+}
+export declare function emptyRuntimeState(nextActIndex?: number): SquareRuntimeState;
+export declare function createSquareState(options: BuildOptions & {
+    hardCap: HardCap;
+}, snippet: string): SquareState;
+export declare function encodeSquare(squareState: SquareState): Buffer;
+export declare function decodeSquare(bytes: Buffer): SquareState;
+export declare function writeSquareFile(squarePath: string, squareState: SquareState): void;
+export declare function loadSquare(squarePath: string): SquareState;
+export declare function probeSquare(squarePath: string): SquareState | undefined;
+export declare function diagnoseSquareFile(squarePath: string): DiagnoseResult;