@orchagent/cli 0.3.86 → 0.3.88

package/dist/commands/trace.js

@@ -0,0 +1,311 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTraceCommand = registerTraceCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const errors_1 = require("../lib/errors");
+const output_1 = require("../lib/output");
+// ============================================
+// HELPERS
+// ============================================
+async function resolveWorkspaceId(config, slug) {
+    const configFile = await (0, config_1.loadConfig)();
+    const targetSlug = slug ?? configFile.workspace;
+    if (!targetSlug) {
+        throw new errors_1.CliError('No workspace specified. Use --workspace <slug> or run `orch workspace use <slug>` first.');
+    }
+    const response = await (0, api_1.request)(config, 'GET', '/workspaces');
+    const workspace = response.workspaces.find((w) => w.slug === targetSlug);
+    if (!workspace) {
+        throw new errors_1.CliError(`Workspace '${targetSlug}' not found.`);
+    }
+    return workspace.id;
+}
+function isUuid(value) {
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
+}
+function isShortUuid(value) {
+    return /^[0-9a-f]{7,}$/i.test(value) && !value.includes('/');
+}
+async function resolveShortRunId(config, workspaceId, shortId) {
+    const result = await (0, api_1.request)(config, 'GET', `/workspaces/${workspaceId}/runs?limit=200&run_id_prefix=${encodeURIComponent(shortId)}`);
+    if (result.runs.length === 0) {
+        throw new errors_1.CliError(`No run found matching '${shortId}'.`);
+    }
+    if (result.runs.length > 1) {
+        throw new errors_1.CliError(`Ambiguous run ID '${shortId}' — matches ${result.runs.length} runs. Use more characters to narrow it down.`);
+    }
+    return result.runs[0].id;
+}
+function statusColor(status) {
+    if (!status)
+        return '-';
+    switch (status) {
+        case 'completed':
+            return chalk_1.default.green(status);
+        case 'failed':
+            return chalk_1.default.red(status);
+        case 'running':
+            return chalk_1.default.yellow(status);
+        case 'timeout':
+            return chalk_1.default.red(status);
+        default:
+            return status;
+    }
+}
+function formatDuration(ms) {
+    if (ms == null)
+        return '-';
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    return `${(ms / 60000).toFixed(1)}m`;
+}
+function formatCost(usd) {
+    if (usd == null || usd === 0)
+        return '-';
+    if (usd < 0.01)
+        return `$${usd.toFixed(6)}`;
+    return `$${usd.toFixed(4)}`;
+}
+function formatTokens(input, output) {
+    const parts = [];
+    if (input)
+        parts.push(`${input.toLocaleString()} in`);
+    if (output)
+        parts.push(`${output.toLocaleString()} out`);
+    return parts.length > 0 ? parts.join(', ') : '-';
+}
+// ============================================
+// COMMAND REGISTRATION
+// ============================================
+function registerTraceCommand(program) {
+    program
+        .command('trace <run-id>')
+        .description('View the execution trace for a run. Shows LLM calls, tool calls, decisions, and errors in timeline order.')
+        .option('--workspace <slug>', 'Workspace slug (default: current workspace)')
+        .option('--json', 'Output as JSON')
+        .action(async (runId, options) => {
+        const config = await (0, config_1.getResolvedConfig)();
+        if (!config.apiKey) {
+            throw new errors_1.CliError('Missing API key. Run `orch login` first.');
+        }
+        const workspaceId = await resolveWorkspaceId(config, options.workspace);
+        // Resolve short run IDs
+        let resolvedRunId = runId;
+        if (isUuid(runId)) {
+            resolvedRunId = runId;
+        }
+        else if (isShortUuid(runId)) {
+            resolvedRunId = await resolveShortRunId(config, workspaceId, runId);
+        }
+        else {
+            throw new errors_1.CliError(`Invalid run ID '${runId}'. Provide a full UUID or a short hex prefix (7+ characters).`);
+        }
+        // Fetch run detail for context
+        const run = await (0, api_1.request)(config, 'GET', `/workspaces/${workspaceId}/runs/${resolvedRunId}`);
+        // Fetch trace header
+        let trace;
+        try {
+            const traceResp = await (0, api_1.request)(config, 'GET', `/workspaces/${workspaceId}/runs/${resolvedRunId}/trace`);
+            trace = traceResp.trace;
+        }
+        catch {
+            throw new errors_1.CliError(`No trace available for run ${resolvedRunId.slice(0, 8)}. Traces are captured for cloud runs only.`);
+        }
+        // Fetch all trace events (paginate if needed)
+        const allEvents = [];
+        let offset = 0;
+        const pageSize = 500;
+        while (true) {
+            const eventsResp = await (0, api_1.request)(config, 'GET', `/workspaces/${workspaceId}/traces/${trace.id}/events?limit=${pageSize}&offset=${offset}`);
+            allEvents.push(...eventsResp.events);
+            if (eventsResp.next_cursor === null || allEvents.length >= eventsResp.total) {
+                break;
+            }
+            offset = parseInt(eventsResp.next_cursor, 10);
+        }
+        if (options.json) {
+            (0, output_1.printJson)({ run, trace, events: allEvents });
+            return;
+        }
+        renderTrace(run, trace, allEvents);
+    });
+}
+// ============================================
+// TRACE RENDERING
+// ============================================
+function renderTrace(run, trace, events) {
+    // Header
+    process.stdout.write(chalk_1.default.bold(`\nTrace for run ${run.id}\n`) +
+        `  Agent:    ${run.agent_name ?? '-'}@${run.agent_version ?? '-'}\n` +
+        `  Status:   ${statusColor(run.status)}\n` +
+        `  Duration: ${formatDuration(run.duration_ms)}\n` +
+        `  Source:   ${run.trigger_source ?? '-'}\n`);
+    // Aggregate stats
+    const stats = computeStats(events);
+    if (stats.totalLlmCalls > 0 || stats.totalToolCalls > 0) {
+        process.stdout.write('\n' + chalk_1.default.bold('  Summary\n'));
+        if (stats.totalLlmCalls > 0) {
+            process.stdout.write(`    LLM calls:   ${stats.totalLlmCalls}` +
+                `  (${formatTokens(stats.totalTokenInput, stats.totalTokenOutput)})` +
+                `  cost: ${formatCost(stats.totalCostUsd)}\n`);
+        }
+        if (stats.totalToolCalls > 0) {
+            process.stdout.write(`    Tool calls:  ${stats.totalToolCalls}\n`);
+        }
+        if (stats.providers.length > 0) {
+            process.stdout.write(`    Providers:   ${stats.providers.join(', ')}\n`);
+        }
+        if (stats.totalErrors > 0) {
+            process.stdout.write(`    Errors:      ${chalk_1.default.red(String(stats.totalErrors))}\n`);
+        }
+    }
+    if (events.length === 0) {
+        process.stdout.write(chalk_1.default.gray('\n  No trace events recorded.\n\n'));
+        return;
+    }
+    // Timeline
+    process.stdout.write('\n' + chalk_1.default.bold('  Timeline\n'));
+    for (const event of events) {
+        renderEvent(event);
+    }
+    process.stdout.write('\n');
+    // Footer hint
+    process.stdout.write(chalk_1.default.gray(`View logs: orch logs ${run.id.slice(0, 8)}\n`));
+    process.stdout.write(chalk_1.default.gray(`Replay:   orch replay ${run.id.slice(0, 8)}\n`));
+}
+function computeStats(events) {
+    const stats = {
+        totalLlmCalls: 0,
+        totalToolCalls: 0,
+        totalErrors: 0,
+        totalTokenInput: 0,
+        totalTokenOutput: 0,
+        totalCostUsd: 0,
+        providers: [],
+    };
+    const providerSet = new Set();
+    for (const e of events) {
+        if (e.event_type === 'llm_call_succeeded') {
+            stats.totalLlmCalls++;
+            stats.totalTokenInput += e.token_input ?? 0;
+            stats.totalTokenOutput += e.token_output ?? 0;
+            stats.totalCostUsd += e.cost_usd ?? 0;
+            if (e.provider)
+                providerSet.add(e.provider);
+        }
+        else if (e.event_type === 'llm_call_failed') {
+            stats.totalLlmCalls++;
+            stats.totalErrors++;
+            if (e.provider)
+                providerSet.add(e.provider);
+        }
+        else if (e.event_type === 'tool_call_succeeded') {
+            stats.totalToolCalls++;
+        }
+        else if (e.event_type === 'tool_call_failed') {
+            stats.totalToolCalls++;
+            stats.totalErrors++;
+        }
+        else if (e.event_type === 'error') {
+            stats.totalErrors++;
+        }
+        else if (e.event_type === 'policy_violation') {
+            stats.totalErrors++;
+        }
+    }
+    stats.providers = Array.from(providerSet);
+    return stats;
+}
+function renderEvent(event) {
+    const seq = chalk_1.default.gray(`  #${String(event.sequence_no).padStart(2, ' ')} `);
+    switch (event.event_type) {
+        case 'llm_call_started': {
+            const provider = event.provider ?? '?';
+            const model = event.model ?? '?';
+            process.stdout.write(seq + chalk_1.default.blue('LLM ') + chalk_1.default.gray(`${provider}/${model} started\n`));
+            break;
+        }
+        case 'llm_call_succeeded': {
+            const provider = event.provider ?? '?';
+            const model = event.model ?? '?';
+            const tokens = formatTokens(event.token_input, event.token_output);
+            const cost = formatCost(event.cost_usd);
+            const dur = formatDuration(event.duration_ms);
+            process.stdout.write(seq + chalk_1.default.green('LLM ') +
+                `${provider}/${model}` +
+                chalk_1.default.gray(` | ${tokens} | ${cost} | ${dur}`) + '\n');
+            break;
+        }
+        case 'llm_call_failed': {
+            const provider = event.provider ?? '?';
+            const model = event.model ?? '?';
+            const errMsg = event.error_message || event.error_type || 'unknown error';
+            const dur = formatDuration(event.duration_ms);
+            process.stdout.write(seq + chalk_1.default.red('LLM ') +
+                `${provider}/${model} ` +
+                chalk_1.default.red(errMsg) +
+                chalk_1.default.gray(` | ${dur}`) + '\n');
+            break;
+        }
+        case 'tool_call_started': {
+            const toolName = event.payload?.tool_name || '?';
+            process.stdout.write(seq + chalk_1.default.cyan('TOOL ') + chalk_1.default.gray(`${toolName} started\n`));
+            break;
+        }
+        case 'tool_call_succeeded': {
+            const toolName = event.payload?.tool_name || '?';
+            const dur = formatDuration(event.duration_ms);
+            process.stdout.write(seq + chalk_1.default.green('TOOL ') + `${toolName}` +
+                chalk_1.default.gray(` | ${dur}`) + '\n');
+            break;
+        }
+        case 'tool_call_failed': {
+            const toolName = event.payload?.tool_name || '?';
+            const errMsg = event.error_message || event.error_type || 'unknown error';
+            const dur = formatDuration(event.duration_ms);
+            process.stdout.write(seq + chalk_1.default.red('TOOL ') + `${toolName} ` +
+                chalk_1.default.red(errMsg) +
+                chalk_1.default.gray(` | ${dur}`) + '\n');
+            break;
+        }
+        case 'decision': {
+            const desc = event.payload?.description || 'decision';
+            process.stdout.write(seq + chalk_1.default.magenta('DECIDE ') + chalk_1.default.gray(desc) + '\n');
+            break;
+        }
+        case 'fallback_transition': {
+            const from = event.payload?.from_provider || '?';
+            const to = event.payload?.to_provider || '?';
+            const reason = event.payload?.reason || '';
+            process.stdout.write(seq + chalk_1.default.yellow('FALLBACK ') +
+                `${from} -> ${to}` +
+                (reason ? chalk_1.default.gray(` (${reason})`) : '') + '\n');
+            break;
+        }
+        case 'policy_violation': {
+            const vType = event.payload?.violation_type || 'violation';
+            const detail = event.payload?.detail || '';
+            process.stdout.write(seq + chalk_1.default.red('POLICY ') + chalk_1.default.red(vType) +
+                (detail ? chalk_1.default.gray(` — ${detail}`) : '') + '\n');
+            break;
+        }
+        case 'error': {
+            const errType = event.error_type || 'error';
+            const errMsg = event.error_message || '';
+            process.stdout.write(seq + chalk_1.default.red('ERROR ') + chalk_1.default.red(errType) +
+                (errMsg ? chalk_1.default.gray(` — ${errMsg}`) : '') + '\n');
+            break;
+        }
+        default: {
+            // Unknown event type — show raw
+            process.stdout.write(seq + chalk_1.default.gray(event.event_type) + '\n');
+        }
+    }
+}

