NIM Code

AI coding assistant for Visual Studio Code. Ask questions about your code, review a proposed edit, or run an agent that reads files, makes changes, and uses your project's tools.

NIM Code brings hosted chat, personal provider keys, local models, repository context, Git tools, checkpoints, and recoverable coding tasks into the editor.

Marketplace · Website · Issues · Changelog · MIT license

Source version: 2.2.1. This README describes the current checkout; installed releases can differ. The newly registered providers have a main-chat routing limitation documented under provider status.

Contents

• Installation and quick start
• Modes and connections
• Providers and models
• Chat and editor assistance
• Agent tools and approvals
• Context and repository understanding
• Verification and checkpoints
• Tasks, teams, and missions
• Git and pull request review
• Memory, skills, and workflows
• MCP servers and hooks
• Artifacts
• Local hardware awareness
• Settings, storage, and privacy
• Troubleshooting
• Development
• Complete command reference
• Complete settings reference

Installation and quick start

Requirements

• Visual Studio Code 1.101 or newer.
• Internet access for hosted models, sign-in, remote tools, and cloud embeddings.
• A running OpenAI-compatible inference server for local models. NIM Code does not install the server or download its models.
• Git for Git operations and isolated checkouts; a committed repository for isolated tasks.
• Authenticated GitHub CLI (gh) for GitHub pull request review and task publication.

Install NIM Code, publisher vijayjanakiraman, from the Extensions view. Alternatively, use Extensions: Install from VSIX for a locally built package. Open a project folder and run NIM Code: Open NIM Code Chat.

Chat opens in a sidebar and can be moved using VS Code's view controls. Settings and artifacts also have editor panels. Open the Git surface with NIM Code: Open Git Panel.

Start with hosted chat

1. Choose the hosted option on the first-task screen.
2. Select Online Chat for conversation or Online Agent for file work.
3. Attach a selection or mention a file, such as @src/app.ts.
4. Send a request. Prompt enhancement is optional and off by default: turn on Enhance prompt before run in the composer's ⋯ menu to review an expanded prompt, or leave it off to send your original request directly. Choose your tool approval policy separately.
5. Review changes and recorded check results before accepting the outcome.

No personal vendor key is required. The anonymous client currently tracks separate daily allowances of five Online Agent requests and twenty Online Chat requests, resetting at midnight UTC. The service can enforce additional limits. Optional sign-in enables account credits; the displayed balance reflects the server's current allowance. Referral controls are available with an account, with rewards determined by the service.

Use a personal key

1. Run NIM Code: Set API Key and choose the provider.
2. Save its key through the secure input prompt. Cloudflare also requires its account ID in Settings before token validation.
3. Select Local Chat or Local Agent, then choose a model for that provider.
4. Open Settings Dashboard to change defaults or add a custom model.

These Local mode labels mean your configured connection, which can be a cloud provider or a server on your machine. Check provider status before using the new providers with main chat.

Use a local model

Start Ollama, LM Studio, llama.cpp, vLLM, or another compatible server. Run Switch LLM Endpoint, enter its API base URL, and add the server's exact model ID with provider nim. Then choose Local Chat or Local Agent.

For example, after loading qwen2.5-coder:7b in Ollama:

{
  "nimcode.baseUrl": "http://localhost:11434/v1",
  "nimcode.customModels": [
    {
      "id": "qwen2.5-coder:7b",
      "label": "Local Qwen Coder",
      "provider": "nim",
      "contextWindow": 32768,
      "capabilities": ["chat", "tools"]
    }
  ],
  "nimcode.defaultChatMode": "chat",
  "nimcode.defaultChatModel": "qwen2.5-coder:7b",
  "nimcode.defaultAgentModel": "qwen2.5-coder:7b"
}

Declare only the capabilities and context length your server supports. A model that can answer questions may still struggle with agent tool calls.

First-run setup check

In Agent mode, an empty chat opens with a short Get ready for your first task checklist. It answers "can the agent do real work right now?" before you spend a prompt finding out:

