@guildai/cli 0.10.0 → 0.12.0

package/dist/commands/agent/pull.js

@@ -1,198 +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 { getOutputMode } 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';
-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 (default: off)', false)
-        .action(async (_options) => {
-        const cwd = process.cwd();
-        const output = createOutputWriter();
-        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
-            const guildConfig = JSON.parse(await fs.readFile(guildJsonPath, 'utf-8'));
-            // Fetch agent to get git_url
-            const client = new GuildAPIClient();
-            const agent = await client.get(`/agents/${guildConfig.agent_id}`);
-            if (!agent.git_url) {
-                output.error('Agent does not have a git repository', 'This agent may not have been initialized with git.');
-                process.exit(1);
-            }
-            // Get authenticated URL
-            const authenticatedUrl = await getAuthenticatedUrl(agent.git_url);
-            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 with rebase
-            let gitPulledNewCommits = false;
-            try {
-                const { stdout: pullOutput } = await runGit(['pull', '--rebase', authenticatedUrl, currentBranch], { cwd });
-                // Update remote-tracking ref so git status stays consistent
-                try {
-                    await runGit(['update-ref', `refs/remotes/origin/${currentBranch}`, 'FETCH_HEAD'], { cwd });
-                }
-                catch {
-                    // Non-fatal: git status will be stale but pull still succeeded
-                }
-                if (pullOutput.includes('Already up to date') ||
-                    pullOutput.includes('Current branch') // "Current branch X is up to date."
-                ) {
-                    // Don't report yet — version check below may have more to say
-                }
-                else {
-                    gitPulledNewCommits = true;
-                    // Count commits pulled
-                    const updateMatch = pullOutput.match(/Updating\s+[a-f0-9]+\.\.[a-f0-9]+/);
-                    const fastForward = pullOutput.includes('Fast-forward');
-                    let message = 'Pulled remote changes';
-                    if (fastForward || updateMatch) {
-                        const filesMatch = pullOutput.match(/(\d+)\s+files?\s+changed/);
-                        if (filesMatch) {
-                            message = `Pulled remote changes (${filesMatch[1]} files changed)`;
-                        }
-                    }
-                    output.progress(`✓ ${message}`);
-                }
-            }
-            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\nOr abort the rebase:\n  git rebase --abort');
-                    process.exit(1);
-                }
-                // No upstream branch — nothing to pull
-                if (errMessage.includes('no tracking information') ||
-                    errMessage.includes("couldn't find remote ref")) {
-                    output.progress('✓ Already up to date (no remote branch yet)');
-                    if (getOutputMode() === 'json') {
-                        output.data({
-                            success: true,
-                            message: 'Already up to date (no remote branch yet)',
-                        });
-                    }
-                    return;
-                }
-                // Unknown git error
-                throw pullError;
-            }
-            // Version check: compare local state against backend
-            const versions = await client.get(`/agents/${guildConfig.agent_id}/versions?limit=1`);
-            if (versions.items.length > 0) {
-                const latest = versions.items[0];
-                const { stdout: headSha } = await runGit(['rev-parse', 'HEAD'], { cwd });
-                const localHead = headSha.trim();
-                if (latest.sha && latest.sha === localHead) {
-                    // Truly up to date — git pull + version match
-                    if (!gitPulledNewCommits) {
-                        output.progress('✓ Already up to date');
-                    }
-                    if (getOutputMode() === 'json') {
-                        output.data({
-                            success: true,
-                            message: gitPulledNewCommits
-                                ? 'Pulled remote changes'
-                                : 'Already up to date',
-                        });
-                    }
-                }
-                else if (latest.sha && latest.sha !== localHead) {
-                    // SHA mismatch — warn user
-                    output.progress(`⚠ Remote has a newer version (${latest.sha.slice(0, 7)}) not on this branch`);
-                    output.progress('  Try: git fetch origin && git log --oneline origin/main');
-                    if (getOutputMode() === 'json') {
-                        output.data({
-                            success: true,
-                            message: 'SHA mismatch with latest version',
-                            latest_sha: latest.sha,
-                            local_sha: localHead,
-                        });
-                    }
-                }
-                else {
-                    // Ephemeral version — download from API
-                    output.progress('Remote has unpublished changes from the web editor');
-                    // Check for local uncommitted changes
-                    const { stdout: status } = await runGit(['status', '--porcelain'], { cwd });
-                    if (status.trim()) {
-                        output.error('Cannot download remote changes — you have uncommitted local changes', 'Commit or stash your changes first, then run guild agent pull again.');
-                        process.exit(1);
-                    }
-                    const files = await client.get(`/agents/${guildConfig.agent_id}/code?include_unpublished=1`);
-                    for (const file of files) {
-                        const filePath = path.join(cwd, file.path);
-                        await fs.mkdir(path.dirname(filePath), { recursive: true });
-                        await fs.writeFile(filePath, file.content, 'utf-8');
-                    }
-                    output.progress(`✓ Downloaded ${files.length} files from latest draft version`);
-                    if (getOutputMode() === 'json') {
-                        output.data({
-                            success: true,
-                            message: `Downloaded ${files.length} files from draft version`,
-                            files_updated: files.length,
-                        });
-                    }
-                }
-            }
-            else {
-                // No versions exist yet — just report git pull result
-                if (!gitPulledNewCommits) {
-                    output.progress('✓ Already up to date');
-                }
-                if (getOutputMode() === 'json') {
-                    output.data({
-                        success: true,
-                        message: gitPulledNewCommits
-                            ? 'Pulled remote changes'
-                            : 'Already up to date',
-                    });
-                }
-            }
-        }
-        catch (error) {
-            if (error instanceof GitError) {
-                output.error('Git operation failed', formatGitError(error));
-                process.exit(1);
-            }
-            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', 'The agent may have been deleted.\nCheck your guild.json agent_id.');
-                process.exit(1);
-            }
-            output.error(`Failed to pull: ${formattedError.details}`);
-            process.exit(1);
-        }
-    });
-    return cmd;
-}
-//# sourceMappingURL=pull.js.map

