@orchagent/cli 0.3.90 → 0.3.92

package/dist/commands/diff-format.js

@@ -0,0 +1,300 @@
+"use strict";
+/**
+ * Formatting and colorized output for `orch diff`.
+ *
+ * Git-style red/green coloring: removed lines are red, added lines are green,
+ * changed fields show old in red and new in green. Structured fields
+ * (arrays, dependencies, custom_tools, schemas, models) get item-level diffs.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatValuePlain = formatValuePlain;
+exports.formatPromptDiff = formatPromptDiff;
+exports.formatSchemaDiff = formatSchemaDiff;
+exports.formatStringArrayDiff = formatStringArrayDiff;
+exports.formatDependencyDiff = formatDependencyDiff;
+exports.formatCustomToolDiff = formatCustomToolDiff;
+exports.formatModelsDiff = formatModelsDiff;
+exports.printDiffs = printDiffs;
+const chalk_1 = __importDefault(require("chalk"));
+// ── Plain value formatting ────────────────────────────────────
+/** Format a value as plain text (no ANSI colors). */
+function formatValuePlain(val) {
+    if (val === undefined || val === null)
+        return '(none)';
+    if (typeof val === 'boolean')
+        return String(val);
+    if (typeof val === 'string') {
+        if (val.length > 120)
+            return val.slice(0, 117) + '...';
+        return val;
+    }
+    if (Array.isArray(val)) {
+        if (val.length === 0)
+            return '[]';
+        if (typeof val[0] === 'string')
+            return val.join(', ');
+        return JSON.stringify(val, null, 2);
+    }
+    if (typeof val === 'object')
+        return JSON.stringify(val, null, 2);
+    return String(val);
+}
+/** Apply a chalk color function to every line of a string. */
+function colorLines(text, colorFn) {
+    return text.split('\n').map(colorFn).join('\n');
+}
+// ── Prompt diff ───────────────────────────────────────────────
+function formatPromptDiff(oldPrompt, newPrompt) {
+    const oldLines = (oldPrompt || '').split('\n');
+    const newLines = (newPrompt || '').split('\n');
+    const lines = [];
+    const oldSet = new Set(oldLines);
+    const newSet = new Set(newLines);
+    for (const line of oldLines) {
+        if (!newSet.has(line)) {
+            lines.push(chalk_1.default.red(`  - ${line}`));
+        }
+    }
+    for (const line of newLines) {
+        if (!oldSet.has(line)) {
+            lines.push(chalk_1.default.green(`  + ${line}`));
+        }
+    }
+    if (lines.length === 0) {
+        lines.push(chalk_1.default.yellow('  (line order changed)'));
+    }
+    if (lines.length > 40) {
+        const shown = lines.slice(0, 40);
+        shown.push(chalk_1.default.dim(`  ... and ${lines.length - 40} more lines`));
+        return shown.join('\n');
+    }
+    return lines.join('\n');
+}
+// ── Schema diff ───────────────────────────────────────────────
+function formatSchemaDiff(_field, oldSchema, newSchema) {
+    const lines = [];
+    const oldProps = oldSchema?.properties || {};
+    const newProps = newSchema?.properties || {};
+    const oldRequired = new Set(oldSchema?.required || []);
+    const newRequired = new Set(newSchema?.required || []);
+    const allKeys = new Set([...Object.keys(oldProps), ...Object.keys(newProps)]);
+    for (const key of allKeys) {
+        const inOld = key in oldProps;
+        const inNew = key in newProps;
+        if (!inOld && inNew) {
+            const reqMark = newRequired.has(key) ? '' : '?';
+            lines.push(chalk_1.default.green(`  + ${key}${reqMark}: ${newProps[key].type || 'any'}`));
+        }
+        else if (inOld && !inNew) {
+            const reqMark = oldRequired.has(key) ? '' : '?';
+            lines.push(chalk_1.default.red(`  - ${key}${reqMark}: ${oldProps[key].type || 'any'}`));
+        }
+        else if (inOld && inNew) {
+            const oldType = oldProps[key].type || 'any';
+            const newType = newProps[key].type || 'any';
+            const wasReq = oldRequired.has(key);
+            const isReq = newRequired.has(key);
+            if (oldType !== newType || wasReq !== isReq) {
+                const oldMark = wasReq ? '' : '?';
+                const newMark = isReq ? '' : '?';
+                lines.push(chalk_1.default.red(`  - ${key}${oldMark}: ${oldType}`));
+                lines.push(chalk_1.default.green(`  + ${key}${newMark}: ${newType}`));
+            }
+        }
+    }
+    return lines.join('\n');
+}
+// ── String array diff ─────────────────────────────────────────
+/** Item-level diff for simple string arrays (tags, providers, secrets, skills). */
+function formatStringArrayDiff(oldArr, newArr) {
+    const oldSet = new Set(oldArr);
+    const newSet = new Set(newArr);
+    const lines = [];
+    for (const item of oldArr) {
+        if (!newSet.has(item)) {
+            lines.push(chalk_1.default.red(`  - ${item}`));
+        }
+    }
+    for (const item of newArr) {
+        if (!oldSet.has(item)) {
+            lines.push(chalk_1.default.green(`  + ${item}`));
+        }
+    }
+    // Show items present in both (unchanged) for context
+    for (const item of newArr) {
+        if (oldSet.has(item)) {
+            lines.push(chalk_1.default.dim(`    ${item}`));
+        }
+    }
+    return lines.join('\n');
+}
+// ── Dependency diff ───────────────────────────────────────────
+/** Item-level diff for ManifestDependency arrays. Shows version changes. */
+function formatDependencyDiff(oldDeps, newDeps) {
+    const oldMap = new Map(oldDeps.map(d => [d.id, d.version]));
+    const newMap = new Map(newDeps.map(d => [d.id, d.version]));
+    const allIds = new Set([...oldMap.keys(), ...newMap.keys()]);
+    const lines = [];
+    for (const id of allIds) {
+        const oldV = oldMap.get(id);
+        const newV = newMap.get(id);
+        if (oldV && !newV) {
+            lines.push(chalk_1.default.red(`  - ${id}@${oldV}`));
+        }
+        else if (!oldV && newV) {
+            lines.push(chalk_1.default.green(`  + ${id}@${newV}`));
+        }
+        else if (oldV && newV && oldV !== newV) {
+            lines.push(`  ${id}: ${chalk_1.default.red(oldV)} ${chalk_1.default.yellow('\u2192')} ${chalk_1.default.green(newV)}`);
+        }
+        else {
+            lines.push(chalk_1.default.dim(`    ${id}@${oldV}`));
+        }
+    }
+    return lines.join('\n');
+}
+// ── Custom tool diff ──────────────────────────────────────────
+/** Item-level diff for CustomTool arrays. */
+function formatCustomToolDiff(oldTools, newTools) {
+    const oldMap = new Map(oldTools.map(t => [t.name, t]));
+    const newMap = new Map(newTools.map(t => [t.name, t]));
+    const allNames = new Set([...oldMap.keys(), ...newMap.keys()]);
+    const lines = [];
+    for (const name of allNames) {
+        const oldT = oldMap.get(name);
+        const newT = newMap.get(name);
+        if (oldT && !newT) {
+            lines.push(chalk_1.default.red(`  - ${name}`));
+        }
+        else if (!oldT && newT) {
+            lines.push(chalk_1.default.green(`  + ${name}`));
+            if (newT.description)
+                lines.push(chalk_1.default.green(`      ${newT.description}`));
+        }
+        else if (oldT && newT && JSON.stringify(oldT) !== JSON.stringify(newT)) {
+            lines.push(`  ~ ${chalk_1.default.bold(name)}`);
+            if (oldT.description !== newT.description) {
+                lines.push(`    desc: ${chalk_1.default.red(oldT.description || '(none)')} ${chalk_1.default.yellow('\u2192')} ${chalk_1.default.green(newT.description || '(none)')}`);
+            }
+            if (oldT.command !== newT.command) {
+                lines.push(`    cmd:  ${chalk_1.default.red(oldT.command || '(none)')} ${chalk_1.default.yellow('\u2192')} ${chalk_1.default.green(newT.command || '(none)')}`);
+            }
+        }
+        else {
+            lines.push(chalk_1.default.dim(`    ${name}`));
+        }
+    }
+    return lines.join('\n');
+}
+// ── Models (key-value object) diff ────────────────────────────
+/** Key-level diff for Record<string, string> objects like default_models. */
+function formatModelsDiff(oldObj, newObj) {
+    const old = oldObj || {};
+    const nw = newObj || {};
+    const allKeys = new Set([...Object.keys(old), ...Object.keys(nw)]);
+    const lines = [];
+    for (const key of allKeys) {
+        if (key in old && !(key in nw)) {
+            lines.push(chalk_1.default.red(`  - ${key}: ${old[key]}`));
+        }
+        else if (!(key in old) && key in nw) {
+            lines.push(chalk_1.default.green(`  + ${key}: ${nw[key]}`));
+        }
+        else if (old[key] !== nw[key]) {
+            lines.push(`  ${key}: ${chalk_1.default.red(old[key])} ${chalk_1.default.yellow('\u2192')} ${chalk_1.default.green(nw[key])}`);
+        }
+    }
+    return lines.join('\n');
+}
+// ── Main printer ──────────────────────────────────────────────
+/** Render a colorized diff to stdout. */
+function printDiffs(refA, refB, diffs) {
+    process.stdout.write('\n');
+    process.stdout.write(chalk_1.default.bold(`${refA}  ${chalk_1.default.yellow('\u2192')}  ${refB}`) + '\n');
+    process.stdout.write(chalk_1.default.dim('\u2500'.repeat(50)) + '\n\n');
+    if (diffs.length === 0) {
+        process.stdout.write(chalk_1.default.green('No differences found.') + '\n');
+        return;
+    }
+    process.stdout.write(`${chalk_1.default.bold(String(diffs.length))} ${diffs.length === 1 ? 'change' : 'changes'}:\n\n`);
+    // Fields that get item-level diff when changed
+    const stringArrayFields = new Set([
+        'supported_providers', 'tags', 'default_skills', 'required_secrets',
+    ]);
+    for (const diff of diffs) {
+        // ── Schema fields: property-level diff ──
+        if ((diff.field === 'input_schema' || diff.field === 'output_schema') &&
+            diff.kind === 'changed') {
+            process.stdout.write(chalk_1.default.cyan(`~ ${diff.field}:`) + '\n');
+            process.stdout.write(formatSchemaDiff(diff.field, diff.old, diff.new) + '\n\n');
+            continue;
+        }
+        // ── Prompt: line-level diff ──
+        if (diff.field === 'prompt' && diff.kind === 'changed') {
+            process.stdout.write(chalk_1.default.cyan(`~ prompt:`) + '\n');
+            process.stdout.write(formatPromptDiff(diff.old, diff.new) + '\n\n');
+            continue;
+        }
+        // ── String arrays: item-level diff ──
+        if (stringArrayFields.has(diff.field) && diff.kind === 'changed') {
+            process.stdout.write(chalk_1.default.cyan(`~ ${diff.field}:`) + '\n');
+            process.stdout.write(formatStringArrayDiff(diff.old, diff.new) + '\n\n');
+            continue;
+        }
+        // ── Dependencies: item-level diff ──
+        if (diff.field === 'dependencies' && diff.kind === 'changed') {
+            process.stdout.write(chalk_1.default.cyan(`~ dependencies:`) + '\n');
+            process.stdout.write(formatDependencyDiff(diff.old, diff.new) + '\n\n');
+            continue;
+        }
+        // ── Custom tools: item-level diff ──
+        if (diff.field === 'custom_tools' && diff.kind === 'changed') {
+            process.stdout.write(chalk_1.default.cyan(`~ custom_tools:`) + '\n');
+            process.stdout.write(formatCustomToolDiff(diff.old, diff.new) + '\n\n');
+            continue;
+        }
+        // ── Default models: key-level diff ──
+        if (diff.field === 'default_models' && diff.kind === 'changed') {
+            process.stdout.write(chalk_1.default.cyan(`~ default_models:`) + '\n');
+            process.stdout.write(formatModelsDiff(diff.old, diff.new) + '\n\n');
+            continue;
+        }
+        // ── Standard scalar fields ──
+        if (diff.kind === 'added') {
+            const formatted = formatValuePlain(diff.new);
+            if (formatted.includes('\n')) {
+                process.stdout.write(chalk_1.default.green(`+ ${diff.field}:`) + '\n');
+                process.stdout.write(colorLines(formatted, l => chalk_1.default.green(`  ${l}`)) + '\n\n');
+            }
+            else {
+                process.stdout.write(chalk_1.default.green(`+ ${diff.field}: ${formatted}`) + '\n');
+            }
+        }
+        else if (diff.kind === 'removed') {
+            const formatted = formatValuePlain(diff.old);
+            if (formatted.includes('\n')) {
+                process.stdout.write(chalk_1.default.red(`- ${diff.field}:`) + '\n');
+                process.stdout.write(colorLines(formatted, l => chalk_1.default.red(`  ${l}`)) + '\n\n');
+            }
+            else {
+                process.stdout.write(chalk_1.default.red(`- ${diff.field}: ${formatted}`) + '\n');
+            }
+        }
+        else {
+            // changed — old in red, new in green
+            const oldFmt = formatValuePlain(diff.old);
+            const newFmt = formatValuePlain(diff.new);
+            if (!oldFmt.includes('\n') && !newFmt.includes('\n')) {
+                process.stdout.write(`${chalk_1.default.cyan('~')} ${chalk_1.default.bold(diff.field)}: ${chalk_1.default.red(oldFmt)} ${chalk_1.default.yellow('\u2192')} ${chalk_1.default.green(newFmt)}\n`);
+            }
+            else {
+                process.stdout.write(chalk_1.default.cyan(`~ ${diff.field}:`) + '\n');
+                process.stdout.write(colorLines(oldFmt, l => chalk_1.default.red(`  - ${l}`)) + '\n');
+                process.stdout.write(colorLines(newFmt, l => chalk_1.default.green(`  + ${l}`)) + '\n\n');
+            }
+        }
+    }
+}

