@toolproof-core/genesis 1.0.53 → 1.0.54

package/src/utils/coreProjection.ts

@@ -1,53 +0,0 @@
-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

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

package/src/utils/schemaDependencies.ts

@@ -1,115 +0,0 @@
-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

@@ -1,71 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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 { projectionSchema?: { $anchor?: unknown }; $anchor?: unknown };
-        const projectionSchema = envelope.projectionSchema;
-        if (projectionSchema && typeof projectionSchema === 'object') {
-            const anchor = projectionSchema.$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

@@ -1,17 +0,0 @@
-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;
-}

package/src/utils/standaloneSchemas.ts

@@ -1,114 +0,0 @@
-export function isObject(value: unknown): value is Record<string, unknown> {
-    return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
-
-export function deepClone<T>(value: T): T {
-    if (Array.isArray(value)) return value.map((item) => deepClone(item)) as T;
-    if (isObject(value)) {
-        const out: Record<string, unknown> = {};
-        for (const key of Object.keys(value)) out[key] = deepClone(value[key]);
-        return out as T;
-    }
-    return value;
-}
-
-export function extractPointerDefName(ref: string): string | null {
-    if (!ref || !ref.startsWith('#/')) return null;
-    const parts = ref.slice(2).split('/');
-    if (parts.length !== 2) return null;
-    if (parts[0] !== '$defs') return null;
-    const defName = parts[1];
-    if (defName === undefined) return null;
-    return defName.replace(/~1/g, '/').replace(/~0/g, '~');
-}
-
-export function collectLocalDefClosure(node: unknown, rootDefs: Record<string, unknown>): Set<string> {
-    const needed = new Set<string>();
-    const queue: string[] = [];
-
-    function visit(value: unknown) {
-        if (Array.isArray(value)) {
-            for (const item of value) visit(item);
-            return;
-        }
-        if (!isObject(value)) return;
-
-        if (typeof value.$ref === 'string') {
-            const name = extractPointerDefName(value.$ref);
-            if (name && !needed.has(name)) {
-                needed.add(name);
-                queue.push(name);
-            }
-        }
-
-        for (const nested of Object.values(value)) visit(nested);
-    }
-
-    visit(node);
-
-    while (queue.length > 0) {
-        const name = queue.shift();
-        if (!name) continue;
-        const def = rootDefs[name];
-        if (def === undefined) continue;
-        visit(def);
-    }
-
-    return needed;
-}
-
-export function extractStandaloneSchema(
-    schemasDocument: { $defs?: Record<string, unknown> },
-    name: string,
-): { schema: unknown; warnings: string[] } {
-    const rootDefs = schemasDocument.$defs;
-    if (!rootDefs || typeof rootDefs !== 'object') {
-        throw new Error('No $defs object found in schema document');
-    }
-
-    const target = rootDefs[name];
-    if (target === undefined) {
-        throw new Error(`Subschema named '${name}' not found under $defs in schema document`);
-    }
-
-    const needed = collectLocalDefClosure(target, rootDefs);
-    const targetClone = deepClone(target);
-    const defsOut: Record<string, unknown> = {};
-    const warnings: string[] = [];
-
-    for (const defName of needed) {
-        if (defName === name) continue;
-        const defSchema = rootDefs[defName];
-        if (defSchema === undefined) {
-            warnings.push(`Warning: referenced def '${defName}' missing in root $defs (skipped).`);
-            continue;
-        }
-        defsOut[defName] = deepClone(defSchema);
-    }
-
-    const existingInner = isObject(targetClone) && isObject(targetClone.$defs)
-        ? targetClone.$defs
-        : {};
-
-    if (isObject(targetClone)) {
-        targetClone.$defs = { ...existingInner, ...defsOut };
-    }
-
-    return { schema: targetClone, warnings };
-}
-
-export function generateStandaloneSchemas(
-    schemasDocument: { $defs?: Record<string, unknown> },
-    names: string[],
-): { standaloneSchemas: Record<string, unknown>; warnings: string[] } {
-    const standaloneSchemas: Record<string, unknown> = {};
-    const warnings: string[] = [];
-
-    for (const name of names) {
-        const result = extractStandaloneSchema(schemasDocument, name);
-        standaloneSchemas[name] = result.schema;
-        warnings.push(...result.warnings);
-    }
-
-    return { standaloneSchemas, warnings };
-}

package/src/utils/standaloneTypes.ts

@@ -1,28 +0,0 @@
-export function generateStandaloneTypeContent(name: string): string {
-    const header = '// Auto-generated strict composite type. Do not edit.\n';
-    const standaloneResourceTypeName = `${name}Resource`;
-
-    const ts =
-        `import type { ResourcePointer, ${name} as ProjectionSchema } from "../types.js";\n` +
-        `export type ${standaloneResourceTypeName} = ResourcePointer & { projection: ProjectionSchema };\n`;
-    return header + ts;
-}
-
-export function validateStandaloneSchemaForWarnings(schema: any): string[] {
-    const warnings: string[] = [];
-    if (schema?.$schema && schema.$schema !== 'https://json-schema.org/draft/2020-12/schema') {
-        warnings.push(
-            `Warning: schema $schema is '${String(schema.$schema)}', expected draft 2020-12. Proceeding anyway.`,
-        );
-    }
-    return warnings;
-}
-
-export function generateStandaloneTypeArtifacts(name: string): { dtsFileName: string; jsFileName: string; dtsContent: string; jsContent: string } {
-    return {
-        dtsFileName: `${name}Resource.d.ts`,
-        jsFileName: `${name}Resource.js`,
-        dtsContent: generateStandaloneTypeContent(name),
-        jsContent: 'export {}\n',
-    };
-}

package/src/utils/standaloneZodSchemas.ts

@@ -1,72 +0,0 @@
-import { jsonSchemaToZodExpressions, type JsonSchemaToZodWarning } from './zodCodegen.js';
-
-export type GeneratedZodModule = {
-    fileName: string;
-    content: string;
-    warnings: JsonSchemaToZodWarning[];
-};
-
-function isValidIdentifier(name: string): boolean {
-    return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name);
-}
-
-function toIdentifier(name: string): string {
-    let out = name.replace(/[^A-Za-z0-9_]/g, '_');
-    if (!/^[A-Za-z_]/.test(out)) out = `_${out}`;
-    return out;
-}
-
-function emitHeader(name: string): string {
-    return (
-        `// Auto-generated from standalone schema '${name}'. Do not edit.\n` +
-        `import { z } from 'zod/v4';\n\n`
-    );
-}
-
-function emitModule(name: string, expressionsByName: Record<string, string>, warnings: JsonSchemaToZodWarning[]): string {
-    const lines: string[] = [];
-    lines.push(emitHeader(name));
-
-    if (warnings.length > 0) {
-        const warningsName = `${toIdentifier(name)}ZodGenerationWarnings`;
-        lines.push(`export const ${warningsName} = ${JSON.stringify(warnings, null, 2)} as const;\n`);
-    }
-
-    const rootIdent = toIdentifier(name);
-    const defNames = Object.keys(expressionsByName)
-        .filter((schemaName) => schemaName !== name)
-        .sort((a, b) => a.localeCompare(b));
-
-    for (const schemaName of defNames) {
-        const ident = toIdentifier(schemaName);
-        if (!isValidIdentifier(ident)) {
-            throw new Error(`Invalid generated identifier for schema '${schemaName}': '${ident}'`);
-        }
-        const expr = expressionsByName[schemaName];
-        lines.push(`const ${ident}Schema: z.ZodTypeAny = z.lazy(() => ${expr});`);
-    }
-
-    lines.push('');
-
-    const rootExpr = expressionsByName[name];
-    lines.push(`export const ${rootIdent}Schema: z.ZodTypeAny = z.lazy(() => ${rootExpr});`);
-
-    return lines.join('\n') + '\n';
-}
-
-export function generateStandaloneZodModule(name: string, standaloneSchema: unknown): GeneratedZodModule {
-    const { expressionsByName, warnings } = jsonSchemaToZodExpressions(standaloneSchema, name);
-    return {
-        fileName: `${name}.ts`,
-        content: emitModule(name, expressionsByName, warnings),
-        warnings,
-    };
-}
-
-export function generateStandaloneZodBarrel(names: string[]): string {
-    const exports = names
-        .slice()
-        .sort((a, b) => a.localeCompare(b))
-        .map((name) => `export { ${toIdentifier(name)}Schema } from './${name}.js';`);
-    return `// Auto-generated barrel file. Do not edit.\n${exports.join('\n')}\n`;
-}

