Search

Search the awesome-ChatGPT-repositories database for the user's query.

Instructions

Ground rules — they apply whether this skill was invoked explicitly or picked automatically:

• Present only repositories from the bundled data files, even when the list has just a few matches — then say so and suggest other keywords rather than filling the gap from elsewhere.
• Don't search the web or open repository pages to add or verify details (setup, license, activity) unless the user explicitly asks for that: the curated list is the source of truth here, and its star counts and descriptions are snapshots. Copy names, URLs, and star counts exactly as they appear in the records.
• The output templates in Steps 5b–7 are fixed: keep their Markdown headings (##, ###), field labels, and order, and don't restyle them (for example, turning the result list into a table or a prose summary).
• If the data files can't be read (for example, shell commands are blocked), say so and link https://github.com/taishi-i/awesome-ChatGPT-repositories instead of substituting other sources.

Step 1 — Interpret the query

The query is the text the user passed to this skill (the same skill runs in Claude Code and Codex):

• Claude Code: the arguments of /awesome-chatgpt-search:search, appended at the end as ARGUMENTS: ….
• Codex: the user's message that invoked $awesome-chatgpt-search:search, minus the $… mention itself.

If there is no explicit query text, use the user's latest request.

Supported query modifiers:

• category:<name> — filter to one category
• language:<lang> — filter by programming language
• list categories or categories — skip to Step 5b
• Plain text — keyword search across all categories

The descriptions are in English, so convert non-English queries to English keywords before searching.

Examples:

Keyword tips:

• Use stems, not full words. Substring match catches variants: embed → embedding/embeddings, retriev → retrieval/retrieve, classif → classification/classifier, generat → generation/generative, fine-tun → fine-tune/fine-tuning, summari → summarize/summarization, orchestrat → orchestrate/orchestration.
• Add domain-specific names. For common LLM/AI domains, include well-known tool or framework names present in the database:

• Aim for 3–6 keywords. Too few miss items; too many inflate low-quality partial matches.

Step 2 — Search the data files with grep

Data is split into per-category files. Each file is a JSON array with one repo record per line, so you can grep for matches instead of reading whole files — this keeps token use low (a typical query pulls in a few dozen matching lines instead of hundreds of KB). Fields per record:

• u: GitHub URL · n: repository name · d: English description
• c: category · l: language (optional) · t: topics comma-separated (optional)
• sc: quality score 0–8 · st: star count (optional) · ns: normalized star score 0–10 (optional)

File list (all under data/ relative to this plugin; six categories over ~200 entries are split a/b):

Which files to search — pick the minimum set that covers the query, then grep them (below):

Rule A — category: specified: grep only that category's file(s), skip routing below. Match the category name case-insensitively and accept common variants: cli/clis/command-line → CLIs · chatbot/bot/chatbots → Chatbots · browser/extension/browser-extension → Browser-extensions · prompt/prompts → Prompts · tutorial/tutorials → Tutorials · reimpl/reimplementation → Reimplementations · awesome/lists → Awesome-lists · open ai/openai → Openai. If the value matches no category, fall back to keyword routing (Rule C).

Rule B — list categories: skip the keyword search, jump to Step 5b.

Rule C — keyword routing for general queries:

Use the English keywords from Step 1 (not the original query text) for routing. For each row below, check if any English keyword contains or matches the listed terms (case-insensitive substring). Use that row's file(s) only if there is a match. If multiple rows match, collect all their files (deduplicated). If no rows match, use the default: repos-chatbots-a.json, repos-nlp-a.json, repos-openai-a.json, repos-others-a.json.

Then grep those files for the keywords — do NOT read whole files into context (no Read tool, cat, or full-file dumps). Locate the data directory once — it is the plugin's data/ folder, two levels above this SKILL.md:

• Claude Code: ${CLAUDE_PLUGIN_ROOT}/data
• Codex: <directory of this SKILL.md>/../../data, built from the absolute path you loaded this SKILL.md from.

If that directory does not exist (unusual install), find it — the data directory is the folder that contains the printed file:

find "${CODEX_HOME:-$HOME/.codex}/plugins" "$HOME/.claude/plugins" "$PWD" -type f -name repos-unity.json -path "*awesome-chatgpt-search*" 2>/dev/null | head -1

Shell variables may not persist between commands, so write the resolved absolute path in place of $DATA in the commands below.

Then grep the selected files for your Step 1 keywords and cap the output. Use -F (literal substring match — same semantics as the scoring step, and safe for keywords like c++ or .net) with one -e per keyword:

grep -ihF -e keyword1 -e keyword2 -e keyword3 "$DATA"/repos-nlp-a.json "$DATA"/repos-nlp-b.json | head -120

Each line of output is one repo record (a JSON object) that matched at least one keyword — score those lines directly in Step 4. This reads only the matching repos, not the whole files. Notes:

• If grep returns fewer than ~8 lines, broaden the keywords (add more general single-word stems or tool names from Step 1 — multi-word phrases rarely match) and re-run.
• If it returns the full head cap, your keywords are good; proceed.
• Only fall back to reading individual files if grep is unavailable.

Step 3 — Filter by language (if language:<lang> was given)

Append a language filter to the grep pipeline (the l field holds the language, matched case-insensitively):

grep -ihF -e keyword1 -e keyword2 "$DATA"/repos-clis-a.json "$DATA"/repos-clis-b.json | grep -iF '"l":"<lang>"' | head -120

Step 4 — Score candidates

Using the English keywords from Step 1, compute a relevance score for each repo record returned by grep:

Text match score (case-insensitive, per keyword):

• Name (n) exact keyword match: +20 pts
• Name (n) contains keyword: +10 pts
• Description (d) contains keyword: +5 pts
• Topics (t) contains keyword: +3 pts
• Category (c) contains keyword: +2 pts

Popularity bonus (added once per item):

• If ns (normalized star score) is present: min(4, ns * 0.4)
• Otherwise: min(4, sc * 0.5)

Quality bonus (always added): min(2, sc * 0.25)

Combined score = text_match + popularity_bonus + quality_bonus

Exclude items with text_match < 5 (catches only accidental partial hits). Collect top 20 candidates by combined score.

Step 5a — Re-rank with your judgment

Apply semantic judgment to produce the final ordered list of 10 results — fewer only when fewer candidates actually fit the query.

Re-rank by evaluating each candidate on:

1. Semantic centrality — how directly does this repo address the query's core intent?
2. Quality signal — higher sc means a richer, better-documented project.
3. Category fit — match the repo type to the implied need:
   • "build a chatbot / ボット" → prefer Chatbots, CLIs
   • "learn / tutorial / 勉強" → prefer Tutorials
   • "prompt engineering" → prefer Prompts
   • "use from browser" → prefer Browser-extensions
   • "NLP task" → prefer NLP, Langchain
   • "OpenAI API" → prefer Openai
4. Specificity — a repo specialized for the exact use-case beats a general one.
5. Language fit — if the user implied a language, prefer repos with matching l.

Step 5b — List categories (only if query was list categories / categories)

Skip scoring. Count the repositories per category from the data (one cheap command, so the numbers always match the bundled data):

grep -ho '"c":"[^"]*"' "$DATA"/repos-*.json | sort | uniq -c

Present the counts in this order, followed by the total:

## Available categories

| Category | Count |
|----------|-------|
| Awesome-lists | N |
| Prompts | N |
| Chatbots | N |
| Browser-extensions | N |
| CLIs | N |
| Reimplementations | N |
| Tutorials | N |
| NLP | N |
| Langchain | N |
| Unity | N |
| Openai | N |
| Others | N |
| **Total** | **N** |

Step 6 — Format the output

## Search results for "<query>"

*(Searched for: keyword1, keyword2, ...)*

Found N result(s).

### 1. [repository-name](url)
**Category:** category  ·  **Language:** language  ·  ⭐ {st} stars
Description text here.
*Topics: tag1, tag2, tag3*

### 2. ...

Fill every field from the record: link text n, URL u, category c, language l, stars st as-is, the description d verbatim (you may drop :emoji: shortcodes), and topics from t (trim long lists to about 8). The results stay in English like the data; only the Step 7 guide follows the query language.

Omit the Language line if l is absent. Omit ⭐ stars if st is absent. Omit the Topics line if t is absent.

If no results found, suggest alternate keywords and link to: https://github.com/taishi-i/awesome-ChatGPT-repositories

Step 7 — Output use-case selection guide

After the search results list, append a guide table to help users pick the right repo for their specific situation.

Match the section heading and table language to the query language — if the query was in Japanese, use Japanese for the heading and column headers; otherwise use English.

## Use-case Selection Guide

| Use case | Recommended | Score | Why |
|---|---|---|---|
| ... | [name](url) | sc=N | short reason |

Rules:

• List 3–6 distinct use cases derived from the top 10 results. Each row should represent a meaningfully different scenario (e.g., "deploy a self-hosted chatbot" vs. "build a RAG pipeline"), not just a restatement of the query.
• For each row, select the single best repo from the top 10 results.
• Score column: show sc=N using the item's quality score.
• Why: write a 10–15 word reason in the query language explaining the practical benefit. Do not copy the description verbatim.
• If two use cases map to the same repo, merge them into one row or drop the weaker one.
• If there are fewer than 3 meaningfully distinct use cases in the results, output as many rows as make sense (minimum 1).