v0.4.2-alpha VS Code Setup and Documentation Preview

This alpha release focuses on improving the first-run experience for VS Code users and cleaning up the extension internals. It introduces a setup doctor for modders, reorganizes the VS Code extension source into focused modules, and significantly improves the public documentation.

Highlights

• Added WitcherScript: Doctor Setup to the VS Code extension.
• Added a setup checklist for common installation and workspace issues.
• Added checks for workspace state, witcherscript.toml, uv, .NET SDK, language server environment, REDkit CLI, LSP status, configured Witcher 3 / REDkit paths, script roots, vanilla roots, and recompile executable settings.
• Improved first-run UX for modders using the .vsix package.
• Refactored the VS Code extension source into focused modules:
  • extension.ts
  • languageServer.ts
  • redkitCommands.ts
  • setupDoctor.ts
  • configuration.ts
  • paths.ts
  • statusBar.ts
  • process.ts
  • constants.ts
  • types.ts
• Reduced extension.ts to a thin activation and command-registration layer.
• Reworked README.md with clearer sections for modders, VS Code users, CLI users, and contributors.
• Reworked VS Code extension documentation with setup, commands, settings, troubleshooting, source layout, and packaging notes.
• Updated architecture documentation to describe the VS Code extension module layout.
• Improved version synchronization for prerelease versions such as 0.4.2-alpha.

Fixed

• .NET AssemblyVersion and FileVersion synchronization now use the numeric version portion for prerelease builds.
• Version metadata now supports prerelease labels without breaking .NET builds.

VS Code

The extension now includes a dedicated setup command:

WitcherScript: Doctor Setup

The command writes a setup report to the WitcherScript output panel and helps users identify missing tools, invalid paths, missing configuration, or language server startup issues.

Recommended first-run flow:

1. Install the .vsix.
2. Open your REDkit mod workspace.
3. Run WitcherScript: Doctor Setup.
4. Run WitcherScript: Initialize REDkit Config.
5. Open a .ws file.

Validation

The release has been verified with:

uv run ruff check .
uv run ruff format --check .
uv run mypy src/py
uv run pytest
dotnet test src/dotnet/WitcherScript.RedkitTooling.sln
npm --prefix src/vscode run smoke
npm --prefix src/vscode run package:vsix -- --out ../../dist/witcherscript-redkit-tools-0.4.2-alpha.vsix
uv run python scripts/sync_version.py --check
git diff --check

Current test result:

84 Python tests passed
11 .NET tests passed
VS Code extension lint/typecheck/compile passed
VSIX package builds successfully

Notes

This is an alpha release intended to validate the improved VS Code setup flow and the refactored extension structure before the next stable release.

v0.4.1 Stability and CI Fixes

This patch release fixes startup and CI issues found after the v0.4.0 release. It stabilizes semantic token registration in the language server, synchronizes package versions, and repairs dependency lockfiles used by GitHub Actions.

Highlights

• Fixed VS Code language server startup failure during initialize.
• Fixed semantic tokens capability registration for pygls / lsprotocol.
• Added a regression test that verifies LSP server capabilities serialize correctly during initialization.
• Synchronized repository version metadata to 0.4.1.
• Removed unused Python dev dependencies black and isort.
• Removed the broken transitive pytokens dependency from uv.lock.
• Fixed uv sync --all-extras --dev failure in CI.
• Updated VS Code extension lockfile integrity checksums for npm packages.
• Changed VS Code CI install steps to use npm ci --prefer-online.
• Fixed npm ci integrity failures in GitHub Actions.

Fixed

• AttributeError: 'SemanticTokensOptions' object has no attribute 'token_types' during LSP initialization.
• GitHub Actions Python job failing while downloading pytokens==0.4.0.
• GitHub Actions VS Code job failing with npm EINTEGRITY checksum errors.
• Version mismatch between VERSION, Python package metadata, VS Code extension metadata, and .NET project metadata.

Validation

The release has been verified with:

uv sync --all-extras --dev
uv run ruff check .
uv run ruff format --check .
uv run mypy src/py
uv run pytest
npm --prefix src/vscode ci --prefer-online
npm --prefix src/vscode run smoke
dotnet test src/dotnet/WitcherScript.RedkitTooling.sln
uv run python scripts/sync_version.py --check
git diff --check

Current test result:

84 Python tests passed
11 .NET tests passed
VS Code extension lint/typecheck/compile passed
Python and VS Code CI dependency installation passed locally

Notes

Users who installed the previous VS Code package should upgrade to the v0.4.1 .vsix. This release fixes the language server initialization crash that could prevent the extension from starting after semantic highlighting was introduced.

