@toolproof-core/genesis 1.0.47

package/src/index.ts

@@ -0,0 +1,27 @@
+// Re-export JSON schemas via .ts shims to avoid .json re-exports in declarations
+export { default as Schemas } from '../generated-src/schemas/schemas.js';
+
+export { default as ResourceTypeSchema } from '../generated-src/schemas/standalone/ResourceType.js';
+export { default as ToolSchema } from '../generated-src/schemas/standalone/Tool.js';
+export { default as StrategySchema } from '../generated-src/schemas/standalone/Strategy.js';
+export { default as StrategyTraceSchema } from '../generated-src/schemas/standalone/StrategyTrace.js';
+
+// Re-export generated Zod validators
+export { ToolSchema as ZodToolSchema } from '../generated-src/schemas/zod/Tool.js';
+export { ResourceTypeSchema as ZodResourceTypeSchema } from '../generated-src/schemas/zod/ResourceType.js';
+export { StrategySchema as ZodStrategySchema } from '../generated-src/schemas/zod/Strategy.js';
+export { StrategyTraceSchema as ZodStrategyTraceSchema } from '../generated-src/schemas/zod/StrategyTrace.js';
+export { GoalSchema as ZodGoalSchema } from '../generated-src/schemas/zod/Goal.js';
+export * as ZodSchemas from '../generated-src/schemas/zod/index.js';
+
+export { default as ResourceTypes } from '../generated-src/resources/resourceTypes.js';
+
+export { default as CONSTANTS } from '../generated-src/derived/constants.js';
+export { default as MAPPINGS } from '../generated-src/derived/mappings.js';
+
+export type * from '../generated-src/types/types.js';
+
+export type * from '../generated-src/types/standalone/ResourceTypeResource.js';
+export type * from '../generated-src/types/standalone/ToolResource.js';
+export type * from '../generated-src/types/standalone/StrategyResource.js';
+export type * from '../generated-src/types/standalone/StrategyTraceResource.js';

package/src/utils/constantsAndMappings.ts

