@guildai/cli 0.11.0 → 0.12.0

package/dist/lib/owner-helpers.js

@@ -1,112 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Owner resolution helper for agent creation commands.
- *
- * Resolves the owner (user or organization) to use when creating agents.
- * Used by `guild agent init` and `guild agent fork`.
- *
- * Resolution priority:
- * 1. --owner flag (explicit)
- * 2. GUILD_OWNER_ID environment variable
- * 3. default_owner from ~/.guild/config.json
- * 4. Fetch user + orgs from API:
- *    - No orgs + non-interactive → use current user (single-account, stated explicitly)
- *    - No orgs + interactive → prompt with personal account as only choice
- *    - Has orgs + interactive → prompt to select from all accounts
- *    - Has orgs + non-interactive → error: require --owner flag
- */
-import inquirer from 'inquirer';
-import { loadGlobalConfig } from './guild-config.js';
-import { debug } from './errors.js';
-/**
- * Look up an owner by ID or name against the current user and their organizations.
- * Returns the resolved owner, or undefined if no match is found.
- */
-export async function lookupOwner(client, val) {
-    const me = await client.get('/me');
-    if (me.id === val || me.name === val) {
-        return { id: me.id, name: me.name, type: 'user' };
-    }
-    const orgs = await client.fetchAll('/me/organizations');
-    const org = orgs.find((o) => o.id === val || o.name === val);
-    if (org) {
-        return { id: org.id, name: org.name, type: 'organization' };
-    }
-    return undefined;
-}
-export async function resolveOwnerId(options) {
-    const { ownerFlag, client, interactive, requireExplicitOwner = false } = options;
-    // Priority 1: --owner flag
-    if (ownerFlag) {
-        debug('Using owner from --owner flag: %s', ownerFlag);
-        const match = await lookupOwner(client, ownerFlag);
-        if (match)
-            return match;
-        // Not found in user or orgs — pass through and let backend validate
-        return { id: ownerFlag, name: ownerFlag, type: 'organization' };
-    }
-    // Priority 2: GUILD_OWNER_ID environment variable
-    if (process.env.GUILD_OWNER_ID) {
-        debug('Using owner from GUILD_OWNER_ID env var: %s', process.env.GUILD_OWNER_ID);
-        const match = await lookupOwner(client, process.env.GUILD_OWNER_ID);
-        if (match)
-            return match;
-        // Not found in user or orgs — pass through and let backend validate
-        return {
-            id: process.env.GUILD_OWNER_ID,
-            name: process.env.GUILD_OWNER_ID,
-            type: 'organization',
-        };
-    }
-    // Priority 3: default_owner from config
-    const globalConfig = await loadGlobalConfig();
-    if (globalConfig?.default_owner) {
-        debug('Using owner from global config: %s', globalConfig.default_owner);
-        const match = await lookupOwner(client, globalConfig.default_owner);
-        if (match)
-            return match;
-        const name = globalConfig.default_owner_name || globalConfig.default_owner;
-        return { id: globalConfig.default_owner, name, type: 'organization' };
-    }
-    // Priority 4: Fetch user + orgs
-    const me = await client.get('/me');
-    const orgs = await client.fetchAll('/me/organizations');
-    // No orgs + non-interactive → use current user (single account, stated explicitly by caller)
-    if (orgs.length === 0 && !interactive) {
-        debug('No organizations found, using current user as owner');
-        return { id: me.id, name: me.name, type: 'user' };
-    }
-    // Has orgs + non-interactive
-    if (orgs.length > 0 && !interactive) {
-        if (requireExplicitOwner) {
-            debug('Non-interactive mode with multiple accounts available, requiring --owner');
-            throw new Error('Owner is required in non-interactive mode when multiple accounts are available.\n\n' +
-                'Use --owner <name-or-id> to specify an owner, or set a default:\n' +
-                '  guild config set default_owner <name-or-id>');
-        }
-        debug('Multiple accounts available, defaulting to current user');
-        return { id: me.id, name: me.name, type: 'user' };
-    }
-    // Interactive → prompt (always, even with single account)
-    const choices = [
-        {
-            name: `${me.name} (personal)`,
-            value: { id: me.id, name: me.name, type: 'user' },
-        },
-        ...orgs.map((org) => ({
-            name: org.name,
-            value: { id: org.id, name: org.name, type: 'organization' },
-        })),
-    ];
-    const { owner } = await inquirer.prompt([
-        {
-            type: 'list',
-            name: 'owner',
-            message: 'Select owner for this agent:',
-            choices,
-        },
-    ]);
-    return owner;
-}
-//# sourceMappingURL=owner-helpers.js.map

