@toolproof-core/schema 1.0.3 → 1.0.5

package/src/scripts/normalizeAnchorsToPointers.ts

@@ -1,123 +1,141 @@
-import fs from 'fs';
-import path from 'path';
-import { getConfig } from './_lib/config.js';
-
-/**
- * Rewrite anchor-style references to JSON Pointer references in Genesis.json
- * 
- * Converts #AnchorName to #/$defs/AnchorName for compatibility with strict
- * JSON Schema validators and downstream tooling. This normalization step runs
- * before both schema extraction and resource envelope generation.
- * 
- * The rewritten file is saved under src/genesis/generated/resourceTypes/Genesis.json
- * for use by other scripts.
- * 
- * Usage: node ./dist/scripts/normalizeAnchorsToPointers.js
- */
-
-type JSONValue = null | boolean | number | string | JSONValue[] | { [k: string]: JSONValue };
-
-/**
- * Pure function to rewrite anchor-style references to JSON Pointer references.
- * Converts #AnchorName to #/$defs/AnchorName for compatibility with strict JSON Schema validators.
- * 
- * This function works on a schema object that has $defs at its top level.
- * @param input The schema object to process
- * @returns A new schema object with rewritten references
- */
-function normalizeAnchorsToPointersToPointers(input: any): any {
-    if (!input || typeof input !== "object") return input;
-
-    // Deep clone the input to ensure the function is pure (no side effects on input)
-    const root = JSON.parse(JSON.stringify(input));
-
-    // Build a map of anchors to their definition names
-    const defs: Record<string, any> = root.$defs && typeof root.$defs === "object" ? root.$defs : {};
-    const anchorToDef: Record<string, string> = {};
-
-    // For Genesis structure: each def is a Type envelope with nucleusSchema.$anchor
-    for (const [defName, defValue] of Object.entries(defs)) {
-        if (!defValue || typeof defValue !== "object") continue;
-
-        // Check if this is a Type envelope (has nucleusSchema property)
-        const nucleusSchema = (defValue as any).nucleusSchema;
-        if (nucleusSchema && typeof nucleusSchema === "object") {
-            // Look for $anchor inside the nucleusSchema
-            const anchor = nucleusSchema.$anchor;
-            if (typeof anchor === "string" && !anchorToDef[anchor]) {
-                anchorToDef[anchor] = defName;
-            }
-        } else {
-            // Fallback: check for $anchor at the def level (non-envelope case)
-            const anchor = (defValue as any).$anchor;
-            if (typeof anchor === "string" && !anchorToDef[anchor]) {
-                anchorToDef[anchor] = defName;
-            }
-        }
-    }
-
-    // Walk the entire tree and rewrite anchor refs to pointer refs
-    function walk(node: any): void {
-        if (Array.isArray(node)) {
-            for (const item of node) walk(item);
-            return;
-        }
-        if (!node || typeof node !== "object") return;
-
-        // Rewrite $ref if it's an anchor-style reference
-        if (typeof node.$ref === "string") {
-            const ref: string = node.$ref;
-            // Match anchor refs: starts with # but not #/ (JSON Pointer syntax)
-            if (ref.startsWith("#") && !ref.startsWith("#/")) {
-                const anchor = ref.slice(1);
-                const defName = anchorToDef[anchor];
-                if (defName) {
-                    node.$ref = `#/$defs/${defName}`;
-                }
-            }
-        }
-
-        // Recursively walk all properties
-        for (const val of Object.values(node)) {
-            walk(val);
-        }
-    }
-
-    walk(root);
-    return root;
-}
-
-async function main() {
-    const config = getConfig();
-    const genesisSourcePath = config.getSourcePath();
-
-    // Create a generated/normalized version (anchor refs rewritten to pointers)
-    const normalizedPath = config.getNormalizedSourcePath();
-
-    if (!fs.existsSync(genesisSourcePath)) {
-        console.error(`Genesis source file not found at ${genesisSourcePath}`);
-        process.exit(1);
-    }
-
-    const raw = fs.readFileSync(genesisSourcePath, 'utf-8');
-    const genesis = JSON.parse(raw);
-
-    // Validate structure
-    if (!genesis.nucleusSchema || !genesis.nucleusSchema.$defs) {
-        console.error('Genesis.json must have nucleusSchema.$defs');
-        process.exit(1);
-    }
-
-    // Rewrite anchors in the nucleusSchema (pure function call)
-    genesis.nucleusSchema = normalizeAnchorsToPointersToPointers(genesis.nucleusSchema);
-
-    // Write normalized version
-    fs.mkdirSync(path.dirname(normalizedPath), { recursive: true });
-    fs.writeFileSync(normalizedPath, JSON.stringify(genesis, null, 4), 'utf-8');
-    console.log(`Wrote normalized Genesis with pointer refs to ${normalizedPath}`);
-}
-
-main().catch((e) => {
-    console.error(e);
-    process.exit(1);
-});
+import fs from 'fs';
+import path from 'path';
+import { getConfig } from './_lib/config.js';
+
+/*
+    * Rewrite anchor-style references to JSON Pointer references in Genesis.json.
+    * We also strip all $anchor fields from the output since they are no longer needed after rewriting refs.
+*/
+
+// PURE: Remove all `$anchor` keys from a schema tree without rewriting refs.
+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;
+}
+
+// PURE: Rewrite anchor-style `$ref` strings (`#Anchor`) into JSON Pointer refs (`#/$defs/DefName`).
+function normalizeAnchorsToPointers(input: any): any {
+    if (!input || typeof input !== "object") return input;
+
+    // Deep clone the input to ensure the function is pure (no side effects on input)
+    const root = JSON.parse(JSON.stringify(input));
+
+    // Build a map of anchors to their definition names
+    const defs: Record<string, any> = root.$defs && typeof root.$defs === "object" ? root.$defs : {};
+    const anchorToDef: Record<string, string> = {};
+
+    // For Genesis structure: each def is a Type envelope with nucleusSchema.$anchor
+    for (const [defName, defValue] of Object.entries(defs)) {
+        if (!defValue || typeof defValue !== "object") continue;
+
+        // Check if this is a Type envelope (has nucleusSchema property)
+        const nucleusSchema = (defValue as any).nucleusSchema;
+        if (nucleusSchema && typeof nucleusSchema === "object") {
+            // Look for $anchor inside the nucleusSchema
+            const anchor = nucleusSchema.$anchor;
+            if (typeof anchor === "string" && !anchorToDef[anchor]) {
+                anchorToDef[anchor] = defName;
+            }
+        } else {
+            // Fallback: check for $anchor at the def level (non-envelope case)
+            const anchor = (defValue as any).$anchor;
+            if (typeof anchor === "string" && !anchorToDef[anchor]) {
+                anchorToDef[anchor] = defName;
+            }
+        }
+    }
+
+    // Walk the entire tree and rewrite anchor refs to pointer refs
+    function walk(node: any): void {
+        if (Array.isArray(node)) {
+            for (const item of node) walk(item);
+            return;
+        }
+        if (!node || typeof node !== "object") return;
+
+        // Rewrite $ref if it's an anchor-style reference
+        if (typeof node.$ref === "string") {
+            const ref: string = node.$ref;
+            // Match anchor refs: starts with # but not #/ (JSON Pointer syntax)
+            if (ref.startsWith("#") && !ref.startsWith("#/")) {
+                const anchor = ref.slice(1);
+                const defName = anchorToDef[anchor];
+                if (defName) {
+                    node.$ref = `#/$defs/${defName}`;
+                }
+            }
+        }
+
+        // Recursively walk all properties
+        for (const val of Object.values(node)) {
+            walk(val);
+        }
+    }
+
+    walk(root);
+    return root;
+}
+
+// IMPURE: Script entrypoint (config + filesystem I/O + console + process exit code).
+function main() {
+    try {
+        const config = getConfig();
+        const genesisSourcePath = config.getSourcePath();
+
+        // Create a generated/normalized version (anchor refs rewritten to pointers)
+        const normalizedPath = config.getNormalizedSourcePath();
+
+        if (!fs.existsSync(genesisSourcePath)) {
+            throw new Error(`Genesis source file not found at ${genesisSourcePath}`);
+        }
+
+        const raw = fs.readFileSync(genesisSourcePath, 'utf-8');
+        const genesis = JSON.parse(raw);
+
+        // Validate structure
+        if (!genesis.nucleusSchema || !genesis.nucleusSchema.$defs) {
+            throw new Error('Genesis.json must have nucleusSchema.$defs');
+        }
+
+        // Rewrite anchors in the nucleusSchema (pure function call)
+        genesis.nucleusSchema = normalizeAnchorsToPointers(genesis.nucleusSchema);
+
+        // Strip $anchor fields from the schemas (pure function call)
+        genesis.nucleusSchema = stripAnchors(genesis.nucleusSchema);
+
+        // Write normalized version
+        fs.mkdirSync(path.dirname(normalizedPath), { recursive: true });
+        fs.writeFileSync(normalizedPath, JSON.stringify(genesis, null, 4), 'utf-8');
+        console.log(`Wrote normalized Genesis with pointer refs to ${normalizedPath}`);
+    } catch (e) {
+        console.error(e);
+        process.exitCode = 1;
+    }
+}
+
+main();

