WIA — Workspace Intelligence Agent

Workspace Intelligence Agent (WIA) is an enterprise-grade, graph-grounded workspace reasoning engine, deterministic AST intelligence platform, and non-autoregressive decision router for modern software repositories, command-line interfaces, and VS Code / Antigravity IDEs.

WIA combines deterministic Abstract Syntax Tree (AST) parsing, $O(1)$ directional knowledge graphs, multi-language reverse indexing, automated dependency conflict resolution, and the Laya JEV (Jaccard-Edit-Vector) Non-Autoregressive Decision Router to anchor all developer queries in verified codebase evidence with zero hallucinations.

📑 Table of Contents

• 🏛️ System Architecture
• ⚡ Key Innovations & Mathematical Formulations
  • 1. Laya JEV Non-Autoregressive Routing Engine
  • 2. Multi-Tier Refactoring Impact & Risk Classification
  • 3. $O(1)$ Inverted Index & Token Relevance Engine
  • 4. Directional Knowledge Graph & Cycle Detection
• 🛠️ Complete CLI Command Reference
• 🧩 VS Code & Antigravity IDE Extension
  • Interactive Sidebar Agent View
  • Refactoring Change Impact Inspector
  • Visual Architecture & Subsystem Explorer
  • In-Editor Symbol Impact CodeLens
  • Extension Command Registry
• 📊 Benchmarks & Performance Statistics
• 💻 Technology Stack
• 🚀 Installation & Setup
• ⚙️ Multi-Provider AI Configuration
• 📁 Repository Structure
• 🧪 Verification & Testing
• 🔒 Security & Privacy Guarantees
• 📄 License & Credits

🏛️ System Architecture

                                        WORKSPACE ROOT REPOSITORY
                                                   │
                ┌──────────────────────────────────┴──────────────────────────────────┐
                ▼                                                                     ▼
     [ Source Code & Manifests ]                                           [ Jupyter Notebooks (.ipynb) ]
     Py, TS, JS, Go, Rust, Java, C/C++                                     Cells, Functions, Imports, Code Chunks
                │                                                                     │
                └──────────────────────────────────┬──────────────────────────────────┘
                                                   │
                                                   ▼
                                 [ MULTI-LANGUAGE AST & LEXICAL PARSER ]
                                 Deterministic Extractor: Classes, Functions,
                                 Signatures, Calls, Imports, Docstrings, Types
                                                   │
                        ┌──────────────────────────┴──────────────────────────┐
                        ▼                                                     ▼
         [ INVERTED SEARCH INDEX (O(1)) ]                      [ DIRECTIONAL KNOWLEDGE GRAPH (O(1)) ]
         Token -> File/Symbol Inverted Maps                    Nodes: Files, Symbols, Modules, Classes
         BM25-Weighted Substring Lexicon                       Edges: DEFINES, CALLS, IMPORTS, INHERITS, TESTS
                        │                                                     │
                        └──────────────────────────┬──────────────────────────┘
                                                   │
                                                   ▼
                                   [ STORAGE & REPOSITORY LAYER ]
                                   SQLite Store (WAL Mode, 64MB Cache)
                                   .wia/index.json + .wia/graph.json
                                                   │
                                                   ▼
                              [ LAYA JEV NON-AUTOREGRESSIVE ROUTER ]
                              Input: Natural Language Query / IDE Command
                                                   │
                   ┌───────────────────────────────┴───────────────────────────────┐
                   │ JEV Score >= 0.55                                             │ JEV Score < 0.55
                   ▼ (Deterministic Canonical Route)                               ▼ (Conceptual Fallback)
        [ CANONICAL WIA TOOL ENGINE ]                                   [ 7,500-TOKEN RAG CONTEXT RETRIEVER ]
        • Impact Analysis (Blast Radius)                                • Symbol & Signature Budgeting
        • Architecture Map & DFS Cycles                                 • Call Hierarchy & Importer Traces
        • Dependency Conflict Detector                                  • Test Suite Citations
        • forward Call Trace Flow                                                      │
        • Git Churn & Hotspot Audit                                                    ▼
        • Secret & Token Scanner                                        [ GROUNDED REASONING ENGINE (LLM) ]
                   │                                                    OpenRouter / NVIDIA NIM / OpenAI /
                   │                                                    Anthropic Claude / Google Gemini
                   └───────────────────────────────┬───────────────────────────────────┘
                                                   │
                                                   ▼
                               [ EVIDENCE-GROUNDED CITATION OUTPUT ]
                               • Terminal Rich/ANSI Formatted Reports
                               • Standalone Interactive HTML Intelligence Report
                               • VS Code Extension Webview & CodeLens Panels

