@astrosheep/square 0.3.4 → 0.3.6

package/dist/claude-hook.js

@@ -1,12 +1,13 @@
 import { leaseOwnsNotification } from './delivery.js';
-import { notificationMessageId } from './delivery-health.js';
+import { notificationMessageId } from './delivery.js';
 import { sessionInbox } from './inbox.js';
 import { participantCommandPrefix } from './presentation.js';
 import { presentOnce } from './presented.js';
 function pendingCount(inbox) {
     return inbox.reduce((total, membership) => total + membership.notifications.length, 0);
 }
-const INJECT_BODY_MAX = 2048;
+const INJECT_BODY_MAX = 200;
+const INJECT_TOTAL_MAX = 1200;
 /** Let a fresh blocking catch own notifications it can deliver; hook injection remains the fallback. */
 export function deferToActiveCatch(inbox) {
     return inbox
@@ -16,38 +17,61 @@ export function deferToActiveCatch(inbox) {
             return membership;
         return {
             ...membership,
-            notifications: membership.notifications.filter((notification) => !leaseOwnsNotification(lease, notification)),
+            notifications: membership.notifications.filter((notification) => !leaseOwnsNotification(lease, { ...notification, recipient: membership.name })),
         };
     })
         .filter((membership) => membership.notifications.length > 0);
 }
