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

package/examples/todo_agent.js

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+import { AgentManager } from '@j-o-r/hello-dave';
+import { parseArgs } from '@j-o-r/sh';
+
+const name = 'todo_agent';
+const api = 'xai';
+let secret = '';
+
+const args = parseArgs();
+
+let input; // Directcall input (positional ONLY - NO pipe)
+if (args._.length === 1 && typeof args._[0] === 'string' && args._[0].trim() !== '') {
+	input = args._[0].trim();
+}
+
+const help = args['help'] || false;
+const connect = args['connect'] ? args['connect'] : undefined;
+const serve = args['serve'] ? parseInt(args['serve']) : undefined;
+
+/** @type {import('lib/API/x.ai/responses.js').XAIOptions} */
+const options = { tools: [] };
+options.tools.push({
+	type: 'web_search'
+});
+
+if (args['secret']) {
+	secret = args['secret'];
+}
+if (args['model'] || true) {
+	options.model = args['model'] || 'grok-4-fast-reasoning';
+}
+if (args['temperature']) {
+	options.temperature = parseFloat(args['temperature']);
+}
+if (args['tokens']) {
+	options.max_output_tokens = parseInt(args['tokens']);
+}
+if (args['top_p']) {
+	options.top_p = parseFloat(args['top_p']);
+}
+const reasoning = true;
+if (reasoning) {
+	options.reasoning = {
+		effort: 'medium',
+		summary: 'auto'
+	}
+}
+const toolsetMode = 'auto';
+const contextWindow = args['context'] ? parseInt(args['context']) : 250000;
+
+function printHelp() {
+	console.log(`
+'${name} --help' You are looking at it.
+
+## USAGE MODES:
+
+### 1. Direct Call (One-Shot, Positional ONLY):
+./examples/${name}.js "List tasks" [--options]
+
+### 2. Interactive CLI (no positional arg):
+./examples/${name}.js [--options]
+
+### 3. WS Server (no positional arg):
+./examples/${name}.js --serve 8080 [--secret mysecret] [--options]
+
+### 4. WS Client (no positional arg):
+./examples/${name}.js --connect ws://127.0.0.1:8080/ws --secret mysecret [--options]
+
+### 5. Hybrid (Server + Client, no positional arg):
+./examples/${name}.js --serve 8081 --connect ws://other:8080/ws [--secret ...] [--options]
+
+## SERVER OPTIONS EXPLAINED:
+--serve [port]: Starts WebSocket SERVER at ws://127.0.0.1:[port]/ws. Allows other agents (--connect) to connect and use this agent as a remote TOOL (e.g., 'todo_agent'). Runs indefinitely until Ctrl+C.
+
+--connect [ws_url]: Connects as CLIENT to remote WS server at [ws_url] (e.g., ws://127.0.0.1:8080/ws). Gains access to remote agent's tools. Interactive CLI available.
+
+--secret [string]: SHARED AUTH TOKEN (min 3 chars). SERVER rejects clients without matching --secret. CLIENTS must provide server's secret to connect. Use same secret for chains.
+
+Note: Server/Client/Hybrid IGNORES positional input arg (use CLI modes instead). Hybrid: This agent serves AND uses remote tools.
+
+## OPTIONS:
+--model [grok-4-fast-reasoning|...] (default: grok-4-fast-reasoning)
+--temperature [float] (-2 to +2)
+--tokens [number] (max output tokens)
+--top_p [float]
+--context [number] (default: 250000)
+
+## SERVER TOOLS (when no input):
+Exposes as 'todo_agent' tool for chaining.
+`);
+	process.exit()
+}
+
+if (help) {
+	printHelp();
+}
+
+const tool_call_name = 'todo_agent';
+const tool_call_description = `
+Project TODO list manager. Maintains TODO.md with tasks in Markdown checklists.
+Inspects current TODO.md, adds/checks/completes tasks based on input, updates the file.
+Suggests next actions, stores future important tasks.
+`.trim();
+
+const prompt = `
+You are an expert TODO manager for this project. TODO.md stores tasks in Markdown format with checklists:
+
+## TODO (high priority pending)
+- [ ] Task 1
+
+## In Progress
+- [ ] Task 2
+
+## Later (future tasks)
+- [ ] Important task to do later
+
+## Done
+- [x] Completed task
+
+**CRITICAL: STRICT NO-CODING RULE** - Stick to TODO management ONLY. NEVER:
+- Use coding tools (e.g., javascript_interpreter, write_file, read_file, syntax_check).
+- Generate, execute, or edit code.
+- Misuse bash for anything beyond safe TODO.md ops (e.g., cat TODO.md, echo > TODO.md).
+If asked to code, decline: "For coding, use other agents. I'll handle TODOs only."
+Delegate complex tasks via suggestions; use memory_agent if available for persistence.
+
+ALWAYS:
+
+1. Inspect the current TODO.md file if it exists (use \`cat TODO.md\` or similar).
+
+2. Understand the user input: 
+   - Add new tasks: "add task: Fix bug in foo.js"
+   - Complete: "done: task X" or mark specific
+   - Check status: "status" or "what's next?"
+   - Prioritize/reorganize
+   - Archive old done tasks if too many
+
+3. Update TODO.md with changes. Keep it organized, add dates if useful (e.g., - [ ] 2026-02-24: Task).
+
+4. Write the FULL updated content to ./TODO.md.
+
+5. In your response, summarize:
+   - Current status (pending count, next suggested)
+   - Changes made
+   - Updated TODO.md preview (first 10 lines or key sections)
+
+If no TODO.md, create one inspecting the project (package.json, README.md, git status) for initial tasks like "Review code", "Add tests", etc.
+
+Use tools to inspect files as needed (ls, cat, git log, etc.).
+`.trim();
+
+const agent = new AgentManager({ name, secret });
+agent.setup({
+	prompt,
+	api,
+	options,
+	toolsetMode,
+	contextWindow
+});
+const toolset = agent.getToolset();
+if (toolset) {
+	agent.addGenericToolcall('execute_bash_script');
+}
+const cliIntro = `
+${name} ${options.model}.
+- context: ${contextWindow}. TODO manager ready.
+${tool_call_name}
+`.trim();
+
+if (input) {
+	const RES = await agent.directCall(input);
+	console.log(RES);
+} else {
+	await agent.start(serve, connect, cliIntro, tool_call_name, tool_call_description);
+}

