yoanbernabeu/grepai-skills
27 skills11.9k installs459 starsGitHub
Install
npx skills add https://github.com/yoanbernabeu/grepai-skillsSkills in this repo
1Grepai Search Basicsgrepai-search-basics teaches solo builders how to use GrepAI’s embedding-backed CLI so coding agents search repositories by intent instead of brittle grep strings. After init and watch have built an index with a local or configured embedding provider, you run grepai search with natural-language queries and read scored hits with file paths and line ranges—useful for tracing auth flows, finding handlers, or onboarding to an unfamiliar indie codebase. The skill is intentionally foundational: it contrasts semantic and text search, shows example output, and sets expectations for prerequisites so you do not waste agent turns on a missing index. Install it when you first adopt GrepAI alongside Claude Code, Cursor, or Codex, or when you want repeatable search phrasing before deeper grepai-skills in the repo. It does not replace ripgrep for exact literals; it complements meaning-first discovery during Build.670installs2Grepai Ollama Setupgrepai-ollama-setup is an agent skill for solo and indie builders who want private semantic code search with GrepAI. It walks through installing Ollama on macOS, Linux, and Windows, starting the Ollama service, and selecting embedding models GrepAI needs to vectorize a codebase locally. Use it when you are adopting GrepAI for the first time, switching from hosted embeddings to local ones, or debugging failures to reach Ollama on localhost. The skill frames the tradeoff clearly: you trade cloud convenience for privacy, predictable cost, and offline indexing. It fits builders using Claude Code, Cursor, or similar agents who already run dev tooling on their laptop and want agent-assisted search without shipping repository contents to an API. After setup, GrepAI can embed and query code in place, which supports faster navigation and review during implementation without changing your git workflow.604installs3Grepai Search Advancedgrepai-search-advanced is an agent skill for GrepAI power users who need search results in forms agents and scripts can consume without re-parsing plain text. It documents command-line options—result limits, JSON output, TOON output for roughly half the tokens of JSON, and compact mode that omits full snippet bodies while staying compatible with structured formats. Solo and indie builders shipping with Claude Code, Cursor, or Codex can wire semantic repo search into custom tooling, CI helpers, or multi-step coding flows where token budget and predictable schemas matter as much as relevance. Use it when you already run grepai search and want programmatic integration, not when you only need a quick terminal lookup without structure.596installs4Grepai Trace GraphGrepAI Trace Graph is an agent skill that teaches your coding agent to run `grepai trace graph` and interpret recursive dependency trees for a named function or entrypoint. Solo builders use it when a change might ripple through initialization, routing, middleware, or shutdown paths and ad-hoc grep is not enough to see the full picture. The skill covers default and custom depth, how to read nested ASCII graphs, and when to prefer graph mode over single-level callee lists. It is aimed at indie hackers maintaining APIs, CLIs, and monolith backends who need fast, local impact analysis without standing up a separate static-analysis dashboard. Expect CLI-oriented workflows: you name a symbol, tune depth for performance versus completeness, and use node and depth stats to decide whether to widen the search before refactoring.573installs5Grepai Search TipsGrepAI Search Tips teaches solo builders how to talk to semantic code search the way GrepAI expects: full sentences about behavior, boundaries, and data flow instead of grepping for a single camelCase symbol. The skill frames a mindset shift from exact string match to conceptual match, then gives repeatable principles—intent over implementation, richer vocabulary than abbreviations, and tight context such as validating email format versus generic validation. That matters when agents wander large monorepos and return irrelevant hits because the query looked like a function name from another stack. Use it whenever search quality drops, you are onboarding to a foreign codebase, or you want agents to discover error-handling or config-loading patterns without knowing local naming. It does not replace indexing setup, CLI installation, or writing GrepAI plugins; it only improves how questions are phrased before and after you run search.570installs6Grepai Trace Calleesgrepai-trace-callees is an agent skill that teaches your coding agent to use GrepAI’s `trace callees` command to discover every function a target function invokes, with file locations and snippet context. Solo and indie builders shipping services in Go, TypeScript, or polyglot repos install it when they need fast answers to “what does ProcessOrder actually call?” without manually hopping through definitions. Use it when understanding function dependencies, mapping behavior before a refactor, documenting control flow, or preparing a focused code review. The skill centers on one CLI invocation pattern and expected output shape so agents can chain reads and edits confidently. It is a task integration around the grepai CLI, not a planning methodology—invoke it whenever you have a symbol name and a indexed workspace, especially during backend changes and pre-ship review of risky paths.558installs7Grepai Trace CallersGrepAI Trace Callers is an agent skill that teaches your coding agent to use the grepai CLI `trace callers` mode to answer who calls a given function or method. Solo builders shipping services or monorepos use it when they need fast impact analysis before renaming, signature changes, or deleting shared helpers, without manually ripgrepping every pattern variant. The workflow starts with the symbol name, runs the trace command, and interprets ranked results that include file paths, line numbers, and short context snippets. JSON mode fits scripted checks in CI or pre-merge review. The skill fits Claude Code, Cursor, and Codex sessions where the repo is already indexed for GrepAI. It complements semantic search skills by focusing on explicit call edges rather than fuzzy text matches.558installs8Grepai Search BoostingGrepAI Search Boosting is an agent skill that teaches solo builders how to steer semantic code search toward the files that actually ship features. When GrepAI returns similarly relevant chunks from tests, documentation, and third-party vendor trees, naive ranking wastes agent context on noise. This skill walks through path-pattern penalties and bonuses in .grepai/config.yaml so production source rises and boilerplate sinks—even when raw embedding scores look equally strong. It is aimed at developers using GrepAI inside Claude Code, Cursor, or other agent loops who want predictable retrieval before refactors, security reviews, or feature work. The configuration is declarative: enable boosting, list regex-friendly path patterns, and assign factors below 1.0 for deprioritization or above 1.0 for emphasis. You will understand when to penalize /tests/ and _test. filenames, when to soften /docs/, and how to boost core application directories without breaking legitimate test-driven exploration. Pair it with broader GrepAI setup skills once indexing works and you need ranking quality tuned for daily agent sessions.545installs9Grepai Embeddings Ollamagrepai-embeddings-ollama teaches solo builders how to use Ollama as GrepAI’s embedding backend so semantic code search never sends source to a cloud API. The skill covers installing and starting Ollama, pulling an embedding model such as nomic-embed-text, and mapping those choices into `.grepai/config.yaml` with provider, model, and endpoint fields—including remote servers when embeddings run on another machine on your network. It explains why local embeddings help privacy-conscious indies and agents working offline, and points to performance and connection troubleshooting when the agent cannot reach the Ollama API. This is the embedder side of the GrepAI stack; chunking policy is configured separately. Ideal for Claude Code, Cursor, or Codex users who already use or plan to use GrepAI and want a free, self-controlled embedding path instead of hosted vector APIs.531installs10Grepai Mcp Toolsgrepai-mcp-tools is a read-only reference skill for solo builders and small teams who connect GrepAI to Claude Code, Cursor, Codex, or other MCP-capable agents. It explains when to start the MCP server with grepai mcp-serve, which tools exist, and how to shape requests—starting with grepai_search for embedding-based code discovery with optional compact output and toon formatting. Install it when you are wiring semantic search into an agent loop, comparing parameter options, or troubleshooting tool responses rather than re-reading scattered docs. The skill does not execute searches itself; it encodes procedural knowledge so your agent picks the right tool names, limits, and formats during backend and agent-tooling work. It matters on Prism because MCP integration skills need a citable, journey-placed entry distinct from raw server repos or popularity metrics.505installs11Grepai Chunkinggrepai-chunking is an agent skill for solo builders who use GrepAI to search code semantically and need control over how source files are segmented before embedding. Large files are split into token-sized chunks so each segment can be embedded and retrieved independently; getting size and overlap wrong either blurs matches or fragments meaning across hits. The skill walks through default-style settings such as 512 tokens per chunk with 50 tokens of overlap, when to adjust for chatty versus minimal code, and how to debug confusing search results by reasoning about the index. It is for indie developers self-hosting or locally running GrepAI as part of Claude Code, Cursor, or Codex workflows—not for choosing an embedder or running Ollama, which is a separate configuration path. Use it while standing up or tuning GrepAI in a repository where search quality matters for day-to-day agent navigation.497installs12Grepai Languagesgrepai-languages is a reference skill for solo builders running GrepAI alongside Claude Code, Cursor, or Codex. It answers whether your stack gets semantic indexing only or full call-graph tracing—a decision that affects how reliably an agent can follow definitions and callers across a repo. The skill documents twelve fully supported languages with extensions, plus a separate index-only tier where trace is unavailable. Use it when onboarding a new codebase, tuning language-specific settings, or debugging why traces fail on certain files. It does not install or configure GrepAI; it is the compatibility sheet you read before indexing. For indie teams shipping polyglot services—Go APIs with TypeScript frontends, Python workers, or Rust CLIs—this skill prevents wasted setup time on languages that will never produce traces and sets expectations for agent-assisted refactors.494installs13Grepai InitGrepAI Init is the first-run setup skill for yoanbernabeu's GrepAI toolchain: it walks solo builders through `grepai init` inside a project root so semantic search and symbol tracing can run locally. You use it when adopting GrepAI for the first time, when you need to understand what files land under `.grepai/`, or when you must tune embedder provider, chunking, or ignore rules before starting `grepai watch`. The readme spells out the generated config.yaml structure—Ollama embeddings, gob stores, debounced file watching, and multi-language trace modes—so agents and humans share the same baseline. For indie agents and CLI-backed dev workflows, this skill reduces guesswork about defaults and troubleshooting failed initialization, positioning GrepAI as repo-local agent tooling rather than a hosted search service.493installs14Grepai Watch Daemongrepai-watch-daemon is an agent skill for configuring and operating GrepAI’s watch command—the process that keeps a local semantic index of your repository current. Solo builders who rely on Claude Code, Cursor, or Codex for navigation and refactors install it when they need an initial bulk index or ongoing file monitoring without manual re-runs. The daemon scans source files, splits them into roughly 512-token chunks, generates embeddings through your configured provider (Ollama, OpenAI, LM Studio, etc.), stores vectors in your chosen backend, and reacts to filesystem changes so search results stay aligned with the tree on disk. You can run interactively to watch progress, detach with --background for day-long sessions, and verify health with --status. It pairs naturally with grepai-config-reference when embedder or storage settings need tuning. It is not a hosted search product; you operate the CLI and local services yourself.493installs15Grepai Troubleshootinggrepai-troubleshooting is a focused agent skill for solo developers who rely on GrepAI for semantic search over a codebase and need fast recovery when the tool stops behaving. It tells you exactly when to reach for it—unexpected behavior, weak search hits, a stale index, or config and connection errors—and opens with a compact diagnostic routine you can run in the terminal before diving into issue-specific playbooks. Each common failure is spelled out as symptom, likely cause, and concrete bash or YAML checks, including initializing the project, starting grepai watch to build the index, validating Ollama at localhost:11434, and confirming embedder endpoint settings. The skill does not replace reading upstream GrepAI docs; it compresses operational knowledge into agent-invokable steps so your coding assistant can walk you through fixes without improvising. Intermediate familiarity with local LLM embedders and project-local CLI tools is assumed.491installs16Grepai Config Referencegrepai-config-reference is a complete agent skill that maps every knob in GrepAI’s project-local config.yaml—embedder provider and model, API endpoints, vector dimensions, storage backends, and watch-related settings—so you do not guess from trial and error. Indie builders shipping with agentic IDEs reach for it when first scaffolding .grepai, when swapping Ollama for OpenAI embeddings, or when a daemon fails because dimensions or URLs disagree with the provider. The skill mirrors the authoritative schema with inline comments on common models (nomic-embed-text, bge-m3, text-embedding-3 variants) and default ports for local inference servers. It is reference-grade documentation meant to be invoked alongside grepai-watch-daemon once you need to change how chunks are produced or stored. It does not run commands itself; it explains what valid YAML should contain and how options interact for your use case.490installs17Grepai Workspacesgrepai-workspaces teaches solo builders and small teams how to configure GrepAI workspaces for monorepos, sibling services, and large multi-package codebases. Workspaces let you group related directories, index them together with grepai watch --workspace, and search across everything at once or narrow to a single member project while reusing shared settings. The skill walks through create, add, and list flows with concrete CLI examples and expected terminal output so agents do not invent paths or skip indexing steps. Use it when microservices, frontend plus backend folders, or shared libraries should appear in one semantic search surface for Claude Code, Cursor, or similar agents. It stays in the Build phase as agent-tooling: you are wiring discovery infrastructure, not shipping end-user features. After setup, developers run watch against the workspace name to keep all attached projects indexed for later grepai queries.482installs18Grepai Ignore Patternsgrepai-ignore-patterns is an agent skill for solo builders who run GrepAI in local or team repos and need search results that reflect real product code—not noise from tests, builds, or vendored trees. It walks through how GrepAI merges two ignore sources: patterns you declare under `ignore:` in `.grepai/config.yaml`, and rules already in `.gitignore`, so you do not duplicate git policy unless you want stricter indexing. The skill explains pattern syntax for directories, single-level wildcards, path substrings, and recursive globs, with concrete examples such as `node_modules`, `dist/`, `*.min.js`, and `**/test/**`. Use it when test files clutter semantic grep, generated or swagger output should stay out of the index, or you want a smaller, faster index on a laptop-first workflow. It is configuration-only: no servers to deploy, just YAML edits aligned with how you already ignore files in git.478installs19Grepai Mcp ClaudeGrepAI MCP Integration with Claude Code is a focused setup skill for solo builders who want semantic code search inside Claude Code rather than keyword-only context. It explains Model Context Protocol wiring so GrepAI’s MCP server supplies semantic search, call graph analysis, and index monitoring as tools the assistant can invoke. The quick path is a single CLI add command; the manual path documents mcp.json location per OS and optional working-directory scoping. You are expected to install GrepAI, run an embedding backend such as Ollama, index the repo with grepai watch, and only then attach Claude. Ideal during Build when you are deep in a codebase and need the agent to find symbols and flows by meaning. It does not replace indexing or embedding ops—it assumes those are already running. After setup, Claude Code sessions gain repo-aware discovery that scales better than pasting file trees into chat.474installs20Grepai Storage Gobgrepai-storage-gob teaches solo developers how to configure GrepAI’s GOB (Go binary) storage backend—the default path for local semantic search over a repository. It fits single-developer projects and small to medium codebases where you want vector embeddings, file metadata, and chunk data in one portable file without standing up Postgres, Redis, or cloud vector stores. The skill explains when GOB is appropriate versus shared or scaled backends, shows explicit and minimal YAML configuration under .grepai/config.yaml, and clarifies limitations such as no concurrent multi-user access and memory-loaded queries. Use it while bootstrapping agent-assisted navigation of your own codebase on one machine. Graduate to other GrepAI storage skills when you need team-wide or multi-machine indexes.468installs21Grepai Quickstartgrepai-quickstart walks solo builders through installing GrepAI, pulling local embeddings with Ollama, initializing a project, and running the first semantic code search—aimed at anyone new to GrepAI or setting it up on a fresh repo. You need terminal access and an existing code project to index. The skill sequences platform-specific installs, starts the embedding stack, creates configuration under .grepai, kicks off indexing with sensible ignore patterns, and validates the toolchain before you query. It is narrowly scoped onboarding: not deep tuning of providers, CI indexing, or team-wide policies. For indie builders using agentic IDEs, it reduces time spent grepping blindly and helps agents retrieve symbols and files by meaning. After this quickstart, you typically iterate on config and search habits as the codebase grows.464installs22Grepai Installationgrepai-installation walks a solo builder through every supported way to put GrepAI on disk: Homebrew on macOS, a shell installer on Linux and macOS, PowerShell on Windows, or compiling from source when you need the latest commit. The skill states platform prerequisites—terminal on Unix-like systems, PowerShell on Windows, and Go when building—and ends each path with a explicit version check so you know the binary is on PATH. It fits early Build work when you are standardizing agent tooling across machines or recovering from a broken manual download. Choosing a method trades convenience (brew or scripted install) against control (source build). The doc is procedural rather than open-ended chat, which reduces wrong-architecture binaries and half-installed copies that break agent-driven grep workflows later.457installs23Grepai Mcp Cursorgrepai-mcp-cursor teaches agents how to connect GrepAI to Cursor using the Model Context Protocol. Solo builders who live in Cursor gain semantic codebase search, dependency-aware navigation, and index-backed answers instead of brittle text grep alone. Setup is deliberate: install GrepAI, run embeddings (commonly Ollama), index with grepai watch, then add mcpServers.grepai to project or global mcp.json and restart the IDE. Verification is a natural-language search prompt in chat. The skill is integration documentation packaged as procedural knowledge—intermediate complexity because MCP and local inference stacks break in subtle ways. It sits firmly in Build integrations for agent-heavy products; it does not replace shipping tests or docs but shortens loop time when the agent must find auth, billing, or glue code across a large monorepo.449installs24Grepai Embeddings LmstudioGrepAI Embeddings with LM Studio is a configuration skill for solo builders who want semantic code search through GrepAI without sending embeddings to a cloud API. It walks you through downloading LM Studio, fetching an embedding model from the Search tab, starting the Local Server, and aligning GrepAI settings with that OpenAI-compatible endpoint. Use it when you already prefer LM Studio’s GUI for model management, need to swap embedding models quickly, or must keep repository indexing on-machine for privacy or air-gapped environments. The skill assumes you are in the build phase wiring agent retrieval infrastructure rather than tuning production observability. It pairs naturally with other GrepAI provider skills in the same repo once the server is live. Complexity is beginner-to-intermediate: no custom training, but you must run a desktop app and understand base URL and model name fields in config files.1installs25Grepai Embeddings OpenaiGrepAI Embeddings OpenAI is a focused integration skill for solo builders and small teams who use GrepAI to semantically search and navigate codebases with agents. It walks you through choosing OpenAI as the embedding provider when you prioritize state-of-the-art vector quality and fast indexing over keeping every chunk on-device. The skill spells out the tradeoffs table—privacy because code is sent to OpenAI, per-token cost, and required connectivity—so indie developers can decide consciously versus local embedders. Configuration examples cover basic YAML, environment-variable API keys, and parallel request tuning for large repos. It is squarely build-phase integrations work: you already decided on GrepAI and now need a production-ready embedder block your Claude Code or Cursor sessions can rely on during agent-tooling workflows. Not a general OpenAI tutorial; it assumes you will export OPENAI_API_KEY and enable billing at platform.openai.com before indexing.1installs26Grepai Storage PostgresGrepAI Storage Postgres is an agent skill for solo builders and small teams who outgrow local GrepAI indexes and want PostgreSQL with pgvector as the durable, shared embedding store. It walks through prerequisites—Postgres 14+, a user who can create tables, and network reachability—and contrasts team sharing, concurrency, and persistence against ephemeral local backends. You get copy-paste Docker setup for development plus guidance for attaching pgvector to an existing server, including package and source install notes. Invoke it while integrating GrepAI into your agent workflow during Build, or when you Operate shared dev infrastructure that must survive restarts. The skill is intermediate: you should be comfortable with connection strings, extensions, and basic DBA permissions. Prism tags it under Databases with AI agent tooling because semantic search over code is a force multiplier for indie shipping velocity.1installs27Grepai Storage Qdrantgrepai-storage-qdrant is an agent skill that walks solo builders through configuring Qdrant as the GrepAI storage backend so semantic code search stays fast as repositories grow. It explains when Qdrant beats lighter backends—huge monorepos, existing Qdrant ops, or need for rich vector filters—and covers Docker-first setup with persistent volumes and port mapping. The guidance maps benefits like scalability to millions of vectors against operational cost, so you can decide before committing infra. For indie developers shipping Claude Code or Cursor workflows that grep the codebase by meaning, this skill turns GrepAI from a local experiment into a production-grade search layer without guessing connection strings or deployment shape.1installs