@j-o-r/hello-dave 0.0.0

package/bin/hdConnect.js

@@ -0,0 +1,230 @@
+#!/usr/bin/env -S node
+/*
+* Websocket client for a hello-dave server
+*/
+import cli from '@j-o-r/cli';
+import { WebSocketClient } from "@j-o-r/apiserver";
+import { parseArgs, SH } from '@j-o-r/sh';
+const args = parseArgs();
+
+
+/**
+* Copy text to the clipboard
+* @param {string} text
+* @retruns {Promise<string>}
+*/
+const copyToClipboard = async (text) => {
+	if (typeof text !== 'string') return;
+	if (text === '') text = ' ';
+	const prams = [
+		'-selection',
+		'clipboard'
+	]
+	return SH`xclip ${prams}`.options({ stdio: 'inherit' }).run(text);
+}
+
+const HELP = () => {
+	console.log(
+		`
+hdConnect [url]
+
+usage:
+npx hdConnect ws:/127.0.0.1:8000/ws
+`.trim()
+	)
+	process.exit(1);
+}
+
+if (args._.length !== 1) {
+	HELP();
+}
+const connect = args._[0];
+let busy = false;
+let lastMessage = '';
+const pendingRequests = new Map(); // key: msg_id (or `${conn_id}:${msg_id}` if conn_id is available), value: {resolve, reject, timeout}                                                                                                                                                                                                                                     11:06:22 [32/1290]
+
+const ws = new WebSocketClient(connect);
+ws.onopen = () => {
+	ws.send(JSON.stringify({
+		action: 'user_introduction',
+		content: '',
+		id: new Date().getTime()
+	}));
+}
+/**
+* @param {MessageEvent} m
+*/
+ws.onmessage = (m) => {
+	try {
+		const data = JSON.parse(m.data);
+		const msgId = data.id; // Assume response has the same 'id' as the request
+		if (msgId && pendingRequests.has(msgId)) {
+			const { resolve, timeout } = pendingRequests.get(msgId);
+			clearTimeout(timeout); // Cancel the timeout
+			pendingRequests.delete(msgId);
+			resolve(data); // Resolve the promise with the response data
+		}
+	} catch (e) {
+		console.error('Error parsing WebSocket message:', e);
+	}
+}
+ws.onclose = () => {
+	console.log('Lost connection');
+	// Optionally, reject all pending requests here
+	for (const [id, { reject }] of pendingRequests) {
+		reject(new Error('Connection closed'));
+		pendingRequests.delete(id);
+	}
+}
+ws.onerror = (e) => {
+	console.error('WebSocket error:', e);
+	// Optionally, reject all pending requests on error
+	for (const [id, { reject }] of pendingRequests) {
+		reject(e);
+		pendingRequests.delete(id);
+	}
+}
+
+
+cli.registerKeyMappings([
+	{ // Clear the screen
+		//  ALT - c
+		name: 'c', ctrl: false, meta: true, shift: false, handler: async () => {
+			if (!busy) {
+				cli.clear();
+			}
+		}
+	},
+	{ // reset the session, empty the context from the prompt
+		//  ALT - r
+		name: 'r', ctrl: false, meta: true, shift: false, handler: async () => {
+			if (!busy) {
+				await sendMessage({
+					action: 'user_reset',
+					content: ''
+				});
+			}
+		}
+	},
+	{ // load a previous ssession
+		// ALT - s
+		name: 's', ctrl: false, meta: true, shift: false, handler: async () => {
+			if (!busy) {
+				await sendMessage({
+					action: 'user_sessionlist',
+					content: '',
+				});
+			}
+		}
+	},
+
+	{ // Request server info
+		// ALT - i
+		name: 'i', ctrl: false, meta: true, shift: false, handler: async () => {
+			if (!busy) {
+				await sendMessage({
+					action: 'user_info',
+					content: '',
+				});
+			}
+		}
+	},
+	{ // Copy last message to clipboard
+		name: 'm', ctrl: false, meta: true, shift: false, handler: async () => {
+			if (!busy) {
+			   const r = await copyToClipboard(lastMessage);
+				cli.focus('util');
+				cli.write('copied');
+				cli.focus('user', true);
+			}
+		}
+	},
+	{ // Show help /keys
+		name: 'k', ctrl: true, meta: false, shift: false, handler: async () => {
+			// cli.focus('util')
+			// cli.write(HELP)
+			// cli.focus('user', true);
+		}
+	}
+]);
+
+
+const sendMessage = async (m) => {
+	const id = new Date().getTime(); // Unique ID for the request
+	m.id = id;
+	busy = true;
+	ws.send(JSON.stringify(m));
+
+	// Create a promise and store it in pendingRequests
+	const promise = new Promise((resolve, reject) => {
+		const timeout = setTimeout(() => {
+			pendingRequests.delete(id);
+			reject(new Error('Request timeout')); // Timeout after 10 seconds (adjust as needed)
+		}, 1000 * 60 * 60 * 12); // 12 hours
+		pendingRequests.set(id, { resolve, reject, timeout });
+	});
+
+	cli.startSpinner(); // Start spinner while waiting
+	try {
+		const response = await promise; // Wait for the response
+		// Process the response here (e.g., log it or display it)
+		// console.log('Response received:', response);
+		if (response.action === 'server_response') {
+			cli.focus('assistant');
+			cli.write(response.content);
+			lastMessage = response.content;
+		}
+		if (response.action === 'server_info') {
+			cli.focus('util');
+			cli.write(response.content);
+		}
+		if (response.action === 'server_reset') {
+			cli.clear();
+		}
+		if (response.action === 'server_sessionlist') {
+			// Select a session to load
+			const list = response.content;
+			const selected = await cli.select('Select your session: ', list);
+			if (selected && selected !== 'NONE') {
+				return sendMessage({ action: 'user_loadsession', content: selected });
+			}
+		}
+		if (response.action === 'server_sessionloaded') {
+			// Putput the selected session messages
+			cli.clear();
+			const messages = response.content;
+			messages.forEach((msg) => {
+				cli.focus(msg.role);
+				cli.write(msg.content);
+				lastMessage = msg.content;
+			});
+		}
+	} catch (e) {
+		console.error('Error waiting for response:', e);
+		// Handle error (e.g., show error message to user)
+	} finally {
+		busy = false;
+		cli.stopSpinner(); // Stop spinner
+		cli.focus('user', true); // Give focus back to user input
+	}
+
+}
+
+// @ts-ignore
+cli.inputHandler = async (s) => {
+	if (!s || s.trim() === '') {
+		// busy = false;
+		// cli.focus('user', true); // Give focus back to user input
+		return;
+	}
+	const m = {
+		action: 'user_request',
+		content: s
+	}
+	await sendMessage(m);
+}
+
+cli.focus('log');
+cli.write('CTRL - d exit');
+cli.write('CTRL - r clear screen / reset');
+cli.focus('user', true);

