feat: basic syntax checking

Signed-off-by: Gordon Smith <GordonJSmith@gmail.com>

Author: GordonSmith

.gitignore

@@ -77,3 +77,5 @@ dist/
 *.vsix
 *.tmLanguage.json
 !/syntaxes/*.tmLanguage.json
+types/
+out/

.vscode/settings.json

@@ -1,23 +1,23 @@
 {
     "editor.formatOnSave": true,
-    "editor.defaultFormatter": "esbenp.prettier-vscode",
+    "editor.defaultFormatter": "vscode.typescript-language-features",
     "editor.codeActionsOnSave": {
         "source.fixAll.eslint": "explicit"
     },
     "[typescript]": {
-        "editor.defaultFormatter": "esbenp.prettier-vscode",
+        "editor.defaultFormatter": "vscode.typescript-language-features",
         "editor.formatOnSave": true
     },
     "[javascript]": {
-        "editor.defaultFormatter": "esbenp.prettier-vscode",
+        "editor.defaultFormatter": "vscode.typescript-language-features",
         "editor.formatOnSave": true
     },
     "[json]": {
-        "editor.defaultFormatter": "esbenp.prettier-vscode",
+        "editor.defaultFormatter": "vscode.json-language-features",
         "editor.formatOnSave": true
     },
     "[jsonc]": {
-        "editor.defaultFormatter": "esbenp.prettier-vscode",
+        "editor.defaultFormatter": "vscode.json-language-features",
         "editor.formatOnSave": true
     }
 }

.vscode/tasks.json

@@ -2,17 +2,26 @@
     "version": "2.0.0",
     "tasks": [
         {
-            "label": "watch",
             "type": "npm",
-            "script": "watch",
+            "label": "gen-watch",
+            "script": "gen-watch",
+            "problemMatcher": ["$tsc-watch"],
+            "presentation": {
+                "group": "build"
+            }
+        },
+        {
+            "type": "npm",
+            "label": "build-watch",
+            "script": "build-watch",
             "problemMatcher": [],
             "presentation": {
                 "group": "build"
             }
         },
         {
             "label": "build",
-            "dependsOn": ["watch"],
+            "dependsOn": ["build-watch", "gen-watch"],
             "group": {
                 "kind": "build",
                 "isDefault": true

.vscodeignore

@@ -2,8 +2,9 @@
 .vscode-test/**
 .github/
 .gitignore
+node_modules/
 tests/
-commitlint.config.js
+commitlint.config.cjs
 src/**
 .yarnrc
 **/tsconfig.json

README.md

