jsdoczoom 0.4.11 → 0.4.13

package/dist/test/type-declarations.test.js

@@ -1,321 +0,0 @@
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import ts from "typescript";
-import { beforeEach, describe, expect, it } from "vitest";
-import { JsdocError } from "../src/errors.js";
-import {
-	generateTypeDeclarations,
-	getLanguageService,
-	resetCache,
-	resolveCompilerOptions,
-} from "../src/type-declarations.js";
-
-/**
- * Verifies that generateTypeDeclarations produces .d.ts-like output
- * including exported types, interfaces, function signatures, const
- * declarations, and class signatures while excluding imports, non-exported
- * internals, and implementation bodies. JSDoc comments are preserved.
- *
- * @summary Tests for TypeScript declaration output generation
- */
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const fixturesDir = join(__dirname, "fixtures", "leaf-files");
-describe("generateTypeDeclarations", () => {
-	const exportedTypesPath = join(fixturesDir, "exported-types.ts");
-	beforeEach(() => {
-		resetCache();
-	});
-	it("includes exported type aliases", () => {
-		const declarations = generateTypeDeclarations(exportedTypesPath);
-		expect(declarations).toContain("export type Name");
-		expect(declarations).toContain("string");
-	});
-	it("includes exported interfaces", () => {
-		const declarations = generateTypeDeclarations(exportedTypesPath);
-		expect(declarations).toContain("export interface User");
-		expect(declarations).toContain("id: number");
-		expect(declarations).toContain("name: string");
-		expect(declarations).toContain("email?: string");
-	});
-	it("includes exported function signatures (no bodies)", () => {
-		const declarations = generateTypeDeclarations(exportedTypesPath);
-		// Should include the function signature (TypeScript uses 'declare' keyword)
-		expect(declarations).toContain("export declare function getUser");
-		expect(declarations).toContain("id: number");
-		expect(declarations).toContain(": User");
-		// Should NOT include the implementation body
-		expect(declarations).not.toContain("return { id, name: 'test' }");
-	});
-	it("includes exported const signatures", () => {
-		const declarations = generateTypeDeclarations(exportedTypesPath);
-		expect(declarations).toContain("export declare const DEFAULT_TIMEOUT");
-		// TypeScript declaration emit includes the literal value for const declarations
-		expect(declarations).toContain("5000");
-	});
-	it("includes exported class declarations (signatures only, no method bodies)", () => {
-		const declarations = generateTypeDeclarations(exportedTypesPath);
-		// Should include the class declaration
-		expect(declarations).toContain("export declare class UserService");
-		// Should include method signatures
-		expect(declarations).toContain("add(user: User): void");
-		expect(declarations).toContain("getAll(): User[]");
-		// Should NOT include method bodies
-		expect(declarations).not.toContain("this.users.push(user)");
-		expect(declarations).not.toContain("return this.users");
-		// Should NOT include private field initializers
-		expect(declarations).not.toContain("private users: User[] = []");
-		// But should include the private field declaration
-		expect(declarations).toContain("private users");
-	});
-	it("preserves all JSDoc comments (file-level and symbol-level)", () => {
-		const declarations = generateTypeDeclarations(exportedTypesPath);
-		// File-level JSDoc
-		expect(declarations).toContain(
-			"Module for testing type declarations generation",
-		);
-		expect(declarations).toContain("Type declarations test module");
-		// Symbol-level JSDoc
-		expect(declarations).toContain("A string type alias");
-		expect(declarations).toContain("A user interface");
-		expect(declarations).toContain("Gets a user by ID");
-		expect(declarations).toContain("@param id - The user ID");
-		expect(declarations).toContain("@returns The user object");
-		expect(declarations).toContain("The default timeout value");
-		expect(declarations).toContain("A simple utility class");
-		expect(declarations).toContain("Add a user");
-		expect(declarations).toContain("Get all users");
-	});
-	it("excludes import statements", () => {
-		const declarations = generateTypeDeclarations(exportedTypesPath);
-		// The fixture doesn't have imports, but we can verify no import statements appear
-		expect(declarations).not.toContain("import ");
-		expect(declarations).not.toContain("from ");
-	});
-	it("excludes non-exported internals", () => {
-		const declarations = generateTypeDeclarations(exportedTypesPath);
-		// Should NOT include internal helper function
-		expect(declarations).not.toContain("internalHelper");
-		// Should NOT include private constant
-		expect(declarations).not.toContain("privateConst");
-	});
-	it("maintains source order of declarations", () => {
-		const declarations = generateTypeDeclarations(exportedTypesPath);
-		// Get positions of each export in the declarations
-		const namePos = declarations.indexOf("export type Name");
-		const userPos = declarations.indexOf("export interface User");
-		const getUserPos = declarations.indexOf("export declare function getUser");
-		const timeoutPos = declarations.indexOf(
-			"export declare const DEFAULT_TIMEOUT",
-		);
-		const classPos = declarations.indexOf("export declare class UserService");
-		// Verify they appear in the same order as the source
-		expect(namePos).toBeGreaterThan(-1);
-		expect(userPos).toBeGreaterThan(namePos);
-		expect(getUserPos).toBeGreaterThan(userPos);
-		expect(timeoutPos).toBeGreaterThan(getUserPos);
-		expect(classPos).toBeGreaterThan(timeoutPos);
-	});
-	it("reuses language service across calls for files sharing the same tsconfig", () => {
-		// Get the resolved compiler options and language service for the first call
-		const { tsconfigPath, options } = resolveCompilerOptions(exportedTypesPath);
-		const firstService = getLanguageService(tsconfigPath, options);
-		// First call
-		generateTypeDeclarations(exportedTypesPath);
-		// Second call should return the same service instance
-		const secondService = getLanguageService(tsconfigPath, options);
-		expect(secondService).toBe(firstService);
-		expect(secondService.service).toBe(firstService.service);
-		// Second call to generateTypeDeclarations should not create a new service
-		generateTypeDeclarations(exportedTypesPath);
-		const thirdService = getLanguageService(tsconfigPath, options);
-		expect(thirdService).toBe(firstService);
-	});
-	it("returns empty string for files with no exports", () => {
-		const noExportsPath = join(fixturesDir, "no-exports.ts");
-		const result = generateTypeDeclarations(noExportsPath);
-		expect(result).toBe("");
-	});
-	it("throws PARSE_ERROR for files with syntax errors", () => {
-		const syntaxErrorPath = join(fixturesDir, "syntax-error.ts");
-		expect(() => generateTypeDeclarations(syntaxErrorPath)).toThrow(JsdocError);
-		try {
-			generateTypeDeclarations(syntaxErrorPath);
-			expect.fail("Should have thrown JsdocError");
-		} catch (e) {
-			expect(e).toBeInstanceOf(JsdocError);
-			expect(e.code).toBe("PARSE_ERROR");
-		}
-	});
-});
-describe("resolveCompilerOptions", () => {
-	const tsconfigFixturesDir = join(__dirname, "fixtures");
-	const tsconfigProjectDir = join(tsconfigFixturesDir, "tsconfig-project");
-	const sampleTsPath = join(tsconfigProjectDir, "sample.ts");
-	const malformedTsconfigPath = join(
-		tsconfigFixturesDir,
-		"tsconfig-malformed",
-		"sample.ts",
-	);
-	beforeEach(() => {
-		resetCache();
-	});
-	it("returns options with declaration: true and removeComments: false regardless of tsconfig", () => {
-		const result = resolveCompilerOptions(sampleTsPath);
-		expect(result.options.declaration).toBe(true);
-		expect(result.options.emitDeclarationOnly).toBe(true);
-		expect(result.options.removeComments).toBe(false);
-		expect(result.options.skipLibCheck).toBe(true);
-	});
-	it("uses fallback defaults when no tsconfig.json is found", () => {
-		// Use a path that won't find any tsconfig.json (root directory)
-		// This assumes there's no tsconfig.json in the root filesystem
-		const noTsconfigPath = "/file.ts";
-		const result = resolveCompilerOptions(noTsconfigPath);
-		expect(result.tsconfigPath).toBe(null);
-		expect(result.options).toEqual({
-			declaration: true,
-			emitDeclarationOnly: true,
-			target: ts.ScriptTarget.Latest,
-			module: ts.ModuleKind.NodeNext,
-			moduleResolution: ts.ModuleResolutionKind.NodeNext,
-			skipLibCheck: true,
-			removeComments: false,
-		});
-	});
-	it("merges tsconfig settings with required overrides", () => {
-		const result = resolveCompilerOptions(sampleTsPath);
-		// Should include settings from the tsconfig
-		expect(result.options.strict).toBe(true);
-		expect(result.options.target).toBe(ts.ScriptTarget.ES2020);
-		// Should also include required overrides
-		expect(result.options.declaration).toBe(true);
-		expect(result.options.emitDeclarationOnly).toBe(true);
-		expect(result.options.removeComments).toBe(false);
-		expect(result.options.skipLibCheck).toBe(true);
-		// Should have found the tsconfig
-		expect(result.tsconfigPath).toContain("tsconfig-project");
-	});
-	it("returns the same result object for the same tsconfig path (caching)", () => {
-		const firstResult = resolveCompilerOptions(sampleTsPath);
-		const secondResult = resolveCompilerOptions(sampleTsPath);
-		// Should return the exact same object reference (not just equal values)
-		expect(firstResult).toBe(secondResult);
-		expect(firstResult.options).toBe(secondResult.options);
-	});
-	it("handles malformed tsconfig.json gracefully (falls back to defaults)", () => {
-		const result = resolveCompilerOptions(malformedTsconfigPath);
-		// Should fall back to defaults when tsconfig is malformed
-		expect(result.tsconfigPath).toBe(null);
-		expect(result.options).toEqual({
-			declaration: true,
-			emitDeclarationOnly: true,
-			target: ts.ScriptTarget.Latest,
-			module: ts.ModuleKind.NodeNext,
-			moduleResolution: ts.ModuleResolutionKind.NodeNext,
-			skipLibCheck: true,
-			removeComments: false,
-		});
-	});
-});
-describe("getLanguageService", () => {
-	const tsconfigFixturesDir = join(__dirname, "fixtures");
-	const tsconfigProjectDir = join(tsconfigFixturesDir, "tsconfig-project");
-	const sampleTsPath = join(tsconfigProjectDir, "sample.ts");
-	beforeEach(() => {
-		resetCache();
-	});
-	it("returns a language service that can emit declarations for a registered file", () => {
-		const { tsconfigPath, options } = resolveCompilerOptions(sampleTsPath);
-		const { service, files } = getLanguageService(tsconfigPath, options);
-		// Add the file to the service's file set
-		files.add(sampleTsPath);
-		// Get emit output for the file
-		const emitOutput = service.getEmitOutput(sampleTsPath, true); // true = emitOnlyDtsFiles
-		// Should have declaration output
-		expect(emitOutput.outputFiles).toBeDefined();
-		expect(emitOutput.outputFiles.length).toBeGreaterThan(0);
-		// Find the .d.ts output
-		const dtsFile = emitOutput.outputFiles.find((file) =>
-			file.name.endsWith(".d.ts"),
-		);
-		expect(dtsFile).toBeDefined();
-		expect(dtsFile?.text).toContain("export");
-	});
-	it("reuses the same language service instance for files sharing a tsconfig", () => {
-		const { tsconfigPath, options } = resolveCompilerOptions(sampleTsPath);
-		// Get the service twice
-		const firstCall = getLanguageService(tsconfigPath, options);
-		const secondCall = getLanguageService(tsconfigPath, options);
-		// Should return the exact same object references
-		expect(firstCall).toBe(secondCall);
-		expect(firstCall.service).toBe(secondCall.service);
-		expect(firstCall.files).toBe(secondCall.files);
-	});
-	it("creates separate service instances for different tsconfigs", () => {
-		// Get service for tsconfig-project
-		const { tsconfigPath: tsconfigPath1, options: options1 } =
-			resolveCompilerOptions(sampleTsPath);
-		const service1 = getLanguageService(tsconfigPath1, options1);
-		// Get service for a file with no tsconfig (uses fallback)
-		const noTsconfigPath = "/file.ts";
-		const { tsconfigPath: tsconfigPath2, options: options2 } =
-			resolveCompilerOptions(noTsconfigPath);
-		const service2 = getLanguageService(tsconfigPath2, options2);
-		// Should be different service instances
-		expect(service1).not.toBe(service2);
-		expect(service1.service).not.toBe(service2.service);
-		expect(service1.files).not.toBe(service2.files);
-	});
-	it("adding a new file to the files Set makes it visible to the existing service's getScriptFileNames()", () => {
-		const { tsconfigPath, options } = resolveCompilerOptions(sampleTsPath);
-		const { service, files } = getLanguageService(tsconfigPath, options);
-		// Initially no files
-		expect(files.size).toBe(0);
-		// Add a file
-		files.add(sampleTsPath);
-		// Service should now see the file via getProgram().getSourceFiles()
-		const program = service.getProgram();
-		expect(program).toBeDefined();
-		const sourceFiles = program?.getSourceFiles() ?? [];
-		const hasOurFile = sourceFiles.some((sf) => sf.fileName === sampleTsPath);
-		expect(hasOurFile).toBe(true);
-		// Add another file
-		const anotherFilePath = join(tsconfigProjectDir, "another-file.ts");
-		files.add(anotherFilePath);
-		// Should now have 2 files in the set
-		expect(files.size).toBe(2);
-		expect(files.has(sampleTsPath)).toBe(true);
-		expect(files.has(anotherFilePath)).toBe(true);
-	});
-});
-describe("resetCache", () => {
-	const tsconfigFixturesDir = join(__dirname, "fixtures");
-	const tsconfigProjectDir = join(tsconfigFixturesDir, "tsconfig-project");
-	const sampleTsPath = join(tsconfigProjectDir, "sample.ts");
-	it("clears the compiler options cache", () => {
-		// Populate the cache
-		const firstResult = resolveCompilerOptions(sampleTsPath);
-		// Reset
-		resetCache();
-		// Get options again
-		const secondResult = resolveCompilerOptions(sampleTsPath);
-		// Should be different object instances (cache was cleared)
-		expect(firstResult).not.toBe(secondResult);
-		// But should have the same values
-		expect(firstResult.tsconfigPath).toBe(secondResult.tsconfigPath);
-	});
-	it("clears the language service cache", () => {
-		// Populate the cache
-		const { tsconfigPath, options } = resolveCompilerOptions(sampleTsPath);
-		const firstService = getLanguageService(tsconfigPath, options);
-		// Reset
-		resetCache();
-		// Get service again (need to resolve options again too since that cache was also cleared)
-		const { tsconfigPath: newTsconfigPath, options: newOptions } =
-			resolveCompilerOptions(sampleTsPath);
-		const secondService = getLanguageService(newTsconfigPath, newOptions);
-		// Should be different service instances (cache was cleared)
-		expect(firstService).not.toBe(secondService);
-		expect(firstService.service).not.toBe(secondService.service);
-	});
-});

