@astrosheep/square 0.3.12 → 0.3.13

package/dist/cli/context.d.ts

@@ -0,0 +1,35 @@
+import { type HardCap } from '../model.js';
+export declare const DEFAULT_SQUARE_PATH = ".square/SQUARE.square";
+export interface CommandContext {
+    squarePath: string;
+    name?: string;
+    homeDir: string;
+    command: string;
+}
+export interface CommandSpec<Intent = unknown, Result = void> {
+    parse(argv: string[], context: CommandContext): Intent;
+    execute(intent: Intent, context: CommandContext): Promise<Result> | Result;
+    present(result: Result, context: CommandContext): void;
+}
+export declare function readStdinSync(): string;
+export declare function resolveBody(arg: string): string;
+export declare function readPipedBodyFallback(): string | undefined;
+export declare function fail(message: string, exitCode?: number): never;
+export declare function usage(command: string): never;
+export declare function requireValue(args: string[], index: number, flag: string): string;
+export declare function parseDurationMs(value: string, flag: string): number;
+export declare function parsePositiveInteger(value: string, flag: string): number;
+export declare function parseNonNegativeInteger(value: string, flag: string): number;
+export declare function parseHardCap(value: string): HardCap;
+export declare function parseNameList(value: string, flag: string): string[];
+export declare function requireParticipant(name: string | undefined): string;
+export interface ParsedGlobalArgs {
+    squarePath: string;
+    explicitSquarePath: boolean;
+    multipleSquares: boolean;
+    name?: string;
+    args: string[];
+}
+export declare function parseGlobalArgs(rawArgs: string[]): ParsedGlobalArgs;
+export declare function locationIsRequired(command: string): boolean;
+export declare function defaultContext(command: string, squarePath: string, name?: string): CommandContext;

package/dist/cli/context.js

@@ -1,9 +1,8 @@
 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';