@@ -0,0 +1,195 @@
+type JSONValue = null | boolean | number | string | JSONValue[] | { [k: string]: JSONValue };
+
+export type GeneratedConstants = {
+    Names: Record<string, string>;
+    Enums: Record<string, Record<string, string>>;
+};
+
+export type GeneratedMappings = {
+    HandleNameToPrefix: Record<string, string>;
+};
+
+function deriveIdPrefixFromPattern(pattern: string): string | undefined {
+    const match = /^\^([^$]+)\.\+\$$/.exec(pattern);
+    if (!match) return undefined;
+
+    const prefix = match[1];
+    if (!prefix || /[`\n\r]/.test(prefix)) return undefined;
+
+    return prefix;
+}
+
+export function extractHandlePrefixes(schema: unknown): Record<string, string> {
+    if (!schema || typeof schema !== 'object') return {};
+
+    const defs = (schema as { $defs?: unknown }).$defs;
+    if (!defs || typeof defs !== 'object') return {};
+
+    const defEntries = Object.entries(defs as Record<string, unknown>);
+    defEntries.sort(([a], [b]) => a.localeCompare(b));
+
+    const out: Record<string, string> = {};
+
+    for (const [defName, defVal] of defEntries) {
+        if (!/(Id|Handle)$/.test(defName)) continue;
+        if (!defVal || typeof defVal !== 'object' || Array.isArray(defVal)) continue;
+
+        const value = defVal as { type?: unknown; pattern?: unknown };
+        if (value.type !== 'string') continue;
+        if (typeof value.pattern !== 'string') continue;
+
+        const prefix = deriveIdPrefixFromPattern(value.pattern);
+        if (!prefix) continue;
+
+        out[defName] = prefix;
+    }
+
+    return out;
+}
+
+export function extractSubschemaNames(schema: unknown): Record<string, string> {
+    if (!schema || typeof schema !== 'object') return {};
+
+    const defs = (schema as { $defs?: unknown }).$defs;
+    if (!defs || typeof defs !== 'object') return {};
+
+    const defEntries = Object.entries(defs as Record<string, unknown>);
+    defEntries.sort(([a], [b]) => a.localeCompare(b));
+
+    const out: Record<string, string> = {};
+    for (const [defName] of defEntries) {
+        if (!defName || /[\n\r`]/.test(defName)) continue;
+        out[defName] = defName;
+    }
+
+    return out;
+}
+
+export function extractEnums(schema: unknown): Record<string, Record<string, string>> {
+    if (!schema || typeof schema !== 'object') return {};
+
+    const defs = (schema as { $defs?: unknown }).$defs;
+    if (!defs || typeof defs !== 'object') return {};
+
+    const defEntries = Object.entries(defs as Record<string, unknown>);
+    defEntries.sort(([a], [b]) => a.localeCompare(b));
+
+    const out: Record<string, Record<string, string>> = {};
+
+    for (const [defName, defVal] of defEntries) {
+        if (!/(Kind|Status)$/.test(defName)) continue;
+        if (!defVal || typeof defVal !== 'object' || Array.isArray(defVal)) continue;
+
+        const value = defVal as { type?: unknown; enum?: unknown };
+        if (value.type !== 'string') continue;
+        if (!Array.isArray(value.enum) || value.enum.length === 0) continue;
+        if (value.enum.some((item) => typeof item !== 'string')) continue;
+
+        const members: Record<string, string> = {};
+        for (const member of value.enum as readonly string[]) {
+            members[member] = member;
+        }
+
+        out[defName] = members;
+    }
+
+    return out;
+}
+
+export function extractGeneratedConstantsAndMappings(schema: JSONValue): {
+    CONSTANTS: GeneratedConstants;
+    MAPPINGS: GeneratedMappings;
+} {
+    const names = extractSubschemaNames(schema);
+    const enums = extractEnums(schema);
+    const handlePrefixes = extractHandlePrefixes(schema);
+
+    return {
+        CONSTANTS: {
+            Names: names,
+            Enums: enums,
+        },
+        MAPPINGS: {
+            HandleNameToPrefix: handlePrefixes,
+        },
+    };
+}
+
+function escapeTsString(value: string): string {
+    return value
+        .replace(/\\/g, '\\\\')
+        .replace(/\r/g, '\\r')
+        .replace(/\n/g, '\\n')
+        .replace(/\t/g, '\\t')
+        .replace(/'/g, "\\'");
+}
+
+function renderTsStringLiteral(value: string): string {
+    return `'${escapeTsString(value)}'`;
+}
+
+function isValidTsIdentifier(key: string): boolean {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key);
+}
+
+function renderTsKey(key: string): string {
+    return isValidTsIdentifier(key) ? key : renderTsStringLiteral(key);
+}
+
+export function renderConstantsTs(constants: GeneratedConstants): string {
+    const nameKeys = Object.keys(constants.Names).sort((a, b) => a.localeCompare(b));
+    const enumKeys = Object.keys(constants.Enums).sort((a, b) => a.localeCompare(b));
+
+    const lines: string[] = [];
+    lines.push('const CONSTANTS = {');
+    lines.push('    Names: {');
+
+    for (const key of nameKeys) {
+        const value = constants.Names[key] ?? '';
+        lines.push(`        ${renderTsKey(key)}: ${renderTsStringLiteral(value)},`);
+    }
+
+    lines.push('    },');
+    lines.push('    Enums: {');
+
+    for (const key of enumKeys) {
+        const members = constants.Enums[key] ?? {};
+        lines.push(`        ${renderTsKey(key)}: {`);
+
+        for (const memberKey of Object.keys(members)) {
+            const value = members[memberKey] ?? '';
+            lines.push(`            ${renderTsKey(memberKey)}: ${renderTsStringLiteral(value)},`);
+        }
+
+        lines.push('        },');
+    }
+
+    lines.push('    }');
+    lines.push('} as const;');
+    lines.push('');
+    lines.push('export default CONSTANTS;');
+    lines.push('');
+
+    return lines.join('\n');
+}
+
+export function renderMappingsTs(mappings: GeneratedMappings): string {
+    const handleKeys = Object.keys(mappings.HandleNameToPrefix).sort((a, b) => a.localeCompare(b));
+
+    const lines: string[] = [];
+    lines.push('const MAPPINGS = {');
+    lines.push('    HandleNameToPrefix: {');
+
+    for (const key of handleKeys) {
+        const value = mappings.HandleNameToPrefix[key] ?? '';
+        lines.push(`        ${renderTsKey(key)}: ${renderTsStringLiteral(value)},`);
+    }
+
+    lines.push('    },');
+    lines.push('} as const;');
+    lines.push('');
+    lines.push('export default MAPPINGS;');
+    lines.push('');
+
+    return lines.join('\n');
+}

package/src/utils/coreProjection.ts

