@j-o-r/hello-dave 0.1.0 → 0.1.4

package/lib/Cli.js

@@ -71,6 +71,8 @@ e.g. >edit< , >paste< , >#!bash [command]<
  * - Event-driven updates from Prompt (messages, truncated, finished).
  * - Built-in help, reset, load session, copy last message (Alt+m).
  * - Customizable intro/help via options.
+ * - Supports rebinding to a new Prompt/Session (for in-process agent handoff) without creating a new CLI instance.
+ *   Use rebind() then start(initialContext) for clean handoff.
  * 
  * @example
  * const cli = new Cli({ prompt: myPrompt, session: mySession });
@@ -89,6 +91,7 @@ class Cli {
 	#prompt;
 	#description = '';
 	#lastMessage = '';
+	#globalInitialized = false;
 
 	/**
 	 * Initializes the Cli instance with required Prompt and Session.
@@ -104,17 +107,27 @@ class Cli {
 		this.#session = options.session;
 		this.#description = options.description ? options.description + '\n\n' + INTRO : INTRO;
 		this.#HELP = options.help || HELP;
-		this.#setupCLI();
+
+		// One-time global setup (input handler, key mappings, base roles)
+		this.#initializeGlobal();
+
+		// Attach prompt-specific listeners (can be re-done on rebind)
+		this.#attachPromptListeners();
 	}
 
-	/** @private */
-	#setupCLI() {
+	/** @private One-time global CLI setup (safe to call only once) */
+	#initializeGlobal() {
+		if (this.#globalInitialized) return;
+
 		cli.setRole('assistant', `${this.#session.name}: > `, 'brightGreen');
 		cli.setRole('util', ``, 'brightYellow');
 		cli.setRole('error', ``, 'red');
-		cli.setRole('log', '', 'brightBlue');
+	  cli.setRole('log', '', 'brightBlue');
+	  cli.setRole('reasoning', 'reasoning: > ', 'brightBlue');
+
 		// @ts-ignore
 		cli.inputHandler = async (s, role) => await this.#handleInput(s, role);
+
 		cli.registerKeyMappings([
 			{ // reset the session, empty the context from the prompt
 				name: 'r', ctrl: false, meta: true, shift: false, handler: async () => {
@@ -146,13 +159,22 @@ class Cli {
 				}
 			}
 		]);
+
+		this.#globalInitialized = true;
+	}
+
+	/** @private Attach (or re-attach) listeners to the current prompt */
+	#attachPromptListeners() {
+		// Remove any previous listeners from this prompt (defensive)
+		// NO: the privious prompt should be destructed outside
+    
 		// Event listeners for Prompt updates
 		this.#prompt.on('message', (msg) => {
 			let write = false;
 			if (msg.role === 'reasoning') {
 				const content = this.#prompt.contentToString(msg.content);
-				cli.focus('util');
-				cli.write(`REASONING: ---------\n${content}\n---------\n`);
+				cli.focus('reasoning');
+				cli.write(`${content}\n`);
 				write = true;
 			} else if (msg.role === 'log') {
 				const content = this.#prompt.contentToString(msg.content);
@@ -173,15 +195,53 @@ class Cli {
 				cli.startSpinner();
 			}
 		});
+
 		this.#prompt.on('truncated', () => {
 			cli.focus('log');
 			cli.write('--- prompt truncated ---');
 		});
+
 		this.#prompt.on('finished', () => {
 			cli.focus('user', true);
 		});
 	}
 