package/dist/commands/diff.js

@@ -1,15 +1,13 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.computeDiffs = computeDiffs;
 exports.registerDiffCommand = registerDiffCommand;
-const chalk_1 = __importDefault(require("chalk"));
 const config_1 = require("../lib/config");
 const api_1 = require("../lib/api");
 const agent_ref_1 = require("../lib/agent-ref");
+const errors_1 = require("../lib/errors");
 const spinner_1 = require("../lib/spinner");
+const diff_format_1 = require("./diff-format");
 // ── Helpers ────────────────────────────────────────────────────
 function extractDependencies(manifest) {
     if (!manifest)
@@ -236,130 +234,6 @@ function computeDiffs(a, b) {
     }
     return diffs;
 }
-// ── Formatting ─────────────────────────────────────────────────
-function formatValue(val) {
-    if (val === undefined || val === null)
-        return chalk_1.default.gray('(none)');
-    if (typeof val === 'boolean')
-        return val ? chalk_1.default.green('true') : chalk_1.default.red('false');
-    if (typeof val === 'string') {
-        if (val.length > 120)
-            return val.slice(0, 117) + '...';
-        return val;
-    }
-    if (Array.isArray(val)) {
-        if (val.length === 0)
-            return chalk_1.default.gray('[]');
-        // Array of strings
-        if (typeof val[0] === 'string')
-            return val.join(', ');
-        // Array of objects — compact JSON
-        return JSON.stringify(val, null, 2);
-    }
-    if (typeof val === 'object')
-        return JSON.stringify(val, null, 2);
-    return String(val);
-}
-function formatPromptDiff(oldPrompt, newPrompt) {
-    const oldLines = (oldPrompt || '').split('\n');
-    const newLines = (newPrompt || '').split('\n');
-    const lines = [];
-    // Simple line-by-line diff (not LCS — good enough for prompt comparison)
-    const maxLines = Math.max(oldLines.length, newLines.length);
-    const oldSet = new Set(oldLines);
-    const newSet = new Set(newLines);
-    for (const line of oldLines) {
-        if (!newSet.has(line)) {
-            lines.push(chalk_1.default.red(`  - ${line}`));
-        }
-    }
-    for (const line of newLines) {
-        if (!oldSet.has(line)) {
-            lines.push(chalk_1.default.green(`  + ${line}`));
-        }
-    }
-    if (lines.length === 0) {
-        // Lines are the same but order changed
-        lines.push(chalk_1.default.yellow('  (line order changed)'));
-    }
-    // Truncate if very large
-    if (lines.length > 40) {
-        const shown = lines.slice(0, 40);
-        shown.push(chalk_1.default.gray(`  ... and ${lines.length - 40} more lines`));
-        return shown.join('\n');
-    }
-    return lines.join('\n');
-}
-function formatSchemaDiff(field, oldSchema, newSchema) {
-    const lines = [];
-    const oldProps = oldSchema?.properties || {};
-    const newProps = newSchema?.properties || {};
-    const oldRequired = new Set(oldSchema?.required || []);
-    const newRequired = new Set(newSchema?.required || []);
-    const allKeys = new Set([...Object.keys(oldProps), ...Object.keys(newProps)]);
-    for (const key of allKeys) {
-        const inOld = key in oldProps;
-        const inNew = key in newProps;
-        if (!inOld && inNew) {
-            const reqMark = newRequired.has(key) ? '' : '?';
-            lines.push(chalk_1.default.green(`  + ${key}${reqMark}: ${newProps[key].type || 'any'}`));
-        }
-        else if (inOld && !inNew) {
-            const reqMark = oldRequired.has(key) ? '' : '?';
-            lines.push(chalk_1.default.red(`  - ${key}${reqMark}: ${oldProps[key].type || 'any'}`));
-        }
-        else if (inOld && inNew) {
-            const oldType = oldProps[key].type || 'any';
-            const newType = newProps[key].type || 'any';
-            const wasReq = oldRequired.has(key);
-            const isReq = newRequired.has(key);
-            if (oldType !== newType || wasReq !== isReq) {
-                const oldMark = wasReq ? '' : '?';
-                const newMark = isReq ? '' : '?';
-                lines.push(chalk_1.default.red(`  - ${key}${oldMark}: ${oldType}`));
-                lines.push(chalk_1.default.green(`  + ${key}${newMark}: ${newType}`));
-            }
-        }
-    }
-    return lines.join('\n');
-}
-function printDiffs(refA, refB, diffs) {
-    process.stdout.write('\n');
-    process.stdout.write(chalk_1.default.bold(`${refA}  ${chalk_1.default.yellow('→')}  ${refB}`) + '\n');
-    process.stdout.write('='.repeat(50) + '\n\n');
-    if (diffs.length === 0) {
-        process.stdout.write(chalk_1.default.green('No differences found.') + '\n');
-        return;
-    }
-    process.stdout.write(`${chalk_1.default.bold(String(diffs.length))} ${diffs.length === 1 ? 'change' : 'changes'}:\n\n`);
-    for (const diff of diffs) {
-        // Schema fields get special formatting
-        if ((diff.field === 'input_schema' || diff.field === 'output_schema') && diff.kind === 'changed') {
-            process.stdout.write(chalk_1.default.cyan(`~ ${diff.field}:`) + '\n');
-            process.stdout.write(formatSchemaDiff(diff.field, diff.old, diff.new) + '\n\n');
-            continue;
-        }
-        // Prompt gets special formatting
-        if (diff.field === 'prompt' && diff.kind === 'changed') {
-            process.stdout.write(chalk_1.default.cyan(`~ prompt:`) + '\n');
-            process.stdout.write(formatPromptDiff(diff.old, diff.new) + '\n\n');
-            continue;
-        }
-        // Standard fields
-        const prefix = diff.kind === 'added' ? chalk_1.default.green('+')
-            : diff.kind === 'removed' ? chalk_1.default.red('-')
-                : chalk_1.default.cyan('~');
-        if (diff.kind === 'added') {
-            process.stdout.write(`${prefix} ${chalk_1.default.bold(diff.field)}: ${formatValue(diff.new)}\n`);
-        }
-        else if (diff.kind === 'removed') {
-            process.stdout.write(`${prefix} ${chalk_1.default.bold(diff.field)}: ${formatValue(diff.old)}\n`);
-        }
-        else {
-            process.stdout.write(`${prefix} ${chalk_1.default.bold(diff.field)}: ${formatValue(diff.old)} ${chalk_1.default.yellow('→')} ${formatValue(diff.new)}\n`);
-        }
-    }
-}
 // ── Ref parsing ────────────────────────────────────────────────
 /**
  * Parse second ref which can be:
@@ -369,7 +243,8 @@ function printDiffs(refA, refB, diffs) {
 function parseSecondRef(value, firstOrg, firstName) {
     // If it contains '/', treat as full ref
     if (value.includes('/')) {
-        return (0, agent_ref_1.parseAgentRef)(value);
+        const parsed = (0, agent_ref_1.parseAgentRef)(value);
+        return { org: parsed.org ?? firstOrg, agent: parsed.agent, version: parsed.version };
     }
     // Otherwise treat as a version shorthand for the same agent
     return { org: firstOrg, agent: firstName, version: value };
@@ -382,7 +257,13 @@ function registerDiffCommand(program) {
         .option('--json', 'Output as JSON')
         .action(async (ref1Arg, ref2Arg, options) => {
         const config = await (0, config_1.getResolvedConfig)();
-        const ref1 = (0, agent_ref_1.parseAgentRef)(ref1Arg);
+        const ref1Raw = (0, agent_ref_1.parseAgentRef)(ref1Arg);
+        const configFile = await (0, config_1.loadConfig)();
+        const ref1Org = ref1Raw.org ?? configFile.workspace ?? config.defaultOrg;
+        if (!ref1Org) {
+            throw new errors_1.CliError('Missing org. Use org/agent format or set default org.');
+        }
+        const ref1 = { org: ref1Org, agent: ref1Raw.agent, version: ref1Raw.version };
         let ref2;
         if (ref2Arg) {
             ref2 = parseSecondRef(ref2Arg, ref1.org, ref1.agent);
@@ -413,6 +294,6 @@ function registerDiffCommand(program) {
             }, null, 2) + '\n');
             return;
         }
-        printDiffs(refALabel, refBLabel, diffs);
+        (0, diff_format_1.printDiffs)(refALabel, refBLabel, diffs);
     });
 }

package/dist/commands/estimate.js

@@ -35,11 +35,14 @@ function registerEstimateCommand(program) {
         .option('--json', 'Output as JSON')
         .action(async (agentArg, options) => {
         const config = await (0, config_1.getResolvedConfig)();
-        const { org, agent, version } = (0, agent_ref_1.parseAgentRef)(agentArg);
+        const parsed = (0, agent_ref_1.parseAgentRef)(agentArg);
+        const configFile = await (0, config_1.loadConfig)();
+        const org = parsed.org ?? configFile.workspace ?? config.defaultOrg;
         if (!org) {
-            process.stderr.write(chalk_1.default.red('Error: org/agent format required (e.g. myorg/my-agent)\n'));
+            process.stderr.write(chalk_1.default.red('Error: Missing org. Use org/agent format or set default org.\n'));
             process.exit(1);
         }
+        const { agent, version } = parsed;
         let data;
         try {
             data = await (0, api_1.getAgentCostEstimate)(config, org, agent, version);

package/dist/commands/fork.js

@@ -56,7 +56,13 @@ Examples:
         if (!config.apiKey) {
             throw new errors_1.CliError('Not logged in. Run `orchagent login` first.');
         }
-        const { org, agent, version } = (0, agent_ref_1.parseAgentRef)(agentRef);
+        const parsed = (0, agent_ref_1.parseAgentRef)(agentRef);
+        const configFile = await (0, config_1.loadConfig)();
+        const org = parsed.org ?? configFile.workspace ?? config.defaultOrg;
+        if (!org) {
+            throw new errors_1.CliError('Missing org. Use org/agent format or set default org.');
+        }
+        const { agent, version } = parsed;
         write('Resolving source agent...\n');
         const source = await (0, api_1.getAgentWithFallback)(config, org, agent, version);
         if (!source.id) {

package/dist/commands/health.js

@@ -14,7 +14,8 @@ const output_1 = require("../lib/output");
 const package_json_1 = __importDefault(require("../../package.json"));
 /**
  * Generate a minimal sample input from an agent's input schema.
- * Produces just enough to satisfy required fields.
+ * Produces just enough to satisfy required fields, using schema hints
+ * (format, examples, field name conventions) to create realistic values.
  */
 function generateSampleInput(schema) {
     if (!schema?.properties)
@@ -24,28 +25,110 @@ function generateSampleInput(schema) {
     for (const [key, prop] of Object.entries(schema.properties)) {
         if (!required.has(key))
             continue;
-        result[key] = sampleValue(prop);
+        result[key] = sampleValue(prop, key);
     }
     // If no required fields, fill one optional field so the request isn't empty
     if (Object.keys(result).length === 0) {
         const firstKey = Object.keys(schema.properties)[0];
         if (firstKey) {
-            result[firstKey] = sampleValue(schema.properties[firstKey]);
+            result[firstKey] = sampleValue(schema.properties[firstKey], firstKey);
         }
     }
     return Object.keys(result).length > 0 ? result : undefined;
 }
-function sampleValue(prop) {
+/** Well-known JSON Schema string formats → realistic sample values. */
+const FORMAT_SAMPLES = {
+    uri: 'https://example.com',
+    url: 'https://example.com',
+    iri: 'https://example.com',
+    'uri-reference': '/test',
+    'iri-reference': '/test',
+    email: 'test@example.com',
+    'idn-email': 'test@example.com',
+    date: '2026-01-01',
+    'date-time': '2026-01-01T00:00:00Z',
+    time: '12:00:00',
+    uuid: '00000000-0000-0000-0000-000000000000',
+    hostname: 'example.com',
+    'idn-hostname': 'example.com',
+    ipv4: '192.0.2.1',
+    ipv6: '::1',
+    'json-pointer': '/test',
+    'relative-json-pointer': '0/test',
+    regex: '.*',
+};
+/**
+ * Field name segments that suggest a specific value type.
+ * Checked after format (format takes priority).
+ */
+const NAME_HINT_SAMPLES = [
+    { segments: new Set(['url', 'uri', 'href', 'link', 'endpoint', 'webhook']), value: 'https://example.com' },
+    { segments: new Set(['email']), value: 'test@example.com' },
+    { segments: new Set(['path', 'file', 'filename', 'filepath']), value: '/tmp/test' },
+    { segments: new Set(['date', 'timestamp']), value: '2026-01-01' },
+    { segments: new Set(['phone', 'tel', 'telephone']), value: '+12025551234' },
+    { segments: new Set(['ip', 'ipaddr', 'ipaddress']), value: '192.0.2.1' },
+    { segments: new Set(['host', 'hostname', 'domain']), value: 'example.com' },
+    { segments: new Set(['uuid', 'guid']), value: '00000000-0000-0000-0000-000000000000' },
+];
+function sampleString(prop, fieldName) {
+    // 1. Schema format (highest priority after default/enum)
+    if (prop.format && FORMAT_SAMPLES[prop.format]) {
+        return FORMAT_SAMPLES[prop.format];
+    }
+    // 2. Field name heuristics — split on _ and - to get semantic segments
+    if (fieldName) {
+        const segments = new Set(fieldName.toLowerCase().split(/[_-]/));
+        for (const hint of NAME_HINT_SAMPLES) {
+            for (const seg of segments) {
+                if (hint.segments.has(seg))
+                    return hint.value;
+            }
+        }
+    }
+    // 3. Respect minLength
+    const base = 'test';
+    if (prop.minLength && prop.minLength > base.length) {
+        return base + 'x'.repeat(prop.minLength - base.length);
+    }
+    return base;
+}
+function sampleNumber(prop) {
+    const min = prop.exclusiveMinimum !== undefined
+        ? prop.exclusiveMinimum + 1
+        : prop.minimum;
+    const max = prop.exclusiveMaximum !== undefined
+        ? prop.exclusiveMaximum - 1
+        : prop.maximum;
+    if (min !== undefined && max !== undefined) {
+        return prop.type === 'integer' ? Math.ceil((min + max) / 2) : (min + max) / 2;
+    }
+    if (min !== undefined)
+        return min;
+    if (max !== undefined)
+        return max;
+    return 1;
+}
+function sampleArray(prop) {
+    const count = prop.minItems || 0;
+    if (count === 0)
+        return [];
+    const itemProp = prop.items || { type: 'string' };
+    return Array.from({ length: count }, () => sampleValue(itemProp));
+}
+function sampleValue(prop, fieldName) {
     if (prop.default !== undefined)
         return prop.default;
+    if (prop.examples?.length)
+        return prop.examples[0];
     if (prop.enum?.length)
         return prop.enum[0];
     switch (prop.type) {
-        case 'string': return 'test';
+        case 'string': return sampleString(prop, fieldName);
         case 'number':
-        case 'integer': return 1;
+        case 'integer': return sampleNumber(prop);
         case 'boolean': return true;
-        case 'array': return [];
+        case 'array': return sampleArray(prop);
         case 'object': return {};
         default: return 'test';
     }

package/dist/commands/index.js

@@ -5,6 +5,7 @@ const login_1 = require("./login");
 const logout_1 = require("./logout");
 const agents_1 = require("./agents");
 const init_1 = require("./init");
+const scaffold_1 = require("./scaffold");
 const publish_1 = require("./publish");
 const whoami_1 = require("./whoami");
 const run_1 = require("./run");
@@ -42,11 +43,14 @@ const replay_1 = require("./replay");
 const trace_1 = require("./trace");
 const metrics_1 = require("./metrics");
 const dag_1 = require("./dag");
+const completion_1 = require("./completion");
+const validate_1 = require("./validate");
 function registerCommands(program) {
     (0, login_1.registerLoginCommand)(program);
     (0, logout_1.registerLogoutCommand)(program);
     (0, whoami_1.registerWhoamiCommand)(program);
     (0, init_1.registerInitCommand)(program);
+    (0, scaffold_1.registerScaffoldCommand)(program);
     (0, publish_1.registerPublishCommand)(program);
     (0, run_1.registerRunCommand)(program);
     (0, info_1.registerInfoCommand)(program);
@@ -84,4 +88,6 @@ function registerCommands(program) {
     (0, trace_1.registerTraceCommand)(program);
     (0, metrics_1.registerMetricsCommand)(program);
     (0, dag_1.registerDagCommand)(program);
+    (0, completion_1.registerCompletionCommand)(program);
+    (0, validate_1.registerValidateCommand)(program);
 }