@toolproof-core/schema 1.0.0

package/src/scripts/generateDependencies.ts

@@ -0,0 +1,120 @@
+import fs from "fs";
+import path from "path";
+import { getConfig } from "./_lib/config.js";
+
+type JSONValue = null | boolean | number | string | JSONValue[] | { [k: string]: JSONValue };
+
+function decodeJsonPointerSegment(segment: string): string {
+  // JSON Pointer decoding: ~1 => / and ~0 => ~
+  return segment.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+
+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);
+  }
+}
+
+function resolveInternalRefToDefKey(ref: string, defKeys: Set<string>, anchorToDef: Record<string, string>): string | null {
+  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: any): Record<string, string[]> {
+  const defs: Record<string, JSONValue> = 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: Record<string, string> = {};
+  for (const [defKey, defSchema] of Object.entries(defs)) {
+    if (!defSchema || typeof defSchema !== "object" || Array.isArray(defSchema)) continue;
+    const anchor = (defSchema as any).$anchor;
+    if (typeof anchor === "string" && !(anchor in anchorToDef)) {
+      anchorToDef[anchor] = defKey;
+    }
+  }
+
+  const dependencyMap: Record<string, string[]> = {};
+
+  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) 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: any) {
+    console.error(`Error generating dependency map: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});

package/src/scripts/generateResourceShells.ts

@@ -0,0 +1,105 @@
+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: 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);
+
+    // Generate Resource envelopes
+    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';
+
+    // 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: any) {
+        console.error(error.message);
+        process.exit(1);
+    }
+}
+
+main().catch((e) => {
+    console.error(e);
+    process.exit(1);
+});

package/src/scripts/generateResourceTypeType.ts

@@ -0,0 +1,110 @@
+import fs from 'fs';
+import path from 'path';
+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: string): string {
+    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: any = 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: string[]): { name?: string } {
+    let name: string | undefined;
+    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/src/scripts/generateSchemaShims.ts

@@ -0,0 +1,115 @@
+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: string, variableName: string): string {
+    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: 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;
+}
+
+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);
+});