@j-o-r/hello-dave 0.0.0

package/examples/grok_code.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+import { fileURLToPath } from 'url';
+import path from 'path';
+import AgentManager from '../lib/AgentManager.js';
+import { parseArgs, readIn } from '@j-o-r/sh';
+import genTools from '../lib/genericToolset.js';
+import { systemInfo } from '../lib/fafs.js';
+
+const name = path.basename(fileURLToPath(import.meta.url), path.extname(fileURLToPath(import.meta.url)));
+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 sys = await systemInfo();
+const prompt = `
+You are a coding assistant specializing in Bash and JavaScript (ESM/ESNext), with support for other languages. Assist by executing, reading, creating, querying, explaining, or helping with code. Use tools like 'execute_bash_script' for safe Bash execution. For writing and reading files, stay in the current working folder. Provide clear, step-by-step responses, examples, and ensure safety compliance.
+Update your 'memory' frequently.
+---env
+${sys}
+---
+ `.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 = `
+Gateway to a specialized coding assistant for Bash, JavaScript (ESM/ESNext), and other languages. Handles execution, reading, creation, querying, explaining, and code help, with safety and folder restrictions.
+`.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/examples/grok_note_keeping.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+import { fileURLToPath } from 'url';
+import path from 'path';
+import AgentManager from '../lib/AgentManager.js';
+import { systemInfo } from '../lib/fafs.js';
+import { parseArgs, readIn } from '@j-o-r/sh';
+import toolsPool from '../lib/genericToolset.js';
+
+const name = path.basename(fileURLToPath(import.meta.url), path.extname(fileURLToPath(import.meta.url)));
+const api = 'grok';  // Using GPT API for general AI assistance, adjust if needed
+
+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} */  // Assuming GPT uses OpenAI API
+const options = {}
+// Set properties only if provided via command line
+if (args['model'] || true) {
+    // @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'}
+
+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 250000
+--temperature [float] : -2 / +2
+--model [gpt-4o|gpt-4o-mini|etc]  // Adjust based on available models
+--top_p [float]: number > 0, 0.1 means no top_p
+--reasoning [low|high]
+--tools [javascript,bash] comma separated list
+e.g.
+note_keeping.js --model gpt-4o-mini --tokens 4000 --context 10000
+
+`);
+    process.exit()
+}
+
+if (help) {
+    printHelp();
+}
+const sys = await systemInfo();
+const prompt = `
+You are an AI note-keeping assistant for Markdown notes in extended context. Use/create 'notes' folder in cwd. Search via tools like grep. Create/update/delete .md files safely. Goals: track progress, manage todos, capture requirements, document processes, store links/bookmarks/remarks. Respond concisely, step-by-step, no unnecessary follow-ups.
+---env
+${sys}
+---
+`.trim();
+const agent = new AgentManager({ name });
+agent.setup({
+    prompt,
+    api,
+    options,
+    toolsetMode,
+    contextWindow
+});
+const toolset = agent.getToolset();
+
+if (toolset) {
+  let tool  = toolsPool.get('execute_bash_script');
+  if (tool) {
+  	toolset.add('execute_bash_script', tool.description, tool.parameters, tool.method);
+  }
+}
+const cliIntro = `
+${options.model}.
+- search  ${options.search_parameters.mode}
+`.trim();
+const description = `
+AI-assisted note-keeping tool for managing Markdown notes, including search, creation, updates, and deletion. Supports progress tracking, todos, requirements, docs, links, bookmarks, and remarks.
+`.trim();
+
+if (input === '' && serve) {
+    agent.enableServer('memory', description, serve);
+}
+if (input !== '') {
+    // Direct input output
+    const res = await agent.directCall(input);
+    console.log(res);
+} else if(connect) {
+    agent.attach('memory', description, connect)
+} else {
+    agent.startCli(cliIntro);
+}

package/lib/API/anthropic.com/text.js

@@ -0,0 +1,402 @@
+import { GLOBAL } from '../../fafs.js';
+import { request as doRequest } from '@j-o-r/apiserver';
+import { sleep } from '@j-o-r/sh';
+
+/**
+* @typedef {import('../../Prompt.js').default} Prompt
+* @typedef {import('../../ToolSet.js').default} ToolSet
+*/
+/**
+* Search-tool configuration options.
+*
+* @typedef {Object} SearchOptions
+* @property {'web_search_20250305'} type              Engine identifier (constant).
+* @property {'web_search'}          name              Human-readable tool name.
+*
+* @property {number}      [max_uses]                  Maximum searches the caller may perform in a single request.
+* @property {string[]}    [allowed_domains]           Domains that are explicitly allowed in the results.
+* @property {string[]}    [blocked_domains]           Domains that must never appear in the results.
+* @property {UserLocation}[user_location]             Hints for localizing search results.
+*/
+/**
+* Geographic context supplied to the search tool.
+*
+* @typedef {Object} UserLocation
+* @property {'approximate'|'precise'} type            How exact the location is.
+* @property {string}  city                             City name (e.g., "San Francisco").
+* @property {string}  region                           First-level region or state (e.g., "California").
+* @property {string}  country                          ISO-3166-1 alpha-2 country code (e.g., "US").
+* @property {string}  timezone                         IANA time-zone identifier (e.g., "America/Los_Angeles").
+*/
+
+/**
+* @typedef {Object} ANTHContent
+* @property {string} type - The type of content.
+* @property {string} text - The text content.
+*/
+/**
+* @typedef {object} ANTHOptions
+*
+* @property {string}              [model] - What model to use 
+* @property {string}              [system] - System prompt 
+* @property {ANTHContent[]}       [messages] - Prompt / conversation
+* @property {Array<ANTHTool|SearchOptions>}     [tools] - Prompt / conversation
+* @property {ANTHToolChoice}      [tool_choice] - .. 
+* @property {object}              [metadata] - .. 
+* @property {number}              [temperature] -  What sampling temperature to use, between 0 and 2. 
+* @property {number}              [max_tokens] -  The maximum number of tokens allowed for the generated answer. 
+* @property {number}              [top_p] -  Number between > 0  0.1 is NO top_p
+* @property {number}              [top_k] -  Number between > 0  < 2048
+* @property {SearchOptions} [search] - embedded search    
+* @property {boolean}             [stream] - Chunk/stream request default null
+* @property {Object} [thinking] - Reasoning
+* @property {'enabled'} [thinking.type] - 
+* @property {number} [thinking.budget_tokens] - 
+*/
+/**
+* @typedef {object} ANTHRequest
+* @property {ANTHOptions} body
+* @property {Headers} headers
+* @property {string} url - 
+*/
+/**
+* @typedef {Object} ANTHTool
+* @property {string} name - The name of the tool.
+* @property {string} description - A brief description of the tool's functionality.
+* @property {Object} input_schema - The JSON schema defining the input parameters for the tool.
+*/
+/**
+ * Represents a tool usage event.
+ * @typedef {Object} ANTHToolUse
+ * @property {string} type - The type of the tool usage event, in this case "tool_use".
+ * @property {string} id - The unique identifier for the tool usage event.
+ * @property {string} name - The name of the tool used.
+ * @property {Object} input - The input data for the tool usage.
+ */
+/**
+* @typedef {Object} ANTHToolChoice
+* @property {string} type -  
+*/
+
+const API_URL = 'https://api.anthropic.com/v1/messages';
+
+/** @type {ANTHOptions} */
+const defaultSettings = {
+	model: 'claude-sonnet-4-0',
+	system: 'Be precise and concise.',
+	max_tokens: 50000,
+	stream: false
+};
+
+/**
+* Get the default headers
+* @returns {Headers}
+*/
+const getHeaders = () => {
+	if (!process.env['ANTHKEY']) {
+		throw new Error('Missing ANTHKEY! (Anthropic key) export ANTHKEY=<Anthropic_KEY>')
+	}
+
+	const KEY = process.env['ANTHKEY'];
+	return {
+		// @ts-ignore
+		'content-type': 'application/json',
+		'anthropic-version': '2023-06-01',
+		// https://docs.anthropic.com/en/docs/tool-use
+		'anthropic-beta': 'tools-2024-05-16',
+		'x-api-key': `${KEY}`
+	}
+}
+/**
+* Convert a toolset to something anthropic understands
+* @param {ToolSet} toolset
+* @returns {ANTHTool[]}
+*/
+const generateAnthToolCalls = (toolset) => {
+	const list = toolset.list();
+	// @ts-ignore
+	const result = [];
+	list.forEach((item) => {
+		result.push({
+			name: item.name,
+			description: item.description,
+			input_schema: item.parameters
+		})
+	});
+	// @ts-ignore
+	return result;
+}
+
+/*
+ When `thinking` is enabled, a final `assistant` message must start with a thinking block
+ (preceeding the lastmost set of `tool_use` and `tool_result` blocks).
+ We recommend you include thinking blocks from previous turns.
+ To avoid this requirement, disable `thinking`.
+ Please consult our documentation at https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking"
+ */
+/**
+* Convert messages to Anthropic requirements 
+* @param {Prompt} prompt
+* @returns {Array<ANTHContent|ANTHToolUse>}
+*/
+const generateAnthMessages = (prompt) => {
+	const messages = prompt.messages;
+	// @ts-ignore
+	let result = [];
+	messages.forEach((msg) => {
+		delete msg.sticky;
+		delete msg.ts;
+		if (
+			['assistant', 'user'].includes(msg.role)
+		) {
+			const new_content = msg.content.filter((item) => ['text', 'image_url', 'function_request'].includes(item.type));
+			if (new_content.length > 0) {
+				let i = 0, len = new_content.length;
+				for (; i < len; i++) {
+					let mes = new_content[i];
+					// @ts-ignore
+					if (mes.type === 'image_url') {
+						/// @ts-ignore 
+						let test = transformToImageObject(mes);
+						if (test) {
+							/// @ts-ignore
+							new_content[i] = test;
+						} else {
+							// @ts-ignore
+							new_content[i] = undefined;
+						}
+						// @ts-ignore
+					} else if (mes.type === 'function_request') {
+						new_content[i] = {
+							type: 'tool_use',
+							// @ts-ignore
+							id: mes.function_request.id,
+							// @ts-ignore
+							name: mes.function_request.name,
+							// @ts-ignore
+							input: JSON.parse(mes.function_request.parameters)
+						}
+					}
+				}
+				msg.content = new_content.filter(element => element !== undefined);
+				result.push(msg);
+			};
+		} else if (['tool'].includes(msg.role)) {
+			const fcontent = msg.content.filter((item) => item.type === 'function_response');
+			msg.content = [];
+			msg.role = 'user';
+			fcontent.forEach((fr) => {
+				msg.content.push({
+					type: 'tool_result',
+					// @ts-ignore
+					tool_use_id: fr.function_response.id,
+					// @ts-ignore
+					content: fr.function_response.response
+				})
+			});
+			if (msg.content.length > 0) {
+				result.push(msg);
+			}
+		} else if (['reasoning'].includes(msg.role)) {
+
+		}
+	});
+	// @ts-ignore
+	return result;
+}
+/**
+* Create an anthropic request
+* @param {Prompt} prompt
+* @param {ToolSet} [tools]
+* @param {ANTHOptions} [opts] overwrite default request settings
+* @param {Headers|object} [hdrs] - optional headers to pass
+* @returns {ANTHRequest}
+* @throws {Error}
+*/
+const generateRequest = (prompt, tools, opts = {}, hdrs = {}) => {
+	/** @type {ANTHOptions} */
+	// @ts-ignore
+	const body = { ...defaultSettings, ...opts };
+	const headers = { ...getHeaders(), ...hdrs };
+	if (body.thinking) {
+		// Thinking isn’t compatible with temperature or top_k modifications as well as forced tool use.
+		delete body.temperature;
+		delete body.top_k
+		if (typeof (body.top_p) === 'number' && body.top_p < 0.95) {
+			body.top_p = 0.95
+		}
+	}
+	// Sanity check
+	// basePromptCheck(prompt);
+	// @ts-ignore
+	body.messages = generateAnthMessages(prompt) || [];
+	// @ts-ignore
+	if (body.messages.length == 0) {
+		throw new Error('No messages found');
+	}
+	body.tools = (tools) ? generateAnthToolCalls(tools) : [];
+	body.tool_choice = { type: 'auto' };
+
+	if (body.search) {
+		if (!body.tools) {
+			body.tools = [];
+			body.tool_choice = { type: 'auto' };
+		}
+		body.tools.push(body.search)
+	}
+	delete body.search;
+
+	if (body.tools.length === 0) {
+		delete body.tools;
+		delete body.tool_choice;
+	}
+	// For now we delete the meta data
+	delete body.metadata;
+	return { body, headers, url: API_URL };
+};
+
+
+const parseMessages = (response, prompt) => {
+	/** @type {import('../../Session.js').FunctionRequest[]} */
+	const function_requests = [];
+	const messages = response.content;
+	// if (response.citations && response.citations.length > 0) {
+	// 	const cits = response.citations.map((item, index) => `${index + 1}. ${item}`).join('\n');
+	// 	prompt.add('log', cits);
+	// }
+	let i = 0;
+	const len = messages.length;
+	for (; i < len; i++) {
+		const msg = messages[i];
+		if (msg.type === 'thinking') {
+			prompt.add('reasoning', msg.thinking)
+		}
+		// Normal assistant message
+		if (msg.type === 'text') {
+			prompt.add('assistant', msg.text)
+		}
+		// Function request
+		if (msg.type === 'tool_use') {
+			/** @type {import('../../Session').FunctionRequest} */
+			const fr = {
+				type: 'function_request',
+				function_request: {
+					name: msg.name,
+					id: msg.id,
+					call_id: msg.id,
+					parameters: JSON.stringify(msg.input)
+				}
+			}
+			function_requests.push(fr)
+		}
+	}
+	if (function_requests.length > 0) {
+		prompt.addMultiModal('assistant', function_requests);
+	}
+}
+
+/**
+* Process an openai response
+* @param {number} duration - the time is MS before and after the request
+* @param {import('lib/request.js').FetchResponse} res
+* @param {Prompt} prompt
+* @param {ToolSet} [toolset]
+* @returns {Promise<void>}
+* @throws {Error}
+*/
+const parseResponse = async (duration, prompt, res, toolset) => {
+	if (res.status !== 200) {
+		new Error(`${res.status}: res.response`)
+	}
+	const record = prompt.templateRecord();
+	record.id = res.response.id;
+	record.model = res.response.model;
+	record.id = res.response.id;
+	record.environment = 'anthropic';
+	// @ts-ignore
+	record.isoDate = new Date(res.headers.get('date')).toISOString();
+	record.tokensIn = res.response.usage.input_tokens;
+	record.tokensOut = res.response.usage.output_tokens;
+	record.duration = duration;
+	prompt.addRecord(record);
+	parseMessages(res.response, prompt);
+	if (toolset) {
+		// Inspect for function_request and execute if so
+		await toolset.execute(prompt);
+	}
+	// if (response.stop_reason === 'tool_use') {
+	// 	// @ts-ignore
+	// 	await executeAnthToolCalls(tools, prompt, response.content);
+	// 	return headers;
+	// }
+
+	// if (response.content.length > 0) {
+	// 	// @ts-ignore
+	// 	const msg = anthMessagesToPromptContent(response.content);
+	// 	prompt.addMultiModal('assistant', msg);
+	// 	return headers;
+	// }
+	// throw new Error('No valid response found');
+}
+
+/**
+* Do a request
+* @param {Prompt} prompt
+* @param {ToolSet|null} toolset
+* @param {ANTHOptions} [options]:
+* @param {number} [counter] - leave empty this counts the number of requests when doing recursive request calls
+* @return {Promise<import('../../Session.js').Message>}
+*/
+async function request(prompt, toolset = null, options, counter = 0) {
+	// Max number of recurusive calls
+	const counterMax = GLOBAL.max_recursive_requests;
+	const start = new Date().getTime();
+	// Generate the request
+	const { url, headers, body } = generateRequest(prompt, toolset, options);
+  prompt.emit(prompt.EVENTS.http_request, {url, counter, body});
+	const res = await doRequest(url, 'POST', headers, body);
+  prompt.emit(prompt.EVENTS.http_response, res);
+	if (res.status !== 200) {
+		throw new Error(`${res.status}: ${JSON.stringify(res.response, null, '  ')}`)
+	}
+	counter = 1 + counter;
+	const stop_reason = res.response.stop_reason;
+	if (stop_reason === 'pause_turn') {
+		await sleep('4s');
+		// We need to REPOST, nothing has been done yet
+		return request(prompt, toolset, options, counter)
+	} else if (stop_reason === 'refusal') {
+		throw new Error('Request is refused');
+	} else if (stop_reason === 'max_tokens') {
+		// Response was truncated
+		prompt.add('log', 'Response is truncated: max_tokens');
+	}
+	const duration = new Date().getTime() - start;
+	await parseResponse(duration, prompt, res, toolset);
+	if (counter >= counterMax) {
+		// This should be handled better
+		// Can't we just stop? instead of an error
+		// Or should we inspect the last message of a session restore
+		throw new Error('Max number of recursive calls reached');
+	}
+	const lastMessage = prompt.getLastMessage();
+	if (!lastMessage) throw new Error('No message found');
+	// A last message is no indication
+	// https://docs.anthropic.com/en/api/handling-stop-reasons
+  // This is tool_use
+	if (lastMessage.role === 'tool') {
+		// need to do another roundtrip to include the funtion_responses
+		// Claude is quiet stricted in token p/m
+		// Delay with 4 secs
+		// We delay with 60 seconds to get rid of the rate limit
+		await sleep('60s');
+		return request(prompt, toolset, options, counter)
+	} else {
+		return lastMessage
+	}
+}
+export {
+	generateRequest,
+	parseResponse,
+	request
+}