package/examples.bak.1774780058/ask_agent.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+import { AgentManager }  from '@j-o-r/hello-dave';
+import { parseArgs } from '@j-o-r/sh';
+
+const name = 'ask_dave';
+const api = 'xai';
+let secret = '';
+
+// const input = await readIn();
+const args = parseArgs();
+const help = args['help'] || false;
+const connect = args['connect'] ? args['connect'] : undefined;
+const serve = args['serve'] ? parseInt(args['serve']) : undefined;
+
+/** @type {import('lib/API/x.ai/responses.js').XAIOptions} */
+const options = {
+	tools: []
+}
+options.tools.push({
+	type: 'web_search'
+});
+options.tools.push({
+	type: 'x_search'
+});
+
+if (args['secret']) { // model gets default value
+	secret = args['secret'];
+}
+// Set properties only if provided via command line (except model which has default)
+if (args['model'] || true) { // model gets default value
+	// @ts-ignore   || grok-4-1-fast-non-reasoning
+	options.model = args['model'] || 'grok-4-1-fast-reasoning';
+}
+if (args['temperature']) {
+	options.temperature = parseFloat(args['temperature']);
+}
+if (args['tokens']) {
+	options.max_output_tokens = parseInt(args['tokens']);
+}
+if (args['top_p']) {
+	options.top_p = parseFloat(args['top_p']);
+}
+const reasoning = true // args['reasoning'] ? args['reasoning'] : null;
+if (reasoning) {
+	options.reasoning = {
+		effort: 'medium',
+		summary: 'auto'
+	}
+}
+// Large context on grok-4-fast
+const contextWindow = args['context'] ? parseInt(args['context']) : 1900000;
+const toolsetMode = 'auto';
+
+function printHelp() {
+	console.log(`
+'${name} --help' You are looking at it.
+'
+OPTIONS: 
+--tokens [number]: max generated tokens 
+--context [number] : truncate message history to context-windows size default 130000
+--temperature [float] : -2 / +2
+--model ['grok-4-1-fast-reasoning'|'grok-4-1-fast-non-reasoning'|'grok-code-fast-1'|'grok-4-fast-reasoning'|'grok-4-fast-non-reasoning']
+--top_p [float]: number > 0, 0.1 means no top_p
+--reasoning [low|high]
+--tools [javascript,bash] comma seperated list
+
+SERVER TOOLS:
+--serve [number]: create a Agent server on port number ws://127.0.0.1:[serve]/ws
+--connect [url]: connect to a Server Agent e.g ws://127.0.0.1:8080/ws (https://my.domain/ws) ...
+--secret [string] : limit access to websocket server with a secret
+
+`);
+	process.exit()
+}
+if (help) {
+	printHelp();
+}
+
+const prompt = `
+Respond briefly and directly, using minimal words. Reason step-by-step first. Focus solely on core point; avoid elaboration or follow-ups. If unclear, ask clarifying questions before proceeding.
+ `.trim();
+
+const agent = new AgentManager({ name, secret });
+agent.setup({
+	prompt,
+	api,
+	options,
+	toolsetMode,
+	contextWindow
+});
+agent.addGenericToolcall('open_link');
+agent.addGenericToolcall('send_email');
+agent.addGenericToolcall('history_search');
+
+const addTools = (args['tools']) ? args['tools'].split(',') : ['bash'];
+if (addTools.includes('javascript')) {
+	agent.addGenericToolcall('javascript_interpreter');
+}
+if (addTools.includes('bash')) {
+	agent.addGenericToolcall('execute_bash_script');
+}
+if (addTools.includes('ssh')) {
+	agent.addGenericToolcall('execute_remote_script');
+}
+const cliIntro = `
+${name} ${options.model}.
+- context: ${contextWindow}
+`.trim();
+const description = `
+Guide for this smart online AI Agent:
+- query: Formulate ONE efficient, comprehensive search query in natural language, combining multiple sources/subjects/domains; mention optional sources if needed. Avoid multiple queries—consolidate into a single one.
+`.trim();
+
+await agent.start(serve, connect, cliIntro, "search_agent", description);

