Metadata-Version: 2.5
Name: chatterchat
Version: 0.1.0
Summary: ChatterChat - an autonomous terminal coding agent powered by Claude, with app connections (Slack, Notion, GitHub, and more)
Project-URL: Homepage, https://github.com/casperwhite-commits/chatterchat
Project-URL: Issues, https://github.com/casperwhite-commits/chatterchat/issues
Author-email: Casper White <casper.white@alpha.school>
License: MIT
License-File: LICENSE
Keywords: agent,ai,anthropic,chatbot,claude,cli,coding-agent,mcp
Classifier: Development Status :: 4 - Beta
Classifier: Environment :: Console
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Classifier: Topic :: Software Development :: Code Generators
Classifier: Topic :: Utilities
Requires-Python: >=3.10
Requires-Dist: anthropic<2,>=1.1.0
Requires-Dist: prompt-toolkit>=3.0.43
Requires-Dist: rich>=13.7
Description-Content-Type: text/markdown

# ChatterChat

An autonomous software engineer in your terminal, powered by the Claude API.

ChatterChat reads and writes real files, runs real commands, searches the web, and can reach into
the apps you already use — Slack, Notion, GitHub, Linear, Sentry, Stripe and more — over the
Model Context Protocol. It runs on **Claude Opus 5** by default, or **Claude Fable 5** for long
autonomous runs.

```
pip install chatterchat
```

or with Homebrew:

```
brew install casper-white/tap/chatterchat
```

## Setup

ChatterChat uses your own Claude Platform access. Either export an API key:

```bash
export ANTHROPIC_API_KEY=sk-ant-...
```

…or sign in with the Anthropic CLI, which stores a profile the SDK picks up automatically:

```bash
ant auth login
```

## Use it

```bash
chatterchat                              # interactive session in the current directory
chatterchat "add tests for auth.py"      # run one task and exit
chatterchat -p "why is CI failing?" -y   # non-interactive, auto-approve tool calls
chatterchat --continue                   # resume the previous conversation
chatterchat -m fable -e max "port this service to async"
```

Inside a session:

```
/help                   show all commands
/model fable            switch model
/effort xhigh           low, medium, high, xhigh, max
/thinking off           hide Claude's reasoning
/tools                  what this session can do
/apps                   connectable apps and their status
/connect notion         connect an app
/cost                   token usage and estimated spend
/clear                  start fresh
```

## What it can do

**On your machine** — `read_file`, `write_file`, `edit_file`, `list_dir`, `glob`, `grep`,
`run_command`. Writes and shell commands ask for approval the first time; answer `a` to stop being
asked for that tool, or start with `-y` to approve everything up front.

**On the web** — Claude's server-side `web_search` and `web_fetch`, so answers about current
library versions and APIs come from the live web rather than memory.

**In your apps** — any remote MCP server. Built-in registry:

| | | |
|---|---|---|
| slack | notion | github |
| linear | asana | atlassian |
| sentry | vercel | cloudflare |
| netlify | supabase | neon |
| stripe | paypal | square |
| figma | canva | webflow |
| sanity | airtable | box |
| intercom | hubspot | monday |
| clickup | zapier | huggingface |
| context7 | deepwiki | exa |

```bash
chatterchat apps                  # list them with connection status
chatterchat connect github        # prompts for a token
chatterchat connect slack --token-env SLACK_MCP_TOKEN
chatterchat connect mine --url https://mcp.example.com/mcp --token abc123
```

Most servers use OAuth. To get an access token for one, run
`npx @modelcontextprotocol/inspector`, point it at the server URL, complete the Quick OAuth Flow
and copy `access_token`. GitHub also accepts a personal access token. Servers that need no token
at all (`huggingface`, `context7`, `deepwiki`, `exa`, `cloudflare-docs`) connect immediately.

## Configuration

Settings live in `~/.chatterchat/config.json`; tokens live in `~/.chatterchat/credentials.json`
(mode 600), or are read from an environment variable if you connected with `--token-env`.

```bash
chatterchat config                          # show everything
chatterchat config --set model=fable
chatterchat config --set effort=xhigh
chatterchat config --set auto_approve=true
chatterchat config --set max_tokens=32000
chatterchat models
```

| Setting | Default | Meaning |
|---|---|---|
| `model` | `claude-opus-5` | `opus` or `fable`, or any exact model ID |
| `effort` | `high` | reasoning effort: `low` → `max` |
| `max_tokens` | `64000` | output cap per turn |
| `show_thinking` | `true` | stream a summary of Claude's reasoning |
| `web` | `true` | web search and fetch |
| `auto_approve` | `false` | never ask before writing files or running commands |
| `compaction` | `true` | let the API summarise old context in long sessions |
| `max_tool_output_chars` | `20000` | truncation limit for tool results |

## Notes

- Conversations are saved to `~/.chatterchat/sessions/` and `--continue` resumes the latest one.
- Long sessions use server-side compaction, so they keep going past the context window.
- Ctrl-C interrupts the current turn without losing the conversation; Ctrl-D exits.
- Requests enable server-side refusal fallbacks, so a policy decline is retried on a fallback
  model inside the same call rather than failing the turn.

## License

MIT
