@metrio-ai/cli 1.1.0 → 1.2.0

package/dist/sync/push.js

@@ -0,0 +1,329 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.versionContent = versionContent;
+exports.hasPendingVersion = hasPendingVersion;
+exports.pushEntry = pushEntry;
+exports.deleteEntry = deleteEntry;
+const crypto_1 = require("crypto");
+const errors_1 = require("../errors");
+const remote_1 = require("./remote");
+const render_1 = require("./render");
+const defined = (o) => Object.fromEntries(Object.entries(o).filter(([, v]) => v !== undefined));
+async function call(ctx, tool, args) {
+    return ((await ctx.client.callTool(tool, defined({ project_slug: ctx.project, ...args }))) ?? {});
+}
+const sha = (text) => (0, crypto_1.createHash)('sha256').update(text).digest('hex');
+const message = (err) => (err instanceof Error ? err.message : String(err));
+/** Best-effort removal of a resource this push just created, so a failed push leaves no orphan. */
+async function undoCreate(ctx, tool, args, what, error) {
+    try {
+        await call(ctx, tool, args);
+        return new errors_1.CliError(`${message(error)} (the half-created ${what.split(' ')[0]} was removed)`);
+    }
+    catch (cleanup) {
+        return new errors_1.CliError(`${message(error)} (cleanup failed: ${message(cleanup)}; ${what} exists in the console)`);
+    }
+}
+/*
+ * When does a push create a version?
+ *
+ * The console normalizes what it stores: create_version fills in output_format and
+ * model_settings defaults and stores an empty model_fallbacks as null; creating or
+ * publishing a workflow version pins its prompt_ref tags. So right after a push the
+ * re-read remote can differ from the local files although nobody edited anything, and
+ * comparing local with remote alone would create a new version on every later push and
+ * every --activate.
+ *
+ * So every push records two hashes of the version content (a prompt's versionPart, a
+ * workflow's canonical definition) in state:
+ *   pushed_content  the local content of the last version this workspace pushed
+ *   remote_content  the remote live content re-read right after the last push
+ * While both still match ("untouched since the push"), neither side changed version
+ * content, and any remaining local/remote difference is console normalization: no new
+ * version. The one exception is a pending version: one this workspace pushed
+ * (pushed_version_id / pushed_workflow_version) that is not the live one (prompt head /
+ * active workflow version), still holding the local content. --activate (or --publish
+ * for a workflow) makes it live; a plain push only reports it.
+ */
+/** sha of the version content of rendered/local files; undefined for skills (unversioned). */
+function versionContent(kind, files, where) {
+    if (kind === 'prompt')
+        return sha((0, render_1.versionPart)((0, render_1.parsePrompt)(files, where)));
+    if (kind === 'workflow')
+        return sha((0, render_1.canonical)((0, render_1.parseWorkflow)(files, where).definition));
+    return undefined;
+}
+const untouchedSincePush = (e, localContent, remoteContent) => e.state?.pushed_content === localContent && e.state.remote_content === remoteContent;
+/** The pushed version that is not live, if it still holds the local content. */
+function pendingVersion(e, localContent) {
+    const s = e.state;
+    if (!s || !e.remote || s.pushed_content !== localContent)
+        return undefined;
+    if (e.kind === 'prompt') {
+        const head = e.remote.data.version?.id;
+        return s.pushed_version_id !== undefined && s.pushed_version_id !== head ? s.pushed_version_id : undefined;
+    }
+    const active = e.remote.data.active_version;
+    return s.pushed_workflow_version !== undefined && s.pushed_workflow_version !== active ? s.pushed_workflow_version : undefined;
+}
+/** An unchanged entry holding a pending version (see above) that these flags should make live. */
+function hasPendingVersion(e, options) {
+    if (!e.local || !e.remote || !e.state)
+        return false;
+    const wanted = e.kind === 'prompt' ? options.activate : e.kind === 'workflow' && (options.activate || options.publish);
+    if (!wanted)
+        return false;
+    try {
+        return pendingVersion(e, versionContent(e.kind, e.local, e.key)) !== undefined;
+    }
+    catch {
+        return false; // unparsable files: a plain push reports the error
+    }
+}
+async function skillId(ctx, name, where) {
+    if (!ctx.skillIds) {
+        const rows = await (0, remote_1.fetchAll)(ctx.client, 'list_skills', { project_slug: ctx.project });
+        ctx.skillIds = new Map(rows.map((r) => [String(r.name), Number(r.id)]));
+    }
+    const id = ctx.skillIds.get(name);
+    if (id === undefined)
+        throw new errors_1.CliError(`${where}/prompt.yaml: unknown skill "${name}"`);
+    return id;
+}
+function modelArgs(doc) {
+    if (doc.model?.tier)
+        return { tier_key: doc.model.tier };
+    return { model_provider: doc.model?.provider, model_name: doc.model?.name };
+}
+function assertVersionable(doc, key) {
+    const m = doc.model;
+    if (!m || !(m.tier || (m.provider && m.name))) {
+        throw new errors_1.CliError(`${key}/prompt.yaml: "model" must be { provider, name } or { tier } to create a version`);
+    }
+    if (!doc.system.trim())
+        throw new errors_1.CliError(`${key}/system.md is empty`);
+}
+/** A new version is built from files only: refuse to silently drop what files cannot carry. */
+function assertNoDroppedHeadFields(e) {
+    const head = e.remote.data.version;
+    const messages = head?.messages;
+    const agentDescription = head?.agent_description;
+    if ((Array.isArray(messages) && messages.length > 0) || (typeof agentDescription === 'string' && agentDescription !== '')) {
+        throw new errors_1.CliError(`${e.key}: the live version has messages/agent_description that files cannot carry; a new version would drop them (use --force to proceed)`);
+    }
+}
+async function pushPrompt(ctx, e) {
+    const local = (0, render_1.parsePrompt)(e.local, e.key);
+    const remote = e.remote ? (0, render_1.parsePrompt)(e.remote.files, e.key) : undefined;
+    const { activate, message: description } = ctx.options;
+    const content = sha((0, render_1.versionPart)(local));
+    // See "When does a push create a version?" above.
+    let createVersion = !remote;
+    let pending;
+    if (remote && (0, render_1.versionPart)(local) !== (0, render_1.versionPart)(remote)) {
+        if (untouchedSincePush(e, content, sha((0, render_1.versionPart)(remote)))) {
+            pending = pendingVersion(e, content);
+            createVersion = pending !== undefined && activate;
+        }
+        else
+            createVersion = true;
+    }
+    // Everything that can fail locally is checked before any write.
+    const ids = new Map();
+    for (const name of new Set([...local.skills, ...(remote?.skills ?? [])]))
+        ids.set(name, await skillId(ctx, name, e.key));
+    if (createVersion)
+        assertVersionable(local, e.key);
+    if (createVersion && remote && !ctx.options.force)
+        assertNoDroppedHeadFields(e);
+    let id = e.remote?.id ?? e.state?.id;
+    let created = false;
+    if (!id) {
+        const row = await call(ctx, 'create_prompt', { name: local.name, description: local.description });
+        id = String(row.external_id);
+        created = true;
+    }
+    else if (remote && (local.name !== remote.name || (local.description ?? '') !== (remote.description ?? ''))) {
+        await call(ctx, 'update_prompt', { prompt_external_id: Number(id), name: local.name, description: local.description ?? '' });
+    }
+    const promptId = Number(id);
+    const result = { id, summary: 'no new version' };
+    try {
+        if (createVersion) {
+            const head = activate || !remote;
+            const v = await call(ctx, 'create_version', {
+                prompt_external_id: promptId,
+                system_prompt: local.system,
+                ...modelArgs(local),
+                output_format: local.output_format,
+                model_settings: local.model_settings,
+                model_fallbacks: local.model_fallbacks,
+                output_schema: local.output_schema,
+                description,
+                set_as_head: head,
+            });
+            result.pushed_version_id = Number(v.id);
+            result.pushed_serial = Number(v.serial);
+            result.pushed_content = content;
+            result.versioned = true;
+            result.summary = `version ${v.serial}${head ? ' (head)' : ''}`;
+        }
+        else if (pending !== undefined) {
+            result.summary = `already pushed as version ${e.state?.pushed_serial} (not live; use --activate)`;
+        }
+        const before = remote?.skills ?? [];
+        for (const name of local.skills.filter((n) => !before.includes(n))) {
+            await call(ctx, 'add_prompt_skill', { prompt_external_id: promptId, skill_id: ids.get(name) });
+        }
+        for (const name of before.filter((n) => !local.skills.includes(n))) {
+            await call(ctx, 'remove_prompt_skill', { prompt_external_id: promptId, skill_id: ids.get(name) });
+        }
+        let remoteMcp = remote?.mcp ?? [];
+        const localIds = local.mcp.map((m) => m.instance_id);
+        const replaced = (0, render_1.canonical)(localIds) !== (0, render_1.canonical)(remoteMcp.map((m) => m.instance_id));
+        if (replaced) {
+            await call(ctx, 'update_prompt', { prompt_external_id: promptId, mcp_instance_ids: localIds });
+            // Replacing the list re-creates every binding with enabled_tools = null.
+            remoteMcp = local.mcp.map((m) => ({ instance_id: m.instance_id, enabled_tools: null }));
+        }
+        // Set every allowlist even if one fails: after a replace, each one not set exposes ALL tools.
+        const failedIds = [];
+        const failures = [];
+        for (const m of local.mcp) {
+            const was = remoteMcp.find((r) => r.instance_id === m.instance_id);
+            const differs = was ? (0, render_1.canonical)(was.enabled_tools) !== (0, render_1.canonical)(m.enabled_tools) : m.enabled_tools !== null;
+            if (!differs)
+                continue;
+            try {
+                await call(ctx, 'set_prompt_mcp_tools', { prompt_external_id: promptId, mcp_instance_id: m.instance_id, enabled_tools: m.enabled_tools });
+            }
+            catch (err) {
+                failedIds.push(m.instance_id);
+                failures.push(`instance ${m.instance_id}: ${message(err)}`);
+            }
+        }
+        if (failedIds.length) {
+            const now = replaced ? 'now expose ALL tools' : 'keep their previous tool allowlist';
+            throw new errors_1.CliError(`${e.key}: MCP instance(s) ${failedIds.join(', ')} ${now} (${failures.join('; ')}); ` +
+                `fix the cause, then run "metrio push --force ${e.key}"`);
+        }
+    }
+    catch (error) {
+        if (created)
+            throw await undoCreate(ctx, 'delete_prompt', { prompt_external_id: promptId }, `prompt ${id}`, error);
+        throw error;
+    }
+    return result;
+}
+async function pushSkill(ctx, e) {
+    const doc = (0, render_1.parseSkill)(e.local['skill.md'], e.key);
+    const existing = e.remote?.id ?? e.state?.id;
+    const fields = { name: doc.name, description: doc.description, content: doc.content, references: doc.references };
+    if (existing) {
+        // Fields missing locally are cleared: the console stores '' as null, which renders as absent.
+        await call(ctx, 'update_skill', {
+            skill_id: Number(existing),
+            ...fields,
+            description: doc.description ?? '',
+            references: doc.references ?? [],
+            enabled: doc.enabled ?? true,
+        });
+        return { id: existing, summary: 'updated' };
+    }
+    const created = await call(ctx, 'create_skill', fields);
+    const id = String(created.id);
+    ctx.skillIds?.set(doc.name, Number(id));
+    if (doc.enabled === false) {
+        try {
+            await call(ctx, 'update_skill', { skill_id: Number(id), enabled: false });
+        }
+        catch (error) {
+            throw await undoCreate(ctx, 'delete_skill', { skill_id: Number(id) }, `skill ${id}`, error);
+        }
+    }
+    return { id, summary: 'created' };
+}
+function assertValid(result, key) {
+    if (result.valid === false) {
+        const errors = Array.isArray(result.errors) ? result.errors.map(String).join('; ') : 'invalid definition';
+        throw new errors_1.CliError(`${key}: the console rejected the definition: ${errors}`, 2);
+    }
+}
+async function pushWorkflow(ctx, e) {
+    // Tracked workflows keep their console id even when the directory name had to be sanitized.
+    const wid = e.state?.id ?? e.remote?.id ?? e.key.slice('workflows/'.length);
+    const doc = (0, render_1.parseWorkflow)(e.local, e.key);
+    if (doc.definition.workflow_id !== wid) {
+        const why = e.state || e.remote ? 'the console workflow id' : 'the directory name';
+        throw new errors_1.CliError(`${e.key}/definition.json: workflow_id must be "${wid}" (${why})`);
+    }
+    const remote = e.remote ? (0, render_1.parseWorkflow)(e.remote.files, e.key) : undefined;
+    const { activate, publish, message: description } = ctx.options;
+    const result = { id: wid, summary: 'no new version' };
+    const content = sha((0, render_1.canonical)(doc.definition));
+    let created = false;
+    if (!remote) {
+        assertValid(await call(ctx, 'create_workflow', { definition: doc.definition }), e.key);
+        created = true;
+        result.pushed_content = content;
+        result.versioned = true;
+        result.summary = 'created';
+    }
+    else if ((0, render_1.canonical)(doc.definition) !== (0, render_1.canonical)(remote.definition)) {
+        // See "When does a push create a version?" above.
+        if (untouchedSincePush(e, content, sha((0, render_1.canonical)(remote.definition)))) {
+            const pending = pendingVersion(e, content);
+            // Already pushed as a version: only make it live, never create a duplicate.
+            if (pending !== undefined && (activate || publish)) {
+                await call(ctx, 'publish_workflow_version', { workflow_id: wid, version: pending, activate });
+                result.versioned = true;
+                result.summary = `version ${pending}${activate ? ' (active)' : ' (published)'}`;
+            }
+            else if (pending !== undefined)
+                result.summary = `already pushed as version ${pending} (draft)`;
+        }
+        else {
+            const row = await call(ctx, 'create_workflow_version', { workflow_id: wid, definition: doc.definition, description, activate });
+            assertValid(row, e.key);
+            // The tool answers { valid, version: { version, status, … }, warnings }.
+            const version = row.version?.version;
+            if (typeof version !== 'number' || !Number.isInteger(version)) {
+                throw new errors_1.CliError(`${e.key}: create_workflow_version answered without a version number (${JSON.stringify(row).slice(0, 200)}); ` +
+                    `a version may have been created: check "metrio workflow version list ${wid}"`);
+            }
+            if (publish && !activate)
+                await call(ctx, 'publish_workflow_version', { workflow_id: wid, version });
+            result.pushed_workflow_version = version;
+            result.pushed_content = content;
+            result.versioned = true;
+            result.summary = `version ${version}${activate ? ' (active)' : publish ? ' (published)' : ' (draft)'}`;
+        }
+    }
+    if (remote ? doc.enabled !== remote.enabled : doc.enabled === false) {
+        try {
+            await call(ctx, 'update_workflow', { workflow_id: wid, enabled: doc.enabled });
+        }
+        catch (error) {
+            if (created)
+                throw await undoCreate(ctx, 'delete_workflow', { workflow_id: wid }, `workflow ${wid}`, error);
+            throw error;
+        }
+    }
+    return result;
+}
+function pushEntry(ctx, e) {
+    if (e.kind === 'prompt')
+        return pushPrompt(ctx, e);
+    if (e.kind === 'skill')
+        return pushSkill(ctx, e);
+    return pushWorkflow(ctx, e);
+}
+async function deleteEntry(ctx, e) {
+    const id = e.state.id;
+    if (e.kind === 'prompt')
+        await call(ctx, 'delete_prompt', { prompt_external_id: Number(id) });
+    else if (e.kind === 'skill')
+        await call(ctx, 'delete_skill', { skill_id: Number(id) });
+    else
+        await call(ctx, 'delete_workflow', { workflow_id: id });
+}