package/bin/hdInspect.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env -S node
+import { CacheSync } from "@j-o-r/cache";
+import path from 'node:path';
+import { parseArgs, readIn } from '@j-o-r/sh';
+
+const args = parseArgs();
+if (args._.length !== 1) {
+	console.log(
+		`File as an argument`.trim()
+	)
+}
+const filePath = args._[0]; // or any relative/absolute path
+
+// folder
+const folder = path.resolve(path.dirname(filePath)); // 'a/b'
+
+// filename without extension
+const { name } = path.parse(filePath); // name = 'c'
+// or: const name2 = path.basename(filePath, path.extname(filePath));
+
+// extension (including dot)
+const ext = path.extname(filePath).slice(1); // '.txt'
+
+console.log({ folder, name, ext });
+
+const c = new CacheSync(folder, false, ext);
+const content = c.read(name);
+console.log(JSON.stringify(content, null, '  '));

package/bin/hdNpm.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+import AgentManager from '../lib/AgentManager.js';
+import { parseArgs, readIn } from '@j-o-r/sh';
+import { systemInfo } from '../lib/fafs.js';
+
+const name = 'hdNpm';
+const api = 'grok';
+
+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/text.js').XOptions} */
+const options = {}
+// 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-code-fast-1';
+}
+if (args['temperature']) {
+	options.temperature = parseFloat(args['temperature']);
+}
+if (args['tokens']) {
+	options.max_completion_tokens = parseInt(args['tokens']);
+}
+if (args['top_p']) {
+	options.top_p = parseFloat(args['top_p']);
+}
+options.search_parameters = { mode: 'auto' }
+const reasoning = args['reasoning'] ? args['reasoning'] : null;
+if (reasoning) {
+	// @ts-ignore
+	options.reasoning_effort = reasoning
+}
+
+const toolsetMode = 'auto';
+const contextWindow = args['context'] ? parseInt(args['context']) : 250000;
+
+// Copy from the generic toolset
+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|grok-3|grok-3-mini|grok-3-mini-fast|grok-code-fast-1]
+--top_p [float]: number > 0, 0.1 means no top_p
+--reasoning [low|high]
+--tools [javascript,bash] comma seperated list
+e.g.
+grok.js --model grok-3-mini --tokens 4000 --context 10000
+
+`);
+	process.exit()
+}
+
+if (help) {
+	printHelp();
+}
+
+const prompt = `
+Assume the module's root directory is the current working directory (cwd) and it's already installed. Inspect:
+- package.json: Extract name, version, description, dependencies, scripts, and entry points.
+- README.md: Summarize installation (noting it's already installed), usage examples, and key features.
+- types/ folder: List and describe TypeScript declaration files (e.g., interfaces, types) to explain the API.
+- node_modules/: Check for any 'module.md' files in installed dependencies and incorporate relevant additional information.
+- Additional files: If API or usage is unclear, inspect relevant files like source code or examples for clarification.
+
+Focus on enabling API usage. Generate markdown content with sections: Overview, Installation Notes, API Usage Examples, Full API Reference (from types and inspections), and Dependencies.
+Write the full markdown content to './module.md'.
+ `.trim();
+const agent = new AgentManager({ name });
+agent.setup({
+	prompt,
+	api,
+	options,
+	toolsetMode,
+	contextWindow
+});
+const toolset = agent.getToolset();
+if (toolset) {
+	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');
+	}
+}
+const cliIntro = `
+${name} ${options.model}.
+- search  ${options.search_parameters.mode}
+- context: ${contextWindow}
+`.trim();
+const description = `
+NPM module expert, creates api usage for this module.
+`.trim();
+
+if (input === '' && serve) {
+	agent.enableServer('code', description, serve);
+}
+if (input !== '') {
+	// Direct input output
+	const res = await agent.directCall(input);
+	console.log(res);
+} else if (connect) {
+	agent.attach('code', description, connect)
+} else {
+	agent.startCli(cliIntro);
+}

package/bin/hdPrompt.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+import AgentManager from '../lib/AgentManager.js';
+import { parseArgs, readIn } from '@j-o-r/sh';
+
+// const name = path.basename(fileURLToPath(import.meta.url), path.extname(fileURLToPath(import.meta.url)));
+const name = 'hdPrompt';
+const api = 'grok';
+
+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/text.js').XOptions} */
+const options = {}
+// 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';
+}
+if (args['temperature']) {
+	options.temperature = parseFloat(args['temperature']);
+}
+if (args['tokens']) {
+	options.max_completion_tokens = parseInt(args['tokens']);
+}
+if (args['top_p']) {
+	options.top_p = parseFloat(args['top_p']);
+}
+
+options.search_parameters = { mode: 'auto' }
+// @ts-ignore
+const reasoning = args['reasoning'] ? args['reasoning'] : null;
+if (reasoning) {
+	// @ts-ignore
+	options.reasoning_effort = reasoning
+}
+const toolsetMode = (args.tools) ? 'auto' : undefined;
+const contextWindow = args['context'] ? parseInt(args['context']) : 250000;
+
+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|grok-3|grok-3-mini|grok-3-mini-fast]
+--top_p [float]: number > 0, 0.1 means no top_p
+--reasoning [low|high]
+--tools [javascript,bash] comma seperated list
+e.g.
+grok.js --model grok-3-mini --tokens 4000 --context 10000
+
+`);
+	process.exit()
+}
+
+if (help) {
+	printHelp();
+}
+// reason step by step
+
+const prompt = `
+You are a prompt optimizer. Check for: 1) Clarity and specificity. 2) Brevity, non-ambiguity, ethics. 3) Token efficiency. If good, say "Approved." If not, rewrite concisely or ask 1-2 questions. Output: - Summary. - Rewritten prompt (if needed). - Questions (if unclear). Be efficient.
+`.trim();
+const agent = new AgentManager({ name });
+agent.setup({
+	prompt,
+	api,
+	options,
+	toolsetMode,
+	contextWindow
+});
+const toolset = agent.getToolset();
+if (toolset) {
+	const addTools = args['tools'].split(',') || [];
+	if (addTools.includes('javascript')) {
+		agent.addGenericToolcall('javascript_interpreter')
+	}
+	if (addTools.includes('bash')) {
+		agent.addGenericToolcall('execute_bash_script');
+	}
+}
+
+const cliIntro = `
+${name} ${options.model}.
+search  ${options.search_parameters.mode}
+`.trim();
+
+const description = `
+Given a specific prompt, inspect and adjust it for better readability and clarity.
+`.trim();
+
+if (input === '' && serve) {
+	agent.enableServer(name, description, serve);
+}
+if (input !== '') {
+	// Direct input output
+	const res = await agent.directCall(input);
+	console.log(res);
+} else if(connect) {
+	agent.attach(name, description, connect)
+} else {
+	agent.startCli(cliIntro);
+}

