c-next 0.2.12 → 0.2.13

package/src/transpiler/data/CppEntryPointScanner.ts

@@ -0,0 +1,174 @@
+import { dirname, join, resolve } from "node:path";
+import IncludeDiscovery from "./IncludeDiscovery";
+import CNextMarkerDetector from "./CNextMarkerDetector";
+import IFileSystem from "../types/IFileSystem";
+import NodeFileSystem from "../NodeFileSystem";
+
+/**
+ * Result of scanning a C/C++ entry point for C-Next sources.
+ */
+interface IScanResult {
+  /** Absolute paths to discovered .cnx source files */
+  cnextSources: string[];
+  /** Errors encountered (e.g., missing .cnx files referenced by markers) */
+  errors: string[];
+  /** Warnings encountered (e.g., includes that couldn't be resolved) */
+  warnings: string[];
+  /** True if no C-Next markers were found (not an error, just informational) */
+  noCNextFound: boolean;
+}
+
+/**
+ * Scans C/C++ entry point files to discover C-Next source dependencies.
+ *
+ * Walks the include tree starting from a C/C++ file, looks for C-Next
+ * generation markers in headers, and extracts the source .cnx paths.
+ * Follows includes transitively through discovered .cnx files.
+ *
+ * Used by the C/C++ entry point feature (ADR-XXX) to enable compilation
+ * where the entry point is a C/C++ file that #includes C-Next generated headers.
+ */
+class CppEntryPointScanner {
+  private readonly fs: IFileSystem;
+  private readonly searchPaths: string[];
+  private readonly visited = new Set<string>();
+  private readonly cnextSources = new Set<string>();
+  private readonly errors: string[] = [];
+  private readonly warnings: string[] = [];
+
+  constructor(
+    searchPaths: string[],
+    fs: IFileSystem = NodeFileSystem.instance,
+  ) {
+    this.searchPaths = searchPaths;
+    this.fs = fs;
+  }
+
+  /**
+   * Scan an entry point file for C-Next source dependencies.
+   *
+   * @param entryPath - Path to the C/C++ entry point file
+   * @returns Scan result with discovered sources, errors, and warnings
+   */
+  scan(entryPath: string): IScanResult {
+    const absolutePath = resolve(entryPath);
+    this._scanFile(absolutePath);
+
+    return {
+      cnextSources: Array.from(this.cnextSources),
+      errors: this.errors,
+      warnings: this.warnings,
+      noCNextFound: this.cnextSources.size === 0 && this.errors.length === 0,
+    };
+  }
+
+  /**
+   * Scan a file for includes and process them.
+   */
+  private _scanFile(filePath: string): void {
+    if (this.visited.has(filePath)) return;
+    this.visited.add(filePath);
+
+    let content: string;
+    try {
+      content = this.fs.readFile(filePath);
+    } catch {
+      this.warnings.push(`Warning: Could not read ${filePath}`);
+      return;
+    }
+
+    const includes = IncludeDiscovery.extractIncludesWithInfo(content);
+    const fileDir = dirname(filePath);
+    const localSearchPaths = [fileDir, ...this.searchPaths];
+
+    for (const includeInfo of includes) {
+      this._processInclude(includeInfo, localSearchPaths, filePath);
+    }
+  }
+
+  /**
+   * Process a single include directive.
+   */
+  private _processInclude(
+    includeInfo: { path: string; isLocal: boolean },
+    searchPaths: string[],
+    fromFile: string,
+  ): void {
+    const resolved = IncludeDiscovery.resolveInclude(
+      includeInfo.path,
+      searchPaths,
+      this.fs,
+    );
+
+    if (!resolved) {
+      // Only warn for local includes that couldn't be resolved
+      // System includes (like <stdio.h>) are expected to not be found
+      if (includeInfo.isLocal) {
+        this.warnings.push(
+          `Warning: #include "${includeInfo.path}" not found (from ${fromFile})`,
+        );
+      }
+      return;
+    }
+
+    const absolutePath = resolve(resolved);
+    if (this.visited.has(absolutePath)) return;
+
+    let headerContent: string;
+    try {
+      headerContent = this.fs.readFile(absolutePath);
+    } catch {
+      return;
+    }
+
+    // Check if this is a C-Next generated header
+    const sourcePath = CNextMarkerDetector.extractSourcePath(headerContent);
+    if (sourcePath) {
+      // New-style marker with source path
+      this._handleCNextMarker(sourcePath, absolutePath);
+    } else if (CNextMarkerDetector.isCNextGenerated(headerContent)) {
+      // Old-style marker without source path - treat as leaf node
+      // (we know it's C-Next generated but can't determine the source)
+      this.visited.add(absolutePath);
+    } else {
+      // Not a C-Next generated header - scan it for nested includes
+      this._scanFile(absolutePath);
+    }
+  }
+
+  /**
+   * Handle a C-Next generation marker found in a header.
+   *
+   * Resolves the source path by first checking relative to the header location,
+   * then searching the include paths. This supports both default behavior (header
+   * next to source) and --header-out (header in separate directory).
+   */
+  private _handleCNextMarker(sourcePath: string, headerPath: string): void {
+    const headerDir = dirname(headerPath);
+    let absoluteSourcePath = resolve(join(headerDir, sourcePath));
+
+    // If not found next to header, search include paths (supports --header-out)
+    if (!this.fs.exists(absoluteSourcePath)) {
+      for (const searchPath of this.searchPaths) {
+        const candidate = resolve(join(searchPath, sourcePath));
+        if (this.fs.exists(candidate)) {
+          absoluteSourcePath = candidate;
+          break;
+        }
+      }
+    }
+
+    if (!this.fs.exists(absoluteSourcePath)) {
+      this.errors.push(
+        `C-Next source not found: ${sourcePath} (referenced by ${headerPath})`,
+      );
+      return;
+    }
+
+    this.cnextSources.add(absoluteSourcePath);
+    // Scan the .cnx file for its own includes (transitive discovery)
+    this._scanFile(absoluteSourcePath);
+  }
+}
+
+export default CppEntryPointScanner;

