@monoes/monograph 1.5.6 → 1.5.8

package/src/analyze/predicates/import.ts

@@ -1,90 +0,0 @@
-export const BUILTIN_MODULES: Set<string> = new Set([
-  "assert",
-  "assert/strict",
-  "async_hooks",
-  "buffer",
-  "child_process",
-  "cluster",
-  "console",
-  "constants",
-  "crypto",
-  "dgram",
-  "diagnostics_channel",
-  "dns",
-  "dns/promises",
-  "domain",
-  "events",
-  "fs",
-  "fs/promises",
-  "http",
-  "http2",
-  "https",
-  "inspector",
-  "inspector/promises",
-  "module",
-  "net",
-  "os",
-  "path",
-  "path/posix",
-  "path/win32",
-  "perf_hooks",
-  "process",
-  "punycode",
-  "querystring",
-  "readline",
-  "readline/promises",
-  "repl",
-  "stream",
-  "stream/consumers",
-  "stream/promises",
-  "stream/web",
-  "string_decoder",
-  "sys",
-  "test",
-  "test/reporters",
-  "timers",
-  "timers/promises",
-  "tls",
-  "trace_events",
-  "tty",
-  "url",
-  "util",
-  "util/types",
-  "v8",
-  "vm",
-  "wasi",
-  "worker_threads",
-  "zlib",
-]);
-
-export function isVirtualModule(specifier: string): boolean {
-  return specifier.startsWith("virtual:");
-}
-
-export function isBuiltinModule(specifier: string): boolean {
-  if (specifier.startsWith("bun:")) return true;
-  if (specifier.startsWith("cloudflare:")) return true;
-  if (specifier.startsWith("sass:")) return true;
-  if (specifier === "std" || specifier.startsWith("std/")) return true;
-
-  const stripped = specifier.startsWith("node:") ? specifier.slice(5) : specifier;
-  return BUILTIN_MODULES.has(stripped);
-}
-
-export function isImplicitDependency(specifier: string): boolean {
-  if (specifier.startsWith("@types/")) return true;
-
-  const implicitDeps = new Set([
-    "react-dom",
-    "react-dom/client",
-    "react-native",
-    "@next/font",
-    "@next/mdx",
-    "@next/bundle-analyzer",
-    "@next/env",
-    "utf-8-validate",
-    "bufferutil",
-  ]);
-
-  return implicitDeps.has(specifier);
-}

package/src/analyze/predicates/lifecycle.ts

@@ -1,55 +0,0 @@
-export const ANGULAR_LIFECYCLE_METHODS: Set<string> = new Set([
-  "ngOnInit",
-  "ngOnDestroy",
-  "ngOnChanges",
-  "ngDoCheck",
-  "ngAfterContentInit",
-  "ngAfterContentChecked",
-  "ngAfterViewInit",
-  "ngAfterViewChecked",
-  "ngAcceptInputType",
-  "canActivate",
-  "canDeactivate",
-  "canActivateChild",
-  "canMatch",
-  "resolve",
-  "intercept",
-  "transform",
-  "validate",
-  "registerOnChange",
-  "registerOnTouched",
-  "writeValue",
-  "setDisabledState",
-]);
-
-export const REACT_LIFECYCLE_METHODS: Set<string> = new Set([
-  "render",
-  "componentDidMount",
-  "componentDidUpdate",
-  "componentWillUnmount",
-  "shouldComponentUpdate",
-  "getSnapshotBeforeUpdate",
-  "getDerivedStateFromProps",
-  "getDerivedStateFromError",
-  "componentDidCatch",
-  "componentWillMount",
-  "componentWillReceiveProps",
-  "componentWillUpdate",
-  "UNSAFE_componentWillMount",
-  "UNSAFE_componentWillReceiveProps",
-  "UNSAFE_componentWillUpdate",
-  "getChildContext",
-  "contextType",
-]);
-
-export function isAngularLifecycleMethod(name: string): boolean {
-  return ANGULAR_LIFECYCLE_METHODS.has(name);
-}
-
-export function isReactLifecycleMethod(name: string): boolean {
-  return REACT_LIFECYCLE_METHODS.has(name);
-}
-
-export function isFrameworkLifecycleMethod(name: string): boolean {
-  return isAngularLifecycleMethod(name) || isReactLifecycleMethod(name);
-}

