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

package/lib/genericToolset.js

@@ -1,5 +1,17 @@
-import { SH } from '@j-o-r/sh'
+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);
+
+// STANDARDIZED UTILS PATHS (hoisted constants for performance/consistency)
+const utilsDir = path.resolve(__dirname, '..', 'utils');
+const searchSessionsSh = path.join(utilsDir, 'search_sessions.sh');
+const listSessionsSh = path.join(utilsDir, 'list_sessions.sh');
+const syntaxCheckSh = path.join(utilsDir, 'syntax_check.sh');
 
 const user = await env();
 const environment = ` 
@@ -33,27 +45,6 @@ const getJSError = (errorStr) => {
 	return result;
 }
 
-/**
-* bash escape a string suitable as an argument on the commandline
-* for javascript code
-* @param {string} x
-* @retruns {string}
-*/
-const bashEscape = (x) => {
-	let str = String(x).trim();
-	// the trick is to double escape escape vars first
-	str = str.replace(/\\/g, '\\\\');
-	// then add escaping for oddities
-	// Replace literal escape sequences like \n, \t, \r in quoted strings
-	str = str.replace(/(['"])\\(.)\1/g, '$1\\\\$2$1');
-	// escape $ (is a BASH var)
-	str = str.replace(/\$/g, '\\$');
-	// Escape backticks
-	str = str.replace(/`/g, '\\`');
-	// Escape quotes
-	str = str.replace(/"/g, '\\"');
-	return str;
-}
 tools.add(
 	'javascript_interpreter',
 	`Execute ESM ES6 javascript on \`node\`.`,
@@ -67,37 +58,21 @@ tools.add(
 		},
 		required: ['script']
 	},
-	// @ts-ignore
 	async (params) => {
-		// @ts-ignore
-		const script = bashEscape(params.script);
 		let response = '';
 		try {
-			// Execute script
-			response = await SH`node -e "${script}"`.run();
+			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)
+			const errorStr = e.toString();
+			response = getJSError(errorStr);
 		}
 		return response;
 	}
 );
-tools.add(
-	'bash_cmd',
-	`Execute a Bash command on ${user.system}.`,
-	{
-		type: 'object',
-		properties: {
-			command: {
-				type: 'string',
-				description: 'The bash command.',
-			}
-		},
-		required: ['command']
-	},
-	// @ts-ignore
-	async (params) => (await SH`${params.command}`.run())
-);
 tools.add(
 	'get_user_env', // name
 	'Get the user location, name and OS environment', // desciption
@@ -113,11 +88,11 @@ tools.add(
 
 tools.add(
 	'execute_bash_script',
-	'Execute a bash script.',
+	'Execute a bash script or command. (char escaping not needed)',
 	{
 		type: 'object',
 		properties: {
-			bash_script: { type: 'string', description: `The bash script to execute (${user.system})` }
+			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']
 	},
@@ -129,27 +104,6 @@ ${delim}
 `.run()
 	}
 );
-/*
-### nu shell Assumptions and Prerequisites
-- You can install it via your package manager (e.g., on Ubuntu: `sudo apt install nushell` or download from the [official Nushell releases](https://github.com/nushell/nushell/releases)).
-- The tool will use a heredoc approach (similar to the Bash tool) to pass the script content to `nu` for execution. This ensures multi-line scripts work reliably.
-- The output from `nu` will be returned as-is, preserving its structured format (e.g., tables or JSON), which is beneficial for LLM consumption.o
-*/
-tools.add(
-	'execute_nushell_script',
-	'Execute a Nushell script.',
-	{
-		type: 'object',
-		properties: {
-			nushell_script: { type: 'string', description: `The Nushell script to execute (${user.system})` }
-		},
-		required: ['nushell_script']
-	},
-	async (params) => {
-		const script = bashEscape(params.nushell_script);
-		return await SH`nu -c "${script}"`.run()
-	}
-);
 
 tools.add(
 	'send_email',
@@ -176,11 +130,11 @@ ${delim}
 );
 tools.add(
 	'open_link',
-	'Open an url in local user environment.',
+	'Open an url or file in the local user environment. (xdg-open)',
 	{
 		type: 'object',
 		properties: {
-			url: { type: 'string', description: 'Link to open' }
+			url: { type: 'string', description: 'file | URL' }
 		},
 		required: ['url']
 	},
@@ -190,18 +144,17 @@ tools.add(
 );
 tools.add(
 	'execute_remote_script',
-	'Execute a script (bash, nu, python, javascript) on a remote machine via SSH. Default type: nu.',
+	'Execute bash script on a remote machine via SSH.',
 	{
 		type: 'object',
 		properties: {
-			type: { type: 'string', enum: ['bash','nu','python','javascript'], description: 'Type of script (default: bash)' },
 			url: { type: 'string', description: 'SSH URL, e.g., ssh://user@host or ssh://user@host:port' },
-			script: { type: 'string', description: 'The script code to execute remotely' }
+			script: { type: 'string', description: 'RAW script code to execute remotely (no escaping needed)' }
 		},
 		required: ['url', 'script']
 	},
 	async (params) => {
-		const { url, type = 'bash', script } = params;
+		const { url, script } = params;
 		if (!url.startsWith('ssh://')) throw new Error('Invalid SSH URL');
 		const withoutProto = url.slice(6);
 		const parts = withoutProto.split(':');
@@ -212,23 +165,240 @@ tools.add(
 			port = parseInt(parts[1]);
 		}
 		const [user, host] = userHost.split('@');
-		if (!user || !host) throw new Error('Invalid SSH URL format');
-		let command;
-		if (type === 'nu') {
-			const escaped = bashEscape(script);
-			command = `nu -c "${escaped}"`;
-		} else {
-			const interpreters = { bash: 'bash', python: 'python3', javascript: 'node' };
-			const interpreter = interpreters[type];
-			if (!interpreter) throw new Error('Unsupported type');
-			const delim = `END_REMOTE_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
-			command = `${interpreter} <<'${delim}'
+		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) => {
+		if (typeof params.query === 'string' && params.query.trim() !== '') {
+			const escapedQuery = bashEscape(params.query);
+			return await SH`${searchSessionsSh} "${escapedQuery}"`.run();
+		} else {
+			return await SH`${listSessionsSh}`.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 hasShebang = content.startsWith('#!');
+
+			let validationMsg = '';
+			try {
+				await SH`${syntaxCheckSh} ${[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.`);
+		}
+		return await SH`${syntaxCheckSh} ${[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.';
 		}
-		return await SH`ssh -p ${port} ${user}@${host} '${command}'`.run()
+		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
+export default tools