+	/**
+	 * Rebind this CLI instance to a new Prompt and Session (used for in-process agent handoff).
+	 * 
+	 * - Unbinds listeners from the old prompt.
+	 * - Updates internal prompt/session references.
+	 * - Updates the assistant role prefix to the new agent's name.
+	 * - Re-attaches prompt event listeners to the *new* prompt.
+	 * - Optionally updates the description shown on next start().
+	 * 
+	 * Does **not** re-register global key mappings or inputHandler (prevents duplication and double-typing).
+	 * Does **not** call start(). Caller should call start() (optionally with initial context) afterwards.
+	 *
+	 * @param {Prompt} newPrompt
+	 * @param {Session} newSession
+	 * @param {string} [newDescription] - Optional new description/intro (banner + agent info). If omitted, keeps previous.
+	 */
+	rebind(newPrompt, newSession, newDescription = null) {
+		if (!newPrompt || !newSession) {
+			throw new Error('rebind() requires a valid prompt and session');
+		}
+
+		this.#prompt = newPrompt;
+		this.#session = newSession;
+
+		if (newDescription && typeof newDescription === 'string' && newDescription.trim()) {
+			this.#description = newDescription + '\n\n' + INTRO;
+		}
+		// else keep the existing description
+
+		// Update the assistant role prefix for the new agent name
+		cli.setRole('assistant', `${this.#session.name}: > `, 'brightGreen');
+
+		// Re-attach listeners to the new prompt only
+		this.#attachPromptListeners();
+	}
+
 	/**
 	 * Handles user input, processes via Prompt.call(), captures last message, and manages errors.
 	 * Only processes 'user' role inputs.
@@ -190,7 +250,11 @@ class Cli {
 	 * @param {string} role - Input role (e.g., 'user').
 	 */
 	async #handleInput(s, role) {
