toolcraft 0.0.99 → 0.0.101

package/node_modules/toolcraft-schema/dist/oneof.js

@@ -0,0 +1,18 @@
+function assertValidBranches(branches, discriminator) {
+    if (Object.keys(branches).length === 0) {
+        throw new Error("OneOf schema requires at least one branch");
+    }
+    for (const [branchName, branch] of Object.entries(branches)) {
+        if (Object.prototype.hasOwnProperty.call(branch.shape, discriminator)) {
+            throw new Error(`OneOf branch "${branchName}" must not declare discriminator field "${discriminator}".`);
+        }
+    }
+}
+export function OneOf(config) {
+    assertValidBranches(config.branches, config.discriminator);
+    return {
+        kind: "oneOf",
+        discriminator: config.discriminator,
+        branches: config.branches,
+    };
+}

package/node_modules/toolcraft-schema/dist/record.compile-check.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/toolcraft-schema/dist/record.compile-check.js

@@ -0,0 +1,2 @@
+import { S } from "./index.js";
+const ignoredSchema = S.Record(S.String());

package/node_modules/toolcraft-schema/dist/record.d.ts

@@ -0,0 +1,5 @@
+import type { AnySchema, SchemaBase, Static } from "./index.js";
+export interface RecordSchema<TValue extends AnySchema> extends SchemaBase<"record", Record<string, Static<TValue>>> {
+    readonly value: TValue;
+}
+export declare function Record<TValue extends AnySchema>(value: TValue): RecordSchema<TValue>;

package/node_modules/toolcraft-schema/dist/record.js

@@ -0,0 +1,6 @@
+export function Record(value) {
+    return {
+        kind: "record",
+        value,
+    };
+}

package/node_modules/toolcraft-schema/dist/union.compile-check.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/toolcraft-schema/dist/union.compile-check.js

@@ -0,0 +1,9 @@
+import { S } from "./index.js";
+const ignoredSchema = S.Union([
+    S.Object({
+        email: S.String(),
+    }),
+    S.Object({
+        phone: S.String(),
+    }),
+]);

package/node_modules/toolcraft-schema/dist/union.d.ts

@@ -0,0 +1,8 @@
+import type { ObjectSchema, SchemaBase, Static } from "./index.js";
+type UnionStatic<TBranches extends readonly ObjectSchema<any>[]> = Static<TBranches[number]>;
+export interface UnionSchema<TBranches extends readonly ObjectSchema<any>[]> extends SchemaBase<"union", UnionStatic<TBranches>> {
+    readonly branches: TBranches;
+}
+export declare function getRequiredKeyFingerprint(schema: ObjectSchema<any>): string;
+export declare function Union<const TBranches extends readonly ObjectSchema<any>[]>(branches: TBranches): UnionSchema<TBranches>;
+export {};

package/node_modules/toolcraft-schema/dist/union.js

@@ -0,0 +1,45 @@
+function isOptionalSchema(schema) {
+    return schema.kind === "optional";
+}
+function getRequiredKeys(schema) {
+    return Object.keys(schema.shape)
+        .filter((key) => !isOptionalSchema(schema.shape[key]))
+        .sort();
+}
+export function getRequiredKeyFingerprint(schema) {
+    return getRequiredKeys(schema).join("+");
+}
+function assertUniqueRequiredKeyFingerprints(branches) {
+    const fingerprints = new Map();
+    branches.forEach((branch, index) => {
+        const requiredKeys = getRequiredKeys(branch);
+        const fingerprint = JSON.stringify(requiredKeys);
+        const existing = fingerprints.get(fingerprint);
+        if (existing === undefined) {
+            fingerprints.set(fingerprint, {
+                display: requiredKeys.join("+"),
+                indices: [index],
+            });
+            return;
+        }
+        existing.indices.push(index);
+    });
+    for (const { display, indices } of fingerprints.values()) {
+        if (indices.length > 1) {
+            throw new Error(`Union branches [${indices.join(", ")}] share required-key fingerprint "${display}". Each branch must require a distinct set of keys.`);
+        }
+    }
+}
+function assertValidBranches(branches) {
+    if (branches.length === 0) {
+        throw new Error("Union schema requires at least one branch");
+    }
+    assertUniqueRequiredKeyFingerprints(branches);
+}
+export function Union(branches) {
+    assertValidBranches(branches);
+    return {
+        kind: "union",
+        branches,
+    };
+}

