@guildai/cli 0.9.0 → 0.10.0

package/dist/commands/agent/chat.d.ts

@@ -1,3 +1,4 @@
 import { Command } from 'commander';
 export declare function createAgentChatCommand(): Command;
+export declare function handleAgentChatAction(_promptArgs: string[], _options: Record<string, unknown>): Promise<void>;
 //# sourceMappingURL=chat.d.ts.map

package/dist/commands/agent/chat.js

@@ -19,6 +19,7 @@ import * as readline from 'readline';
 import { pollForResponse } from '../../lib/session-polling.js';
 import { readStdinAsJSON, ensureInteractiveStdin } from '../../lib/stdin.js';
 import { fetchSession, fetchSessionEvents } from '../../lib/session-resume.js';
+import { getWorkspaceId, getWorkspaceSourceLabel } from '../../lib/guild-config.js';
 // ESM equivalent of __dirname
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // Read version from package.json
@@ -103,9 +104,26 @@ export function createAgentChatCommand() {
                 const sessionPrompt = options.mode === 'json' && inputData
                     ? JSON.stringify(inputData)
                     : initialPrompt;
-                const session = await createSession(client, options.workspace, sessionPrompt, version.id);
+                // Pre-resolve workspace so we can show the source label in output.
+                // When --workspace is given explicitly, no source label is shown.
+                let resolvedWorkspaceId = options.workspace;
+                let workspaceSourceLabel;
+                if (!resolvedWorkspaceId) {
+                    const wsResolved = await getWorkspaceId(resolvedPath);
+                    resolvedWorkspaceId = wsResolved?.workspaceId;
+                    workspaceSourceLabel = wsResolved
+                        ? getWorkspaceSourceLabel(wsResolved.source)
+                        : undefined;
+                }
+                const session = await createSession(client, resolvedWorkspaceId, sessionPrompt, version.id);
                 if (!quiet) {
                     console.log(`✓ Agent: ${config?.name || agentId}`);
+                    if (session.workspace_id) {
+                        const workspaceDisplay = workspaceSourceLabel
+                            ? `${session.workspace_id} (from ${workspaceSourceLabel})`
+                            : session.workspace_id;
+                        console.log(`✓ Workspace: ${workspaceDisplay}`);
+                    }
                     const sessionLink = session.session_url
                         ? hyperlink(session.id, session.session_url)
                         : session.id;
@@ -252,4 +270,9 @@ export function createAgentChatCommand() {
     });
     return cmd;
 }
+// Thin wrapper for lazy-loading from index.ts (avoids importing React at startup)
+export async function handleAgentChatAction(_promptArgs, _options) {
+    const cmd = createAgentChatCommand();
+    await cmd.parseAsync(process.argv.slice(3), { from: 'user' });
+}
 //# sourceMappingURL=chat.js.map

package/dist/commands/agent/fork.js

@@ -143,6 +143,7 @@ export function createAgentForkCommand() {
                 ownerFlag: options.owner,
                 client,
                 interactive: isInteractive(),
+                requireExplicitOwner: true,
             });
             // Create forked agent
             output.progress(`✓ Forking agent '${agentName}'...`);

package/dist/commands/agent/init.js

@@ -1,7 +1,6 @@
 // Copyright 2026 Guild.ai
 // SPDX-License-Identifier: Apache-2.0
 import { Command } from 'commander';
-import inquirer from 'inquirer';
 import { GuildAPIClient } from '../../lib/api-client.js';
 import { handleAxiosError, ErrorCodes } from '../../lib/errors.js';
 import { createSteps, createSpinner, format } from '../../lib/progress.js';
