Agent skill

Gograph Go Repository Intelligence

by ozgurcd in ozgurcd/gograph

Gives an agent working in a Go codebase a structural view through a local MCP server: call graphs, blast-radius and impact analysis, and bounded first-call exploration.

MITAuto-check: notesDevelopment

Install Gograph Go Repository Intelligence

skills CLI
$ npx skills add ozgurcd/gograph --skill gograph -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install ozgurcd/gograph gograph --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/ozgurcd/gograph.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/gograph .claude/skills/gograph && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
gograph
GitHub stars
227
Token cost
~4.8k tokens
SKILL.md length
2,307 words
Files
1
Skills in repo
1
Repo updated
First seen
Licence
MIT

At a glance

Gives an agent working in a Go codebase a structural view through a local MCP server: call graphs, blast-radius and impact analysis, and bounded first-call exploration.

  • Works in 6 steps: At the start of any Go coding session,… → Confirm graph health before symbol… → For unfamiliar structural questions,… → …
  • Tracing how a Go function or type is used across a codebase
  • SKILL.md covers When to invoke this skill, Prerequisite, Mandatory workflow (enforced) and High-value tools, plus 3 more sections
  • Calls go

What it does

The engine is a local, AST-aware Go analysis tool that exposes dozens of query, analysis and workflow capabilities over the Model Context Protocol, backed by a persisted or in-memory graph. Its exploration tool offers three bounded depths in one shared result: compact for identity, role and complete counts, standard adding source evidence and exact impact, and deep adding depth-three evidence and package context. It complements, rather than replaces, gopls, which gives live compiler-backed navigation; this engine adds the persisted graph, composed change-analysis workflows and policy gates.

The skill applies whenever a Go file is in the working directory or the user names a Go symbol, type, package or interface, for reading code, planning or executing an edit, reviewing a diff, hunting a bug or measuring complexity and coupling. It requires its own binary on PATH, and for unrelated broken packages the project is built with explicit exclude-dirs flags passed consistently to both the build and the MCP startup so excluded code stays outside the census; symlinked skill directories need their real parent excluded too.

When your agent uses it

  • Tracing how a Go function or type is used across a codebase
  • Assessing the blast radius of a planned Go refactor or deletion
  • Reviewing a Go diff with structural context instead of just the text

Example prompts

  • “What's the blast radius of removing this exported Go function?”
  • “Trace the call graph from this handler down to the database layer.”
  • “Review this Go diff with impact analysis before I merge it.”

Requirements

  • The gograph binary on PATH
  • An MCP-capable coding agent
  • Pre-approved tools (allowed-tools): Bash, Read

Workflow steps

6 steps, taken from the first numbered list in SKILL.md.

  1. At the start of any Go coding session, run CLI gograph doctor --json
  2. Confirm graph health before symbol queries. MCP creates an in-memory AST
  3. For unfamiliar structural questions, invoke gograph_explore first; for complete structural symbol / type / function discovery, use…
  4. Before editing any Go symbol, invoke gograph_plan with
  5. To understand a function or method, invoke gograph_context with
  6. After editing Go code, invoke gograph_review with uncommitted=true;

What it can do on your machine

Read from SKILL.md and the folder at commit 26498c2. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • Bash
    • Read

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • go

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Gograph Go Repository Intelligence loads about 4.8k tokens when it runs. Until then it costs about 87 tokens; SKILL.md has 2,307 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~87
When it runs · the whole SKILL.md, loaded when a task matches
~4.8k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check: notes

The automated check noted patterns worth knowing about, such as sudo or a known installer.

  • NoteMentions a .env fileSKILL.md:178
    `.env`, key, certificate, kubeconfig, tfstate, or credential files. It respects
  • NotePre-approves every shell command (allowed-tools: Bash)SKILL.md
    allowed-tools: Bash, Read

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from ozgurcd/gograph at commit 26498c2, republished under its MIT licence (© ozgurcd). 2,307 words, ~4,809 tokens.

