@cargo-ai/cdk 1.0.3 → 1.0.4

package/build/src/cli/inputTypes.js

@@ -0,0 +1,273 @@
+// 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, false);
+    return printed === "unknown" ? "Record<string, unknown>" : printed;
+}
+/**
+ * Like {@link printJsonSchemaInput} but WITHOUT the top-level `Ref<T> | T`
+ * widening — for CDK connector/model config types, which are plain data (no
+ * workflow builder Refs). Used by `cargo-ai cdk types`.
+ */
+export function printJsonSchemaType(schema) {
+    if (schema === null || typeof schema !== "object") {
+        return "Record<string, unknown>";
+    }
+    // encRef=true: print `EncryptionRef` at encryption-typed fields so only those
+    // accept a `secret()`.
+    const printed = printSchema(schema, false, true);
+    return printed === "unknown" ? "Record<string, unknown>" : printed;
+}
+// The platform's shared `encryption` schema definition: an object with a `type`
+// const/enum of "encryption" plus `isEncrypted` and `value`. In CDK config types
+// these positions become `EncryptionRef` (see printObject).
+function isEncryptionSchema(schema) {
+    const props = schema.properties;
+    if (props === undefined)
+        return false;
+    const typeProp = props["type"];
+    if (typeProp === undefined)
+        return false;
+    const isEnc = typeProp.const === "encryption" ||
+        (Array.isArray(typeProp.enum) &&
+            typeProp.enum.length === 1 &&
+            typeProp.enum[0] === "encryption");
+    return (isEnc && props["isEncrypted"] !== undefined && props["value"] !== undefined);
+}
+function printSchema(schema, topLevel, encRef) {
+    if (Array.isArray(schema.type)) {
+        return uniqueUnion(schema.type.map((t) => printPrimitive(t, schema, false, encRef)));
+    }
+    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, encRef)));
+    }
+    if (schema.anyOf !== undefined && schema.anyOf.length > 0) {
+        return uniqueUnion(schema.anyOf.map((s) => printSchema(s, false, encRef)));
+    }
+    if (schema.allOf !== undefined && schema.allOf.length > 0) {
+        // Connectors model "pick an auth method, then its fields" as an object with
+        // a discriminant property plus `allOf: [{ if, then, else }]`. Expand that to
+        // a discriminated union (e.g. HubSpot → `{ method: "privateApp"; … } | { …
+        // "oauth"; … }`); otherwise fall back to rendering the head.
+        const conditional = printConditionalObject(schema, topLevel, encRef);
+        if (conditional !== undefined)
+            return conditional;
+        return printSchema(schema.allOf[0], topLevel, encRef);
+    }
+    if (typeof schema.type !== "string")
+        return "unknown";
+    return printPrimitive(schema.type, schema, topLevel, encRef);
+}
+function printPrimitive(type, schema, topLevel, encRef) {
+    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, encRef);
+        case "object":
+            return printObject(schema, topLevel, encRef);
+        default:
+            return "unknown";
+    }
+}
+// Expand the connector "discriminant + allOf[{ if, then, else }]" pattern into a
+// discriminated union. Returns undefined when the schema isn't that shape (the
+// caller then falls back to rendering the allOf head).
+function printConditionalObject(schema, topLevel, encRef) {
+    const props = schema.properties;
+    if (props === undefined || schema.allOf === undefined)
+        return undefined;
+    const block = schema.allOf.find((a) => a.if !== undefined);
+    if (block === undefined || block.if?.properties === undefined)
+        return undefined;
+    // The discriminant: the single property the `if` tests, and its `const` value.
+    const ifEntries = Object.entries(block.if.properties);
+    if (ifEntries.length !== 1)
+        return undefined;
+    const [discKey, discCond] = ifEntries[0];
+    const thenValue = discCond.const;
+    if (thenValue === undefined)
+        return undefined;
+    // All the discriminant's allowed values, from its own oneOf/enum consts.
+    const discSchema = props[discKey];
+    const values = discriminantValues(discSchema);
+    if (values.length === 0)
+        return undefined;
+    const baseRequired = Array.isArray(schema.required) ? schema.required : [];
+    const branches = values.map((value) => {
+        const isThen = value === thenValue;
+        const extra = isThen ? block.then : block.else;
+        const branchProps = {
+            ...props,
+            [discKey]: { const: value },
+        };
+        if (extra?.properties !== undefined) {
+            Object.assign(branchProps, extra.properties);
+        }
+        const required = new Set(baseRequired);
+        if (Array.isArray(extra?.required)) {
+            for (const r of extra.required)
+                required.add(r);
+        }
+        return printSchema({ type: "object", properties: branchProps, required: [...required] }, topLevel, encRef);
+    });
+    return uniqueUnion(branches);
+}
+function discriminantValues(schema) {
+    if (schema === undefined)
+        return [];
+    if (schema.const !== undefined)
+        return [schema.const];
+    if (Array.isArray(schema.enum))
+        return schema.enum;
+    const variants = schema.oneOf ?? schema.anyOf;
+    if (Array.isArray(variants)) {
+        const consts = variants.map((v) => v.const).filter((v) => v !== undefined);
+        if (consts.length > 0)
+            return consts;
+    }
+    return [];
+}
+function printArray(schema, encRef) {
+    if (schema.items === undefined)
+        return "unknown[]";
+    if (Array.isArray(schema.items)) {
+        return `[${schema.items.map((s) => printSchema(s, false, encRef)).join(", ")}]`;
+    }
+    return `Array<${printSchema(schema.items, false, encRef)}>`;
+}
+function printObject(schema, topLevel, encRef) {
+    // An encryption-typed field becomes `EncryptionRef` (which accepts `secret()`)
+    // — but only in CDK config mode; workflow input types print it structurally.
+    if (encRef && isEncryptionSchema(schema))
+        return "EncryptionRef";
+    const props = schema.properties;
+    if (props === undefined) {
+        if (typeof schema.additionalProperties === "object" &&
+            schema.additionalProperties !== null) {
+            return `Record<string, ${printSchema(schema.additionalProperties, false, encRef)}>`;
+        }
+        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, encRef);
+        // 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/src/cli/io.d.ts

@@ -0,0 +1,38 @@
+export declare const ExitCodes: {
+    readonly Success: 0;
+    readonly GenericError: 1;
+    readonly InvalidUsage: 2;
+    readonly NotAuthenticated: 3;
+    readonly PermissionDenied: 4;
+    readonly NotFound: 5;
+};
+export type ExitCode = (typeof ExitCodes)[keyof typeof ExitCodes];
+export declare const colors: {
+    red: (s: string) => string;
+    green: (s: string) => string;
+    yellow: (s: string) => string;
+    cyan: (s: string) => string;
+    dim: (s: string) => string;
+    bold: (s: string) => string;
+};
+export declare function outputJson(value: unknown): void;
+export declare function info(message: string): void;
+export declare function success(message: string): void;
+export declare function confirm(question: string): Promise<boolean>;
+type FailWithOpts = {
+    code?: ExitCode;
+    extra?: Record<string, unknown>;
+};
+export declare function failWith(message: string, opts?: FailWithOpts): never;
+export type Spinner = {
+    update: (message: string) => void;
+    log: (line: string) => void;
+    stop: () => void;
+};
+export declare function startSpinner(message: string): Spinner;
+type HandleApiCallOpts = {
+    spinner?: string | false;
+};
+export declare function handleApiCall<T>(fn: () => Promise<T>, opts?: HandleApiCallOpts): Promise<T>;
+export {};
+//# sourceMappingURL=io.d.ts.map

package/build/src/cli/io.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"io.d.ts","sourceRoot":"","sources":["../../../src/cli/io.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,SAAS;;;;;;;CAOZ,CAAC;AAEX,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC;AAclE,eAAO,MAAM,MAAM;aACR,MAAM,KAAG,MAAM;eACb,MAAM,KAAG,MAAM;gBACd,MAAM,KAAG,MAAM;cACjB,MAAM,KAAG,MAAM;aAChB,MAAM,KAAG,MAAM;cACd,MAAM,KAAG,MAAM;CAC1B,CAAC;AAEF,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAM/C;AAED,wBAAgB,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAE1C;AAED,wBAAgB,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAE7C;AAID,wBAAsB,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAUhE;AAED,KAAK,YAAY,GAAG;IAClB,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC,CAAC;AAEF,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,YAAY,GAAG,KAAK,CAyBpE;AAKD,MAAM,MAAM,OAAO,GAAG;IAEpB,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAGlC,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5B,IAAI,EAAE,MAAM,IAAI,CAAC;CAClB,CAAC;AAEF,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CA6CrD;AAED,KAAK,iBAAiB,GAAG;IACvB,OAAO,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;CAC1B,CAAC;AAOF,wBAAsB,aAAa,CAAC,CAAC,EACnC,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,IAAI,CAAC,EAAE,iBAAiB,GACvB,OAAO,CAAC,CAAC,CAAC,CAiDZ"}

package/build/src/cli/io.js

@@ -0,0 +1,226 @@
+// Terminal I/O helpers (colors, info/success, confirm, failWith, a spinner, and
+// API-error formatting) — a self-contained copy of the CLI's presentation helpers
+// so the command layer ships with @cargo-ai/cdk and needn't reach into the CLI.
+import { determineIfIsFetcherError } from "@cargo-ai/api";
+export const ExitCodes = {
+    Success: 0,
+    GenericError: 1,
+    InvalidUsage: 2,
+    NotAuthenticated: 3,
+    PermissionDenied: 4,
+    NotFound: 5,
+};
+const useColor = process.stderr.isTTY === true &&
+    process.env["NO_COLOR"] === undefined &&
+    process.env["CI"] !== "true";
+const colorize = (text, code) => {
+    if (useColor !== true) {
+        return text;
+    }
+    return `\x1B[${code}m${text}\x1B[0m`;
+};
+export const colors = {
+    red: (s) => colorize(s, "31"),
+    green: (s) => colorize(s, "32"),
+    yellow: (s) => colorize(s, "33"),
+    cyan: (s) => colorize(s, "36"),
+    dim: (s) => colorize(s, "2"),
+    bold: (s) => colorize(s, "1"),
+};
+export function outputJson(value) {
+    if (process.stdout.isTTY === true) {
+        process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+        return;
+    }
+    process.stdout.write(`${JSON.stringify(value)}\n`);
+}
+export function info(message) {
+    process.stderr.write(`${message}\n`);
+}
+export function success(message) {
+    process.stderr.write(`${colors.green("✓")} ${message}\n`);
+}
+// Ask a yes/no question on stderr (stdout stays reserved for JSON). Resolves
+// false on a non-TTY stdin (callers should require an explicit --yes there).
+export async function confirm(question) {
+    if (process.stdin.isTTY !== true)
+        return false;
+    const { createInterface } = await import("node:readline/promises");
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    try {
+        const answer = await rl.question(`${question} [y/N] `);
+        return /^y(es)?$/i.test(answer.trim());
+    }
+    finally {
+        rl.close();
+    }
+}
+export function failWith(message, opts) {
+    const code = opts !== undefined && opts.code !== undefined
+        ? opts.code
+        : ExitCodes.GenericError;
+    const extra = opts !== undefined ? opts.extra : undefined;
+    if (process.stderr.isTTY === true) {
+        process.stderr.write(`${colors.red("✗")} ${message}\n`);
+        if (extra !== undefined) {
+            for (const [key, value] of Object.entries(extra)) {
+                const valueStr = typeof value === "string" ? value : JSON.stringify(value);
+                process.stderr.write(`  ${colors.dim(`${key}:`)} ${valueStr}\n`);
+            }
+        }
+    }
+    else {
+        const payload = { error: message };
+        if (extra !== undefined) {
+            Object.assign(payload, extra);
+        }
+        process.stderr.write(`${JSON.stringify(payload)}\n`);
+    }
+    process.exit(code);
+}
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const SPINNER_INTERVAL_MS = 80;
+export function startSpinner(message) {
+    if (process.stderr.isTTY !== true) {
+        // Non-TTY (CI, piped): no animation — just emit each line so progress is
+        // still visible in logs.
+        process.stderr.write(`${message}\n`);
+        return {
+            update: (m) => process.stderr.write(`${m}\n`),
+            log: (line) => process.stderr.write(`${line}\n`),
+            stop: () => undefined,
+        };
+    }
+    process.stderr.write("\x1B[?25l");
+    let current = message;
+    let frame = 0;
+    const render = () => {
+        const ch = SPINNER_FRAMES[frame % SPINNER_FRAMES.length];
+        if (ch !== undefined) {
+            // \x1B[K clears any stale characters when the message shrinks.
+            process.stderr.write(`\r\x1B[K${colors.cyan(ch)} ${colors.dim(current)}`);
+        }
+        frame += 1;
+    };
+    const id = setInterval(render, SPINNER_INTERVAL_MS);
+    let stopped = false;
+    return {
+        update: (m) => {
+            current = m;
+        },
+        log: (line) => {
+            // Wipe the spinner line, drop a permanent line, let the next frame redraw
+            // the spinner beneath it.
+            process.stderr.write(`\r\x1B[K${line}\n`);
+        },
+        stop: () => {
+            if (stopped) {
+                return;
+            }
+            stopped = true;
+            clearInterval(id);
+            process.stderr.write("\r\x1B[K\x1B[?25h");
+        },
+    };
+}
+const SPINNER_DELAY_MS = 200;
+const DEFAULT_SPINNER_MESSAGE = "Loading...";
+// Run an API call, surfacing a delayed spinner and turning FetcherErrors into a
+// clean `failWith` with the right exit code. Used by `cdk types`.
+export async function handleApiCall(fn, opts) {
+    const spinnerMessage = opts !== undefined && opts.spinner === false
+        ? undefined
+        : opts !== undefined && typeof opts.spinner === "string"
+            ? opts.spinner
+            : DEFAULT_SPINNER_MESSAGE;
+    let spinner;
+    let startTimer;
+    if (spinnerMessage !== undefined) {
+        startTimer = setTimeout(() => {
+            spinner = startSpinner(spinnerMessage);
+        }, SPINNER_DELAY_MS);
+    }
+    const stopAll = () => {
+        if (startTimer !== undefined) {
+            clearTimeout(startTimer);
+        }
+        if (spinner !== undefined) {
+            spinner.stop();
+        }
+    };
+    try {
+        const result = await fn();
+        stopAll();
+        return result;
+    }
+    catch (error) {
+        stopAll();
+        if (determineIfIsFetcherError(error)) {
+            const parsedError = error;
+            const status = parsedError.status;
+            const body = parsedError.body !== undefined ? parsedError.body : String(error);
+            const { message, code } = describeApiError(status, body);
+            failWith(message, {
+                code,
+                extra: { status: status !== undefined ? status : "unknown", body },
+            });
+        }
+        throw error;
+    }
+}
+function describeApiError(status, body) {
+    const detail = extractApiErrorDetail(body);
+    const detailSuffix = detail !== undefined ? `: ${detail}` : "";
+    if (status === 401) {
+        return {
+            message: `Not authenticated${detailSuffix}. Run \`cargo-ai login\` to refresh credentials.`,
+            code: ExitCodes.NotAuthenticated,
+        };
+    }
+    if (status === 403) {
+        return {
+            message: `Permission denied${detailSuffix}. Check your workspace permissions or selected workspace UUID.`,
+            code: ExitCodes.PermissionDenied,
+        };
+    }
+    if (status === 404) {
+        return {
+            message: `Not found${detailSuffix}. Verify the UUID(s) you passed.`,
+            code: ExitCodes.NotFound,
+        };
+    }
+    if (status === 429) {
+        return {
+            message: `Rate limited${detailSuffix}. Retry in a moment.`,
+            code: ExitCodes.GenericError,
+        };
+    }
+    if (status !== undefined && status >= 500) {
+        return {
+            message: `Server error (${String(status)})${detailSuffix}. Retry shortly or check status.getcargo.io.`,
+            code: ExitCodes.GenericError,
+        };
+    }
+    return {
+        message: `API error (${status !== undefined ? String(status) : "unknown"})${detailSuffix}`,
+        code: ExitCodes.GenericError,
+    };
+}
+function extractApiErrorDetail(body) {
+    if (typeof body === "string" && body.length > 0) {
+        return body;
+    }
+    if (body !== null && typeof body === "object") {
+        const record = body;
+        if (typeof record["message"] === "string") {
+            return record["message"];
+        }
+        if (typeof record["reason"] === "string") {
+            return record["reason"];
+        }
+        if (typeof record["error"] === "string") {
+            return record["error"];
+        }
+    }
+    return undefined;
+}

package/build/src/cli/templates.d.ts

@@ -0,0 +1,6 @@
+export declare const listTemplates: (root: string) => Promise<string[]>;
+export declare const copyDirectory: (src: string, dest: string, rename: {
+    from: string;
+    to: string;
+}[]) => Promise<void>;
+//# sourceMappingURL=templates.d.ts.map

package/build/src/cli/templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"templates.d.ts","sourceRoot":"","sources":["../../../src/cli/templates.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,aAAa,SAAgB,MAAM,KAAG,QAAQ,MAAM,EAAE,CAUlE,CAAC;AAEF,eAAO,MAAM,aAAa,QACnB,MAAM,QACL,MAAM,UACJ;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,EAAE,KACrC,QAAQ,IAAI,CAmBd,CAAC"}

package/build/src/cli/templates.js

@@ -0,0 +1,34 @@
+// Template scaffolding for `cdk init` — list the template directories under
+// `@cargo-ai/cdk/templates` and copy one into a target directory, substituting
+// `__APP_NAME__`. (A self-contained copy of the CLI's templateUtils so the
+// command layer ships with the package.)
+import { promises as fs } from "node:fs";
+import path from "node:path";
+export const listTemplates = async (root) => {
+    try {
+        const entries = await fs.readdir(root, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isDirectory() === true)
+            .map((entry) => entry.name)
+            .filter((name) => name.startsWith("_") === false);
+    }
+    catch {
+        return [];
+    }
+};
+export const copyDirectory = async (src, dest, rename) => {
+    const entries = await fs.readdir(src, { withFileTypes: true });
+    await fs.mkdir(dest, { recursive: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory() === true) {
+            await copyDirectory(srcPath, destPath, rename);
+        }
+        else if (entry.isFile() === true) {
+            const raw = await fs.readFile(srcPath, "utf-8");
+            const replaced = rename.reduce((current, { from, to }) => current.split(from).join(to), raw);
+            await fs.writeFile(destPath, replaced, "utf-8");
+        }
+    }
+};

package/build/src/cli/typesCommand.d.ts

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

package/build/src/cli/typesCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typesCommand.d.ts","sourceRoot":"","sources":["../../../src/cli/typesCommand.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA2FzC,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,GAAG,IAAI,CA8D7E"}