⚡ Key Innovations & Mathematical Formulations

1. Laya JEV Non-Autoregressive Routing Engine

Traditional developer tooling relies on slow, expensive LLM calls ($1,200\text{ms}+$) just to decide which tool to execute. The Laya Decision Engine replaces autoregressive classification with a deterministic, sub-millisecond ($<0.2\text{ms}$) multi-factor Jaccard-Edit-Vector (JEV) routing algorithm.

Composite JEV Scoring Function

For an incoming user query $Q$ and candidate command pattern $C$:

$$\text{JEV}(Q, C) = w_j \cdot \text{SoftJaccard}(Q, C) + w_e \cdot \text{NormalizedEditSim}(Q, C) + w_v \cdot \text{VectorScore}(Q, C)$$

where the optimal empirical weights are calibrated to:

$$w_j = 0.35, \quad w_e = 0.35, \quad w_v = 0.30 \quad \left(\sum w_k = 1.0\right)$$

Component Formulations:

1. Soft Jaccard with Token Containment ($\text{SoftJaccard}$): Measures lexical set overlap while boosting queries where the full command token vocabulary is completely contained within the user input:

   $$\text{SoftJaccard}(Q, C) = \frac{|T(Q) \cap T(C)|}{|T(Q) \cup T(C)|} \cdot \left(1.0 + 0.2 \cdot \mathbb{I}(T(C) \subseteq T(Q))\right)$$

   where $T(x)$ is the normalized alphanumeric token set of string $x$, and $\mathbb{I}(\cdot)$ is the indicator function.

2. Normalized Levenshtein Edit Similarity ($\text{NormalizedEditSim}$): Provides robust typo-tolerance against misspelled developer inputs (e.g., "archtecture map" $\to$ "architecture", "diagnostix doctor" $\to$ "doctor"):

   $$\text{NormalizedEditSim}(Q, C) = 1.0 - \frac{\text{Levenshtein}(Q, C)}{\max(|Q|, |C|)}$$

3. Domain Vector Vocabulary Overlap ($\text{VectorScore}$)

Weights technical domain terms and command trigger keywords:

$$ \text{VectorScore}(Q, C) = \frac{ \sum_{t \in T(Q) \cap T(C)} \text{IDF}{\text{domain}}(t) }{ \sum{t \in T(C)} \text{IDF}_{\text{domain}}(t) } $$

Decision Boundary & Fallback Threshold

$$ \text{Route}(Q) = \begin{cases} \arg\max_{C} \text{JEV}(Q,C), & \text{if } \max_{C} \text{JEV}(Q,C) \geq \theta_{\text{route}} \land \text{IsDeterministic}(Q) \[6pt] \text{AI-FALLBACK}, & \text{if } \max_{C} \text{JEV}(Q,C) < \theta_{\text{route}} \lor \text{IsConceptual}(Q) \end{cases} $$

where $\theta_{\mathrm{route}} = 0.55$.

Conceptual triggers ("why", "explain why", "trade-offs", "design pattern", "how should we refactor") automatically route to the citation-grounded LLM layer.

2. Multi-Tier Refactoring Impact & Risk Classification

WIA computes the exact blast radius of changing any symbol or file by traversing the directed knowledge graph $G = (V, E)$.

Traversal Formulation:

• Target Node: $v_t \in V_{\text{symbol}} \cup V_{\text{file}}$ defined in file $f(v_t)$.
• Direct Consumers: $$\text{DirectFiles}(v_t) = { f(u) \mid (u, v_t) \in E \land \text{relation}(u, v_t) \in {\text{CALLS}, \text{IMPORTS}, \text{INHERITS}} \land f(u) \neq f(v_t) }$$
• Indirect/Transitive Ripple: $$\text{IndirectFiles}(v_t) = \text{BFS}_{\text{depth} \le 4}(\text{DirectFiles}(v_t)) \setminus \text{DirectFiles}(v_t)$$
• Total Affected Component Set: $$\text{AffectedFiles}(v_t) = \text{DirectFiles}(v_t) \cup \text{IndirectFiles}(v_t)$$
• Affected Test Suite: $$\text{AffectedTests}(v_t) = { f \in \text{AffectedFiles}(v_t) \mid \text{IsTestFile}(f) }$$