Download SKILL.mdSave it as .claude/skills/gograph/SKILL.md (or your agent's skills folder).
name
gograph
description
Go repository intelligence for Claude Code. Use when reading, navigating, editing, reviewing, or refactoring a Go codebase. Exposes 64 query, analysis, and workflow capabilities through the local gograph MCP server, including bounded first-call exploration, AST-aware call graphs, blast-radius analysis, impact, and security-flow candidates.
allowed-tools
Bash, Read
version
0.1.0
argument-hint
gograph stats | gograph plan UserService.Login | gograph review --uncommitted
homepage
https://gograph.identuum.ai
repository
https://github.com/ozgurcd/gograph
author
ozgurcd
license
MIT
user-invocable
true

gograph: Go Repository Intelligence

gograph is a local, AST-aware Go code intelligence engine that exposes 64 query, analysis, and workflow capabilities over the Model Context Protocol (68 endpoints including session lifecycle). It gives terminal LLMs (Claude Code, Cursor agents, OpenClaw) a structural view backed by a persisted or in-memory graph. gograph_explore offers compact, standard, and deep bounded discovery over one shared native result: compact preserves identity/role and complete counts, standard includes source/direct evidence and exact impact, and deep adds depth-3 exact evidence, package context, and explanation. gograph_context remains the focused known-symbol bundle. Actual savings depend on the task.

gopls provides live compiler-backed navigation, diagnostics, implementations, refactoring, and experimental MCP support. gograph complements it with a persisted repository graph, composed change-analysis workflows, and policy gates for coding agents.

When to invoke this skill

Activate whenever the user is working in a Go repository:

  • Reading code, asking what a function does, or tracing a behavior across files.
  • Planning, editing, refactoring, or deleting any Go symbol (function, method, struct, interface, package).
  • Reviewing a Go diff or unstaged changes.
  • Hunting a bug, auditing for security issues, or measuring complexity / coupling.

If a .go file is in the CWD or the user mentions a Go symbol, type, package, or interface by name, the skill applies.

Do NOT invoke for non-Go work. The skill is Go-scoped.

Prerequisite

For unrelated broken packages, use gograph build . --precise --strict --exclude-dirs=legacy,examples/broken. Pass the same --exclude-dirs to MCP startup and verify analysis_build_context.exclude_dirs in capabilities. Paths are literal root-relative subtrees; imported dependencies still must compile. Excluded code is outside the census. Workspace members use exclude_dirs in their manifest. See docs/build-selection.md. For symlinked skills in v1.7.2+, exclude their real parent, for example --exclude-dirs=.claude/skills. Precise production/test loading masks directory links beneath it without following targets. Linked Go inputs/metadata remain errors, and an existing Go overlay conflicts with masking. doc retains its independent strict preflight. Codex setup: docs/codex-integration.md.

The gograph binary must be installed and on $PATH:

bash
go install github.com/ozgurcd/gograph/cmd/gograph@latest

Verify the active installation with gograph doctor --json; it reports the running binary, PATH resolution, shadowed copies, and—inside a repository—the current graph's freshness, analysis capabilities, and diagnostic without executing alternate binaries. The marketplace plugin supplies this workflow guidance; it does not install the binary or register an MCP server. Register gograph mcp <project-path> for each project using the client's MCP setup. Packaged and generated registrations keep refresh persistence off by default.

Mandatory workflow (enforced)

  1. At the start of any Go coding session, run CLI gograph doctor --json to detect installation shadowing, then invoke gograph_capabilities to confirm what the connected server exposes.
  2. Confirm graph health before symbol queries. MCP creates an in-memory AST graph when the artifact is missing, unreadable, unsafe, or has an unsupported source-policy marker, and refreshes source analysis per call. Invoke gograph_stats with no parameters and require build_status=complete; a build with zero successful parses never replaces the previous graph, while partial failures are reported explicitly. When durable precise enrichment is needed, run CLI gograph build . --precise; use gograph build . --precise --strict when CI must fail on fallback. If compilation prevents precision during exploratory work, use CLI gograph build . and explain the fallback.
  3. For unfamiliar structural questions, invoke gograph_explore first; for complete structural symbol / type / function discovery, use gograph_query instead of grep, rg, find, or glob. Start with compact=true when identity and evidence counts are enough; use standard mode for direct evidence or deep=true for bounded depth-3 exact evidence, package context, and explanation. Compact/deep are mutually exclusive and default to 5/25 rows versus standard's 10; an explicit limit overrides the mode default. gograph_explore discloses lexical selection, ambiguity, totals, truncation, and omissions; follow with a focused tool when a complete section is needed. Text search also matches comments and string literals; gograph_query returns AST-derived matches. Continue to use text search for literal strings, documentation, ordinary non-sensitive configuration, and non-Go files.
  4. Before editing any Go symbol, invoke gograph_plan with symbol=<symbol>. The plan returns callers, tests connected to the symbol, and a blast-radius estimate. Edit decisions should reference the plan.
  5. To understand a function or method, invoke gograph_context with symbol=<symbol>. This single call combines node + source + callers + callees + statically mapped tests; inspect source or gopls when the evidence is incomplete.
  6. After editing Go code, invoke gograph_review with uncommitted=true; MCP refreshes source analysis before the review. If the task requires a durable precise artifact for later CLI or server processes, run CLI gograph build . --precise first. Run the repository's required tests and checks separately.

MCP responses carry graph provenance in _meta and native structured content where supported. Common bounded row lists use gograph.results.v1; native explain/changes retain their schemas. Other legacy results retain a gograph.mcp-result.v1 (source/context instead use gograph.read.v1 with the answer or refusal) structured companion. Inspect the accompanying graph_state before using an absence or broad impact result: source, freshness, completeness, and precision are independent. A current in-memory fallback and a trusted stale persisted result are intentionally usable but degraded; disclose them and cross-check important negatives. A different effective Go build context fails closed rather than being served. CLI graph-backed --json responses expose the same gograph.graph-state.v1 object at the envelope top level.

High-value tools

Uncommitted modes compare declarations against HEAD. Incomplete comparisons, deleted declarations needing historical caller evidence, and missing/ambiguous current identities are explicit errors, not empty successful reviews. Inspect gograph_changes with git_ref=HEAD for deletions; rebuild before traversing new declarations. CLI uses the same rules.

ToolUse case
gograph_capabilitiesRecord the running server version and discover what it exposes
gograph_explore with query=<term-or-symbol>Compact/standard/deep bounded discovery with shared CLI semantics; start compact and deepen only when needed
gograph_query with term=<term> or terms=[...]AST-derived structural symbol search
gograph_context with symbol=<symbol>Node + source + callers + callees + tests in one call
gograph_plan with symbol=<symbol>Pre-edit blast radius + callers + tests
gograph_review with uncommitted=truePost-edit coverage check
gograph_impact with symbol=<symbol>Canonical upstream identities with exact/possible labels; exact_only=true excludes uncertain paths
gograph_callers / gograph_callees with function=<symbol>Explicit call-graph traversal
gograph_implementers with interface=<interface>Type-checked production implementers plus AST-discovered test fakes; set test_only=true for only fakes
gograph_usages with type=<type>Signature, field, interface-method, and composite-literal uses; use gograph_literals for only construction sites
gograph_routes with optional term, module, include_tests, limit, cursorBounded production-first HTTP route pages; root repositories and nested modules accept directory-name selectors; follow next_cursor for all rows (CLI --files-only is a file census)
gograph_sql with optional term, tables[], verbs[], accesses[], function, module, no_tests, limit, cursorBounded PostgreSQL static SQL pages, including statically resolved declarations/concatenations, with explicit operation/table classification; follow next_cursor for a complete census
gograph_complexityCyclomatic complexity per function
gograph_godobjGod-object detection
gograph_couplingPackage coupling / instability scores
gograph_diagramMermaid architecture diagrams
gograph_errors with optional term=<term>Error inventory
gograph_errorflow with query=<term>Error propagation paths
gograph_flowPotential HTTP/JSON/env paths to SQL, process, filesystem, and outbound HTTP sinks
gograph_changesDeclaration add/modify/delete/excluded/unknown census against persisted graph or git_ref; require evaluation=complete before treating the result as exhaustive
gograph_tests with symbol=<symbol>, transitive=trueEvery test statically reaching a symbol, with exact/possible path and depth; omit transitive for direct edges, where Receiver.Method and stable IDs are accepted
gograph_coverage with test=<TestFunc>Transitive product symbols one unambiguous test statically reaches; exact/possible paths; optional package disambiguation
gograph_identity with symbol=<symbol-or-stable-id>Print or re-resolve canonical symbol identity without silently choosing ambiguity; optional package disambiguation
gograph_checkPolicy checks, including changed-route tests, coverage, orphans, API drift, arity, and complexity

The live surface is 68 MCP endpoints; gograph_capabilities is the tested source of truth. gograph_flow is path-insensitive with bounded call-site matching; use it for security review leads, not exploitability proof. Common list tools (including query, callers/callees, impact, types/usages, errors/envs, and httpcalls) default to 100 rows, maximum 200, within a 16 KiB native-page budget. Inspect total, returned, truncated, and next_cursor; follow cursors with the same snapshot and filters for a complete census. Changing page size is allowed. Snapshot or selection changes reject old cursors; restart the census. Never combine pagination with mermaid or files_only. Routes and SQL retain their specialized 64 KiB page contracts. gograph_explain returns ambiguity candidates instead of selecting a name twin. gograph_changes reuses recorded platform/build tags and rediscovers current module ownership; missing legacy selection or a racing source tree makes its evaluation incomplete. CLI incomplete changes exit 2.

gograph_httpcalls retains bounded lexical URL-base/static-suffix evidence and labels NewRequest/NewRequestWithContext as request construction, not dispatch proof. Workspace http_clients explicitly maps bases (cfg.API, env:API_URL) to logical authorities in the selected scope; no environment values are read. Workspace query retains http_unresolved diagnostics; verified status includes per-scope unresolved counts. Such diagnostics never participate in traversal. The four gograph_workspace_* tools require a separate workspace server and share native values with CLI workspace status/query/path/impact. For gograph_callers, gograph_callees, gograph_impact, gograph_endpoint, gograph_dependents, gograph_deps, gograph_path, and gograph_coupling, set mermaid=true to request Markdown-fenced Mermaid instead of the tool's normal response.

CLI path and MCP gograph_path share deterministic best-path selection: exact before possible, then shorter, production before tests, typed resolution before heuristics, and a canonical tie-breaker. Workspace path adds fewer cross-repository transitions as the final semantic preference.

Show full SKILL.md (844 more words)Show less

Privacy

Graph artifacts and MCP transport are local. Indexing asks the installed Go toolchain for effective build/module context; precise mode additionally type-loads packages, and doc runs go doc. These operations follow the configured module-cache and network policy and remain open-world. Indexing reads Go source and ordinary project/gograph metadata; it does not intentionally scan .env, key, certificate, kubeconfig, tfstate, or credential files. It respects .gitignore and skips AI-agent worktree directories automatically. See PRIVACY.md in the gograph repo for details.

Linked directories and linked/special files for recognized Go build inputs are excluded; unrelated regular-file or dangling non-Go links do not block precision. AST and graph-directed source reads are confined to regular files beneath the analyzed repository; an explicitly symlinked repository root remains supported. Persisted graph.json must also be a regular repository-confined file, and publication refuses a linked or non-directory .gograph and linked/non-regular lock files. The automatic .gitignore update rejects links rather than modifying their targets. Linked/non-regular go.mod, go.sum, go.work, go.work.sum, and vendor/modules.txt metadata is rejected before gograph or the Go toolchain reads it. Applicable go.work use members may be sibling modules beneath the nearest real Git checkout; without one they remain beneath the workspace directory. Nested Git boundaries are not crossed, and each member directory, go.mod, and optional go.sum is validated before cmd/go. A persisted graph with a missing or unsupported source-policy marker must be rebuilt before graph-backed tools use it, and its serialized root is ignored. Saved .json baselines for gograph_api and gograph_check must be regular, non-linked files inside the selected project with the exact current marker; their serialized roots are also ignored. Use the current binary for untrusted repositories. Precise repository package loading and go doc are refused when source/metadata-link validation fails; their preflight rejects source-tree links without following targets that cmd/go may inspect across the selected root plus its effective module root, or the workspace root and member trees; .git and .gograph are excluded from that walk. doc also rejects filesystem-shaped queries.

Most MCP tools are read-only. Boundary creation writes configuration, session create/end mutate telemetry, session cleanup deletes stale logs, and gograph_wiki writes documentation; their MCP annotations declare those effects. Repository-controlled session, snapshot, boundary, gate-init, and relative wiki paths use rooted regular-file operations and reject linked path components. Absolute wiki output is an explicit local destination whose generated descendants remain confined beneath its real directory. Wiki regeneration prunes obsolete generator-owned package pages while preserving custom pages and packages/README.md.

An operator can opt into durable MCP refreshes with gograph mcp [path] --persist-refresh. After a successful refresh this writes or overwrites .gograph/graph.json and the nine reports, without modifying .gitignore. Refresh-capable tools then advertise that they may write. A publication failure during a tool-triggered refresh is reported as persistence.outcome=failed; the fresh in-memory result remains usable and the write is retried on a later refresh-capable call without rebuilding. If startup must auto-build, failure to publish prevents the server from starting. A failed precise retry retains an already-fresh successful precise artifact for the same sources. The artifact is the latest state only, not a branch cache. Because default gograph_changes compares the working tree with the persisted graph, a successful publication also advances that comparison baseline. Reports are replaced first and graph.json is replaced last as the publication marker. Same-directory replacement is atomic on Unix-like systems but is not guaranteed atomic by Go on non-Unix platforms; the complete ten-file bundle is not one atomic transaction, and .artifacts.lock remains as separate operational state. The server must start under the same effective GOWORK, GOFLAGS, and tag selection used by the persisted graph; a mismatch is stale and must refresh successfully or return a diagnostic rather than silently serving incompatible facts.

Queries pin immutable graph/provenance snapshots while refresh is serialized. Cancellation reaches Go loading and pre-publication checks; a started artifact commit finishes its set, without promising rollback. Derived indexes are cached for the current fingerprint; workspace verification receipts never bypass source freshness, path confinement, module ownership, or artifact-byte checks. After installing a new binary, restart the MCP server and verify gograph_capabilities.version; an existing process does not hot-reload schemas.

Anti-patterns

  • Treating text search or gograph as universally authoritative. Use gograph first for supported structural queries; use gopls or targeted source/text search when precision is AST/fallback, results are ambiguous, or a known call is missing. Use text search directly for literals, comments, generated or non-indexed files, and non-Go content.
  • Editing a Go function without gograph_plan first. This can miss relevant callers and downstream tests.
  • Skipping gograph_review with uncommitted=true after a multi-file change and therefore missing a useful static review signal.
  • Repeating broad source reads when gograph_context with symbol=<symbol> can provide a focused structural starting point.
  • Assuming MCP refreshes are durable, or that --persist-refresh caches branch history. Default registrations refresh only in memory, and the opt-in mode keeps one latest artifact set.

Why this exists

Coding agents often need a symbol's source, callers, callees, tests, and role at the same time. gograph_context combines that indexed evidence in one response. Measure tool calls, actual model tokens, false positives, false negatives, and task success on your own repository; gograph output remains static-analysis evidence rather than runtime proof.

© ozgurcd, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in skills/gograph of ozgurcd/gograph.

Open the folder on GitHubat commit 26498c2

Compare with similar skills

Gograph Go Repository Intelligence next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Gograph Go Repository Intelligence compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Gograph Go Repository Intelligence this skillozgurcd/gograph227—~4.8kAutomated safety check: NotesMIT
Golang Goplscontext-labs/whip1.1k1 repos~2.3kAutomated safety check: PassMIT
ast-grep Structural Searchcode-yeongyu/oh-my-openagent70k—~3.3kAutomated safety check: PassMIT
Grepaiyoanbernabeu/grepai1.9k—~1.1kAutomated safety check: PassMIT
Releaseyoanbernabeu/grepai1.9k—~918Automated safety check: PassMIT
Typed Dependencies with fp-go EffectIBM/fp-go2k—~4.3kAutomated safety check: PassApache-2.0

Similar skills

  • Golang Gopls

    context-labs/whip

    Golang semantic code intelligence via gopls — go-to-definition, references, call hierarchy, symbols, diagnostics, rename, refactors.

    1.1k GitHub starsUsed in 1 repo~2.3k tokens
    DevelopmentAuto-check passed
  • ast-grep Structural Search

    code-yeongyu/oh-my-openagent

    Searches and rewrites code by syntax-tree shape across 25 languages with ast-grep, for codemods, structural queries and YAML lint rules, using a Python wrapper script.

    70k GitHub stars~3.3k tokensUpdated today
    DevelopmentAuto-check passed
  • Grepai

    yoanbernabeu/grepai

    Semantic code search and call-graph tracing. An agent skill from yoanbernabeu/grepai.

    1.9k GitHub stars~1.1k tokensUpdated 16 days ago
    DevelopmentAuto-check passed
  • Release

    yoanbernabeu/grepai

    Create a new release for grepai. An agent skill from yoanbernabeu/grepai.

    1.9k GitHub stars~918 tokensUpdated 16 days ago
    DevelopmentAuto-check passed
  • Teaches an agent to write fp-go v2 services with the Effect type, carrying dependencies in its type parameter instead of in context.Context or parameters.

    2k GitHub stars~4.3k tokensUpdated today
    DevelopmentAuto-check passed
  • Ripwire Graph Query

    redhat-et/ripwire

    Answers call-graph questions that combine several conditions, such as complex functions that reach a target or untested symbols near main, using ripwire's graph-query mode.

    2.4k GitHub stars~1.1k tokensUpdated 2 days ago
    DevelopmentAuto-check: notes

Questions about Gograph Go Repository Intelligence

What does Gograph Go Repository Intelligence do?

Gives an agent working in a Go codebase a structural view through a local MCP server: call graphs, blast-radius and impact analysis, and bounded first-call exploration. The engine is a local, AST-aware Go analysis tool that exposes dozens of query, analysis and workflow capabilities over the Model Context Protocol, backed by a persisted or in-memory graph. Its exploration tool offers three bounded depths in one shared result: compact for identity, role and complete counts, standard adding source evidence and exact impact, and deep adding depth-three evidence and package context.

When should I use Gograph Go Repository Intelligence?

Gograph Go Repository Intelligence fits situations like: tracing how a Go function or type is used across a codebase; assessing the blast radius of a planned Go refactor or deletion; reviewing a Go diff with structural context instead of just the text.

How do I install Gograph Go Repository Intelligence in Claude Code?

Run `npx skills add ozgurcd/gograph --skill gograph -a claude-code`. Or copy the skill folder (skills/gograph in ozgurcd/gograph) into .claude/skills/gograph in your project. Claude Code loads it when a task matches its description.

How do I install Gograph Go Repository Intelligence in Codex?

Run `npx skills add ozgurcd/gograph --skill gograph -a codex`. Or copy the skill folder (skills/gograph in ozgurcd/gograph) into .agents/skills/gograph in your project. Codex loads it when a task matches its description.

Can I use Gograph Go Repository Intelligence in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add ozgurcd/gograph --skill gograph -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/gograph, .gemini/skills/gograph, .github/skills/gograph and .opencode/skills/gograph in your project.

What does Gograph Go Repository Intelligence need to run?

Going by SKILL.md and its folder, Gograph Go Repository Intelligence needs the command-line tools its instructions call (go). Our summary lists: The gograph binary on PATH; An MCP-capable coding agent. Its frontmatter pre-approves these tools: Bash, Read.

Does Gograph Go Repository Intelligence access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Gograph Go Repository Intelligence safe to install?

Our automated static check of SKILL.md found notes only (mentions a .env file; pre-approves every shell command (allowed-tools: bash)), nothing it rates as a warning. It is not a guarantee. Review the folder before installing.

What licence does Gograph Go Repository Intelligence use?

Gograph Go Repository Intelligence is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Gograph Go Repository Intelligence use?

About 4.8k tokens (SKILL.md is roughly 19k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Gograph Go Repository Intelligence?

Skills that share tags, products or a category with Gograph Go Repository Intelligence: Golang Gopls (context-labs/whip, 1.1k stars), ast-grep Structural Search (code-yeongyu/oh-my-openagent, 70k stars), Grepai (yoanbernabeu/grepai, 1.9k stars) and Release (yoanbernabeu/grepai, 1.9k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Gograph Go Repository Intelligence?

ozgurcd (a GitHub user) maintains it in ozgurcd/gograph, which has 227 GitHub stars. The repository was last updated on October 6, 2026.

Source: ozgurcd/gograph on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.