@cargo-ai/cli 1.0.18 → 1.0.20

package/build/commands/workflow/inputTypes.js

@@ -0,0 +1,175 @@
+// TypeScript input-type printers for `cargo-ai workflow sync` codegen.
+//
+// Three sources of truth, three printers:
+//   - Integration actions expose their config as JSON Schema on
+//     `connection.integration.list` (`action.config.schema`).
+//   - Workspace tools expose their input as `formFields` on the tool
+//     workflow's deployed release (`orchestration.release.getDeployed`).
+//   - Agent nodes accept a single global shape (`{ prompt, output? }`) —
+//     the engine validates every agent node against `AiUtils.agentConfig`.
+//
+// All printers run in "input mode": each top-level property is widened to
+// `Ref<T> | T` so callers can pass either a builder Ref or a literal.
+// Anything unrecognized falls back to `unknown` — codegen must never abort
+// on a schema edge case.
+//
+// Mirrors `packages/workflow-sdk/scripts/lib/jsonSchemaToTs.ts` (which is a
+// build-time-only script the CLI can't import).
+/**
+ * Fixed input shape of every agent node. Matches the SDK's `AgentInput`
+ * type and the engine's `AiUtils.agentConfig` schema.
+ */
+export const AGENT_INPUT_TYPE_SRC = `{ prompt: Ref<string> | string; ` +
+    `output?: { type: "default" | "text" | "jsonSchema"; jsonSchema?: Record<string, unknown> } }`;
+/**
+ * Print an integration action's JSON Schema config as a TS input type.
+ * Returns `"Record<string, unknown>"` when the schema is missing or not an
+ * object schema we can render.
+ */
+export function printJsonSchemaInput(schema) {
+    if (schema === null || typeof schema !== "object") {
+        return "Record<string, unknown>";
+    }
+    const printed = printSchema(schema, true);
+    return printed === "unknown" ? "Record<string, unknown>" : printed;
+}
+function printSchema(schema, topLevel) {
+    if (Array.isArray(schema.type)) {
+        return uniqueUnion(schema.type.map((t) => printPrimitive(t, schema, false)));
+    }
+    if (schema.enum !== undefined && schema.enum.length > 0) {
+        return schema.enum.map((v) => JSON.stringify(v)).join(" | ");
+    }
+    if (schema.const !== undefined) {
+        return JSON.stringify(schema.const);
+    }
+    if (schema.oneOf !== undefined && schema.oneOf.length > 0) {
+        return uniqueUnion(schema.oneOf.map((s) => printSchema(s, false)));
+    }
+    if (schema.anyOf !== undefined && schema.anyOf.length > 0) {
+        return uniqueUnion(schema.anyOf.map((s) => printSchema(s, false)));
+    }
+    if (schema.allOf !== undefined && schema.allOf.length > 0) {
+        // Conservative: render the head rather than a TS intersection.
+        return printSchema(schema.allOf[0], topLevel);
+    }
+    if (typeof schema.type !== "string")
+        return "unknown";
+    return printPrimitive(schema.type, schema, topLevel);
+}
+function printPrimitive(type, schema, topLevel) {
+    switch (type) {
+        case "string":
+            return "string";
+        case "number":
+        case "integer":
+            return "number";
+        case "boolean":
+            return "boolean";
+        case "null":
+            return "null";
+        case "array":
+            return printArray(schema);
+        case "object":
+            return printObject(schema, topLevel);
+        default:
+            return "unknown";
+    }
+}
+function printArray(schema) {
+    if (schema.items === undefined)
+        return "unknown[]";
+    if (Array.isArray(schema.items)) {
+        return `[${schema.items.map((s) => printSchema(s, false)).join(", ")}]`;
+    }
+    return `Array<${printSchema(schema.items, false)}>`;
+}
+function printObject(schema, topLevel) {
+    const props = schema.properties;
+    if (props === undefined) {
+        if (typeof schema.additionalProperties === "object" &&
+            schema.additionalProperties !== null) {
+            return `Record<string, ${printSchema(schema.additionalProperties, false)}>`;
+        }
+        return "Record<string, unknown>";
+    }
+    const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+    const fields = [];
+    for (const [key, child] of Object.entries(props)) {
+        const inner = printSchema(child, false);
+        // Only top-level properties are Ref-widened; nested values are plain.
+        const value = topLevel ? `Ref<${inner}> | ${inner}` : inner;
+        const opt = required.has(key) ? "" : "?";
+        fields.push(`${tsKey(key)}${opt}: ${value}`);
+    }
+    if (fields.length === 0)
+        return "Record<string, never>";
+    return `{ ${fields.join("; ")} }`;
+}
+/**
+ * Print a tool release's `formFields` as a TS input type. Returns
+ * `undefined` when the fields can't be interpreted (caller falls back to
+ * `Record<string, unknown>`).
+ */
+export function printFormFieldsInput(formFields) {
+    if (!Array.isArray(formFields))
+        return undefined;
+    const fields = formFields.filter(isFormFieldLike);
+    if (fields.length === 0)
+        return "Record<string, never>";
+    const rendered = fields.map((f) => {
+        const inner = formFieldToTs(f);
+        const opt = f.isRequired === true ? "" : "?";
+        return `${tsKey(f.slug)}${opt}: Ref<${inner}> | ${inner}`;
+    });
+    return `{ ${rendered.join("; ")} }`;
+}
+function isFormFieldLike(value) {
+    if (value === null || typeof value !== "object")
+        return false;
+    const v = value;
+    return typeof v["slug"] === "string" && typeof v["kind"] === "string";
+}
+function formFieldToTs(field) {
+    switch (field.kind) {
+        case "string":
+        case "date":
+            return "string";
+        case "number":
+            return "number";
+        case "boolean":
+            return "boolean";
+        case "enum": {
+            const values = Array.isArray(field.enum)
+                ? field.enum.filter((v) => typeof v === "string")
+                : [];
+            if (values.length === 0)
+                return "string";
+            return values.map((v) => JSON.stringify(v)).join(" | ");
+        }
+        case "array": {
+            const nested = Array.isArray(field.fields)
+                ? field.fields.filter(isFormFieldLike)
+                : [];
+            if (nested.length === 0)
+                return "unknown[]";
+            const inner = nested
+                .map((f) => {
+                const opt = f.isRequired === true ? "" : "?";
+                return `${tsKey(f.slug)}${opt}: ${formFieldToTs(f)}`;
+            })
+                .join("; ");
+            return `Array<{ ${inner} }>`;
+        }
+        case "any":
+        default:
+            return "unknown";
+    }
+}
+function uniqueUnion(parts) {
+    const dedup = Array.from(new Set(parts));
+    return dedup.length === 1 ? dedup[0] : dedup.join(" | ");
+}
+function tsKey(key) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+}