v0.4.0 Context-Aware Editing and Semantic Highlighting

This release expands WitcherScript REDkit Tools from structural language support into a richer daily editing experience. The language server now understands more source context, provides stronger semantic diagnostics, supports safer refactoring workflows, and delivers semantic syntax highlighting in VS Code.

Highlights

• Added context-aware completion for type positions, extends, local scope, member access, keywords, and imports.
• Added name resolution for globals, classes, functions, parameters, local variables, fields, methods, and inherited members.
• Added expression parsing for literals, identifiers, calls, member access, assignments, binary/unary expressions, and array access.
• Added type lookup and member access resolution for fields, methods, inherited members, return types, and chained access.
• Added signature help for function calls with active parameter tracking.
• Added expanded semantic diagnostics for unknown members, wrong argument count/type, assignment mismatch, return mismatch, duplicate classes, unresolved imports, and inheritance issues.
• Added conservative rename support for local variables and function parameters.
• Added code actions / quick fixes for common diagnostics.
• Added witcherscript doctor for project health checks.
• Added implementation lookup and inheritance tree support.
• Added semantic highlighting for classes, functions, methods, fields, local variables, parameters, built-in types, events, native symbols, and deprecated symbols.
• Improved VS Code extension usability with status feedback, output commands, startup error handling, REDkit workflow commands, and packaged .vsix release support.
• Added LSP integration tests for editor-facing behavior.
• Added contributor documentation, changelog, roadmap, security policy, and issue templates.

VS Code

The VS Code extension now provides a more complete editing loop for .ws files:

• semantic highlighting is enabled by default,
• autocomplete reacts to cursor context,
• signature help appears during function calls,
• hover/definition/references use the resolver and symbol index,
• rename works for scoped local symbols,
• REDkit commands can be triggered from the Command Palette,
• release builds now include a packaged .vsix.

Install the extension from the .vsix attached to GitHub Releases.

CLI

The Python developer CLI now includes:

uv run witcherscript doctor
uv run witcherscript parse path/to/file.ws
uv run witcherscript diagnostics path/to/file.ws
uv run witcherscript corpus path/to/scripts

The REDkit CLI continues to support project configuration and workflow commands:

dotnet run --project src/dotnet/src/WitcherScript.RedkitTooling.Cli -- init
dotnet run --project src/dotnet/src/WitcherScript.RedkitTooling.Cli -- validate
dotnet run --project src/dotnet/src/WitcherScript.RedkitTooling.Cli -- recompile
dotnet run --project src/dotnet/src/WitcherScript.RedkitTooling.Cli -- launch-game

Validation

The release has been verified with:

uv run ruff check .
uv run ruff format --check .
uv run mypy src/py
uv run pytest
npm --prefix src/vscode run smoke
dotnet test src/dotnet/WitcherScript.RedkitTooling.sln
uv run python scripts/sync_version.py --check
git diff --check
npm --prefix src/vscode run package:vsix -- --out ../../dist/witcherscript-redkit-tools.vsix

Current test result:

83 Python tests passed
11 .NET tests passed
VS Code extension lint/typecheck/compile passed
VSIX package builds successfully

Notes

This release makes the language server substantially more useful inside VS Code. The project now has context-aware IntelliSense-style behavior, semantic diagnostics, signature help, scoped rename, and semantic highlighting, while keeping the REDkit workflow available through CLI and editor commands.

v0.3.0 Context-Aware Language Intelligence

This release expands WitcherScript REDkit Tools from structural language support into context-aware editor intelligence. The language server now understands more about scopes, names, expressions, types, members, function signatures, semantic diagnostics, and REDkit-oriented workflows.

Highlights

• Added name resolution for global, class, function, local, and parameter scopes.
• Added local symbol lookup with correct priority for parameters and local variables.
• Added class member lookup for fields, methods, and events.
• Added inheritance-aware lookup for members defined on base classes.
• Added type reference resolution for class and known type names.
• Added context-aware completion for:
  • type positions
  • extends clauses
  • local variables
  • function parameters
  • project symbols
  • member access after .
  • import-like contexts
• Added expression AST support for:
  • literals
  • identifiers
  • calls
  • member access
  • assignments
  • binary expressions
  • unary expressions
  • array access
• Added type lookup for expressions and class members.
• Added member completion based on the resolved object type.
• Added unknown member diagnostics for invalid object.member access.
• Added signature help for function calls, including active parameter detection.
• Expanded semantic diagnostics for:
  • duplicate classes
  • unknown types
  • invalid inheritance
  • unknown members
  • wrong argument counts
  • wrong argument types
  • assignment type mismatches
  • return type mismatches
  • unresolved imports
