@guildai/cli 0.3.17 → 0.4.0

package/dist/commands/agent/chat.js

@@ -19,7 +19,7 @@ import { runGit } from '../../lib/git.js';
 import { suppressScrollbackClear } from '../../lib/alternate-screen.js';
 import * as readline from 'readline';
 import { pollForResponse } from '../../lib/session-polling.js';
-import { readStdinAsJSON } from '../../lib/stdin.js';
+import { readStdinAsJSON, ensureInteractiveStdin } from '../../lib/stdin.js';
 import { fetchSession, fetchSessionEvents } from '../../lib/session-resume.js';
 // ESM equivalent of __dirname
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -266,6 +266,7 @@ export function createAgentChatCommand() {
             else {
                 // Interactive mode: use shared ChatApp with full features
                 // (splash animation, task panel, status line, etc.)
+                ensureInteractiveStdin('guild agent chat');
                 const resumeCommand = 'guild agent chat';
                 // Handle --resume: fetch existing session + events
                 let resumeSession;

package/dist/commands/agent/clone.js

@@ -4,25 +4,9 @@ import { GuildAPIClient } from '../../lib/api-client.js';
 import { handleAxiosError, ErrorCodes } from '../../lib/errors.js';
 import * as fs from 'fs/promises';
 import * as path from 'path';
-import * as readline from 'readline';
 import { getAuthenticatedUrl } from '../../lib/auth.js';
 import { runGit, GitError, formatGitError } from '../../lib/git.js';
 import { createOutputWriter } from '../../lib/output.js';
-async function promptForDirectory(suggestedDir) {
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
-    return new Promise((resolve) => {
-        rl.question(`Target directory (default: ${suggestedDir}): `, (answer) => {
-            rl.close();
-            resolve(answer.trim() || suggestedDir);
-        });
-    });
-}
-function isInteractive() {
-    return process.stdin.isTTY === true;
-}
 async function isDirectoryEmpty(dirPath) {
     try {
         const files = await fs.readdir(dirPath);
@@ -51,18 +35,8 @@ export function createAgentCloneCommand() {
                 process.exit(1);
             }
             output.progress(`✓ Fetched agent '${agent.name}' (${agent.id})`);
-            // Determine target directory
-            let targetDir = options.directory;
-            if (!targetDir) {
-                if (isInteractive()) {
-                    const suggestedDir = `./${agent.name}`;
-                    targetDir = await promptForDirectory(suggestedDir);
-                }
-                else {
-                    output.error('Error: Target directory required in non-interactive mode', `Provide a directory:\n  guild agent clone ${agentId} --directory ./my-agent\n\nOr run interactively to be prompted.`);
-                    process.exit(1);
-                }
-            }
+            // Determine target directory (default to agent name, like git clone)
+            const targetDir = options.directory || agent.name;
             // Check if directory exists and is not empty
             const dirExists = await fs
                 .access(targetDir)

package/dist/commands/agent/init.js

@@ -64,15 +64,23 @@ function isInteractive() {
 export function createAgentInitCommand() {
     const cmd = new Command('init');
     cmd
-        .description('Initialize current directory as a Guild agent')
+        .description('Initialize a directory as a Guild agent')
         .option('--name <name>', 'Agent name')
         .option('--template <template>', 'Agent template (LLM, AUTO_MANAGED_STATE, BLANK)')
         .option('--fork <agent-id>', 'Fork from existing agent')
         .option('--owner <owner-id>', 'Owner account (user or organization ID)')
+        .option('--directory <path>', 'Directory to initialize (created if needed)')
         .option('--force', 'Overwrite existing guild.json', false)
         .action(async (options) => {
-        const cwd = process.cwd();
-        const guildJsonPath = path.join(cwd, 'guild.json');
+        // Resolve target directory
+        const targetDir = options.directory
+            ? path.resolve(process.cwd(), options.directory)
+            : process.cwd();
+        // Create directory if it doesn't exist
+        if (options.directory) {
+            await fs.mkdir(targetDir, { recursive: true });
+        }
+        const guildJsonPath = path.join(targetDir, 'guild.json');
         try {
             // Check if already initialized
             const guildJsonExists = await fs
@@ -93,7 +101,7 @@ export function createAgentInitCommand() {
             if (!agentName) {
                 if (isInteractive()) {
                     // Use slugified directory name as default
-                    const dirName = path.basename(cwd);
+                    const dirName = path.basename(targetDir);
                     const defaultName = slugify(dirName);
                     agentName = await promptForName(defaultName);
                     if (!agentName) {
@@ -176,13 +184,13 @@ export function createAgentInitCommand() {
             format.detail(`Agent: ${agent.name} (${agent.id})`);
             format.detail(`Owner: ${owner.name}`);
             // Step 2: Initialize git repository if needed
-            const gitDir = path.join(cwd, '.git');
+            const gitDir = path.join(targetDir, '.git');
             const gitExists = await fs
                 .access(gitDir)
                 .then(() => true)
                 .catch(() => false);
             if (!gitExists) {
-                await runGit(['init'], { cwd });
+                await runGit(['init'], { cwd: targetDir });
                 steps.succeed('Initialize git repository');
             }
             else {
@@ -192,13 +200,17 @@ export function createAgentInitCommand() {
             // Step 3: Configure git remote
             try {
                 // Check if remote 'origin' exists
-                await runGit(['remote', 'get-url', 'origin'], { cwd });
+                await runGit(['remote', 'get-url', 'origin'], { cwd: targetDir });
                 // Remote exists, update it
-                await runGit(['remote', 'set-url', 'origin', agent.git_url], { cwd });
+                await runGit(['remote', 'set-url', 'origin', agent.git_url], {
+                    cwd: targetDir,
+                });
             }
             catch {
                 // Remote doesn't exist, add it
-                await runGit(['remote', 'add', 'origin', agent.git_url], { cwd });
+                await runGit(['remote', 'add', 'origin', agent.git_url], {
+                    cwd: targetDir,
+                });
             }
             steps.succeed('Configure git remote');
             format.detail(`Remote: ${agent.git_url}`);
@@ -242,7 +254,7 @@ export function createAgentInitCommand() {
                 console.error(`  guild agent get ${agent.id}`);
                 console.error('');
                 console.error('Or wait and try pulling the scaffolding manually:');
-                console.error(`  cd ${cwd}`);
+                console.error(`  cd ${targetDir}`);
                 console.error('  git pull origin main');
                 process.exit(1);
             }
@@ -258,7 +270,7 @@ export function createAgentInitCommand() {
             }
             for (let attempt = 1; attempt <= pullMaxAttempts; attempt++) {
                 try {
-                    await runGit(['pull', authenticatedGitUrl, 'main'], { cwd });
+                    await runGit(['pull', authenticatedGitUrl, 'main'], { cwd: targetDir });
                     steps.succeed('Pull scaffolding from remote');
                     break;
                 }
@@ -288,7 +300,7 @@ export function createAgentInitCommand() {
             await fs.writeFile(guildJsonPath, JSON.stringify(guildConfig, null, 2) + '\n', 'utf-8');
             steps.succeed('Create guild.json');
             // Add guild.json to .gitignore if not already present
-            const gitignorePath = path.join(cwd, '.gitignore');
+            const gitignorePath = path.join(targetDir, '.gitignore');
             try {
                 const gitignoreContent = await fs.readFile(gitignorePath, 'utf-8');
                 if (!gitignoreContent.includes('guild.json')) {
@@ -303,9 +315,17 @@ export function createAgentInitCommand() {
             steps.complete('Agent initialized successfully');
             // Display next steps
             format.section('Next steps:');
-            format.detail('1. Edit agent.ts to implement your agent logic');
-            format.detail(`2. Run 'guild agent save --message "Initial implementation"'`);
-            format.detail(`3. Run 'guild agent test' to test your agent`);
+            if (options.directory) {
+                format.detail(`1. cd ${targetDir}`);
+                format.detail('2. Edit agent.ts to implement your agent logic');
+                format.detail(`3. Run 'guild agent save --message "Initial implementation"'`);
+                format.detail(`4. Run 'guild agent test' to test your agent`);
+            }
+            else {
+                format.detail('1. Edit agent.ts to implement your agent logic');
+                format.detail(`2. Run 'guild agent save --message "Initial implementation"'`);
+                format.detail(`3. Run 'guild agent test' to test your agent`);
+            }
         }
         catch (error) {
             if (error instanceof GitError) {

package/dist/commands/agent/list.js

@@ -3,7 +3,8 @@ import { Command } from 'commander';
 import { GuildAPIClient } from '../../lib/api-client.js';
 import { getAuthToken } from '../../lib/auth.js';
 import { handleAxiosError } from '../../lib/errors.js';
-import { createOutputWriter } from '../../lib/output.js';
+import { getOutputMode } from '../../lib/output-mode.js';
+import { createOutputWriter, formatAgentTable } from '../../lib/output.js';
 const SORT_MAP = {
     updated: 'updated_at',
     newest: 'created_at',
@@ -42,7 +43,12 @@ export function createAgentListCommand() {
                 params.append('sort_by', sortField);
             }
             const response = await client.get(`/agents?${params.toString()}`);
-            output.data(response);
+            if (getOutputMode() === 'json') {
+                output.data(response);
+            }
+            else {
+                formatAgentTable(response.items, response.pagination);
+            }
         }
         catch (error) {
             const formattedError = handleAxiosError(error);

package/dist/commands/agent/save.js

@@ -2,6 +2,7 @@
 import { Command } from 'commander';
 import { GuildAPIClient } from '../../lib/api-client.js';
 import { handleAxiosError, ErrorCodes } from '../../lib/errors.js';
+import { getOutputMode } from '../../lib/output-mode.js';
 import { createOutputWriter } from '../../lib/output.js';
 import * as fs from 'fs/promises';
 import * as path from 'path';
@@ -254,8 +255,12 @@ export function createAgentSaveCommand() {
                 output.progress('To publish this version:');
                 output.progress('  guild agent save --message "..." --publish');
             }
-            // Output JSON to stdout for programmatic use
-            output.data({ version });
+            // Output JSON to stdout only in --json mode.
+            // In interactive mode the progress messages above already
+            // show version details; dumping raw JSON is noise.
+            if (getOutputMode() === 'json') {
+                output.data({ version });
+            }
         }
         catch (error) {
             if (error instanceof GitError) {

package/dist/commands/agent/search.js

@@ -3,7 +3,8 @@ import { Command } from 'commander';
 import { GuildAPIClient } from '../../lib/api-client.js';
 import { getAuthToken } from '../../lib/auth.js';
 import { handleAxiosError } from '../../lib/errors.js';
-import { createOutputWriter } from '../../lib/output.js';
+import { getOutputMode } from '../../lib/output-mode.js';
+import { createOutputWriter, formatAgentTable } from '../../lib/output.js';
 const SORT_MAP = {
     updated: 'updated_at',
     newest: 'created_at',
@@ -40,7 +41,12 @@ export function createAgentSearchCommand() {
                 params.append('sort_by', sortField);
             }
             const response = await client.get(`/agents?${params.toString()}`);
-            output.data(response);
+            if (getOutputMode() === 'json') {
+                output.data(response);
+            }
+            else {
+                formatAgentTable(response.items, response.pagination);
+            }
         }
         catch (error) {
             const formattedError = handleAxiosError(error);

package/dist/commands/agent/test.js

@@ -14,7 +14,7 @@ import { showBetaGuidance } from '../../lib/auth.js';
 import * as readline from 'readline';
 import { isQuietMode, getOutputMode } from '../../lib/output-mode.js';
 import { pollForResponse } from '../../lib/session-polling.js';
-import { readStdinAsJSON } from '../../lib/stdin.js';
+import { readStdinAsJSON, ensureInteractiveStdin } from '../../lib/stdin.js';
 import { loadLocalConfig, getWorkspaceId } from '../../lib/guild-config.js';
 import { runGit, GitError, formatGitError } from '../../lib/git.js';
 import { pollUntilComplete } from '../../lib/polling.js';
@@ -415,6 +415,7 @@ export function createAgentTestCommand() {
                 process.exit(0);
             }
             // Interactive mode: use shared ChatApp (spinner, progress, prompt)
+            ensureInteractiveStdin('guild agent test');
             const resumeCommand = 'guild agent test';
             const isInteractive = getOutputMode() === 'interactive' && !isQuietMode();
             if (isInteractive) {

package/dist/commands/agent/versions.js

@@ -4,7 +4,8 @@ import { GuildAPIClient } from '../../lib/api-client.js';
 import { getGuildcoreUrl } from '../../lib/config.js';
 import { handleAxiosError, ErrorCodes } from '../../lib/errors.js';
 import { getAgentId } from '../../lib/agent-helpers.js';
-import { createOutputWriter } from '../../lib/output.js';
+import { getOutputMode } from '../../lib/output-mode.js';
+import { createOutputWriter, formatVersionTable } from '../../lib/output.js';
 export function createAgentVersionsCommand() {
     const cmd = new Command('versions');
     cmd
@@ -22,7 +23,12 @@ export function createAgentVersionsCommand() {
         const offset = parseInt(options.offset, 10);
         try {
             const result = await client.get(`/agents/${agentId}/versions?limit=${limit}&offset=${offset}`);
-            output.data(result);
+            if (getOutputMode() === 'json') {
+                output.data(result);
+            }
+            else {
+                formatVersionTable(result.items, result.pagination);
+            }
         }
         catch (error) {
             const formattedError = handleAxiosError(error);

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

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function createAgentWorkspacesCommand(): Command;
+//# sourceMappingURL=workspaces.d.ts.map

package/dist/commands/agent/workspaces.js

@@ -0,0 +1,51 @@
+// Copyright (c) 2026 Guild.ai All Rights Reserved
+import { Command } from 'commander';
+import { GuildAPIClient } from '../../lib/api-client.js';
+import { getGuildcoreUrl } from '../../lib/config.js';
+import { handleAxiosError, ErrorCodes } from '../../lib/errors.js';
+import { getAgentId } from '../../lib/agent-helpers.js';
+import { createOutputWriter, formatWorkspaceTable } from '../../lib/output.js';
+import { getOutputMode } from '../../lib/output-mode.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')
+        .action(async (agentIdArg, options) => {
+        const output = createOutputWriter();
+        const { agentId } = await getAgentId(agentIdArg);
+        const baseUrl = getGuildcoreUrl();
+        const client = new GuildAPIClient({ baseUrl });
+        const limit = parseInt(options.limit, 10);
+        const offset = parseInt(options.offset, 10);
+        try {
+            const result = await client.get(`/agents/${agentId}/workspaces?limit=${limit}&offset=${offset}`);
+            if (getOutputMode() === 'json') {
+                output.data(result);
+            }
+            else {
+                formatWorkspaceTable(result.items, result.pagination);
+            }
+        }
+        catch (error) {
+            const formattedError = handleAxiosError(error);
+            if (formattedError.code === ErrorCodes.AUTH_REQUIRED) {
+                output.error('Not logged in.', 'Please authenticate first:\n  guild auth login');
+            }
+            else if (formattedError.code === ErrorCodes.CONN_REFUSED) {
+                output.error('Cannot connect to Guild servers');
+            }
+            else if (formattedError.code === ErrorCodes.NOT_FOUND) {
+                output.error(`Agent not found: ${agentId}`, 'Check the agent ID:\n  guild agent list');
+            }
+            else {
+                output.error(`Failed to list workspaces: ${formattedError.details}`);
+            }
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=workspaces.js.map

package/dist/commands/chat.js

@@ -16,6 +16,7 @@ import { isUnfulfilledAgentInstallRequest, isFilteredTaskName, getTaskDisplayNam
 import { printResumeHint, fetchSession, fetchSessionEvents, eventsToDisplayMessages, } from '../lib/session-resume.js';
 import { AgentInstallPrompt } from '../components/AgentInstallPrompt.js';
 import { getWorkspaceId } from '../lib/guild-config.js';
+import { ensureInteractiveStdin } from '../lib/stdin.js';
 import { brand, BRAND_COLOR, code as codeColor } from '../lib/colors.js';
 import { SplashAnimation } from '../components/SplashAnimation.js';
 import { LOADING_TIMINGS } from '../lib/loading-messages.js';
@@ -1062,6 +1063,7 @@ export function createChatCommand() {
         }
         else {
             // Interactive mode - check auth first, then render UI with splash animation
+            ensureInteractiveStdin('guild chat');
             await ensureAuthenticated();
             // Build the resume command string for exit hints
             let resumeCommand = 'guild chat';

package/dist/commands/workspace/agent/list.js

@@ -4,7 +4,8 @@ import { GuildAPIClient } from '../../../lib/api-client.js';
 import { getAuthToken } from '../../../lib/auth.js';
 import { getWorkspaceId } from '../../../lib/guild-config.js';
 import { handleAxiosError, ErrorCodes } from '../../../lib/errors.js';
-import { createOutputWriter } from '../../../lib/output.js';
+import { createOutputWriter, formatWorkspaceAgentTable } from '../../../lib/output.js';
+import { getOutputMode } from '../../../lib/output-mode.js';
 export function createWorkspaceAgentListCommand() {
     const cmd = new Command('list');
     cmd
@@ -36,12 +37,12 @@ export function createWorkspaceAgentListCommand() {
             params.append('limit', options.limit);
             params.append('offset', options.offset);
             const response = await client.get(`/workspaces/${workspaceId}/workspace_agents?${params.toString()}`);
-            const agents = response.items;
-            if (agents.length === 0) {
-                output.data({ items: [], message: 'No agents installed in this workspace.' });
-                return;
+            if (getOutputMode() === 'json') {
+                output.data(response);
+            }
+            else {
+                formatWorkspaceAgentTable(response.items);
             }
-            output.data(response);
         }
         catch (error) {
             const formattedError = handleAxiosError(error);

package/dist/commands/workspace/context/list.js

@@ -2,7 +2,8 @@
 import { Command } from 'commander';
 import { GuildAPIClient } from '../../../lib/api-client.js';
 import { handleAxiosError, ErrorCodes } from '../../../lib/errors.js';
-import { createOutputWriter } from '../../../lib/output.js';
+import { getOutputMode } from '../../../lib/output-mode.js';
+import { createOutputWriter, formatContextTable } from '../../../lib/output.js';
 export function createWorkspaceContextListCommand() {
     const cmd = new Command('list');
     cmd
@@ -18,7 +19,12 @@ export function createWorkspaceContextListCommand() {
             params.append('limit', options.limit);
             params.append('offset', options.offset);
             const response = await client.get(`/workspaces/${workspaceId}/contexts?${params.toString()}`);
-            output.data(response);
+            if (getOutputMode() === 'json') {
+                output.data(response);
+            }
+            else {
+                formatContextTable(response.items, response.pagination);
+            }
         }
         catch (error) {
             const formattedError = handleAxiosError(error);

package/dist/commands/workspace/context/publish.js

@@ -13,7 +13,7 @@ export function createWorkspaceContextPublishCommand() {
         const output = createOutputWriter();
         try {
             const client = new GuildAPIClient();
-            await client.patch(`/workspaces/${workspaceId}/contexts/${contextId}`, {
+            await client.patch(`/contexts/${contextId}`, {
                 status: 'PUBLISHED',
             });
             output.success(`Context ${contextId} published successfully`);

package/dist/index.js

@@ -28,6 +28,7 @@ import { createAgentUnpublishCommand } from './commands/agent/unpublish.js';
 import { createAgentRevalidateCommand } from './commands/agent/revalidate.js';
 import { createAgentSearchCommand } from './commands/agent/search.js';
 import { createAgentOwnersCommand } from './commands/agent/owners.js';
+import { createAgentWorkspacesCommand } from './commands/agent/workspaces.js';
 import { createAgentTagsListCommand } from './commands/agent/tags/list.js';
 import { createAgentTagsAddCommand } from './commands/agent/tags/add.js';
 import { createAgentTagsRemoveCommand } from './commands/agent/tags/remove.js';
@@ -66,6 +67,7 @@ import { createDoctorCommand } from './commands/doctor.js';
 import { createSetupCommand } from './commands/setup.js';
 import { showSplashScreen, shouldShowSplash } from './lib/splash.js';
 import { checkForUpdate } from './lib/update-check.js';
+import { setupUnknownCommandSuggestions } from './lib/did-you-mean.js';
 import chalk from 'chalk';
 // ESM equivalent of __dirname
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -131,6 +133,7 @@ agentCmd.addCommand(createAgentUnpublishCommand());
 agentCmd.addCommand(createAgentRevalidateCommand());
 agentCmd.addCommand(createAgentSearchCommand());
 agentCmd.addCommand(createAgentOwnersCommand());
+agentCmd.addCommand(createAgentWorkspacesCommand());
 // Agent tags subcommand group
 const tagsCmd = agentCmd.command('tags').description('Manage agent tags');
 tagsCmd.addCommand(createAgentTagsListCommand());
@@ -214,6 +217,8 @@ configCmd.addCommand(createConfigListCommand());
 configCmd.addCommand(createConfigGetCommand());
 configCmd.addCommand(createConfigSetCommand());
 configCmd.addCommand(createConfigPathCommand());
+// Set up cross-level "Did you mean?" suggestions for unknown commands
+setupUnknownCommandSuggestions(program);
 // Parse arguments
 program.parse(process.argv);
 //# sourceMappingURL=index.js.map

package/dist/lib/agent-helpers.js

@@ -66,8 +66,8 @@ export async function readAgentFiles(cwd) {
         const content = await fs.readFile(fullPath, 'utf-8');
         files.push({ path: filePath, content });
     }
-    const fileNames = files.map((f) => f.path);
-    const missing = REQUIRED_AGENT_FILES.filter((f) => !fileNames.includes(f));
+    const filePaths = files.map((f) => f.path);
+    const missing = REQUIRED_AGENT_FILES.filter((req) => !filePaths.some((fp) => fp === req || fp.endsWith(`/${req}`)));
     if (missing.length > 0) {
         throw new Error(`Missing required files: ${missing.join(', ')}`);
     }

package/dist/lib/did-you-mean.d.ts

@@ -0,0 +1,25 @@
+import { Command } from 'commander';
+interface CommandEntry {
+    path: string;
+    description: string;
+    leafName: string;
+}
+/**
+ * Recursively collects all commands from the command tree.
+ * Includes both leaf commands and command groups (parents with subcommands).
+ * Aliases are added as separate entries.
+ */
+export declare function getAllCommands(cmd: Command, prefix?: string): CommandEntry[];
+/**
+ * Standard Levenshtein distance between two strings.
+ */
+export declare function levenshtein(a: string, b: string): number;
+/**
+ * Sets up cross-level "Did you mean?" suggestions for unknown commands.
+ *
+ * Disables Commander's built-in same-level suggestions and intercepts
+ * "unknown command" errors to search the entire command tree.
+ */
+export declare function setupUnknownCommandSuggestions(program: Command): void;
+export {};
+//# sourceMappingURL=did-you-mean.d.ts.map

package/dist/lib/did-you-mean.js

@@ -0,0 +1,143 @@
+// Copyright (c) 2026 Guild.ai All Rights Reserved
+/**
+ * Recursively collects all commands from the command tree.
+ * Includes both leaf commands and command groups (parents with subcommands).
+ * Aliases are added as separate entries.
+ */
+export function getAllCommands(cmd, prefix = '') {
+    const results = [];
+    for (const sub of cmd.commands) {
+        const name = sub.name();
+        const cmdPath = prefix ? `${prefix} ${name}` : name;
+        const description = sub.description();
+        const hasChildren = sub.commands.length > 0;
+        // Always include this command (even if it has subcommands)
+        results.push({ path: cmdPath, description, leafName: name });
+        // If this command has subcommands, also recurse into them
+        if (hasChildren) {
+            results.push(...getAllCommands(sub, cmdPath));
+        }
+        // Add aliases as separate entries
+        for (const alias of sub.aliases()) {
+            const aliasPath = prefix ? `${prefix} ${alias}` : alias;
+            results.push({ path: aliasPath, description, leafName: alias });
+            if (hasChildren) {
+                results.push(...getAllCommands(sub, aliasPath));
+            }
+        }
+    }
+    return results;
+}
+/**
+ * Standard Levenshtein distance between two strings.
+ */
+export function levenshtein(a, b) {
+    const m = a.length;
+    const n = b.length;
+    // Use a single-row DP approach for space efficiency
+    const row = Array.from({ length: n + 1 }, (_, i) => i);
+    for (let i = 1; i <= m; i++) {
+        let prev = i - 1;
+        row[0] = i;
+        for (let j = 1; j <= n; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            const val = Math.min(row[j] + 1, // deletion
+            row[j - 1] + 1, // insertion
+            prev + cost // substitution
+            );
+            prev = row[j];
+            row[j] = val;
+        }
+    }
+    return row[n];
+}
+/**
+ * Recursively disables Commander's built-in suggestion on all commands.
+ */
+function disableBuiltinSuggestions(cmd) {
+    cmd.showSuggestionAfterError(false);
+    for (const sub of cmd.commands) {
+        disableBuiltinSuggestions(sub);
+    }
+}
+/**
+ * Creates the writeErr handler that intercepts "unknown command" errors
+ * and prints cross-level suggestions.
+ */
+function createWriteErrHandler(program) {
+    return (str) => {
+        // Always write the original error
+        process.stderr.write(str);
+        // Check if this is an "unknown command" error
+        const match = /unknown command '([^']+)'/.exec(str);
+        if (!match) {
+            return;
+        }
+        const unknown = match[1];
+        const allCommands = getAllCommands(program);
+        // Determine the typed parent context from process.argv
+        // e.g., "guild agent trigger" → typed args are ["agent", "trigger"]
+        const typedArgs = process.argv.slice(2);
+        const typedParent = typedArgs.slice(0, -1).join(' ');
+        // Score each command
+        const scored = allCommands.map((entry) => {
+            const leafName = entry.leafName;
+            // Exact leaf name match gets score 0
+            let score = leafName === unknown ? 0 : levenshtein(unknown, leafName);
+            // Context bonus: if command's parent matches typed parent, reduce score
+            const entryParts = entry.path.split(' ');
+            const entryParent = entryParts.slice(0, -1).join(' ');
+            if (entryParent === typedParent && score > 0) {
+                score -= 0.5;
+            }
+            return { ...entry, score };
+        });
+        // Filter poor matches
+        const threshold = Math.max(2, unknown.length / 2);
+        const filtered = scored.filter((s) => s.score <= threshold);
+        if (filtered.length === 0) {
+            return;
+        }
+        // Sort by score, deduplicate by path
+        filtered.sort((a, b) => a.score - b.score);
+        const seen = new Set();
+        const unique = filtered.filter((entry) => {
+            if (seen.has(entry.path)) {
+                return false;
+            }
+            seen.add(entry.path);
+            return true;
+        });
+        // Print top 5 suggestions
+        const top = unique.slice(0, 5);
+        process.stderr.write('\nDid you mean?\n');
+        for (const entry of top) {
+            const cmd = `guild ${entry.path}`;
+            const padding = ' '.repeat(Math.max(2, 30 - cmd.length));
+            process.stderr.write(`  ${cmd}${padding}${entry.description}\n`);
+        }
+    };
+}
+/**
+ * Recursively configures writeErr on a command and all its subcommands.
+ */
+function configureOutputRecursively(cmd, writeErr) {
+    cmd.configureOutput({ writeErr });
+    for (const sub of cmd.commands) {
+        configureOutputRecursively(sub, writeErr);
+    }
+}
+/**
+ * Sets up cross-level "Did you mean?" suggestions for unknown commands.
+ *
+ * Disables Commander's built-in same-level suggestions and intercepts
+ * "unknown command" errors to search the entire command tree.
+ */
+export function setupUnknownCommandSuggestions(program) {
+    // Disable Commander's built-in suggestion on all commands
+    disableBuiltinSuggestions(program);
+    // Create a shared writeErr handler and apply it to all commands
+    const writeErr = createWriteErrHandler(program);
+    configureOutputRecursively(program, writeErr);
+}
+//# sourceMappingURL=did-you-mean.js.map