@typecad/expect 0.1.0-alpha.1

package/dist/host/cli.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+// ---------------------------------------------------------------------------
+// @typecad/expect — CLI entry point
+//
+// Usage:
+//   cuttlefish-test [options] [files...]
+//
+// Options:
+//   --port <port>       Serial port (e.g. COM3, /dev/ttyACM0)
+//   --board <board>     Board package override
+//   --build-target <id> Framework-specific build target override
+//   --baud <rate>       Serial baud rate (default: 115200)
+//   --timeout <ms>      Serial read timeout in ms (default: 30000)
+//   --include <glob>    Test file glob pattern (repeatable)
+//   --exclude <glob>    Test file glob pattern to skip (repeatable)
+//   --verbose           Show debug serial output and assertion details
+//   --help              Show this help
+//
+// If no files are given, discovers tests via config include patterns.
+// ---------------------------------------------------------------------------
+import { loadConfig } from './config.js';
+import { run } from './runner.js';
+import path from 'node:path';
+function parseArgs(argv) {
+    const result = { files: [] };
+    const args = argv.slice(2); // skip node + script
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        switch (arg) {
+            case '--port':
+            case '-p':
+                result.port = args[++i];
+                break;
+            case '--board':
+            case '-b':
+                result.board = args[++i];
+                break;
+            case '--build-target':
+                result.buildTarget = args[++i];
+                break;
+            case '--baud': {
+                const val = args[++i];
+                const num = parseInt(val, 10);
+                if (isNaN(num)) {
+                    console.error(`--baud requires a number, got "${val}"`);
+                    process.exit(2);
+                }
+                result.baudRate = num;
+                break;
+            }
+            case '--timeout':
+            case '-t': {
+                const val = args[++i];
+                const num = parseInt(val, 10);
+                if (isNaN(num)) {
+                    console.error(`--timeout requires a number, got "${val}"`);
+                    process.exit(2);
+                }
+                result.timeout = num;
+                break;
+            }
+            case '--include':
+            case '-i':
+                if (!result.include)
+                    result.include = [];
+                result.include.push(args[++i]);
+                break;
+            case '--exclude':
+            case '-x':
+                if (!result.exclude)
+                    result.exclude = [];
+                result.exclude.push(args[++i]);
+                break;
+            case '--verbose':
+            case '-v':
+                result.verbose = true;
+                break;
+            case '--help':
+            case '-h':
+                result.help = true;
+                break;
+            default:
+                if (!arg.startsWith('-')) {
+                    result.files.push(arg);
+                }
+                else {
+                    console.error(`Unknown option: ${arg}`);
+                    process.exit(2);
+                }
+        }
+    }
+    return result;
+}
+// ---------------------------------------------------------------------------
+// Help text
+// ---------------------------------------------------------------------------
+const HELP = `
+\x1b[1m\x1b[36m cuttlefish-test\x1b[0m — Hardware test runner for TypeCAD
+
+\x1b[1mUsage:\x1b[0m
+  cuttlefish-test [options] [files...]
+
+\x1b[1mOptions:\x1b[0m
+  --port, -p <port>     Serial port (e.g. COM4, /dev/ttyACM0)
+  --board, -b <board>   Board package override
+  --build-target <id>   Framework-specific build target override
+  --baud <rate>         Serial baud rate (default: 115200)
+  --timeout, -t <ms>    Serial read timeout (default: 30000)
+  --include, -i <glob>  Test file pattern (repeatable)
+  --exclude, -x <glob>  Test file pattern to skip (repeatable)
+  --verbose, -v         Show debug serial output
+  --help, -h            Show this help
+
+\x1b[1mExamples:\x1b[0m
+  cuttlefish-test --port COM4
+  cuttlefish-test --port /dev/ttyACM0 tests/my-test.test.ts
+  cuttlefish-test -p COM4 -v
+
+\x1b[1mConfiguration:\x1b[0m
+  Add a \`test\` section to your cuttlefish.config.ts:
+
+    const config = {
+      board: '@typecad/board-arduino-uno',
+      test: {
+        buildTarget: 'arduino:avr:uno',
+        port: 'COM4',
+        include: ['tests/**/*.test.ts'],
+        baudRate: 115200,
+        timeout: 30000,
+      },
+    };
+`.trim();
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+async function main() {
+    const args = parseArgs(process.argv);
+    if (args.help) {
+        console.log(HELP);
+        process.exit(0);
+    }
+    const projectRoot = process.cwd();
+    // Build config overrides from CLI args
+    const overrides = {};
+    if (args.port)
+        overrides.port = args.port;
+    if (args.board)
+        overrides.board = args.board;
+    if (args.buildTarget)
+        overrides.buildTarget = args.buildTarget;
+    if (args.baudRate)
+        overrides.baudRate = args.baudRate;
+    if (args.timeout)
+        overrides.timeout = args.timeout;
+    if (args.verbose)
+        overrides.verbose = args.verbose;
+    if (args.exclude)
+        overrides.exclude = args.exclude;
+    // If files are specified directly, use them as include patterns
+    if (args.files.length > 0) {
+        overrides.include = args.files.map(f => {
+            // Convert relative paths to be relative to project root
+            return path.isAbsolute(f) ? path.relative(projectRoot, f) : f;
+        });
+    }
+    else if (args.include) {
+        overrides.include = args.include;
+    }
+    // Load config
+    let config;
+    try {
+        config = loadConfig(projectRoot, overrides);
+    }
+    catch (e) {
+        console.error(`\x1b[31m${e.message}\x1b[0m`);
+        process.exit(2);
+    }
+    // Run tests
+    const exitCode = await run(config);
+    process.exit(exitCode);
+}
+main().catch((e) => {
+    console.error(`\x1b[31mFatal error: ${e.message}\x1b[0m`);
+    process.exit(2);
+});