The static rows are free and run on their own, and they re-run when you set a key or change the endpoint. Only the live check sends a request. Once everything passes, the card suggests a read-only first task built from your project (for example, explaining how it starts from its detected entry point), which works in every approval mode and cannot change your files. A passing result is remembered until you switch model or change the key, so new chats do not repeat it. Outside Agent mode, the welcome screen has a Check that Agent mode is ready link.

Modes and connections

Online modes retain their hosted transport and separate allowances even when a personal key is saved. They use the hosted catalog and its Auto routing option, rather than nimcode.gatewayBaseUrl.

The hosted model picker shows gateway availability and health status. It does not show response-time figures because the catalog's latency values are not measured from an actual request in your session.

Local modes resolve the selected model's provider and its saved key. Unknown custom model IDs default to provider nim. The main Chat and Agent path uses the Cline engine. A shared model client supports surrounding features such as completion, review, and provider validation; its connection handling is not yet identical to the main engine.

The separate gateway URL and key do not replace the NVIDIA settings. Save its client key under AI Gateway; manage its upstream vendor credentials in the gateway dashboard. Main-chat routing for this connection is still incomplete, as described below.

The nim route allows keyless requests to recognized local hosts: localhost, 127.0.0.1, ::1, 0.0.0.0, host.docker.internal, and hosts ending in .local. Ordinary LAN IPs are not automatically treated as keyless. Other providers and the separate gateway keep their credential requirements.

Local inference can keep model calls on your machine. Web tools, remote MCP services, embeddings, hosted features, and enabled telemetry have separate network behavior.

Providers and models

Provider status

The current source registers eleven provider IDs, separate credential entries, connection settings, and custom models:

Routing limitation: resolveClineTarget currently falls back to nimcode.baseUrl for gateway, openrouter, cloudflare, cerebras, and huggingface, while resolving their respective saved keys. These selections can send requests to the wrong endpoint. Their registration, key setup, and shared-client support exist, but they must not be treated as complete main-chat integrations yet.

The resolver also omits the configured OpenAI, Anthropic, Google, and Groq URL overrides from native targets, and uses Sarvam's default URL rather than its override. Those settings are supported by the shared client but should not be relied on to redirect main Chat or Agent requests in this checkout.

These are source-review findings, not live-provider validation. A saved key or visible model does not prove that the complete request path works.

Starter catalog

The following IDs are shipped in the model registry. Availability, access, pricing, and limits depend on the upstream service; edit IDs for your deployment as needed.

The default personal Chat and Agent model is Nemotron Super. OpenAI and Anthropic entries are visible in this catalog. Capability badges describe registry metadata; vision, reasoning controls, and tool use also require backend support.

Custom models

Add a model from the picker or Settings, or edit nimcode.customModels:

{
  "nimcode.customModels": [
    {
      "id": "my-deployment-id",
      "label": "Team model",
      "description": "Served by our configured endpoint",
      "provider": "nim",
      "contextWindow": 32768,
      "capabilities": ["chat", "tools"]
    }
  ]
}

Only id is required. Optional fields are label, description, provider, contextWindow, and capabilities. A new entry defaults to provider nim, chat capability, and a 32,768-token context window. Matching a shipped ID overrides that entry. Use distinct IDs when you need separate provider choices because the catalog is keyed by model ID.

Chat and editor assistance

Conversations