-function injectBodyPreview(body, squarePath, name, actIndex) {
+function injectBodyPreview(body) {
     const compact = body.replace(/\r\n/g, '\n');
     if (compact.length <= INJECT_BODY_MAX)
         return compact;
-    const pointer = `${participantCommandPrefix(squarePath, name)} echo --ids act_${actIndex} --full`;
-    return `${compact.slice(0, INJECT_BODY_MAX).trimEnd()}\n… [truncated] full echo: ${pointer}`;
+    return `${compact.slice(0, INJECT_BODY_MAX).trimEnd()}\n… [truncated; run catch --now]`;
 }
 export function renderClaudeInboxContext(inbox) {
     const count = pendingCount(inbox);
     const noun = count === 1 ? 'notification' : 'notifications';
-    return [
-        `<system-reminder source="square">You have ${count} unread Square ${noun}.`,
-        ...inbox.flatMap((membership) => {
-            const command = `${participantCommandPrefix(membership.squarePath, membership.name)} catch --now`;
-            return membership.notifications.map((notification) => {
-                const id = notificationMessageId(membership.squarePath, notification.actIndex);
-                const body = injectBodyPreview(notification.body, membership.squarePath, membership.name, notification.actIndex);
-                return [
-                    `${id} · ${membership.squarePath}: @${membership.name} from @${notification.actor} (${notification.via})`,
-                    body,
-                    `Ack with: ${command}`,
-                ].join('\n');
-            });
-        }),
+    const header = `<system-reminder source="square">You have ${count} unread Square ${noun}.`;
+    const footer = [
         // Body here is a cache only. Delivered is written solely by catch.
         'Ids are stable across turns. If you already acted on an id, do not repeat the action; still run catch --now to mark delivered.',
         'Read and respond in the square before finishing the current turn.</system-reminder>',
+    ];
+    const queued = inbox.flatMap((membership) => membership.notifications.map((notification) => ({ membership, notification })));
+    const blocks = [];
+    let omitted = 0;
+    for (const [index, entry] of queued.entries()) {
+        const { membership, notification } = entry;
+        const command = `${participantCommandPrefix(membership.squarePath, membership.name)} catch --now`;
+        const id = notificationMessageId(membership.squarePath, notification.actIndex);
+        const block = [
+            `${id} · ${membership.squarePath}: @${membership.name} from @${notification.actor} (${notification.route})`,
+            injectBodyPreview(notification.body),
+            `Ack with: ${command}`,
+        ].join('\n');
+        const omittedAfter = omitted + queued.length - index - 1;
+        const prospective = [
+            header,
+            ...blocks,
+            block,
+            ...(omittedAfter > 0
+                ? [`… ${omittedAfter} unread ${omittedAfter === 1 ? 'notification' : 'notifications'} omitted. Run catch --now to receive them.`]
+                : []),
+            ...footer,
+        ].join('\n');
+        if (prospective.length > INJECT_TOTAL_MAX) {
+            omitted += 1;
+            continue;
+        }
+        blocks.push(block);
+    }
+    return [
+        header,
+        ...blocks,
+        ...(omitted > 0
+            ? [`… ${omitted} unread ${omitted === 1 ? 'notification' : 'notifications'} omitted. Run catch --now to receive them.`]
+            : []),
+        ...footer,
     ].join('\n');
 }
 function nativeHookResponse(input, lookup, env) {
@@ -58,7 +82,7 @@ function nativeHookResponse(input, lookup, env) {
     }
     if (input.hook_event_name === 'Stop' && input.stop_hook_active === true)
         return undefined;
-    // Delivery membership is only claimed by explicit participant actions (join/act/catch/...).
+    // Delivery membership is only claimed by explicit participant actions (join/express/catch/...).
     // Inherited PASEO_AGENT_ID proves process ancestry, not conversational ownership.
     // Stop is the guaranteed "don't leave while undelivered" nudge; it does not consume presentation.
     if (input.hook_event_name === 'Stop') {

package/dist/cli/context.js

@@ -0,0 +1,143 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { loadSquare } from '../artifact.js';
+import { commandUsageHint } from '../help.js';
+import { parseParticipantList, validateName } from '../model.js';
+export const DEFAULT_SQUARE_PATH = '.square/SQUARE.md';
+export function readStdinSync() {
+    try {
+        return fs.readFileSync(0, 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+export function resolveBody(arg) {
+    return arg === '-' ? readStdinSync() : arg;
+}
+export function readPipedBodyFallback() {
+    if (process.stdin.isTTY)
+        return undefined;
+    const content = readStdinSync();
+    return content.trim() === '' ? undefined : content;
+}
+export function fail(message, exitCode = 2) {
+    process.stderr.write(`${message}\n`);
+    process.exit(exitCode);
+}
+export function usage(command) {
+    process.stderr.write(`✕ invalid arguments${command === '' ? '' : ` for ${command}`}\n`);
+    process.stderr.write(commandUsageHint(command || undefined));
+    process.exit(2);
+}
+export function requireValue(args, index, flag) {
+    const value = args[index + 1];
+    if (value === undefined || value.startsWith('--'))
+        fail(`Missing value for ${flag}.`);
+    return value;
+}
+export function parseDurationMs(value, flag) {
+    const match = value.match(/^([1-9]\d*)(ms|s|m|h)$/);
+    if (!match)
+        fail(`Invalid ${flag}: expected a positive duration with unit ms, s, m, or h (for example 500ms, 30s, 3m, 1h).`);
+    const amount = Number.parseInt(match[1], 10);
+    const multiplier = { ms: 1, s: 1000, m: 60000, h: 3600000 };
+    const milliseconds = amount * multiplier[match[2]];
+    if (!Number.isSafeInteger(milliseconds))
+        fail(`Invalid ${flag}: duration is too large.`);
+    return milliseconds;
+}
+export function parsePositiveInteger(value, flag) {
+    if (!/^[1-9]\d*$/.test(value))
+        fail(`Invalid ${flag}: expected a positive integer.`);
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed))
+        fail(`Invalid ${flag}: value is too large.`);
+    return parsed;
+}
+export function parseNonNegativeInteger(value, flag) {
+    if (!/^\d+$/.test(value))
+        fail(`Invalid ${flag}: expected a non-negative integer.`);
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed))
+        fail(`Invalid ${flag}: value is too large.`);
+    return parsed;
+}
+export function parseHardCap(value) {
+    if (value === 'unlimited')
+        return null;
+    if (!/^[1-9]\d*$/.test(value))
+        fail('Invalid build option: --cap must be a positive integer or unlimited.');
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed))
+        fail('Invalid build option: --cap must be a positive integer or unlimited.');
+    return parsed;
+}
+export function parseNameList(value, flag) {
+    const names = parseParticipantList(value);
+    if (names.length === 0)
+        fail(`Invalid ${flag}: expected at least one participant name.`);
+    for (const name of names)
+        validateName(name);
+    return names;
+}
+export function requireParticipant(name) {
+    if (!name)
+        fail('Missing required option: --as <name>.');
+    validateName(name);
+    return name;
+}
+function resolveDefaultSquarePath() {
+    const directory = path.join(process.cwd(), '.square');
+    let entries;
+    try {
+        entries = fs.readdirSync(directory, { withFileTypes: true });
+    }
+    catch {
+        return { path: DEFAULT_SQUARE_PATH, multiple: false };
+    }
+    const candidates = [];
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith('.md'))
+            continue;
+        const fullPath = path.join(directory, entry.name);
+        try {
+            const doc = loadSquare(fullPath);
+            candidates.push({ relPath: path.relative(process.cwd(), fullPath), at: doc.acts.at(-1)?.at ?? fs.statSync(fullPath).mtimeMs });
+        }
+        catch {
+            // Unreadable artifacts are not implicit command targets.
+        }
+    }
+    candidates.sort((a, b) => b.at - a.at);
+    return { path: candidates[0]?.relPath ?? DEFAULT_SQUARE_PATH, multiple: candidates.length > 1 };
+}
+export function parseGlobalArgs(rawArgs) {
+    const args = [...rawArgs];
+    let requestedPath;
+    let name;
+    for (let index = 0; index < args.length; index++) {
+        if (args[index] === '--square-path') {
+            requestedPath = requireValue(args, index, args[index]);
+            args.splice(index, 2);
+            index -= 1;
+        }
+        else if (args[index] === '--as') {
+            name = requireValue(args, index, args[index]);
+            args.splice(index, 2);
+            index -= 1;
+        }
+    }
+    if (name !== undefined)
+        validateName(name);
+    const explicitSquarePath = requestedPath !== undefined;
+    const command = args[0];
+    const resolved = !explicitSquarePath && !['ls', 'list', 'version'].includes(command ?? '')
+        ? resolveDefaultSquarePath()
+        : { path: requestedPath ?? DEFAULT_SQUARE_PATH, multiple: false };
+    return { squarePath: resolved.path, explicitSquarePath, multipleSquares: resolved.multiple, name, args };
+}
+export function defaultContext(command, squarePath, name) {
+    return { command, squarePath, name, homeDir: os.homedir() };
+}