package/src/analyze/unused-deps.ts

@@ -1,70 +0,0 @@
-export type DepCategory =
-  | "dependencies"
-  | "devDependencies"
-  | "optionalDependencies"
-  | "peerDependencies";
-
-export interface UnusedDepResult {
-  name: string;
-  category: DepCategory;
-  reason: string;
-}
-
-export interface UnresolvedImportResult {
-  specifier: string;
-  filePath: string;
-}
-
-export interface DepCategoryConfig {
-  skipDev?: boolean;
-  skipOptional?: boolean;
-  skipPeer?: boolean;
-}
-
-export function findUnusedDependencies(
-  usedPackages: Set<string>,
-  declaredDeps: Record<DepCategory, string[]>,
-  config: DepCategoryConfig = {}
-): UnusedDepResult[] {
-  const results: UnusedDepResult[] = [];
-
-  const categories: Array<{ key: DepCategory; skip?: boolean }> = [
-    { key: "dependencies" },
-    { key: "devDependencies", skip: config.skipDev },
-    { key: "optionalDependencies", skip: config.skipOptional },
-    { key: "peerDependencies", skip: config.skipPeer },
-  ];
-
-  for (const { key, skip } of categories) {
-    if (skip) continue;
-    const deps = declaredDeps[key] ?? [];
-    for (const dep of deps) {
-      if (!usedPackages.has(dep)) {
-        results.push({
-          name: dep,
-          category: key,
-          reason: `declared in ${key} but never imported`,
-        });
-      }
-    }
-  }
-
-  return results;
-}
-
-export function findUnresolvedImports(
-  importSpecifiers: Array<{ specifier: string; filePath: string }>,
-  resolvedPackages: Set<string>
-): UnresolvedImportResult[] {
-  return importSpecifiers.filter(({ specifier }) => !resolvedPackages.has(specifier));
-}
-
-export function findTypeOnlyDependencies(
-  usedInProduction: Set<string>,
-  usedInTypes: Set<string>,
-  deps: string[]
-): string[] {
-  return deps.filter(
-    (dep) => !usedInProduction.has(dep) && usedInTypes.has(dep)
-  );
-}

package/src/analyze/unused-exports.ts

