@j-o-r/hello-dave 0.1.1 → 0.1.5

package/bin/dave.js

@@ -1,194 +1,446 @@
 #!/usr/bin/env -S node
+import fs from 'node:fs';
 import path from 'node:path';
-import cli from '@j-o-r/cli';
-import { AgentManager, wsCli, wsIO } from '@j-o-r/hello-dave';
-import { SH, parseArgs, readIn, bashEscape } from '@j-o-r/sh';
 import { fileURLToPath } from 'node:url';
+import cli from '@j-o-r/cli';
+import { SH, parseArgs, readIn } from '@j-o-r/sh';
+import { AgentLauncher, listToolsets, renderToolsetList, renderToolsetsHelp } from '@j-o-r/hello-dave';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-const pipedInput = await readIn();
-const args = parseArgs();
 
+/**
+ * Convert a command path to the public CLI command name.
+ *
+ * @param {string | undefined} commandPath Path used to invoke the command.
+ * @param {string} fallback Fallback command name.
+ * @returns {string} Extensionless command basename.
+ */
+function commandNameFromPath(commandPath, fallback) {
+  if (typeof commandPath !== 'string' || commandPath.trim().length === 0) return fallback;
+  const base = path.basename(commandPath);
+  return base.endsWith('.js') ? base.slice(0, -3) : base;
+}
+
+/**
+ * Find the nearest package.json by walking upward from a start directory.
+ *
+ * @param {string} startDir Directory where the search starts.
+ * @returns {string | null} Absolute package.json path, or null when not found.
+ */
+function findNearestPackageJson(startDir) {
+  let dir = path.resolve(startDir);
+  while (true) {
+    const candidate = path.join(dir, 'package.json');
+    if (fs.existsSync(candidate)) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+/**
+ * Read the npm package name for the package that owns this bin script.
+ *
+ * @param {string} startDir Directory inside the owning package.
+ * @param {string} fallback Fallback package name.
+ * @returns {string} npm package name.
+ */
+function packageNameFromNearestPackageJson(startDir, fallback) {
+  const packageJsonPath = findNearestPackageJson(startDir);
+  if (!packageJsonPath) return fallback;
+  try {
+    const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    return typeof pkg.name === 'string' && pkg.name.trim().length > 0 ? pkg.name.trim() : fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+/**
+ * Resolve the absolute path to an installed module entry point.
+ *
+ * @param {string} specifier Package import specifier.
+ * @returns {string | null} Absolute module entry path, or null when unavailable.
+ */
+function moduleEntryPath(specifier) {
+  try {
+    return fileURLToPath(import.meta.resolve(specifier));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Resolve a utility script shipped by @j-o-r/hello-dave.
+ *
+ * @param {string} scriptName Utility script basename, e.g. list_sessions.sh.
+ * @returns {string} Absolute utility script path.
+ */
+function helloDaveUtilityPath(scriptName) {
+  const moduleEntry = moduleEntryPath('@j-o-r/hello-dave');
+  const candidates = [
+    moduleEntry ? path.resolve(path.dirname(moduleEntry), '..', 'utils', scriptName) : null,
+    path.resolve(__dirname, '..', 'utils', scriptName)
+  ].filter(Boolean);
+
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) return candidate;
+  }
+
+  throw new Error(`Cannot find @j-o-r/hello-dave utility script: ${scriptName}`);
+}
+
+/**
+ * Capitalize a CLI command name for greeting text.
+ *
+ * @param {string} name CLI command name.
+ * @returns {string} Display name.
+ */
+function titleName(name) {
+  return name.length > 0 ? name[0].toUpperCase() + name.slice(1) : name;
+}
+
+/**
+ * Execute a utility script through @j-o-r/sh and return stdout/stderr.
+ *
+ * @param {string} file Absolute executable file path.
+ * @param {string[]} [args] Arguments passed safely as command arguments.
+ * @returns {Promise<string>} Process output.
+ */
+async function runExecutable(file, args = []) {
+  return await SH`${[file, ...args]} 2>&1`.options({ maxBuffer: 64 * 1024 * 1024 }).run();
+}
+
+/**
+ * Ask a yes/no question through @j-o-r/cli, but never block non-interactive stdin.
+ *
+ * @param {string} question Prompt text.
+ * @returns {Promise<boolean>} Whether the user answered yes.
+ */
+async function yesNo(question) {
+  if (!process.stdin.isTTY) return false;
+  return await cli.yesNo(question);
+}
+
+/**
+ * Print all discoverable agents in the standard CLI format.
+ *
+ * @param {Array<{name: string, path: string, desc?: string}>} agents Discoverable agents.
+ * @returns {void}
+ */
+function printAgentList(agents) {
+  if (agents.length === 0) {
+    console.log('  (no agents found)');
+    return;
+  }
+
+  for (const agent of agents) {
+    console.log(`  ${agent.name}`);
+    console.log(`    path: ${agent.path}`);
+    const desc = typeof agent.desc === 'string' && agent.desc.trim()
+      ? agent.desc.trim().replace(/\s+/g, ' ')
+      : '[ERROR]';
+    console.log(`    desc: ${desc.length > 140 ? desc.slice(0, 137) + '...' : desc}`);
+  }
+}
+
+/**
+ * Build a generic CLI help message.
+ *
+ * @param {string} cliName Public CLI command name.
+ * @param {string} npmPackageName Owning npm package name.
+ * @returns {string} Help text.
+ */
+function helpText(cliName, npmPackageName) {
+  return `
+Hello, ${titleName(cliName)}.
+
+${cliName} — a calm, reliable interface.
+
+Usage:
+  ${cliName} [agent] [message...]          # global install: npm install -g ${npmPackageName}
+                                     #   then just run: ${cliName} (or ${cliName} --help) — no npx, no long name
+  npx ${npmPackageName} [agent] [message...]   # without global install
+                                     #   (recommended: add a shell alias, e.g. in ~/.zshrc or ~/.bashrc)
+                                     #   alias npx${cliName}='npx ${npmPackageName}'
+                                     #   then use: npx${cliName} --help
+  ${cliName} --parameter ...
+
+Agent parameters (passed after the agent name):
+  Example: ${cliName} ask_agent --info
+
+  --info
+    Show information about the loaded agent (name, session, prompt, etc.).
+
+  --help
+    Show help specific to that agent.
+
+  [message...]
+    Send a one-shot message to the agent.
+    If no message is provided (and no piped input), starts the interactive CLI.
+
+  (no extra args)
+    Start the interactive CLI for the agent.
+
+Built-in ${cliName} commands / flags:
+  --help
+    Show this help message.
+
+  --clear
+    Clear the entire session cache.
+
+  --search "[query]"
+    Search through saved session history.
+
+  --list
+    List recent sessions.
+
+  --inspect "[log.ndjson]" [--last 20|-n 20]
+    Pretty-print / inspect a session log file. Defaults to the last 20 events.
+
+  --list-agents
+    List all discoverable agents (via AgentLauncher).
+
+  --toolsets [filter...] [--json]
+    List toolsets exposed via API.toolset.
+    Filters match provider (e.g. minimax), type (e.g. image, music), or path.
+    Examples:
+      ${cliName} --toolsets
+      ${cliName} --toolsets image
+      ${cliName} --toolsets minimax music
+      ${cliName} --toolsets --json
+
+Running agents:
+  Bare (non -flag) words are always treated as agent names.
+  Project-local agents in ./agents/ take precedence over built-in package agents.
+
+  Only bare names (as the first argument) are supported.
+
+  Two main modes:
+
+    Interactive CLI (no message):
+      ${cliName} ask_agent
+      npx ${npmPackageName} ask_agent   (or your npx${cliName} alias)
+
+    One-shot (message provided or piped input):
+      ${cliName} code_agent "Refactor lib/Session.js"
+      npx ${npmPackageName} code_agent "Refactor lib/Session.js"
+      echo "hello" | ${cliName} some_agent
+      echo "hello" | npx ${npmPackageName} some_agent
+
+  Agents are loaded and executed via AgentLauncher (supports one-shot direct calls and interactive CLI).
+`;
+}
+
+/**
+ * Print help and exit.
+ *
+ * @param {number} exitCode Process exit code.
+ * @returns {never}
+ */
 function printHelp(exitCode = 0) {
-	console.log(`
-FLAGS:
---help : Show this help
---clear : Removes the entire 'hello-dave' cache (chat history etc.)
---search "[search_query_or_regex]" : Search in cache history
---list : List all agent sessions in this folder
---inspect "[path_to_ndjson_log]" : Inspect, Format and output a ndjson log file
---connect [ws://url] [--secret "..."] : Connect to Agent websocket server
-  Interactive: bin/dave.js --connect 'ws://localhost:8080' --secret '123'
-  Piped actions:
-    echo "predict the weather" | bin/dave.js --connect 'ws://...' --secret '123'  # user_request
-    echo "user_info" | bin/dave.js --connect 'ws://...' --secret '123'           # user_info
-    echo "user_reset" | bin/dave.js --connect 'ws://...' --secret '123'          # user_reset
---ask [--connect [ws://url]] [--secret "..."] [--model modelname] : Ask agent locally (XAIKEY req.) or remote
-  Local:        bin/dave.js --ask [--model grok-4-1-fast-reasoning]
-  Remote:       bin/dave.js --ask --connect 'ws://localhost:8080' --secret '123'
-  Piped local:  echo "predict the weather" | bin/dave.js --ask
-  Piped remote: echo "predict the weather" | bin/dave.js --ask --connect 'ws://...' --secret '123'
---code [port] [--secret "..."] : Launch CodeServer PM2 cluster via agents/codeserver.sh
-  Usage: bin/dave.js --code 8080 --secret 123
+  console.log(helpText(cliName, npmPackageName));
+  process.exit(exitCode);
+}
+
+/**
+ * Add piped input as the one-shot agent message when no message argument exists.
+ *
+ * @param {string} pipedInput Text read from stdin.
+ * @returns {void}
+ */
+function appendPipedAgentMessage(pipedInput) {
+  const currentArgs = process.argv.slice(2);
+  const positionals = currentArgs.filter((arg) => !arg.startsWith('--'));
+  const hasMessageInArgv = positionals.length > 1;
+  const message = pipedInput.replace(/\r?\n$/, '').replace(/\r$/, '').trim();
+
+  if (!hasMessageInArgv && message.length > 0) {
+    process.argv.push(message);
+  }
+}
+
+/**
+ * Run a named agent through AgentLauncher.
+ *
+ * @param {AgentLauncher} launcher Agent launcher instance.
+ * @param {string} agentName Agent name from argv.
+ * @param {string} pipedInput Text read from stdin.
+ * @returns {Promise<void>}
+ */
+async function runAgent(launcher, agentName, pipedInput) {
+  try {
+    await launcher.load(agentName);
+  } catch (err) {
+    console.error(`Failed to load agent "${agentName}": ${err.message}`);
+    try {
+      const agents = await launcher.list();
+      if (agents.length > 0) {
+        console.log('\nAvailable agents:');
+        printAgentList(agents);
+      }
+    } catch {}
+    process.exit(1);
+  }
+
+  if (process.argv.slice(2).includes('--help')) {
+    console.log(`
+Usage: ${cliName} ${agentName} [message...]
+       npx ${npmPackageName} ${agentName} [message...]
+       ${cliName} ${agentName} --info
+       ${cliName} ${agentName}          # starts interactive CLI
+
+Loaded via AgentLauncher.
+
+Modes:
+  ${cliName} ${agentName}                    → interactive CLI session
+  ${cliName} ${agentName} "your message"     → one-shot response
+  echo "..." | ${cliName} ${agentName}       → one-shot from piped input
+
+  ${cliName} ${agentName} --info
+  ${cliName} ${agentName} --help
 `);
-	process.exit(exitCode)
-}
-
-// Make sure an action is defined
-const actions = ['help', 'clear', 'search', 'list', 'inspect', 'connect', 'code', 'ask'];
-if (!actions.some(key => args[key])) {
-	printHelp(1);
-}
-
-if (args.help) {
-	printHelp();
-}
-
-if (args.clear) {
-	const clear_sessions = path.resolve(__dirname, '..', 'utils', 'clear_sessions.sh');
-	const y = await cli.yesNo('Delete entire cache? (y/n) ');
-	if (y) {
-		console.log(clear_sessions);
-		const res = await SH`${clear_sessions}`.run();
-		console.log(res);
-	}
-	process.exit();
-} else if (args.search) {
-	const history_search = path.resolve(__dirname, '..', 'utils', 'search_sessions.sh');
-	if (typeof args.search !== 'string') {
-		printHelp(1);
-	}
-	const res = await SH`${history_search} "${bashEscape(args.search)}"`.run();
-	console.log(res);
-	process.exit();
-} else if (args.list) {
-	const list = path.resolve(__dirname, '..', 'utils', 'list_sessions.sh');
-	const res = await SH`${list}`.run();
-	console.log(res);
-	process.exit();
-} else if (args.inspect) {
-	const format = path.resolve(__dirname, '..', 'utils', 'format_log.js');
-	if (typeof args.inspect !== 'string') {
-		printHelp(1);
-	}
-	try {
-		const res = await SH`${format} "${bashEscape(args.inspect)}"`.run();
-		console.log(res);
-	} catch (e) {
-		console.error(e);
-		process.exit(1);
-	}
-} else if (args.ask) {
-	let secret = args.secret || '';
-	if (args.connect) {
-		// Remote mode: same as --connect
-		if (typeof pipedInput === 'string' && pipedInput.trim() !== '') {
-			// Piped input mode: use wsIO for one-shot actions
-			let action, input;
-			const trimmed = pipedInput.trim();
-			if (trimmed === 'user_info' || trimmed === 'user_reset') {
-				action = trimmed;
-				input = '';
-			} else {
-				action = 'user_request';
-				input = trimmed;
-			}
-
-			try {
-				const response = await wsIO(args.connect, secret, action, input);
-				console.log(JSON.stringify(response.content, null, '  '));
-			} catch (e) {
-				console.error(`Error: ${e.message}`);
-				process.exit(1);
-			}
-		} else {
-			// No piped input: interactive wsCli mode
-			wsCli(args.connect, secret);
-		}
-	} else {
-		// Local mode
-		const name = 'ask_dave';
-		const api = 'xai';
-		const contextWindow = 1900000;
-		const toolsetMode = 'auto';
-		/** @type {import('lib/API/x.ai/responses.js').XAIOptions} */
-		const options = {
-			tools: []
-		};
-		options.tools.push({ type: 'web_search' });
-		options.tools.push({ type: 'x_search' });
-		options.model = args.model || 'grok-4.20-reasoning';
-		options.temperature = 0.2;
-		// options.reasoning = { effort: 'medium', summary: 'auto' };
-
-		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 });
-		agent.setup({
-			prompt,
-			api,
-			options,
-			toolsetMode,
-			contextWindow
-		});
-		agent.addGenericToolcall('open_link');
-		agent.addGenericToolcall('send_email');
-		agent.addGenericToolcall('history_search');
-
-		const cliIntro = `
-${name} (${options.model}).
-- context: ${contextWindow}
-		`.trim();
-		const description = `Ask dave, he knows.`.trim();
-
-		// Support piped one-shot (like --connect), else interactive CLI
-		if (typeof pipedInput === 'string' && pipedInput.trim() !== '') {
-			try {
-				const response = await agent.directCall(pipedInput.trim());
-				console.log(response);
-			} catch (e) {
-				console.error(`Error: ${e.message}`);
-				process.exit(1);
-			}
-		} else {
-			await agent.start(undefined, undefined, cliIntro, name, description);
-		}
-	}
-} else if (args.connect) {
-	// Pure --connect (no --ask): same logic
-	let secret = args.secret || '';
-
-	if (typeof pipedInput === 'string' && pipedInput.trim() !== '') {
-		// Piped input mode: use wsIO for one-shot actions
-		let action, input;
-		const trimmed = pipedInput.trim();
-		if (trimmed === 'user_info' || trimmed === 'user_reset') {
-			action = trimmed;
-			input = '';
-		} else {
-			action = 'user_request';
-			input = trimmed;
-		}
-
-		try {
-			const response = await wsIO(args.connect, secret, action, input);
-			console.log(response.content);
-		} catch (e) {
-			console.error(`Error: ${e.message}`);
-			process.exit(1);
-		}
-	} else {
-		// No piped input: interactive wsCli mode
-		wsCli(args.connect, secret);
-	}
-} else if (args.code) {
-	const port = parseInt(args.code || '8080');
-	const secret = (args.secret || '').trim() || '123';
-	const server = path.resolve(__dirname, '..', 'examples', 'codeserver.sh');
-	const RES = await SH`${server} ${port} ${bashEscape(secret)}`.run();
-	console.log(RES);
-	process.exit(0);
+    const active = launcher.getActiveAgent();
+    if (active && typeof active.info === 'function') {
+      try {
+        console.log(active.info());
+      } catch {}
+    }
+    process.exit(0);
+  }
+
+  appendPipedAgentMessage(pipedInput);
+  await launcher.run();
+}
+
+/**
+ * Get the log path passed to --inspect.
+ *
+ * @param {{inspect?: boolean | string, _: string[]}} args Parsed CLI args.
+ * @returns {string} Log file path.
+ */
+function inspectFilePath(args) {
+  if (typeof args.inspect === 'string') return args.inspect;
+  if (Array.isArray(args._) && typeof args._[0] === 'string') return args._[0];
+  printHelp(1);
 }
+
+/**
+ * Build optional --last arguments forwarded to format_log.js.
+ *
+ * @param {{last?: boolean | string, n?: boolean | string}} args Parsed CLI args.
+ * @returns {string[]} CLI arguments to forward.
+ */
+function inspectLastArgs(args) {
+  const value = args.last ?? args.n;
+  if (value === undefined) return [];
+  if (typeof value !== 'string' || !/^[1-9]\d*$/.test(value)) printHelp(1);
+  return ['--last', value];
+}
+
+/**
+ * Build toolset filters from parsed CLI arguments.
+ *
+ * @param {{toolsets?: boolean | string, _: string[]}} args Parsed CLI args.
+ * @returns {string[]} Toolset filters.
+ */
+function toolsetFilters(args) {
+  const filters = Array.isArray(args._) ? [...args._] : [];
+  return typeof args.toolsets === 'string' ? [args.toolsets, ...filters] : filters;
+}
+
+/**
+ * Run the built-in CLI commands.
+ *
+ * @param {AgentLauncher} launcher Agent launcher instance.
+ * @returns {Promise<void>}
+ */
+async function runBuiltins(launcher) {
+  const args = parseArgs(rawArgv);
+  const hasCliAction = Object.keys(args).some((key) => BUILTIN_COMMANDS.has(key));
+
+  if (!hasCliAction) printHelp(1);
+  if (args.help && args.toolsets === undefined) printHelp(0);
+
+  if (args.clear) {
+    const script = helloDaveUtilityPath('clear_sessions.sh');
+    if (await yesNo('Delete entire cache? (y/n) ')) {
+      console.log(script);
+      console.log(await runExecutable(script));
+    }
+    process.exit(0);
+  }
+
+  if (args.search) {
+    if (typeof args.search !== 'string') printHelp(1);
+    console.log(await runExecutable(helloDaveUtilityPath('search_sessions.sh'), [args.search]));
+    process.exit(0);
+  }
+
+  if (args.list) {
+    console.log(await runExecutable(helloDaveUtilityPath('list_sessions.sh')));
+    process.exit(0);
+  }
+
+  if (args.inspect) {
+    try {
+      console.log(await runExecutable(helloDaveUtilityPath('format_log.js'), [
+        ...inspectLastArgs(args),
+        inspectFilePath(args)
+      ]));
+      process.exit(0);
+    } catch (err) {
+      console.error(err);
+      process.exit(1);
+    }
+  }
+
+  if (args.toolsets !== undefined) {
+    if (args.help) {
+      console.log(renderToolsetsHelp(`${cliName} --toolsets`));
+      process.exit(0);
+    }
+    const result = listToolsets({ filters: toolsetFilters(args) });
+    console.log(args.json ? JSON.stringify(result, null, 2) : renderToolsetList(result));
+    process.exit(0);
+  }
+
+  if (args['list-agents']) {
+    try {
+      console.log('\nAvailable agents (via AgentLauncher):');
+      printAgentList(await launcher.list());
+      console.log(`\nUsage: ${cliName} <name> [message...]   (or npx ${npmPackageName} <name> [message...])`);
+    } catch (err) {
+      console.error('Error listing agents via AgentLauncher:', err.message);
+    }
+    process.exit(0);
+  }
+}
+
+const cliName = commandNameFromPath(process.argv[1], 'dave');
+const npmPackageName = packageNameFromNearestPackageJson(__dirname, '@j-o-r/hello-dave');
+
+/** Flag names that trigger built-in CLI behavior. */
+const BUILTIN_COMMANDS = new Set([
+  'help',
+  'clear',
+  'search',
+  'list',
+  'inspect',
+  'list-agents',
+  'toolsets'
+]);
+
+const rawArgv = process.argv.slice(2);
+const agentName = rawArgv.length > 0 && !rawArgv[0].startsWith('-') ? rawArgv[0] : null;
+const pipedInput = (await readIn()) ?? '';
+const launcher = new AgentLauncher({ from: import.meta.url });
+
+if (agentName) {
+  await runAgent(launcher, agentName, pipedInput);
+} else {
+  await runBuiltins(launcher);
+}
+
+/* ===================== End of CLI entry ===================== */