@mndrk/agx 1.4.3 → 1.4.8

package/README.md

@@ -1,6 +1,6 @@
 # agx
 
-Unified AI Agent CLI with persistent memory. Wraps Claude, Gemini, and Ollama with automatic state management via [mem](https://github.com/ramarlina/memx).
+Autonomous AI agents. One command, works until done.
 
 ```bash
 npm install -g @mndrk/agx
@@ -9,166 +9,82 @@ npm install -g @mndrk/agx
 ## Quick Start
 
 ```bash
-# Simple prompt
-agx claude -p "explain this code"
+agx -a -p "Build a REST API with auth"
+# ✓ Created task: build-rest-api  
+# ✓ Daemon started (wakes every 15m)
+# ✓ Working...
+```
 
-# Use default provider
-agx -p "what does this function do?"
+That's it. The agent continues working autonomously until complete.
 
-# With persistent memory (auto-detected)
-agx claude -p "continue working on the todo app"
+## How It Works
 
-# Autonomous mode - creates task and works until done
-agx claude --autonomous -p "Build a todo app with React"
-```
+The `-a` flag starts an autonomous task:
+1. Creates a task from your prompt
+2. Starts background daemon
+3. Agent works on the task
+4. Wakes every 15 minutes to continue
+5. Stops when agent outputs `[done]` or `[blocked]`
 
-## Memory Integration
+No manual task management. No babysitting. Just results.
 
-agx integrates with [mem](https://github.com/ramarlina/memx) for persistent state across sessions:
+## Checking Progress
 
 ```bash
-# If ~/.mem has a task mapped to cwd, context is auto-loaded
-cd ~/Projects/my-app
-agx claude -p "continue"   # Knows where it left off
-
-# Create task with explicit criteria
-agx claude --task todo-app \
-  --criteria "CRUD working" \
-  --criteria "Tests passing" \
-  --criteria "Deployed to Vercel" \
-  -p "Build a todo app"
+agx status          # Current task
+agx tasks           # All tasks
+agx progress        # % complete
+agx daemon logs     # Recent activity
 ```
 
-## Output Markers
+## One-Shot Mode
 
-Agents control state via markers in their output:
+For quick questions without persistence:
 
-```
-[checkpoint: Hero section complete]   # Save progress
-[learn: Tailwind is fast]             # Record learning
-[next: Add auth system]               # Set next step
-[criteria: 2]                         # Mark criterion #2 done
-[approve: Deploy to production?]      # Halt for approval
-[blocked: Need API key from client]   # Mark stuck
-[pause]                               # Stop, resume later
-[continue]                            # Keep going (daemon)
-[done]                                # Task complete
-[split: auth "Handle authentication"] # Create subtask
+```bash
+agx -p "explain this error"
+agx claude -p "refactor this function"
 ```
 
 ## Providers
 
-| Provider | Aliases | Description |
-|----------|---------|-------------|
-| claude | c, cl | Anthropic Claude Code |
-| gemini | g, gem | Google Gemini CLI |
-| ollama | o, ol | Local Ollama models |
-
-## Options
+| Provider | Alias | Description |
+|----------|-------|-------------|
+| claude | c | Anthropic Claude Code |
+| gemini | g | Google Gemini |
+| ollama | o | Local Ollama |
 
-```
---prompt, -p <text>    Prompt to send
---model, -m <name>     Model name
---yolo, -y             Skip permission prompts
---print                Non-interactive output
---interactive, -i      Force interactive mode
---mem                  Enable mem integration (auto-detected)
---no-mem               Disable mem integration
---autonomous, -a       Create task and run autonomously (starts daemon)
---task <name>          Specific task name
---criteria <text>      Success criterion (repeatable)
-```
-
-## Claude Code Plugin
+## Output Markers
 
-Install as a Claude Code plugin:
+Agents control their state via markers:
 
-```bash
-claude plugin install github:ramarlina/agx
 ```
-
-This adds:
-- **Skill**: Claude learns how to spawn background agents
-- **Commands**: `/agx:spawn <goal>`, `/agx:continue`
-
-## Commands
-
-```bash
-agx init               # Setup wizard
-agx config             # Configuration menu
-agx status             # Show current config
-agx skill              # View LLM skill
-agx skill install      # Install skill to Claude/Gemini
-
-# Daemon management
-agx daemon start       # Start background daemon
-agx daemon stop        # Stop daemon
-agx daemon status      # Check if running
-agx daemon logs        # Show recent logs
+[checkpoint: Built login page]    # Save progress
+[learn: JWT works better here]    # Record insight
+[next: Add signup flow]           # Set next step
+[done]                            # Task complete
+[blocked: Need API key]           # Can't proceed
 ```
 
-## Autonomous Mode
+## Manual Control (Optional)
 
-Start a task that runs autonomously until complete:
+For power users who want fine control:
 
 ```bash
-agx claude --autonomous -p "Build a React todo app with auth"
-# ✓ Created task: build-react-todo
-# ✓ Mapped: ~/Projects/app → task/build-react-todo
-# ✓ Daemon started (pid 12345)
-# ✓ Autonomous mode: daemon will continue work every 15m
-```
-
-The daemon:
-- Runs in background (survives terminal close)
-- Wakes every 15 minutes
-- Continues work on active tasks
-- Stops when task is `[done]` or `[blocked]`
-
-## Loop Control
-
-The agent controls execution flow via markers:
-
-- `[done]` → Task complete, exit
-- `[pause]` → Save state, exit (resume later with same command)
-- `[blocked: reason]` → Mark stuck, notify human, exit
-- `[continue]` → Keep going (daemon mode loops)
-- `[approve: question]` → Halt until human approves
-
-## Task Splitting
-
-Break large tasks into subtasks:
-
-```
-Agent output:
-This is too big. Breaking it down.
-
-[split: setup "Project scaffolding"]
-[split: auth "Authentication system"]
-[split: crud "CRUD operations"]
-[next: Start with setup subtask]
-[pause]
+agx run [task]        # Run task now
+agx pause [task]      # Pause scheduled runs
+agx stop [task]       # Mark done
+agx stuck <reason>    # Mark blocked
 ```
 
-agx creates subtask branches in ~/.mem linked to the parent.
+## Setup
 
-## Example: Full Workflow
+First run walks you through setup:
 
 ```bash
-# Day 1: Start project
-mkdir ~/Projects/my-app && cd ~/Projects/my-app
-agx claude --auto-task -p "Build a React todo app with auth"
-
-# Agent works, outputs markers
-# [checkpoint: Scaffolded with Vite]
-# [learn: Vite is faster than CRA]
-# [next: Add todo list component]
-# [pause]
-
-# Day 2: Continue
-cd ~/Projects/my-app
-agx claude -p "continue"
-# Context auto-loaded, agent picks up where it left off
+agx setup             # Install providers, set defaults
+agx add claude        # Add a provider
+agx login claude      # Authenticate
 ```
 
 ## License