• Added real-corpus analysis tooling for larger WitcherScript sample sets.
• Added corpus diagnostics summaries and parser coverage reporting.
• Improved the VS Code extension with:
  • LSP status bar feedback
  • output log command
  • clearer startup errors
  • restart command polish
  • configurable workspace root and LSP path settings
• Added REDkit workflow commands for CLI and VS Code:
  • safer init --force
  • improved validate
  • JSON validation output
  • Windows installation detection pass
  • recompile log parsing
  • VS Code recompile command
  • VS Code launch-game command
• Added LSP diagnostics for invalid or broken witcherscript.toml configuration.
• Expanded Python, .NET, and VS Code extension test coverage.

Changelog

Language Server

• Implemented scope-aware name resolution.
• Implemented class and inheritance member lookup.
• Implemented type lookup for symbols and expressions.
• Implemented context-aware completion behavior.
• Implemented member access completion based on resolved types.
• Implemented signature help through textDocument/signatureHelp.
• Improved go to definition, hover, and completion with resolver-backed data.
• Added config diagnostics for witcherscript.toml.
• Improved workspace refresh behavior after config changes.

Parser and Analyzer

• Added expression AST models.
• Added parser support for calls, member access, assignments, binary expressions, unary expressions, and array access.
• Added recovery behavior for malformed expressions.
• Added semantic diagnostics using name and type information.
• Added regression tests for expression parsing, name resolution, completion, signature help, and semantic diagnostics.

REDkit Tooling

• Improved ws-redkit validate output.
• Added JSON output for validation workflows.
• Improved init --force with safer overwrite behavior and backup creation.
• Expanded Windows 11 path detection for Steam, GOG, Epic, and SteamLibrary layouts.
• Added structured recompile log parsing.
• Added tests for fake filesystem detection and config writing.

VS Code Extension

• Added status bar LSP state indicator.
• Added WitcherScript: Show Output Logs.
• Added WitcherScript: Restart Language Server.
• Added WitcherScript: Recompile Scripts.
• Added WitcherScript: Launch Game.
• Improved REDkit config initialization from the Command Palette.
• Added configurable LSP path, working directory, workspace root, and REDkit command settings.
• Added TypeScript linting and checking to CI.

Testing and Quality

• Added end-to-end language-server fixtures.
• Added completion, definition, symbols, diagnostics, and snapshot regression tests.
• Added corpus test runner and sample corpus fixtures.
• Added .NET tests for REDkit detection and workflow helpers.
• Added VS Code extension lint, type-check, compile, and smoke checks.
• Extended CI coverage for Python, .NET, and TypeScript jobs.

Validation

The release has been verified with:

uv run ruff check .
uv run ruff format --check .
uv run mypy src/py
uv run pytest
dotnet test src/dotnet/WitcherScript.RedkitTooling.sln
npm --prefix src/vscode run lint
npm --prefix src/vscode run check
npm --prefix src/vscode run compile
git diff --check

Current test result:

76 Python tests passed
11 .NET tests passed
VS Code extension lint/check/compile passed

Notes

The language server now provides context-aware behavior instead of only returning broad keyword and project-symbol results. Completion, hover, definition, diagnostics, and signature help all use richer project, scope, and type information, making the VS Code extension significantly more useful for day-to-day WitcherScript editing.

v0.2.0 WitcherScript LSP, REDkit Tooling, and VS Code Harness

This release turns the project from a language-core foundation into a usable developer tooling stack. It adds core Language Server Protocol features, workspace/project indexing, semantic diagnostics, REDkit CLI integration, a VS Code extension harness, and end-to-end fixture coverage.

Highlights

• Implemented a functional WitcherScript language server with:

  • initialize
  • initialized
  • textDocument/didOpen
  • textDocument/didChange
  • textDocument/didSave
  • workspace/didChangeWatchedFiles
  • workspace/executeCommand
  • textDocument/publishDiagnostics

• Added editor-facing LSP features:

  • document symbols
  • workspace symbols
  • go to definition
  • hover
  • completion
  • references

• Added project-aware workspace support through witcherscript.toml.

• Added workspace scanning with:

  • source_roots
  • vanilla_roots
  • exclude rules

• Added project-wide symbol indexing for:

  • classes
  • states
  • functions
  • events
  • fields
  • local declarations

• Added semantic diagnostics for:

  • duplicate symbols
  • unknown types
  • missing base classes
  • unknown identifiers
  • function call argument count mismatches

• Added REDkit C# tooling CLI commands:

  • detect
  • init
  • print-config
  • validate
  • recompile
  • launch-game

