agenthood 0.1.0__tar.gz

agenthood-0.1.0/.gitignore

@@ -0,0 +1,12 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.pytest_cache/
+.agents/
+*.db
+*.log
+
+# secrets -- never commit
+mcp_config.json

agenthood-0.1.0/AGENTS.md

@@ -0,0 +1,74 @@
+# AgentHood -- Trading Agent Rules
+
+## Identity
+You are AgentHood, a disciplined Robinhood trading assistant. You have deep knowledge
+of equities, options, technical analysis, and portfolio risk management.
+
+## Safety rules (non-negotiable)
+1. **Never place an order without a prior review call.** Always run review_equity_order
+   or review_option_order first and show the result to the user.
+2. **Never place an order without explicit user confirmation.** Even if the user says
+   "buy X", confirm: "I'm about to place a [details]. Confirm? (yes/no)".
+3. **Flag high-risk plays clearly.** Options, leveraged ETFs, penny stocks, and
+   earnings plays must include a risk warning before any review/order call.
+4. **Prefer limit orders.** Only use market orders when user explicitly requests it.
+5. **Respect dry_run mode.** If the system says dry_run is active, explain this to
+   the user and offer to simulate instead.
+
+## Architecture
+
+### Dispatch pipeline (order matters)
+`_direct_dispatch` in agent.py processes user input in this order:
+1. **Watch/alert detection** -- regex match, returns `__watch__` sentinel
+2. **Meta questions** -- "what can you do?", "hello", etc. Returns canned string (no LLM)
+3. **Stock query detection** -- natural language ("how's PYPL doing?") or bare tickers ("pypl, google, meta"). Returns `__analyze__` sentinel
+4. **Fallthrough** -- returns None, goes to LLM via `agent.infer()`
+
+### TUI command dispatch (handle_meta in tui.py)
+Dot commands are handled BEFORE the agent's dispatch pipeline:
+- `.analyze TICKER [, TICKER2]` -- returns list of tickers
+- `.portfolio` / `.port` / `.p` -- returns `__portfolio__` sentinel
+- `.positions` / `.pos` -- returns `__positions__` sentinel
+- `.quote TICKER` / `.q TICKER` -- returns `(__quote__, TICKER)` tuple
+- `.model`, `.cost`, `.memory`, `.tools`, `.verbose` -- handled inline, returns True
+
+### Provider config
+- **Chat model**: `model` field in agenthood.json (OpenRouter free tier)
+- **Analyze model**: separate `analyze_model`, `analyze_api_base`, `analyze_api_key` fields
+- Groq is the fast path for `.analyze` (~1s vs ~14s on free tier)
+- The status bar shows both: `model gemma-4-26b | analyze llama-3.3-70b (groq) LIVE`
+
+### MCP tool calls
+- Portfolio and positions require `account_number` param (fetch via `get_accounts` first)
+- Prefer the agentic account (`agentic_allowed: true`), then default, then first
+- Accounts response shape: `data.accounts[]` (NOT `data.results[]`)
+- Quotes use `symbols: [TICKER]` param
+- Technical indicators require `type`, `interval`, `start_time` params
+
+### Ticker resolution
+- `_NAME_TO_TICKER` in tui.py and `_NAMES` in agent.py map company names to symbols
+- Bare ticker lists (e.g. "pypl, google, meta") are detected when ALL words are known names/tickers
+- Unknown tickers are uppercase 1-5 letter words; stopwords are filtered out
+- Fallback: Robinhood search MCP tool for unrecognized company names
+
+## Reasoning style
+- Think step-by-step before making tool calls.
+- State assumptions (e.g. "I'll assume you want a 0DTE call on AAPL").
+- After gathering data, provide a brief analysis before recommending action.
+- Prefer fewer, well-targeted tool calls over many redundant ones.
+- Include BUY, SELL, or HOLD verdict in every analysis.
+
+## Output style
+- Use markdown tables for quotes, positions, and order previews.
+- Use bullet points for analysis.
+- No emojis. No em-dashes.
+- All analysis output renders through Rich Markdown panels.
+- Multi-ticker analysis shows separate panels per ticker.
+- Keep streaming progress clean: show step labels, not character counts.
+
+## Testing rules
+- Run `python3.14 -m pytest tests/test_tui.py` for TUI changes.
+- Test dispatch detection with inline scripts before declaring it works.
+- Clear `__pycache__` after edits: the CLI uses editable install.
+- The full test suite (`tests/`) has 200+ tests; some mock agentu and may hang.
+  Run specific test files instead of the full suite for fast feedback.

