home / skills / tenequm / claude-plugins / gh-cli

gh-cli skill

/gh-cli

This skill analyzes GitHub repositories remotely, compares codebases, and discovers trending code and projects without cloning, enhancing discovery and

npx playbooks add skill tenequm/claude-plugins --skill gh-cli

Review the files below or copy the command above to add this skill to your agents.

Files (19)
SKILL.md
5.9 KB
---
name: gh-cli
description: GitHub CLI for remote repository analysis, file fetching, codebase comparison, and discovering trending code/repos. Use when analyzing repos without cloning, comparing codebases, or searching for popular GitHub projects.
---

# GitHub CLI - Remote Analysis & Discovery

Remote repository operations, codebase comparison, and code discovery without cloning.

## When to Use

- Analyze repositories without cloning
- Compare codebases side-by-side
- Fetch specific files from any repo
- Find trending repositories and code patterns
- Search code across GitHub

## Quick Operations

### Fetch a file remotely

```bash
gh api repos/OWNER/REPO/contents/path/file.ts | jq -r '.content' | base64 -d
```

### Get directory listing

```bash
gh api repos/OWNER/REPO/contents/PATH
```

### Search code

```bash
gh search code "pattern" --language=typescript
```

### Find trending repos

```bash
gh search repos --language=rust --sort stars --order desc
```

## Compare Two Codebases

Systematic workflow for comparing repositories to identify similarities and differences.

**Example use**: "Compare solana-fm/explorer-kit and tenequm/solana-idls"

### Step 1: Fetch directory structures

```bash
gh api repos/OWNER-A/REPO-A/contents/PATH > repo1.json
gh api repos/OWNER-B/REPO-B/contents/PATH > repo2.json
```

If comparing a monorepo package, specify the path (e.g., `packages/explorerkit-idls`).

### Step 2: Compare file lists

```bash
jq -r '.[].name' repo1.json > repo1-files.txt
jq -r '.[].name' repo2.json > repo2-files.txt
diff repo1-files.txt repo2-files.txt
```

Shows files unique to each repo and common files.

### Step 3: Fetch key files for comparison

Compare package dependencies:

```bash
gh api repos/OWNER-A/REPO-A/contents/package.json | jq -r '.content' | base64 -d > repo1-pkg.json
gh api repos/OWNER-B/REPO-B/contents/package.json | jq -r '.content' | base64 -d > repo2-pkg.json
```

Compare main entry points:

```bash
gh api repos/OWNER-A/REPO-A/contents/src/index.ts | jq -r '.content' | base64 -d > repo1-index.ts
gh api repos/OWNER-B/REPO-B/contents/src/index.ts | jq -r '.content' | base64 -d > repo2-index.ts
```

### Step 4: Analyze differences

Compare the fetched files to identify:

**API Surface**
- What functions/classes are exported?
- Are the APIs similar or completely different?

**Dependencies**
- Shared dependencies (same approach)
- Different dependencies (different implementation)

**Unique Features**
- Features only in repo1
- Features only in repo2

For detailed comparison strategies, see [references/comparison.md](references/comparison.md).

## Discover Trending Content

### Find trending repositories

```bash
# Most starred repos
gh search repos --sort stars --order desc --limit 20

# Trending in specific language
gh search repos --language=rust --sort stars --order desc

# Recently popular (created in last month)
gh search repos "created:>2024-10-01" --sort stars --order desc

# Trending in specific topic
gh search repos "topic:machine-learning" --sort stars --order desc
```

### Discover popular code patterns

```bash
# Find popular implementations
gh search code "function useWallet" --language=typescript --sort indexed

# Find code in popular repos only
gh search code "implementation" "stars:>1000"

# Search specific organization
gh search code "authentication" --owner=anthropics
```

For complete discovery queries and patterns, see [references/discovery.md](references/discovery.md).

## Search Basics

### Code search

```bash
# Search across all repositories
gh search code "API endpoint" --language=python

# Search in specific organization
gh search code "auth" --owner=anthropics

# Exclude results with negative qualifiers
gh search issues -- "bug report -label:wontfix"
```

### Issue & PR search

