@typecad/cuttlefish 0.1.0-alpha.1

package/dist/utils/strings.js

@@ -0,0 +1,142 @@
+import path from "node:path";
+function stripExtension(fileName) {
+    return fileName.replace(/\.[^.]+$/, "");
+}
+export function toModuleKey(moduleSpecifier) {
+    const normalized = moduleSpecifier.replace(/\\/g, "/");
+    const base = path.posix.basename(normalized);
+    return stripExtension(base).toLowerCase();
+}
+export function toPascalCase(input) {
+    return input
+        .split(/[^a-zA-Z0-9]+/)
+        .filter(Boolean)
+        .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
+        .join("");
+}
+export function withLineColumn(content, position) {
+    const prefix = content.slice(0, position);
+    const lines = prefix.split(/\r?\n/);
+    return {
+        line: lines.length,
+        column: (lines.at(-1)?.length ?? 0) + 1,
+    };
+}
+/**
+ * C++ reserved keywords that cannot be used as identifiers.
+ * When a TypeScript parameter/variable name matches one of these,
+ * we append an underscore to avoid compile errors.
+ */
+const CPP_RESERVED_KEYWORDS = new Set([
+    // C keywords also reserved in C++
+    "auto", "break", "case", "char", "const", "continue", "default", "do",
+    "double", "else", "enum", "extern", "float", "for", "goto", "if",
+    "int", "long", "register", "return", "short", "signed", "sizeof",
+    "static", "struct", "switch", "typedef", "union", "unsigned", "void",
+    "volatile", "while",
+    // C++-specific keywords
+    "alignas", "alignof", "and", "and_eq", "asm", "atomic_cancel",
+    "atomic_commit", "atomic_noexcept", "bitand", "bitor", "bool",
+    "catch", "char16_t", "char32_t", "char8_t", "class", "compl",
+    "concept", "const_cast", "consteval", "constexpr", "constinit",
+    "co_await", "co_return", "co_yield", "decltype", "delete",
+    "dynamic_cast", "explicit", "export", "false", "friend", "inline",
+    "mutable", "namespace", "new", "noexcept", "not", "not_eq",
+    "nullptr", "operator", "or", "or_eq", "private", "protected",
+    "public", "reflexpr", "reinterpret_cast", "requires", "static_assert",
+    "static_cast", "template", "this", "thread_local", "throw",
+    "true", "try", "typedef", "typeid", "typename", "using",
+    "virtual", "wchar_t", "xor", "xor_eq",
+]);
+const C_STDLIB_RESERVED_NAMES = new Set([
+    "abort", "abs", "acos", "asin", "atan", "atan2",
+    "atexit", "atof", "atoi", "atol",
+    "calloc", "ceil", "clearerr", "clock", "cos", "cosh", "ctime",
+    "div", "exit", "exp",
+    "fabs", "fclose", "feof", "ferror", "fflush", "fgetc", "fgetpos", "fgets",
+    "floor", "fmod", "fopen", "fprintf", "fputc", "fputs", "fread", "free",
+    "freopen", "frexp", "fscanf", "fseek", "fsetpos", "ftell", "fwrite",
+    "getc", "getchar", "getenv", "gets", "gmtime",
+    "isalnum", "isalpha", "iscntrl", "isdigit", "isgraph", "islower",
+    "isprint", "ispunct", "isspace", "isupper", "isxdigit",
+    "labs", "ldexp", "ldiv", "localtime", "log", "log10", "longjmp",
+    "malloc", "memchr", "memcmp", "memcpy", "memmove", "memset", "mktime", "modf",
+    "perror", "pow", "printf", "putc", "putchar", "puts",
+    "qsort",
+    "raise", "rand", "realloc", "remove", "rename", "rewind",
+    "scanf", "setbuf", "setjmp", "setvbuf", "signal", "sin", "sinh", "sprintf",
+    "sqrt", "srand", "sscanf", "strcat", "strchr", "strcmp", "strcoll",
+    "strcpy", "strcspn", "strerror", "strftime", "strlen", "strncat", "strncmp",
+    "strncpy", "strpbrk", "strrchr", "strspn", "strstr", "strtod", "strtok",
+    "strtol", "strtoul", "strxfrm", "system",
+    "tan", "tanh", "time", "tmpfile", "tmpnam", "tolower", "toupper",
+    "ungetc",
+    "va_arg", "va_end", "va_start",
+    "vfprintf", "vprintf", "vsprintf",
+]);
+/**
+ * Escapes a name that conflicts with a C++ reserved keyword by appending `_`.
+ * Additionally checks against the optional `platformNames` set, which should
+ * come from `PlatformStrategy.reservedNames()` for the active framework.
+ *
+ * For example, `register` → `register_`.
+ * With Arduino strategy: `min` → `min_`, `map` → `map_`.
+ */
+export function escapeCppKeyword(name, platformNames) {
+    if (CPP_RESERVED_KEYWORDS.has(name)) {
+        return `${name}_`;
+    }
+    if (C_STDLIB_RESERVED_NAMES.has(name)) {
+        return `${name}_`;
+    }
+    if (platformNames?.has(name)) {
+        return `${name}_`;
+    }
+    return name;
+}
+/**
+ * Escape the trailing member name of a (possibly compound) C++ lvalue/access
+ * string against the reserved-name sets. Handles both bare identifiers
+ * (`min` → `min_`) and member-access chains (`this->min`, `obj.min`,
+ * `ptr->field`) by renaming only the final segment, so a reserved member name
+ * is escaped consistently with how the field is DECLARED (renameStructField /
+ * escapeCppKeyword applied to the bare field name). Demo #33: applying plain
+ * escapeCppKeyword to the compound string `this.min` left `min` untouched,
+ * diverging from the access path and producing a declaration/access mismatch.
+ */
+export function escapeTrailingMember(text, platformNames) {
+    // A member-access chain ends in `->name`, `.name`, or `::name`. Rename only
+    // the trailing identifier so the receiver chain is preserved verbatim.
+    const match = text.match(/^(.*?(?:->|\.|::))([A-Za-z_][A-Za-z0-9_]*)$/);
+    if (match) {
+        const [, prefix, member] = match;
+        return `${prefix}${escapeCppKeyword(member, platformNames)}`;
+    }
+    // No member-access separator — treat the whole text as a bare identifier.
+    return escapeCppKeyword(text, platformNames);
+}
+export function escapeCppStringLiteral(value) {
+    return value
+        .replace(/\\/g, "\\\\")
+        .replace(/"/g, '\\"')
+        .replace(/\n/g, "\\n")
+        .replace(/\r/g, "\\r")
+        .replace(/\t/g, "\\t");
+}
+/** Escape a literal text fragment destined for a snprintf *format* string.
+ *  Same as escapeCppStringLiteral, but also doubles `%` so a trailing or
+ *  embedded percent (e.g. `meter: ${v}%`) doesn't get misread as a conversion
+ *  specifier on hardware. Use this for any fragment that becomes part of the
+ *  format argument to snprintf(...) — NOT for snprintf *arguments* or for
+ *  standalone C++ string literals, where a bare `%` is harmless. */
+export function escapeSnprintfFormatFragment(value) {
+    return escapeCppStringLiteral(value).replace(/%/g, "%%");
+}
+export function normalizeKebabName(name) {
+    return name
+        .toLowerCase()
+        .replace(/[\s_]+/g, '-')
+        .replace(/[^a-z0-9-]/g, '')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+}

package/dist/utils/ui.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Print the Cuttlefish branded header
+ */
+export declare function printHeader(): void;
+/**
+ * Print build configuration info
+ */
+export declare function printBuildInfo(options: {
+    framework?: string;
+    mcu?: string;
+    board?: string;
+    buildTarget?: string;
+}): void;
+/**
+ * Print discovered tasks and timers
+ */
+export declare function printTasks(tasks: string[], usesTimers: boolean): void;
+/**
+ * Print a step notification (transpiling, compiling, etc.)
+ */
+export declare function printStep(message: string): void;
+/**
+ * Print transpiling step
+ */
+export declare function printTranspiling(): void;
+/**
+ * Print compiling step
+ */
+export declare function printCompiling(target: string): void;
+/**
+ * Print uploading step
+ */
+export declare function printUploading(port: string): void;
+/**
+ * Print monitoring step
+ */
+export declare function printMonitoring(port: string, baud: number): void;
+/**
+ * Print success message
+ */
+export declare function printSuccess(message?: string): void;
+/**
+ * Print error message
+ */
+export declare function printError(message: string): void;
+/**
+ * Print warning message
+ */
+export declare function printWarning(message: string): void;
+/**
+ * Print info message
+ */
+export declare function printInfo(message: string): void;
+/**
+ * Print a file creation notification (for scaffold commands)
+ */
+export declare function printFileCreated(filePath: string): void;
+/**
+ * Print memory usage info
+ */
+export declare function printMemoryUsage(usage: {
+    flashUsed?: number;
+    flashTotal?: number;
+    ramUsed?: number;
+    ramTotal?: number;
+}): void;

package/dist/utils/ui.js

@@ -0,0 +1,149 @@
+import chalk from "chalk";
+const VERSION = "0.1.0";
+// Icons
+const ICON_CUTTLEFISH = "⤳";
+const ICON_COMPILE = "⇉";
+const ICON_UPLOAD = "↱";
+const ICON_SUCCESS = "✓";
+const ICON_ERROR = "✗";
+const ICON_INFO = "•";
+const ICON_MEMORY = " ";
+/**
+ * Print the Cuttlefish branded header
+ */
+export function printHeader() {
+    console.log();
+    console.log(chalk.cyan(`${ICON_CUTTLEFISH} Cuttlefish`) + chalk.gray(` v${VERSION}`));
+    console.log();
+}
+/**
+ * Print build configuration info
+ */
+export function printBuildInfo(options) {
+    if (options.framework) {
+        console.log(chalk.gray(`  ${ICON_INFO} Framework: `) + chalk.white(options.framework));
+    }
+    if (options.mcu) {
+        console.log(chalk.gray(`  ${ICON_INFO} MCU: `) + chalk.white(options.mcu));
+    }
+    if (options.board) {
+        console.log(chalk.gray(`  ${ICON_INFO} Board: `) + chalk.white(options.board));
+    }
+    if (options.buildTarget) {
+        console.log(chalk.gray(`  • Build Target: `) + chalk.white(options.buildTarget));
+    }
+    if (options.framework || options.mcu || options.board || options.buildTarget) {
+        console.log();
+    }
+}
+/**
+ * Print discovered tasks and timers
+ */
+export function printTasks(tasks, usesTimers) {
+    if (tasks.length === 0 && !usesTimers)
+        return;
+    console.log(chalk.gray(`  ${ICON_INFO} Discovered Tasks:`));
+    for (const task of tasks) {
+        console.log(chalk.gray(`    Task:  `) + chalk.white(task));
+    }
+    if (usesTimers) {
+        console.log(chalk.gray(`    Timer: `) + chalk.white(`Active (setInterval/setTimeout)`));
+    }
+    console.log();
+}
+/**
+ * Print a step notification (transpiling, compiling, etc.)
+ */
+export function printStep(message) {
+    console.log(chalk.cyan(`${ICON_COMPILE} ${message}`));
+}
+/**
+ * Print transpiling step
+ */
+export function printTranspiling() {
+    console.log(chalk.cyan(`${ICON_CUTTLEFISH} Transpiling...`));
+}
+/**
+ * Print compiling step
+ */
+export function printCompiling(target) {
+    console.log(chalk.cyan(`${ICON_COMPILE} Compiling for `) + chalk.white(target));
+}
+/**
+ * Print uploading step
+ */
+export function printUploading(port) {
+    console.log(chalk.cyan(`${ICON_UPLOAD} Uploading to `) + chalk.white(port));
+}
+/**
+ * Print monitoring step
+ */
+export function printMonitoring(port, baud) {
+    console.log(chalk.cyan(`${ICON_UPLOAD} Monitor `) + chalk.white(`${port} @ ${baud} baud`));
+    console.log(chalk.gray(`  Press Ctrl+C to exit`));
+}
+/**
+ * Print success message
+ */
+export function printSuccess(message = "Done") {
+    console.log(chalk.green(`${ICON_SUCCESS} ${message}`));
+}
+/**
+ * Print error message
+ */
+export function printError(message) {
+    console.log(chalk.red(`${ICON_ERROR} ${message}`));
+}
+/**
+ * Print warning message
+ */
+export function printWarning(message) {
+    console.log(chalk.yellow(`! ${message}`));
+}
+/**
+ * Print info message
+ */
+export function printInfo(message) {
+    console.log(chalk.gray(`  ${ICON_INFO} ${message}`));
+}
+/**
+ * Print a file creation notification (for scaffold commands)
+ */
+export function printFileCreated(filePath) {
+    console.log(chalk.gray(`  ${ICON_SUCCESS} ${filePath}`));
+}
+/**
+ * Print memory usage info
+ */
+export function printMemoryUsage(usage) {
+    const formatBytes = (bytes) => {
+        if (bytes < 1024)
+            return `${bytes} B`;
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    };
+    const renderBar = (used, total) => {
+        const percent = Math.round((used / total) * 100);
+        const color = percent > 90 ? chalk.red : percent > 75 ? chalk.yellow : chalk.green;
+        return color(`${percent}%`);
+    };
+    console.log(chalk.gray(`  ${ICON_MEMORY} Memory Usage:`));
+    if (usage.flashUsed !== undefined && usage.flashTotal !== undefined) {
+        console.log(chalk.gray(`    Flash: `) +
+            chalk.white(formatBytes(usage.flashUsed)) +
+            chalk.gray(` / ${formatBytes(usage.flashTotal)} (`) +
+            renderBar(usage.flashUsed, usage.flashTotal) +
+            chalk.gray(`)`));
+    }
+    if (usage.ramUsed !== undefined && usage.ramTotal !== undefined) {
+        console.log(chalk.gray(`    RAM:   `) +
+            chalk.white(formatBytes(usage.ramUsed)) +
+            chalk.gray(` / ${formatBytes(usage.ramTotal)} (`) +
+            renderBar(usage.ramUsed, usage.ramTotal) +
+            chalk.gray(`)`));
+        const free = usage.ramTotal - usage.ramUsed;
+        console.log(chalk.gray(`    Heap:  `) +
+            chalk.white(formatBytes(free)) +
+            chalk.gray(` available`));
+    }
+    console.log();
+}

package/dist/watch.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Options for the watch mode runner.
+ */
+interface WatchOptions {
+    /** Directories to watch recursively. */
+    watchDirs: string[];
+    /** Path to cuttlefish.config.ts (if any) — watched for changes. */
+    configPath?: string;
+    /** Directory containing the entry file — used for relevance filtering. */
+    entryDir: string;
+    /** Callback invoked on each relevant file change. */
+    onRebuild: (changedFile: string) => Promise<void>;
+    /** Callback invoked once after watchers are set up. */
+    onReady?: () => void;
+}
+/**
+ * Discover directories that should be watched for a given entry file and
+ * optional config path.  Returns unique, resolved directory paths.
+ */
+export declare function discoverWatchDirs(entryFile: string, configPath?: string): string[];
+/**
+ * Determine whether a file change event is relevant and should trigger a
+ * rebuild.
+ */
+export declare function isRelevantChange(changedPath: string, _entryDir: string, configPath?: string): boolean;
+/**
+ * Start the file watcher loop.  Sets up `fs.watch` listeners on each of the
+ * supplied `watchDirs`, debounces rapid events, and invokes `onRebuild` for
+ * relevant changes.
+ *
+ * This function **never resolves** under normal operation — it keeps the
+ * process alive until the user presses Ctrl+C.
+ */
+export declare function runWatch(options: WatchOptions): Promise<void>;
+export {};

package/dist/watch.js

@@ -0,0 +1,111 @@
+// ---------------------------------------------------------------------------
+// File watcher for automatic retranspilation on source changes
+// ---------------------------------------------------------------------------
+import fs from "node:fs";
+import path from "node:path";
+/** Debounce interval in milliseconds to collapse rapid file events. */
+const DEBOUNCE_MS = 150;
+/**
+ * Discover directories that should be watched for a given entry file and
+ * optional config path.  Returns unique, resolved directory paths.
+ */
+export function discoverWatchDirs(entryFile, configPath) {
+    const dirs = new Set();
+    // Always watch the entry file's directory tree
+    dirs.add(path.dirname(path.resolve(entryFile)));
+    // Also watch the config file's directory if it lives elsewhere
+    if (configPath) {
+        dirs.add(path.dirname(path.resolve(configPath)));
+    }
+    return [...dirs];
+}
+/**
+ * Determine whether a file change event is relevant and should trigger a
+ * rebuild.
+ */
+export function isRelevantChange(changedPath, _entryDir, configPath) {
+    const resolved = path.resolve(changedPath);
+    const ext = path.extname(resolved).toLowerCase();
+    if (configPath && resolved === path.resolve(configPath)) {
+        return true;
+    }
+    if (ext !== ".ts") {
+        return false;
+    }
+    if (resolved.endsWith(".d.ts")) {
+        return false;
+    }
+    if (resolved.includes(`${path.sep}node_modules${path.sep}`)) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Start the file watcher loop.  Sets up `fs.watch` listeners on each of the
+ * supplied `watchDirs`, debounces rapid events, and invokes `onRebuild` for
+ * relevant changes.
+ *
+ * This function **never resolves** under normal operation — it keeps the
+ * process alive until the user presses Ctrl+C.
+ */
+export async function runWatch(options) {
+    const { watchDirs, configPath, entryDir, onRebuild, onReady } = options;
+    const watchers = [];
+    let debounceTimer = null;
+    let rebuilding = false;
+    // ---- Debounced rebuild scheduler ----------------------------------------
+    const scheduleRebuild = (changedFile) => {
+        if (!isRelevantChange(changedFile, entryDir, configPath)) {
+            return;
+        }
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+        }
+        debounceTimer = setTimeout(async () => {
+            debounceTimer = null;
+            if (rebuilding)
+                return;
+            rebuilding = true;
+            try {
+                await onRebuild(changedFile);
+            }
+            finally {
+                rebuilding = false;
+            }
+        }, DEBOUNCE_MS);
+    };
+    // ---- Start watchers -----------------------------------------------------
+    for (const dir of watchDirs) {
+        try {
+            const watcher = fs.watch(dir, { recursive: true }, (_eventType, filename) => {
+                if (!filename)
+                    return;
+                scheduleRebuild(path.join(dir, filename));
+            });
+            watchers.push(watcher);
+        }
+        catch {
+            // Directory might not exist or recursive watch unsupported on this platform
+        }
+    }
+    // Signal readiness
+    onReady?.();
+    // ---- Graceful shutdown on Ctrl+C ----------------------------------------
+    const onSigInt = () => {
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+        }
+        for (const w of watchers) {
+            w.close();
+        }
+        console.log();
+        console.log("  Watch stopped.");
+        process.exit(0);
+    };
+    process.on("SIGINT", onSigInt);
+    // Return a promise that never resolves so the caller can `await` this
+    // function and block the main thread indefinitely.  The fs.watch listeners
+    // keep the Node.js event loop alive.
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    return new Promise(() => { });
+}