@@ -0,0 +1,53 @@
+import * as path from 'node:path';
+
+export type CoreProjectionNode = CoreProjectionDirectoryNode | CoreProjectionFileNode;
+
+export interface CoreProjectionBaseNode {
+    kind: 'directory' | 'file';
+    name: string;
+    path: string;
+}
+
+export interface CoreProjectionDirectoryNode extends CoreProjectionBaseNode {
+    kind: 'directory';
+    children: CoreProjectionNode[];
+}
+
+export interface CoreProjectionFileNode extends CoreProjectionBaseNode {
+    kind: 'file';
+}
+
+const EXCLUDED_DIRECTORY_NAMES = new Set([
+    '.git',
+    '.next',
+    'dist',
+    'node_modules',
+]);
+
+export function toPosixPath(value: string): string {
+    return value.split(path.sep).join('/');
+}
+
+export function shouldExclude(relativePath: string, isDirectory: boolean, excludedRelativePathPrefixes: string[]): boolean {
+    if (!relativePath || relativePath === '.') {
+        return false;
+    }
+
+    const normalizedPath = toPosixPath(relativePath);
+    const baseName = path.posix.basename(normalizedPath);
+
+    if (isDirectory && EXCLUDED_DIRECTORY_NAMES.has(baseName)) {
+        return true;
+    }
+
+    return excludedRelativePathPrefixes.some((prefix) => {
+        return normalizedPath === prefix || normalizedPath.startsWith(`${prefix}/`);
+    });
+}
+
+export function compareNodes(a: CoreProjectionNode, b: CoreProjectionNode): number {
+    if (a.kind !== b.kind) {
+        return a.kind === 'directory' ? -1 : 1;
+    }
+    return a.name.localeCompare(b.name);
+}

package/src/utils/resourceTypes.ts

@@ -0,0 +1,39 @@
+type JsonObject = Record<string, unknown>;
+
+type SchemasDocument = {
+    $defs?: Record<string, JsonObject>;
+};
+
+type ResourceTypeShell = JsonObject & {
+    handle?: unknown;
+    name?: unknown;
+    description?: unknown;
+};
+
+type ResourceTypeShellByName = Record<string, ResourceTypeShell>;
+
+export function generateResourceTypes(
+    schemasDocument: SchemasDocument,
+    resourceTypeShells: ResourceTypeShellByName,
+): ResourceTypeShellByName {
+    if (!schemasDocument.$defs || typeof schemasDocument.$defs !== 'object') {
+        throw new Error('Schema document must have root $defs');
+    }
+
+    const resourceTypes: ResourceTypeShellByName = {};
+
+    for (const [resourceTypeName, resourceTypeShell] of Object.entries(resourceTypeShells)) {
+        const valueSchema = schemasDocument.$defs[resourceTypeName];
+
+        if (!valueSchema || typeof valueSchema !== 'object' || Array.isArray(valueSchema)) {
+            throw new Error(`Missing matching schema for resource type record ${resourceTypeName}`);
+        }
+
+        resourceTypes[resourceTypeName] = {
+            ...resourceTypeShell,
+            valueSchema,
+        };
+    }
+
+    return resourceTypes;
+}

package/src/utils/resources.ts

@@ -0,0 +1,26 @@
+type JsonObject = Record<string, unknown>;
+
+type ResourceTypeByName = Record<string, JsonObject>;
+
+type ResourceByName = Record<string, JsonObject>;
+
+const GENESIS_TIMESTAMP = '2025-11-30T00:00:00.000Z';
+
+export function generateResources(resourceTypes: ResourceTypeByName): ResourceByName {
+    const resources: ResourceByName = {};
+
+    for (const [name, resourceType] of Object.entries(resourceTypes)) {
+        resources[name] = {
+            id: `RESOURCE-${name}`,
+            resourceTypeHandle: 'TYPE-ResourceType',
+            provenance: {
+                resourceProvenanceKind: 'genesis',
+            },
+            version: 1,
+            timestamp: GENESIS_TIMESTAMP,
+            value: resourceType,
+        };
+    }
+
+    return resources;
+}

package/src/utils/schemaDependencies.ts