package/src/transpiler/data/FileDiscovery.ts

@@ -1,13 +1,11 @@
 /**
  * File Discovery
- * Scans directories for source files using fast-glob
+ * Classifies source files by type
  */
 
-import fg from "fast-glob";
 import { extname, resolve } from "node:path";
 import EFileType from "./types/EFileType";
 import IDiscoveredFile from "./types/IDiscoveredFile";
-import IDiscoveryOptions from "./types/IDiscoveryOptions";
 import IFileSystem from "../types/IFileSystem";
 import NodeFileSystem from "../NodeFileSystem";
 
@@ -31,34 +29,9 @@ const EXTENSION_MAP: Record<string, EFileType> = {
 };
 
 /**
- * Default ignore patterns for fast-glob
- * Issue #355: Exclude .pio/build (compiled artifacts) but allow .pio/libdeps (library headers)
- */
-const DEFAULT_IGNORE_GLOBS = [
-  "**/node_modules/**",
-  "**/.git/**",
-  "**/.build/**",
-  "**/.pio/build/**",
-];
-
-/**
- * Discovers source files in directories
+ * Classifies and discovers source files
  */
 class FileDiscovery {
-  /**
-   * Convert RegExp patterns to glob ignore patterns
-   */
-  private static regexToGlob(pattern: RegExp): string {
-    // Convert common patterns
-    const src = pattern.source;
-    if (src === "node_modules") return "**/node_modules/**";
-    if (src === String.raw`\.git`) return "**/.git/**";
-    if (src === String.raw`\.build`) return "**/.build/**";
-    if (src === String.raw`\.pio[/\\]build`) return "**/.pio/build/**";
-    // Fallback: wrap in wildcards
-    return `**/*${src.replaceAll("\\", "")}*/**`;
-  }
-
   /**
    * Classify a file path into a discovered file
    */
@@ -72,82 +45,6 @@ class FileDiscovery {
     };
   }
 
