@manifesto-ai/compiler 1.6.2 → 1.8.0

package/dist/generator/ir.js

@@ -1,715 +0,0 @@
-/**
- * IR Generator - Transforms MEL AST to Core DomainSchema
- * Based on MEL SPEC v0.3.3 Section 5
- */
-import { normalizeExpr, normalizeFunctionCall } from "./normalizer.js";
-import { hashSchemaSync, sha256Sync } from "@manifesto-ai/core";
-function createContext(domainName) {
-    return {
-        domainName,
-        stateFields: new Set(),
-        computedFields: new Set(),
-        actionParams: new Map(),
-        onceIntentCounters: new Map(),
-        currentAction: null,
-        diagnostics: [],
-        typeDefs: new Map(),
-    };
-}
-// ============ Main Generator ============
-/**
- * Generate Core DomainSchema from MEL AST
- */
-export function generate(program) {
-    const ctx = createContext(program.domain.name);
-    // First pass: collect state and computed field names
-    collectFieldNames(program.domain, ctx);
-    // v0.3.3: Generate types first
-    const types = generateTypes(program.domain, ctx);
-    // Generate schema parts
-    const state = generateState(program.domain, ctx);
-    const computed = generateComputed(program.domain, ctx);
-    const actions = generateActions(program.domain, ctx);
-    if (ctx.diagnostics.some(d => d.severity === "error")) {
-        return {
-            schema: null,
-            diagnostics: ctx.diagnostics,
-        };
-    }
-    // Create schema
-    const schemaWithoutHash = {
-        id: `mel:${program.domain.name.toLowerCase()}`,
-        version: "1.0.0",
-        types,
-        state,
-        computed,
-        actions,
-        meta: {
-            name: program.domain.name,
-        },
-    };
-    // Compute hash
-    const hash = computeHash(schemaWithoutHash);
-    const schema = {
-        ...schemaWithoutHash,
-        hash,
-    };
-    return {
-        schema,
-        diagnostics: ctx.diagnostics,
-    };
-}
-// ============ Field Collection ============
-function collectFieldNames(domain, ctx) {
-    // Collect type declarations first
-    for (const typeDecl of domain.types) {
-        ctx.typeDefs.set(typeDecl.name, typeDecl);
-    }
-    for (const member of domain.members) {
-        if (member.kind === "state") {
-            for (const field of member.fields) {
-                ctx.stateFields.add(field.name);
-            }
-        }
-        else if (member.kind === "computed") {
-            ctx.computedFields.add(member.name);
-        }
-    }
-}
-// ============ Type Generation (v0.3.3) ============
-function generateTypes(domain, _ctx) {
-    const types = {};
-    for (const typeDecl of domain.types) {
-        types[typeDecl.name] = {
-            name: typeDecl.name,
-            definition: typeExprToDefinition(typeDecl.typeExpr),
-        };
-    }
-    return types;
-}
-function typeExprToDefinition(typeExpr) {
-    switch (typeExpr.kind) {
-        case "simpleType":
-            // Primitive types vs type references
-            if (["string", "number", "boolean", "null"].includes(typeExpr.name)) {
-                return { kind: "primitive", type: typeExpr.name };
-            }
-            // User-defined type reference
-            return { kind: "ref", name: typeExpr.name };
-        case "arrayType":
-            return {
-                kind: "array",
-                element: typeExprToDefinition(typeExpr.elementType),
-            };
-        case "recordType":
-            return {
-                kind: "record",
-                key: typeExprToDefinition(typeExpr.keyType),
-                value: typeExprToDefinition(typeExpr.valueType),
-            };
-        case "objectType":
-            const fields = {};
-            for (const field of typeExpr.fields) {
-                fields[field.name] = {
-                    type: typeExprToDefinition(field.typeExpr),
-                    optional: field.optional,
-                };
-            }
-            return { kind: "object", fields };
-        case "unionType":
-            return {
-                kind: "union",
-                types: typeExpr.types.map(typeExprToDefinition),
-            };
-        case "literalType":
-            return { kind: "literal", value: typeExpr.value };
-        default:
-            // Exhaustive check
-            const _exhaustive = typeExpr;
-            throw new Error(`Unknown type expression kind: ${typeExpr.kind}`);
-    }
-}
-// ============ State Generation ============
-function generateState(domain, ctx) {
-    const fields = {};
-    for (const member of domain.members) {
-        if (member.kind === "state") {
-            for (const field of member.fields) {
-                fields[field.name] = generateFieldSpec(field, ctx);
-            }
-        }
-    }
-    return { fields };
-}
-function generateFieldSpec(field, ctx) {
-    const spec = typeExprToFieldSpec(field.typeExpr, ctx);
-    const defaultValue = field.initializer
-        ? evaluateInitializer(field.initializer, ctx)
-        : undefined;
-    return {
-        ...spec,
-        required: true,
-        default: defaultValue,
-    };
-}
-/**
- * Convert TypeExprNode to complete FieldSpec (including nested fields)
- * This is the full conversion that includes `fields` for object types
- */
-function typeExprToFieldSpec(typeExpr, ctx) {
-    switch (typeExpr.kind) {
-        case "simpleType":
-            switch (typeExpr.name) {
-                case "string": return { type: "string", required: true };
-                case "number": return { type: "number", required: true };
-                case "boolean": return { type: "boolean", required: true };
-                case "null": return { type: "null", required: true };
-                default: {
-                    // User-defined type - look up and expand
-                    const typeDef = ctx.typeDefs.get(typeExpr.name);
-                    if (typeDef) {
-                        return typeExprToFieldSpec(typeDef.typeExpr, ctx);
-                    }
-                    // Unknown type - treat as opaque object
-                    return { type: "object", required: true };
-                }
-            }
-        case "unionType": {
-            // Check if it's a literal union (enum)
-            const literals = [];
-            let isLiteralUnion = true;
-            let hasNull = false;
-            for (const t of typeExpr.types) {
-                if (t.kind === "literalType") {
-                    if (t.value === null) {
-                        hasNull = true;
-                    }
-                    literals.push(t.value);
-                    continue;
-                }
-                if (t.kind === "simpleType" && t.name === "null") {
-                    hasNull = true;
-                    literals.push(null);
-                    continue;
-                }
-                isLiteralUnion = false;
-            }
-            if (isLiteralUnion && literals.length > 0) {
-                return { type: { enum: literals }, required: !hasNull };
-            }
-            // Nullable type: T | null -> get spec of T
-            if (hasNull) {
-                for (const t of typeExpr.types) {
-                    if (t.kind !== "simpleType" || t.name !== "null") {
-                        const innerSpec = typeExprToFieldSpec(t, ctx);
-                        return { ...innerSpec, required: false };
-                    }
-                }
-            }
-            // Mixed union - default to first non-null type
-            for (const t of typeExpr.types) {
-                if (t.kind !== "simpleType" || t.name !== "null") {
-                    return typeExprToFieldSpec(t, ctx);
-                }
-            }
-            return { type: "null", required: true };
-        }
-        case "arrayType": {
-            const itemSpec = typeExprToFieldSpec(typeExpr.elementType, ctx);
-            return {
-                type: "array",
-                required: true,
-                items: itemSpec,
-            };
-        }
-        case "recordType":
-            return { type: "object", required: true };
-        case "literalType":
-            // Single literal type - use its base type
-            if (typeof typeExpr.value === "string")
-                return { type: "string", required: true };
-            if (typeof typeExpr.value === "number")
-                return { type: "number", required: true };
-            if (typeof typeExpr.value === "boolean")
-                return { type: "boolean", required: true };
-            return { type: "null", required: true };
-        case "objectType": {
-            // v0.3.3: Inline object type - expand to fields
-            const objectFields = {};
-            for (const field of typeExpr.fields) {
-                const fieldSpec = typeExprToFieldSpec(field.typeExpr, ctx);
-                objectFields[field.name] = {
-                    ...fieldSpec,
-                    required: !field.optional,
-                };
-            }
-            return {
-                type: "object",
-                required: true,
-                fields: objectFields,
-            };
-        }
-    }
-}
-/**
- * Simple type extraction (for backward compat with action input specs)
- */
-function typeExprToFieldType(typeExpr, ctx) {
-    const spec = typeExprToFieldSpec(typeExpr, ctx);
-    return spec.type;
-}
-function evaluateInitializer(expr, ctx) {
-    // Only evaluate literals and simple expressions for default values
-    switch (expr.kind) {
-        case "literal":
-            return expr.value;
-        case "arrayLiteral":
-            return expr.elements.map(e => evaluateInitializer(e, ctx));
-        case "objectLiteral": {
-            const obj = {};
-            for (const prop of expr.properties) {
-                obj[prop.key] = evaluateInitializer(prop.value, ctx);
-            }
-            return obj;
-        }
-        default:
-            // Complex expressions can't be evaluated statically
-            return undefined;
-    }
-}
-// ============ Computed Generation ============
-function generateComputed(domain, ctx) {
-    const fields = {};
-    for (const member of domain.members) {
-        if (member.kind === "computed") {
-            const expr = generateExpr(member.expression, ctx);
-            const deps = extractDeps(expr);
-            fields[`computed.${member.name}`] = {
-                deps,
-                expr,
-            };
-        }
-    }
-    return { fields };
-}
-function extractDeps(expr) {
-    const deps = new Set();
-    function visit(node) {
-        if (node.kind === "get") {
-            deps.add(node.path);
-        }
-        else {
-            // Visit all nested expressions
-            for (const value of Object.values(node)) {
-                if (typeof value === "object" && value !== null) {
-                    if (Array.isArray(value)) {
-                        for (const item of value) {
-                            if (typeof item === "object" && item !== null && "kind" in item) {
-                                visit(item);
-                            }
-                        }
-                    }
-                    else if ("kind" in value) {
-                        visit(value);
-                    }
-                }
-            }
-        }
-    }
-    visit(expr);
-    return Array.from(deps);
-}
-// ============ Action Generation ============
-function generateActions(domain, ctx) {
-    const actions = {};
-    for (const member of domain.members) {
-        if (member.kind === "action") {
-            ctx.currentAction = member.name;
-            ctx.onceIntentCounters.set(member.name, 0);
-            // Collect params
-            const params = new Set();
-            for (const param of member.params) {
-                params.add(param.name);
-            }
-            ctx.actionParams.set(member.name, params);
-            const flow = generateFlow(member.body, ctx);
-            // Generate input spec if there are params
-            let input;
-            if (member.params.length > 0) {
-                const inputFields = {};
-                for (const param of member.params) {
-                    const fieldSpec = typeExprToFieldSpec(param.typeExpr, ctx);
-                    const inputField = {
-                        type: fieldSpec.type,
-                        required: fieldSpec.required ?? true,
-                    };
-                    if (fieldSpec.type === "object" && fieldSpec.fields) {
-                        inputField.fields = fieldSpec.fields;
-                    }
-                    if (fieldSpec.type === "array" && fieldSpec.items) {
-                        inputField.items = fieldSpec.items;
-                    }
-                    inputFields[param.name] = inputField;
-                }
-                input = {
-                    type: "object",
-                    required: true,
-                    fields: inputFields,
-                };
-            }
-            // v0.3.2: Generate available condition if present
-            let available;
-            if (member.available) {
-                available = generateExpr(member.available, ctx);
-            }
-            actions[member.name] = {
-                flow,
-                input,
-                available,
-            };
-            ctx.currentAction = null;
-        }
-    }
-    return actions;
-}
-function generateFlow(stmts, ctx) {
-    if (stmts.length === 0) {
-        return { kind: "seq", steps: [] };
-    }
-    if (stmts.length === 1) {
-        return generateStmt(stmts[0], ctx);
-    }
-    return {
-        kind: "seq",
-        steps: stmts.map(s => generateStmt(s, ctx)),
-    };
-}
-function generateStmt(stmt, ctx) {
-    switch (stmt.kind) {
-        case "when":
-            return generateWhen(stmt, ctx);
-        case "once":
-            return generateOnce(stmt, ctx);
-        case "onceIntent":
-            return generateOnceIntent(stmt, ctx);
-        case "patch":
-            return generatePatch(stmt, ctx);
-        case "effect":
-            return generateEffect(stmt, ctx);
-        case "fail":
-            return generateFail(stmt, ctx);
-        case "stop":
-            return generateStop(stmt, ctx);
-    }
-}
-function generateWhen(stmt, ctx) {
-    const cond = generateExpr(stmt.condition, ctx);
-    const thenFlow = generateFlow(stmt.body, ctx);
-    return {
-        kind: "if",
-        cond,
-        then: thenFlow,
-    };
-}
-function generateOnce(stmt, ctx) {
-    // Desugar once(marker) { ... } to:
-    // when neq(marker, $meta.intentId) { patch marker = $meta.intentId; ... }
-    // Note: Core accesses $meta intent values via meta.*
-    const markerPath = generatePath(stmt.marker, ctx);
-    const intentIdExpr = { kind: "get", path: "meta.intentId" };
-    // Condition: marker != $meta.intentId
-    let cond = {
-        kind: "neq",
-        left: { kind: "get", path: markerPath },
-        right: intentIdExpr,
-    };
-    // Add extra condition if present
-    if (stmt.condition) {
-        const extraCond = generateExpr(stmt.condition, ctx);
-        cond = {
-            kind: "and",
-            args: [cond, extraCond],
-        };
-    }
-    // Body: patch marker = $meta.intentId, then rest
-    const markerPatch = {
-        kind: "patch",
-        op: "set",
-        path: markerPath,
-        value: intentIdExpr,
-    };
-    const bodySteps = stmt.body.map(s => generateStmt(s, ctx));
-    return {
-        kind: "if",
-        cond,
-        then: {
-            kind: "seq",
-            steps: [markerPatch, ...bodySteps],
-        },
-    };
-}
-function generateOnceIntent(stmt, ctx) {
-    const actionName = ctx.currentAction ?? "unknown";
-    const nextIndex = ctx.onceIntentCounters.get(actionName) ?? 0;
-    ctx.onceIntentCounters.set(actionName, nextIndex + 1);
-    const guardId = sha256Sync(`${actionName}:${nextIndex}:intent`);
-    const guardPath = `$mel.guards.intent.${guardId}`;
-    const intentIdExpr = { kind: "get", path: "meta.intentId" };
-    let cond = {
-        kind: "neq",
-        left: { kind: "get", path: guardPath },
-        right: intentIdExpr,
-    };
-    if (stmt.condition) {
-        const extraCond = generateExpr(stmt.condition, ctx);
-        cond = {
-            kind: "and",
-            args: [cond, extraCond],
-        };
-    }
-    // Guard write: semantic target is guardPath, lowered as map-level merge.
-    const markerPatch = {
-        kind: "patch",
-        op: "merge",
-        path: "$mel.guards.intent",
-        value: {
-            kind: "object",
-            fields: { [guardId]: intentIdExpr },
-        },
-    };
-    const bodySteps = stmt.body.map(s => generateStmt(s, ctx));
-    return {
-        kind: "if",
-        cond,
-        then: {
-            kind: "seq",
-            steps: [markerPatch, ...bodySteps],
-        },
-    };
-}
-function generatePatch(stmt, ctx) {
-    const path = generatePath(stmt.path, ctx);
-    const result = {
-        kind: "patch",
-        op: stmt.op,
-        path,
-    };
-    if (stmt.value) {
-        result.value = generateExpr(stmt.value, ctx);
-    }
-    return result;
-}
-function generateEffect(stmt, ctx) {
-    const params = {};
-    for (const arg of stmt.args) {
-        if (arg.isPath) {
-            // Path arguments like into:, pass:, fail:
-            params[arg.name] = { kind: "lit", value: generatePath(arg.value, ctx) };
-        }
-        else {
-            params[arg.name] = generateExpr(arg.value, ctx);
-        }
-    }
-    return {
-        kind: "effect",
-        type: stmt.effectType,
-        params,
-    };
-}
-/**
- * v0.3.2: Generate fail statement
- * fail "CODE" with expr → { kind: "fail", code, message? }
- */
-function generateFail(stmt, ctx) {
-    const result = {
-        kind: "fail",
-        code: stmt.code,
-    };
-    if (stmt.message) {
-        result.message = generateExpr(stmt.message, ctx);
-    }
-    return result;
-}
-/**
- * v0.3.2: Generate stop statement
- * stop "reason" → { kind: "halt", reason }
- */
-function generateStop(stmt, ctx) {
-    return {
-        kind: "halt",
-        reason: stmt.reason,
-    };
-}
-// ============ Path Generation ============
-function escapePathSegment(segment) {
-    return segment.replaceAll("\\", "\\\\").replaceAll(".", "\\.");
-}
-function joinPathPreserveEmptySegments(...segments) {
-    return segments.map(escapePathSegment).join(".");
-}
-function generatePath(path, ctx) {
-    const segments = [];
-    for (const segment of path.segments) {
-        if (segment.kind === "propertySegment") {
-            segments.push(segment.name);
-        }
-        else {
-            // Index segment - for now, stringify the index
-            // In reality, this would need runtime evaluation
-            const indexExpr = generateExpr(segment.index, ctx);
-            if (indexExpr.kind === "lit") {
-                segments.push(String(indexExpr.value));
-            }
-            else {
-                // Dynamic index - use placeholder
-                segments.push("*");
-            }
-        }
-    }
-    // Determine prefix based on first segment
-    const first = segments[0];
-    if (ctx.stateFields.has(first)) {
-        // Core expects state paths without prefix (e.g., "count" not "data.count")
-        return joinPathPreserveEmptySegments(...segments);
-    }
-    if (ctx.computedFields.has(first)) {
-        return `computed.${joinPathPreserveEmptySegments(...segments)}`;
-    }
-    if (ctx.currentAction && ctx.actionParams.get(ctx.currentAction)?.has(first)) {
-        return `input.${joinPathPreserveEmptySegments(...segments)}`;
-    }
-    // Default to plain path (state-like)
-    return joinPathPreserveEmptySegments(...segments);
-}
-// ============ Expression Generation ============
-function generateExpr(expr, ctx) {
-    switch (expr.kind) {
-        case "literal":
-            return { kind: "lit", value: expr.value };
-        case "identifier":
-            return generateIdentifier(expr.name, ctx);
-        case "systemIdent":
-            return generateSystemIdent(expr.path, ctx);
-        case "iterationVar":
-            // v0.3.2: $item only (reduce pattern deprecated, $acc removed)
-            // $item is used in filter/map expressions
-            return { kind: "get", path: `$${expr.name}` };
-        case "propertyAccess":
-            return generatePropertyAccess(expr, ctx);
-        case "indexAccess":
-            return {
-                kind: "at",
-                array: generateExpr(expr.object, ctx),
-                index: generateExpr(expr.index, ctx),
-            };
-        case "functionCall":
-            return normalizeFunctionCall(expr.name, expr.args.map(a => generateExpr(a, ctx)));
-        case "binary":
-            return normalizeExpr(expr.operator, generateExpr(expr.left, ctx), generateExpr(expr.right, ctx));
-        case "unary":
-            if (expr.operator === "!") {
-                return { kind: "not", arg: generateExpr(expr.operand, ctx) };
-            }
-            else {
-                return { kind: "neg", arg: generateExpr(expr.operand, ctx) };
-            }
-        case "ternary":
-            return {
-                kind: "if",
-                cond: generateExpr(expr.condition, ctx),
-                then: generateExpr(expr.consequent, ctx),
-                else: generateExpr(expr.alternate, ctx),
-            };
-        case "objectLiteral": {
-            const fields = {};
-            for (const prop of expr.properties) {
-                fields[prop.key] = generateExpr(prop.value, ctx);
-            }
-            return { kind: "object", fields };
-        }
-        case "arrayLiteral":
-            // For array literals, we build using append
-            if (expr.elements.length === 0) {
-                return { kind: "lit", value: [] };
-            }
-            // Check if all elements are literals
-            const allLiterals = expr.elements.every(e => e.kind === "literal");
-            if (allLiterals) {
-                return { kind: "lit", value: expr.elements.map(e => e.value) };
-            }
-            // Otherwise use append
-            return {
-                kind: "append",
-                array: { kind: "lit", value: [] },
-                items: expr.elements.map(e => generateExpr(e, ctx)),
-            };
-    }
-}
-function generateIdentifier(name, ctx) {
-    // Resolve identifier to path
-    if (ctx.stateFields.has(name)) {
-        // Core expects state paths without prefix (e.g., "count" not "data.count")
-        return { kind: "get", path: name };
-    }
-    if (ctx.computedFields.has(name)) {
-        return { kind: "get", path: `computed.${name}` };
-    }
-    if (ctx.currentAction && ctx.actionParams.get(ctx.currentAction)?.has(name)) {
-        return { kind: "get", path: `input.${name}` };
-    }
-    // Unknown identifier - report error and default to plain path
-    ctx.diagnostics.push({
-        severity: "error",
-        code: "E_UNKNOWN_IDENT",
-        message: `Unknown identifier '${name}'`,
-        location: { start: { line: 0, column: 0, offset: 0 }, end: { line: 0, column: 0, offset: 0 } },
-    });
-    return { kind: "get", path: name };
-}
-function generateSystemIdent(path, ctx) {
-    // $system.uuid -> will be lowered later
-    // $meta.intentId -> meta.intentId
-    // $input.* -> input.*
-    const [namespace, ...rest] = path;
-    switch (namespace) {
-        case "system":
-            // $system values are placeholders - will be lowered in the lowering pass
-            return { kind: "get", path: `$system.${rest.join(".")}` };
-        case "meta":
-            return { kind: "get", path: `meta.${rest.join(".")}` };
-        case "input":
-            return { kind: "get", path: `input.${rest.join(".")}` };
-        default:
-            ctx.diagnostics.push({
-                severity: "error",
-                code: "E_INVALID_SYSTEM",
-                message: `Invalid system identifier namespace '$${namespace}'`,
-                location: { start: { line: 0, column: 0, offset: 0 }, end: { line: 0, column: 0, offset: 0 } },
-            });
-            return { kind: "lit", value: null };
-    }
-}
-function generatePropertyAccess(expr, ctx) {
-    // Handle chained property access
-    const objectExpr = generateExpr(expr.object, ctx);
-    // If the object is a get expression, we can extend the path
-    if (objectExpr.kind === "get") {
-        return { kind: "get", path: `${objectExpr.path}.${expr.property}` };
-    }
-    // Static member access: use field() to access a known property on a computed object.
-    // This is semantically distinct from at() (array indexing) and get() (snapshot path lookup).
-    return {
-        kind: "field",
-        object: objectExpr,
-        property: expr.property,
-    };
-}
-// ============ Hash Computation ============
-/**
- * Compute schema hash using browser-compatible SHA-256.
- * Uses @manifesto-ai/core's sha256Sync for universal compatibility.
- */
-function computeHash(schema) {
-    return hashSchemaSync(schema);
-}
-//# sourceMappingURL=ir.js.map