@cargo-ai/cdk 1.0.2 → 1.0.4

package/build/src/cli/commands/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/commands/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/commands/templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"templates.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/templates.ts"],"names":[],"mappings":"AAOA,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/commands/templates.js

@@ -0,0 +1,33 @@
+// Template scaffolding for `cargo-cdk init` — list the templates under
+// `@cargo-ai/cdk/templates` and copy one into a target dir, substituting
+// `__APP_NAME__`.
+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/commands/types.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=types.d.ts.map

package/build/src/cli/commands/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/types.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"}