package/dist/cli/harness-command.js

@@ -0,0 +1,50 @@
+import os from 'node:os';
+import { executeHarnessTarget, harnessTargets, } from '../harness.js';
+export const harnessCommand = {
+    parse(argv) {
+        const action = argv[0];
+        if (action !== 'install' && action !== 'uninstall' && action !== 'doctor') {
+            throw new Error('harness requires install, uninstall, or doctor');
+        }
+        const rest = argv.slice(1);
+        const option = rest.find((argument) => argument.startsWith('-') && argument !== '-f' && argument !== '--force');
+        if (option !== undefined)
+            throw new Error(`Unknown harness option: ${option}`);
+        return {
+            action,
+            target: rest.find((argument) => !argument.startsWith('-')),
+            force: rest.includes('-f') || rest.includes('--force'),
+        };
+    },
+    async execute(intent, context) {
+        if (intent.target === undefined && intent.action !== 'doctor') {
+            throw new Error('harness install/uninstall requires an explicit target: skills | claude | codex | opencode | pi');
+        }
+        const targetNames = intent.target === undefined
+            ? harnessTargets().map((target) => target.name)
+            : [intent.target];
+        const results = [];
+        for (const target of targetNames) {
+            results.push(await executeHarnessTarget(target, intent.action, {
+                homeDir: context.homeDir,
+                squarePath: context.squarePath,
+                force: intent.force,
+            }));
+        }
+        return {
+            notes: results.flatMap((result) => result.notes),
+            lines: results.flatMap((result) => result.lines),
+        };
+    },
+    present(result) {
+        process.stdout.write(formatHarnessResult(result));
+    },
+};
+export function formatHarnessResult(result) {
+    return `${[...result.notes, ...result.lines].join('\n')}\n`;
+}
+export function runHarnessCommand(argv, squarePath) {
+    const context = { homeDir: os.homedir(), squarePath: squarePath ?? '.square/SQUARE.md', command: 'harness' };
+    const intent = harnessCommand.parse(argv, context);
+    return Promise.resolve(harnessCommand.execute(intent, context)).then(formatHarnessResult);
+}

package/dist/cli/maintenance-commands.js

