universal-ast-mapper 2.0.0 → 2.0.2

package/dist/smells.js

@@ -0,0 +1,285 @@
+// ─── Parameter counting ───────────────────────────────────────────────────────
+/**
+ * Count the number of parameters in a signature string by finding the first
+ * `(...)` group and splitting by comma. Handles `...rest` as 1 param.
+ * Returns -1 when no parameter list can be found.
+ */
+function countParams(signature) {
+    if (!signature)
+        return -1;
+    // Find the first balanced parenthesis group
+    const start = signature.indexOf("(");
+    if (start === -1)
+        return -1;
+    let depth = 0;
+    let end = -1;
+    for (let i = start; i < signature.length; i++) {
+        if (signature[i] === "(")
+            depth++;
+        else if (signature[i] === ")") {
+            depth--;
+            if (depth === 0) {
+                end = i;
+                break;
+            }
+        }
+    }
+    if (end === -1)
+        return -1;
+    const inner = signature.slice(start + 1, end).trim();
+    if (inner === "")
+        return 0;
+    // Split by top-level commas only (ignore generics / nested parens)
+    const parts = [];
+    let buf = "";
+    let nested = 0;
+    for (const ch of inner) {
+        if (ch === "(" || ch === "<" || ch === "[" || ch === "{") {
+            nested++;
+            buf += ch;
+        }
+        else if (ch === ")" || ch === ">" || ch === "]" || ch === "}") {
+            nested--;
+            buf += ch;
+        }
+        else if (ch === "," && nested === 0) {
+            parts.push(buf.trim());
+            buf = "";
+        }
+        else {
+            buf += ch;
+        }
+    }
+    if (buf.trim())
+        parts.push(buf.trim());
+    // Filter out empty strings and `this` parameters
+    const filtered = parts.filter((p) => p.length > 0 && p !== "this" && !p.startsWith("this:"));
+    return filtered.length;
+}
+/**
+ * Determine whether a signature's parameter list consists exclusively of
+ * primitive types (string, number, boolean). Returns true only when there are
+ * more than 3 params AND every param type annotation is a primitive (or a
+ * union of primitives).
+ */
+function isPrimitiveObsession(signature, paramCount) {
+    if (!signature || paramCount <= 3)
+        return false;
+    const start = signature.indexOf("(");
+    if (start === -1)
+        return false;
+    let depth = 0;
+    let end = -1;
+    for (let i = start; i < signature.length; i++) {
+        if (signature[i] === "(")
+            depth++;
+        else if (signature[i] === ")") {
+            depth--;
+            if (depth === 0) {
+                end = i;
+                break;
+            }
+        }
+    }
+    if (end === -1)
+        return false;
+    const inner = signature.slice(start + 1, end).trim();
+    if (!inner)
+        return false;
+    // Remove `this` param
+    const withoutThis = inner.replace(/^this\s*:[^,]+,?\s*/, "");
+    // Strip parameter names — keep only the type annotation portion
+    // Handles: `name: type`, `name?: type`, `...rest: type`
+    // We check the extracted type annotations against known primitives
+    const PRIMITIVE_RE = /^(string|number|boolean)(\s*\|\s*(string|number|boolean))*(\[\])?(\s*\|\s*null|\s*\|\s*undefined)*$/;
+    // Extract type annotations: split by top-level comma, then grab the part after `:`
+    const parts = [];
+    let buf = "";
+    let nested2 = 0;
+    for (const ch of withoutThis) {
+        if (ch === "(" || ch === "<" || ch === "[" || ch === "{") {
+            nested2++;
+            buf += ch;
+        }
+        else if (ch === ")" || ch === ">" || ch === "]" || ch === "}") {
+            nested2--;
+            buf += ch;
+        }
+        else if (ch === "," && nested2 === 0) {
+            parts.push(buf.trim());
+            buf = "";
+        }
+        else {
+            buf += ch;
+        }
+    }
+    if (buf.trim())
+        parts.push(buf.trim());
+    const meaningful = parts.filter((p) => p.length > 0 && p !== "this" && !p.startsWith("this:"));
+    if (meaningful.length === 0)
+        return false;
+    for (const param of meaningful) {
+        // Strip leading `...` for rest params
+        const stripped = param.replace(/^\.\.\./, "");
+        // Get the type annotation after `:`
+        const colonIdx = stripped.indexOf(":");
+        if (colonIdx === -1) {
+            // No explicit type — treat as unknown (non-primitive)
+            return false;
+        }
+        const typeAnnotation = stripped.slice(colonIdx + 1).trim().replace(/\s*=\s*.*$/, ""); // remove default value
+        if (!PRIMITIVE_RE.test(typeAnnotation))
+            return false;
+    }
+    return true;
+}
+// ─── Individual smell detectors ───────────────────────────────────────────────
+function checkGodClass(sym, file, maxMethods, maxFields) {
+    if (sym.kind !== "class")
+        return null;
+    const publicMethods = sym.children.filter((c) => (c.kind === "method" || c.kind === "function") && c.visibility === "public");
+    const fields = sym.children.filter((c) => c.kind === "field");
+    if (publicMethods.length > maxMethods) {
+        return {
+            file,
+            smell: "god-class",
+            symbol: sym.name,
+            severity: "warning",
+            message: `Class "${sym.name}" has ${publicMethods.length} public methods (threshold: ${maxMethods})`,
+            line: sym.range.startLine,
+        };
+    }
+    if (fields.length > maxFields) {
+        return {
+            file,
+            smell: "god-class",
+            symbol: sym.name,
+            severity: "warning",
+            message: `Class "${sym.name}" has ${fields.length} fields (threshold: ${maxFields})`,
+            line: sym.range.startLine,
+        };
+    }
+    return null;
+}
+function checkLongMethod(sym, file, maxLines) {
+    if (sym.kind !== "function" && sym.kind !== "method")
+        return null;
+    const length = sym.range.endLine - sym.range.startLine;
+    if (length > maxLines) {
+        return {
+            file,
+            smell: "long-method",
+            symbol: sym.name,
+            severity: "warning",
+            message: `"${sym.name}" is ${length} lines long (threshold: ${maxLines})`,
+            line: sym.range.startLine,
+        };
+    }
+    return null;
+}
+function checkLongParamList(sym, file, maxParams) {
+    if (sym.kind !== "function" && sym.kind !== "method")
+        return null;
+    const count = countParams(sym.signature);
+    if (count > maxParams) {
+        return {
+            file,
+            smell: "long-param-list",
+            symbol: sym.name,
+            severity: "warning",
+            message: `"${sym.name}" has ${count} parameters (threshold: ${maxParams})`,
+            line: sym.range.startLine,
+        };
+    }
+    return null;
+}
+function checkPrimitiveObsession(sym, file) {
+    if (sym.kind !== "function" && sym.kind !== "method")
+        return null;
+    const count = countParams(sym.signature);
+    if (count > 3 && isPrimitiveObsession(sym.signature, count)) {
+        return {
+            file,
+            smell: "primitive-obsession",
+            symbol: sym.name,
+            severity: "info",
+            message: `"${sym.name}" has ${count} parameters all of primitive types — consider a parameter object`,
+            line: sym.range.startLine,
+        };
+    }
+    return null;
+}
+function checkShallowWrapper(sym, file) {
+    if (sym.kind !== "class")
+        return null;
+    const publicMethods = sym.children.filter((c) => (c.kind === "method" || c.kind === "function") && c.visibility === "public");
+    if (publicMethods.length !== 1)
+        return null;
+    const method = publicMethods[0];
+    const methodLines = method.range.endLine - method.range.startLine;
+    if (methodLines <= 5) {
+        return {
+            file,
+            smell: "shallow-wrapper",
+            symbol: sym.name,
+            severity: "info",
+            message: `Class "${sym.name}" has exactly 1 public method "${method.name}" (${methodLines} lines) — may be a thin wrapper`,
+            line: sym.range.startLine,
+        };
+    }
+    return null;
+}
+// ─── Walk helpers ─────────────────────────────────────────────────────────────
+/**
+ * Recursively walk top-level symbols and their children, collecting smells.
+ * `exported` is propagated from the parent class when checking methods.
+ */
+function walkSymbols(symbols, file, maxMethods, maxFields, maxMethodLines, maxParams, results, parentExported) {
+    for (const sym of symbols) {
+        const isExported = sym.exported ?? parentExported;
+        // Only check exported (or publicly accessible) symbols
+        if (isExported || parentExported) {
+            // class-level smells
+            const godClass = checkGodClass(sym, file, maxMethods, maxFields);
+            if (godClass)
+                results.push(godClass);
+            const shallowWrapper = checkShallowWrapper(sym, file);
+            if (shallowWrapper)
+                results.push(shallowWrapper);
+            // function/method smells
+            const longMethod = checkLongMethod(sym, file, maxMethodLines);
+            if (longMethod)
+                results.push(longMethod);
+            const longParam = checkLongParamList(sym, file, maxParams);
+            if (longParam)
+                results.push(longParam);
+            const primitiveObs = checkPrimitiveObsession(sym, file);
+            if (primitiveObs)
+                results.push(primitiveObs);
+        }
+        // Recurse into children (methods inside a class inherit the parent's exported status)
+        if (sym.children.length > 0) {
+            walkSymbols(sym.children, file, maxMethods, maxFields, maxMethodLines, maxParams, results, isExported);
+        }
+    }
+}
+// ─── Main entry ───────────────────────────────────────────────────────────────
+export function detectSmells(skel, sourceLineCount, opts) {
+    const maxMethods = opts?.maxMethods ?? 10;
+    const maxFields = opts?.maxFields ?? 8;
+    const maxMethodLines = opts?.maxMethodLines ?? 60;
+    const maxParams = opts?.maxParams ?? 4;
+    const results = [];
+    // ── large-file ────────────────────────────────────────────────────────────
+    if (sourceLineCount > 500) {
+        results.push({
+            file: skel.file,
+            smell: "large-file",
+            severity: "warning",
+            message: `File has ${sourceLineCount} lines (threshold: 500)`,
+        });
+    }
+    // ── symbol-level smells ───────────────────────────────────────────────────
+    walkSymbols(skel.symbols, skel.file, maxMethods, maxFields, maxMethodLines, maxParams, results, false);
+    return results;
+}