-  /**
-   * Discover files in the given directories
-   *
-   * Issue #331: Uses fast-glob's unique option to avoid duplicates
-   * when overlapping directories are provided.
-   *
-   * Note: fast-glob accesses the filesystem directly; the fs parameter
-   * is used only for directory existence checks.
-   *
-   * @param directories - Directories to scan
-   * @param options - Discovery options
-   * @param fs - File system abstraction (defaults to NodeFileSystem)
-   */
-  static discover(
-    directories: string[],
-    options: IDiscoveryOptions = {},
-    fs: IFileSystem = defaultFs,
-  ): IDiscoveredFile[] {
-    const recursive = options.recursive ?? true;
-    const extensions = options.extensions ?? Object.keys(EXTENSION_MAP);
-
-    // Build ignore patterns
-    let ignorePatterns: string[];
-    if (options.excludePatterns) {
-      ignorePatterns = options.excludePatterns.map((r) => this.regexToGlob(r));
-    } else {
-      ignorePatterns = DEFAULT_IGNORE_GLOBS;
-    }
-
-    // Build glob pattern for extensions
-    const extPattern =
-      extensions.length === 1
-        ? `*${extensions[0]}`
-        : `*{${extensions.join(",")}}`;
-    const pattern = recursive ? `**/${extPattern}` : extPattern;
-
-    const allFiles: IDiscoveredFile[] = [];
-
-    for (const dir of directories) {
-      const resolvedDir = resolve(dir);
-
-      if (!fs.exists(resolvedDir)) {
-        console.warn(`Warning: Directory not found: ${dir}`);
-        continue;
-      }
-
-      try {
-        // Use fast-glob to find files
-        const files = fg.sync(pattern, {
-          cwd: resolvedDir,
-          absolute: true,
-          ignore: ignorePatterns,
-          deep: recursive ? Infinity : 1,
-          onlyFiles: true,
-          followSymbolicLinks: false,
-        });
-
-        for (const file of files) {
-          allFiles.push(this.classifyFile(file));
-        }
-      } catch {
-        console.warn(`Warning: Cannot read directory: ${dir}`);
-      }
-    }
-
-    // Issue #331: Remove duplicates from overlapping directories
-    const seenPaths = new Set<string>();
-    return allFiles.filter((file) => {
-      if (seenPaths.has(file.path)) {
-        return false;
-      }
-      seenPaths.add(file.path);
-      return true;
-    });
-  }
-
   /**
    * Discover a single file
    *

package/src/transpiler/data/InputExpansion.ts

@@ -1,17 +1,24 @@
 import { resolve, extname, basename } from "node:path";
-import { existsSync, statSync, readdirSync } from "node:fs";
+import { existsSync } from "node:fs";
 
 /**
  * Input expansion for C-Next CLI
  *
- * Expands file paths and directories into a list of .cnx files to compile.
- * Handles recursive directory scanning and file validation.
+ * Validates and resolves file paths for compilation.
  */
 class InputExpansion {
+  private static readonly CPP_EXTENSIONS = [
+    ".c",
+    ".cpp",
+    ".cc",
+    ".cxx",
+    ".c++",
+  ];
+  private static readonly CNEXT_EXTENSIONS = [".cnx", ".cnext"];
   /**
-   * Expand inputs (files or directories) to list of .cnx files
+   * Expand inputs (files) to list of .cnx files
    *
-   * @param inputs - Array of file paths or directories
+   * @param inputs - Array of file paths
    * @returns Array of .cnx file paths
    */
   static expandInputs(inputs: string[]): string[] {
@@ -24,75 +31,17 @@ class InputExpansion {
         throw new Error(`Input not found: ${input}`);
       }
 
-      const stats = statSync(resolvedPath);
-
-      if (stats.isDirectory()) {
-        // Recursively find .cnx files
-        const cnextFiles = this.findCNextFiles(resolvedPath);
-        files.push(...cnextFiles);
-      } else if (stats.isFile()) {
-        // Validate and add file
-        this.validateFileExtension(resolvedPath);
-        files.push(resolvedPath);
-      }
+      this.validateFileExtension(resolvedPath);
+      files.push(resolvedPath);
     }
 
-    // Remove duplicates
     return Array.from(new Set(files));
   }
 
