@monoes/monograph 1.5.6 → 1.5.7

package/src/analysis/targets.ts

@@ -1,237 +0,0 @@
-import type { MonographDb } from '../storage/db.js';
-
-export type RecommendationCategory =
-  | 'UrgentChurnComplexity'
-  | 'BreakCircularDependency'
-  | 'SplitHighImpact'
-  | 'RemoveDeadCode'
-  | 'ExtractComplexFunctions'
-  | 'ExtractDependencies'
-  | 'AddTestCoverage';
-
-export type EffortEstimate = 'Low' | 'Medium' | 'High';
-export type TargetConfidence = 'High' | 'Medium' | 'Low';
-
-export interface RefactoringTarget {
-  nodeId: string;
-  filePath: string;
-  priorityScore: number;     // 0-100
-  efficiency: number;        // priorityScore / effortWeight
-  category: RecommendationCategory;
-  effort: EffortEstimate;
-  confidence: TargetConfidence;
-  evidence: string[];        // human-readable reasons: 'fan-in: 47', 'unreachable', etc.
-}
-
-export interface RefactoringTargetsResult {
-  targets: RefactoringTarget[];
-  totalAnalyzed: number;
-}
-
-interface FileNodeRow {
-  id: string;
-  file_path: string;
-  properties: string | null;
-  reachability_role: string | null;
-  in_degree: number;
-  out_degree: number;
-}
-
-export function computeRefactoringTargets(db: MonographDb): RefactoringTargetsResult {
-  // Query all File nodes with degree counts and properties
-  const rows = db.prepare(`
-    SELECT
-      n.id,
-      n.file_path,
-      n.properties,
-      COALESCE(d_in.cnt, 0) as in_degree,
-      COALESCE(d_out.cnt, 0) as out_degree
-    FROM nodes n
-    LEFT JOIN (SELECT target_id, COUNT(*) AS cnt FROM edges GROUP BY target_id) d_in ON d_in.target_id = n.id
-    LEFT JOIN (SELECT source_id, COUNT(*) AS cnt FROM edges GROUP BY source_id) d_out ON d_out.source_id = n.id
-    WHERE n.label = 'File' AND n.file_path IS NOT NULL
-  `).all() as FileNodeRow[];
-
-  if (rows.length === 0) {
-    return { targets: [], totalAnalyzed: 0 };
-  }
-
-  // Compute fan-ins for percentile calculation
-  const fanIns = rows.map(r => r.in_degree).sort((a, b) => a - b);
-  const p95Index = Math.floor(fanIns.length * 0.95);
-  const p95FanIn = fanIns[p95Index] ?? fanIns[fanIns.length - 1] ?? 1;
-
-  const maxInDegree  = rows.reduce((m, r) => r.in_degree  > m ? r.in_degree  : m, 1);
-  const maxOutDegree = rows.reduce((m, r) => r.out_degree > m ? r.out_degree : m, 1);
-
-  const targets: RefactoringTarget[] = [];
-
-  for (const row of rows) {
-    const props = row.properties ? JSON.parse(row.properties) : {};
-    const reachabilityRole: string = props.reachabilityRole ?? '';
-    const churnScore: number = typeof props.churnScore === 'number' ? props.churnScore : 0;
-
-    // Component scores
-    const density = p95FanIn > 0 ? row.in_degree / p95FanIn : 1.0;
-    const hotspot_boost = Math.min(1.0, churnScore);
-    const dead_code = reachabilityRole === 'unreachable' ? 1.0 : 0;
-    const fan_in_norm = row.in_degree / maxInDegree;
-    const fan_out_norm = row.out_degree / maxOutDegree;
-
-    // Priority formula
-    const priorityScore = Math.min(100,
-      density * 30 +
-      hotspot_boost * 25 +
-      dead_code * 20 +
-      fan_in_norm * 15 +
-      fan_out_norm * 10
-    );
-
-    // Evidence strings
-    const evidence: string[] = [];
-    if (dead_code === 1.0) evidence.push('unreachable');
-    if (density > 0.8) evidence.push(`fan-in: ${row.in_degree} (p95)`);
-    if (hotspot_boost > 0.5) evidence.push(`churn score: ${churnScore.toFixed(2)}`);
-    if (fan_in_norm > 0.7) evidence.push(`fan-in: ${row.in_degree} (high)`);
-    if (fan_out_norm > 0.8) evidence.push(`fan-out: ${row.out_degree} (high)`);
-
-    // Category selection
-    let category: RecommendationCategory;
-    if (dead_code === 1.0) {
-      category = 'RemoveDeadCode';
-    } else if (density > 0.8 && hotspot_boost > 0.5) {
-      category = 'UrgentChurnComplexity';
-    } else if (fan_in_norm > 0.7) {
-      category = 'SplitHighImpact';
-    } else if (fan_out_norm > 0.8) {
-      category = 'ExtractDependencies';
-    } else {
-      category = 'ExtractComplexFunctions';
-    }
-
-    // Count factors above threshold for confidence
-    let factorCount = 0;
-    if (dead_code === 1.0) factorCount++;
-    if (density > 0.8) factorCount++;
-    if (hotspot_boost > 0.5) factorCount++;
-    if (fan_in_norm > 0.7) factorCount++;
-    if (fan_out_norm > 0.8) factorCount++;
-
-    const confidence: TargetConfidence = factorCount > 2 ? 'High' : factorCount === 2 ? 'Medium' : 'Low';
-
-    // Effort
-    let effort: EffortEstimate;
-    let effortWeight: number;
-    if (priorityScore < 33) {
-      effort = 'Low';
-      effortWeight = 1;
-    } else if (priorityScore < 66) {
-      effort = 'Medium';
-      effortWeight = 2;
-    } else {
-      effort = 'High';
-      effortWeight = 3;
-    }
-
-    const efficiency = effortWeight > 0 ? priorityScore / effortWeight : priorityScore;
-
-    targets.push({
-      nodeId: row.id,
-      filePath: row.file_path,
-      priorityScore,
-      efficiency,
-      category,
-      effort,
-      confidence,
-      evidence,
-    });
-  }
-
-  // Sort by efficiency descending, return top 50
-  const sorted = targets
-    .sort((a, b) => b.efficiency - a.efficiency)
-    .slice(0, 50);
-
-  return {
-    targets: sorted,
-    totalAnalyzed: rows.length,
-  };
-}
-
-// ── Round 8: priority scoring + evidence types ─────────────────────────────
-
-export interface ContributingFactor {
-  metric: string;          // e.g. 'fanIn', 'cyclomaticComplexity'
-  value: number;
-  threshold: number;
-  detail: string;
-}
-
-export interface EvidenceFunction {
-  name: string;
-  startLine: number;
-  cognitiveComplexity: number;
-}
-
-export interface TargetEvidence {
-  unusedExportsCount: number;
-  complexFunctions: EvidenceFunction[];
-  cyclePath: string[];       // for circular-dep evidence
-  contributingFactors: ContributingFactor[];
-}
-
-export interface PriorityRule {
-  name: string;
-  description: string;
-  weight: number;
-  /** Returns a 0-1 score contribution or null if the rule doesn't apply. */
-  evaluate: (factors: Record<string, number>) => number | null;
-}
-
-export const PRIORITY_RULE_WEIGHTS = {
-  densityWeight: 30,
-  hotspotWeight: 25,
-  deadCodeWeight: 20,
-  fanInWeight: 15,
-  fanOutWeight: 10,
-} as const;
-
-/** Normalize a raw metric value against a threshold to a 0-1 score. */
-export function normalizeMetric(value: number, threshold: number): number {
-  if (threshold <= 0) return 0;
-  return Math.min(value / threshold, 1);
-}
-
-/** Compute a 0-100 composite priority score for a refactoring target. */
-export function computeTargetPriority(factors: {
-  densityScore: number;     // 0-1 already normalized
-  hotspotScore: number;     // 0-1
-  deadCodeScore: number;    // 0-1
-  fanInRaw: number;
-  fanOutRaw: number;
-  fanInThreshold: number;
-  fanOutThreshold: number;
-}): number {
-  const { densityWeight, hotspotWeight, deadCodeWeight, fanInWeight, fanOutWeight } = PRIORITY_RULE_WEIGHTS;
-  const fanIn  = normalizeMetric(factors.fanInRaw,  factors.fanInThreshold);
-  const fanOut = normalizeMetric(factors.fanOutRaw, factors.fanOutThreshold);
-  return Math.min(100, Math.round(
-    factors.densityScore * densityWeight +
-    factors.hotspotScore * hotspotWeight +
-    factors.deadCodeScore * deadCodeWeight +
-    fanIn  * fanInWeight +
-    fanOut * fanOutWeight,
-  ));
-}
-
-/** Apply named priority rules in priority order, returning the first match's score or null. */
-export function tryMatchPriorityRules(
-  rules: PriorityRule[],
-  factors: Record<string, number>,
-): { rule: PriorityRule; score: number } | null {
-  for (const rule of [...rules].sort((a, b) => b.weight - a.weight)) {
-    const score = rule.evaluate(factors);
-    if (score !== null) return { rule, score };
-  }
-  return null;
-}

