@typecad/cuttlefish 0.1.0-alpha.1

package/dist/emit/utils/type-inference.js

@@ -0,0 +1,559 @@
+/**
+ * Type inference utilities for C++ code emission.
+ * Pure functions with no side effects - extracted from cpp-emitter.ts
+ */
+import { parsedIsPointer } from "../../api/shared/cpp-type-ir.js";
+/**
+ * Infers the C++ type for an object field based on its initializer value.
+ *
+ * @param value The expression to infer type for
+ * @param pointerVarTypes Map of variable names to their pointer types (e.g., "sensor" -> "Sensor*")
+ * @param knownFunctionReturnTypes Map of function names to their return types
+ * @param knownObjectTypes Map of object names to their types
+ * @param knownObjectFieldTypes Map of object names to their field type maps
+ * @param largeEnumNames Set of enum names with values outside 16-bit int range
+ * @param resolvePinType Optional callback to resolve pin types from the platform strategy
+ * @returns The inferred C++ type string
+ */
+export function inferObjectFieldType(value, pointerVarTypes, knownFunctionReturnTypes, knownObjectTypes, knownObjectFieldTypes, largeEnumNames, parentName, fieldName, defaultIntType = "int", resolvePinType) {
+    if (value.kind === "number") {
+        if (value.cppType === "float" || value.cppType === "double" || !Number.isInteger(value.value)) {
+            return value.cppType === "double" ? "double" : "float";
+        }
+        if (value.value > 32767 || value.value < -32768) {
+            return "long";
+        }
+        return defaultIntType;
+    }
+    if (value.kind === "boolean") {
+        return "bool";
+    }
+    if (value.kind === "string") {
+        return "const char*";
+    }
+    if (value.kind === "identifier") {
+        if (knownObjectTypes && knownObjectTypes.has(value.value)) {
+            return knownObjectTypes.get(value.value);
+        }
+        if (value.value === "Pins") {
+            return "_Pins_t";
+        }
+        // Check if this identifier is a known pointer variable
+        if (pointerVarTypes && pointerVarTypes.has(value.value)) {
+            return pointerVarTypes.get(value.value);
+        }
+        // Default to the defaultIntType for unknown identifiers
+        // This will be overridden if knownVariableTypes is provided
+        return defaultIntType;
+    }
+    // For enum member access (e.g. I2CSpeed.STANDARD), return `long` if the
+    // enum has values outside the 16-bit int range, otherwise `int`.
+    if (value.kind === "property-access" && value.object.kind === "identifier") {
+        const enumName = value.object.value;
+        return largeEnumNames?.has(enumName) ? "long" : defaultIntType;
+    }
+    if (value.kind === "raw") {
+        const memberAccessMatch = value.value.match(/^([A-Za-z_][A-Za-z0-9_]*)\.([A-Za-z_][A-Za-z0-9_]*)$/);
+        if (memberAccessMatch && knownObjectFieldTypes) {
+            const objectName = memberAccessMatch[1];
+            const fieldName = memberAccessMatch[2];
+            const fields = knownObjectFieldTypes.get(objectName);
+            if (fields?.has(fieldName)) {
+                return fields.get(fieldName);
+            }
+            if (objectName === "Pins" && resolvePinType) {
+                const resolved = resolvePinType(objectName, fieldName);
+                if (resolved)
+                    return resolved;
+            }
+        }
+        const newMatch = value.value.match(/^new\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(/);
+        if (newMatch) {
+            return `${newMatch[1]}*`;
+        }
+        const callMatch = value.value.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*\(/);
+        if (callMatch && knownFunctionReturnTypes) {
+            const inferred = knownFunctionReturnTypes.get(callMatch[1]);
+            if (inferred) {
+                return inferred;
+            }
+        }
+    }
+    if (value.kind === "array") {
+        const elementKinds = value.elements.map((element) => element.kind);
+        let elementType = defaultIntType;
+        if (elementKinds.includes("string")) {
+            elementType = "const char*";
+        }
+        else if (value.elements.some((element) => element.kind === "number" && !Number.isInteger(element.value))) {
+            elementType = "float";
+        }
+        else if (elementKinds.includes("boolean") && !elementKinds.includes("number")) {
+            elementType = "bool";
+        }
+        return `std::vector<${elementType}>`;
+    }
+    // Nested object literal — generate a struct type name
+    if (value.kind === "object") {
+        if (parentName && fieldName) {
+            return `_${parentName}_${fieldName}_t`;
+        }
+        return defaultIntType;
+    }
+    return defaultIntType;
+}
+/**
+ * Recursively collects nested struct definitions from an object ExpressionIR.
+ * Returns an array of struct definitions ordered from deepest to shallowest,
+ * so that inner structs are defined before outer structs that reference them.
+ *
+ * @param objExpr  The object ExpressionIR to scan for nested objects
+ * @param parentName The variable/struct name prefix for generating struct type names
+ * @param pointerVarTypes Optional pointer variable type map
+ * @param knownFunctionReturnTypes Optional function return type map
+ * @param knownObjectTypes Optional object type map
+ * @param knownObjectFieldTypes Optional object field type map
+ * @param largeEnumNames Optional large enum names set
+ */
+export function collectNestedStructDefs(objExpr, parentName, pointerVarTypes, knownFunctionReturnTypes, knownObjectTypes, knownObjectFieldTypes, largeEnumNames) {
+    const result = [];
+    for (const field of objExpr.fields) {
+        if (field.value.kind === "object") {
+            const nestedObj = field.value;
+            const nestedStructName = `_${parentName}_${field.name}_t`;
+            // Recursively collect deeper nested structs first
+            const deeper = collectNestedStructDefs(nestedObj, `${parentName}_${field.name}`, pointerVarTypes, knownFunctionReturnTypes, knownObjectTypes, knownObjectFieldTypes, largeEnumNames);
+            result.push(...deeper);
+            // Collect this nested struct's fields
+            const nestedFields = nestedObj.fields.map((f) => ({
+                type: inferObjectFieldType(f.value, pointerVarTypes, knownFunctionReturnTypes, knownObjectTypes, knownObjectFieldTypes, largeEnumNames, `${parentName}_${field.name}`, f.name),
+                name: f.name,
+            }));
+            result.push({ structName: nestedStructName, fields: nestedFields });
+        }
+    }
+    return result;
+}
+/**
+ * Checks if a program contains array literals inside object literals.
+ * This affects whether std::vector needs to be included.
+ *
+ * @param program The program IR to analyze
+ * @returns true if arrays in object literals are found
+ */
+export function hasArrayInObjectLiteral(program) {
+    const hasArray = (expr) => {
+        if (expr.kind === "array") {
+            return true;
+        }
+        if (expr.kind === "object") {
+            return expr.fields.some((field) => hasArray(field.value));
+        }
+        if (expr.kind === "ternary") {
+            return hasArray(expr.condition) || hasArray(expr.whenTrue) || hasArray(expr.whenFalse);
+        }
+        return false;
+    };
+    const hasArrayInStatement = (statement) => {
+        if (statement.kind === "var_decl" && statement.initializer) {
+            return hasArray(statement.initializer);
+        }
+        if (statement.kind === "assign") {
+            return hasArray(statement.value);
+        }
+        if (statement.kind === "return" && statement.value) {
+            return hasArray(statement.value);
+        }
+        if (statement.kind === "call") {
+            return statement.args.some((arg) => hasArray(arg));
+        }
+        return false;
+    };
+    if (program.topLevelStatements.some((statement) => hasArrayInStatement(statement))) {
+        return true;
+    }
+    for (const fn of program.functions) {
+        if (fn.statements.some((statement) => hasArrayInStatement(statement))) {
+            return true;
+        }
+    }
+    for (const classDef of program.classes) {
+        if (classDef.fields.some((field) => field.initializer ? hasArray(field.initializer) : false)) {
+            return true;
+        }
+        for (const method of classDef.methods) {
+            if (method.statements.some((statement) => hasArrayInStatement(statement))) {
+                return true;
+            }
+        }
+        if (classDef.constructor && classDef.constructor.statements.some((statement) => hasArrayInStatement(statement))) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Checks if a program contains throw statements.
+ * This affects whether <stdexcept> needs to be included.
+ *
+ * @param program The program IR to analyze
+ * @returns true if throw statements are found
+ */
+export function hasThrowStatements(program) {
+    const statementHasThrow = (statement) => {
+        if (statement.kind === "throw") {
+            return true;
+        }
+        if (statement.kind === "while" || statement.kind === "do_while") {
+            return statement.body.some(statementHasThrow);
+        }
+        if (statement.kind === "for" || statement.kind === "for_of" || statement.kind === "for_in") {
+            return statement.body.some(statementHasThrow);
+        }
+        if (statement.kind === "if") {
+            return statement.thenBranch.some(statementHasThrow) || (statement.elseBranch?.some(statementHasThrow) ?? false);
+        }
+        if (statement.kind === "switch") {
+            return statement.cases.some((caseClause) => caseClause.body.some(statementHasThrow));
+        }
+        if (statement.kind === "try") {
+            return statement.tryBlock.some(statementHasThrow) || (statement.catchBlock?.some(statementHasThrow) ?? false);
+        }
+        return false;
+    };
+    if (program.topLevelStatements.some(statementHasThrow)) {
+        return true;
+    }
+    for (const fn of program.functions) {
+        if (fn.statements.some(statementHasThrow)) {
+            return true;
+        }
+    }
+    for (const classDef of program.classes) {
+        if (classDef.methods.some((method) => method.statements.some(statementHasThrow))) {
+            return true;
+        }
+        if (classDef.constructor && classDef.constructor.statements.some(statementHasThrow)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Checks if a program contains std::math function calls.
+ * This affects whether <cmath> or <math.h> needs to be included.
+ *
+ * @param program The program IR to analyze
+ * @returns true if math calls are found
+ */
+export function hasStdMathCalls(program) {
+    const mathPattern = /\bstd::(floor|ceil|round|trunc|sqrt|pow|sin|cos|tan|asin|acos|atan|abs|max|min)\b/;
+    const expressionHasMath = (expr) => {
+        if (expr.kind === "raw") {
+            return mathPattern.test(expr.value);
+        }
+        if (expr.kind === "await") {
+            return expressionHasMath(expr.value);
+        }
+        if (expr.kind === "ternary") {
+            return expressionHasMath(expr.condition) || expressionHasMath(expr.whenTrue) || expressionHasMath(expr.whenFalse);
+        }
+        if (expr.kind === "array") {
+            return expr.elements.some(expressionHasMath);
+        }
+        if (expr.kind === "object") {
+            return expr.fields.some((field) => expressionHasMath(field.value));
+        }
+        if (expr.kind === "instanceof") {
+            return expressionHasMath(expr.object);
+        }
+        if (expr.kind === "spread_array") {
+            return expressionHasMath(expr.spreadExpr) || expr.additionalElements.some(expressionHasMath);
+        }
+        return false;
+    };
+    const statementHasMath = (statement) => {
+        if (statement.kind === "call") {
+            return statement.args.some(expressionHasMath);
+        }
+        if (statement.kind === "var_decl") {
+            return statement.initializer ? expressionHasMath(statement.initializer) : false;
+        }
+        if (statement.kind === "assign") {
+            return expressionHasMath(statement.value);
+        }
+        if (statement.kind === "return") {
+            return statement.value ? expressionHasMath(statement.value) : false;
+        }
+        if (statement.kind === "while" || statement.kind === "do_while") {
+            return expressionHasMath(statement.condition) || statement.body.some(statementHasMath);
+        }
+        if (statement.kind === "if") {
+            return expressionHasMath(statement.condition) || statement.thenBranch.some(statementHasMath) || (statement.elseBranch?.some(statementHasMath) ?? false);
+        }
+        if (statement.kind === "for") {
+            return (statement.initializer ? statementHasMath(statement.initializer) : false)
+                || (statement.condition ? expressionHasMath(statement.condition) : false)
+                || (statement.increment ? statementHasMath(statement.increment) : false)
+                || statement.body.some(statementHasMath);
+        }
+        if (statement.kind === "for_of") {
+            return statementHasMath(statement.variable) || expressionHasMath(statement.iterable) || statement.body.some(statementHasMath);
+        }
+        if (statement.kind === "for_in") {
+            return statementHasMath(statement.variable) || expressionHasMath(statement.object) || statement.body.some(statementHasMath);
+        }
+        if (statement.kind === "switch") {
+            return expressionHasMath(statement.expression) || statement.cases.some((caseClause) => (caseClause.value ? expressionHasMath(caseClause.value) : false) || caseClause.body.some(statementHasMath));
+        }
+        if (statement.kind === "try") {
+            return statement.tryBlock.some(statementHasMath) || (statement.catchBlock?.some(statementHasMath) ?? false);
+        }
+        if (statement.kind === "throw") {
+            return expressionHasMath(statement.value);
+        }
+        return false;
+    };
+    if (program.topLevelStatements.some(statementHasMath)) {
+        return true;
+    }
+    if (program.functions.some((fn) => fn.statements.some(statementHasMath))) {
+        return true;
+    }
+    for (const classDef of program.classes) {
+        if (classDef.methods.some((method) => method.statements.some(statementHasMath))) {
+            return true;
+        }
+        if (classDef.constructor && classDef.constructor.statements.some(statementHasMath)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Checks if a program contains console.* calls (console.log, console.error, etc.)
+ *
+ * @param program The program IR to analyze
+ * @returns true if console calls are found
+ */
+export function hasConsoleCalls(program, strategy) {
+    const checkStatements = (statements) => {
+        for (const stmt of statements) {
+            if (stmt.kind === "call" && isConsoleCall(stmt.callee, strategy)) {
+                return true;
+            }
+            // Check nested statements in control flow
+            if ("body" in stmt && Array.isArray(stmt.body)) {
+                if (checkStatements(stmt.body))
+                    return true;
+            }
+            if ("thenBranch" in stmt && Array.isArray(stmt.thenBranch)) {
+                if (checkStatements(stmt.thenBranch))
+                    return true;
+            }
+            if ("elseBranch" in stmt && Array.isArray(stmt.elseBranch)) {
+                if (checkStatements(stmt.elseBranch))
+                    return true;
+            }
+            if ("cases" in stmt && Array.isArray(stmt.cases)) {
+                for (const c of stmt.cases) {
+                    if (checkStatements(c.body))
+                        return true;
+                }
+            }
+            if ("tryBlock" in stmt && Array.isArray(stmt.tryBlock)) {
+                if (checkStatements(stmt.tryBlock))
+                    return true;
+            }
+            if ("catchBlock" in stmt && Array.isArray(stmt.catchBlock)) {
+                if (checkStatements(stmt.catchBlock))
+                    return true;
+            }
+        }
+        return false;
+    };
+    // Check all functions
+    for (const fn of program.functions) {
+        if (checkStatements(fn.statements))
+            return true;
+    }
+    // Check top-level statements
+    if (checkStatements(program.topLevelStatements))
+        return true;
+    // Check class methods
+    for (const cls of program.classes) {
+        for (const method of cls.methods) {
+            if (checkStatements(method.statements))
+                return true;
+        }
+        if (cls.constructor && checkStatements(cls.constructor.statements))
+            return true;
+    }
+    return false;
+}
+/**
+ * Checks if a callee is a console method call (e.g., "console.log", "console.error")
+ */
+export function isConsoleCall(callee, strategy) {
+    if (strategy)
+        return strategy.isConsoleCall(callee);
+    return callee.startsWith("console.");
+}
+/**
+ * Gets the console method name from a callee (e.g., "log" from "console.log")
+ */
+export function getConsoleMethod(callee) {
+    return callee.slice("console.".length);
+}
+/**
+ * Checks if an expression requires runtime execution (cannot be evaluated at global scope in C++).
+ * Compile-time expressions can be placed at global scope; runtime expressions must go in setup()/main().
+ *
+ * @param expr The expression to check
+ * @returns true if the expression requires runtime execution
+ */
+export function collectExpressionIdentifiers(expr) {
+    const names = new Set();
+    function scan(e) {
+        if (!e || typeof e !== 'object' || !e.kind)
+            return;
+        if (e.kind === "identifier") {
+            names.add(e.value);
+            return;
+        }
+        for (const key of Object.keys(e)) {
+            if (key === "kind" || key === "loc" || key === "range" || key === "sourceSpan")
+                continue;
+            const val = e[key];
+            if (Array.isArray(val)) {
+                for (const item of val) {
+                    if (item && typeof item === 'object' && item.kind)
+                        scan(item);
+                }
+            }
+            else if (val && typeof val === 'object' && val.kind) {
+                scan(val);
+            }
+        }
+    }
+    scan(expr);
+    return names;
+}
+export function isRuntimeExpression(expr) {
+    // Safety check
+    if (!expr || typeof expr !== 'object' || !expr.kind) {
+        return false;
+    }
+    switch (expr.kind) {
+        case "number":
+        case "string":
+        case "boolean":
+            // Literals are compile-time constants
+            return false;
+        case "identifier":
+            // Simple identifiers might be compile-time constants, but could also be
+            // runtime values. We'll be conservative and allow them at global scope
+            // since they might reference constants.
+            return false;
+        case "array":
+            // Arrays are okay at global scope if all elements are compile-time
+            return expr.elements.some((e) => isRuntimeExpression(e));
+        case "object":
+            // Plain object literals can stay at global scope as long as all their
+            // field initializers are themselves compile-time-safe.
+            return expr.fields.some((f) => isRuntimeExpression(f.value));
+        case "raw":
+            // Raw expressions might contain method calls - check for common patterns
+            // Look for function/method call patterns: identifier(...) or ...(...)
+            const rawValue = expr.value;
+            // Check for call patterns: ends with ) and contains ( not at start
+            if (rawValue.includes("(") && rawValue.includes(")")) {
+                // Has function call syntax - likely runtime
+                return true;
+            }
+            // Check for 'new' keyword
+            if (rawValue.startsWith("new ") || rawValue.includes(" new ")) {
+                return true;
+            }
+            return false;
+        case "await":
+            // Await expressions are definitely runtime
+            return true;
+        case "ternary":
+            // Ternary expressions are runtime if any part is runtime
+            return (isRuntimeExpression(expr.condition) ||
+                isRuntimeExpression(expr.whenTrue) ||
+                isRuntimeExpression(expr.whenFalse));
+        case "binary":
+            return isRuntimeExpression(expr.left) || isRuntimeExpression(expr.right);
+        case "unary":
+            return isRuntimeExpression(expr.operand);
+        case "method-call":
+            return true;
+        case "instanceof":
+            // instanceof requires RTTI and runtime evaluation
+            return true;
+        case "spread_array":
+            // Spread operations are runtime
+            return true;
+        case "property-access":
+            // An enum member access (Mode.Run → Mode::Run) is a compile-time
+            // constant, NOT a runtime expression. Without this, a top-level
+            // `const currentMode: Mode = Mode.Run` was classified as runtime
+            // (the default returns true) and emitted as a local inside setup()
+            // instead of a file-scope global, making it invisible to functions
+            // (enum stress test Finding B). Only consider it compile-time when
+            // it's a static/enum access (no runtime object receiver).
+            return false;
+        default:
+            // Unknown expression types - be conservative
+            return true;
+    }
+}
+/**
+ * Checks if a statement requires runtime execution.
+ *
+ * @param statement The statement to check
+ * @returns true if the statement requires runtime execution
+ */
+export function statementRequiresRuntime(statement) {
+    if (statement.kind === "var_decl") {
+        // Variable declaration requires runtime if its initializer does
+        return statement.initializer ? isRuntimeExpression(statement.initializer) : false;
+    }
+    // All other statement types (calls, assignments, etc.) are runtime
+    return true;
+}
+/**
+ * Collects pointer variable types from program statements.
+ * Variables initialized with 'new ClassName()' get type 'ClassName*'.
+ *
+ * @param statements The statements to analyze
+ * @param classNameMap Optional map for transforming simple class names to fully qualified names
+ * @returns Map of variable names to their pointer types
+ */
+export function collectPointerVarTypes(statements, classNameMap) {
+    const pointerVarTypes = new Map();
+    for (const statement of statements) {
+        if (statement.kind === "var_decl" && statement.initializer) {
+            const declaredType = statement.cppType;
+            if (parsedIsPointer(declaredType)) {
+                pointerVarTypes.set(statement.name, declaredType);
+                continue;
+            }
+            const init = statement.initializer;
+            // Check for raw expression containing 'new'
+            if (init.kind === "raw" && init.value.startsWith("new ")) {
+                // Extract class name from 'new ClassName(...)'
+                const match = init.value.match(/^new\s+(\w+)/);
+                if (match) {
+                    const simpleName = match[1];
+                    // Use fully qualified name if available (for namespaced classes)
+                    const fullName = classNameMap?.get(simpleName) ?? simpleName;
+                    pointerVarTypes.set(statement.name, `${fullName}*`);
+                }
+            }
+        }
+    }
+    return pointerVarTypes;
+}

package/dist/eslint-check.d.ts

@@ -0,0 +1,10 @@
+export interface ESLintError {
+    filePath: string;
+    line: number;
+    column: number;
+    message: string;
+    ruleId: string;
+    sourceLine: string;
+}
+export declare function runEslintCheck(projectRoot: string): Promise<ESLintError[]>;
+export declare function printEslintErrors(errors: ESLintError[]): void;

package/dist/eslint-check.js

@@ -0,0 +1,102 @@
+import path from "node:path";
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+import chalk from "chalk";
+const selfRequire = createRequire(import.meta.url);
+export async function runEslintCheck(projectRoot) {
+    // Look for eslint config in .cuttlefish/ (new layout) or project root (legacy)
+    const cuttlefishConfig = path.join(projectRoot, ".cuttlefish", "eslint.config.mjs");
+    const rootConfigNames = ["eslint.config.mjs", "eslint.config.js", "eslint.config.cjs"];
+    const rootConfig = rootConfigNames.find(name => fs.existsSync(path.join(projectRoot, name)));
+    let overrideConfigFile;
+    if (fs.existsSync(cuttlefishConfig)) {
+        overrideConfigFile = cuttlefishConfig;
+    }
+    else if (rootConfig) {
+        // Legacy: config at project root (existing demo projects)
+        overrideConfigFile = path.join(projectRoot, rootConfig);
+    }
+    else {
+        return [];
+    }
+    let ESLintCls;
+    try {
+        // Prefer the user project's own eslint install (handles pinned versions),
+        // then fall back to the cuttlefish package's install (monorepo / global).
+        let eslintPath;
+        try {
+            const projectRequire = createRequire(path.join(projectRoot, "package.json"));
+            eslintPath = projectRequire.resolve("eslint");
+        }
+        catch {
+            eslintPath = selfRequire.resolve("eslint");
+        }
+        const eslintModule = await import(pathToFileURL(eslintPath).href);
+        ESLintCls = eslintModule.ESLint;
+    }
+    catch {
+        return [];
+    }
+    if (!ESLintCls)
+        return [];
+    const eslint = new ESLintCls({ cwd: projectRoot, overrideConfigFile });
+    const srcDir = path.join(projectRoot, "src");
+    if (!fs.existsSync(srcDir))
+        return [];
+    let results;
+    try {
+        results = await eslint.lintFiles([srcDir]);
+    }
+    catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        // "All files matched by ... are ignored" is raised when src/ contains no
+        // lintable .ts files (e.g. a pure-.ui entry). That is a legitimate no-op,
+        // not a config-load failure — return [] so the build proceeds.
+        if (/all files matched/i.test(detail) && /ignored/i.test(detail)) {
+            return [];
+        }
+        // A config that exists but cannot be loaded (broken import, bad parser
+        // reference, etc.) means linting silently no-ops — the exact regression
+        // this gate exists to prevent. Surface it instead of returning [].
+        throw new Error(`ESLint config could not be loaded from ${overrideConfigFile}:\n${detail}\n\n` +
+            `Fix the config so linting runs, or remove it to skip the ESLint gate.`);
+    }
+    const errors = [];
+    for (const result of results) {
+        if (result.errorCount === 0)
+            continue;
+        const sourceLines = result.source
+            ? result.source.split("\n")
+            : fs.existsSync(result.filePath)
+                ? fs.readFileSync(result.filePath, "utf-8").split("\n")
+                : [];
+        for (const msg of result.messages) {
+            if (msg.severity !== 2)
+                continue;
+            errors.push({
+                filePath: path.relative(projectRoot, result.filePath),
+                line: msg.line,
+                column: msg.column,
+                message: msg.message,
+                ruleId: msg.ruleId ?? "unknown",
+                sourceLine: sourceLines[msg.line - 1] ?? "",
+            });
+        }
+    }
+    return errors;
+}
+export function printEslintErrors(errors) {
+    for (const err of errors) {
+        const location = `${err.filePath}(${err.line},${err.column})`;
+        const rule = chalk.gray(`[${err.ruleId}]`);
+        console.error(`${chalk.red.bold("error")} ${location} ${rule}: ${chalk.white(err.message)}`);
+        if (err.sourceLine) {
+            const prefix = "    ";
+            console.error(prefix + err.sourceLine);
+            console.error(chalk.gray(prefix + " ".repeat(Math.max(0, err.column - 1)) + "^"));
+        }
+    }
+    console.error("");
+    console.error(chalk.red(`✖ ${errors.length} ESLint error${errors.length === 1 ? "" : "s"} — build stopped`));
+}

package/dist/framework-package.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Load a framework package and populate the LoadedFramework registry.
+ *
+ * The loaded module is expected to export at minimum `FrameworkStrategy`.
+ * Optional exports include `Toolchain`, `SYMBOL_KINDS`, library resolver,
+ * class name map builder, and lib declaration generator.
+ *
+ * Returns the raw module for backward compatibility.
+ */
+export declare function loadFrameworkPackage(packageName: string, fromDir?: string): any;