onbuzz 4.7.2 → 4.8.1

package/src/tools/__tests__/baseTool.test.js

@@ -364,6 +364,148 @@ describe('ToolsRegistry', () => {
     expect(desc).toContain('HOW TO GET TOOL DOCUMENTATION');
   });
 
+  describe('OPERATING POSTURE section', () => {
+    // Minimal fakes so the registry will accept these as memory/skills/taskmanager.
+    // BaseTool derives `this.id` from the class name (lowercased, with
+    // "Tool" stripped) — so the class must be named exactly *Tool* and
+    // the id is derived. We override `this.id` after super() to pin it
+    // independently of the class name, which keeps the test classes
+    // readable. validateTool() also requires parseParameters.
+    class FakeMemoryTool extends BaseTool {
+      constructor() { super(); this.id = 'memory'; }
+      getDescription() { return 'Memory tool stub'; }
+      parseParameters() { return {}; }
+      async execute() { return { ok: true }; }
+    }
+    class FakeSkillsTool extends BaseTool {
+      constructor() { super(); this.id = 'skills'; }
+      getDescription() { return 'Skills tool stub'; }
+      parseParameters() { return {}; }
+      async execute() { return { ok: true }; }
+    }
+    class FakeTaskManagerTool extends BaseTool {
+      constructor() { super(); this.id = 'taskmanager'; }
+      getDescription() { return 'TaskManager tool stub'; }
+      parseParameters() { return {}; }
+      async execute() { return { ok: true }; }
+    }
+
+    test('appears when memory tool is in capabilities (proactive memory nudge)', async () => {
+      await registry.registerTool(FakeMemoryTool);
+      const desc = registry.generateToolDescriptionsForPrompt(['memory']);
+      expect(desc).toContain('OPERATING POSTURE');
+      expect(desc).toMatch(/memory.*list/i);
+      // Plan/* should be cross-referenced here so agents writing a plan
+      // memory isn't an isolated tip buried in the memory tool's own desc.
+      expect(desc).toContain('plan/');
+    });
+
+    test('appears when skills tool is in capabilities (proactive skills nudge)', async () => {
+      await registry.registerTool(FakeSkillsTool);
+      const desc = registry.generateToolDescriptionsForPrompt(['skills']);
+      expect(desc).toContain('OPERATING POSTURE');
+      expect(desc).toMatch(/skills.*list/i);
+    });
+
+    test('does NOT appear when neither memory nor skills is in capabilities', async () => {
+      await registry.registerTool(TestTool);
+      const desc = registry.generateToolDescriptionsForPrompt(['test']);
+      expect(desc).not.toContain('OPERATING POSTURE');
+    });
+
+    test('distinguishes memory vs taskmanager when both are present (so agents know which to use)', async () => {
+      await registry.registerTool(FakeMemoryTool);
+      await registry.registerTool(FakeTaskManagerTool);
+      const desc = registry.generateToolDescriptionsForPrompt(['memory', 'taskmanager']);
+      expect(desc).toContain('OPERATING POSTURE');
+      expect(desc).toContain('persistent knowledge'); // memory
+      expect(desc).toContain('step-by-step');          // taskmanager
+    });
+  });
+
+  // ── Per-model prompt shape: skip text docs for tools with native schemas
+  //    when the target uses the Responses API (codex / o-series / gpt-5-pro).
+  describe('apiType="responses" — trims duplication with native function schemas', () => {
+    class FakeMemoryTool extends BaseTool {
+      constructor() { super(); this.id = 'memory'; }
+      getDescription() { return 'Memory tool stub with LONG description that would normally take many tokens'; }
+      getSummary() { return 'Persistent memory'; }
+      parseParameters() { return {}; }
+      async execute() { return { ok: true }; }
+    }
+    class FakeTerminalTool extends BaseTool {
+      constructor() { super(); this.id = 'terminal'; }
+      getDescription() { return 'Terminal tool LONG description that would normally take many tokens'; }
+      getSummary() { return 'Shell access'; }
+      parseParameters() { return {}; }
+      async execute() { return { ok: true }; }
+    }
+    class FakeWebTool extends BaseTool {
+      // 'web' is NOT in OPENAI_FUNCTION_SCHEMAS — its text doc must always appear.
+      constructor() { super(); this.id = 'web'; }
+      getDescription() { return 'Web tool LONG description that would normally take many tokens'; }
+      getSummary() { return 'Browser automation'; }
+      parseParameters() { return {}; }
+      async execute() { return { ok: true }; }
+    }
+
+    test('omits text description for tools that have native function schemas (memory, terminal)', async () => {
+      await registry.registerTool(FakeMemoryTool);
+      await registry.registerTool(FakeTerminalTool);
+
+      const responsesDesc = registry.generateToolDescriptionsForPrompt(
+        ['memory', 'terminal'],
+        { apiType: 'responses' },
+      );
+      // Header still present + one-line pointer to structured schema.
+      expect(responsesDesc).toContain('AVAILABLE TOOLS');
+      expect(responsesDesc).toContain('see structured schema');
+      // The big multi-line text doc must NOT be repeated.
+      expect(responsesDesc).not.toContain('### MEMORY TOOL');
+      expect(responsesDesc).not.toContain('### TERMINAL TOOL');
+      expect(responsesDesc).not.toContain('LONG description that would normally take many tokens');
+    });
+
+    test('keeps text description for tools that do NOT have native function schemas (e.g. web)', async () => {
+      await registry.registerTool(FakeWebTool);
+      const responsesDesc = registry.generateToolDescriptionsForPrompt(
+        ['web'],
+        { apiType: 'responses' },
+      );
+      // 'web' has no native schema → text doc MUST be present.
+      expect(responsesDesc).toContain('### WEB TOOL');
+      expect(responsesDesc).toContain('LONG description that would normally take many tokens');
+    });
+
+    test('BACKWARD COMPAT: without apiType option, behaves exactly as before (full text for everything)', async () => {
+      await registry.registerTool(FakeMemoryTool);
+      await registry.registerTool(FakeTerminalTool);
+
+      const defaultDesc = registry.generateToolDescriptionsForPrompt(['memory', 'terminal']);
+      // No apiType → keep the heavy text docs as today.
+      expect(defaultDesc).toContain('### MEMORY TOOL');
+      expect(defaultDesc).toContain('### TERMINAL TOOL');
+    });
+
+    test('BACKWARD COMPAT: apiType="chat_completion" is equivalent to no apiType', async () => {
+      await registry.registerTool(FakeMemoryTool);
+      const a = registry.generateToolDescriptionsForPrompt(['memory'], { apiType: 'chat_completion' });
+      const b = registry.generateToolDescriptionsForPrompt(['memory']);
+      expect(a).toBe(b);
+    });
+
+    test('enhanceSystemPrompt forwards apiType option to the description builder', async () => {
+      await registry.registerTool(FakeMemoryTool);
+      const native = registry.enhanceSystemPrompt('Base.', ['memory'], { apiType: 'responses' });
+      const inline = registry.enhanceSystemPrompt('Base.', ['memory']);
+      // Native form is meaningfully shorter (we dropped the per-tool block).
+      expect(native.length).toBeLessThan(inline.length);
+      // Both still contain the section headers and the original base prompt.
+      expect(native).toContain('Base.');
+      expect(native).toContain('AVAILABLE TOOLS');
+    });
+  });
+
   test('enhanceSystemPrompt appends tool docs', async () => {
     await registry.registerTool(TestTool);
     const enhanced = registry.enhanceSystemPrompt('Base prompt.', []);
@@ -419,6 +561,28 @@ describe('ToolsRegistry', () => {
     expect(tools[0].iconName.length).toBeGreaterThan(0);
   });
 
+  test('getAvailableToolsForUI prefers tool.name over description-parsed name', async () => {
+    // Regression: previously getAvailableToolsForUI ignored the explicit
+    // `this.name` set in every tool's constructor and tried to parse
+    // a name from "Foo Tool: …" prefixes in the description. When the
+    // description didn't follow that pattern OR had a colon elsewhere,
+    // the UI ended up rendering long sentences as the "name".
+    class NamedTool extends BaseTool {
+      constructor(...args) { super(...args); this.id = 'named'; this.name = 'Named Display'; }
+      getDescription() { return 'Some long description with a colon: that the old regex would eat'; }
+      parseParameters() { return {}; }
+      async execute() { return {}; }
+    }
+    await registry.registerTool(NamedTool);
+    const tools = registry.getAvailableToolsForUI();
+    const named = tools.find(t => t.id === 'named');
+    expect(named).toBeTruthy();
+    expect(named.name).toBe('Named Display');
+    // The description field still carries the readable first line —
+    // never the raw "name: " token alone.
+    expect(named.description.length).toBeGreaterThan(0);
+  });
+
   test('_getToolCategory maps every known tool (no "Other") incl. video-gen', () => {
     // Locks the "tools introduced to UI" alignment — a tool with no
     // explicit category falls into "Other" and gets buried in dropdowns.

package/src/tools/__tests__/codeMapTool.test.js

@@ -334,6 +334,298 @@ describe('CodeMapTool', () => {
     expect(re).toContain('(.+/)?');
   });
 
+  // ─────────────────────────────────────────────────────────────────
+  // Browser-JS / pre-ES-module patterns. Before this set of regexes,
+  // CodeMap on a vanilla client-side .js file produced an empty map
+  // because the parser only matched ESM exports + class methods.
+  // These tests pin the new patterns. Each test exercises ONE pattern
+  // in isolation so a future regression on any one of them surfaces
+  // a precise failure.
+  // ─────────────────────────────────────────────────────────────────
+  describe('_parseJS — browser-JS patterns', () => {
+    const opts = { publicOnly: false, withComments: false, includeImports: false };
+    const signatures = (entries) =>
+      entries.filter(e => e.kind === 'signature').map(e => e.text.trim());
+
+    test('top-level IIFE is captured', () => {
+      const entries = tool._parseJS([
+        '(function () {',
+        '  var x = 1;',
+        '})();',
+      ], opts);
+      expect(signatures(entries)).toContain('(function () {');
+    });
+
+    test('IIFE with leading ! or + prefix (Webpack-UMD style)', () => {
+      const entries = tool._parseJS([
+        '!function () { return 1; }();',
+        '+function () { return 2; }();',
+      ], opts);
+      expect(signatures(entries)).toEqual(expect.arrayContaining([
+        '!function () { return 1; }();',
+        '+function () { return 2; }();',
+      ]));
+    });
+
+    test('window.X = function — global assignment', () => {
+      const entries = tool._parseJS([
+        'window.MyApp = function () {',
+        '  return 1;',
+        '};',
+      ], opts);
+      expect(signatures(entries).join('\n')).toMatch(/window\.MyApp\s*=\s*function/);
+    });
+
+    test('globalThis.foo = () => — global arrow assignment', () => {
+      const entries = tool._parseJS([
+        'globalThis.greet = (name) => `hi ${name}`;',
+      ], opts);
+      expect(signatures(entries).join('\n')).toMatch(/globalThis\.greet/);
+    });
+
+    test('Namespace.utils.foo = function — namespaced global assignment', () => {
+      const entries = tool._parseJS([
+        'MyApp.utils.formatDate = function (d) {',
+        '  return d.toISOString();',
+        '};',
+      ], opts);
+      expect(signatures(entries).join('\n')).toMatch(/MyApp\.utils\.formatDate/);
+    });
+
+    test('Foo.prototype.bar = function — prototype method', () => {
+      const entries = tool._parseJS([
+        'Foo.prototype.bar = function () {',
+        '  return this.x;',
+        '};',
+      ], opts);
+      expect(signatures(entries).join('\n')).toMatch(/Foo\.prototype\.bar/);
+    });
+
+    test('Foo.prototype.bar = () => — prototype arrow assignment', () => {
+      // (Real-world prototype-as-arrow is unusual but the regex
+      // covers it for completeness.)
+      const entries = tool._parseJS([
+        'Foo.prototype.bar = () => 42;',
+      ], opts);
+      expect(signatures(entries).join('\n')).toMatch(/Foo\.prototype\.bar/);
+    });
+
+    test('jQuery $.fn.plugin = function — jQuery plugin pattern', () => {
+      const entries = tool._parseJS([
+        '$.fn.myPlugin = function (opts) {',
+        '  return this.each(function () {});',
+        '};',
+      ], opts);
+      expect(signatures(entries).join('\n')).toMatch(/\$\.fn\.myPlugin/);
+    });
+
+    test('jQuery.fn.plugin = function — full jQuery prefix', () => {
+      const entries = tool._parseJS([
+        'jQuery.fn.banner = function () { return this; };',
+      ], opts);
+      expect(signatures(entries).join('\n')).toMatch(/jQuery\.fn\.banner/);
+    });
+
+    test('document.addEventListener("DOMContentLoaded", …) — page lifecycle', () => {
+      const entries = tool._parseJS([
+        'document.addEventListener("DOMContentLoaded", () => {',
+        '  init();',
+        '});',
+      ], opts);
+      expect(signatures(entries).join('\n')).toMatch(/document\.addEventListener/);
+    });
+
+    test('window.addEventListener("load", …) — page lifecycle (alt)', () => {
+      const entries = tool._parseJS([
+        'window.addEventListener("load", function () { boot(); });',
+      ], opts);
+      expect(signatures(entries).join('\n')).toMatch(/window\.addEventListener/);
+    });
+
+    test('REGRESSION: a vanilla browser file (IIFE wrapping jQuery plugins) now produces a non-empty map', () => {
+      // This is the original failure case: pure client-side .js with
+      // none of the new patterns produced zero entries. Pre-fix this
+      // file's signatures.length would have been 0; post-fix it's > 0.
+      const entries = tool._parseJS([
+        '(function ($) {',
+        '  $.fn.tooltip = function (options) {',
+        '    return this.each(function () {});',
+        '  };',
+        '  $.fn.popover = function (options) {',
+        '    return this.each(function () {});',
+        '  };',
+        '})(jQuery);',
+      ], opts);
+      expect(signatures(entries).length).toBeGreaterThanOrEqual(3);
+    });
+
+    test('REGRESSION: file unaffected by changes — modern ESM still matches', () => {
+      // Make sure adding the new regexes didn't regress the original
+      // matcher set.
+      const entries = tool._parseJS([
+        'export function hello() {}',
+        'export class Greeter {}',
+        'export const sum = (a, b) => a + b;',
+      ], opts);
+      expect(signatures(entries).length).toBe(3);
+    });
+  });
+
+  // ─────────────────────────────────────────────────────────────────
+  // C / C++ — _parseC. Same approach as the JS path; we lock the
+  // patterns the regex needs to handle on real-world C/CPP files so
+  // a future refactor (e.g. swapping for tree-sitter) has explicit
+  // behavior to preserve.
+  // ─────────────────────────────────────────────────────────────────
+  describe('_parseC — C/C++ skeleton extraction', () => {
+    const opts = { publicOnly: false, withComments: false, includeImports: true };
+    const sig = (lines) => tool._parseC(lines, opts).filter(e => e.kind === 'signature').map(e => e.text.trim());
+    const imp = (lines) => tool._parseC(lines, opts).filter(e => e.kind === 'import').map(e => e.text.trim());
+
+    test('#include with angle brackets and quotes', () => {
+      const lines = [
+        '#include <stdio.h>',
+        '#include "myheader.h"',
+      ];
+      expect(imp(lines)).toEqual([
+        '#include <stdio.h>',
+        '#include "myheader.h"',
+      ]);
+    });
+
+    test('#define captured as signature', () => {
+      expect(sig(['#define MAX_BUF 1024', '#define PI 3.14'])).toEqual([
+        '#define MAX_BUF 1024',
+        '#define PI 3.14',
+      ]);
+    });
+
+    test('class / struct / union / enum / namespace headers', () => {
+      const lines = [
+        'class Foo {',
+        '};',
+        'struct Bar {',
+        '};',
+        'union Baz { int a; };',
+        'enum class Color { RED, GREEN };',
+        'namespace loxia {',
+        '}',
+      ];
+      const found = sig(lines).join('\n');
+      expect(found).toMatch(/class Foo/);
+      expect(found).toMatch(/struct Bar/);
+      expect(found).toMatch(/union Baz/);
+      expect(found).toMatch(/enum class Color/);
+      expect(found).toMatch(/namespace loxia/);
+    });
+
+    test('typedef and using alias', () => {
+      const lines = [
+        'typedef unsigned long u64;',
+        'using IntList = std::vector<int>;',
+      ];
+      const found = sig(lines).join('\n');
+      expect(found).toMatch(/typedef unsigned long u64/);
+      expect(found).toMatch(/using IntList/);
+    });
+
+    test('free function definition with simple return type', () => {
+      const lines = [
+        'int add(int a, int b) {',
+        '  return a + b;',
+        '}',
+      ];
+      expect(sig(lines).join('\n')).toMatch(/int add\(int a, int b\)/);
+    });
+
+    test('static + inline + const-qualified function definitions', () => {
+      const lines = [
+        'static inline int square(int x) { return x * x; }',
+        'const char* greet(const char* name) {',
+        '  return name;',
+        '}',
+      ];
+      const found = sig(lines).join('\n');
+      expect(found).toMatch(/static inline int square/);
+      expect(found).toMatch(/const char\* greet/);
+    });
+
+    test('method, constructor, and destructor', () => {
+      const lines = [
+        'Foo::Foo(int x) : x_(x) {',
+        '}',
+        'Foo::~Foo() {',
+        '}',
+        'int Foo::compute(int n) const {',
+        '  return n * x_;',
+        '}',
+      ];
+      const found = sig(lines).join('\n');
+      expect(found).toMatch(/Foo::Foo\(int x\)/);
+      expect(found).toMatch(/Foo::~Foo\(\)/);
+      expect(found).toMatch(/int Foo::compute/);
+    });
+
+    test('REGRESSION: function CALLS are NOT misidentified as definitions', () => {
+      // Without the call-rejection heuristic, the regex would happily
+      // grab `printf("hi");` as a signature. Lock that it doesn't.
+      const lines = [
+        'int main(void) {',
+        '  printf("hi");',
+        '  foo();',
+        '  return 0;',
+        '}',
+      ];
+      // Only main(void) should be a signature; printf/foo are calls.
+      const found = sig(lines);
+      expect(found).toEqual(['int main(void) {']);
+    });
+
+    test('REGRESSION: a tiny realistic C file produces a useful skeleton', () => {
+      const lines = [
+        '#include <stdio.h>',
+        '',
+        '#define BUF_SIZE 256',
+        '',
+        'typedef struct {',
+        '  int x;',
+        '  int y;',
+        '} Point;',
+        '',
+        'static int distance_sq(Point p) {',
+        '  return p.x * p.x + p.y * p.y;',
+        '}',
+        '',
+        'int main(int argc, char** argv) {',
+        '  Point p = { 3, 4 };',
+        '  printf("d² = %d\\n", distance_sq(p));',
+        '  return 0;',
+        '}',
+      ];
+      const all = tool._parseC(lines, opts);
+      // Includes count as imports; the rest are signatures.
+      const imports = all.filter(e => e.kind === 'import').map(e => e.text.trim());
+      const signatures = all.filter(e => e.kind === 'signature').map(e => e.text.trim());
+      expect(imports).toEqual(['#include <stdio.h>']);
+      expect(signatures).toEqual(expect.arrayContaining([
+        '#define BUF_SIZE 256',
+        'static int distance_sq(Point p) {',
+        'int main(int argc, char** argv) {',
+      ]));
+    });
+  });
+
+  test('_langOf detects C/C++ files', () => {
+    expect(tool._langOf('foo.c')).toBe('c');
+    expect(tool._langOf('foo.h')).toBe('c');
+    expect(tool._langOf('foo.cpp')).toBe('c');
+    expect(tool._langOf('foo.cxx')).toBe('c');
+    expect(tool._langOf('foo.hpp')).toBe('c');
+    expect(tool._langOf('foo.cc')).toBe('c');
+    expect(tool._langOf('app.js')).toBe('js'); // sanity
+    expect(tool._langOf('script.py')).toBe('python'); // sanity
+  });
+
   test('execute skeleton on unsupported file type throws', async () => {
     mockFsPromises.stat.mockResolvedValue({
       isFile: () => true,
@@ -345,4 +637,100 @@ describe('CodeMapTool', () => {
       context
     )).rejects.toThrow('Unsupported file type');
   });
+
+  // ─────────────────────────────────────────────────────────────────
+  // Regex-free parser regressions — these cases are exactly the
+  // kind of pattern that brittle regex would silently mis-classify.
+  // They lock down the new string-utility implementation against
+  // the most common false-positive risks.
+  // ─────────────────────────────────────────────────────────────────
+  describe('REGRESSION: no-regex parsers — false-positive guards', () => {
+    const opts = { publicOnly: false, withComments: false, includeImports: true };
+
+    // JS
+    test('JS: `class` keyword does NOT match `classroom = …`', () => {
+      const entries = tool._parseJS(['classroom = 1;'], opts);
+      // No signature should be emitted — `classroom` is a plain var, not a class.
+      expect(entries.filter(e => e.kind === 'signature').length).toBe(0);
+    });
+    test('JS: string literal containing `class` does NOT push a class frame', () => {
+      // Pre-fix the original regex `(stripped.match(/\{/g) || []).length` could
+      // be tripped by content inside strings if not pre-masked. The no-regex
+      // implementation masks strings before counting braces.
+      const entries = tool._parseJS([
+        'const x = "class Foo {";',
+      ], opts);
+      // Only the `const` line should produce something; no class signature.
+      const sigs = entries.filter(e => e.kind === 'signature').map(e => e.text);
+      expect(sigs.some(s => s.startsWith('class '))).toBe(false);
+    });
+    test('JS: `// foo` and `/* foo */` line/block comments still suppress signatures', () => {
+      const entries = tool._parseJS([
+        '// export function fake() {}',
+        '/* export function alsoFake() {} */',
+        'export function real() {}',
+      ], opts);
+      const sigs = entries.filter(e => e.kind === 'signature').map(e => e.text.trim());
+      expect(sigs).toEqual(['export function real() {}']);
+    });
+    test('JS: `require` as a substring inside another identifier is NOT an import', () => {
+      // E.g. `prerequires = []` or `xrequireY()` — neither should be classified
+      // as an import line by the require-call detector.
+      const entries = tool._parseJS([
+        'const xrequireY = makeIt();',
+      ], opts);
+      expect(entries.filter(e => e.kind === 'import').length).toBe(0);
+    });
+    test('JS: `==` after a global LHS does NOT trigger an assignment match', () => {
+      const entries = tool._parseJS([
+        'window.foo == bar;',
+      ], opts);
+      expect(entries.filter(e => e.kind === 'signature').length).toBe(0);
+    });
+
+    // C
+    test('C: `class` inside a string literal does NOT push a class signature', () => {
+      const entries = tool._parseC([
+        'const char* msg = "class is a keyword in C++";',
+      ], opts);
+      // The C parser is line-based and doesn't deeply track string state;
+      // this asserts the realistic case where the assignment isn't a class.
+      // The line shouldn't surface as a "class …" signature.
+      const sigs = entries.filter(e => e.kind === 'signature').map(e => e.text);
+      expect(sigs.some(s => s.trim().startsWith('class '))).toBe(false);
+    });
+    test('C: bare function CALL `foo(x, y);` is NOT a definition', () => {
+      const entries = tool._parseC(['  foo(1, 2);'], opts);
+      expect(entries.filter(e => e.kind === 'signature').length).toBe(0);
+    });
+
+    // Python
+    test('Python: `class` keyword does NOT match `classroom = 1`', () => {
+      const entries = tool._parsePython(['classroom = 1'], opts);
+      // It's a top-level data assignment, NOT a class signature.
+      const sigs = entries.filter(e => e.kind === 'signature').map(e => e.text);
+      expect(sigs.length).toBe(0);
+      const datas = entries.filter(e => e.kind === 'data');
+      expect(datas.length).toBe(1);
+    });
+    test('Python: `def` keyword on a line where it is NOT the leading token (e.g. `nodef(x):`) is not a function', () => {
+      // The word-boundary check in startsWithKeyword catches this case.
+      const entries = tool._parsePython(['nodef(x):'], opts);
+      expect(entries.filter(e => e.kind === 'signature').length).toBe(0);
+    });
+    test('Python: relative import `from . import foo` is captured', () => {
+      const entries = tool._parsePython(['from . import foo'], opts);
+      expect(entries.filter(e => e.kind === 'import').length).toBe(1);
+    });
+    test('Python: docstring closes correctly on a one-liner', () => {
+      const entries = tool._parsePython([
+        'def hello():',
+        '    """One-liner docstring."""',
+        '    return 1',
+      ], { ...opts, withComments: true });
+      const kinds = entries.map(e => e.kind);
+      expect(kinds).toContain('signature');
+      expect(kinds).toContain('comment');
+    });
+  });
 });