@j-o-r/hello-dave 0.0.5 → 0.0.7

package/lib/AgentClient.js

@@ -1,58 +1,82 @@
-/*
-Websocket client for AI sessions
-*/
-import { WebSocketClient } from "@j-o-r/apiserver";
+import { WebSocketClient } from '@j-o-r/apiserver';
+/**
+ * @module lib/AgentClient
+ * @exports default AgentClient
+ * Websocket client for AI agent sessions, wrapping a Prompt/ToolSet instance with robust queue-based message handling, auto-reconnect, and epoch-based resets.
+ */
 
 /**
-* @typedef {import('./API/openai.com/reponses/text.js').request} OARequest
-* @typedef {import('./API/x.ai/text.js').request} XRequest
-* @typedef {import('./API/anthropic.com/text.js').request} ANTHRequest
-* 
-* @typedef {import('./API/x.ai/text.js').XOptions} XOptions
-* @typedef {import('./API/openai.com/reponses/text.js').OAOptions} OAOptions
-* @typedef {import('./API/anthropic.com/text.js').ANTHOptions} ANTHOptions
-*
-* @typedef {import('./Prompt.js').default} Prompt
-* @typedef {import('./ToolSet.js').default} ToolSet
-*/
+ * @typedef {import('./API/openai.com/reponses/text.js').request} OARequest
+ * @typedef {import('./API/x.ai/text.js').request} XRequest
+ * @typedef {import('./API/anthropic.com/text.js').request} ANTHRequest
+ * 
+ * @typedef {import('./API/x.ai/text.js').XOptions} XOptions
+ * @typedef {import('./API/openai.com/reponses/text.js').OAOptions} OAOptions
+ * @typedef {import('./API/anthropic.com/text.js').ANTHOptions} ANTHOptions
+ *
+ * @typedef {import('./Prompt.js').default} Prompt
+ * @typedef {import('./ToolSet.js').default} ToolSet
+ */
 /**
-* @typedef {Object} WSOptions
-* @property {Prompt} prompt - The prompt session
-* @property {ToolSet} [toolset] - The toolset
-* @property {string} description - Custom introduction message.
-* @property {string} name - Logical name: e.g. search, code, os, support.
-* @property {string} secret - Websocket server access secret.
-* @property {string} [url='ws://127.0.0.1:8000/ws?params=1234']
-* @property {number} [intervalMs=250] - How often to pull one message from the queue.
-*/
+ * @typedef {Object} WSOptions
+ * @property {Prompt} prompt - The prompt session instance.
+ * @property {ToolSet} [toolset] - Optional toolset for the prompt.
+ * @property {string} description - Custom introduction message for the agent.
+ * @property {string} name - Logical name (e.g., 'search', 'code', 'os').
+ * @property {string} secret - Websocket server access secret (must match server).
+ * @property {string} [url='ws://127.0.0.1:8000/ws'] - WebSocket URL.
+ * @property {number} [intervalMs=2000] - Polling interval for queue processing (ms).
+ * @example { prompt, name: 'code-agent', secret: 'abc123', url: 'ws://localhost:8001/ws' }
+ */
+
 /**
-* Websocket Client
-* Wrapper combining a session and a websocket
-*/
+ * AgentClient: WebSocket client wrapper for AI agent sessions.
+ * Combines Prompt/ToolSet with WS communication for bidirectional queries, responses, tool calls, and resets.
+ * Features: Sequential message queue (one-at-a-time processing), auto-reconnect on close, epoch invalidation for resets.
+ * Logs events via console; emits via underlying Prompt (tool_request, tool_error, etc.).
+ * @emits tool_request - When tools are requested (via #prompt).
+ * @emits tool_error - When tools fail (via #prompt).
+ * @example
+ * const client = new AgentClient({
+ *   prompt: myPrompt,
+ *   name: 'code',
+ *   description: 'Code execution agent',
+ *   secret: 'mysecret',
+ *   intervalMs: 1000
+ * });
+ */
 class AgentClient {
-	/** @type {Prompt} */
+	/** @private @type {Prompt} */
 	#prompt;
+	/** @private @type {string} */
 	#description = '';
+	/** @private @type {string} */
 	#name;
+	/** @private @type {string} */
 	#secret = '';
-	/** @type {WebSocketClient} */
+	/** @private @type {import('@j-o-r/apiserver').WebSocketClient} */
 	#ws;
+	/** @private @type {string} */
 	#url = 'ws://127.0.0.1:8000/ws';
 
-	// Message queue and processing flag to ensure one-at-a-time handling
-	/** @type {Array<any>} */
+	/** @private @type {Array&lt;Object&gt;} Message queue for sequential processing. */
 	#queue = [];
+	/** @private @type {boolean} Flag to prevent reentrant processing. */
 	#processing = false;
-	// Bump this to invalidate in-flight work (hard reset)
+	/** @private @type {number} Epoch counter; increments on reset to invalidate in-flight work. */
 	#epoch = 0;
 
-	// Interval-based scheduler (no tight while-loop)
+	/** @private @type {NodeJS.Timeout|null} Interval ID for scheduler. */
 	#intervalId = null;
+	/** @private @type {number} Queue polling interval (ms). */
 	#intervalMs = 2000;
 
 	/**
-	 * Creates an instance of CLILoader.
-	 * @param {WSOptions} options - The options to configure the CLILoader.
+	 * Initializes the AgentClient with configuration options.
+	 * Registers Prompt events for logging and starts the WebSocket connection.
+	 * @param {WSOptions} options - Configuration object.
+	 * @throws {TypeError} If required options (e.g., prompt, secret) are invalid/missing.
+	 * @example See WSOptions.
 	 */
 	constructor(options) {
 		if (options.url) this.#url = options.url;
@@ -64,11 +88,13 @@ class AgentClient {
 		this.#registerPromptEvents();
 		this._start();
 	}
-  /**
-  * Informative.
-  * See what is happening
-  */
-	#registerPromptEvents () {
+
+	/**
+	 * @private
+	 * Registers Prompt events for logging tool requests/errors.
+	 * @returns {void}
+	 */
+	#registerPromptEvents() {
 		const events = Object.keys(this.#prompt.EVENTS);
 		events.forEach((evt) => {
 			this.#prompt.on(evt, (_msg) => {
@@ -82,72 +108,85 @@ class AgentClient {
 			});
 		});
 	}
+
+	/**
+	 * @private
+	 * Starts the WebSocket connection, sends introduction, sets up handlers.
+	 * Auto-retries on close after 5s.
+	 * @returns {void}
+	 */
 	_start() {
 		const url = this.#url + '?wssrc_id=' + this.#secret;
-		this.#ws = new WebSocketClient(url);  // Match server port/path
+		this.#ws = new WebSocketClient(url);
 		this.#ws.onopen = () => {
-			// Send my introduction to the server
 			this.#ws.send(JSON.stringify({
 				action: 'agent_introduction',
 				name: this.#name,
 				content: this.#description,
 				id: new Date().getTime()
 			}));
-			console.log('introduction_send:>>')
+			console.log('introduction_send:>>');
 			console.log(this.#name);
 			console.log(this.#description);
 		};
 		this.#ws.onmessage = (m) => {
-			// Enqueue messages; processing happens sequentially
 			this.incoming(m);
 		};
 		this.#ws.onclose = () => {
 			console.error('CLOSE: Lost Connection, retry in 5 seconds');
-			// Stop ticking while disconnected
 			this.#stopInterval();
 			setTimeout(() => {
 				this._start();
-			}, 5000)
+			}, 5000);
 		};
