@j-o-r/hello-dave 0.0.2 → 0.0.4

package/scenarios.bak.1774780058/promptFishbowl.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+import {assert, Test } from '@j-o-r/sh';
+import Prompt from '../lib/Prompt.js';
+
+const isNpm = process.env.npm_lifecycle_event ? true : false;
+const test = new Test(isNpm);
+const createText = (text, nr) => {
+	let result = '';
+	const len = nr;
+	let i = 0;
+	for(;i < len; i++) {
+		result += `${text} `;
+	}
+	return result;
+}
+
+test.add('Create a 500 tokens prompt', async () => {
+	const prompt = new Prompt(500);
+	prompt.add('system', createText('system', 50), true);    // 0
+	prompt.add('user', createText('user', 50), true);        // 1
+	prompt.add('assistant', 'yes', true);                    // 2
+	prompt.add('user', createText('user2', 50));             // 3
+	prompt.add('assistant', createText('assistant 2', 100)); // 4
+	prompt.add('user', createText('user3', 50));             // 5
+	prompt.add('assistant', createText('assistant 3', 100)); // 6
+	prompt.add('user', createText('user 4', 50));            // 7
+	prompt.add('assistant', createText('assistant 4', 100)); // 8
+	assert.equal(prompt.length, 9);
+	const reduced = prompt.truncate();
+	assert.equal(prompt.length, 5);
+	assert.equal(reduced, true);
+	assert.equal(prompt.contextLength, 500);
+});
+
+
+test.add('Create a 500 tokens prompt with function calls',async () => {
+	const prompt = new Prompt(500);
+	prompt.add('system', createText('system', 50), true);    // 0
+	prompt.add('user', createText('user', 50), true);        // 1
+	prompt.add('assistant', 'yes', true);                    // 2
+	prompt.add('user', 'Wat is the temperatuur in Den Haag');
+	/** @type {import('../lib/Prompt.js').PRFunctionRequest} */
+	const fr = {
+		type: 'function_request',
+		function_request: {
+			name: 'get_current_weather',
+			id: 'call_zXFv3espCtpa3zfEu9ElOkJw',
+			parameters: "{\"location\":\"Den·Haag\",\"unit\":\"celsius\"}"
+		}
+	}
+	prompt.addMultiModal('assistant', [fr]);
+	/** @type {import('../lib/Prompt.js').PRFunctionResponse} */
+	const res = {
+		type: 'function_response',
+		function_response: {
+			name: 'get_current_weather',
+			id: 'call_zXFv3espCtpa3zfEu9ElOkJw',
+			response: "{\"temperature\":24}"
+		}
+	}
+	prompt.addMultiModal('tool', [res]);
+	prompt.add('assistant', 'Het is 24 graden Celsius in Den Haag.');
+	prompt.add('user', createText('user2', 50));             // 3
+	prompt.add('assistant', createText('assistant 2', 100)); // 4
+	prompt.add('user', createText('user3', 50));             // 5
+	prompt.add('assistant', createText('assistant 3', 100)); // 6
+	prompt.add('user', createText('user 4', 50));             // 7
+	prompt.add('assistant', createText('assistant 4', 100)); // 8
+	prompt.truncate();
+	assert.equal(prompt.length, 5);
+});
+
+const report = await test.run();
+if (report.errors > 0) {
+  process.exit(1);
+}

package/scenarios.bak.1774780058/search.brave.com.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { Test, assert } from '@j-o-r/sh'
+import {request} from '../lib/API/brave.com/search.js';
+
+const test = new Test();
+
+test.add('simple brave search', async () => {
+	/** @type {import('../lib/search/brave.com/index.js').BRSearchOptions} */
+  const options = {search_lang: 'nl', summary: 1, count: 3};
+  const res = await request('What is the most populair behringer synth?', options);
+  console.log(res);
+})
+
+test.add('extended simple brave search', async () => {
+	/** @type {import('../lib/search/brave.com/search.js').BRSearchOptions} */
+		// const options = {
+		// 	summary: 1,
+		// 	count: 6,
+		// 	freshness: 'py',
+		// 	result_filter: ''
+		// }
+  const res = await request('"openapi doc" "openai response models" API calls');
+  console.log(res);
+})
+await test.run([0]);