```bash
# Find open bugs
gh search issues --label=bug --state=open

# Search assigned issues
gh search issues --assignee=@me --state=open
```

For advanced search syntax, see [references/search.md](references/search.md).

## Special Syntax

### Field name inconsistencies

**IMPORTANT:** GitHub CLI uses inconsistent field names across commands:

| Field | `gh repo view` | `gh search repos` |
|-------|----------------|-------------------|
| Stars | `stargazerCount` | `stargazersCount` |
| Forks | `forkCount` | `forksCount` |

**Examples:**

```bash
# ✅ Correct for gh repo view
gh repo view owner/repo --json stargazerCount,forkCount

# ✅ Correct for gh search repos
gh search repos "query" --json stargazersCount,forksCount
```

### Excluding search results

When using negative qualifiers (like `-label:bug`), use `--` to prevent the hyphen from being interpreted as a flag:

```bash
gh search issues -- "query -label:bug"
```

For more syntax gotchas, see [references/syntax.md](references/syntax.md).

## Advanced Workflows

For detailed documentation on specific workflows:

**Core Workflows:**
- [remote-analysis.md](references/remote-analysis.md) - Advanced file fetching patterns
- [comparison.md](references/comparison.md) - Complete codebase comparison guide
- [discovery.md](references/discovery.md) - All trending and discovery queries
- [search.md](references/search.md) - Advanced search syntax
- [syntax.md](references/syntax.md) - Special syntax and command quirks

**GitHub Operations:**
- [repositories.md](references/repositories.md) - Repository operations
- [pull_requests.md](references/pull_requests.md) - PR workflows
- [issues.md](references/issues.md) - Issue management
- [actions.md](references/actions.md) - GitHub Actions
- [releases.md](references/releases.md) - Release management

**Setup & Configuration:**
- [getting_started.md](references/getting_started.md) - Installation and auth
- [other.md](references/other.md) - Environment variables, aliases, config
- [extensions.md](references/extensions.md) - CLI extensions

## Resources

- Official docs: https://cli.github.com/manual/
- GitHub CLI: https://github.com/cli/cli
- Search syntax: https://docs.github.com/en/search-github

Overview

This skill provides a GitHub CLI–based toolkit for remote repository analysis, file fetching, codebase comparison, and discovering trending code and repositories without cloning. It streamlines targeted inspections, side-by-side comparisons, and advanced search queries to quickly surface differences, dependencies, and popular patterns. Ideal for audits, code reviews, and discovery workflows.

How this skill works

The skill uses gh CLI commands to query repository contents, download specific files (decoded from base64), list directories, and run code and repo searches. It automates fetching JSON directory listings, extracting file lists, and pulling key files like package.json or source entry points for offline comparison. It also composes search queries to find trending repos and common code patterns across GitHub.

When to use it

  • Audit or inspect a repo without cloning the full project
  • Compare two codebases to identify API, dependency, or feature differences
  • Fetch specific files (package.json, README, source files) from remote repos
  • Discover trending repositories or common code patterns in a language or topic
  • Search across GitHub for implementations, bugs, or examples tied to stars or recency

Best practices

  • Fetch directory listings then extract filenames to compare structural differences before pulling file contents
  • Use base64 decoding on gh API responses to save exact file contents locally
  • Limit searches with language, owner, topic, stars, or created: filters to reduce noise
  • Be explicit with gh JSON field names (stargazerCount vs stargazersCount) depending on the command
  • Use -- to pass negative qualifiers in search queries to avoid flag parsing issues

Example use cases

  • Compare package.json files between two libraries to surface divergent dependencies
  • Pull src/index.ts from two repos and diff exported APIs and implementations
  • Search popular repos for a function name to learn common implementations or patterns
  • List and fetch files from a monorepo package path without cloning the entire repository
  • Find recently created, highly starred projects in a language to seed research or dependency selection

FAQ

Do I need to clone repositories to compare code?

No. Use gh api to list directories and fetch specific files, then diff locally. This saves time and bandwidth.

How do I decode file contents fetched via gh api?

The gh API returns base64-encoded file content. Pipe the .content field through jq -r and base64 -d to write the original file.