JetBrains plugin

One plugin that brings insrc into the JetBrains IDE family — IntelliJ IDEA, PyCharm, GoLand and WebStorm — from a single install. It is a thin orchestrator that owns no reasoning: it wires insrc's grounded-analyze and tracked-workflow capabilities into the IDE's own AI assistant and manages the backing daemon, so your assistant answers from a citation-grounded model of your codebase.

What it is

All the reasoning still runs through the insrc MCP server that your IDE's assistant invokes — the plugin opens no cloud path of its own. Its whole job is orchestration at IDE lifecycle moments (project open, install, uninstall):

• One integration, four IDEs. The plugin descriptor depends only on the common platform module (com.intellij.modules.platform), so a single artifact activates identically in IntelliJ IDEA, PyCharm, GoLand and WebStorm.
• Wires your AI host automatically. On project open it detects your agentic assistant — JetBrains AI Assistant or Junie — and registers the insrc MCP server plus the tracked-workflow steering into that host's own configuration.
• Manages the daemon. It ensures the insrc daemon is present and current, delegating to the same installer the CLI uses — provisioning a private Node runtime when the system one is unsuitable.
• Scopes every call to the open project. The active project's path is passed as the explicit repo scope, so multiple open windows never cross-scope.

Requirements

Install

A · JetBrains Marketplace (recommended)

In your IDE, open Settings → Plugins → Marketplace, search for insrc, and click Install. Updates are delivered through the Marketplace like any other plugin.

B · Install from disk (pre-release / internal)

Build the distribution artifact (see building from source) — a single zip in jetbrains-plugin/build/distributions/ — then install it directly:

Settings → Plugins → ⚙ → Install Plugin from Disk… and select the built insrc-jetbrains-<version>.zip.

First-run setup

Installing the plugin does not touch the daemon by itself — setup happens the first time you open a project with the plugin active. On project open the plugin:

1. Probes for the daemon (a health + staleness check over the daemon socket).
2. Offers a one-click setup if the daemon is absent — a notification you accept explicitly. Accepting runs the bootstrap installer bundled inside the plugin, which clones and builds the daemon into ~/.insrc/daemon. If the daemon is already present it is silently kept current instead.
3. Offers "Enable insrc for this project" — a one-click prompt that registers the open project with the daemon through the strict repo.add contract.
4. Wires your AI host — writes the insrc MCP-server registration plus the tracked-workflow steering block into the detected host's config and rules files.

How it works

Once a project is enabled, you keep using your IDE's assistant exactly as before — the plugin just makes it far more grounded:

• Grounded answers. Because the insrc MCP server is registered with your host, your assistant explores the code through insrc's citation-grounded analyze tools — file paths come from the real index, not guesses.
• Tracked workflow. The steering block guides the assistant to route feature work through insrc's define → design → plan → build workflow, with an independent review before approval.
• Per-project scope. Every capability call carries the open project's path, so each window is scoped to its own repo — no cross-talk between projects.

In the IDE

Beyond the invisible wiring, the plugin adds a small set of native surfaces so you can drive and inspect insrc without leaving the IDE or dropping to a shell:

• Settings → Tools → insrc. A live editor for the daemon's entire configuration — models and tiers, per-role and per-repo overrides, workflow/review, analysis and embeddings — plus nested Daemon, Workflows and Debug pages that give you a health readout with lifecycle controls, the read-only workflow-chain status, and diagnostics (stray-process cleanup, MCP clients & attached sessions, and live log tails). See the settings guide for the full surface.
• Project-view context menu. Right-click a project in the Project tool window for Show Repo status — a rich popup of the repo's index stats (file / entity / relation counts, languages, size, queue depth, last indexed) — and Register Repo, a one-click add with steering toggles for a repo not yet tracked.
• Artifact review tool window. Review the tracked workflow's pending artifacts in-IDE: read each design/plan document, leave inline-anchored comments, and approve — the same gated approval the workflow enforces, without switching to the terminal.

Clean removal

All of the plugin's writes into host-owned files are reversible:

• Uninstall removes exactly the insrc marker-delimited blocks it added (the MCP registration and the steering section), restoring each file to its prior content — your own rules and other MCP servers are untouched.
• A mere disable leaves those writes intact, so re-enabling needs no re-prompting.

Build from source

The plugin lives in-repo under jetbrains-plugin/ as a separate Gradle / Kotlin build (deliberately independent of the TypeScript backend). It requires JDK 21; the committed Gradle wrapper pins Gradle 8.10.2, so you do not need Gradle on your PATH.

$ cd jetbrains-plugin
$ ./gradlew build          # compile + run tests + produce the distribution zip
$ ./gradlew buildPlugin     # just the installable zip → build/distributions/
$ ./gradlew runIde          # launch a sandbox IDE with the plugin loaded
$ ./gradlew verifyPlugin     # run the IntelliJ Platform plugin verifier

runIde is the fastest way to exercise the integration end-to-end: it boots a throwaway IDE with the plugin loaded against your real ~/.insrc/daemon, where you can watch the onboarding offer, the MCP + steering wiring, and the daemon lifecycle in action.

Where next