package/dist/sync/remote.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchAll = fetchAll;
+exports.fetchRemote = fetchRemote;
+const shared_1 = require("../commands/shared");
+const errors_1 = require("../errors");
+const render_1 = require("./render");
+const CONCURRENCY = 4;
+async function read(client, tool, args) {
+    return client.callTool(tool, args, { retry: true });
+}
+/** Every row of a paginated list tool (limit 100 per page). */
+async function fetchAll(client, tool, args) {
+    const rows = [];
+    for (let pageNo = 1;; pageNo += 1) {
+        const data = (await read(client, tool, { ...args, page: pageNo, limit: 100 }));
+        if (Array.isArray(data))
+            return data;
+        if (typeof data !== 'object' || data === null)
+            throw new errors_1.CliError(`Unexpected response from ${tool}`);
+        const record = data;
+        const key = Array.isArray(record.items) ? 'items' : Object.keys(record).find((k) => Array.isArray(record[k]));
+        rows.push(...(key ? record[key] : []));
+        const pagination = (record.pagination ?? {});
+        if (!pagination.total_pages || pageNo >= pagination.total_pages)
+            return rows;
+    }
+}
+async function fetchPrompts(client, project) {
+    const rows = await fetchAll(client, 'list_prompts', { project_slug: project });
+    return (0, shared_1.mapWithConcurrency)(rows, CONCURRENCY, async (row) => {
+        const externalId = Number(row.external_id);
+        const [version, skills, mcps] = await Promise.all([
+            row.head_version_id === null || row.head_version_id === undefined
+                ? Promise.resolve(null)
+                : read(client, 'get_version', { version_id: row.head_version_id }),
+            read(client, 'list_prompt_skills', { project_slug: project, prompt_external_id: externalId }),
+            read(client, 'list_prompt_mcps', { project_slug: project, prompt_external_id: externalId }),
+        ]);
+        const data = {
+            external_id: String(row.external_id),
+            name: String(row.name),
+            description: row.description ?? null,
+            version: version,
+            skills: skills.map((s) => String(s.name)),
+            mcp: mcps.map((m) => ({ instance_id: Number(m.id), enabled_tools: (m.enabled_tools ?? null) })),
+        };
+        return { kind: 'prompt', id: data.external_id, name: data.name, files: (0, render_1.renderPrompt)(data), data };
+    });
+}
+async function fetchSkills(client, project) {
+    const rows = await fetchAll(client, 'list_skills', { project_slug: project });
+    return (0, shared_1.mapWithConcurrency)(rows, CONCURRENCY, async (row) => {
+        const data = (await read(client, 'get_skill', { project_slug: project, skill_id: row.id }));
+        return { kind: 'skill', id: String(data.id), name: data.name, files: (0, render_1.renderSkill)(data), data };
+    });
+}
+async function fetchWorkflows(client, project) {
+    const rows = await fetchAll(client, 'list_workflows', { project_slug: project });
+    return (0, shared_1.mapWithConcurrency)(rows, CONCURRENCY, async (row) => {
+        const w = (await read(client, 'get_workflow', { project_slug: project, workflow_id: row.workflow_id }));
+        const active = [w.active_version, w.version].find((v) => typeof v === 'number');
+        const data = {
+            workflow_id: String(w.workflow_id), enabled: w.enabled !== false, definition: w.definition, active_version: active ?? null,
+        };
+        return { kind: 'workflow', id: data.workflow_id, name: data.workflow_id, files: (0, render_1.renderWorkflow)(data), data };
+    });
+}
+/** Rendered remote resources of the given kinds, in kind order. */
+async function fetchRemote(client, project, kinds) {
+    const out = [];
+    if (kinds.includes('prompt'))
+        out.push(...(await fetchPrompts(client, project)));
+    if (kinds.includes('skill'))
+        out.push(...(await fetchSkills(client, project)));
+    if (kinds.includes('workflow'))
+        out.push(...(await fetchWorkflows(client, project)));
+    return out;
+}

