@guildai/cli 0.11.0 → 0.12.0

package/dist/commands/agent/save.js

@@ -1,345 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-import { Command } from 'commander';
-import { GuildAPIClient } from '../../lib/api-client.js';
-import { handleAxiosError, ErrorCodes } from '../../lib/errors.js';
-import { isMachineReadable } from '../../lib/output-mode.js';
-import { createOutputWriter } from '../../lib/output.js';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { getAuthenticatedUrl } from '../../lib/auth.js';
-import { runGit, GitError, formatGitError } from '../../lib/git.js';
-import { waitForValidation, waitForPublish } from '../../lib/version-helpers.js';
-export function createAgentSaveCommand() {
-    const cmd = new Command('save');
-    cmd
-        .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 (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')
-        .action(async (options) => {
-        const cwd = process.cwd();
-        let guildConfig = null;
-        const output = createOutputWriter();
-        // Resolve bump level: bare --bump defaults to 'patch', --no-bump skips
-        const bumpLevel = options.bump === true || options.bump === 'patch'
-            ? 'patch'
-            : options.bump === 'minor'
-                ? 'minor'
-                : options.bump === 'major'
-                    ? 'major'
-                    : options.bump === false
-                        ? null
-                        : null;
-        if (options.bump !== false && bumpLevel === null) {
-            output.error(`Invalid bump level: ${String(options.bump)}`, 'Valid levels are: patch, minor, major\n  guild agent save --bump minor');
-            process.exit(1);
-        }
-        // With --all, a commit message is required (unless bump auto-generates one)
-        if (options.all && !options.message && !bumpLevel) {
-            output.error('Commit message is required with --all', 'Provide a message describing your changes:\n  guild agent save -A --message "Add new feature"');
-            process.exit(1);
-        }
-        let versionNumber;
-        try {
-            // Check for guild.json
-            const guildJsonPath = path.join(cwd, 'guild.json');
-            const guildJsonExists = await fs
-                .access(guildJsonPath)
-                .then(() => true)
-                .catch(() => false);
-            if (!guildJsonExists) {
-                output.error('Not in an agent directory', 'guild.json not found in current directory.\n\nInitialize an agent directory:\n  guild agent init --name my-agent\n\nOr clone an existing agent:\n  guild agent clone <agent-id>');
-                process.exit(1);
-            }
-            // Read guild.json
-            guildConfig = JSON.parse(await fs.readFile(guildJsonPath, 'utf-8'));
-            // Handle --bump: bump package.json version before git operations
-            if (bumpLevel) {
-                const packageJsonPath = path.join(cwd, 'package.json');
-                let packageJsonContent;
-                try {
-                    packageJsonContent = await fs.readFile(packageJsonPath, 'utf-8');
-                }
-                catch {
-                    output.error('package.json not found', 'A package.json file is required in the agent directory to use --bump.');
-                    process.exit(1);
-                }
-                const packageJson = JSON.parse(packageJsonContent);
-                const currentVersion = packageJson.version || '0.0.0';
-                const parts = currentVersion.split('.').map(Number);
-                if (parts.length !== 3 || parts.some((p) => isNaN(p))) {
-                    output.error(`Cannot bump invalid version: ${currentVersion}`, 'package.json version must be in MAJOR.MINOR.PATCH format (e.g. 1.0.0)');
-                    process.exit(1);
-                }
-                const [major, minor, patch] = parts;
-                let newVersion;
-                if (bumpLevel === 'major') {
-                    newVersion = `${major + 1}.0.0`;
-                }
-                else if (bumpLevel === 'minor') {
-                    newVersion = `${major}.${minor + 1}.0`;
-                }
-                else {
-                    newVersion = `${major}.${minor}.${patch + 1}`;
-                }
-                packageJson.version = newVersion;
-                await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n');
-                versionNumber = newVersion;
-                output.progress(`✓ Bumped version: ${currentVersion} → ${newVersion}`);
-            }
-            else {
-                // No bump — read version from package.json if it exists
-                const packageJsonPath = path.join(cwd, 'package.json');
-                try {
-                    const pkg = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
-                    if (pkg.version) {
-                        versionNumber = pkg.version;
-                    }
-                }
-                catch {
-                    // No package.json or unreadable — version stays undefined
-                }
-            }
-            // Check for uncommitted changes and unpushed commits
-            const { stdout: statusOutput } = await runGit(['status', '--porcelain'], {
-                cwd,
-            });
-            const hasUncommittedChanges = statusOutput.trim().length > 0;
-            let hasUnpushedCommits = false;
-            // Check for unpushed commits
-            try {
-                const { stdout: branchForCheck } = await runGit(['rev-parse', '--abbrev-ref', 'HEAD'], { cwd });
-                const { stdout: unpushed } = await runGit(['log', `origin/${branchForCheck.trim()}..HEAD`, '--oneline'], { cwd });
-                hasUnpushedCommits = unpushed.trim().length > 0;
-            }
-            catch {
-                // No remote tracking branch yet — if HEAD has commits, treat
-                // as unpushed so the push flow can create the remote branch.
-                try {
-                    const { stdout: logOutput } = await runGit(['log', '--oneline', '-1'], {
-                        cwd,
-                    });
-                    hasUnpushedCommits = logOutput.trim().length > 0;
-                }
-                catch {
-                    hasUnpushedCommits = false;
-                }
-            }
-            // --bump implies --all (the version change needs to be committed)
-            const shouldStageAll = options.all || !!bumpLevel;
-            if (shouldStageAll) {
-                // Stage and commit before pushing
-                if (hasUncommittedChanges) {
-                    await runGit(['add', '-A'], { cwd });
-                    output.progress('✓ Staged changes');
-                    const commitMsg = options.message || (bumpLevel ? `Bump version` : '');
-                    await runGit(['commit', '-m', commitMsg], { cwd });
-                    output.progress('✓ Committed locally');
-                    hasUnpushedCommits = true;
-                }
-            }
-            else {
-                // Default: push-only, no staging or committing
-                if (!hasUnpushedCommits && hasUncommittedChanges) {
-                    output.error('Uncommitted changes', 'You have uncommitted changes. Either commit them first:\n  git add . && git commit -m "your message"\n\nOr use --all to stage and commit automatically:\n  guild agent save -A --message "your message"');
-                    process.exit(1);
-                }
-            }
-            if (!hasUnpushedCommits) {
-                output.error('No changes to save', 'Working tree is clean and there are no unpushed commits.');
-                process.exit(1);
-            }
-            // Resolve version summary: use --message if provided, otherwise
-            // extract the latest commit message.
-            let versionMessage = options.message;
-            if (!versionMessage) {
-                const { stdout: commitMsg } = await runGit(['log', '-1', '--pretty=%s'], {
-                    cwd,
-                });
-                versionMessage = commitMsg.trim();
-            }
-            // Get remote URL with auth credentials
-            const { stdout: remoteUrl } = await runGit(['remote', 'get-url', 'origin'], {
-                cwd,
-            });
-            const authenticatedUrl = await getAuthenticatedUrl(remoteUrl.trim());
-            if (!authenticatedUrl) {
-                output.error('Not authenticated.', 'Run: guild auth login');
-                process.exit(1);
-            }
-            // Get current branch name
-            const { stdout: branchName } = await runGit(['rev-parse', '--abbrev-ref', 'HEAD'], {
-                cwd,
-            });
-            const currentBranch = branchName.trim();
-            // Pull remote changes first (rebase to avoid merge commits)
-            const gitEnv = { GUILD_AGENT_SAVE: '1' };
-            try {
-                const { stdout: pullOutput } = await runGit(['pull', '--rebase', authenticatedUrl, currentBranch], { cwd, env: gitEnv });
-                if (pullOutput.includes('Updating') ||
-                    pullOutput.includes('Fast-forward')) {
-                    output.progress('✓ Synced with remote');
-                }
-            }
-            catch (pullError) {
-                const errMessage = pullError instanceof GitError
-                    ? pullError.stderr || pullError.stdout
-                    : String(pullError);
-                // Check for rebase conflicts
-                if (errMessage.includes('CONFLICT') ||
-                    errMessage.includes('could not apply')) {
-                    output.error('Merge conflict detected', 'Your changes conflict with remote changes.\n\nTo resolve:\n  1. Fix conflicts in the listed files\n  2. git add <resolved-files>\n  3. git rebase --continue\n  4. guild agent save --message "..."\n\nOr abort the rebase:\n  git rebase --abort');
-                    process.exit(1);
-                }
-                // If pull fails, check if it's because there's no upstream
-                if (!errMessage.includes('no tracking information') &&
-                    !errMessage.includes("couldn't find remote ref")) {
-                    // Real error we don't understand
-                    output.error('Failed to sync with remote', errMessage);
-                    process.exit(1);
-                }
-                // No upstream branch yet, that's fine - first push will set it
-            }
-            // Push to remote using authenticated URL
-            // Note: We push to the URL directly (not via origin remote) because
-            // origin doesn't have auth credentials. This means we must manually
-            // update the remote-tracking ref afterward.
-            //
-            // Retry on transient server-side errors (e.g. GitHub returning
-            // "fatal error in commit_refs" when the repo isn't fully ready).
-            const maxPushAttempts = 3;
-            for (let attempt = 1; attempt <= maxPushAttempts; attempt++) {
-                try {
-                    await runGit(['push', authenticatedUrl, `HEAD:${currentBranch}`], {
-                        cwd,
-                        env: gitEnv,
-                    });
-                    break;
-                }
-                catch (pushError) {
-                    const msg = pushError instanceof GitError
-                        ? pushError.stderr || pushError.stdout
-                        : String(pushError);
-                    const isTransient = msg.includes('commit_refs') ||
-                        msg.includes('remote rejected') ||
-                        msg.includes('Service Unavailable') ||
-                        msg.includes('502') ||
-                        msg.includes('503');
-                    if (!isTransient || attempt === maxPushAttempts) {
-                        throw pushError;
-                    }
-                    const delaySec = attempt * 2;
-                    output.progress(`Push failed (attempt ${attempt}/${maxPushAttempts}), retrying in ${delaySec}s...`);
-                    await new Promise((resolve) => setTimeout(resolve, delaySec * 1000));
-                }
-            }
-            // Update origin's remote-tracking ref so git status stays consistent.
-            // Pushing via URL doesn't update refs/remotes/origin/*, which causes
-            // "branch is ahead of origin/<branch>" confusion.
-            try {
-                await runGit(['update-ref', `refs/remotes/origin/${currentBranch}`, 'HEAD'], { cwd });
-            }
-            catch {
-                // Non-fatal: git status will be stale but save still succeeded
-            }
-            // Set up tracking for future operations
-            try {
-                await runGit(['branch', '--set-upstream-to', `origin/${currentBranch}`], {
-                    cwd,
-                });
-            }
-            catch {
-                // Ignore if branch tracking already set or doesn't exist on remote yet
-            }
-            output.progress('✓ Pushed to remote');
-            // Get final commit SHA (after potential rebase)
-            const { stdout: shaOutput } = await runGit(['rev-parse', 'HEAD'], {
-                cwd,
-            });
-            const commitSha = shaOutput.trim();
-            // Create version in guildcore (always as DRAFT, publish happens separately)
-            const client = new GuildAPIClient();
-            const agentId = guildConfig?.agent_id;
-            if (!agentId) {
-                output.error('Not in an agent directory');
-                process.exit(1);
-            }
-            let version = await client.post(`/agents/${agentId}/versions`, {
-                commit_sha: commitSha,
-                summary: versionMessage,
-                version_type: 'COMMITTED',
-                ...(versionNumber ? { version_number: versionNumber } : {}),
-            });
-            output.progress(`✓ Created version (${version.id})`);
-            if (options.wait || options.publish) {
-                version = await waitForValidation(version.id, output);
-            }
-            if (options.publish) {
-                output.progress('Validation passed, publishing...');
-                version = await client.post(`/versions/${version.id}/publish`, {});
-                if (options.wait && version.status !== 'PUBLISHED') {
-                    version = await waitForPublish(version.id, output);
-                }
-                else {
-                    output.progress('✓ Published');
-                }
-            }
-            output.progress('');
-            output.progress('Version details:');
-            output.progress(`  ID: ${version.id}`);
-            output.progress(`  SHA: ${version.sha ? version.sha.substring(0, 12) : '-'}`);
-            output.progress(`  Status: ${version.status}`);
-            if (version.published_at) {
-                output.progress(`  Published at: ${version.published_at}`);
-            }
-            output.progress(`  Summary: ${version.summary}`);
-            if (options.publish && version.status === 'PUBLISHED') {
-                output.progress('');
-                output.progress('Version is now published and available in the catalog.');
-            }
-            else if (options.publish) {
-                output.progress('');
-                output.progress('Publish is in progress. Use --wait to wait for completion.');
-            }
-            else {
-                output.progress('');
-                output.progress('To publish this version:');
-                output.progress('  guild agent save --message "..." --publish');
-            }
-            // 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 (isMachineReadable()) {
-                output.data({ version });
-            }
-        }
-        catch (error) {
-            if (error instanceof GitError) {
-                output.error('Git operation failed', formatGitError(error));
-                process.exit(1);
-            }
-            // Handle API errors
-            const formattedError = handleAxiosError(error);
-            if (formattedError.code === ErrorCodes.AUTH_REQUIRED) {
-                output.error('Not authenticated. Please log in first.', 'Run: guild auth login');
-                process.exit(1);
-            }
-            if (formattedError.code === ErrorCodes.NOT_FOUND) {
-                output.error(`Agent not found${guildConfig ? ': ' + guildConfig.agent_id : ''}`, 'The agent may have been deleted.');
-                process.exit(1);
-            }
-            if (formattedError.details.includes('does not exist')) {
-                output.error('Commit not found in repository', "This might mean:\n  • The commit wasn't pushed to the remote repository\n  • The git remote is configured incorrectly\n  • There's a sync issue with the backend\n\nVerify the commit exists:\n  git log --oneline\n\nVerify the remote:\n  git remote -v");
-                process.exit(1);
-            }
-            output.error(`Failed to save agent: ${formattedError.details}`);
-            process.exit(1);
-        }
-    });
-    return cmd;
-}
-//# sourceMappingURL=save.js.map

