@toolproof-core/genesis 1.0.50 → 1.0.52

package/src/utils/coreProjection.ts

@@ -1,53 +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);
+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 +1,71 @@
-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;
+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 +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));
+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 +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;
+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;
 }