@toolproof-core/genesis 1.0.52 → 1.0.54

package/src/implementations/tools.ts

@@ -1,214 +0,0 @@
-import type {
-    Boolean,
-    Natural,
-    ResourceType,
-    Tool,
-} from '../../generated-src/types/types.js';
-
-type GenericAssignmentByRoleName<GenericRoleName extends string> = Record<GenericRoleName, ResourceType>;
-
-type InstantiationToolHandleBySpecializationKey = Record<string, Tool>;
-
-type TemplateInputs<GenericRoleName extends string> = {
-    GenericAssignmentByRoleName: GenericAssignmentByRoleName<GenericRoleName>;
-    InstantiationToolHandleBySpecializationKey: InstantiationToolHandleBySpecializationKey;
-};
-
-type TemplateOutputs = {
-    InstantiationTool: Tool;
-};
-
-type OperandTemplateInputs = TemplateInputs<'OperandType'>;
-
-const OPERAND_TYPE_ROLE_NAMES = ['OperandType'] as const;
-
-function assertExactKeys(actualKeys: string[], expectedKeys: readonly string[], label: string): void {
-    const sortedActualKeys = [...actualKeys].sort();
-    const sortedExpectedKeys = [...expectedKeys].sort();
-
-    if (sortedActualKeys.length !== sortedExpectedKeys.length) {
-        throw new Error(
-            `${label} must contain exactly [${sortedExpectedKeys.join(', ')}], got [${sortedActualKeys.join(', ')}]`
-        );
-    }
-
-    for (let index = 0; index < sortedExpectedKeys.length; index += 1) {
-        if (sortedActualKeys[index] !== sortedExpectedKeys[index]) {
-            throw new Error(
-                `${label} must contain exactly [${sortedExpectedKeys.join(', ')}], got [${sortedActualKeys.join(', ')}]`
-            );
-        }
-    }
-}
-
-function asNatural(value: number, label: string): Natural {
-    if (!Number.isInteger(value) || value < 0) {
-        throw new Error(`${label} must be a non-negative integer, got ${value}`);
-    }
-
-    return value as Natural;
-}
-
-export function createSpecializationKey(assignments: Record<string, ResourceType>): string {
-    return JSON.stringify(
-        Object.entries(assignments)
-            .sort(([leftRoleName], [rightRoleName]) => leftRoleName.localeCompare(rightRoleName))
-            .map(([roleName, resourceType]) => [roleName, resourceType.handle])
-    );
-}
-
-function resolveTemplateInstantiation<GenericRoleName extends string>(
-    inputs: TemplateInputs<GenericRoleName>,
-    expectedGenericRoleNames: readonly GenericRoleName[]
-): TemplateOutputs {
-    const { GenericAssignmentByRoleName, InstantiationToolHandleBySpecializationKey } = inputs;
-
-    assertExactKeys(
-        Object.keys(GenericAssignmentByRoleName),
-        expectedGenericRoleNames,
-        'GenericAssignmentByRoleName'
-    );
-
-    const specializationKey = createSpecializationKey(GenericAssignmentByRoleName);
-    const instantiationTool = InstantiationToolHandleBySpecializationKey[specializationKey];
-
-    if (!instantiationTool) {
-        throw new Error(`No instantiation tool registered for specializationKey ${specializationKey}`);
-    }
-
-    return {
-        InstantiationTool: instantiationTool,
-    };
-}
-
-export function Identity(inputs: OperandTemplateInputs): TemplateOutputs {
-    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
-}
-
-export function Add(inputs: OperandTemplateInputs): TemplateOutputs {
-    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
-}
-
-export function Subtract(inputs: OperandTemplateInputs): TemplateOutputs {
-    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
-}
-
-export function Multiply(inputs: OperandTemplateInputs): TemplateOutputs {
-    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
-}
-
-export function Divide(inputs: OperandTemplateInputs): TemplateOutputs {
-    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
-}
-
-export function Double(inputs: OperandTemplateInputs): TemplateOutputs {
-    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
-}
-
-export function LessThan(inputs: OperandTemplateInputs): TemplateOutputs {
-    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
-}
-
-export function BooleanIdentity(inputs: { In: Boolean }): { Out: Boolean } {
-    return {
-        Out: inputs.In,
-    };
-}
-
-export function NaturalIdentity(inputs: { In: Natural }): { Out: Natural } {
-    return {
-        Out: inputs.In,
-    };
-}
-
-export function NaturalLessThan(inputs: {
-    LessThanSource: Natural;
-    LessThanTarget: Natural;
-}): { LessThanDecision: Boolean } {
-    return {
-        LessThanDecision: inputs.LessThanSource < inputs.LessThanTarget,
-    };
-}
-
-export function NaturalAdd(inputs: {
-    AddendOne: Natural;
-    AddendTwo: Natural;
-}): { Sum: Natural } {
-    return {
-        Sum: asNatural(inputs.AddendOne + inputs.AddendTwo, 'Sum'),
-    };
-}
-
-export function NaturalSubtract(inputs: {
-    Minuend: Natural;
-    Subtrahend: Natural;
-}): { Difference: Natural } {
-    return {
-        Difference: asNatural(inputs.Minuend - inputs.Subtrahend, 'Difference'),
-    };
-}
-
-export function NaturalMultiply(inputs: {
-    Multiplicand: Natural;
-    Multiplier: Natural;
-}): { Product: Natural } {
-    return {
-        Product: asNatural(inputs.Multiplicand * inputs.Multiplier, 'Product'),
-    };
-}
-
-export function NaturalDivide(inputs: {
-    Dividend: Natural;
-    Divisor: Natural;
-}): { Quotient: Natural; Remainder: Natural } {
-    if (inputs.Divisor === 0) {
-        throw new Error('Divisor must be non-zero');
-    }
-
-    return {
-        Quotient: asNatural(Math.floor(inputs.Dividend / inputs.Divisor), 'Quotient'),
-        Remainder: asNatural(inputs.Dividend % inputs.Divisor, 'Remainder'),
-    };
-}
-
-export function NaturalDouble(inputs: { N: Natural }): { Doubled: Natural } {
-    return {
-        Doubled: asNatural(inputs.N * 2, 'Doubled'),
-    };
-}
-
-export const TOOL_IMPLEMENTATION_BY_NAME = {
-    Identity,
-    Add,
-    Subtract,
-    Multiply,
-    Divide,
-    Double,
-    LessThan,
-    BooleanIdentity,
-    NaturalIdentity,
-    NaturalLessThan,
-    NaturalAdd,
-    NaturalSubtract,
-    NaturalMultiply,
-    NaturalDivide,
-    NaturalDouble,
-} as const;
-
-export const TOOL_IMPLEMENTATION_BY_HANDLE = {
-    'TOOL-Identity': Identity,
-    'TOOL-Add': Add,
-    'TOOL-Subtract': Subtract,
-    'TOOL-Multiply': Multiply,
-    'TOOL-Divide': Divide,
-    'TOOL-Double': Double,
-    'TOOL-LessThan': LessThan,
-    'TOOL-BooleanIdentity': BooleanIdentity,
-    'TOOL-NaturalIdentity': NaturalIdentity,
-    'TOOL-NaturalLessThan': NaturalLessThan,
-    'TOOL-NaturalAdd': NaturalAdd,
-    'TOOL-NaturalSubtract': NaturalSubtract,
-    'TOOL-NaturalMultiply': NaturalMultiply,
-    'TOOL-NaturalDivide': NaturalDivide,
-    'TOOL-NaturalDouble': NaturalDouble,
-} as const;