-  /**
-   * Recursively find .cnx files in directory
-   *
-   * @param dir - Directory to scan
-   * @returns Array of .cnx file paths
-   */
-  static findCNextFiles(dir: string): string[] {
-    const files: string[] = [];
-
-    try {
-      const entries = readdirSync(dir, { withFileTypes: true });
-
-      for (const entry of entries) {
-        const fullPath = resolve(dir, entry.name);
-
-        // Skip hidden directories and common build/dependency directories
-        if (entry.isDirectory()) {
-          const dirName = entry.name;
-          if (
-            dirName.startsWith(".") ||
-            dirName === "node_modules" ||
-            dirName === "build" ||
-            dirName === ".pio" ||
-            dirName === "dist"
-          ) {
-            continue;
-          }
-
-          // Recursively scan subdirectory
-          const subFiles = this.findCNextFiles(fullPath);
-          files.push(...subFiles);
-        } else if (entry.isFile()) {
-          const ext = extname(entry.name);
-          if (ext === ".cnx" || ext === ".cnext") {
-            files.push(fullPath);
-          }
-        }
-      }
-    } catch (error) {
-      throw new Error(`Failed to scan directory ${dir}: ${error}`, {
-        cause: error,
-      });
-    }
-
-    return files;
-  }
-
   /**
    * Validate file extension
    *
-   * Accepts: .cnx, .cnext
-   * Rejects: .c, .cpp, .cc, .cxx, .c++ (implementation files)
+   * Accepts: .cnx, .cnext, .c, .cpp, .cc, .cxx, .c++
    *
    * @param path - File path to validate
    * @throws Error if extension is invalid
@@ -101,24 +50,31 @@ class InputExpansion {
     const ext = extname(path);
     const fileName = basename(path);
 
-    // Reject implementation files
-    const rejectedExtensions = [".c", ".cpp", ".cc", ".cxx", ".c++"];
-    if (rejectedExtensions.includes(ext)) {
-      throw new Error(
-        `Cannot process implementation file '${fileName}'. ` +
-          `C-Next only compiles .cnx files. ` +
-          `If you need to include this file, create a header (.h) instead.`,
-      );
+    // Accept C-Next source files
+    if (InputExpansion.CNEXT_EXTENSIONS.includes(ext)) {
+      return;
     }
 
-    // Accept C-Next source files
-    const acceptedExtensions = [".cnx", ".cnext"];
-    if (!acceptedExtensions.includes(ext)) {
-      throw new Error(
-        `Invalid file extension '${ext}' for file '${fileName}'. ` +
-          `C-Next only accepts .cnx or .cnext files.`,
-      );
+    // Accept C/C++ entry point files
+    if (InputExpansion.CPP_EXTENSIONS.includes(ext)) {
+      return;
     }
+
+    throw new Error(
+      `Invalid file extension '${ext}' for file '${fileName}'. ` +
+        `C-Next only accepts .cnx, .cnext, .c, .cpp, .cc, .cxx, or .c++ files.`,
+    );
+  }
+
+  /**
+   * Check if a file is a C/C++ entry point
+   *
+   * @param path - File path to check
+   * @returns true if the file has a C/C++ extension
+   */
+  static isCppEntryPoint(path: string): boolean {
+    const ext = extname(path);
+    return InputExpansion.CPP_EXTENSIONS.includes(ext);
   }
 }
 

package/src/transpiler/data/__tests__/CNextMarkerDetector.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect } from "vitest";
+import CNextMarkerDetector from "../CNextMarkerDetector";
+
+describe("CNextMarkerDetector", () => {
+  describe("extractSourcePath", () => {
+    it("should extract source path from valid marker", () => {
+      const content = `/**
+ * Generated by C-Next Transpiler from: led.cnx
+ * Header file for cross-language interoperability
+ */`;
+      expect(CNextMarkerDetector.extractSourcePath(content)).toBe("led.cnx");
+    });
+
+    it("should return null for header without marker", () => {
+      const content = `/**
+ * Some other header
+ */
+#ifndef FOO_H
+#define FOO_H`;
+      expect(CNextMarkerDetector.extractSourcePath(content)).toBeNull();
+    });
+
+    it("should return null for old-style marker without source path", () => {
+      const content = `/**
+ * Generated by C-Next Transpiler
+ * Header file for cross-language interoperability
+ */`;
+      expect(CNextMarkerDetector.extractSourcePath(content)).toBeNull();
+    });
+
+    it("should handle paths with directories", () => {
+      const content = `/**
+ * Generated by C-Next Transpiler from: ../lib/utils.cnx
+ */`;
+      expect(CNextMarkerDetector.extractSourcePath(content)).toBe(
+        "../lib/utils.cnx",
+      );
+    });
+  });
+
+  describe("isCNextGenerated", () => {
+    it("should return true for C-Next generated header", () => {
+      const content = `/**
+ * Generated by C-Next Transpiler from: led.cnx
+ */`;
+      expect(CNextMarkerDetector.isCNextGenerated(content)).toBe(true);
+    });
+
+    it("should return true for old-style marker", () => {
+      const content = `/**
+ * Generated by C-Next Transpiler
+ */`;
+      expect(CNextMarkerDetector.isCNextGenerated(content)).toBe(true);
+    });
+
+    it("should return false for non-generated header", () => {
+      const content = `#ifndef FOO_H
+#define FOO_H`;
+      expect(CNextMarkerDetector.isCNextGenerated(content)).toBe(false);
+    });
+  });
+});