c-next 0.2.1 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "A safer C for embedded systems development. Transpiles to clean, readable C.",
   "packageManager": "npm@11.9.0",
   "type": "module",
@@ -23,7 +23,7 @@
     "test:q": "tsx scripts/test.ts -q",
     "test:update": "tsx scripts/test.ts --update",
     "analyze": "./scripts/static-analysis.sh",
-    "clean": "rm -rf src/transpiler/logic/parser/grammar src/transpiler/logic/parser/c/grammar src/transpiler/logic/parser/cpp/grammar",
+    "clean": "rm -rf dist src/transpiler/logic/parser/grammar src/transpiler/logic/parser/c/grammar src/transpiler/logic/parser/cpp/grammar",
     "prettier:check": "prettier --check .",
     "prettier:fix": "prettier --write .",
     "cspell:check": "cspell .",
@@ -33,7 +33,7 @@
     "depcruise": "depcruise src/transpiler --config .dependency-cruiser.cjs",
     "depcruise:graph": "depcruise src/transpiler --config .dependency-cruiser.cjs --output-type dot | dot -T svg > dependency-graph.svg",
     "prepare": "husky",
-    "prepublishOnly": "npm run prettier:check && npm run oxlint:check && npm test",
+    "prepublishOnly": "npm run prettier:check && npm run oxlint:check && npm run build && npm test",
     "coverage:check": "tsx scripts/coverage-checker.ts check",
     "coverage:report": "tsx scripts/coverage-checker.ts report",
     "coverage:gaps": "tsx scripts/coverage-checker.ts gaps",
@@ -45,7 +45,9 @@
     "unit:watch": "vitest",
     "unit:coverage": "vitest run --coverage",
     "unit:coverage:html": "vitest run --coverage && echo 'Coverage report: coverage/index.html'",
-    "test:all": "npm run unit && npm run test:q",
+    "build": "node scripts/build.mjs",
+    "test:all": "npm run build && npm run unit && npm run test:q && npm run validate:c",
+    "validate:c": "node scripts/batch-validate.mjs",
     "duplication": "npx jscpd src/ scripts/ --reporters console",
     "duplication:json": "npx jscpd src/ scripts/ --reporters json --output .jscpd",
     "duplication:sonar": "curl -s 'https://sonarcloud.io/api/measures/component_tree?component=jlaustill_c-next&metricKeys=duplicated_blocks,duplicated_lines&s=metric&metricSort=duplicated_blocks&metricSortFilter=withMeasuresOnly&asc=false&ps=20' | jq -r '.components[] | \"\\(.path)\\t\\(.measures[0].value) blocks\\t\\(.measures[1].value) lines\"'",