package/src/utils/timestampedResources.ts

@@ -1,42 +0,0 @@
-type JsonObject = Record<string, unknown>;
-
-type TimestampedResource = JsonObject & {
-    id: string;
-    resourceTypeHandle: string;
-    provenance: {
-        resourceProvenanceKind: 'genesis';
-    };
-    timestamp: string;
-    projection: unknown;
-};
-
-type GenerateTimestampedResourcesOptions = {
-    resourceTypeHandle: string;
-    getResourceId: (projection: unknown) => string;
-};
-
-const GENESIS_TIMESTAMP = '2025-11-30T00:00:00.000Z';
-
-export function generateTimestampedResources(
-    declarations: unknown[],
-    options: GenerateTimestampedResourcesOptions,
-): TimestampedResource[] {
-    return declarations.map((projection) => {
-        return createTimestampedResource(projection, options);
-    });
-}
-
-function createTimestampedResource(
-    projection: unknown,
-    options: GenerateTimestampedResourcesOptions,
-): TimestampedResource {
-    return {
-        id: options.getResourceId(projection),
-        resourceTypeHandle: options.resourceTypeHandle,
-        provenance: {
-            resourceProvenanceKind: 'genesis',
-        },
-        timestamp: GENESIS_TIMESTAMP,
-        projection,
-    };
-}