package/build/commands/workflow/sync.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "commander";
+import type { Api } from "../../api.js";
+export declare function registerSyncCommand(parent: Command, getApi: () => Api): void;
+//# sourceMappingURL=sync.d.ts.map

package/build/commands/workflow/sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../../../src/commands/workflow/sync.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAgGxC,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,GAAG,IAAI,CAsD5E"}

package/build/commands/workflow/sync.js

@@ -0,0 +1,454 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { handleApiCall, info, success } from "../runHandler.js";
+import { AGENT_INPUT_TYPE_SRC, printFormFieldsInput, printJsonSchemaInput, } from "./inputTypes.js";
+// Composite natives surfaced via dedicated SDK syntax / scope helpers —
+// excluded so we don't double-register them. Mirrors the codegen exclusion
+// list in `packages/workflow-sdk/scripts/generateNativeIntegration.ts`
+// (everything in the `logic` category gets dedicated syntax instead of
+// going through `native.<slug>`).
+const COMPOSITE_NATIVE = new Set([
+    "start",
+    "end",
+    "agent",
+    "balance",
+    "branch",
+    "delay",
+    "filter",
+    "group",
+    "humanReview",
+    "memory",
+    "split",
+    "switch",
+    "tool",
+    "variables",
+]);
+// Native actions the SDK already ships typed declarations + registrations
+// for (platform-level, identical in every workspace) — skipped so the
+// synced `.d.ts` doesn't redeclare `Native` properties with conflicting
+// (looser) types. Source of truth lives in
+// `packages/workflow-sdk/src/native/manifest.generated.ts`.
+const BUNDLED_NATIVE = new Set([
+    "note",
+    "python",
+    "scoring",
+    "script",
+]);
+export function registerSyncCommand(parent, getApi) {
+    parent
+        .command("sync")
+        .description("Generate per-workspace TypeScript types + eager registration for the Cargo Workflow SDK")
+        .option("--out <dir>", "Output directory for generated files (default: .cargo-ai)", ".cargo-ai")
+        .option("--cwd <dir>", "Working directory the --out path is resolved against (default: process.cwd())")
+        .action(async (opts) => {
+        const api = getApi();
+        const baseDir = opts.cwd !== undefined ? opts.cwd : process.cwd();
+        const outDir = resolve(baseDir, opts.out);
+        info(`Fetching workspace surface…`);
+        const payload = await fetchWorkspaceSurface(api);
+        mkdirSync(outDir, { recursive: true });
+        const typesPath = resolve(outDir, "cargo-types.d.ts");
+        writeFileSync(typesPath, renderTypes(payload));
+        success(`Wrote ${relativeToBase(baseDir, typesPath)}`);
+        const eagerPath = resolve(outDir, "cargo-register.ts");
+        writeFileSync(eagerPath, renderEagerRegistration(payload));
+        success(`Wrote ${relativeToBase(baseDir, eagerPath)}`);
+        info(``);
+        info([
+            `Next steps:`,
+            `  1. Add ${relativeToBase(baseDir, outDir)} to your tsconfig include`,
+            `     so the .d.ts is picked up.`,
+            `  2. Add \`import "./${relativeToBase(baseDir, eagerPath).replace(/\.ts$/, ".js")}";\``,
+            `     to your project's entry file (or before any defineWorkflow call)`,
+            `     so the workspace's integrations / tools / agents register at runtime.`,
+        ].join("\n"));
+        info(``);
+        info(`Synced ${String(payload.integrations.length)} integration(s), ${String(payload.tools.length)} tool(s), ${String(payload.agents.length)} agent(s), ${String(payload.native.length)} native action(s).`);
+    });
+}
+async function fetchWorkspaceSurface(api) {
+    const integrationsResult = await handleApiCall(() => api.connection.integration.list({}));
+    const nativeIntegrationResult = await handleApiCall(() => api.connection.nativeIntegration.get());
+    const orchestrationToolsResult = await handleApiCall(() => api.orchestration.tool.all());
+    const aiAgentsResult = await handleApiCall(() => api.ai.agent.all());
+    const integrations = collectIntegrations(integrationsResult.integrations);
+    const tools = collectTools(orchestrationToolsResult.tools);
+    await resolveToolInputTypes(api, tools);
+    const agents = collectAgents(aiAgentsResult);
+    const native = collectNative(nativeIntegrationResult.nativeIntegration.actions);
+    return { integrations, tools, agents, native };
+}
+function collectIntegrations(integrations) {
+    const out = [];
+    for (const integration of integrations) {
+        const actionEntries = Object.entries(integration.actions ?? {}).sort(([a], [b]) => a.localeCompare(b));
+        if (actionEntries.length === 0)
+            continue;
+        const actions = actionEntries.map(([slug, raw]) => {
+            const meta = raw;
+            return {
+                slug,
+                name: trimOrUndefined(meta.name),
+                description: trimOrUndefined(meta.description),
+                inputTypeSrc: printJsonSchemaInput(meta.config?.schema),
+            };
+        });
+        out.push({
+            slug: integration.slug,
+            name: trimOrUndefined(integration.name),
+            description: trimOrUndefined(integration.description),
+            actions,
+        });
+    }
+    out.sort((a, b) => a.slug.localeCompare(b.slug));
+    return out;
+}
+function collectTools(workspaceTools) {
+    const out = [];
+    const used = new Set();
+    for (const t of workspaceTools) {
+        out.push({
+            slug: pickSlug(t.name, t.uuid, used),
+            name: t.name,
+            description: trimOrUndefined(t.description),
+            uuid: t.uuid,
+            workflowUuid: t.workflowUuid,
+            updatedAt: dateToIso(t.updatedAt),
+            inputTypeSrc: "Record<string, unknown>",
+        });
+    }
+    out.sort((a, b) => a.slug.localeCompare(b.slug));
+    return out;
+}
+// The tools list endpoint doesn't carry input schemas — they live on each
+// tool workflow's deployed release as `formFields`. Resolve them with one
+// `release.getDeployed` call per tool (bounded concurrency). A tool without
+// a deployed release (or whose release fetch fails) keeps the
+// `Record<string, unknown>` fallback; sync must not abort over one tool.
+const TOOL_RELEASE_CONCURRENCY = 5;
+async function resolveToolInputTypes(api, tools) {
+    const queue = [...tools];
+    const workers = Array.from({ length: Math.min(TOOL_RELEASE_CONCURRENCY, queue.length) }, async () => {
+        for (;;) {
+            const tool = queue.shift();
+            if (tool === undefined)
+                return;
+            try {
+                const result = await api.orchestration.release.getDeployed({
+                    workflowUuid: tool.workflowUuid,
+                });
+                const formFields = result.release?.formFields;
+                const printed = printFormFieldsInput(formFields);
+                if (printed !== undefined) {
+                    tool.inputTypeSrc = printed;
+                }
+            }
+            catch {
+                // Not deployed / not accessible — keep the loose fallback type.
+            }
+        }
+    });
+    await Promise.all(workers);
+}
+function collectAgents(workspaceAgents) {
+    const out = [];
+    const used = new Set();
+    const allAgents = isAgentsResult(workspaceAgents)
+        ? workspaceAgents.agents
+        : [];
+    for (const a of allAgents) {
+        out.push({
+            slug: pickSlug(a.name, a.uuid, used),
+            name: a.name,
+            description: trimOrUndefined(a.description),
+            uuid: a.uuid,
+            updatedAt: dateToIso(a.updatedAt),
+        });
+    }
+    out.sort((a, b) => a.slug.localeCompare(b.slug));
+    return out;
+}
+function isAgentsResult(value) {
+    if (value === null || typeof value !== "object")
+        return false;
+    const v = value;
+    return Array.isArray(v.agents);
+}
+function collectNative(actions) {
+    const out = [];
+    for (const [slug, meta] of Object.entries(actions)) {
+        if (COMPOSITE_NATIVE.has(slug))
+            continue;
+        if (BUNDLED_NATIVE.has(slug))
+            continue;
+        const name = meta.name.length > 0 ? meta.name : slug;
+        out.push({
+            slug,
+            name,
+            description: trimOrUndefined(meta.description),
+        });
+    }
+    out.sort((a, b) => a.slug.localeCompare(b.slug));
+    return out;
+}
+function trimOrUndefined(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function dateToIso(value) {
+    if (value === null || value === undefined)
+        return undefined;
+    if (value instanceof Date) {
+        return Number.isNaN(value.getTime()) ? undefined : value.toISOString();
+    }
+    if (typeof value === "string") {
+        const date = new Date(value);
+        return Number.isNaN(date.getTime()) ? undefined : date.toISOString();
+    }
+    return undefined;
+}
+// Slugify `name` to a JS identifier; append a UUID-based suffix on collision
+// (or when the name slugifies to nothing). `used` is mutated.
+function pickSlug(name, uuid, used) {
+    const base = slugify(name);
+    if (base.length > 0 && !used.has(base)) {
+        used.add(base);
+        return base;
+    }
+    const suffix = uuid.replace(/-/g, "_");
+    const fallback = base.length > 0 ? `${base}_${suffix}` : `_${suffix}`;
+    used.add(fallback);
+    return fallback;
+}
+function slugify(name) {
+    const normalized = name
+        .normalize("NFKD")
+        .replace(/[^\w]+/g, "_")
+        .replace(/^_+|_+$/g, "")
+        .toLowerCase();
+    if (normalized.length === 0)
+        return "";
+    // JS identifiers can't start with a digit.
+    return /^\d/.test(normalized) ? `_${normalized}` : normalized;
+}
+const GENERATED_AT = new Date().toISOString();
+const HEADER = `// THIS FILE IS GENERATED by \`cargo-ai workflow sync\`. Do not edit by hand.
+// Re-run the command to refresh after adding/removing workspace integrations,
+// tools, or agents.
+// Last regenerated: ${GENERATED_AT}
+
+`;
+function renderTypes(payload) {
+    const lines = [];
+    lines.push(`declare module "@cargo-ai/workflow-sdk" {`);
+    if (payload.integrations.length > 0) {
+        lines.push(`  interface Integrations {`);
+        for (const c of payload.integrations) {
+            const intDoc = formatJsDoc({
+                name: c.name ?? c.slug,
+                description: c.description,
+                updatedAt: GENERATED_AT,
+            }, "    ");
+            if (intDoc !== "")
+                lines.push(intDoc.trimEnd());
+            lines.push(`    ${jsonKey(c.slug)}: {`);
+            for (const action of c.actions) {
+                const actionDoc = formatJsDoc({
+                    name: action.name,
+                    description: action.description,
+                    category: c.slug,
+                    updatedAt: GENERATED_AT,
+                }, "      ");
+                if (actionDoc !== "")
+                    lines.push(actionDoc.trimEnd());
+                lines.push(`      ${jsonKey(action.slug)}: IntegrationAction<${action.inputTypeSrc}, Record<string, unknown>>;`);
+            }
+            lines.push(`    };`);
+        }
+        lines.push(`  }`);
+    }
+    if (payload.tools.length > 0) {
+        lines.push(`  interface Tools {`);
+        for (const t of payload.tools) {
+            const doc = formatJsDoc({
+                name: t.name,
+                description: t.description,
+                updatedAt: t.updatedAt ?? GENERATED_AT,
+            }, "    ");
+            if (doc !== "")
+                lines.push(doc.trimEnd());
+            lines.push(`    ${jsonKey(t.slug)}: ToolFn<${t.inputTypeSrc}, Record<string, unknown>>;`);
+        }
+        lines.push(`  }`);
+    }
+    if (payload.agents.length > 0) {
+        lines.push(`  interface Agents {`);
+        for (const a of payload.agents) {
+            const doc = formatJsDoc({
+                name: a.name,
+                description: a.description,
+                updatedAt: a.updatedAt ?? GENERATED_AT,
+            }, "    ");
+            if (doc !== "")
+                lines.push(doc.trimEnd());
+            lines.push(`    ${jsonKey(a.slug)}: AgentFn<${AGENT_INPUT_TYPE_SRC}, AgentDefaultOutput>;`);
+        }
+        lines.push(`  }`);
+    }
+    if (payload.native.length > 0) {
+        lines.push(`  interface Native {`);
+        for (const n of payload.native) {
+            const doc = formatJsDoc({
+                name: n.name,
+                description: n.description,
+                updatedAt: GENERATED_AT,
+            }, "    ");
+            if (doc !== "")
+                lines.push(doc.trimEnd());
+            lines.push(`    ${jsonKey(n.slug)}: NativeAction<Record<string, unknown>, Record<string, unknown>>;`);
+        }
+        lines.push(`  }`);
+    }
+    lines.push(`}`);
+    lines.push(``);
+    const body = lines.join("\n");
+    // `Ref` only appears when at least one entry has a typed input, so import
+    // it conditionally to keep the generated .d.ts free of unused imports.
+    const imports = [
+        "AgentDefaultOutput",
+        "AgentFn",
+        "IntegrationAction",
+        "NativeAction",
+        ...(body.includes("Ref<") ? ["Ref"] : []),
+        "ToolFn",
+    ];
+    const header = [
+        HEADER.trim(),
+        `import type {`,
+        ...imports.map((name) => `  ${name},`),
+        `} from "@cargo-ai/workflow-sdk";`,
+        ``,
+    ].join("\n");
+    return `${header}\n${body}`;
+}
+function renderEagerRegistration(payload) {
+    const lines = [];
+    lines.push(HEADER.trim());
+    const imports = [];
+    if (payload.integrations.length > 0)
+        imports.push("registerIntegration");
+    if (payload.tools.length > 0)
+        imports.push("registerTool");
+    if (payload.agents.length > 0)
+        imports.push("registerAgent");
+    if (payload.native.length > 0)
+        imports.push("registerNative");
+    if (imports.length === 0) {
+        lines.push(``);
+        lines.push(`// Workspace surface is empty (no custom integrations / tools / agents / natives).`);
+        lines.push(``);
+        return lines.join("\n");
+    }
+    lines.push(`import { ${imports.join(", ")} } from "@cargo-ai/workflow-sdk";`);
+    lines.push(``);
+    for (const c of payload.integrations) {
+        lines.push(`registerIntegration(${JSON.stringify(c.slug)}, {`);
+        for (const action of c.actions) {
+            const displayName = action.name !== undefined && action.name.length > 0
+                ? action.name
+                : `${capitalize(c.slug)} ${humanize(action.slug)}`;
+            lines.push(`  ${jsonKey(action.slug)}: { name: ${JSON.stringify(displayName)} },`);
+        }
+        lines.push(`});`);
+    }
+    for (const t of payload.tools) {
+        lines.push(`registerTool(${JSON.stringify(t.slug)}, { toolUuid: ${JSON.stringify(t.uuid)} }, ${JSON.stringify(t.name)});`);
+    }
+    for (const a of payload.agents) {
+        lines.push(`registerAgent(${JSON.stringify(a.slug)}, { agentUuid: ${JSON.stringify(a.uuid)} }, ${JSON.stringify(a.name)});`);
+    }
+    for (const n of payload.native) {
+        lines.push(`registerNative(${JSON.stringify(n.slug)}, ${JSON.stringify(n.name)});`);
+    }
+    lines.push(``);
+    return lines.join("\n");
+}
+function jsonKey(key) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+}
+// Render a JSDoc block above a generated declaration so editors surface the
+// entry's metadata on hover. Returns "" when there's nothing to document.
+function formatJsDoc(doc, indent) {
+    const body = [];
+    if (doc.name !== undefined && doc.name.trim().length > 0) {
+        body.push(doc.name.trim());
+    }
+    if (doc.description !== undefined && doc.description.trim().length > 0) {
+        if (body.length > 0)
+            body.push("");
+        for (const line of doc.description.split("\n")) {
+            body.push(line.trimEnd());
+        }
+    }
+    const tags = [];
+    if (doc.category !== undefined) {
+        const cats = Array.isArray(doc.category)
+            ? doc.category.join(", ")
+            : String(doc.category);
+        if (cats.trim().length > 0) {
+            tags.push(`@category ${cats}`);
+        }
+    }
+    if (doc.author !== undefined && doc.author.trim().length > 0) {
+        tags.push(`@author ${doc.author.trim()}`);
+    }
+    if (doc.version !== undefined && String(doc.version).length > 0) {
+        tags.push(`@version ${String(doc.version)}`);
+    }
+    if (doc.updatedAt !== undefined && doc.updatedAt !== null) {
+        const date = doc.updatedAt instanceof Date ? doc.updatedAt : new Date(doc.updatedAt);
+        if (!Number.isNaN(date.getTime())) {
+            tags.push(`@updated ${date.toISOString().slice(0, 10)}`);
+        }
+    }
+    if (doc.see !== undefined && doc.see.trim().length > 0) {
+        tags.push(`@see ${doc.see.trim()}`);
+    }
+    if (body.length > 0 && tags.length > 0) {
+        body.push("");
+    }
+    body.push(...tags);
+    if (body.length === 0)
+        return "";
+    const out = [`${indent}/**`];
+    for (const line of body) {
+        const safe = line.replace(/\*\//g, "*\\/");
+        out.push(safe.length > 0 ? `${indent} * ${safe}` : `${indent} *`);
+    }
+    out.push(`${indent} */`);
+    return `${out.join("\n")}\n`;
+}
+function capitalize(s) {
+    if (s.length === 0)
+        return s;
+    const first = s[0];
+    if (first === undefined)
+        return s;
+    return first.toUpperCase() + s.slice(1);
+}
+function humanize(slug) {
+    return slug
+        .replace(/([A-Z])/g, " $1")
+        .replace(/[_-]+/g, " ")
+        .trim()
+        .toLowerCase();
+}
+function relativeToBase(base, path) {
+    if (path.startsWith(base)) {
+        const rel = path.slice(base.length);
+        return rel.startsWith("/") ? rel.slice(1) : rel;
+    }
+    return path;
+}

package/build/index.js

@@ -6,6 +6,7 @@ import { registerAiCommands } from "./commands/ai/index.js";
 import { registerAuthCommands } from "./commands/auth/index.js";
 import { registerBillingCommands } from "./commands/billing/index.js";
 import { registerConnectionCommands } from "./commands/connection/index.js";
+import { registerContentCommands } from "./commands/content/index.js";
 import { registerContextCommands } from "./commands/context/index.js";
 import { registerExpressionCommands } from "./commands/expression/index.js";
 import { registerHostingCommands } from "./commands/hosting/index.js";
@@ -60,6 +61,7 @@ registerInitCommand(program, getApi);
 registerOrchestrationCommands(program, getApi);
 registerWorkspaceManagementCommands(program, getApi);
 registerStorageCommands(program, getApi);
+registerContentCommands(program, getApi);
 registerConnectionCommands(program, getApi);
 registerContextCommands(program, getApi);
 registerBillingCommands(program, getApi);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cargo-ai/cli",
-  "version": "1.0.18",
+  "version": "1.0.20",
   "private": false,
   "description": "Command-line interface for the Cargo API",
   "engines": {
@@ -28,10 +28,11 @@
     "format:check": "prettier --check ."
   },
   "dependencies": {
-    "@cargo-ai/api": "^1.0.26",
+    "@cargo-ai/api": "^1.0.27",
     "@cargo-ai/app-sdk": "^1.0.0",
-    "@cargo-ai/worker-sdk": "^1.0.1",
-    "commander": "^12.1.0"
+    "@cargo-ai/worker-sdk": "^1.0.2",
+    "commander": "^12.1.0",
+    "tsx": "^4.19.2"
   },
   "devDependencies": {
     "@cargo-ai/eslint-config": "*",
@@ -40,7 +41,6 @@
     "@types/node": "^20.10.8",
     "eslint": "9.26.0",
     "prettier": "3.3.3",
-    "tsx": "^4.19.2",
     "typescript": "5.3.2"
   }
 }

package/build/commands/ai/file.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../../src/commands/ai/file.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAGxC,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,GAAG,IAAI,CAkF7E"}