@toolproof-core/genesis 1.0.51 → 1.0.53

package/dist/src/utils/constantsAndMappings.d.ts

@@ -1,17 +1,35 @@
 type JSONValue = null | boolean | number | string | JSONValue[] | {
     [k: string]: JSONValue;
 };
+type HandleRecord = {
+    handle?: unknown;
+};
+type HandleRecordByName = Record<string, HandleRecord>;
+type ToolRecord = HandleRecord & {
+    isTemplate?: unknown;
+    templateToolHandle?: unknown;
+    instantiationRoleSpec?: unknown;
+    roleSpec?: unknown;
+};
+type ToolRecordByName = Record<string, ToolRecord>;
 export type GeneratedConstants = {
     Names: Record<string, string>;
+    Handles: {
+        ResourceTypes: Record<string, string>;
+        Tools: Record<string, string>;
+    };
+    ToolRoleNames: Record<string, Record<string, string>>;
     Enums: Record<string, Record<string, string>>;
 };
 export type GeneratedMappings = {
-    HandleNameToPrefix: Record<string, string>;
+    IdentifierNameToPrefix: Record<string, string>;
 };
 export declare function extractHandlePrefixes(schema: unknown): Record<string, string>;
 export declare function extractSubschemaNames(schema: unknown): Record<string, string>;
 export declare function extractEnums(schema: unknown): Record<string, Record<string, string>>;
-export declare function extractGeneratedConstantsAndMappings(schema: JSONValue): {
+export declare function extractHandles(records: HandleRecordByName): Record<string, string>;
+export declare function extractToolRoleNames(tools: ToolRecordByName): Record<string, Record<string, string>>;
+export declare function extractGeneratedConstantsAndMappings(schema: JSONValue, resourceTypeShells: HandleRecordByName, tools: ToolRecordByName): {
     CONSTANTS: GeneratedConstants;
     MAPPINGS: GeneratedMappings;
 };

package/dist/src/utils/constantsAndMappings.js

@@ -78,17 +78,96 @@ export function extractEnums(schema) {
     }
     return out;
 }
-export function extractGeneratedConstantsAndMappings(schema) {
+function toHandleConstantKey(handle) {
+    return handle.replace(/[^A-Za-z0-9]+/g, '_');
+}
+export function extractHandles(records) {
+    const recordEntries = Object.entries(records);
+    recordEntries.sort(([a], [b]) => a.localeCompare(b));
+    const out = {};
+    for (const [, record] of recordEntries) {
+        if (!record || typeof record !== 'object')
+            continue;
+        if (typeof record.handle !== 'string')
+            continue;
+        if (!record.handle || /[\n\r`]/.test(record.handle))
+            continue;
+        out[toHandleConstantKey(record.handle)] = record.handle;
+    }
+    return out;
+}
+function isPlainObject(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function extractRoleNameMap(roleSpec) {
+    if (!isPlainObject(roleSpec)) {
+        return {};
+    }
+    const out = {};
+    const groups = [
+        roleSpec.inputRoleValueByName,
+        roleSpec.outputRoleValueByName,
+    ];
+    for (const group of groups) {
+        if (!isPlainObject(group)) {
+            continue;
+        }
+        const entries = Object.keys(group).sort((a, b) => a.localeCompare(b));
+        for (const roleName of entries) {
+            if (!roleName || /[\n\r`]/.test(roleName)) {
+                continue;
+            }
+            out[roleName] = roleName;
+        }
+    }
+    return out;
+}
+function isCanonicalToolRecord(tool) {
+    if (tool.isTemplate === true) {
+        return true;
+    }
+    return tool.isTemplate === false && tool.templateToolHandle === undefined;
+}
+export function extractToolRoleNames(tools) {
+    const toolEntries = Object.values(tools)
+        .filter((tool) => isPlainObject(tool))
+        .filter((tool) => typeof tool.handle === 'string' && !!tool.handle)
+        .sort((a, b) => String(a.handle).localeCompare(String(b.handle)));
+    const out = {};
+    for (const tool of toolEntries) {
+        if (!isCanonicalToolRecord(tool)) {
+            continue;
+        }
+        const roleSpec = tool.isTemplate === true
+            ? tool.instantiationRoleSpec
+            : tool.roleSpec;
+        const roleNameMap = extractRoleNameMap(roleSpec);
+        if (Object.keys(roleNameMap).length === 0) {
+            continue;
+        }
+        out[toHandleConstantKey(tool.handle)] = roleNameMap;
+    }
+    return out;
+}
+export function extractGeneratedConstantsAndMappings(schema, resourceTypeShells, tools) {
     const names = extractSubschemaNames(schema);
+    const resourceTypeHandles = extractHandles(resourceTypeShells);
+    const toolHandles = extractHandles(tools);
+    const toolRoleNames = extractToolRoleNames(tools);
     const enums = extractEnums(schema);
     const handlePrefixes = extractHandlePrefixes(schema);
     return {
         CONSTANTS: {
             Names: names,
+            Handles: {
+                ResourceTypes: resourceTypeHandles,
+                Tools: toolHandles,
+            },
+            ToolRoleNames: toolRoleNames,
             Enums: enums,
         },
         MAPPINGS: {
-            HandleNameToPrefix: handlePrefixes,
+            IdentifierNameToPrefix: handlePrefixes,
         },
     };
 }