@@ -79,6 +81,7 @@
   },
   "files": [
     "bin/",
+    "dist/",
     "src/",
     "grammar/",
     "README.md",
@@ -87,6 +90,7 @@
   "devDependencies": {
     "@types/node": "^25.2.1",
     "@types/yargs": "^17.0.35",
+    "esbuild": "^0.27.3",
     "@vitest/coverage-v8": "^4.0.18",
     "antlr4ng-cli": "^2.0.0",
     "chalk": "^5.6.2",

package/src/cli/Cli.ts

@@ -10,6 +10,7 @@ import ConfigLoader from "./ConfigLoader";
 import ConfigPrinter from "./ConfigPrinter";
 import PlatformIOCommand from "./PlatformIOCommand";
 import CleanCommand from "./CleanCommand";
+import PathNormalizer from "./PathNormalizer";
 import ICliResult from "./types/ICliResult";
 import ICliConfig from "./types/ICliConfig";
 import IParsedArgs from "./types/IParsedArgs";
@@ -92,7 +93,7 @@ class Cli {
     args: IParsedArgs,
     fileConfig: IFileConfig,
   ): ICliConfig {
-    return {
+    const rawConfig: ICliConfig = {
       inputs: args.inputFiles,
       outputPath: args.outputPath || fileConfig.output || "",
       // Merge include dirs: config includes come first, CLI includes override/append
@@ -100,7 +101,7 @@ class Cli {
       defines: args.defines,
       preprocess: args.preprocess,
       verbose: args.verbose,
-      cppRequired: args.cppRequired ?? fileConfig.cppRequired ?? false,
+      cppRequired: args.cppRequired || fileConfig.cppRequired || false,
       noCache: args.noCache || fileConfig.noCache === true,
       parseOnly: args.parseOnly,
       headerOutDir: args.headerOutDir ?? fileConfig.headerOut,
@@ -108,6 +109,8 @@ class Cli {
       target: args.target ?? fileConfig.target,
       debugMode: args.debugMode || fileConfig.debugMode,
     };
+
+    return PathNormalizer.normalizeConfig(rawConfig);
   }
 }
 

package/src/cli/PathNormalizer.ts

@@ -0,0 +1,170 @@
+/**
+ * PathNormalizer
+ * Centralized path normalization for all config paths.
+ * Handles tilde expansion and recursive directory search.
+ */
+
+import { join } from "node:path";
+import IFileSystem from "../transpiler/types/IFileSystem";
+import NodeFileSystem from "../transpiler/NodeFileSystem";
+import ICliConfig from "./types/ICliConfig";
+
+/** Default file system instance */
+const defaultFs = NodeFileSystem.instance;
+
+class PathNormalizer {
+  /**
+   * Expand ~ at the start of a path to the home directory.
+   * Only expands leading tilde (~/path or bare ~).
+   * @param path - Path that may start with ~
+   * @returns Path with ~ expanded to home directory
+   */
+  static expandTilde(path: string): string {
+    if (!path.startsWith("~")) {
+      return path;
+    }
+
+    const home = process.env.HOME || process.env.USERPROFILE;
+    if (!home) {
+      return path;
+    }
+
+    if (path === "~") {
+      return home;
+    }
+
+    if (path.startsWith("~/")) {
+      return home + path.slice(1);
+    }
+
+    return path;
+  }
+
+  /**
+   * Expand path/** to include all subdirectories recursively.
+   * If path doesn't end with /**, returns the path as single-element array
+   * (if it exists) or empty array (if it doesn't exist).
+   * @param path - Path that may end with /**
+   * @param fs - File system abstraction for testing
+   * @returns Array of all directories found
+   */
+  static expandRecursive(path: string, fs: IFileSystem = defaultFs): string[] {
+    const hasRecursiveSuffix = path.endsWith("/**");
+    const basePath = hasRecursiveSuffix ? path.slice(0, -3) : path;
+
+    if (!fs.exists(basePath)) {
+      return [];
+    }
+
+    if (!fs.isDirectory(basePath)) {
+      return [basePath];
+    }
+
+    if (!hasRecursiveSuffix) {
+      return [basePath];
+    }
+
+    // Recursively collect all subdirectories
+    const dirs: string[] = [basePath];
+    this.collectSubdirectories(basePath, dirs, fs);
+    return dirs;
+  }
+
+  /**
+   * Recursively collect all subdirectories into the dirs array.
+   * Uses a visited set to prevent symlink loops.
+   */
+  private static collectSubdirectories(
+    dir: string,
+    dirs: string[],
+    fs: IFileSystem,
+    visited: Set<string> = new Set(),
+  ): void {
+    // Get real path to detect symlink loops
+    const realPath = fs.realpath ? fs.realpath(dir) : dir;
+    if (visited.has(realPath)) {
+      return; // Skip already-visited directories (symlink loop protection)
+    }
+    visited.add(realPath);
+
+    const entries = fs.readdir(dir);
+    for (const entry of entries) {
+      const fullPath = join(dir, entry);
+      if (fs.isDirectory(fullPath)) {
+        // Check if this subdirectory's real path was already visited
+        const subRealPath = fs.realpath ? fs.realpath(fullPath) : fullPath;
+        if (!visited.has(subRealPath)) {
+          dirs.push(fullPath);
+          this.collectSubdirectories(fullPath, dirs, fs, visited);
+        }
+      }
+    }
+  }
+
+  /**
+   * Normalize a single path (tilde expansion only).
+   * Used for output, headerOut, basePath.
+   * @param path - Path to normalize
+   * @returns Normalized path
+   */
+  static normalizePath(path: string): string {
+    if (!path) {
+      return path;
+    }
+    return this.expandTilde(path);
+  }
+
+  /**
+   * Normalize include paths (tilde + recursive expansion).
+   * Deduplicates paths to avoid redundant includes.
+   * @param paths - Array of paths to normalize
+   * @param fs - File system abstraction for testing
+   * @returns Flattened array of all resolved directories (deduplicated)
+   */
+  static normalizeIncludePaths(
+    paths: string[],
+    fs: IFileSystem = defaultFs,
+  ): string[] {
+    const seen = new Set<string>();
+    const result: string[] = [];
+
+    for (const path of paths) {
+      const expanded = this.expandTilde(path);
+      const dirs = this.expandRecursive(expanded, fs);
+      for (const dir of dirs) {
+        if (!seen.has(dir)) {
+          seen.add(dir);
+          result.push(dir);
+        }
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Normalize all paths in a CLI config.
+   * Single entry point for all path normalization.
+   * @param config - CLI config with potentially unnormalized paths
+   * @param fs - File system abstraction for testing
+   * @returns New config with all paths normalized
+   */
+  static normalizeConfig(
+    config: ICliConfig,
+    fs: IFileSystem = defaultFs,
+  ): ICliConfig {
+    return {
+      ...config,
+      outputPath: this.normalizePath(config.outputPath),
+      headerOutDir: config.headerOutDir
+        ? this.normalizePath(config.headerOutDir)
+        : undefined,
+      basePath: config.basePath
+        ? this.normalizePath(config.basePath)
+        : undefined,
+      includeDirs: this.normalizeIncludePaths(config.includeDirs, fs),
+    };
+  }
+}
+
+export default PathNormalizer;

package/src/cli/PlatformIOCommand.ts

@@ -5,6 +5,7 @@
 
 import { resolve } from "node:path";
 import { existsSync, readFileSync, writeFileSync, unlinkSync } from "node:fs";
+import IFileConfig from "./types/IFileConfig";
 
 /**
  * Resolved paths for PlatformIO project.
@@ -43,11 +44,14 @@ class PlatformIOCommand {
     const { pioIniPath, scriptPath } = getPioProjectPaths();
 
     // Create cnext_build.py script
+    // Issue #833: Run transpilation at import time (before compilation),
+    // not as a pre-action on buildprog (which runs after compilation)
     const buildScript = `Import("env")
 import subprocess
+import sys
 from pathlib import Path
 
-def transpile_cnext(source, target, env):
+def transpile_cnext():
     """Transpile all .cnx files before build"""
     # Find all .cnx files in src directory
     src_dir = Path("src")
@@ -72,9 +76,10 @@ def transpile_cnext(source, target, env):
         except subprocess.CalledProcessError as e:
             print(f"  ✗ Error: {cnx_file.name}")
             print(e.stderr)
-            env.Exit(1)
+            sys.exit(1)
 
-env.AddPreAction("buildprog", transpile_cnext)
+# Run transpilation at import time (before compilation starts)
+transpile_cnext()
 `;
 
     writeFileSync(scriptPath, buildScript, "utf-8");
@@ -107,6 +112,9 @@ env.AddPreAction("buildprog", transpile_cnext)
     writeFileSync(pioIniPath, pioIni, "utf-8");
     console.log(`✓ Modified: ${pioIniPath}`);
 
+    // Setup cnext.config.json for PlatformIO
+    this.setupConfig();
+
     console.log("");
     console.log("✓ PlatformIO integration configured!");
     console.log("");
@@ -122,6 +130,46 @@ env.AddPreAction("buildprog", transpile_cnext)
     console.log("Commit both .cnx and generated .c files to version control.");
   }
 
+  /**
+   * Setup cnext.config.json with PlatformIO-appropriate defaults
+   * - Appends .pio/libdeps to include array
+   * - Sets headerOut to "include" if not already set
+   */
+  private static setupConfig(): void {
+    const configPath = resolve(process.cwd(), "cnext.config.json");
+    const pioInclude = ".pio/libdeps";
+
+    let config: IFileConfig = {};
+
+    if (existsSync(configPath)) {
+      try {
+        const content = readFileSync(configPath, "utf-8");
+        config = JSON.parse(content) as IFileConfig;
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        console.log(
+          `⚠ Could not parse existing cnext.config.json (${msg}), creating new one`,
+        );
+        config = {};
+      }
+    }
+
+    // Append .pio/libdeps to include array if not already present
+    const includes = config.include ?? [];
+    if (!includes.includes(pioInclude)) {
+      config.include = [...includes, pioInclude];
+    }
+
+    // Set headerOut only if not already set
+    if (!config.headerOut) {
+      config.headerOut = "include";
+    }
+
+    // Write config (with pretty formatting)
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+    console.log(`✓ Updated: ${configPath}`);
+  }
+
   /**
    * Remove PlatformIO integration
    * Deletes cnext_build.py and removes extra_scripts from platformio.ini

package/src/cli/__tests__/Cli.integration.test.ts

@@ -0,0 +1,100 @@
+/**
+ * Integration tests for Cli path normalization.
+ * These tests do NOT mock dependencies - they test real behavior.
+ *
+ * Separate from Cli.test.ts to avoid vi.mock() hoisting issues.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import Cli from "../Cli";
+
+describe("Cli path normalization (integration)", () => {
+  let tempDir: string;
+  const originalHome = process.env.HOME;
+  const originalArgv = process.argv;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), "cli-paths-"));
+    process.env.HOME = "/home/testuser";
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+    process.env.HOME = originalHome;
+    process.argv = originalArgv;
+  });
+
+  it("expands tilde in config include paths", () => {
+    // Create a real home directory structure to verify tilde expansion
+    const homeDir = mkdtempSync(join(tmpdir(), "home-"));
+    mkdirSync(join(homeDir, "sdk", "include"), { recursive: true });
+
+    process.env.HOME = homeDir;
+
+    writeFileSync(
+      join(tempDir, "cnext.config.json"),
+      JSON.stringify({ include: ["~/sdk/include"] }),
+    );
+    writeFileSync(join(tempDir, "test.cnx"), "void main() {}");
+
+    process.argv = ["node", "cnext", join(tempDir, "test.cnx")];
+
+    const result = Cli.run();
+
+    // Verify tilde was expanded to actual home directory path
+    expect(result.config?.includeDirs).toContain(join(homeDir, "sdk/include"));
+    // Verify the unexpanded tilde path is NOT present
+    expect(result.config?.includeDirs).not.toContain("~/sdk/include");
+
+    rmSync(homeDir, { recursive: true, force: true });
+  });
+
+  it("expands ** in config include paths", () => {
+    // Create directory structure
+    mkdirSync(join(tempDir, "include", "sub"), { recursive: true });
+    writeFileSync(
+      join(tempDir, "cnext.config.json"),
+      JSON.stringify({ include: [`${tempDir}/include/**`] }),
+    );
+    writeFileSync(join(tempDir, "test.cnx"), "void main() {}");
+
+    process.argv = ["node", "cnext", join(tempDir, "test.cnx")];
+
+    const result = Cli.run();
+
+    expect(result.config?.includeDirs).toContain(join(tempDir, "include"));
+    expect(result.config?.includeDirs).toContain(
+      join(tempDir, "include", "sub"),
+    );
+  });
+
+  it("expands tilde in CLI --include paths", () => {
+    // Create a real home directory structure to verify tilde expansion
+    const homeDir = mkdtempSync(join(tmpdir(), "home-"));
+    mkdirSync(join(homeDir, "my-libs"), { recursive: true });
+
+    process.env.HOME = homeDir;
+
+    writeFileSync(join(tempDir, "test.cnx"), "void main() {}");
+
+    process.argv = [
+      "node",
+      "cnext",
+      join(tempDir, "test.cnx"),
+      "--include",
+      "~/my-libs",
+    ];
+
+    const result = Cli.run();
+
+    // Verify tilde was expanded to actual home directory path
+    expect(result.config?.includeDirs).toContain(join(homeDir, "my-libs"));
+    // Verify the unexpanded tilde path is NOT present
+    expect(result.config?.includeDirs).not.toContain("~/my-libs");
+
+    rmSync(homeDir, { recursive: true, force: true });
+  });
+});

package/src/cli/__tests__/Cli.test.ts

@@ -25,6 +25,12 @@ vi.mock("../ConfigLoader");
 vi.mock("../ConfigPrinter");
 vi.mock("../PlatformIOCommand");
 vi.mock("../CleanCommand");
+vi.mock("../PathNormalizer", () => ({
+  default: {
+    // Pass through the config unchanged for unit tests
+    normalizeConfig: (config: unknown) => config,
+  },
+}));
 
 describe("Cli", () => {
   let mockParsedArgs: IParsedArgs;
@@ -180,40 +186,39 @@ describe("Cli", () => {
       expect(result.config?.includeDirs).toContain("lib/");
     });
 
-    it("uses file config cppRequired when CLI is undefined", () => {
-      // This test documents that with yargs, cppRequired is always defined,
-      // so file config cppRequired only applies if we explicitly set CLI to undefined
+    it("honors config file cppRequired when CLI does not specify --cpp (issue #827)", () => {
+      // Issue #827: When user doesn't pass --cpp, config file cppRequired should be used
+      // yargs returns cppRequired: false as the default, but config file should override
       const fileConfig: IFileConfig = {
         cppRequired: true,
       };
       vi.mocked(ConfigLoader.load).mockReturnValue(fileConfig);
 
-      // Simulate undefined cppRequired (not possible with real yargs, but tests the merge logic)
-      mockParsedArgs.cppRequired = undefined as unknown as boolean;
+      // CLI has cppRequired: false (yargs default when --cpp not specified)
+      mockParsedArgs.cppRequired = false;
       vi.mocked(ArgParser.parse).mockReturnValue(mockParsedArgs);
 
       const result = Cli.run();
 
+      // Config file's cppRequired: true should be honored
       expect(result.config?.cppRequired).toBe(true);
     });
 
-    it("CLI args take precedence over file config", () => {
-      mockParsedArgs.cppRequired = false;
+    it("CLI --cpp flag takes precedence over file config", () => {
+      mockParsedArgs.cppRequired = true;
       mockParsedArgs.target = "cortex-m0";
       vi.mocked(ArgParser.parse).mockReturnValue(mockParsedArgs);
 
       const fileConfig: IFileConfig = {
-        cppRequired: true,
+        cppRequired: false,
         target: "teensy41",
       };
       vi.mocked(ConfigLoader.load).mockReturnValue(fileConfig);
 
       const result = Cli.run();
 
-      // CLI explicitly set cppRequired to false, but the merge uses ?? so undefined would fall through
-      // Actually, looking at the code: args.cppRequired ?? fileConfig.cppRequired ?? false
-      // So if args.cppRequired is false (not undefined), it should use false
-      expect(result.config?.cppRequired).toBe(false);
+      // CLI --cpp flag should take precedence
+      expect(result.config?.cppRequired).toBe(true);
       expect(result.config?.target).toBe("cortex-m0");
     });