package/dist/test/validate.test.js

@@ -1,361 +0,0 @@
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { describe, expect, it } from "vitest";
-import { JsdocError } from "../src/errors.js";
-import { validate, validateFiles } from "../src/validate.js";
-
-/**
- * Verifies status classification (valid, syntax_error, missing_jsdoc,
- * missing_summary, missing_description), priority-order group filling
- * under limits, and error handling for missing files and empty globs.
- *
- * @summary Tests for file-level JSDoc validation and grouped result output
- */
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const fixturesDir = path.resolve(__dirname, "fixtures", "leaf-files");
-function fixture(name) {
-	return path.join(fixturesDir, name);
-}
-describe("validate", () => {
-	it("valid file produces empty result", async () => {
-		const selector = {
-			type: "path",
-			pattern: fixture("two-summaries.ts"),
-			depth: undefined,
-		};
-		const result = await validate(selector, fixturesDir);
-		expect(result.syntax_error).toBeUndefined();
-		expect(result.missing_jsdoc).toBeUndefined();
-		expect(result.missing_summary).toBeUndefined();
-		expect(result.missing_description).toBeUndefined();
-	});
-	it("file with @summary but no description is missing_description", async () => {
-		const selector = {
-			type: "path",
-			pattern: fixture("summary-only.ts"),
-			depth: undefined,
-		};
-		const result = await validate(selector, fixturesDir);
-		expect(result.missing_description?.files).toEqual(["summary-only.ts"]);
-		expect(result.missing_jsdoc).toBeUndefined();
-		expect(result.missing_summary).toBeUndefined();
-	});
-	it("file with no @summary is missing_summary", async () => {
-		const selector = {
-			type: "path",
-			pattern: fixture("description-only.ts"),
-			depth: undefined,
-		};
-		const result = await validate(selector, fixturesDir);
-		expect(result.missing_summary?.files).toEqual(["description-only.ts"]);
-	});
-	it("file with no file-level JSDoc is missing_jsdoc", async () => {
-		const selector = {
-			type: "path",
-			pattern: fixture("no-jsdoc.ts"),
-			depth: undefined,
-		};
-		const result = await validate(selector, fixturesDir);
-		expect(result.missing_jsdoc?.files).toEqual(["no-jsdoc.ts"]);
-	});
-	it("file with syntax error is syntax_error", async () => {
-		const selector = {
-			type: "path",
-			pattern: fixture("syntax-error.ts"),
-			depth: undefined,
-		};
-		const result = await validate(selector, fixturesDir);
-		expect(result.syntax_error?.files).toEqual(["syntax-error.ts"]);
-	});
-	it("whitespace-only @summary is skipped, uses next non-empty one", async () => {
-		const selector = {
-			type: "path",
-			pattern: fixture("whitespace-summary.ts"),
-			depth: undefined,
-		};
-		const result = await validate(selector, fixturesDir);
-		expect(result.missing_summary).toBeUndefined();
-	});
-	it("flags files with multiple @summary tags", async () => {
-		const selector = {
-			type: "path",
-			pattern: "multiple-summaries.ts",
-			depth: undefined,
-		};
-		const result = await validate(selector, fixturesDir);
-		expect(result.multiple_summary).toBeDefined();
-		expect(result.multiple_summary?.files).toEqual(["multiple-summaries.ts"]);
-	});
-	it("silently strips @depth suffix", async () => {
-		const selector = {
-			type: "glob",
-			pattern: "**/*.ts",
-			depth: 1,
-		};
-		const result = await validate(selector, fixturesDir);
-		// Should succeed without throwing — depth is ignored
-		expect(typeof result).toBe("object");
-	});
-	it("output groups only contain invalid files, empty groups omitted", async () => {
-		const selector = {
-			type: "glob",
-			pattern: "*.ts",
-			depth: undefined,
-		};
-		const result = await validate(selector, fixturesDir);
-		// Every group key that exists should have { guidance, files } shape
-		for (const key of [
-			"syntax_error",
-			"missing_jsdoc",
-			"missing_summary",
-			"multiple_summary",
-			"missing_description",
-			"missing_barrel",
-		]) {
-			const group = result[key];
-			if (group !== undefined) {
-				expect(typeof group.guidance).toBe("string");
-				expect(group.guidance.length).toBeGreaterThan(0);
-				expect(Array.isArray(group.files)).toBe(true);
-				expect(group.files.length).toBeGreaterThan(0);
-				for (const p of group.files) {
-					expect(typeof p).toBe("string");
-				}
-			}
-		}
-	});
-	it("each group includes guidance text", async () => {
-		const selector = {
-			type: "glob",
-			pattern: "*.ts",
-			depth: undefined,
-		};
-		const result = await validate(selector, fixturesDir);
-		if (result.syntax_error) {
-			expect(result.syntax_error.guidance).toContain("### Syntax error");
-		}
-		if (result.missing_jsdoc) {
-			expect(result.missing_jsdoc.guidance).toContain(
-				"### Missing file-level JSDoc",
-			);
-		}
-		if (result.missing_summary) {
-			expect(result.missing_summary.guidance).toContain("### The @summary tag");
-		}
-		if (result.missing_description) {
-			expect(result.missing_description.guidance).toContain(
-				"### The description paragraph",
-			);
-		}
-	});
-	it("works with glob selectors", async () => {
-		const selector = {
-			type: "glob",
-			pattern: "two-*.ts",
-			depth: undefined,
-		};
-		const result = await validate(selector, fixturesDir);
-		// two-summaries.ts is valid, so no groups should appear
-		expect(result.syntax_error).toBeUndefined();
-		expect(result.missing_jsdoc).toBeUndefined();
-		expect(result.missing_summary).toBeUndefined();
-		expect(result.missing_description).toBeUndefined();
-	});
-	it("works with path selectors", async () => {
-		const selector = {
-			type: "path",
-			pattern: fixture("two-summaries.ts"),
-			depth: undefined,
-		};
-		const result = await validate(selector, fixturesDir);
-		expect(result.syntax_error).toBeUndefined();
-		expect(result.missing_jsdoc).toBeUndefined();
-		expect(result.missing_summary).toBeUndefined();
-		expect(result.missing_description).toBeUndefined();
-	});
-	it("path targeting nonexistent file throws FILE_NOT_FOUND", async () => {
-		const selector = {
-			type: "path",
-			pattern: fixture("nonexistent.ts"),
-			depth: undefined,
-		};
-		await expect(validate(selector, fixturesDir)).rejects.toThrow(JsdocError);
-		try {
-			await validate(selector, fixturesDir);
-		} catch (e) {
-			expect(e).toBeInstanceOf(JsdocError);
-			expect(e.code).toBe("FILE_NOT_FOUND");
-		}
-	});
-	it("glob with no matches throws NO_FILES_MATCHED", async () => {
-		const selector = {
-			type: "glob",
-			pattern: "nonexistent-*.ts",
-			depth: undefined,
-		};
-		await expect(validate(selector, fixturesDir)).rejects.toThrow(JsdocError);
-		try {
-			await validate(selector, fixturesDir);
-		} catch (e) {
-			expect(e).toBeInstanceOf(JsdocError);
-			expect(e.code).toBe("NO_FILES_MATCHED");
-		}
-	});
-	it("flags directories with >3 files and no barrel as missing_barrel", async () => {
-		// leaf-files has 12+ .ts files and no index.ts
-		const selector = {
-			type: "glob",
-			pattern: "*.ts",
-			depth: undefined,
-		};
-		const result = await validate(selector, fixturesDir);
-		expect(result.missing_barrel).toBeDefined();
-		expect(result.missing_barrel?.files).toContain(".");
-	});
-	it("does not flag directories with <=3 files as missing_barrel", async () => {
-		// depth-advancement has only 2 files
-		const depthDir = path.resolve(__dirname, "fixtures", "depth-advancement");
-		const selector = {
-			type: "glob",
-			pattern: "*.ts",
-			depth: undefined,
-		};
-		const result = await validate(selector, depthDir);
-		expect(result.missing_barrel).toBeUndefined();
-	});
-	it("does not flag directories that have a barrel as missing_barrel", async () => {
-		// barrel-basic has index.ts + helper.ts + utils.ts
-		const barrelDir = path.resolve(__dirname, "fixtures", "barrel-basic");
-		const selector = {
-			type: "glob",
-			pattern: "**/*.ts",
-			depth: undefined,
-		};
-		const result = await validate(selector, barrelDir);
-		expect(result.missing_barrel).toBeUndefined();
-	});
-	describe("limit", () => {
-		it("all invalid files shown when within limit", async () => {
-			const selector = {
-				type: "glob",
-				pattern: "*.ts",
-				depth: undefined,
-			};
-			const result = await validate(selector, fixturesDir, 100);
-			// With a high limit, all invalid files should be present
-			const totalShown =
-				(result.syntax_error?.files.length ?? 0) +
-				(result.missing_jsdoc?.files.length ?? 0) +
-				(result.missing_summary?.files.length ?? 0) +
-				(result.missing_description?.files.length ?? 0);
-			expect(totalShown).toBeGreaterThan(0);
-		});
-		it("total shown paths capped at limit", async () => {
-			const selector = {
-				type: "glob",
-				pattern: "*.ts",
-				depth: undefined,
-			};
-			const result = await validate(selector, fixturesDir, 1);
-			// Total shown paths should equal limit
-			const shownPaths =
-				(result.syntax_error?.files.length ?? 0) +
-				(result.missing_jsdoc?.files.length ?? 0) +
-				(result.missing_summary?.files.length ?? 0) +
-				(result.missing_description?.files.length ?? 0);
-			expect(shownPaths).toBe(1);
-		});
-		it("limit of 0 shows no file paths", async () => {
-			const selector = {
-				type: "glob",
-				pattern: "*.ts",
-				depth: undefined,
-			};
-			const result = await validate(selector, fixturesDir, 0);
-			expect(result.syntax_error).toBeUndefined();
-			expect(result.missing_jsdoc).toBeUndefined();
-			expect(result.missing_summary).toBeUndefined();
-			expect(result.missing_description).toBeUndefined();
-		});
-		it("groups are filled in priority order (syntax_error first)", async () => {
-			const files = [
-				fixture("syntax-error.ts"),
-				fixture("no-jsdoc.ts"),
-				fixture("description-only.ts"),
-				fixture("summary-only.ts"),
-			];
-			const result = await validateFiles(files, fixturesDir, 2);
-			// syntax_error should be filled first
-			expect(result.syntax_error?.files).toEqual(["syntax-error.ts"]);
-			// Then missing_jsdoc
-			expect(result.missing_jsdoc?.files).toEqual(["no-jsdoc.ts"]);
-			// Remaining groups should not appear (limit reached)
-			expect(result.missing_summary).toBeUndefined();
-			expect(result.missing_description).toBeUndefined();
-		});
-	});
-});
-describe("validateFiles", () => {
-	it("validates explicit file list", async () => {
-		const files = [
-			fixture("two-summaries.ts"),
-			fixture("one-summary.ts"),
-			fixture("no-jsdoc.ts"),
-		];
-		const result = await validateFiles(files, fixturesDir);
-		expect(result.missing_jsdoc?.files).toEqual(["no-jsdoc.ts"]);
-	});
-	it("filters to .ts/.tsx only", async () => {
-		const files = [
-			fixture("two-summaries.ts"),
-			"/some/path/file.js",
-			"/some/path/file.jsx",
-			fixture("one-summary.ts"),
-		];
-		const result = await validateFiles(files, fixturesDir);
-		// Should only validate .ts/.tsx files (filters out .js/.jsx) — all valid
-		expect(result.syntax_error).toBeUndefined();
-		expect(result.missing_jsdoc).toBeUndefined();
-		expect(result.missing_summary).toBeUndefined();
-		expect(result.missing_description).toBeUndefined();
-	});
-	it("produces grouped output format with ValidationGroup shape", async () => {
-		const files = [fixture("no-jsdoc.ts")];
-		const result = await validateFiles(files, fixturesDir);
-		expect(result.missing_jsdoc).toBeDefined();
-		expect(typeof result.missing_jsdoc?.guidance).toBe("string");
-		expect(Array.isArray(result.missing_jsdoc?.files)).toBe(true);
-	});
-	it("handles empty file list", async () => {
-		const result = await validateFiles([], fixturesDir);
-		expect(result.syntax_error).toBeUndefined();
-		expect(result.missing_jsdoc).toBeUndefined();
-		expect(result.missing_summary).toBeUndefined();
-		expect(result.missing_description).toBeUndefined();
-	});
-	it("handles mixed pass/fail results", async () => {
-		const files = [
-			fixture("one-summary.ts"), // Pass
-			fixture("description-only.ts"), // Fail — missing_summary
-		];
-		const result = await validateFiles(files, fixturesDir);
-		expect(result.missing_summary?.files).toEqual(["description-only.ts"]);
-	});
-});
-describe("cache integration", () => {
-	it("validate returns cached classification for unchanged files", async () => {
-		// Run validate twice on same file, second time should be cached
-		// (we can't directly verify caching without mocking, but verify correctness)
-		const files = [fixture("two-summaries.ts")];
-		const result1 = await validateFiles(files, fixturesDir);
-		const result2 = await validateFiles(files, fixturesDir);
-		expect(result1).toEqual(result2);
-	});
-	it("validate works with cache disabled", async () => {
-		const files = [fixture("two-summaries.ts")];
-		const disabledConfig = { enabled: false, directory: "" };
-		const result = await validateFiles(files, fixturesDir, 100, disabledConfig);
-		expect(result.syntax_error).toBeUndefined();
-		expect(result.missing_jsdoc).toBeUndefined();
-	});
-});

package/types/test/barrel.test.d.ts

@@ -1 +0,0 @@
-export {};

package/types/test/cache.test.d.ts

@@ -1,8 +0,0 @@
-/**
- * Tests for the content-hash-based disk cache module. Verifies content hashing,
- * cache read/write operations, directory creation, graceful error handling,
- * concurrency safety, and mode namespacing using temporary test directories.
- *
- * @summary Unit and integration tests for cache operations
- */
-export {};