package/dist/lib/polling.js

@@ -1,76 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-import { GuildAPIClient } from './api-client.js';
-import { createSpinner } from './progress.js';
-/**
- * Poll an endpoint until a condition is met or timeout occurs
- *
- * @example
- * ```typescript
- * const result = await pollUntilComplete({
- *   resourceId: agentId,
- *   endpoint: `/agents/${agentId}`,
- *   isComplete: (response) => response.status === 'READY',
- *   message: 'Waiting for agent initialization...',
- *   successMessage: 'Agent initialization complete'
- * });
- *
- * if (result.success) {
- *   console.log('Agent is ready:', result.response);
- * }
- * ```
- */
-export async function pollUntilComplete(options) {
-    const { endpoint, isComplete, message = 'Waiting for operation to complete...', maxAttempts = 60, delayMs = 1000, successMessage = 'Operation complete', timeoutMessage = 'Operation timed out', onPoll, } = options;
-    const client = new GuildAPIClient();
-    const spinner = createSpinner(message);
-    spinner.start();
-    let attempts = 0;
-    let lastResponse;
-    for (attempts = 1; attempts <= maxAttempts; attempts++) {
-        await new Promise((resolve) => setTimeout(resolve, delayMs));
-        try {
-            const response = await client.get(endpoint);
-            lastResponse = response;
-            if (isComplete(response)) {
-                spinner.succeed(successMessage);
-                return {
-                    success: true,
-                    response,
-                    attempts,
-                };
-            }
-            // Update spinner with progress — prefer onPoll text when available
-            let spinnerText = null;
-            if (onPoll) {
-                try {
-                    spinnerText = await onPoll(response, attempts);
-                }
-                catch {
-                    // Silently ignore step-fetch errors; fall back to default text
-                }
-            }
-            spinner.text = spinnerText ?? `${message} (${attempts}/${maxAttempts})`;
-        }
-        catch {
-            // If we can't fetch the resource, continue polling
-            // Only fail on the last attempt
-            if (attempts === maxAttempts) {
-                spinner.warn('Could not verify operation status');
-                return {
-                    success: false,
-                    response: lastResponse,
-                    attempts,
-                };
-            }
-        }
-    }
-    // Timed out
-    spinner.warn(timeoutMessage);
-    return {
-        success: false,
-        response: lastResponse,
-        attempts,
-    };
-}
-//# sourceMappingURL=polling.js.map

package/dist/lib/progress.js