package/src/scripts/wrapResourceTypesWithResourceShells.ts

@@ -1,84 +1,82 @@
-import fs from 'fs';
-import path from 'path';
-import { getConfig } from './_lib/config.js';
-
-/**
- * Wrap each ResourceType definition (from Genesis.nucleusSchema.$defs) with a Resource shell
- * that conforms to the Resource.nucleusSchema pattern defined in Genesis.json.
- */
-
-function generateResourceShellLogic(genesis: any): Record<string, any> {
-    if (!genesis.nucleusSchema || !genesis.nucleusSchema.$defs) {
-        throw new Error('Genesis.json must have nucleusSchema.$defs');
-    }
-
-    const defs = genesis.nucleusSchema.$defs;
-    const defKeys = Object.keys(defs);
-
-    const resources: Record<string, any> = {};
-
-    // Genesis timestamp: 2025-11-30T00:00:00.000Z marks the genesis of ToolProof
-    const genesisTimestamp = '2025-11-30T00:00:00.000Z';
-
-    resources['Genesis'] = {
-        identity: 'RESOURCE-Genesis',
-        resourceTypeHandle: 'TYPE-ResourceType',
-        creationContext: {
-            resourceRoleHandle: 'ROLE-Genesis',
-            jobStepHandle: 'JOB_STEP-Genesis'
-        },
-        kind: 'materialized',
-        timestamp: genesisTimestamp,
-        nucleus: {}
-    };
-
-    defKeys.forEach((defName) => {
-        const defValue = defs[defName];
-
-        resources[defName] = {
-            identity: `RESOURCE-${defName}`,
-            resourceTypeHandle: 'TYPE-ResourceType',
-            creationContext: {
-                resourceRoleHandle: 'ROLE-Genesis',
-                jobStepHandle: `JOB_STEP-${defName}`
-            },
-            kind: 'materialized',
-            timestamp: genesisTimestamp,
-            nucleus: defValue
-        };
-    });
-
-    return resources;
-}
-
-async function main() {
-    const config = getConfig();
-    const genesisSourcePath = config.getNormalizedSourcePath();
-    const outputPath = path.join(config.getResourcesDir(), 'Genesis.json');
-
-    if (!fs.existsSync(genesisSourcePath)) {
-        console.error(`Genesis source file not found at ${genesisSourcePath}`);
-        process.exit(1);
-    }
-
-    const raw = fs.readFileSync(genesisSourcePath, 'utf-8');
-    const genesis = JSON.parse(raw);
-
-    try {
-        const resources = generateResourceShellLogic(genesis);
-
-        const outputDir = path.dirname(outputPath);
-        fs.mkdirSync(outputDir, { recursive: true });
-
-        fs.writeFileSync(outputPath, JSON.stringify(resources, null, 4) + '\n', 'utf-8');
-        console.log(`Generated ${Object.keys(resources).length} Resource envelopes -> ${outputPath}`);
-    } catch (error: any) {
-        console.error(error.message);
-        process.exit(1);
-    }
-}
-
-main().catch((e) => {
-    console.error(e);
-    process.exit(1);
-});
+import fs from 'fs';
+import path from 'path';
+import { getConfig } from './_lib/config.js';
+
+/**
+ * Wrap each ResourceType definition (from Genesis.nucleusSchema.$defs) with a Resource shell
+ * that conforms to the Resource.nucleusSchema pattern defined in Genesis.json.
+ */
+
+// PURE: Build Resource shell envelopes for each $defs entry (no I/O, no mutation of inputs).
+function generateResourceShellLogic(genesis: any): Record<string, any> {
+    if (!genesis.nucleusSchema || !genesis.nucleusSchema.$defs) {
+        throw new Error('Genesis.json must have nucleusSchema.$defs');
+    }
+
+    const defs = genesis.nucleusSchema.$defs;
+    const defKeys = Object.keys(defs);
+
+    const resources: Record<string, any> = {};
+
+    // Genesis timestamp: 2025-11-30T00:00:00.000Z marks the genesis of ToolProof
+    const genesisTimestamp = '2025-11-30T00:00:00.000Z';
+
+    resources['Genesis'] = {
+        identity: 'RESOURCE-Genesis',
+        resourceTypeHandle: 'TYPE-ResourceType',
+        creationContext: {
+            resourceRoleHandle: 'ROLE-Genesis',
+            jobStepHandle: 'JOB_STEP-Genesis'
+        },
+        kind: 'materialized',
+        timestamp: genesisTimestamp,
+        nucleus: {}
+    };
+
+    defKeys.forEach((defName) => {
+        const defValue = defs[defName];
+
+        resources[defName] = {
+            identity: `RESOURCE-${defName}`,
+            resourceTypeHandle: 'TYPE-ResourceType',
+            creationContext: {
+                resourceRoleHandle: 'ROLE-Genesis',
+                jobStepHandle: `JOB_STEP-${defName}`
+            },
+            kind: 'materialized',
+            timestamp: genesisTimestamp,
+            nucleus: defValue
+        };
+    });
+
+    return resources;
+}
+
+// IMPURE: Script entrypoint (config + filesystem I/O + console + process exit code).
+function main() {
+    try {
+        const config = getConfig();
+        const genesisSourcePath = config.getNormalizedSourcePath();
+        const outputPath = path.join(config.getResourcesDir(), 'Genesis.json');
+
+        if (!fs.existsSync(genesisSourcePath)) {
+            throw new Error(`Genesis source file not found at ${genesisSourcePath}`);
+        }
+
+        const raw = fs.readFileSync(genesisSourcePath, 'utf-8');
+        const genesis = JSON.parse(raw);
+
+        const resources = generateResourceShellLogic(genesis);
+
+        const outputDir = path.dirname(outputPath);
+        fs.mkdirSync(outputDir, { recursive: true });
+
+        fs.writeFileSync(outputPath, JSON.stringify(resources, null, 4) + '\n', 'utf-8');
+        console.log(`Generated ${Object.keys(resources).length} Resource envelopes -> ${outputPath}`);
+    } catch (error: any) {
+        console.error(error?.message ?? error);
+        process.exitCode = 1;
+    }
+}
+
+main();