@guildai/cli 0.11.0 → 0.12.0

package/dist/lib/splash.js

@@ -1,42 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-import chalk from 'chalk';
-import LOGO from './logo.js';
-import { brand } from './colors.js';
-import { isMachineReadable } from './output-mode.js';
-/**
- * Show splash screen with logo
- */
-export function showSplashScreen(options) {
-    console.log('');
-    LOGO.forEach((line) => console.log(brand(line)));
-    console.log('');
-    console.log('Guild.ai CLI');
-    console.log(chalk.dim(`v${options.version}`));
-    console.log('');
-}
-/**
- * Determine if splash screen should be shown
- *
- * Show for: help, version, interactive chat
- * Never for: --json, data commands, action commands
- */
-export function shouldShowSplash() {
-    // Never in machine-readable mode (--mode json, --mode jsonl, --json)
-    if (isMachineReadable()) {
-        return false;
-    }
-    const args = process.argv.slice(2);
-    // Show for top-level help/version only
-    // Don't show for subcommand help (e.g., 'guild chat --help')
-    // Note: chat command renders its own header, so we skip splash for it
-    if (args.length === 0 || args[0] === 'version') {
-        return true;
-    }
-    // Only show splash for top-level --help (no other commands before it)
-    if ((args[0] === '--help' || args[0] === '-h') && args.length === 1) {
-        return true;
-    }
-    return false;
-}
-//# sourceMappingURL=splash.js.map

package/dist/lib/stdin.js

@@ -1,91 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Check if the CLI is running in interactive mode.
- *
- * Returns false when:
- *  - stdin is not a TTY (piped input, CI, cron)
- *  - the global --non-interactive flag is set
- */
-export function isInteractive() {
-    if (process.argv.includes('--non-interactive')) {
-        return false;
-    }
-    return process.stdin.isTTY === true;
-}
-/**
- * Exit with a helpful error when stdin is piped but no --mode flag was given.
- * Call this before rendering an interactive UI (Ink render()) so users who
- * accidentally pipe input without --mode get clear guidance instead of a hang.
- */
-export function ensureInteractiveStdin(command) {
-    if (!process.stdin.isTTY) {
-        console.error('Error: stdin is piped but --mode was not specified');
-        console.error('');
-        console.error('When piping input, use --mode to set the input format:');
-        console.error(`  echo '{"prompt":"hello"}' | ${command} --mode json`);
-        console.error(`  cat inputs.jsonl | ${command} --mode jsonl`);
-        console.error('');
-        console.error('Or run interactively (no pipe):');
-        console.error(`  ${command}`);
-        process.exit(1);
-    }
-}
-/**
- * Read raw text from stdin with a timeout.
- */
-export function readStdinAsText() {
-    return new Promise((resolve, reject) => {
-        let input = '';
-        const timeout = setTimeout(() => {
-            reject(new Error('Timeout waiting for stdin'));
-        }, 5000);
-        process.stdin.setEncoding('utf8');
-        process.stdin.on('data', (chunk) => {
-            input += chunk;
-        });
-        process.stdin.on('end', () => {
-            clearTimeout(timeout);
-            resolve(input);
-        });
-        process.stdin.on('error', (error) => {
-            clearTimeout(timeout);
-            reject(error);
-        });
-    });
-}
-/**
- * Read JSON from stdin with a timeout.
- */
-export function readStdinAsJSON() {
-    return new Promise((resolve, reject) => {
-        let input = '';
-        const timeout = setTimeout(() => {
-            reject(new Error('Timeout waiting for stdin'));
-        }, 5000);
-        process.stdin.setEncoding('utf8');
-        process.stdin.on('data', (chunk) => {
-            input += chunk;
-        });
-        process.stdin.on('end', () => {
-            clearTimeout(timeout);
-            if (!input.trim()) {
-                reject(new Error('No JSON input provided'));
-                return;
-            }
-            try {
-                const parsed = JSON.parse(input);
-                resolve(parsed);
-            }
-            catch (error) {
-                const err = error;
-                reject(new Error(`Invalid JSON: ${err.message}`));
-            }
-        });
-        process.stdin.on('error', (error) => {
-            clearTimeout(timeout);
-            reject(error);
-        });
-    });
-}
-//# sourceMappingURL=stdin.js.map

