agent-tempo 1.0.1

package/dist/tools/worktree.js

@@ -0,0 +1,181 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerWorktreeTool = registerWorktreeTool;
+const zod_1 = require("zod");
+const resolve_1 = require("./resolve");
+const signals_1 = require("../workflows/signals");
+const helpers_1 = require("./helpers");
+const worktree_1 = require("../utils/worktree");
+const validation_1 = require("../utils/validation");
+function registerWorktreeTool(server, client, config, handle, getPlayerId) {
+    (0, helpers_1.defineTool)(server, 'worktree', 'Manage git worktrees for player isolation. Conductor only. Actions: create (provision worktree for a player), remove (clean up), list (show active worktrees). Use when multiple players commit to different branches of the same repo simultaneously; skip for read-only work, sequential work, or tasks under ~5 min. IMPORTANT: before `remove`, have the player stop any long-running processes inside the worktree (dev servers, file watchers) — on Windows a memory-mapped native module will block directory removal and `remove` will fail. See docs/orchestration.md#when-to-use-worktrees.', {
+        action: zod_1.z.enum(['create', 'remove', 'list']).describe('Action to perform'),
+        player: zod_1.z.string().max(validation_1.PLAYER_NAME_MAX).optional().describe('Player name (required for create/remove)'),
+        branch: zod_1.z.string().optional().describe('Git branch for the worktree (defaults to {ensemble}/{player-name})'),
+    }, async (args) => {
+        const { action, player, branch } = args;
+        try {
+            switch (action) {
+                case 'create': {
+                    if (!player) {
+                        return (0, helpers_1.fail)('`player` is required for create action.');
+                    }
+                    // Verify player exists
+                    const targetHandle = await (0, resolve_1.resolveSession)(client, config.ensemble, player);
+                    if (!targetHandle) {
+                        return (0, helpers_1.fail)(`No active session found for "${player}".`);
+                    }
+                    // Check target is on same host (cross-machine worktrees not supported)
+                    const targetMeta = await targetHandle.query('getMetadata');
+                    const { hostname } = await Promise.resolve().then(() => __importStar(require('os'))).then((os) => ({ hostname: os.hostname() }));
+                    if (targetMeta.hostname && targetMeta.hostname !== hostname) {
+                        return (0, helpers_1.fail)(`Cannot create worktree for "${player}" — they are on host "${targetMeta.hostname}" but worktrees must be created locally.`);
+                    }
+                    const gitRoot = process.cwd();
+                    const result = (0, worktree_1.createWorktree)({
+                        gitRoot,
+                        ensemble: config.ensemble,
+                        playerName: player,
+                        branch,
+                    });
+                    if (result.created) {
+                        (0, worktree_1.installDependencies)(result.path);
+                    }
+                    // Record in conductor's worktree state
+                    const entry = {
+                        player,
+                        path: result.path,
+                        branch: result.branch,
+                        gitRoot,
+                        createdAt: new Date().toISOString(),
+                        createdBy: getPlayerId(),
+                    };
+                    await handle.signal('setWorktree', entry);
+                    // Auto-cue the player with worktree info
+                    const cueMessage = [
+                        `\u{1f33f} **Worktree ready** for your task:`,
+                        `- **Path**: \`${result.path}\``,
+                        `- **Branch**: \`${result.branch}\``,
+                        '',
+                        `Run \`cd ${result.path}\` to switch to your isolated workspace.`,
+                        `All your changes will be on branch \`${result.branch}\`.`,
+                        `When done, commit and push \u2014 the conductor will handle cleanup.`,
+                    ].join('\n');
+                    await handle.executeUpdate(signals_1.submitOutboxUpdate, {
+                        args: [{
+                                type: 'cue',
+                                targetPlayerId: player,
+                                message: cueMessage,
+                            }],
+                    });
+                    // #261: when we reused an existing worktree directory, surface the
+                    // actual state transition (same branch / switched / created-from-main)
+                    // so the conductor sees ground truth instead of the prior silent
+                    // "reused existing" that implied the worktree was already on the
+                    // requested branch.
+                    const createdLabel = result.created
+                        ? 'new'
+                        : (() => {
+                            switch (result.switched) {
+                                case 'same':
+                                    return `reused existing (already on \`${result.branch}\`)`;
+                                case 'switched':
+                                    return `reused existing (switched to \`${result.branch}\`)`;
+                                case 'created-from-main':
+                                    return `reused existing (created \`${result.branch}\` from origin/main)`;
+                                default:
+                                    return 'reused existing';
+                            }
+                        })();
+                    return (0, helpers_1.ok)(`Worktree created for **${player}**:\n- Path: \`${result.path}\`\n- Branch: \`${result.branch}\`\n- Created: ${createdLabel}\n\nPlayer has been notified.`);
+                }
+                case 'remove': {
+                    if (!player) {
+                        return (0, helpers_1.fail)('`player` is required for remove action.');
+                    }
+                    // Look up worktree entry from conductor state
+                    const entries = await handle.query('worktrees');
+                    const entry = entries.find((w) => w.player === player);
+                    if (!entry) {
+                        return (0, helpers_1.fail)(`No worktree found for player "${player}".`);
+                    }
+                    // Remove from disk. #594: removeWorktree throws if the directory
+                    // survives the removal (Windows file-lock half-removal). We must
+                    // NOT signal `removeWorktree` state or cue the player until disk
+                    // removal is confirmed — otherwise Temporal state records "no
+                    // worktree" while a locked orphan directory remains on disk, and
+                    // the next `create` fails with a confusing git fatal.
+                    try {
+                        (0, worktree_1.removeWorktree)(entry.path, entry.gitRoot);
+                    }
+                    catch (err) {
+                        return (0, helpers_1.fail)(`Worktree for **${player}** could not be removed: ${(0, helpers_1.formatError)(err)}\n\n` +
+                            `Conductor state is unchanged — the worktree is still tracked. ` +
+                            `Have the player stop any long-running processes inside the worktree ` +
+                            `(dev servers, file watchers), then retry \`worktree remove\`.`);
+                    }
+                    // Remove from conductor state (only reached on confirmed disk removal)
+                    await handle.signal('removeWorktree', player);
+                    // Auto-cue the player
+                    try {
+                        await handle.executeUpdate(signals_1.submitOutboxUpdate, {
+                            args: [{
+                                    type: 'cue',
+                                    targetPlayerId: player,
+                                    message: `Worktree removed. You're back in the shared repository.`,
+                                }],
+                        });
+                    }
+                    catch {
+                        // Player may no longer be active — non-fatal
+                    }
+                    return (0, helpers_1.ok)(`Worktree for **${player}** removed (branch: \`${entry.branch}\`).`);
+                }
+                case 'list': {
+                    const entries = await handle.query('worktrees');
+                    if (entries.length === 0) {
+                        return (0, helpers_1.ok)('No active worktrees.');
+                    }
+                    const lines = entries.map((w) => `- **${w.player}**: \`${w.path}\` (branch: \`${w.branch}\`, created: ${w.createdAt} by ${w.createdBy})`);
+                    return (0, helpers_1.ok)(`${entries.length} active worktree${entries.length === 1 ? '' : 's'}:\n${lines.join('\n')}`);
+                }
+            }
+        }
+        catch (err) {
+            return (0, helpers_1.fail)(`Worktree operation failed: ${(0, helpers_1.formatError)(err)}`);
+        }
+    });
+}