package/dist/commands/agent/search.js

@@ -1,61 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-import { Command } from 'commander';
-import { GuildAPIClient } from '../../lib/api-client.js';
-import { getAuthToken } from '../../lib/auth.js';
-import { handleAxiosError } from '../../lib/errors.js';
-import { isMachineReadable } 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',
-    name: 'name',
-    popular: 'cached_likes_count',
-};
-export function createAgentSearchCommand() {
-    const cmd = new Command('search');
-    cmd
-        .description('Search agents')
-        .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 (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 {
-            const token = await getAuthToken();
-            if (!token) {
-                output.error('Not authenticated. Please log in first.', 'Run: guild auth login');
-                process.exit(1);
-            }
-            const client = new GuildAPIClient();
-            const params = new URLSearchParams();
-            params.append('search', query);
-            params.append('limit', options.limit);
-            params.append('offset', options.offset);
-            if (options.published) {
-                params.append('published_only', 'true');
-            }
-            const sortField = SORT_MAP[options.sort];
-            if (sortField) {
-                params.append('sort_by', sortField);
-            }
-            const response = await client.get(`/agents?${params.toString()}`);
-            if (isMachineReadable()) {
-                output.data(response);
-            }
-            else {
-                formatAgentTable(response.items, response.pagination);
-            }
-        }
-        catch (error) {
-            const formattedError = handleAxiosError(error);
-            output.error(`Failed to search agents: ${formattedError.details}`);
-            process.exit(1);
-        }
-    });
-    return cmd;
-}
-//# sourceMappingURL=search.js.map