@@ -14,6 +14,57 @@ This extension provides:
 - [Snippets](https://code.visualstudio.com/docs/editor/userdefinedsnippets) for worlds and interfaces.
 - Basic markdown highlighting in comments.
 - Simple list-based autocomplete.
+- **WIT Syntax Checking**: Validate WIT files for common syntax errors and provide diagnostics.
+
+### Syntax Validation and Error Display
+
+The extension provides comprehensive WIT syntax validation with error display in VS Code's PROBLEMS pane:
+
+#### Automatic Validation
+- **On File Save**: Automatically validates WIT files when saved
+- **On File Open**: Validates WIT files when opened in the editor
+- **Real-time Feedback**: Errors appear immediately in the PROBLEMS pane
+
+#### Manual Commands
+- **WIT: Check Syntax** (`Ctrl+Shift+P` → "WIT: Check Syntax")
+  - Validates the currently active WIT file
+  - Shows detailed error information in notifications
+  - Displays errors in the PROBLEMS pane
+
+- **WIT: Check Syntax in Workspace** (`Ctrl+Shift+P` → "WIT: Check Syntax in Workspace")
+  - Validates all WIT files in the workspace
+  - Shows progress notification during validation
+  - Provides summary of results
+  - Creates detailed report in output channel
+
+#### Error Information
+When validation fails, the extension displays:
+- **Error location**: Precise line and column numbers
+- **Error message**: Detailed description of the syntax error
+- **Context**: Additional information about the error
+- **Related information**: Links to relevant documentation or context
+
+#### PROBLEMS Pane Integration
+- Errors appear automatically in VS Code's PROBLEMS pane
+- Click on any error to jump directly to the problematic line
+- Errors are cleared automatically when files are fixed or closed
+- Supports multiple files with errors simultaneously
+
+### Code Completion
+
+The extension offers intelligent code completion for WIT files:
+
+- **Context-aware suggestions**: Provides completion items based on the current context
+- **Keyword snippets**: Includes common WIT keywords and constructs
+- **Custom snippets**: User-defined snippets for faster coding
+
+### Command Palette Integration
+
+Easily access extension features through the Command Palette:
+
+- **WIT: Check Syntax**: Validate the current file's syntax
+- **WIT: Check Syntax in Workspace**: Validate all WIT files in the workspace
+- **WIT: Show Output Channel**: Display the extension's output channel
 
 ## Installation
 

TESTING.md

@@ -0,0 +1,60 @@
+# Testing with Vitest
+
+This project now uses [Vitest](https://vitest.dev/) for unit testing, providing a fast and modern testing experience with excellent TypeScript support.
+
+## Available Test Scripts
+
+- `npm run test:unit` - Run all unit tests once
+- `npm run test:unit:watch` - Run tests in watch mode (reruns when files change)
+- `npm run test:unit:ui` - Open the Vitest UI for interactive testing
+- `npm test` - Run the full test suite (lint, format check, build, package, grammar tests, and unit tests)
+
+## Test Structure
+
+### Unit Tests
+- Located in `tests/` directory
+- Use `.test.ts` or `.spec.ts` suffix
+- Written using Vitest's `describe`, `it`, and `expect` APIs
+
+### Current Tests
+- `tests/errorParser.test.ts` - Tests for WIT error parsing functionality
+
+## Writing Tests
+
+```typescript
+import { describe, it, expect } from 'vitest';
+import { yourFunction } from '../src/yourModule';
+
+describe('Your Module', () => {
+    it('should do something', () => {
+        const result = yourFunction('input');
+        expect(result).toBe('expected output');
+    });
+});
+```
+
+## Error Parser Tests
+
+The `errorParser.test.ts` file contains comprehensive tests for the WIT error parsing regex, including:
+
+- Extraction from real WIT error stacks
+- Handling invalid/malformed stacks
+- Edge cases with large line/column numbers
+- Different file path formats
+- Stacks with and without "Caused by" sections
+
+## Configuration
+
+The Vitest configuration is in `vitest.config.ts` and includes:
+- TypeScript support out of the box
+- Node.js environment
+- Path aliases for cleaner imports
+- Automatic file discovery for tests
+
+## VS Code Integration
+
+Vitest works great with VS Code. You can:
+1. Install the [Vitest extension](https://marketplace.visualstudio.com/items?itemName=ZixuanChen.vitest-explorer)
+2. Run tests directly from the editor
+3. See test results inline
+4. Debug tests with breakpoints

commitlint.config.js commitlint.config.cjscommitlint.config.js renamed to commitlint.config.cjs

@@ -2,10 +2,142 @@
 // See: https://github.com/microsoft/vscode-extension-samples/blob/main/esbuild-sample/esbuild.js
 
 import * as esbuild from "esbuild";
+import * as fs from "fs";
+import * as path from "path";
 
 const production = process.argv.includes("--production");
 const watch = process.argv.includes("--watch");
 
+/**
+ * Copy WASM and worker resources from node_modules to dist
+ */
+function copyWasmResources() {
+    const distDir = path.join(process.cwd(), "dist");
+
+    // Ensure dist directory exists
+    fs.mkdirSync(distDir, { recursive: true });
+
+    // Copy WASM files from @bytecodealliance/jco/lib
+    const jcoLibDir = path.join(process.cwd(), "node_modules", "@bytecodealliance", "jco", "lib");
+    const jcoLibFiles = ["wasi_snapshot_preview1.command.wasm", "wasi_snapshot_preview1.reactor.wasm"];
+
+    jcoLibFiles.forEach((file) => {
+        const srcPath = path.join(jcoLibDir, file);
+        const destPath = path.join(distDir, file);
+
+        if (fs.existsSync(srcPath)) {
+            fs.copyFileSync(srcPath, destPath);
+            console.log(`Copied ${file} to dist/`);
+        } else {
+            console.warn(`Warning: ${srcPath} not found`);
+        }
+    });
+
+    // Copy all WASM files from jco/obj
+    const jcoObjDir = path.join(process.cwd(), "node_modules", "@bytecodealliance", "jco", "obj");
+    if (fs.existsSync(jcoObjDir)) {
+        const objFiles = fs.readdirSync(jcoObjDir).filter((file) => file.endsWith(".wasm"));
+        objFiles.forEach((file) => {
+            const srcPath = path.join(jcoObjDir, file);
+            const destPath = path.join(distDir, file);
+            fs.copyFileSync(srcPath, destPath);
+            console.log(`Copied ${file} to dist/`);
+        });
+    }
+
+    // Copy WASM files from @bytecodealliance/componentize-js
+    const componentizeJsLibDir = path.join(
+        process.cwd(),
+        "node_modules",
+        "@bytecodealliance",
+        "componentize-js",
+        "lib"
+    );
+
+    const componentizeJsLibFiles = [
+        "spidermonkey-embedding-splicer.core.wasm",
+        "spidermonkey-embedding-splicer.core2.wasm",
+        "starlingmonkey_embedding.wasm",
+        "starlingmonkey_embedding.debug.wasm",
+        "starlingmonkey_embedding_weval.wasm",
+    ];
+
+    componentizeJsLibFiles.forEach((file) => {
+        const srcPath = path.join(componentizeJsLibDir, file);
+        const destPath = path.join(distDir, file);
+
+        if (fs.existsSync(srcPath)) {
+            fs.copyFileSync(srcPath, destPath);
+            console.log(`Copied ${file} to dist/`);
+        } else {
+            console.warn(`Warning: ${srcPath} not found`);
+        }
+    });
+
+    // Also check nested componentize-js in jco
+    const jcoNestedComponentizeJsLibDir = path.join(
+        process.cwd(),
+        "node_modules",
+        "@bytecodealliance",
+        "jco",
+        "node_modules",
+        "@bytecodealliance",
+        "componentize-js",
+        "lib"
+    );
+
+    if (fs.existsSync(jcoNestedComponentizeJsLibDir)) {
+        componentizeJsLibFiles.forEach((file) => {
+            const srcPath = path.join(jcoNestedComponentizeJsLibDir, file);
+            const destPath = path.join(distDir, file);
+
+            if (fs.existsSync(srcPath) && !fs.existsSync(destPath)) {
+                fs.copyFileSync(srcPath, destPath);
+                console.log(`Copied ${file} from nested jco/componentize-js to dist/`);
+            }
+        });
+    }
+
+    // Copy files from @bytecodealliance/preview2-shim
+    const preview2ShimDir = path.join(process.cwd(), "node_modules", "@bytecodealliance", "preview2-shim");
+
+    if (fs.existsSync(preview2ShimDir)) {
+        // Copy the main module files
+        const shimFiles = ["lib", "src"];
+        shimFiles.forEach((item) => {
+            const srcPath = path.join(preview2ShimDir, item);
+            const destPath = path.join(distDir, "preview2-shim", item);
+
+            if (fs.existsSync(srcPath)) {
+                // Create destination directory
+                fs.mkdirSync(path.dirname(destPath), { recursive: true });
+
+                if (fs.statSync(srcPath).isDirectory()) {
+                    // Copy directory recursively
+                    fs.cpSync(srcPath, destPath, { recursive: true });
+                    console.log(`Copied ${item}/ from preview2-shim to dist/preview2-shim/`);
+                } else {
+                    // Copy file
+                    fs.copyFileSync(srcPath, destPath);
+                    console.log(`Copied ${item} from preview2-shim to dist/preview2-shim/`);
+                }
+            }
+        });
+
+        // Copy package.json for module resolution
+        const packageJsonSrc = path.join(preview2ShimDir, "package.json");
+        const packageJsonDest = path.join(distDir, "preview2-shim", "package.json");
+        if (fs.existsSync(packageJsonSrc)) {
+            fs.mkdirSync(path.dirname(packageJsonDest), { recursive: true });
+            fs.copyFileSync(packageJsonSrc, packageJsonDest);
+            console.log("Copied package.json from preview2-shim to dist/preview2-shim/");
+        }
+    }
+
+    // Note: Worker files are bundled directly into dist/ to ensure proper module resolution
+    // This prevents import errors when the extension tries to load worker threads at runtime
+}
+
 /**
  * @type {import('esbuild').Plugin}
  */
@@ -28,18 +160,56 @@ const esbuildProblemMatcherPlugin = {
 };
 
 async function main() {
+    // Copy WASM resources first
+    console.log("Copying WASM resources...");
+    copyWasmResources();
+
+    // Find all worker files in preview2-shim
+    const preview2ShimWorkerDir = path.join(
+        process.cwd(),
+        "node_modules",
+        "@bytecodealliance",
+        "preview2-shim",
+        "lib",
+        "io"
+    );
+
+    const workerEntryPoints = [];
+    if (fs.existsSync(preview2ShimWorkerDir)) {
+        const workerFiles = fs
+            .readdirSync(preview2ShimWorkerDir)
+            .filter((file) => file.startsWith("worker-") && file.endsWith(".js"))
+            .map((file) => path.join(preview2ShimWorkerDir, file));
+        workerEntryPoints.push(...workerFiles);
+        console.log(
+            `Found ${workerFiles.length} worker files to bundle:`,
+            workerFiles.map((f) => path.basename(f))
+        );
+    }
+
     const ctx = await esbuild.context({
-        entryPoints: ["src/extension.ts"],
+        entryPoints: ["src/extension.ts", ...workerEntryPoints],
         bundle: true,
-        format: "cjs",
+        format: "esm",
         minify: production,
         sourcemap: !production,
         sourcesContent: false,
         platform: "node",
-        outfile: "dist/extension.js",
+        target: "node18",
+        outdir: "dist",
+        entryNames: "[name]",
         external: ["vscode"],
         logLevel: "silent",
         plugins: [esbuildProblemMatcherPlugin],
+        inject: ["src/node-polyfills.js"],
+        define: {
+            // Define globals to prevent bundling issues
+            "process.env.NODE_ENV": JSON.stringify(production ? "production" : "development"),
+        },
+        // Add banner to ensure polyfills are loaded first
+        banner: {
+            js: "// VS Code Extension - ESM Node.js Environment\n",
+        },
     });
     if (watch) {
         await ctx.watch();