@toolproof-core/schema 1.0.0

package/dist/scripts/generateDependencies.js

@@ -0,0 +1,106 @@
+import fs from "fs";
+import path from "path";
+import { getConfig } from "./_lib/config.js";
+function decodeJsonPointerSegment(segment) {
+    // JSON Pointer decoding: ~1 => / and ~0 => ~
+    return segment.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function collectRefs(node, out) {
+    if (Array.isArray(node)) {
+        for (const item of node)
+            collectRefs(item, out);
+        return;
+    }
+    if (!node || typeof node !== "object")
+        return;
+    const obj = node;
+    const ref = obj["$ref"];
+    if (typeof ref === "string")
+        out.add(ref);
+    for (const value of Object.values(obj)) {
+        collectRefs(value, out);
+    }
+}
+function resolveInternalRefToDefKey(ref, defKeys, anchorToDef) {
+    if (!ref.startsWith("#"))
+        return null;
+    // JSON Pointer: #/$defs/<Name>(/...)
+    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;
+    }
+    // Anchor ref: #AnchorName
+    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;
+}
+/**
+ * Pure function that generates a dependency map from a JSON Schema document.
+ *
+ * @param doc The source JSON Schema document
+ * @returns A record mapping definition names to their dependency lists
+ */
+function generateDependencyMapLogic(doc) {
+    const defs = doc?.$defs && typeof doc.$defs === "object" ? doc.$defs : {};
+    const defKeys = new Set(Object.keys(defs));
+    // Map anchors to $defs keys (useful if any anchor-style refs remain)
+    const anchorToDef = {};
+    for (const [defKey, defSchema] of Object.entries(defs)) {
+        if (!defSchema || typeof defSchema !== "object" || Array.isArray(defSchema))
+            continue;
+        const anchor = defSchema.$anchor;
+        if (typeof anchor === "string" && !(anchor in anchorToDef)) {
+            anchorToDef[anchor] = defKey;
+        }
+    }
+    const dependencyMap = {};
+    for (const [defKey, defSchema] of Object.entries(defs)) {
+        const refs = new Set();
+        collectRefs(defSchema, refs);
+        const deps = new Set();
+        for (const ref of refs) {
+            const depKey = resolveInternalRefToDefKey(ref, defKeys, anchorToDef);
+            if (!depKey)
+                continue;
+            if (depKey === defKey)
+                continue;
+            deps.add(depKey);
+        }
+        dependencyMap[defKey] = Array.from(deps);
+    }
+    return dependencyMap;
+}
+async function main() {
+    const config = getConfig();
+    const inPath = config.getOutputPath("Genesis.json");
+    const outPath = config.getDependencyMapPath();
+    if (!fs.existsSync(inPath)) {
+        console.error(`Genesis schema not found at ${inPath}. Run extractSchemas first.`);
+        process.exit(1);
+    }
+    try {
+        const raw = fs.readFileSync(inPath, "utf8");
+        const doc = JSON.parse(raw);
+        const dependencyMap = generateDependencyMapLogic(doc);
+        fs.mkdirSync(path.dirname(outPath), { recursive: true });
+        fs.writeFileSync(outPath, JSON.stringify(dependencyMap, null, 4), "utf8");
+        console.log(`Wrote dependency map to ${outPath}`);
+    }
+    catch (error) {
+        console.error(`Error generating dependency map: ${error.message}`);
+        process.exit(1);
+    }
+}
+main().catch((e) => {
+    console.error(e);
+    process.exit(1);
+});

package/dist/scripts/generateResourceShells.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/generateResourceShells.js