+import { localParticipantName } from '../registry.js';
 export const DEFAULT_SQUARE_PATH = '.square/SQUARE.square';
 export function readStdinSync() {
     try {
@@ -88,30 +87,17 @@ export function requireParticipant(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('.square'))
-            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 };
+const LOCATION_REQUIRED_COMMANDS = new Set(['join', 'catch', 'express', 'done', 'hold', 'resume']);
+function configuredLocation() {
+    const value = process.env.SQUARE_LOCATION?.trim();
+    return value === '' ? undefined : value;
+}
+function configuredName() {
+    const value = process.env.SQUARE_PARTICIPANT_NAME?.trim();
+    if (!value)
+        return undefined;
+    validateName(value);
+    return value;
 }
 export function parseGlobalArgs(rawArgs) {
     const args = [...rawArgs];
@@ -129,14 +115,23 @@ export function parseGlobalArgs(rawArgs) {
             index -= 1;
         }
     }
+    if (name === undefined)
+        name = configuredName();
     if (name !== undefined)
         validateName(name);
     const explicitSquarePath = requestedPath !== undefined;
     const command = args[0];
-    const resolved = !explicitSquarePath && !['ls', 'list', 'version', 'install', 'uninstall'].includes(command ?? '')
-        ? resolveDefaultSquarePath()
-        : { path: requestedPath ?? DEFAULT_SQUARE_PATH, multiple: false };
-    return { squarePath: resolved.path, explicitSquarePath, multipleSquares: resolved.multiple, name, args };
+    const configured = configuredLocation();
+    if (command !== undefined && !['--help', '-h'].includes(command) && locationIsRequired(command) && requestedPath === undefined && configured === undefined) {
+        fail(`✕ ${command} needs a square location\n» square ls`);
+    }
+    const squarePath = requestedPath ?? configured ?? DEFAULT_SQUARE_PATH;
+    if (name === undefined && command !== undefined && locationIsRequired(command))
+        name = localParticipantName(squarePath);
+    return { squarePath, explicitSquarePath: explicitSquarePath || configured !== undefined, multipleSquares: false, name, args };
+}
+export function locationIsRequired(command) {
+    return LOCATION_REQUIRED_COMMANDS.has(command);
 }
 export function defaultContext(command, squarePath, name) {
     return { command, squarePath, name, homeDir: os.homedir() };

package/dist/cli/harness-command.d.ts

@@ -0,0 +1,28 @@
+import { executeHarnessTarget, type HarnessAction } from '../harness.js';
+import { type CommandSpec } from './context.js';
+export type HarnessCommandAction = HarnessAction;
+export interface ParsedHarnessCommand {
+    target?: string;
+}
+export interface ParsedInstallCommand {
+    targets: string[];
+    all: boolean;
+    force: boolean;
+}
+export interface HarnessCommandResult {
+    lines: string[];
+    notes: string[];
+    failures: string[];
+}
+type HarnessTargetExecutor = typeof executeHarnessTarget;
+export declare function executeTargetBatch(targets: string[], action: 'install' | 'uninstall', context: {
+    homeDir: string;
+    squarePath?: string;
+    force: boolean;
+}, executeTarget?: HarnessTargetExecutor): Promise<HarnessCommandResult>;
+export declare const installCommand: CommandSpec<ParsedInstallCommand, HarnessCommandResult>;
+export declare const uninstallCommand: CommandSpec<ParsedInstallCommand, HarnessCommandResult>;
+export declare const harnessCommand: CommandSpec<ParsedHarnessCommand, HarnessCommandResult>;
+export declare function formatHarnessResult(result: HarnessCommandResult): string;
+export declare function runHarnessCommand(argv: string[], squarePath?: string): Promise<string>;
+export {};

package/dist/cli/harness-command.js

@@ -26,24 +26,38 @@ function parseInstall(argv, action) {
         throw new Error(`Cannot combine ${action} --all with named targets`);
     return { targets, all, force };
 }
+export async function executeTargetBatch(targets, action, context, executeTarget = executeHarnessTarget) {
+    const results = [];
+    const failures = [];
+    for (const target of targets) {
+        try {
+            results.push(await executeTarget(target, action, context));
+        }
+        catch (error) {
+            failures.push(`✕ ${target} ${action} failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return {
+        notes: results.flatMap((result) => result.notes),
+        lines: results.flatMap((result) => result.lines),
+        failures,
+    };
+}
 function targetCommand(action) {
     return {
         parse(argv) { return parseInstall(argv, action); },
         async execute(intent, context) {
-            const results = [];
-            for (const target of installTargets(intent, action)) {
-                results.push(await executeHarnessTarget(target, action, {
-                    homeDir: context.homeDir,
-                    squarePath: context.squarePath,
-                    force: intent.force,
-                }));
-            }
-            return {
-                notes: results.flatMap((result) => result.notes),
-                lines: results.flatMap((result) => result.lines),
-            };
+            return executeTargetBatch(installTargets(intent, action), action, {
+                homeDir: context.homeDir,
+                squarePath: context.squarePath,
+                force: intent.force,
+            });
+        },
+        present(result) {
+            process.stdout.write(formatHarnessResult(result));
+            if (result.failures.length > 0)
+                process.exitCode = 1;
         },
-        present(result) { process.stdout.write(formatHarnessResult(result)); },
     };
 }
 export const installCommand = targetCommand('install');
@@ -77,6 +91,7 @@ export const harnessCommand = {
         return {
             notes: results.flatMap((result) => result.notes),
             lines: results.flatMap((result) => result.lines),
+            failures: [],
         };
     },
     present(result) {
@@ -84,7 +99,7 @@ export const harnessCommand = {
     },
 };
 export function formatHarnessResult(result) {
-    return `${[...result.notes, ...result.lines].join('\n')}\n`;
+    return `${[...result.notes, ...result.lines, ...result.failures].join('\n')}\n`;
 }
 export function runHarnessCommand(argv, squarePath) {
     const context = { homeDir: os.homedir(), squarePath: squarePath ?? '.square/SQUARE.square', command: 'harness' };

package/dist/cli/maintenance-commands.d.ts

@@ -0,0 +1,7 @@
+import { type CommandSpec } from './context.js';
+interface DoctorResult {
+    output: string;
+    exitCode?: number;
+}
+export declare const doctorCommand: CommandSpec<undefined, DoctorResult>;
+export {};

package/dist/cli/maintenance-commands.js

@@ -1,4 +1,4 @@
-import { diagnoseSquareFile } from '../artifact.js';
+import { diagnoseSquareFile } from '../square-storage.js';
 import { renderDoctorClean, renderDoctorUnfixable, withPathOutput } from '../presentation.js';
 import { inSquareCount } from '../runtime.js';
 import { usage } from './context.js';
@@ -10,7 +10,7 @@ export const doctorCommand = {
     },
     execute(_intent, context) {
         const diagnosis = diagnoseSquareFile(context.squarePath);
-        if (diagnosis.unfixable !== undefined || diagnosis.doc === undefined) {
+        if (diagnosis.unfixable !== undefined || diagnosis.state === undefined) {
             return {
                 output: withPathOutput(context.squarePath, renderDoctorUnfixable(diagnosis.unfixable ?? 'the snapshot could not be decoded')),
                 exitCode: 2,
@@ -18,7 +18,7 @@ export const doctorCommand = {
         }
         return {
             output: withPathOutput(context.squarePath, renderDoctorClean(), {
-                participantCount: inSquareCount(diagnosis.doc),
+                participantCount: inSquareCount(diagnosis.state),
             }),
         };
     },

package/dist/cli/meta-commands.d.ts

@@ -0,0 +1,5 @@
+import { type CommandSpec } from './context.js';
+export declare const helpCommand: CommandSpec<{
+    command?: string;
+}, string>;
+export declare const versionCommand: CommandSpec<undefined, string>;

package/dist/cli/observation-commands.d.ts

@@ -0,0 +1,20 @@
+import { type ActivitiesOptions, type WatchOptions } from '../model.js';
+import { type CommandSpec } from './context.js';
+export declare const listCommand: CommandSpec<string[]>;
+interface StreamIntent {
+    ndjson: boolean;
+    forName?: string;
+}
+export declare const streamCommand: CommandSpec<StreamIntent>;
+export declare const catchCommand: CommandSpec<WatchOptions>;
+export declare const historyCommand: CommandSpec<ActivitiesOptions, string>;
+export declare const participantsCommand: CommandSpec<undefined, string>;
+export declare const statusCommand: CommandSpec<undefined, string>;
+interface InboxIntent {
+    sessionId: string;
+    json: boolean;
+}
+export declare const inboxCommand: CommandSpec<InboxIntent, string>;
+export declare const claudeHookCommand: CommandSpec<undefined, string>;
+export declare const codexHookCommand: CommandSpec<undefined, string>;
+export {};