package/dist/sync/render.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonical = canonical;
+exports.renderPrompt = renderPrompt;
+exports.parsePrompt = parsePrompt;
+exports.versionPart = versionPart;
+exports.renderSkill = renderSkill;
+exports.parseSkill = parseSkill;
+exports.renderWorkflow = renderWorkflow;
+exports.parseWorkflow = parseWorkflow;
+const yaml_1 = require("yaml");
+const errors_1 = require("../errors");
+const VERSION_FIELDS = ['output_format', 'model_settings', 'model_fallbacks', 'output_schema'];
+const present = (v) => v !== null && v !== undefined;
+/** JSON with object keys sorted at every level, for order-insensitive comparison. */
+function canonical(value) {
+    return JSON.stringify(value, (_key, v) => v && typeof v === 'object' && !Array.isArray(v)
+        ? Object.fromEntries(Object.keys(v).sort().map((k) => [k, v[k]]))
+        : v);
+}
+const sortedMcp = (mcp) => [...mcp].sort((a, b) => a.instance_id - b.instance_id).map((m) => ({ instance_id: m.instance_id, enabled_tools: m.enabled_tools }));
+function renderPrompt(p) {
+    const doc = { name: p.name };
+    if (p.description)
+        doc.description = p.description;
+    const v = p.version;
+    if (v) {
+        const tier = v.model_tier?.tier_key;
+        doc.model = tier ? { tier } : { provider: v.model_provider, name: v.model_name };
+        for (const field of VERSION_FIELDS)
+            if (present(v[field]))
+                doc[field] = v[field];
+    }
+    if (p.skills.length)
+        doc.skills = [...p.skills].sort();
+    if (p.mcp.length)
+        doc.mcp = sortedMcp(p.mcp);
+    return { 'prompt.yaml': (0, yaml_1.stringify)(doc), 'system.md': v ? String(v.system_prompt ?? '') : '' };
+}
+function yamlObject(text, where) {
+    let doc;
+    try {
+        doc = (0, yaml_1.parse)(text);
+    }
+    catch (err) {
+        throw new errors_1.CliError(`${where} is not valid YAML: ${err.message}`);
+    }
+    if (doc === null || doc === undefined)
+        return {};
+    if (typeof doc !== 'object' || Array.isArray(doc))
+        throw new errors_1.CliError(`${where} must be a YAML mapping`);
+    return doc;
+}
+function parsePrompt(files, where) {
+    const file = `${where}/prompt.yaml`;
+    const raw = yamlObject(files['prompt.yaml'] ?? '', file);
+    if (typeof raw.name !== 'string' || !raw.name)
+        throw new errors_1.CliError(`${file}: "name" is required`);
+    if (raw.skills !== undefined && !Array.isArray(raw.skills))
+        throw new errors_1.CliError(`${file}: "skills" must be a list`);
+    if (raw.mcp !== undefined && !Array.isArray(raw.mcp))
+        throw new errors_1.CliError(`${file}: "mcp" must be a list`);
+    if (raw.description !== undefined && raw.description !== null && typeof raw.description !== 'string') {
+        throw new errors_1.CliError(`${file}: "description" must be a string`);
+    }
+    (raw.skills ?? []).forEach((s, i) => {
+        if (typeof s !== 'string')
+            throw new errors_1.CliError(`${file}: skills[${i}] must be a string`);
+    });
+    if (raw.model !== undefined && raw.model !== null) {
+        const m = raw.model;
+        const ok = typeof m === 'object' &&
+            !Array.isArray(m) &&
+            Object.entries(m).every(([k, v]) => ['provider', 'name', 'tier'].includes(k) && typeof v === 'string');
+        if (!ok)
+            throw new errors_1.CliError(`${file}: "model" must be { provider, name } or { tier }`);
+    }
+    (raw.mcp ?? []).forEach((m, i) => {
+        const e = m;
+        const tools = e?.enabled_tools;
+        const ok = e !== null &&
+            typeof e === 'object' &&
+            !Array.isArray(e) &&
+            Number.isInteger(e.instance_id) &&
+            (tools === undefined || tools === null || (Array.isArray(tools) && tools.every((t) => typeof t === 'string')));
+        if (!ok) {
+            throw new errors_1.CliError(`${file}: mcp[${i}] must be { instance_id: <integer>, enabled_tools: <list of strings> | null }`);
+        }
+    });
+    const doc = {
+        name: raw.name,
+        skills: [...(raw.skills ?? [])].sort(),
+        mcp: sortedMcp((raw.mcp ?? []).map((m) => ({
+            instance_id: Number(m.instance_id),
+            enabled_tools: (m.enabled_tools ?? null),
+        }))),
+        system: files['system.md'] ?? '',
+    };
+    if (typeof raw.description === 'string' && raw.description)
+        doc.description = raw.description;
+    if (raw.model)
+        doc.model = raw.model;
+    for (const field of VERSION_FIELDS)
+        if (present(raw[field]))
+            doc[field] = raw[field];
+    return doc;
+}
+/**
+ * Everything that defines a prompt version; equal strings mean no new version is needed.
+ * For comparison and hashing only: CRLF counts as LF, like the status hashes (what a push
+ * sends is the file content as is).
+ */
+function versionPart(doc) {
+    return canonical({
+        model: doc.model ?? null,
+        output_format: doc.output_format ?? null,
+        model_settings: doc.model_settings ?? null,
+        model_fallbacks: doc.model_fallbacks ?? null,
+        output_schema: doc.output_schema ?? null,
+        system: doc.system.replace(/\r\n/g, '\n'),
+    });
+}
+function renderSkill(s) {
+    const front = { name: s.name };
+    if (s.description !== null && s.description !== undefined)
+        front.description = s.description;
+    if (Array.isArray(s.references) && s.references.length)
+        front.references = s.references;
+    front.enabled = s.enabled;
+    return { 'skill.md': `---\n${(0, yaml_1.stringify)(front)}---\n\n${s.content}` };
+}
+function parseSkill(text, where) {
+    const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n\r?\n?([\s\S]*)$/.exec(text.replace(/^\ufeff/, ''));
+    if (!match)
+        throw new errors_1.CliError(`${where}: needs YAML frontmatter with "name" (---\\nname: …\\n---)`);
+    const front = yamlObject(match[1], `${where} frontmatter`);
+    if (typeof front.name !== 'string' || !front.name)
+        throw new errors_1.CliError(`${where}: needs YAML frontmatter with "name"`);
+    const doc = { name: front.name, content: match[2] };
+    if (front.description !== undefined && front.description !== null) {
+        if (typeof front.description !== 'string')
+            throw new errors_1.CliError(`${where}: "description" must be a string`);
+        doc.description = front.description;
+    }
+    if (front.references !== undefined && front.references !== null) {
+        if (!Array.isArray(front.references))
+            throw new errors_1.CliError(`${where}: "references" must be a list`);
+        doc.references = front.references;
+    }
+    if (front.enabled !== undefined) {
+        if (typeof front.enabled !== 'boolean')
+            throw new errors_1.CliError(`${where}: "enabled" must be true or false`);
+        doc.enabled = front.enabled;
+    }
+    return doc;
+}
+function renderWorkflow(w) {
+    return {
+        'workflow.yaml': (0, yaml_1.stringify)({ enabled: w.enabled }),
+        'definition.json': `${JSON.stringify(w.definition, null, 2)}\n`,
+    };
+}
+function parseWorkflow(files, where) {
+    if (files['definition.json'] === undefined)
+        throw new errors_1.CliError(`${where}/definition.json is missing`);
+    let definition;
+    try {
+        definition = JSON.parse(files['definition.json']);
+    }
+    catch (err) {
+        throw new errors_1.CliError(`${where}/definition.json is not valid JSON: ${err.message}`);
+    }
+    if (!definition || typeof definition !== 'object' || Array.isArray(definition)) {
+        throw new errors_1.CliError(`${where}/definition.json must be a JSON object`);
+    }
+    const meta = yamlObject(files['workflow.yaml'] ?? '', `${where}/workflow.yaml`);
+    if (meta.enabled !== undefined && typeof meta.enabled !== 'boolean') {
+        throw new errors_1.CliError(`${where}/workflow.yaml: "enabled" must be true or false`);
+    }
+    return { enabled: meta.enabled === undefined ? true : meta.enabled, definition: definition };
+}