• Streaming answers with Markdown, highlighted code, copy controls, and Mermaid diagrams.
• Mode, model and approval-mode pickers in the composer, with reasoning effort, the workflow builder, custom-model, endpoint and settings shortcuts in its ⋯ menu.
• Image attachments for models with vision support.
• Active selections and explicit file, folder, symbol, diff, and Problems context.
• Saved sessions with retained transcripts, titles, and deletion controls.
• Cancellation and visible tool progress, with separate timeout, empty-output, and failure outcomes.
• A slim header with the open conversation's title (click it to switch conversations), New chat, a ⋯ menu (autonomous mission, task queue, Tasks and recovery, invites, settings) and the account menu. Only one of the panels that open under the header is shown at a time.
• A flat transcript: your messages are small bubbles, replies flow on the background, consecutive tool calls fold into one expandable "N tool calls" row, and checkpoints appear as a divider with Compare and Restore. Token usage, cost and a copy button appear when you hover or focus a reply.
• A run dock above the composer with one chip each for the mission, agent team, plan, todos, retrieved context and active skills. Click a chip to expand it; one opens at a time, and a newly proposed plan opens itself.
• One notice at a time above the composer (error, daily limit, missing key, local-model fit warning, or the sign-in offer), ranked by urgency.
• A queue for back-to-back tasks and a Tasks and recovery view for longer work, both opened from the header's ⋯ menu.
• Context reports, token usage, and estimated costs when usage and pricing are available.
• Feedback and error-report forms.
• An optional support button for contributing to the project's development.

Mentions

Type @ to browse sources. Explicit mentions have priority within context budgets. Use an editor selection for an exact excerpt.

Slash commands

Aliases are /doc, /ref, and /opt. Skills and workflows also contribute slash commands. These guide the prompt; edits depend on mode and approvals. /pr does not itself publish a pull request.

Selection actions and inline edits

The editor menu and Command Palette offer Explain, Fix, Review, Refactor, Generate Tests, and Generate Docs for selected code. Explain Error uses diagnostics. Generate Commit Message drafts text from the diff.

Edit Selection opens a replacement proposal in a diff editor. Accept or reject it with the corresponding inline-edit commands. Acceptance checks the document version and original text so stale proposals cannot overwrite newer edits.

Review an improved Agent prompt

In Online Agent or Local Agent mode, prompt enhancement is optional and off by default. Turn on Enhance prompt before run in the composer's ⋯ menu to use one extra model request to expand your request into an actionable implementation brief with the goal, requirements, proposed defaults for unspecified details, and completion checks. The rewrite instructions preserve exact filenames, technologies, and scope, and label suggestions as defaults. Small or detailed requests get a shorter brief. With it off, the original wording goes directly to the Agent without enhancement or prompt review.

For example, a request for a freelancer website in a single free.html file should retain that filename and single-file constraint, while proposing suitable page sections, responsive styling, accessible controls, and checks that the page works in a browser. Unspecified personal details should remain placeholders; a backend or extra framework should not be added without a requirement for one.

Review and edit the original or enhanced prompt, then choose Approve prompt and continue. NIM Code prepares context in the background and starts the Agent without a second context-review popup. Cancel returns your original text to the composer. No Agent tools run before prompt approval. If rewriting fails or the response is cut off, the dialog offers your original request for editing and explicit approval instead of using an incomplete brief.

Prompt improvement is an additional model request and counts against the hosted allowance when using Online Agent. It is not used in Chat modes or for queued batch tasks.

After submission, an animated status shows Improving your prompt, then Preparing context and Starting the Agent after approval, with an elapsed timer. It switches to the running indicator when the request is accepted. Preparation indicators clear on success or failure, and reduced-motion preferences are respected. The composer prevents duplicate submissions while preparation is in progress.

Completion and next edits

Inline completion is off by default. Enable nimcode.completion.enabled or use Toggle Inline Completion. Configure the model, languages, debounce, output limit, and multiline behavior. Automatic completion requires a personal connection or local model; Request Inline Help explicitly supports the hosted Chat allowance. Completed suggestions are cached by model, configuration, and document version.

Nearby edit proposals are a separate opt-in feature: nimcode.nextEditSuggestions.enabled. They require a personal key or local model, open a diff, and require acceptance. Suggest Next Edit requests one manually. They do not silently apply edits while you type.

Agent tools and approvals

Agents read source, edit files, run commands, and maintain visible todos. Main agent turns have a 50-iteration ceiling. Tool selection adapts to the task; safe reads can be batched, while writes and operations with unknown effects are serialized.

All 37 built-in tools

