@j-o-r/hello-dave 0.0.0

package/lib/Session.js

@@ -0,0 +1,231 @@
+/**
+* Records sessions
+* Get sessions
+* This is an optional extension for the prompt 
+*/
+
+import path from 'path';
+import { CacheSync } from '@j-o-r/cache';
+import Prompt from './Prompt.js';
+
+/**
+* @typedef {import('./Prompt.js').Message} Message
+* @typedef {import('./Prompt.js').Record} Record
+*/
+
+/**
+ * Get the next version number for a given key in the array.
+ *
+ * @param {string[]} arr - The array of versioned strings.
+ * @param {string} key - The key to check for the highest version.
+ * @returns {number} - The next version number.
+ */
+const getNextVersion = (arr, key) => {
+	const regex = new RegExp(`^${key}_(\\d+)$`);
+	const versions = arr
+		.map(item => {
+			const match = item.match(regex);
+			// @ts-ignore
+			return match ? parseInt(match[1], 10) : null;
+		})
+		.filter(version => version !== null);
+	return versions.length > 0 ? Math.max(...versions) + 1 : 0;
+};
+
+/**
+ */
+class Session {
+	/**
+	* sticky message que
+	* @type {Message[]}
+	*/
+	#que = [];
+	/** @type {string} session name */
+	#sessionName = '';
+	/** @type {number} count the number of session iterations */
+	#sessionCounter = 0;
+	/** @type {CacheSync} */
+	#sessionCache;
+	/** @type {CacheSync} */
+	#recordCache;
+	/** @type {CacheSync} */
+	#logCache;
+
+	/**
+	* Create and set the cache folders
+	* @param {string} promptName - The name of the prompt.
+	* @param {Prompt} prompt - The prompt
+	* @param {string} [baseFolder] - The base storage folder, default this is process.cwd()
+	*/
+	#inititializeCache = (promptName, prompt, baseFolder) => {
+		// If not base folder, we take FOLDERS.ROOT
+		// else we use the baseFolder
+		if (!baseFolder) {
+			// Relative from cwd()
+			baseFolder = path.resolve('.cache', 'hello-dave');
+		}
+		// Create the root folder, just in case
+		const root = new CacheSync(baseFolder, true, 'any');
+		// this.#baseStorage = baseFolder;
+		this.name = root.sanitizeKey(promptName);
+		const sessionStorage = path.resolve(baseFolder, this.name);
+		// Create the session folder
+		new CacheSync(sessionStorage, true, 'any');
+		// Create the records cache
+		this.#logCache = new CacheSync(path.resolve(sessionStorage, 'logs'), true, 'ndjson');
+		this.#recordCache = new CacheSync(path.resolve(sessionStorage, 'records'), true, 'ndjson');
+		if (this.name.length === 0) {
+			throw new Error(`Invalid session name: ${promptName}`);
+		}
+		// create and init the session storage
+		this.#sessionCache = new CacheSync(path.resolve(sessionStorage, 'sessions'), true, 'ndjson');
+		prompt.on(prompt.EVENTS.message, (msg) => {
+			this.#msg(msg);
+		});
+		prompt.on(prompt.EVENTS.record, (rec) => {
+			this.#rec(rec);
+		});
+		prompt.on(prompt.EVENTS.reset, () => {
+			// Prompt has only sticky messages
+			// fill the que
+			this.#sessionCounter = 0;
+			this.#sessionName = '';
+			this.#que = prompt.messages;
+		});
+		prompt.on(prompt.EVENTS.truncated, () => {
+			// Prompt has only sticky messages
+			// fill the que
+			this.#sessionCounter = 0;
+			this.#sessionName = '';
+			this.#que = prompt.messages;
+		});
+		const events = Object.keys(prompt.EVENTS);
+		events.forEach((evt) => {
+			prompt.on(evt, (msg) => {
+				this.#log({ evt, msg });
+			});
+		})
+	}
+	/**
+	* Constructs a new Prompt instance.
+	* If contextWindow = 0 (defaut) the prompt will have no context building up (ONE_SHOT)
+	* @param {string} name - The name of the prompt.
+	* @param {Prompt} prompt - The prompt
+	* @param {string} [storage] - The base storage folder, default this is process.cwd()
+	*/
+	constructor(name, prompt, storage) {
+		this.#inititializeCache(name, prompt, storage)
+	}
+
+  info() {
+  	const name = this.name;
+  	const session = this.#sessionName;
+  	const sessionCount = this.#sessionCounter;
+  	const path = this.#sessionCache.folder;
+  	return `Name: ${name}\nSession: ${session}\nSessionCount: ${sessionCount}\nPath: ${path}`;
+  }
+	/**
+	* Add message to the cache
+	* @param {import('./Prompt.js').Message} msg
+	*/
+	#msg(msg) {
+		const role = msg.role;
+		const sticky = msg.sticky;
+		let sessKey;
+		if (this.#sessionName === '' && role === 'user' && sticky === false) {
+			// Create a sessioname
+			if (msg.content.length > 0 && msg.content[0].type === 'text') {
+				/**
+				* @param {string} str
+				*/
+				const truncateString = (str) => str.length > 50 ? str.slice(0, 80) : str;
+				// @ts-ignore
+				this.#sessionName = this.#sessionCache.sanitizeKey(truncateString(msg.content[0].text).trim());
+				this.#sessionCounter = getNextVersion(this.#sessionCache.list(), this.#sessionName);
+				sessKey = this.#sessionCache.sanitizeKey(`${this.#sessionName}_${this.#sessionCounter}`);
+			}
+		} else if(this.#sessionName !== '') {
+			sessKey = this.#sessionCache.sanitizeKey(`${this.#sessionName}_${this.#sessionCounter}`);
+		}
+		if (sessKey) {
+			// Alway write the que if there is a name
+			// May the must be written sticky nots or a truncated previous sessions
+			if (this.#que.length > 0) {
+				// Write outstanding messages
+				let i = 0;
+				const len = this.#que.length;
+				for (; i < len; i++) {
+					this.#sessionCache.append(sessKey, this.#que[i]);
+				}
+				this.#que = [];
+			}
+			this.#sessionCache.append(sessKey, msg);
+		} else {
+			this.#que.push(msg);
+		}
+	}
+
+	/**
+	* store a record
+	* @param {Record} record - Records for billing and optimizing
+	* @throws {Error} If the record is invalid.
+	*/
+	#rec(record) {
+		const key = new Date().toISOString().split('T')[0];
+		this.#recordCache.append(key, record);
+	}
+
+	/**
+	* log all events
+	* @param {*} o - just log
+	* @throws {Error} If the record is invalid.
+	*/
+	#log(o) {
+		const key = new Date().toISOString().split('T')[0];
+		this.#logCache.append(key, o);
+	}
+	sessionList() {
+		const list = this.#sessionCache.list();
+		const processedSet = new Set(
+			list.map(str => {
+				// Remove the last '_[number]' part
+				const withoutNumber = str.replace(/_\d+$/, '');
+				// Replace '_' with ' '
+				return withoutNumber.replace(/_/g, ' ');
+			})
+		);
+		return [...processedSet];
+	}
+
+	/**
+	* Get messages fro, a session
+	* 
+	* @param {string} sess - The session name.
+	* @return {Message[]}
+	*/
+	set(sess) {
+		const counter = getNextVersion(this.#sessionCache.list(), sess);
+		if (counter === 0) {
+			this.#sessionCounter = counter;
+		} else {
+			this.#sessionCounter = counter - 1;
+		}
+		// Load last know session
+		const sessKey = this.#sessionCache.sanitizeKey(`${sess}_${this.#sessionCounter}`);
+		const res = this.#sessionCache.read(sessKey) || [];
+
+		if (res) {
+			this.#sessionName = sess;
+		}
+		return res;
+	}
+	/**
+	* Remove all previous sessions and records
+	*/
+	empty() {
+		this.#sessionCache.empty();
+		this.#recordCache.empty();
+	}
+}
+
+export default Session;

