terminal-pilot 0.0.30 → 0.0.31

package/dist/commands/create-session.js

@@ -76,6 +76,9 @@ function isOptionalSchema(schema) {
 function getRequiredKeys(schema) {
   return Object.keys(schema.shape).filter((key) => !isOptionalSchema(schema.shape[key])).sort();
 }
+function getRequiredKeyFingerprint(schema) {
+  return getRequiredKeys(schema).join("+");
+}
 function assertUniqueRequiredKeyFingerprints(branches) {
   const fingerprints = /* @__PURE__ */ new Map();
   branches.forEach((branch, index) => {
@@ -113,6 +116,451 @@ function Union(branches) {
   };
 }
 
+// ../toolcraft-schema/src/validate.ts
+var missingValue = /* @__PURE__ */ Symbol("missingValue");
+function validate(schema, value) {
+  const state = { issues: [] };
+  const result = walkSchema(schema, value, [], state);
+  if (state.issues.length > 0) {
+    return { ok: false, issues: state.issues };
+  }
+  return { ok: true, value: result.present ? result.value : void 0 };
+}
+function walkSchema(schema, value, path2, state) {
+  if (schema.kind === "optional") {
+    return walkOptional(schema, value, path2, state);
+  }
+  if (value === missingValue) {
+    addIssue(
+      state,
+      path2,
+      expectedFor(schema),
+      "missing",
+      `Expected ${expectedFor(schema)} at ${formatPath(path2)}`
+    );
+    return { present: false };
+  }
+  if (value === null && schema.nullable === true) {
+    return { present: true, value };
+  }
+  switch (schema.kind) {
+    case "string":
+      return walkString(schema, value, path2, state);
+    case "number":
+      return walkNumber(schema, value, path2, state);
+    case "boolean":
+      return walkBoolean(value, path2, state);
+    case "enum":
+      return walkEnum(schema, value, path2, state);
+    case "array":
+      return walkArray(schema, value, path2, state);
+    case "object":
+      return walkObject(schema, value, path2, state);
+    case "oneOf":
+      return walkOneOf(schema, value, path2, state);
+    case "union":
+      return walkUnion(schema, value, path2, state);
+    case "record":
+      return walkRecord(schema, value, path2, state);
+    case "json":
+      return walkJson(value, path2, state);
+  }
+}
+function walkOptional(schema, value, path2, state) {
+  if (value === missingValue || value === void 0) {
+    const defaultValue = getDefault(schema.inner);
+    if (defaultValue.present) {
+      return walkSchema(schema.inner, cloneDefault(defaultValue.value), path2, state);
+    }
+    return { present: false };
+  }
+  return walkSchema(schema.inner, value, path2, state);
+}
+function walkString(schema, value, path2, state) {
+  if (typeof value !== "string") {
+    addExpectedIssue(state, path2, "string", value);
+    return { present: true, value };
+  }
+  if (schema.minLength !== void 0 && value.length < schema.minLength) {
+    const expected = `string with length at least ${schema.minLength}`;
+    addIssue(
+      state,
+      path2,
+      expected,
+      `string with length ${value.length}`,
+      `Expected ${expected} at ${formatPath(path2)}`
+    );
+  }
+  if (schema.maxLength !== void 0 && value.length > schema.maxLength) {
+    const expected = `string with length at most ${schema.maxLength}`;
+    addIssue(
+      state,
+      path2,
+      expected,
+      `string with length ${value.length}`,
+      `Expected ${expected} at ${formatPath(path2)}`
+    );
+  }
+  if (schema.pattern !== void 0) {
+    const pattern = compilePattern(schema.pattern);
+    if (pattern === void 0 || !pattern.test(value)) {
+      const expected = `string matching pattern ${schema.pattern}`;
+      addIssue(state, path2, expected, value, `Expected ${expected} at ${formatPath(path2)}`);
+    }
+  }
+  return { present: true, value };
+}
+function walkNumber(schema, value, path2, state) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    addExpectedIssue(state, path2, schema.jsonType === "integer" ? "integer" : "number", value);
+    return { present: true, value };
+  }
+  if (schema.jsonType === "integer" && !Number.isInteger(value)) {
+    addExpectedIssue(state, path2, "integer", value);
+  }
+  if (schema.minimum !== void 0 && value < schema.minimum) {
+    const expected = `number greater than or equal to ${schema.minimum}`;
+    addIssue(state, path2, expected, String(value), `Expected ${expected} at ${formatPath(path2)}`);
+  }
+  if (schema.maximum !== void 0 && value > schema.maximum) {
+    const expected = `number less than or equal to ${schema.maximum}`;
+    addIssue(state, path2, expected, String(value), `Expected ${expected} at ${formatPath(path2)}`);
+  }
+  return { present: true, value };
+}
+function walkBoolean(value, path2, state) {
+  if (typeof value !== "boolean") {
+    addExpectedIssue(state, path2, "boolean", value);
+  }
+  return { present: true, value };
+}
+function walkEnum(schema, value, path2, state) {
+  if (!schema.values.includes(value)) {
+    const expected = `one of ${schema.values.join(", ")}`;
+    addIssue(
+      state,
+      path2,
+      expected,
+      receivedValue(value),
+      `Expected ${expected} at ${formatPath(path2)}`
+    );
+  }
+  return { present: true, value };
+}
+function walkArray(schema, value, path2, state) {
+  if (!Array.isArray(value)) {
+    addExpectedIssue(state, path2, "array", value);
+    return { present: true, value };
+  }
+  if (schema.minItems !== void 0 && value.length < schema.minItems) {
+    const expected = `array with at least ${schema.minItems} items`;
+    addIssue(
+      state,
+      path2,
+      expected,
+      `array with ${value.length} items`,
+      `Expected ${expected} at ${formatPath(path2)}`
+    );
+  }
+  if (schema.maxItems !== void 0 && value.length > schema.maxItems) {
+    const expected = `array with at most ${schema.maxItems} items`;
+    addIssue(
+      state,
+      path2,
+      expected,
+      `array with ${value.length} items`,
+      `Expected ${expected} at ${formatPath(path2)}`
+    );
+  }
+  const nextValue = value.map((item, index) => {
+    const result = walkSchema(schema.item, item, [...path2, String(index)], state);
+    return result.present ? result.value : item;
+  });
+  return { present: true, value: nextValue };
+}
+function walkObject(schema, value, path2, state, injectedProperties = {}) {
+  if (!isPlainRecord(value)) {
+    addExpectedIssue(state, path2, "object", value);
+    return { present: true, value };
+  }
+  const nextValue = {};
+  const allowedKeys = /* @__PURE__ */ new Set([...Object.keys(schema.shape), ...Object.keys(injectedProperties)]);
+  for (const [key, propertySchema] of Object.entries(schema.shape)) {
+    const propertyValue = Object.hasOwn(value, key) ? value[key] : missingValue;
+    const result = walkSchema(propertySchema, propertyValue, [...path2, key], state);
+    if (result.present) {
+      setOwnValue(nextValue, key, result.value);
+    }
+  }
+  for (const [key, injectedValue] of Object.entries(injectedProperties)) {
+    if (Object.hasOwn(value, key)) {
+      setOwnValue(nextValue, key, value[key]);
+    } else {
+      setOwnValue(nextValue, key, injectedValue);
+    }
+  }
+  for (const [key, propertyValue] of Object.entries(value)) {
+    if (allowedKeys.has(key)) {
+      continue;
+    }
+    if (schema.additionalProperties === true) {
+      setOwnValue(nextValue, key, propertyValue);
+    } else {
+      addUnexpectedPropertyIssue(state, [...path2, key]);
+    }
+  }
+  return { present: true, value: nextValue };
+}
+function walkOneOf(schema, value, path2, state) {
+  if (!isPlainRecord(value)) {
+    addExpectedIssue(state, path2, "object", value);
+    return { present: true, value };
+  }
+  const discriminatorValue = value[schema.discriminator];
+  const discriminatorPath = [...path2, schema.discriminator];
+  const branchValues = Object.keys(schema.branches);
+  const expected = `one of ${branchValues.join(", ")}`;
+  if (!Object.hasOwn(value, schema.discriminator)) {
+    addIssueWithMessage(
+      state,
+      discriminatorPath,
+      expected,
+      "missing",
+      `Missing discriminator "${schema.discriminator}" at ${formatPath(path2)}. Expected one of: ${branchValues.join(", ")}.`
+    );
+    return { present: true, value };
+  }
+  if (typeof discriminatorValue !== "string" || !Object.hasOwn(schema.branches, discriminatorValue)) {
+    addIssueWithMessage(
+      state,
+      discriminatorPath,
+      expected,
+      receivedValue(discriminatorValue),
+      `Expected ${expected} at ${formatPath(discriminatorPath)}, got ${formatReceivedDiscriminator(discriminatorValue)}`
+    );
+    return { present: true, value };
+  }
+  return walkObject(schema.branches[discriminatorValue], value, path2, state, {
+    [schema.discriminator]: discriminatorValue
+  });
+}
+function walkUnion(schema, value, path2, state) {
+  if (isPlainRecord(value)) {
+    const candidateBranches = schema.branches.filter((branch) => hasRequiredKeys(branch, value));
+    if (candidateBranches.length === 1) {
+      return walkObject(candidateBranches[0], value, path2, state);
+    }
+  }
+  const matches = [];
+  for (const branch of schema.branches) {
+    const branchState = { issues: [] };
+    const result = walkObject(branch, value, path2, branchState);
+    if (branchState.issues.length === 0 && result.present) {
+      matches.push({ fingerprint: getRequiredKeyFingerprint(branch), value: result.value });
+    }
+  }
+  if (matches.length === 1) {
+    return { present: true, value: matches[0].value };
+  }
+  if (matches.length === 0) {
+    const branchDescriptions = schema.branches.map((branch) => getRequiredKeyFingerprint(branch));
+    addIssueWithMessage(
+      state,
+      path2,
+      "exactly one union branch",
+      "0 matching branches",
+      `No union branch matched at ${formatPath(path2)}. Tried ${schema.branches.length} branches. Expected one of: ${branchDescriptions.join(" | ")}.`
+    );
+    return { present: true, value };
+  }
+  addIssueWithMessage(
+    state,
+    path2,
+    "exactly one union branch",
+    `${matches.length} matching branches`,
+    `Expected exactly one union branch at ${formatPath(path2)}, but matched more than one branch: ${matches.map((match) => match.fingerprint).join(" | ")}`
+  );
+  return { present: true, value };
+}
+function hasRequiredKeys(schema, value) {
+  for (const [key, propertySchema] of Object.entries(schema.shape)) {
+    if (propertySchema.kind !== "optional" && !Object.hasOwn(value, key)) {
+      return false;
+    }
+  }
+  return true;
+}
+function walkRecord(schema, value, path2, state) {
+  if (!isPlainRecord(value)) {
+    addExpectedIssue(state, path2, "object", value);
+    return { present: true, value };
+  }
+  const nextValue = {};
+  for (const [key, propertyValue] of Object.entries(value)) {
+    const result = walkSchema(schema.value, propertyValue, [...path2, key], state);
+    if (result.present) {
+      setOwnValue(nextValue, key, result.value);
+    }
+  }
+  return { present: true, value: nextValue };
+}
+function walkJson(value, path2, state) {
+  if (isJsonValue(value)) {
+    return { present: true, value };
+  }
+  addExpectedIssue(state, path2, "JSON value", value);
+  return { present: true, value };
+}
+function getDefault(schema) {
+  if (schema.default !== void 0) {
+    return { present: true, value: schema.default };
+  }
+  if (schema.kind === "optional") {
+    return getDefault(schema.inner);
+  }
+  return { present: false };
+}
+function isPlainRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function isJsonValue(value, ancestors = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return typeof value !== "number" || Number.isFinite(value);
+  }
+  if (Array.isArray(value)) {
+    if (ancestors.has(value)) {
+      return false;
+    }
+    ancestors.add(value);
+    const result = value.every((item) => isJsonValue(item, ancestors));
+    ancestors.delete(value);
+    return result;
+  }
+  if (isPlainRecord(value)) {
+    if (ancestors.has(value)) {
+      return false;
+    }
+    ancestors.add(value);
+    const result = Object.values(value).every((item) => isJsonValue(item, ancestors));
+    ancestors.delete(value);
+    return result;
+  }
+  return false;
+}
+function cloneDefault(value) {
+  return structuredClone(value);
+}
+function setOwnValue(target, key, value) {
+  Object.defineProperty(target, key, {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    value
+  });
+}
+function expectedFor(schema) {
+  switch (schema.kind) {
+    case "string":
+      return "string";
+    case "number":
+      return schema.jsonType === "integer" ? "integer" : "number";
+    case "boolean":
+      return "boolean";
+    case "enum":
+      return `one of ${schema.values.join(", ")}`;
+    case "array":
+      return "array";
+    case "object":
+    case "oneOf":
+    case "record":
+      return "object";
+    case "union":
+      return "exactly one union branch";
+    case "json":
+      return "JSON value";
+    case "optional":
+      return expectedFor(schema.inner);
+  }
+}
+function addExpectedIssue(state, path2, expected, value) {
+  addIssue(
+    state,
+    path2,
+    expected,
+    receivedType(value),
+    `Expected ${expected} at ${formatPath(path2)}`
+  );
+}
+function addUnexpectedPropertyIssue(state, path2) {
+  addIssue(
+    state,
+    path2,
+    "no additional properties",
+    "unknown property",
+    `Unexpected property ${formatPath(path2)}`
+  );
+}
+function addIssue(state, path2, expected, received, _message) {
+  state.issues.push({
+    path: path2,
+    expected,
+    received,
+    message: formatIssueMessage(expected, path2, received)
+  });
+}
+function addIssueWithMessage(state, path2, expected, received, message) {
+  state.issues.push({
+    path: path2,
+    expected,
+    received,
+    message
+  });
+}
+function formatIssueMessage(expected, path2, received) {
+  return `Expected ${expected} at ${formatPath(path2)}, got ${received}`;
+}
+function formatPath(path2) {
+  return path2.length === 0 ? "value" : path2.join(".");
+}
+function compilePattern(pattern) {
+  try {
+    return new RegExp(pattern);
+  } catch {
+    return void 0;
+  }
+}
+function receivedType(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (Array.isArray(value)) {
+    return "array";
+  }
+  if (typeof value === "number" && Number.isInteger(value)) {
+    return "integer";
+  }
+  return typeof value;
+}
+function receivedValue(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value === void 0) {
+    return "undefined";
+  }
+  return String(value);
+}
+function formatReceivedDiscriminator(value) {
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  return receivedValue(value);
+}
+
 // ../toolcraft-schema/src/index.ts
 function assertValidEnumValues(values) {
   if (values.length === 0) {
@@ -136,6 +584,22 @@ function assertFiniteNumber(value, name) {
     throw new Error(`${name} must be finite`);
   }
 }
+function assertMinMaxOrder(minimum, maximum, minimumName, maximumName) {
+  if (minimum !== void 0 && maximum !== void 0 && minimum > maximum) {
+    throw new Error(`${minimumName} must be less than or equal to ${maximumName}`);
+  }
+}
+function assertValidDefault(schema) {
+  if (schema.default === void 0) {
+    return;
+  }
+  const result = validate(schema, schema.default);
+  if (!result.ok) {
+    throw new Error(
+      `default must satisfy schema: ${result.issues[0]?.message ?? "invalid default"}`
+    );
+  }
+}
 function assertPattern(pattern) {
   if (pattern === void 0) {
     return;
@@ -150,56 +614,71 @@ var S = {
   String(options = {}) {
     assertNonNegativeInteger(options.minLength, "minLength");
     assertNonNegativeInteger(options.maxLength, "maxLength");
+    assertMinMaxOrder(options.minLength, options.maxLength, "minLength", "maxLength");
     assertPattern(options.pattern);
-    return {
+    const schema = {
       kind: "string",
       ...options
     };
+    assertValidDefault(schema);
+    return schema;
   },
   Number(options = {}) {
     assertFiniteNumber(options.minimum, "minimum");
     assertFiniteNumber(options.maximum, "maximum");
+    assertMinMaxOrder(options.minimum, options.maximum, "minimum", "maximum");
     assertFiniteNumber(options.default, "default");
     if (options.jsonType === "integer" && options.default !== void 0 && !Number.isInteger(options.default)) {
       throw new Error("default must be an integer");
     }
-    return {
+    const schema = {
       kind: "number",
       ...options
     };
+    assertValidDefault(schema);
+    return schema;
   },
   Boolean(options = {}) {
-    return {
+    const schema = {
       kind: "boolean",
       ...options
     };
+    assertValidDefault(schema);
+    return schema;
   },
   Enum(values, options = {}) {
     assertValidEnumValues(values);
     if (options.jsonType === "integer" && values.some((value) => typeof value !== "number" || !Number.isInteger(value))) {
       throw new Error("Integer enum values must be integers");
     }
-    return {
+    const schema = {
       kind: "enum",
       values,
       ...options
     };
+    assertValidDefault(schema);
+    return schema;
   },
   Array(item, options = {}) {
     assertNonNegativeInteger(options.minItems, "minItems");
     assertNonNegativeInteger(options.maxItems, "maxItems");
-    return {
+    assertMinMaxOrder(options.minItems, options.maxItems, "minItems", "maxItems");
+    const schema = {
       kind: "array",
       item,
       ...options
     };
+    assertValidDefault(schema);
+    return schema;
   },
   Object(shape, options = {}) {
-    return {
+    const schema = {
       kind: "object",
       shape,
       ...options
     };
+    assertValidDefault(schema);
+    return schema;
   },
   Optional(inner) {
     return {