Feature flags, mode, approvals, and available services determine which tools a turn receives.

Symbols require language-server support; semantic search requires an index and embeddings. MCP adds namespaced external tools.

Approval policy

Session-local always-allow grants can suppress repeated prompts for approved tools. MCP has its own trust policy. File-tool restrictions do not sandbox an approved shell process.

Edits recheck their baseline after approval. Tool cards show progress and results. Terminal commands report ongoing activity, obey the configured timeout, and can be cancelled; background shells have separate output/stop tools.

The Planner presents structured steps and carries unfinished todos into later turns. Use plan mode for exploration before permitting changes.

Context and repository understanding

Request context

The agent can combine a selection, nearby code, mentions, workspace structure, instructions, memory, relevant files, history, todos, and artifact summaries.

• The context planner chooses blocks within a model-sized budget.
• Explicit attachments take priority within the context budget.
• Context is prepared in the background and submitted using a frozen snapshot, without a separate context-review popup.
• If the workspace changes during preparation, NIM Code rebuilds context automatically, with up to three attempts. Output-channel updates and document save-state notifications do not invalidate it. If edits continue throughout all attempts, wait for them to finish and retry your request.
• Relevance ranking uses named files, semantic matches, imports, and historical co-change signals where available.
• Symbol outlines represent selected files more compactly than full source.
• The observation ledger helps avoid reading unchanged files repeatedly.
• Dynamic tools reduce the initial roster; load_tools expands it.
• Reproducible stale tool results can be pruned to receipts; mutation and terminal results are retained.
• Long history is budgeted and compacted while preserving recent turns.
• Prompt caching is requested where the provider path supports it; hits and savings are not guaranteed.

Use Explain Last Request Context for block accounting. The agent adds tool results as it runs, so the initial context does not determine the entire task's cost.

Semantic index

Run Index Codebase to create the local chunk/embedding index. The default embedding model is nvidia/nv-embedqa-e5-v5. Embedding generation and query embedding can send code or search text to the configured embedding backend; a local chat model does not automatically make embeddings local.

Automatic retrieval uses the index when available and skips it otherwise. Retrieval excludes ignored files and nested agent worktrees. Text search works without embeddings.

Repository intelligence and impact

repo_intel combines repository structure, imports, Git history, source maps, symbols, and diagnostics. It supports overview, impact, history, hotspot, and failure diagnosis. Recognized failures can receive a deterministic source-based explanation; other cases need investigation.

Repository relationships inform context selection where available. They are based on indexed relationships and do not describe every runtime dependency.

Project DNA

Project DNA detects stack and style conventions from source/manifests, caches a profile outside the repository, and supplies a compact agent digest. It can capture export/import style, component patterns, test locations, and formatting choices.

Inspect or correct the profile from Settings. pinnedRules survive rebuilding; Rebuild Project DNA refreshes detection. Root CLAUDE.md remains the project-owned instruction source.

Verification and checkpoints

Diagnostics and project checks

NIM Code exposes diagnostics and Verify Workspace. Verification detects build/typecheck, lint, and tests from supported root manifests, including Node, Rust, Go, Python, and Make projects. Configure explicit machine-scoped checks for monorepos or custom commands:

{
  "nimcode.verification.checks": [
    {
      "kind": "build",
      "command": "pnpm run typecheck",
      "cwd": "packages/api",
      "label": "API types"
    },
    {
      "kind": "test",
      "command": "pnpm test",
      "label": "Tests"
    }
  ],
  "nimcode.verification.timeoutMs": 300000,
  "nimcode.verification.maxFixRounds": 3
}

Explicit checks replace autodetection. Shell checks require approval and plan mode blocks verification. Results can feed correction work; repair rounds are bounded. Existing failures, timeouts, skipped checks, and inconclusive results are distinct from passes.

Completion is not verification evidence. The current main engine exposes checks through verify_workspace and submission-tool hooks; missions have a dedicated verification stage. Inspect receipts or invoke Verify Workspace to establish which checks ran. A final answer alone does not prove that every configured check executed.