package/scenarios.bak.1774780058/sh.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import {SH} from '@j-o-r/sh';  // Note: relative path
+
+
+async function main() {
+  try {
+    const res = await SH`node --check bin/dave.js`.run()
+    console.log(res);
+  } catch (error) {
+    console.log('------ error ------');
+    console.error(error)
+  }
+}
+
+main();

package/scenarios.bak.1774780058/test-wsio.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import wsio from './lib/wsIO.js';  // Note: relative path
+
+const connectionUrl = 'ws://localhost:8080/ws';  // Your server
+const secret = '123';  // Or your secret
+
+async function main() {
+  try {
+    console.log('=== User Input ===');
+    const inputResp = await wsio(connectionUrl, secret, 'user_request', 'Hello, what is the date?');
+    console.log(inputResp);
+
+    console.log('\n=== Server Info ===');
+    const infoResp = await wsio(connectionUrl, secret, 'user_info');
+    console.log(infoResp);
+
+    console.log('\n=== Reset ===');
+    const resetResp = await wsio(connectionUrl, secret, 'user_reset');
+    console.log(resetResp);
+  } catch (error) {
+    console.error('Error:', error.message);
+    process.exit(1);
+  }
+}
+
+main();

package/scenarios.bak.1774780058/testToolset.js

@@ -0,0 +1,42 @@
+import ToolSet from '../lib/ToolSet.js'
+// Generic TEST toolset
+const tools = new ToolSet('auto');
+tools.add(
+	'get_current_weather', // name
+	'Get the current weather in a given location', // desciption
+	{
+		type: 'object',
+		properties: {
+			location: {
+				type: 'string',
+				description: 'The city and country'
+			}
+		},
+		required: ["location"]
+	},
+	async (params) => {
+		if (params.location.trim() === '') {
+		  throw new Error('Missing location.');
+			// return { records, response };
+		}
+		const response = {current_weather:'24 C, Cloudy'};
+		return response;
+	}
+);
+tools.add(
+	'get_date_time', // name
+	'Get the current date and time', // desciption
+	{
+		type: 'object',
+		properties: {
+		}
+	},
+	async (_params) => {
+		const response = {
+			date_time: new Date().toISOString(),
+		}
+		return response;
+	}
+);
+
+export default tools;

package/scenarios.bak.1774780058/toolset.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import { Test , assert} from '@j-o-r/sh'
+// import ToolSet from '../lib/ToolSet.js'
+import tools from './testToolset.js';
+const test = new Test();
+test.add('Basic', async () => {
+	assert.equal(tools.has('get_current_weather'), true);
+	assert.equal(tools.has('i_am_not_here'), false);
+	const ob = await tools.call('get_current_weather', { location: 'Den haag' })
+	assert.equal(ob.current_weather, '24 C, Cloudy')
+	const list = tools.list();
+	assert.equal(list.length, 2);
+	assert.equal(list[0].name, 'get_current_weather');;
+});
+
+await test.run();