package/dist/lib/svg-to-braille.js

@@ -1,76 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Simple SVG to Braille converter using proper SVG rendering
- * Uses sharp to render SVG to bitmap, then samples pixels for braille
- */
-import sharp from 'sharp';
-// Braille Unicode range: U+2800 to U+28FF
-// Each braille character represents an 8-pixel grid (2x4)
-// Bit positions (0-indexed):
-//   0 3
-//   1 4
-//   2 5
-//   6 7
-/**
- * Convert SVG string to braille text representation
- */
-export async function svgToBraille(svgString, widthChars, heightChars) {
-    // Each braille char is 2 pixels wide, 4 pixels tall
-    const pixelWidth = widthChars * 2;
-    const pixelHeight = heightChars * 4;
-    // Single-pass pipeline: render SVG to bitmap and get raw pixel data
-    const { data, info } = await sharp(Buffer.from(svgString))
-        .resize(pixelWidth, pixelHeight, {
-        fit: 'contain',
-        background: { r: 255, g: 255, b: 255, alpha: 1 },
-    })
-        .flatten({ background: { r: 255, g: 255, b: 255 } })
-        .greyscale()
-        .raw()
-        .toBuffer({ resolveWithObject: true });
-    // Convert pixels to braille
-    const lines = [];
-    for (let row = 0; row < heightChars; row++) {
-        let line = '';
-        for (let col = 0; col < widthChars; col++) {
-            // Sample 2x4 pixel grid for this braille character
-            let brailleBits = 0;
-            for (let dy = 0; dy < 4; dy++) {
-                for (let dx = 0; dx < 2; dx++) {
-                    const pixelX = col * 2 + dx;
-                    const pixelY = row * 4 + dy;
-                    // Get pixel value (grayscale: black = 0, white = 255)
-                    const pixelIndex = (pixelY * info.width + pixelX) * info.channels;
-                    const pixelValue = data[pixelIndex]; // R channel (they're all the same for grayscale)
-                    // If pixel is dark (< 128), set the corresponding braille bit
-                    if (pixelValue < 128) {
-                        // Map pixel position to braille bit position
-                        // dx=0,dy=0 -> bit 0
-                        // dx=0,dy=1 -> bit 1
-                        // dx=0,dy=2 -> bit 2
-                        // dx=0,dy=3 -> bit 6
-                        // dx=1,dy=0 -> bit 3
-                        // dx=1,dy=1 -> bit 4
-                        // dx=1,dy=2 -> bit 5
-                        // dx=1,dy=3 -> bit 7
-                        let bitPos;
-                        if (dx === 0) {
-                            bitPos = dy < 3 ? dy : 6;
-                        }
-                        else {
-                            bitPos = dy < 3 ? dy + 3 : 7;
-                        }
-                        brailleBits |= 1 << bitPos;
-                    }
-                }
-            }
-            // Convert bit pattern to braille Unicode character
-            const brailleChar = String.fromCharCode(0x2800 + brailleBits);
-            line += brailleChar;
-        }
-        lines.push(line);
-    }
-    return lines;
-}
-//# sourceMappingURL=svg-to-braille.js.map

package/dist/lib/table.js