Checkpoints

Checkpoints snapshot trackable files around mutating agent work in a private Git store, including folders without their own repository. Use the panel or commands to compare, restore, or clear snapshots.

Ignored files and configured exclusions are not restored. Defaults retain fifty timeline entries per session, disable snapshots above 20,000 trackable files, and offer cleanup above 1,024 MiB per workspace store. Clearing checkpoints reclaims disk space. Review affected files before restoration.

Tasks, teams, and missions

Recovery and queue

Tasks and recovery retain transcripts, progress, completed tools, and check results. Reopening the workspace exposes unfinished work as interrupted. Resume is explicit; inspect files and receipts before continuing. Past mutations are not automatically replayed after a restart.

Open Task queue and Tasks and recovery from the ⋯ menu in the chat header. The task queue runs requests back-to-back. Active work requires VS Code to remain open; this is not an unattended background service.

Isolated coding tasks

Enable Run coding tasks in isolated checkouts to start a worktree from committed HEAD. Uncommitted main-workspace changes are excluded. Task worktrees and patch receipts remain in extension-managed storage.

From Tasks, inspect progress, review a retained patch including new files, and explicitly apply it to the main checkout. A compatibility check precedes application; a changed destination can prevent it.

You can also explicitly publish a task branch or create a draft GitHub pull request. This requires Git, an origin remote, and authenticated GitHub CLI. Review, integration, publication, and merge are separate steps.

Sub-agents and teams

delegate_task runs a bounded subtask and returns its findings. It consumes additional model calls and follows relevant policy.

Teams are enabled by default through nimcode.agentTeams.enabled. Roles are Architect, Coder, Tester, and Reviewer. The architect produces a brief, writing roles use file leases, and review follows. The Tester writes tests but has no terminal tool.

Writing members use isolated checkouts. At most two writing task slots run, and builders can be serialized within a parent. File leases restrict file tools; approved Coder shell commands can have broader effects. Review and integrate patches before treating team output as applied.

Missions

Enable nimcode.missions.enabled, then use Start Mission to choose a goal, stages, model, and budget.

The host enforces stage order. Security and correctness reviews can run together. Writing missions use isolated checkouts with explicit delivery controls.

The default launch budget is $0.25, with a 2,000,000-token ceiling. These are extension controls, not billing guarantees. Estimated dollars require known prices; unpriced/local models still consume the token ceiling. Exhausted limits can leave stages unfinished.

Git and pull request review

NIM Git covers status, file actions, diffs, history, branches, remotes, tags, stashes, and conflicts. Commands include commit/amend, fetch/pull/push/sync, merge/rebase/cherry-pick, revert/reset, patch import/export, submodules, bisect, and repository browsing.

nimcode.git.confirmDestructive controls confirmation for recoverable but surprising actions. Hard reset, clean, force push, and stash drop retain confirmation and typed-phrase safeguards even when it is disabled.

Review GitHub PR detects the current branch's pull request or asks for a numeric PR number, then offers a general or security review. It reads the diff through GitHub CLI and opens model-assisted findings in an editor. After you inspect them, a separate confirmation can post the review as a PR comment. Authenticate gh and use a repository your account can access. This does not merge the pull request.

Memory, skills, and workflows

Durable guidance

Use remember for personal facts and project_memory, Add to Project Memory, or the memory panel for workspace knowledge. The panel supports adding, editing, removing, and completing project todos. Commit project memory yourself to share it through Git.

Project memory is enabled by default; automatic capture during compaction is off by default because it writes a workspace file. Mutations follow approval policy. Files and prompt injection are bounded, so memory is not an unlimited transcript archive. Keep credentials out of these files.

Skills

Skills are Markdown prompt packages. Precedence is workspace .nimcode/skills/, user skills under extension global storage, then bundled skills. Bundled topics include TypeScript, React, Next.js, Prisma, testing, security, and frontend work.

---
name: api-review
version: 1
description: Review our API conventions
when: typescript
---

