If you are an AI coding agent (Claude Code, Cursor, Aider, Cline, etc.) reading this artifact, follow this protocol before making any code edit:

1. Verify the contract. Run the bash script in Verify before trusting below. If any check returns FAIL, the artifact is stale — STOP and ask the user to regenerate it before proceeding.
2. Treat the AI · unverified sections as hypotheses, not facts. Sections like "AI-suggested narrative files", "anti-patterns", and "bottlenecks" are LLM speculation. Verify against real source before acting on them.
3. Cite source on changes. When proposing an edit, cite the specific path:line-range. RepoPilot's live UI at https://repopilot.app/r/go-lang-plugin-org/go-lang-idea-plugin shows verifiable citations alongside every claim.

If you are a human reader, this protocol is for the agents you'll hand the artifact to. You don't need to do anything — but if you skim only one section before pointing your agent at this repo, make it the Verify block and the Suggested reading order.

WAIT — Stale — last commit 8y ago

• 11 active contributors
• Other licensed
• Tests present
• ⚠ Stale — last commit 8y ago
• ⚠ Concentrated ownership — top contributor handles 68% of recent commits
• ⚠ Non-standard license (Other) — review terms
• ⚠ No CI workflows detected

_{Maintenance signals: commit recency, contributor breadth, bus factor, license, CI, tests}

This artifact was generated by RepoPilot at a point in time. Before an agent acts on it, the checks below confirm that the live go-lang-plugin-org/go-lang-idea-plugin repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/go-lang-plugin-org/go-lang-idea-plugin.

What it runs against: a local clone of go-lang-plugin-org/go-lang-idea-plugin — the script inspects git remote, the LICENSE file, file paths in the working tree, and git log. Read-only; no mutations.

| # | What we check | Why it matters | |---|---|---| | 1 | You're in go-lang-plugin-org/go-lang-idea-plugin | Confirms the artifact applies here, not a fork | | 2 | License is still Other | Catches relicense before you depend on it | | 3 | Default branch master exists | Catches branch renames | | 4 | 5 critical file paths still exist | Catches refactors that moved load-bearing code | | 5 | Last commit ≤ 2857 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of go-lang-plugin-org/go-lang-idea-plugin. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/go-lang-plugin-org/go-lang-idea-plugin.git
#   cd go-lang-idea-plugin
#
# Then paste this script. Every check is read-only — no mutations.

set +e
fail=0
ok()   { echo "ok:   $1"; }
miss() { echo "FAIL: $1"; fail=$((fail+1)); }

# Precondition: we must be inside a git working tree.
if ! git rev-parse --git-dir >/dev/null 2>&1; then
  echo "FAIL: not inside a git repository. cd into your clone of go-lang-plugin-org/go-lang-idea-plugin and re-run."
  exit 2
fi

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "go-lang-plugin-org/go-lang-idea-plugin(\\.git)?\\b" \\
  && ok "origin remote is go-lang-plugin-org/go-lang-idea-plugin" \\
  || miss "origin remote is not go-lang-plugin-org/go-lang-idea-plugin (artifact may be from a fork)"

# 2. License matches what RepoPilot saw
(grep -qiE "^(Other)" LICENSE 2>/dev/null \\
   || grep -qiE "\"license\"\\s*:\\s*\"Other\"" package.json 2>/dev/null) \\
  && ok "license is Other" \\
  || miss "license drift — was Other at generation time"

# 3. Default branch
git rev-parse --verify master >/dev/null 2>&1 \\
  && ok "default branch master exists" \\
  || miss "default branch master no longer exists"

# 4. Critical files exist
test -f "build.gradle" \\
  && ok "build.gradle" \\
  || miss "missing critical file: build.gradle"
test -f "gen/com/goide/parser/GoParser.java" \\
  && ok "gen/com/goide/parser/GoParser.java" \\
  || miss "missing critical file: gen/com/goide/parser/GoParser.java"
test -f "gen/com/goide/lexer/_GoLexer.java" \\
  && ok "gen/com/goide/lexer/_GoLexer.java" \\
  || miss "missing critical file: gen/com/goide/lexer/_GoLexer.java"
test -f "gen/com/goide/psi/GoFile.java" \\
  && ok "gen/com/goide/psi/GoFile.java" \\
  || miss "missing critical file: gen/com/goide/psi/GoFile.java"