@@ -0,0 +1,91 @@
+import fs from 'fs';
+import path from 'path';
+import { getConfig } from './_lib/config.js';
+/**
+ * Generate Resource envelopes for all ResourceTypes defined in Genesis.json
+ *
+ * This script wraps each ResourceType definition (from $defs) with a Resource envelope
+ * that conforms to the Resource.nucleusSchema pattern defined in Genesis.json.
+ *
+ * For the top-level Genesis ResourceType, extractedData is set to {} to avoid
+ * duplicating the entire $defs object.
+ *
+ * Resource identities follow the pattern RESOURCE-{Name} where Name is the key
+ * from the $defs object. Genesis itself uses RESOURCE-Genesis.
+ *
+ * Usage: node ./dist/scripts/generateResourceEnvelopes.js
+ */
+/**
+ * Pure function to generate resource envelopes from a Genesis schema.
+ *
+ * @param genesis The Genesis schema object
+ * @returns A record mapping resource names to their envelopes
+ */
+function generateResourceEnvelopesLogic(genesis) {
+    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);
+    // Generate Resource envelopes
+    const resources = {};
+    // Genesis timestamp: 2025-11-30T00:00:00.000Z marks the genesis of ToolProof
+    const genesisTimestamp = '2025-11-30T00:00:00.000Z';
+    // First entry is Genesis itself with empty extractedData
+    resources['Genesis'] = {
+        identity: 'RESOURCE-Genesis',
+        resourceTypeRef: 'TYPE-ResourceType',
+        creationContext: {
+            resourceRoleRef: 'ROLE-Genesis',
+            executionRef: 'EXECUTION-Genesis'
+        },
+        kind: 'materialized',
+        timestamp: genesisTimestamp,
+        extractedData: {}
+    };
+    // Generate resources for all other $defs
+    defKeys.forEach((defName) => {
+        const defValue = defs[defName];
+        resources[defName] = {
+            identity: `RESOURCE-${defName}`,
+            resourceTypeRef: 'TYPE-ResourceType',
+            creationContext: {
+                resourceRoleRef: 'ROLE-Genesis',
+                executionRef: `EXECUTION-${defName}`
+            },
+            kind: 'materialized',
+            timestamp: genesisTimestamp,
+            extractedData: defValue
+        };
+    });
+    return resources;
+}
+async function main() {
+    const config = getConfig();
+    // Use normalized version with anchor refs rewritten to pointers
+    const genesisSourcePath = config.getNormalizedSourcePath();
+    const outputPath = path.join(config.getGeneratedResourcesDir(), '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 = generateResourceEnvelopesLogic(genesis);
+        // Ensure output directory exists
+        const outputDir = path.dirname(outputPath);
+        fs.mkdirSync(outputDir, { recursive: true });
+        // Write the generated resources file
+        fs.writeFileSync(outputPath, JSON.stringify(resources, null, 4) + '\n', 'utf-8');
+        console.log(`Generated ${Object.keys(resources).length} Resource envelopes -> ${outputPath}`);
+    }
+    catch (error) {
+        console.error(error.message);
+        process.exit(1);
+    }
+}
+main().catch((e) => {
+    console.error(e);
+    process.exit(1);
+});

package/dist/scripts/generateResourceTypeType.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/generateResourceTypeType.js

@@ -0,0 +1,93 @@
+import fs from 'fs';
+import { getConfig } from './_lib/config.js';
+/**
+ * Generate a typed Resource variant where `extractedData` is typed to a specific schema
+ * extracted under the configured output directory.
+ *
+ * Usage: node ./dist/scripts/generateResourceTypeType.js --name Job
+ */
+/**
+ * Pure function to generate the typed Resource D.TS content.
+ *
+ * @param name The name of the schema
+ * @returns The TypeScript D.TS file content
+ */
+function generateResourceTypeTypeLogic(name) {
+    const header = '// Auto-generated strict composite type. Do not edit.\n';
+    const ts = `import type { ResourceMetaBase, ${name} as ExtractedData } from './types.js';\n` +
+        `export type Resource_${name} = ResourceMetaBase & { extractedData: ExtractedData };\n`;
+    return header + ts;
+}
+async function main() {
+    const config = getConfig();
+    const { name } = parseArgs(process.argv.slice(2));
+    if (!name) {
+        console.error('Missing --name <SchemaBasename> argument');
+        process.exit(1);
+    }
+    const inPath = config.getOutputPath(`${name}.json`);
+    if (!fs.existsSync(inPath)) {
+        console.error(`Schema file not found: ${inPath}`);
+        process.exit(1);
+    }
+    // Basic validation against the expected shape of nucleusSchema.
+    const raw = fs.readFileSync(inPath, 'utf8');
+    let parsed = null;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (e) {
+        console.error(`Failed to parse JSON schema ${inPath}:`, e);
+        process.exit(1);
+    }
+    // Minimal checks that roughly match the nucleusSchema constraints used elsewhere.
+    if (parsed.$schema && parsed.$schema !== 'https://json-schema.org/draft/2020-12/schema') {
+        console.warn(`Warning: schema $schema is '${parsed.$schema}', expected draft 2020-12. Proceeding anyway.`);
+    }
+    if (parsed.type && parsed.type !== 'object') {
+        console.warn(`Warning: nucleusSchema usually has type: 'object' but this schema has type: '${parsed.type}'. Proceeding.`);
+    }
+    const tsContent = generateResourceTypeTypeLogic(name);
+    const jsContent = 'export {}\n';
+    // Output setup
+    const outName = `Resource_${name}.d.ts`;
+    const outJsName = `Resource_${name}.js`;
+    // Process src output
+    const outDir = config.getTypesSrcDir();
+    fs.mkdirSync(outDir, { recursive: true });
+    const outPath = config.getTypesSrcPath(outName);
+    const outJsPath = config.getTypesSrcPath(outJsName);
+    fs.writeFileSync(outPath, tsContent, 'utf8');
+    console.log(`Wrote ${outPath}`);
+    if (!fs.existsSync(outJsPath)) {
+        fs.writeFileSync(outJsPath, jsContent, 'utf8');
+        console.log(`Wrote ${outJsPath}`);
+    }
+    // Process dist output
+    const distLibDir = config.getTypesDistDir();
+    fs.mkdirSync(distLibDir, { recursive: true });
+    const distDtsPath = config.getTypesDistPath(outName);
+    const distJsPath = config.getTypesDistPath(outJsName);
+    fs.writeFileSync(distDtsPath, tsContent, 'utf8');
+    fs.writeFileSync(distJsPath, jsContent, 'utf8');
+    console.log(`Wrote ${distDtsPath}`);
+    console.log(`Wrote ${distJsPath}`);
+}
+function parseArgs(args) {
+    let name;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--name') {
+            name = args[i + 1];
+            i++;
+        }
+        else if (a.startsWith('--name=')) {
+            name = a.split('=')[1];
+        }
+    }
+    return { name };
+}
+main().catch((e) => {
+    console.error(e);
+    process.exit(1);
+});