package/dist/tui/App.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Root TUI application component — chat-focused shell with slash commands.
+ *
+ * Layout (top to bottom):
+ * - TitleBar (pinned)
+ * - Divider
+ * - Static scroll-up history
+ * - Live content area (splash, main, chat, error)
+ * - Divider
+ * - PromptArea (pinned)
+ */
+import React from 'react';
+import type { TuiState } from './store';
+import type { TempoClient } from '../client';
+interface AppProps {
+    api: TempoClient;
+    /** If provided, start directly in ensemble view. */
+    ensemble?: string;
+    /** Default agent type from config (defaults to 'claude'). */
+    defaultAgent?: 'claude' | 'copilot';
+}
+export declare function App({ api, ensemble, defaultAgent }: AppProps): React.ReactSVGElement | React.FunctionComponentElement<React.FragmentProps>;
+/**
+ * #306: Strip a leading kind-icon (`✗ `, `⚠ `, `ⓘ `) from notification
+ * content. Defensive: many call sites historically prepended the icon into
+ * the message string, and the renderer also prepends a kind-based icon —
+ * without this normalization the user sees the icon twice (e.g.
+ * `✗ ✗ Cannot destroy the conductor …`). Exported for unit testing.
+ */
+export declare function stripLeadingIcon(content: string): string;
+/**
+ * #306: True when the TUI is on the home picker view — `phase === 'main'`
+ * AND `view === 'home'`. The chat input has no target on this view (the
+ * ensemble has not been entered yet), and HomeView owns Enter to navigate
+ * its own row list. Render guard for PromptArea + the second divider so
+ * the input cannot double-fire alongside HomeView's own `useInput`.
+ *
+ * Pure function, exported so tests can pin the guard's logic without
+ * standing up an Ink render. Mirrors the splash-phase bypass pattern.
+ */
+export declare function isHomeView(state: Pick<TuiState, 'phase' | 'view'>): boolean;
+/**
+ * #306: Build the pinned-confirmation line(s) for the current state. Returns
+ * an array (possibly empty) of `{ key, text }` entries — one per active
+ * `confirming*` state field. Rendered above the notifications stack by
+ * `renderPinnedConfirmations` and sized by `countPinnedConfirmationLines`
+ * so `FOOTER_LINES` reserves terminal rows correctly.
+ *
+ * Pure function, exported for unit testing — no Ink imports, no dispatch.
+ * The render helper below is the only caller that wraps these in Text nodes.
+ */
+export declare function pinnedConfirmationLines(state: Pick<TuiState, 'confirmingStop' | 'confirmingStopReason' | 'confirmingDisband' | 'confirmingEnsembleDestroy' | 'confirmingLineup'>): Array<{
+    key: string;
+    text: string;
+}>;
+/**
+ * #306: Count of pinned confirmation lines — one per active `confirming*`
+ * state field. Consumed by the `FOOTER_LINES` reservation so the live
+ * content area shrinks when a confirmation is active, keeping the pinned
+ * prompt on-screen.
+ */
+export declare function countPinnedConfirmationLines(state: Pick<TuiState, 'confirmingStop' | 'confirmingStopReason' | 'confirmingDisband' | 'confirmingEnsembleDestroy' | 'confirmingLineup'>): number;
+/**
+ * #306 follow-up: Build the pinned tip line for the current paused/held
+ * state. Returns `null` when neither flag is set — no tip should render.
+ *
+ * The tip appears below the input prompt in a dim color (informational,
+ * not an error or warning) and tells the user which slash commands they
+ * need to fully resume the ensemble. `/load_lineup` flips both flags;
+ * `/play` clears only paused; `/go` clears only held — without this
+ * tip users would unpause an ensemble and stare at frozen players.
+ *
+ * Pure function, exported for unit testing — no Ink imports.
+ */
+export declare function pinnedTipLine(state: Pick<TuiState, 'ensemblePaused' | 'ensembleHeld' | 'activeEnsemble'>): {
+    key: string;
+    text: string;
+} | null;
+/**
+ * Count of pinned tip lines (0 or 1). Mirrors
+ * {@link countPinnedConfirmationLines} so `FOOTER_LINES` can reserve a
+ * row for the tip without re-evaluating the state shape twice.
+ */
+export declare function countPinnedTipLines(state: Pick<TuiState, 'ensemblePaused' | 'ensembleHeld' | 'activeEnsemble'>): number;
+export {};