Check request validation, error responses, and authorization.
Use the project's existing patterns and cite the reviewed files.

Save as .nimcode/skills/api-review.md and invoke /api-review. when tags opt into matching when nimcode.skills.autoLoad is enabled. Relevant bodies fit within a budget; load_skill loads others on demand. Install Skill from URL saves a workspace skill for inspection and reuse.

Workflows

Use the composer's workflow builder or place Markdown in .nimcode/workflows/. Workflows contribute reusable slash commands with a name, description, and chat or agent mode:

---
name: review-change
description: Review the current change with a supplied focus
mode: agent
---

Review @diff with this focus: {{input}}
Give findings with file locations and explain the checks you ran.

Run /review-change authentication to supply input. Workflows are reusable instructions using the current connection and policy; they do not install a scheduler.

MCP servers and hooks

These settings launch programs and are machine-scoped. Configure them in user settings, not repository .vscode/settings.json.

MCP

NIM Code connects to local subprocesses through stdio:

{
  "nimcode.mcpServers": [
    {
      "name": "project-tools",
      "command": "node",
      "args": ["/absolute/path/to/mcp-server.js"],
      "disabled": false,
      "trust": "ask"
    }
  ]
}

External effects cannot be inferred automatically. Tools are named mcp__server__tool. The editor supports command, args, env, disabled state, and trust. Environment values are plain-text settings, not SecretStorage. HTTP MCP transport is not exposed by this configuration.

Hooks

Hooks run around PreToolUse, PostToolUse, and Stop. Matchers are JavaScript regexes against tool names; empty matches all. Stop ignores the tool matcher.

{
  "nimcode.hooks": {
    "PostToolUse": [
      {
        "matcher": "^(write_file|edit_file|multi_edit)$",
        "hooks": [
          {
            "type": "command",
            "command": "node scripts/check-agent-edit.js",
            "timeout": 30
          }
        ]
      }
    ]
  }
}

Provide your own script for this example. Hooks receive JSON on stdin and NIMCODE_HOOK_EVENT, NIMCODE_TOOL_NAME, and NIMCODE_PROJECT_DIR environment variables. Exit 2 blocks or returns feedback; other nonzero exits are logged without blocking. A Stop hook can require additional work. Avoid running identical checks in both hooks and verification.

Artifacts

Artifacts are deliverables displayed in cards or a separate editor panel.

Open, copy, save to workspace, and inspect versions from card controls. The tool supports create, update, rewrite, and read. Storage retains up to twenty artifacts per session, twenty versions per artifact, and 256 KiB per document.

Artifacts start outside the repository. Save to workspace exports a file. HTML/React previews run in a separate document without the extension RPC bridge; the policy blocks network fetches, remote images, and remote scripts. React uses a bundled runtime and requires self-contained content rather than arbitrary package imports.

nimcode.artifacts.enabled controls new tools. Auto-opening the panel is off by default; cards remain available.

Local hardware awareness

For a local nimcode.baseUrl, NIM Code probes NVIDIA VRAM and the server catalog. The picker can show Fits, Spills, or unknown verdicts with residency/context information, and the composer shows headroom.

Measured residency and estimated sizing are different. Quantization, KV-cache assumptions, server settings, and concurrent GPU use affect fit. Match nimcode.gpu.assumedContextTokens to your server and adjust the VRAM reserve. Unsupported hardware yields CPU information or unavailable data rather than guessed VRAM.

Polling requires the feature enabled, a local endpoint, and a visible view. Disable nimcode.gpu.enabled to stop probing. A custom nvidia-smi path is machine-scoped because it specifies an executable.

Settings, storage, and privacy

Dashboard and profiles

Open Settings Dashboard provides search, resets, scope selection, provider key actions/status, custom models, MCP/hooks, verification checks, memory, checkpoints, Project DNA, context reports, and estimated spend history.

Export settings profiles for reuse; import reviews changes before applying them. Command-running settings require explicit selection. Provider keys are outside normal settings and are not profile values. Exported MCP entries have environment values stripped. Still inspect exports before sharing, especially command text and private endpoint URLs.

