@alimaandev/ripple 0.1.0

package/dist/bin.js

@@ -0,0 +1,1829 @@
+#!/usr/bin/env node
+import { CommanderError, Command } from 'commander';
+import { createJiti } from 'jiti';
+import path8 from 'path';
+import fs from 'fs/promises';
+import fs2 from 'fs';
+import { Project, ts, SyntaxKind } from 'ts-morph';
+import { z } from 'zod';
+import ora from 'ora';
+import treeify from 'treeify';
+import chalk from 'chalk';
+import fg from 'fast-glob';
+
+// src/output/writer.ts
+var TerminalWriter = class {
+  constructor(stream = process.stdout) {
+    this.stream = stream;
+  }
+  stream;
+  write(text) {
+    this.stream.write(text);
+  }
+  writeLine(text = "") {
+    this.stream.write(`${text}
+`);
+  }
+};
+
+// src/types/cli.ts
+var ExitCode = {
+  Success: 0,
+  Failure: 1,
+  NotFound: 2,
+  InvalidConfig: 3
+};
+async function pathExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function pathExistsSync(filePath) {
+  try {
+    fs2.accessSync(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readFileSafe(filePath) {
+  try {
+    return await fs.readFile(filePath, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+async function findPackageJson(startDir) {
+  let current = path8.resolve(startDir);
+  for (; ; ) {
+    const candidate = path8.join(current, "package.json");
+    if (await pathExists(candidate)) return candidate;
+    const parent = path8.dirname(current);
+    if (parent === current) return void 0;
+    current = parent;
+  }
+}
+async function readPackageEntryPoints(packageJsonPath) {
+  const raw = await readFileSafe(packageJsonPath);
+  if (!raw) return [];
+  try {
+    const manifest = JSON.parse(raw);
+    const entries = [];
+    if (typeof manifest.main === "string") entries.push(manifest.main);
+    if (typeof manifest.bin === "string") entries.push(manifest.bin);
+    if (manifest.bin && typeof manifest.bin === "object")
+      entries.push(...Object.values(manifest.bin));
+    return entries;
+  } catch {
+    return [];
+  }
+}
+
+// src/utils/errors.ts
+var RippleError = class extends Error {
+  exitCode;
+  hint;
+  constructor(message, exitCode2 = ExitCode.Failure, hint) {
+    super(message);
+    this.name = "RippleError";
+    this.exitCode = exitCode2;
+    this.hint = hint;
+  }
+};
+function fileNotFound(filePath) {
+  return new RippleError(
+    `File not found: ${filePath}`,
+    ExitCode.NotFound,
+    "Run `ripple graph` to list the files Ripple can analyze."
+  );
+}
+function asStringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function readTsconfig(tsconfigPath) {
+  if (!pathExistsSync(tsconfigPath)) return void 0;
+  const readResult = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
+  if (readResult.error) return void 0;
+  const dir = path8.dirname(tsconfigPath);
+  const parsed = ts.parseJsonConfigFileContent(
+    readResult.config,
+    ts.sys,
+    dir,
+    void 0,
+    tsconfigPath
+  );
+  if (parsed.errors.length > 0) return void 0;
+  const options = parsed.options;
+  const paths = {};
+  if (options.paths) {
+    for (const [pattern, targets] of Object.entries(options.paths)) {
+      paths[pattern] = [...targets];
+    }
+  }
+  return {
+    path: tsconfigPath,
+    dir,
+    baseUrl: options.baseUrl ? path8.resolve(dir, options.baseUrl) : void 0,
+    paths,
+    include: asStringArray(readResult.config.include ?? []),
+    exclude: asStringArray(readResult.config.exclude ?? [])
+  };
+}
+var WILDCARD = "*";
+function hasWildcard(value) {
+  return value.includes(WILDCARD);
+}
+function normalizeEntry(key, target, baseDir) {
+  const trimmedKey = key.replace(/\/+$/, "");
+  const trimmedTarget = target.replace(/\/+$/, "");
+  if (hasWildcard(trimmedKey)) {
+    return { pattern: trimmedKey, target: path8.resolve(baseDir, trimmedTarget) };
+  }
+  return {
+    pattern: `${trimmedKey}/${WILDCARD}`,
+    target: path8.join(path8.resolve(baseDir, trimmedTarget), WILDCARD)
+  };
+}
+function buildAliasMap(configAliases, tsconfig, rootDir) {
+  const merged = {};
+  if (tsconfig) {
+    const base = tsconfig.baseUrl ?? tsconfig.dir;
+    for (const [pattern, targets] of Object.entries(tsconfig.paths)) {
+      const first = targets[0];
+      if (!first) continue;
+      const absolute = path8.isAbsolute(first) ? first : path8.resolve(base, first);
+      merged[pattern] = absolute;
+    }
+  }
+  for (const [key, target] of Object.entries(configAliases)) {
+    if (key === "") continue;
+    const entry = normalizeEntry(key, target, rootDir);
+    merged[entry.pattern] = entry.target;
+  }
+  return merged;
+}
+function substituteAlias(specifier, aliases) {
+  for (const [pattern, target] of Object.entries(aliases)) {
+    const starIndex = pattern.indexOf(WILDCARD);
+    if (starIndex === -1) {
+      if (specifier === pattern) return target;
+      continue;
+    }
+    const prefix = pattern.slice(0, starIndex);
+    const suffix = pattern.slice(starIndex + 1);
+    if (!specifier.startsWith(prefix) || !specifier.endsWith(suffix)) continue;
+    const captured = specifier.slice(prefix.length, specifier.length - suffix.length);
+    const targetStar = target.indexOf(WILDCARD);
+    if (targetStar === -1) return target;
+    return target.slice(0, targetStar) + captured + target.slice(targetStar + 1);
+  }
+  return void 0;
+}
+
+// src/config/defaults.ts
+var DEFAULT_CONFIG = {
+  include: ["**/*.{ts,tsx,js,jsx}"],
+  ignore: ["node_modules", "dist", "build", "coverage", ".next", "out", ".git"],
+  aliases: {},
+  tsconfigPath: "tsconfig.json",
+  risk: {
+    weights: {
+      affectedFiles: 0.3,
+      entryPoint: 0.15,
+      sharedUtility: 0.15,
+      publicExports: 0.1,
+      tests: 0.1,
+      routes: 0.1,
+      cycleMembership: 0.1
+    },
+    thresholds: {
+      medium: 30,
+      high: 55,
+      critical: 80
+    }
+  }
+};
+
+// src/config/schema.ts
+var fraction = z.number().min(0).max(1);
+var score = z.number().min(0).max(100);
+var riskWeightsSchema = z.object({
+  affectedFiles: fraction.default(DEFAULT_CONFIG.risk.weights.affectedFiles),
+  entryPoint: fraction.default(DEFAULT_CONFIG.risk.weights.entryPoint),
+  sharedUtility: fraction.default(DEFAULT_CONFIG.risk.weights.sharedUtility),
+  publicExports: fraction.default(DEFAULT_CONFIG.risk.weights.publicExports),
+  tests: fraction.default(DEFAULT_CONFIG.risk.weights.tests),
+  routes: fraction.default(DEFAULT_CONFIG.risk.weights.routes),
+  cycleMembership: fraction.default(DEFAULT_CONFIG.risk.weights.cycleMembership)
+}).strict();
+var riskThresholdsSchema = z.object({
+  medium: score.default(DEFAULT_CONFIG.risk.thresholds.medium),
+  high: score.default(DEFAULT_CONFIG.risk.thresholds.high),
+  critical: score.default(DEFAULT_CONFIG.risk.thresholds.critical)
+}).strict();
+var riskConfigSchema = z.object({
+  weights: riskWeightsSchema.default(DEFAULT_CONFIG.risk.weights),
+  thresholds: riskThresholdsSchema.default(DEFAULT_CONFIG.risk.thresholds)
+}).strict();
+var rippleConfigSchema = z.object({
+  include: z.array(z.string().min(1)).min(1).default(DEFAULT_CONFIG.include),
+  ignore: z.array(z.string()).default(DEFAULT_CONFIG.ignore),
+  aliases: z.record(z.string(), z.string()).default(DEFAULT_CONFIG.aliases),
+  tsconfigPath: z.string().min(1).default(DEFAULT_CONFIG.tsconfigPath),
+  risk: riskConfigSchema.default(DEFAULT_CONFIG.risk)
+}).strict();
+function formatSchemaIssues(error) {
+  return error.issues.map((issue) => {
+    const path12 = issue.path.join(".");
+    const location = path12 === "" ? "config" : `config.${path12}`;
+    return `${location}: ${issue.message}`;
+  });
+}
+
+// src/config/loader.ts
+var CONFIG_CANDIDATES = [
+  "ripple.config.ts",
+  "ripple.config.mjs",
+  "ripple.config.js",
+  "ripple.config.cjs",
+  "ripple.config.json"
+];
+var jiti = createJiti(import.meta.url, { interopDefault: true });
+function findConfigFile(cwd, explicitPath) {
+  if (explicitPath) return path8.resolve(cwd, explicitPath);
+  for (const candidate of CONFIG_CANDIDATES) {
+    const absolute = path8.join(cwd, candidate);
+    if (pathExistsSync(absolute)) return absolute;
+  }
+  return void 0;
+}
+async function importConfig(configPath) {
+  let loaded;
+  try {
+    loaded = await jiti.import(configPath);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new RippleError(
+      `Could not load ${path8.basename(configPath)}: ${detail}`,
+      ExitCode.InvalidConfig
+    );
+  }
+  const value = loaded?.default ?? loaded;
+  if (typeof value === "function") {
+    throw new RippleError(
+      `${path8.basename(configPath)} must export a plain object, not a function.`,
+      ExitCode.InvalidConfig
+    );
+  }
+  return value;
+}
+function validateConfig(value) {
+  const result = rippleConfigSchema.safeParse(value);
+  if (!result.success) {
+    const issues = formatSchemaIssues(result.error);
+    throw new RippleError(
+      `Invalid config:
+${issues.map((issue) => `  ${issue}`).join("\n")}`,
+      ExitCode.InvalidConfig
+    );
+  }
+  return result.data;
+}
+async function loadConfig(cwd, explicitPath) {
+  const configPath = findConfigFile(cwd, explicitPath);
+  if (explicitPath && !configPath) {
+    throw new RippleError(
+      `Config file not found: ${explicitPath}`,
+      ExitCode.InvalidConfig,
+      "Pass a path that exists, or remove --config to use defaults."
+    );
+  }
+  if (!configPath) {
+    return { config: rippleConfigSchema.parse({}), rootDir: path8.resolve(cwd) };
+  }
+  const raw = await importConfig(configPath);
+  const config = validateConfig(raw);
+  return { config, configPath, rootDir: path8.dirname(configPath) };
+}
+async function loadProjectContext(cwd, explicitConfigPath) {
+  const loaded = await loadConfig(cwd, explicitConfigPath);
+  const { config, rootDir } = loaded;
+  const tsconfigPath = path8.resolve(rootDir, config.tsconfigPath);
+  const tsconfig = readTsconfig(tsconfigPath);
+  const aliases = buildAliasMap(config.aliases, tsconfig, rootDir);
+  return {
+    rootDir,
+    config,
+    ...tsconfig ? { tsconfig } : {},
+    aliases
+  };
+}
+
+// src/types/graph.ts
+function cycleMemberPaths(graph) {
+  const members = /* @__PURE__ */ new Set();
+  for (const cycle of graph.cycles) {
+    for (const path12 of cycle.members) {
+      members.add(path12);
+    }
+  }
+  return members;
+}
+
+// src/analyzer/confidence.ts
+function computeConfidence(stats, targetInCycle) {
+  const parseRate = stats.files === 0 ? 1 : stats.parsed / stats.files;
+  const totalEdges = stats.internalEdges + stats.unresolvedEdges;
+  const resolutionRate = totalEdges === 0 ? 1 : stats.internalEdges / totalEdges;
+  let confidence = parseRate * (0.4 + 0.6 * resolutionRate);
+  if (targetInCycle) confidence *= 0.95;
+  return Math.round(Math.min(1, Math.max(0, confidence)) * 100);
+}
+var SOURCE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx"];
+var RESOLVABLE_EXTENSIONS = [...SOURCE_EXTENSIONS, ".mjs", ".cjs", ".d.ts"];
+function toPosix(filePath) {
+  return filePath.replace(/\\/g, "/");
+}
+function normalizeAbsolute(filePath, cwd) {
+  return path8.resolve(cwd, filePath);
+}
+function pathKey(filePath, cwd) {
+  const absolute = normalizeAbsolute(filePath, cwd);
+  const posix = toPosix(absolute);
+  return process.platform === "win32" ? posix.toLowerCase() : posix;
+}
+function sourceFileKind(filePath) {
+  if (/\.d\.[cm]?ts$/i.test(filePath)) return void 0;
+  const ext = path8.extname(filePath).toLowerCase();
+  return SOURCE_EXTENSIONS.includes(ext) ? ext.slice(1) : void 0;
+}
+function extensionCandidates(basePath) {
+  return RESOLVABLE_EXTENSIONS.map((ext) => basePath + ext);
+}
+function jsToTsCandidate(candidate) {
+  const ext = path8.extname(candidate);
+  if (ext === ".js") return candidate.slice(0, -3) + ".ts";
+  if (ext === ".jsx") return candidate.slice(0, -4) + ".tsx";
+  if (ext === ".mjs") return candidate.slice(0, -4) + ".mts";
+  if (ext === ".cjs") return candidate.slice(0, -4) + ".cts";
+  return candidate;
+}
+function displayPath(filePath, cwd) {
+  const relative = path8.relative(cwd, filePath);
+  return toPosix(relative === "" ? path8.basename(filePath) : relative);
+}
+function firstSegment(filePath, root) {
+  const relative = toPosix(path8.relative(root, filePath));
+  if (relative.startsWith("..") || path8.isAbsolute(relative)) return void 0;
+  const segment = relative.split("/")[0];
+  return segment && segment !== "" ? segment : void 0;
+}
+
+// src/analyzer/categorize.ts
+var ROUTE_FILE_NAMES = /* @__PURE__ */ new Set([
+  "route",
+  "page",
+  "layout",
+  "middleware",
+  "loading",
+  "error",
+  "not-found"
+]);
+var ROUTE_DIR_NAMES = /* @__PURE__ */ new Set(["routes", "api"]);
+var UTILITY_DIR_NAMES = /* @__PURE__ */ new Set(["lib", "utils", "helpers", "shared", "common", "core"]);
+var COMPONENT_DIR_NAMES = /* @__PURE__ */ new Set(["components", "ui"]);
+var ENTRY_FILE_NAMES = /* @__PURE__ */ new Set(["index", "main", "app", "server", "cli", "bin"]);
+var TEST_SEGMENT = "__tests__";
+function relativeSegments(filePath, rootDir) {
+  const relative = toPosix(path8.relative(rootDir, filePath));
+  if (relative.startsWith("..")) return [];
+  return relative.split("/").filter((segment) => segment !== "" && segment !== ".");
+}
+function isRouteFile(basename) {
+  return ROUTE_FILE_NAMES.has(basename);
+}
+function isTestFile(name, segments) {
+  if (segments.includes(TEST_SEGMENT)) return true;
+  if (/(^|[._-])(test|spec)([._-]|$)/i.test(name)) return true;
+  return segments.some((segment) => segment === "tests");
+}
+function isComponentFile(basename, extension, segments) {
+  if (extension === "tsx" || extension === "jsx") return true;
+  if (!COMPONENT_DIR_NAMES.has(segments.at(-2) ?? "")) return false;
+  return /^[A-Z]/.test(basename);
+}
+function isUtilityFile(segments) {
+  return segments.some((segment) => UTILITY_DIR_NAMES.has(segment));
+}
+function isEntryFile(filePath, rootDir, entryPoints) {
+  if (entryPoints.has(path8.normalize(filePath))) return true;
+  const relative = toPosix(path8.relative(rootDir, filePath));
+  if (relative.startsWith("..")) return false;
+  const segments = relative.split("/");
+  if (segments.length !== 2) return false;
+  if (segments[0] !== "src" && segments[0] !== "") return false;
+  const basename = segments[1] ?? "";
+  const dot = basename.lastIndexOf(".");
+  const name = dot === -1 ? basename : basename.slice(0, dot);
+  return ENTRY_FILE_NAMES.has(name);
+}
+function createCategorizer(options) {
+  const { rootDir, entryPoints } = options;
+  return (filePath) => {
+    const segments = relativeSegments(filePath, rootDir);
+    const basename = segments.at(-1) ?? "";
+    const dot = basename.lastIndexOf(".");
+    const name = dot === -1 ? basename : basename.slice(0, dot);
+    const extension = dot === -1 ? "" : basename.slice(dot + 1).toLowerCase();
+    const categories = [];
+    if (isRouteFile(name)) categories.push("route");
+    else if (segments.some((segment) => ROUTE_DIR_NAMES.has(segment))) categories.push("route");
+    if (isTestFile(name, segments)) categories.push("test");
+    if (isComponentFile(name, extension, segments)) categories.push("component");
+    if (isUtilityFile(segments)) categories.push("utility");
+    if (isEntryFile(filePath, rootDir, entryPoints)) categories.push("entry");
+    if (categories.length === 0) categories.push("other");
+    return categories;
+  };
+}
+async function detectEntryPoints(rootDir) {
+  const entryPoints = /* @__PURE__ */ new Set();
+  const packageJsonPath = await findPackageJson(rootDir);
+  if (packageJsonPath) {
+    const packageDir = path8.dirname(packageJsonPath);
+    for (const entry of await readPackageEntryPoints(packageJsonPath)) {
+      const absolute = path8.resolve(packageDir, entry);
+      if (pathExistsSync(absolute)) entryPoints.add(path8.normalize(absolute));
+    }
+  }
+  const baseDirs = [rootDir, path8.join(rootDir, "src")];
+  for (const baseDir of baseDirs) {
+    for (const name of ENTRY_FILE_NAMES) {
+      for (const extension of ["ts", "tsx", "js", "jsx"]) {
+        const candidate = path8.join(baseDir, `${name}.${extension}`);
+        if (pathExistsSync(candidate)) entryPoints.add(path8.normalize(candidate));
+      }
+    }
+  }
+  return entryPoints;
+}
+
+// src/analyzer/humanize.ts
+var ACRONYM_CANONICAL = {
+  api: "API",
+  ui: "UI",
+  ux: "UX",
+  oauth: "OAuth",
+  jwt: "JWT",
+  http: "HTTP",
+  https: "HTTPS",
+  ws: "WS",
+  sse: "SSE",
+  db: "DB",
+  sql: "SQL",
+  id: "ID",
+  cli: "CLI",
+  ci: "CI",
+  cd: "CD",
+  csv: "CSV",
+  json: "JSON",
+  pdf: "PDF",
+  cors: "CORS",
+  url: "URL",
+  uri: "URI",
+  uuid: "UUID",
+  html: "HTML",
+  css: "CSS",
+  js: "JS",
+  ts: "TS",
+  tsx: "TSX",
+  jsx: "JSX",
+  aws: "AWS",
+  s3: "S3",
+  sms: "SMS",
+  mfa: "MFA",
+  otp: "OTP",
+  smtp: "SMTP",
+  rss: "RSS"
+};
+function splitWords(segment) {
+  const normalized = segment.replace(/[^a-zA-Z0-9]+/g, " ");
+  const matches = normalized.match(/[A-Z]+(?=[A-Z][a-z])|[A-Z]?[a-z]+|[A-Z]+|[0-9]+/g);
+  return (matches ?? [segment]).map((word) => word.toLowerCase());
+}
+function capitalize(word) {
+  return word.charAt(0).toUpperCase() + word.slice(1);
+}
+function humanizeArea(segment) {
+  const words = splitWords(segment);
+  if (words.length === 0) return capitalize(segment);
+  return words.map((word) => ACRONYM_CANONICAL[word] ?? capitalize(word)).join(" ");
+}
+
+// src/analyzer/impact.ts
+var MAX_IMPACT_AREAS = 5;
+function buildSummary(affected, srcRoot, confidence) {
+  let routes = 0;
+  let tests = 0;
+  let components = 0;
+  let utilities = 0;
+  let entries = 0;
+  let maxDepth = 0;
+  const areaCounts = /* @__PURE__ */ new Map();
+  for (const file of affected.values()) {
+    if (file.depth > maxDepth) maxDepth = file.depth;
+    if (file.categories.includes("route")) routes++;
+    if (file.categories.includes("test")) tests++;
+    if (file.categories.includes("component")) components++;
+    if (file.categories.includes("utility")) utilities++;
+    if (file.categories.includes("entry")) entries++;
+    const area = firstSegment(file.path, srcRoot);
+    if (area) {
+      areaCounts.set(area, (areaCounts.get(area) ?? 0) + 1);
+    }
+  }
+  const topImpact = [...areaCounts.entries()].map(([label, count]) => ({ label: humanizeArea(label), count })).sort((a, b) => b.count - a.count || a.label.localeCompare(b.label)).slice(0, MAX_IMPACT_AREAS);
+  return {
+    affectedFiles: affected.size,
+    routes,
+    tests,
+    components,
+    utilities,
+    entries,
+    maxDepth,
+    topImpact,
+    confidence
+  };
+}
+
+// src/analyzer/reverse-traverse.ts
+function reverseTraverse(graph, targetKey, options) {
+  const { maxDepth, categorize } = options;
+  const affected = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set([targetKey]);
+  const cycleMembers = cycleMemberPaths(graph);
+  if (!graph.reverse.has(targetKey)) {
+    return { affected, maxDepth: 0 };
+  }
+  const queue = [];
+  for (const importer of graph.reverse.get(targetKey) ?? []) {
+    queue.push({ key: importer, depth: 1 });
+  }
+  let deepest = 0;
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (current === void 0) break;
+    if (visited.has(current.key)) continue;
+    visited.add(current.key);
+    deepest = Math.max(deepest, current.depth);
+    const node = graph.nodes.get(current.key);
+    const filePath = node?.path ?? current.key;
+    affected.set(current.key, {
+      path: filePath,
+      depth: current.depth,
+      direct: current.depth === 1,
+      categories: categorize(filePath),
+      inCycle: cycleMembers.has(current.key)
+    });
+    if (maxDepth === void 0 || current.depth < maxDepth) {
+      for (const importer of graph.reverse.get(current.key) ?? []) {
+        if (!visited.has(importer)) {
+          queue.push({ key: importer, depth: current.depth + 1 });
+        }
+      }
+    }
+  }
+  return { affected, maxDepth: deepest };
+}
+
+// src/risk/levels.ts
+function scoreToLevel(score2, thresholds) {
+  if (score2 >= thresholds.critical) return "CRITICAL";
+  if (score2 >= thresholds.high) return "HIGH";
+  if (score2 >= thresholds.medium) return "MEDIUM";
+  return "LOW";
+}
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function logScale(count, cap) {
+  if (count <= 0) return 0;
+  return clamp(Math.log10(count + 1) / Math.log10(cap + 1), 0, 1);
+}
+
+// src/risk/score.ts
+var CAP_AFFECTED_FILES = 100;
+var CAP_UTILITIES = 10;
+var CAP_TESTS = 15;
+var CAP_ROUTES = 10;
+var CAP_EXPORTS = 20;
+var FACTORS = [
+  {
+    name: "affectedFiles",
+    label: "Affected files",
+    defaultWeight: 0.3,
+    compute: ({ summary }) => logScale(summary.affectedFiles, CAP_AFFECTED_FILES)
+  },
+  {
+    name: "entryPoint",
+    label: "Entry point impacted",
+    defaultWeight: 0.15,
+    compute: ({ summary }) => summary.entries > 0 ? 1 : 0
+  },
+  {
+    name: "sharedUtility",
+    label: "Shared utilities impacted",
+    defaultWeight: 0.15,
+    compute: ({ summary }) => clamp(summary.utilities / CAP_UTILITIES, 0, 1)
+  },
+  {
+    name: "publicExports",
+    label: "Public export surface",
+    defaultWeight: 0.1,
+    compute: ({ targetParsed }) => {
+      const { exports } = targetParsed;
+      const count = exports.named.length + (exports.hasDefault ? 1 : 0) + exports.reExportedFrom.length;
+      return clamp(count / CAP_EXPORTS, 0, 1);
+    }
+  },
+  {
+    name: "tests",
+    label: "Tests affected",
+    defaultWeight: 0.1,
+    compute: ({ summary }) => clamp(summary.tests / CAP_TESTS, 0, 1)
+  },
+  {
+    name: "routes",
+    label: "Routes affected",
+    defaultWeight: 0.1,
+    compute: ({ summary }) => clamp(summary.routes / CAP_ROUTES, 0, 1)
+  },
+  {
+    name: "cycleMembership",
+    label: "Circular dependency",
+    defaultWeight: 0.1,
+    compute: ({ targetInCycle }) => targetInCycle ? 1 : 0
+  }
+];
+function weightFor(definition, input) {
+  const configured = input.riskConfig.weights[definition.name];
+  return configured ?? definition.defaultWeight;
+}
+function scoreRisk(input) {
+  const factors = FACTORS.map((definition) => {
+    const weight = weightFor(definition, input);
+    const value = definition.compute(input);
+    return {
+      name: definition.name,
+      label: definition.label,
+      weight,
+      value,
+      contribution: Math.round(weight * value * 100 * 100) / 100
+    };
+  });
+  const score2 = clamp(
+    Math.round(factors.reduce((sum, factor) => sum + factor.contribution, 0) * 100) / 100,
+    0,
+    100
+  );
+  return {
+    score: score2,
+    level: scoreToLevel(score2, input.riskConfig.thresholds),
+    factors
+  };
+}
+
+// src/analyzer/analyze.ts
+function sourceRoot(rootDir) {
+  const candidate = path8.join(rootDir, "src");
+  return pathExistsSync(candidate) ? candidate : rootDir;
+}
+function analyzeFile(input) {
+  const { graph, context, entryPoints, targetKey, targetPath, durationMs, maxDepth } = input;
+  const node = graph.nodes.get(targetKey);
+  if (!node) {
+    throw new Error(`Target file is not part of the graph: ${targetPath}`);
+  }
+  const categorize = createCategorizer({ rootDir: context.rootDir, entryPoints });
+  const { affected, maxDepth: reachedDepth } = reverseTraverse(graph, targetKey, {
+    maxDepth,
+    categorize
+  });
+  const targetInCycle = cycleMemberPaths(graph).has(targetKey);
+  const confidence = computeConfidence(graph.stats, targetInCycle);
+  const summary = buildSummary(affected, sourceRoot(context.rootDir), confidence);
+  const risk = scoreRisk({
+    summary,
+    targetParsed: node.parsed,
+    targetInCycle,
+    riskConfig: context.config.risk
+  });
+  return {
+    targetPath,
+    rootDir: context.rootDir,
+    graph,
+    affected,
+    summary,
+    risk,
+    targetInCycle,
+    durationMs,
+    maxDepth: reachedDepth
+  };
+}
+function createSpinner(enabled) {
+  if (!enabled || !process.stdout.isTTY) {
+    return { start: () => {
+    }, stop: () => {
+    } };
+  }
+  let instance;
+  return {
+    start(text) {
+      instance = ora(text).start();
+    },
+    stop() {
+      instance?.stop();
+      instance = void 0;
+    }
+  };
+}
+
+// src/formatter/table.ts
+function renderTable(columns, rows) {
+  const widths = columns.map((column, index) => {
+    const cells = [column.header, ...rows.map((row) => row[index] ?? "")];
+    return Math.max(...cells.map((cell) => cell.length));
+  });
+  const pad = (value, index) => {
+    const width = widths[index] ?? value.length;
+    return columns[index]?.align === "right" ? value.padStart(width) : value.padEnd(width);
+  };
+  const lines = [];
+  lines.push(columns.map((column, index) => pad(column.header, index)).join("  "));
+  for (const row of rows) {
+    lines.push(row.map((cell, index) => pad(cell, index)).join("  "));
+  }
+  return lines.join("\n");
+}
+function renderKeyValue(entries) {
+  const width = Math.max(...entries.map(([key]) => key.length));
+  return entries.map(([key, value]) => `${key.padEnd(width)}  ${value}`).join("\n");
+}
+function toTreeify(node) {
+  if (!node.children || node.children.length === 0) return "";
+  const branch = {};
+  for (const child of node.children) {
+    branch[child.label] = toTreeify(child);
+  }
+  return branch;
+}
+function renderTree(nodes) {
+  if (nodes.length === 0) return "";
+  const root = {};
+  for (const node of nodes) {
+    root[node.label] = toTreeify(node);
+  }
+  return treeify.asTree(root, false, false).trimEnd();
+}
+function banner(text, style) {
+  return style.color ? chalk.cyanBright.bold(text) : text;
+}
+function sectionTitle(text, style) {
+  return style.color ? chalk.bold.underline(text) : text;
+}
+function dim(text, style) {
+  return style.color ? chalk.dim(text) : text;
+}
+function strong(text, style) {
+  return style.color ? chalk.bold(text) : text;
+}
+var RISK_COLORS = {
+  LOW: (text) => chalk.green(text),
+  MEDIUM: (text) => chalk.yellow(text),
+  HIGH: (text) => chalk.magenta(text),
+  CRITICAL: (text) => chalk.red.bold(text)
+};
+function riskBadge(level, style) {
+  return style.color ? RISK_COLORS[level](level) : level;
+}
+function confidenceText(percent, style) {
+  const text = `${percent}%`;
+  if (!style.color) return text;
+  if (percent >= 90) return chalk.green(text);
+  if (percent >= 70) return chalk.yellow(text);
+  return chalk.red(text);
+}
+function formatDuration(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  return `${(ms / 1e3).toFixed(2)}s`;
+}
+function pluralize(count, noun, plural = `${noun}s`) {
+  return `${count} ${count === 1 ? noun : plural}`;
+}
+
+// src/output/report.ts
+var DEFAULT_LIST_LIMIT = 20;
+var textStyle = (options) => ({ color: options.color });
+function fileLabel(filePath, depth, inCycle, style) {
+  const relative = dim(filePath, style);
+  const depthSuffix = dim(`(depth ${depth})`, style);
+  const cycleSuffix = dim("(cycle)", style);
+  return `${relative} ${depthSuffix}${inCycle ? ` ${cycleSuffix}` : ""}`;
+}
+function buildAffectedTree(result, cwd, style) {
+  const { affected, graph } = result;
+  const sorted = [...affected.entries()].sort(
+    ([, a], [, b]) => a.depth - b.depth || a.path.localeCompare(b.path)
+  );
+  const nodesByKey = /* @__PURE__ */ new Map();
+  const depthByKey = /* @__PURE__ */ new Map();
+  for (const [key, file] of sorted) {
+    const node = { label: "", children: [] };
+    node.label = fileLabel(displayPath(file.path, cwd), file.depth, file.inCycle, style);
+    nodesByKey.set(key, node);
+    depthByKey.set(key, file.depth);
+  }
+  const roots = [];
+  for (const [key, file] of sorted) {
+    const node = nodesByKey.get(key);
+    if (!node) continue;
+    if (file.depth === 1) {
+      roots.push(node);
+      continue;
+    }
+    const importers = graph.reverse.get(key) ?? [];
+    const parents = [...importers].filter(
+      (candidate) => depthByKey.get(candidate) === file.depth - 1 && nodesByKey.has(candidate)
+    ).sort((a, b) => (depthByKey.get(a) ?? 0) - (depthByKey.get(b) ?? 0) || a.localeCompare(b));
+    const parent = parents[0] ? nodesByKey.get(parents[0]) : void 0;
+    if (parent) {
+      parent.children.push(node);
+    } else {
+      roots.push(node);
+    }
+  }
+  return roots;
+}
+function renderAnalyzeReport(result, options, writer) {
+  const style = textStyle(options);
+  const { summary, risk } = result;
+  const file = displayPath(result.targetPath, options.cwd);
+  writer.writeLine(banner("\u{1F30A} Ripple Analysis", style));
+  writer.writeLine();
+  writer.writeLine(
+    renderKeyValue([
+      ["File", file],
+      ["Risk", riskBadge(risk.level, style)],
+      ["Affected Files", pluralize(summary.affectedFiles, "file")],
+      ["Components", String(summary.components)],
+      ["API Routes", String(summary.routes)],
+      ["Tests", String(summary.tests)],
+      ["Utilities", String(summary.utilities)],
+      ["Max Depth", String(summary.maxDepth)],
+      ["Confidence", confidenceText(summary.confidence, style)],
+      ["Duration", dim(formatDuration(result.durationMs), style)]
+    ])
+  );
+  writer.writeLine();
+  writer.writeLine(sectionTitle("Top Impact", style));
+  for (const area of summary.topImpact) {
+    writer.writeLine(`\u2022 ${strong(area.label, style)} ${dim(`(${area.count})`, style)}`);
+  }
+  writer.writeLine();
+  writer.writeLine(sectionTitle("Circular Dependencies", style));
+  if (result.graph.cycles.length === 0) {
+    writer.writeLine(dim("none", style));
+  } else {
+    for (const cycle of result.graph.cycles) {
+      const chain = cycle.path.map((key) => {
+        const node = result.graph.nodes.get(key);
+        return displayPath(node?.path ?? key, options.cwd);
+      }).join(" \u2192 ");
+      writer.writeLine(`\u2B55 ${chain}`);
+    }
+  }
+  writer.writeLine();
+  if (summary.affectedFiles > 0) {
+    writer.writeLine(sectionTitle(`Affected Files (${summary.affectedFiles})`, style));
+    const tree = buildAffectedTree(result, options.cwd, style);
+    writer.writeLine(renderTree(tree));
+    const limit = options.listLimit ?? DEFAULT_LIST_LIMIT;
+    if (summary.affectedFiles > limit) {
+      writer.writeLine(
+        dim(`${summary.affectedFiles - limit} more\u2026 use --json for the full list`, style)
+      );
+    }
+    writer.writeLine();
+  }
+  if (options.verbose) {
+    writer.writeLine(sectionTitle("Risk Factors", style));
+    const columns = [
+      { header: "Factor" },
+      { header: "Weight" },
+      { header: "Signal" },
+      { header: "Points" }
+    ];
+    const rows = risk.factors.map((factor) => [
+      factor.label,
+      factor.weight.toFixed(2),
+      factor.value.toFixed(2),
+      factor.contribution.toFixed(2)
+    ]);
+    writer.writeLine(renderTable(columns, rows));
+    writer.writeLine();
+  }
+}
+function buildAnalyzeJsonReport(result, version, cwd) {
+  const realPath = (key) => result.graph.nodes.get(key)?.path ?? key;
+  const affected = [...result.affected.values()].sort((a, b) => a.depth - b.depth || a.path.localeCompare(b.path)).map((file) => ({ ...file, path: displayPath(file.path, cwd) }));
+  return {
+    tool: "ripple",
+    version,
+    command: "analyze",
+    file: displayPath(result.targetPath, cwd),
+    risk: result.risk,
+    summary: result.summary,
+    affected,
+    cycles: result.graph.cycles.map((cycle) => ({
+      members: cycle.members.map((key) => displayPath(realPath(key), cwd)),
+      path: cycle.path.map((key) => displayPath(realPath(key), cwd))
+    })),
+    targetInCycle: result.targetInCycle,
+    durationMs: result.durationMs
+  };
+}
+function renderGraphReport(input, options, writer) {
+  const style = textStyle(options);
+  const { stats } = input;
+  writer.writeLine(banner("\u{1F30A} Dependency Graph", style));
+  writer.writeLine();
+  writer.writeLine(
+    renderKeyValue([
+      ["Files", String(stats.files)],
+      ["Edges", String(stats.internalEdges)],
+      ["External", String(stats.externalEdges)],
+      ["Unresolved", String(stats.unresolvedEdges)],
+      ["Circular groups", String(stats.cycles)]
+    ])
+  );
+  writer.writeLine();
+  if (input.forward) {
+    writer.writeLine(sectionTitle("Dependants (forward)", style));
+    writer.writeLine(renderTree(input.forward.map((path12) => ({ label: path12 }))));
+    writer.writeLine();
+  }
+  if (input.reverse) {
+    writer.writeLine(sectionTitle("Dependents (reverse)", style));
+    writer.writeLine(renderTree(input.reverse.map((path12) => ({ label: path12 }))));
+    writer.writeLine();
+  }
+  if (input.cycles.length > 0) {
+    writer.writeLine(sectionTitle("Circular Dependencies", style));
+    for (const cycle of input.cycles) {
+      const chain = cycle.path.map((key) => {
+        const node = input.nodes.get(key);
+        return displayPath(node?.path ?? key, input.cwd);
+      }).join(" \u2192 ");
+      writer.writeLine(`\u2B55 ${chain}`);
+    }
+  } else {
+    writer.writeLine(dim("No circular dependencies found.", style));
+  }
+}
+function buildGraphJsonReport(input, version) {
+  const realPath = (key) => input.nodes.get(key)?.path ?? key;
+  return {
+    tool: "ripple",
+    version,
+    command: "graph",
+    fileCount: input.stats.files,
+    edgeCount: input.stats.internalEdges,
+    externalEdgeCount: input.stats.externalEdges,
+    cycles: input.cycles.map((cycle) => ({
+      members: cycle.members.map((key) => displayPath(realPath(key), input.cwd)),
+      path: cycle.path.map((key) => displayPath(realPath(key), input.cwd))
+    })),
+    ...input.forward ? { forward: input.forward } : {},
+    ...input.reverse ? { reverse: input.reverse } : {}
+  };
+}
+
+// src/formatter/json.ts
+function serializeJson(report) {
+  return `${JSON.stringify(report, null, 2)}
+`;
+}
+function createTsProject() {
+  return new Project({
+    skipAddingFilesFromTsConfig: true,
+    compilerOptions: {
+      allowJs: true,
+      checkJs: false,
+      jsx: ts.JsxEmit.Preserve,
+      noEmit: true,
+      target: ts.ScriptTarget.ESNext
+    }
+  });
+}
+async function globFiles(options) {
+  const matches = await fg(options.patterns, {
+    cwd: options.cwd,
+    ignore: options.ignore,
+    onlyFiles: true,
+    absolute: true,
+    unique: true,
+    followSymbolicLinks: false,
+    suppressErrors: true
+  });
+  return matches;
+}
+function toIgnoreGlob(segment) {
+  const trimmed = segment.replace(/^\/+|\/+$/g, "");
+  if (trimmed === "") return "";
+  const glob = trimmed.includes("*") || trimmed.includes("{") ? trimmed : `**/${trimmed}/**`;
+  return glob;
+}
+
+// src/scanner/rules.ts
+`*.{${SOURCE_EXTENSIONS.map((e) => e.slice(1)).join(",")}}`;
+function isSourceFile(filePath) {
+  return sourceFileKind(filePath) !== void 0;
+}
+
+// src/scanner/discover.ts
+async function discoverSourceFiles(options) {
+  const ignoreGlobs = options.ignore.map(toIgnoreGlob).filter((glob) => glob !== "").concat(["**/node_modules/**"]);
+  const files = await globFiles({
+    cwd: options.rootDir,
+    patterns: options.include,
+    ignore: ignoreGlobs
+  });
+  return files.filter(isSourceFile).sort((a, b) => a.localeCompare(b));
+}
+
+// src/parser/exports.ts
+function extractExports(sourceFile) {
+  const named = [];
+  const reExportedFrom = [];
+  const reExportedAll = [];
+  for (const decl of sourceFile.getExportDeclarations()) {
+    const specifier = decl.getModuleSpecifierValue();
+    const namedExports = decl.getNamedExports();
+    if (specifier) {
+      if (namedExports.length === 0) {
+        reExportedAll.push(specifier);
+      } else {
+        reExportedFrom.push(specifier);
+      }
+      continue;
+    }
+    for (const namedExport of namedExports) {
+      named.push(namedExport.getName());
+    }
+  }
+  for (const statement of sourceFile.getVariableStatements()) {
+    if (!statement.isExported()) continue;
+    for (const declaration of statement.getDeclarations()) {
+      named.push(declaration.getName());
+    }
+  }
+  for (const fn of sourceFile.getFunctions()) {
+    if (!fn.isExported()) continue;
+    const name = fn.getName();
+    if (name) named.push(name);
+  }
+  for (const cls of sourceFile.getClasses()) {
+    if (!cls.isExported()) continue;
+    const name = cls.getName();
+    if (name) named.push(name);
+  }
+  for (const en of sourceFile.getEnums()) {
+    if (!en.isExported()) continue;
+    const name = en.getName();
+    if (name) named.push(name);
+  }
+  for (const iface of sourceFile.getInterfaces()) {
+    if (!iface.isExported()) continue;
+    named.push(iface.getName());
+  }
+  for (const alias of sourceFile.getTypeAliases()) {
+    if (!alias.isExported()) continue;
+    named.push(alias.getName());
+  }
+  const hasDefault = sourceFile.getExportAssignments().length > 0 || sourceFile.getFunctions().some((fn) => fn.isDefaultExport()) || sourceFile.getClasses().some((cls) => cls.isDefaultExport());
+  named.sort();
+  return { named, hasDefault, reExportedFrom, reExportedAll };
+}
+function specifierFor(imported, alias, isType) {
+  return alias && alias !== imported ? { name: imported, alias, isType } : { name: imported, isType };
+}
+function extractImports(sourceFile) {
+  const declarations = [];
+  for (const decl of sourceFile.getImportDeclarations()) {
+    declarations.push({
+      raw: decl.getModuleSpecifierValue(),
+      kind: "import",
+      isTypeOnly: decl.isTypeOnly(),
+      specifiers: decl.getNamedImports().map(
+        (named) => specifierFor(named.getName(), named.getAliasNode()?.getText(), named.isTypeOnly())
+      )
+    });
+  }
+  for (const decl of sourceFile.getExportDeclarations()) {
+    const specifier = decl.getModuleSpecifierValue();
+    if (!specifier) continue;
+    declarations.push({
+      raw: specifier,
+      kind: "export-from",
+      isTypeOnly: decl.isTypeOnly(),
+      specifiers: decl.getNamedExports().map(
+        (named) => specifierFor(named.getName(), named.getAliasNode()?.getText(), named.isTypeOnly())
+      )
+    });
+  }
+  const importEqualsNodes = sourceFile.getDescendantsOfKind(SyntaxKind.ImportEqualsDeclaration).map((node) => node);
+  for (const decl of importEqualsNodes) {
+    const literal = decl.getFirstDescendantByKind(SyntaxKind.StringLiteral);
+    if (literal) {
+      declarations.push({
+        raw: literal.getLiteralText(),
+        kind: "require",
+        isTypeOnly: false,
+        specifiers: []
+      });
+    }
+  }
+  for (const call of sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+    const callee = call.getExpression().getText();
+    if (callee !== "require" && callee !== "import") continue;
+    const argument = call.getArguments()[0];
+    if (!argument?.isKind(SyntaxKind.StringLiteral)) continue;
+    declarations.push({
+      raw: argument.getLiteralText(),
+      kind: callee === "require" ? "require" : "dynamic",
+      isTypeOnly: false,
+      specifiers: []
+    });
+  }
+  return declarations;
+}
+
+// src/parser/symbols.ts
+function extractSymbols(sourceFile) {
+  return {
+    functions: sourceFile.getFunctions().map((fn) => fn.getName() ?? "(default)"),
+    classes: sourceFile.getClasses().map((cls) => cls.getName() ?? "(default)"),
+    interfaces: sourceFile.getInterfaces().map((iface) => iface.getName()),
+    enums: sourceFile.getEnums().map((en) => en.getName()),
+    typeAliases: sourceFile.getTypeAliases().map((alias) => alias.getName())
+  };
+}
+
+// src/parser/parse.ts
+function parseSourceFile(project, filePath) {
+  let sourceFile;
+  try {
+    sourceFile = project.addSourceFileAtPath(filePath);
+  } catch (error) {
+    return {
+      path: filePath,
+      kind: sourceFileKind(filePath) ?? "ts",
+      imports: [],
+      exports: { named: [], hasDefault: false, reExportedFrom: [], reExportedAll: [] },
+      symbols: { functions: [], classes: [], interfaces: [], enums: [], typeAliases: [] },
+      parseError: error instanceof Error ? error.message : String(error)
+    };
+  }
+  return {
+    path: filePath,
+    kind: sourceFileKind(filePath) ?? "ts",
+    imports: extractImports(sourceFile),
+    exports: extractExports(sourceFile),
+    symbols: extractSymbols(sourceFile)
+  };
+}
+function parseMany(project, filePaths) {
+  return filePaths.map((filePath) => parseSourceFile(project, filePath));
+}
+
+// src/graph/cycles.ts
+function findCycles(graph) {
+  const nodeKeys = [...graph.nodes.keys()];
+  const visited = /* @__PURE__ */ new Set();
+  const finishOrder = [];
+  for (const start of nodeKeys) {
+    if (visited.has(start)) continue;
+    const stack = [[start, 0]];
+    visited.add(start);
+    while (stack.length > 0) {
+      const top = stack[stack.length - 1];
+      if (top === void 0) break;
+      const [node, index] = top;
+      const neighbors = [...graph.forward.get(node) ?? []];
+      if (index < neighbors.length) {
+        top[1] = index + 1;
+        const neighbor = neighbors[index];
+        if (neighbor === void 0) continue;
+        if (!visited.has(neighbor)) {
+          visited.add(neighbor);
+          stack.push([neighbor, 0]);
+        }
+      } else {
+        stack.pop();
+        finishOrder.push(node);
+      }
+    }
+  }
+  const componentOf = /* @__PURE__ */ new Map();
+  const components = [];
+  for (let i = finishOrder.length - 1; i >= 0; i--) {
+    const start = finishOrder[i];
+    if (start === void 0 || componentOf.has(start)) continue;
+    const component = [];
+    const stack = [start];
+    componentOf.set(start, components.length);
+    while (stack.length > 0) {
+      const node = stack.pop();
+      if (node === void 0) continue;
+      component.push(node);
+      for (const neighbor of graph.reverse.get(node) ?? []) {
+        if (!componentOf.has(neighbor)) {
+          componentOf.set(neighbor, components.length);
+          stack.push(neighbor);
+        }
+      }
+    }
+    components.push(component);
+  }
+  const cycles = [];
+  for (const component of components) {
+    if (component.length < 2) {
+      const single = component[0];
+      if (single !== void 0 && graph.forward.get(single)?.has(single)) {
+        cycles.push({ members: [single], path: [single, single] });
+      }
+      continue;
+    }
+    const members = [...component].sort();
+    const componentSet = new Set(component);
+    const path12 = representativeCyclePath(graph, component, componentSet);
+    cycles.push({ members, path: path12 ?? [members[0], members[0]] });
+  }
+  cycles.sort(
+    (a, b) => a.members.length - b.members.length || a.members[0].localeCompare(b.members[0])
+  );
+  return cycles;
+}
+function representativeCyclePath(graph, component, componentSet) {
+  const inPath = /* @__PURE__ */ new Set();
+  const path12 = [];
+  let current = component[0];
+  for (let steps = 0; steps <= component.length * 2 && current !== void 0; steps++) {
+    const firstOccurrence = inPath.has(current);
+    if (firstOccurrence) {
+      const start = path12.indexOf(current);
+      if (start === -1) return void 0;
+      const cycle = path12.slice(start);
+      if (cycle.length > 1 || graph.forward.get(current)?.has(current)) {
+        cycle.push(current);
+        return cycle;
+      }
+      return void 0;
+    }
+    inPath.add(current);
+    path12.push(current);
+    const next = [...graph.forward.get(current) ?? []].find(
+      (candidate) => componentSet.has(candidate)
+    );
+    current = next;
+  }
+  return void 0;
+}
+function probeCandidates(base, fileKeys, rootDir) {
+  for (const candidate of extensionCandidates(base)) {
+    const key = pathKey(candidate, rootDir);
+    if (fileKeys.has(key)) return path8.normalize(candidate);
+  }
+  const jsSwapped = jsToTsCandidate(base);
+  if (jsSwapped !== base) {
+    const swappedKey = pathKey(jsSwapped, rootDir);
+    if (fileKeys.has(swappedKey)) return path8.normalize(jsSwapped);
+  }
+  return void 0;
+}
+function existsOnDisk(filePath) {
+  try {
+    fs2.accessSync(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function specifierToBase(specifier, fromDir, context) {
+  const { rootDir, aliases } = context;
+  if (specifier.startsWith("/")) {
+    return path8.resolve(rootDir, specifier.slice(1));
+  }
+  if (specifier.startsWith(".")) {
+    return path8.resolve(fromDir, specifier);
+  }
+  const substituted = substituteAlias(specifier, aliases);
+  if (substituted === void 0) return void 0;
+  return path8.isAbsolute(substituted) ? substituted : path8.resolve(rootDir, substituted);
+}
+function resolveToFile(base, context) {
+  const { rootDir, fileKeys } = context;
+  const exactKey = pathKey(base, rootDir);
+  if (fileKeys.has(exactKey)) return path8.normalize(base);
+  const probed = probeCandidates(base, fileKeys, rootDir);
+  if (probed) return probed;
+  if (existsOnDisk(base) && fs2.statSync(base).isDirectory()) {
+    const indexProbed = probeCandidates(path8.join(base, "index"), fileKeys, rootDir);
+    if (indexProbed) return indexProbed;
+  }
+  return void 0;
+}
+function resolveEdge(specifier, fromPath, context) {
+  const base = specifierToBase(specifier, path8.dirname(fromPath), context);
+  if (base !== void 0) {
+    const resolved = resolveToFile(base, context);
+    if (resolved !== void 0) return { filePath: resolved, kind: "internal" };
+    if (existsOnDisk(base)) return { kind: "external" };
+  }
+  const isRelative = specifier.startsWith(".") || specifier.startsWith("/");
+  const isAlias = specifierToBase(specifier, path8.dirname(fromPath), context) !== void 0;
+  if (isRelative || isAlias) return { kind: "unresolved" };
+  return { kind: "external" };
+}
+function resolveImports(fromPath, importSpecifiers, context) {
+  const internal = [];
+  const external = [];
+  const unresolved = [];
+  for (const specifier of importSpecifiers) {
+    const edge = resolveEdge(specifier, fromPath, context);
+    if (edge.kind === "internal" && edge.filePath) {
+      internal.push(edge.filePath);
+    } else if (edge.kind === "external") {
+      external.push(specifier);
+    } else {
+      unresolved.push(specifier);
+    }
+  }
+  return { internal, external, unresolved };
+}
+
+// src/graph/build.ts
+function buildGraph(project, filePaths, context) {
+  const parsedFiles = parseMany(project, filePaths);
+  const nodes = /* @__PURE__ */ new Map();
+  const forward = /* @__PURE__ */ new Map();
+  const reverse = /* @__PURE__ */ new Map();
+  const external = /* @__PURE__ */ new Map();
+  let parsedCount = 0;
+  let internalEdges = 0;
+  let unresolvedEdges = 0;
+  let externalEdges = 0;
+  for (const parsed of parsedFiles) {
+    const key = pathKey(parsed.path, context.rootDir);
+    nodes.set(key, { path: parsed.path, parsed });
+    if (!parsed.parseError) parsedCount++;
+  }
+  for (const parsed of parsedFiles) {
+    const fromKey = pathKey(parsed.path, context.rootDir);
+    const targets = /* @__PURE__ */ new Set();
+    const {
+      internal,
+      external: externalSpecifiers,
+      unresolved
+    } = resolveImports(
+      parsed.path,
+      parsed.imports.map((decl) => decl.raw),
+      context
+    );
+    internalEdges += internal.length;
+    unresolvedEdges += unresolved.length;
+    externalEdges += externalSpecifiers.length;
+    for (const target of internal) {
+      targets.add(pathKey(target, context.rootDir));
+    }
+    if (externalSpecifiers.length > 0) {
+      external.set(fromKey, new Set(externalSpecifiers));
+    }
+    forward.set(fromKey, targets);
+    for (const target of targets) {
+      const importers = reverse.get(target) ?? /* @__PURE__ */ new Set();
+      importers.add(fromKey);
+      reverse.set(target, importers);
+    }
+  }
+  const graph = {
+    nodes,
+    forward,
+    reverse,
+    external,
+    cycles: [],
+    stats: {
+      files: parsedFiles.length,
+      parsed: parsedCount,
+      internalEdges,
+      unresolvedEdges,
+      externalEdges,
+      cycles: 0
+    }
+  };
+  graph.cycles = findCycles(graph);
+  graph.stats.cycles = graph.cycles.length;
+  return graph;
+}
+
+// src/commands/pipeline.ts
+async function runPipeline(context) {
+  const started = Date.now();
+  const project = createTsProject();
+  const filePaths = await discoverSourceFiles({
+    rootDir: context.rootDir,
+    include: context.config.include,
+    ignore: context.config.ignore
+  });
+  const graph = buildGraph(project, filePaths, {
+    rootDir: context.rootDir,
+    aliases: context.aliases,
+    fileKeys: new Set(filePaths.map((p) => pathKey(p, context.rootDir)))
+  });
+  const entryPoints = await detectEntryPoints(context.rootDir);
+  return { graph, filePaths, entryPoints, durationMs: Date.now() - started };
+}
+function resolveTargetFile(fileArg, cwd) {
+  return path8.isAbsolute(fileArg) ? fileArg : path8.join(cwd, fileArg);
+}
+function requireNode(graph, targetPath, rootDir) {
+  const key = pathKey(targetPath, rootDir);
+  if (!graph.nodes.has(key)) {
+    throw fileNotFound(displayPath(targetPath, rootDir));
+  }
+  return { key };
+}
+
+// src/commands/analyze.ts
+async function analyzeCommand(fileArg, options, ctx2) {
+  const targetPath = resolveTargetFile(fileArg, ctx2.cwd);
+  if (!await pathExists(targetPath)) {
+    throw new RippleError(`File not found: ${fileArg}`, ExitCode.NotFound);
+  }
+  const spinner = createSpinner(!options.json);
+  spinner.start("Analyzing project\u2026");
+  const started = Date.now();
+  const context = await loadProjectContext(ctx2.cwd, options.config);
+  const { graph, entryPoints, durationMs: pipelineMs } = await runPipeline(context);
+  const completed = Date.now();
+  const result = analyzeFile({
+    graph,
+    context,
+    entryPoints,
+    targetKey: requireNode(graph, targetPath, context.rootDir).key,
+    targetPath,
+    durationMs: pipelineMs + (completed - started),
+    ...options.depth !== void 0 ? { maxDepth: options.depth } : {}
+  });
+  spinner.stop();
+  if (options.json) {
+    const report = buildAnalyzeJsonReport(result, ctx2.version, ctx2.cwd);
+    ctx2.writer.write(serializeJson(report));
+    return ExitCode.Success;
+  }
+  renderAnalyzeReport(
+    result,
+    {
+      cwd: ctx2.cwd,
+      color: options.color !== false,
+      verbose: options.verbose
+    },
+    ctx2.writer
+  );
+  return ExitCode.Success;
+}
+
+// src/commands/graph.ts
+function walk(graph, startKey, edges, maxDepth, cwd) {
+  const seen = /* @__PURE__ */ new Set([startKey]);
+  const queue = [{ key: startKey, depth: 0 }];
+  const entries = [];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current) continue;
+    if (current.key !== startKey) {
+      const nodePath = graph.nodes.get(current.key)?.path ?? current.key;
+      entries.push({ path: displayPath(nodePath, cwd), depth: current.depth });
+    }
+    if (maxDepth !== void 0 && current.depth >= maxDepth) continue;
+    for (const candidate of edges.get(current.key) ?? []) {
+      if (seen.has(candidate)) continue;
+      seen.add(candidate);
+      queue.push({ key: candidate, depth: current.depth + 1 });
+    }
+  }
+  return entries.sort((a, b) => a.depth - b.depth || a.path.localeCompare(b.path)).map((entry) => entry.path);
+}
+async function graphCommand(fileArg, options, ctx2) {
+  const spinner = createSpinner(!options.json);
+  spinner.start(fileArg ? "Building dependency tree\u2026" : "Building graph\u2026");
+  const cwd = ctx2.cwd;
+  try {
+    const context = await loadProjectContext(cwd, options.config);
+    const { graph } = await runPipeline(context);
+    const input = {
+      stats: graph.stats,
+      cycles: graph.cycles,
+      nodes: graph.nodes,
+      cwd
+    };
+    if (!fileArg) {
+      if (options.json) {
+        const report = buildGraphJsonReport(input, ctx2.version);
+        ctx2.writer.write(serializeJson(report));
+      } else {
+        renderGraphReport(
+          input,
+          { cwd, color: options.color !== false, verbose: options.verbose },
+          ctx2.writer
+        );
+      }
+      return ExitCode.Success;
+    }
+    const targetPath = resolveTargetFile(fileArg, cwd);
+    const { key } = requireNode(graph, targetPath, context.rootDir);
+    const dependants = walk(graph, key, graph.forward, options.depth, cwd);
+    const dependents = walk(graph, key, graph.reverse, options.depth, cwd);
+    if (options.json) {
+      const report = buildGraphJsonReport(
+        {
+          ...input,
+          ...options.reverse ? { reverse: dependents } : { forward: dependants }
+        },
+        ctx2.version
+      );
+      ctx2.writer.write(serializeJson(report));
+    } else {
+      renderGraphReport(
+        {
+          ...input,
+          forward: options.reverse ? void 0 : dependants,
+          reverse: options.reverse ? dependents : void 0
+        },
+        { cwd, color: options.color !== false, verbose: options.verbose },
+        ctx2.writer
+      );
+    }
+    return ExitCode.Success;
+  } finally {
+    spinner.stop();
+  }
+}
+async function doctorCommand(options, ctx2) {
+  const spinner = createSpinner(options.color !== false);
+  spinner.start("Running diagnostics\u2026");
+  const results = [];
+  const check = (label, state, detail) => {
+    results.push({ label, state, detail });
+  };
+  try {
+    check("Node.js runtime", "ok", process.version);
+    const packageJson = await findPackageJson(ctx2.cwd);
+    if (packageJson) {
+      check("package.json", "ok", path8.relative(ctx2.cwd, packageJson));
+    } else {
+      check("package.json", "fail", "not found in this directory or its parents");
+    }
+    let context;
+    try {
+      const loaded = await loadConfig(ctx2.cwd, options.config);
+      check(
+        "ripple config",
+        "ok",
+        loaded.configPath ? path8.relative(ctx2.cwd, loaded.configPath) : "defaults"
+      );
+      context = await loadProjectContext(ctx2.cwd, options.config);
+    } catch (error) {
+      check("ripple config", "fail", error instanceof Error ? error.message : String(error));
+      renderResults(results, ctx2);
+      return ExitCode.InvalidConfig;
+    }
+    if (context.tsconfig) {
+      check("tsconfig.json", "ok", path8.relative(ctx2.cwd, context.tsconfig.path));
+    } else {
+      check("tsconfig.json", "warn", "not found \u2014 path aliases unavailable");
+    }
+    const project = createTsProject();
+    const filePaths = await discoverSourceFiles({
+      rootDir: context.rootDir,
+      include: context.config.include,
+      ignore: context.config.ignore
+    });
+    if (filePaths.length > 0) {
+      check("source files", "ok", `${filePaths.length} discovered`);
+    } else {
+      check("source files", "fail", "no source files matched the include globs");
+    }
+    if (Object.keys(context.aliases).length > 0) {
+      check("path aliases", "ok", `${Object.keys(context.aliases).length} configured`);
+    }
+    const graph = buildGraph(project, filePaths, {
+      rootDir: context.rootDir,
+      aliases: context.aliases,
+      fileKeys: new Set(filePaths.map((p) => pathKey(p, context.rootDir)))
+    });
+    const { stats } = graph;
+    const parseRate = stats.files === 0 ? 1 : stats.parsed / stats.files;
+    if (parseRate >= 0.99) {
+      check("parse", "ok", "all files parsed cleanly");
+    } else if (parseRate >= 0.9) {
+      check("parse", "warn", `${stats.files - stats.parsed} file(s) failed to parse`);
+    } else {
+      check("parse", "fail", `${stats.files - stats.parsed} file(s) failed to parse`);
+    }
+    if (stats.unresolvedEdges === 0) {
+      check("import resolution", "ok", "all internal imports resolved");
+    } else {
+      check("import resolution", "warn", `${stats.unresolvedEdges} unresolved import(s)`);
+    }
+    if (stats.cycles === 0) {
+      check("circular dependencies", "ok", "none found");
+    } else {
+      check("circular dependencies", "warn", `${stats.cycles} cycle group(s)`);
+    }
+  } finally {
+    spinner.stop();
+  }
+  renderResults(results, ctx2);
+  const failed = results.some((check2) => check2.state === "fail");
+  const warned = results.some((check2) => check2.state === "warn");
+  ctx2.writer.writeLine(
+    failed ? "\u2716 Diagnoses found problems." : warned ? "\u26A0 Diagnoses passed with warnings." : "\u2713 All checks passed."
+  );
+  return failed ? ExitCode.Failure : ExitCode.Success;
+}
+function renderResults(results, ctx2) {
+  for (const check of results) {
+    const icon = check.state === "ok" ? "\u2713" : check.state === "warn" ? "\u26A0" : "\u2716";
+    const suffix = check.detail ? ` ${check.detail}` : "";
+    ctx2.writer.writeLine(`${icon} ${check.label}${suffix}`);
+  }
+  ctx2.writer.writeLine();
+}
+var INIT_FILENAME = "ripple.config.json";
+async function initCommand(options, ctx2) {
+  const target = path8.join(ctx2.cwd, INIT_FILENAME);
+  try {
+    await fs.access(target);
+    if (!options.force) {
+      ctx2.writer.writeLine(`\u2716 ${INIT_FILENAME} already exists. Pass --force to overwrite it.`);
+      return ExitCode.Failure;
+    }
+  } catch {
+  }
+  const payload = {
+    ...DEFAULT_CONFIG
+  };
+  try {
+    await fs.writeFile(target, `${JSON.stringify(payload, null, 2)}
+`, "utf8");
+    ctx2.writer.writeLine(`\u2713 Wrote ${INIT_FILENAME}`);
+    ctx2.writer.writeLine(`  Edit it to tune include globs, aliases and risk weights.`);
+    return ExitCode.Success;
+  } catch (error) {
+    ctx2.writer.writeLine(
+      `\u2716 Could not write ${INIT_FILENAME}: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return ExitCode.Failure;
+  }
+}
+
+// src/cli/program.ts
+var PROGRAM_NAME = "ripple";
+function createProgram(ctx2) {
+  const program = new Command().name(PROGRAM_NAME).description("Dependency impact analysis for TypeScript and JavaScript projects.").version(ctx2.version, "-V, --version", "print the Ripple version").showHelpAfterError();
+  program.command("analyze <file>").description("Analyze the impact of changing a file").option("-j, --json", "emit a machine-readable JSON report").option("-v, --verbose", "include the risk factor breakdown").option("-d, --depth <number>", "cap the reverse traversal depth", parsePositiveInt).option("-c, --config <path>", "path to a ripple config file").option("--no-color", "disable ANSI colors").action(async (file, options) => {
+    const exitCode2 = await analyzeCommand(
+      file,
+      {
+        json: Boolean(options.json),
+        verbose: Boolean(options.verbose),
+        ...options.depth !== void 0 ? { depth: options.depth } : {},
+        ...options.config !== void 0 ? { config: options.config } : {},
+        color: options.color
+      },
+      ctx2
+    );
+    if (exitCode2 !== ExitCode.Success) {
+      throw new ExitError(exitCode2);
+    }
+  });
+  program.command("graph [file]").description("Show project graph stats, or the dependency tree of one file").option("-j, --json", "emit a machine-readable JSON report").option("-v, --verbose", "include extra sections").option("-r, --reverse", "show dependents (what imports the file) instead of dependants").option("-d, --depth <number>", "cap the tree depth", parsePositiveInt).option("-c, --config <path>", "path to a ripple config file").option("--no-color", "disable ANSI colors").action(async (file, options) => {
+    const exitCode2 = await graphCommand(
+      file,
+      {
+        json: Boolean(options.json),
+        verbose: Boolean(options.verbose),
+        reverse: Boolean(options.reverse),
+        ...options.depth !== void 0 ? { depth: options.depth } : {},
+        ...options.config !== void 0 ? { config: options.config } : {},
+        color: options.color
+      },
+      ctx2
+    );
+    if (exitCode2 !== ExitCode.Success) {
+      throw new ExitError(exitCode2);
+    }
+  });
+  program.command("doctor").description("Check the project and environment for Ripple readiness").option("-v, --verbose", "print detailed diagnostics").option("-c, --config <path>", "path to a ripple config file").option("--no-color", "disable ANSI colors").action(async (options) => {
+    const exitCode2 = await doctorCommand(
+      {
+        verbose: Boolean(options.verbose),
+        config: options.config,
+        color: options.color
+      },
+      ctx2
+    );
+    if (exitCode2 !== ExitCode.Success) {
+      throw new ExitError(exitCode2);
+    }
+  });
+  program.command("init").description("Create a ripple.config.json with the default settings").option("-f, --force", "overwrite an existing config file").action(async (options) => {
+    const exitCode2 = await initCommand({ force: Boolean(options.force) }, ctx2);
+    if (exitCode2 !== ExitCode.Success) {
+      throw new ExitError(exitCode2);
+    }
+  });
+  program.command("version").description("Print the Ripple version").action(() => {
+    ctx2.writer.writeLine(ctx2.version);
+  });
+  return program;
+}
+var ExitError = class extends Error {
+  constructor(exitCode2) {
+    super(`exit ${exitCode2}`);
+    this.exitCode = exitCode2;
+    this.name = "ExitError";
+  }
+  exitCode;
+};
+function parsePositiveInt(value) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed < 1) {
+    throw new CommanderError(
+      1,
+      "commander.invalidArgument",
+      `expected a positive integer, got "${value}"`
+    );
+  }
+  return parsed;
+}
+function printError(error, ctx2) {
+  if (error instanceof RippleError) {
+    ctx2.errorWriter.writeLine(`\u2716 ${error.message}`);
+    if (error.hint) ctx2.errorWriter.writeLine(`  ${error.hint}`);
+    return;
+  }
+  if (error instanceof Error) {
+    ctx2.errorWriter.writeLine(`\u2716 ${error.message}`);
+    return;
+  }
+  ctx2.errorWriter.writeLine(`\u2716 ${String(error)}`);
+}
+async function run({ argv, ctx: ctx2 }) {
+  const program = createProgram(ctx2);
+  program.exitOverride();
+  try {
+    await program.parseAsync(argv);
+    return ExitCode.Success;
+  } catch (error) {
+    if (error instanceof ExitError) {
+      return error.exitCode;
+    }
+    if (error instanceof CommanderError) {
+      if (error.exitCode === 0) return ExitCode.Success;
+      return ExitCode.Failure;
+    }
+    printError(error, ctx2);
+    return error instanceof RippleError ? error.exitCode : ExitCode.Failure;
+  }
+}
+
+// package.json
+var package_default = {
+  version: "0.1.0"};
+
+// src/cli/bin.ts
+var ctx = {
+  writer: new TerminalWriter(),
+  errorWriter: new TerminalWriter(process.stderr),
+  cwd: process.cwd(),
+  version: package_default.version
+};
+var exitCode = await run({ argv: process.argv, ctx });
+process.exitCode = exitCode;
+//# sourceMappingURL=bin.js.map
+//# sourceMappingURL=bin.js.map