@astrosheep/square 0.3.2

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

@@ -0,0 +1,25 @@
+{
+  "name": "square",
+  "version": "0.3.2",
+  "description": "Shared Square activity with reliable participant attention at Codex boundaries.",
+  "author": {
+    "name": "Square"
+  },
+  "license": "MIT",
+  "keywords": [
+    "square",
+    "collaboration",
+    "multi-agent"
+  ],
+  "skills": "./skills/",
+  "interface": {
+    "displayName": "Square",
+    "shortDescription": "Join and coordinate through a shared square",
+    "longDescription": "Participate in a shared activity stream and receive addressed Square activity at Codex boundaries.",
+    "developerName": "Square",
+    "category": "Developer Tools",
+    "capabilities": [
+      "Interactive"
+    ]
+  }
+}

package/codex-plugin/hooks/hooks.json

@@ -0,0 +1,28 @@
+{
+  "hooks": {
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "square codex-hook",
+            "timeout": 5,
+            "statusMessage": "square-codex-hook"
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "square codex-hook",
+            "timeout": 5,
+            "statusMessage": "square-codex-hook"
+          }
+        ]
+      }
+    ]
+  }
+}

package/dist/activity-feed.js

@@ -0,0 +1,36 @@
+import { sameName } from './model.js';
+import { actStableIndex, advanceCursor, latestIndexedActIndex } from './runtime.js';
+import { matchesCatchFilter } from './delivery.js';
+export function indexedDelta(acts, cursor) {
+    return acts
+        .map((act) => ({ act, index: actStableIndex(act) }))
+        .filter((item) => item.index > cursor);
+}
+export function peerRoomChanges(delta, name) {
+    return delta.filter((item) => item.act.actor !== undefined && !sameName(item.act.actor, name) && item.act.kind !== 'say' && item.act.kind !== 'read');
+}
+export function peerPublicActs(delta, name) {
+    return delta.filter((item) => item.act.actor !== undefined && !sameName(item.act.actor, name) && (item.act.kind === 'say' || item.act.kind === 'done'));
+}
+function matchesParticipants(item, participants) {
+    return participants === undefined || (item.act.actor !== undefined && participants.some((participant) => sameName(participant, item.act.actor)));
+}
+export function matchesFeedFilter(item, filter) {
+    if (item.act.kind === 'say') {
+        return matchesCatchFilter({ actor: item.act.actor, body: item.act.body, bell: item.act.reach === 'bell' }, filter);
+    }
+    return filter.mention === undefined && matchesParticipants(item, filter.participants);
+}
+export function filteredPeerActivities(delta, name, filter) {
+    return peerPublicActs(delta, name)
+        .filter((item) => item.act.kind === 'say')
+        .filter((item) => matchesFeedFilter(item, filter));
+}
+export function filteredRoomChanges(delta, name, filter) {
+    if (filter.mention !== undefined)
+        return [];
+    return peerRoomChanges(delta, name).filter((item) => matchesParticipants(item, filter.participants));
+}
+export function ackPeerDelta(doc, name, delta) {
+    return advanceCursor(doc, name, latestIndexedActIndex([...peerPublicActs(delta, name), ...peerRoomChanges(delta, name)]), 'watch');
+}

package/dist/activity.js

@@ -0,0 +1,151 @@
+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 { dispatchActNotifications } from './notifications.js';
+import { actHintLine, renderActivityBlocked, renderActivityLimit, renderActNoWait, renderActWaiting, renderPendingFeed, withActivityNextOutput, } from './presentation.js';
+import { appendAct, currentHold, inSquareCount, nowMs, SLEEP_MS, withSquareLock, resolveRosterName } from './runtime.js';
+import { decideAct, resolveKnownName } from './decisions.js';
+import { formatTimestamp } from './time.js';
+function draftDirFor(squarePath) {
+    return path.join(path.dirname(squarePath), 'drafts');
+}
+function draftTimestamp(at) {
+    return new Date(at).toISOString().replace(/\.\d{3}Z$/, 'Z').replace(/[:.]/g, '-');
+}
+function draftNamePart(name) {
+    return name.replace(/[^\p{L}\p{N}_-]+/gu, '-').replace(/^-+|-+$/g, '') || 'participant';
+}
+export function saveActivityDraft(squarePath, name, body) {
+    const draftDir = draftDirFor(squarePath);
+    fs.mkdirSync(draftDir, { recursive: true });
+    const hash = crypto.createHash('sha256').update(body).digest('hex').slice(0, 8);
+    const base = `${draftTimestamp(nowMs())}-${draftNamePart(name)}-${hash}`;
+    for (let i = 0;; i++) {
+        const filename = `${base}${i === 0 ? '' : `-${i}`}.md`;
+        const target = path.join(draftDir, filename);
+        try {
+            fs.writeFileSync(target, body, { flag: 'wx' });
+            return target;
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+        }
+    }
+}
+export async function cmdActivity(squarePath, name, activity, resolveBody, opts) {
+    validateName(name);
+    const rawInput = String(resolveBody(activity)).replace(/\r\n/g, '\n');
+    let doc;
+    try {
+        doc = loadSquare(squarePath);
+    }
+    catch (err) {
+        if (err instanceof SquareError) {
+            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);
+    }
+    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) };
+    let announcedWait;
+    while (true) {
+        const { decision, sent, headerCount, held } = await withSquareLock(squarePath, () => {
+            const freshDoc = loadSquare(squarePath);
+            const d = decideAct(freshDoc, { name, body, force, now: nowMs(), reach });
+            if (d.type === 'sent') {
+                const appended = appendAct(squarePath, freshDoc, d.act);
+                return { decision: d, sent: { act: appended, index: appended.index }, headerCount: inSquareCount(freshDoc), held: currentHold(freshDoc.acts).active };
+            }
+            return { decision: d, sent: undefined, headerCount: inSquareCount(freshDoc), held: currentHold(freshDoc.acts).active };
+        });
+        switch (decision.type) {
+            case 'sent': {
+                if (sent)
+                    await dispatchActNotifications(squarePath, sent);
+                const hasPending = decision.pendingPublic.length > 0 || decision.pendingRoomChanges.length > 0;
+                const pending = hasPending ? `\n\n${renderPendingFeed(decision.pendingPublic, decision.pendingRoomChanges)}` : '';
+                const hint = actHintLine(decision.ownActCount);
+                const withHint = hint ? `${decision.confirmation}\n${hint}` : decision.confirmation;
+                process.stdout.write(withActivityNextOutput(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) {
+                    const draftPath = saveActivityDraft(squarePath, name, rawInput);
+                    process.stdout.write(renderActNoWait({ squarePath, name: knownName, reason: 'throttled', delayMs: decision.delayMs, draftPath, participantCount: headerCount, held }));
+                    process.exit(1);
+                }
+                if (announcedWait !== 'throttled') {
+                    process.stdout.write(renderActWaiting({ 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(renderActNoWait({ squarePath, name: knownName, reason: 'held', holdReason: decision.reason, draftPath, participantCount: headerCount, held }));
+                    process.exit(1);
+                }
+                if (announcedWait !== 'held') {
+                    process.stdout.write(renderActWaiting({ reason: 'held' }) + '\n');
+                    announcedWait = 'held';
+                }
+                await sleep(SLEEP_MS);
+                break;
+            }
+            case 'bell_quota': {
+                process.stdout.write(withActivityNextOutput(squarePath, [`✕ the bell stays quiet for now`, `  · you can ring it again at ${formatTimestamp(decision.nextAt)}`].join('\n'), { participantCount: headerCount, held }));
+                process.exit(1);
+            }
+        }
+    }
+}