@@ -1,145 +0,0 @@
-import type { ModuleNode, ExportSymbol } from '../graph/node-types.js';
-import { isEntryPoint, ModuleNodeFlags } from '../graph/node-types.js';
-import type { FallowUnusedExport, FallowDuplicateExport, FallowDuplicateLocation } from '../results/fallow-results.js';
-
-export interface UnusedExportsOptions {
-  isEntryPoint?: (path: string) => boolean;
-  ignorePaths?: string[];
-  includeTypeOnlyExports?: boolean;
-  maxDuplicates?: number;
-}
-
-function matchesIgnorePath(filePath: string, patterns: string[]): boolean {
-  for (const pattern of patterns) {
-    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*');
-    if (new RegExp(escaped).test(filePath)) return true;
-  }
-  return false;
-}
-
-function buildReferencedNamesMap(modules: ModuleNode[]): Map<string, Set<string>> {
-  const referencedByFile = new Map<string, Set<string>>();
-
-  for (const mod of modules) {
-    for (const ref of mod.references) {
-      const target = ref.fromFile;
-      if (!referencedByFile.has(target)) {
-        referencedByFile.set(target, new Set());
-      }
-      referencedByFile.get(target)!.add(ref.name);
-    }
-  }
-
-  return referencedByFile;
-}
-
-function buildReExportedNamesMap(modules: ModuleNode[]): Map<string, Set<string>> {
-  const reExportedByFile = new Map<string, Set<string>>();
-
-  for (const mod of modules) {
-    for (const edge of mod.reExports) {
-      if (!reExportedByFile.has(edge.fromFile)) {
-        reExportedByFile.set(edge.fromFile, new Set());
-      }
-      if (edge.symbol) {
-        reExportedByFile.get(edge.fromFile)!.add(edge.symbol);
-      }
-    }
-  }
-
-  return reExportedByFile;
-}
-
-function isModuleEntryPoint(mod: ModuleNode, opts: UnusedExportsOptions): boolean {
-  if (opts.isEntryPoint && opts.isEntryPoint(mod.filePath)) return true;
-  return isEntryPoint(mod);
-}
-
-function hasCjsExports(mod: ModuleNode): boolean {
-  return (mod.flags & ModuleNodeFlags.CJS_EXPORTS) !== 0;
-}
-
-export function findUnusedExports(
-  modules: ModuleNode[],
-  opts: UnusedExportsOptions = {},
-): FallowUnusedExport[] {
-  const {
-    ignorePaths = [],
-    includeTypeOnlyExports = true,
-  } = opts;
-
-  const referencedByFile = buildReferencedNamesMap(modules);
-  const reExportedNames = buildReExportedNamesMap(modules);
-
-  const reachableFileIds = new Set(
-    modules
-      .filter(m => (m.flags & ModuleNodeFlags.REACHABLE) !== 0)
-      .map(m => m.filePath),
-  );
-
-  const results: FallowUnusedExport[] = [];
-
-  for (const mod of modules) {
-    if (isModuleEntryPoint(mod, opts)) continue;
-    if (ignorePaths.length > 0 && matchesIgnorePath(mod.filePath, ignorePaths)) continue;
-    if (hasCjsExports(mod) && mod.exports.length === 0) continue;
-
-    const reachable = reachableFileIds.has(mod.filePath);
-    const referenced = referencedByFile.get(mod.filePath) ?? new Set<string>();
-    const reExportedHere = reExportedNames.get(mod.filePath) ?? new Set<string>();
-
-    for (const exp of mod.exports) {
-      if (!includeTypeOnlyExports && exp.isType) continue;
-
-      const isReferenced = referenced.has(exp.name);
-      if (isReferenced) continue;
-
-      const isReExport = exp.isReExport || reExportedHere.has(exp.name);
-
-      if (!reachable && !isReExport) continue;
-
-      const line = exp.line ?? 1;
-
-      results.push({
-        filePath: mod.filePath,
-        line,
-        col: 0,
-        exportName: exp.name,
-        spanStart: 0,
-        isReExport,
-        isTypeOnly: exp.isType,
-      });
-    }
-  }
-
-  return results;
-}
-
-export function findDuplicateExports(
-  modules: ModuleNode[],
-): Array<{ name: string; files: Array<{ filePath: string; line: number; col: number }> }> {
-  const byName = new Map<string, Array<{ filePath: string; line: number; col: number }>>();
-
-  for (const mod of modules) {
-    for (const exp of mod.exports) {
-      if (!byName.has(exp.name)) {
-        byName.set(exp.name, []);
-      }
-      byName.get(exp.name)!.push({
-        filePath: mod.filePath,
-        line: exp.line ?? 1,
-        col: 0,
-      });
-    }
-  }
-
-  const results: Array<{ name: string; files: Array<{ filePath: string; line: number; col: number }> }> = [];
-
-  for (const [name, files] of byName) {
-    if (files.length > 1) {
-      results.push({ name, files });
-    }
-  }
-
-  return results;
-}

package/src/analyze/unused-files.ts