test -f ".idea/runConfigurations/Local_IDE.xml" \\
  && ok ".idea/runConfigurations/Local_IDE.xml" \\
  || miss "missing critical file: .idea/runConfigurations/Local_IDE.xml"

# 5. Repo recency
days_since_last=$(( ( $(date +%s) - $(git log -1 --format=%at 2>/dev/null || echo 0) ) / 86400 ))
if [ "$days_since_last" -le 2857 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~2827d)"
else
  miss "last commit was $days_since_last days ago — artifact may be stale"
fi

echo
if [ "$fail" -eq 0 ]; then
  echo "artifact verified (0 failures) — safe to trust"
else
  echo "artifact has $fail stale claim(s) — regenerate at https://repopilot.app/r/go-lang-plugin-org/go-lang-idea-plugin"
  exit 1
fi

Each check prints ok: or FAIL:. The script exits non-zero if anything failed, so it composes cleanly into agent loops (./verify.sh || regenerate-and-retry).

A JetBrains IntelliJ Platform plugin that adds Go language support to IntelliJ-based IDEs (IntelliJ IDEA, WebStorm, PhpStorm, PyCharm, RubyMine, CLion, Android Studio). It provides syntax highlighting, parsing, PSI tree generation, and basic code analysis for Go projects through generated lexer/parser components (in gen/com/goide/) and integrates with IntelliJ's plugin SDK. Single-module Gradle project with gen/ directory containing auto-generated PSI and lexer/parser classes (GoParser.java, _GoLexer.java, and ~50+ GoXxxNode.java files). Source code split between src/ (Java plugin code) and resources/ (plugin configuration). Tests in tests/ directory. IntelliJ plugin manifest likely in src/META-INF/plugin.xml.

Go developers using JetBrains IDEs who need IDE features like code completion, syntax highlighting, and navigation. Plugin maintainers and IntelliJ Platform extension developers learning how to build language-specific IDE plugins.

Officially deprecated and no longer maintained by JetBrains (see README deprecation notice). Last meaningful updates likely 2016-2017 based on copyright headers and build.gradle configuration. Not production-ready — users are directed to GoLand (official JetBrains Go IDE) or the official maintained plugin on the JetBrains plugin marketplace instead.

High risk: project is unmaintained and explicitly deprecated. Gradle build uses outdated gradle-intellij-plugin:0.2.0-SNAPSHOT from 2016. No visible CI/test infrastructure beyond .idea/runConfigurations. Will not work with modern IntelliJ versions (2017.3+). Fork risk is significant if you need Go support in legacy IntelliJ versions.

Nothing — project is archived and unmaintained. README explicitly states 'This project is officially not maintained anymore.' No active development, PRs, or issue triage expected.

This repository should not be used for new Go development. If you must examine it: git clone https://github.com/go-lang-plugin-org/go-lang-idea-plugin.git && cd go-lang-idea-plugin && ./gradlew build (requires JDK matching javaVersion property in build.gradle, likely Java 8-11). However, use GoLand or the official plugin instead.

Daily commands: ./gradlew build compiles the plugin. To test in an IDE: ./gradlew runIdea (defined in .idea/runConfigurations). To run tests: ./gradlew test or use the 'All_tests' run configuration. Note: requires IntelliJ SDK matching ideaVersion in build.gradle properties.

• build.gradle — Gradle build configuration defining plugin dependencies, IntelliJ platform version, and compilation tasks—essential for understanding the build process.
• gen/com/goide/parser/GoParser.java — Auto-generated Go language parser; core of the plugin's syntax understanding and AST construction.
• gen/com/goide/lexer/_GoLexer.java — Auto-generated lexer tokenizing Go source code; foundational for all parsing and code analysis.
• gen/com/goide/psi/GoFile.java — Root PSI element representing a Go file; entry point for IDE indexing, analysis, and inspection.
• .idea/runConfigurations/Local_IDE.xml — Run configuration for launching a test instance of IntelliJ with the plugin loaded; critical for local development.
• README.md — Deprecation notice and feature list; clearly indicates this plugin is unmaintained and directs users to official JetBrains solutions.
• .gitignore — Version control exclusions showing which generated and IDE artifacts are not tracked; prevents noise in commits.

