@optave/codegraph 3.3.0 → 3.4.0

package/src/features/{manifesto.js → manifesto.ts}

@@ -4,17 +4,20 @@ import { findCycles } from '../domain/graph/cycles.js';
 import { loadConfig } from '../infrastructure/config.js';
 import { debug } from '../infrastructure/logger.js';
 import { paginateResult } from '../shared/paginate.js';
+import type { BetterSqlite3Database, CodegraphConfig, ThresholdRule } from '../types.js';
 import { evaluateBoundaries } from './boundaries.js';
 
 // ─── Rule Definitions ─────────────────────────────────────────────────
 
-/**
- * All supported manifesto rules.
- * level: 'function' | 'file' | 'graph'
- * metric: DB column or special key
- * defaults: { warn, fail } — null means disabled
- */
-export const RULE_DEFS = [
+interface RuleDef {
+  name: string;
+  level: 'function' | 'file' | 'graph';
+  metric: string;
+  defaults: { warn: number | null; fail: number | null };
+  reportOnly?: boolean;
+}
+
+export const RULE_DEFS: RuleDef[] = [
   {
     name: 'cognitive',
     level: 'function',
@@ -74,12 +77,12 @@ const NO_TEST_SQL = `
   AND n.file NOT LIKE '%__tests__%'
   AND n.file NOT LIKE '%.stories.%'`;
 
-/**
- * Deep-merge user config with RULE_DEFS defaults per rule.
- * mergeConfig in config.js is shallow for nested objects, so we do per-rule merging here.
- */
-function resolveRules(userRules) {
-  const resolved = {};
+interface ResolvedRules {
+  [name: string]: ThresholdRule;
+}
+
+function resolveRules(userRules?: Record<string, Partial<ThresholdRule>>): ResolvedRules {
+  const resolved: ResolvedRules = {};
   for (const def of RULE_DEFS) {
     const user = userRules?.[def.name];
     resolved[def.name] = {
@@ -90,17 +93,27 @@ function resolveRules(userRules) {
   return resolved;
 }
 
-/**
- * Check if a rule is enabled (has at least one non-null threshold).
- */
-function isEnabled(thresholds) {
+function isEnabled(thresholds: ThresholdRule): boolean {
   return thresholds.warn != null || thresholds.fail != null;
 }
 
-/**
- * Check a numeric value against warn/fail thresholds, push violations.
- */
-function checkThreshold(rule, thresholds, value, meta, violations) {
+interface Violation {
+  rule: string;
+  level: string;
+  value: number;
+  threshold: number;
+  name?: string;
+  file?: string;
+  line?: number | null;
+}
+
+function checkThreshold(
+  rule: string,
+  thresholds: ThresholdRule,
+  value: number,
+  meta: { name?: string; file?: string; line?: number | null },
+  violations: Violation[],
+): 'fail' | 'warn' | 'pass' {
   if (thresholds.fail != null && value >= thresholds.fail) {
     violations.push({
       rule,
@@ -126,16 +139,39 @@ function checkThreshold(rule, thresholds, value, meta, violations) {
 
 // ─── Evaluators ───────────────────────────────────────────────────────
 
-function evaluateFunctionRules(db, rules, opts, violations, ruleResults) {
+interface RuleResult {
+  name: string;
+  level: string;
+  status: string;
+  thresholds: ThresholdRule;
+  violationCount: number;
+}
+
+interface ManifestoOpts {
+  noTests?: boolean;
+  file?: string;
+  kind?: string;
+  config?: CodegraphConfig;
+  limit?: number;
+  offset?: number;
+}
+
+function evaluateFunctionRules(
+  db: BetterSqlite3Database,
+  rules: ResolvedRules,
+  opts: ManifestoOpts,
+  violations: Violation[],
+  ruleResults: RuleResult[],
+): void {
   const functionDefs = RULE_DEFS.filter((d) => d.level === 'function');
-  const activeDefs = functionDefs.filter((d) => isEnabled(rules[d.name]));
+  const activeDefs = functionDefs.filter((d) => isEnabled(rules[d.name]!));
   if (activeDefs.length === 0) {
     for (const def of functionDefs) {
       ruleResults.push({
         name: def.name,
         level: def.level,
         status: 'pass',
-        thresholds: rules[def.name],
+        thresholds: rules[def.name]!,
         violationCount: 0,
       });
     }
@@ -143,10 +179,10 @@ function evaluateFunctionRules(db, rules, opts, violations, ruleResults) {
   }
 
   let where = "WHERE n.kind IN ('function','method')";
-  const params = [];
+  const params: unknown[] = [];
   if (opts.noTests) where += NO_TEST_SQL;
   {
-    const fc = buildFileConditionSQL(opts.file, 'n.file');
+    const fc = buildFileConditionSQL(opts.file as string, 'n.file');
     where += fc.sql;
     params.push(...fc.params);
   }
@@ -155,7 +191,7 @@ function evaluateFunctionRules(db, rules, opts, violations, ruleResults) {
     params.push(opts.kind);
   }
 
-  let rows;
+  let rows: Array<Record<string, unknown>>;
   try {
     rows = db
       .prepare(
@@ -165,15 +201,15 @@ function evaluateFunctionRules(db, rules, opts, violations, ruleResults) {
          JOIN nodes n ON fc.node_id = n.id
          ${where}`,
       )
-      .all(...params);
-  } catch (err) {
-    debug('manifesto function query failed: %s', err.message);
+      .all(...params) as Array<Record<string, unknown>>;
+  } catch (err: unknown) {
+    debug(`manifesto function query failed: ${(err as Error).message}`);
     rows = [];
   }
 
   // Track worst status per rule
-  const worst = {};
-  const counts = {};
+  const worst: Record<string, string> = {};
+  const counts: Record<string, number> = {};
   for (const def of functionDefs) {
     worst[def.name] = 'pass';
     counts[def.name] = 0;
@@ -181,12 +217,16 @@ function evaluateFunctionRules(db, rules, opts, violations, ruleResults) {
 
   for (const row of rows) {
     for (const def of activeDefs) {
-      const value = row[def.metric];
+      const value = row[def.metric] as number | null;
       if (value == null) continue;
-      const meta = { name: row.name, file: row.file, line: row.line };
-      const status = checkThreshold(def.name, rules[def.name], value, meta, violations);
+      const meta = {
+        name: row['name'] as string,
+        file: row['file'] as string,
+        line: row['line'] as number,
+      };
+      const status = checkThreshold(def.name, rules[def.name]!, value, meta, violations);
       if (status !== 'pass') {
-        counts[def.name]++;
+        counts[def.name] = (counts[def.name] ?? 0) + 1;
         if (status === 'fail') worst[def.name] = 'fail';
         else if (worst[def.name] !== 'fail') worst[def.name] = 'warn';
       }
@@ -197,23 +237,29 @@ function evaluateFunctionRules(db, rules, opts, violations, ruleResults) {
     ruleResults.push({
       name: def.name,
       level: def.level,
-      status: worst[def.name],
-      thresholds: rules[def.name],
-      violationCount: counts[def.name],
+      status: worst[def.name]!,
+      thresholds: rules[def.name]!,
+      violationCount: counts[def.name] ?? 0,
     });
   }
 }
 
-function evaluateFileRules(db, rules, opts, violations, ruleResults) {
+function evaluateFileRules(
+  db: BetterSqlite3Database,
+  rules: ResolvedRules,
+  opts: ManifestoOpts,
+  violations: Violation[],
+  ruleResults: RuleResult[],
+): void {
   const fileDefs = RULE_DEFS.filter((d) => d.level === 'file');
-  const activeDefs = fileDefs.filter((d) => isEnabled(rules[d.name]));
+  const activeDefs = fileDefs.filter((d) => isEnabled(rules[d.name]!));
   if (activeDefs.length === 0) {
     for (const def of fileDefs) {
       ruleResults.push({
         name: def.name,
         level: def.level,
         status: 'pass',
-        thresholds: rules[def.name],
+        thresholds: rules[def.name]!,
         violationCount: 0,
       });
     }
@@ -221,15 +267,15 @@ function evaluateFileRules(db, rules, opts, violations, ruleResults) {
   }
 
   let where = "WHERE n.kind = 'file'";
-  const params = [];
+  const params: unknown[] = [];
   if (opts.noTests) where += NO_TEST_SQL;
   {
-    const fc = buildFileConditionSQL(opts.file, 'n.file');
+    const fc = buildFileConditionSQL(opts.file as string, 'n.file');
     where += fc.sql;
     params.push(...fc.params);
   }
 
-  let rows;
+  let rows: Array<Record<string, unknown>>;
   try {
     rows = db
       .prepare(
@@ -240,14 +286,14 @@ function evaluateFileRules(db, rules, opts, violations, ruleResults) {
          JOIN nodes n ON nm.node_id = n.id
          ${where}`,
       )
-      .all(...params);
-  } catch (err) {
-    debug('manifesto file query failed: %s', err.message);
+      .all(...params) as Array<Record<string, unknown>>;
+  } catch (err: unknown) {
+    debug(`manifesto file query failed: ${(err as Error).message}`);
     rows = [];
   }
 
-  const worst = {};
-  const counts = {};
+  const worst: Record<string, string> = {};
+  const counts: Record<string, number> = {};
   for (const def of fileDefs) {
     worst[def.name] = 'pass';
     counts[def.name] = 0;
@@ -255,12 +301,16 @@ function evaluateFileRules(db, rules, opts, violations, ruleResults) {
 
   for (const row of rows) {
     for (const def of activeDefs) {
-      const value = row[def.metric];
+      const value = row[def.metric] as number | null;
       if (value == null) continue;
-      const meta = { name: row.name, file: row.file, line: row.line };
-      const status = checkThreshold(def.name, rules[def.name], value, meta, violations);
+      const meta = {
+        name: row['name'] as string,
+        file: row['file'] as string,
+        line: row['line'] as number,
+      };
+      const status = checkThreshold(def.name, rules[def.name]!, value, meta, violations);
       if (status !== 'pass') {
-        counts[def.name]++;
+        counts[def.name] = (counts[def.name] ?? 0) + 1;
         if (status === 'fail') worst[def.name] = 'fail';
         else if (worst[def.name] !== 'fail') worst[def.name] = 'warn';
       }
@@ -271,15 +321,21 @@ function evaluateFileRules(db, rules, opts, violations, ruleResults) {
     ruleResults.push({
       name: def.name,
       level: def.level,
-      status: worst[def.name],
-      thresholds: rules[def.name],
-      violationCount: counts[def.name],
+      status: worst[def.name]!,
+      thresholds: rules[def.name]!,
+      violationCount: counts[def.name] ?? 0,
     });
   }
 }
 
-function evaluateGraphRules(db, rules, opts, violations, ruleResults) {
-  const thresholds = rules.noCycles;
+function evaluateGraphRules(
+  db: BetterSqlite3Database,
+  rules: ResolvedRules,
+  opts: ManifestoOpts,
+  violations: Violation[],
+  ruleResults: RuleResult[],
+): void {
+  const thresholds = rules['noCycles']!;
   if (!isEnabled(thresholds)) {
     ruleResults.push({
       name: 'noCycles',
@@ -329,14 +385,24 @@ function evaluateGraphRules(db, rules, opts, violations, ruleResults) {
   });
 }
 
-function evaluateBoundaryRules(db, rules, config, opts, violations, ruleResults) {
-  const thresholds = rules.boundaries;
+function evaluateBoundaryRules(
+  db: BetterSqlite3Database,
+  rules: ResolvedRules,
+  config: CodegraphConfig,
+  opts: ManifestoOpts,
+  violations: Violation[],
+  ruleResults: RuleResult[],
+): void {
+  const thresholds = rules['boundaries']!;
   const boundaryConfig = config.manifesto?.boundaries;
 
   // Auto-enable at warn level when boundary config exists but threshold not set
-  const effectiveThresholds = { ...thresholds };
+  const effectiveThresholds: ThresholdRule = {
+    warn: thresholds.warn ?? null,
+    fail: thresholds.fail ?? null,
+  };
   if (boundaryConfig && !isEnabled(thresholds)) {
-    effectiveThresholds.warn = true;
+    effectiveThresholds.warn = true as unknown as number;
   }
 
   if (!isEnabled(effectiveThresholds) || !boundaryConfig) {
@@ -384,25 +450,20 @@ function evaluateBoundaryRules(db, rules, config, opts, violations, ruleResults)
 
 // ─── Public API ───────────────────────────────────────────────────────
 
-/**
- * Evaluate all manifesto rules and return structured results.
- *
- * @param {string} [customDbPath] - Path to graph.db
- * @param {object} [opts] - Options
- * @param {boolean} [opts.noTests] - Exclude test files
- * @param {string} [opts.file] - Filter by file (partial match)
- * @param {string} [opts.kind] - Filter by symbol kind
- * @returns {{ rules: object[], violations: object[], summary: object, passed: boolean }}
- */
-export function manifestoData(customDbPath, opts = {}) {
+export function manifestoData(
+  customDbPath?: string,
+  opts: ManifestoOpts = {},
+): Record<string, unknown> {
   const db = openReadonlyOrFail(customDbPath);
 
   try {
     const config = opts.config || loadConfig(process.cwd());
-    const rules = resolveRules(config.manifesto?.rules);
+    const rules = resolveRules(
+      config.manifesto?.rules as unknown as Record<string, Partial<ThresholdRule>>,
+    );
 
-    const violations = [];
-    const ruleResults = [];
+    const violations: Violation[] = [];
+    const ruleResults: RuleResult[] = [];
 
     evaluateFunctionRules(db, rules, opts, violations, ruleResults);
     evaluateFileRules(db, rules, opts, violations, ruleResults);

package/src/features/{owners.js → owners.ts}

@@ -8,16 +8,21 @@ import { isTestFile } from '../infrastructure/test-filter.js';
 
 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) {
+interface CodeownersRule {
+  pattern: string;
+  owners: string[];
+  regex: RegExp;
+}
+
+interface CodeownersCache {
+  rules: CodeownersRule[];
+  path: string;
+  mtime: number;
+}
+
+const codeownersCache = new Map<string, CodeownersCache>();
+
+export function parseCodeowners(rootDir: string): { rules: CodeownersRule[]; path: string } | null {
   const cached = codeownersCache.get(rootDir);
 
   for (const rel of CODEOWNERS_PATHS) {
@@ -37,24 +42,18 @@ export function parseCodeowners(rootDir) {
   return null;
 }
 
-/** Clear the parseCodeowners cache (for testing). */
-export function clearCodeownersCache() {
+export function clearCodeownersCache(): void {
   codeownersCache.clear();
 }
 
-/**
- * Parse CODEOWNERS file content into rules.
- * @param {string} content - Raw CODEOWNERS file content
- * @returns {Array<{pattern: string, owners: string[], regex: RegExp}>}
- */
-export function parseCodeownersContent(content) {
-  const rules = [];
+export function parseCodeownersContent(content: string): CodeownersRule[] {
+  const rules: CodeownersRule[] = [];
   for (const raw of content.split('\n')) {
     const line = raw.trim();
     if (!line || line.startsWith('#')) continue;
     const parts = line.split(/\s+/);
     if (parts.length < 2) continue;
-    const pattern = parts[0];
+    const pattern = parts[0]!;
     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) });
@@ -62,17 +61,7 @@ export function parseCodeownersContent(content) {
   return rules;
 }
 
-/**
- * Convert a CODEOWNERS glob pattern to a RegExp.
- *
- * CODEOWNERS semantics:
- * - Leading `/` anchors to repo root; without it, matches anywhere
- * - `*` matches anything except `/`
- * - `**` matches everything including `/`
- * - Trailing `/` matches directory contents
- * - A bare filename like `Makefile` matches anywhere
- */
-export function patternToRegex(pattern) {
+export function patternToRegex(pattern: string): RegExp {
   let p = pattern;
   const anchored = p.startsWith('/');
   if (anchored) p = p.slice(1);
@@ -112,14 +101,8 @@ export function patternToRegex(pattern) {
   return new RegExp(regex);
 }
 
-/**
- * Find the owners for a file path. CODEOWNERS uses last-match-wins semantics.
- * @param {string} filePath - Relative file path (forward slashes)
- * @param {Array<{pattern: string, owners: string[], regex: RegExp}>} rules
- * @returns {string[]}
- */
-export function matchOwners(filePath, rules) {
-  let owners = [];
+export function matchOwners(filePath: string, rules: CodeownersRule[]): string[] {
+  let owners: string[] = [];
   for (const rule of rules) {
     if (rule.regex.test(filePath)) {
       owners = rule.owners;
@@ -130,19 +113,15 @@ export function matchOwners(filePath, rules) {
 
 // ─── Data Functions ──────────────────────────────────────────────────
 
-/**
- * Lightweight helper for diff-impact integration.
- * Returns owner mapping for a list of file paths.
- * @param {string[]} filePaths - Relative file paths
- * @param {string} repoRoot - Repository root directory
- * @returns {{ owners: Map<string, string[]>, affectedOwners: string[], suggestedReviewers: string[] }}
- */
-export function ownersForFiles(filePaths, repoRoot) {
+export function ownersForFiles(
+  filePaths: string[],
+  repoRoot: string,
+): { owners: Map<string, string[]>; affectedOwners: string[]; suggestedReviewers: string[] } {
   const parsed = parseCodeowners(repoRoot);
   if (!parsed) return { owners: new Map(), affectedOwners: [], suggestedReviewers: [] };
 
-  const ownersMap = new Map();
-  const ownerSet = new Set();
+  const ownersMap = new Map<string, string[]>();
+  const ownerSet = new Set<string>();
   for (const file of filePaths) {
     const fileOwners = matchOwners(file, parsed.rules);
     ownersMap.set(file, fileOwners);
@@ -152,17 +131,35 @@ export function ownersForFiles(filePaths, repoRoot) {
   return { owners: ownersMap, affectedOwners, suggestedReviewers: affectedOwners };
 }
 
-/**
- * Full ownership data for the graph.
- * @param {string} [customDbPath]
- * @param {object} [opts]
- * @param {string} [opts.owner] - Filter to a specific owner
- * @param {string} [opts.file] - Filter by partial file path
- * @param {string} [opts.kind] - Filter by symbol kind
- * @param {boolean} [opts.noTests] - Exclude test files
- * @param {boolean} [opts.boundary] - Show cross-owner boundary edges
- */
-export function ownersData(customDbPath, opts = {}) {
+interface OwnersDataOpts {
+  owner?: string;
+  file?: string;
+  kind?: string;
+  noTests?: boolean;
+  boundary?: boolean;
+}
+
+export function ownersData(
+  customDbPath?: string,
+  opts: OwnersDataOpts = {},
+): {
+  codeownersFile: string | null;
+  files: { file: string; owners: string[] }[];
+  symbols: { name: string; kind: string; file: string; line: number; owners: string[] }[];
+  boundaries: {
+    from: { name: string; kind: string; file: string; line: number; owners: string[] };
+    to: { name: string; kind: string; file: string; line: number; owners: string[] };
+    edgeKind: string;
+  }[];
+  summary: {
+    totalFiles: number;
+    ownedFiles: number;
+    unownedFiles: number;
+    coveragePercent: number;
+    ownerCount: number;
+    byOwner: { owner: string; fileCount: number }[];
+  };
+} {
   const db = openReadonlyOrFail(customDbPath);
   try {
     const dbPath = findDbPath(customDbPath);
@@ -187,10 +184,9 @@ export function ownersData(customDbPath, opts = {}) {
     }
 
     // Get all distinct files from nodes
-    let allFiles = db
-      .prepare('SELECT DISTINCT file FROM nodes')
-      .all()
-      .map((r) => r.file);
+    let allFiles = (db.prepare('SELECT DISTINCT file FROM nodes').all() as { file: string }[]).map(
+      (r) => r.file,
+    );
 
     if (opts.noTests) allFiles = allFiles.filter((f) => !isTestFile(f));
     const fileFilters = normalizeFileFilter(opts.file);
@@ -205,28 +201,32 @@ export function ownersData(customDbPath, opts = {}) {
     }));
 
     // Build owner-to-files index
-    const ownerIndex = new Map();
+    const ownerIndex = new Map<string, string[]>();
     let ownedCount = 0;
     for (const fo of fileOwners) {
       if (fo.owners.length > 0) ownedCount++;
       for (const o of fo.owners) {
         if (!ownerIndex.has(o)) ownerIndex.set(o, []);
-        ownerIndex.get(o).push(fo.file);
+        ownerIndex.get(o)!.push(fo.file);
       }
     }
 
     // Filter files if --owner specified
     let filteredFiles = fileOwners;
     if (opts.owner) {
-      filteredFiles = fileOwners.filter((fo) => fo.owners.includes(opts.owner));
+      filteredFiles = fileOwners.filter((fo) => fo.owners.includes(opts.owner!));
     }
 
     // Get symbols for filtered files
     const fileSet = new Set(filteredFiles.map((fo) => fo.file));
-    let symbols = db
-      .prepare('SELECT name, kind, file, line FROM nodes')
-      .all()
-      .filter((n) => fileSet.has(n.file));
+    let symbols = (
+      db.prepare('SELECT name, kind, file, line FROM nodes').all() as {
+        name: string;
+        kind: string;
+        file: string;
+        line: number;
+      }[]
+    ).filter((n) => fileSet.has(n.file));
 
     if (opts.noTests) symbols = symbols.filter((s) => !isTestFile(s.file));
     if (opts.kind) symbols = symbols.filter((s) => s.kind === opts.kind);
@@ -237,7 +237,11 @@ export function ownersData(customDbPath, opts = {}) {
     }));
 
     // Boundary analysis — cross-owner call edges
-    const boundaries = [];
+    const boundaries: {
+      from: { name: string; kind: string; file: string; line: number; owners: string[] };
+      to: { name: string; kind: string; file: string; line: number; owners: string[] };
+      edgeKind: string;
+    }[] = [];
     if (opts.boundary) {
       const edges = db
         .prepare(
@@ -249,7 +253,18 @@ export function ownersData(customDbPath, opts = {}) {
            JOIN nodes t ON e.target_id = t.id
            WHERE e.kind = 'calls'`,
         )
-        .all();
+        .all() as {
+        id: number;
+        edgeKind: string;
+        srcName: string;
+        srcKind: string;
+        srcFile: string;
+        srcLine: number;
+        tgtName: string;
+        tgtKind: string;
+        tgtFile: string;
+        tgtLine: number;
+      }[];
 
       for (const e of edges) {
         if (opts.noTests && (isTestFile(e.srcFile) || isTestFile(e.tgtFile))) continue;