@@ -111,6 +190,9 @@ function renderTsKey(key) {
 }
 export function renderConstantsTs(constants) {
     const nameKeys = Object.keys(constants.Names).sort((a, b) => a.localeCompare(b));
+    const resourceTypeHandleKeys = Object.keys(constants.Handles.ResourceTypes).sort((a, b) => a.localeCompare(b));
+    const toolHandleKeys = Object.keys(constants.Handles.Tools).sort((a, b) => a.localeCompare(b));
+    const toolRoleNameKeys = Object.keys(constants.ToolRoleNames).sort((a, b) => a.localeCompare(b));
     const enumKeys = Object.keys(constants.Enums).sort((a, b) => a.localeCompare(b));
     const lines = [];
     lines.push('const CONSTANTS = {');
@@ -120,6 +202,32 @@ export function renderConstantsTs(constants) {
         lines.push(`        ${renderTsKey(key)}: ${renderTsStringLiteral(value)},`);
     }
     lines.push('    },');
+    lines.push('    Handles: {');
+    lines.push('        ResourceTypes: {');
+    for (const key of resourceTypeHandleKeys) {
+        const value = constants.Handles.ResourceTypes[key] ?? '';
+        lines.push(`            ${renderTsKey(key)}: ${renderTsStringLiteral(value)},`);
+    }
+    lines.push('        },');
+    lines.push('        Tools: {');
+    for (const key of toolHandleKeys) {
+        const value = constants.Handles.Tools[key] ?? '';
+        lines.push(`            ${renderTsKey(key)}: ${renderTsStringLiteral(value)},`);
+    }
+    lines.push('        },');
+    lines.push('    },');
+    lines.push('    ToolRoleNames: {');
+    for (const toolKey of toolRoleNameKeys) {
+        const roleNames = constants.ToolRoleNames[toolKey] ?? {};
+        const roleKeys = Object.keys(roleNames).sort((a, b) => a.localeCompare(b));
+        lines.push(`        ${renderTsKey(toolKey)}: {`);
+        for (const roleKey of roleKeys) {
+            const value = roleNames[roleKey] ?? '';
+            lines.push(`            ${renderTsKey(roleKey)}: ${renderTsStringLiteral(value)},`);
+        }
+        lines.push('        },');
+    }
+    lines.push('    },');
     lines.push('    Enums: {');
     for (const key of enumKeys) {
         const members = constants.Enums[key] ?? {};
@@ -138,12 +246,12 @@ export function renderConstantsTs(constants) {
     return lines.join('\n');
 }
 export function renderMappingsTs(mappings) {
-    const handleKeys = Object.keys(mappings.HandleNameToPrefix).sort((a, b) => a.localeCompare(b));
+    const handleKeys = Object.keys(mappings.IdentifierNameToPrefix).sort((a, b) => a.localeCompare(b));
     const lines = [];
     lines.push('const MAPPINGS = {');
-    lines.push('    HandleNameToPrefix: {');
+    lines.push('    IdentifierNameToPrefix: {');
     for (const key of handleKeys) {
-        const value = mappings.HandleNameToPrefix[key] ?? '';
+        const value = mappings.IdentifierNameToPrefix[key] ?? '';
         lines.push(`        ${renderTsKey(key)}: ${renderTsStringLiteral(value)},`);
     }
     lines.push('    },');

package/generated-src/lookups/constants.ts

@@ -92,6 +92,73 @@ const CONSTANTS = {
         UnthreadedToolStepPathSpec: 'UnthreadedToolStepPathSpec',
         WhileStep: 'WhileStep',
     },
+    Handles: {
+        ResourceTypes: {
+            TYPE_Boolean: 'TYPE-Boolean',
+            TYPE_Error: 'TYPE-Error',
+            TYPE_Goal: 'TYPE-Goal',
+            TYPE_Natural: 'TYPE-Natural',
+            TYPE_Resource: 'TYPE-Resource',
+            TYPE_ResourceType: 'TYPE-ResourceType',
+            TYPE_Strategy: 'TYPE-Strategy',
+            TYPE_StrategyTrace: 'TYPE-StrategyTrace',
+            TYPE_Suite: 'TYPE-Suite',
+            TYPE_Tool: 'TYPE-Tool',
+        },
+        Tools: {
+            TOOL_Add: 'TOOL-Add',
+            TOOL_BooleanIdentity: 'TOOL-BooleanIdentity',
+            TOOL_Divide: 'TOOL-Divide',
+            TOOL_Double: 'TOOL-Double',
+            TOOL_Identity: 'TOOL-Identity',
+            TOOL_LessThan: 'TOOL-LessThan',
+            TOOL_Multiply: 'TOOL-Multiply',
+            TOOL_NaturalAdd: 'TOOL-NaturalAdd',
+            TOOL_NaturalDivide: 'TOOL-NaturalDivide',
+            TOOL_NaturalDouble: 'TOOL-NaturalDouble',
+            TOOL_NaturalIdentity: 'TOOL-NaturalIdentity',
+            TOOL_NaturalLessThan: 'TOOL-NaturalLessThan',
+            TOOL_NaturalMultiply: 'TOOL-NaturalMultiply',
+            TOOL_NaturalSubtract: 'TOOL-NaturalSubtract',
+            TOOL_Subtract: 'TOOL-Subtract',
+        },
+    },
+    ToolRoleNames: {
+        TOOL_Add: {
+            AddendOne: 'AddendOne',
+            AddendTwo: 'AddendTwo',
+            Sum: 'Sum',
+        },
+        TOOL_Divide: {
+            Dividend: 'Dividend',
+            Divisor: 'Divisor',
+            Quotient: 'Quotient',
+            Remainder: 'Remainder',
+        },
+        TOOL_Double: {
+            Doubled: 'Doubled',
+            N: 'N',
+        },
+        TOOL_Identity: {
+            In: 'In',
+            Out: 'Out',
+        },
+        TOOL_LessThan: {
+            LessThanDecision: 'LessThanDecision',
+            LessThanSource: 'LessThanSource',
+            LessThanTarget: 'LessThanTarget',
+        },
+        TOOL_Multiply: {
+            Multiplicand: 'Multiplicand',
+            Multiplier: 'Multiplier',
+            Product: 'Product',
+        },
+        TOOL_Subtract: {
+            Difference: 'Difference',
+            Minuend: 'Minuend',
+            Subtrahend: 'Subtrahend',
+        },
+    },
     Enums: {
         ContainerKind: {
             scalar: 'scalar',

package/generated-src/lookups/mappings.ts

@@ -1,5 +1,5 @@
 const MAPPINGS = {
-    HandleNameToPrefix: {
+    IdentifierNameToPrefix: {
         GoalHandle: 'GOAL-',
         ResourceId: 'RESOURCE-',
         ResourceTypeHandle: 'TYPE-',

package/generated-src/metadata/Core.json

@@ -1422,18 +1422,6 @@
                             "name": "src",
                             "path": "packages/lib/src",
                             "children": [
-                                {
-                                    "kind": "directory",
-                                    "name": "artifacts",
-                                    "path": "packages/lib/src/artifacts",
-                                    "children": [
-                                        {
-                                            "kind": "file",
-                                            "name": "artifacts.ts",
-                                            "path": "packages/lib/src/artifacts/artifacts.ts"
-                                        }
-                                    ]
-                                },
                                 {
                                     "kind": "directory",
                                     "name": "integrations",
@@ -1468,6 +1456,18 @@
                                         }
                                     ]
                                 },
+                                {
+                                    "kind": "directory",
+                                    "name": "lookups",
+                                    "path": "packages/lib/src/lookups",
+                                    "children": [
+                                        {
+                                            "kind": "file",
+                                            "name": "lookups.ts",
+                                            "path": "packages/lib/src/lookups/lookups.ts"
+                                        }
+                                    ]
+                                },
                                 {
                                     "kind": "directory",
                                     "name": "types",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolproof-core/genesis",
-  "version": "1.0.51",
+  "version": "1.0.53",
   "description": "Core ToolProof ontology, schemas, declarations, implementations, and generated type artifacts.",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -34,6 +34,7 @@
   },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
+    "update-and-build": "pnpm run update && pnpm run build",
     "build": "tsc -b",
     "build:scripts": "tsc -p tsconfig.scripts.json",
     "normalizeAnchorsToPointers": "node ./dist/scripts/normalizeAnchorsToPointers.js",

package/src/utils/constantsAndMappings.ts

@@ -1,12 +1,39 @@
 type JSONValue = null | boolean | number | string | JSONValue[] | { [k: string]: JSONValue };
 
+type HandleRecord = {
+    handle?: unknown;
+};
+
+type HandleRecordByName = Record<string, HandleRecord>;
+
+type RoleValueByNameRecord = Record<string, unknown>;
+
+type RoleSpecRecord = {
+    inputRoleValueByName?: unknown;
+    outputRoleValueByName?: unknown;
+};
+
+type ToolRecord = HandleRecord & {
+    isTemplate?: unknown;
+    templateToolHandle?: unknown;
+    instantiationRoleSpec?: unknown;
+    roleSpec?: unknown;
+};
+
+type ToolRecordByName = Record<string, ToolRecord>;
+
 export type GeneratedConstants = {
     Names: Record<string, string>;
+    Handles: {
+        ResourceTypes: Record<string, string>;
+        Tools: Record<string, string>;
+    };
+    ToolRoleNames: Record<string, Record<string, string>>;
     Enums: Record<string, Record<string, string>>;
 };
 
 export type GeneratedMappings = {
-    HandleNameToPrefix: Record<string, string>;
+    IdentifierNameToPrefix: Record<string, string>;
 };
 
 function deriveIdPrefixFromPattern(pattern: string): string | undefined {
@@ -96,21 +123,123 @@ export function extractEnums(schema: unknown): Record<string, Record<string, str
     return out;
 }
 
-export function extractGeneratedConstantsAndMappings(schema: JSONValue): {
+function toHandleConstantKey(handle: string): string {
+    return handle.replace(/[^A-Za-z0-9]+/g, '_');
+}
+
+export function extractHandles(records: HandleRecordByName): Record<string, string> {
+    const recordEntries = Object.entries(records);
+    recordEntries.sort(([a], [b]) => a.localeCompare(b));
+
+    const out: Record<string, string> = {};
+
+    for (const [, record] of recordEntries) {
+        if (!record || typeof record !== 'object') continue;
+        if (typeof record.handle !== 'string') continue;
+        if (!record.handle || /[\n\r`]/.test(record.handle)) continue;
+
+        out[toHandleConstantKey(record.handle)] = record.handle;
+    }
+
+    return out;
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function extractRoleNameMap(roleSpec: unknown): Record<string, string> {
+    if (!isPlainObject(roleSpec)) {
+        return {};
+    }
+
+    const out: Record<string, string> = {};
+    const groups = [
+        roleSpec.inputRoleValueByName,
+        roleSpec.outputRoleValueByName,
+    ];
+
+    for (const group of groups) {
+        if (!isPlainObject(group)) {
+            continue;
+        }
+
+        const entries = Object.keys(group).sort((a, b) => a.localeCompare(b));
+        for (const roleName of entries) {
+            if (!roleName || /[\n\r`]/.test(roleName)) {
+                continue;
+            }
+
+            out[roleName] = roleName;
+        }
+    }
+
+    return out;
+}
+
+function isCanonicalToolRecord(tool: ToolRecord): boolean {
+    if (tool.isTemplate === true) {
+        return true;
+    }
+
+    return tool.isTemplate === false && tool.templateToolHandle === undefined;
+}
+
+export function extractToolRoleNames(tools: ToolRecordByName): Record<string, Record<string, string>> {
+    const toolEntries = Object.values(tools)
+        .filter((tool): tool is ToolRecord => isPlainObject(tool))
+        .filter((tool) => typeof tool.handle === 'string' && !!tool.handle)
+        .sort((a, b) => String(a.handle).localeCompare(String(b.handle)));
+
+    const out: Record<string, Record<string, string>> = {};
+
+    for (const tool of toolEntries) {
+        if (!isCanonicalToolRecord(tool)) {
+            continue;
+        }
+
+        const roleSpec = tool.isTemplate === true
+            ? tool.instantiationRoleSpec
+            : tool.roleSpec;
+
+        const roleNameMap = extractRoleNameMap(roleSpec);
+        if (Object.keys(roleNameMap).length === 0) {
+            continue;
+        }
+
+        out[toHandleConstantKey(tool.handle as string)] = roleNameMap;
+    }
+
+    return out;
+}
+
+export function extractGeneratedConstantsAndMappings(
+    schema: JSONValue,
+    resourceTypeShells: HandleRecordByName,
+    tools: ToolRecordByName,
+): {
     CONSTANTS: GeneratedConstants;
     MAPPINGS: GeneratedMappings;
 } {
     const names = extractSubschemaNames(schema);
+    const resourceTypeHandles = extractHandles(resourceTypeShells);
+    const toolHandles = extractHandles(tools);
+    const toolRoleNames = extractToolRoleNames(tools);
     const enums = extractEnums(schema);
     const handlePrefixes = extractHandlePrefixes(schema);
 
     return {
         CONSTANTS: {
             Names: names,
+            Handles: {
+                ResourceTypes: resourceTypeHandles,
+                Tools: toolHandles,
+            },
+            ToolRoleNames: toolRoleNames,
             Enums: enums,
         },
         MAPPINGS: {
-            HandleNameToPrefix: handlePrefixes,
+            IdentifierNameToPrefix: handlePrefixes,
         },
     };
 }
@@ -138,6 +267,9 @@ function renderTsKey(key: string): string {
 
 export function renderConstantsTs(constants: GeneratedConstants): string {
     const nameKeys = Object.keys(constants.Names).sort((a, b) => a.localeCompare(b));
+    const resourceTypeHandleKeys = Object.keys(constants.Handles.ResourceTypes).sort((a, b) => a.localeCompare(b));
+    const toolHandleKeys = Object.keys(constants.Handles.Tools).sort((a, b) => a.localeCompare(b));
+    const toolRoleNameKeys = Object.keys(constants.ToolRoleNames).sort((a, b) => a.localeCompare(b));
     const enumKeys = Object.keys(constants.Enums).sort((a, b) => a.localeCompare(b));
 
     const lines: string[] = [];
@@ -149,6 +281,40 @@ export function renderConstantsTs(constants: GeneratedConstants): string {
         lines.push(`        ${renderTsKey(key)}: ${renderTsStringLiteral(value)},`);
     }
 
+    lines.push('    },');
+    lines.push('    Handles: {');
+    lines.push('        ResourceTypes: {');
+
+    for (const key of resourceTypeHandleKeys) {
+        const value = constants.Handles.ResourceTypes[key] ?? '';
+        lines.push(`            ${renderTsKey(key)}: ${renderTsStringLiteral(value)},`);
+    }
+
+    lines.push('        },');
+    lines.push('        Tools: {');
+
+    for (const key of toolHandleKeys) {
+        const value = constants.Handles.Tools[key] ?? '';
+        lines.push(`            ${renderTsKey(key)}: ${renderTsStringLiteral(value)},`);
+    }
+
+    lines.push('        },');
+    lines.push('    },');
+    lines.push('    ToolRoleNames: {');
+
+    for (const toolKey of toolRoleNameKeys) {
+        const roleNames = constants.ToolRoleNames[toolKey] ?? {};
+        const roleKeys = Object.keys(roleNames).sort((a, b) => a.localeCompare(b));
+        lines.push(`        ${renderTsKey(toolKey)}: {`);
+
+        for (const roleKey of roleKeys) {
+            const value = roleNames[roleKey] ?? '';
+            lines.push(`            ${renderTsKey(roleKey)}: ${renderTsStringLiteral(value)},`);
+        }
+
+        lines.push('        },');
+    }
+
     lines.push('    },');
     lines.push('    Enums: {');
 
@@ -174,14 +340,14 @@ export function renderConstantsTs(constants: GeneratedConstants): string {
 }
 
 export function renderMappingsTs(mappings: GeneratedMappings): string {
-    const handleKeys = Object.keys(mappings.HandleNameToPrefix).sort((a, b) => a.localeCompare(b));
+    const handleKeys = Object.keys(mappings.IdentifierNameToPrefix).sort((a, b) => a.localeCompare(b));
 
     const lines: string[] = [];
     lines.push('const MAPPINGS = {');
-    lines.push('    HandleNameToPrefix: {');
+    lines.push('    IdentifierNameToPrefix: {');
 
     for (const key of handleKeys) {
-        const value = mappings.HandleNameToPrefix[key] ?? '';
+        const value = mappings.IdentifierNameToPrefix[key] ?? '';
         lines.push(`        ${renderTsKey(key)}: ${renderTsStringLiteral(value)},`);
     }