@@ -1,59 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-import chalk from 'chalk';
-import stringWidth from 'string-width';
-/**
- * Minimal table renderer using string-width@7 for ANSI-aware column sizing.
- */
-export class Table {
-    columns;
-    rows = [];
-    constructor(config) {
-        this.columns = config.columns;
-    }
-    addRow(row) {
-        const sanitized = {};
-        for (const [k, v] of Object.entries(row)) {
-            sanitized[k] = v.replace(/[\r\n]+/g, ' ').trim();
-        }
-        this.rows.push(sanitized);
-    }
-    render() {
-        const widths = this.columns.map((col) => {
-            const headerWidth = stringWidth(col.title);
-            const maxData = this.rows.reduce((max, row) => Math.max(max, stringWidth(row[col.name] ?? '')), 0);
-            return Math.max(headerWidth, maxData);
-        });
-        const pad = (text, width) => {
-            const visible = stringWidth(text);
-            return visible >= width ? text : text + ' '.repeat(width - visible);
-        };
-        const top = '┌' + widths.map((w) => '─'.repeat(w + 2)).join('┬') + '┐';
-        const mid = '├' + widths.map((w) => '─'.repeat(w + 2)).join('┼') + '┤';
-        const bot = '└' + widths.map((w) => '─'.repeat(w + 2)).join('┴') + '┘';
-        const header = '│' +
-            this.columns
-                .map((col, i) => ' ' + chalk.bold(pad(col.title, widths[i])) + ' ')
-                .join('│') +
-            '│';
-        const dataRows = this.rows.map((row) => '│' +
-            this.columns
-                .map((col, i) => {
-                const val = row[col.name] ?? '';
-                const padded = pad(val, widths[i]);
-                if (col.color && col.color in chalk) {
-                    return (' ' +
-                        chalk[col.color](padded) +
-                        ' ');
-                }
-                return ' ' + padded + ' ';
-            })
-                .join('│') +
-            '│');
-        return [top, header, mid, ...dataRows, bot].join('\n');
-    }
-    printTable() {
-        console.log(this.render());
-    }
-}
-//# sourceMappingURL=table.js.map

package/dist/lib/update-check.js

@@ -1,65 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-import https from 'https';
-import { getOutputMode, isQuietMode } from './output-mode.js';
-/**
- * Fire-and-forget check for a newer version on npm.
- * Prints a one-liner to stderr if an update is available.
- * Network failures are silently ignored.
- */
-export function checkForUpdate(currentVersion) {
-    // Suppress in JSON mode, quiet mode, or non-TTY stderr
-    if (getOutputMode() === 'json' || isQuietMode() || !process.stderr.isTTY) {
-        return;
-    }
-    const req = https.get('https://registry.npmjs.org/@guildai/cli/latest', { timeout: 3000 }, (res) => {
-        let data = '';
-        res.on('data', (chunk) => {
-            data += chunk.toString();
-        });
-        res.on('end', () => {
-            try {
-                const pkg = JSON.parse(data);
-                if (pkg.version && isNewer(pkg.version, currentVersion)) {
-                    process.stderr.write(`\nUpdate available: ${currentVersion} → ${pkg.version}  Run: npm install -g @guildai/cli\n`);
-                }
-            }
-            catch {
-                // malformed JSON — ignore
-            }
-        });
-    });
-    req.on('error', () => {
-        // network failure — ignore
-    });
-    req.on('timeout', () => {
-        req.destroy();
-    });
-    // Don't let this request keep the process alive
-    if (req.socket) {
-        req.socket.unref();
-    }
-    else {
-        req.on('socket', (socket) => {
-            socket.unref();
-        });
-    }
-}
-/**
- * Simple numeric version comparison (major.minor.patch).
- * Returns true if `latest` is strictly newer than `current`.
- */
-export function isNewer(latest, current) {
-    const l = latest.split('.').map(Number);
-    const c = current.split('.').map(Number);
-    for (let i = 0; i < Math.max(l.length, c.length); i++) {
-        const lv = l[i] ?? 0;
-        const cv = c[i] ?? 0;
-        if (lv > cv)
-            return true;
-        if (lv < cv)
-            return false;
-    }
-    return false;
-}
-//# sourceMappingURL=update-check.js.map

package/dist/lib/validate-input-schema.js

