docguard-cli 0.9.0 → 0.9.1

package/cli/commands/score.mjs

@@ -405,38 +405,77 @@ function calcDocQualityScore(dir, config) {
 function calcTestingScore(dir, config) {
   let score = 0;
 
-  // Check test directory exists
+  // ── Check 1: Test files exist (40 pts) ──
+  // Check top-level test directories
   const testDirs = ['tests', 'test', '__tests__', 'spec', 'e2e'];
-  const hasTestDir = testDirs.some(d => existsSync(resolve(dir, d)));
-  if (hasTestDir) score += 40;
+  const hasTopLevelTestDir = testDirs.some(d => existsSync(resolve(dir, d)));
 
-  // Check test spec exists
+  // Check co-located tests: src/**/__tests__/ and src/**/*.test.* / src/**/*.spec.*
+  let hasColocatedTests = false;
+  if (!hasTopLevelTestDir) {
+    hasColocatedTests = findColocatedTests(dir);
+  }
+
+  // Check vitest/jest config for custom test patterns
+  let hasConfigTests = false;
+  if (!hasTopLevelTestDir && !hasColocatedTests) {
+    const testConfigs = ['vitest.config.ts', 'vitest.config.js', 'vitest.config.mts', 'jest.config.ts', 'jest.config.js'];
+    for (const cfgFile of testConfigs) {
+      const cfgPath = resolve(dir, cfgFile);
+      if (existsSync(cfgPath)) {
+        try {
+          const cfgContent = readFileSync(cfgPath, 'utf-8');
+          const includeMatch = cfgContent.match(/include\s*:\s*\[([^\]]+)\]/);
+          if (includeMatch) {
+            const patterns = includeMatch[1].match(/['"]([^'"]+)['"]/g);
+            if (patterns) {
+              for (const p of patterns) {
+                const pattern = p.replace(/['"]|\s/g, '');
+                const rootDir = pattern.split('/')[0];
+                if (rootDir && rootDir !== '**' && rootDir !== '*') {
+                  const fullDir = resolve(dir, rootDir);
+                  if (existsSync(fullDir)) {
+                    hasConfigTests = true;
+                    break;
+                  }
+                }
+              }
+            }
+          }
+        } catch { /* config parse may fail */ }
+        break;
+      }
+    }
+  }
+
+  if (hasTopLevelTestDir || hasColocatedTests || hasConfigTests) score += 40;
+
+  // ── Check 2: TEST-SPEC.md exists (30 pts) ──
   if (existsSync(resolve(dir, 'docs-canonical/TEST-SPEC.md'))) score += 30;
 
-  // Check for test config files OR built-in test runner
-  const testConfigs = ['jest.config.js', 'jest.config.ts', 'vitest.config.ts', 'vitest.config.js', 'pytest.ini', 'setup.cfg', '.mocharc.yml'];
-  const hasTestConfig = testConfigs.some(f => existsSync(resolve(dir, f)));
+  // ── Check 3: Test config or built-in runner (15 pts) ──
+  const testConfigs2 = ['jest.config.js', 'jest.config.ts', 'vitest.config.ts', 'vitest.config.js', 'pytest.ini', 'setup.cfg', '.mocharc.yml'];
+  const hasTestConfig = testConfigs2.some(f => existsSync(resolve(dir, f)));
 
   if (hasTestConfig) {
     score += 15;
   } else {
-    // Check if using node:test (no config needed) — look in package.json scripts
     const ptc = config.projectTypeConfig || {};
     const pkgPath = resolve(dir, 'package.json');
     if (ptc.testFramework === 'node:test') {
-      score += 15; // Config says node:test — no config file needed
+      score += 15;
     } else if (existsSync(pkgPath)) {
       try {
         const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
         const testScript = pkg.scripts?.test || '';
         if (testScript.includes('node --test') || testScript.includes('node:test')) {
-          score += 15; // Using built-in test runner
+          score += 15;
         }
       } catch { /* skip */ }
     }
   }
 
-  // Check for CI test step
+  // ── Check 4: CI test step (15 pts) ──
   const ciFiles = ['.github/workflows/ci.yml', '.github/workflows/test.yml'];
   const hasCITest = ciFiles.some(f => existsSync(resolve(dir, f)));
   if (hasCITest) score += 15;
@@ -444,6 +483,53 @@ function calcTestingScore(dir, config) {
   return Math.min(100, score);
 }
 
+/**
+ * Scan common source directories for co-located test files.
+ * Checks: __tests__/ dirs, *.test.*, *.spec.* anywhere in src/, app/, lib/, packages/
+ * Also checks root-level for *.test.* files.
+ */
+function findColocatedTests(dir) {
+  // Scan these common source roots for co-located tests
+  const sourceRoots = ['src', 'app', 'lib', 'packages', 'modules'];
+  const ignoreSet = new Set(['node_modules', '.git', 'dist', 'build', '.next', 'coverage', '.cache']);
+
+  for (const root of sourceRoots) {
+    const rootDir = resolve(dir, root);
+    if (!existsSync(rootDir)) continue;
+    if (walkForTests(rootDir, ignoreSet)) return true;
+  }
+
+  // Also check root-level for *.test.* files (some projects put tests at root)
+  try {
+    const rootEntries = readdirSync(dir);
+    for (const entry of rootEntries) {
+      if (/\.(test|spec)\.[^.]+$/.test(entry)) return true;
+    }
+  } catch { /* ignore */ }
+
+  return false;
+}
+
+/** Recursively walk a dir looking for test files. Returns true as soon as one is found. */
+function walkForTests(d, ignoreSet) {
+  let entries;
+  try { entries = readdirSync(d); } catch { return false; }
+  for (const entry of entries) {
+    if (ignoreSet.has(entry) || entry.startsWith('.')) continue;
+    const full = join(d, entry);
+    try {
+      const s = statSync(full);
+      if (s.isDirectory()) {
+        if (entry === '__tests__' || entry === '__test__') return true;
+        if (walkForTests(full, ignoreSet)) return true;
+      } else {
+        if (/\.(test|spec)\.[^.]+$/.test(entry)) return true;
+      }
+    } catch { continue; }
+  }
+  return false;
+}
+
 function calcSecurityScore(dir, config) {
   let score = 0;
   const ptc = config.projectTypeConfig || {};

package/cli/validators/test-spec.mjs

@@ -3,7 +3,7 @@
  * Now respects projectTypeConfig (e.g., skip E2E for CLI tools)
  */
 
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { resolve } from 'node:path';
 
 export function validateTestSpec(projectDir, config) {
@@ -130,19 +130,66 @@ export function validateTestSpec(projectDir, config) {
     }
   }
 
-  // If no test spec entries parsed, check if test directory exists
+  // If no test spec entries parsed, check if tests exist anywhere
   if (results.total === 0) {
     results.total = 1;
+
+    // 1. Check top-level test dirs
     const commonTestDirs = ['tests', 'test', '__tests__', 'spec'];
     const hasTestDir = commonTestDirs.some(d =>
       existsSync(resolve(projectDir, d))
     );
-    if (hasTestDir) {
+
+    // 2. Check co-located tests (src/**/__tests__/, src/**/*.test.*)
+    let hasColocated = false;
+    if (!hasTestDir) {
+      const sourceRoots = ['src', 'app', 'lib', 'packages'];
+      for (const root of sourceRoots) {
+        const rootPath = resolve(projectDir, root);
+        if (existsSync(rootPath) && hasTestFilesRecursive(rootPath)) {
+          hasColocated = true;
+          break;
+        }
+      }
+    }
+
+    // 3. Check vitest/jest config for custom patterns
+    let hasConfigTests = false;
+    if (!hasTestDir && !hasColocated) {
+      const configs = ['vitest.config.ts', 'vitest.config.js', 'jest.config.ts', 'jest.config.js'];
+      hasConfigTests = configs.some(f => existsSync(resolve(projectDir, f)));
+    }
+
+    if (hasTestDir || hasColocated || hasConfigTests) {
       results.passed = 1;
     } else {
-      results.warnings.push('No test directory found (expected: tests/, test/, __tests__/)');
+      results.warnings.push(
+        'No test directory or co-located test files found. ' +
+        'Expected: tests/, src/**/__tests__/, or src/**/*.test.* files'
+      );
     }
   }
 
   return results;
 }
+
+/** Recursively check if a directory contains test files */
+function hasTestFilesRecursive(dir) {
+  const ignore = new Set(['node_modules', '.git', 'dist', 'build', 'coverage']);
+  let entries;
+  try { entries = readdirSync(dir); } catch { return false; }
+  for (const entry of entries) {
+    if (ignore.has(entry) || entry.startsWith('.')) continue;
+    const full = resolve(dir, entry);
+    try {
+      const s = statSync(full);
+      if (s.isDirectory()) {
+        if (entry === '__tests__' || entry === '__test__') return true;
+        if (hasTestFilesRecursive(full)) return true;
+      } else if (/\.(test|spec)\.[^.]+$/.test(entry)) {
+        return true;
+      }
+    } catch { continue; }
+  }
+  return false;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "docguard-cli",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "The enforcement tool for Canonical-Driven Development (CDD). Audit, generate, and guard your project documentation.",
   "type": "module",
   "bin": {