Evidence-Derived Risk Rating Metric:

$$\text{RiskLevel}(v_t) = \begin{cases} \mathbf{HIGH} & \text{if } |\text{AffectedFiles}(v_t)| \ge 10 \lor |\text{AffectedTests}(v_t)| \ge 5 \ \mathbf{MEDIUM} & \text{if } 3 \le |\text{AffectedFiles}(v_t)| < 10 \ \mathbf{LOW} & \text{if } 0 < |\text{AffectedFiles}(v_t)| < 3 \lor \left(|\text{AffectedFiles}(v_t)| = 0 \land \text{Found}(v_t)\right) \ \mathbf{NOT_FOUND} & \text{if } \neg\text{Found}(v_t) \end{cases}$$

Key Rule: Symbol-level impact analysis evaluates the symbol's actual incoming call and reference edges. It never contaminates isolated symbols with whole-file container importers.

3. $O(1)$ Inverted Index & Token Relevance Engine

The WIA inverted search index maps tokens, symbols, docstring terms, and file paths into memory-mapped posting lists for instantaneous sub-millisecond retrieval.

Lexical Relevance Scoring:

$$\text{Score}(D, Q) = \sum_{t \in Q \cap D} \text{IDF}(t) \cdot \frac{\text{TF}(t, D) \cdot (k_1 + 1)}{\text{TF}(t, D) + k_1 \cdot \left(1 - b + b \cdot \frac{|D|}{\text{avgdl}}\right)} + \text{ExactMatchBonus}(t, D)$$

• $\text{TF}(t, D)$: Term frequency of token $t$ in document/symbol metadata $D$.
• $\text{IDF}(t) = \ln\left(1 + \frac{N - n(t) + 0.5}{n(t) + 0.5}\right)$, where $N$ is total indexed files and $n(t)$ is count of files containing $t$.
• $k_1 = 1.2$, $b = 0.75$.
• $\text{ExactMatchBonus}(t, D) = 2.5 \cdot \mathbb{I}(t = \text{SymbolName}(D))$.

4. Directional Knowledge Graph & Cycle Detection

The WorkspaceGraph models the entire repository as a typed directed multi-graph:

• Node Types: file, module, class, function, package.
• Edge Types: DEFINES, CALLS, IMPORTS, INHERITS, DEPENDS_ON, TESTS.

Circular Dependency Cycle Detection:

WIA executes Tarjan's Strongly Connected Components (SCC) and Depth-First Search (DFS) back-edge detection on file-level IMPORTS subgraphs to locate architectural violations:

$$\text{Cycle}(G) = { (v_1, v_2, \dots, v_k, v_1) \mid (v_i, v_{i+1}) \in E_{\text{IMPORTS}} }$$

🛠️ Complete CLI Command Reference

All commands support running 100% offline on local repositories.

wia [OPTIONS] COMMAND [ARGS]...

General Options

• --version: Print WIA version and build metadata.
• --help: Show detailed command help and options.

Command Directory

1. wia init

Initialize a new .wia/ knowledge workspace in the target directory.

wia init [PATH]
# Example:
wia init ./

2. wia index

Perform high-speed incremental AST parsing and knowledge graph extraction.

wia index [OPTIONS]
# Options:
#   -w, --workspace PATH      Path to workspace directory (default: current directory)
#   -f, --force               Force full clean re-indexing
#   --workers INTEGER         Number of parallel worker processes (default: CPU core count)
# Example:
wia index --workers 8 --force

3. wia status

Inspect index health, timestamps, tracked files, total lines of code, and language distribution.

wia status [-w PATH]

4. wia summary

Generate an executive technical summary of the codebase, primary entry points, and component hierarchy.

wia summary [-w PATH]

5. wia search

Execute an $O(1)$ inverted index search across symbols, signatures, docstrings, and files.

wia search [OPTIONS] QUERY
# Options:
#   -t, --type [all|symbol|file|function|class]  Filter by entity type
#   -l, --limit INTEGER                          Maximum results to display (default: 20)
# Example:
wia search "WorkspaceIndex" --type class

6. wia explain

Generate an evidence-grounded, citation-backed 13-section architectural breakdown of a file or symbol.