package/node_modules/toolcraft-schema/dist/validate.d.ts

@@ -0,0 +1,16 @@
+import type { AnySchema, Static } from "./index.js";
+export type SchemaDescriptor = AnySchema;
+export type ValidationIssue = {
+    path: readonly string[];
+    expected: string;
+    received: string;
+    message: string;
+};
+export type ValidationResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    issues: readonly ValidationIssue[];
+};
+export declare function validate<S extends SchemaDescriptor>(schema: S, value: unknown): ValidationResult<Static<S>>;

package/node_modules/toolcraft-schema/dist/validate.js

@@ -0,0 +1,379 @@
+import { getRequiredKeyFingerprint } from "./union.js";
+const missingValue = Symbol("missingValue");
+export 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 : undefined) };
+}
+function walkSchema(schema, value, path, state) {
+    if (schema.kind === "optional") {
+        return walkOptional(schema, value, path, state);
+    }
+    if (value === missingValue) {
+        addIssue(state, path, expectedFor(schema), "missing", `Expected ${expectedFor(schema)} at ${formatPath(path)}`);
+        return { present: false };
+    }
+    if (value === null && schema.nullable === true) {
+        return { present: true, value };
+    }
+    switch (schema.kind) {
+        case "string":
+            return walkString(schema, value, path, state);
+        case "number":
+            return walkNumber(schema, value, path, state);
+        case "boolean":
+            return walkBoolean(value, path, state);
+        case "enum":
+            return walkEnum(schema, value, path, state);
+        case "array":
+            return walkArray(schema, value, path, state);
+        case "object":
+            return walkObject(schema, value, path, state);
+        case "oneOf":
+            return walkOneOf(schema, value, path, state);
+        case "union":
+            return walkUnion(schema, value, path, state);
+        case "record":
+            return walkRecord(schema, value, path, state);
+        case "json":
+            return walkJson(value, path, state);
+    }
+}
+function walkOptional(schema, value, path, state) {
+    if (value === missingValue || value === undefined) {
+        const defaultValue = getDefault(schema.inner);
+        if (defaultValue.present) {
+            return walkSchema(schema.inner, cloneDefault(defaultValue.value), path, state);
+        }
+        return { present: false };
+    }
+    return walkSchema(schema.inner, value, path, state);
+}
+function walkString(schema, value, path, state) {
+    if (typeof value !== "string") {
+        addExpectedIssue(state, path, "string", value);
+        return { present: true, value };
+    }
+    if (schema.minLength !== undefined && value.length < schema.minLength) {
+        const expected = `string with length at least ${schema.minLength}`;
+        addIssue(state, path, expected, `string with length ${value.length}`, `Expected ${expected} at ${formatPath(path)}`);
+    }
+    if (schema.maxLength !== undefined && value.length > schema.maxLength) {
+        const expected = `string with length at most ${schema.maxLength}`;
+        addIssue(state, path, expected, `string with length ${value.length}`, `Expected ${expected} at ${formatPath(path)}`);
+    }
+    if (schema.pattern !== undefined) {
+        const pattern = compilePattern(schema.pattern);
+        if (pattern === undefined || !pattern.test(value)) {
+            const expected = `string matching pattern ${schema.pattern}`;
+            addIssue(state, path, expected, value, `Expected ${expected} at ${formatPath(path)}`);
+        }
+    }
+    return { present: true, value };
+}
+function walkNumber(schema, value, path, state) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        addExpectedIssue(state, path, schema.jsonType === "integer" ? "integer" : "number", value);
+        return { present: true, value };
+    }
+    if (schema.jsonType === "integer" && !Number.isInteger(value)) {
+        addExpectedIssue(state, path, "integer", value);
+    }
+    if (schema.minimum !== undefined && value < schema.minimum) {
+        const expected = `number greater than or equal to ${schema.minimum}`;
+        addIssue(state, path, expected, String(value), `Expected ${expected} at ${formatPath(path)}`);
+    }
+    if (schema.maximum !== undefined && value > schema.maximum) {
+        const expected = `number less than or equal to ${schema.maximum}`;
+        addIssue(state, path, expected, String(value), `Expected ${expected} at ${formatPath(path)}`);
+    }
+    return { present: true, value };
+}
+function walkBoolean(value, path, state) {
+    if (typeof value !== "boolean") {
+        addExpectedIssue(state, path, "boolean", value);
+    }
+    return { present: true, value };
+}
+function walkEnum(schema, value, path, state) {
+    if (!schema.values.includes(value)) {
+        const expected = `one of ${schema.values.join(", ")}`;
+        addIssue(state, path, expected, receivedValue(value), `Expected ${expected} at ${formatPath(path)}`);
+    }
+    return { present: true, value };
+}
+function walkArray(schema, value, path, state) {
+    if (!Array.isArray(value)) {
+        addExpectedIssue(state, path, "array", value);
+        return { present: true, value };
+    }
+    if (schema.minItems !== undefined && value.length < schema.minItems) {
+        const expected = `array with at least ${schema.minItems} items`;
+        addIssue(state, path, expected, `array with ${value.length} items`, `Expected ${expected} at ${formatPath(path)}`);
+    }
+    if (schema.maxItems !== undefined && value.length > schema.maxItems) {
+        const expected = `array with at most ${schema.maxItems} items`;
+        addIssue(state, path, expected, `array with ${value.length} items`, `Expected ${expected} at ${formatPath(path)}`);
+    }
+    const nextValue = value.map((item, index) => {
+        const result = walkSchema(schema.item, item, [...path, String(index)], state);
+        return result.present ? result.value : item;
+    });
+    return { present: true, value: nextValue };
+}
+function walkObject(schema, value, path, state, injectedProperties = {}) {
+    if (!isPlainRecord(value)) {
+        addExpectedIssue(state, path, "object", value);
+        return { present: true, value };
+    }
+    const nextValue = {};
+    const allowedKeys = 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, [...path, 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, [...path, key]);
+        }
+    }
+    return { present: true, value: nextValue };
+}
+function walkOneOf(schema, value, path, state) {
+    if (!isPlainRecord(value)) {
+        addExpectedIssue(state, path, "object", value);
+        return { present: true, value };
+    }
+    const discriminatorValue = value[schema.discriminator];
+    const discriminatorPath = [...path, 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(path)}. 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, path, state, {
+        [schema.discriminator]: discriminatorValue
+    });
+}
+function walkUnion(schema, value, path, state) {
+    if (isPlainRecord(value)) {
+        const candidateBranches = schema.branches.filter((branch) => hasRequiredKeys(branch, value));
+        if (candidateBranches.length === 1) {
+            return walkObject(candidateBranches[0], value, path, state);
+        }
+    }
+    const matches = [];
+    for (const branch of schema.branches) {
+        const branchState = { issues: [] };
+        const result = walkObject(branch, value, path, 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, path, "exactly one union branch", "0 matching branches", `No union branch matched at ${formatPath(path)}. Tried ${schema.branches.length} branches. Expected one of: ${branchDescriptions.join(" | ")}.`);
+        return { present: true, value };
+    }
+    addIssueWithMessage(state, path, "exactly one union branch", `${matches.length} matching branches`, `Expected exactly one union branch at ${formatPath(path)}, 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, path, state) {
+    if (!isPlainRecord(value)) {
+        addExpectedIssue(state, path, "object", value);
+        return { present: true, value };
+    }
+    const nextValue = {};
+    for (const [key, propertyValue] of Object.entries(value)) {
+        const result = walkSchema(schema.value, propertyValue, [...path, key], state);
+        if (result.present) {
+            setOwnValue(nextValue, key, result.value);
+        }
+    }
+    return { present: true, value: nextValue };
+}
+function walkJson(value, path, state) {
+    if (isJsonValue(value)) {
+        return { present: true, value };
+    }
+    addExpectedIssue(state, path, "JSON value", value);
+    return { present: true, value };
+}
+function getDefault(schema) {
+    if (schema.default !== undefined) {
+        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 = 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, path, expected, value) {
+    addIssue(state, path, expected, receivedType(value), `Expected ${expected} at ${formatPath(path)}`);
+}
+function addUnexpectedPropertyIssue(state, path) {
+    addIssue(state, path, "no additional properties", "unknown property", `Unexpected property ${formatPath(path)}`);
+}
+function addIssue(state, path, expected, received, _message) {
+    state.issues.push({
+        path,
+        expected,
+        received,
+        message: formatIssueMessage(expected, path, received)
+    });
+}
+function addIssueWithMessage(state, path, expected, received, message) {
+    state.issues.push({
+        path,
+        expected,
+        received,
+        message
+    });
+}
+function formatIssueMessage(expected, path, received) {
+    return `Expected ${expected} at ${formatPath(path)}, got ${received}`;
+}
+function formatPath(path) {
+    return path.length === 0 ? "value" : path.join(".");
+}
+function compilePattern(pattern) {
+    try {
+        return new RegExp(pattern);
+    }
+    catch {
+        return undefined;
+    }
+}
+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 === undefined) {
+        return "undefined";
+    }
+    return String(value);
+}
+function formatReceivedDiscriminator(value) {
+    if (typeof value === "string") {
+        return JSON.stringify(value);
+    }
+    return receivedValue(value);
+}

package/node_modules/toolcraft-schema/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "toolcraft-schema",
+  "version": "0.0.101",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc",
+    "test": "cd ../.. && vitest run packages/toolcraft-schema/src/*.test.ts",
+    "test:unit": "cd ../.. && vitest run packages/toolcraft-schema/src/*.test.ts",
+    "lint": "cd ../.. && eslint packages/toolcraft-schema/src --ext ts && tsc -p packages/toolcraft-schema/tsconfig.json --noEmit"
+  },
+  "files": [
+    "LICENSE",
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18.18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/poe-platform/poe-code.git",
+    "directory": "packages/toolcraft-schema"
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft",
-  "version": "0.0.99",
+  "version": "0.0.101",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",
@@ -100,11 +100,10 @@
     "test": "cd ../.. && vitest run packages/toolcraft/src",
     "test:unit": "cd ../.. && vitest run packages/toolcraft/src",
     "lint": "cd ../.. && eslint packages/toolcraft/src --ext ts && tsc -p packages/toolcraft/tsconfig.json --noEmit",
-    "prepack": "node ../../scripts/manage-bundled-workspace-deps.mjs prepare . toolcraft-design @poe-code/frontmatter @poe-code/agent-mcp-config @poe-code/agent-human-in-loop @poe-code/task-list @poe-code/agent-defs @poe-code/config-mutations @poe-code/process-runner tiny-mcp-client auth-store",
-    "postpack": "node ../../scripts/manage-bundled-workspace-deps.mjs cleanup . toolcraft-design @poe-code/frontmatter @poe-code/agent-mcp-config @poe-code/agent-human-in-loop @poe-code/task-list @poe-code/agent-defs @poe-code/config-mutations @poe-code/process-runner tiny-mcp-client auth-store"
+    "prepack": "node ../../scripts/manage-bundled-workspace-deps.mjs prepare . toolcraft-schema toolcraft-design @poe-code/frontmatter @poe-code/agent-mcp-config @poe-code/agent-human-in-loop @poe-code/task-list @poe-code/agent-defs @poe-code/config-mutations @poe-code/process-runner tiny-mcp-client auth-store",
+    "postpack": "node ../../scripts/manage-bundled-workspace-deps.mjs cleanup . toolcraft-schema toolcraft-design @poe-code/frontmatter @poe-code/agent-mcp-config @poe-code/agent-human-in-loop @poe-code/task-list @poe-code/agent-defs @poe-code/config-mutations @poe-code/process-runner tiny-mcp-client auth-store"
   },
   "dependencies": {
-    "toolcraft-schema": "0.0.99",
     "commander": "^13.1.0",
     "fast-string-width": "^3.0.2",
     "fast-wrap-ansi": "^0.2.0",
@@ -131,6 +130,7 @@
     "directory": "packages/toolcraft"
   },
   "bundleDependencies": [
+    "toolcraft-schema",
     "toolcraft-design",
     "@poe-code/frontmatter",
     "@poe-code/agent-mcp-config",
@@ -143,6 +143,7 @@
     "auth-store"
   ],
   "optionalDependencies": {
+    "toolcraft-schema": "0.0.101",
     "toolcraft-design": "^0.0.2",
     "@poe-code/frontmatter": "*",
     "@poe-code/agent-mcp-config": "*",