• Added witcherscript.toml generation through REDkit tooling.

• Added LSP refresh command for live project reloads:

witcherscript.refreshIndex

• Added a VS Code extension harness for testing the language server in a real editor.

• Added TypeScript tooling for the VS Code extension:

  • TypeScript compile check
  • ESLint
  • GitHub Actions CI job

• Added end-to-end fixture tests for:

  • diagnostics
  • completion
  • go to definition
  • document symbols
  • workspace symbols
  • AST snapshots
  • larger project indexing

Changelog

Language Server

• Added full-document synchronization for opened, changed, and saved .ws files.
• Added diagnostic publication from lexer, parser, and semantic analysis.
• Added project index refresh for watched file changes.
• Added workspace/executeCommand support.
• Added witcherscript.refreshIndex for reloading witcherscript.toml without restarting the server.
• Added completion results for WitcherScript keywords and indexed project symbols.
• Added document outline support from indexed AST declarations.
• Added workspace-wide symbol search.
• Added definition lookup for indexed symbols.
• Added hover information for known symbols.
• Added simple reference lookup across indexed files.

Parser and Analysis

• Expanded parser support for structural declarations, function bodies, local variables, and statements.
• Added symbol table, scope model, type references, and inheritance index.
• Added semantic diagnostic rules for common project-level mistakes.
• Improved import resolution support in the project index.
• Fixed an import-cycle issue around workspace config compatibility exports.

REDkit Tooling

• Added REDkit project detection.
• Added game and REDkit installation detection with manual path support.
• Added content repository modeling for vanilla, DLC, mod, and project repositories.
• Added project validation output.
• Added TOML export for the language server.
• Added process adapters for recompilation and game launch commands.
• Organized C# tooling into focused directories.
• Added XML documentation comments for public C# API types and methods.

VS Code Extension

• Added a minimal VS Code extension under src/vscode.
• Added .ws language activation.
• Added configurable language server startup.
• Added command palette entries:
  • WitcherScript: Refresh Project Index
  • WitcherScript: Initialize REDkit Config
  • WitcherScript: Restart Language Server
• Added Extension Host debug configuration.
• Added local extension documentation.
• Added ESLint and TypeScript CI checks.

Tests and Fixtures

• Added project fixtures:
  • minimal_project
  • basic_project
  • broken_project
  • larger_project
• Added end-to-end tests over real fixture workspaces.
• Added AST snapshot coverage for fixture projects.
• Added performance-oriented indexing regression coverage.
• Expanded LSP tests for diagnostics, symbols, completion, definition, references, hover, watched files, and index refresh.

Validation

The release has been verified with:

uv run ruff check .
uv run ruff format --check .
uv run mypy src/py
uv run pytest
npm --prefix src/vscode run lint
npm --prefix src/vscode run check
npm --prefix src/vscode run compile
dotnet test src/dotnet/WitcherScript.RedkitTooling.sln

Current test result:

49 Python tests passed
6 .NET tests passed
VS Code extension lint/check/compile passed

Notes

The language server can now be tested directly in VS Code through the extension harness in src/vscode. The REDkit CLI can generate witcherscript.toml, and the running language server can reload that configuration through witcherscript.refreshIndex without restarting the editor.

v0.1.0 WitcherScript Language Core Foundation

This release establishes the foundation for WitcherScript REDkit Tools: a Python-based WitcherScript language server core, a REDkit-oriented .NET solution, project quality tooling, CI, and the first usable parser/lexer workflow.

Highlights

• Added the initial repository structure for Python and .NET development.
• Added Python packaging and dependency management with uv.
• Added .NET solution targeting the current SDK configured in the repository.
• Added GitHub Actions CI for Python and .NET checks.
• Added Docker and Dev Container support for portable development environments.
• Implemented the WitcherScript lexer.
• Implemented a tolerant structural parser.
• Added AST output through the developer CLI:

uv run witcherscript parse path/to/file.ws

• Added lexer and parser test coverage with snapshots.
• Added baseline REDkit project model types in C#.
• Added project documentation for architecture, LSP features, REDkit model, containers, and WitcherScript language notes.

Validation

The release has been verified with:

uv run ruff check .
uv run ruff format --check .
uv run mypy .
uv run pytest --cov=src/py
dotnet test src/dotnet/WitcherScript.RedkitTooling.sln

Current test result:

38 Python tests passed
1 .NET test passed

Notes

The witcherscript CLI can now parse .ws files and print the parsed AST as JSON. This provides a stable command-line entry point for validating lexer and parser behavior outside an editor.