@typecad/cuttlefish 1.0.0-alpha.14 → 1.0.0-alpha.16

package/dist/create/pack-targets.d.ts

@@ -0,0 +1,19 @@
+import type { BoardDataEntry } from '../board-catalog/types.js';
+import type { KnownTarget } from './scaffold.js';
+export declare function architectureFromSoc(soc: string): string;
+/** Look up a pack entry by qualified identifier or bare board name.
+ *  Bare names with multiple variants return the first (deterministic —
+ *  the pack is keyed in directory-walk order). */
+export declare function findPackBoard(idOrTarget: string): {
+    identifier: string;
+    name: string;
+    vendor: string;
+    soc: string;
+    probeMethods?: BoardDataEntry['probeMethods'];
+} | undefined;
+/** Build a create-flow KnownTarget from a pack entry. */
+export declare function packBoardAsTarget(entry: {
+    identifier: string;
+    name: string;
+    soc: string;
+}): KnownTarget;

package/dist/create/pack-targets.js

@@ -0,0 +1,56 @@
+// ---------------------------------------------------------------------------
+// pack-targets.ts — any-board target resolution off the generated catalog.
+//
+// The curated KNOWN_TARGETS list covers the nine hardware-validated boards;
+// the board data pack carries every Zephyr board variant (1,300+). This
+// module turns a pack entry into the same KnownTarget shape the create flow
+// consumes, so `cuttlefish create --target <any-zephyr-board>` works with no
+// per-board catalog entry. The soc's prefix derives an architecture id for
+// framework narrowing (the fallback maps unknowns to zephyr anyway).
+// ---------------------------------------------------------------------------
+import { activeBoardCatalog, findBoardInCatalog } from '../board-catalog/index.js';
+/** A coarse architecture id derived from a Zephyr soc name. Used only for
+ *  framework narrowing and display — every value here resolves through
+ *  FALLBACK_FRAMEWORKS to zephyr, which is correct for every pack board;
+ *  the known families just display nicely. */
+const SOC_FAMILIES = [
+    [/^esp32/, 'esp32'],
+    [/^nrf5/, 'nrf52'],
+    [/^nrf9/, 'nrf91'],
+    [/^stm32/, 'stm32'],
+    [/^stm32mp/, 'stm32mp1'],
+    [/^rp2/, 'rp2040'],
+    [/^samd/, 'samd'],
+    [/^mcimx|^imx/, 'imx'],
+];
+export function architectureFromSoc(soc) {
+    for (const [re, family] of SOC_FAMILIES) {
+        if (re.test(soc))
+            return family;
+    }
+    return soc;
+}
+/** Look up a pack entry by qualified identifier or bare board name.
+ *  Bare names with multiple variants return the first (deterministic —
+ *  the pack is keyed in directory-walk order). */
+export function findPackBoard(idOrTarget) {
+    const data = activeBoardCatalog();
+    const raw = idOrTarget.trim();
+    const entry = findBoardInCatalog(data, raw);
+    if (entry) {
+        return { identifier: entry.identifier, name: entry.name, vendor: entry.vendor, soc: entry.identifier.split('/')[1], probeMethods: entry.probeMethods };
+    }
+    return undefined;
+}
+/** Build a create-flow KnownTarget from a pack entry. */
+export function packBoardAsTarget(entry) {
+    return {
+        id: entry.identifier.split('/')[0],
+        displayName: entry.name,
+        isNative: false,
+        architecture: architectureFromSoc(entry.soc),
+        board: entry.identifier,
+        buildTarget: entry.identifier,
+        soc: entry.soc,
+    };
+}

package/dist/create/scaffold.d.ts