package/examples.bak.1774780058/code_agent.js

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+import { AgentManager } from '@j-o-r/hello-dave';
+import { parseArgs } from '@j-o-r/sh';
+
+const name = 'code_dave';
+const api = 'xai';
+let secret = '';
+
+const args = parseArgs();
+const help = args['help'] || false;
+const connect = args['connect'] ? args['connect'] : undefined;
+const serve = args['serve'] ? parseInt(args['serve']) : undefined;
+
+/** @type {import('lib/API/x.ai/responses.js').XAIOptions} */
+const options = {
+	tools: []
+}
+options.tools.push({
+ 	type: 'web_search'
+});
+if (args['secret']) { 
+	secret= args['secret'];
+}
+// Set properties only if provided via command line (except model which has default)
+if (args['model'] || true) { // model gets default value
+	// @ts-ignore
+	options.model = args['model'] || 'grok-4-1-fast-reasoning';
+}
+// if (args['temperature']) {
+	options.temperature = 0.2;
+// }
+if (args['tokens']) {
+	options.max_output_tokens = parseInt(args['tokens']);
+}
+if (args['top_p']) {
+	options.top_p = parseFloat(args['top_p']);
+}
+const reasoning = args['reasoning'] ? args['reasoning'] : 'medium';
+if (reasoning) {
+	options.reasoning = {
+		// @ts-ignore
+		effort:reasoning,
+		summary: 'auto'
+	}
+}
+const toolsetMode = 'auto';
+const contextWindow = args['context'] ? parseInt(args['context']) : 2565000;
+
+function printHelp() {
+	console.log(`
+'${name} --help' You are looking at it.
+'
+OPTIONS: 
+--tokens [number]: max generated tokens 
+--context [number] : truncate message history to context-windows size default 130000
+--temperature [float] : -2 / +2
+--model [string] : model name 
+--top_p [float]: number > 0, 0.1 means no top_p
+--reasoning [low|medium|high]
+--tools [javascript,bash,nushell,ssh] comma seperated list
+
+SERVER TOOLS:
+--serve [number]: create a Agent server on port number ws://127.0.0.1:[serve]/ws
+--connect [url]: connect to a Server Agent e.g ws://127.0.0.1:8080/ws (https://my.domain/ws) ...
+--secret [string] : limit access to websocket server with a secret
+
+`);
+	process.exit()
+}
+
+if (help) {
+	printHelp();
+}
+
+const agent = new AgentManager({ name, secret});
+const sys = (await agent.environment()).system;
+const prompt = `
+You are a coding assistant specializing in Bash and JavaScript (ESM/ESNext), with support for other languages. Assist by executing, reading, creating, querying, explaining, or helping with code. Use tools like 'execute_bash_script' for code execution and for writing and reading files, stay in the current working folder. Provide clear, step-by-step responses, examples, and ensure safety compliance.
+---env
+\${sys}
+---
+
+**MANDATORY MEMORY PROTOCOL (For EVERY query/task - NO EXCEPTIONS):**
+
+Connected clients (todo_agent, readme_agent, npm_agent, docs_agent, **memory_agent**) are available as tools. **ALWAYS** use **memory_agent** FIRST and LAST:
+
+1. **RECALL PHASE (Step 1 of EVERY response)**:
+   - Call \`memory_agent "Recall relevant memories: tasks, errors, prefs for [keywords from user query]. List recent if empty."\`
+   - Incorporate recalled info (e.g., avoid known errors, resume tasks, apply prefs like temp=0.2).
+
+2. **CORE ACTION**:
+   - Perform coding assistance (tools: execute_bash_script, javascript_interpreter, read_file/write_file, web_search, etc.).
+   - Delegate to specialists if relevant:
+     - todo_agent: Tasks/TODO.md
+     - readme_agent: README.md
+     - npm_agent: NPM modules/package.json
+     - docs_agent: Documentation
+     - memory_agent: Persistent storage
+
+3. **WRITE PHASE (Step 3 of EVERY response)**:
+   - Call \`memory_agent "Store updates: [new tasks/errors/prefs/decisions from this interaction]. E.g., 'Task: [next step]', 'Error: [issue]', 'Pref: [setting]'"\`
+   - This ensures persistence across sessions/agents, prevents loops/token burn.
+
+**EXAMPLE FLOW**:
+User: "Fix bug in main.js"
+- 1. memory_agent "Recall: tasks errors code bugs main.js"
+- 2. read_file main.js → analyze/fix → write_file
+- 3. memory_agent "Write: Task completed: fixed main.js bug. New task: add tests."
+
+**PRIORITIES**:
+- Safety: CWD-only, no escapes, validate before write.
+- Efficiency: Use memories to skip repeats (e.g., "Known error: git conflict → skip").
+- Step-by-step: Clear responses with code blocks.
+- Current date: March 27, 2026.
+
+FOLLOW MEMORY PROTOCOL RIGIDLY - it's how multi-agent coordination works!
+`.trim();
+agent.setup({
+	prompt,
+	api,
+	options,
+	toolsetMode,
+	contextWindow
+});
+
+const toolset = agent.getToolset();
+if (toolset) {
+	agent.addGenericToolcall('history_search');
+	agent.addGenericToolcall('javascript_interpreter');
+	agent.addGenericToolcall('execute_bash_script');
+	agent.addGenericToolcall('read_file');
+	agent.addGenericToolcall('write_file');
+
+	const addTools = (args['tools']) ? args['tools'].split(',') : [''];
+	if (addTools.includes('ssh')) {
+		agent.addGenericToolcall('execute_remote_script');
+	}
+}
+const cliIntro = `
+${name} ${options.model}
+- context: ${contextWindow}
+- **Memory Protocol ACTIVE**: Auto-recalls/writes via memory_agent for every query!
+`.trim();
+const description = `
+Main CodeServer hub: Coding expert + delegates to todo/readme/npm/docs/memory agents.
+ALWAYS uses memory_agent for persistent tasks/errors/prefs.
+`.trim();
+
+await agent.start(serve, connect, cliIntro, "code_agent", description);