@@ -1,208 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as os from 'os';
-import { execFile } from 'child_process';
-import { promisify } from 'util';
-import { debug } from './errors.js';
-const execFileAsync = promisify(execFile);
-function resolveSourceEntryPoint(agentDir, packageJson) {
-    const exports = packageJson.exports;
-    if (exports?.['.']) {
-        const distPath = exports['.'];
-        const sourcePath = distPath
-            .replace(/^\.\/dist\//, '')
-            .replace(/\.compiled\.js$/, '.ts')
-            .replace(/\.js$/, '.ts');
-        return path.join(agentDir, sourcePath);
-    }
-    return path.join(agentDir, 'agent.ts');
-}
-async function fileExists(filePath) {
-    return fs
-        .access(filePath)
-        .then(() => true)
-        .catch(() => false);
-}
-/**
- * Extract a single `const <name> = z.<call>(...)` declaration from source,
- * starting at the given regex match. Uses balanced parenthesis matching
- * with string literal awareness.
- */
-function extractZodDeclaration(source, match) {
-    const startIndex = match.index;
-    const afterEquals = match.index + match[0].length;
-    let depth = 0;
-    let foundOpen = false;
-    let endIndex = afterEquals;
-    let inString = null;
-    for (let charIndex = afterEquals; charIndex < source.length; charIndex++) {
-        const char = source[charIndex];
-        if (inString) {
-            if (char === '\\') {
-                charIndex++;
-            }
-            else if (char === inString) {
-                inString = null;
-            }
-            continue;
-        }
-        if (char === '"' || char === "'" || char === '`') {
-            inString = char;
-        }
-        else if (char === '(') {
-            depth++;
-            foundOpen = true;
-        }
-        else if (char === ')') {
-            depth--;
-            if (foundOpen && depth === 0) {
-                endIndex = charIndex + 1;
-                if (source[endIndex] === ';')
-                    endIndex++;
-                break;
-            }
-        }
-    }
-    if (!foundOpen)
-        return null;
-    return source.substring(startIndex, endIndex);
-}
-/**
- * Extract inputSchema and any Zod schema dependencies from agent source.
- * Finds all `const <name> = z.<call>(...)` declarations that appear before
- * inputSchema (which may be referenced inside it), plus inputSchema itself.
- * Returns them in source order so dependencies are defined before use.
- */
-function extractInputSchema(source) {
-    const inputPattern = /const\s+inputSchema\s*=\s*/;
-    const inputMatch = inputPattern.exec(source);
-    if (!inputMatch)
-        return null;
-    const inputBlock = extractZodDeclaration(source, inputMatch);
-    if (!inputBlock)
-        return null;
-    const blocks = [];
-    const zodDeclPattern = /const\s+\w+\s*=\s*z\s*\.\s*/g;
-    let declMatch;
-    while ((declMatch = zodDeclPattern.exec(source)) !== null) {
-        if (declMatch.index >= inputMatch.index)
-            break;
-        const block = extractZodDeclaration(source, declMatch);
-        if (block)
-            blocks.push(block);
-    }
-    blocks.push(inputBlock);
-    return blocks.join('\n');
-}
-export async function validateInputSchema(agentDir, inputs) {
-    const nodeModulesPath = path.join(agentDir, 'node_modules');
-    if (!(await fileExists(nodeModulesPath))) {
-        return {
-            valid: true,
-            skipped: true,
-            reason: 'run npm install for pre-build input validation',
-        };
-    }
-    const pkgJsonPath = path.join(agentDir, 'package.json');
-    if (!(await fileExists(pkgJsonPath))) {
-        return {
-            valid: true,
-            skipped: true,
-            reason: 'no package.json found',
-        };
-    }
-    const pkgJson = JSON.parse(await fs.readFile(pkgJsonPath, 'utf-8'));
-    let entryPoint = resolveSourceEntryPoint(agentDir, pkgJson);
-    if (!(await fileExists(entryPoint))) {
-        const fallback = path.join(agentDir, 'agent.ts');
-        if (await fileExists(fallback)) {
-            entryPoint = fallback;
-        }
-        else {
-            return {
-                valid: true,
-                skipped: true,
-                reason: `could not find agent source file (tried ${path.basename(entryPoint)})`,
-            };
-        }
-    }
-    const agentSource = await fs.readFile(entryPoint, 'utf-8');
-    const schemaBlock = extractInputSchema(agentSource);
-    if (!schemaBlock) {
-        return {
-            valid: true,
-            skipped: true,
-            reason: 'could not find inputSchema definition in agent source',
-        };
-    }
-    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'guild-validate-'));
-    try {
-        const extractorSource = [
-            `import { z } from "zod";`,
-            schemaBlock,
-            `const inputs = JSON.parse(process.argv[2]);`,
-            `const errors = [];`,
-            `for (let i = 0; i < inputs.length; i++) {`,
-            `  try {`,
-            `    inputSchema.parse(inputs[i]);`,
-            `  } catch (e) {`,
-            `    const issues = e.issues || [{ message: e.message }];`,
-            `    errors.push({ index: i, issues: issues.map(iss => ({ message: iss.message, path: iss.path })) });`,
-            `  }`,
-            `}`,
-            `if (errors.length > 0) {`,
-            `  console.log(JSON.stringify({ valid: false, errors }));`,
-            `} else {`,
-            `  console.log(JSON.stringify({ valid: true }));`,
-            `}`,
-        ].join('\n');
-        const extractorPath = path.join(tmpDir, 'validate.mjs');
-        await fs.writeFile(extractorPath, extractorSource);
-        const { build } = await import('esbuild');
-        const bundlePath = path.join(tmpDir, 'validate-bundle.mjs');
-        await build({
-            entryPoints: [extractorPath],
-            bundle: true,
-            format: 'esm',
-            target: 'esnext',
-            platform: 'node',
-            outfile: bundlePath,
-            logLevel: 'silent',
-            nodePaths: [path.join(agentDir, 'node_modules')],
-        });
-        const inputArg = JSON.stringify(inputs);
-        const { stdout } = await execFileAsync('node', [bundlePath, inputArg], {
-            cwd: agentDir,
-            timeout: 10000,
-        });
-        const result = JSON.parse(stdout.trim());
-        if (result.valid) {
-            return { valid: true };
-        }
-        const flatErrors = [];
-        for (const entry of result.errors) {
-            for (const issue of entry.issues) {
-                const prefix = inputs.length > 1 ? `Line ${entry.index + 1}: ` : '';
-                flatErrors.push({
-                    message: `${prefix}${issue.message}`,
-                    path: issue.path,
-                });
-            }
-        }
-        return { valid: false, errors: flatErrors };
-    }
-    catch (error) {
-        debug('Local input validation failed: %s', error);
-        return {
-            valid: true,
-            skipped: true,
-            reason: 'local validation encountered an error (server-side validation will still run)',
-        };
-    }
-    finally {
-        await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => { });
-    }
-}
-//# sourceMappingURL=validate-input-schema.js.map