package/src/index.ts

@@ -1,131 +0,0 @@
-// Re-export JSON schemas via .ts shims to avoid .json re-exports in declarations
-export { default as Schemas } from '../generated-src/schemas/schemas.js';
-
-export { default as ResourceTypeSchema } from '../generated-src/schemas/standalone/ResourceType.js';
-export { default as ToolSchema } from '../generated-src/schemas/standalone/Tool.js';
-export { default as StrategySchema } from '../generated-src/schemas/standalone/Strategy.js';
-export { default as StrategyTraceSchema } from '../generated-src/schemas/standalone/StrategyTrace.js';
-
-// Re-export generated Zod validators
-export { ToolSchema as ZodToolSchema } from '../generated-src/schemas/zod/Tool.js';
-export { ResourceTypeSchema as ZodResourceTypeSchema } from '../generated-src/schemas/zod/ResourceType.js';
-export { StrategySchema as ZodStrategySchema } from '../generated-src/schemas/zod/Strategy.js';
-export { StrategyTraceSchema as ZodStrategyTraceSchema } from '../generated-src/schemas/zod/StrategyTrace.js';
-export { GoalSchema as ZodGoalSchema } from '../generated-src/schemas/zod/Goal.js';
-export * as ZodSchemas from '../generated-src/schemas/zod/index.js';
-
-export { default as ResourceTypeTimestampedResources } from '../generated-src/timestampedResources/resourceTypes.js';
-
-export {
-    Add,
-    BooleanIdentity,
-    createSpecializationKey,
-    Divide,
-    Double,
-    Identity,
-    LessThan,
-    Multiply,
-    NaturalAdd,
-    NaturalDivide,
-    NaturalDouble,
-    NaturalIdentity,
-    NaturalLessThan,
-    NaturalMultiply,
-    NaturalSubtract,
-    Subtract,
-    TOOL_IMPLEMENTATION_BY_HANDLE,
-    TOOL_IMPLEMENTATION_BY_NAME,
-} from '../generated-src/implementations/tools.js';
-
-export { default as CONSTANTS } from '../generated-src/lookups/constants.js';
-export { default as MAPPINGS } from '../generated-src/lookups/mappings.js';
-
-export type {
-    ResourceTypeResource,
-} from '../generated-src/types/standalone/ResourceTypeResource.js';
-export type {
-    ToolResource,
-} from '../generated-src/types/standalone/ToolResource.js';
-export type {
-    StrategyResource,
-} from '../generated-src/types/standalone/StrategyResource.js';
-export type {
-    StrategyTraceResource,
-} from '../generated-src/types/standalone/StrategyTraceResource.js';
-
-export type {
-    BaseResource,
-    BaseStrategy,
-    BaseToolStepPathSpec,
-    Boolean,
-    BranchStep,
-    Case,
-    ContainerKind,
-    DeferredStrategyProvenance,
-    Description,
-    DescriptionFacet,
-    DocumentationSpec,
-    ExternalInputPotential,
-    GenesisProvenance,
-    Goal,
-    InputPotential,
-    InputResource,
-    InternalInputPotential,
-    JsonSchemaObject,
-    JsonSchemaObject1,
-    JsonSchemaObject2,
-    Name,
-    NameFacet,
-    Natural,
-    OutputAddress,
-    Provenance,
-    ProvenanceFacet,
-    ProvenanceKind,
-    Resource,
-    ResourceId,
-    ResourcePointer,
-    ResourceType,
-    ResourceTypeHandle,
-    RoleBindingSpec,
-    RoleBindingSpecFacet,
-    RoleBindingSpecFacet1,
-    RoleName,
-    RoleNameArray,
-    RoleSpec,
-    RoleSpecFacet,
-    RoleValue,
-    RoleValueByName,
-    Step,
-    StepArray,
-    StepArrayArray,
-    StepKind,
-    StepKindFacet,
-    Strategy,
-    StrategyHandle,
-    StrategyKind,
-    StrategyProvenance,
-    StrategyStateInputEntry,
-    StrategyStateInputEntryByRoleName,
-    StrategyStateInputKind,
-    StrategyTrace,
-    StrategyTraceHandle,
-    ThreadedStrategy,
-    ThreadedStrategyState,
-    ThreadedStrategyStateFacet,
-    ThreadedToolStepPath,
-    ThreadedToolStepPathSpec,
-    Tool,
-    ToolHandle,
-    ToolStep,
-    ToolStepPath,
-    ToolStepPathSlot,
-    ToolStepPathSlotFacet,
-    TypeRef,
-    UnthreadedStrategy,
-    UnthreadedStrategyState,
-    UnthreadedStrategyStateFacet,
-    UnthreadedToolStepPath,
-    UnthreadedToolStepPathSpec,
-    WhileStep,
-    ForStep,
-} from '../generated-src/types/types.js';