package/examples.bak.1774780058/coderev_agent.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+import { AgentManager } from '@j-o-r/hello-dave';
+import { parseArgs } from '@j-o-r/sh';
+
+const name = 'coderev';  // ← REPLACE w/ lowercase /^[a-z_0-9_]{2,}$/
+const api = 'xai';
+let secret = '';
+
+const args = parseArgs();
+const help = args['help'] || false;
+const connect = args['connect'] ? args['connect'] : undefined;
+const serve = args['serve'] ? parseInt(args['serve']) : undefined;
+
+/** @type {import('lib/API/x.ai/responses.js').XAIOptions} */
+const options = { tools: [] };
+
+// NATIVES HERE e.g. options.tools.push({ type: 'web_search' });
+options.tools.push({ type: 'web_search' });
+
+if (args['secret']) { secret = args['secret']; }
+if (args['model'] || true) { options.model = args['model'] || 'grok-4-fast-reasoning'; }
+if (args['temperature']) { options.temperature = parseFloat(args['temperature']); } else { options.temperature = 0.8; }
+// tokens, top_p, reasoning...
+
+options.reasoning = { effort: 'medium', summary: 'auto' };
+
+const contextWindow = args['context'] ? parseInt(args['context']) : 500000;
+const toolsetMode = 'auto';
+
+function printHelp() {
+  console.log(`coderev --help: Git diff analyzer
+
+Full AgentManager modes (docs/agent-manager.md):
+
+USAGE:
+  ./bin/coderev             # Interactive CLI
+  echo "query" | ./bin/coderev  # One-shot pipe
+  ./bin/coderev --serve 8081    # WS Server: Expose as tool
+  ./bin/coderev --connect ws://host:8081/ws --secret KEY  # WS Client: Attach/gain tools
+  ./bin/coderev --serve 8081 --connect ws://other:8080/ws  # Hybrid
+
+OPTIONS: --model ... --secret ...
+
+EXAMPLES:
+  Test server: Start server, then client query above.
+  Chain: Server A --connect B → A calls B as tool.`);
+  process.exit();
+}
+
+if (help) printHelp();
+
+const prompt = `You are coderev, a Git diff analyzer.
+
+Analyze git diffs provided in queries, review code changes for bugs, improvements, best practices, security issues, and provide actionable suggestions. Use read_file to access specific files, execute_bash_script for git commands or other shell tasks, and web_search for looking up coding standards or references if needed. Be thorough, constructive, and reference specific lines in diffs when possible.
+
+Respond in a structured format: Summary, Issues Found, Suggestions, Overall Rating (1-10).`.trim();
+
+const agent = new AgentManager({ name, secret });
+agent.setup({ prompt, api, options, toolsetMode, contextWindow });
+
+// GENERICS HERE e.g. agent.addGenericToolcall('execute_bash_script');
+agent.addGenericToolcall('read_file');
+agent.addGenericToolcall('execute_bash_script');
+
+const cliIntro = `🤖 coderev ready! Modes: CLI/Server/Client (docs/agent-manager.md)
+
+I'm here to analyze your git diffs and code changes. Paste a diff or describe changes, and I'll review them step-by-step!`.trim();
+
+const toolName = 'agent_' + name;
+const toolDescription = `Git diff analyzer. Supports WS chaining.`.trim();
+
+await agent.start(serve, connect, cliIntro, toolName, toolDescription);