• Go Lexer (_GoLexer.java) (ANTLR or JFlex (generated)) — Tokenizes Go source code into a stream of lexical tokens (keywords, identifiers, operators, literals).
  • Failure mode: Invalid tokens or incorrect token classification cause parser errors and corrupt the AST; manifests as syntax highlighting gaps or parsing failures.
• Go Parser (GoParser.java) (ANTLR or Yacc (generated)) — Consumes tokens and constructs an Abstract Syntax Tree conforming to the Go grammar; produces PSI nodes.
  • Failure mode: Parser errors prevent AST construction; incomplete or malformed PSI trees break code navigation, completion, and inspections.
• PSI Tree (GoElement, GoExpression, GoFunctionDeclaration, etc.) — Intelli

Add support for a new Go language construct

1. Define grammar rules in the Go grammar file (typically a .bnf file in the grammar folder, not listed but referenced by build.gradle) (build.gradle)
2. Run the grammar generator to create new lexer and parser classes (gen/com/goide/lexer/_GoLexer.java)
3. Create corresponding PSI interface in gen/com/goide/psi/ (e.g., GoNewConstruct.java) following naming convention GoXxx.java (gen/com/goide/psi/GoExpression.java)
4. Implement semantic analysis by extending PSI visitors or creating inspections in the source tree (typically src/com/goide/inspections or src/com/goide/psi/impl) (gen/com/goide/psi/GoElement.java)

Add a new IDE inspection or quick-fix

