@cargo-ai/cli 1.0.120 → 1.0.122

package/build/utils/sampleFromSchema.js

@@ -0,0 +1,474 @@
+// A plausible value for a JSON schema, built without running anything.
+//
+// `action execute --dry-run` prints this in place of a provider's answer, so
+// someone with no account can see the exact shape an action returns before
+// they pay for one. Everything here is deterministic: the same schema always
+// yields the same sample, so a dry run can be diffed, cached and tested.
+//
+// The values lean on the property name (an `email` reads as an address, a
+// `linkedin_url` as a profile URL) because most connector output schemas say
+// little beyond `type: "string"`. When nothing matches, the value is a neutral
+// placeholder rather than a guess that could pass for real data.
+/** Deeper than any real connector output; keeps a recursive `$ref` finite. */
+const MAX_DEPTH = 8;
+const SAMPLE_UUID = "123e4567-e89b-42d3-a456-426614174000";
+const SAMPLE_DATE_TIME = "2026-01-15T09:30:00.000Z";
+const SAMPLE_DATE = "2026-01-15";
+const COMPANY_WORDS = ["company", "organization", "organisation", "employer"];
+export function sampleFromSchema(schema, options = {}) {
+    const root = isSchemaObject(schema) === true ? schema : {};
+    return sampleValue(root, {
+        root,
+        subject: options.subject === undefined ? "person" : options.subject,
+        path: [],
+        depth: 0,
+    });
+}
+/**
+ * Whether a schema says enough about an output to sample it. `{}`, a bare
+ * `{ type: "object" }` and a free-form record all describe "some object", and
+ * a sample of one would be `{}` — which reads as "this action returns nothing"
+ * rather than "the shape is decided at run time".
+ */
+export function describesOutput(schema) {
+    return describes(schema, schema, 0);
+}
+function describes(schema, root, depth) {
+    if (isSchemaObject(schema) === false || depth > MAX_DEPTH) {
+        return false;
+    }
+    const ref = schema["$ref"];
+    if (typeof ref === "string") {
+        return describes(resolveRef(ref, root), root, depth + 1);
+    }
+    if (schema["const"] !== undefined || Array.isArray(schema["enum"])) {
+        return true;
+    }
+    for (const key of ["anyOf", "oneOf", "allOf"]) {
+        const branches = schema[key];
+        if (Array.isArray(branches) === true &&
+            branches.some((branch) => describes(branch, root, depth + 1)) === true) {
+            return true;
+        }
+    }
+    const properties = schema["properties"];
+    if (isSchemaObject(properties) === true) {
+        return Object.keys(properties).length > 0;
+    }
+    const type = pickType(schema["type"]);
+    // An object with no declared properties is a free-form record; anything
+    // else typed (an array, a scalar) is a shape a sample can show.
+    return type !== undefined && type !== "object";
+}
+function sampleValue(schema, ctx) {
+    const ref = schema["$ref"];
+    if (typeof ref === "string") {
+        const target = ctx.depth < MAX_DEPTH ? resolveRef(ref, ctx.root) : {};
+        return sampleValue(isSchemaObject(target) === true ? target : {}, {
+            ...ctx,
+            depth: ctx.depth + 1,
+        });
+    }
+    const examples = schema["examples"];
+    if (Array.isArray(examples) === true && examples.length > 0) {
+        return examples[0];
+    }
+    if (schema["default"] !== undefined) {
+        return schema["default"];
+    }
+    if (schema["const"] !== undefined) {
+        return schema["const"];
+    }
+    const enumValues = schema["enum"];
+    if (Array.isArray(enumValues) === true && enumValues.length > 0) {
+        const firstNonNull = enumValues.find((value) => value !== null);
+        return firstNonNull !== undefined ? firstNonNull : enumValues[0];
+    }
+    const allOf = schema["allOf"];
+    if (Array.isArray(allOf) === true && allOf.length > 0) {
+        return sampleAllOf(schema, allOf, ctx);
+    }
+    for (const key of ["anyOf", "oneOf"]) {
+        const branches = schema[key];
+        if (Array.isArray(branches) === true && branches.length > 0) {
+            const branch = pickBranch(branches);
+            return sampleValue(branch, { ...ctx, depth: ctx.depth + 1 });
+        }
+    }
+    const type = inferType(schema);
+    if (type === "object") {
+        return sampleObject(schema, ctx);
+    }
+    if (type === "array") {
+        return sampleArray(schema, ctx);
+    }
+    if (type === "string") {
+        return sampleString(schema, ctx);
+    }
+    if (type === "integer" || type === "number") {
+        return sampleNumber(schema, ctx, type === "integer");
+    }
+    if (type === "boolean") {
+        return true;
+    }
+    if (type === "null") {
+        return null;
+    }
+    // No type at all (`{}`, `items: {}`): let the name decide, as a string.
+    return sampleString(schema, ctx);
+}
+function sampleObject(schema, ctx) {
+    const out = {};
+    if (ctx.depth >= MAX_DEPTH) {
+        return out;
+    }
+    const properties = schema["properties"];
+    if (isSchemaObject(properties) === false) {
+        return out;
+    }
+    for (const [key, value] of Object.entries(properties)) {
+        out[key] = sampleValue(isSchemaObject(value) === true ? value : {}, {
+            ...ctx,
+            path: [...ctx.path, key],
+            depth: ctx.depth + 1,
+        });
+    }
+    // Declared properties cover every required one in practice; a required name
+    // with no declaration still has to be present for the sample to validate.
+    const required = schema["required"];
+    if (Array.isArray(required) === true) {
+        for (const key of required) {
+            if (typeof key === "string" && key in out === false) {
+                out[key] = sampleValue({}, {
+                    ...ctx,
+                    path: [...ctx.path, key],
+                    depth: ctx.depth + 1,
+                });
+            }
+        }
+    }
+    return out;
+}
+function sampleArray(schema, ctx) {
+    if (ctx.depth >= MAX_DEPTH) {
+        return [];
+    }
+    const prefixItems = schema["prefixItems"];
+    const items = schema["items"];
+    const tuple = Array.isArray(prefixItems) === true
+        ? prefixItems
+        : Array.isArray(items) === true
+            ? items
+            : undefined;
+    if (tuple !== undefined) {
+        return tuple.map((item) => sampleValue(isSchemaObject(item) === true ? item : {}, {
+            ...ctx,
+            depth: ctx.depth + 1,
+        }));
+    }
+    // One item: enough to show its shape, and the name of the array (`emails`,
+    // `technologies`) is what the item's value is guessed from.
+    return [
+        sampleValue(isSchemaObject(items) === true ? items : {}, {
+            ...ctx,
+            depth: ctx.depth + 1,
+        }),
+    ];
+}
+function sampleAllOf(schema, allOf, ctx) {
+    const samples = allOf.map((branch) => sampleValue(isSchemaObject(branch) === true ? branch : {}, {
+        ...ctx,
+        depth: ctx.depth + 1,
+    }));
+    const rest = { ...schema, allOf: undefined };
+    const objects = samples.filter((sample) => typeof sample === "object" &&
+        sample !== null &&
+        Array.isArray(sample) === false);
+    if (objects.length === samples.length) {
+        const own = isSchemaObject(rest["properties"]) === true
+            ? sampleObject(rest, ctx)
+            : {};
+        return Object.assign({}, ...objects, own);
+    }
+    return samples[0];
+}
+function sampleString(schema, ctx) {
+    const format = schema["format"];
+    if (typeof format === "string") {
+        const formatted = stringForFormat(format);
+        if (formatted !== undefined) {
+            return formatted;
+        }
+    }
+    const hinted = stringForName(ctx);
+    return hinted !== undefined ? hinted : "sample";
+}
+function stringForFormat(format) {
+    if (format === "email" || format === "idn-email") {
+        return "jane.doe@example.com";
+    }
+    if (format === "uri" || format === "url" || format === "iri") {
+        return "https://example.com";
+    }
+    if (format === "date-time") {
+        return SAMPLE_DATE_TIME;
+    }
+    if (format === "date") {
+        return SAMPLE_DATE;
+    }
+    if (format === "time") {
+        return "09:30:00Z";
+    }
+    if (format === "uuid") {
+        return SAMPLE_UUID;
+    }
+    if (format === "hostname" || format === "idn-hostname") {
+        return "example.com";
+    }
+    if (format === "ipv4") {
+        return "192.0.2.1";
+    }
+    if (format === "ipv6") {
+        return "2001:db8::1";
+    }
+    return undefined;
+}
+/** The nearest property name, with separators dropped: `linkedin_url` → `linkedinurl`. */
+function nameOf(ctx) {
+    const last = ctx.path[ctx.path.length - 1];
+    return last === undefined ? "" : last.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function aboutCompany(ctx) {
+    const parents = ctx.path.slice(0, -1).map((part) => part.toLowerCase());
+    if (parents.some((part) => COMPANY_WORDS.some((word) => part.includes(word))) === true) {
+        return true;
+    }
+    if (parents.some((part) => part.includes("person") ||
+        part.includes("contact") ||
+        part.includes("employee")) === true) {
+        return false;
+    }
+    return ctx.subject === "company";
+}
+// Ordered: the first match wins, so the specific names (`linkedin_url`,
+// `company_name`) come before the general ones (`url`, `name`).
+function stringForName(ctx) {
+    const name = nameOf(ctx);
+    if (name === "") {
+        return undefined;
+    }
+    const has = (...words) => words.some((word) => name.includes(word));
+    const raw = ctx.path[ctx.path.length - 1];
+    // `id`, `companyId`, `person_uuid`: an identifier, whatever it identifies.
+    if (raw !== undefined &&
+        /(^id$|^uuid$|Id$|ID$|_id$|Uuid$|_uuid$)/.test(raw) === true) {
+        return name.endsWith("uuid") === true ? SAMPLE_UUID : "sample-id-1";
+    }
+    // `createdAt`, `updated_at`.
+    if (raw !== undefined && /(At$|_at$)/.test(raw) === true) {
+        return SAMPLE_DATE_TIME;
+    }
+    // `extracted_on`, `publishedOn`.
+    if (raw !== undefined && /(On$|_on$)/.test(raw) === true) {
+        return SAMPLE_DATE;
+    }
+    // `company_type`, `email_status`: a label whose values only the provider
+    // knows. A placeholder says so; "Example Inc" would read as a real answer.
+    if (/(type|kind|category|status)$/.test(name) === true) {
+        return undefined;
+    }
+    if (has("email", "mail")) {
+        return "jane.doe@example.com";
+    }
+    if (has("linkedin")) {
+        return aboutCompany(ctx) === true || has("company")
+            ? "https://www.linkedin.com/company/example"
+            : "https://www.linkedin.com/in/jane-doe";
+    }
+    if (has("twitter")) {
+        return "https://twitter.com/example";
+    }
+    if (has("logo", "image", "avatar", "photo", "picture")) {
+        return "https://example.com/logo.png";
+    }
+    if (has("domain", "hostname")) {
+        return "example.com";
+    }
+    if (has("website", "url", "uri", "link", "href", "homepage")) {
+        return "https://example.com";
+    }
+    if (has("phone", "mobile")) {
+        return "+1 415 555 0100";
+    }
+    if (has("firstname", "givenname")) {
+        return "Jane";
+    }
+    if (has("lastname", "surname", "familyname")) {
+        return "Doe";
+    }
+    if (has("company", "organization", "organisation", "employer", "account")) {
+        return "Example Inc";
+    }
+    if (has("fullname", "name")) {
+        return aboutCompany(ctx) === true ? "Example Inc" : "Jane Doe";
+    }
+    if (has("jobtitle", "title", "position", "headline", "role")) {
+        return "Head of Growth";
+    }
+    if (has("seniority")) {
+        return "director";
+    }
+    if (has("department", "function")) {
+        return "Marketing";
+    }
+    if (has("countrycode")) {
+        return "US";
+    }
+    if (has("country")) {
+        return "United States";
+    }
+    if (has("city", "locality")) {
+        return "San Francisco";
+    }
+    if (has("state", "region", "province")) {
+        return "California";
+    }
+    if (has("zip", "postal")) {
+        return "94105";
+    }
+    if (has("address", "street")) {
+        return "1 Market St, San Francisco, CA 94105";
+    }
+    if (has("location")) {
+        return "San Francisco, California, United States";
+    }
+    if (has("industr")) {
+        return "Software";
+    }
+    if (has("currency")) {
+        return "USD";
+    }
+    if (has("timezone")) {
+        return "America/Los_Angeles";
+    }
+    if (has("language", "locale")) {
+        return "en";
+    }
+    if (has("revenue")) {
+        return "$10M-$50M";
+    }
+    if (has("employee", "headcount", "size")) {
+        return "51-200";
+    }
+    if (has("year", "founded")) {
+        return "2015";
+    }
+    if (has("description", "summary", "bio", "about")) {
+        return "Sample description.";
+    }
+    if (has("date", "time")) {
+        return SAMPLE_DATE_TIME;
+    }
+    return undefined;
+}
+function sampleNumber(schema, ctx, integer) {
+    const hinted = numberForName(ctx);
+    let value = hinted !== undefined ? hinted : 1;
+    const minimum = schema["minimum"];
+    const maximum = schema["maximum"];
+    if (typeof minimum === "number" && value < minimum) {
+        value = minimum;
+    }
+    if (typeof maximum === "number" && value > maximum) {
+        value = maximum;
+    }
+    return integer === true ? Math.round(value) : value;
+}
+function numberForName(ctx) {
+    const name = nameOf(ctx);
+    if (name === "") {
+        return undefined;
+    }
+    const has = (...words) => words.some((word) => name.includes(word));
+    if (has("year", "founded")) {
+        return 2015;
+    }
+    if (has("employee", "headcount", "staff")) {
+        return 120;
+    }
+    if (has("revenue", "funding", "amount", "valuation")) {
+        return 25000000;
+    }
+    if (has("score", "confidence", "probability")) {
+        return 0.9;
+    }
+    if (has("latitude")) {
+        return 37.7749;
+    }
+    if (has("longitude")) {
+        return -122.4194;
+    }
+    if (has("count", "total", "number", "size")) {
+        return 1;
+    }
+    return undefined;
+}
+function inferType(schema) {
+    const type = pickType(schema["type"]);
+    if (type !== undefined) {
+        return type;
+    }
+    if (isSchemaObject(schema["properties"]) === true) {
+        return "object";
+    }
+    if (schema["items"] !== undefined || schema["prefixItems"] !== undefined) {
+        return "array";
+    }
+    return undefined;
+}
+/** `["string", "null"]` samples as a string: null shows nothing about the shape. */
+function pickType(type) {
+    if (typeof type === "string") {
+        return type;
+    }
+    if (Array.isArray(type) === true) {
+        const nonNull = type.find((value) => typeof value === "string" && value !== "null");
+        if (nonNull !== undefined) {
+            return nonNull;
+        }
+        return type.length > 0 && typeof type[0] === "string" ? type[0] : undefined;
+    }
+    return undefined;
+}
+/** The first branch that is not just `{ type: "null" }`. */
+function pickBranch(branches) {
+    const objects = branches.filter((branch) => isSchemaObject(branch));
+    const nonNull = objects.find((branch) => branch["type"] !== "null");
+    if (nonNull !== undefined) {
+        return nonNull;
+    }
+    const first = objects[0];
+    return first !== undefined ? first : {};
+}
+/** Local refs only (`#/$defs/x`, `#/definitions/x`); anything else samples as `{}`. */
+function resolveRef(ref, root) {
+    if (ref.startsWith("#") === false) {
+        return {};
+    }
+    let current = root;
+    for (const segment of ref.slice(1).split("/")) {
+        if (segment === "") {
+            continue;
+        }
+        if (isSchemaObject(current) === false) {
+            return {};
+        }
+        current = current[segment.replace(/~1/g, "/").replace(/~0/g, "~")];
+    }
+    return current;
+}
+function isSchemaObject(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        Array.isArray(value) === false);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cargo-ai/cli",
-  "version": "1.0.120",
+  "version": "1.0.122",
   "mcpName": "io.github.getcargohq/cargo",
   "private": false,
   "license": "UNLICENSED",
@@ -74,16 +74,17 @@
   "dependencies": {
     "@ai-sdk/harness": "^1.0.144",
     "@ai-sdk/harness-claude-code": "^1.0.148",
-    "@cargo-ai/api": "^1.0.99",
+    "@cargo-ai/api": "^1.0.101",
     "@cargo-ai/app-sdk": "^1.0.11",
-    "@cargo-ai/cdk": "^1.0.116",
-    "@cargo-ai/types": "^1.0.99",
-    "@cargo-ai/utils": "^1.0.33",
+    "@cargo-ai/cdk": "^1.0.117",
+    "@cargo-ai/types": "^1.0.101",
+    "@cargo-ai/utils": "^1.0.35",
     "@cargo-ai/worker-sdk": "^1.0.21",
     "@modelcontextprotocol/sdk": "^1.31.0",
     "ai": "^7.0.133",
     "ai-sdk-sandbox-local": "^0.1.2",
     "commander": "^12.1.0",
+    "jsonschema": "^1.4.1",
     "tsx": "^4.19.2",
     "undici": "^7.29.1",
     "uuid": "^14.0.0"