@j-o-r/hello-dave 0.0.3 → 0.0.4

package/README.md.bak2

@@ -0,0 +1,455 @@
+# @j-o-r/hello-dave
+
+[![npm version](https://badge.fury.io/js/%40j-o-r%2Fhello-dave.svg)](https://www.npmjs.com/package/%40j-o-r%2Fhello-dave)
+[![Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+[![Node.js >=20](https://img.shields.io/badge/Node.js-%3E=20-green.svg)](https://nodejs.org/)
+
+## Table of Contents
+
+- [Description](#description)
+- [Features](#features)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Usage](#usage)
+- [Startup Modes](#startup-modes)
+- [Examples](#examples)
+- [Development](#development)
+- [Changelog](#changelog)
+- [Contributing](#contributing)
+- [License](#license)
+- [TODO Alignment](#todo-alignment)
+
+## Description
+
+**@j-o-r/hello-dave** is a lightweight, ESM-only Node.js framework for building intelligent AI agents powered by large language models (LLMs) such as xAI Grok, Anthropic Claude, or OpenAI GPT. It simplifies the creation of custom agents with features like the central `AgentManager` class, WebSocket-based client/server support for networked agents, seamless tool integration (e.g., bash execution, web search), customizable system prompts, and robust session management supporting large context windows (up to millions of tokens).
+
+The framework emphasizes ease of use, allowing developers and non-experts alike to rapidly prototype and deploy specialized agents. Core integrations include unified xAI Grok API access, WebSocket (WS) networking with secret-based authentication, and direct CLI/cron messaging (no heartbeat/ping mechanism required). Example scripts like `readmeDave`, `todoDave`, and others have been reorganized into the `examples/` folder for clarity.
+
+Whether you're building a code reviewer, a research assistant, or a creative collaborator, `@j-o-r/hello-dave` abstracts away API complexities, providing a unified interface across providers. It's alpha-stage but production-ready for personal projects, with persistence for sessions and logs in NDJSON format.
+
+## Features
+
+- **Unified LLM Access**: Seamless integration with xAI Grok API, Anthropic Claude, and OpenAI GPT via a single API.
+- **AgentManager Class**: Core orchestrator for prompts, tools, sessions, and interactions (CLI, direct calls, WebSocket).
+- **Tool Integration**: Built-in tools for bash scripting, web search, JavaScript execution, and more; easily extensible.
+- **WebSocket Networking with Secrets**: Agents can act as servers or clients with optional secret authentication, enabling secure distributed agent networks across machines.
+- **Direct CLI/Cron Messaging**: Simplified interactions without needing heartbeat mechanisms—ideal for scheduled tasks.
+- **Customizable Prompts**: Tailor agent behavior with system prompts for specialized tasks (e.g., music production, code analysis).
+- **Session Management**: Persistent conversations with large context windows; automatic truncation and history search.
+- **CLI Utilities**: Core tool at `bin/dave.js` for cache management, WS connections, and interactive queries; plus agent generator.
+- **Lightweight & TypeScript-Friendly**: ESM-only, no heavy deps; full types included.
+- **Memory Tools**: Generic tools `memory_recall` and `memory_write` for persisting and recalling tasks, errors, and preferences in `.cache/memory.ndjson`, optimizing loops and long-running agent sessions (available in `toolsetMode: 'auto'`).
+
+## Installation
+
+Install as a dependency in your Node.js project (requires Node.js >= 20 with `"type": "module"` in `package.json`):
+
+```bash
+npm install @j-o-r/hello-dave
+```
+
+For global access to CLI tools (including `dave` from `bin/dave.js`):
+
+```bash
+npm install -g @j-o-r/hello-dave
+```
+
+Set your API keys via environment variables (only set what you need):
+- `XAIKEY` for xAI Grok
+- `ANTHKEY` for Anthropic Claude
+- `OPENAIKEY` for OpenAI GPT
+- `BRAVESEARCHKEY` for web search (optional)
+
+Create a cache directory for sessions:
+```bash
+mkdir .cache
+```
+
+## Quick Start
+
+1. Set an API key (e.g., for Grok):
+   ```bash
+   export XAIKEY=your_xai_api_key
+   ```
+
+2. Use the core CLI utility `bin/dave.js` for interactive queries or management:
+   ```bash
+   npx @j-o-r/hello-dave dave --ask
+   ```
+   - Launches an interactive agent session. Use `Alt+d` to exit, `Alt+r` to reset.
+   - Example: Ask questions about anything; it uses xAI Grok by default with web search and X search tools.
+
+3. For one-shot queries via piped input:
+   ```bash
+   echo "Explain quantum computing" | npx @j-o-r/hello-dave dave --ask --model grok-4
+   ```
+   - Provides a direct response using the specified model (e.g., `--model grok-4`).
+
+4. Connect to a WebSocket server (e.g., for networked agents):
+   ```bash
+   npx @j-o-r/hello-dave dave --connect ws://localhost:8080 --secret your_secret
+   ```
+
+5. Generate a custom agent using the portable `spawn_agent` tool (CLI/WS agents + CodeServer launchers):
+   ```bash
+   npx @j-o-r/hello-dave spawn_agent
+   ```
+   - Interactive: Follow prompts to create a new agent script in `bin/` (e.g., `bin/myagent.js`).
+   - Portable to any project (auto-installs deps like `@j-o-r/hello-dave`):
+     ```bash
+     npx @j-o-r/hello-dave spawn_agent --cwd ~/my-project
+     ```
+   - Supports one-shot: `echo "Create code-review agent" | npx @j-o-r/hello-dave spawn_agent --cwd ~/proj`.
+   - Aligns with CodeServer pattern for multi-agent setups (see Usage/Examples).
+
+`bin/dave.js` also supports cache operations like `--list` (list sessions), `--search "query"`, `--clear`, and `--inspect path/to/log.ndjson`.
+
+## Usage
+
+### Core CLI via `bin/dave.js`
+
+`bin/dave.js` provides essential utilities and examples for agent spawning, WS interactions, and basic querying. Key commands:
+
+- **Ask Mode** (Interactive or Piped One-Shot):
+  ```bash
+  # Interactive
+  npx @j-o-r/hello-dave dave --ask --model grok-4 --temperature 0.2
+
+  # Piped one-shot
+  echo "What is quantum computing?" | npx @j-o-r/hello-dave dave --ask --model grok-4
+  ```
+  - Note: Piped input triggers a direct response via `directCall`; without pipe, it launches an interactive CLI session.
+  - `--model` option works for both modes (e.g., `grok-4`, `grok-4-1-fast-reasoning`).
+  - Uses `AgentManager` with xAI Grok API integration, adds tools like `web_search`, `x_search`, `open_link`, `send_email`, `history_search`.
+  - System prompt emphasizes brief, direct responses with step-by-step reasoning.
+
+- **SpawnDave Mode** (Portable Agent Creator with --cwd Support):
+  ```bash
+  # Interactive in current project
+  npx @j-o-r/hello-dave spawn_agent --model grok-4-fast-reasoning --temperature 0.7
+
+  # Portable to another project (switches cwd, auto-deps)
+  npx @j-o-r/hello-dave spawn_agent --cwd ../other-proj
+
+  # One-shot for quick generation
+  echo "name=coderev desc=Git diff analyzer tools=read_file execute_bash_script web_search" | npx @j-o-r/hello-dave spawn_agent --cwd ~/my-proj
+  ```
+  - Creates production-ready CLI/WS agents (`bin/<name>.js`) supporting CLI, server (`--serve`), client (`--connect`), and hybrid modes.
+  - Generates multi-agent CodeServer launchers (`examples/<Name>Server`) using PM2 for persistent networked setups (main server + sub-agents).
+  - **Portable**: Runs via `npx` anywhere—no local install needed. Auto-inspects project, installs `@j-o-r/hello-dave @j-o-r/sh` if missing, validates ESM code (`node --check`), tests deployment.
+  - Aligns with CodeServer pattern: Self-contained Bash launchers for PM2-managed multi-agents (e.g., code review + TODO + NPM agents).
+  - Requires `XAIKEY`; uses online repo docs (https://codeberg.org/duin/hello-dave) for portability.
+  - Example output: Deploys `bin/coderev_agent.js`, tests it, provides server/client usage guide.
+
+- **WebSocket Client Mode** (with secrets for secure networking):
+  ```bash
+  # Interactive connection
+  npx @j-o-r/hello-dave dave --connect ws://localhost:8080 --secret "mysecret"
+
+  # Piped one-shot (direct CLI/cron messaging, no heartbeat needed)
+  echo "Predict the weather" | npx @j-o-r/hello-dave dave --connect ws://localhost:8080 --secret "mysecret"
+  echo "user_reset" | npx @j-o-r/hello-dave dave --connect ws://localhost:8080 --secret "mysecret"
+  ```
+
+- **Cache Management**:
+  ```bash
+  npx @j-o-r/hello-dave dave --list  # List sessions
+  npx @j-o-r/hello-dave dave --search "AI agents"  # Search history
+  npx @j-o-r/hello-dave dave --clear  # Clear cache
+  ```
+
+For custom agents, use `AgentManager` programmatically (see Examples).
+
+### Programmatic Usage with AgentManager
+
+```javascript
+import AgentManager from '@j-o-r/hello-dave';
+
+const agent = new AgentManager({ name: 'MyAgent', secret: 'optional_secret' });
+agent.setup({
+  prompt: 'You are a helpful assistant...',
+  api: 'xai',  // Uses unified xAI Grok API access
+  options: { model: 'grok-4', temperature: 0.7, tools: [{ type: 'web_search' }] },
+  toolsetMode: 'auto',
+  contextWindow: 500000
+});
+
+agent.addGenericToolcall('execute_bash_script');  // Post-setup generics
+agent.addGenericToolcall('read_file');
+agent.addGenericToolcall('write_file');
+agent.addGenericToolcall('memory_recall');  // Persist/recall tasks, errors, prefs in .cache/memory.ndjson
+agent.addGenericToolcall('memory_write');   // Optimizes loops and long-running sessions
+
+await agent.start();  // Interactive CLI
+// Or: await agent.start(undefined, 8000, undefined, 'Intro', 'toolName', 'desc');  // WS server
+// Or: const response = await agent.directCall('Query');  // One-shot
+```
+
+Direct CLI/cron: Pipe inputs to custom scripts for non-interactive use. WS supports secrets for authentication; no heartbeat required due to event-driven messaging.
+
+The `memory_recall` and `memory_write` tools, available when `toolsetMode: 'auto'`, enable agents to persist and recall tasks, errors, and preferences in `.cache/memory.ndjson`. This optimizes iterative loops and long-running sessions by maintaining state across interactions without relying solely on session history.
+
+## Startup Modes
+
+This section details the startup modes for agents like `examples/npm_agent.js`, `bin/dave.js`, and programmatic `AgentManager.start()`. These modes support flexible deployments from one-shot CLI queries to persistent WebSocket servers in networked ecosystems. All modes are cron-friendly with no heartbeat/ping required—agents respond directly to event-driven inputs. In WS modes (--serve, --connect, hybrid), positional arguments are ignored; use interactive CLI or piped inputs for messaging.
+
+### 1. Direct Call (One-Shot, Positional ONLY)
+For single responses via positional query. Ideal for scripts/cron.
+
+**npm_agent.js:**
+```bash
+./examples/npm_agent.js "What modules are installed?" [--model grok-4]
+```
+
+**bin/dave.js:**
+```bash
+npx @j-o-r/hello-dave dave "Explain quantum computing" --ask [--model grok-4]
+```
+
+**Programmatic (AgentManager):**
+```javascript
+import AgentManager from '@j-o-r/hello-dave';
+const agent = new AgentManager({ name: 'MyAgent' });
+await agent.setup({ /* config */ });
+const response = await agent.directCall('What modules are installed?');
+console.log(response);
+```
+
+### 2. Interactive CLI (No Positional Arg)
+Launches ongoing conversation session.
+
+**npm_agent.js:**
+```bash
+./examples/npm_agent.js [--model grok-4]
+```
+
+**bin/dave.js:**
+```bash
+npx @j-o-r/hello-dave dave --ask
+```
+
+**Programmatic:**
+```javascript
+await agent.start();  // Interactive CLI
+```
+
+### 3. WS Server (--serve [port])
+Starts WS server at `ws://127.0.0.1:[port]/ws` for remote tool access. Runs indefinitely.
+
+**Explanations:**
+- `--serve [port]`: Listen port (e.g., 8080). Exposes agent's tools (e.g., 'npm_module_inspector') to clients.
+
+**npm_agent.js:**
+```bash
+./examples/npm_agent.js --serve 8080 [--secret mysecret]
+```
+
+**bin/dave.js:**
+```bash
+npx @j-o-r/hello-dave dave --serve 8080 [--secret mysecret]
+```
+
+**Programmatic:**
+```javascript
+await agent.start(undefined, 8080, 'mysecret');  // Starts server on port 8080 with secret
+```
+
+See [docs/agent-manager.md](docs/agent-manager.md) for server config.
+
+### 4. WS Client (--connect [ws_url])
+Connects to remote server for tool access; launches interactive CLI.
+
+**Explanations:**
+- `--connect [ws_url]`: URL (e.g., ws://127.0.0.1:8080/ws). Gains remote tools.
+
+**npm_agent.js:**
+```bash
+./examples/npm_agent.js --connect ws://127.0.0.1:8080/ws --secret mysecret
+```
+
+**bin/dave.js:**
+```bash
+npx @j-o-r/hello-dave dave --connect ws://localhost:8080 --secret mysecret
+```
+
+**Programmatic:**
+```javascript
+await agent.start('ws://localhost:8080/ws', undefined, 'mysecret');
+```
+
+### 5. Hybrid (Server + Client, No Positional Arg)
+Serves tools locally while using remote ones.
+
+**Explanations:**
+- Combines `--serve` and `--connect`; ignores positional args.
+
+**npm_agent.js:**
+```bash
+./examples/npm_agent.js --serve 8081 --connect ws://other:8080/ws [--secret mysecret]
+```
+
+**bin/dave.js:**
+```bash
+npx @j-o-r/hello-dave dave --serve 8081 --connect ws://other:8080 --secret mysecret
+```
+
+**Programmatic:**
+Custom handling required; see [docs/agent-manager.md](docs/agent-manager.md).
+
+### Shared Options & Notes
+- `--secret [string]`: Min 3-char auth token. Servers reject mismatched clients; use same for chains.
+- Other: `--model [grok-4-fast-reasoning|...]`, `--temperature [-2 to +2]`, `--tokens`, `--top_p`, `--context [250000]`.
+- Positional ignored in WS modes; no heartbeat—event-driven.
+- For multi-agent examples, see [examples/](examples/) and [docs/codeserver-pattern.md](docs/codeserver-pattern.md).
+
+This completes high-priority TODO: "Explain startup modes...".
+
+## Examples
+
+Example scripts (e.g., `readme_agent.js` for README management, `todo_agent.js` for task handling, `spawn_agent.js` for agent creation) are now organized in the `examples/` folder. These demonstrate specialized agents using `AgentManager`, xAI Grok API integration, and tools. **Note**: Agent names and filenames follow lowercase naming rules per [docs/agent-manager.md](docs/agent-manager.md) (regex `/^[a-z_0-9_]{2,}$/` for safety in folders, tools, and filesystems—no uppercase, hyphens, or specials).
+
+- **Link to Examples Folder**: Explore [examples/](examples/) for full scripts like `daisy_agent.js` (music agent), `code_agent.js` (code review), `npm_agent.js` (NPM inspector).
+
+In custom agents, consider adding `memory_recall` and `memory_write` tools to enable state persistence for complex workflows, such as tracking progress in multi-step tasks or storing user preferences across sessions.
+
+### Persistent Multi-Agent CodeServer Pattern
+
+The `examples/CodeServer` script provides a persistent multi-agent setup using PM2 to manage long-running processes. It starts a main code agent as a WebSocket server on a specified port, with sub-agents (for TODO, README, NPM, and docs tasks) attached as clients. This pattern enables a networked ecosystem of specialized agents that maintain state across sessions, ideal for extended development workflows where context persistence and task delegation are key.
+
+Benefits include seamless integration for dev sessions—agents stay online, handling queries via WS without restarts, supporting large context windows and tool calls. For full details, see [docs/codeserver-pattern.md](docs/codeserver-pattern.md).
+
+**Usage:**
+
+```bash
+# Start the CodeServer (requires PM2: npm i -g pm2)
+./examples/CodeServer 8080 mysecret
+
+# Connect via CLI (interactive or piped)
+npx @j-o-r/hello-dave dave --connect ws://127.0.0.1:8080/ws --secret mysecret
+# Or for one-shot: echo "Review this code" | npx @j-o-r/hello-dave dave --connect ws://127.0.0.1:8080/ws --secret mysecret
+```
+
+Monitor with `pm2 list` and stop via `pm2 delete <name>`.
+
+### Snippet: Spawning Agents (Portable via `bin/dave.js` --spawn_agent)
+
+`spawn_agent` uses `AgentManager` to interactively generate new agent scripts, now fully aware of WebSocket server/client modes and the CodeServer multi-agent pattern for networked setups.
+
+Now CodeServer-aware: Can generate PM2 multi-agent launchers (e.g., 'Generate CodeServer for coderev + todo'). See updated [examples/spawn_agent.js](examples/spawn_agent.js) and [docs/codeserver-pattern.md](docs/codeserver-pattern.md).
+
+**Portable**: `spawn_agent` is fully portable—no local docs/examples needed. Uses online repo links (https://codeberg.org/duin/hello-dave). Works in any project via `npx` (auto-deps with `--cwd`).
+
+```javascript
+// Core setup in spawn_agent
+const agent = new AgentManager({ name: 'spawn_agent', secret });
+agent.setup({
+  prompt: 'You are AgentCreator... [detailed prompt for portability, validation]',
+  api: 'xai',
+  options: { model: 'grok-4-fast-reasoning', tools: [{ type: 'web_search' }], reasoning: { effort: 'high' } },
+  toolsetMode: 'auto',
+  contextWindow: 500000
+});
+agent.addGenericToolcall('execute_bash_script');  // For project inspection
+agent.addGenericToolcall('read_file');
+agent.addGenericToolcall('write_file');  // For generating bin/ scripts
+agent.addGenericToolcall('memory_recall');  // For recalling previous generations or prefs
+agent.addGenericToolcall('memory_write');   // For persisting agent configs or errors
+
+await agent.start();  // Guides user to create e.g., bin/myagent.js
+```
+
+- Validates generated ESM code with `node --check` and tool rules (xAI natives pre-setup, generics post-setup).
+- Ensures absolute imports for portability.
+
+**Example Usage:**
+
+```bash
+# Interactive spawning (runs from npm without cloning; current dir)
+npx @j-o-r/hello-dave spawn_agent
+
+# Portable to specific project (auto-switches cwd, installs deps if needed)
+npx @j-o-r/hello-dave spawn_agent --cwd ~/my-proj
+
+# Piped one-shot for CodeServer launcher (portable, no cloning)
+echo "Generate CodeServer launcher for coderev + tododave" | npx @j-o-r/hello-dave spawn_agent --cwd ~/proj
+```
+
+### Snippet: Using xAI Grok API Integration
+
+The unified xAI Grok API access supports options like reasoning and tools:
+
+```javascript
+// In AgentManager setup
+const options = {
+  model: 'grok-4-1-fast-reasoning',
+  temperature: 0.8,
+  tools: [{ type: 'web_search' }, { type: 'x_search', from_date: '2024-01-01' }],  // Native xAI tools
+  reasoning: { effort: 'medium', summary: 'auto' }  // Chain-of-thought support
+};
+```
+
+Detailed examples for xAI integration (e.g., advanced tool calls, reasoning) are planned (see TODO).
+
+### Running Examples
+
+```bash
+# Music agent (examples/daisy_agent.js)
+chmod +x examples/daisy_agent.js
+./examples/daisy_agent.js "Generate lyrics for a pop song"
+
+# TODO manager (examples/todo_agent.js)
+./examples/todo_agent.js --connect ws://localhost:8080 --secret "secret"
+
+# Server setup for networked examples
+npx @j-o-r/hello-dave dave --ask --serve 8080  # Expose as WS server
+```
+
+## Development
+
+- **Scripts**: `npm test` (runs scenarios/grok_agent.js), `npm run types` (generate TypeScript defs), `npm run release` (pack for release).
+- **Structure**: Core in `lib/` (AgentManager.js, wsCli.js, etc.), API integrations in `lib/API/`, examples in `examples/`, utils in `utils/`.
+- **Testing**: Basic validation via `npm test`. Unit tests for xAI integration planned (see TODO).
+- **Prep for v0.0.4**: Focus on spawn_agent enhancements and release testing.
+
+## Changelog
+
+### v0.0.4 (Prep - March 2026)
+- Reorganized examples to `examples/` folder (readmeDave, todoDave, etc.).
+- Enhanced `bin/dave.js` for core utilities: spawning, WS with secrets, direct messaging.
+- Improved xAI Grok API integration; added native tools/reasoning support.
+- Removed heartbeat needs; direct CLI/cron support.
+- Added piped one-shot support to dave --ask.
+- TODO alignment: High-priority items noted (release prep, spawn_agent enhancements).
+
+### v0.0.3 (Previous)
+- Initial WS secrets, generic tools, AgentManager refinements.
+
+Full history in git tags.
+
+## Contributing
+
+Contributions are welcome! Fork the repo at [https://codeberg.org/duin/hello-dave](https://codeberg.org/duin/hello-dave), create a feature branch, and submit a pull request.
+
+1. Install deps: `npm install`
+2. Self dep `npm run link-self`
+3. Run tests: `npm test`
+4. Generate types: `npm run types`
+5. Report issues: [https://codeberg.org/duin/hello-dave/issues](https://codeberg.org/duin/hello-dave/issues)
+
+Follow the [Code of Conduct](CODE_OF_CONDUCT.md) and Apache-2.0 license.
+
+## License
+
+Apache License 2.0. See [LICENSE](LICENSE) for details.
+
+## TODO Alignment
+
+This README aligns with high-priority items from [TODO.md](TODO.md):
+- **v0.0.4 Prep**: Changelog snippet added; release testing emphasized in Development.
+- **spawn_agent Enhancements**: Highlighted in Examples with portability notes.
+- xAI integration tests/examples: Deferred to later (general enhancements).
+- Documentation tasks (e.g., AgentManager internals) integrated into Usage/Examples.
+- **Completed: Explain startup modes** - New dedicated section added with details on CLI/WS modes, options, and examples.
+- Deferred: Other xAI features to later; focus on core release and spawn_agent.
+
+For full TODO, see [TODO.md](TODO.md).

package/docs.bak.1774780058/agent-manager.md

@@ -0,0 +1,167 @@
+# AgentManager (`lib/AgentManager.js`)
+
+## Overview
+**AgentManager** is the central orchestrator class in the hello-dave framework. It manages agent lifecycle: setup (prompts, API, tools, sessions), execution modes (CLI, direct calls, WebSocket server/client), and tool integration. Designed for simplicity and extensibility, it abstracts LLM providers (`xai`, `gpt`, `claude`), `Prompt.js`, `ToolSet.js`, and `Session.js`.
+
+**Uses named exports from `lib/index.js` - NO default export.**
+
+Key Features:
+- **Modes**: Interactive CLI, one-shot `directCall`, WS **server** (expose agent as tool), **client** (attach to remote server), hybrid (server + client).
+- **Tool Handling**: Pre-configured (`toolsetMode: 'auto'`/`'required'`), generics (`addGenericToolcall`), custom `ToolSet`.
+- **Persistence**: Sessions in `.cache/[name]/` (NDJSON logs).
+- **Networking**: WS with optional `secret` auth (base64-encoded).
+- **Validation**: Strict name regex `/^[a-z_0-9_]{2,}$/`.
+- **Events**: Leverages `Prompt` events (e.g., `reset` → server resetAll).
+
+Exports: `{ AgentManager }` (named).
+
+## Agent Naming Rules ⚠️
+**CRITICAL**: The `name` (constructor) and `toolName` (in `start()`) **MUST** match regex `/^[a-z_0-9_]{2,}$/`:
+- Lowercase `a-z`, digits `0-9`, `_` **only**.
+- **Minimum 2 characters**.
+
+**Valid ✅**:
+- `myagent`
+- `chatbot`
+- `weather_agent`
+- `tool123`
+- `ws_client`
+
+**Invalid ❌ (throws `Error`)**:
+- `MyAgent` (uppercase)
+- `agent-v1` (hyphen)
+- `a` (too short)
+- `agent#tool` (`#` invalid)
+- `Agent_` (uppercase)
+
+**Why?** Safe for folders, tool names, filesystems (no specials/caps/spaces).
+
+## Quick Usage
+```javascript
+import { AgentManager } from '@j-o-r/hello-dave';
+
+const agent = new AgentManager({ name: 'myagent', secret: 'mysecret' });
+agent.setup({
+  prompt: 'You are a helpful coding assistant.',
+  api: 'xai',
+  options: { model: 'grok-4-fast-reasoning' },
+  toolsetMode: 'auto',
+  contextWindow: 128000
+});
+agent.addGenericToolcall('execute_bash_script');
+
+await agent.start();  // CLI mode
+// Or: await agent.directCall('Write a Bash script');  // One-shot
+// Or: await agent.start(8000);  // WS server on port 8000
+```
+
+## Constructor Options
+| Property | Type | Default | Description |
+|----------|------|---------|-------------|
+| `name` | string | `'agent'` | **Agent ID (session folder, tool name). MUST match `/^[a-z_0-9_]{2,}$/` (lowercase a-z0-9_; ≥2 chars).** |
+| `secret` | string | `''` | WS auth (base64-encoded; optional, match server/client). |
+| `cachePath` | string | `'.cache/hello-dave'` | Session storage root. |
+
+## setup(setup) → `this` (chainable)
+Configures the agent. Must call before `start()`/`directCall()`.
+
+| Property | Type | Default | Description |
+|----------|------|---------|-------------|
+| `prompt` | string | - | **Required**: System prompt. |
+| `api` | `'xai'|'gpt'|'claude'` | `'gpt'` | LLM provider (uses `lib/API/[provider]/text.js`). |
+| `options` | `XAIOptions`/`OAOptions`/etc. | `{}` | Provider-specific (model, temperature, tools, reasoning). |
+| `contextWindow` | number | `300000` | Token limit for `Prompt`. |
+| `toolsetMode` | `'auto'|'required'` | `null` | `'auto'`: Generic tools; `'required'`: Empty `ToolSet` (add manually). |
+| `debug` | boolean | `false` | Verbose logging. |
+
+Internals: Creates `Prompt`, `Session`, sets `Prompt.setAdaptor(API.text[api], toolset, options)`.
+
+## Key Methods
+| Method | Args | Returns | Description |
+|--------|------|---------|-------------|
+| `directCall(input)` | `string` | `Promise<string>` | One-shot query (via `prompt.call()`). |
+| `getPrompt()` | - | `Prompt` | Access internal `Prompt`. |
+| `getToolset()` | - | `ToolSet\|void` | Access tools. |
+| `environment()` | - | `Promise<EnvironmentInfo>` | System info (via `fafs.js/env()`). |
+| `addGenericToolcall(name)` | string (e.g., `'read_file'`) | - | Copy from `genericToolset.js` pool. Post-setup only. |
+| `start(servePort?, connectUrl?, cliIntro?, toolName?, toolDesc?)` | Mixed | `Promise<void>` | **Smart launcher**:<br>- `servePort` (num): WS **server** (**toolName** MUST match name regex or auto-gen).<br>- `connectUrl` (str, e.g. `'ws://127.0.0.1:8000/ws'`): WS **client** (toolName/desc for attachment).<br>- Neither: **CLI** mode.<br>- Both: Hybrid. |
+
+## Workflow Diagram
+```mermaid
+graph TD
+    A[New AgentManager name, secret] --> B[setup prompt, api, options, toolsetMode]
+    B --> C{start args?}
+    C -->|servePort| D[enableServer port, name, desc<br/>+ optional attach client]
+    C -->|connectUrl| E[attach client url, name, desc]
+    C -->|none| F[startCli intro]
+    D --> G[Session Loop: Prompt → API/Tools → Response]
+    E --> G
+    F --> G
+    G --> H[directCall or persist]
+```
+
+**Per-Endpoint Options**:
+- **CLI**: `start()` → `Cli` (interactive/piped). Options via `setup`.
+- **WS Server**: `start(port)` → `AgentServer` (localhost only). Exposes agent as tool (name/desc). `secret` required for clients. `prompt.on('reset')` → `server.resetAll()`.
+- **WS Client**: `start(undefined, url)` → `AgentClient`. Connects to remote server; agent callable as tool.
+- **Direct**: `directCall()` bypasses networking/CLI.
+
+## Examples
+
+### 1. Interactive CLI Agent
+```javascript
+import { AgentManager } from '@j-o-r/hello-dave';
+
+const agent = new AgentManager({ name: 'chatbot' });
+agent.setup({
+  prompt: 'You are a friendly chatbot.',
+  api: 'xai',
+  toolsetMode: 'auto'
+});
+await agent.start('Chatbot ready!');  // Auto-generates intro
+```
+
+### 2. WS Server (Expose as Tool)
+```javascript
+import { AgentManager } from '@j-o-r/hello-dave';
+
+agent.setup({ ... });
+await agent.start(8000, undefined, undefined, 'weathertool', 'Get real-time weather');
+```
+- Clients: `npx @j-o-r/hello-dave dave --connect ws://localhost:8000/ws --secret mysecret`
+
+### 3. Hybrid + Direct Call
+```javascript
+import { AgentManager } from '@j-o-r/hello-dave';
+
+await agent.start(8001, 'ws://other:8000/ws');  // Server on 8001 + client to other
+const resp = await agent.directCall('Hybrid query');  // Uses attached tools too
+```
+
+### 4. Custom Tools + Generics
+```javascript
+import { AgentManager } from '@j-o-r/hello-dave';
+
+agent.setup({ toolsetMode: 'required' });
+const ts = agent.getToolset();
+ts.add('custommath', 'Add numbers', {
+  type: 'object', properties: {a: {type: 'number'}, b: {type: 'number'}},
+  required: ['a', 'b']
+}, async ({a, b}) => a + b);
+agent.addGenericToolcall('javascript_interpreter');
+```
+
+## Advanced: Networking & Secrets
+- **Server-Client Chain**: Server A attaches to Server B → A callable from B (and vice versa if mutual).
+- **Cron/CLI Messaging**: Pipe to client: `echo 'query' | npx ... dave --connect ...`
+- **Reset**: `Prompt` emits `'reset'` → propagates to attached servers/clients.
+
+## Errors
+- No `setup()`: Throws.
+- **Invalid `name`/`toolName`: Regex `/^[a-z_0-9_]{2,}$/` fail → `Error`.**
+- No `toolset` on server: Throws.
+
+See source `lib/AgentManager.js` for full JSDoc/types. Cross-links:
+- [Prompt](./prompt-class.md)
+- [ToolSet](./toolset.md)
+- [Generic Tools](../lib/genericToolset.js)