package/dist/commands/agent/revalidate.js

@@ -1,56 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-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, resolveAgentRef } from '../../lib/agent-helpers.js';
-import { createOutputWriter } from '../../lib/output.js';
-export function createAgentRevalidateCommand() {
-    const cmd = new Command('revalidate');
-    cmd
-        .description('Revalidate an agent version')
-        .argument('[identifier]', 'Agent ID or full name (e.g., owner~agent-name)')
-        .argument('[version-id]', 'ID of the version to revalidate (uses latest if omitted)')
-        .action(async (agentIdArg, versionIdArg) => {
-        const output = createOutputWriter();
-        // Get agent ID from argument or guild.json
-        const { agentId } = await getAgentId(agentIdArg);
-        const baseUrl = getGuildcoreUrl();
-        const client = new GuildAPIClient({ baseUrl });
-        try {
-            const resolvedId = await resolveAgentRef(client, agentId);
-            let versionId = versionIdArg;
-            // If no version ID provided, get the latest version
-            if (!versionId) {
-                const versions = await client.get(`/agents/${resolvedId}/versions?limit=1&offset=0`);
-                if (!versions.items || versions.items.length === 0) {
-                    output.error('No versions found for this agent.', `The agent may still be initializing. Check status:\n  guild agent get ${agentId}`);
-                    process.exit(1);
-                }
-                versionId = versions.items[0].id;
-            }
-            // Revalidate the version
-            const result = await client.post(`/agents/${resolvedId}/versions/${versionId}/revalidate`);
-            output.data(result);
-        }
-        catch (error) {
-            const formattedError = handleAxiosError(error);
-            if (formattedError.code === ErrorCodes.AUTH_REQUIRED) {
-                output.error('Not authenticated.', '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 or version not found', `Check the agent and version IDs:\n  guild agent list\n  guild agent versions ${agentId}`);
-            }
-            else {
-                output.error(`Failed to revalidate version: ${formattedError.details}`);
-            }
-            process.exit(1);
-        }
-    });
-    return cmd;
-}
-//# sourceMappingURL=revalidate.js.map

package/dist/commands/agent/save.js

@@ -1,346 +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 { getOutputMode } 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')
-        .option('--json', 'Output JSON only, no progress messages (default: off)', false)
-        .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 (getOutputMode() === 'json') {
-                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 { 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',
-    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 (getOutputMode() === 'json') {
-                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