agentic-qe 3.6.14 → 3.6.16

package/v3/dist/mcp/bundle.js

@@ -38669,7 +38669,7 @@ var BaseTestGenerator = class _BaseTestGenerator {
     for (const [typeKey, generator] of _BaseTestGenerator.TYPE_VALUE_TABLE) {
       if (type.includes(typeKey)) return generator();
     }
-    return `mock${param.name.charAt(0).toUpperCase() + param.name.slice(1)}`;
+    return `{} /* TODO: provide ${param.name}: ${param.type || "unknown"} */`;
   }
   /**
    * Generate test cases for a function based on its signature
@@ -38682,21 +38682,62 @@ var BaseTestGenerator = class _BaseTestGenerator {
     const testCases = [];
     const validParams = fn.parameters.map((p74) => this.generateTestValue(p74)).join(", ");
     const fnCall = fn.isAsync ? `await ${fn.name}(${validParams})` : `${fn.name}(${validParams})`;
+    const isVoid = fn.returnType === "void" || fn.returnType === "Promise<void>";
+    let assertion = "expect(result).toBeDefined();";
+    if (!isVoid) {
+      if (/^(is|has|can)[A-Z]/.test(fn.name)) {
+        assertion = "expect(typeof result).toBe('boolean');";
+      } else if (/^(get|fetch|find)[A-Z]/.test(fn.name)) {
+        assertion = "expect(result).not.toBeUndefined();";
+      } else if (/^(create|build|make)[A-Z]/.test(fn.name)) {
+        assertion = "expect(result).toBeTruthy();";
+      } else if (fn.returnType) {
+        const rt3 = fn.returnType.toLowerCase().replace(/promise<(.+)>/, "$1");
+        if (rt3.includes("boolean")) assertion = "expect(typeof result).toBe('boolean');";
+        else if (rt3.includes("number")) assertion = "expect(typeof result).toBe('number');";
+        else if (rt3.includes("string")) assertion = "expect(typeof result).toBe('string');";
+        else if (rt3.includes("[]") || rt3.includes("array")) assertion = "expect(Array.isArray(result)).toBe(true);";
+      }
+    }
     testCases.push({
       description: "should handle valid input correctly",
       type: "happy-path",
-      action: `const result = ${fnCall};`,
-      assertion: "expect(result).toBeDefined();"
+      action: isVoid ? `${fnCall};` : `const result = ${fnCall};`,
+      assertion: isVoid ? `// void function \u2014 no return value to assert` : assertion
     });
+    const bodyText = fn.body || "";
+    const hasExplicitThrow = /\bthrow\b/.test(bodyText) || /\bvalidat/i.test(bodyText);
     for (const param of fn.parameters) {
       if (!param.optional) {
         const paramsWithUndefined = fn.parameters.map((p74) => p74.name === param.name ? "undefined" : this.generateTestValue(p74)).join(", ");
-        testCases.push({
-          description: `should handle undefined ${param.name}`,
-          type: "error-handling",
-          action: fn.isAsync ? `const action = async () => await ${fn.name}(${paramsWithUndefined});` : `const action = () => ${fn.name}(${paramsWithUndefined});`,
-          assertion: "expect(action).toThrow();"
-        });
+        if (hasExplicitThrow) {
+          testCases.push({
+            description: `should handle undefined ${param.name}`,
+            type: "error-handling",
+            action: fn.isAsync ? `const action = async () => await ${fn.name}(${paramsWithUndefined});` : `const action = () => ${fn.name}(${paramsWithUndefined});`,
+            assertion: "expect(action).toThrow();"
+          });
+        } else {
+          const undefinedCall = fn.isAsync ? `await ${fn.name}(${paramsWithUndefined})` : `${fn.name}(${paramsWithUndefined})`;
+          testCases.push({
+            description: `should handle undefined ${param.name}`,
+            type: "edge-case",
+            action: fn.isAsync ? `let threw = false;
+    try {
+      await ${fn.name}(${paramsWithUndefined});
+    } catch (e) {
+      threw = true;
+      expect(e).toBeInstanceOf(Error);
+    }` : `let threw = false;
+    try {
+      ${fn.name}(${paramsWithUndefined});
+    } catch (e) {
+      threw = true;
+      expect(e).toBeInstanceOf(Error);
+    }`,
+            assertion: `expect(true).toBe(true); // function either handles undefined or throws TypeError`
+          });
+        }
       }
       testCases.push(...this.generateBoundaryTestCases(fn, param));
     }
@@ -38716,32 +38757,48 @@ var BaseTestGenerator = class _BaseTestGenerator {
   generateBoundaryTestCases(fn, param) {
     const testCases = [];
     const type = param.type?.toLowerCase() || "";
+    const wrapBoundaryAction = (call, isAsync) => {
+      if (isAsync) {
+        return `try {
+      const result = await ${call};
+      expect(result).toBeDefined();
+    } catch (e) {
+      expect(e).toBeInstanceOf(Error);
+    }`;
+      }
+      return `try {
+      const result = ${call};
+      expect(result).toBeDefined();
+    } catch (e) {
+      expect(e).toBeInstanceOf(Error);
+    }`;
+    };
     if (type.includes("string")) {
       const paramsWithEmpty = fn.parameters.map((p74) => p74.name === param.name ? "''" : this.generateTestValue(p74)).join(", ");
-      const emptyCall = fn.isAsync ? `await ${fn.name}(${paramsWithEmpty})` : `${fn.name}(${paramsWithEmpty})`;
+      const emptyCall = `${fn.name}(${paramsWithEmpty})`;
       testCases.push({
         description: `should handle empty string for ${param.name}`,
         type: "boundary",
-        action: `const result = ${emptyCall};`,
-        assertion: "expect(result).toBeDefined();"
+        action: wrapBoundaryAction(emptyCall, fn.isAsync),
+        assertion: ""
       });
     }
     if (type.includes("number")) {
       const paramsWithZero = fn.parameters.map((p74) => p74.name === param.name ? "0" : this.generateTestValue(p74)).join(", ");
-      const zeroCall = fn.isAsync ? `await ${fn.name}(${paramsWithZero})` : `${fn.name}(${paramsWithZero})`;
+      const zeroCall = `${fn.name}(${paramsWithZero})`;
       testCases.push({
         description: `should handle zero for ${param.name}`,
         type: "boundary",
-        action: `const result = ${zeroCall};`,
-        assertion: "expect(result).toBeDefined();"
+        action: wrapBoundaryAction(zeroCall, fn.isAsync),
+        assertion: ""
       });
       const paramsWithNegative = fn.parameters.map((p74) => p74.name === param.name ? "-1" : this.generateTestValue(p74)).join(", ");
-      const negativeCall = fn.isAsync ? `await ${fn.name}(${paramsWithNegative})` : `${fn.name}(${paramsWithNegative})`;
+      const negativeCall = `${fn.name}(${paramsWithNegative})`;
       testCases.push({
         description: `should handle negative value for ${param.name}`,
         type: "edge-case",
-        action: `const result = ${negativeCall};`,
-        assertion: "expect(result).toBeDefined();"
+        action: wrapBoundaryAction(negativeCall, fn.isAsync),
+        assertion: ""
       });
     }
     if (type.includes("[]") || type.includes("array")) {
@@ -38839,24 +38896,31 @@ ${importStatement}
 `;
     if (dependencies && dependencies.imports.length > 0) {
       const mockFn = this.framework === "vitest" ? "vi.fn()" : "jest.fn()";
-      testCode += `
+      const externalDeps = dependencies.imports.filter((dep) => !dep.startsWith("."));
+      if (externalDeps.length > 0) {
+        testCode += `
 // Auto-generated mocks from Knowledge Graph dependency analysis
 `;
-      for (const dep of dependencies.imports.slice(0, 10)) {
-        const depName = dep.split("/").pop()?.replace(/[^a-zA-Z0-9_]/g, "_") || dep;
-        testCode += `${this.framework === "vitest" ? "vi" : "jest"}.mock('${dep}', () => ({ default: ${mockFn} }));
+        for (const dep of externalDeps.slice(0, 10)) {
+          testCode += `${this.framework === "vitest" ? "vi" : "jest"}.mock('${dep}', () => ({ default: ${mockFn} }));
 `;
-      }
-      testCode += `
+        }
+        testCode += `
 `;
+      } else {
+        testCode += `
+`;
+      }
     } else {
       testCode += `
 `;
     }
-    for (const fn of analysis.functions) {
+    const exportedFns = analysis.functions.filter((fn) => fn.isExported);
+    const exportedClasses = analysis.classes.filter((cls) => cls.isExported);
+    for (const fn of exportedFns) {
       testCode += this.generateFunctionTests(fn, testType);
     }
-    for (const cls of analysis.classes) {
+    for (const cls of exportedClasses) {
       testCode += this.generateClassTests(cls, testType);
     }
     return testCode;
@@ -38943,24 +39007,68 @@ ${importStatement}
     const validParams = method.parameters.map((p74) => this.generateTestValue(p74)).join(", ");
     const methodCall = method.isAsync ? `await instance.${method.name}(${validParams})` : `instance.${method.name}(${validParams})`;
     const asyncPrefix = method.isAsync ? "async " : "";
+    const isVoid = method.returnType === "void" || method.returnType === "Promise<void>";
+    let methodAssertion = "expect(result).toBeDefined();";
+    if (!isVoid) {
+      if (/^(is|has|can)[A-Z]/.test(method.name)) {
+        methodAssertion = "expect(typeof result).toBe('boolean');";
+      } else if (/^(get|fetch|find)[A-Z]/.test(method.name)) {
+        methodAssertion = "expect(result).not.toBeUndefined();";
+      } else if (/^(create|build|make)[A-Z]/.test(method.name)) {
+        methodAssertion = "expect(result).toBeTruthy();";
+      } else if (method.returnType) {
+        const mrt = method.returnType.toLowerCase().replace(/promise<(.+)>/, "$1");
+        if (mrt.includes("boolean")) methodAssertion = "expect(typeof result).toBe('boolean');";
+        else if (mrt.includes("number")) methodAssertion = "expect(typeof result).toBe('number');";
+        else if (mrt.includes("string")) methodAssertion = "expect(typeof result).toBe('string');";
+        else if (mrt.includes("[]") || mrt.includes("array")) methodAssertion = "expect(Array.isArray(result)).toBe(true);";
+      }
+    }
     code += `    it('should execute successfully', ${asyncPrefix}() => {
 `;
-    code += `      const result = ${methodCall};
+    if (isVoid) {
+      code += `      ${methodCall};
+`;
+      code += `      // void return \u2014 no assertion on result needed
+`;
+    } else {
+      code += `      const result = ${methodCall};
 `;
-    code += `      expect(result).toBeDefined();
+      code += `      ${methodAssertion}
 `;
+    }
     code += `    });
 `;
+    const methodBody = method.body || "";
+    const methodThrows = /\bthrow\b/.test(methodBody) || /\bvalidat/i.test(methodBody);
     for (const param of method.parameters) {
       if (!param.optional) {
         const paramsWithUndefined = method.parameters.map((p74) => p74.name === param.name ? "undefined as any" : this.generateTestValue(p74)).join(", ");
-        code += `
-    it('should handle invalid ${param.name}', () => {
+        if (methodThrows) {
+          code += `
+    it('should handle invalid ${param.name}', ${asyncPrefix}() => {
 `;
-        code += `      expect(() => instance.${method.name}(${paramsWithUndefined})).toThrow();
+          code += `      expect(() => instance.${method.name}(${paramsWithUndefined})).toThrow();
 `;
-        code += `    });
+          code += `    });
+`;
+        } else {
+          code += `
+    it('should handle undefined ${param.name}', ${asyncPrefix}() => {
+`;
+          code += `      try {
+`;
+          code += `        ${method.isAsync ? "await " : ""}instance.${method.name}(${paramsWithUndefined});
+`;
+          code += `      } catch (e) {
 `;
+          code += `        expect(e).toBeInstanceOf(Error);
+`;
+          code += `      }
+`;
+          code += `    });
+`;
+        }
       }
     }
     code += `  });
@@ -38980,12 +39088,15 @@ ${importStatement}
     let mockDeclarations = "";
     if (dependencies && dependencies.imports.length > 0) {
       const mockFn = this.framework === "vitest" ? "vi.fn()" : "jest.fn()";
-      mockDeclarations += `
+      const externalDeps = dependencies.imports.filter((dep) => !dep.startsWith("."));
+      if (externalDeps.length > 0) {
+        mockDeclarations += `
 // Auto-generated mocks from Knowledge Graph dependency analysis
 `;
-      for (const dep of dependencies.imports.slice(0, 10)) {
-        mockDeclarations += `${this.mockUtil}.mock('${dep}', () => ({ default: ${mockFn} }));
+        for (const dep of externalDeps.slice(0, 10)) {
+          mockDeclarations += `${this.mockUtil}.mock('${dep}', () => ({ default: ${mockFn} }));
 `;
+        }
       }
     }
     let similarityComment = "";
@@ -39262,10 +39373,11 @@ var MochaGenerator = class extends BaseTestGenerator {
     const importStatement = this.generateImportStatement(exports, importPath, moduleName);
     let sinonImport = "";
     let stubSetup = "";
-    if (dependencies && dependencies.imports.length > 0) {
+    const externalDeps = dependencies?.imports.filter((dep) => !dep.startsWith(".")) || [];
+    if (externalDeps.length > 0) {
       sinonImport = `import sinon from 'sinon';
 `;
-      const depsToMock = dependencies.imports.slice(0, 5);
+      const depsToMock = externalDeps.slice(0, 5);
       stubSetup += `  // Auto-generated stubs from Knowledge Graph dependency analysis
 `;
       stubSetup += `  let stubs;
@@ -39298,10 +39410,12 @@ ${sinonImport}${importStatement}
 
 describe('${moduleName} - ${testType} tests', function() {
 ${stubSetup}`;
-    for (const fn of analysis.functions) {
+    const exportedFns = analysis.functions.filter((fn) => fn.isExported);
+    const exportedClasses = analysis.classes.filter((cls) => cls.isExported);
+    for (const fn of exportedFns) {
       code += this.generateFunctionTests(fn, testType);
     }
-    for (const cls of analysis.classes) {
+    for (const cls of exportedClasses) {
       code += this.generateClassTests(cls, testType);
     }
     code += `});
@@ -39314,26 +39428,68 @@ ${stubSetup}`;
   generateFunctionTests(fn, _testType) {
     const validParams = fn.parameters.map((p74) => this.generateTestValue(p74)).join(", ");
     const fnCall = fn.isAsync ? `await ${fn.name}(${validParams})` : `${fn.name}(${validParams})`;
+    const isVoid = fn.returnType === "void" || fn.returnType === "Promise<void>";
     let code = `  describe('${fn.name}', function() {
 `;
+    let chaiAssertion = "expect(result).to.not.be.undefined;";
+    if (!isVoid) {
+      if (/^(is|has|can)[A-Z]/.test(fn.name)) {
+        chaiAssertion = "expect(typeof result).to.equal('boolean');";
+      } else if (/^(get|fetch|find)[A-Z]/.test(fn.name)) {
+        chaiAssertion = "expect(result).to.not.be.undefined;";
+      } else if (/^(create|build|make)[A-Z]/.test(fn.name)) {
+        chaiAssertion = "expect(result).to.be.ok;";
+      } else if (fn.returnType) {
+        const rt3 = fn.returnType.toLowerCase().replace(/promise<(.+)>/, "$1");
+        if (rt3.includes("boolean")) chaiAssertion = "expect(typeof result).to.equal('boolean');";
+        else if (rt3.includes("number")) chaiAssertion = "expect(typeof result).to.equal('number');";
+        else if (rt3.includes("string")) chaiAssertion = "expect(typeof result).to.equal('string');";
+        else if (rt3.includes("[]") || rt3.includes("array")) chaiAssertion = "expect(result).to.be.an('array');";
+      }
+    }
     code += `    it('should handle valid input', ${fn.isAsync ? "async " : ""}function() {
 `;
-    code += `      const result = ${fnCall};
+    if (isVoid) {
+      code += `      ${fnCall};
+`;
+    } else {
+      code += `      const result = ${fnCall};
 `;
-    code += `      expect(result).to.not.be.undefined;
+      code += `      ${chaiAssertion}
 `;
+    }
     code += `    });
 `;
+    const bodyText = fn.body || "";
+    const hasExplicitThrow = /\bthrow\b/.test(bodyText) || /\bvalidat/i.test(bodyText);
     for (const param of fn.parameters) {
       if (!param.optional) {
         const paramsWithUndefined = fn.parameters.map((p74) => p74.name === param.name ? "undefined" : this.generateTestValue(p74)).join(", ");
-        code += `
+        if (hasExplicitThrow) {
+          code += `
     it('should handle undefined ${param.name}', function() {
 `;
-        code += `      expect(function() { ${fn.name}(${paramsWithUndefined}); }).to.throw();
+          code += `      expect(function() { ${fn.name}(${paramsWithUndefined}); }).to.throw();
 `;
-        code += `    });
+          code += `    });
+`;
+        } else {
+          code += `
+    it('should handle undefined ${param.name}', function() {
+`;
+          code += `      try {
+`;
+          code += `        ${fn.name}(${paramsWithUndefined});
+`;
+          code += `      } catch (e) {
+`;
+          code += `        expect(e).to.be.instanceOf(Error);
+`;
+          code += `      }
+`;
+          code += `    });
 `;
+        }
       }
     }
     code += `  });
@@ -39365,15 +39521,35 @@ ${stubSetup}`;
     code += `    });
 `;
     for (const method of cls.methods) {
-      if (!method.name.startsWith("_")) {
+      if (!method.name.startsWith("_") && !method.name.startsWith("#")) {
         const methodParams = method.parameters.map((p74) => this.generateTestValue(p74)).join(", ");
+        const isMethodVoid = method.returnType === "void" || method.returnType === "Promise<void>";
+        let methodAssertion = "expect(result).to.not.be.undefined;";
+        if (!isMethodVoid) {
+          if (/^(is|has|can)[A-Z]/.test(method.name)) {
+            methodAssertion = "expect(typeof result).to.equal('boolean');";
+          } else if (/^(create|build|make)[A-Z]/.test(method.name)) {
+            methodAssertion = "expect(result).to.be.ok;";
+          } else if (method.returnType) {
+            const mrt = method.returnType.toLowerCase().replace(/promise<(.+)>/, "$1");
+            if (mrt.includes("boolean")) methodAssertion = "expect(typeof result).to.equal('boolean');";
+            else if (mrt.includes("number")) methodAssertion = "expect(typeof result).to.equal('number');";
+            else if (mrt.includes("string")) methodAssertion = "expect(typeof result).to.equal('string');";
+            else if (mrt.includes("[]") || mrt.includes("array")) methodAssertion = "expect(result).to.be.an('array');";
+          }
+        }
         code += `
     it('${method.name} should work', ${method.isAsync ? "async " : ""}function() {
 `;
-        code += `      const result = ${method.isAsync ? "await " : ""}instance.${method.name}(${methodParams});
+        if (isMethodVoid) {
+          code += `      ${method.isAsync ? "await " : ""}instance.${method.name}(${methodParams});
 `;
-        code += `      expect(result).to.not.be.undefined;
+        } else {
+          code += `      const result = ${method.isAsync ? "await " : ""}instance.${method.name}(${methodParams});
+`;
+          code += `      ${methodAssertion}
 `;
+        }
         code += `    });
 `;
       }
@@ -39396,10 +39572,11 @@ ${stubSetup}`;
     let sinonImport = "";
     let stubSetup = "";
     let stubTeardown = "";
-    if (dependencies && dependencies.imports.length > 0) {
+    const stubExternalDeps = dependencies?.imports.filter((dep) => !dep.startsWith(".")) || [];
+    if (stubExternalDeps.length > 0) {
       sinonImport = `import sinon from 'sinon';
 `;
-      const depsToMock = dependencies.imports.slice(0, 5);
+      const depsToMock = stubExternalDeps.slice(0, 5);
       stubSetup += `
     // Auto-generated stubs from Knowledge Graph dependency analysis
 `;
@@ -39570,12 +39747,13 @@ var PytestGenerator = class extends BaseTestGenerator {
     const exports = this.extractExports(analysis.functions, analysis.classes);
     const pythonImport = importPath.replace(/\//g, ".").replace(/\.(ts|js)$/, "");
     const importStatement = exports.length > 0 ? `from ${pythonImport} import ${exports.join(", ")}` : `import ${pythonImport} as ${moduleName}`;
+    const externalDeps = dependencies?.imports.filter((dep) => !dep.startsWith(".")) || [];
     let mockImport = "";
-    if (dependencies && dependencies.imports.length > 0) {
+    if (externalDeps.length > 0) {
       mockImport = `from unittest.mock import patch, MagicMock
 `;
     }
-    const depsToMock = dependencies?.imports.slice(0, 5) || [];
+    const depsToMock = externalDeps.slice(0, 5);
     const patchDecorators = depsToMock.map((dep) => {
       const depModule = dep.replace(/\//g, ".").replace(/\.py$/, "");
       return `@patch('${depModule}')`;
@@ -39588,10 +39766,12 @@ class Test${this.pascalCase(moduleName)}:
     """${testType} tests for ${moduleName}"""
 
 `;
-    for (const fn of analysis.functions) {
+    const exportedFns = analysis.functions.filter((fn) => fn.isExported);
+    const exportedClasses = analysis.classes.filter((cls) => cls.isExported);
+    for (const fn of exportedFns) {
       code += this.generateFunctionTestsWithPatches(fn, testType, patchDecorators);
     }
-    for (const cls of analysis.classes) {
+    for (const cls of exportedClasses) {
       code += this.generateClassTests(cls, testType);
     }
     return code;
@@ -39611,15 +39791,36 @@ class Test${this.pascalCase(moduleName)}:
     const allParams = mockParams ? `self, ${mockParams}` : "self";
     const patchPrefix = patchDecorators.map((d74) => `    ${d74}
 `).join("");
+    const isVoid = fn.returnType === "void" || fn.returnType === "Promise<void>" || fn.returnType === "None";
     let code = `${patchPrefix}    def test_${fn.name}_valid_input(${allParams}):
 `;
     code += `        """Test ${fn.name} with valid input"""
 `;
-    code += `        result = ${fn.name}(${validParams})
+    let pyAssertion = "assert result is not None";
+    if (!isVoid) {
+      if (/^(is|has|can)[A-Z]/.test(fn.name)) {
+        pyAssertion = "assert isinstance(result, bool)";
+      } else if (/^(create|build|make)[A-Z]/.test(fn.name)) {
+        pyAssertion = "assert result";
+      } else if (fn.returnType) {
+        const rt3 = fn.returnType.toLowerCase().replace(/promise<(.+)>/, "$1");
+        if (rt3.includes("boolean") || rt3.includes("bool")) pyAssertion = "assert isinstance(result, bool)";
+        else if (rt3.includes("number") || rt3.includes("int") || rt3.includes("float")) pyAssertion = "assert isinstance(result, (int, float))";
+        else if (rt3.includes("string") || rt3.includes("str")) pyAssertion = "assert isinstance(result, str)";
+        else if (rt3.includes("[]") || rt3.includes("array") || rt3.includes("list")) pyAssertion = "assert isinstance(result, list)";
+      }
+    }
+    if (isVoid) {
+      code += `        ${fn.name}(${validParams})  # void function
+
+`;
+    } else {
+      code += `        result = ${fn.name}(${validParams})
 `;
-    code += `        assert result is not None
+      code += `        ${pyAssertion}
 
 `;
+    }
     for (const param of fn.parameters) {
       if (!param.optional && param.type?.includes("str")) {
         code += `${patchPrefix}    def test_${fn.name}_empty_${param.name}(${allParams}):
@@ -39660,15 +39861,36 @@ class Test${cls.name}:
 
 `;
     for (const method of cls.methods) {
-      if (!method.name.startsWith("_")) {
+      if (!method.name.startsWith("_") && !method.name.startsWith("#")) {
         const methodParams = method.parameters.map((p74) => this.generatePythonTestValue(p74)).join(", ");
+        const isMethodVoid = method.returnType === "void" || method.returnType === "Promise<void>";
+        let mAssertion = "assert result is not None";
+        if (!isMethodVoid) {
+          if (/^(is|has|can)[A-Z]/.test(method.name)) {
+            mAssertion = "assert isinstance(result, bool)";
+          } else if (/^(create|build|make)[A-Z]/.test(method.name)) {
+            mAssertion = "assert result";
+          } else if (method.returnType) {
+            const mrt = method.returnType.toLowerCase().replace(/promise<(.+)>/, "$1");
+            if (mrt.includes("boolean") || mrt.includes("bool")) mAssertion = "assert isinstance(result, bool)";
+            else if (mrt.includes("number") || mrt.includes("int") || mrt.includes("float")) mAssertion = "assert isinstance(result, (int, float))";
+            else if (mrt.includes("string") || mrt.includes("str")) mAssertion = "assert isinstance(result, str)";
+            else if (mrt.includes("[]") || mrt.includes("array") || mrt.includes("list")) mAssertion = "assert isinstance(result, list)";
+          }
+        }
         code += `    def test_${method.name}(self, instance):
 `;
-        code += `        result = instance.${method.name}(${methodParams})
+        if (isMethodVoid) {
+          code += `        instance.${method.name}(${methodParams})
+
 `;
-        code += `        assert result is not None
+        } else {
+          code += `        result = instance.${method.name}(${methodParams})
+`;
+          code += `        ${mAssertion}
 
 `;
+        }
       }
     }
     return code;
@@ -39686,11 +39908,11 @@ class Test${cls.name}:
     const asyncDef = isAsync ? "async def" : "def";
     let mockImports = "";
     let mockPatches = "";
-    if (dependencies && dependencies.imports.length > 0) {
+    const stubExternalDeps = dependencies?.imports.filter((dep) => !dep.startsWith(".")) || [];
+    if (stubExternalDeps.length > 0) {
       mockImports = `from unittest.mock import patch, MagicMock
 `;
-      const depsToMock = dependencies.imports.slice(0, 5);
-      for (const dep of depsToMock) {
+      for (const dep of stubExternalDeps.slice(0, 5)) {
         const depModule = dep.replace(/\//g, ".").replace(/\.py$/, "");
         mockPatches += `    @patch('${depModule}')
 `;
@@ -39853,12 +40075,214 @@ class Test${this.pascalCase(moduleName)}Coverage:
   }
 };
 
+// src/domains/test-generation/generators/node-test-generator.ts
+var NodeTestGenerator = class extends BaseTestGenerator {
+  framework = "node-test";
+  /**
+   * Generate complete test file from analysis
+   */
+  generateTests(context) {
+    const { moduleName, importPath, testType, patterns, analysis } = context;
+    if (!analysis || analysis.functions.length === 0 && analysis.classes.length === 0) {
+      return this.generateStubTests(context);
+    }
+    const patternComment = this.generatePatternComment(patterns);
+    const exportedFunctions = analysis.functions.filter((fn) => fn.isExported);
+    const exportedClasses = analysis.classes.filter((cls) => cls.isExported);
+    const exports = this.extractExports(exportedFunctions, exportedClasses);
+    const importStatement = this.generateImportStatement(exports, importPath, moduleName);
+    let testCode = `${patternComment}import { describe, it, beforeEach } from 'node:test';
+import assert from 'node:assert';
+${importStatement}
+
+`;
+    for (const fn of exportedFunctions) {
+      testCode += this.generateFunctionTests(fn, testType);
+    }
+    for (const cls of exportedClasses) {
+      testCode += this.generateClassTests(cls, testType);
+    }
+    return testCode;
+  }
+  /**
+   * Generate tests for a standalone function
+   */
+  generateFunctionTests(fn, _testType) {
+    const testCases = this.generateTestCasesForFunction(fn);
+    let code = `describe('${fn.name}', () => {
+`;
+    for (const testCase of testCases) {
+      if (testCase.setup) {
+        code += `  ${testCase.setup}
+
+`;
+      }
+      const asyncPrefix = fn.isAsync ? "async " : "";
+      code += `  it('${testCase.description}', ${asyncPrefix}() => {
+`;
+      code += `    ${this.convertToAssert(testCase.action)}
+`;
+      code += `    ${this.convertToAssert(testCase.assertion)}
+`;
+      code += `  });
+
+`;
+    }
+    code += `});
+
+`;
+    return code;
+  }
+  /**
+   * Generate tests for a class
+   */
+  generateClassTests(cls, testType) {
+    let code = `describe('${cls.name}', () => {
+`;
+    code += `  let instance;
+
+`;
+    const constructorArgs = cls.constructorParams?.map((p74) => this.generateTestValue(p74)).join(", ") || "";
+    code += `  beforeEach(() => {
+`;
+    code += `    instance = new ${cls.name}(${constructorArgs});
+`;
+    code += `  });
+
+`;
+    code += `  it('should instantiate correctly', () => {
+`;
+    code += `    assert.ok(instance instanceof ${cls.name});
+`;
+    code += `  });
+
+`;
+    for (const method of cls.methods) {
+      if (!method.name.startsWith("_") && !method.name.startsWith("#")) {
+        code += this.generateMethodTest(method);
+      }
+    }
+    code += `});
+
+`;
+    return code;
+  }
+  /**
+   * Generate test for a class method
+   */
+  generateMethodTest(method) {
+    const validParams = method.parameters.map((p74) => this.generateTestValue(p74)).join(", ");
+    const isVoid = method.returnType === "void" || method.returnType === "Promise<void>";
+    const asyncPrefix = method.isAsync ? "async " : "";
+    const methodCall = method.isAsync ? `await instance.${method.name}(${validParams})` : `instance.${method.name}(${validParams})`;
+    let assertLine = "assert.ok(result !== undefined);";
+    if (!isVoid) {
+      const mLower = method.name.toLowerCase();
+      if (/^(is|has|can)[A-Z]/.test(method.name)) {
+        assertLine = "assert.strictEqual(typeof result, 'boolean');";
+      } else if (/^(get|fetch|find)[A-Z]/.test(method.name)) {
+        assertLine = "assert.ok(result !== undefined);";
+      } else if (/^(create|build|make)[A-Z]/.test(method.name)) {
+        assertLine = "assert.ok(result);";
+      } else if (method.returnType) {
+        const rt3 = method.returnType.toLowerCase().replace(/promise<(.+)>/, "$1");
+        if (rt3.includes("boolean")) assertLine = "assert.strictEqual(typeof result, 'boolean');";
+        else if (rt3.includes("number")) assertLine = "assert.strictEqual(typeof result, 'number');";
+        else if (rt3.includes("string")) assertLine = "assert.strictEqual(typeof result, 'string');";
+        else if (rt3.includes("[]") || rt3.includes("array")) assertLine = "assert.ok(Array.isArray(result));";
+      }
+    }
+    let code = `  it('${method.name} should execute successfully', ${asyncPrefix}() => {
+`;
+    if (isVoid) {
+      code += `    ${methodCall};
+`;
+    } else {
+      code += `    const result = ${methodCall};
+`;
+      code += `    ${assertLine}
+`;
+    }
+    code += `  });
+
+`;
+    return code;
+  }
+  /**
+   * Generate stub tests when no AST analysis is available
+   */
+  generateStubTests(context) {
+    const { moduleName, importPath, testType, patterns } = context;
+    const patternComment = this.generatePatternComment(patterns);
+    return `${patternComment}import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { ${moduleName} } from '${importPath}';
+
+describe('${moduleName}', () => {
+  describe('${testType} tests', () => {
+    it('should be defined', () => {
+      assert.ok(${moduleName} !== undefined);
+    });
+
+    it('should handle basic operations', () => {
+      const moduleType = typeof ${moduleName};
+      assert.ok(['function', 'object'].includes(moduleType));
+    });
+
+    it('should handle error conditions', () => {
+      assert.doesNotThrow(() => {
+        const instance = typeof ${moduleName} === 'function'
+          ? new ${moduleName}()
+          : ${moduleName};
+        return instance;
+      });
+    });
+  });
+});
+`;
+  }
+  /**
+   * Generate coverage-focused tests for specific lines
+   */
+  generateCoverageTests(moduleName, importPath, lines) {
+    const funcName = this.camelCase(moduleName);
+    const lineRange = this.formatLineRange(lines);
+    return `// Coverage test for ${lineRange} in ${moduleName}
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { ${funcName} } from '${importPath}';
+
+describe('${moduleName} coverage', () => {
+  it('should exercise code path covering ${lineRange}', () => {
+    const testInput = undefined; // Replace with appropriate input
+    const result = ${funcName}(testInput);
+    assert.ok(result !== undefined || result === undefined);
+  });
+
+  it('should handle edge case for ${lineRange}', () => {
+    assert.doesNotThrow(() => ${funcName}(null));
+  });
+});
+`;
+  }
+  // ============================================================================
+  // Helpers
+  // ============================================================================
+  /**
+   * Convert expect() style assertions to node:assert
+   */
+  convertToAssert(assertion) {
+    return assertion.replace(/expect\(typeof ([^)]+)\)\.toBe\('([^']+)'\);?/g, "assert.strictEqual(typeof $1, '$2');").replace(/expect\(Array\.isArray\(([^)]+)\)\)\.toBe\(true\);?/g, "assert.ok(Array.isArray($1));").replace(/expect\(([^)]+)\)\.toThrow\(\);?/g, "assert.throws($1);").replace(/expect\(([^)]+)\)\.not\.toThrow\(\);?/g, "assert.doesNotThrow($1);").replace(/expect\(([^)]+)\)\.toBeInstanceOf\(([^)]+)\);?/g, "assert.ok($1 instanceof $2);").replace(/expect\(([^)]+)\)\.toBeDefined\(\);?/g, "assert.ok($1 !== undefined);").replace(/expect\(([^)]+)\)\.not\.toBeUndefined\(\);?/g, "assert.ok($1 !== undefined);").replace(/expect\(([^)]+)\)\.toBeUndefined\(\);?/g, "assert.strictEqual($1, undefined);").replace(/expect\(([^)]+)\)\.toBeTruthy\(\);?/g, "assert.ok($1);").replace(/expect\(([^)]+)\)\.toBeFalsy\(\);?/g, "assert.ok(!$1);").replace(/expect\(([^)]+)\)\.toBe\(([^)]+)\);?/g, "assert.strictEqual($1, $2);").replace(/expect\(([^)]+)\)\.toEqual\(([^)]+)\);?/g, "assert.deepStrictEqual($1, $2);");
+  }
+};
+
 // src/domains/test-generation/factories/test-generator-factory.ts
 var SUPPORTED_FRAMEWORKS = [
   "jest",
   "vitest",
   "mocha",
-  "pytest"
+  "pytest",
+  "node-test"
 ];
 var DEFAULT_FRAMEWORK = "vitest";
 var TestGeneratorFactory = class {
@@ -39920,6 +40344,8 @@ var TestGeneratorFactory = class {
         return new MochaGenerator();
       case "pytest":
         return new PytestGenerator();
+      case "node-test":
+        return new NodeTestGenerator();
       default:
         throw new Error(`Unsupported test framework: ${framework}`);
     }
@@ -41267,12 +41693,32 @@ ${sourceCode}
     };
   }
   extractParameters(params, sourceFile) {
-    return params.map((param) => ({
-      name: param.name.getText(sourceFile),
-      type: param.type?.getText(sourceFile),
-      optional: param.questionToken !== void 0,
-      defaultValue: param.initializer?.getText(sourceFile)
-    }));
+    let objectDestructureCount = 0;
+    let arrayDestructureCount = 0;
+    return params.map((param) => {
+      let name = param.name.getText(sourceFile);
+      let type = param.type?.getText(sourceFile);
+      if (ts.isObjectBindingPattern(param.name)) {
+        objectDestructureCount++;
+        name = objectDestructureCount > 1 ? `options${objectDestructureCount}` : "options";
+        if (!type) {
+          const props = param.name.elements.map((el) => `${el.name.getText(sourceFile)}: unknown`).join(", ");
+          type = `{ ${props} }`;
+        }
+      } else if (ts.isArrayBindingPattern(param.name)) {
+        arrayDestructureCount++;
+        name = arrayDestructureCount > 1 ? `items${arrayDestructureCount}` : "items";
+        if (!type) {
+          type = "unknown[]";
+        }
+      }
+      return {
+        name,
+        type,
+        optional: param.questionToken !== void 0,
+        defaultValue: param.initializer?.getText(sourceFile)
+      };
+    });
   }
   calculateComplexity(node) {
     let complexity = 1;
@@ -41331,12 +41777,18 @@ ${sourceCode}
       const callees = [];
       const callers = [];
       const tsImports = sourceContent.matchAll(/(?:import|from)\s+['"]([^'"]+)['"]/g);
-      const pyImports = sourceContent.matchAll(/(?:^|\n)\s*(?:from\s+(\S+)\s+import|import\s+(\S+))/g);
       for (const match of tsImports) {
         imports.push(match[1]);
       }
-      for (const match of pyImports) {
-        imports.push(match[1] || match[2]);
+      const isPython = filePath.endsWith(".py");
+      if (isPython) {
+        const pyImports = sourceContent.matchAll(/(?:^|\n)\s*(?:from\s+(\S+)\s+import|import\s+(\S+))/g);
+        for (const match of pyImports) {
+          const mod = match[1] || match[2];
+          if (mod && /^[a-zA-Z_][\w.]*$/.test(mod)) {
+            imports.push(mod);
+          }
+        }
       }
       const normalizedPath = filePath.replace(/\\/g, "/");
       const baseName = normalizedPath.split("/").pop()?.replace(/\.(ts|js|tsx|jsx|py)$/, "") || "";
@@ -42365,7 +42817,7 @@ var PatternMatcherService = class _PatternMatcherService {
         return template.replace("{{name}}", param.name);
       }
     }
-    return `mock${param.name.charAt(0).toUpperCase() + param.name.slice(1)}`;
+    return `{} /* TODO: provide ${param.name}: ${param.type || "unknown"} */`;
   }
   /**
    * Estimate number of branches from cyclomatic complexity
@@ -43281,12 +43733,32 @@ var TypeScriptASTParser = class {
    * Extract parameter information
    */
   extractParameters(params, sourceFile) {
-    return params.map((param) => ({
-      name: param.name.getText(sourceFile),
-      type: param.type?.getText(sourceFile),
-      optional: param.questionToken !== void 0,
-      defaultValue: param.initializer?.getText(sourceFile)
-    }));
+    let objectDestructureCount = 0;
+    let arrayDestructureCount = 0;
+    return params.map((param) => {
+      let name = param.name.getText(sourceFile);
+      let type = param.type?.getText(sourceFile);
+      if (ts2.isObjectBindingPattern(param.name)) {
+        objectDestructureCount++;
+        name = objectDestructureCount > 1 ? `options${objectDestructureCount}` : "options";
+        if (!type) {
+          const props = param.name.elements.map((el) => `${el.name.getText(sourceFile)}: unknown`).join(", ");
+          type = `{ ${props} }`;
+        }
+      } else if (ts2.isArrayBindingPattern(param.name)) {
+        arrayDestructureCount++;
+        name = arrayDestructureCount > 1 ? `items${arrayDestructureCount}` : "items";
+        if (!type) {
+          type = "unknown[]";
+        }
+      }
+      return {
+        name,
+        type,
+        optional: param.questionToken !== void 0,
+        defaultValue: param.initializer?.getText(sourceFile)
+      };
+    });
   }
   /**
    * Calculate cyclomatic complexity of a node