package/dist/commands/agent/tags/add.js

@@ -1,73 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-import { Command } from 'commander';
-import { GuildAPIClient } from '../../../lib/api-client.js';
-import { getAgentId, resolveAgentRef } from '../../../lib/agent-helpers.js';
-import { handleAxiosError, ErrorCodes } from '../../../lib/errors.js';
-import { createOutputWriter } from '../../../lib/output.js';
-export function createAgentTagsAddCommand() {
-    const cmd = new Command('add');
-    cmd
-        .description('Add tags to an agent')
-        .argument('[agent-id]', 'Agent ID (optional if in agent directory)')
-        .argument('<tags...>', 'Tags to add')
-        .action(async (agentIdOrFirstTag, remainingTags) => {
-        const output = createOutputWriter();
-        try {
-            const client = new GuildAPIClient();
-            // Parse arguments - need to determine if first arg is agent-id or tag
-            let agentIdArg;
-            let tagsToAdd;
-            // Try to resolve agent ID from first argument
-            try {
-                await getAgentId(agentIdOrFirstTag);
-                // If successful, first arg was agent-id
-                agentIdArg = agentIdOrFirstTag;
-                tagsToAdd = remainingTags;
-            }
-            catch {
-                // First arg is not agent-id, must be a tag
-                // Try to get agent-id from guild.json
-                await getAgentId(undefined);
-                agentIdArg = undefined;
-                tagsToAdd = [agentIdOrFirstTag, ...remainingTags];
-            }
-            // Now resolve agent ID properly
-            const { agentId, config } = await getAgentId(agentIdArg);
-            const resolvedId = await resolveAgentRef(client, agentId);
-            if (tagsToAdd.length === 0) {
-                output.error('At least one tag is required.', 'Usage: guild agent tags add [agent-id] <tag...>');
-                process.exit(1);
-            }
-            // Fetch current tags
-            const response = await client.get(`/agents/${resolvedId}/tags`);
-            const currentTags = response.names;
-            // Add new tags (deduplicate)
-            const updatedTags = Array.from(new Set([...currentTags, ...tagsToAdd]));
-            // Update tags
-            await client.post(`/agents/${resolvedId}/tags`, { names: updatedTags });
-            const agentName = config?.name || `agent ${agentId}`;
-            const label = `${agentName}${config ? '' : ` (${agentId})`}`;
-            output.success(`Updated tags for agent: ${label}`);
-            output.data({ names: updatedTags });
-        }
-        catch (error) {
-            const formattedError = handleAxiosError(error);
-            if (formattedError.code === ErrorCodes.AUTH_REQUIRED) {
-                output.error('Not authenticated.', 'Run: guild auth login');
-            }
-            else if (formattedError.code === ErrorCodes.NOT_FOUND) {
-                output.error('Agent not found.', 'Run: guild agent list');
-            }
-            else if (formattedError.code === ErrorCodes.CONN_REFUSED) {
-                output.error('Cannot connect to Guild servers');
-            }
-            else {
-                output.error(`Failed to add tags: ${formattedError.details}`);
-            }
-            process.exit(1);
-        }
-    });
-    return cmd;
-}
-//# sourceMappingURL=add.js.map

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