package/scenarios.bak.1774780058/toolset.test.js

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+import { Test, assert, jsType } from '@j-o-r/sh';
+import ToolSet from '../lib/ToolSet.js';
+
+const t = new Test();
+
+// Constructor
+t.add('Constructor default auto', () => {
+  const ts = new ToolSet();
+  assert.strictEqual(ts.toolChoice, 'auto');
+  assert.strictEqual(ts.length, 0);
+  assert.strictEqual(jsType(ts), 'ToolSet');
+});
+
+t.add('Constructor valid choices', () => {
+  ['auto', 'none', 'required'].forEach(choice => {
+    const ts = new ToolSet(choice);
+    assert.strictEqual(ts.toolChoice, choice);
+  });
+});
+
+t.add('Constructor invalid choice throws', () => {
+  try {
+    new ToolSet('invalid');
+    assert.fail('Should throw on invalid choice');
+  } catch (e) {
+    assert.ok(e.message.includes('Tool choice not defined'));
+  }
+});
+
+// add method
+t.add('add invalid name throws', () => {
+  const ts = new ToolSet();
+  try {
+    ts.add('a', 'desc', { type: 'object' }, async () => {});
+    assert.fail('Should throw invalid name');
+  } catch (e) {
+    assert.ok(e.message.includes('Invalid name'));
+  }
+});
+
+t.add('add valid tool', () => {
+  const ts = new ToolSet();
+  const mockMethod = async (params) => ({ received: params });
+  ts.add('valid_tool', 'Valid tool description', {
+    type: 'object',
+    properties: { foo: { type: 'string' } },
+    required: ['foo']
+  }, mockMethod);
+  assert.strictEqual(ts.length, 1);
+  assert.strictEqual(ts.has('valid_tool'), true);
+});
+
+t.add('add duplicate no throw, overwrites', () => {
+  const ts = new ToolSet();
+  const method1 = async () => 'first';
+  const method2 = async () => 'second';
+  ts.add('dup', 'desc', { type: 'object' }, method1);
+  ts.add('dup', 'desc', { type: 'object' }, method2);
+  assert.strictEqual(ts.length, 1);
+  const tool = ts.get('dup');
+  assert.strictEqual(tool.description, 'desc'); // last one
+});
+
+t.add('get throws not found', () => {
+  const ts = new ToolSet();
+  try {
+    ts.get('missing');
+    assert.fail('Should throw');
+  } catch (e) {
+    assert.ok(e.message.includes('Function not found'));
+  }
+});
+
+t.add('get existing tool', () => {
+  const ts = new ToolSet();
+  ts.add('gettool', 'desc', { type: 'object' }, async () => {});
+  const tool = ts.get('gettool');
+  assert.strictEqual(jsType(tool), 'Object');
+  assert.strictEqual(tool.description, 'desc');
+  assert.strictEqual(jsType(tool.parameters), 'Object');
+  assert.strictEqual(jsType(tool.method), 'AsyncFunction');
+});
+
+// delete
+t.add('delete reduces length', () => {
+  const ts = new ToolSet();
+  ts.add('to_delete', 'desc', { type: 'object' }, async () => {});
+  assert.strictEqual(ts.length, 1);
+  ts.delete('to_delete');
+  assert.strictEqual(ts.length, 0);
+  assert.strictEqual(ts.has('to_delete'), false);
+});
+
+t.add('delete non-existing no error', () => {
+  const ts = new ToolSet();
+  ts.delete('nonexistent');
+  assert.strictEqual(ts.length, 0);
+});
+
+// list
+t.add('list empty', () => {
+  const ts = new ToolSet();
+  const list = ts.list();
+  assert.strictEqual(list.length, 0);
+  assert.strictEqual(jsType(list), 'Array');
+});
+
+t.add('list sorted by name', () => {
+  const ts = new ToolSet();
+  ts.add('b_tool', 'b desc', { type: 'object' }, async () => {});
+  ts.add('a_tool', 'a desc', { type: 'object' }, async () => {});
+  ts.add('c_tool', 'c desc', { type: 'object' }, async () => {});
+  const list = ts.list();
+  assert.strictEqual(list.length, 3);
+  assert.strictEqual(list[0].name, 'a_tool');
+  assert.strictEqual(list[1].name, 'b_tool');
+  assert.strictEqual(list[2].name, 'c_tool');
+});
+
+// call
+t.add('call success', async () => {
+  const ts = new ToolSet();
+  const expected = { result: 42 };
+  ts.add('calc', 'calc', { type: 'object' }, async () => expected);
+  const res = await ts.call('calc', {});
+  assert.deepStrictEqual(res, expected);
+});
+
+t.add('call not found throws', async () => {
+  const ts = new ToolSet();
+  try {
+    await ts.call('missing', {});
+    assert.fail('Should throw');
+  } catch (e) {
+    assert.ok(e.message.includes('Function not found'));
+  }
+});
+
+const report = await t.run();
+process.exit(report.errors > 0 ? 1 : 0);

