qodo-get-rules

Files (6)

• SKILL.md
• output-format.md · references/
• query-generation.md · references/
• repository-scope.md · references/
• search-endpoint.md · references/
• scope-parse.sh · tests/

SKILL.md (first lines)

# Get Qodo Rules Skill

## Description

Fetches the most relevant Qodo coding rules for the current coding task. Generates a focused semantic search query from the coding assignment and calls `POST /rules/search` to retrieve only the rules most relevant to the task at hand, ranked by relevance.

**Skip** if "Qodo Rules Loaded" already appears in conversation context.

---

## Workflow

### Step 1: Check if Rules Already Loaded

If rules are already loaded (look for "Qodo Rules Loaded" in recent messages), skip to Step 6.

### Step 2: Verify Working in a Git Repository and Detect Repository Scope

Check that the current directory is inside a git repository. If not, inform the user that a git repository is required and exit gracefully.

After confirming a git repository exists, extract the repository scope to pass to the search API. Scope narrows results to rules relevant to this specific repository.

Use only POSIX shell here — no `sed`, no `grep`. Parameter expansion and `case` behave
identically on macOS (BSD) and Linux (GNU); `sed` does not (see
[repository scope detection](references/repository-scope.md#portability)).

```bash
# 1. Confirm inside a git repository
git rev-parse --is-inside-work-tree

# 2. Get the remote URL
REMOTE_URL=$(git remote get-url origin 2>/dev/null)

# 3. Parse the URL into a scope path
SCOPE=""
if [ -n "$REMOTE_URL" ]; then
  # Trailing slash first, then .git — the other order leaves ".git" on
  # "https://host/org/repo.git/", because %.git only strips an exact suffix.
  REPO_PATH="${REMOTE_URL%/}"
  REPO_PATH="${REPO_PATH%.git}"

  case "$REPO_PATH" in
    # local clone — no rules are scoped to a filesystem path
    file://*)
      REPO_PATH=""
      ;;
    # scheme://[user[:pass]@]host/path — https, http, ssh, git
    *://*)
      REPO_PATH="${REPO_PATH#*://}"   # drop scheme
      REPO_PATH="${REPO_PATH#*/}"     # drop [userinfo@]host
      ;;
    # scp-like: [user@]host:path — git@github.com:org/repo
    *:*/*)
      REPO_PATH="${REPO_PATH#*:}"
      ;;
    *)
      REPO_PATH=""
      ;;
  esac

  # Require at least org/repo; reject absolute and Windows paths
  case "$REPO_PATH" in
    /*|*\\*) REPO_PATH="" ;;
    */*)     ;;
    *)       REPO_PATH="" ;;
  esac

  if [ -n "$REPO_PATH" ]; then
    # 4. Detect module-level scope: is cwd inside modules/<name>/ ?
    #    --show-prefix is the cwd relative to the repo root, "" at the root,
    #    with a trailing slash. No realpath, no python3.
    PREFIX=$(git rev-parse --show-prefix)
    MODULE=""
    case "$PREFIX" in
      modules/*/*)
        MODULE="${PREFIX#modules/}"
        MODULE="${MODULE%%/*}"
        ;;
    esac

    if [ -n "$MODULE" ]; then
      SCOPE="/${REPO_PATH}/modules/${MODULE}/"
    else
      SCOPE="/${REPO_PATH}/"
    fi
  fi
fi
# If SCOPE is empty (no remote, unparseable URL), proceed without scope — graceful degradation
```

Pass `SCOPE` in the search request body if set (see Step 5). If `SCOPE` is empty or unset, omit the `scopes` field entirely and proceed — org-wide search still returns relevant results.

See [repository scope detection](references/repository-scope.md) for URL format details and degradation behavior.

### Step 3: Verify Qodo Configuration

Check that the required Qodo configuration is present. The default location is `~/.qodo/config.json`.

- **API key**: Read from `~/.qodo/config.json` (`API_KEY` field). Environment variable `QODO_API_KEY` takes precedence. If not found, inform the user that an API key is required and provide setup instructions, then exit gracefully.
- **Environment name**: Read from `~/.qodo/config.json` (`ENVIRONMENT_NAME` field), with `QODO_ENVIRONMENT_NAME` environment variable taking precedence. If not found or empty, use production.
- **API URL override** (optional): Read from `~/.qodo/config.json` (`QODO_API_URL` field). If present, use `{QODO_API_URL}/rules/v1` as the API base URL. If absent, the `ENVIRONMENT_NAME`-based URL is used.
- **Request ID**: Generate a UUID (e.g. `python3 -c "import uuid; print(uuid.uuid4())"`) to use as `request-id` for all API calls in this invocation.

Example config parsing:
```bash
API_KEY=$(python3 -c "import json,os; c=json.load(open(os.path.expanduser('~/.qodo/config.json'))); print(c['API_KEY'])")
ENV_NAME=$(python3 -c "import json,os; c=json.load(open(os.path.expanduser('~/.qodo/config.json'))); print(c.get('ENVIRONMENT_NAME',''))")
QODO_API_URL=$(python3 -c "import json,os; c=json.load(open(os.path.expanduser('~/.qodo/config.json'))); print(c.get('QODO_API_URL',''))")
REQUEST_ID=$(uuidgen || python3 -c "import uuid; print(uuid.uuid4())")
# Determine API_URL: QODO_API_URL takes precedence over ENVIRONMENT_NAME
if [ -n "$QODO_API_URL" ]; then
  API_URL="${QODO_API_URL}/rules/v1"
elif [ -z "$ENV_NAME" ]; then
  API_URL="https://qodo-platform.qodo.ai/rules/v1"
else
  API_URL="https://qodo-platform.${ENV_NAME}.qodo.ai/rules/v1"
fi
```

From Atul-Chahar/Foreman, MIT.

More from Atul-Chahar/Foreman