@@ -0,0 +1,115 @@
+type JSONValue = null | boolean | number | string | JSONValue[] | { [k: string]: JSONValue };
+
+export type DependencyMap = Record<string, string[]>;
+
+export function decodeJsonPointerSegment(segment: string): string {
+    return segment.replace(/~1/g, '/').replace(/~0/g, '~');
+}
+
+export function collectRefs(node: unknown, out: Set<string>): void {
+    if (Array.isArray(node)) {
+        for (const item of node) collectRefs(item, out);
+        return;
+    }
+    if (!node || typeof node !== 'object') return;
+
+    const obj = node as Record<string, unknown>;
+    const ref = obj.$ref;
+    if (typeof ref === 'string') out.add(ref);
+
+    for (const value of Object.values(obj)) {
+        collectRefs(value, out);
+    }
+}
+
+export function resolveInternalRefToDefKey(
+    ref: string,
+    defKeys: Set<string>,
+    anchorToDef: Record<string, string>,
+): string | null {
+    if (!ref.startsWith('#')) return null;
+
+    const defsPrefix = '#/$defs/';
+    if (ref.startsWith(defsPrefix)) {
+        const rest = ref.slice(defsPrefix.length);
+        const firstSegment = rest.split('/')[0] ?? '';
+        const defKey = decodeJsonPointerSegment(firstSegment);
+        return defKeys.has(defKey) ? defKey : null;
+    }
+
+    if (!ref.startsWith('#/')) {
+        const anchor = ref.slice(1);
+        const mapped = anchorToDef[anchor];
+        if (mapped && defKeys.has(mapped)) return mapped;
+        if (defKeys.has(anchor)) return anchor;
+    }
+
+    return null;
+}
+
+export function generateDependencyMap(doc: { $defs?: Record<string, JSONValue> } | null | undefined): DependencyMap {
+    const defs: Record<string, JSONValue> = doc?.$defs && typeof doc.$defs === 'object' ? doc.$defs : {};
+    const defKeys = new Set(Object.keys(defs));
+
+    const anchorToDef: Record<string, string> = {};
+    for (const [defKey, defSchema] of Object.entries(defs)) {
+        if (!defSchema || typeof defSchema !== 'object' || Array.isArray(defSchema)) continue;
+        const anchor = (defSchema as { $anchor?: unknown }).$anchor;
+        if (typeof anchor === 'string' && !(anchor in anchorToDef)) {
+            anchorToDef[anchor] = defKey;
+        }
+    }
+
+    const dependencyMap: DependencyMap = {};
+
+    for (const [defKey, defSchema] of Object.entries(defs)) {
+        const refs = new Set<string>();
+        collectRefs(defSchema, refs);
+
+        const deps = new Set<string>();
+        for (const ref of refs) {
+            const depKey = resolveInternalRefToDefKey(ref, defKeys, anchorToDef);
+            if (!depKey || depKey === defKey) continue;
+            deps.add(depKey);
+        }
+
+        dependencyMap[defKey] = Array.from(deps);
+    }
+
+    return dependencyMap;
+}
+
+export function normalizeDependencyMap(value: unknown): DependencyMap {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('Invalid dependencyMap.json: expected an object');
+    }
+
+    const input = value as Record<string, unknown>;
+    const out: DependencyMap = {};
+
+    for (const [key, rawDeps] of Object.entries(input)) {
+        if (rawDeps == null) {
+            out[key] = [];
+            continue;
+        }
+        if (!Array.isArray(rawDeps)) {
+            throw new Error(`Invalid dependencyMap.json: value for ${key} must be an array`);
+        }
+        out[key] = rawDeps.filter((dep): dep is string => typeof dep === 'string');
+    }
+
+    return out;
+}
+
+export function computeTerminalsInKeyOrder(dependencyMap: DependencyMap): string[] {
+    const keys = Object.keys(dependencyMap);
+    const dependedUpon = new Set<string>();
+
+    for (const key of keys) {
+        for (const dep of dependencyMap[key] ?? []) {
+            dependedUpon.add(dep);
+        }
+    }
+
+    return keys.filter((key) => !dependedUpon.has(key));
+}

package/src/utils/schemaObjectNormalization.ts

@@ -0,0 +1,71 @@
+export function normalizeAllOfSiblingObjectKeywords(node: any): any {
+    if (Array.isArray(node)) {
+        let changed = false;
+        const out = node.map((item) => {
+            const next = normalizeAllOfSiblingObjectKeywords(item);
+            if (next !== item) changed = true;
+            return next;
+        });
+        return changed ? out : node;
+    }
+    if (!node || typeof node !== 'object') return node;
+
+    const hasAllOf = Array.isArray((node as any).allOf) && (node as any).allOf.length > 0;
+    const looksLikeObjectSchema =
+        (node as any).type === 'object' ||
+        (node as any).properties !== undefined ||
+        (node as any).required !== undefined ||
+        (node as any).unevaluatedProperties !== undefined ||
+        (node as any).additionalProperties !== undefined ||
+        (node as any).propertyNames !== undefined;
+
+    const siblingKeys = [
+        'type',
+        'properties',
+        'required',
+        'additionalProperties',
+        'unevaluatedProperties',
+        'propertyNames',
+        'patternProperties',
+        'dependentRequired',
+        'dependentSchemas',
+        'minProperties',
+        'maxProperties',
+    ] as const;
+
+    let localNode: any = node;
+    if (hasAllOf && looksLikeObjectSchema) {
+        const hasSiblingObjectKeywords = siblingKeys.some((key) => key in localNode);
+        if (hasSiblingObjectKeywords) {
+            const overlay: any = {};
+            const nextNode: any = { ...localNode };
+
+            for (const key of siblingKeys) {
+                if (key in nextNode) {
+                    overlay[key] = nextNode[key];
+                    delete nextNode[key];
+                }
+            }
+
+            nextNode.allOf = [overlay, ...(nextNode.allOf as any[])];
+            localNode = nextNode;
+        }
+    }
+
+    let changed = localNode !== node;
+    const out: Record<string, any> = localNode === node ? ({} as any) : { ...localNode };
+    for (const [key, value] of Object.entries(localNode)) {
+        const next = normalizeAllOfSiblingObjectKeywords(value);
+        if (next !== value) {
+            if (!changed) {
+                changed = true;
+                Object.assign(out, localNode);
+            }
+            out[key] = next;
+        } else if (changed) {
+            out[key] = value;
+        }
+    }
+
+    return changed ? out : node;
+}