package/src/utils/constantsAndMappings.ts

@@ -1,195 +0,0 @@
-type JSONValue = null | boolean | number | string | JSONValue[] | { [k: string]: JSONValue };
-
-export type GeneratedConstants = {
-    Names: Record<string, string>;
-    Enums: Record<string, Record<string, string>>;
-};
-
-export type GeneratedMappings = {
-    HandleNameToPrefix: Record<string, string>;
-};
-
-function deriveIdPrefixFromPattern(pattern: string): string | undefined {
-    const match = /^\^([^$]+)\.\+\$$/.exec(pattern);
-    if (!match) return undefined;
-
-    const prefix = match[1];
-    if (!prefix || /[`\n\r]/.test(prefix)) return undefined;
-
-    return prefix;
-}
-
-export function extractHandlePrefixes(schema: unknown): Record<string, string> {
-    if (!schema || typeof schema !== 'object') return {};
-
-    const defs = (schema as { $defs?: unknown }).$defs;
-    if (!defs || typeof defs !== 'object') return {};
-
-    const defEntries = Object.entries(defs as Record<string, unknown>);
-    defEntries.sort(([a], [b]) => a.localeCompare(b));
-
-    const out: Record<string, string> = {};
-
-    for (const [defName, defVal] of defEntries) {
-        if (!/(Id|Handle)$/.test(defName)) continue;
-        if (!defVal || typeof defVal !== 'object' || Array.isArray(defVal)) continue;
-
-        const value = defVal as { type?: unknown; pattern?: unknown };
-        if (value.type !== 'string') continue;
-        if (typeof value.pattern !== 'string') continue;
-
-        const prefix = deriveIdPrefixFromPattern(value.pattern);
-        if (!prefix) continue;
-
-        out[defName] = prefix;
-    }
-
-    return out;
-}
-
-export function extractSubschemaNames(schema: unknown): Record<string, string> {
-    if (!schema || typeof schema !== 'object') return {};
-
-    const defs = (schema as { $defs?: unknown }).$defs;
-    if (!defs || typeof defs !== 'object') return {};
-
-    const defEntries = Object.entries(defs as Record<string, unknown>);
-    defEntries.sort(([a], [b]) => a.localeCompare(b));
-
-    const out: Record<string, string> = {};
-    for (const [defName] of defEntries) {
-        if (!defName || /[\n\r`]/.test(defName)) continue;
-        out[defName] = defName;
-    }
-
-    return out;
-}
-
-export function extractEnums(schema: unknown): Record<string, Record<string, string>> {
-    if (!schema || typeof schema !== 'object') return {};
-
-    const defs = (schema as { $defs?: unknown }).$defs;
-    if (!defs || typeof defs !== 'object') return {};
-
-    const defEntries = Object.entries(defs as Record<string, unknown>);
-    defEntries.sort(([a], [b]) => a.localeCompare(b));
-
-    const out: Record<string, Record<string, string>> = {};
-
-    for (const [defName, defVal] of defEntries) {
-        if (!/(Kind|Status)$/.test(defName)) continue;
-        if (!defVal || typeof defVal !== 'object' || Array.isArray(defVal)) continue;
-
-        const value = defVal as { type?: unknown; enum?: unknown };
-        if (value.type !== 'string') continue;
-        if (!Array.isArray(value.enum) || value.enum.length === 0) continue;
-        if (value.enum.some((item) => typeof item !== 'string')) continue;
-
-        const members: Record<string, string> = {};
-        for (const member of value.enum as readonly string[]) {
-            members[member] = member;
-        }
-
-        out[defName] = members;
-    }
-
-    return out;
-}
-
-export function extractGeneratedConstantsAndMappings(schema: JSONValue): {
-    CONSTANTS: GeneratedConstants;
-    MAPPINGS: GeneratedMappings;
-} {
-    const names = extractSubschemaNames(schema);
-    const enums = extractEnums(schema);
-    const handlePrefixes = extractHandlePrefixes(schema);
-
-    return {
-        CONSTANTS: {
-            Names: names,
-            Enums: enums,
-        },
-        MAPPINGS: {
-            HandleNameToPrefix: handlePrefixes,
-        },
-    };
-}
-
-function escapeTsString(value: string): string {
-    return value
-        .replace(/\\/g, '\\\\')
-        .replace(/\r/g, '\\r')
-        .replace(/\n/g, '\\n')
-        .replace(/\t/g, '\\t')
-        .replace(/'/g, "\\'");
-}
-
-function renderTsStringLiteral(value: string): string {
-    return `'${escapeTsString(value)}'`;
-}
-
-function isValidTsIdentifier(key: string): boolean {
-    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key);
-}
-
-function renderTsKey(key: string): string {
-    return isValidTsIdentifier(key) ? key : renderTsStringLiteral(key);
-}
-
-export function renderConstantsTs(constants: GeneratedConstants): string {
-    const nameKeys = Object.keys(constants.Names).sort((a, b) => a.localeCompare(b));
-    const enumKeys = Object.keys(constants.Enums).sort((a, b) => a.localeCompare(b));
-
-    const lines: string[] = [];
-    lines.push('const CONSTANTS = {');
-    lines.push('    Names: {');
-
-    for (const key of nameKeys) {
-        const value = constants.Names[key] ?? '';
-        lines.push(`        ${renderTsKey(key)}: ${renderTsStringLiteral(value)},`);
-    }
-
-    lines.push('    },');
-    lines.push('    Enums: {');
-
-    for (const key of enumKeys) {
-        const members = constants.Enums[key] ?? {};
-        lines.push(`        ${renderTsKey(key)}: {`);
-
-        for (const memberKey of Object.keys(members)) {
-            const value = members[memberKey] ?? '';
-            lines.push(`            ${renderTsKey(memberKey)}: ${renderTsStringLiteral(value)},`);
-        }
-
-        lines.push('        },');
-    }
-
-    lines.push('    }');
-    lines.push('} as const;');
-    lines.push('');
-    lines.push('export default CONSTANTS;');
-    lines.push('');
-
-    return lines.join('\n');
-}
-
-export function renderMappingsTs(mappings: GeneratedMappings): string {
-    const handleKeys = Object.keys(mappings.HandleNameToPrefix).sort((a, b) => a.localeCompare(b));
-
-    const lines: string[] = [];
-    lines.push('const MAPPINGS = {');
-    lines.push('    HandleNameToPrefix: {');
-
-    for (const key of handleKeys) {
-        const value = mappings.HandleNameToPrefix[key] ?? '';
-        lines.push(`        ${renderTsKey(key)}: ${renderTsStringLiteral(value)},`);
-    }
-
-    lines.push('    },');
-    lines.push('} as const;');
-    lines.push('');
-    lines.push('export default MAPPINGS;');
-    lines.push('');
-
-    return lines.join('\n');
-}