package/lib/ToolSet.js

@@ -0,0 +1,186 @@
+import Prompt from "./Prompt.js";
+/**
+* @module @j-o-r/toolset
+* Register function_calls / tools
+* This library can be used stand-alone or as a wrapper for AI functions_calls tools
+*/
+
+/**
+* @typedef {object} TSSchema
+* @property {string} type - Type of the object
+* @property {object} properties - Description of properties
+* @property {string[]} [required] - Required properties
+*/
+/**
+* @typedef {object} TSTool
+* @property {string} description - Command description
+* @property {TSSchema} parameters - JS JSON schema
+* @property {function(object): Promise} method
+*/
+/**
+* @typedef {object} TSToolListItem
+* @property {string} name - Command name
+* @property {string} description - Command description
+* @property {TSSchema} parameters - JS JSON schema
+*/
+
+/** Type of choices */
+const CHOICES = {
+	NONE: 'none',
+	AUTO: 'auto',
+	REQUIRED: 'required'
+};
+
+/**
+* The function name is limited
+* @param {string} s
+* @returns {boolean}
+*/
+const isValidName = (s) => /^[#!a-z_0-9]{2,}$/.test(s);
+
+class ToolSet {
+	/** @type {Map<string, TSTool>} */
+	#tools = new Map();
+	/** default auto */
+	#toolChoice = 'auto';
+
+	/**
+	* @param {string} [choice] - Default 'auto' auto|none|required
+	*/
+	constructor(choice = 'auto') {
+		if (choice && Object.values(CHOICES).includes(choice)) {
+			this.#toolChoice = choice;
+		} else if (choice) {
+			throw new Error('Tool choice not defined');
+		}
+	}
+
+	/**
+	* How many functions have we registered
+	* @returns {number}
+	*/
+	get length() {
+		return this.#tools.size;
+	}
+
+	/**
+	* Register a Tool/Command/Function
+	* @param {string} name - [a-z_0-9]{2,} The lowercase string name of the callback e.g. 'get_node_version'
+	* @param {string} description - What does it do
+	* @param {TSSchema} parameters - SCHEMA object describing the function's input parameters
+	* @param {function(object): Promise<*>} method - Async function to call
+	*/
+	add(name, description, parameters, method) {
+		if (!isValidName(name)) {
+			throw new Error('Invalid name /[a-z_0-9]{2,}/');
+		}
+		if (this.has(name)) {
+			// throw new Error('Function already defined');
+		}
+		this.#tools.set(name, { description, parameters, method });
+	}
+
+	/**
+	* Get a  tool from the toolset
+	* @param {string} name
+	* @returns {TSTool}
+	*/
+	get(name) {
+		if (!this.has(name)) {
+			throw new Error('Function not found');
+		}
+		return this.#tools.get(name);
+	}
+	/**
+	* Delete a function_call
+	* @param {string} name
+	*/
+	delete(name) {
+		this.#tools.delete(name);
+	}
+	/**
+	* Is 'name' already registered
+	* @param {string} name
+	* @returns {boolean}
+	*/
+	has(name) {
+		return this.#tools.has(name);
+	}
+
+	/**
+	* Get a list of tools available
+	* @returns {TSToolListItem[]}
+	*/
+	list() {
+		return Array.from(this.#tools.entries()).map(([name, value]) => ({
+			name,
+			description: value.description,
+			parameters: value.parameters
+		})).sort((a, b) => a.name.localeCompare(b.name));
+	}
+
+	get toolChoice() {
+		return this.#toolChoice;
+	}
+	/**
+	* Execute a method
+	* @param {string} name
+	* @param {object} params
+	*/
+	async call(name, params) {
+		if (!this.has(name)) {
+			throw new Error('Function not found');
+		}
+		const tool = this.#tools.get(name);
+		return tool.method(params);
+	}
+	/**
+	 * Execute function requests from the last message.
+	 * @param {Prompt} prompt - Handle tool calls.
+	 */
+	async execute(prompt) {
+		const lastMessage = prompt.getLastMessage();
+		if (!lastMessage) return;
+		if (!(lastMessage.content.length > 0 && lastMessage.content[0].type === 'function_request')) {
+			return;
+		}
+		/** @type {import("./Prompt.js").FunctionResponse[]} */
+		const functionResponses = [];
+		/** @type {import("./Prompt.js").FunctionRequest[]} */
+		// @ts-ignore
+		const calls = lastMessage.content;
+		const len = calls.length;
+		for (let i = 0; i < len; i++) {
+			const call = calls[i];
+			const startTime = new Date().getTime();
+			let response = '';
+			prompt.emit(prompt.EVENTS.tool_request, { name: call.function_request.name, call_id: call.function_request.call_id });
+			try {
+				response = await this.call(call.function_request.name, JSON.parse(call.function_request.parameters));
+			} catch (error) {
+				prompt.emit(prompt.EVENTS.tool_error, { name: call.function_request.name, call_id: call.function_request.call_id, error });
+				response = `Error: ${error.name} - ${error.message}`;
+			}
+			const duration = new Date().getTime() - startTime;
+			prompt.emit(prompt.EVENTS.tool_response, { name: call.function_request.name, call_id: call.function_request.call_id, duration });
+			let functionRes = response;
+			if (typeof functionRes !== 'string') {
+				functionRes = JSON.stringify(functionRes);
+			}
+			/** @type {import("./Prompt.js").FunctionResponse} */
+			const responseObj = {
+				type: 'function_response',
+				function_response: {
+					name: call.function_request.name,
+					id: call.function_request.id,
+					call_id: call.function_request.call_id,
+					response: functionRes
+				}
+			};
+			functionResponses.push(responseObj);
+		}
+		prompt.addMultiModal('tool', functionResponses);
+	}
+}
+
+export default ToolSet;