agenthood-0.1.0/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: agenthood
+Version: 0.1.0
+Summary: Robinhood trading agent powered by agentu + Robinhood MCP
+License: MIT
+Requires-Python: >=3.11
+Requires-Dist: agentu>=2.4.0
+Requires-Dist: rich>=13.0
+Description-Content-Type: text/markdown
+
+# agenthood
+
+Robinhood trading agent -- talk to your portfolio in plain English.
+
+```bash
+pip install agenthood
+agenthood setup
+```
+
+`setup` walks you through Robinhood OAuth and LLM selection. Config saves to `~/.agenthood/config.json`. After that, just run `agenthood`.
+
+## Quick start
+
+```python
+import asyncio
+from agenthood import AgentHood
+
+async def main():
+    async with AgentHood() as agent:
+        print(await agent.chat("What are my open positions?"))
+        print(await agent.chat("Get me a quote for NVDA and AAPL"))
+        print(await agent.chat("Review a limit buy of 5 AAPL at $210"))
+
+asyncio.run(main())
+```
+
+`chat()` sends a prompt and returns the response. The agent picks the right Robinhood tools, fetches data, and explains what it found.
+
+## CLI
+
+```bash
+agenthood                          # interactive REPL
+agenthood "What is TSLA at?"       # one-shot
+agenthood --live                   # real orders
+agenthood --stream                 # token-by-token
+```
+
+Inside the REPL, dot commands skip the LLM entirely:
+
+```
+.portfolio          show portfolio (alias: .p)
+.positions          show open positions (alias: .pos)
+.quote NVDA         quick price quote (alias: .q NVDA)
+.analyze PYPL       multi-source analysis
+.help               all commands
+```
+
+## Direct tool calls
+
+```python
+import asyncio, json
+from agenthood import AgentHood
+
+async def main():
+    async with AgentHood() as agent:
+        result = json.loads(await agent.call_tool("robinhood_get_equity_quotes", {
+            "symbols": ["NVDA", "AAPL"]
+        }))
+        print(result["data"]["results"])
+
+asyncio.run(main())
+```
+
+`call_tool(name, params)` bypasses the LLM and calls a Robinhood MCP tool directly. 53 tools available.
+
+## Safety
+
+```python
+from agenthood import AgentHood, AgentHoodConfig
+
+cfg = AgentHoodConfig(
+    dry_run=False,           # default True -- blocks place_* tools
+    max_order_value=1000,    # hard cap per order in USD
+    allowed_symbols=["AAPL", "NVDA", "TSLA"],
+)
+```
+
+Safety hooks run at the tool-call level. The LLM cannot talk its way around them.
+
+## Config
+
+All config lives in `~/.agenthood/`:
+
+```
+~/.agenthood/
+  config.json       # model, api keys, safety settings
+  history           # readline history
+  sessions/         # saved chat sessions
+  watches.json      # price alerts
+  triggered.db      # alert history
+  logs/             # daemon logs
+  daemon.pid        # background process
+```
+
+```json
+{
+  "model": "meta-llama/llama-3.3-70b-instruct:free",
+  "api_base": "https://openrouter.ai/api/v1",
+  "api_key": "sk-or-...",
+  "analyze_model": "llama-3.3-70b-versatile",
+  "analyze_api_base": "https://api.groq.com/openai/v1",
+  "analyze_api_key": "gsk_...",
+  "dry_run": false,
+  "max_order_value": 1000,
+  "max_turns": 20
+}
+```
+
+Robinhood token is auto-discovered from `~/.mcp-auth/`. No manual setup needed after the first `npx mcp-remote` auth flow.
+
+## Multi-provider routing
+
+```json
+{
+  "model": "google/gemma-4-26b-a4b-it:free",
+  "model_fallbacks": ["nvidia/nemotron-3-super-120b-a12b:free"],
+  "analyze_model": "llama-3.3-70b-versatile",
+  "analyze_api_base": "https://api.groq.com/openai/v1"
+}
+```
+
+`model` handles chat. `analyze_model` handles `.analyze` -- Groq runs analysis in ~1s vs ~14s on free tier. Dot commands use no model at all.
+
+## Autonomous scanning
+
+```python
+cfg = AgentHoodConfig(scan_interval=300)  # every 5 minutes
+```
+
+The agent wakes up on a schedule, checks for positions down >5%, scans for RSI breakouts, and records findings.
+
+## License
+
+MIT [Hemanth.HM](https://h3manth.com)

agenthood-0.1.0/README.md

@@ -0,0 +1,134 @@
+# agenthood
+
+Robinhood trading agent -- talk to your portfolio in plain English.
+
+```bash
+pip install agenthood
+agenthood setup
+```
+
+`setup` walks you through Robinhood OAuth and LLM selection. Config saves to `~/.agenthood/config.json`. After that, just run `agenthood`.
+
+## Quick start
+
+```python
+import asyncio
+from agenthood import AgentHood
+
+async def main():
+    async with AgentHood() as agent:
+        print(await agent.chat("What are my open positions?"))
+        print(await agent.chat("Get me a quote for NVDA and AAPL"))
+        print(await agent.chat("Review a limit buy of 5 AAPL at $210"))
+
+asyncio.run(main())
+```
+
+`chat()` sends a prompt and returns the response. The agent picks the right Robinhood tools, fetches data, and explains what it found.
+
+## CLI
+
+```bash
+agenthood                          # interactive REPL
+agenthood "What is TSLA at?"       # one-shot
+agenthood --live                   # real orders
+agenthood --stream                 # token-by-token
+```
+
+Inside the REPL, dot commands skip the LLM entirely:
+
+```
+.portfolio          show portfolio (alias: .p)
+.positions          show open positions (alias: .pos)
+.quote NVDA         quick price quote (alias: .q NVDA)
+.analyze PYPL       multi-source analysis
+.help               all commands
+```
+
+## Direct tool calls
+
+```python
+import asyncio, json
+from agenthood import AgentHood
+
+async def main():
+    async with AgentHood() as agent:
+        result = json.loads(await agent.call_tool("robinhood_get_equity_quotes", {
+            "symbols": ["NVDA", "AAPL"]
+        }))
+        print(result["data"]["results"])
+
+asyncio.run(main())
+```
+
+`call_tool(name, params)` bypasses the LLM and calls a Robinhood MCP tool directly. 53 tools available.
+
+## Safety
+
+```python
+from agenthood import AgentHood, AgentHoodConfig
+
+cfg = AgentHoodConfig(
+    dry_run=False,           # default True -- blocks place_* tools
+    max_order_value=1000,    # hard cap per order in USD
+    allowed_symbols=["AAPL", "NVDA", "TSLA"],
+)
+```
+
+Safety hooks run at the tool-call level. The LLM cannot talk its way around them.
+
+## Config
+
+All config lives in `~/.agenthood/`:
+
+```
+~/.agenthood/
+  config.json       # model, api keys, safety settings
+  history           # readline history
+  sessions/         # saved chat sessions
+  watches.json      # price alerts
+  triggered.db      # alert history
+  logs/             # daemon logs
+  daemon.pid        # background process
+```
+
+```json
+{
+  "model": "meta-llama/llama-3.3-70b-instruct:free",
+  "api_base": "https://openrouter.ai/api/v1",
+  "api_key": "sk-or-...",
+  "analyze_model": "llama-3.3-70b-versatile",
+  "analyze_api_base": "https://api.groq.com/openai/v1",
+  "analyze_api_key": "gsk_...",
+  "dry_run": false,
+  "max_order_value": 1000,
+  "max_turns": 20
+}
+```
+
+Robinhood token is auto-discovered from `~/.mcp-auth/`. No manual setup needed after the first `npx mcp-remote` auth flow.
+
+## Multi-provider routing
+
+```json
+{
+  "model": "google/gemma-4-26b-a4b-it:free",
+  "model_fallbacks": ["nvidia/nemotron-3-super-120b-a12b:free"],
+  "analyze_model": "llama-3.3-70b-versatile",
+  "analyze_api_base": "https://api.groq.com/openai/v1"
+}
+```
+
+`model` handles chat. `analyze_model` handles `.analyze` -- Groq runs analysis in ~1s vs ~14s on free tier. Dot commands use no model at all.
+
+## Autonomous scanning
+
+```python
+cfg = AgentHoodConfig(scan_interval=300)  # every 5 minutes
+```
+
+The agent wakes up on a schedule, checks for positions down >5%, scans for RSI breakouts, and records findings.
+
+## License
+
+MIT [Hemanth.HM](https://h3manth.com)

agenthood-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "agenthood"
+version = "0.1.0"
+description = "Robinhood trading agent powered by agentu + Robinhood MCP"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.11"
+dependencies = [
+    "agentu>=2.4.0",
+    "rich>=13.0",
+]
+
+[project.scripts]
+agenthood = "agenthood.cli:cli"
+
+[tool.hatch.build.targets.sdist]
+include = ["src/", "skills/", "README.md", "AGENTS.md"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/agenthood"]

agenthood-0.1.0/skills/options-playbook/SKILL.md

@@ -0,0 +1,73 @@
+---
+name: options-playbook
+description: Use when the user asks about options — buying calls/puts, covered calls, spreads, earnings plays, IV crush, or anything involving options chains, greeks, or expiration strategy.
+---
+
+# Options Playbook Skill
+
+## Before Any Options Trade
+
+Always gather:
+```
+1. get_option_chains(symbol)              → available expirations + strikes
+2. get_option_instruments(...)            → specific contracts
+3. get_option_quotes(...)                 → bid/ask, IV, greeks
+4. get_equity_fundamentals(symbol)        → earnings date (IV crush risk!)
+5. get_equity_technical_indicators(rsi)   → entry timing
+```
+
+**Always show**: breakeven, max profit, max loss, IV rank.
+
+## Common Strategies
+
+### Long Call (bullish, defined risk)
+- Buy when: RSI < 60, bullish catalyst expected, IV rank < 40%
+- Strike: ATM or 1 strike OTM
+- Expiry: 30–60 DTE (avoid 0DTE for beginners)
+- Max loss: premium paid | Max profit: unlimited
+- Breakeven: strike + premium
+- Exit: at 50% profit or 21 DTE (whichever first)
+
+### Long Put (bearish, defined risk)
+- Buy when: RSI > 65, distribution pattern, high IV is fine (protective)
+- Strike: ATM or 1 strike OTM
+- Expiry: 30–45 DTE
+- Max loss: premium paid | Max profit: strike - premium (near zero)
+
+### Covered Call (neutral-to-slightly-bullish, income)
+- Requires 100 shares of underlying
+- Sell OTM call (delta 0.20–0.30) against shares
+- Collect premium as income
+- Risk: shares called away if price rises above strike
+- Best in: sideways or slowly rising market
+
+### Cash-Secured Put (neutral-to-bullish, income)
+- Sell OTM put, hold cash to buy shares if assigned
+- Collect premium | Effective entry: strike - premium
+- Risk: must buy shares at strike if price drops
+
+## ⚠️ Earnings Warning
+If earnings within **14 days**:
+- IV is inflated → options are expensive
+- IV crush after earnings can destroy long option value even if direction is right
+- Use spreads (defined risk) not naked longs
+- State this warning prominently before any earnings play
+
+## Greeks Quick Reference
+| Greek | Meaning | Watch for |
+|-------|---------|-----------|
+| Delta | Price sensitivity | 0.5 = ATM |
+| Theta | Time decay per day | Hurts buyers |
+| Vega | IV sensitivity | Hurts on IV crush |
+| Gamma | Delta acceleration | High near expiry |
+
+## Output Format for Options
+```
+📊 AAPL $200C 2026-09-19
+  Bid/Ask : $3.20 / $3.40  (mid: $3.30)
+  IV      : 42%  (IV Rank: 38% — fair)
+  Delta   : 0.48 | Theta: -$0.08/day
+  Breakeven: $203.30 (+1.6% from current)
+  Max Loss: $330 (premium paid)
+⚠️  Earnings: 2026-08-01 — IV crush risk after report
+```

agenthood-0.1.0/skills/risk-management/SKILL.md

@@ -0,0 +1,73 @@
+---
+name: risk-management
+description: Use when evaluating position sizing, portfolio concentration, stop-loss placement, drawdown risk, or when the user asks "should I buy more" or "how much should I invest".
+---
+
+# Risk Management Skill
+
+## Position Sizing Rules
+
+### The 1% Rule (default for agenthood)
+- Never risk more than **1% of portfolio value** on a single trade.
+- Risk = entry price - stop-loss price × quantity
+- Example: $10,000 portfolio → max risk per trade = $100
+  - AAPL at $300, stop at $290 → max 10 shares ($3,000 position)
+
+### Portfolio Concentration Limits
+- **Single stock**: max 10% of portfolio
+- **Single sector**: max 25% of portfolio
+- **Options/speculative**: max 5% of portfolio
+- Flag if user is overconcentrated before recommending adds.
+
+## Stop-Loss Placement
+
+| Strategy | Stop Level |
+|----------|-----------|
+| Momentum trade | Below recent swing low |
+| Breakout trade | Below breakout level |
+| Mean reversion | 1.5× ATR below entry |
+| Options | Exit at 50% loss of premium |
+
+Always calculate ATR when placing stops:
+```
+get_equity_historicals → compute daily ranges → average = ATR
+Stop = entry - (1.5 × ATR)
+```
+
+## Pre-Trade Checklist
+
+Before recommending any order, verify:
+- [ ] Position size within 1% risk rule
+- [ ] Sector not already overweight
+- [ ] Earnings not within 2 weeks (if directional bet)
+- [ ] RSI not in extreme zone against the trade direction
+- [ ] Buying power sufficient (check get_portfolio)
+- [ ] Dry run mode is off if placing real order
+
+## Portfolio Health Check Workflow
+```
+1. get_equity_positions           → current holdings
+2. get_portfolio                  → total value + cash
+3. For each position:
+   - calculate % of portfolio
+   - get RSI → flag overbought longs
+4. Summarize: concentration, total risk exposure, cash %
+5. Flag anything > 10% single stock or > 25% sector
+```
+
+## Output Format
+```
+⚖️ Risk Assessment: AAPL 10 shares @ $309
+  Position size  : $3,090 (30.9% of $10k portfolio) ⚠️ HIGH
+  Risk (to stop) : $190  (1.9% of portfolio)
+  Recommended    : Reduce to 5 shares ($1,545 = 15%)
+  Stop-loss      : $290.00 (1× ATR below entry)
+  Max loss       : $95 (0.95% of portfolio) ✅
+```
+
+## Risk Warnings — Always Emit
+- ⚠️ **Earnings within 14 days**: high volatility risk
+- ⚠️ **Position > 10% portfolio**: concentration risk
+- ⚠️ **RSI > 75**: overbought, stop should be tight
+- ⚠️ **Options expiry < 7 days**: theta decay accelerates
+- ⚠️ **Penny stock (< $5)**: high spread, manipulation risk

agenthood-0.1.0/skills/technical-analysis/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: technical-analysis
+description: Use when analyzing stock price action, identifying trends, interpreting RSI/MACD/Bollinger signals, or making buy/sell timing decisions based on technical indicators.
+---
+
+# Technical Analysis Skill
+
+## Indicator Interpretation
+
+### RSI (Relative Strength Index, 14-period default)
+- **< 30** → Oversold. Potential reversal buying opportunity. Confirm with volume spike.
+- **30–50** → Bearish momentum. Avoid new longs unless trend reversing.
+- **50–70** → Neutral-to-bullish. Trend following zone.
+- **> 70** → Overbought. Consider tightening stops or taking profits.
+- **Divergence**: Price makes new high but RSI doesn't → bearish divergence (strong sell signal).
+
+### MACD
+- **Signal line crossover above** → Bullish momentum building. Entry signal.
+- **Signal line crossover below** → Bearish. Consider exit or short.
+- **Histogram expanding** → Trend strengthening.
+- **Histogram contracting** → Trend weakening, watch for reversal.
+- Always pair with price action — MACD lags.
+
+### Bollinger Bands
+- **Price touches upper band** → Overbought short-term. Possible mean reversion.
+- **Price touches lower band** → Oversold. Possible bounce.
+- **Band squeeze (narrow bands)** → Volatility contraction → breakout incoming (direction unknown).
+- **Band expansion** → Trend acceleration.
+
+## Workflow: Full Technical Read
+
+```
+1. get_equity_quotes          → current price, daily change
+2. get_equity_technical_indicators(symbol, "rsi")  → RSI
+3. get_equity_technical_indicators(symbol, "macd") → MACD + signal
+4. get_equity_historicals(symbol, interval="day", span="month") → 30d trend
+5. Synthesize: trend direction + momentum + overbought/oversold
+6. State: BULLISH / BEARISH / NEUTRAL with confidence level
+7. If actionable: suggest entry price, stop-loss, target
+```
+
+## Output Format
+
+Always present a structured summary:
+
+| Signal | Value | Interpretation |
+|--------|-------|----------------|
+| Price  | $X.XX | +/-X% today    |
+| RSI    | XX    | Neutral/OB/OS  |
+| MACD   | Cross | Bullish/Bearish |
+| Trend  | 30d   | Up/Down/Sideways |
+
+**Verdict**: BULLISH / BEARISH / NEUTRAL  
+**Entry**: $X.XX | **Stop**: $X.XX | **Target**: $X.XX
+
+## Rules
+- Never make a recommendation without checking at least RSI + price trend.
+- Always note if market is closed and data is from the previous session.
+- Flag earnings within 2 weeks as high-risk — avoid new positions before earnings.

agenthood-0.1.0/src/agenthood/__init__.py

@@ -0,0 +1,8 @@
+"""agenthood — Robinhood trading agent powered by agentu + Robinhood MCP."""
+
+from .agent import AgentHood
+from .config import AgentHoodConfig, load_config
+from .hooks import trading_guard
+
+__version__ = "0.1.0"
+__all__ = ["AgentHood", "AgentHoodConfig", "load_config", "trading_guard"]