@toolproof-core/schema 1.0.1 → 1.0.2

package/src/scripts/normalizeAnchorsToPointers.ts

@@ -1,123 +1,123 @@
-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
+ * 
+ * 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);
+});

package/src/scripts/wrapResourceTypesWithResourceShells.ts

@@ -1,84 +1,84 @@
-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.
+ */
+
+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);
+});