Software Knowledge Engine

Software Knowledge Engine (SKE) helps you understand an unfamiliar TypeScript codebase without uploading it or asking an AI to guess. It indexes compiler and syntax evidence locally, then shows files, symbols, calls, references, dependencies, types, and exact source locations in a focused VS Code graph.

SKE was made for the questions that arrive before a safe code change:

• Where should I start in this repository?
• What uses this function, and what does it use?
• Where is this symbol referenced?
• What could a change affect?
• How are two parts of the project connected?

It is not a chatbot. It uses deterministic TypeScript compiler evidence, Tree-sitter syntax facts, and a local SQLite database. Runtime indexing requires no account, telemetry service, cloud database, AI model, or network connection.

Start here

If you received a .vsix from a release or a friend, read the User Guide. The short version is:

1. Choose the VSIX matching the computer where the VS Code extension host runs.
2. In VS Code, open Extensions → … → Install from VSIX….
3. Open a local TypeScript repository containing a tsconfig*.json file.
4. Open the Command Palette and run SKE: Index Workspace.
5. Use Project structure for orientation, then select a symbol and ask a plain-language relationship question.

The extension needs VS Code 1.125 or newer. It carries its native engine and uses VS Code's Node-compatible runtime, so extension users do not install Rust, pnpm, SQLite, or a separate Node.js runtime.

Desktop platform support

SKE uses platform-specific VSIX files because each one contains a native Rust engine. A VSIX for one platform must not be installed on another.

See BINARIES.md for exact VSIX filenames, CLI bundle layouts, executable locations, checksums, signing status, and release qualification.

Computer / extension host	VSIX target	Native engine
Windows x64	win32-x64	ske.exe
Windows ARM64	win32-arm64	ske.exe
macOS Intel	darwin-x64	ske
macOS Apple Silicon	darwin-arm64	ske
Linux x64	linux-x64	ske
Linux ARM64	linux-arm64	ske

The native release workflow builds, tests, smoke-indexes, packages, and checksums all six targets on matching Windows, macOS, and Linux runners. VS Code Remote users must choose the platform of the remote extension host, not always the laptop in front of them. VS Code Web and virtual workspaces are not supported.

First workflow

After indexing, the repository overview opens automatically.

Ask in SKE	Technical name	Meaning
What uses this?	Callers	Functions or modules that call the selected symbol
What does this use?	Callees	Functions or modules called by the selected symbol
Where is this used?	References	Resolved source locations that refer to the symbol
What could this affect?	Impact	Code that may depend on the selected symbol
How are these connected?	Path	The shortest known relationship path between two symbols
Project structure	Repository overview	Files/modules and their dependencies
Types and relationships	UML structure	Classes, interfaces, inheritance, and implementation

Select a node or edge for its full name, direction, relationship type, and evidence. Source navigation validates the indexed file hash before opening the exact range, so stale evidence is never silently presented as current.

What it is made of

• Rust engine: stable identities, indexing, invalidation, bounded queries, process supervision, cache recovery, and the CLI.
• TypeScript semantic worker: a pinned TypeScript 6 compiler/Language Service bridge, packaged with its standard library declarations.
• SQLite/WAL/FTS5: local, versioned evidence and snapshots.
• VS Code extension host: commands, progress, source navigation, clipboard, and the native engine process.
• React + Cytoscape + ELK: a responsive, keyboard-accessible graph in a network-denying webview.

Repository code, scripts, plugins, and the repository's own TypeScript package are never executed by SKE.

CLI quick start

The optional CLI bundle requires Node.js 22.12 or newer. Extract the bundle for your platform, keep its bin and lib directories together, and run:

ske index /path/to/repository
ske --root /path/to/repository symbol runJob
ske --root /path/to/repository callers <symbol-id>
ske --root /path/to/repository callees <symbol-id>
ske --root /path/to/repository references <symbol-id>
ske --root /path/to/repository impact <symbol-id>
ske --root /path/to/repository path <source-id> <target-id>
ske --root /path/to/repository status
ske --root /path/to/repository doctor