@@ -1,43 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-import { Command } from 'commander';
-import { GuildAPIClient } from '../../../lib/api-client.js';
-import { getAgentId, resolveAgentRef } from '../../../lib/agent-helpers.js';
-import { handleAxiosError, ErrorCodes } from '../../../lib/errors.js';
-import { createOutputWriter } from '../../../lib/output.js';
-export function createAgentTagsListCommand() {
-    const cmd = new Command('list');
-    cmd
-        .description('List tags for an agent')
-        .argument('[agent-id]', 'Agent ID (optional if in agent directory)')
-        .action(async (agentIdArg) => {
-        const output = createOutputWriter();
-        try {
-            const client = new GuildAPIClient();
-            // Resolve agent ID
-            const { agentId } = await getAgentId(agentIdArg);
-            const resolvedId = await resolveAgentRef(client, agentId);
-            // Fetch tags
-            const response = await client.get(`/agents/${resolvedId}/tags`);
-            output.data(response);
-        }
-        catch (error) {
-            const formattedError = handleAxiosError(error);
-            if (formattedError.code === ErrorCodes.AUTH_REQUIRED) {
-                output.error('Not authenticated.', 'Run: guild auth login');
-            }
-            else if (formattedError.code === ErrorCodes.NOT_FOUND) {
-                output.error('Agent not found.', 'Run: guild agent list');
-            }
-            else if (formattedError.code === ErrorCodes.CONN_REFUSED) {
-                output.error('Cannot connect to Guild servers');
-            }
-            else {
-                output.error(`Failed to fetch tags: ${formattedError.details}`);
-            }
-            process.exit(1);
-        }
-    });
-    return cmd;
-}
-//# sourceMappingURL=list.js.map

