@metrio-ai/cli 1.1.0 → 1.2.0

package/README.md

@@ -48,3 +48,22 @@ For CI set `METRIO_TOKEN` (and `METRIO_CONSOLE_URL` if not `https://app.metrio.a
 Exit codes: `0` ok, `1` failure, `2` usage or validation error, `3` not logged in / not allowed. Codes 2 and 3 apply to the account and resource-management commands (`login`, `logout`, `whoami`, `tools`, `call`, and every `metrio <group> ...` command); the run commands (`chat`, `workflow run` / `run-batch`, `prompt run-batch` / `create-version`) keep their original behavior (errors exit 1). A workflow DAG the console rejects exits 2; a partially failed `version create-batch` exits 1.
 
 Migrating from `@metrio-ai/client`'s bundled CLI: if the old CLI was installed globally, run `npm rm -g @metrio-ai/client` before `npm i -g @metrio-ai/cli` (both install a `metrio` bin). Every command and flag is unchanged. Bare `metrio --messages …` still works but is deprecated in favor of `metrio chat --messages …`.
+
+## Sync a project as files
+
+```bash
+mkdir my-project && cd my-project
+metrio pull --project my-project      # metrio.yaml, prompts/, skills/, workflows/, .metrio/state.json
+$EDITOR prompts/pick-products/system.md
+metrio diff                           # modified / remote-changed / conflict / new … with unified diffs
+metrio push -m "tighter wording"      # new prompt version (not live)
+metrio push --activate                # …or make it live right away
+metrio version list pick-products     # prompt directories work wherever a prompt id is expected
+```
+
+`push` creates new versions and never overwrites changes made in the console since your last `pull` (use `--force` deliberately: local wins, bindings and MCP lists are replaced, and resources changed in the console may be pruned). Workflow pushes create draft versions (`--publish`, `--activate`). Deleting files deletes nothing remotely unless you pass `--prune --yes`. Commit `.metrio/state.json` with the files. Run `metrio pull --help` for every option.
+
+- A second plain `metrio push` does not create duplicates ("already pushed as version N"); `metrio push --activate` (prompts) or `--publish` / `--activate` (workflows) makes the pending pushed version live.
+- `pull` adopts untracked local files that are identical to the console. `pull` and `push` report per-resource failures, exit 1, and still save state for the resources that succeeded.
+- Renaming a prompt or skill directory is detected by content (status `renamed`); pull/push move the state entry. Workflow directories are named by workflow id and cannot be renamed locally; push refuses it.
+- Known limitation: renaming AND editing a prompt/skill directory in one go looks like a delete plus a new resource (push would create a second one; `--prune --yes` would delete the old one). Rename first, sync, then edit.

package/dist/commands/sync.js

@@ -0,0 +1,488 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SYNC_HELP = void 0;
+exports.parseSyncArgs = parseSyncArgs;
+exports.openWorkspace = openWorkspace;
+exports.filterEntries = filterEntries;
+exports.loadEntries = loadEntries;
+exports.runDiffCommand = runDiffCommand;
+exports.runPullCommand = runPullCommand;
+exports.runPushCommand = runPushCommand;
+const path = __importStar(require("path"));
+const diff_1 = require("diff");
+const client_1 = require("../console/client");
+const errors_1 = require("../errors");
+const push_1 = require("../sync/push");
+const remote_1 = require("../sync/remote");
+const status_1 = require("../sync/status");
+const workspace_1 = require("../sync/workspace");
+const ONLY = { prompts: 'prompt', skills: 'skill', workflows: 'workflow' };
+function parseSyncArgs(argv) {
+    const o = {
+        paths: [], kinds: ['prompt', 'skill', 'workflow'], force: false, activate: false, publish: false,
+        prune: false, yes: false, dryRun: false, json: false,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        const value = () => {
+            const v = argv[i + 1];
+            if (v === undefined)
+                throw new errors_1.CliError(`${arg} needs a value`);
+            i += 1;
+            return v;
+        };
+        if (arg === '--only') {
+            const kind = ONLY[value()];
+            if (!kind)
+                throw new errors_1.CliError('--only must be prompts, skills or workflows');
+            o.kinds = [kind];
+        }
+        else if (arg === '-m' || arg === '--message')
+            o.message = value();
+        else if (arg === '--project')
+            o.project = value();
+        else if (arg === '--force')
+            o.force = true;
+        else if (arg === '--activate')
+            o.activate = true;
+        else if (arg === '--publish')
+            o.publish = true;
+        else if (arg === '--prune')
+            o.prune = true;
+        else if (arg === '--yes')
+            o.yes = true;
+        else if (arg === '--dry-run')
+            o.dryRun = true;
+        else if (arg === '--json')
+            o.json = true;
+        else if (arg.startsWith('-'))
+            throw new errors_1.CliError(`Unknown option ${arg}`);
+        else
+            o.paths.push(arg);
+    }
+    return o;
+}
+async function openWorkspace() {
+    const root = (0, workspace_1.findRoot)();
+    if (!root)
+        throw new errors_1.CliError('Not in a metrio workspace (no metrio.yaml). Run "metrio pull --project <slug>" first.');
+    return { root, project: (0, workspace_1.readProject)(root), client: new client_1.ConsoleClient(await (0, client_1.resolveConsoleAuth)()) };
+}
+/** Entries whose key equals or sits under one of the given paths (relative to the workspace root). */
+function filterEntries(entries, root, paths) {
+    if (!paths.length)
+        return entries;
+    const wanted = paths.map((p) => {
+        const rel = path.relative(root, path.resolve(p));
+        if (rel === '..' || rel.startsWith(`..${path.sep}`) || path.isAbsolute(rel)) {
+            throw new errors_1.CliError(`${p} is outside the metrio workspace`);
+        }
+        return rel.split(path.sep).join('/').replace(/\/+$/, '');
+    });
+    const matches = (e, w) => w === '' || e.key === w || e.key.startsWith(`${w}/`) || w.startsWith(`${e.key}/`);
+    wanted.forEach((w, i) => {
+        if (!entries.some((e) => matches(e, w)))
+            throw new errors_1.CliError(`${paths[i]} matches nothing in this workspace`);
+    });
+    return entries.filter((e) => wanted.some((w) => matches(e, w)));
+}
+async function loadEntries(ctx, opts) {
+    const state = (0, workspace_1.readState)(ctx.root, ctx.project);
+    const remote = await (0, remote_1.fetchRemote)(ctx.client, ctx.project, opts.kinds);
+    return filterEntries((0, status_1.computeEntries)(ctx.root, state, remote, opts.kinds), ctx.root, opts.paths);
+}
+/** Console-sourced text must not carry terminal control sequences. */
+function safe(text) {
+    return text.replace(/[\x00-\x08\x0b-\x1f\x7f-\x9f]/g, (c) => `\\x${c.charCodeAt(0).toString(16).padStart(2, '0')}`);
+}
+exports.SYNC_HELP = `metrio pull | diff | push - sync prompts, skills and workflows with local files
+
+  metrio pull --project <slug>   First pull: creates metrio.yaml here and writes:
+                                   prompts/<name>/prompt.yaml + system.md
+                                   skills/<name>.md
+                                   workflows/<id>/workflow.yaml + definition.json
+  metrio pull [paths…]           Update files from the console (keeps local edits unless --force)
+  metrio diff [paths…]           Show what differs: modified, remote-changed, conflict, new, …
+  metrio push [paths…]           Send local edits: new prompt version (not live unless --activate),
+                                 skill update, workflow version (draft; --publish / --activate)
+
+Options:
+  --only prompts|skills|workflows   Limit to one kind
+  --force                           pull: overwrite local edits; push: push over console changes
+                                    (local wins — bindings and MCP list are replaced), allow
+                                    pruning resources changed in the console, and allow a prompt
+                                    version that drops the live messages/agent_description
+  -m, --message <text>              push: description of the new versions
+  --activate                        push: make new prompt versions head / workflow versions live
+  --publish                         push: publish new workflow versions without activating
+  --prune --yes                     push: delete console resources whose local files were removed
+  --dry-run                         Print the plan without changing anything
+  --json                            diff: machine-readable statuses
+
+State lives in .metrio/state.json (commit it with the files).
+`;
+const wantsHelp = (argv) => argv.includes('-h') || argv.includes('--help');
+function patch(e) {
+    const local = e.local ?? {};
+    const remote = e.remote?.files ?? {};
+    return [...new Set([...Object.keys(local), ...Object.keys(remote)])]
+        .sort()
+        .filter((f) => local[f] !== remote[f])
+        .map((f) => (0, diff_1.createTwoFilesPatch)(`remote/${e.key}/${f}`, `local/${e.key}/${f}`, remote[f] ?? '', local[f] ?? ''))
+        .join('');
+}
+async function runDiffCommand(argv) {
+    if (wantsHelp(argv)) {
+        process.stdout.write(exports.SYNC_HELP);
+        return;
+    }
+    const opts = parseSyncArgs(argv);
+    const ctx = await openWorkspace();
+    const entries = await loadEntries(ctx, opts);
+    if (opts.json) {
+        const rows = entries.map((e) => ({ key: e.key, kind: e.kind, status: e.status, ...(e.from ? { from: e.from } : {}) }));
+        process.stdout.write(`${JSON.stringify(rows, null, 2)}\n`);
+        return;
+    }
+    let unchanged = 0;
+    for (const e of entries) {
+        if (e.status === 'unchanged') {
+            unchanged += 1;
+            continue;
+        }
+        process.stdout.write(safe(`${e.status.padEnd(15)}${e.key}${e.from ? ` (from ${e.from})` : ''}\n`));
+        if (e.status === 'modified' || e.status === 'conflict' || e.status === 'remote-changed')
+            process.stdout.write(safe(patch(e)));
+    }
+    process.stdout.write(`${unchanged} unchanged\n`);
+}
+async function runPullCommand(argv) {
+    if (wantsHelp(argv)) {
+        process.stdout.write(exports.SYNC_HELP);
+        return;
+    }
+    const opts = parseSyncArgs(argv);
+    const found = (0, workspace_1.findRoot)();
+    let root = found;
+    if (!root) {
+        if (!opts.project)
+            throw new errors_1.CliError('Not in a metrio workspace. Run "metrio pull --project <slug>" to start one here.');
+        root = process.cwd(); // metrio.yaml is only created once the console fetch succeeded
+    }
+    else if (opts.project && opts.project !== (0, workspace_1.readProject)(root)) {
+        (0, workspace_1.initRoot)(root, opts.project); // throws: metrio.yaml names another project
+    }
+    const ctx = { root, project: found ? (0, workspace_1.readProject)(root) : opts.project, client: new client_1.ConsoleClient(await (0, client_1.resolveConsoleAuth)()) };
+    // A fresh workspace is locked once metrio.yaml exists (below).
+    let release = found && !opts.dryRun ? (0, workspace_1.acquireLock)(root) : undefined;
+    try {
+        const state = (0, workspace_1.readState)(ctx.root, ctx.project);
+        const entries = await loadEntries(ctx, opts);
+        if (!found && !opts.dryRun) {
+            (0, workspace_1.initRoot)(root, ctx.project);
+            release = (0, workspace_1.acquireLock)(root);
+        }
+        let unchanged = 0;
+        let failed = 0;
+        const record = (e, files) => {
+            const h = (0, workspace_1.hashFiles)(files);
+            state.resources[e.key] = { ...(state.resources[e.key] ?? {}), kind: e.kind, id: e.remote.id, base: h, remote: h };
+        };
+        const take = (e, verb) => {
+            if (!opts.dryRun) {
+                (0, workspace_1.writeLocal)(ctx.root, e.key, e.kind, e.remote.files);
+                record(e, e.remote.files);
+            }
+            process.stdout.write(safe(`${opts.dryRun ? 'would pull' : verb} ${e.key}\n`));
+        };
+        for (const e of entries) {
+            try {
+                switch (e.status) {
+                    case 'unchanged':
+                        if (e.refresh && !opts.dryRun)
+                            record(e, e.remote.files);
+                        if (e.refresh && !e.state)
+                            process.stdout.write(safe(`${opts.dryRun ? 'would track' : 'tracked'} ${e.key}\n`));
+                        else
+                            unchanged += 1;
+                        break;
+                    case 'remote-new':
+                    case 'remote-changed':
+                        take(e, 'pulled');
+                        break;
+                    case 'deleted':
+                        take(e, 'restored');
+                        break;
+                    case 'modified':
+                        if (opts.force)
+                            take(e, 'pulled');
+                        else
+                            process.stderr.write(safe(`skipped ${e.key}: local changes (use --force to overwrite)\n`));
+                        break;
+                    case 'conflict':
+                        if (!e.state && e.kind === 'prompt' && e.remote.data.version === null) {
+                            // A console prompt without a version has nothing to pull: track it as if its empty render
+                            // had been pulled, so the local files show as edits and push creates the first version.
+                            if (!opts.dryRun) {
+                                const h = (0, workspace_1.hashFiles)(e.remote.files);
+                                state.resources[e.key] = { kind: e.kind, id: e.remote.id, base: h, remote: h };
+                            }
+                            process.stdout.write(safe(`${opts.dryRun ? 'would track' : 'tracked'} ${e.key} (the console prompt has no version yet; push to create one)\n`));
+                        }
+                        else if (opts.force)
+                            take(e, 'pulled');
+                        else
+                            process.stderr.write(safe(`skipped ${e.key}: local changes (use --force to overwrite)\n`));
+                        break;
+                    case 'renamed': {
+                        const old = state.resources[e.from];
+                        if (!opts.dryRun) {
+                            state.resources[e.key] = old;
+                            delete state.resources[e.from];
+                        }
+                        process.stdout.write(safe(`${opts.dryRun ? 'would rename' : 'renamed'} ${e.from} -> ${e.key}\n`));
+                        if ((0, workspace_1.hashFiles)(e.remote.files) !== old.remote)
+                            take(e, 'pulled');
+                        break;
+                    }
+                    case 'remote-deleted':
+                        if (!opts.dryRun)
+                            delete state.resources[e.key];
+                        process.stderr.write(safe(`${e.key}: deleted in the console; local files kept (push to recreate, or delete them)\n`));
+                        break;
+                    case 'new':
+                        break;
+                }
+            }
+            catch (error) {
+                failed += 1;
+                process.stderr.write(safe(`failed ${e.key}: ${error instanceof Error ? error.message : String(error)}\n`));
+            }
+        }
+        if (!opts.dryRun)
+            (0, workspace_1.writeState)(ctx.root, state);
+        process.stdout.write(`${unchanged} unchanged\n`);
+        if (failed > 0)
+            throw new errors_1.CliError(`${failed} resources failed`, 1);
+    }
+    finally {
+        release?.();
+    }
+}
+function remoteContent(r) {
+    try {
+        return (0, push_1.versionContent)(r.kind, r.files, r.kind);
+    }
+    catch {
+        return undefined;
+    }
+}
+const remoteMoved = (e) => (0, workspace_1.hashFiles)(e.remote.files) !== e.state.remote;
+function planPush(entries, opts, options) {
+    const actions = [];
+    for (const entry of entries) {
+        switch (entry.status) {
+            case 'unchanged':
+                if ((0, push_1.hasPendingVersion)(entry, options))
+                    actions.push({ entry, op: 'update' });
+                break;
+            case 'modified':
+                actions.push({ entry, op: 'update' });
+                break;
+            case 'new':
+                actions.push({ entry, op: 'create' });
+                break;
+            case 'renamed':
+                if (entry.kind === 'workflow') {
+                    actions.push({ entry, skip: 'workflow directories are named by workflow_id; rename it in the console instead', failure: true });
+                }
+                else if (remoteMoved(entry))
+                    actions.push({ entry, skip: 'remote changed; run "metrio pull" first', failure: true });
+                else
+                    actions.push({ entry, op: 'rename' });
+                break;
+            case 'conflict':
+                if (!entry.state) {
+                    const reason = `exists in the console but is not tracked here. "metrio pull --force ${entry.key}" would OVERWRITE your local files; ` +
+                        'to keep them, rename the local directory (it will be pushed as new) or delete the console copy first';
+                    actions.push({ entry, skip: reason, failure: true });
+                }
+                else if (opts.force)
+                    actions.push({ entry, op: 'update' });
+                else
+                    actions.push({ entry, skip: 'conflict: changed locally and in the console (pull, merge, then push; or --force)', failure: true });
+                break;
+            case 'remote-changed':
+                actions.push({ entry, skip: 'remote changed; run "metrio pull" first', failure: true });
+                break;
+            case 'remote-deleted':
+                actions.push({ entry, skip: 'deleted in the console; run "metrio pull" to drop it, then push to recreate', failure: true });
+                break;
+            case 'deleted':
+                if (opts.prune && opts.yes) {
+                    if (remoteMoved(entry) && !opts.force) {
+                        actions.push({ entry, skip: 'changed in the console since your last pull; use --force to delete anyway', failure: true });
+                    }
+                    else
+                        actions.push({ entry, op: 'delete' });
+                }
+                else if (opts.prune)
+                    actions.push({ entry, skip: 'use --prune --yes to delete it in the console', failure: true });
+                else
+                    actions.push({ entry, skip: 'deleted locally (use --prune --yes to delete it in the console)', failure: false });
+                break;
+            default:
+                break;
+        }
+    }
+    return sortForExecution(actions);
+}
+const KIND_RANK = { skill: 0, prompt: 1, workflow: 2 };
+const DELETE_RANK = { prompt: 3, workflow: 3, skill: 4 };
+/** Skills first (prompts may name new ones), then prompts, workflows; deletes last, skills after what uses them. */
+function sortForExecution(actions) {
+    const rank = (a) => ('op' in a && a.op === 'delete' ? DELETE_RANK : KIND_RANK)[a.entry.kind];
+    return [...actions].sort((a, b) => rank(a) - rank(b));
+}
+const PAST = { create: 'created', update: 'updated', delete: 'deleted', rename: 'renamed' };
+const describeOp = (op, e) => (op === 'rename' ? `${e.from} -> ${e.key}` : e.key);
+async function runPushCommand(argv) {
+    if (wantsHelp(argv)) {
+        process.stdout.write(exports.SYNC_HELP);
+        return;
+    }
+    const opts = parseSyncArgs(argv);
+    const ctx = await openWorkspace();
+    const release = opts.dryRun ? undefined : (0, workspace_1.acquireLock)(ctx.root);
+    try {
+        const state = (0, workspace_1.readState)(ctx.root, ctx.project);
+        const options = { activate: opts.activate, publish: opts.publish, message: opts.message, force: opts.force };
+        const entries = await loadEntries(ctx, opts);
+        const actions = planPush(entries, opts, options);
+        if (opts.dryRun) {
+            for (const a of actions) {
+                process.stdout.write(safe('op' in a ? `would ${a.op} ${describeOp(a.op, a.entry)}\n` : `skip ${a.entry.key}: ${a.skip}\n`));
+            }
+            return;
+        }
+        const pushCtx = { client: ctx.client, project: ctx.project, options };
+        const done = [];
+        let failed = 0;
+        for (const a of actions) {
+            if (!('op' in a)) {
+                if (a.failure) {
+                    failed += 1;
+                    process.stderr.write(safe(`skip ${a.entry.key}: ${a.skip}\n`));
+                }
+                else
+                    process.stderr.write(safe(`${a.entry.key}: ${a.skip}\n`));
+                continue;
+            }
+            try {
+                let result;
+                if (a.op === 'delete')
+                    await (0, push_1.deleteEntry)(pushCtx, a.entry);
+                else if (a.op !== 'rename')
+                    result = await (0, push_1.pushEntry)(pushCtx, a.entry);
+                done.push({ entry: a.entry, op: a.op, result });
+                process.stdout.write(safe(`${PAST[a.op]} ${describeOp(a.op, a.entry)}${result ? ` (${result.summary})` : ''}\n`));
+            }
+            catch (error) {
+                failed += 1;
+                process.stderr.write(safe(`failed ${a.entry.key}: ${error instanceof Error ? error.message : String(error)}\n`));
+            }
+        }
+        // Converged resources (same content on both sides, stale state): record them as synced.
+        const converged = entries.filter((e) => e.refresh && !done.some((d) => d.entry === e));
+        for (const e of converged) {
+            const h = (0, workspace_1.hashFiles)(e.local);
+            state.resources[e.key] = { ...(state.resources[e.key] ?? {}), kind: e.kind, id: e.remote.id, base: h, remote: h };
+        }
+        if (converged.length && !done.length)
+            (0, workspace_1.writeState)(ctx.root, state);
+        let refetchFailed = false;
+        if (done.length) {
+            const pushed = done.filter((d) => d.result);
+            let refreshed;
+            if (pushed.length) {
+                try {
+                    refreshed = await (0, remote_1.fetchRemote)(ctx.client, ctx.project, [...new Set(pushed.map((d) => d.entry.kind))]);
+                }
+                catch (error) {
+                    refetchFailed = true;
+                    process.stderr.write(safe(`could not re-read the console after pushing: ${error instanceof Error ? error.message : String(error)}; run "metrio diff" to check\n`));
+                }
+            }
+            for (const d of done) {
+                const key = d.entry.key;
+                if (d.op === 'delete') {
+                    delete state.resources[key];
+                }
+                else if (d.op === 'rename') {
+                    state.resources[key] = state.resources[d.entry.from];
+                    delete state.resources[d.entry.from];
+                }
+                else {
+                    const r = d.result;
+                    const previous = state.resources[key];
+                    const remote = refreshed?.find((x) => x.kind === d.entry.kind && x.id === r.id);
+                    state.resources[key] = {
+                        ...(previous ?? {}),
+                        kind: d.entry.kind,
+                        id: r.id,
+                        base: (0, workspace_1.hashFiles)(d.entry.local),
+                        // Without a re-read, keep the last known remote hash: the next diff then shows what really changed.
+                        remote: refreshed ? (remote ? (0, workspace_1.hashFiles)(remote.files) : '') : (previous?.remote ?? ''),
+                        ...(r.pushed_version_id !== undefined ? { pushed_version_id: r.pushed_version_id, pushed_serial: r.pushed_serial } : {}),
+                        ...(r.pushed_workflow_version !== undefined ? { pushed_workflow_version: r.pushed_workflow_version } : {}),
+                        ...(r.pushed_content !== undefined ? { pushed_content: r.pushed_content } : {}),
+                        // What the console made of a new/activated version (defaults filled, prompt_refs pinned): see push.ts.
+                        ...(refreshed && r.versioned ? { remote_content: remote ? remoteContent(remote) : undefined } : {}),
+                    };
+                }
+            }
+            (0, workspace_1.writeState)(ctx.root, state);
+        }
+        process.stdout.write(`${done.length} pushed, ${failed} failed\n`);
+        if (failed)
+            throw new errors_1.CliError(`${failed} of ${done.length + failed} resources failed`, 1);
+        if (refetchFailed)
+            throw new errors_1.CliError('pushed, but could not re-read the console; run "metrio diff" to check', 1);
+    }
+    finally {
+        release?.();
+    }
+}

package/dist/index.js

@@ -19,6 +19,7 @@ const prompt_1 = require("./commands/prompt");
 const workflow_1 = require("./commands/workflow");
 const tools_1 = require("./commands/tools");
 const run_1 = require("./manage/run");
+const sync_1 = require("./commands/sync");
 const registry_1 = require("./manage/registry");
 exports.HELP = `metrio - MetrioAI CLI
 
@@ -40,6 +41,7 @@ Manage (console OAuth; run "metrio <group> --help"):
   project | prompt | version | skill | workflow | schedule | mcp | run | admin | model-tiers
                         e.g. metrio version create 12 -f system.md
                              metrio skill get 5 -o skill.md
+  pull | diff | push    Sync prompts, skills and workflows with local files ("metrio pull --help")
   tools                 List the console tools your login can call
   call <tool>           Call any console tool with JSON args (-f file | --args json)
 
@@ -81,6 +83,12 @@ async function main(argv) {
             return runMixedGroup('workflow', argv);
         case 'prompt':
             return runMixedGroup('prompt', argv);
+        case 'pull':
+            return (0, sync_1.runPullCommand)(argv.slice(1));
+        case 'diff':
+            return (0, sync_1.runDiffCommand)(argv.slice(1));
+        case 'push':
+            return (0, sync_1.runPushCommand)(argv.slice(1));
         case 'login':
             return (0, auth_1.runLoginCommand)(argv.slice(1));
         case 'logout':

package/dist/manage/output.js

@@ -110,7 +110,12 @@ async function writeOutput(data, opts) {
         process.stdout.write(record.text.endsWith('\n') ? record.text : `${record.text}\n`);
         return;
     }
-    const rows = Array.isArray(data) ? data : Array.isArray(record.items) ? record.items : undefined;
+    const listKey = Array.isArray(record.items)
+        ? 'items'
+        : 'pagination' in record
+            ? Object.keys(record).find((k) => Array.isArray(record[k]))
+            : undefined;
+    const rows = Array.isArray(data) ? data : listKey ? record[listKey] : undefined;
     if (rows) {
         process.stdout.write(rows.length ? `${renderTable(rows)}\n` : '(none)\n');
         const p = asRecord(record.pagination);

package/dist/manage/run.js

@@ -7,6 +7,7 @@ const input_1 = require("./input");
 const output_1 = require("./output");
 const project_1 = require("./project");
 const registry_1 = require("./registry");
+const workspace_1 = require("../sync/workspace");
 const schema_1 = require("./schema");
 function parse(rest) {
     const parsed = { tokens: [], json: false, yes: false };
@@ -66,6 +67,27 @@ function isCommandPrefix(argv) {
     const words = argv.filter((a) => !a.startsWith('-'));
     return registry_1.COMMANDS.some((c) => words.length < c.path.length && words.every((w, i) => c.path[i] === w));
 }
+/**
+ * A prompt positional may name a tracked directory (prompts/<dir> or <dir>) instead of the
+ * numeric id — only for the workspace's own project, since ids are per project.
+ */
+function promptRef(raw, project) {
+    if (/^\d+$/.test(raw))
+        return raw;
+    const root = (0, workspace_1.findRoot)();
+    const dir = raw.replace(/\/+$/, '');
+    const key = dir.startsWith('prompts/') ? dir : `prompts/${dir}`;
+    // A broken workspace surfaces its own (informative) CliError.
+    const workspaceProject = root ? (0, workspace_1.readProject)(root) : undefined;
+    const entry = root ? (0, workspace_1.readState)(root, workspaceProject).resources[key] : undefined;
+    if (!entry || entry.kind !== 'prompt') {
+        throw new errors_1.CliError(`Unknown prompt "${raw}": use the numeric id, or a prompts/<dir> tracked in .metrio/state.json`);
+    }
+    if (project !== undefined && project !== workspaceProject) {
+        throw new errors_1.CliError(`"${raw}" is a directory of project ${workspaceProject}, but this command targets project ${String(project)}`);
+    }
+    return entry.id;
+}
 /** Runs one registry command; argv starts with the group, e.g. ['version', 'create', '12', '-f', 's.md']. */
 async function runManageCommand(argv, readStdin) {
     const match = (0, registry_1.findCommand)(argv);
@@ -107,7 +129,14 @@ async function runManageCommand(argv, readStdin) {
         put('project_slug', opts.project, 'project');
     for (const [k, v] of Object.entries(values))
         put(k, v, `--${(0, schema_1.kebab)(k)}`);
-    expected.forEach((arg, i) => put(arg.prop, (0, schema_1.coercePositional)(positionals[i], props[arg.prop], arg.label), arg.label));
+    // A prompt directory resolves against the final project_slug, so it waits for it.
+    let promptDir;
+    expected.forEach((arg, i) => {
+        if (arg.prop === 'prompt_external_id' && !/^\d+$/.test(positionals[i]))
+            promptDir = { prop: arg.prop, raw: positionals[i], label: arg.label };
+        else
+            put(arg.prop, (0, schema_1.coercePositional)(positionals[i], props[arg.prop], arg.label), arg.label);
+    });
     if ('project_slug' in props && !opts.project && args.project_slug === undefined) {
         try {
             const project = (0, project_1.resolveProject)(undefined);
@@ -119,6 +148,9 @@ async function runManageCommand(argv, readStdin) {
                 throw err;
         }
     }
+    if (promptDir) {
+        put(promptDir.prop, (0, schema_1.coercePositional)(promptRef(promptDir.raw, args.project_slug), props[promptDir.prop], promptDir.label), promptDir.label);
+    }
     if ((schema.required ?? []).includes('project_slug') && args.project_slug === undefined) {
         throw new errors_1.CliError('No project. Pass --project <slug>, set METRIO_PROJECT, or add "project: <slug>" to metrio.yaml.');
     }