@@ -61,6 +60,7 @@ async function promptForName(defaultName) {
     return ask();
 }
 async function promptForTemplate() {
+    const { default: inquirer } = await import('inquirer');
     const { template } = await inquirer.prompt([
         {
             type: 'list',
@@ -192,6 +192,7 @@ export function createAgentInitCommand() {
                 ownerFlag: options.owner,
                 client,
                 interactive: isInteractive(),
+                requireExplicitOwner: true,
             });
             const agent = await client.post('/agents', {
                 name: agentName,

package/dist/commands/agent/list.js

@@ -6,6 +6,7 @@ import { getAuthToken } from '../../lib/auth.js';
 import { handleAxiosError, ErrorCodes } from '../../lib/errors.js';
 import { getOutputMode } from '../../lib/output-mode.js';
 import { createOutputWriter, formatAgentTable } from '../../lib/output.js';
+import { DEFAULT_PAGE_LIMIT } from '../../lib/api-types.js';
 const SORT_MAP = {
     updated: 'updated_at',
     newest: 'created_at',
@@ -23,8 +24,8 @@ export function createAgentListCommand() {
         .option('--all', 'Show all agents including archived')
         .option('--owner <name>', 'Filter by owner (user or org name). Without this flag, lists your own agents')
         .option('--workspace <id>', 'Filter agents by workspace ID or name')
-        .option('--limit <number>', 'Number of results to return', '20')
-        .option('--offset <number>', 'Offset for pagination', '0')
+        .option('--limit <number>', `Number of results to return (default: ${DEFAULT_PAGE_LIMIT})`, String(DEFAULT_PAGE_LIMIT))
+        .option('--offset <number>', 'Offset for pagination (default: 0)', '0')
         .action(async (options) => {
         const output = createOutputWriter();
         if (options.archived && options.all) {

package/dist/commands/agent/pull.js

@@ -13,7 +13,7 @@ export function createAgentPullCommand() {
     const cmd = new Command('pull');
     cmd
         .description('Pull remote changes into local agent directory')
-        .option('--json', 'Output JSON only (no progress messages)', false)
+        .option('--json', 'Output JSON only, no progress messages (default: off)', false)
         .action(async (_options) => {
         const cwd = process.cwd();
         const output = createOutputWriter();

package/dist/commands/agent/save.js

@@ -16,11 +16,11 @@ export function createAgentSaveCommand() {
         .description('Commit, push, and create a new agent version')
         .option('-A, --all', 'Stage all changes and commit before pushing', false)
         .option('-m, --message <text>', 'Commit message (required with --all)')
-        .option('--wait', 'Wait for validation to complete before returning', false)
-        .option('--publish', 'Publish after validation passes (implies --wait)', false)
-        .option('--bump [level]', 'Bump package.json version before saving (patch, or minor/major)', 'patch')
+        .option('--wait', 'Wait for validation to complete before returning (default: returns immediately)', false)
+        .option('--publish', 'Publish after validation passes (implies --wait) (default: does not publish)', false)
+        .option('--bump [level]', 'Bump package.json version before saving (patch, or minor/major) (default: patch)', 'patch')
         .option('--no-bump', 'Skip automatic version bump')
-        .option('--json', 'Output JSON only (no progress messages)', false)
+        .option('--json', 'Output JSON only, no progress messages (default: off)', false)
         .action(async (options) => {
         const cwd = process.cwd();
         let guildConfig = null;

package/dist/commands/agent/search.js

@@ -6,6 +6,7 @@ import { getAuthToken } from '../../lib/auth.js';
 import { handleAxiosError } from '../../lib/errors.js';
 import { getOutputMode } from '../../lib/output-mode.js';
 import { createOutputWriter, formatAgentTable } from '../../lib/output.js';
+import { DEFAULT_PAGE_LIMIT } from '../../lib/api-types.js';
 const SORT_MAP = {
     updated: 'updated_at',
     newest: 'created_at',
@@ -19,8 +20,8 @@ export function createAgentSearchCommand() {
         .argument('<query>', 'Search query')
         .option('--sort <field>', 'Sort by: updated, newest, name, popular (default: updated)', 'updated')
         .option('--published', 'Only show published agents')
-        .option('--limit <number>', 'Number of results to return', '20')
-        .option('--offset <number>', 'Offset for pagination', '0')
+        .option('--limit <number>', `Number of results to return (default: ${DEFAULT_PAGE_LIMIT})`, String(DEFAULT_PAGE_LIMIT))
+        .option('--offset <number>', 'Offset for pagination (default: 0)', '0')
         .action(async (query, options) => {
         const output = createOutputWriter();
         try {

package/dist/commands/agent/test.d.ts

@@ -1,3 +1,4 @@
 import { Command } from 'commander';
 export declare function createAgentTestCommand(): Command;
+export declare function handleAgentTestAction(_options: Record<string, unknown>): Promise<void>;
 //# sourceMappingURL=test.d.ts.map

package/dist/commands/agent/test.js

@@ -12,14 +12,14 @@ import { hyperlink } from '../../lib/colors.js';
 import { GuildAPIClient } from '../../lib/api-client.js';
 import { handleAxiosError, ErrorCodes } from '../../lib/errors.js';
 import { format } from '../../lib/progress.js';
-import * as readline from 'readline';
 import { parseEventFilter } from '../../lib/event-filter.js';
 import { isQuietMode, getOutputMode } from '../../lib/output-mode.js';
-import { pollForResponseWithEvents } from '../../lib/session-polling.js';
-import { readStdinAsJSON, ensureInteractiveStdin } from '../../lib/stdin.js';
-import { loadLocalConfig, getWorkspaceId } from '../../lib/guild-config.js';
+import { pollForResponse, pollForResponseWithEvents, } from '../../lib/session-polling.js';
+import { readStdinAsJSON, readStdinAsText, ensureInteractiveStdin, } from '../../lib/stdin.js';
+import { loadLocalConfig, getWorkspaceId, getWorkspaceSourceLabel, } from '../../lib/guild-config.js';
 import { GitError, formatGitError } from '../../lib/git.js';
 import { readAgentFiles, buildEphemeralVersion, buildBundledVersion, BundleNotFoundError, BuildTimeoutError, BuildFailedError, } from '../../lib/agent-helpers.js';
+import { validateInputSchema } from '../../lib/validate-input-schema.js';
 import { fetchSession, fetchSessionEvents } from '../../lib/session-resume.js';
 import { ChatApp, ensureAuthenticated } from '../chat.js';
 import { suppressScrollbackClear } from '../../lib/alternate-screen.js';
@@ -36,13 +36,15 @@ export function createAgentTestCommand() {
         .option('--agent-version <id>', 'Test a specific version (UUID or version number)')
         .option('--resume <session-id>', 'Resume an existing test session')
         .option('--open', 'Open session in web dashboard')
-        .option('--events <types>', 'Event types to stream (default: all). Shorthands: none, user, system, all, or comma-separated type names')
+        .option('--events <types>', 'Event types to stream (default: user). Shorthands: none, user, system, all, or comma-separated type names')
         .option('--bundle <file>', 'Path to a pre-built gzip+base64 bundle file')
         .option('--no-cache', 'Skip ephemeral build cache (force a fresh build)')
         .action(async (options) => {
         const cwd = process.cwd();
-        // Parse --events filter once, before any branching (default: all)
-        const eventFilter = parseEventFilter(options.events ?? 'all');
+        // Parse --events filter once, before any branching
+        const eventFilter = options.events
+            ? parseEventFilter(options.events)
+            : undefined;
         try {
             // Handle --resume: skip build, fetch existing session, hand off to ChatApp
             if (options.resume) {
@@ -81,9 +83,10 @@ export function createAgentTestCommand() {
                 console.error('  guild agent clone <agent-id>');
                 process.exit(1);
             }
-            // If using JSON input, read and validate it early (before auth/session creation)
-            // This provides better UX - fail fast on bad JSON without needing auth
+            // If using JSON/JSONL input, read and validate it early (before auth/session creation)
+            // This provides better UX - fail fast on bad input without needing auth
             let inputData;
+            let jsonlInputs;
             if (options.mode === 'json') {
                 try {
                     inputData = await readStdinAsJSON();
@@ -98,6 +101,57 @@ export function createAgentTestCommand() {
                     process.exit(1);
                 }
             }
+            else if (options.mode === 'jsonl') {
+                try {
+                    const stdinContent = await readStdinAsText();
+                    jsonlInputs = [];
+                    const lines = stdinContent.split('\n');
+                    for (let i = 0; i < lines.length; i++) {
+                        const line = lines[i].trim();
+                        if (!line)
+                            continue;
+                        try {
+                            jsonlInputs.push(JSON.parse(line));
+                        }
+                        catch {
+                            console.error(`Error: Invalid JSON on line ${i + 1}`);
+                            console.error('');
+                            console.error('Each line must be valid JSON.');
+                            console.error('  cat inputs.jsonl | guild agent test --mode jsonl');
+                            process.exit(1);
+                        }
+                    }
+                    if (jsonlInputs.length === 0) {
+                        console.error('Error: No JSON input provided');
+                        console.error('');
+                        console.error('Example usage:');
+                        console.error('  cat inputs.jsonl | guild agent test --mode jsonl');
+                        process.exit(1);
+                    }
+                }
+                catch (error) {
+                    const err = error;
+                    console.error(`Error: ${err.message}`);
+                    process.exit(1);
+                }
+            }
+            // Validate input against agent's schema locally (before build)
+            // Skip when --agent-version is set since local source may differ from that version
+            const inputsToValidate = inputData !== undefined ? [inputData] : (jsonlInputs ?? []);
+            if (inputsToValidate.length > 0 && !options.agentVersion) {
+                const validationResult = await validateInputSchema(cwd, inputsToValidate);
+                if (!validationResult.valid) {
+                    console.error('Input validation failed:');
+                    for (const err of validationResult.errors) {
+                        const pathStr = err.path?.length ? ` (at ${err.path.join('.')})` : '';
+                        console.error(`  - ${err.message}${pathStr}`);
+                    }
+                    process.exit(1);
+                }
+                if ('skipped' in validationResult && validationResult.skipped) {
+                    format.warn(`Skipping local validation: ${validationResult.reason}`);
+                }
+            }
             // If using bundle, verify the file exists early (before auth/session creation)
             // so we fail fast without needing auth if the path is wrong.
             if (options.bundle) {
@@ -115,9 +169,13 @@ export function createAgentTestCommand() {
             }
             // Determine workspace (priority: flag > local config > global config)
             let workspaceId = options.workspace;
+            let workspaceSourceLabel;
             if (!workspaceId) {
                 const resolved = await getWorkspaceId(cwd);
                 workspaceId = resolved?.workspaceId;
+                workspaceSourceLabel = resolved
+                    ? getWorkspaceSourceLabel(resolved.source)
+                    : undefined;
                 if (!workspaceId) {
                     console.error('Error: No default workspace configured');
                     console.error('');
@@ -249,7 +307,10 @@ export function createAgentTestCommand() {
                             ? 'ephemeral (cached, no changes)'
                             : 'ephemeral (working directory)';
                 console.log(`✓ Version: ${versionDisplay}`);
-                console.log(`✓ Workspace: ${workspaceId}`);
+                const workspaceDisplay = workspaceSourceLabel
+                    ? `${workspaceId} (from ${workspaceSourceLabel})`
+                    : workspaceId;
+                console.log(`✓ Workspace: ${workspaceDisplay}`);
                 const sessionLink = session.session_url
                     ? hyperlink(session.id, session.session_url)
                     : session.id;
@@ -270,7 +331,9 @@ export function createAgentTestCommand() {
                     });
                     // Poll for response (starting from beginning)
                     // 3 minutes - allow time for agents that use LLM calls for input parsing
-                    const { response } = await pollForResponseWithEvents(client, session.id, eventFilter, undefined, 180000);
+                    const { response } = eventFilter
+                        ? await pollForResponseWithEvents(client, session.id, eventFilter, undefined, 180000)
+                        : await pollForResponse(client, session.id, undefined, 180000);
                     if (!response) {
                         console.error('Error: No response received from agent within timeout');
                         console.error('');
@@ -321,41 +384,33 @@ export function createAgentTestCommand() {
                     process.exit(1);
                 }
             }
-            else if (options.mode === 'jsonl') {
-                // JSONL input mode: line-by-line processing
-                const rl = readline.createInterface({
-                    input: process.stdin,
-                    output: process.stdout,
-                    terminal: false,
-                });
-                let lineNumber = 0;
+            else if (options.mode === 'jsonl' && jsonlInputs) {
+                // JSONL input mode: line-by-line processing (inputs already parsed and validated)
                 let processedCount = 0;
                 let lastEventId;
-                for await (const line of rl) {
-                    lineNumber++;
-                    if (!line.trim())
-                        continue; // Skip empty lines
+                for (let inputIndex = 0; inputIndex < jsonlInputs.length; inputIndex++) {
+                    const jsonInput = jsonlInputs[inputIndex];
+                    if (!quiet) {
+                        console.error(`Processing input ${inputIndex + 1}/${jsonlInputs.length}...`);
+                    }
                     try {
-                        const jsonInput = JSON.parse(line);
-                        if (!quiet) {
-                            console.error(`Processing line ${lineNumber}...`);
-                        }
                         // Send message
                         await client.post(`/sessions/${session.id}/events`, {
                             mode: 'json',
                             content: jsonInput,
                         });
                         // Wait for response (looking for events after last seen)
-                        const result = await pollForResponseWithEvents(client, session.id, eventFilter, lastEventId, 180000);
+                        const result = eventFilter
+                            ? await pollForResponseWithEvents(client, session.id, eventFilter, lastEventId, 180000)
+                            : await pollForResponse(client, session.id, lastEventId, 180000);
                         lastEventId = result.lastEventId;
                         if (!result.response) {
-                            console.error(`Timeout: No response for line ${lineNumber}`);
+                            console.error(`Timeout: No response for input ${inputIndex + 1}`);
                             continue;
                         }
                         const response = result.response;
                         // Output response
                         if (quiet) {
-                            // In quiet mode, output just the message content (or as JSON if --json is used)
                             console.log(response);
                         }
                         else {
@@ -365,10 +420,8 @@ export function createAgentTestCommand() {
                         processedCount++;
                     }
                     catch (error) {
-                        const err = error;
-                        console.error(`Error: Invalid JSON on line ${lineNumber}`);
-                        console.error(`Failed to parse JSON: ${err.message}`);
-                        console.error('Skipping line and continuing...');
+                        const formattedErr = handleAxiosError(error);
+                        console.error(`Error processing input ${inputIndex + 1}: ${formattedErr.details}`);
                     }
                 }
                 if (!quiet) {
@@ -425,4 +478,9 @@ export function createAgentTestCommand() {
     });
     return cmd;
 }
+// Thin wrapper for lazy-loading from index.ts (avoids importing React at startup)
+export async function handleAgentTestAction(_options) {
+    const cmd = createAgentTestCommand();
+    await cmd.parseAsync(process.argv.slice(3), { from: 'user' });
+}
 //# sourceMappingURL=test.js.map

package/dist/commands/agent/versions.js

@@ -7,13 +7,14 @@ import { handleAxiosError, ErrorCodes } from '../../lib/errors.js';
 import { getAgentId, resolveAgentRef } from '../../lib/agent-helpers.js';
 import { getOutputMode } from '../../lib/output-mode.js';
 import { createOutputWriter, formatVersionTable } from '../../lib/output.js';
+import { DEFAULT_PAGE_LIMIT } from '../../lib/api-types.js';
 export function createAgentVersionsCommand() {
     const cmd = new Command('versions');
     cmd
         .description('List all versions of an agent')
         .argument('[identifier]', 'Agent ID or full name (e.g., owner~agent-name)')
-        .option('--limit <number>', 'Maximum number of versions to return', '20')
-        .option('--offset <number>', 'Number of versions to skip', '0')
+        .option('--limit <number>', `Maximum number of versions to return (default: ${DEFAULT_PAGE_LIMIT})`, String(DEFAULT_PAGE_LIMIT))
+        .option('--offset <number>', 'Number of versions to skip (default: 0)', '0')
         .action(async (agentIdArg, options) => {
         const output = createOutputWriter();
         // Get agent ID from argument or guild.json

package/dist/commands/agent/workspaces.js

@@ -7,13 +7,14 @@ import { handleAxiosError, ErrorCodes } from '../../lib/errors.js';
 import { getAgentId, resolveAgentRef } from '../../lib/agent-helpers.js';
 import { createOutputWriter, formatWorkspaceTable } from '../../lib/output.js';
 import { getOutputMode } from '../../lib/output-mode.js';
+import { DEFAULT_PAGE_LIMIT } from '../../lib/api-types.js';
 export function createAgentWorkspacesCommand() {
     const cmd = new Command('workspaces');
     cmd
         .description('List workspaces that use an agent')
         .argument('[identifier]', 'Agent ID or full name (e.g., owner~agent-name)')
-        .option('--limit <number>', 'Maximum number of workspaces to return', '20')
-        .option('--offset <number>', 'Number of workspaces to skip', '0')
+        .option('--limit <number>', `Maximum number of workspaces to return (default: ${DEFAULT_PAGE_LIMIT})`, String(DEFAULT_PAGE_LIMIT))
+        .option('--offset <number>', 'Number of workspaces to skip (default: 0)', '0')
         .action(async (agentIdArg, options) => {
         const output = createOutputWriter();
         const { agentId } = await getAgentId(agentIdArg);

package/dist/commands/chat.d.ts

@@ -2,6 +2,15 @@ import React from 'react';
 import { Command } from 'commander';
 import { GuildAPIClient } from '../lib/api-client.js';
 import { SessionEvent, Session } from '../lib/session-events.js';
+/** Thrown when no workspace is configured (no --workspace flag, no config). */
+export declare class WorkspaceNotConfiguredError extends Error {
+    constructor();
+}
+/** Thrown when the specified workspace ID is not found in the backend. */
+export declare class WorkspaceNotFoundError extends Error {
+    readonly workspaceId: string;
+    constructor(workspaceId: string);
+}
 /**
  * ChatApp wrapper component that shows splash animation during connection
  * and then transitions to ChatUIWithConnection once connected.
@@ -23,4 +32,5 @@ export declare function ChatApp({ initialPrompt, version, workspaceId, versionId
 export declare function ensureAuthenticated(): Promise<string>;
 export declare function createSession(client: GuildAPIClient, workspaceId: string | undefined, initialPrompt: string, versionId?: string, onProgress?: (status: string) => void): Promise<Session>;
 export declare function createChatCommand(): Command;
+export declare function handleChatAction(_promptArgs: string[], _options: Record<string, unknown>): Promise<void>;
 //# sourceMappingURL=chat.d.ts.map