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

package/lib/genericToolset.js.bak_syntax

@@ -0,0 +1,402 @@
+import { SH, bashEscape } from '@j-o-r/sh'
+import { ToolSet, env } from './index.js'
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const user = await env();
+const environment = ` 
+Name: ${user.name}
+System: ${user.system}
+City: ${user.city}
+Region: ${user.region}
+Country: ${user.country}
+Timezone: ${user.timezone}
+ExternalIp: ${user.external_ip}  
+`.trim();
+const tools = new ToolSet('auto');
+
+/**
+* reduce the error output to essential info only, if possible
+* @param {string} errorStr
+* @returns {string}
+*/
+const getJSError = (errorStr) => {
+	let result = '';
+	const linematch = errorStr.match(/\[eval\]:(\d+)/);
+	const lineNumber = linematch ? linematch[1] : '';
+	const match = errorStr.split(/\" \"\[eval\]:\d+/s);
+	if (match.length > 1) {
+		// Remove last 10 lines
+		const res = match[1].split('\n').slice(0, -10).join('\n');
+		result = `Error: line ${lineNumber}\n${res} `
+	} else {
+		result = errorStr;
+	}
+	return result;
+}
+
+tools.add(
+	'javascript_interpreter',
+	`Execute ESM ES6 javascript on \`node\`.`,
+	{
+		type: 'object',
+		properties: {
+			script: {
+				type: 'string',
+				description: `ES6 ESM Javascript eval. 'console.log' to capture the response. cwd: ${user.cwd}`,
+			}
+		},
+		required: ['script']
+	},
+	async (params) => {
+		let response = '';
+		try {
+			const delim = `JS_STDIN_${Date.now().toString(36)}_${Math.random().toString(36).slice(2,6)}`;
+			response = await SH`cat <<'${delim}' | node --input-type=module -
+${params.script}
+${delim}
+`.run();
+		} catch (e) {
+			const errorStr = e.toString();
+			response = getJSError(errorStr);
+		}
+		return response;
+	}
+);
+tools.add(
+	'get_user_env', // name
+	'Get the user location, name and OS environment', // desciption
+	{
+		type: 'object',
+		properties: {
+		}
+	},
+	async (_params) => {
+		return environment;
+	}
+);
+
+tools.add(
+	'execute_bash_script',
+	'Execute a bash script or command. (char escaping not needed)',
+	{
+		type: 'object',
+		properties: {
+			bash_script: { type: 'string', description: `RAW bash script (LITERAL TEXT: NO ESCAPING—output $, |, <, >, &, ", ', \\, \` , newlines, $(()), [[ ]] verbatim. Heredoc delimiter handles safely. EX: echo "$((1+1)) | grep \'<&>\"hi$USER\"\' && ls -la\`. (${user.system})` }
+		},
+		required: ['bash_script']
+	},
+	async (params) => {
+		const delim = `END_SCRIPT_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+		return await SH`bash <<'${delim}'
+${params.bash_script}
+${delim}
+`.run()
+	}
+);
+
+tools.add(
+	'send_email',
+	'Send an email.',
+	{
+		type: 'object',
+		properties: {
+			to: { type: 'string', description: 'Recipient email' },
+			subject: { type: 'string', description: 'Subject' },
+			body: { type: 'string', description: 'Message body' }
+		},
+		required: ['to', 'subject', 'body']
+	},
+	async (params) => {
+		const delim = `END_EMAIL_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+		return await SH`msmtp ${params.to} <<'${delim}'
+To: ${params.to}
+Subject: ${params.subject}
+
+${params.body}
+${delim}
+`.run();
+	}
+);
+tools.add(
+	'open_link',
+	'Open an url or file in the local user environment. (xdg-open)',
+	{
+		type: 'object',
+		properties: {
+			url: { type: 'string', description: 'file | URL' }
+		},
+		required: ['url']
+	},
+	async (params) => {
+		return await SH`xdg-open ${[params.url]}`.run();
+	}
+);
+tools.add(
+	'execute_remote_script',
+	'Execute bash script on a remote machine via SSH.',
+	{
+		type: 'object',
+		properties: {
+			url: { type: 'string', description: 'SSH URL, e.g., ssh://user@host or ssh://user@host:port' },
+			script: { type: 'string', description: 'RAW script code to execute remotely (no escaping needed)' }
+		},
+		required: ['url', 'script']
+	},
+	async (params) => {
+		const { url, script } = params;
+		if (!url.startsWith('ssh://')) throw new Error('Invalid SSH URL');
+		const withoutProto = url.slice(6);
+		const parts = withoutProto.split(':');
+		let port = 22;
+		let userHost = withoutProto;
+		if (parts.length > 1) {
+			userHost = parts[0];
+			port = parseInt(parts[1]);
+		}
+		const [user, host] = userHost.split('@');
+		if (!user || !host) throw new Error('Invalid SSH URL format: use ssh://user@host[:port]');
+
+		const delim = `END_SCRIPT_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+		return await SH`ssh -p ${port} ${user}@${host} bash <<'${delim}'
+${script}
+${delim}
+`.run();
+
+	}
+);
+tools.add(
+  'history_search',
+  `Search previous LLM chat sessions or list them hierarchically.
+Example query: "(todo|task)" or "package.json".
+Searches filenames & content in .cache/[app]/[prompt]/sessions/*.ndjson (case-insensitive regex, with context).
+Omit query (or use empty string) to list sessions (see utils/list_sessions.sh).`,
+  {
+    type: 'object',
+    properties: {
+      query: {
+        type: 'string',
+        description: `Search query or regex (quoted for multi-word/regex). Omit or empty for list mode.`
+      }
+    },
+    required: []
+  },
+  async (params) => {
+    const history_search = path.resolve(__dirname, '..', 'utils', 'search_sessions.sh');
+    const list_sessions = path.resolve(__dirname, '..', 'utils', 'list_sessions.sh');
+    if (typeof params.query === 'string' && params.query.trim() !== '') {
+      const escapedQuery = bashEscape(params.query);
+      return await SH`${history_search} "${escapedQuery}"`.run();
+    } else {
+      return await SH`${list_sessions}`.run();
+    }
+  }
+);
+tools.add(
+	'read_file',
+	'Read the raw content of a file strictly within the current working directory (CWD). Paths must be relative (no leading /, no ..).',
+	{
+		type: 'object',
+		properties: {
+			file: {
+				type: 'string',
+				description: `Relative path to the file within CWD, e.g., 'path/to/file.txt' (no escaping needed). cwd: ${user.cwd}`
+			}
+		},
+		required: ['file']
+	},
+	async (params) => {
+		const file = params.file?.trim();
+		if (typeof file !== 'string' || !file) {
+			throw new Error('Valid relative file path required.');
+		}
+		if (file.startsWith('/') || file.includes('..') || file.includes('\\\\')) {
+			throw new Error('Path must be relative within CWD only (no `/`, `..`, or `\\\\`).');
+		}
+		const resolvedPath = path.resolve(process.cwd(), file);
+		if (!resolvedPath.startsWith(process.cwd())) {
+			throw new Error(`Path '${file}' escapes CWD scope.`);
+		}
+		try {
+			const content = await fs.readFile(resolvedPath, 'utf8');
+			return content;
+		} catch (e) {
+			throw new Error(`Failed to read '${file}': ${e.message}`);
+		}
+	}
+);
+
+tools.add(
+	'write_file',
+	'Write raw content to a file strictly within the current working directory (CWD). Paths must be relative (no leading /, no ..). Content written as-is (no escaping). **AUTO-VALIDATES** JS/Python/Bash/JSON/etc. via `utils/syntax_check.sh`; chmod +x shebangs. Retries syntax errors force LLM fix.',
+	{
+		type: 'object',
+		properties: {
+			file: {
+				type: 'string',
+				description: `Relative path to the file within CWD, e.g., 'path/to/file.txt' (no escaping needed).`
+			},
+			content: {
+				type: 'string',
+				description: `Raw content to write (as-is, no char escaping needed; supports newlines, $, |, <, >, &, ", ', \\, etc.).`
+			}
+		},
+		required: ['file', 'content']
+	},
+	async (params) => {
+		const file = params.file?.trim();
+		const content = params.content ?? '';
+		if (typeof file !== 'string' || !file) {
+			throw new Error('Valid relative file path required.');
+		}
+		if (file.startsWith('/') || file.includes('..') || file.includes('\\\\')) {
+			throw new Error('Path must be relative within CWD only (no `/`, `..`, or `\\\\`).');
+		}
+		const resolvedPath = path.resolve(process.cwd(), file);
+		if (!resolvedPath.startsWith(process.cwd())) {
+			throw new Error(`Path '${file}' escapes CWD scope.`);
+		}
+		try {
+			await fs.writeFile(resolvedPath, content, 'utf8');
+			
+			// AUTO-VALIDATE: Multi-lang syntax check via utils/syntax_check.sh + chmod shebang
+			const syntaxChecker = path.resolve(process.cwd(), 'utils/syntax_check.sh');
+			const hasShebang = content.startsWith('#!');
+			
+			let validationMsg = '';
+			try {
+				await SH`${syntaxChecker} ${[resolvedPath]}`.run();
+				validationMsg = ' ✓ Multi-lang syntax OK';
+			} catch (e) {
+				const errPreview = content.slice(0, 1000).split('\n').slice(0, 20).join('\n');
+				throw new Error(`❌ SYNTAX ERROR in '${file}' (syntax_check.sh failed):\n${e.message}\n\nPREVIEW:\n${errPreview}\n\n... Fix syntax (quotes/backticks) and retry write_file.`);
+			}
+			if (hasShebang) {
+				await SH`chmod +x ${[resolvedPath]}`.run();
+				validationMsg += ' ✓ chmod +x';
+			}
+			
+			return `Successfully wrote to '${file}' (${Buffer.byteLength(content, 'utf8')} bytes).${validationMsg}`;
+		} catch (e) {
+			throw new Error(`Failed to write '${file}': ${e.message}`);
+		}
+	}
+);
+
+tools.add(
+  'syntax_check',
+  'Standalone syntax validation for files (JS/Python/Bash/JSON/etc.) via utils/syntax_check.sh. Detects lang from ext/shebang.',
+  {
+    type: 'object',
+    properties: {
+      file: {
+        type: 'string',
+        description: `Relative path to the file within CWD.`
+      }
+    },
+    required: ['file']
+  },
+  async (params) => {
+    const file = params.file?.trim();
+    if (typeof file !== 'string' || !file) {
+      throw new Error('Valid relative file path required.');
+    }
+    const resolvedPath = path.resolve(process.cwd(), file);
+    if (!resolvedPath.startsWith(process.cwd())) {
+      throw new Error(`Path '${file}' escapes CWD scope.`);
+    }
+    const syntaxChecker = path.resolve(process.cwd(), 'utils/syntax_check.sh');
+    return await SH`${syntaxChecker} ${[resolvedPath]}`.run();
+  }
+);
+
+tools.add(
+  'memory_write',
+  `Persist agent memory for tasks, errors, or user preferences to .cache/memory.ndjson in CWD (${user.cwd}). Use to store decisions, tasks, errors, or prefs for later recall. Agent should use this to avoid repeating work or token burn on loops.`,
+  {
+    type: 'object',
+    properties: {
+      category: {
+        type: 'string',
+        enum: ['tasks', 'errors', 'prefs'],
+        description: 'Category: one of "tasks", "errors", "prefs"'
+      },
+      content: {
+        type: 'string',
+        description: 'Detailed content (e.g., "Pending task: implement runWithMemory optimization", "Error: loop burning tokens", "Pref: temperature=0.2 for decisions")'
+      }
+    },
+    required: ['category', 'content']
+  },
+  async ({category, content}) => {
+    if (!['tasks', 'errors', 'prefs'].includes(category)) {
+      throw new Error(`Invalid category '${category}'. Must be 'tasks', 'errors', or 'prefs'.`);
+    }
+    const memoryPath = path.join(process.cwd(), '.cache', 'memory.ndjson');
+    const dir = path.dirname(memoryPath);
+    try {
+      await fs.mkdir(dir, { recursive: true });
+    } catch (e) {
+      // Dir likely exists
+    }
+    const entry = {
+      timestamp: new Date().toISOString(),
+      category,
+      content: content.trim()
+    };
+    await fs.appendFile(memoryPath, JSON.stringify(entry) + '\n', 'utf8');
+    return `✓ Memory stored: [${category}] ${content.length > 50 ? content.slice(0, 47) + '...' : content}`;
+  }
+);
+
+tools.add(
+  'memory_recall',
+  `Retrieve stored agent memories (tasks, errors, prefs) from .cache/memory.ndjson in CWD (${user.cwd}). Use before acting to check prior decisions/tasks/errors/prefs. Query by keyword or category; empty lists recent.`,
+  {
+    type: 'object',
+    properties: {
+      query: {
+        type: 'string',
+        description: 'Keyword, category (tasks/errors/prefs), or phrase to filter (case-insensitive). Empty/omit lists last 20.'
+      }
+    },
+    required: []
+  },
+  async (params = {}) => {
+    const memoryPath = path.join(process.cwd(), '.cache', 'memory.ndjson');
+    let content;
+    try {
+      content = await fs.readFile(memoryPath, 'utf8');
+    } catch (e) {
+      return 'No memories stored yet. Use memory_write first.';
+    }
+    const lines = content.trim().split('\n').filter(l => l.trim());
+    const memories = [];
+    for (const line of lines) {
+      try {
+        memories.push(JSON.parse(line));
+      } catch {
+        // Skip invalid lines
+      }
+    }
+    if (!params.query || !params.query.toString().trim()) {
+      const recent = memories.slice(-20).reverse();
+      return recent.length 
+        ? 'Recent memories:\n' + recent.map(m => `• ${m.timestamp.slice(0, 19).replace('T', ' ')} [${m.category}] ${m.content}`).join('\n')
+        : 'No memories stored.';
+    }
+    const q = params.query.toString().toLowerCase();
+    const matches = memories.filter(m => 
+      m.category.toLowerCase().includes(q) || m.content.toLowerCase().includes(q)
+    );
+    return matches.length 
+      ? `Matches for "${params.query}":\n` + matches.slice(0, 20).map(m => `• ${m.timestamp.slice(0, 19).replace('T', ' ')} [${m.category}] ${m.content}`).join('\n')
+      : `No memories match "${params.query}".`;
+  }
+);
+
+export default tools

package/lib/index.js

@@ -1,11 +1,12 @@
 import {request as gpt} from './API/openai.com/reponses/text.js';
-import {request as grok} from './API/x.ai/text.js';
+import {request as xai} from './API/x.ai/responses.js';
 import {request as claude} from './API/anthropic.com/text.js';
 import {request as brave} from './API/brave.com/search.js';
 
 import { env, GLOBAL } from './fafs.js';
 import ToolSet from './ToolSet.js';
 import AgentServer from './AgentServer.js';
+import AgentManager from './AgentManager.js';
 import AgentClient from './AgentClient.js';
 import Session from './Session.js';
 import Prompt from './Prompt.js';
@@ -14,7 +15,7 @@ import Cli from './Cli.js';
 const API = {
 	text:{
 	 gpt,
-	 grok,
+	 xai,
 	 claude
   },
   search: {
@@ -22,6 +23,7 @@ const API = {
   },
 }
 export {
+	AgentManager,
   AgentServer,
   AgentClient,
   Prompt,

package/lib/wsCli.js

@@ -0,0 +1,256 @@
+#!/usr/bin/env -S node
+/*
+ * WebSocket client for a hello-dave server with auto-reconnect and improved structure.
+ * user CLI 
+ */
+import cli from '@j-o-r/cli';
+import { WebSocketClient } from "@j-o-r/apiserver";
+import { SH } from '@j-o-r/sh';
+
+const OPEN = 1; // WebSocket.OPEN
+
+
+/**
+ * Copy text to the clipboard using xclip.
+ * @param {string} text
+ * @returns {Promise<void>}
+ */
+const copyToClipboard = async (text) => {
+	if (typeof text !== 'string') return;
+	if (text === '') text = ' ';
+	const prams = ['-selection', 'clipboard'];
+	await SH`xclip ${prams}`.options({ stdio: 'inherit' }).run(text);
+};
+/**
+* Launch a CLI to an Agent Server
+* @param {string} connectUrl - Websocket server endpoint to connect to
+* @param {string} [secret] - Secret websocket connection key
+*/
+export default (connectUrl, secret = '') => {
+	let ws;
+	let busy = false;
+	let lastMessage = '';
+	const pendingRequests = new Map();
+	if (secret !== '') {
+		secret = Buffer.from(secret).toString('base64');
+	}
+
+	/**
+	 * Connect to the WebSocket server (with handlers).
+	 * Sets up reconnection on close.
+	 */
+	const connect = () => {
+		if (ws && ws.readyState === OPEN) {
+			console.log('Already connected');
+			return;
+		}
+		const url = connectUrl + '?wssrc_id=' + secret;
+		console.log(`Connecting to ${url}`);
+		ws = new WebSocketClient(url);
+
+		ws.onopen = () => {
+			console.log('Connected to server');
+			// Send introduction (no pending request for this)
+			const id = Date.now();
+			ws.send(JSON.stringify({
+				action: 'user_introduction',
+				content: '',
+				id
+			}));
+			cli.focus('user', true);
+		};
+
+		ws.onmessage = (m) => {
+			try {
+				const data = JSON.parse(m.data);
+				const msgId = data.id;
+				if (msgId && pendingRequests.has(msgId)) {
+					const { resolve, timeout } = pendingRequests.get(msgId);
+					clearTimeout(timeout);
+					pendingRequests.delete(msgId);
+					resolve(data);
+				}
+				// Ignore unsolicited messages for now
+			} catch (e) {
+				console.error('Error parsing WebSocket message:', e, m.data);
+			}
+		};
+
+		ws.onclose = (event) => {
+			console.log('Connection closed (reconnecting in 5s):', event.code, event.reason || 'No reason');
+			// Reject all pending requests
+			for (const [id, { reject, timeout }] of pendingRequests) {
+				clearTimeout(timeout);
+				reject(new Error(`Connection closed (${event.code})`));
+				pendingRequests.delete(id);
+			}
+			// Auto-reconnect
+			setTimeout(connect, 5000);
+		};
+
+		ws.onerror = (event) => {
+			console.error('WebSocket error:', event.toString());
+		};
+	};
+
+	/**
+	 * Send a message and await response.
+	 * Handles response actions and UI updates.
+	 * @param {Object} message - Message object (action, content)
+	 * @returns {Promise<Object>} Response data
+	 */
+	const sendMessage = async (message) => {
+		if (!ws || ws.readyState !== OPEN) {
+			throw new Error('WebSocket not connected');
+		}
+
+		const id = Date.now();
+		message.id = id;
+		busy = true;
+		cli.startSpinner();
+
+		const promise = new Promise((resolve, reject) => {
+			const timeout = setTimeout(() => {
+				if (pendingRequests.has(id)) {
+					pendingRequests.delete(id);
+					reject(new Error('Request timeout (12 hours)'));
+				}
+			}, 1000 * 60 * 60 * 12); // 12 hours
+			pendingRequests.set(id, { resolve, reject, timeout });
+		});
+
+		try {
+			ws.send(JSON.stringify(message));
+			const response = await promise;
+
+			// Handle specific response actions
+			if (response.action === 'server_response') {
+				cli.focus('assistant');
+				cli.write(response.content);
+				lastMessage = response.content;
+			} else if (response.action === 'server_info') {
+				cli.focus('util');
+				cli.write(response.content);
+			} else if (response.action === 'server_reset') {
+				cli.clear();
+			} else if (response.action === 'server_sessionlist') {
+				const list = response.content;
+				const selected = await cli.select('Select your session: ', list);
+				if (selected && selected !== 'NONE') {
+					await sendMessage({ action: 'user_loadsession', content: selected });
+				}
+			} else if (response.action === 'server_sessionloaded') {
+				cli.clear();
+				const messages = response.content;
+				messages.forEach((msg) => {
+					cli.focus(msg.role);
+					cli.write(msg.content);
+					lastMessage = msg.content;
+				});
+			}
+			// Other actions ignored
+			return response;
+		} catch (e) {
+			console.error('Request error:', e.message);
+		} finally {
+			if (pendingRequests.has(id)) {
+				const { timeout } = pendingRequests.get(id);
+				clearTimeout(timeout);
+				pendingRequests.delete(id);
+			}
+			busy = false;
+			cli.stopSpinner();
+			cli.focus('user', true);
+		}
+	};
+
+	// Register key mappings
+	cli.registerKeyMappings([
+		// ALT-C: Clear screen
+		{
+			name: 'c', ctrl: false, meta: true, shift: false,
+			handler: async () => {
+				if (!busy) {
+					cli.clear();
+				}
+			}
+		},
+		// ALT-R: Reset session
+		{
+			name: 'r', ctrl: false, meta: true, shift: false,
+			handler: async () => {
+				if (!busy) {
+					await sendMessage({ action: 'user_reset', content: '' });
+				}
+			}
+		},
+		// ALT-S: Session list
+		{
+			name: 's', ctrl: false, meta: true, shift: false,
+			handler: async () => {
+				if (!busy) {
+					await sendMessage({ action: 'user_sessionlist', content: '' });
+				}
+			}
+		},
+		// ALT-I: Server info
+		{
+			name: 'i', ctrl: false, meta: true, shift: false,
+			handler: async () => {
+				if (!busy) {
+					await sendMessage({ action: 'user_info', content: '' });
+				}
+			}
+		},
+		// ALT-M: Copy last message
+		{
+			name: 'm', ctrl: false, meta: true, shift: false,
+			handler: async () => {
+				if (!busy && lastMessage) {
+					await copyToClipboard(lastMessage);
+					cli.focus('util');
+					cli.write('Copied last message to clipboard');
+					cli.focus('user', true);
+				}
+			}
+		},
+		// CTRL-K: Help
+		{
+			name: 'k', ctrl: true, meta: false, shift: false,
+			handler: async () => {
+				cli.focus('util');
+				cli.write(`
+Available keys:
+• ALT-C: Clear screen
+• ALT-R: Reset session
+• ALT-I: Server info
+• ALT-S: List/load sessions
+• ALT-M: Copy last message
+• CTRL-K: Show help
+• CTRL-D: Exit
+`.trim());
+				cli.focus('user', true);
+			}
+		}
+	]);
+
+	// Input handler for user messages
+	cli.inputHandler = async (s) => {
+		if (busy || !s || !s.trim()) {
+			return;
+		}
+		await sendMessage({
+			action: 'user_request',
+			content: s.trim()
+		});
+	};
+
+	// Initialize
+
+	cli.focus('log');
+	cli.write('Connecting... (ALT-I for info, CTRL-K for keys, CTRL-D to exit)');
+
+	connect();
+
+}
+