wia explain [OPTIONS] TARGET
# Example:
wia explain wia/core/impact.py
wia explain LayaDecisionEngine

7. wia impact

Evaluate refactoring blast radius, direct callers, downstream ripple, affected tests, and risk classification.

wia impact [OPTIONS] SYMBOL
# Options:
#   --json                    Output structured JSON impact report
#   -w, --workspace PATH      Workspace directory path
# Example:
wia impact getNonce
wia impact WorkspaceIndex --json

8. wia architecture

Map architectural subsystems, fan-in/fan-out metrics, external dependencies, and detect circular import cycles.

wia architecture [-w PATH]

9. wia flow

Trace downstream and upstream execution call chains starting from any root function or entry point.

wia flow [OPTIONS] ENTRY_SYMBOL
# Options:
#   -d, --depth INTEGER       Maximum call depth (default: 5)
# Example:
wia flow main --depth 4

10. wia diff

Audit local uncommitted git changes and determine affected symbols and test suites before committing.

wia diff [-w PATH]

11. wia analyze deps

Audit package manifests (requirements.txt, pyproject.toml, package.json, go.mod, Cargo.toml), missing imports, and version conflicts.

wia analyze deps [-w PATH]

12. wia analyze git

Analyze commit velocity, file churn hotspots, code stability, and author contribution distributions.

wia analyze git [--days 30] [-w PATH]

13. wia analyze security

High-throughput scanning for hardcoded secrets, API keys, credentials, and vulnerable patterns.

wia analyze security [-w PATH]

14. wia doctor

Perform deep diagnostic checks on Python version, SQLite integrity, PATH variables, compiler availability, and dependencies.

wia doctor

15. wia report

Generate an interactive, standalone HTML intelligence report with collapsible language views, graph visualizers, and metrics.

wia report [OPTIONS]
# Options:
#   -o, --output PATH         Output HTML file path (default: wia-report.html)
# Example:
wia report --output wia-report.html

16. wia export

Export indexed knowledge graph and entities into Open Knowledge Format (OKF) or JSON.

wia export [--format okf|json] [--output PATH]

17. wia ask

Ask natural-language questions about codebase architecture, design trade-offs, and implementation details.

wia ask [OPTIONS] "QUERY"
# Options:
#   --offline                 Force local deterministic offline answering
#   --provider TEXT           Override AI provider (openrouter, nvidia, openai, anthropic, gemini)
# Example:
wia ask "How is the Laya routing score computed?"

18. wia config

Manage AI providers, model endpoints, and API credentials securely.

wia config [OPTIONS]
# Options:
#   --show                    Display active configuration and masked API keys
#   --set-provider TEXT       Set active provider (openrouter|nvidia|openai|anthropic|gemini|local)
#   --set-model TEXT          Set default model name
#   --set-key TEXT            Store API key securely
#   --clear-key               Remove stored API key
# Example:
wia config --set-provider openrouter --set-model anthropic/claude-3.5-sonnet

19. wia serve

Launch the local background daemon and REST API server for IDE extensions.

wia serve [--port 8000] [--host 127.0.0.1]

🧩 VS Code & Antigravity IDE Extension

The WIA extension (yashwanth112004.wia-agent) embeds workspace intelligence directly into VS Code, VS Code Insiders, and Google Antigravity IDE.

┌─────────────────────────────────────────────────────────────────────────┐
│  VS CODE / ANTIGRAVITY IDE WORKSPACE                                    │
│                                                                         │
│  ┌───────────────────────┐  ┌────────────────────────────────────────┐  │
│  │ ⚡ WIA SIDEBAR CHAT   │  │ EDITOR: src/core/impact.ts             │  │
│  │                       │  │                                        │  │
│  │ [Ask anything...    ] │  │ ⚡ WIA Impact (analyze) | 🔍 Trace Flow  │  │
│  │ [Architecture] [Deps] │  │ export function analyze(target: str) { │  │
│  │                       │  │     // Code implementation...          │  │
│  │ > Route: impact       │  │ }                                      │  │
│  │ > Risk: LOW           │  └────────────────────────────────────────┘  │
│  │ > Callers: 0          │  ┌────────────────────────────────────────┐  │
│  │ > Affected: 0 files   │  │ ⚡ WIA CHANGE IMPACT INSPECTOR (PANEL)  │  │
│  └───────────────────────┘  │ Target: getNonce()  [ LOW RISK ]       │  │
│                             │ Direct Callers: 0 | Affected Files: 0  │  │
│                             └────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────────────────┘