package/package.json

@@ -0,0 +1,127 @@
+{
+  "name": "@typecad/cuttlefish",
+  "version": "0.1.0-alpha.1",
+  "description": "TypeScript to C++ transpiler — native, Arduino, and bare-metal targets",
+  "type": "module",
+  "main": "./dist/transpile.js",
+  "types": "./dist/transpile.d.ts",
+  "bin": {
+    "cuttlefish": "dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/transpile.d.ts",
+      "default": "./dist/transpile.js"
+    },
+    "./testing": {
+      "types": "./dist/testing.d.ts",
+      "default": "./dist/testing.js"
+    },
+    "./api": {
+      "types": "./dist/api/index.d.ts",
+      "default": "./dist/api/index.js"
+    },
+    "./api/shared": {
+      "types": "./dist/api/shared/index.d.ts",
+      "default": "./dist/api/shared/index.js"
+    },
+    "./ui-hook": {
+      "types": "./dist/ui-hook.d.ts",
+      "default": "./dist/ui-hook.js"
+    },
+    "./config-loader": {
+      "types": "./dist/config-loader.d.ts",
+      "default": "./dist/config-loader.js"
+    },
+    "./stores/display-profile-store": {
+      "types": "./dist/stores/display-profile-store.d.ts",
+      "default": "./dist/stores/display-profile-store.js"
+    },
+    "./stores/theme-store": {
+      "types": "./dist/stores/theme-store.d.ts",
+      "default": "./dist/stores/theme-store.js"
+    },
+    "./api/schema": {
+      "types": "./dist/api/schema/index.d.ts",
+      "default": "./dist/api/schema/index.js"
+    },
+    "./emit/route-hal-op": {
+      "types": "./dist/emit/route-hal-op.d.ts",
+      "default": "./dist/emit/route-hal-op.js"
+    },
+    "./ir/transformers/ui-lowering": {
+      "types": "./dist/ir/transformers/ui-lowering.d.ts",
+      "default": "./dist/ir/transformers/ui-lowering.js"
+    },
+    "./ir/ui-element-auto-wire": {
+      "types": "./dist/ir/ui-element-auto-wire.d.ts",
+      "default": "./dist/ir/ui-element-auto-wire.js"
+    },
+    "./ir/transformers/ui-mount": {
+      "types": "./dist/ir/transformers/ui-mount.d.ts",
+      "default": "./dist/ir/transformers/ui-mount.js"
+    },
+    "./ir/transformers/ui-reactive": {
+      "types": "./dist/ir/transformers/ui-reactive.d.ts",
+      "default": "./dist/ir/transformers/ui-reactive.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "start": "node dist/cli.js"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "typescript": "^5.7.3",
+    "zod": "^3.24.0"
+  },
+  "peerDependencies": {
+    "@typecad/ui": "0.1.0-alpha.1"
+  },
+  "peerDependenciesMeta": {
+    "@typecad/ui": {
+      "optional": true
+    }
+  },
+  "optionalDependencies": {
+    "@typecad/framework-native": "0.1.0-alpha.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.7"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/justind000/typecode.git",
+    "directory": "packages/cuttlefish"
+  },
+  "homepage": "https://github.com/justind000/typecode/tree/main/packages/cuttlefish",
+  "bugs": {
+    "url": "https://github.com/justind000/typecode/issues"
+  },
+  "keywords": [
+    "arduino",
+    "cli",
+    "codegen",
+    "cpp",
+    "cuttlefish",
+    "embedded",
+    "firmware",
+    "microcontroller",
+    "transpiler",
+    "typecad",
+    "typescript"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "author": "typecad0",
+  "sideEffects": false
+}