@@ -0,0 +1,76 @@
+import fs from 'node:fs';
+import { diagnoseSquare, loadSquare } from '../artifact.js';
+import { renderDoctorClean, renderDoctorProblems, renderDoctorRepaired, renderDoctorUnfixable, withPathOutput, } from '../presentation.js';
+import { inSquareCount } from '../runtime.js';
+import { repairSquare } from '../square-application.js';
+import { SquareError } from '../model.js';
+import { pruneRegistry } from '../registry.js';
+import { usage } from './context.js';
+function readSquareText(squarePath) {
+    try {
+        return fs.readFileSync(squarePath, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            throw new SquareError('not_found', `square file not found: ${squarePath}`);
+        throw error;
+    }
+}
+function quarantinePath(squarePath) {
+    return squarePath.replace(/\.md$/, '') + '.quarantine.md';
+}
+export const doctorCommand = {
+    parse(argv, context) {
+        let fix = false;
+        for (let index = 0; index < argv.length; index++) {
+            const argument = argv[index];
+            if (argument === '--fix')
+                fix = true;
+            else if (argument === '--before') {
+                index += 1;
+                if (argv[index] === undefined)
+                    usage(context.command);
+            }
+            else
+                usage(context.command);
+        }
+        return { fix };
+    },
+    async execute(intent, context) {
+        if (!intent.fix) {
+            const diagnosis = diagnoseSquare(readSquareText(context.squarePath));
+            if (diagnosis.unfixable) {
+                return {
+                    output: withPathOutput(context.squarePath, renderDoctorUnfixable(diagnosis.unfixable), { participantCount: inSquareCount(loadSquare(context.squarePath)) }),
+                    exitCode: 2,
+                };
+            }
+            const summary = diagnosis.problems.length === 0 ? renderDoctorClean() : renderDoctorProblems(diagnosis.problems);
+            return {
+                output: withPathOutput(context.squarePath, summary, { participantCount: inSquareCount(loadSquare(context.squarePath)) }),
+                exitCode: diagnosis.problems.length === 0 ? 0 : 1,
+            };
+        }
+        const repair = await repairSquare(context.squarePath);
+        if (repair.diagnosis.unfixable) {
+            return {
+                output: withPathOutput(context.squarePath, renderDoctorUnfixable(repair.diagnosis.unfixable), { participantCount: inSquareCount(loadSquare(context.squarePath)) }),
+                exitCode: 2,
+            };
+        }
+        const repaired = repair.repaired;
+        const registry = pruneRegistry();
+        if (registry.removed > 0) {
+            repaired.actions.push({ message: `pruned ${registry.removed} obsolete registry membership(s)` });
+        }
+        const sidecar = quarantinePath(context.squarePath);
+        return {
+            output: withPathOutput(context.squarePath, renderDoctorRepaired(repaired.actions, repaired.quarantinedBlocks.length, repaired.quarantinedBlocks.length > 0 ? sidecar : undefined), { participantCount: inSquareCount(loadSquare(context.squarePath)) }),
+        };
+    },
+    present(result) {
+        process.stdout.write(result.output);
+        if (result.exitCode !== undefined)
+            process.exit(result.exitCode);
+    },
+};

package/dist/cli/meta-commands.js

@@ -0,0 +1,28 @@
+import { renderGlobalHelp, renderSubcommandHelp } from '../help.js';
+import { SQUARE_IDENTITY } from '../identity.js';
+import { fail } from './context.js';
+export const helpCommand = {
+    parse(argv) {
+        if (argv.length > 1)
+            fail('Usage: square help [command]');
+        return { command: argv[0] };
+    },
+    execute(intent) {
+        if (intent.command === undefined)
+            return renderGlobalHelp();
+        const rendered = renderSubcommandHelp(intent.command);
+        if (rendered === undefined)
+            fail(`unknown command: ${intent.command}\nrun 'square help' to list available commands`);
+        return rendered;
+    },
+    present: (result) => process.stdout.write(result),
+};
+export const versionCommand = {
+    parse() {
+        return undefined;
+    },
+    execute() {
+        return `${SQUARE_IDENTITY.packageVersion}\n`;
+    },
+    present: (result) => process.stdout.write(result),
+};