invoking-github

# Invoking GitHub

Programmatically interact with GitHub repositories from Claude.ai chat: read files, commit changes, create PRs, and persist state across sessions.

## When to Use This Skill

**Primary use cases:**
- Commit code/documentation from Claude.ai chat (mobile/web)
- Auto-persist DEVLOG.md for iterating skill
- Manage state across sessions via GitHub branches
- Read and update repository files programmatically
- Create pull requests from chat interface

**Trigger patterns:**
- "Commit this to the repository"
- "Update the README on GitHub"
- "Save this to a feature branch"
- "Create a PR with these changes"
- "Persist DEVLOG to GitHub"
- "Read the config file from my repo"

**Not needed for:**
- Claude Code environments (use native git commands)
- Read-only repository access (use GitHub UI or API directly)

## Quick Start

### Prerequisites

Create a GitHub Personal Access Token and add to Project Knowledge:

1. Go to https://github.com/settings/tokens
2. Create new token (classic or fine-grained)
3. Required scopes: `repo` (or `public_repo` for public repos only)
4. In Claude.ai, add to Project Knowledge:
   - Title: `GITHUB_API_KEY`
   - Content: Your token (e.g., `ghp_abc123...`)

### Single File Commit

```python
from invoking_github import commit_file

result = commit_file(
    repo="username/repo-name",
    path="README.md",
    content="# Updated README\n\nNew content here...",
    branch="main",
    message="Update README with new instructions"
)

print(f"Committed: {result['commit_sha']}")
```

### Read File

```python
from invoking_github import read_file

content = read_file(
    repo="username/repo-name",
    path="config.json",
    branch="main"
)

print(content)
```

### Batch Commit (Multiple Files)

```python
from invoking_github import commit_files

files = [
    {"path": "src/main.py", "content": "# Python code..."},
    {"path": "README.md", "content": "# Updated docs..."},
    {"path": "tests/test.py", "content": "# Tests..."}
]

result = commit_files(
    repo="username/repo-name",
    files=files,
    branch="feature-branch",
    message="Add new feature implementation",
    create_branch_from="main"  # Create branch if it doesn't exist
)

print(f"Committed {len(files)} files: {result['commit_sha']}")
```

### Create Pull Request

```python
from invoking_github import create_pull_request

pr = create_pull_request(
    repo="username/repo-name",
    head="feature-branch",
    base="main",
    title="Add new feature",
    body="## Changes\n- Implemented feature X\n- Updated docs\n- Added tests"
)

print(f"PR created: {pr['html_url']}")
```

## Core Functions

### `read_file()`

Read a file from repository:

```python
read_file(
    repo: str,           # "owner/name"
    path: str,           # "path/to/file.py"
    branch: str = "main" # Branch name
) -> str
```

**Returns**: File content as string
**Raises**: `GitHubAPIError` if file not found or access denied

### `commit_file()`

Commit a single file (create or update):

```python
commit_file(
    repo: str,                      # "owner/name"
    path: str,                      # "path/to/file.py"
    content: str,                   # New file content
    branch: str,                    # Target branch
    message: str,                   # Commit message
    create_branch_from: str = None  # Create branch from this if doesn't exist
) -> dict
```

**Returns**: Dict with `commit_sha`, `branch`, `file_path`
**Raises**: `GitHubAPIError` on conflicts or auth failures

### `commit_files()`

Commit multiple files in a single commit:

```python
commit_files(
    repo: str,                      # "owner/name"
    files: list[dict],              # [{"path": "...", "content": "..."}]
    branch: str,                    # Target branch
    message: str,                   # Commit message
    create_branch_from: str = None  # Create branch from this if doesn't exist
) -> dict
```

**Returns**: Dict with `commit_sha`, `branch`, `files_committed`
**Raises**: `GitHubAPIError` on failures

**Note**: Uses Git Trees API for efficiency - atomic commit of all files.

### `create_pull_request()`

Create a pull request:

```python
create_pull_request(
    repo: str,      # "owner/name"
    head: str,      # Source branch (your changes)
    base: str,      # Target branch (where to merge)
    title: str,     # PR title
    body: str = ""  # PR description (supports markdown)
) -> dict
```

**Returns**: Dict with `number`, `html_url`, `state`
**Raises**: `GitHubAPIError` if branches invalid or PR exists

## Credential Configuration

This skill requires a GitHub Personal Access Token. Two configuration methods:

### Method 1: Project Knowledge (Recommended)

Best for Claude.ai chat users (mobile/web):

1. Create token at https://github.com/settings/tokens
2. In Claude.ai Project settings → Add to Project Knowledge
3. Create document titled `GITHUB_API_KEY`
4. Paste your token as content

**Permissions required**:
- Classic token: `repo` scope
- Fine-grained token: Repository permissions → Contents (read/write) and Pull requests (read/write)

### Method 2: API Credentials Skill (Fallback)

Alternatively, use combined credentials file:

1. Create `API_CREDENTIALS.json` in project knowledge
2. Add: `{"github_api_key": "ghp_your-token-here"}`

## Integration with Iterating Skill

Auto-persist DEVLOG.md to GitHub for cross-session continuity:

```python
# In your DEVLOG update function
from invoking_github import commit_file
from pathlib import Path

def update_devlog_with_sync(data, repo="user/project", branch="devlog"):
    """Update DEVLOG.md locally and sync to GitHub"""

    # Update local DEVLOG
    update_devlog(data)  # Your existing function

    # Auto-sync to GitHub
    try:
        devlog_content = Path("DEVLOG.md").read_text()

        result = commit_file(
            repo=repo,
            path="DEVLOG.md",
            content=devlog_content,
            branch=branch,
            message=f"DEVLOG: {data['title']}",