package/src/utils/coreProjection.ts

@@ -1,53 +0,0 @@
-import * as path from 'node:path';
-
-export type CoreProjectionNode = CoreProjectionDirectoryNode | CoreProjectionFileNode;
-
-export interface CoreProjectionBaseNode {
-    kind: 'directory' | 'file';
-    name: string;
-    path: string;
-}
-
-export interface CoreProjectionDirectoryNode extends CoreProjectionBaseNode {
-    kind: 'directory';
-    children: CoreProjectionNode[];
-}
-
-export interface CoreProjectionFileNode extends CoreProjectionBaseNode {
-    kind: 'file';
-}
-
-const EXCLUDED_DIRECTORY_NAMES = new Set([
-    '.git',
-    '.next',
-    'dist',
-    'node_modules',
-]);
-
-export function toPosixPath(value: string): string {
-    return value.split(path.sep).join('/');
-}
-
-export function shouldExclude(relativePath: string, isDirectory: boolean, excludedRelativePathPrefixes: string[]): boolean {
-    if (!relativePath || relativePath === '.') {
-        return false;
-    }
-
-    const normalizedPath = toPosixPath(relativePath);
-    const baseName = path.posix.basename(normalizedPath);
-
-    if (isDirectory && EXCLUDED_DIRECTORY_NAMES.has(baseName)) {
-        return true;
-    }
-
-    return excludedRelativePathPrefixes.some((prefix) => {
-        return normalizedPath === prefix || normalizedPath.startsWith(`${prefix}/`);
-    });
-}
-
-export function compareNodes(a: CoreProjectionNode, b: CoreProjectionNode): number {
-    if (a.kind !== b.kind) {
-        return a.kind === 'directory' ? -1 : 1;
-    }
-    return a.name.localeCompare(b.name);
-}

