fix: add CODEOWNERS parse cache and tighten email validation (#222)

* feat: add CODEOWNERS module with parsing, matching, and ownership data

Adds src/owners.js implementing CODEOWNERS parsing (3 standard locations),
glob-to-regex pattern matching (**, *, ?, anchored/unanchored), last-match-wins
owner resolution, file-level and symbol-level ownership data, cross-owner
boundary detection, and diff-impact integration helper.

Includes unit tests (parseCodeownersContent, patternToRegex, matchOwners,
parseCodeowners) and integration tests (ownersData, ownersForFiles with
fixture DB and CODEOWNERS file).

Also updates BACKLOG.md to mark branch structural diff as done and
reorganize backlog items.

* fix: add parseCodeowners cache and tighten email validation

Cache CODEOWNERS parse results per rootDir, invalidated by file mtime.
Replace permissive `p.includes('@')` email filter with regex that
requires non-empty local and domain parts.

Impact: 3 functions changed, 4 affected

* fix(test): set mtime after write for Windows NTFS compatibility

NTFS can lazily update mtime on writeFileSync, causing the cache
invalidation test to see a stale timestamp. Set mtime explicitly
after writing to guarantee it differs from the cached value.

* fix: restore BACKLOG.md to main branch version

Remove stale BACKLOG.md changes that leaked from outdated branch base,
reverting completion status of 6 items and the date regression.

* fix: sync BACKLOG.md with latest main (restore 6 completed items)

Previous commit restored from stale local main. This fetches from
origin/main to correctly preserve all DONE markers for IDs 5, 15,
16, 18, 20, 31 and the current date.

Author: carlos-alm

src/owners.js

@@ -1,29 +1,46 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { findDbPath, openReadonlyOrFail } from './db.js';
-
 import { isTestFile } from './queries.js';
 
 // ─── CODEOWNERS Parsing ──────────────────────────────────────────────
 
 const CODEOWNERS_PATHS = ['CODEOWNERS', '.github/CODEOWNERS', 'docs/CODEOWNERS'];
 
+/** @type {Map<string, { rules: Array, path: string, mtime: number }>} */
+const codeownersCache = new Map();
+
 /**
  * Find and parse a CODEOWNERS file from the standard locations.
+ * Results are cached per rootDir and invalidated when the file's mtime changes.
  * @param {string} rootDir - Repository root directory
  * @returns {{ rules: Array<{pattern: string, owners: string[], regex: RegExp}>, path: string } | null}
  */
 export function parseCodeowners(rootDir) {
+  const cached = codeownersCache.get(rootDir);
+
   for (const rel of CODEOWNERS_PATHS) {
     const fullPath = path.join(rootDir, rel);
     if (fs.existsSync(fullPath)) {
+      const mtime = fs.statSync(fullPath).mtimeMs;
+      if (cached && cached.path === rel && cached.mtime === mtime) {
+        return { rules: cached.rules, path: cached.path };
+      }
       const content = fs.readFileSync(fullPath, 'utf-8');
-      return { rules: parseCodeownersContent(content), path: rel };
+      const rules = parseCodeownersContent(content);
+      codeownersCache.set(rootDir, { rules, path: rel, mtime });
+      return { rules, path: rel };
     }
   }
+  codeownersCache.delete(rootDir);
   return null;
 }
 
+/** Clear the parseCodeowners cache (for testing). */
+export function clearCodeownersCache() {
+  codeownersCache.clear();
+}
+
 /**
  * Parse CODEOWNERS file content into rules.
  * @param {string} content - Raw CODEOWNERS file content
@@ -37,7 +54,7 @@ export function parseCodeownersContent(content) {
     const parts = line.split(/\s+/);
     if (parts.length < 2) continue;
     const pattern = parts[0];
-    const owners = parts.slice(1).filter((p) => p.startsWith('@') || p.includes('@'));
+    const owners = parts.slice(1).filter((p) => p.startsWith('@') || /^[^@\s]+@[^@\s]+$/.test(p));
     if (owners.length === 0) continue;
     rules.push({ pattern, owners, regex: patternToRegex(pattern) });
   }

tests/integration/owners.test.js

@@ -2,7 +2,6 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import Database from 'better-sqlite3';
-
 import { afterAll, beforeAll, describe, expect, test } from 'vitest';
 import { initSchema } from '../../src/db.js';
 import { ownersData, ownersForFiles } from '../../src/owners.js';

tests/unit/owners.test.js

@@ -2,8 +2,8 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-
 import {
+  clearCodeownersCache,
   matchOwners,
   parseCodeowners,
   parseCodeownersContent,
@@ -37,6 +37,22 @@ describe('parseCodeownersContent', () => {
     expect(rules[0].owners).toEqual(['dev@example.com', '@python-team']);
   });
 
+  it('rejects malformed email-style owners', () => {
+    // foo@ has no domain — rejected by the email regex
+    // @bar passes as a GitHub handle (startsWith('@'))
+    const rules = parseCodeownersContent('*.js foo@ @bar');
+    expect(rules).toHaveLength(1);
+    expect(rules[0].owners).toEqual(['@bar']);
+  });
+
+  it('rejects @bar-only-at as email (no local part)', () => {
+    // Standalone token that looks like @domain but not a handle check
+    // This tests the email path: '@bar' would pass startsWith('@'), which is fine
+    // But 'nothandle' without @ is rejected, and 'a@' without domain is rejected
+    const rules = parseCodeownersContent('*.js a@ nothandle');
+    expect(rules).toHaveLength(0);
+  });
+
   it('skips lines with no owners', () => {
     const rules = parseCodeownersContent('*.js\nsrc/ @team');
     expect(rules).toHaveLength(1);
@@ -147,6 +163,7 @@ describe('parseCodeowners', () => {
   let tmpDir;
 
   beforeEach(() => {
+    clearCodeownersCache();
     tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codeowners-test-'));
   });
 
@@ -190,4 +207,29 @@ describe('parseCodeowners', () => {
     expect(result.path).toBe('CODEOWNERS');
     expect(result.rules[0].owners).toEqual(['@root']);
   });
+
+  it('returns cached result on repeated calls', () => {
+    fs.writeFileSync(path.join(tmpDir, 'CODEOWNERS'), '* @team\n');
+    const first = parseCodeowners(tmpDir);
+    const second = parseCodeowners(tmpDir);
+    expect(second).toEqual(first);
+    // Same rule array reference means cache was hit
+    expect(second.rules).toBe(first.rules);
+  });
+
+  it('invalidates cache when file mtime changes', () => {
+    const filePath = path.join(tmpDir, 'CODEOWNERS');
+    fs.writeFileSync(filePath, '* @old-team\n');
+    const first = parseCodeowners(tmpDir);
+    expect(first.rules[0].owners).toEqual(['@old-team']);
+
+    // Write new content then force a distinct mtime (NTFS can lazily update mtime)
+    fs.writeFileSync(filePath, '* @new-team\n');
+    const afterWrite = fs.statSync(filePath).mtimeMs;
+    fs.utimesSync(filePath, new Date(), new Date(afterWrite + 5000));
+
+    const second = parseCodeowners(tmpDir);
+    expect(second.rules[0].owners).toEqual(['@new-team']);
+    expect(second.rules).not.toBe(first.rules);
+  });
 });