package/dist/sync/status.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeEntries = computeEntries;
+const workspace_1 = require("./workspace");
+function proposedKey(r) {
+    if (r.kind === 'workflow') {
+        const unsafe = /[/\\:\0]/.test(r.id) || r.id === '.' || r.id === '..';
+        return `${workspace_1.KIND_DIR.workflow}/${unsafe ? 'workflow-' + (0, workspace_1.slugify)(r.id, 'workflow') : r.id}`;
+    }
+    const slug = (0, workspace_1.slugify)(r.name, `${r.kind}-${r.id}`);
+    return r.kind === 'skill' ? `${workspace_1.KIND_DIR.skill}/${slug}.md` : `${workspace_1.KIND_DIR.prompt}/${slug}`;
+}
+function withSuffix(key, id) {
+    return key.endsWith('.md') ? `${key.slice(0, -3)}-${id}.md` : `${key}-${id}`;
+}
+function computeEntries(root, state, remote, kinds) {
+    const tracked = Object.entries(state.resources).filter(([, s]) => kinds.includes(s.kind));
+    const remoteAt = new Map();
+    const taken = new Set(tracked.map(([key]) => key));
+    for (const r of remote) {
+        const known = tracked.find(([, s]) => s.kind === r.kind && s.id === r.id);
+        let key = known ? known[0] : proposedKey(r);
+        if (!known && (taken.has(key) || remoteAt.has(key))) {
+            const base = key;
+            key = withSuffix(base, (0, workspace_1.slugify)(r.id, 'id'));
+            for (let n = 2; taken.has(key) || remoteAt.has(key); n += 1)
+                key = withSuffix(base, `${(0, workspace_1.slugify)(r.id, 'id')}-${n}`);
+        }
+        taken.add(key);
+        remoteAt.set(key, r);
+    }
+    const locals = (0, workspace_1.listLocal)(root, kinds);
+    const keys = new Set([...remoteAt.keys(), ...tracked.map(([k]) => k), ...locals.map((l) => l.key)]);
+    const entries = [];
+    for (const key of [...keys].sort()) {
+        const s = state.resources[key];
+        const r = remoteAt.get(key);
+        const kind = (s?.kind ?? r?.kind ?? locals.find((l) => l.key === key).kind);
+        if (!kinds.includes(kind))
+            continue;
+        const local = (0, workspace_1.readLocal)(root, key, kind);
+        let status;
+        let refresh = false;
+        if (local && r && (0, workspace_1.hashFiles)(local) === (0, workspace_1.hashFiles)(r.files)) {
+            // Converged (e.g. a pull interrupted after writing files, or the same edit made on
+            // both sides): nothing to sync whatever the recorded baseline says.
+            status = 'unchanged';
+            refresh = !s || s.base !== (0, workspace_1.hashFiles)(local) || s.remote !== (0, workspace_1.hashFiles)(r.files);
+        }
+        else if (local && s && r) {
+            const localChanged = (0, workspace_1.hashFiles)(local) !== s.base;
+            const remoteChanged = (0, workspace_1.hashFiles)(r.files) !== s.remote;
+            status = localChanged && remoteChanged ? 'conflict' : localChanged ? 'modified' : remoteChanged ? 'remote-changed' : 'unchanged';
+        }
+        else if (local && !s)
+            status = r ? 'conflict' : 'new';
+        else if (!local && s && r)
+            status = 'deleted';
+        else if (s && !r)
+            status = 'remote-deleted';
+        else
+            status = 'remote-new';
+        entries.push({ key, kind, status, local, remote: r, state: s, ...(refresh ? { refresh } : {}) });
+    }
+    return detectRenames(entries);
+}
+/** A new directory identical to exactly one deleted directory of the same kind is a rename. */
+function detectRenames(entries) {
+    const dropped = new Set();
+    const out = [];
+    for (const e of entries) {
+        if (e.status === 'new') {
+            const h = (0, workspace_1.hashFiles)(e.local);
+            const matches = entries.filter((d) => d.status === 'deleted' && d.kind === e.kind && !dropped.has(d) && d.state.base === h);
+            const newMatches = entries.filter((n) => n.status === 'new' && n.kind === e.kind && (0, workspace_1.hashFiles)(n.local) === h);
+            if (matches.length === 1 && newMatches.length === 1) {
+                const d = matches[0];
+                dropped.add(d);
+                dropped.add(e);
+                out.push({ key: e.key, kind: e.kind, status: 'renamed', local: e.local, remote: d.remote, state: d.state, from: d.key });
+            }
+        }
+    }
+    return [...entries.filter((e) => !dropped.has(e)), ...out].sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));
+}