@@ -1,46 +0,0 @@
-import { isDeclarationFile, isConfigFile, isHtmlFile } from "./predicates/file.js";
-
-export interface UnusedFileResult {
-  filePath: string;
-  reason: string;
-}
-
-export interface FindUnusedFilesOptions {
-  skipDeclarations?: boolean;
-  skipConfig?: boolean;
-  skipHtml?: boolean;
-}
-
-export function findUnusedFiles(
-  allFiles: string[],
-  reachableFiles: Set<string>,
-  opts: FindUnusedFilesOptions = {}
-): UnusedFileResult[] {
-  const { skipDeclarations = true, skipConfig = true, skipHtml = true } = opts;
-
-  return allFiles
-    .filter((filePath) => !reachableFiles.has(filePath))
-    .filter((filePath) => {
-      if (skipDeclarations && isDeclarationFile(filePath)) return false;
-      if (skipConfig && isConfigFile(filePath)) return false;
-      if (skipHtml && isHtmlFile(filePath)) return false;
-      return true;
-    })
-    .map((filePath) => ({
-      filePath,
-      reason: "not reachable from any entry point",
-    }));
-}
-
-export function hasReachableImporter(
-  filePath: string,
-  importers: Map<string, Set<string>>,
-  reachable: Set<string>
-): boolean {
-  const fileImporters = importers.get(filePath);
-  if (!fileImporters) return false;
-  for (const importer of fileImporters) {
-    if (reachable.has(importer)) return true;
-  }
-  return false;
-}

package/src/api/production-override.ts

@@ -1,63 +0,0 @@
-// Per-analysis production mode override — allows library consumers to set
-// production=true/false independently of the config file.
-
-export type ProductionOverride = boolean | 'config';
-
-export interface ProductionModeConfig {
-  deadCode: boolean;
-  health: boolean;
-  duplication: boolean;
-  complexity: boolean;
-}
-
-export const DEFAULT_PRODUCTION_MODE: ProductionModeConfig = {
-  deadCode: false,
-  health: false,
-  duplication: false,
-  complexity: false,
-};
-
-/** Resolve the effective production mode for a specific analysis kind. */
-export function resolveProductionMode(
-  override: ProductionOverride | undefined,
-  configuredMode: boolean,
-): boolean {
-  if (override === undefined || override === 'config') return configuredMode;
-  return override;
-}
-
-/** Resolve production mode for all analysis kinds from a per-analysis override map. */
-export function resolveAllProductionModes(
-  overrides: Partial<Record<keyof ProductionModeConfig, ProductionOverride>>,
-  configured: ProductionModeConfig,
-): ProductionModeConfig {
-  return {
-    deadCode:    resolveProductionMode(overrides.deadCode,    configured.deadCode),
-    health:      resolveProductionMode(overrides.health,      configured.health),
-    duplication: resolveProductionMode(overrides.duplication, configured.duplication),
-    complexity:  resolveProductionMode(overrides.complexity,  configured.complexity),
-  };
-}
-
-export interface BaselineAuditMeta {
-  savedAt: string;
-  gitSha?: string;
-  productionMode: boolean;
-}
-
-/** Build baseline audit metadata for storage alongside a saved baseline. */
-export function buildBaselineAuditMeta(
-  productionMode: boolean,
-  gitSha?: string,
-): BaselineAuditMeta {
-  return {
-    savedAt: new Date().toISOString(),
-    gitSha,
-    productionMode,
-  };
-}
-
-/** Human-readable production mode label for CLI output. */
-export function productionModeLabel(mode: boolean): string {
-  return mode ? 'production (conservative, entry-point-aware)' : 'development (all-exports visible)';
-}

package/src/api/programmatic.ts