@@ -1,324 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-import ora from 'ora';
-import chalk from 'chalk';
-import { brand, warn as warnColor } from './colors.js';
-/**
- * Shared progress utilities for beautiful CLI UX
- *
- * Design Philosophy:
- * - Beautiful for humans, parseable for agents
- * - Interactive mode: Elegant spinners, clear status updates
- * - Non-interactive mode: Structured timestamped output
- * - All progress goes to stderr (keeps stdout clean for JSON)
- * - Respects NO_COLOR environment variable
- * - Respects --quiet flag (suppresses stderr output)
- * - --json mode still shows spinners (stderr is okay, stdout stays clean)
- */
-// Detect TTY mode and color support
-// Check stderr since spinners write to stderr
-const isTTY = process.stderr.isTTY || false;
-const useColor = !process.env.NO_COLOR;
-/**
- * Create a spinner for operations with unknown duration
- *
- * In TTY mode: Uses ora with elegant spinner animation
- * In non-TTY mode: Outputs timestamped messages to stderr
- * In quiet mode (--quiet): Returns no-op spinner (no output)
- *
- * Note: --json mode still shows spinners to stderr (use --quiet to suppress)
- *
- * @param text - Initial spinner text
- * @returns Spinner instance
- */
-export function createSpinner(text) {
-    // In quiet mode (--quiet), return no-op spinner
-    // Note: --json is NOT quiet by default (spinners to stderr are okay)
-    const isQuiet = process.argv.includes('--quiet') || process.argv.includes('-q');
-    if (isQuiet) {
-        let currentText = text;
-        return {
-            get text() {
-                return currentText;
-            },
-            set text(value) {
-                currentText = value;
-            },
-            start() {
-                // No-op
-            },
-            stop() {
-                // No-op
-            },
-            succeed() {
-                // No-op
-            },
-            fail() {
-                // No-op
-            },
-            warn() {
-                // No-op
-            },
-        };
-    }
-    if (isTTY) {
-        // Use ora in interactive mode
-        const spinner = ora({
-            text,
-            stream: process.stderr,
-            color: useColor ? 'blue' : undefined,
-        });
-        return {
-            get text() {
-                return spinner.text;
-            },
-            set text(value) {
-                spinner.text = value;
-            },
-            start() {
-                spinner.start();
-            },
-            stop() {
-                spinner.stop();
-            },
-            succeed(successText) {
-                // Show green checkmark with dim text (like Claude Code)
-                const textToShow = successText || spinner.text;
-                spinner.stopAndPersist({
-                    symbol: useColor ? chalk.green('✔') : '✔',
-                    text: useColor ? chalk.dim(textToShow) : textToShow,
-                });
-            },
-            fail(failText) {
-                spinner.fail(failText);
-            },
-            warn(warnText) {
-                spinner.warn(warnText);
-            },
-        };
-    }
-    else {
-        // Fallback for non-TTY mode (CI, scripts, etc.)
-        let currentText = text;
-        return {
-            get text() {
-                return currentText;
-            },
-            set text(value) {
-                currentText = value;
-                const timestamp = new Date().toLocaleTimeString();
-                process.stderr.write(`[${timestamp}] ${value}\n`);
-            },
-            start() {
-                const timestamp = new Date().toLocaleTimeString();
-                process.stderr.write(`[${timestamp}] ${currentText}\n`);
-            },
-            stop() {
-                // No-op in non-TTY mode
-            },
-            succeed(successText) {
-                const timestamp = new Date().toLocaleTimeString();
-                const message = successText || currentText;
-                process.stderr.write(`[${timestamp}] ${message}\n`);
-            },
-            fail(failText) {
-                const timestamp = new Date().toLocaleTimeString();
-                const message = failText || currentText;
-                process.stderr.write(`[${timestamp}] ${message}\n`);
-            },
-            warn(warnText) {
-                const timestamp = new Date().toLocaleTimeString();
-                const message = warnText || currentText;
-                process.stderr.write(`[${timestamp}] ${message}\n`);
-            },
-        };
-    }
-}
-/**
- * Create a multi-step progress tracker
- *
- * Tracks progress through a known sequence of steps, showing success/failure
- * for each step and a final summary.
- *
- * @param steps - Array of step names
- * @returns Steps instance
- */
-export function createSteps(steps) {
-    const stepStatus = new Map();
-    // Initialize all steps as pending
-    steps.forEach((step) => stepStatus.set(step, 'pending'));
-    const formatStep = (step, status, details) => {
-        let icon;
-        let formattedIcon;
-        switch (status) {
-            case 'success':
-                icon = '✓';
-                formattedIcon = useColor ? chalk.green(icon) : icon;
-                break;
-            case 'fail':
-                icon = '✗';
-                formattedIcon = useColor ? chalk.red(icon) : icon;
-                break;
-            case 'warn':
-                icon = '⚠';
-                formattedIcon = useColor ? warnColor(icon) : icon;
-                break;
-        }
-        let output = `${formattedIcon} ${step}`;
-        if (details) {
-            const detailColor = useColor ? chalk.dim : (text) => text;
-            output += `\n${detailColor(`  ${details}`)}`;
-        }
-        return output;
-    };
-    return {
-        start() {
-            // No-op for now, could show initial step list
-        },
-        succeed(step, details) {
-            stepStatus.set(step, 'success');
-            const output = formatStep(step, 'success', details);
-            if (isTTY) {
-                process.stderr.write(output + '\n');
-            }
-            else {
-                const timestamp = new Date().toLocaleTimeString();
-                process.stderr.write(`[${timestamp}] ${step}... done\n`);
-                if (details) {
-                    process.stderr.write(`[${timestamp}] ${details}\n`);
-                }
-            }
-        },
-        fail(step, details) {
-            stepStatus.set(step, 'fail');
-            const output = formatStep(step, 'fail', details);
-            if (isTTY) {
-                process.stderr.write(output + '\n');
-            }
-            else {
-                const timestamp = new Date().toLocaleTimeString();
-                process.stderr.write(`[${timestamp}] ${step}... failed\n`);
-                if (details) {
-                    process.stderr.write(`[${timestamp}] ${details}\n`);
-                }
-            }
-        },
-        warn(step, details) {
-            stepStatus.set(step, 'warn');
-            const output = formatStep(step, 'warn', details);
-            if (isTTY) {
-                process.stderr.write(output + '\n');
-            }
-            else {
-                const timestamp = new Date().toLocaleTimeString();
-                process.stderr.write(`[${timestamp}] ${step}... warning\n`);
-                if (details) {
-                    process.stderr.write(`[${timestamp}] ${details}\n`);
-                }
-            }
-        },
-        complete(summary) {
-            const successCount = Array.from(stepStatus.values()).filter((s) => s === 'success').length;
-            const totalCount = stepStatus.size;
-            const defaultSummary = `Completed (${successCount}/${totalCount} steps successful)`;
-            const message = summary || defaultSummary;
-            if (isTTY && useColor) {
-                const iconColor = successCount === totalCount ? chalk.green : warnColor;
-                process.stderr.write('\n' + iconColor('✓') + ' ' + message + '\n');
-            }
-            else {
-                const timestamp = new Date().toLocaleTimeString();
-                process.stderr.write(`[${timestamp}] ${message}\n`);
-            }
-        },
-    };
-}
-/**
- * Formatting helpers for consistent, beautiful output
- */
-export const format = {
-    /**
-     * Format a success message (green checkmark + white text)
-     */
-    success(message) {
-        if (isTTY && useColor) {
-            process.stderr.write(chalk.green('✓') + ' ' + message + '\n');
-        }
-        else {
-            process.stderr.write(`✓ ${message}\n`);
-        }
-    },
-    /**
-     * Format an error message (red X + text)
-     */
-    error(message) {
-        if (isTTY) {
-            const color = useColor ? chalk.red : (text) => text;
-            process.stderr.write(color(`✗ ${message}`) + '\n');
-        }
-        else {
-            process.stderr.write(`✗ ${message}\n`);
-        }
-    },
-    /**
-     * Format a warning message (yellow warning + text)
-     */
-    warn(message) {
-        if (isTTY) {
-            const color = useColor ? warnColor : (text) => text;
-            process.stderr.write(color(`⚠ ${message}`) + '\n');
-        }
-        else {
-            process.stderr.write(`⚠ ${message}\n`);
-        }
-    },
-    /**
-     * Format an info message (blue info + text)
-     */
-    info(message) {
-        if (isTTY) {
-            const color = useColor ? brand : (text) => text;
-            process.stderr.write(color(`ℹ ${message}`) + '\n');
-        }
-        else {
-            process.stderr.write(`ℹ ${message}\n`);
-        }
-    },
-    /**
-     * Format an indented detail line
-     */
-    detail(message) {
-        if (isTTY) {
-            const color = useColor ? chalk.dim : (text) => text;
-            process.stderr.write(color(`  ${message}`) + '\n');
-        }
-        else {
-            process.stderr.write(`  ${message}\n`);
-        }
-    },
-    /**
-     * Format a section header
-     */
-    section(message) {
-        if (isTTY) {
-            const color = useColor ? chalk.bold : (text) => text;
-            process.stderr.write('\n' + color(message) + '\n');
-        }
-        else {
-            process.stderr.write(`\n${message}\n`);
-        }
-    },
-    /**
-     * Format a code snippet
-     */
-    code(message) {
-        if (isTTY) {
-            const color = useColor ? chalk.dim : (text) => text;
-            process.stderr.write(color(`  ${message}`) + '\n');
-        }
-        else {
-            process.stderr.write(`  ${message}\n`);
-        }
-    },
-};
-//# sourceMappingURL=progress.js.map