-		this.#ws.onerror = (e) => {
-
-		}
+		this.#ws.onerror = (e) => {};
 	}
+
 	/**
-	* Enqueue an incoming websocket message and trigger the processor.
-	*/
+	 * Enqueues an incoming WebSocket message and starts interval processing if needed.
+	 * Immediately handles 'reset' actions (clears queue, resets prompt, increments epoch).
+	 * @param {MessageEvent} e - Raw WebSocket message event.
+	 * @returns {void}
+	 * @throws {SyntaxError} If JSON parse fails.
+	 */
 	incoming(e) {
-		const message = JSON.parse(e.data);
-		// Handle resets immediately: do not enqueue, just clear the queue and reset the prompt
+		let message;
+		try {
+			message = JSON.parse(e.data);
+		} catch (err) {
+			console.error('Invalid JSON in incoming message');
+			return;
+		}
 		if (message?.action === "reset") {
 			console.log("<RESET:incoming>");
-			// Invalidate in-flight work
 			this.#epoch++;
-			// Empty the queue immediately
 			this.#queue = [];
-			// Stop the scheduler; any in-flight handler will finish, but no further items will run
 			this.#stopInterval();
-			// Reset the prompt/session state
 			this.#prompt.reset();
-			return; // Do not enqueue this message
+			return;
 		}
 		this.#queue.push(message);
-		// Start interval-based processing (no while-loop)
 		this.#startInterval();
 	}
 
 	/**
-	 * Start the interval that pulls one message at each tick.
+	 * @private
+	 * Starts the interval ticker to process one queued message per tick.
+	 * Idempotent; skips if already running.
+	 * @returns {void}
 	 */
 	#startInterval() {
 		if (this.#intervalId) return;
 		this.#intervalId = setInterval(() => {
-			// We intentionally do not await here; #processOne guards reentrancy
 			void this.#processOne();
 		}, this.#intervalMs);
 	}
 