package/examples.bak.1774780058/codeserver.sh

@@ -0,0 +1,47 @@
+#!/bin/bash
+if [ $# -lt 1 ] || [ $# -gt 2 ]; then
+  echo "Usage: $0 <PORT> [SECRET]  # PORT: 1024-65535, SECRET: optional (defaults to '123')"
+  exit 1
+fi
+
+PORT="$1"
+SECRET="${2:-123}"
+
+if [ -z "$SECRET" ] || [ ${#SECRET} -lt 3 ]; then
+  echo "Error: SECRET must be at least 3 characters: '$SECRET'"
+  exit 1
+fi
+
+if ! [[ "$PORT" =~ ^[0-9]+$ ]] || [ "$PORT" -lt 1024 ] || [ "$PORT" -gt 65535 ]; then
+  echo "Error: Invalid port number: $PORT. Must be between 1024 and 65535."
+  exit 1
+fi
+
+# Compute paths relative to THIS script's location (portable from anywhere)
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+PROJECT_DIR="$( cd "$( dirname "${SCRIPT_DIR}" )" && pwd )"
+FOLDER=$(basename "$PROJECT_DIR")
+
+echo "Starting CodeServer on port ${PORT} in folder '${FOLDER}' (SCRIPT_DIR: ${SCRIPT_DIR}) with SECRET '${SECRET}'..."
+
+# Delete existing processes with folder_port suffix
+pm2 delete "${FOLDER}_code_agent_${PORT}" 2>/dev/null || true
+pm2 delete "${FOLDER}_todo_agent_${PORT}"  2>/dev/null || true
+pm2 delete "${FOLDER}_readme_agent_${PORT}" 2>/dev/null || true
+pm2 delete "${FOLDER}_npm_agent_${PORT}" 2>/dev/null || true
+pm2 delete "${FOLDER}_docs_agent_${PORT}" 2>/dev/null || true
+pm2 delete "${FOLDER}_test_agent_${PORT}" 2>/dev/null || true
+pm2 delete "${FOLDER}_memory_agent_${PORT}" 2>/dev/null || true
+
+# Spawn main Agent / server (absolute paths to scripts)
+pm2 start "${SCRIPT_DIR}/code_agent.js" --name "${FOLDER}_code_agent_${PORT}" -- --serve "${PORT}" --tools javascript --secret "${SECRET}"
+# Attach clients
+pm2 start "${SCRIPT_DIR}/todo_agent.js"   --name "${FOLDER}_todo_agent_${PORT}"   -- --connect "ws://127.0.0.1:${PORT}/ws" --secret "${SECRET}"
+pm2 start "${SCRIPT_DIR}/readme_agent.js" --name "${FOLDER}_readme_agent_${PORT}" -- --connect "ws://127.0.0.1:${PORT}/ws" --secret "${SECRET}"
+pm2 start "${SCRIPT_DIR}/npm_agent.js"    --name "${FOLDER}_npm_agent_${PORT}"    -- --connect "ws://127.0.0.1:${PORT}/ws" --secret "${SECRET}"
+pm2 start "${SCRIPT_DIR}/docs_agent.js"   --name "${FOLDER}_docs_agent_${PORT}"   -- --connect "ws://127.0.0.1:${PORT}/ws" --secret "${SECRET}"
+pm2 start "${SCRIPT_DIR}/test_agent.js"   --name "${FOLDER}_test_agent_${PORT}"   -- --connect "ws://127.0.0.1:${PORT}/ws" --secret "${SECRET}"
+pm2 start "${SCRIPT_DIR}/memory_agent.js"   --name "${FOLDER}_memory_agent_${PORT}"   -- --connect "ws://127.0.0.1:${PORT}/ws" --secret "${SECRET}"
+
+echo "CodeServer processes spawned with prefix '${FOLDER}_' and suffix _${PORT}. Check with: pm2 list | grep '${FOLDER}_${PORT}'"
+echo "dave --connect ws://127.0.0.1:${PORT}/ws --secret '$SECRET'"