@@ -5,7 +5,9 @@ export interface KnownTarget {
     displayName: string;
     isNative: boolean;
     architecture?: ArchitectureIdentifier;
-    boardPackage?: string;
+    /** Qualified Zephyr board target — the config's board: value and the
+     *  boardgen input (materialized to .cuttlefish/board.ts at create). */
+    board?: string;
     /** Framework package + id. Optional on embedded targets: the scaffold wizard
      *  fills these in by discovering installed @typecad/framework-* packages, so
      *  KNOWN_TARGETS board entries do not hardcode a framework. Native targets
@@ -13,17 +15,12 @@ export interface KnownTarget {
     frameworkPackage?: string;
     framework?: string;
     buildTarget?: string;
-    mcu?: string;
+    soc?: string;
     /** Framework-specific config (becomes frameworkData in cuttlefish.config.ts).
      *  Carries framework-specific target/options data for the selected framework. */
     frameworkData?: Record<string, unknown>;
 }
-export declare function registerKnownTarget(target: KnownTarget): void;
 export declare const KNOWN_TARGETS: ReadonlyArray<KnownTarget>;
-/** @deprecated Use KNOWN_TARGETS */
-export declare const KNOWN_BOARDS: KnownTarget[];
-/** @deprecated Use KnownTarget */
-export type KnownBoard = KnownTarget;
 export declare function normalizeProjectName(name: string): string;
 export interface ScaffoldProjectResult {
     createdFiles: string[];

package/dist/create/scaffold.js

@@ -1,7 +1,7 @@
 import path from "node:path";
 import fs from "node:fs";
 import chalk from "chalk";
-import { generateProjectPackageJson, generateProjectTsconfig, generateProjectConfig, generateProjectEnvDts, generateStarterSketch, generateStarterTest, generateStarterSim, generateGitignore, generateEditorconfig, generateBoardForwardingFile, generateEslintConfig, } from "./templates.js";
+import { generateProjectPackageJson, generateProjectTsconfig, generateProjectConfig, generateProjectEnvDts, generateStarterProgram, generateStarterTest, generateStarterSim, generateGitignore, generateEditorconfig, generateEslintConfig, } from "./templates.js";
 import { generateEslintRules } from "./eslint-rules-template.js";
 import { writeEditorIntegration } from "./editor-integration.js";
 const _knownTargets = [
@@ -12,104 +12,10 @@ const _knownTargets = [
         frameworkPackage: '@typecad/framework-native',
         framework: 'native',
     },
-    {
-        id: 'arduino-uno',
-        displayName: 'Arduino Uno',
-        isNative: false,
-        architecture: 'avr',
-        boardPackage: '@typecad/board-arduino-uno',
-        buildTarget: 'arduino:avr:uno',
-        mcu: 'atmega328p',
-    },
-    {
-        id: 'esp32-devkit',
-        displayName: 'ESP32 DevKit',
-        isNative: false,
-        architecture: 'esp32',
-        boardPackage: '@typecad/board-esp32-devkit',
-        buildTarget: 'esp32:esp32:esp32',
-        mcu: 'esp32',
-    },
-    {
-        id: 'esp32s3',
-        displayName: 'ESP32-S3',
-        isNative: false,
-        architecture: 'esp32s3',
-        boardPackage: '@typecad/board-esp32s3',
-        buildTarget: 'esp32:esp32:esp32s3',
-        mcu: 'esp32s3',
-    },
-    {
-        id: 'esp32c3',
-        displayName: 'ESP32-C3',
-        isNative: false,
-        architecture: 'esp32c3',
-        boardPackage: '@typecad/board-esp32c3',
-        buildTarget: 'esp32:esp32:esp32c3',
-        mcu: 'esp32c3',
-    },
-    {
-        id: 'esp32c6',
-        displayName: 'ESP32-C6',
-        isNative: false,
-        architecture: 'esp32c6',
-        boardPackage: '@typecad/board-esp32c6',
-        buildTarget: 'esp32:esp32:esp32c6',
-        mcu: 'esp32c6',
-    },
-    {
-        id: 'rp2040',
-        displayName: 'RP2040 (Pico)',
-        isNative: false,
-        architecture: 'rp2040',
-        boardPackage: '@typecad/board-rp2040',
-        buildTarget: 'rp2040:rp2040:rpipico',
-        mcu: 'rp2040',
-    },
-    {
-        id: 'rp2350',
-        displayName: 'RP2350 (Pico 2)',
-        isNative: false,
-        architecture: 'rp2350',
-        boardPackage: '@typecad/board-rp2350',
-        buildTarget: 'rp2040:rp2040:rpipico2',
-        mcu: 'rp2350',
-    },
-    {
-        id: 'xiao-nrf52840',
-        displayName: 'XIAO nRF52840',
-        isNative: false,
-        architecture: 'nrf52',
-        boardPackage: '@typecad/board-xiao-nrf52840',
-        // Zephyr-only target: the build target is the `west build -b` board id,
-        // not an Arduino FQBN (frameworkTargetProfile resolves it for Zephyr).
-        buildTarget: 'xiao_ble/nrf52840',
-        mcu: 'nrf52840',
-    },
-    {
-        id: 'blackpill-f411ce',
-        displayName: 'Black Pill (STM32F411)',
-        isNative: false,
-        architecture: 'stm32f411',
-        boardPackage: '@typecad/board-blackpill-f411ce',
-        // Zephyr-only target: the build target is the `west build -b` board id,
-        // not an Arduino FQBN (frameworkTargetProfile resolves it for Zephyr).
-        buildTarget: 'blackpill_f411ce/stm32f411xe',
-        mcu: 'stm32f411',
-    },
 ];
-export function registerKnownTarget(target) {
-    const existing = _knownTargets.findIndex(t => t.id === target.id);
-    if (existing >= 0) {
-        _knownTargets[existing] = target;
-    }
-    else {
-        _knownTargets.push(target);
-    }
-}
+// Bare-silicon (contract) targets were removed with the curated soc layer:
+// every embedded target resolves through the board catalog like any other.
 export const KNOWN_TARGETS = _knownTargets;
-/** @deprecated Use KNOWN_TARGETS */
-export const KNOWN_BOARDS = _knownTargets;
 export function normalizeProjectName(name) {
     return name
         .toLowerCase()
@@ -151,18 +57,20 @@ export function scaffoldProject(options, outDir) {
     writeFile('.editorconfig', generateEditorconfig(options));
     // Editor integration: workspace-bundled VS Code extension for .ui syntax
     // highlighting (best-effort — warns and skips if the assets are missing).
-    for (const file of writeEditorIntegration(resolvedOutDir))
+    // hideNpm: end-user projects are not npm packages — hide VS Code's NPM
+    // Scripts view and npm task detection.
+    for (const file of writeEditorIntegration(resolvedOutDir, undefined, true))
         createdFiles.push(file);
-    if (options.boardPackage) {
-        const boardFilePath = path.join(cuttlefishDir, 'board.ts');
-        fs.writeFileSync(boardFilePath, generateBoardForwardingFile(options.boardPackage), 'utf-8');
-        createdFiles.push(boardFilePath);
+    if (options.board) {
+        // Board-target projects materialize .cuttlefish/board.ts + board.json on
+        // the first build (config-loader → the framework's board generator);
+        // nothing to write here.
     }
-    if (options.includeSketch) {
+    if (options.includeStarter) {
         const entryName = 'main.ts';
-        const sketchPath = path.join(srcDir, entryName);
-        fs.writeFileSync(sketchPath, generateStarterSketch(options), 'utf-8');
-        createdFiles.push(sketchPath);
+        const entryPath = path.join(srcDir, entryName);
+        fs.writeFileSync(entryPath, generateStarterProgram(options), 'utf-8');
+        createdFiles.push(entryPath);
     }
     // Embedded projects get a starter hardware test (@typecad/expect / cuttlefish-test).
     // Native projects have no serial/board path, so they get no test setup.
@@ -205,7 +113,6 @@ export function printCreateNextSteps(options, outDir, opts = {}) {
     console.log(chalk.bold.white("To edit .ui files (VS Code):"));
     console.log(`  ${chalk.cyan("open the folder and approve the workspace extension")} ${chalk.dim("(adds .ui syntax highlighting)")}`);
     if (!options.isNative) {
-        const portHint = process.platform === 'win32' ? 'COM4' : '/dev/ttyACM0';
         console.log();
         console.log(chalk.bold.white("To simulate without hardware:"));
         console.log(`  ${chalk.cyan("npm run simulate")}`);
@@ -215,7 +122,10 @@ export function printCreateNextSteps(options, outDir, opts = {}) {
         console.log();
         console.log(chalk.bold.white("To run hardware tests:"));
         console.log(`  ${chalk.cyan("npm run test:hw")}`);
-        console.log();
-        console.log(chalk.dim(`Edit ${chalk.white("cuttlefish.config.ts")} to change the serial port from ${chalk.white(portHint)} to your port.`));
+        if (!options.port) {
+            const portHint = process.platform === 'win32' ? 'COM4' : '/dev/ttyACM0';
+            console.log();
+            console.log(chalk.dim(`No serial port was set — edit ${chalk.white("cuttlefish.config.ts")} to change ${chalk.white(portHint)} to your port (or pass --port on any command).`));
+        }
     }
 }

package/dist/create/templates.d.ts

@@ -5,25 +5,52 @@ export interface CreateProjectOptions {
     targetDisplayName: string;
     isNative: boolean;
     architecture?: ArchitectureIdentifier;
-    boardPackage?: string;
+    /** Qualified Zephyr board target (board-target projects). */
+    board?: string;
+    /** True when the board's devicetree declares an LED (pack fact — drives
+     *  the starter between an I/O skeleton and LED-blink). */
+    hasLed?: boolean;
     frameworkPackage: string;
     framework: string;
     buildTarget?: string;
-    mcu?: string;
+    /** Zephyr SoC name (bare-silicon / contract projects). */
+    soc?: string;
     baudRate?: number;
-    includeSketch: boolean;
+    includeStarter: boolean;
     toolchainType?: string;
     /** Extra frameworkData fields (e.g. `{ target: 'esp32s3' }` for framework-esp32). */
     frameworkData?: Record<string, unknown>;
+    /** Selected probe-method id (Zephyr boards with a probeMethods table);
+     *  emits the zephyr.probe section in the scaffolded config. */
+    probeMethod?: string;
+    /** Probe methods the board supports (wizard/catalog data) — used to write
+     *  the config comment listing the alternatives. */
+    probeMethods?: {
+        id: string;
+        description?: string;
+    }[];
+    /** Pre-baked zephyr.runnerArgs for the selected probe method (from
+     *  probeRunnerQuirks — board-catalog facts, e.g. an srst-based openocd.cfg
+     *  behind a debug header with no NRST). Emitted after probe with an
+     *  explanatory comment. */
+    probeRunnerArgs?: string[];
+    /** Serial port picked at create time (test.port). Absent →
+     *  the platform hint placeholder. */
+    port?: string;
+    /** MCU-only Zephyr target: emit `zephyr.customBoard: true` so the framework
+     *  generates an out-of-tree board named after the build target. */
+    zephyrCustomBoard?: boolean;
+    /** Starter-program pin for MCU-only targets (a port name — bare silicon has
+     *  no board-level LED alias). */
+    starterPin?: string;
 }
 export declare function generateProjectPackageJson(options: CreateProjectOptions): string;
 export declare function generateProjectTsconfig(options: CreateProjectOptions): string;
 export declare function generateProjectConfig(options: CreateProjectOptions): string;
 export declare function generateProjectEnvDts(options: CreateProjectOptions): string;
-export declare function generateStarterSketch(options: CreateProjectOptions): string;
+export declare function generateStarterProgram(options: CreateProjectOptions): string;
 export declare function generateStarterTest(_options: CreateProjectOptions): string;
 export declare function generateStarterSim(options: CreateProjectOptions): string;
-export declare function generateBoardForwardingFile(boardPackage: string): string;
 export declare function generateGitignore(_options: CreateProjectOptions): string;
 export declare function generateEditorconfig(_options: CreateProjectOptions): string;
 export declare function generateEslintConfig(_options: CreateProjectOptions): string;