Use ske.exe on Windows. Add --format json or --format jsonl for structured output. The User Guide has shell-specific examples and cache locations.

Build from source

Install Rust 1.92.0, Node.js 22.12 or newer, pnpm 11.7.0, and a native C/C++ toolchain (Visual Studio Build Tools on Windows, Xcode Command Line Tools on macOS, or GCC/build-essential on Linux). Then run from the repository root:

pnpm install --frozen-lockfile
cargo xtask verify
cargo xtask build-dev
pnpm -r test
cargo test --workspace --locked

Create a VSIX from the command line

Build the VSIX on the same operating system and CPU architecture that will run the VS Code extension host. First compile the native release engine, then pass that executable to the platform-aware packager:

cargo build --release --locked --bin ske --target <rust-target>
node packages/vscode-extension/package-platform.mjs \
  --target <vscode-target> \
  --engine target/<rust-target>/release/<ske-or-ske.exe> \
  --out target-dist/ske-vscode-0.1.0-<vscode-target>.vsix

For example, on Windows x64 in PowerShell:

cargo build --release --locked --bin ske --target x86_64-pc-windows-msvc
node packages/vscode-extension/package-platform.mjs `
  --target win32-x64 `
  --engine target\x86_64-pc-windows-msvc\release\ske.exe `
  --out target-dist\ske-vscode-0.1.0-win32-x64.vsix
``

or Bash:

```bash
cargo build --release --locked --bin ske --target x86_64-pc-windows-msvc
node packages/vscode-extension/package-platform.mjs \
  --target win32-x64 \
  --engine target/x86_64-pc-windows-msvc/release/ske.exe \
  --out target-dist/ske-vscode-0.1.0-win32-x64.vsix

The packager rebuilds the TypeScript extension assets and runs vsce package with the matching platform target. Supported VS Code targets are win32-x64, win32-arm64, darwin-x64, darwin-arm64, linux-x64, and linux-arm64; the complete Rust target mapping is in BUILD.md.

cargo xtask build-dev produces target/debug/ske on macOS/Linux or target\debug\ske.exe on Windows and builds the semantic worker, webview, and extension. See BUILD.md for native packaging commands and the full platform matrix.

To remove reproducible build output and QA scratch databases without touching reports or source files, run pnpm clean. Preview the affected paths with pnpm clean:dry-run; use pnpm clean:all only when dependency installations should also be removed.

Verification and release artifacts

The repository includes:

• cross-platform runtime discovery and OS-native cache paths;
• target-aware ske/ske.exe extension packaging;
• platform-specific vsce --target assembly;
• native Windows, macOS, and Linux CI jobs for x64 and ARM64;
• packaged CLI index/query smoke tests and SHA-256 manifests;
• the responsive/accessibility test evidence documented in UX_REMEDIATION.md.

Do not relabel a VSIX from another operating system. Share the matching artifact and its SHA256SUMS file together.

Roadmap

The next milestones are signed/notarized public release artifacts, Marketplace publishing with automatic platform selection, larger real-world repository qualification, richer module grouping and saved graph sessions, and eventually additional compiler-grounded languages. SKE will keep deterministic evidence, offline operation, bounded graphs, and source-read-only behavior as invariants; AI-generated explanations are not a substitute for evidence.

Documentation

• USER_GUIDE.md — install, learn, use, troubleshoot, uninstall, share, and understand the roadmap
• BUILD.md — contributor setup, native builds, packages, and CI
• BINARIES.md — choose, install, verify, build, and share native binaries
• UX_REMEDIATION.md — frontend root causes and QA evidence
• Desktop compatibility report — OS/architecture corrections, native matrix, local evidence, and release boundary
• ARCHITECTURE.md — trust boundaries and component ownership
• SECURITY.md — local-data and vulnerability guidance
• CONTRIBUTING.md — change and verification gates

SKE source is licensed under Apache License 2.0. Bundled third-party notices and asset licenses are retained in each release artifact's LICENSES directory.