package/dist/scripts/generateSchemaShims.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/generateSchemaShims.js

@@ -0,0 +1,105 @@
+import fs from 'fs';
+import path from 'path';
+import { getConfig } from './_lib/config.js';
+/**
+ * Generate TypeScript shim files for all JSON schemas and resources
+ *
+ * Creates .ts files that import and re-export .json files using
+ * the JSON import assertion syntax. This enables proper dependency resolution
+ * and type inference when importing schemas in TypeScript.
+ *
+ * Generates shims for:
+ * - src/genesis/generated/schemas/*.json (schema files)
+ * - src/genesis/generated/resources/*.json (resource envelope files)
+ *
+ * Usage: node ./dist/scripts/generateSchemaShims.js
+ */
+/**
+ * Pure function to generate the content of a TypeScript shim file.
+ *
+ * @param jsonFile The name of the JSON file to import
+ * @param variableName The name of the variable to use for the import
+ * @returns The TypeScript file content
+ */
+function generateShimContent(jsonFile, variableName) {
+    return `import ${variableName} from './${jsonFile}' with { type: 'json' };\nexport default ${variableName};\n`;
+}
+/**
+ * Pure function to map a list of JSON files to their corresponding TypeScript shim files and contents.
+ *
+ * @param jsonFiles List of JSON filenames
+ * @param variableName The variable name to use in the shim
+ * @returns A record mapping TS filenames to their contents
+ */
+function getShimsForFiles(jsonFiles, variableName) {
+    const shims = {};
+    for (const jsonFile of jsonFiles) {
+        const baseName = path.basename(jsonFile, '.json');
+        const tsFile = `${baseName}.ts`;
+        shims[tsFile] = generateShimContent(jsonFile, variableName);
+    }
+    return shims;
+}
+async function main() {
+    const config = getConfig();
+    const schemasDir = config.getOutputDir();
+    const resourcesDir = config.getGeneratedResourcesDir();
+    const generatedResourceTypesDir = config.getNormalizedDir();
+    let totalCount = 0;
+    // Process schemas directory
+    if (fs.existsSync(schemasDir)) {
+        const files = fs.readdirSync(schemasDir);
+        const jsonFiles = files.filter(f => f.endsWith('.json') && !f.startsWith('.'));
+        const shims = getShimsForFiles(jsonFiles, 'schema');
+        for (const [tsFile, content] of Object.entries(shims)) {
+            const tsPath = path.join(schemasDir, tsFile);
+            fs.writeFileSync(tsPath, content, 'utf-8');
+            console.log(`Generated ${tsFile} in ${schemasDir}`);
+            totalCount++;
+        }
+        console.log(`Generated ${jsonFiles.length} TypeScript schema shims in ${schemasDir}`);
+    }
+    else {
+        console.warn(`Schemas directory not found at ${schemasDir}`);
+    }
+    // Process resources directory
+    if (fs.existsSync(resourcesDir)) {
+        const files = fs.readdirSync(resourcesDir);
+        const jsonFiles = files.filter(f => f.endsWith('.json') && !f.startsWith('.'));
+        const shims = getShimsForFiles(jsonFiles, 'resources');
+        for (const [tsFile, content] of Object.entries(shims)) {
+            const tsPath = path.join(resourcesDir, tsFile);
+            fs.writeFileSync(tsPath, content, 'utf-8');
+            console.log(`Generated ${tsFile} in ${resourcesDir}`);
+            totalCount++;
+        }
+        console.log(`Generated ${jsonFiles.length} TypeScript resource shims in ${resourcesDir}`);
+    }
+    else {
+        console.warn(`Resources directory not found at ${resourcesDir}`);
+    }
+    // Genesis (normalized) shim
+    try {
+        const genesisJsonPath = config.getNormalizedSourcePath();
+        if (fs.existsSync(genesisJsonPath)) {
+            fs.mkdirSync(generatedResourceTypesDir, { recursive: true });
+            const tsFile = 'Genesis.ts';
+            const content = generateShimContent('Genesis.json', 'schema');
+            const tsPath = path.join(generatedResourceTypesDir, tsFile);
+            fs.writeFileSync(tsPath, content, 'utf-8');
+            console.log(`Generated ${tsFile} in ${generatedResourceTypesDir}`);
+            totalCount++;
+        }
+        else {
+            console.warn(`Genesis source JSON not found at ${genesisJsonPath}; skipping Genesis.ts shim`);
+        }
+    }
+    catch (e) {
+        console.warn('Failed to generate Genesis.ts shim:', e);
+    }
+    console.log(`Generated ${totalCount} total TypeScript shims`);
+}
+main().catch((e) => {
+    console.error(e);
+    process.exit(1);
+});

package/dist/scripts/generateTypes.d.ts

@@ -0,0 +1 @@
+export {};