package/dist/commands/agent/tags/remove.js

@@ -1,84 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-import { Command } from 'commander';
-import { GuildAPIClient } from '../../../lib/api-client.js';
-import { getAgentId, resolveAgentRef } from '../../../lib/agent-helpers.js';
-import { handleAxiosError, ErrorCodes } from '../../../lib/errors.js';
-import { createOutputWriter } from '../../../lib/output.js';
-export function createAgentTagsRemoveCommand() {
-    const cmd = new Command('remove');
-    cmd
-        .description('Remove tags from an agent')
-        .argument('[agent-id]', 'Agent ID (optional if in agent directory)')
-        .argument('<tags...>', 'Tags to remove')
-        .action(async (agentIdOrFirstTag, remainingTags) => {
-        const output = createOutputWriter();
-        try {
-            const client = new GuildAPIClient();
-            // Parse arguments - need to determine if first arg is agent-id or tag
-            let agentIdArg;
-            let tagsToRemove;
-            // Try to resolve agent ID from first argument
-            try {
-                await getAgentId(agentIdOrFirstTag);
-                // If successful, first arg was agent-id
-                agentIdArg = agentIdOrFirstTag;
-                tagsToRemove = remainingTags;
-            }
-            catch {
-                // First arg is not agent-id, must be a tag
-                // Try to get agent-id from guild.json
-                await getAgentId(undefined);
-                agentIdArg = undefined;
-                tagsToRemove = [agentIdOrFirstTag, ...remainingTags];
-            }
-            // Now resolve agent ID properly
-            const { agentId, config } = await getAgentId(agentIdArg);
-            const resolvedId = await resolveAgentRef(client, agentId);
-            if (tagsToRemove.length === 0) {
-                output.error('At least one tag is required.', 'Usage: guild agent tags remove [agent-id] <tag...>');
-                process.exit(1);
-            }
-            // Fetch current tags
-            const response = await client.get(`/agents/${resolvedId}/tags`);
-            const currentTags = response.names;
-            // Remove specified tags
-            const updatedTags = currentTags.filter((tag) => !tagsToRemove.includes(tag));
-            // Track which tags were not present
-            const notPresentTags = tagsToRemove.filter((tag) => !currentTags.includes(tag));
-            // Update tags
-            await client.post(`/agents/${resolvedId}/tags`, { names: updatedTags });
-            const agentName = config?.name || `agent ${agentId}`;
-            const label = `${agentName}${config ? '' : ` (${agentId})`}`;
-            output.success(`Updated tags for agent: ${label}`);
-            output.data({ names: updatedTags });
-            // Show warning for tags that weren't present
-            if (notPresentTags.length > 0) {
-                if (notPresentTags.length === 1) {
-                    output.progress(`Note: Tag '${notPresentTags[0]}' was not present`);
-                }
-                else {
-                    output.progress(`Note: Tags not present: ${notPresentTags.map((t) => `'${t}'`).join(', ')}`);
-                }
-            }
-        }
-        catch (error) {
-            const formattedError = handleAxiosError(error);
-            if (formattedError.code === ErrorCodes.AUTH_REQUIRED) {
-                output.error('Not authenticated.', 'Run: guild auth login');
-            }
-            else if (formattedError.code === ErrorCodes.NOT_FOUND) {
-                output.error('Agent not found.', 'Run: guild agent list');
-            }
-            else if (formattedError.code === ErrorCodes.CONN_REFUSED) {
-                output.error('Cannot connect to Guild servers');
-            }
-            else {
-                output.error(`Failed to remove tags: ${formattedError.details}`);
-            }
-            process.exit(1);
-        }
-    });
-    return cmd;
-}
-//# sourceMappingURL=remove.js.map