package/lib/fafs.js

@@ -0,0 +1,93 @@
+/* Frequently asked functions */
+import os from 'os';
+import { CacheAsync, path } from '@j-o-r/cache';
+import { SH, jsType } from '@j-o-r/sh'
+
+const APPNAME = 'hello-dave';
+
+const RELATIVE_CACHE = path.resolve('.cache');
+new CacheAsync(RELATIVE_CACHE, true, 'bin');
+const APP_CACHE = path.resolve(RELATIVE_CACHE, APPNAME);
+new CacheAsync(APP_CACHE, true, 'bin');
+
+const GLOBAL = {
+	max_recursive_requests: 20, // max number recursive of request 
+	default_cache: APP_CACHE,
+	secret: 'tdb.e3a0cd73dd6a429283f921f9fc1bad41'
+}
+
+/**
+* @typedef {Object} EnvironmentInfo
+* @property {string} name - User's name
+* @property {string} system - Linux OS / PROC 
+* @property {string} city
+* @property {string} region
+* @property {string} country
+* @property {string} timezone
+* @property {string} external_ip
+* @property {string} cwd - current working folder
+*/
+
+/**
+* @returns {Promise<string>}
+*/
+async function systemInfo() {
+	let system = 'system: ' +  (await SH`cat /etc/issue`.run()).trim().replace('\\n', '').replace('\\l', '');
+	system += (await SH`uname -m`.run()).trim().replace('\\n', '').replace('\\l', '');
+	system += '' + (await SH`uname -o`.run()).trim().replace('\\n', '').replace('\\l', '');
+	system += '\ncwd: ' + process.cwd();
+	// try {
+	// 	await SH` which xdg-open`.run();
+	// 	system += ' and with xdg-open';
+	// } catch (_e) { }
+	// try {
+	// 	await SH` which msmtp`.run();
+	// 	system += ', msmtp';
+	// } catch (_e) { }
+	return system
+}
+
+/**
+* Gather information about this environment
+* @returns {Promise<EnvironmentInfo>}
+*/
+async function env() {
+  const CACHE_PATH = (await SH`echo ~/.cache/${APPNAME}`.run()).trim();
+	const KEY = 'env';
+	const storage = new CacheAsync(CACHE_PATH, true, 'bin');
+	storage.secret = GLOBAL.secret;
+	const day = 1000 * 60 * 60 *24
+	// Expire after 31 days, refresh info after that,
+	await storage.expire(day * 31);
+
+  const wd = process.cwd();
+  const home = os.homedir();
+  const cwd = wd.replace(home, '~');
+  let info = await storage.read(KEY) 
+  if (info) {
+  	const res = JSON.parse(info);
+  	res.cwd = cwd;
+  	return res;
+  }
+	const name = (await SH`getent passwd "$USER" | cut -d: -f5`.run()).replaceAll(',',' ').trim();
+	const system = await systemInfo();
+	const userInfo = JSON.parse((await SH`curl -fsSL https://ipinfo.io/json`.run()));
+	info = {
+		name,
+		system,
+		city: userInfo.city,
+		region: userInfo.region,
+		country: userInfo.country,
+		timezone: userInfo.timezone,
+		external_ip: userInfo.ip
+	}
+	await storage.write(KEY, JSON.stringify(info));
+	return info;
+}
+
+export {
+	jsType,
+	GLOBAL,
+	env,
+	systemInfo
+}

