@zhijiewang/openharness 2.17.0 → 2.18.0

package/dist/utils/json-schema.js

@@ -0,0 +1,110 @@
+/**
+ * Minimal JSON Schema validator — covers the common subset sufficient for
+ * constraining LLM output in headless mode. Supported keywords:
+ *
+ *   - `type`: "string" | "number" | "integer" | "boolean" | "object" | "array" | "null"
+ *             (or an array of those for union types)
+ *   - `properties`: object → sub-schema per field
+ *   - `required`: array of field names that must be present
+ *   - `items`: sub-schema for array elements
+ *   - `enum`: array of allowed literal values (compared with strict equality)
+ *
+ * Anything else is silently accepted. This is intentional — we don't want to
+ * ship a full JSON Schema engine. For cases that need more (e.g. `pattern`,
+ * `oneOf`, `$ref`), use an external validator.
+ */
+export function validateAgainstJsonSchema(value, schema) {
+    const errors = [];
+    validate(value, schema, "", errors);
+    return errors.length === 0 ? { ok: true } : { ok: false, errors };
+}
+function validate(value, schema, path, errors) {
+    if (schema.enum !== undefined && Array.isArray(schema.enum)) {
+        if (!schema.enum.some((allowed) => deepEqual(allowed, value))) {
+            errors.push(`${prefix(path)}value ${JSON.stringify(value)} is not one of the enum values`);
+            return;
+        }
+    }
+    if (schema.type !== undefined) {
+        const types = Array.isArray(schema.type) ? schema.type : [schema.type];
+        if (!types.some((t) => matchesType(value, t))) {
+            errors.push(`${prefix(path)}expected ${types.join(" or ")}, got ${describeActual(value)}`);
+            return;
+        }
+    }
+    if (matchesType(value, "object") && schema.properties) {
+        const properties = schema.properties;
+        const required = schema.required ?? [];
+        const obj = value;
+        for (const field of required) {
+            if (!(field in obj)) {
+                const fullPath = path ? `${path}.${field}` : field;
+                errors.push(`missing required property '${fullPath}'`);
+            }
+        }
+        for (const [field, subSchema] of Object.entries(properties)) {
+            if (field in obj) {
+                validate(obj[field], subSchema, path ? `${path}.${field}` : field, errors);
+            }
+        }
+    }
+    if (matchesType(value, "array") && schema.items) {
+        const items = schema.items;
+        const arr = value;
+        arr.forEach((item, i) => {
+            validate(item, items, `${path}[${i}]`, errors);
+        });
+    }
+}
+function matchesType(value, type) {
+    switch (type) {
+        case "string":
+            return typeof value === "string";
+        case "number":
+            return typeof value === "number" && Number.isFinite(value);
+        case "integer":
+            return typeof value === "number" && Number.isInteger(value);
+        case "boolean":
+            return typeof value === "boolean";
+        case "null":
+            return value === null;
+        case "array":
+            return Array.isArray(value);
+        case "object":
+            return typeof value === "object" && value !== null && !Array.isArray(value);
+        default:
+            return false;
+    }
+}
+function describeActual(value) {
+    if (value === null)
+        return "null";
+    if (Array.isArray(value))
+        return "array";
+    return typeof value;
+}
+function prefix(path) {
+    return path ? `${path}: ` : "";
+}
+function deepEqual(a, b) {
+    if (a === b)
+        return true;
+    if (typeof a !== typeof b)
+        return false;
+    if (a === null || b === null)
+        return a === b;
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length)
+            return false;
+        return a.every((x, i) => deepEqual(x, b[i]));
+    }
+    if (typeof a === "object" && typeof b === "object") {
+        const ka = Object.keys(a);
+        const kb = Object.keys(b);
+        if (ka.length !== kb.length)
+            return false;
+        return ka.every((k) => deepEqual(a[k], b[k]));
+    }
+    return false;
+}
+//# sourceMappingURL=json-schema.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhijiewang/openharness",
-  "version": "2.17.0",
+  "version": "2.18.0",
   "description": "Open-source terminal coding agent. Works with any LLM.",
   "type": "module",
   "bin": {