package/src/analysis/unused-class-members.ts

@@ -1,79 +0,0 @@
-// Detect unused class methods and properties (distinct from enum members).
-
-export type MemberKind = 'method' | 'property' | 'getter' | 'setter' | 'staticMethod' | 'staticProperty';
-
-export interface UnusedMember {
-  filePath: string;
-  parentName: string;
-  memberName: string;
-  kind: MemberKind;
-  line: number;
-  col: number;
-}
-
-export interface UnusedMembersResult {
-  unusedMembers: UnusedMember[];
-  totalScanned: number;
-  filesAffected: number;
-}
-
-export interface ClassMemberAllowlistEntry {
-  pattern: string;
-  classExtends?: string[];
-  classImplements?: string[];
-}
-
-export function isClassMemberSuppressed(
-  member: UnusedMember,
-  allowlist: ClassMemberAllowlistEntry[],
-  classHeritage: { extends: string[]; implements: string[] },
-): boolean {
-  for (const entry of allowlist) {
-    const nameMatch = member.memberName === entry.pattern || memberGlobMatch(member.memberName, entry.pattern);
-    if (!nameMatch) continue;
-    const extMatch = !entry.classExtends?.length || entry.classExtends.some(e => classHeritage.extends.includes(e));
-    const implMatch = !entry.classImplements?.length || entry.classImplements.some(i => classHeritage.implements.includes(i));
-    if (extMatch && implMatch) return true;
-  }
-  return false;
-}
-
-// Cache compiled glob regexes to avoid re-compilation on repeated allowlist checks
-const _globReCache = new Map<string, RegExp>();
-
-function memberGlobMatch(name: string, pattern: string): boolean {
-  if (!pattern.includes('*')) return name === pattern;
-  let re = _globReCache.get(pattern);
-  if (!re) {
-    re = new RegExp('^' + pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*') + '$');
-    _globReCache.set(pattern, re);
-  }
-  return re.test(name);
-}
-
-export function summarizeUnusedMembers(members: UnusedMember[]): UnusedMembersResult {
-  const files = new Set(members.map(m => m.filePath));
-  return {
-    unusedMembers: members,
-    totalScanned: members.length,
-    filesAffected: files.size,
-  };
-}
-
-export function groupUnusedMembersByFile(members: UnusedMember[]): Map<string, UnusedMember[]> {
-  const map = new Map<string, UnusedMember[]>();
-  for (const m of members) {
-    if (!map.has(m.filePath)) map.set(m.filePath, []);
-    map.get(m.filePath)!.push(m);
-  }
-  return map;
-}
-
-export function formatUnusedMembersReport(result: UnusedMembersResult): string {
-  if (result.unusedMembers.length === 0) return 'No unused class members found.';
-  const lines = [`${result.unusedMembers.length} unused class member(s) in ${result.filesAffected} file(s):`];
-  for (const m of result.unusedMembers) {
-    lines.push(`  ${m.filePath}:${m.line} — ${m.parentName}.${m.memberName} (${m.kind})`);
-  }
-  return lines.join('\n');
-}

package/src/analysis/workspace-filter.ts

@@ -1,89 +0,0 @@
-export interface SubsetFilter {
-  roots: string[];
-  test(filePath: string): boolean;
-}
-
-export function createSubsetFilter(roots: string[]): SubsetFilter {
-  // Normalize roots to ensure they end with '/'
-  const normalizedRoots = roots.map((root) => (root.endsWith('/') ? root : root + '/'));
-
-  return {
-    roots: normalizedRoots,
-    test(filePath: string): boolean {
-      return normalizedRoots.some((root) => filePath.startsWith(root));
-    },
-  };
-}
-
-export function filterToWorkspaces<T extends { filePath?: string | null }>(
-  items: T[],
-  workspaceRoots: string[],
-): T[] {
-  const filter = createSubsetFilter(workspaceRoots);
-  return items.filter((item) => item.filePath != null && filter.test(item.filePath));
-}
-
-// ── Round 8: gitignore-style negation patterns + changed-file scoping ──────
-
-export interface WorkspaceFilterPattern {
-  pattern: string;
-  negated: boolean;   // true if pattern starts with '!'
-  isGlob: boolean;
-}
-
-/** Parse a workspace filter string into a structured pattern. */
-export function parseWorkspaceFilterPattern(raw: string): WorkspaceFilterPattern {
-  const negated = raw.startsWith('!');
-  const pattern = negated ? raw.slice(1) : raw;
-  const isGlob = pattern.includes('*') || pattern.includes('?');
-  return { pattern, negated, isGlob };
-}
-
-/** Match a workspace name against a gitignore-style pattern (supports ! negation and globs). */
-export function matchWorkspacePattern(name: string, pattern: WorkspaceFilterPattern): boolean {
-  if (pattern.isGlob) {
-    const re = new RegExp('^' + pattern.pattern.replace(/\*/g, '.*').replace(/\?/g, '.') + '$');
-    return re.test(name);
-  }
-  return name === pattern.pattern;
-}
-
-/** Resolve a list of workspace names against a list of filter patterns with negation. */
-export function resolveWorkspaceFilters(
-  names: string[],
-  patterns: string[],
-): string[] {
-  if (patterns.length === 0) return names;
-  const parsed = patterns.map(parseWorkspaceFilterPattern);
-  return names.filter(name => {
-    let included = false;
-    for (const p of parsed) {
-      if (matchWorkspacePattern(name, p)) {
-        included = !p.negated;
-      }
-    }
-    return included;
-  });
-}
-
-/** Format available workspace names for display, capping at 10 with overflow count. */
-export function formatAvailableWorkspaces(names: string[]): string {
-  const MAX = 10;
-  if (names.length <= MAX) return names.join(', ');
-  return `${names.slice(0, MAX).join(', ')} ... and ${names.length - MAX} more (${names.length} total)`;
-}
-
-/** Map a set of changed file paths to workspace indices that contain at least one changed file. */
-export function workspacesContainingAny(
-  changedFiles: string[],
-  workspaceRoots: string[],
-): number[] {
-  const indices: number[] = [];
-  for (let i = 0; i < workspaceRoots.length; i++) {
-    const root = workspaceRoots[i].replace(/\\/g, '/').replace(/\/$/, '');
-    if (changedFiles.some(f => f.replace(/\\/g, '/').startsWith(root + '/'))) {
-      indices.push(i);
-    }
-  }
-  return indices;
-}

package/src/analyze/boundary-analysis.ts

@@ -1,129 +0,0 @@
-import type { ResolvedBoundaryConfig } from '../config/boundary-config.js';
-import { classifyZone, isImportAllowed } from '../config/boundary-config.js';
-import type { ModuleNode } from '../graph/node-types.js';
-import { ModuleNodeFlags } from '../graph/node-types.js';
-import type { FallowBoundaryViolation } from '../results/fallow-results.js';
-
-export interface BoundaryAnalysisResult {
-  violations: FallowBoundaryViolation[];
-  checkedEdges: number;
-  uncheckedFiles: number;
-}
-
-function isReachableOrEntry(mod: ModuleNode): boolean {
-  return (
-    (mod.flags & ModuleNodeFlags.REACHABLE) !== 0 ||
-    (mod.flags & ModuleNodeFlags.ENTRY_POINT) !== 0
-  );
-}
-
-function hasRules(config: ResolvedBoundaryConfig, zoneName: string): boolean {
-  return config.rules.some(r => r.from.name === zoneName);
-}
-
-export function findBoundaryViolations(
-  modules: ModuleNode[],
-  config: ResolvedBoundaryConfig,
-): FallowBoundaryViolation[] {
-  if (config.zones.length === 0) return [];
-
-  const zoneCache = new Map<string, string | undefined>();
-
-  const classify = (filePath: string): string | undefined => {
-    if (zoneCache.has(filePath)) return zoneCache.get(filePath);
-    const zone = classifyZone(config, filePath);
-    zoneCache.set(filePath, zone);
-    return zone;
-  };
-
-  const filePathByPath = new Map<string, ModuleNode>(modules.map(m => [m.filePath, m]));
-
-  const violations: FallowBoundaryViolation[] = [];
-
-  for (const mod of modules) {
-    if (!isReachableOrEntry(mod)) continue;
-
-    const fromZone = classify(mod.filePath);
-    if (!fromZone) continue;
-
-    if (!hasRules(config, fromZone)) continue;
-
-    for (const edge of mod.reExports) {
-      const toPath = edge.toFile;
-      const toZone = classify(toPath);
-      if (!toZone) continue;
-      if (fromZone === toZone) continue;
-
-      if (!isImportAllowed(config, mod.filePath, toPath)) {
-        violations.push({
-          fromPath: mod.filePath,
-          toPath,
-          fromZone,
-          toZone,
-          importSpecifier: toPath,
-          line: 1,
-          col: 0,
-        });
-      }
-    }
-  }
-
-  return violations;
-}
-
-export function analyzeBoundaries(
-  modules: ModuleNode[],
-  config: ResolvedBoundaryConfig,
-): BoundaryAnalysisResult {
-  if (config.zones.length === 0) {
-    return { violations: [], checkedEdges: 0, uncheckedFiles: 0 };
-  }
-
-  const zoneCache = new Map<string, string | undefined>();
-
-  const classify = (filePath: string): string | undefined => {
-    if (zoneCache.has(filePath)) return zoneCache.get(filePath);
-    const zone = classifyZone(config, filePath);
-    zoneCache.set(filePath, zone);
-    return zone;
-  };
-
-  const violations: FallowBoundaryViolation[] = [];
-  let checkedEdges = 0;
-  let uncheckedFiles = 0;
-
-  for (const mod of modules) {
-    if (!isReachableOrEntry(mod)) continue;
-
-    const fromZone = classify(mod.filePath);
-    if (!fromZone) {
-      uncheckedFiles++;
-      continue;
-    }
-
-    if (!hasRules(config, fromZone)) continue;
-
-    for (const edge of mod.reExports) {
-      const toPath = edge.toFile;
-      checkedEdges++;
-
-      const toZone = classify(toPath);
-      if (!toZone) continue;
-      if (fromZone === toZone) continue;
-
-      if (!isImportAllowed(config, mod.filePath, toPath)) {
-        violations.push({
-          fromPath: mod.filePath,
-          toPath,
-          fromZone,
-          toZone,
-          importSpecifier: toPath,
-          line: 1,
-          col: 0,
-        });
-      }
-    }
-  }
-
-  return { violations, checkedEdges, uncheckedFiles };
-}

package/src/analyze/predicates/file.ts

@@ -1,86 +0,0 @@
-import path from "node:path";
-
-export function isDeclarationFile(filePath: string): boolean {
-  const name = path.basename(filePath);
-  return name.endsWith(".d.ts") || name.endsWith(".d.mts") || name.endsWith(".d.cts");
-}
-
-export function isHtmlFile(filePath: string): boolean {
-  return path.extname(filePath) === ".html";
-}
-
-export function isConfigFile(filePath: string): boolean {
-  const name = path.basename(filePath);
-
-  if (name.startsWith(".") && !name.startsWith("..")) {
-    const lower = name.toLowerCase();
-    if (lower.includes("rc.")) {
-      return true;
-    }
-  }
-
-  const configPatterns = [
-    "babel.config.",
-    "rollup.config.",
-    "webpack.config.",
-    "postcss.config.",
-    "stencil.config.",
-    "metro.config.",
-    "tsup.config.",
-    "unbuild.config.",
-    "esbuild.config.",
-    "swc.config.",
-    "turbo.",
-    "jest.config.",
-    "jest.setup.",
-    "vitest.config.",
-    "vitest.ci.config.",
-    "vitest.setup.",
-    "vitest.workspace.",
-    "playwright.config.",
-    "cypress.config.",
-    "karma.conf.",
-    "eslint.config.",
-    "prettier.config.",
-    "stylelint.config.",
-    "lint-staged.config.",
-    "commitlint.config.",
-    "next.config.",
-    "next-sitemap.config.",
-    "nuxt.config.",
-    "astro.config.",
-    "sanity.config.",
-    "vite.config.",
-    "tailwind.config.",
-    "drizzle.config.",
-    "knexfile.",
-    "sentry.client.config.",
-    "sentry.server.config.",
-    "sentry.edge.config.",
-    "react-router.config.",
-    "typedoc.",
-    "knip.config.",
-    "fallow.config.",
-    "i18next-parser.config.",
-    "codegen.config.",
-    "graphql.config.",
-    "npmpackagejsonlint.config.",
-    "release-it.",
-    "release.config.",
-    "contentlayer.config.",
-    "next-env.d.",
-    "env.d.",
-    "vite-env.d.",
-  ];
-
-  return configPatterns.some((p) => name.startsWith(p));
-}
-
-export function isTestFile(filePath: string): boolean {
-  return (
-    filePath.includes("/__tests__/") ||
-    filePath.includes("/.test.") ||
-    filePath.includes(".test.") ||
-    filePath.includes(".spec.")
-  );
-}