package/lib/genericToolset.js

@@ -0,0 +1,170 @@
+import { SH } from '@j-o-r/sh'
+import { ToolSet, env } from './index.js'
+
+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;
+}
+
+/**
+* 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\`.`,
+	{
+		type: 'object',
+		properties: {
+			script: {
+				type: 'string',
+				description: `ES6 ESM Javascript eval. 'console.log' to capture the response. cwd: ${user.cwd}`,
+			}
+		},
+		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();
+		} catch (e) {
+			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
+	{
+		type: 'object',
+		properties: {
+		}
+	},
+	async (_params) => {
+		return environment;
+	}
+);
+
+tools.add(
+	'execute_bash_script',
+	'Execute a bash script.',
+	{
+		type: 'object',
+		properties: {
+			bash_script: { type: 'string', description: `The bash script to execute (${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 in local user environment.',
+	{
+		type: 'object',
+		properties: {
+			url: { type: 'string', description: 'Link to open' }
+		},
+		required: ['url']
+	},
+	async (params) => {
+		return await SH`xdg-open ${[params.url]}`.run();
+	}
+);
+export default tools
+

package/lib/index.js

@@ -0,0 +1,34 @@
+import {request as gpt} from './API/openai.com/reponses/text.js';
+import {request as grok} from './API/x.ai/text.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 AgentClient from './AgentClient.js';
+import Session from './Session.js';
+import Prompt from './Prompt.js';
+import Cli from './Cli.js';
+
+const API = {
+	text:{
+	 gpt,
+	 grok,
+	 claude
+  },
+  search: {
+  	brave
+  },
+}
+export {
+  AgentServer,
+  AgentClient,
+  Prompt,
+  ToolSet,
+  Session,
+  API,
+  Cli,
+  env,
+  GLOBAL
+};