@@ -1,118 +0,0 @@
-// Stable one-shot entry points for embedding monograph as a library.
-
-export type DuplicationMode = 'default' | 'aggressive' | 'lenient';
-export type ComplexitySort = 'score' | 'loc' | 'name';
-export type OwnershipEmailMode = 'full' | 'domain' | 'name';
-export type TargetEffort = 'quick' | 'standard' | 'deep';
-
-export interface AnalysisOptions {
-  root: string;
-  configPath?: string;
-  threads?: number;
-  productionOverride?: boolean;
-  workspaceFilter?: string[];
-  changedSince?: string;
-}
-
-export interface DeadCodeFilters {
-  includeUnusedExports?: boolean;
-  includeUnusedTypes?: boolean;
-  includeUnusedEnums?: boolean;
-  includeUnusedClasses?: boolean;
-  includeUnusedFunctions?: boolean;
-  includeDeadFiles?: boolean;
-  includeCircularDeps?: boolean;
-}
-
-export interface DeadCodeOptions extends AnalysisOptions {
-  filters?: DeadCodeFilters;
-  limit?: number;
-}
-
-export interface DuplicationOptions extends AnalysisOptions {
-  mode?: DuplicationMode;
-  minLines?: number;
-  minTokens?: number;
-}
-
-export interface ComplexityOptions extends AnalysisOptions {
-  sort?: ComplexitySort;
-  limit?: number;
-  minComplexity?: number;
-}
-
-export interface ProgrammaticError {
-  code: string;
-  message: string;
-  help?: string;
-  context?: Record<string, unknown>;
-  exitCode: number;
-}
-
-export function isProgrammaticError(v: unknown): v is ProgrammaticError {
-  return typeof v === 'object' && v !== null && 'code' in v && 'exitCode' in v;
-}
-
-export function makeProgrammaticError(
-  code: string,
-  message: string,
-  exitCode = 1,
-  extras?: Partial<ProgrammaticError>,
-): ProgrammaticError {
-  return { code, message, exitCode, ...extras };
-}
-
-/** Validate AnalysisOptions — throws ProgrammaticError if invalid. */
-export function validateAnalysisOptions(opts: AnalysisOptions): void {
-  if (!opts.root) throw makeProgrammaticError('MISSING_ROOT', 'root directory is required', 2);
-  if (opts.threads !== undefined && (opts.threads < 1 || opts.threads > 64)) {
-    throw makeProgrammaticError('INVALID_THREADS', 'threads must be between 1 and 64', 2);
-  }
-}
-
-/** Serialize a ProgrammaticError to a JSON-lines compatible envelope. */
-export function programmaticErrorToJson(err: ProgrammaticError): string {
-  return JSON.stringify({
-    status: 'error',
-    code: err.code,
-    message: err.message,
-    help: err.help,
-    context: err.context,
-    exitCode: err.exitCode,
-  });
-}
-
-// ── Round 9: programmatic execution function stubs ────────────────────────────
-// These return structured JSON strings matching the CLI JSON reporter output.
-
-export interface ProgrammaticRunOptions {
-  root: string;
-  tsconfig?: string;
-  entry?: string | string[];
-  production?: boolean;
-  reporter?: 'json' | 'compact';
-}
-
-export async function detectDeadCodeProgrammatic(opts: ProgrammaticRunOptions): Promise<string> {
-  return JSON.stringify({ kind: 'dead-code', root: opts.root, results: [], message: 'Run via CLI: npx monograph analyze' });
-}
-
-export async function detectCircularDependenciesProgrammatic(opts: ProgrammaticRunOptions): Promise<string> {
-  return JSON.stringify({ kind: 'cycles', root: opts.root, results: [], message: 'Run via CLI: npx monograph analyze --cycles' });
-}
-
-export async function detectBoundaryViolationsProgrammatic(opts: ProgrammaticRunOptions): Promise<string> {
-  return JSON.stringify({ kind: 'boundaries', root: opts.root, results: [], message: 'Run via CLI: npx monograph check-boundaries' });
-}
-
-export async function detectDuplicationProgrammatic(opts: ProgrammaticRunOptions): Promise<string> {
-  return JSON.stringify({ kind: 'duplication', root: opts.root, results: [], message: 'Run via CLI: npx monograph find-dupes' });
-}
-
-export async function computeComplexityProgrammatic(opts: ProgrammaticRunOptions): Promise<string> {
-  return JSON.stringify({ kind: 'complexity', root: opts.root, results: [], message: 'Run via CLI: npx monograph health' });
-}
-
-export async function computeHealthProgrammatic(opts: ProgrammaticRunOptions): Promise<string> {
-  return JSON.stringify({ kind: 'health', root: opts.root, results: [], message: 'Run via CLI: npx monograph health --reporter json' });
-}