package/dist/lib/session-events-fetch.js

@@ -1,25 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Fetch session events from the API.
- *
- * Uses from_id cursor so callers only fetch new events
- * instead of re-fetching everything on every poll cycle.
- */
-export async function fetchEvents(client, sessionId, options = {}) {
-    const { fromId, limit = 1000 } = options;
-    let url = `/sessions/${sessionId}/events?limit=${limit}`;
-    if (fromId) {
-        url += `&from_id=${fromId}`;
-    }
-    const response = await client.get(url);
-    return response?.items || [];
-}
-/**
- * Fetch session tasks from the API.
- */
-export async function fetchTasks(client, sessionId) {
-    const response = await client.get(`/sessions/${sessionId}/tasks?limit=1000`);
-    return response?.items || [];
-}
-//# sourceMappingURL=session-events-fetch.js.map

package/dist/lib/session-events.js

@@ -1,126 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-// =============================================================================
-// Task Filtering
-// =============================================================================
-/**
- * Internal task names that should be hidden from user-facing displays.
- * These are coordination/UI mechanisms, not meaningful tasks to show.
- *
- * - ui_notify: Internal notification dispatch
- * - ui_prompt: User input prompts (shown via dedicated UI, not task panel)
- * - __submit__: Internal message submission
- * - guild_credentials_request: Credential configuration prompts (shown via dedicated UI)
- */
-export const FILTERED_TASK_NAMES = new Set([
-    'ui_notify',
-    'ui_prompt',
-    '__submit__',
-    'guild_credentials_request',
-]);
-/** Check if a task/tool name should be filtered from display */
-export function isFilteredTaskName(name) {
-    return FILTERED_TASK_NAMES.has(name);
-}
-// =============================================================================
-// Task Utility Functions
-// =============================================================================
-/** Check if task is an agent task (has agent property) */
-export function isAgentTask(task) {
-    return 'agent' in task;
-}
-/** Check if task is a tool task (has tool_name property) */
-export function isToolTask(task) {
-    return 'tool_name' in task;
-}
-/** Extract display name from an agent reference */
-export function getAgentName(agent) {
-    return agent?.full_name || 'assistant';
-}
-/**
- * Check if a task's agent matches a target agent identifier.
- *
- * Target format: "@scope/owner~name" (e.g. "@guildai/guildai~agent-builder") or simple name ("assistant")
- * AgentRef format: { name: "agent-builder", full_name: "guildai~agent-builder", ... }
- */
-export function matchesAgent(taskAgent, targetAgent) {
-    if (!taskAgent)
-        return false;
-    // Direct name match for simple identifiers like "assistant"
-    if (taskAgent.name === targetAgent)
-        return true;
-    // Normalize target to match full_name format:
-    // 1. Strip npm scope prefix: "@scope/owner~name" -> "owner~name"
-    // 2. Convert slash separator to tilde: "owner/name" -> "owner~name"
-    if (taskAgent.full_name) {
-        const normalized = targetAgent.replace(/^@[^/]+\//, '').replace('/', '~');
-        if (taskAgent.full_name === normalized)
-            return true;
-    }
-    return false;
-}
-/** Get display name for a task - agent name or tool name */
-export function getTaskDisplayName(task) {
-    if (isAgentTask(task)) {
-        return getAgentName(task.agent);
-    }
-    if (isToolTask(task)) {
-        return task.tool_name;
-    }
-    return 'Unknown';
-}
-/** Get task type label */
-export function getTaskTypeLabel(task) {
-    if (isAgentTask(task)) {
-        return 'Agent';
-    }
-    if (isToolTask(task)) {
-        return 'Tool';
-    }
-    return 'Task';
-}
-/** Check if event is an unfulfilled agent install request */
-export function isUnfulfilledAgentInstallRequest(event) {
-    return event.type === 'agent_install_request' && !event.is_fulfilled;
-}
-/** Check if event is an unfulfilled credentials request */
-export function isUnfulfilledCredentialsRequest(event) {
-    return event.type === 'credentials_request' && !event.is_fulfilled;
-}
-/** Check if an agent notification message is a transient response stream draft. */
-export function isResponseStreamEvent(event) {
-    return (event.type === 'agent_notification_message' &&
-        event.content.type === 'application/guild-response-stream');
-}
-/** Check if a response stream event carries the final generated text. */
-export function isDoneResponseStreamEvent(event) {
-    return isResponseStreamEvent(event) && event.content.status === 'done';
-}
-/** Apply a response-stream payload to the accumulated display text. */
-export function applyResponseStreamText(currentText, content) {
-    return content.is_delta ? currentText + content.text : content.text;
-}
-/** Extract display text from notification content. */
-export function getAgentNotificationText(event) {
-    if (event.content.type === 'text') {
-        return event.content.data;
-    }
-    if (event.content.type === 'application/guild-response-stream') {
-        return event.content.text;
-    }
-    if (event.content.type === 'multipart/mixed' && event.content.parts.length === 1) {
-        const part = event.content.parts[0];
-        return part.type === 'text' && typeof part.data === 'string' ? part.data : '';
-    }
-    return '';
-}
-/** Check if an event belongs to the root task or has no task context. */
-export function isRootTaskEvent(event) {
-    const task = event.task;
-    if (!task)
-        return true;
-    if ('parent_task_id' in task)
-        return task.parent_task_id === null;
-    return task.parent_task === null;
-}
-//# sourceMappingURL=session-events.js.map