Interactive Sidebar Agent View

• View ID: wia-agent-view
• Provides natural-language query routing via the embedded Laya JEV engine.
• Interactive quick-action chips for instant architecture review, dependency conflict checks, and health reports.
• Nonce-secured Content Security Policy (CSP) with complete event delegation.

Refactoring Change Impact Inspector

• Command: wia.openImpactPanel / wia.analyzeImpactForSymbol
• Live inspection panel displaying:
  • Evidence-grounded risk badge (LOW, MEDIUM, HIGH).
  • Stat cards: Direct Callers, Affected Files, Risk Rating.
  • Direct callers and dependents list with clickable file navigation (Jump to Source).
  • Transitive downstream ripple files list.
  • One-click Trace Flow buttons.

Visual Architecture & Subsystem Explorer

• Command: wia.openArchPanel / wia.architecture
• Interactive visual subsystem dependency map.
• Immediate circular import cycle indicators with file paths.
• Component breakdown and fan-in / fan-out complexity metrics.

In-Editor Symbol Impact CodeLens

• Injects clickable CodeLens actions directly above function, class, and method declarations:
  • ⚡ WIA Impact (<symbol>): Opens the Impact Inspector for that exact symbol.
  • 🔍 Trace Flow: Traces forward execution call hierarchy.

Extension Command Registry

📊 Benchmarks & Performance Statistics

All benchmarks measured on an AMD Ryzen 9 5900X / 32GB RAM across varying repository scales:

Routing Engine Latency Comparison

💻 Technology Stack

┌─────────────────────────────────────────────────────────────────────────────┐
│                              WIA TECH STACK                                 │
├──────────────────────────────┬──────────────────────────────────────────────┤
│ Core Engine & Backend        │ Python 3.10+, Click, Pathspec, Typing        │
│ AST & Parsing                │ Tree-Sitter, Python AST, JSON Notebook AST   │
│ Persistence & Cache          │ SQLite 3 (WAL Mode, PRAGMA Tuning), JSON     │
│ Graph & Indexing             │ Directional Multi-Graph, Inverted BM25 Index │
│ Non-Autoregressive AI        │ Laya JEV Similarity (Jaccard + Levenshtein)  │
│ LLM & Cloud Providers        │ OpenRouter, NVIDIA NIM, OpenAI, Claude,      │
│                              │ Google Gemini (Context Budget: 7,500 Tokens) │
│ IDE Extension                │ TypeScript 5.x, VS Code API 1.80+, VSCE      │
│ Webview Security             │ Nonce-based Content Security Policy (CSP)    │
│ Packaging & CI/CD            │ PyPI (Flit/Hatch), GitHub Actions, VSIX      │
└──────────────────────────────┴──────────────────────────────────────────────┘

🚀 Installation & Setup

1. Install CLI Tool from PyPI

# Install WIA globally or in your virtual environment
pip install --upgrade wia-agent

# Verify CLI installation
wia --version
wia doctor

2. Install VS Code Extension

From VS Code Marketplace:

Search for Workspace Intelligence Agent (WIA) (yashwanth112004.wia-agent) in the Extensions tab (Ctrl+Shift+X).

From Local VSIX Bundle:

code --install-extension vscode-extension/wia-agent-v0.1.1.vsix

⚙️ Multi-Provider AI Configuration

Deterministic features (AST search, impact calculation, dependency conflicts, architecture diagrams, call flows) require no API keys.

To enable citation-grounded natural-language answers for complex conceptual questions:

# 1. OpenRouter (Recommended for Claude 3.5 Sonnet / Llama 3.3 70B)
export OPENROUTER_API_KEY="sk-or-v1-..."
wia config --set-provider openrouter --set-model anthropic/claude-3.5-sonnet

# 2. NVIDIA NIM
export NVIDIA_API_KEY="nvapi-..."
wia config --set-provider nvidia --set-model meta/llama-3.1-70b-instruct

# 3. OpenAI
export OPENAI_API_KEY="sk-..."
wia config --set-provider openai --set-model gpt-4o

# 4. Anthropic
export ANTHROPIC_API_KEY="sk-ant-..."
wia config --set-provider anthropic --set-model claude-3-5-sonnet-20241022