package/src/utils/resourceTypes.ts

@@ -1,71 +0,0 @@
-type JsonObject = Record<string, unknown>;
-
-type SchemasDocument = {
-    $defs?: Record<string, JsonObject>;
-};
-
-type ResourceTypeShell = JsonObject & {
-    handle?: unknown;
-    name?: unknown;
-    description?: unknown;
-    ingestorToolInputSchema?: unknown;
-};
-
-type ResourceTypeShellByName = Record<string, ResourceTypeShell>;
-
-export function generateResourceTypes(
-    schemasDocument: SchemasDocument,
-    resourceTypeShells: ResourceTypeShellByName,
-): ResourceTypeShell[] {
-    if (!schemasDocument.$defs || typeof schemasDocument.$defs !== 'object') {
-        throw new Error('Schema document must have root $defs');
-    }
-
-    const resourceTypes: ResourceTypeShell[] = [];
-
-    for (const [resourceTypeName, resourceTypeShell] of Object.entries(resourceTypeShells)) {
-        const projectionSchema = schemasDocument.$defs[resourceTypeName];
-        const ingestorToolInputSchemaDefName = resourceTypeShell.ingestorToolInputSchema;
-
-        if (!projectionSchema || typeof projectionSchema !== 'object' || Array.isArray(projectionSchema)) {
-            throw new Error(`Missing matching schema for resource type record ${resourceTypeName}`);
-        }
-
-        if (
-            ingestorToolInputSchemaDefName !== undefined &&
-            typeof ingestorToolInputSchemaDefName !== 'string'
-        ) {
-            throw new Error(
-                `ingestorToolInputSchema for resource type record ${resourceTypeName} must be a schema definition name when present`,
-            );
-        }
-
-        const ingestorToolInputSchema =
-            typeof ingestorToolInputSchemaDefName === 'string'
-                ? schemasDocument.$defs[ingestorToolInputSchemaDefName]
-                : undefined;
-
-        if (typeof ingestorToolInputSchemaDefName === 'string' && !ingestorToolInputSchema) {
-            throw new Error(
-                `Missing ingestor input schema ${ingestorToolInputSchemaDefName} for resource type record ${resourceTypeName}`,
-            );
-        }
-
-        if (
-            ingestorToolInputSchema !== undefined &&
-            (typeof ingestorToolInputSchema !== 'object' || Array.isArray(ingestorToolInputSchema))
-        ) {
-            throw new Error(
-                `Ingestor input schema ${ingestorToolInputSchemaDefName} for resource type record ${resourceTypeName} must be an object`,
-            );
-        }
-
-        resourceTypes.push({
-            ...resourceTypeShell,
-            projectionSchema,
-            ...(ingestorToolInputSchema ? { ingestorToolInputSchema } : {}),
-        });
-    }
-
-    return resourceTypes;
-}