package/dist/sourcemap.js

@@ -0,0 +1,60 @@
+import fs from "node:fs";
+import path from "node:path";
+function decodeInline(url) {
+    const b64 = url.match(/base64,(.+)$/);
+    try {
+        if (b64)
+            return JSON.parse(Buffer.from(b64[1], "base64").toString("utf8"));
+        const comma = url.indexOf(",");
+        if (comma >= 0)
+            return JSON.parse(decodeURIComponent(url.slice(comma + 1)));
+    }
+    catch { /* malformed */ }
+    return null;
+}
+/**
+ * Read the source map for a compiled JS/CSS file: handles an inline
+ * `//# sourceMappingURL=data:...` comment or an external `.map` file, and
+ * returns the original source paths it maps back to.
+ */
+export function readSourceMap(absPath, relPath) {
+    let src;
+    try {
+        src = fs.readFileSync(absPath, "utf8");
+    }
+    catch {
+        return null;
+    }
+    const matches = [...src.matchAll(/[#@]\s*sourceMappingURL=([^\s'"]+)/g)];
+    if (matches.length === 0)
+        return null;
+    const url = matches[matches.length - 1][1];
+    let map = null;
+    let mapKind;
+    let mapFile;
+    if (url.startsWith("data:")) {
+        mapKind = "inline";
+        map = decodeInline(url);
+    }
+    else {
+        mapKind = "external";
+        mapFile = url;
+        try {
+            map = JSON.parse(fs.readFileSync(path.resolve(path.dirname(absPath), url), "utf8"));
+        }
+        catch {
+            map = null;
+        }
+    }
+    if (!map || !Array.isArray(map.sources))
+        return null;
+    const root = typeof map.sourceRoot === "string" ? map.sourceRoot.replace(/\/$/, "") : "";
+    const sources = map.sources.map((s) => root && !s.startsWith("/") ? root + "/" + s : s);
+    return {
+        file: relPath,
+        mapKind,
+        ...(mapFile ? { mapFile } : {}),
+        sources,
+        hasContent: Array.isArray(map.sourcesContent) && map.sourcesContent.length > 0,
+    };
+}

package/dist/testgen.js

@@ -0,0 +1,280 @@
+import fs from "node:fs";
+import path from "node:path";
+// ─── Framework detection ───────────────────────────────────────────────────────
+/** Infer the test framework from the nearest package.json. */
+export function detectTestFramework(root) {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (deps["vitest"])
+            return "vitest";
+        if (deps["jest"] || deps["@jest/core"] || deps["ts-jest"] || deps["babel-jest"])
+            return "jest";
+        if (deps["mocha"])
+            return "mocha";
+    }
+    catch { /* no package.json */ }
+    return "node";
+}
+/** Derive the conventional test file path for a source file. */
+export function resolveTestPath(sourceAbs, lang, outDir) {
+    const dir = outDir ?? path.dirname(sourceAbs);
+    const base = path.basename(sourceAbs);
+    const ext = path.extname(base);
+    const stem = base.slice(0, -ext.length);
+    if (lang === "python")
+        return path.join(dir, `test_${stem}.py`);
+    if (lang === "go")
+        return path.join(dir, `${stem}_test.go`);
+    if (lang === "java")
+        return path.join(dir, `${stem}Test.java`);
+    if (lang === "ruby")
+        return path.join(dir, `${stem}_spec.rb`);
+    return path.join(dir, `${stem}.test${ext}`);
+}
+// ─── Signature helpers ─────────────────────────────────────────────────────────
+/** Extract param names from a function signature, returned as comment hints. */
+function paramHints(sym) {
+    const s = sym.signature ?? "";
+    const m = s.match(/\(([^)]*)\)/);
+    if (!m || !m[1].trim())
+        return "";
+    return m[1]
+        .split(",")
+        .map((p) => {
+        const raw = p.trim()
+            .replace(/^\.\.\./, "")
+            .replace(/:.*$/, "")
+            .replace(/=.*$/, "")
+            .replace(/\?$/, "")
+            .trim();
+        return raw && raw !== "this" ? raw : null;
+    })
+        .filter(Boolean)
+        .map((n) => `/* ${n} */`)
+        .join(", ");
+}
+function isAsync(sym) {
+    return (sym.signature ?? "").includes("async ");
+}
+// ─── JavaScript / TypeScript ───────────────────────────────────────────────────
+function jsFrameworkHeader(fw) {
+    if (fw === "vitest")
+        return [`import { describe, it, expect, beforeEach, vi } from 'vitest';`];
+    if (fw === "jest")
+        return [`import { describe, it, expect, beforeEach, jest } from '@jest/globals';`];
+    if (fw === "mocha")
+        return [`import { describe, it } from 'mocha';`, `import { expect } from 'chai';`];
+    // node:test (default)
+    return [`import { describe, it } from 'node:test';`, `import assert from 'node:assert/strict';`];
+}
+function jsAssert(fw, expr, indent) {
+    if (fw === "node")
+        return `${indent}assert.ok(${expr}); // TODO: assert expected value`;
+    return `${indent}expect(${expr}).toBeDefined(); // TODO: assert expected value`;
+}
+function jsSymbolTests(sym, fw, isTs) {
+    const lines = [];
+    let count = 0;
+    if (sym.kind === "function") {
+        const hint = paramHints(sym);
+        const awaitKw = isAsync(sym) ? "await " : "";
+        const itKw = isAsync(sym) ? "it('should ...', async () => {" : "it('should ...', () => {";
+        count++;
+        lines.push(`describe('${sym.name}', () => {`, `  ${itKw}`, `    // TODO: arrange`, `    const result = ${awaitKw}${sym.name}(${hint});`, jsAssert(fw, "result", "    "), `  });`, `});`, "");
+    }
+    else if (sym.kind === "class") {
+        const publicMethods = sym.children.filter((c) => c.kind === "method" && c.visibility === "public" && c.name !== "constructor");
+        const typeAnno = isTs ? `: ${sym.name}` : "";
+        lines.push(`describe('${sym.name}', () => {`, `  let instance${typeAnno};`, "", `  beforeEach(() => {`, `    instance = new ${sym.name}(/* TODO: constructor args */);`, `  });`, "");
+        if (publicMethods.length === 0) {
+            count++;
+            lines.push(`  it('should be instantiable', () => {`, jsAssert(fw, "instance", "    "), `  });`);
+        }
+        else {
+            for (const m of publicMethods) {
+                const hint = paramHints(m);
+                const awaitKw = isAsync(m) ? "await " : "";
+                const itKw = isAsync(m) ? `it('${m.name}: should ...', async () => {` : `it('${m.name}: should ...', () => {`;
+                count++;
+                lines.push(`  ${itKw}`, `    // TODO: arrange`, `    const result = ${awaitKw}instance.${m.name}(${hint});`, jsAssert(fw, "result", "    "), `  });`, "");
+            }
+        }
+        lines.push(`});`, "");
+    }
+    else if (sym.kind === "const" || sym.kind === "var") {
+        count++;
+        lines.push(`describe('${sym.name}', () => {`, `  it('should be defined', () => {`, jsAssert(fw, sym.name, "    "), `  });`, `});`, "");
+    }
+    return { lines, count };
+}
+function generateJsTest(skel, syms, fw, isTs) {
+    const lines = [...jsFrameworkHeader(fw), ""];
+    const srcBase = path.basename(skel.file).replace(/\.[^.]+$/, "");
+    const srcPath = `./${srcBase}${isTs ? "" : ".js"}`;
+    const runtimeImports = syms.filter((s) => !["interface", "type"].includes(s.kind)).map((s) => s.name);
+    if (runtimeImports.length > 0)
+        lines.push(`import { ${runtimeImports.join(", ")} } from '${srcPath}';`);
+    if (isTs) {
+        const typeImports = syms.filter((s) => s.kind === "interface" || s.kind === "type").map((s) => s.name);
+        if (typeImports.length > 0)
+            lines.push(`import type { ${typeImports.join(", ")} } from '${srcPath}';`);
+    }
+    lines.push("");
+    let testCount = 0;
+    for (const sym of syms) {
+        const { lines: symLines, count } = jsSymbolTests(sym, fw, isTs);
+        lines.push(...symLines);
+        testCount += count;
+    }
+    return { content: lines.join("\n"), testCount };
+}
+// ─── Python ───────────────────────────────────────────────────────────────────
+function generatePyTest(skel, syms) {
+    const lines = ["import pytest", ""];
+    const mod = path.basename(skel.file).replace(/\.py$/, "");
+    const fns = syms.filter((s) => s.kind === "function" && !s.name.startsWith("_"));
+    const classes = syms.filter((s) => s.kind === "class");
+    const toImport = [...fns.map((s) => s.name), ...classes.map((s) => s.name)];
+    if (toImport.length > 0)
+        lines.push(`from .${mod} import ${toImport.join(", ")}`, "");
+    let testCount = 0;
+    for (const fn of fns) {
+        const hint = paramHints(fn).replace(/\/\* (\w+) \*\//g, "$1");
+        testCount++;
+        lines.push(`def test_${fn.name}():`, `    # TODO: arrange`, `    result = ${fn.name}(${hint})`, `    assert result is not None  # TODO: assert expected value`, "");
+    }
+    for (const cls of classes) {
+        const methods = cls.children.filter((c) => c.kind === "method" && c.visibility === "public" && !c.name.startsWith("__"));
+        lines.push(`class Test${cls.name}:`, "");
+        lines.push(`    def setup_method(self):`, `        self.instance = ${cls.name}()  # TODO: args`, "");
+        if (methods.length === 0) {
+            testCount++;
+            lines.push(`    def test_created(self):`, `        assert self.instance is not None`, "");
+        }
+        else {
+            for (const m of methods) {
+                const hint = paramHints(m).replace(/\/\* (\w+) \*\//g, "$1");
+                testCount++;
+                lines.push(`    def test_${m.name}(self):`, `        # TODO: arrange`, `        result = self.instance.${m.name}(${hint})`, `        assert result is not None  # TODO: assert expected value`, "");
+            }
+        }
+    }
+    return { content: lines.join("\n"), testCount };
+}
+// ─── Go ───────────────────────────────────────────────────────────────────────
+function generateGoTest(skel, syms) {
+    const pkgDir = path.dirname(skel.file).split("/").pop() ?? "main";
+    const lines = [`package ${pkgDir}`, "", `import (`, `\t"testing"`, `)`, ""];
+    let testCount = 0;
+    const fns = syms.filter((s) => s.kind === "function" && s.exported);
+    const structs = syms.filter((s) => s.kind === "struct" && s.exported);
+    for (const fn of fns) {
+        const hint = paramHints(fn).replace(/\/\* (\w+) \*\//g, "/* $1 */");
+        testCount++;
+        lines.push(`func Test${fn.name}(t *testing.T) {`, `\t// TODO: arrange`, `\t_ = ${fn.name}(${hint})`, `\t// if got != want { t.Errorf("expected %v, got %v", want, got) }`, `}`, "");
+    }
+    for (const s of structs) {
+        const methods = s.children.filter((c) => c.kind === "method" && c.visibility === "public");
+        for (const m of methods) {
+            testCount++;
+            lines.push(`func Test${s.name}_${m.name}(t *testing.T) {`, `\t// TODO: arrange`, `\t// instance := ${s.name}{}`, `\t// got := instance.${m.name}(/* args */)`, `\t// if got != want { t.Errorf("expected %v, got %v", want, got) }`, `}`, "");
+        }
+    }
+    return { content: lines.join("\n"), testCount };
+}
+// ─── Java ─────────────────────────────────────────────────────────────────────
+function generateJavaTest(skel, syms) {
+    const classes = syms.filter((s) => s.kind === "class" && s.exported);
+    const lines = [
+        `import org.junit.jupiter.api.Test;`,
+        `import org.junit.jupiter.api.BeforeEach;`,
+        `import static org.junit.jupiter.api.Assertions.*;`,
+        "",
+    ];
+    let testCount = 0;
+    for (const cls of classes) {
+        const methods = cls.children.filter((c) => c.kind === "method" && c.visibility === "public");
+        lines.push(`class ${cls.name}Test {`, "", `    private ${cls.name} instance;`, "");
+        lines.push(`    @BeforeEach`, `    void setUp() {`, `        instance = new ${cls.name}(); // TODO: args`, `    }`, "");
+        if (methods.length === 0) {
+            testCount++;
+            lines.push(`    @Test`, `    void shouldBeCreated() {`, `        assertNotNull(instance);`, `    }`, "");
+        }
+        else {
+            for (const m of methods) {
+                if (m.name === "constructor" || m.name === cls.name)
+                    continue;
+                testCount++;
+                const camel = m.name.charAt(0).toUpperCase() + m.name.slice(1);
+                lines.push(`    @Test`, `    void ${m.name}ShouldWork() {`, `        // TODO: arrange`, `        var result = instance.${m.name}(/* args */);`, `        assertNotNull(result); // TODO: assert expected value`, `    }`, "");
+            }
+        }
+        lines.push(`}`);
+    }
+    return { content: lines.join("\n"), testCount };
+}
+// ─── Ruby ─────────────────────────────────────────────────────────────────────
+function generateRubyTest(skel, syms) {
+    const srcRel = "./" + path.basename(skel.file).replace(/\.rb$/, "");
+    const lines = [`require 'rspec'`, `require_relative '${srcRel}'`, ""];
+    let testCount = 0;
+    const classes = syms.filter((s) => s.kind === "class");
+    const fns = syms.filter((s) => s.kind === "function");
+    for (const cls of classes) {
+        const methods = cls.children.filter((c) => c.kind === "method" && c.visibility === "public" && !c.name.startsWith("initialize"));
+        lines.push(`RSpec.describe ${cls.name} do`, `  subject { described_class.new }`, "");
+        if (methods.length === 0) {
+            testCount++;
+            lines.push(`  it 'is instantiable' do`, `    expect(subject).not_to be_nil`, `  end`, "");
+        }
+        else {
+            for (const m of methods) {
+                testCount++;
+                lines.push(`  describe '#${m.name}' do`, `    it 'should ...' do`, `      # TODO: arrange`, `      result = subject.${m.name}(/* args */)`, `      expect(result).not_to be_nil`, `    end`, `  end`, "");
+            }
+        }
+        lines.push(`end`, "");
+    }
+    for (const fn of fns) {
+        testCount++;
+        lines.push(`RSpec.describe '${fn.name}' do`, `  it 'should ...' do`, `    result = ${fn.name}(/* args */)`, `    expect(result).not_to be_nil`, `  end`, `end`, "");
+    }
+    return { content: lines.join("\n"), testCount };
+}
+// ─── Entry point ───────────────────────────────────────────────────────────────
+/** Generate a test file for a parsed skeleton. Returns content and metadata. */
+export function generateTestFile(skel, sourceAbs, opts = {}) {
+    const fw = opts.framework ?? "node";
+    const exportedOnly = opts.exportedOnly ?? true;
+    const syms = exportedOnly
+        ? skel.symbols.filter((s) => s.exported !== false)
+        : skel.symbols;
+    const testPath = resolveTestPath(sourceAbs, skel.language, opts.outDir);
+    const lang = skel.language;
+    let content;
+    let testCount;
+    if (lang === "typescript" || lang === "tsx") {
+        ({ content, testCount } = generateJsTest(skel, syms, fw, true));
+    }
+    else if (lang === "javascript" || lang === "jsx") {
+        ({ content, testCount } = generateJsTest(skel, syms, fw, false));
+    }
+    else if (lang === "python") {
+        ({ content, testCount } = generatePyTest(skel, syms));
+    }
+    else if (lang === "go") {
+        ({ content, testCount } = generateGoTest(skel, syms));
+    }
+    else if (lang === "java") {
+        ({ content, testCount } = generateJavaTest(skel, syms));
+    }
+    else if (lang === "ruby") {
+        ({ content, testCount } = generateRubyTest(skel, syms));
+    }
+    else {
+        content = `// Test file for ${skel.file}\n// Language: ${lang} — add tests manually\n`;
+        testCount = 0;
+    }
+    return { sourceFile: skel.file, testFilePath: testPath, framework: fw, content, testCount };
+}