-		if (!s || s.trim() === '') return;
+		if (!s || s.trim() === '') {
+			cli.focus('util');
+		  cli.focus('user', true);
+		  return;
+		}
 		if (role !== 'user') return;
 		cli.startSpinner();
 		try {
@@ -226,18 +290,28 @@ class Cli {
 
 	/**
 	 * Starts the CLI: Shows intro/description, focuses user input, optionally processes initial message.
-	 * @param {string} [s] - Optional initial user message to process.
+	 * 
+	 * When called with a string `s` (e.g. handoff context), the context is shown as a user message
+	 * and then processed. This makes the injected handoff context visible in the terminal.
+	 *
+	 * @param {string} [s] - Optional initial user message / handoff context to process.
 	 * @returns {Promise<void>}
-	 * @example
-	 * await cli.start(); // Interactive mode
-	 * await cli.start('What is the weather?'); // Start with query
 	 */
 	async start(s) {
 		cli.focus('util');
 		cli.write(this.#description);
-		cli.focus('user', true);
+
 		if (s && s.trim() !== '') {
+			// Explicitly render the injected context as a user message
+			// (normal typed input is echoed by the underlying cli library;
+			//  programmatically injected messages need to be written manually)
+			cli.focus('user');
+			cli.write(s);
+			cli.focus('user', true);
+
 			await this.#handleInput(s, 'user');
+		} else {
+			cli.focus('user', true);
 		}
 	}
 
@@ -293,4 +367,4 @@ const copyToClipboard = async (text) => {
 };
 
 export default Cli;
-export { copyToClipboard };
+export { copyToClipboard };

package/lib/Prompt.js

@@ -538,6 +538,27 @@ class Prompt extends EventEmitter {
 	}
 
 
+	/**
+	 * Prune resolved function-call I/O from the prompt history, keeping only the
+	 * most recent complete function request/response pair.
+	 *
+	 * A resolved function call is an assistant `function_request` that has a
+	 * matching tool `function_response` by `call_id` (or `id` fallback). Older
+	 * resolved pairs are removed from their messages; empty assistant/tool
+	 * messages are removed entirely. Unresolved function calls and normal
+	 * user/assistant text messages are preserved.
+	 *
+	 * This is useful before serializing history for providers such as the OpenAI
+	 * Responses API, where repeatedly sending all historical tool transcripts can
+	 * pollute context and waste tokens.
+	 *
+	 * @returns {boolean} True when the prompt history was changed.
+	 */
+	pruneResolvedFunctionCallsExceptLast() {
+		return pruneResolvedToolIOByCallIdExceptLastHelper(this.#messages, 'lastCall');
+	}
+
+
 	/**
 	* reduce the prompt length to fit in the contextWindow
 	* or simply reset when there is no contextWindow
@@ -756,7 +777,8 @@ class Prompt extends EventEmitter {
 		const tools = this.toolsetFunctions().join(', ');
 		const context = this.contextLength;
 		const tokens = this.countTokens();
-		return `Cwd: ${cwd}\nTools: ${tools}\nMax context: ${context}\nUsed Tokens: ${tokens}`
+		const options = JSON.stringify(this.#adapter.options, null, '  ')
+		return `Cwd: ${cwd}\nFunction_calls: ${tools}\nMax context: ${context}\nUsed Tokens: ${tokens}\nOptions:\n${options}\n`
 	}
 
 }

package/lib/Session.js

@@ -1,6 +1,6 @@
 /**
 * Session manager for recording and retrieving chat sessions tied to a Prompt instance.
-* Handles caching of messages, records, and logs in NDJSON files under `.cache/hello-dave/<name>/`.
+* Handles caching of messages, records, and logs in NDJSON files under `.cache/@j-o-r/hello-dave/<name>/`.
 * Automatically creates session names from first non-sticky user message.
 * Listens to Prompt events (message, record, reset, truncated, others) for persistence.
 *
@@ -74,12 +74,12 @@ class Session {
 	* Initializes cache folders and event listeners.
 	* @param {string} promptName - The name of the prompt.
 	* @param {Prompt} prompt - The Prompt instance.
-	* @param {string} [baseFolder] - Base storage folder; defaults to `.cache/hello-dave`.
+	* @param {string} [baseFolder] - Base storage folder; defaults to `.cache/@j-o-r/hello-dave`.
 	* @private
 	*/
 	#initializeCache = (promptName, prompt, baseFolder) => {
 		if (!baseFolder) {
-			baseFolder = path.resolve('.cache', 'hello-dave');
+			baseFolder = path.resolve('.cache', '@j-o-r/hello-dave');
 		}
 		const root = new CacheSync(baseFolder, true, 'any');
 		this.name = root.sanitizeKey(promptName);
@@ -121,7 +121,7 @@ class Session {
 	*
 	* @param {string} name - The name of the prompt.
 	* @param {Prompt} prompt - The Prompt instance.
-	* @param {string} [storage] - The base storage folder; defaults to process.cwd()/.cache/hello-dave.
+	* @param {string} [storage] - The base storage folder; defaults to process.cwd()/.cache/@j-o-r/hello-dave.
 	*/
 	constructor(name, prompt, storage) {
 		this.#initializeCache(name, prompt, storage);
@@ -164,6 +164,7 @@ class Session {
 		} else if (this.#sessionName !== '') {
 			sessKey = this.#sessionCache.sanitizeKey(`${this.#sessionName}_${this.#sessionCounter}`);
 		}
+		// console.log({sessKey});
 		if (sessKey) {
 			if (this.#queue.length > 0) {
 				let i = 0;

package/lib/ToolSet.js

@@ -39,6 +39,43 @@ const CHOICES = {
  */
 const isValidName = (s) => /^[#!a-z_0-9]{2,}$/.test(s);
 
+/**
+ * Parse function-call parameters from provider output.
+ *
+ * Providers normally return parameters as a JSON object string, but some model
+ * outputs/API layers double-encode that string. This parser accepts objects,
+ * normal JSON strings, and double-encoded JSON strings without touching nested
+ * string literal values.
+ *
+ * @param {*} parameters - Raw function-call parameters.
+ * @returns {Record<string, *>} Parsed parameter object.
+ * @throws {Error} If parameters cannot be parsed as an object.
+ */
+const parseFunctionParameters = (parameters) => {
+	if (parameters == null || parameters === '') return {};
+	if (typeof parameters === 'object' && !Array.isArray(parameters)) return parameters;
+	if (typeof parameters !== 'string') {
+		throw new Error('Function parameters must be a JSON object or JSON object string');
+	}
+
+	let current = parameters;
+	const seen = new Set();
+	for (let i = 0; i < 4 && !seen.has(current); i++) {
+		seen.add(current);
+		const parsed = JSON.parse(current);
+		if (typeof parsed === 'string') {
+			current = parsed;
+			continue;
+		}
+		if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+			return parsed;
+		}
+		throw new Error('Function parameters must decode to a JSON object');
+	}
+
+	throw new Error('Function parameters are repeatedly encoded or invalid');
+};
+
 /**
  * @classdesc ToolSet manages a collection of tools (functions) that can be registered and executed, typically for AI agent function calling.
  * Supports schema definition compatible with JSON Schema for parameters.
@@ -150,6 +187,25 @@ class ToolSet {
 		return this;
 	}
 
+
+  /**
+   * Copies ONE tool from another ToolSet into this one.
+   * Optionally renames it to avoid name conflicts.
+   *
+   * @param {ToolSet} sourceToolSet - The source ToolSet
+   * @param {string} sourceName - Name of the tool in the source ToolSet
+   * @param {string} [newName] - Optional new name for the tool in this ToolSet
+   * @returns {ToolSet} Returns this instance for chaining
+   */
+  addFrom(sourceToolSet, sourceName, newName = null) {
+    if (!(sourceToolSet instanceof ToolSet)) {
+      throw new Error("addFrom() expects a ToolSet instance");
+    }
+    const tool = sourceToolSet.get(sourceName);
+    const finalName = newName || sourceName;
+    this.add(finalName, tool.description, tool.parameters, tool.method);
+    return this;
+  }
 	/**
 	 * Getter for the current tool choice setting.
 	 * @returns {string} The tool choice: 'auto', 'none', or 'required'
@@ -196,11 +252,17 @@ class ToolSet {
 			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) {
-				response = `Error: ${error.name} - ${error.message}`;
-				prompt.emit(prompt.EVENTS.tool_error, { name: call.function_request.name, call_id: call.function_request.call_id, error: response });
+			if (call.function_request.name === 'load_agent' || call.function_request.name === 'hand_over') {
+				// Special handoff tool (Stage 1 prototype). Do not attempt normal execution.
+				// A clean response is provided here; the handoff sequence (assistant message + emit) is handled below.
+				response = 'Handoff initiated.';
+			} else {
+				try {
+					response = await this.call(call.function_request.name, parseFunctionParameters(call.function_request.parameters));
+				} catch (error) {
+					response = `Error: ${error.name} - ${error.message}`;
+					prompt.emit(prompt.EVENTS.tool_error, { name: call.function_request.name, call_id: call.function_request.call_id, error: response });
+				}
 			}
 			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 });
@@ -221,7 +283,41 @@ class ToolSet {
 			functionResponses.push(responseObj);
 		}
 		prompt.addMultiModal('tool', functionResponses);
+
+		// === Clean in-process handoff support (matches lib/handOffToolset.js schema) ===
+		// After all normal function calls (including their function_responses) have been processed:
+		// 1. Normal function_response for load_agent / hand_over is already added above (as "Handoff initiated.").
+		// 2. Add assistant message: "agent hand-over to <target>..."
+		// 3. Emit 'agent:handoff' with clean payload { agent, context } so AgentLauncher can perform fresh-state replacement.
+		// This block activates for calls named exactly 'load_agent' or 'hand_over'.
+		// All other behavior (existing tools, error handling, events, etc.) remains 100% unchanged.
+		for (let i = 0; i < len; i++) {
+			const call = calls[i];
+			if (call.function_request.name === 'load_agent' || call.function_request.name === 'hand_over') {
+				let params = {};
+				try {
+					params = parseFunctionParameters(call.function_request.parameters || '{}');
+				} catch (_) {
+					params = {};
+				}
+
+				// Clean schema from handOffToolset.js: { agent: string (required), context: string (required) }
+				const target = params.agent || params.target || params.name || params.agentName;
+				const context = params.context || '';
+
+				if (!target) {
+					// Fallback: do not emit if we cannot determine a target
+					continue;
+				}
+
+				// 2. Add the specified assistant message (non-sticky)
+				prompt.add('assistant', `agent hand-over to ${target}...`, false);
+
+				// 3. Emit the event with clean payload (AgentLauncher.#handleHandoff expects this)
+				prompt.emit('agent:handoff', { agent: target, context });
+			}
+		}
 	}
 }
 
-export default ToolSet;
+export default ToolSet;