package/examples/claude-test.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+/*
+* Claude test with a simple toolset
+*/
+// -------------------------------
+const PROMPT_NAME = 'claude-test'
+// ------------------------------
+import { Prompt, API, CliWrapper, Session, env } from '../lib/index.js';
+import { parseArgs, SH } from '@j-o-r/sh';
+import toolset from '../lib/testToolset.js';
+
+const session = new Session(PROMPT_NAME);
+
+const args = parseArgs();
+// Get parameter values
+const max_completion_tokens = args['tokens'] ? parseInt(args['tokens']) : 4000;
+const context_window = args['context'] ? parseInt(args['context']) : 7000;
+const temperature = args['temperature'] ? parseFloat(args['temperature']) : 0.4;
+const model = args['model'] ? args['model'] : 'claude-3-7-sonnet-latest';
+const thinking = args['thinking'] ? parseInt(args['thinking']) : 0;
+const search = args['search'] ? parseInt(args['search']) : 0;
+const help = args['help'] || false;
+
+function printHelp() {
+	console.log(`
+'${PROMPT_NAME} --help' You are looking at it.
+'
+OPTIONS: 
+--tokens [number]: max generated tokens default 4000
+--context [number] : truncate message history to context-windows size default 700
+--temperature [float] : -2 / +2 default 0.4
+--model [grok-3|grok-3-mini|grok-3-mini-fast]
+--thinking [number_of_tokens] default 0
+--search [number_of_search_request] default 0 (no search)
+e.g.
+daisy --model grok-3-mini --tokens 4000 --context 10000
+
+`);
+	process.exit()
+}
+
+const userInfo = await env();
+/** @type {import('lib/API/anthropic.com/text.js').SearchOptions} */
+const searchOptions = {
+	type: 'web_search_20250305',
+	name: 'web_search',
+	max_uses: 5,
+	user_location: {
+		type: 'approximate',
+		timezone: userInfo.timezone,
+		region: userInfo.region,
+		city: userInfo.city,
+		country: userInfo.country
+	}
+}
+if (help) {
+	printHelp();
+}
+// reason step by step
+
+const PROMPT = `
+You an assistant dedicated to answering questions.
+- Reason step by step.
+- Be very brief.
+ `.trim();
+const prompt = new Prompt(context_window);
+prompt.add('system', PROMPT.trim(), true);
+/** @type {import('lib/API/anthropic.com/text.js').ANTHOptions} */
+const options = {
+	model,
+	temperature: temperature,
+	max_tokens: max_completion_tokens
+}
+// Enable reasoning
+if (thinking > 0) {
+	options.thinking = {
+		type: "enabled",
+		budget_tokens: thinking
+	}
+}
+if (search > 0) {
+	searchOptions.max_uses = search;
+	options.search = searchOptions
+}
+const intro = `
+Hi, I am ${PROMPT_NAME} ${options.model}, your assistant in this project.
+`;
+const cli = new CliWrapper({ request: API.text[PROMPT_NAME], session, intro, prompt, toolset, options });
+cli.start();