package/dist/host/compiler.d.ts

@@ -0,0 +1,27 @@
+export interface CompileResult {
+    success: boolean;
+    sketchDir: string;
+    sketchPath: string;
+    output: string;
+    error?: string;
+}
+export interface UploadResult {
+    success: boolean;
+    output: string;
+    error?: string;
+}
+/**
+ * Transpile preprocessed TypeScript source to a C++ Arduino sketch.
+ *
+ * Writes the preprocessed source to a temp file, invokes the cuttlefish
+ * transpiler, and returns the path to the generated .ino file.
+ */
+export declare function transpileTestFile(preprocessedSource: string, originalFilePath: string, projectRoot: string, buildTarget: string): CompileResult;
+/**
+ * Compile the Arduino sketch using arduino-cli.
+ */
+export declare function compileSketch(sketchDir: string, buildTarget: string): CompileResult;
+/**
+ * Upload the compiled sketch to the board.
+ */
+export declare function uploadSketch(sketchDir: string, buildTarget: string, port: string): UploadResult;

package/dist/host/compiler.js

@@ -0,0 +1,250 @@
+// ---------------------------------------------------------------------------
+// @typecad/expect — Compiler
+//
+// Wraps the cuttlefish transpiler + arduino-cli compile/upload cycle.
+// Takes preprocessed TypeScript source, transpiles to C++, compiles, uploads.
+// ---------------------------------------------------------------------------
+import path from 'node:path';
+import fs from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { parseConfigAST } from './config.js';
+/**
+ * Transpile preprocessed TypeScript source to a C++ Arduino sketch.
+ *
+ * Writes the preprocessed source to a temp file, invokes the cuttlefish
+ * transpiler, and returns the path to the generated .ino file.
+ */
+export function transpileTestFile(preprocessedSource, originalFilePath, projectRoot, buildTarget) {
+    // Create a build directory for this test file
+    const baseName = path.basename(originalFilePath, '.test.ts').replace(/[^a-zA-Z0-9_]/g, '_');
+    const buildDir = path.join(projectRoot, '.build', 'expect', baseName);
+    try {
+        fs.rmSync(buildDir, { recursive: true, force: true });
+        fs.mkdirSync(buildDir, { recursive: true });
+    }
+    catch {
+        return { success: false, sketchDir: buildDir, sketchPath: '', output: '', error: `Failed to create build dir: ${buildDir}` };
+    }
+    const rewrittenSource = rewriteRelativeImports(preprocessedSource, originalFilePath, buildDir);
+    // Write the preprocessed source as a .ts file
+    const tsPath = path.join(buildDir, `${baseName}.ts`);
+    fs.writeFileSync(tsPath, rewrittenSource, 'utf8');
+    // Invoke the cuttlefish transpiler
+    // We call it as a CLI command rather than importing to avoid coupling
+    const cuttlefishCmd = resolveCuttlefishCmd(projectRoot);
+    const useBuildMode = hasRelativeImports(rewrittenSource);
+    if (useBuildMode) {
+        writeBuildConfig(buildDir, projectRoot, path.basename(tsPath), buildTarget);
+    }
+    const result = spawnSync(process.execPath, useBuildMode
+        ? [cuttlefishCmd, 'build', '--skip-type-check', '--force']
+        : [cuttlefishCmd, tsPath, '--skip-type-check', '--force'], {
+        encoding: 'utf8',
+        cwd: useBuildMode ? buildDir : projectRoot,
+        timeout: 60000,
+        env: { ...process.env },
+    });
+    const transpileOutput = `${result.stdout ?? ''}\n${result.stderr ?? ''}`.trim();
+    if (result.status !== 0) {
+        return {
+            success: false,
+            sketchDir: buildDir,
+            sketchPath: '',
+            output: transpileOutput,
+            error: `Transpilation failed:\n${transpileOutput}`,
+        };
+    }
+    // Find the generated .ino file
+    const outDir = findOutputDir(buildDir, baseName, projectRoot);
+    const inoPath = findInoFile(outDir);
+    if (!inoPath) {
+        return {
+            success: false,
+            sketchDir: outDir,
+            sketchPath: '',
+            output: transpileOutput,
+            error: `No .ino file found in ${outDir} after transpilation`,
+        };
+    }
+    return {
+        success: true,
+        sketchDir: path.dirname(inoPath),
+        sketchPath: inoPath,
+        output: transpileOutput,
+    };
+}
+/**
+ * Compile the Arduino sketch using arduino-cli.
+ */
+export function compileSketch(sketchDir, buildTarget) {
+    const result = spawnSync('arduino-cli', ['compile', '--fqbn', buildTarget, sketchDir], { encoding: 'utf8', timeout: 120000 });
+    const output = `${result.stdout ?? ''}\n${result.stderr ?? ''}`.trim();
+    return {
+        success: result.status === 0,
+        sketchDir,
+        sketchPath: '',
+        output,
+        error: result.status !== 0 ? `Compilation failed:\n${output}` : undefined,
+    };
+}
+/**
+ * Upload the compiled sketch to the board.
+ */
+export function uploadSketch(sketchDir, buildTarget, port) {
+    const result = spawnSync('arduino-cli', ['upload', '--fqbn', buildTarget, '--port', port, sketchDir], { encoding: 'utf8', timeout: 60000 });
+    const output = `${result.stdout ?? ''}\n${result.stderr ?? ''}`.trim();
+    return {
+        success: result.status === 0,
+        output,
+        error: result.status !== 0 ? `Upload failed:\n${output}` : undefined,
+    };
+}
+// ---------------------------------------------------------------------------
+// Internal
+// ---------------------------------------------------------------------------
+function resolveCuttlefishCmd(projectRoot) {
+    // Try to find cuttlefish CLI in the monorepo (current dir and parent dirs).
+    // We prefer the JS entry point over the .bin shims because the shell wrapper
+    // (no extension) cannot be passed to `node process.execPath` on Windows, and
+    // invoking it via the shell would require platform-specific handling.
+    let searchDir = projectRoot;
+    for (let i = 0; i < 5; i++) {
+        const candidates = [
+            path.join(searchDir, 'packages', 'cuttlefish', 'dist', 'cli.js'),
+            path.join(searchDir, 'node_modules', '@typecad', 'cuttlefish', 'dist', 'cli.js'),
+            path.join(searchDir, 'node_modules', 'cuttlefish', 'dist', 'cli.js'),
+        ];
+        for (const c of candidates) {
+            if (fs.existsSync(c))
+                return c;
+        }
+        const parent = path.dirname(searchDir);
+        if (parent === searchDir)
+            break; // reached root
+        searchDir = parent;
+    }
+    // Fallback: assume it's on PATH
+    return 'cuttlefish';
+}
+function findOutputDir(buildDir, baseName, projectRoot) {
+    // The cuttlefish transpiler writes output next to the source by default,
+    // or to the configured outDir.  Check common locations.
+    const candidates = [
+        buildDir,
+        path.join(buildDir, baseName),
+        path.join(buildDir, 'out', baseName),
+        path.join(buildDir, 'out'),
+        path.join(projectRoot, 'out'),
+        path.join(projectRoot, '.build', 'expect', baseName, baseName),
+    ];
+    for (const c of candidates) {
+        if (fs.existsSync(c) && hasInoFile(c))
+            return c;
+    }
+    // Last resort: walk the buildDir tree recursively to find any .ino
+    const found = findInoFileRecursive(buildDir);
+    if (found)
+        return path.dirname(found);
+    return buildDir;
+}
+function hasInoFile(dir) {
+    if (!fs.existsSync(dir))
+        return false;
+    return fs.readdirSync(dir).some(f => f.endsWith('.ino'));
+}
+function findInoFile(dir) {
+    if (!fs.existsSync(dir))
+        return undefined;
+    for (const entry of fs.readdirSync(dir)) {
+        if (entry.endsWith('.ino')) {
+            return path.join(dir, entry);
+        }
+    }
+    return undefined;
+}
+function findInoFileRecursive(dir) {
+    if (!fs.existsSync(dir))
+        return undefined;
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (entry.name.endsWith('.ino')) {
+            return path.join(dir, entry.name);
+        }
+        if (entry.isDirectory()) {
+            const result = findInoFileRecursive(path.join(dir, entry.name));
+            if (result)
+                return result;
+        }
+    }
+    return undefined;
+}
+function hasRelativeImports(source) {
+    return /from\s+['"]\.\.?\//.test(source);
+}
+function rewriteRelativeImports(source, originalFilePath, buildDir) {
+    const originalDir = path.dirname(originalFilePath);
+    return source.replace(/from\s+(['"])(\.\.?\/[^'"]+)\1/g, (_match, quote, specifier) => {
+        const resolvedPath = path.resolve(originalDir, specifier);
+        let relativePath = path.relative(buildDir, resolvedPath).replace(/\\/g, '/');
+        if (!relativePath.startsWith('.')) {
+            relativePath = `./${relativePath}`;
+        }
+        return `from ${quote}${relativePath}${quote}`;
+    });
+}
+function writeBuildConfig(buildDir, projectRoot, entryFileName, buildTarget) {
+    const baseConfigPath = path.join(projectRoot, 'cuttlefish.config.ts');
+    const buildConfigPath = path.join(buildDir, 'cuttlefish.config.ts');
+    if (fs.existsSync(baseConfigPath)) {
+        // Parse base config via AST to extract scalar values, then inline them.
+        // This avoids spreads (...baseConfig) which the config loader cannot evaluate.
+        const baseValues = parseConfigAST(baseConfigPath);
+        const lines = [
+            `import type { CuttlefishConfig } from '@typecad/hal';`,
+            '',
+            'const config: CuttlefishConfig = {',
+            `  entry: './${entryFileName}',`,
+        ];
+        if (baseValues.target)
+            lines.push(`  target: '${baseValues.target}',`);
+        if (baseValues.board)
+            lines.push(`  board: '${baseValues.board}',`);
+        if (baseValues.framework)
+            lines.push(`  framework: '${baseValues.framework}',`);
+        if (baseValues.frameworkData?.buildTarget)
+            lines.push(`  frameworkData: { buildTarget: '${baseValues.frameworkData.buildTarget}' },`);
+        lines.push('  output: {');
+        if (baseValues.output?.framework)
+            lines.push(`    framework: '${baseValues.output?.framework}',`);
+        if (baseValues.output?.optimize)
+            lines.push(`    optimize: '${baseValues.output?.optimize}',`);
+        lines.push(`    outDir: './out',`);
+        lines.push('  },');
+        if (baseValues.console?.baudRate) {
+            lines.push('  console: {');
+            lines.push(`    baudRate: ${baseValues.console?.baudRate},`);
+            lines.push('  },');
+        }
+        lines.push('};');
+        lines.push('');
+        lines.push('export default config;');
+        lines.push('');
+        fs.writeFileSync(buildConfigPath, lines.join('\n'), 'utf8');
+        return;
+    }
+    fs.writeFileSync(buildConfigPath, [
+        `import type { CuttlefishConfig } from '@typecad/hal';`,
+        '',
+        'const config: CuttlefishConfig = {',
+        `  entry: './${entryFileName}',`,
+        `  target: 'avr',`,
+        `  frameworkData: { buildTarget: '${buildTarget}' },`,
+        '  output: {',
+        `    framework: 'arduino',`,
+        `    outDir: './out',`,
+        '  },',
+        '};',
+        '',
+        'export default config;',
+        '',
+    ].join('\n'), 'utf8');
+}

package/dist/host/config.d.ts

@@ -0,0 +1,29 @@
+import type { ResolvedConfig, TestConfig } from './types.js';
+/**
+ * Load configuration from `cuttlefish.config.ts` in the given project root.
+ *
+ * Parses the config file via the TypeScript AST (no dynamic import) to
+ * extract scalar properties — consistent with how the cuttlefish CLI does it.
+ *
+ * @param projectRoot  Absolute path to the project root.
+ * @param overrides    CLI flag overrides for test config.
+ */
+export declare function loadConfig(projectRoot: string, overrides?: Partial<TestConfig>): ResolvedConfig;
+export interface RawConfig {
+    target?: string;
+    board?: string;
+    frameworkData?: {
+        buildTarget?: string;
+    };
+    framework?: string;
+    test?: Partial<TestConfig>;
+    output?: {
+        framework?: string;
+        optimize?: string;
+        outDir?: string;
+    };
+    console?: {
+        baudRate?: number;
+    };
+}
+export declare function parseConfigAST(configPath: string): RawConfig;