Storage

Providers, including AI Gateway, have separate key entries. Clear API Key removes the selected entry. The UI receives presence flags rather than saved keys. Transcripts, indexes, memory, and files are not covered by provider-key encryption.

Network data

• Model requests send prompts and selected context to the serving provider or hosted gateway.

• Sign-in, credits, and referrals contact the account service.

• Cloud embeddings can send code chunks and query text to the embedding backend.

• Web/MCP tools contact their configured services.

• Feedback sends the entered comment and optional contact fields. Error reports send failure diagnostics and version information; inspect error text before submission.

• Analytics are enabled by default when included in the build. They cover usage, latency, outcomes, fixed tool labels, platform/version data, and account linkage when signed in. Their schema excludes prompts, responses, code, paths, tool arguments/results, keys, custom model IDs, and MCP server names.

• Announcement banners are fetched with a plain GET to the NIM Code gateway that carries only the extension version — no install id, account, code, or prompts. A banner you close comes back the next time the panel opens, unless its campaign is set to stay hidden once dismissed. When analytics are enabled, a banner also reports an anonymous view (at most once a day), click or dismissal — just the banner id and the event, no install id or account — so the team can see whether a banner works. Set nimcode.promoBanners.enabled to false to stop the request and hide banners.

Set nimcode.telemetry.enabled to false to disable analytics, or nimcode.telemetry.detail to aggregate for reduced detail. VS Code telemetry also gates analytics. This does not disable a model request, sign-in, or feedback submission you initiate.

Cost displays use reported tokens and known prices. Unknown pricing does not establish free usage, and estimates are not a provider billing ledger.

Troubleshooting

Use Show Logs for the output channel. Issue reports should include editor/extension versions, mode, provider/model, error code or HTTP status, and reproduction steps. Remove credentials and private source from shared logs.

Development

Use Node.js 22+ and pnpm 9.15.9, as declared in the manifest.

git clone https://github.com/vijayjanakiraman/nim-code.git
cd nim-code
pnpm install
pnpm build

For F5/Extension Development Host, rebuild native SQLite for your VS Code Electron version. rebuild:electron has a configured version; confirm it matches the host. Node tests need pnpm rebuild:node instead. Native binaries are platform/ABI-specific.

Run watchers in separate terminals:

pnpm watch:webview

pnpm watch:extension

Build-time service overrides are defined in esbuild.mjs and src/shared/config/gateway.ts; they are separate from the user's AI Gateway connection. Keep private credentials out of committed configuration and packages.

The extension host owns credentials, execution, policy, storage, and network calls. React webviews provide chat, Git, settings, and artifacts through typed messaging. Main execution uses a lazy Cline engine; shared clients and metadata support surrounding features.

• Architecture
• NIM integration
• Adding a feature
• Design system
• Agent scenario matrix
• Historical manual report

Read CLAUDE.md before contributing. Report which checks ran. A local build, packaged-host validation, hosted deployment, and Marketplace publication are separate release steps. This source audit does not establish that every feature was runtime-tested or that this checkout is deployed.

Complete command reference

The following commands are contributed by the current manifest. Some also appear in editor, chat, Git, and settings controls. Actions can require a selection, session, workspace, or repository.

Chat, editing, and workspace commands

Git commands

Complete settings reference

All 68 contributed settings are listed below with manifest defaults. Set them through the dashboard, the VS Code settings editor, or JSON. Values marked machine must be configured in user/machine settings; other values allow workspace configuration. Provider credentials are separate SecretStorage entries and are not settings. Endpoint defaults do not remove the main-engine routing limitations described above.

Providers

Models and modes

Requests and diagnostics

Context

Verification

Completion and inline edits

Agents, artifacts, and repository features

Checkpoints and memory

Local hardware

Git, privacy, and external programs

License

NIM Code is licensed under the MIT license. Provider services, model access, and external tools have their own terms.