package/src/utils/schemaRefNormalization.ts

@@ -0,0 +1,83 @@
+export function stripAnchors<T>(schema: T): T {
+    const seen = new WeakMap<object, unknown>();
+
+    function walk(node: unknown): unknown {
+        if (!node || typeof node !== 'object') return node;
+
+        const existing = seen.get(node as object);
+        if (existing) return existing;
+
+        if (Array.isArray(node)) {
+            const out: unknown[] = [];
+            seen.set(node, out);
+            for (const item of node) out.push(walk(item));
+            return out;
+        }
+
+        const out: Record<string, unknown> = {};
+        seen.set(node as object, out);
+
+        for (const [key, value] of Object.entries(node as Record<string, unknown>)) {
+            if (key === '$anchor') continue;
+            out[key] = walk(value);
+        }
+
+        return out;
+    }
+
+    return walk(schema) as T;
+}
+
+export function normalizeAnchorsToPointers<T>(input: T): T {
+    if (!input || typeof input !== 'object') return input;
+
+    const root = JSON.parse(JSON.stringify(input)) as { $defs?: Record<string, unknown> };
+    const defs: Record<string, unknown> = root.$defs && typeof root.$defs === 'object' ? root.$defs : {};
+    const anchorToDef: Record<string, string> = {};
+
+    for (const [defName, defValue] of Object.entries(defs)) {
+        if (!anchorToDef[defName]) {
+            anchorToDef[defName] = defName;
+        }
+
+        if (!defValue || typeof defValue !== 'object') continue;
+
+        const envelope = defValue as { valueSchema?: { $anchor?: unknown }; $anchor?: unknown };
+        const valueSchema = envelope.valueSchema;
+        if (valueSchema && typeof valueSchema === 'object') {
+            const anchor = valueSchema.$anchor;
+            if (typeof anchor === 'string' && !anchorToDef[anchor]) {
+                anchorToDef[anchor] = defName;
+            }
+        } else {
+            const anchor = envelope.$anchor;
+            if (typeof anchor === 'string' && !anchorToDef[anchor]) {
+                anchorToDef[anchor] = defName;
+            }
+        }
+    }
+
+    function walk(node: unknown): void {
+        if (Array.isArray(node)) {
+            for (const item of node) walk(item);
+            return;
+        }
+        if (!node || typeof node !== 'object') return;
+
+        const obj = node as { $ref?: unknown } & Record<string, unknown>;
+        if (typeof obj.$ref === 'string' && obj.$ref.startsWith('#') && !obj.$ref.startsWith('#/')) {
+            const anchor = obj.$ref.slice(1);
+            const defName = anchorToDef[anchor];
+            if (defName) {
+                obj.$ref = `#/$defs/${defName}`;
+            }
+        }
+
+        for (const value of Object.values(obj)) {
+            walk(value);
+        }
+    }
+
+    walk(root);
+    return root as T;
+}

package/src/utils/schemaShims.ts

@@ -0,0 +1,17 @@
+import * as path from 'node:path';
+
+export function generateShimContent(jsonFile: string, variableName: string): string {
+    return `import ${variableName} from './${jsonFile}' with { type: 'json' };\nexport default ${variableName};\n`;
+}
+
+export function getShimsForFiles(jsonFiles: string[], variableName: string): Record<string, string> {
+    const shims: Record<string, string> = {};
+
+    for (const jsonFile of jsonFiles) {
+        const baseName = path.basename(jsonFile, '.json');
+        const tsFile = `${baseName}.ts`;
+        shims[tsFile] = generateShimContent(jsonFile, variableName);
+    }
+
+    return shims;
+}