c-next 0.1.60 → 0.1.61

package/README.md

@@ -94,6 +94,14 @@ cnext src/ -o build/src --header-out build/include --clean
 cnext --help
 ```
 
+## VS Code Extension
+
+The C-Next VS Code extension provides syntax highlighting, live C preview, IntelliSense, and error diagnostics.
+
+**Install from:** [VS Code Marketplace](https://marketplace.visualstudio.com/items?itemName=jlaustill.vscode-c-next) (coming soon)
+
+**Source:** [github.com/jlaustill/vscode-c-next](https://github.com/jlaustill/vscode-c-next)
+
 ## Getting Started with PlatformIO
 
 C-Next integrates seamlessly with PlatformIO embedded projects. The transpiler automatically converts `.cnx` files to `.c` before each build.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.1.60",
+  "version": "0.1.61",
   "description": "A safer C for embedded systems development. Transpiles to clean, readable C.",
   "packageManager": "npm@11.9.0",
   "type": "module",

package/src/cli/serve/ServeCommand.ts

@@ -1,20 +1,29 @@
 /**
  * ServeCommand
  * JSON-RPC server for VS Code extension communication
+ *
+ * Phase 2b (ADR-060): Uses the full Transpiler for transpilation and symbol
+ * extraction, enabling include resolution, C++ auto-detection, and cross-file
+ * symbol support.
  */
 
 import { createInterface, Interface } from "node:readline";
+import { dirname } from "node:path";
 import JsonRpcHandler from "./JsonRpcHandler";
 import IJsonRpcRequest from "./types/IJsonRpcRequest";
 import IJsonRpcResponse from "./types/IJsonRpcResponse";
 import ConfigPrinter from "../ConfigPrinter";
-import transpile from "../../lib/transpiler";
+import ConfigLoader from "../ConfigLoader";
+import Transpiler from "../../transpiler/Transpiler";
 import parseWithSymbols from "../../lib/parseWithSymbols";
+import parseCHeader from "../../lib/parseCHeader";
 
 /**
- * Method handler type
+ * Method handler type (async to support Transpiler.transpileSource)
  */
-type MethodHandler = (params?: Record<string, unknown>) => IMethodResult;
+type MethodHandler = (
+  params?: Record<string, unknown>,
+) => Promise<IMethodResult>;
 
 /**
  * Result from a method handler
@@ -41,14 +50,17 @@ class ServeCommand {
   private static shouldShutdown = false;
   private static readline: Interface | null = null;
   private static debugMode = false;
+  private static transpiler: Transpiler | null = null;
 
   /**
    * Method handlers registry
    */
   private static readonly methods: Record<string, MethodHandler> = {
     getVersion: ServeCommand.handleGetVersion,
+    initialize: ServeCommand.handleInitialize,
     transpile: ServeCommand.handleTranspile,
     parseSymbols: ServeCommand.handleParseSymbols,
+    parseCHeader: ServeCommand.handleParseCHeader,
     shutdown: ServeCommand.handleShutdown,
   };
 
@@ -115,20 +127,23 @@ class ServeCommand {
     const request = parseResult.request!;
     this.log(`method: ${request.method}`);
 
-    // Dispatch to method handler
-    const response = this.dispatch(request);
-    this.writeResponse(response);
+    // Dispatch to method handler (async)
+    this.dispatch(request).then((response) => {
+      this.writeResponse(response);
 
-    // Handle shutdown after response is written
-    if (this.shouldShutdown) {
-      this.readline?.close();
-    }
+      // Handle shutdown after response is written
+      if (this.shouldShutdown) {
+        this.readline?.close();
+      }
+    });
   }
 
   /**
    * Dispatch a request to the appropriate handler
    */
-  private static dispatch(request: IJsonRpcRequest): IJsonRpcResponse {
+  private static async dispatch(
+    request: IJsonRpcRequest,
+  ): Promise<IJsonRpcResponse> {
     const handler = this.methods[request.method];
 
     if (!handler) {
@@ -139,7 +154,7 @@ class ServeCommand {
       );
     }
 
-    const result = handler(request.params);
+    const result = await handler(request.params);
 
     if (result.success) {
       return JsonRpcHandler.formatResponse(request.id, result.result);
@@ -162,19 +177,59 @@ class ServeCommand {
   /**
    * Handle getVersion method
    */
-  private static handleGetVersion(): IMethodResult {
+  private static async handleGetVersion(): Promise<IMethodResult> {
     return {
       success: true,
       result: { version: ConfigPrinter.getVersion() },
     };
   }
 
+  /**
+   * Handle initialize method
+   * Loads project config and creates a Transpiler instance
+   */
+  private static async handleInitialize(
+    params?: Record<string, unknown>,
+  ): Promise<IMethodResult> {
+    if (!params || typeof params.workspacePath !== "string") {
+      return {
+        success: false,
+        errorCode: JsonRpcHandler.ERROR_INVALID_PARAMS,
+        errorMessage: "Missing required param: workspacePath",
+      };
+    }
+
+    const workspacePath = params.workspacePath;
+    ServeCommand.log(`initializing with workspace: ${workspacePath}`);
+
+    const config = ConfigLoader.load(workspacePath);
+
+    ServeCommand.transpiler = new Transpiler({
+      inputs: [],
+      includeDirs: config.include ?? [],
+      cppRequired: config.cppRequired ?? false,
+      target: config.target ?? "",
+      debugMode: config.debugMode ?? false,
+      noCache: config.noCache ?? false,
+    });
+
+    ServeCommand.log(
+      `initialized (cppRequired=${config.cppRequired ?? false}, includeDirs=${(config.include ?? []).length})`,
+    );
+
+    return {
+      success: true,
+      result: { success: true },
+    };
+  }
+
   /**
    * Handle transpile method
+   * Uses full Transpiler for include resolution and C++ auto-detection
    */
-  private static handleTranspile(
+  private static async handleTranspile(
     params?: Record<string, unknown>,
-  ): IMethodResult {
+  ): Promise<IMethodResult> {
     if (!params || typeof params.source !== "string") {
       return {
         success: false,
@@ -183,7 +238,26 @@ class ServeCommand {
       };
     }
 
-    const result = transpile(params.source);
+    if (!ServeCommand.transpiler) {
+      return {
+        success: false,
+        errorCode: JsonRpcHandler.ERROR_INVALID_PARAMS,
+        errorMessage: "Server not initialized. Call initialize first.",
+      };
+    }
+
+    const source = String(params.source);
+    const filePath =
+      typeof params.filePath === "string" ? params.filePath : undefined;
+
+    const options = filePath
+      ? { workingDir: dirname(filePath), sourcePath: filePath }
+      : undefined;
+
+    const result = await ServeCommand.transpiler.transpileSource(
+      source,
+      options,
+    );
 
     return {
       success: true,
@@ -191,16 +265,19 @@ class ServeCommand {
         success: result.success,
         code: result.code,
         errors: result.errors,
+        cppDetected: ServeCommand.transpiler.isCppDetected(),
       },
     };
   }
 
   /**
    * Handle parseSymbols method
+   * Runs full transpilation for include/C++ detection, then extracts symbols
+   * from the parse tree (preserving "extract symbols even with parse errors" behavior)
    */
-  private static handleParseSymbols(
+  private static async handleParseSymbols(
     params?: Record<string, unknown>,
-  ): IMethodResult {
+  ): Promise<IMethodResult> {
     if (!params || typeof params.source !== "string") {
       return {
         success: false,
@@ -209,22 +286,64 @@ class ServeCommand {
       };
     }
 
-    const result = parseWithSymbols(params.source);
+    const source = String(params.source);
+    const filePath =
+      typeof params.filePath === "string" ? params.filePath : undefined;
+
+    // If transpiler is initialized, run transpileSource to trigger header
+    // resolution and C++ detection (results are discarded, we just want
+    // the side effects on the symbol table)
+    if (ServeCommand.transpiler && filePath) {
+      try {
+        await ServeCommand.transpiler.transpileSource(source, {
+          workingDir: dirname(filePath),
+          sourcePath: filePath,
+        });
+      } catch {
+        // Ignore transpilation errors - we still extract symbols below
+      }
+    }
+
+    // Delegate symbol extraction to parseWithSymbols (shared with WorkspaceIndex)
+    const result = parseWithSymbols(source);
 
     return {
       success: true,
-      result: {
-        success: result.success,
-        errors: result.errors,
-        symbols: result.symbols,
-      },
+      result,
+    };
+  }
+
+  /**
+   * Handle parseCHeader method
+   * Parses C/C++ header files and extracts symbols
+   */
+  private static async handleParseCHeader(
+    params?: Record<string, unknown>,
+  ): Promise<IMethodResult> {
+    if (!params || typeof params.source !== "string") {
+      return {
+        success: false,
+        errorCode: JsonRpcHandler.ERROR_INVALID_PARAMS,
+        errorMessage: "Missing required param: source",
+      };
+    }
+
+    const source = String(params.source);
+    const filePath =
+      typeof params.filePath === "string" ? params.filePath : undefined;
+
+    const result = parseCHeader(source, filePath);
+
+    return {
+      success: true,
+      result,
     };
   }
 
   /**
    * Handle shutdown method
    */
-  private static handleShutdown(): IMethodResult {
+  private static async handleShutdown(): Promise<IMethodResult> {
     ServeCommand.shouldShutdown = true;
     return {
       success: true,

package/src/cli/serve/__tests__/ServeCommand.test.ts

@@ -25,7 +25,7 @@ describe("ServeCommand", () => {
     stdoutWriteSpy.mockRestore();
   });
 
-  // Helper to send a request and capture the response
+  // Helper to send a request and capture the async response
   async function sendRequest(request: object): Promise<object> {
     const line = JSON.stringify(request);
     // Access private handleLine method for testing
@@ -34,8 +34,14 @@ describe("ServeCommand", () => {
     ).handleLine.bind(ServeCommand);
     handleLine(line);
 
-    // Parse the response from stdout.write call
-    const writeCall = stdoutWriteSpy.mock.calls[0];
+    // Wait for async dispatch to complete and write response
+    await vi.waitFor(() => {
+      expect(stdoutWriteSpy.mock.calls.length).toBeGreaterThan(0);
+    });
+
+    // Parse the response from the latest stdout.write call
+    const writeCall =
+      stdoutWriteSpy.mock.calls[stdoutWriteSpy.mock.calls.length - 1];
     if (writeCall) {
       const responseStr = writeCall[0] as string;
       return JSON.parse(responseStr.trim());
@@ -54,8 +60,67 @@ describe("ServeCommand", () => {
     });
   });
 
+  describe("initialize", () => {
+    it("initializes with workspace path", async () => {
+      const response = await sendRequest({
+        id: 10,
+        method: "initialize",
+        params: { workspacePath: "/tmp" },
+      });
+
+      expect(response).toMatchObject({
+        id: 10,
+        result: { success: true },
+      });
+    });
+
+    it("returns error for missing workspacePath param", async () => {
+      const response = await sendRequest({
+        id: 11,
+        method: "initialize",
+        params: {},
+      });
+
+      expect(response).toMatchObject({
+        id: 11,
+        error: {
+          code: JsonRpcHandler.ERROR_INVALID_PARAMS,
+          message: "Missing required param: workspacePath",
+        },
+      });
+    });
+  });
+
   describe("transpile", () => {
+    it("returns error when server not initialized", async () => {
+      // Reset transpiler to null by accessing private field
+      (ServeCommand as unknown as { transpiler: null }).transpiler = null;
+      stdoutWriteSpy.mockClear();
+
+      const response = await sendRequest({
+        id: 50,
+        method: "transpile",
+        params: { source: "u8 x <- 5;" },
+      });
+
+      expect(response).toMatchObject({
+        id: 50,
+        error: {
+          code: JsonRpcHandler.ERROR_INVALID_PARAMS,
+          message: "Server not initialized. Call initialize first.",
+        },
+      });
+    });
+
     it("transpiles valid C-Next source", async () => {
+      // Initialize first (required for transpile)
+      await sendRequest({
+        id: 100,
+        method: "initialize",
+        params: { workspacePath: "/tmp" },
+      });
+      stdoutWriteSpy.mockClear();
+
       const response = await sendRequest({
         id: 2,
         method: "transpile",
@@ -73,6 +138,14 @@ describe("ServeCommand", () => {
     });
 
     it("returns errors for invalid source", async () => {
+      // Initialize first
+      await sendRequest({
+        id: 101,
+        method: "initialize",
+        params: { workspacePath: "/tmp" },
+      });
+      stdoutWriteSpy.mockClear();
+
       const response = await sendRequest({
         id: 3,
         method: "transpile",
@@ -139,6 +212,35 @@ describe("ServeCommand", () => {
       );
     });
 
+    it("parses symbols with filePath after initialization", async () => {
+      // Initialize first
+      await sendRequest({
+        id: 60,
+        method: "initialize",
+        params: { workspacePath: "/tmp" },
+      });
+      stdoutWriteSpy.mockClear();
+
+      const response = await sendRequest({
+        id: 61,
+        method: "parseSymbols",
+        params: {
+          source: "void myFunc() { }",
+          filePath: "/tmp/test.cnx",
+        },
+      });
+
+      const result = response as {
+        id: number;
+        result: { success: boolean; symbols: Array<{ name: string }> };
+      };
+      expect(result.id).toBe(61);
+      expect(result.result.success).toBe(true);
+      expect(result.result.symbols).toEqual(
+        expect.arrayContaining([expect.objectContaining({ name: "myFunc" })]),
+      );
+    });
+
     it("returns error for missing source param", async () => {
       const response = await sendRequest({
         id: 7,
@@ -154,6 +256,95 @@ describe("ServeCommand", () => {
         },
       });
     });
+
+    it("returns error for missing params", async () => {
+      const response = await sendRequest({
+        id: 70,
+        method: "parseSymbols",
+      });
+
+      expect(response).toMatchObject({
+        id: 70,
+        error: {
+          code: JsonRpcHandler.ERROR_INVALID_PARAMS,
+          message: "Missing required param: source",
+        },
+      });
+    });
+  });
+
+  describe("parseCHeader", () => {
+    it("parses symbols from C header source", async () => {
+      const response = await sendRequest({
+        id: 71,
+        method: "parseCHeader",
+        params: { source: "int myFunction(void);" },
+      });
+
+      const result = response as {
+        id: number;
+        result: { success: boolean; symbols: Array<{ name: string }> };
+      };
+      expect(result.id).toBe(71);
+      expect(result.result.success).toBe(true);
+      expect(result.result.symbols).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({ name: "myFunction" }),
+        ]),
+      );
+    });
+
+    it("parses struct definitions", async () => {
+      const response = await sendRequest({
+        id: 72,
+        method: "parseCHeader",
+        params: {
+          source: "typedef struct { int x; int y; } Point;",
+          filePath: "/tmp/types.h",
+        },
+      });
+
+      const result = response as {
+        id: number;
+        result: { success: boolean; symbols: Array<{ name: string }> };
+      };
+      expect(result.id).toBe(72);
+      expect(result.result.success).toBe(true);
+      expect(result.result.symbols).toEqual(
+        expect.arrayContaining([expect.objectContaining({ name: "Point" })]),
+      );
+    });
+
+    it("returns error for missing source param", async () => {
+      const response = await sendRequest({
+        id: 73,
+        method: "parseCHeader",
+        params: {},
+      });
+
+      expect(response).toMatchObject({
+        id: 73,
+        error: {
+          code: JsonRpcHandler.ERROR_INVALID_PARAMS,
+          message: "Missing required param: source",
+        },
+      });
+    });
+
+    it("returns error for missing params", async () => {
+      const response = await sendRequest({
+        id: 74,
+        method: "parseCHeader",
+      });
+
+      expect(response).toMatchObject({
+        id: 74,
+        error: {
+          code: JsonRpcHandler.ERROR_INVALID_PARAMS,
+          message: "Missing required param: source",
+        },
+      });
+    });
   });
 
   describe("shutdown", () => {
@@ -197,11 +388,44 @@ describe("ServeCommand", () => {
       handleLine("");
       handleLine("   ");
 
+      // Wait a tick to ensure any async work would have started
+      await new Promise((r) => setTimeout(r, 10));
+
       // No response should be written for empty lines
       expect(stdoutWriteSpy).not.toHaveBeenCalled();
     });
   });
 
+  describe("debug logging", () => {
+    it("writes debug messages to stderr when debug mode is enabled", async () => {
+      const stderrWriteSpy = vi
+        .spyOn(process.stderr, "write")
+        .mockImplementation(() => true);
+
+      // Enable debug mode via private field
+      (ServeCommand as unknown as { debugMode: boolean }).debugMode = true;
+
+      const response = await sendRequest({
+        id: 80,
+        method: "getVersion",
+      });
+
+      expect(response).toMatchObject({
+        id: 80,
+        result: { version: expect.any(String) },
+      });
+
+      // Debug logs should have been written to stderr
+      expect(stderrWriteSpy).toHaveBeenCalled();
+      const debugOutput = stderrWriteSpy.mock.calls.map((c) => c[0]).join("");
+      expect(debugOutput).toContain("[serve]");
+
+      // Clean up
+      (ServeCommand as unknown as { debugMode: boolean }).debugMode = false;
+      stderrWriteSpy.mockRestore();
+    });
+  });
+
   describe("invalid JSON", () => {
     it("returns parse error", async () => {
       const handleLine = (