package/dist/lib/version-helpers.js

@@ -1,137 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-import { GuildAPIClient } from './api-client.js';
-import { pollUntilComplete } from './polling.js';
-/**
- * Format a list of validation steps into a compact single-line status string
- * suitable for spinner text, e.g. `✓ build  ⟳ test  ○ deploy`.
- * Returns null when the steps array is empty so callers can fall back to the
- * default attempt-counter text.
- */
-function formatStepProgress(steps) {
-    if (steps.length === 0)
-        return null;
-    const tokens = steps.map((step) => {
-        let prefix;
-        switch (step.status) {
-            case 'SUCCEEDED':
-                prefix = '✓';
-                break;
-            case 'RUNNING':
-                prefix = '⟳';
-                break;
-            case 'FAILED':
-                prefix = '✗';
-                break;
-            default:
-                prefix = '○';
-        }
-        return `${prefix} ${step.name}`;
-    });
-    return tokens.join('  ');
-}
-/**
- * Poll until a version's validation completes, then check the result.
- * Exits the process on timeout or validation failure.
- * Returns the updated version on success.
- */
-export async function waitForValidation(versionId, output) {
-    const client = new GuildAPIClient();
-    const pollResult = await pollUntilComplete({
-        resourceId: versionId,
-        endpoint: `/versions/${versionId}`,
-        isComplete: (response) => response.validation_status !== 'PENDING' &&
-            response.validation_status !== 'RUNNING',
-        message: 'Waiting for validation to complete...',
-        successMessage: 'Validation complete',
-        timeoutMessage: 'Validation timed out',
-        maxAttempts: 120,
-        delayMs: 1000,
-        onPoll: async () => {
-            const r = await client.get(`/versions/${versionId}/validation/steps`);
-            return formatStepProgress(r.steps);
-        },
-    });
-    if (!pollResult.success || !pollResult.response) {
-        output.error('Validation did not complete in time', 'Check status manually:\n  guild agent versions');
-        process.exit(1);
-    }
-    const version = pollResult.response;
-    if (version.validation_status === 'FAILED') {
-        const details = await fetchValidationFailureDetails(version.id);
-        output.error('Validation failed', details);
-        process.exit(1);
-    }
-    return version;
-}
-/**
- * Fetch validation step details for a failed version.
- * Shows content from all steps (not just failed) so the full build output is visible.
- */
-async function fetchValidationFailureDetails(versionId) {
-    const client = new GuildAPIClient();
-    let failureDetails = '';
-    try {
-        const stepsResponse = await client.get(`/versions/${versionId}/validation/steps`);
-        if (stepsResponse.steps.length > 0) {
-            failureDetails = stepsResponse.steps
-                .map((step) => {
-                let icon;
-                switch (step.status) {
-                    case 'SUCCEEDED':
-                        icon = '✓';
-                        break;
-                    case 'FAILED':
-                    case 'ERRORED':
-                        icon = '✗';
-                        break;
-                    case 'RUNNING':
-                        icon = '⟳';
-                        break;
-                    default:
-                        icon = '○';
-                }
-                const header = `${icon} ${step.name} [${step.status}]`;
-                return step.content ? `${header}\n${step.content}` : header;
-            })
-                .join('\n\n');
-        }
-        else {
-            failureDetails = 'No steps found. Check validation logs for details.';
-        }
-    }
-    catch {
-        failureDetails = 'Could not fetch validation details.';
-    }
-    failureDetails +=
-        '\n\nFix the issues, then save a new version:\n  guild agent save --message "Fix validation errors"';
-    return failureDetails;
-}
-/**
- * Poll until a version's publish completes (PUBLISHING → PUBLISHED).
- * Exits the process on timeout or failure.
- * Returns the updated version on success.
- */
-export async function waitForPublish(versionId, output) {
-    const client = new GuildAPIClient();
-    const pollResult = await pollUntilComplete({
-        resourceId: versionId,
-        endpoint: `/versions/${versionId}`,
-        isComplete: (response) => response.status === 'PUBLISHED' || response.status === 'FAILED',
-        message: 'Waiting for publish to complete...',
-        successMessage: 'Published',
-        timeoutMessage: 'Publish timed out',
-        maxAttempts: 60,
-        delayMs: 1000,
-        onPoll: async () => {
-            const r = await client.get(`/versions/${versionId}/publish/steps`);
-            return formatStepProgress(r.steps);
-        },
-    });
-    if (!pollResult.success || pollResult.response?.status !== 'PUBLISHED') {
-        output.error('Publish did not complete in time', 'Check status manually:\n  guild agent versions');
-        process.exit(1);
-    }
-    return pollResult.response;
-}
-//# sourceMappingURL=version-helpers.js.map