feat: Add QA Subagent Profile leveraging Local Gemma4 Swarm (#9749)

Author: tobiu

ai/Agent.mjs

@@ -52,7 +52,8 @@ class Agent extends Base {
          */
         subAgents: {
             browser  : async () => (await import('./agent/profile/Browser.mjs')).default,
-            librarian: async () => (await import('./agent/profile/Librarian.mjs')).default
+            librarian: async () => (await import('./agent/profile/Librarian.mjs')).default,
+            qa       : async () => (await import('./agent/profile/QA.mjs')).default
         }
     }
 

ai/agent/profile/QA.mjs

@@ -0,0 +1,60 @@
+import Agent from '../../Agent.mjs';
+
+/**
+ * A specialized sub-agent for generating and validating automated test coverage.
+ * Configured by default to execute locally ensuring zero-cost test suite scaling.
+ *
+ * @class Neo.ai.agent.profile.QA
+ * @extends Neo.ai.Agent
+ */
+class QA extends Agent {
+    static config = {
+        /**
+         * @member {String} className='Neo.ai.agent.profile.QA'
+         * @protected
+         */
+        className: 'Neo.ai.agent.profile.QA',
+        /**
+         * The QA Bot executes natively on the local swarm to prevent token explosion.
+         * Default Provider is Ollama, targeting the workspace's default local inference daemon.
+         * @member {String|Neo.ai.provider.Base} modelProvider='ollama'
+         */
+        modelProvider: 'ollama',
+        /**
+         * @member {String} model='gemma4'
+         */
+        model: 'gemma4',
+        /**
+         * The QA agent needs context matching capabilities to assert components,
+         * so we attach the knowledge base.
+         * @member {String[]} servers=['knowledge-base']
+         */
+        systemPrompt: `You are the QA Subagent, a strict Quality Assurance automation engineer specializing in Neo.mjs and Playwright.
+Your responsibility is to analyze given class designs or code implementations, and output highly robust, isolated unit tests using Playwright syntax inside the Neo context.
+
+CRITICAL NEO.MJS UNIT TESTING RULES:
+1. NEVER use generic Playwright page navigation (e.g. page.goto). Tests run in Node.js using "Single-Thread Simulation".
+2. You MUST import the setup block:
+   import {setup} from '../../setup.mjs';
+   setup({ neoConfig: { allowVdomUpdatesInTests: true, unitTestMode: true, useDomApiRenderer: true }, appConfig: { name: 'TestApp', isMounted: () => true, vnodeInitialising: false }});
+3. You MUST import the Neo framework and augment the core environment:
+   import Neo from '../../../../src/Neo.mjs';
+   import * as core from '../../../../src/core/_export.mjs';
+4. To test a Component VDOM rendering, import the renderer and engine:
+   import DomApiVnodeCreator from '../../../../src/vdom/util/DomApiVnodeCreator.mjs';
+   import VdomHelper from '../../../../src/vdom/Helper.mjs';
+5. Always create components using Neo.create:
+   componentInstance = Neo.create(Button, { iconCls: 'fa fa-user', text: 'Hello' });
+6. Always manually trigger virtual mounting:
+   const { vnode } = await componentInstance.initVnode();
+   componentInstance.mounted = true;
+7. Always perform state mutation tests using the generic set() API to trigger automated VDOM loops (do NOT hallucinate internal updateVnode methods):
+   await componentInstance.set({ text: 'Update' });
+   await VdomHelper.render(componentInstance.vnode, container);
+8. Always destroy instances in test.afterEach().
+
+Never write boilerplate placeholders. ALWAYS use exhaustive assertions. If you cannot test something, explicitly fail and state why.`
+    }
+}
+
+export default Neo.setupClass(QA);

ai/provider/Ollama.mjs

@@ -20,9 +20,9 @@ class OllamaProvider extends Base {
          */
         host: 'http://127.0.0.1:11434',
         /**
-         * @member {String} modelName='gemma-4'
+         * @member {String} modelName='gemma4'
          */
-        modelName: 'gemma-4',
+        modelName: 'gemma4',
         /**
          * @member {String[]} requiredEnv=[]
          */

test/playwright/unit/ai/agent/QA.spec.mjs

@@ -0,0 +1,96 @@
+import {setup} from '../../../setup.mjs';
+
+const appName = 'QAAgentTest';
+
+setup({
+    neoConfig: {
+        allowVdomUpdatesInTests: false,
+        unitTestMode           : true,
+        useDomApiRenderer      : false
+    },
+    appConfig: {
+        name             : appName,
+        isMounted        : () => true,
+        vnodeInitialising: false
+    }
+});
+
+import {test, expect}  from '@playwright/test';
+import Neo             from '../../../../../src/Neo.mjs';
+import * as core       from '../../../../../src/core/_export.mjs';
+import Agent           from '../../../../../ai/Agent.mjs';
+import Assembler       from '../../../../../ai/context/Assembler.mjs';
+import path            from 'path';
+import {fileURLToPath} from 'url';
+import dotenv          from 'dotenv';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname  = path.dirname(__filename);
+dotenv.config({path: path.resolve(__dirname, '../../../../../.env'), quiet: true});
+
+test.describe('QA Sub-Agent Swarm Node', () => {
+    let primaryAgent;
+    let originalAssemble;
+
+    test.beforeAll(() => {
+        originalAssemble = Assembler.prototype.assemble;
+        // Mock the ContextAssembler across the entire Swarm to prevent
+        // offline Test nodes from trying to query the live MCP Vector Databases.
+        Assembler.prototype.assemble = async function({systemPrompt, userQuery}) {
+            return {
+                system: systemPrompt,
+                messages: [{ role: 'user', content: userQuery }]
+            };
+        };
+    });
+
+    test.afterAll(async () => {
+        Assembler.prototype.assemble = originalAssemble;
+        if (primaryAgent) {
+            await primaryAgent.disconnect();
+        }
+    });
+
+    test('Primary Agent delegates unit testing task to QA via Gemma4/Ollama', async () => {
+        // Skip test in CI environments or if we explicitly don't have a local daemon
+        // Since this relies on a local Ollama daemon hosting gemma-4, we just let it run locally 
+        // to evaluate the Swarm's intelligence.
+        test.setTimeout(120000); // Give Gemma4 up to 2 minutes to generate the test code
+
+        // The primary orchestrator boots up
+        primaryAgent = Neo.create(Agent, {
+            servers: []
+        });
+
+        await primaryAgent.initAsync();
+
+        const request = `
+        Analyze the component 'Neo.button.Base'.
+        Write a 100% complete Playwright test suite for it.
+        Focus exclusively on DOM mounting and testing the 'text' configuration property mutability.
+        Return ONLY the code block and nothing else.
+        `;
+
+        // We DO NOT mock the delegate method here. We want to actually hit the local Gemma-4 node 
+        // through the Ollama provider to evaluate its ability to follow the System Prompt rules.
+        console.log('Sending request to local Gemma4 Swarm node...');
+        const generatedCode = await primaryAgent.delegate('qa', request);
+
+        // Basic sanity checks on the raw AI output string to ensure it adhered to the Neo.mjs Testing Primitives
+        expect(typeof generatedCode).toBe('string');
+        expect(generatedCode.length).toBeGreaterThan(100);
+
+        // Core assertions to ensure Gemma4 learned the rules from its System Prompt
+        expect(generatedCode).toContain('import {setup} from');
+        expect(generatedCode).toContain("import Neo from '../../../../src/Neo.mjs'");
+        expect(generatedCode).toContain('DomApiVnodeCreator');
+        expect(generatedCode).toContain('Neo.create(');
+        expect(generatedCode).toContain('initVnode()');
+        expect(generatedCode).toContain('.mounted = true');
+        expect(generatedCode).toContain('.set({');
+
+        console.log('\n--- Gemma4 QA Output Start ---');
+        console.log(generatedCode);
+        console.log('--- Gemma4 QA Output End ---\n');
+    });
+});