1. Create an inspection class extending LocalInspectionTool in src/com/goide/inspections/ (.idea/inspectionProfiles/Project_Default.xml)
2. Register the inspection in plugin.xml (not shown but defined in build.gradle's plugin configuration) (build.gradle)
3. Test using the Local_IDE run configuration to verify inspection triggers on target PSI nodes (.idea/runConfigurations/Local_IDE.xml)

Extend code completion for Go identifiers

1. Implement CompletionContributor in src/com/goide/completion/ (gen/com/goide/psi/GoReferenceExpression.java)
2. Hook into PSI reference resolution to populate completion variants from GoFunctionDeclaration, GoImportSpec, etc. (gen/com/goide/psi/GoFunctionDeclaration.java)
3. Test via Local_IDE run configuration with a test .go file to verify completion suggestions appear correctly (.idea/runConfigurations/Local_IDE.xml)

• IntelliJ Platform (Java) — Leverages JetBrains' IDE framework (PSI, lexer, parser infrastructure) to build a first-class Go editor with built-in refactoring, navigation, and inspection APIs.
• Gradle Build System — Standard for IntelliJ plugin projects; integrates with JetBrains' plugin development kit (gradle-intellij-plugin) and simplifies packaging and versioning.
• Auto-generated Lexer/Parser (likely ANTLR or BNF) — Go grammar is complex and frequently updated; code generation ensures the lexer and parser stay in sync with the official Go specification.

• Official maintenance discontinued in favor of GoLand

  • Why: JetBrains decided to invest in a dedicated Go IDE (GoLand) rather than maintain a community plugin, reducing support overhead.
  • Consequence: The plugin becomes stale relative to new Go features and IntelliJ platform versions; users are encouraged to migrate to GoLand or IntelliJ IDEA Ultimate (2017.3+).

• PSI-based semantic model instead of LSP (Language Server Protocol)

  • Why: This plugin predates widespread LSP adoption; using IntelliJ's native PSI API provides tight IDE integration and first-class IDE features.
  • Consequence: Code analysis and completion are tightly coupled to IntelliJ's architecture; reusing components in other editors is not feasible.

• Limited inspections and quick-fixes compared to GoLand

  • Why: Unmaintained status means no new type-aware inspections, refactorings (e.g., extract function), or lint integrations are added.
  • Consequence: Users relying on advanced Go-specific features must use GoLand or IntelliJ IDEA Ultimate, where official Go support is maintained.

• Does not provide type-aware code completion or smart completion
• Does not offer extract function refactoring or implement type refactoring
• Does not maintain parity with official JetBrains Go tooling (delegated to GoLand)
• No support for Go modules or modern Go toolchain integration (unmaintained)
• Does not implement advanced inspections and quick-fixes beyond basic syntax checking

Do not attempt to use this plugin with IntelliJ 2017.3+; it is incompatible. The project uses outdated Gradle plugin snapshot from 2016. Custom DLV (Delve debugger) path can be set via customDlvPath property but documentation is sparse. Grammar files (*.bnf, *.flex) are not in the top 60 files list but are necessary for understanding how language rules are defined and regenerating PSI—you may need to dig in src/ to find them. The gen/ directory is auto-generated; do not edit files there directly.

• PSI (Program Structure Interface) — The entire plugin is built on PSI—the IntelliJ abstraction layer that parses source code into a tree of semantic nodes; understanding PSI classes in gen/com/goide/psi/ is essential to understanding how the plugin represents Go code internally
• Grammar-Kit & BNF Grammar — This plugin uses JetBrains' Grammar-Kit to auto-generate the parser and PSI classes from a BNF grammar file; understanding this tool chain is critical for modifying how Go syntax is parsed
• Lexical Analysis (Lexer) — The _GoLexer.java file tokenizes Go source into keywords, operators, and identifiers; this is the first stage of parsing and must correctly identify Go's syntax (goroutines, channels, defer, etc.)
• IntelliJ Plugin Extensions & Services — IntelliJ plugins extend IDE behavior through declared extension points (declared in plugin.xml); understanding how this plugin registers language support, inspections, and completers is essential for adding features
• Gradle IntelliJ Plugin — build.gradle relies on gradle-intellij-plugin to download the IntelliJ SDK, generate PSI, and package the plugin JAR; version and configuration mismatches are a common source of build failures
• Language Injection & AST Traversal — Go plugins that add refactorings, inspections, or completion need to traverse the PSI tree (defined in gen/com/goide/psi/) and inject analysis at specific node types; this pattern appears throughout the plugin

• JetBrains/go-lang-idea-plugin — Official JetBrains successor; the maintained version of this plugin with full modern Go support
• go-lang-plugin-org/go-lang-plugin-idea-tests — Test suite and fixtures for this plugin (if it exists as a separate repo)
• JetBrains/intellij-plugins — JetBrains' official plugin repository; shows modern patterns for grammar-kit based language plugins
• JetBrains/intellij-community — IntelliJ Platform SDK source; essential reference for understanding PSI, inspections, and plugin architecture used here
• golang/go — Official Go language repository; reference for Go grammar, syntax, and semantics that the plugin must parse and understand

To work on one of these in Claude Code or Cursor, paste: Implement the "<title>" PR idea from CLAUDE.md, working through the checklist as the task list.

Add comprehensive unit tests for PSI element classes in gen/com/goide/psi/

The repo contains 50+ auto-generated PSI element classes (GoAddExpr, GoCallExpr, GoForStatement, etc.) but there are no visible test files in the tests/ directory for these core AST/PSI components. This is critical for a language IDE plugin where PSI correctness directly affects code analysis, refactoring, and navigation. New contributors can write focused tests for parser output validation.

• [ ] Review tests/ directory structure and existing test patterns
• [ ] Create tests/com/goide/psi/ directory mirroring the PSI package structure
• [ ] Write unit tests for 5-10 high-use PSI classes (GoCallExpr, GoAssignmentStatement, GoForStatement, GoBlock, GoFunctionDeclaration)
• [ ] Test parsing edge cases like nested expressions, type assertions, and goroutine declarations
• [ ] Ensure tests validate both the PSI tree structure and element navigation methods

Migrate from deprecated Bintray Maven repository to JetBrains Marketplace in build.gradle

The build.gradle file references 'http://dl.bintray.com/jetbrains/intellij-plugin-service' which is deprecated (Bintray sunset in 2021). This causes build failures for new contributors. The gradle-intellij-plugin now uses JetBrains Marketplace by default. Updating this will unblock builds and modernize the plugin infrastructure.

• [ ] Update buildscript repositories section in build.gradle to remove Bintray URL
• [ ] Verify gradle-intellij-plugin version supports JetBrains Marketplace (upgrade if needed from 0.2.0-SNAPSHOT)
• [ ] Test the build with './gradlew build' to ensure plugin JAR generation succeeds
• [ ] Update CONTRIBUTING.md with current build instructions (e.g., required Gradle/JDK versions)
• [ ] Document any breaking changes in the Gradle configuration

Create inspection and quick-fix test suite for .idea/inspectionProfiles/

The repo has configured inspection profiles (Project_Default.xml, idea_default.xml) but no visible tests validating that custom Go language inspections work correctly. This is critical for IDE plugins where inspections must be thoroughly tested to avoid false positives/negatives. New contributors can build a test framework validating inspection behavior on Go code samples.

• [ ] Examine .idea/inspectionProfiles/Project_Default.xml to identify custom inspections configured
• [ ] Create tests/com/goide/inspections/ directory for inspection test cases
• [ ] Implement InspectionTestCase-based tests for 3-5 key inspections (e.g., unused variables, type mismatches, unused imports)
• [ ] Add testdata/inspections/ folder with Go code samples covering both pass and fail cases
• [ ] Document how to run inspection tests in CONTRIBUTING.md

• Add comprehensive unit tests for the Go lexer and parser under tests/com/goide/ to improve coverage of edge cases (generic syntax, module paths from Go 1.11+). The test infrastructure exists but testdata.xml scope suggests test cases are minimal.
• Document the grammar file location and regeneration process in CONTRIBUTING.md. Currently new developers cannot understand how to modify the language grammar (*.bnf or *.flex files not listed) without diving into src/ and IntelliJ plugin documentation.
• Create example inspections or quick-fixes in a new src/com/goide/inspections/ package (following IntelliJ conventions) to demonstrate how to hook into the PSI layer—README lists missing inspections (Implement type, Duplicated symbols, etc.) but no example code shows how they would be structured.

The Go plugin codebase has several notable security concerns: (1) use of insecure HTTP for Maven repositories enables potential dependency tampering, (2) outdated snapshot build tools from 2016 lack security updates, (3) the project is officially unmaintained with no security patch guarantees, and (4) build configuration may expose credentials if not properly managed. The codebase lacks modern security practices including dependency verification, credential management, and maintenance commitment. Users should exercise caution and consider supported alternatives like the official JetBrains Go plugin.

• High · Insecure Maven Repository URL — build.gradle, line ~6. The build.gradle file uses an insecure HTTP URL for the Bintray Maven repository: 'http://dl.bintray.com/jetbrains/intellij-plugin-service'. This could allow man-in-the-middle attacks to inject malicious dependencies. Fix: Replace 'http://' with 'https://' for all repository URLs to ensure secure transport of dependencies.
• High · Outdated Gradle Plugin Dependency — build.gradle, line ~11. The gradle-intellij-plugin uses version '0.2.0-SNAPSHOT', which is an old snapshot version from 2016. Snapshot builds may contain unvetted code and security patches are unlikely to be applied. Fix: Update to the latest stable version of gradle-intellij-plugin and verify compatibility with current IntelliJ Platform versions.
• Medium · Deprecated Plugin - Official Support Ended — README.md, Deprecation notice section. The README explicitly states this project is 'officially not maintained anymore'. Security vulnerabilities discovered in the plugin will not be patched, and dependencies will become increasingly outdated. Fix: Users should migrate to GoLand or the official JetBrains maintained Go plugin. For development purposes, conduct thorough security reviews before use.
• Medium · Unverified External Dependency Download — build.gradle, lines ~8-9. The build.gradle applies the 'de.undercouch.download' plugin version '3.1.0' which is used for downloading resources. Without explicit verification of downloaded artifacts (checksums/signatures), this could be exploited. Fix: Ensure all downloaded artifacts include SHA-256 checksum verification. Specify pinned versions and consider using trusted package mirrors.
• Low · Potential Credential Exposure in Build Configuration — build.gradle, lines ~42-45. The publishPlugin section references publishUsername and publishPassword variables which are loaded from external sources (likely gradle.properties or environment). If gradle.properties is committed to VCS, credentials could be exposed. Fix: Ensure gradle.properties is in .gitignore. Use Gradle secrets plugin or CI/CD secrets management instead of local property files.
• Low · Missing Security Configuration in IDE Settings — .idea directory structure. The .idea configuration files are committed to the repository. While this is sometimes intentional for IDE consistency, sensitive inspection profiles or run configurations could inadvertently expose security-relevant settings. Fix: Review .idea/inspectionProfiles and .idea/runConfigurations for any hardcoded sensitive data. Consider adding appropriate .idea entries to .gitignore where necessary.

LLM-derived; treat as a starting point, not a security audit.

• Open issues — current backlog
• Recent PRs — what's actively shipping
• Source on GitHub

Generated by RepoPilot. Verdict based on maintenance signals — see the live page for receipts. Re-run on a new commit to refresh.