package/scenarios.bak.1774780058/write_file_syntax.test.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+import { Test, assert, jsType } from '@j-o-r/sh';
+import { execSync } from 'child_process';
+import { mkdtempSync, writeFileSync, rmSync, mkdirSync } from 'fs';
+import { tmpdir } from 'os';
+import { join, dirname } from 'path';
+
+const t = new Test();
+const TMP = mkdtempSync(join(tmpdir(), 'syntax_test_'));
+process.on('exit', () => rmSync(TMP, { recursive: true, force: true }));
+
+const checkSyntax = (file) => {
+  try {
+    execSync(`./utils/syntax_check.sh "${file}"`, { cwd: process.cwd(), stdio: 'pipe', timeout: 5000 });
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
+
+const writeTemp = (relpath, content) => {
+  const file = join(TMP, relpath);
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, content);
+  return file;
+};
+
+t.add('checkSyntax returns boolean', () => {
+  const file = writeTemp('test.js', 'console.log("ok");');
+  assert.strictEqual(jsType(checkSyntax(file)), 'Boolean');
+});
+
+t.add('syntax_check: JS valid', () => {
+  const file = writeTemp('valid.js', '// Valid JS\nconsole.log("ok");');
+  assert.strictEqual(checkSyntax(file), true);
+});
+
+t.add('syntax_check: JS invalid (unexpected token)', () => {
+  const file = writeTemp('invalid.js', 'const x = ; console.log(x);');
+  assert.strictEqual(checkSyntax(file), false);
+});
+
+t.add('syntax_check: JS invalid unterminated quote', () => {
+  const file = writeTemp('invalid-quote.js', 'console.log("hi );');
+  assert.strictEqual(checkSyntax(file), false);
+});
+
+t.add('syntax_check: JS invalid unbalanced paren', () => {
+  const file = writeTemp('invalid-paren.js', 'if (true {\n  console.log("ok");\n}');
+  assert.strictEqual(checkSyntax(file), false);
+});
+
+t.add('syntax_check: JS valid ESM import', () => {
+  const file = writeTemp('valid-esm.js', 'import { Test } from "@j-o-r/sh";\nconsole.log("ok");');
+  assert.strictEqual(checkSyntax(file), true);
+});
+
+t.add('syntax_check: JS shebang valid', () => {
+  const file = writeTemp('valid-shebang.js', '#!/usr/bin/env node\nimport { Test } from "@j-o-r/sh";');
+  assert.strictEqual(checkSyntax(file), true);
+});
+
+t.add('syntax_check: JS subdir valid', () => {
+  const file = writeTemp('subdir/valid.js', 'console.log("ok");');
+  assert.strictEqual(checkSyntax(file), true);
+});
+
+// PY invalid: missing indent
+t.add('syntax_check: PY invalid (indent err)', () => {
+  const file = writeTemp('invalid.py', 'def f():\nprint("hi")');
+  assert.strictEqual(checkSyntax(file), false);
+});
+
+// PY valid
+t.add('syntax_check: PY valid', () => {
+  const file = writeTemp('valid.py', '#!/usr/bin/env python3\ndef f():\n    print("hi")\nf()');
+  assert.strictEqual(checkSyntax(file), true);
+});
+
+// SH invalid: missing fi
+t.add('syntax_check: SH invalid (missing fi)', () => {
+  const file = writeTemp('invalid.sh', '#!/bin/bash\nif true; then\necho "hi"');
+  assert.strictEqual(checkSyntax(file), false);
+});
+
+// SH valid
+t.add('syntax_check: SH valid', () => {
+  const file = writeTemp('valid.sh', '#!/bin/bash\necho "ok"');
+  assert.strictEqual(checkSyntax(file), true);
+});
+
+// SH shebang + if/fi
+t.add('syntax_check: SH valid (if/fi)', () => {
+  const file = writeTemp('valid-if.sh', '#!/usr/bin/env bash\nif true; then\n  echo "ok"\nfi');
+  assert.strictEqual(checkSyntax(file), true);
+});
+
+// JSON invalid: trailing comma
+t.add('syntax_check: JSON invalid', () => {
+  const file = writeTemp('invalid.json', '{ "key": "value", }');
+  assert.strictEqual(checkSyntax(file), false);
+});
+
+// JSON valid
+t.add('syntax_check: JSON valid', () => {
+  const file = writeTemp('valid.json', '{ "key": "value" }');
+  assert.strictEqual(checkSyntax(file), true);
+});
+
+// Unknown ext: non-fatal pass
+t.add('syntax_check: unknown ext (txt)', () => {
+  const file = writeTemp('test.txt', 'plain text');
+  assert.strictEqual(checkSyntax(file), true);
+});
+
+// write_file sim: invalid → reject (PY/SH/JSON/JS)
+t.add('syntax_check: write_file sim JS reject', () => {
+  const file = writeTemp('sim_invalid.js', 'console.log("hi );');
+  assert.strictEqual(checkSyntax(file), false);
+});
+
+t.add('syntax_check: write_file sim PY reject', () => {
+  const file = writeTemp('sim_invalid.py', 'def f():\nprint("hi")');
+  assert.strictEqual(checkSyntax(file), false);
+});
+
+t.add('syntax_check: write_file sim SH reject', () => {
+  const file = writeTemp('sim_invalid.sh', '#!/bin/bash\nif true; then echo hi');
+  assert.strictEqual(checkSyntax(file), false);
+});
+
+t.add('syntax_check: write_file sim JSON reject', () => {
+  const file = writeTemp('sim_invalid.json', '{invalid}');
+  assert.strictEqual(checkSyntax(file), false);
+});
+
+t.add('syntax_check: async valid JS', async () => {
+  const file = writeTemp('async-valid.js', 'console.log("ok");');
+  await new Promise(r => setTimeout(r, 10));
+  assert.strictEqual(checkSyntax(file), true);
+});
+
+const report = await t.run();
+assert.strictEqual(jsType(report), 'Object');
+process.exit(report.errors > 0 ? 1 : 0);

package/scenarios.bak.1774780058/write_file_validation/README.md

@@ -0,0 +1,30 @@
+# write_file Auto-Validation Test Suite
+
+## Purpose
+Tests the enhanced \`write_file\` tool in \`lib/genericToolset.js\`:
+- **JS Syntax Check**: \`node --check\` on .js/shebang files → blocks invalid.
+- **Error Guidance**: Forces LLM retry with \\\` fix hints.
+- **chmod +x**: Auto for shebangs.
+- **Self-Healing**: LLM sees error → regenerates valid JS.
+
+## Files
+- \`bad.js\`: Intentional syntax error (unclosed template literal \`console.log(\`).
+- \`good.js\`: Fixed (properly escaped \`console.log(\\\\\\`hello\\\\\\\`); \`).
+- \`test.sh\`: Runs write_file simulation → expect error on bad → success on good.
+
+## Run
+```bash
+cd scenarios/write_file_validation
+chmod +x test.sh
+./test.sh
+```
+Expected:
+```
+❌ Write bad.js → SYNTAX ERROR (node --check fails)
+✅ Write good.js → ✓ JS syntax OK + chmod +x (if shebang)
+```
+
+## LLM Test (via CodeServer)
+Query: \"Use write_file to create bad.js with console.log(\`hi\`); then fix it.\" → Auto-triggers retry loop.
+
+Current date: March 27, 2026.

package/scenarios.bak.1774780058/write_file_validation/bad.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+console.log(`Unclosed backtick syntax error!
+import { foo } from 'bar';

package/scenarios.bak.1774780058/write_file_validation/good.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+console.log(`Hello, fixed template literal!`);
+console.log('Proper JS syntax.');
+import { parseArgs } from '@j-o-r/sh'; // ESM OK

package/scenarios.bak.1774780058/write_file_validation/test.sh

@@ -0,0 +1,43 @@
+#!/bin/bash
+set -e
+
+echo "=== write_file Auto-Validation Test ==="
+cd "$(dirname "$0")"
+
+# Simulate toolset write_file (manual for demo; real uses lib/genericToolset.js)
+echo "1. Write BAD JS (expect SYNTAX ERROR)..."
+cat > temp_bad.js << 'EOF'
+#!/usr/bin/env node
+console.log(`Unclosed backtick!  // ERROR: Missing closing \`
+EOF
+
+# Manual node --check (mimics tool)
+if node --check temp_bad.js 2>&1; then
+  echo "❌ FAIL: Bad JS passed check!"
+else
+  echo "✅ PASS: Bad JS correctly rejected ($(node --check temp_bad.js 2>&1 | head -1))"
+fi
+
+echo "2. Write GOOD JS (expect ✓ OK + chmod)..."
+cat > temp_good.js << 'EOF'
+#!/usr/bin/env node
+console.log(`Fixed template!`);
+console.log('All good.');
+EOF
+
+if node --check temp_good.js 2>&1; then
+  echo "✅ PASS: Good JS syntax OK"
+  chmod +x temp_good.js
+  echo "✅ PASS: chmod +x applied"
+  ./temp_good.js  # Runs!
+else
+  echo "❌ FAIL: Good JS failed check!"
+fi
+
+# Real toolset test (requires running agent)
+echo "3. REAL TOOL TEST (run via CodeServer):"
+echo "   echo 'write_file scenarios/write_file_validation/new.js: console.log(\`test\`);' | dave --connect ws://...:8081/ws"
+echo "   → If bad: Error → LLM fixes → ✓ OK"
+
+rm -f temp_*.js
+echo "=== ALL TESTS PASS ✅ ==="

package/scenarios.bak.1774780058/wsClient.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+import cli from '@j-o-r/cli';
+import { WebSocketClient } from "@j-o-r/apiserver";
+const NAME = 'clarification';
+const wsUser = new WebSocketClient('ws://localhost:2000/ws?test=param');  // Match server port/path
+
+const queryMessages = new Map();
+
+/*
+HANDSHAKE:
+
+1: requests an introduction with 'introduce'
+2: get a response 'introduction'
+
+This must be DONE before anything else can take place
+
+*/
+
+cli.registerKeyMappings([
+    { name: 'd', ctrl: true, meta: false, shift: false, handler: async () => {
+    	process.exit(0);
+    }},
+    { name: 'r', ctrl: true, meta: false, shift: false, handler: async () => {
+    	cli.clear();
+    }}
+    
+]);
+// @ts-ignore
+cli.inputHandler = async (s, role) => {
+  const message = {
+  	action: 'query',
+  	content: s,
+  }
+  wsUser.send(JSON.stringify(message));
+  cli.startSpinner();
+}
+cli.focus('log');
+cli.write('CTRL - d exit');
+cli.write('CTRL - r clear screen / reset');
+// cli.focus('user', true);
+
+wsUser.onopen = () => {
+  cli.focus('log');
+	cli.write('Jorrit connected');
+	// Send my introduction to the server
+	wsUser.send(JSON.stringify({
+		action: 'introduction',
+		name: NAME,
+		content: 'I am a human named Jorrit. Query me for questions that needs clearfication',
+		id: new Date().getTime()
+	}));
+	cli.focus('user', true);
+
+};
+/**
+* @type {MessageEvent} event
+*/
+wsUser.onmessage = (event) => {
+	const data = JSON.parse(event.data);  // Forwarded HTTP request
+	console.log('Received request:', data);
+	cli.focus('user', true);
+};
+wsUser.onclose = () => {
+	console.log('WS closed');
+	process.exit();
+}
+wsUser.onerror = (err) => {
+	console.error('WS error:', err);
+}