-	/** Stop the interval if it is running. */
+	/**
+	 * @private
+	 * Stops the processing interval.
+	 * @returns {void}
+	 */
 	#stopInterval() {
 		if (this.#intervalId) {
 			clearInterval(this.#intervalId);
@@ -156,13 +195,15 @@ class AgentClient {
 	}
 
 	/**
-	 * Internal: process at most ONE message. Called on an interval tick.
+	 * @private
+	 * Processes exactly one queued message (guards reentrancy).
+	 * Stops interval if queue empty post-process.
+	 * @returns {Promise&lt;void&gt;}
 	 */
 	async #processOne() {
 		if (this.#processing) return;
 		const message = this.#queue.shift();
 		if (!message) {
-			// Nothing to do; stop ticking until a new message arrives
 			this.#stopInterval();
 			return;
 		}
@@ -172,13 +213,17 @@ class AgentClient {
 			await this.#handleMessage(message, epochAtStart);
 		} finally {
 			this.#processing = false;
-			// If the queue drained, we can stop; else the next tick will pick the next one
 			if (this.#queue.length === 0) this.#stopInterval();
 		}
 	}
 
 	/**
-	 * Internal: handle a single message
+	 * @private
+	 * Handles a single enqueued message (query/response/reset).
+	 * Sends responses/errors back via WS.
+	 * @param {Object} message - Parsed message.
+	 * @param {number} epochAtStart - Epoch at start; aborts if changed.
+	 * @returns {Promise&lt;void&gt;}
 	 */
 	async #handleMessage(message, epochAtStart) {
 		if (message.action === 'agent_query') {
@@ -193,7 +238,6 @@ class AgentClient {
 			}
 		} else if (message.action === 'reset') {
 			console.log('<RESET>');
-			// Empty the que;
 			this.#queue = [];
 			this.#epoch++;
 			this.#prompt.reset();

package/lib/AgentManager.js

@@ -1,56 +1,83 @@
 import { Prompt, Cli, AgentClient, AgentServer, API, ToolSet, Session, env } from './index.js';
 import toolsPool from './genericToolset.js'
 /**
-* @typedef {import('./API/x.ai/text.js').XOptions} XOptions
-* @typedef {import('./API/x.ai/responses.js').XAIOptions} XAIOptions
-* @typedef {import('./API/openai.com/reponses/text.js').OAOptions} OAOptions
-* @typedef {import('./API/anthropic.com/text.js').ANTHOptions} ANTHOptions
-*/
+ * @module lib/AgentManager
+ * @exports default AgentManager
+ * High-level orchestrator for AI agent lifecycle: configures Prompt/Session/ToolSet, launches CLI/Server/Client modes.
+ * Supports chaining setup() → start(); adds generic tools; direct calls.
+ */
+
+/**
+ * @typedef {import('./API/x.ai/text.js').XOptions} XOptions
+ * @typedef {import('./API/x.ai/responses.js').XAIOptions} XAIOptions
+ * @typedef {import('./API/openai.com/reponses/text.js').OAOptions} OAOptions
+ * @typedef {import('./API/anthropic.com/text.js').ANTHOptions} ANTHOptions
+ */
 /**
-* @typedef {Object} Setup
-* @property {string} prompt - Initial system prompt
-* @property {XAIOptions|OAOptions|XOptions|ANTHOptions} options - Model options
-* @property {'gpt'|'xai'|'claude'} api - AI endpoint to use
-* @property {number} [contextWindow] - The size in tokens for the context/session
-* @property {'auto'|'required'|void} [toolsetMode] - 
-* @property {boolean} [debug] - verbose output
-*/
+ * @typedef {Object} Setup
+ * @property {string} prompt - Initial system prompt.
+ * @property {XAIOptions|OAOptions|XOptions|ANTHOptions} options - API model options.
+ * @property {'gpt'|'xai'|'claude'} api - AI provider.
+ * @property {number} [contextWindow=300000] - Token limit for context.
+ * @property {'auto'|'required'|null} [toolsetMode] - Toolset activation mode.
+ * @property {boolean} [debug] - Enable verbose output.
+ */
 /**
-* @typedef {Object} Options
-* @property {string} name - Agent name
-* @property {string} secret - Secret string for WS access authorisation (server and client secrets should match)
-* @property {string} [cachePath] - path to session/record storage 
-*/
+ * @typedef {Object} Options
+ * @property {string} name - Agent name (validated /^[a-z_0-9]{2,}$/).
+ * @property {string} secret - WS auth secret (base64-encoded).
+ * @property {string} [cachePath='.cache/hello-dave'] - Session cache directory.
+ * @example { name: 'code-agent', secret: 'mysecret' }
+ */
+/** @const {RegExp} Validates agent/tool names (lowercase a-z0-9_, min 2 chars). */
+const validNameRegex = /^[a-z_0-9]{2,}$/;
+
 class AgentManager {
-	/** @type {Prompt} */
+	/** @private @type {Prompt} */
   #prompt;
-  /** @type {Session} */
+  /** @private @type {Session} */
   #sessionStorage;
+  /** @private @type {string} */
   #name = 'agent';
+  /** @private @type {string} */
   #secret = '';
+  /** @private @type {string} */
   #cachePath = '.cache/hello-dave';
+  /** @private @type {boolean} */
   #debug = false;
+  /** @private @type {string} */
   #model = '';
+  /** @private @type {number} */
   #contextWindow = 0;
+  /** @private @type {string} */
   #sysPrompt = '';
+
   /**
-  * @param {Options} options
-  */
+   * Initializes AgentManager with base options.
+   * Validates name regex; encodes secret.
+   * @param {Options} options - Base configuration.
+   * @throws {Error} Invalid name (regex) or options.
+   * @chainable
+   */
   constructor(options) {
     this.#name = options.name || this.#name;
     if (options.secret && typeof options.secret === 'string') {
       this.#secret = Buffer.from(options.secret).toString('base64');
     } 
-    const validNameRegex = /^[a-z_0-9]{2,}$/;
     if (!validNameRegex.test(this.#name)) {
-      throw new Error(`Invalid agent 'name' in options: '${this.#name}'. Must match /^[a-z_0-9]{2,}$/ (lowercase a-z, digits, underscores; min 2 chars).`);
+      throw new Error(`Invalid agent 'name': '${this.#name}'. Must match /^[a-z_0-9]{2,}$/`);
     }
     this.#cachePath = options.cachePath || this.#cachePath;
   }
 
   /**
-  * @param {Setup} setup
-  */
+   * Configures the Prompt/Session/ToolSet with API adaptor.
+   * Adds system prompt; chains to start().
+   * @param {Setup} setup - AI setup details.
+   * @returns {AgentManager} This instance (chainable).
+   * @throws {Error} Invalid setup.
+   * @example mgr.setup({ prompt: 'You are a coder...', api: 'gpt', options: { model: 'gpt-4o' } });
+   */
   setup(setup) {
     const {
     	prompt,
@@ -63,9 +90,6 @@ class AgentManager {
     this.#sysPrompt = prompt;
     this.#contextWindow = contextWindow;
     if (options?.model) this.#model = options.model;
-    this.#sysPrompt = prompt;
-    this.#contextWindow = contextWindow;
-    if (options?.model) this.#model = options.model;
     let toolset;
     if (toolsetMode) {
     	toolset = new ToolSet(toolsetMode);
@@ -77,43 +101,48 @@ class AgentManager {
     this.#sessionStorage = new Session(this.#name, this.#prompt, this.#cachePath);
     this.#prompt.add('system', prompt, true);
     this.#prompt.setAdaptor(API.text[api], toolset, options);
-    return this; // For chaining
+    return this;
   }
 
   /**
-  * Start a CLI for local usage
-  * @param {string} description - introduction message for the CLI user
-  */
+   * @private
+   * Launches interactive CLI mode.
+   * @param {string} description - CLI intro message.
+   * @returns {void}
+   * @throws {Error} No setup() called.
+   */
   #startCli(description) {
     if (!this.#prompt) throw new Error('Run setup first');
     const cli = new Cli({ prompt: this.#prompt, session: this.#sessionStorage, description });
     setTimeout(() => {
-      // This resolves issues with log output after the console has been started
       cli.start();
     }, 1000);
   }
 
   /**
-  * Attach a session to an AgentServer
-  * DO NOT ATTACH TO SELF, however, when in server mode
-  * An AgentServer can attach as client to another server
-  * @param {string} name - function_call name
-  * @param {string} description - function_call description
-  * @param {string} [url='ws://127.0.0.1:8000/ws'] - ws URL
-  */
+   * @private
+   * Attaches this agent as a WS client to another server (for chaining agents).
+   * @param {string} name - Tool name.
+   * @param {string} description - Tool desc.
+   * @param {string} [url='ws://127.0.0.1:8000/ws'] - Target WS URL.
+   * @returns {AgentClient} New client instance.
+   * @throws {Error} No setup().
+   */
   #attach(name, description, url = 'ws://127.0.0.1:8000/ws') {
     if (!this.#prompt) throw new Error('Run setup first');
     return new AgentClient({ prompt: this.#prompt, name, description, url, secret: this.#secret });
   }
 
   /**
-  * Start the Agent in server mode.
-  * A server is always started on localhost
-  * Clients can attach now and are accesible as via function_calls (toolset)  
-  * @param {string} name - function_call name
-  * @param {string} description - function_call description
-  * @param {number} [port=8000] - Start the dynamic toolset server on this port
-  */
+   * @private
+   * Enables server mode: Registers this agent for remote tool calls.
+   * Optionally attaches as client too.
+   * @param {string} name - Server/tool name.
+   * @param {string} [description=''] - Desc (auto from sysPrompt).
+   * @param {number} [port=8000] - Port.
+   * @returns {void}
+   * @throws {Error} No setup/toolset.
+   */
   #enableServer(name, description = '', port = 8000) {
     if (!this.#prompt) throw new Error('Run setup first');
     if (!this.#prompt.toolset) throw new Error('No toolset defined');
@@ -125,64 +154,68 @@ class AgentManager {
     	prompt: this.#prompt,
     	session: this.#sessionStorage,
     	debug: this.#debug
-    	
     });
-    // trigger reset on all Agents
     this.#prompt.on('reset', () => {
-    	// Generate new context for all Agents
     	server.resetAll();
-    })
+    });
   }
+
   /**
-  * Direct call to the prompt
-  * @param {string} input
-  * @returns {Promise<string>}
-  */
+   * Direct synchronous call to the underlying Prompt.
+   * @param {string} input - User input.
+   * @returns {Promise&lt;string&gt;} Response.
+   * @throws {Error} No setup.
+   */
   async directCall(input) {
 		const res = await this.#prompt.call(input);
   	return res;
   }
-  /** @returns {Prompt} */
+
+  /** @returns {Prompt} Underlying Prompt instance. */
   getPrompt() { return this.#prompt; }
-  /** @returns {ToolSet|void} */
+
+  /** @returns {ToolSet|null} Toolset if configured. */
   getToolset() { return this.#prompt.toolset; }
-  /** @returns {Promise<import('./fafs.js').EnvironmentInfo>} */
+
+  /** @returns {Promise&lt;import('./fafs.js').EnvironmentInfo&gt;} System env info. */
   async environment() {
   	return env();
   }
+
   /**
-   * Adds a pre-defined generic tool from lib/genericToolset.js to this agent's ToolSet.
-   * @param {'execute_bash_script'|'execute_remote_script'|'get_user_env'|'history_search'|'javascript_interpreter'|'memory_recall'|'memory_write'|'open_link'|'read_file'|'send_email'|'syntax_check'|'write_file'} name - Valid generic tool name (validated /^[a-z_0-9]{2,}$/).
-   * @throws {Error} If toolset not initialized or tool not found in pool.
+   * Adds a pre-defined generic tool from toolsPool to this agent's ToolSet.
+   * @param {'execute_bash_script'|'execute_remote_script'|'get_user_env'|'history_search'|'javascript_interpreter'|'memory_recall'|'memory_write'|'open_link'|'read_file'|'send_email'|'syntax_check'|'write_file'} name - Tool name.
+   * @throws {Error} Invalid name, no toolset, or tool missing.
+   * @example mgr.addGenericToolcall('read_file');
    */
   addGenericToolcall(name) {
-    const validNameRegex = /^[a-z_0-9]{2,}$/;
     if (!validNameRegex.test(name)) {
-      throw new Error(`Invalid 'name': '${name}'. Must match /^[a-z_0-9]{2,}$/ (lowercase a-z, digits, underscores; min 2 chars).`);
+      throw new Error(`Invalid 'name': '${name}'. Must match /^[a-z_0-9]{2,}$/`);
     }
-    if (!this.#prompt.toolset) throw new Error('No ToolSet defined')
+    if (!this.#prompt.toolset) throw new Error('No ToolSet defined');
     let tool = toolsPool.get(name);
-    if (!tool) throw new Error('Tool not defined')
+    if (!tool) throw new Error(`Tool '${name}' not found in pool`);
     this.#prompt.toolset.add(name, tool.description, tool.parameters, tool.method);
   }
   
   /**
-   * Smart launcher: Dispatches to CLI/server/attach/direct. Auto-gens cliIntro/desc if empty.
-   * @param {number} [servePort] - Server port (if no input).
-   * @param {string} [connectUrl] - WS to attach. e.g. ws://127.0.0.1:8091/ws
-   * @param {string} [cliIntro=""] - CLI intro (auto-gen if falsy).
-   * @param {string} [toolName=""] - name /^[a-z_0-9]{2,}$/ Tool name for server/attach (defaults to agent.name).
-   * @param {string} [toolDescription=""] - Tool desc (auto-gen if falsy).
+   * Smart launcher: CLI (default), server (servePort), or client (connectUrl).
+   * Auto-generates intros/descriptions if empty.
+   * @param {number} [servePort] - Launch server on port.
+   * @param {string} [connectUrl] - Connect as client to WS.
+   * @param {string} [cliIntro=""] - CLI intro text.
+   * @param {string} [toolName=""] - Tool/server name (falls back to #name).
+   * @param {string} [toolDescription=""] - Tool desc.
+   * @returns {Promise&lt;void&gt;}
+   * @throws {Error} No setup; invalid names/ports.
+   * @example mgr.start(8000); // Server\nmgr.start(undefined, 'ws://other:8001/ws'); // Client\nmgr.start(); // CLI
    */
   async start(servePort, connectUrl, cliIntro = "", toolName = "", toolDescription = "") {
     if (!this.#prompt) throw new Error("Run setup first");
 
-    const validNameRegex = /^[a-z_0-9]{2,}$/;
-
     toolName = toolName || this.#name;
-    // Validate 'toolName' (or fallback agent name)
     if (!validNameRegex.test(toolName)) {
-      throw new Error(`Invalid 'toolName' (or agent #name): '${toolName}'. Must match /^[a-z_0-9]{2,}$/ (lowercase a-z, digits, underscores; min 2 chars).`);
+      throw new Error(`Invalid 'toolName': '${toolName}'. Must match /^[a-z_0-9]{2,}$/`);
     }
 
     if (!toolDescription && this.#sysPrompt) {
@@ -190,22 +223,20 @@ class AgentManager {
     }
 
     if (!cliIntro) {
-      const introStr = this.#name + " " + (this.#model || "unknown-model") + " - context: " + this.#contextWindow;
+      const introStr = `${this.#name} ${this.#model || "unknown-model"} - context: ${this.#contextWindow}`;
       cliIntro = introStr.trim();
     }
+
     if (servePort) {
       console.log(toolName);
       console.log(toolDescription);
       this.#enableServer(toolName, toolDescription, servePort);
-      // A server can also be a client
       if (connectUrl) {
         this.#attach(toolName, toolDescription, connectUrl);
       }
     } else if (connectUrl) {
-      // Connect to a agent 'server' and enable via websocket / toolcalls
       this.#attach(toolName, toolDescription, connectUrl);
     } else {
-      // Terminal user CLI
       this.#startCli(cliIntro);
     }
   }