package/dist/lib/api.js

@@ -44,6 +44,7 @@ exports.publicRequest = publicRequest;
 exports.getOrg = getOrg;
 exports.updateOrg = updateOrg;
 exports.getPublicAgent = getPublicAgent;
+exports.getAgentCostEstimate = getAgentCostEstimate;
 exports.listMyAgents = listMyAgents;
 exports.createAgent = createAgent;
 exports.downloadCodeBundle = downloadCodeBundle;
@@ -58,6 +59,7 @@ exports.forkAgent = forkAgent;
 exports.checkAgentTransfer = checkAgentTransfer;
 exports.transferAgent = transferAgent;
 exports.previewAgentVersion = previewAgentVersion;
+exports.validateAgentPublish = validateAgentPublish;
 exports.reportInstall = reportInstall;
 exports.fetchUserProfile = fetchUserProfile;
 exports.listEnvironments = listEnvironments;
@@ -288,6 +290,9 @@ async function updateOrg(config, payload) {
 async function getPublicAgent(config, org, agent, version) {
     return publicRequest(config, `/public/agents/${org}/${agent}/${version}`);
 }
+async function getAgentCostEstimate(config, org, agent, version) {
+    return publicRequest(config, `/public/agents/${org}/${agent}/${version}/cost-estimate`);
+}
 async function listMyAgents(config, workspaceId) {
     const headers = {};
     if (workspaceId)
@@ -430,15 +435,21 @@ async function downloadCodeBundleAuthenticated(config, agentId) {
 /**
  * Check if an agent requires confirmation for deletion.
  */
-async function checkAgentDelete(config, agentId) {
-    return request(config, 'GET', `/agents/${agentId}/delete-check`);
+async function checkAgentDelete(config, agentId, workspaceId) {
+    const headers = {};
+    if (workspaceId)
+        headers['X-Workspace-Id'] = workspaceId;
+    return request(config, 'GET', `/agents/${agentId}/delete-check`, { headers });
 }
 /**
  * Soft delete an agent.
  */
-async function deleteAgent(config, agentId, confirmationName) {
+async function deleteAgent(config, agentId, confirmationName, workspaceId) {
     const params = confirmationName ? `?confirmation_name=${encodeURIComponent(confirmationName)}` : '';
-    return request(config, 'DELETE', `/agents/${agentId}${params}`);
+    const headers = {};
+    if (workspaceId)
+        headers['X-Workspace-Id'] = workspaceId;
+    return request(config, 'DELETE', `/agents/${agentId}${params}`, { headers });
 }
 /**
  * Fork a public agent into the caller's workspace (or an explicit workspace_id).
@@ -473,6 +484,20 @@ async function previewAgentVersion(config, agentName, workspaceId) {
         headers['X-Workspace-Id'] = workspaceId;
     return request(config, 'GET', `/agents/preview?name=${encodeURIComponent(agentName)}`, { headers });
 }
+/**
+ * Validate an agent publish payload without actually creating the agent.
+ * Runs server-side validation (name, tier limits, manifest, dependencies, etc.)
+ * and returns a validation report. Used by --dry-run.
+ */
+async function validateAgentPublish(config, data, workspaceId) {
+    const headers = { 'Content-Type': 'application/json' };
+    if (workspaceId)
+        headers['X-Workspace-Id'] = workspaceId;
+    return request(config, 'POST', '/agents/validate', {
+        body: JSON.stringify(data),
+        headers,
+    });
+}
 /**
  * Report a skill installation to the backend.
  * Only tracks authenticated installs (requires API key).

package/dist/lib/batch-publish.js

@@ -0,0 +1,223 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverAgents = discoverAgents;
+exports.topoSort = topoSort;
+exports.formatPublishPlan = formatPublishPlan;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Scan immediate subdirectories for orchagent.json or SKILL.md files.
+ * Does NOT recurse deeper than one level (matching GitHub App import behavior).
+ */
+async function discoverAgents(rootDir) {
+    const agents = [];
+    let entries;
+    try {
+        entries = await promises_1.default.readdir(rootDir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    // Also check the root directory itself
+    const dirsToCheck = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (entry.name.startsWith('.') || entry.name === 'node_modules' || entry.name === '__pycache__')
+            continue;
+        dirsToCheck.push({
+            dir: path_1.default.join(rootDir, entry.name),
+            dirName: entry.name,
+        });
+    }
+    for (const { dir, dirName } of dirsToCheck) {
+        const agent = await tryParseAgentDir(dir, dirName);
+        if (agent)
+            agents.push(agent);
+    }
+    return agents;
+}
+/**
+ * Try to parse a directory as an agent. Returns null if no orchagent.json or SKILL.md found.
+ */
+async function tryParseAgentDir(dir, dirName) {
+    // Check for SKILL.md first (takes precedence, matching publish.ts behavior)
+    const skillMdPath = path_1.default.join(dir, 'SKILL.md');
+    try {
+        const content = await promises_1.default.readFile(skillMdPath, 'utf-8');
+        const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+        if (match) {
+            // Parse YAML frontmatter to get name
+            const yamlContent = match[1];
+            const nameMatch = yamlContent.match(/^name:\s*(.+)$/m);
+            const name = nameMatch ? nameMatch[1].trim().replace(/^['"]|['"]$/g, '') : dirName;
+            return {
+                dir,
+                dirName,
+                name,
+                isSkill: true,
+                dependencyRefs: [], // Skills have no dependencies
+            };
+        }
+    }
+    catch {
+        // No SKILL.md, try orchagent.json
+    }
+    // Check for orchagent.json
+    const manifestPath = path_1.default.join(dir, 'orchagent.json');
+    try {
+        const raw = await promises_1.default.readFile(manifestPath, 'utf-8');
+        const manifest = JSON.parse(raw);
+        if (!manifest.name)
+            return null;
+        // Extract dependency refs from manifest.manifest.dependencies
+        const dependencyRefs = [];
+        const deps = manifest.manifest?.dependencies;
+        if (deps && Array.isArray(deps)) {
+            for (const dep of deps) {
+                if (dep.id && typeof dep.id === 'string') {
+                    dependencyRefs.push(dep.id);
+                }
+            }
+        }
+        // Also extract from custom_tools that reference other agents via orch_call
+        // Pattern: orch_call.py org/agent@version or orch_call.js org/agent@version
+        const loopTools = manifest.loop?.custom_tools || manifest.custom_tools;
+        if (Array.isArray(loopTools)) {
+            for (const tool of loopTools) {
+                if (tool.command) {
+                    const orchCallMatch = tool.command.match(/orch_call(?:\.py|\.js)?\s+([a-z0-9-]+\/[a-z0-9-]+)/);
+                    if (orchCallMatch) {
+                        const ref = orchCallMatch[1];
+                        if (!dependencyRefs.includes(ref)) {
+                            dependencyRefs.push(ref);
+                        }
+                    }
+                }
+            }
+        }
+        return {
+            dir,
+            dirName,
+            name: manifest.name,
+            isSkill: false,
+            dependencyRefs,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Topologically sort agents so dependencies are published first (leaf-first).
+ *
+ * Only considers intra-project dependencies (agents whose dependency refs
+ * match another discovered agent's name). Cross-org or external deps are
+ * ignored since they must already be published.
+ */
+function topoSort(agents) {
+    // Build name → agent lookup (using agent name, not dir name)
+    const byName = new Map();
+    for (const agent of agents) {
+        byName.set(agent.name, agent);
+    }
+    // Build adjacency: agent → set of local agents it depends on
+    // "depends on" means: must be published BEFORE this agent
+    const adjList = new Map();
+    for (const agent of agents) {
+        const localDeps = new Set();
+        for (const ref of agent.dependencyRefs) {
+            // ref is "org/name" — extract just the name part for local matching
+            const depName = ref.includes('/') ? ref.split('/')[1] : ref;
+            if (byName.has(depName) && depName !== agent.name) {
+                localDeps.add(depName);
+            }
+        }
+        adjList.set(agent.name, localDeps);
+    }
+    // Kahn's algorithm for topological sort
+    const inDegree = new Map();
+    for (const agent of agents) {
+        inDegree.set(agent.name, 0);
+    }
+    for (const [, deps] of adjList) {
+        for (const dep of deps) {
+            inDegree.set(dep, (inDegree.get(dep) || 0) + 1);
+        }
+    }
+    // Note: inDegree counts how many agents depend ON this agent.
+    // We want to publish agents with no dependents-that-haven't-been-published first.
+    // Actually, let me re-think: we want leaf-first ordering.
+    // A "leaf" is an agent with NO dependencies (inDegree in the "depends-on" graph = 0 outgoing).
+    // Let's use Kahn's on the reverse: process nodes whose dependencies are all satisfied.
+    // Reset: inDegree = number of local deps this agent has (not yet satisfied)
+    const remaining = new Map();
+    for (const agent of agents) {
+        remaining.set(agent.name, adjList.get(agent.name)?.size || 0);
+    }
+    const queue = [];
+    for (const [name, count] of remaining) {
+        if (count === 0)
+            queue.push(name);
+    }
+    // Sort queue alphabetically for deterministic ordering among peers
+    queue.sort();
+    const sorted = [];
+    const visited = new Set();
+    while (queue.length > 0) {
+        const name = queue.shift();
+        if (visited.has(name))
+            continue;
+        visited.add(name);
+        const agent = byName.get(name);
+        sorted.push(agent);
+        // For each agent that depends on this one, decrement their remaining count
+        for (const [otherName, deps] of adjList) {
+            if (deps.has(name) && !visited.has(otherName)) {
+                const newCount = (remaining.get(otherName) || 1) - 1;
+                remaining.set(otherName, newCount);
+                if (newCount === 0) {
+                    // Insert in sorted position for determinism
+                    const insertIdx = queue.findIndex(q => q > otherName);
+                    if (insertIdx === -1)
+                        queue.push(otherName);
+                    else
+                        queue.splice(insertIdx, 0, otherName);
+                }
+            }
+        }
+    }
+    // If not all agents were visited, there's a cycle
+    if (sorted.length < agents.length) {
+        const inCycle = agents
+            .filter(a => !visited.has(a.name))
+            .map(a => a.name);
+        return { ok: false, cycle: inCycle };
+    }
+    return { ok: true, sorted };
+}
+/**
+ * Format the publish plan for display (used by both dry-run and normal mode).
+ */
+function formatPublishPlan(sorted, orgSlug) {
+    const lines = [];
+    lines.push('');
+    lines.push(`  Found ${sorted.length} agent${sorted.length === 1 ? '' : 's'} to publish:`);
+    lines.push('');
+    for (let i = 0; i < sorted.length; i++) {
+        const agent = sorted[i];
+        const type = agent.isSkill ? 'skill' : 'agent';
+        const deps = agent.dependencyRefs.length > 0
+            ? ` (depends on: ${agent.dependencyRefs.map(r => r.split('/').pop()).join(', ')})`
+            : '';
+        const prefix = orgSlug ? `${orgSlug}/` : '';
+        lines.push(`  ${i + 1}. ${prefix}${agent.name} [${type}]${deps}`);
+        lines.push(`     ${chalk_1.default.gray(agent.dirName + '/')}`);
+    }
+    lines.push('');
+    return lines.join('\n');
+}