@guildai/cli 0.11.0 → 0.12.0

package/dist/commands/agent/code.js

@@ -1,87 +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 { getAgentId, resolveAgentRef } from '../../lib/agent-helpers.js';
-import { createOutputWriter } from '../../lib/output.js';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-export function createAgentCodeCommand() {
-    const cmd = new Command('code');
-    cmd
-        .description('Fetch the latest code for an agent')
-        .argument('[identifier]', 'Agent ID or full name (e.g., owner~agent-name)')
-        .option('--draft', 'Include draft versions (default: only published)', false)
-        .option('--output <directory>', 'Write files to directory instead of printing JSON')
-        .action(async (agentIdArg, options) => {
-        const output = createOutputWriter();
-        // Get agent ID from argument or guild.json
-        const { agentId } = await getAgentId(agentIdArg);
-        const client = new GuildAPIClient();
-        const includeDraft = options.draft ? '1' : '0';
-        let files;
-        try {
-            const resolvedId = await resolveAgentRef(client, agentId);
-            files = await client.get(`/agents/${resolvedId}/code?include_unpublished=${includeDraft}`);
-        }
-        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 fetch agent code: ${formattedError.details}`);
-            }
-            process.exit(1);
-        }
-        if (files.length === 0) {
-            if (options.draft) {
-                output.error('No code found for this agent.', 'This agent has no versions saved yet.\n\nTo save code: cd <agent-directory> && guild agent save --message "..."');
-            }
-            else {
-                output.error('No code found for this agent.', 'This agent has no published versions.\n\nTo see draft versions: guild agent code <agent-id> --draft\nTo publish a version: cd <agent-directory> && guild agent save --message "..." --publish');
-            }
-            process.exit(1);
-        }
-        // If output directory specified, write files
-        if (options.output) {
-            try {
-                await fs.mkdir(options.output, { recursive: true });
-                for (const file of files) {
-                    const filePath = path.join(options.output, file.path);
-                    const fileDir = path.dirname(filePath);
-                    // Create subdirectories if needed
-                    await fs.mkdir(fileDir, { recursive: true });
-                    // Write file
-                    await fs.writeFile(filePath, file.content, 'utf-8');
-                }
-                output.data({
-                    success: 'Code written to directory',
-                    directory: options.output,
-                    files_written: files.length,
-                    files: files.map((f) => f.path),
-                });
-                process.exit(0);
-            }
-            catch (error) {
-                const err = error;
-                output.error(`Could not write files to directory: ${options.output}`, `Error: ${err.message || 'Unknown error'}\n\nCheck that:\n  • Directory is writable\n  • You have permission to create files\n  • Disk space is available`);
-                process.exit(1);
-            }
-        }
-        else {
-            // Just print JSON
-            output.data({ files });
-            process.exit(0);
-        }
-    });
-    return cmd;
-}
-//# sourceMappingURL=code.js.map

package/dist/commands/agent/fork.js

@@ -1,220 +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, debug } from '../../lib/errors.js';
-import * as fs from 'fs/promises';
-import * as readline from 'readline';
-import { runGit, GitError, formatGitError } from '../../lib/git.js';
-import { createOutputWriter } from '../../lib/output.js';
-import { resolveOwnerId } from '../../lib/owner-helpers.js';
-import { isInteractive } from '../../lib/stdin.js';
-async function promptForName() {
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
-    return new Promise((resolve) => {
-        rl.question('Name for forked agent: ', (answer) => {
-            rl.close();
-            resolve(answer.trim());
-        });
-    });
-}
-async function promptForDescription(defaultDescription) {
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
-    return new Promise((resolve) => {
-        rl.question(`Description (default: "${defaultDescription}"): `, (answer) => {
-            rl.close();
-            resolve(answer.trim() || defaultDescription);
-        });
-    });
-}
-async function isDirectoryEmpty(dirPath) {
-    try {
-        const files = await fs.readdir(dirPath);
-        return files.length === 0;
-    }
-    catch {
-        // Directory doesn't exist, that's fine
-        return true;
-    }
-}
-export function createAgentForkCommand() {
-    const cmd = new Command('fork');
-    cmd
-        .description('Fork an existing agent version to create a new agent')
-        .argument('[identifier]', 'Agent ID, full name, or agent:version (e.g., owner~agent-name:version_xyz)')
-        .option('--name <name>', 'Name for the forked agent')
-        .option('--description <desc>', 'Description for the forked agent')
-        .option('--directory <path>', 'Target directory for clone')
-        .option('--owner <owner>', 'Owner (name or ID)')
-        .action(async (identifierArg, options) => {
-        const output = createOutputWriter();
-        try {
-            // Resolve agent ID and optional version ID
-            let sourceAgentId;
-            let sourceVersionId;
-            if (identifierArg && identifierArg.includes(':')) {
-                // Explicit agent:version format
-                const colonIndex = identifierArg.lastIndexOf(':');
-                const agentPart = identifierArg.substring(0, colonIndex);
-                sourceVersionId = identifierArg.substring(colonIndex + 1);
-                if (!agentPart || !sourceVersionId) {
-                    output.error('Error: Invalid argument format', 'Expected: [identifier] or [identifier]:[version-id]\nExample: guild agent fork owner~agent-name:version_xyz\n\nTo find versions:\n  guild agent versions <agent-id>');
-                    process.exit(1);
-                }
-                const resolved = await getAgentId(agentPart);
-                sourceAgentId = resolved.agentId;
-            }
-            else {
-                // No version specified — resolve agent, then find latest published
-                const resolved = await getAgentId(identifierArg);
-                sourceAgentId = resolved.agentId;
-            }
-            // Auto-resolve version if not specified
-            const client = new GuildAPIClient();
-            sourceAgentId = await resolveAgentRef(client, sourceAgentId);
-            if (!sourceVersionId) {
-                const versions = await client.get(`/agents/${sourceAgentId}/versions`);
-                const published = versions.items
-                    .filter((v) => v.status === 'PUBLISHED')
-                    .sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
-                if (published.length === 0) {
-                    output.error('No published versions found', `Agent ${sourceAgentId} has no published versions to fork.\n\nTo see all versions:\n  guild agent versions ${sourceAgentId}`);
-                    process.exit(1);
-                }
-                sourceVersionId = published[0].id;
-            }
-            // Determine name (validate before API call for better UX)
-            let agentName = options.name;
-            if (!agentName) {
-                if (isInteractive()) {
-                    agentName = await promptForName();
-                    if (!agentName) {
-                        output.error('Error: Agent name is required');
-                        process.exit(1);
-                    }
-                }
-                else {
-                    output.error('Error: Agent name required in non-interactive mode', `Provide a name:\n  guild agent fork ${identifierArg || '<identifier>'} --name my-forked-agent\n\nOr run interactively to be prompted.`);
-                    process.exit(1);
-                }
-            }
-            // Validate name format (before API call)
-            if (!/^[a-z0-9_-]{5,100}$/.test(agentName)) {
-                output.error('Error: Invalid agent name', 'Name must:\n  • Be between 5 and 100 characters\n  • Only contain lowercase letters, numbers, hyphens, and underscores\n\nExamples: my-agent, weather_bot, agent-007');
-                process.exit(1);
-            }
-            // Determine directory (default to agent name)
-            const targetDir = options.directory || `./${agentName}`;
-            // Check if directory exists and is empty (before API call)
-            const dirExists = await fs
-                .access(targetDir)
-                .then(() => true)
-                .catch(() => false);
-            if (dirExists) {
-                const isEmpty = await isDirectoryEmpty(targetDir);
-                if (!isEmpty) {
-                    output.error(`Error: Directory '${targetDir}' already exists and is not empty`, `Choose a different directory:\n  guild agent fork ${identifierArg || '<identifier>'} --directory ./different-path\n\nOr remove the existing directory first.`);
-                    process.exit(1);
-                }
-            }
-            // Fetch source version from API (after local validations)
-            const sourceVersion = await client.get(`/agents/${sourceAgentId}/versions/${sourceVersionId}`);
-            output.progress(`✓ Fetched source version from '${sourceVersion.agent.name}' (${sourceVersionId.substring(0, 12)})`);
-            // Determine description
-            let description = options.description;
-            if (!description) {
-                if (isInteractive()) {
-                    description = await promptForDescription(sourceVersion.agent.description);
-                }
-                else {
-                    // Use source description in non-interactive mode
-                    description = sourceVersion.agent.description;
-                }
-            }
-            // Resolve owner
-            const owner = await resolveOwnerId({
-                ownerFlag: options.owner,
-                client,
-                interactive: isInteractive(),
-                requireExplicitOwner: true,
-            });
-            // Create forked agent
-            output.progress(`✓ Forking agent '${agentName}'...`);
-            const newAgent = await client.post('/agents', {
-                name: agentName,
-                description,
-                forked_from_version: sourceVersionId,
-                owner_id: owner.id,
-            });
-            output.progress(`✓ Agent created: ${newAgent.name} (${newAgent.id})`);
-            // Poll until repository is ready
-            output.progress('✓ Waiting for repository initialization...');
-            let attempts = 0;
-            const maxAttempts = 60; // 2 minutes
-            let agent = newAgent;
-            while (agent.status !== 'READY' &&
-                agent.status !== 'FAILED' &&
-                attempts < maxAttempts) {
-                await new Promise((resolve) => setTimeout(resolve, 2000));
-                agent = await client.get(`/agents/${newAgent.id}`);
-                attempts++;
-                debug(`Agent status: ${agent.status} (attempt ${attempts}/${maxAttempts})`);
-            }
-            if (agent.status === 'FAILED') {
-                output.error('Error: Repository initialization failed', `The agent was created but the repository could not be initialized.\nCheck the agent status:\n  guild agent get ${newAgent.id}`);
-                process.exit(1);
-            }
-            if (agent.status !== 'READY') {
-                output.error('Error: Timed out waiting for repository initialization', `The agent was created but the repository is not ready yet.\nCheck the status with:\n  guild agent get ${newAgent.id}\n\nOnce ready, clone manually:\n  guild agent clone ${newAgent.id} --directory ${targetDir}`);
-                process.exit(1);
-            }
-            output.progress('✓ Repository ready!');
-            if (!agent.git_url) {
-                output.error('Error: Agent repository URL not available', `The agent was created but git_url is missing.\nCheck the agent details:\n  guild agent get ${newAgent.id}`);
-                process.exit(1);
-            }
-            // Clone the new repository
-            await runGit(['clone', agent.git_url, targetDir]);
-            output.progress(`✓ Cloned repository to ${targetDir}`);
-            // Display next steps
-            output.progress('');
-            output.progress('Next steps:');
-            output.progress(`  1. cd ${targetDir}`);
-            output.progress('  2. Make your changes to the code');
-            output.progress(`  3. Run 'guild agent save --message "your changes"'`);
-            output.progress(`  4. Run 'guild agent test' to test your changes`);
-            output.progress('');
-            output.progress(`Tip: Using a coding agent? Run 'guild setup' to install skills for Claude Code, Codex, etc.`);
-        }
-        catch (error) {
-            if (error instanceof GitError) {
-                output.error('Error: Failed to clone repository', `${formatGitError(error)}\n\nThe agent was created successfully, but cloning failed.\nTry cloning manually:\n  guild agent clone <agent-id>`);
-                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(`Error: Agent or version not found: ${identifierArg || '<identifier>'}`, `Check available versions:\n  guild agent versions <agent-id>`);
-                process.exit(1);
-            }
-            if (formattedError.code === ErrorCodes.CONN_REFUSED) {
-                output.error('Cannot connect to Guild servers');
-                process.exit(1);
-            }
-            output.error(`Failed to fork agent: ${formattedError.details}`);
-            process.exit(1);
-        }
-    });
-    return cmd;
-}
-//# sourceMappingURL=fork.js.map

package/dist/commands/agent/get.js

@@ -1,37 +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 { getAgentId, resolveAgentRef } from '../../lib/agent-helpers.js';
-import { handleAxiosError } from '../../lib/errors.js';
-import { createOutputWriter } from '../../lib/output.js';
-export function createAgentGetCommand() {
-    const cmd = new Command('get');
-    cmd
-        .description('Get agent details')
-        .argument('[identifier]', 'Agent ID or full name (e.g., owner~agent-name)')
-        .action(async (idArg) => {
-        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);
-            }
-            // Get agent ID from argument or guild.json
-            const { agentId } = await getAgentId(idArg);
-            const client = new GuildAPIClient();
-            const resolvedId = await resolveAgentRef(client, agentId);
-            const response = await client.get(`/agents/${resolvedId}`);
-            output.data(response);
-        }
-        catch (error) {
-            const formattedError = handleAxiosError(error);
-            output.error(`Failed to get agent: ${formattedError.details}`);
-            process.exit(1);
-        }
-    });
-    return cmd;
-}
-//# sourceMappingURL=get.js.map

package/dist/commands/agent/grep.js

@@ -1,107 +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 { createOutputWriter } from '../../lib/output.js';
-import { handleAxiosError } from '../../lib/errors.js';
-import { loadLocalConfig } from '../../lib/guild-config.js';
-export function createAgentGrepCommand() {
-    const cmd = new Command('grep');
-    cmd
-        .description('Search agent files for a matching pattern')
-        .argument('[pattern]', 'JavaScript regex for which to search: all lines matching this pattern will be printed')
-        .option('--all', 'Search all agents (default: current agent only)')
-        .option('--published', 'Only search published agents (requires --all)')
-        .action(grep);
-    return cmd;
-}
-const BATCH_SIZE = 20;
-async function grep(patternArg, 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);
-        }
-        if (patternArg === undefined) {
-            output.error('Please specify a pattern to match');
-            process.exit(1);
-        }
-        let patternRE;
-        try {
-            patternRE = new RegExp(patternArg);
-        }
-        catch {
-            output.error(`Invalid regex pattern: ${patternArg}`);
-            process.exit(1);
-        }
-        const client = new GuildAPIClient();
-        if (options.all) {
-            await grepAllAgents(client, patternRE, options.published, output);
-        }
-        else {
-            await grepCurrentAgent(client, patternRE, output);
-        }
-    }
-    catch (error) {
-        const formattedError = handleAxiosError(error);
-        output.error(`Failed to search agents: ${formattedError.details}`);
-        process.exit(1);
-    }
-}
-function searchFiles(files, patternRE, prefix, output) {
-    for (const { path, content } of files) {
-        content.split('\n').forEach((line, lineNumber) => {
-            if (patternRE.test(line)) {
-                output.progress(`${prefix}${path}:${lineNumber + 1}:${line}`);
-            }
-        });
-    }
-}
-async function grepCurrentAgent(client, patternRE, output) {
-    const config = await loadLocalConfig();
-    if (!config?.agent_id) {
-        output.error('Not in an agent directory.', 'Either run from an agent directory with guild.json:\n  cd <agent-directory>\n  guild agent grep <pattern>\n\nOr search all agents:\n  guild agent grep <pattern> --all');
-        process.exit(1);
-    }
-    let files = [];
-    try {
-        files = await client.get(`/agents/${config.agent_id}/code`);
-    }
-    catch (ex) {
-        const formattedError = handleAxiosError(ex);
-        output.error(`Failed to fetch agent code: ${formattedError.details}`);
-        process.exit(1);
-    }
-    searchFiles(files, patternRE, '', output);
-}
-async function grepAllAgents(client, patternRE, publishedOnly, output) {
-    let offset = 0;
-    while (true) {
-        const params = new URLSearchParams();
-        params.append('offset', `${offset}`);
-        params.append('limit', `${BATCH_SIZE}`);
-        if (publishedOnly) {
-            params.append('published_only', 'true');
-        }
-        const response = await client.get(`/agents?${params.toString()}`);
-        await Promise.all(response.items.map(async (agent) => {
-            let files = [];
-            try {
-                files = await client.get(`/agents/${agent.id}/code`);
-            }
-            catch (ex) {
-                const formattedError = handleAxiosError(ex);
-                output.error(`${agent.owner?.name}~${agent.name}: ${formattedError.details}`);
-                return;
-            }
-            searchFiles(files, patternRE, `${agent.owner?.name}~${agent.name}/`, output);
-        }));
-        offset += response.pagination.limit;
-        if (!response.pagination.has_more)
-            break;
-    }
-}
-//# sourceMappingURL=grep.js.map