@astrosheep/square 0.3.11 → 0.3.13

package/dist/cli/square-commands.js

@@ -1,12 +1,13 @@
 import { cmdActivity } from '../activity.js';
-import { loadSquare } from '../artifact.js';
-import { cmdCompact } from '../compact.js';
-import { SquareError, formatHardCap, validateName, } from '../model.js';
-import { participantCommandPrefix, quoteShell, renderEventCli, renderPublicTail, withPathOutput, } from '../presentation.js';
-import { hasAutomaticDeliveryIdentity, localParticipantOwner, recordLocalDone, recordLocalJoin } from '../registry.js';
-import { sweepPendingNotifications } from '../notifications.js';
-import { inSquareCount, isCurrentlyJoined, nowMs, resolveRosterName } from '../runtime.js';
-import { createSquare, execute } from '../square-application.js';
+import { formatActivityId, formatHardCap, parseActivityId, } from '../model.js';
+import { participantCommandPrefix, participantIdentity, renderEventCli, renderAmbientEvent, withPathOutput, } from '../presentation.js';
+import { hasAutomaticDeliveryIdentity, localParticipantOwner, recordLocalDone, recordLocalJoin, } from '../registry.js';
+import { sweepPendingNotifications, wakeNotifierForSquare } from '../notifications.js';
+import { nowMs } from '../runtime.js';
+import { createSquare, openSquare } from '../square-file-adapter.js';
+import { closeOpenSquare } from '../open-square.js';
+import { Square } from '../square-wiring.js';
+import { entryPresentation, eventPresentation } from '../views.js';
 import { fail, parseHardCap, parsePositiveInteger, readPipedBodyFallback, readStdinSync, requireParticipant, requireValue, resolveBody, usage, } from './context.js';
 function parseBuild(argv) {
     const options = { force: false, hardCap: null };
@@ -78,54 +79,55 @@ function parseJoin(argv, context) {
 export const joinCommand = {
     parse: parseJoin,
     async execute(intent, context) {
-        validateName(intent.name);
+        const beforeSquare = await openSquare(context.squarePath, { clock: nowMs });
+        const before = await entryPresentation(beforeSquare, intent.name, intent.lastN);
+        await closeOpenSquare(beforeSquare);
+        const square = await Square.at({ path: context.squarePath, clock: nowMs, notifier: wakeNotifierForSquare(context.squarePath) });
         try {
-            const committed = await execute(context.squarePath, { type: 'join', name: intent.name, now: nowMs() });
-            const joinedName = committed.result.joinedName;
-            const isRejoin = !committed.result.addParticipant;
-            const after = loadSquare(context.squarePath);
-            const preamble = after.preamble.at(-1) === '---' ? after.preamble.slice(0, -1) : after.preamble;
+            const participant = await square.join(intent.name);
+            const joinedName = participant.name;
+            const isRejoin = before.joined;
+            const reconnect = isRejoin
+                && localParticipantOwner(context.squarePath, joinedName) !== undefined;
+            if (isRejoin && !intent.kick && !reconnect) {
+                fail([
+                    `✕ ${participantIdentity(joinedName)} shoos you out of the square`,
+                    `  · a same-named participant stands here — the name is taken`,
+                    `  · --kick banishes her and the name becomes yours`,
+                    `» ${participantCommandPrefix(context.squarePath, joinedName)} join --kick`,
+                ].join('\n'));
+            }
+            const afterSquare = await openSquare(context.squarePath, { clock: nowMs });
+            const after = await entryPresentation(afterSquare, joinedName, intent.lastN);
+            await closeOpenSquare(afterSquare);
             recordLocalJoin(joinedName, context.squarePath);
             await sweepPendingNotifications(context.squarePath);
-            const activities = renderPublicTail(after.acts, intent.lastN, nowMs(), joinedName);
-            const contextText = preamble.join('\n').trim();
+            const activities = after.recentActivities.map((event) => renderAmbientEvent(event, joinedName, {
+                now: nowMs(),
+                preview: intent.lastN === null ? undefined : 200,
+                actNumber: event.kind === 'say' ? after.sayNumbers[event.index] : undefined,
+            })).filter(Boolean).join('\n\n');
+            const contextText = after.joinContext;
             const fallback = hasAutomaticDeliveryIdentity()
                 ? []
                 : ['', `» ${participantCommandPrefix(context.squarePath, joinedName)} catch --idle 30m`, '  no session delivery detected — keep this catch open for new activity'];
+            const scene = after.scene;
+            const entryLine = !isRejoin
+                ? '● You stepped into the square'
+                : reconnect && !intent.kick
+                    ? '● you are already in the square'
+                    : `✓ you banished the original ${participantIdentity(joinedName)} — the name is yours`;
             const output = [
-                `● ${joinedName} stepped into the square`,
+                entryLine,
+                ...(reconnect || scene === '' ? [] : ['', scene]),
                 ...(isRejoin || contextText === '' ? [] : ['', 'context', contextText]),
-                ...(activities === '' ? [] : ['', 'recent activity', activities]),
-                ...(isRejoin ? [] : ['', `» ${participantCommandPrefix(context.squarePath, joinedName)} warmup`]),
+                ...(isRejoin || activities === '' ? [] : ['', 'recent activity', activities]),
                 ...fallback,
             ].join('\n');
-            return withPathOutput(context.squarePath, output, { participantCount: inSquareCount(after) });
+            return withPathOutput(context.squarePath, output, { participantCount: after.participantCount });
         }
-        catch (error) {
-            if (!(error instanceof SquareError) || error.code !== 'conflict')
-                throw error;
-            const doc = loadSquare(context.squarePath);
-            const joinedName = resolveRosterName(doc, intent.name);
-            if (joinedName === undefined || !isCurrentlyJoined(doc.acts, joinedName))
-                throw error;
-            const reconnect = localParticipantOwner(context.squarePath, joinedName) !== undefined;
-            if (!intent.kick && !reconnect) {
-                fail([
-                    `✕ ${joinedName} shoos you out of the square`,
-                    `  · a same-named participant stands here — the name is taken`,
-                    `  · --kick banishes her and the name becomes yours`,
-                    `» ${participantCommandPrefix(context.squarePath, joinedName)} join --kick`,
-                ].join('\n'));
-            }
-            recordLocalJoin(joinedName, context.squarePath);
-            await sweepPendingNotifications(context.squarePath);
-            const fallback = hasAutomaticDeliveryIdentity()
-                ? ''
-                : `\n» ${participantCommandPrefix(context.squarePath, joinedName)} catch --idle 30m\n  no session delivery detected — keep this catch open for new activity`;
-            const line = reconnect && !intent.kick
-                ? `● you are already in the square`
-                : `✓ you banished the original ${joinedName} — the name is yours`;
-            return withPathOutput(context.squarePath, `${line}${fallback}`, { participantCount: inSquareCount(doc) });
+        finally {
+            await square.close();
         }
     },
     present: (result) => process.stdout.write(result),
@@ -133,7 +135,6 @@ export const joinCommand = {
 function parseActivity(argv, context) {
     let force = false;
     let noWait = false;
-    let beside;
     let bell = false;
     let reply;
     const bodyArgs = [];
@@ -143,25 +144,21 @@ function parseActivity(argv, context) {
             force = true;
         else if (argument === '--no-wait')
             noWait = true;
-        else if (argument === '--beside') {
-            beside = requireValue(argv, index, argument);
-            index += 1;
-        }
+        else if (argument === '--beside')
+            fail('✕ express does not know --beside\n» square express --help');
         else if (argument === '--bell')
             bell = true;
         else if (argument === '--reply') {
-            const value = requireValue(argv, index, argument).trim().match(/^(?:act_)?(\d+)$/i);
-            if (!value || !Number.isSafeInteger(Number(value[1])))
-                fail('Invalid --reply: expected an activity id like act_12 or 12.');
-            reply = Number(value[1]);
+            const replyIndex = parseActivityId(requireValue(argv, index, argument));
+            if (replyIndex === undefined)
+                fail('Invalid --reply: expected an activity id like act/12');
+            reply = replyIndex;
             index += 1;
         }
         else
             bodyArgs.push(argument);
     }
-    if (bell && beside !== undefined)
-        fail('Invalid express options: --beside and --bell are mutually exclusive.');
-    const reach = bell ? 'bell' : beside === undefined ? undefined : { beside };
+    const reach = bell ? 'bell' : undefined;
     if (bodyArgs.length !== 1) {
         if (bodyArgs.length === 0) {
             const piped = readPipedBodyFallback();
@@ -176,13 +173,13 @@ export const expressCommand = {
     parse: parseActivity,
     async execute(intent, context) {
         await sweepPendingNotifications(context.squarePath);
-        const reachArg = intent.reach === 'bell' ? ' --bell' : intent.reach === undefined ? '' : ` --beside ${quoteShell(intent.reach.beside)}`;
+        const reachArg = intent.reach === 'bell' ? ' --bell' : '';
         await cmdActivity(context.squarePath, intent.name, intent.activity, resolveBody, {
             force: intent.force,
             noWait: intent.noWait,
             reach: intent.reach,
             reply: intent.reply,
-            forceCommand: `${participantCommandPrefix(context.squarePath, intent.name)} express --force${reachArg}${intent.reply === undefined ? '' : ` --reply act_${intent.reply}`} -`,
+            forceCommand: `${participantCommandPrefix(context.squarePath, intent.name)} express --force${reachArg}${intent.reply === undefined ? '' : ` --reply ${formatActivityId(intent.reply)}`} -`,
         });
     },
     present: () => { },
@@ -196,10 +193,15 @@ export const doneCommand = {
     parse: parseDone,
     async execute(intent, context) {
         const body = resolveBody(intent.body ?? '').replace(/\r\n/g, '\n').trim();
-        const committed = await execute(context.squarePath, { type: 'done', name: intent.name, body, now: nowMs() });
-        const name = committed.acts[0].actor;
+        const square = await Square.at({ path: context.squarePath, clock: nowMs, notifier: wakeNotifierForSquare(context.squarePath) });
+        const participant = await square.join(intent.name);
+        const result = await participant.done(body);
+        await square.close();
+        const name = result.activity.actor;
         recordLocalDone(name, context.squarePath);
-        return withPathOutput(context.squarePath, `× ${name} steps out of the square — done · just now`, { participantCount: inSquareCount(loadSquare(context.squarePath)) });
+        const presentation = await openSquare(context.squarePath, { clock: nowMs });
+        const participantCount = (await entryPresentation(presentation, name).finally(() => closeOpenSquare(presentation))).participantCount;
+        return withPathOutput(context.squarePath, `○ ${participantIdentity(name)} steps out of the square — done · just now`, { participantCount });
     },
     present: (result) => process.stdout.write(result),
 };
@@ -211,9 +213,19 @@ function parseHold(argv, context) {
 export const holdCommand = {
     parse: parseHold,
     async execute(intent, context) {
-        const committed = await execute(context.squarePath, { type: 'hold', actor: intent.name, body: resolveBody(intent.body ?? '').replace(/\r\n/g, '\n').trim(), now: nowMs() });
-        const doc = loadSquare(context.squarePath);
-        return withPathOutput(context.squarePath, renderEventCli(committed.acts[0]), { participantCount: inSquareCount(doc), held: true });
+        const square = await Square.at({ path: context.squarePath, clock: nowMs, notifier: wakeNotifierForSquare(context.squarePath) });
+        try {
+            const participant = await square.join(intent.name);
+            const result = await participant.hold(resolveBody(intent.body ?? '').replace(/\r\n/g, '\n').trim());
+            await square.close();
+            const presentationSquare = await openSquare(context.squarePath, { clock: nowMs });
+            const presentation = await eventPresentation(presentationSquare, result.activity.id);
+            await closeOpenSquare(presentationSquare);
+            return withPathOutput(context.squarePath, renderEventCli(presentation.activity), { participantCount: presentation.participantCount, held: true });
+        }
+        finally {
+            await square.close();
+        }
     },
     present: (result) => process.stdout.write(result),
 };
@@ -224,25 +236,19 @@ export const resumeCommand = {
         return { name: requireParticipant(context.name) };
     },
     async execute(intent, context) {
-        const committed = await execute(context.squarePath, { type: 'resume', actor: intent.name, now: nowMs() });
-        const doc = loadSquare(context.squarePath);
-        return withPathOutput(context.squarePath, renderEventCli(committed.acts[0]), { participantCount: inSquareCount(doc) });
-    },
-    present: (result) => process.stdout.write(result),
-};
-export const compactCommand = {
-    parse(argv, context) {
-        let keep = 50;
-        for (let index = 0; index < argv.length; index++) {
-            if (argv[index] !== '--keep')
-                usage(context.command);
-            keep = parsePositiveInteger(requireValue(argv, index, argv[index]), argv[index]);
-            index += 1;
+        const square = await Square.at({ path: context.squarePath, clock: nowMs, notifier: wakeNotifierForSquare(context.squarePath) });
+        try {
+            const participant = await square.join(intent.name);
+            const result = await participant.resume();
+            await square.close();
+            const presentationSquare = await openSquare(context.squarePath, { clock: nowMs });
+            const presentation = await eventPresentation(presentationSquare, result.activity.id);
+            await closeOpenSquare(presentationSquare);
+            return withPathOutput(context.squarePath, renderEventCli(presentation.activity), { participantCount: presentation.participantCount });
+        }
+        finally {
+            await square.close();
         }
-        return { keep };
-    },
-    async execute(intent, context) {
-        await cmdCompact(context.squarePath, intent);
     },
-    present: () => { },
+    present: (result) => process.stdout.write(result),
 };

package/dist/cmd/notify-once.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/codex-hook.d.ts

@@ -0,0 +1,10 @@
+import type { InboxMembership } from './model.js';
+export interface CodexHookInput {
+    session_id?: unknown;
+    hook_event_name?: unknown;
+    cwd?: unknown;
+    source?: unknown;
+}
+export declare function codexHookResponse(input: CodexHookInput, lookup?: (sessionId: string) => Promise<InboxMembership[]> | InboxMembership[], env?: NodeJS.ProcessEnv): Promise<object | undefined>;
+export declare function runCodexHook(inputText: string, env?: NodeJS.ProcessEnv): Promise<string>;
+export declare function runCodexHookAsync(inputText: string, env?: NodeJS.ProcessEnv): Promise<string>;

package/dist/codex-hook.js

@@ -1,13 +1,14 @@
 import { presentPendingAtBoundary } from './boundary-presentation.js';
 import { sessionInbox } from './inbox.js';
-export function codexHookResponse(input, lookup = sessionInbox, env = process.env) {
+import { automaticSessionEnd, automaticSessionStart } from './automatic-session.js';
+export async function codexHookResponse(input, lookup = sessionInbox, env = process.env) {
     if (typeof input.session_id !== 'string' || input.session_id === '')
         return undefined;
     if (input.hook_event_name !== 'PostToolUse')
         return undefined;
     return presentPendingAtBoundary(input.session_id, (context) => ({ hookSpecificOutput: { hookEventName: 'PostToolUse', additionalContext: context } }), lookup, env);
 }
-export function runCodexHook(inputText, env = process.env) {
+export async function runCodexHook(inputText, env = process.env) {
     let input;
     try {
         input = JSON.parse(inputText);
@@ -17,6 +18,37 @@ export function runCodexHook(inputText, env = process.env) {
     }
     if (input === null || typeof input !== 'object')
         return '';
-    const response = codexHookResponse(input, sessionInbox, env);
+    const response = await codexHookResponse(input, sessionInbox, env);
     return response === undefined ? '' : `${JSON.stringify(response)}\n`;
 }
+export async function runCodexHookAsync(inputText, env = process.env) {
+    let input;
+    try {
+        input = JSON.parse(inputText);
+    }
+    catch {
+        return '';
+    }
+    if (input === null || typeof input !== 'object')
+        return '';
+    const value = input;
+    if (typeof value.session_id !== 'string' || typeof value.cwd !== 'string')
+        return runCodexHook(inputText, env);
+    if (value.hook_event_name === 'SessionStart' || value.hook_event_name === 'SessionResume') {
+        try {
+            const context = await automaticSessionStart('codex', value.session_id, value.cwd, env);
+            return context === undefined ? '' : `${JSON.stringify({ hookSpecificOutput: { hookEventName: value.hook_event_name, additionalContext: context } })}\n`;
+        }
+        catch {
+            return '';
+        }
+    }
+    if (value.hook_event_name === 'SessionEnd') {
+        try {
+            await automaticSessionEnd('codex', value.session_id, value.cwd, env);
+        }
+        catch { /* end remains bounded */ }
+        return '';
+    }
+    return runCodexHook(inputText, env);
+}

package/dist/decisions.d.ts

@@ -0,0 +1,92 @@
+import { type ActivitiesOptions, type Act, type StoredAct, type SquareState, type Reach, type HardCap } from './model.js';
+import { peerPublicActs, peerRoomChanges } from './activity-feed.js';
+export interface UnreadActivitySummary {
+    name: string;
+    count: number;
+    latestActivityAgeMs: number;
+    previews: UnreadActivityPreview[];
+}
+export interface UnreadActivityPreview {
+    number: number;
+    act: Extract<StoredAct, {
+        kind: 'say';
+    }>;
+}
+export declare function resolveKnownName(squareState: SquareState, name: string): string;
+export interface DecideJoinResult {
+    joinedName: string;
+    addParticipant: boolean;
+    joinAct?: Extract<Act, {
+        kind: 'join';
+    }>;
+}
+export declare function decideJoin(squareState: SquareState, name: string, now: number): DecideJoinResult;
+export type ActDecision = {
+    type: 'sent';
+    act: Act;
+    confirmation: string;
+    ownActCount: number;
+    pendingPublic: ReturnType<typeof peerPublicActs>;
+    pendingRoomChanges: ReturnType<typeof peerRoomChanges>;
+} | {
+    type: 'blocked';
+    activitySummaries: UnreadActivitySummary[];
+    unreadRoomChanges: ReturnType<typeof peerRoomChanges>;
+} | {
+    type: 'capped';
+    count: number;
+    hardCap: number;
+} | {
+    type: 'throttled';
+    delayMs: number;
+} | {
+    type: 'held';
+    reason: string | undefined;
+} | {
+    type: 'bell_quota';
+    nextAt: number;
+};
+export declare function decideAct(squareState: SquareState, input: {
+    name: string;
+    body: string;
+    force: boolean;
+    now: number;
+    reach?: Reach;
+    reply?: number;
+}): ActDecision;
+export declare function coreDone(squareState: SquareState, name: string, body: string, now: number): Extract<Act, {
+    kind: 'done';
+}>;
+export declare function coreHold(squareState: SquareState, actor: string, body: string, now: number): Extract<Act, {
+    kind: 'hold';
+}>;
+export declare function coreResume(squareState: SquareState, actor: string, now: number): Extract<Act, {
+    kind: 'resume';
+}>;
+export interface ParticipantStatus {
+    name: string;
+    state: 'active' | 'done' | 'not joined';
+    activityCount: number;
+    lastActiveAt: number | undefined;
+    presence: CorePresenceState;
+    presenceAt: number | undefined;
+    unreadActivityCount: number;
+    pendingMentionCount: number;
+}
+export type CorePresenceState = 'never-joined' | 'active' | 'watching' | 'done';
+export interface StatusResult {
+    hardCap: HardCap;
+    throttlePerMinute: number | undefined;
+    activeCount: number;
+    doneCount: number;
+    holdActive: boolean;
+    holdReason: string | undefined;
+    holdActor: string | undefined;
+    holdAt: number | undefined;
+    participants: ParticipantStatus[];
+    latestAct: StoredAct | undefined;
+    now: number;
+}
+export declare function coreStatus(squareState: SquareState, now: number): StatusResult;
+export declare function coreParticipants(squareState: SquareState, now: number): ParticipantStatus[];
+export declare function coreActivities(squareState: SquareState, opts: ActivitiesOptions): StoredAct[];