# 5. Google Gemini
export GEMINI_API_KEY="AIzaSy..."
wia config --set-provider gemini --set-model gemini-1.5-pro

In VS Code, keys can also be securely stored in OS Keychains via WIA: Open Settings without touching .env files.

📁 Repository Structure

Workspace-Intelligence-Agent/
├── .github/
│   └── workflows/
│       ├── ci.yml                     # Multi-matrix Python & Extension test workflow
│       └── release.yml                # Automated PyPI & VS Code Marketplace release pipeline
├── wia/                               # Core Python Intelligence Package
│   ├── analyzers/
│   │   ├── code/                      # Multi-language AST & Jupyter Notebook parsers
│   │   ├── dependency/                # Package manifest & conflict analyzers
│   │   ├── git/                       # Git churn & hotspot analyzers
│   │   └── security/                  # High-speed secret & token scanner
│   ├── cli/
│   │   ├── app.py                     # CLI dispatcher & command registry
│   │   ├── formatting.py              # ANSI colors, table formatting, and styling
│   │   └── commands/                  # Individual CLI commands (impact, doctor, search, etc.)
│   ├── core/
│   │   ├── architecture.py            # Subsystem discovery & DFS cycle detection
│   │   ├── discovery.py               # File tree traversal & ignore filtering
│   │   ├── impact.py                  # Multi-tier blast radius & risk classification
│   │   ├── index_model.py             # WorkspaceIndex schema & data structures
│   │   ├── inverted_index.py          # O(1) inverted search engine
│   │   └── retrieval.py               # 7,500-token evidence-grounded retriever
│   ├── knowledge/
│   │   ├── graph.py                   # Directional WorkspaceGraph engine
│   │   ├── embeddings.py              # Vector embeddings interface
│   │   └── vector_store.py            # Vector similarity store
│   ├── llm/
│   │   ├── base.py                    # Provider abstraction interface
│   │   ├── reasoning.py               # Grounded ReasoningEngine
│   │   └── relevance.py               # Relevance & citation grading
│   ├── services/                      # Indexing, Explanation, and Status services
│   └── storage/                       # SQLite store with WAL mode & atomic batching
├── vscode-extension/                  # VS Code / Antigravity IDE Extension
│   ├── src/
│   │   ├── auth/                      # SecretStorage & credential management
│   │   ├── decision/                  # LayaDecisionEngine & JEV router
│   │   ├── executor/                  # WiaExecutor CLI execution bridge
│   │   ├── formatting/                # Terminal & markdown response formatting
│   │   ├── llm/                       # Extension LLM client
│   │   ├── panels/                    # Webview panels (Impact, Architecture, Chat)
│   │   ├── providers/                 # Sidebar view, CodeLens, and Tree providers
│   │   ├── registry/                  # Canonical command registry
│   │   └── test/                      # 82 extension test suites
│   ├── package.json                   # Extension manifest & command configuration
│   └── wia-agent-v0.1.1.vsix          # Packaged extension artifact
├── tests/                             # Python Test Suites (200 tests)
│   ├── unit/                          # Unit tests for analyzers, graph, and core
│   ├── integration/                   # Pipeline & end-to-end integration tests
│   └── cli/                           # CLI command tests
├── pyproject.toml                     # PEP 517/621 package build configuration
└── README.md                          # Master Project Documentation

🧪 Verification & Testing

WIA maintains strict test coverage across both core Python engines and the VS Code extension.

1. Run Core Python Engine Test Suite (200 Tests)

pytest -v

2. Run VS Code Extension Test Suite (82 Tests)

cd vscode-extension
npm test

3. Compile TypeScript & Build Extension Bundle

cd vscode-extension
npm run compile
npx @vscode/vsce package

🔒 Security & Privacy Guarantees

• 🛡️ Zero Bundled Credentials: No secrets or private keys are ever stored in source code or packaged builds.
• 🔒 Local-First Processing: Code indexing, graph construction, and search run entirely on your local machine.
• 🎭 Automatic Secret Masking: All keys and tokens are automatically masked in CLI outputs, logs, and Webviews.
• 🛡️ Strict Content Security Policy (CSP): Extension webviews execute under strict nonce-secured CSP with zero inline eval allowances.
• 🔐 OS Keyring Integration: API tokens in VS Code are stored in platform credential managers via vscode.SecretStorage.

Developed and maintained by Yashwanth. Contributions and issues are welcome on GitHub.