fcis 0.1.0

package/dist/index.js

@@ -0,0 +1,1845 @@
+import { SyntaxKind, Project } from 'ts-morph';
+import * as path from 'path';
+import * as fs2 from 'fs';
+import chalk from 'chalk';
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/types.ts
+var DEFAULT_QUALITY_THRESHOLDS = {
+  okThreshold: 70,
+  reviewThreshold: 40
+};
+function extractFunctions(sourceFile) {
+  const functions = [];
+  const filePath = sourceFile.getFilePath();
+  const addedPositions = /* @__PURE__ */ new Set();
+  const addFunction = (fn) => {
+    const posKey = `${fn.startLine}:${fn.endLine}`;
+    if (!addedPositions.has(posKey)) {
+      addedPositions.add(posKey);
+      functions.push(fn);
+    }
+  };
+  for (const func of sourceFile.getFunctions()) {
+    addFunction(extractFunctionData(func, filePath, "function"));
+  }
+  for (const classDecl of sourceFile.getClasses()) {
+    const className = classDecl.getName() ?? null;
+    for (const method of classDecl.getMethods()) {
+      addFunction(extractFunctionData(method, filePath, "method", className));
+    }
+    for (const getter of classDecl.getGetAccessors()) {
+      addFunction(extractFunctionData(getter, filePath, "getter", className));
+    }
+    for (const setter of classDecl.getSetAccessors()) {
+      addFunction(extractFunctionData(setter, filePath, "setter", className));
+    }
+  }
+  for (const varStatement of sourceFile.getVariableStatements()) {
+    const isExported = varStatement.isExported();
+    for (const decl of varStatement.getDeclarations()) {
+      const initializer = decl.getInitializer();
+      const varName = decl.getName();
+      if (initializer) {
+        if (initializer.getKind() === SyntaxKind.ArrowFunction) {
+          addFunction(
+            extractFunctionData(
+              initializer,
+              filePath,
+              "arrow",
+              varName,
+              isExported
+            )
+          );
+        } else if (initializer.getKind() === SyntaxKind.FunctionExpression) {
+          addFunction(
+            extractFunctionData(
+              initializer,
+              filePath,
+              "function-expression",
+              varName,
+              isExported
+            )
+          );
+        }
+      }
+    }
+  }
+  const defaultExport = sourceFile.getDefaultExportSymbol();
+  if (defaultExport) {
+    const declarations = defaultExport.getDeclarations();
+    for (const decl of declarations) {
+      if (decl.getKind() === SyntaxKind.ArrowFunction) {
+        addFunction(
+          extractFunctionData(
+            decl,
+            filePath,
+            "arrow",
+            "default",
+            true
+          )
+        );
+      } else if (decl.getKind() === SyntaxKind.FunctionExpression) {
+        addFunction(
+          extractFunctionData(
+            decl,
+            filePath,
+            "function-expression",
+            "default",
+            true
+          )
+        );
+      }
+    }
+  }
+  sourceFile.forEachDescendant((node) => {
+    if (node.getKind() === SyntaxKind.ArrowFunction) {
+      const arrowFn = node;
+      const parentContext = inferParentContext(arrowFn);
+      addFunction(
+        extractFunctionData(arrowFn, filePath, "arrow", parentContext, false)
+      );
+    } else if (node.getKind() === SyntaxKind.FunctionExpression) {
+      const funcExpr = node;
+      const parentContext = inferParentContext(funcExpr);
+      addFunction(
+        extractFunctionData(
+          funcExpr,
+          filePath,
+          "function-expression",
+          parentContext,
+          false
+        )
+      );
+    }
+  });
+  return functions;
+}
+function inferParentContext(node) {
+  const parent = node.getParent();
+  if (!parent) return null;
+  if (parent.getKind() === SyntaxKind.CallExpression) {
+    const callExpr = parent;
+    const expression = callExpr.getExpression();
+    if (expression.getKind() === SyntaxKind.PropertyAccessExpression) {
+      const propAccess = expression;
+      return propAccess.getName();
+    }
+    if (expression.getKind() === SyntaxKind.Identifier) {
+      return expression.getText();
+    }
+  }
+  if (parent.getKind() === SyntaxKind.PropertyAssignment) {
+    const propAssignment = parent;
+    return propAssignment.getName();
+  }
+  if (parent.getKind() === SyntaxKind.ShorthandPropertyAssignment) {
+    const shorthand = parent;
+    return shorthand.getName();
+  }
+  return null;
+}
+function extractFunctionData(node, filePath, kind, parentContext = null, isExportedOverride) {
+  const startLine = node.getStartLineNumber();
+  const endLine = node.getEndLineNumber();
+  const bodyLineCount = endLine - startLine + 1;
+  let name = null;
+  if ("getName" in node && typeof node.getName === "function") {
+    name = node.getName() ?? null;
+  }
+  if (name === null && parentContext !== null) {
+    name = parentContext;
+  }
+  const isAsync = "isAsync" in node ? node.isAsync?.() ?? false : false;
+  let isExported = isExportedOverride ?? false;
+  if (!isExported && "isExported" in node) {
+    isExported = node.isExported?.() ?? false;
+  }
+  const body = getBodyNode(node);
+  const statementCount = countStatements(body);
+  const hasConditionals = checkForConditionals(body);
+  const callSites = extractCallSites(node, startLine);
+  const hasAwait = callSites.some((cs) => cs.isAwaited) || checkForAwait(node);
+  const propertyAccessChains = extractPropertyAccessChains(node);
+  return {
+    name,
+    filePath,
+    startLine,
+    endLine,
+    isAsync,
+    isExported,
+    bodyLineCount,
+    statementCount,
+    hasConditionals,
+    parentContext,
+    callSites,
+    hasAwait,
+    propertyAccessChains,
+    kind
+  };
+}
+function getBodyNode(node) {
+  if ("getBody" in node) {
+    return node.getBody();
+  }
+  return void 0;
+}
+function countStatements(body) {
+  if (!body) return 0;
+  if (body.getKind() === SyntaxKind.Block) {
+    const statements = body.getChildrenOfKind(SyntaxKind.SyntaxList);
+    if (statements.length > 0 && statements[0]) {
+      return statements[0].getChildren().filter(isStatement).length;
+    }
+  }
+  return 1;
+}
+function isStatement(node) {
+  const kind = node.getKind();
+  return kind === SyntaxKind.VariableStatement || kind === SyntaxKind.ExpressionStatement || kind === SyntaxKind.ReturnStatement || kind === SyntaxKind.IfStatement || kind === SyntaxKind.ForStatement || kind === SyntaxKind.ForInStatement || kind === SyntaxKind.ForOfStatement || kind === SyntaxKind.WhileStatement || kind === SyntaxKind.DoStatement || kind === SyntaxKind.SwitchStatement || kind === SyntaxKind.TryStatement || kind === SyntaxKind.ThrowStatement || kind === SyntaxKind.BreakStatement || kind === SyntaxKind.ContinueStatement;
+}
+function checkForConditionals(body) {
+  if (!body) return false;
+  let hasConditionals = false;
+  body.forEachDescendant((node) => {
+    const kind = node.getKind();
+    if (kind === SyntaxKind.IfStatement || kind === SyntaxKind.ConditionalExpression || kind === SyntaxKind.SwitchStatement) {
+      hasConditionals = true;
+    }
+  });
+  return hasConditionals;
+}
+function checkForAwait(node) {
+  let hasAwait = false;
+  node.forEachDescendant((descendant, traversal) => {
+    const kind = descendant.getKind();
+    if (kind === SyntaxKind.FunctionDeclaration || kind === SyntaxKind.FunctionExpression || kind === SyntaxKind.ArrowFunction || kind === SyntaxKind.MethodDeclaration) {
+      traversal.skip();
+      return;
+    }
+    if (kind === SyntaxKind.AwaitExpression) {
+      hasAwait = true;
+    }
+  });
+  return hasAwait;
+}
+function extractCallSites(node, functionStartLine) {
+  const callSites = [];
+  node.forEachDescendant((descendant, traversal) => {
+    const kind = descendant.getKind();
+    if (kind === SyntaxKind.FunctionDeclaration || kind === SyntaxKind.FunctionExpression || kind === SyntaxKind.ArrowFunction || kind === SyntaxKind.MethodDeclaration) {
+      traversal.skip();
+      return;
+    }
+    if (kind === SyntaxKind.CallExpression) {
+      const callExpr = descendant;
+      const expression = getCallExpressionText(callExpr);
+      const line = callExpr.getStartLineNumber() - functionStartLine;
+      const parent = callExpr.getParent();
+      const isAwaited = parent?.getKind() === SyntaxKind.AwaitExpression;
+      callSites.push({
+        expression,
+        line,
+        isAwaited
+      });
+    }
+  });
+  return callSites;
+}
+function getCallExpressionText(callExpr) {
+  const expression = callExpr.getExpression();
+  if (expression.getKind() === SyntaxKind.PropertyAccessExpression) {
+    return getPropertyAccessChainText(expression);
+  }
+  return expression.getText();
+}
+function getPropertyAccessChainText(node) {
+  const parts = [];
+  let current = node;
+  while (current.getKind() === SyntaxKind.PropertyAccessExpression) {
+    const propAccess = current;
+    parts.unshift(propAccess.getName());
+    current = propAccess.getExpression();
+  }
+  parts.unshift(current.getText());
+  return parts.join(".");
+}
+function extractPropertyAccessChains(node) {
+  const chains = /* @__PURE__ */ new Set();
+  node.forEachDescendant((descendant, traversal) => {
+    const kind = descendant.getKind();
+    if (kind === SyntaxKind.FunctionDeclaration || kind === SyntaxKind.FunctionExpression || kind === SyntaxKind.ArrowFunction || kind === SyntaxKind.MethodDeclaration) {
+      traversal.skip();
+      return;
+    }
+    if (kind === SyntaxKind.PropertyAccessExpression) {
+      const propAccess = descendant;
+      const parent = propAccess.getParent();
+      if (parent?.getKind() !== SyntaxKind.PropertyAccessExpression) {
+        const chain = getPropertyAccessChainText(propAccess);
+        if (chain.includes(".")) {
+          chains.add(chain);
+        }
+      }
+    }
+  });
+  return Array.from(chains);
+}
+function extractImports(sourceFile) {
+  const filePath = sourceFile.getFilePath();
+  const imports = [];
+  for (const importDecl of sourceFile.getImportDeclarations()) {
+    const moduleSpecifier = importDecl.getModuleSpecifierValue();
+    const namedImports = [];
+    for (const namedImport of importDecl.getNamedImports()) {
+      namedImports.push(namedImport.getName());
+    }
+    const defaultImport = importDecl.getDefaultImport();
+    if (defaultImport) {
+      namedImports.push(defaultImport.getText());
+    }
+    const namespaceImport = importDecl.getNamespaceImport();
+    if (namespaceImport) {
+      namedImports.push(namespaceImport.getText());
+    }
+    imports.push({
+      moduleSpecifier,
+      namedImports
+    });
+  }
+  return {
+    filePath,
+    imports
+  };
+}
+function isTypeOnlyFile(sourceFile) {
+  if (sourceFile.getFunctions().length > 0) return false;
+  for (const classDecl of sourceFile.getClasses()) {
+    if (classDecl.getMethods().length > 0) return false;
+    if (classDecl.getGetAccessors().length > 0) return false;
+    if (classDecl.getSetAccessors().length > 0) return false;
+  }
+  for (const varStatement of sourceFile.getVariableStatements()) {
+    for (const decl of varStatement.getDeclarations()) {
+      const initializer = decl.getInitializer();
+      if (initializer) {
+        const kind = initializer.getKind();
+        if (kind === SyntaxKind.ArrowFunction || kind === SyntaxKind.FunctionExpression) {
+          return false;
+        }
+      }
+    }
+  }
+  return true;
+}
+function stripJsonComments(jsonString) {
+  let result = "";
+  let inString = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  let i = 0;
+  while (i < jsonString.length) {
+    const char = jsonString[i];
+    const nextChar = jsonString[i + 1];
+    if (!inLineComment && !inBlockComment && char === '"') {
+      let backslashCount = 0;
+      let j = i - 1;
+      while (j >= 0 && jsonString[j] === "\\") {
+        backslashCount++;
+        j--;
+      }
+      if (backslashCount % 2 === 0) {
+        inString = !inString;
+      }
+    }
+    if (inString) {
+      result += char;
+      i++;
+      continue;
+    }
+    if (!inBlockComment && char === "/" && nextChar === "/") {
+      inLineComment = true;
+      i += 2;
+      continue;
+    }
+    if (inLineComment && (char === "\n" || char === "\r")) {
+      inLineComment = false;
+      result += char;
+      i++;
+      continue;
+    }
+    if (!inLineComment && char === "/" && nextChar === "*") {
+      inBlockComment = true;
+      i += 2;
+      continue;
+    }
+    if (inBlockComment && char === "*" && nextChar === "/") {
+      inBlockComment = false;
+      i += 2;
+      continue;
+    }
+    if (!inLineComment && !inBlockComment) {
+      result += char;
+    }
+    i++;
+  }
+  return result;
+}
+function loadProject(options) {
+  const { tsconfigPath, filesGlob } = options;
+  const errors = [];
+  const absoluteTsconfigPath = path.resolve(tsconfigPath);
+  if (!fs2.existsSync(absoluteTsconfigPath)) {
+    throw new Error(`tsconfig.json not found at: ${absoluteTsconfigPath}`);
+  }
+  try {
+    const content = fs2.readFileSync(absoluteTsconfigPath, "utf-8");
+    const strippedContent = stripJsonComments(content);
+    JSON.parse(strippedContent);
+  } catch (e) {
+    throw new Error(
+      `Invalid tsconfig.json at ${absoluteTsconfigPath}: ${e instanceof Error ? e.message : String(e)}`
+    );
+  }
+  const project = new Project({
+    tsConfigFilePath: absoluteTsconfigPath,
+    skipAddingFilesFromTsConfig: false
+  });
+  let sourceFiles = project.getSourceFiles().filter((sf) => {
+    const filePath = sf.getFilePath();
+    return filePath.endsWith(".ts") && !filePath.endsWith(".d.ts") && !filePath.endsWith(".test.ts") && !filePath.endsWith(".spec.ts") && !filePath.includes("/node_modules/") && !filePath.includes("/generated/");
+  });
+  if (filesGlob) {
+    const globPattern = createGlobMatcher(filesGlob);
+    sourceFiles = sourceFiles.filter((sf) => globPattern(sf.getFilePath()));
+  }
+  return {
+    project,
+    sourceFiles,
+    errors
+  };
+}
+function createGlobMatcher(glob) {
+  const regexStr = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{DOUBLE_STAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, ".").replace(/\{\{DOUBLE_STAR\}\}/g, ".*");
+  const regex = new RegExp(regexStr);
+  return (filePath) => regex.test(filePath);
+}
+function getCommitHash() {
+  try {
+    const { execSync } = __require("child_process");
+    const hash = execSync("git rev-parse HEAD", { encoding: "utf-8" }).trim();
+    return hash;
+  } catch {
+    return null;
+  }
+}
+
+// src/detection/detect-markers.ts
+var DATABASE_OPERATIONS = /* @__PURE__ */ new Set([
+  "findFirst",
+  "findMany",
+  "findUnique",
+  "findUniqueOrThrow",
+  "findFirstOrThrow",
+  "create",
+  "createMany",
+  "update",
+  "updateMany",
+  "delete",
+  "deleteMany",
+  "upsert",
+  "aggregate",
+  "count",
+  "groupBy",
+  "$transaction",
+  "$queryRaw",
+  "$executeRaw"
+]);
+var TELEMETRY_PATTERNS = [
+  /^track[A-Z]/,
+  /^analytics\./,
+  /^segment\./,
+  /^mixpanel\./,
+  /^amplitude\./,
+  /^posthog\./,
+  /^gtag\(/,
+  /^ga\(/
+];
+function detectMarkers(fn, context) {
+  const markers = [];
+  detectAwaitMarkers(fn, markers);
+  detectDatabaseMarkers(fn, markers);
+  detectNetworkMarkers(fn, context, markers);
+  detectFileSystemMarkers(fn, context, markers);
+  detectEnvMarkers(fn, markers);
+  detectLoggingMarkers(fn, context, markers);
+  detectTelemetryMarkers(fn, markers);
+  detectQueueMarkers(fn, markers);
+  detectEventMarkers(fn, markers);
+  return markers;
+}
+function detectAwaitMarkers(fn, markers) {
+  if (fn.hasAwait) {
+    const awaitedCalls = fn.callSites.filter((cs) => cs.isAwaited);
+    if (awaitedCalls.length > 0) {
+      for (const call of awaitedCalls) {
+        markers.push({
+          type: "await-expression",
+          detail: `await ${call.expression}`,
+          line: call.line
+        });
+      }
+    } else {
+      markers.push({
+        type: "await-expression",
+        detail: "await expression"
+      });
+    }
+  }
+}
+function detectDatabaseMarkers(fn, markers) {
+  for (const callSite of fn.callSites) {
+    if (isDatabaseCall(callSite.expression)) {
+      markers.push({
+        type: "database-call",
+        detail: callSite.expression,
+        line: callSite.line
+      });
+    }
+  }
+}
+function isDatabaseCall(expression) {
+  const parts = expression.split(".");
+  if (parts.length < 3) {
+    if (parts.length === 2) {
+      const [base, operation] = parts;
+      if ((base === "db" || base === "prisma") && operation && DATABASE_OPERATIONS.has(operation)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  const lastPart = parts[parts.length - 1];
+  if (!lastPart || !DATABASE_OPERATIONS.has(lastPart)) {
+    return false;
+  }
+  return parts.some(
+    (part) => part === "db" || part === "prisma" || part === "database"
+  );
+}
+function detectNetworkMarkers(fn, _context, markers) {
+  for (const callSite of fn.callSites) {
+    if (callSite.expression === "fetch" || callSite.expression.endsWith(".fetch")) {
+      markers.push({
+        type: "network-fetch",
+        detail: callSite.expression,
+        line: callSite.line
+      });
+    }
+    if (callSite.expression.startsWith("axios") || callSite.expression === "axios") {
+      markers.push({
+        type: "network-http",
+        detail: callSite.expression,
+        line: callSite.line
+      });
+    }
+  }
+}
+function detectFileSystemMarkers(fn, _context, markers) {
+  for (const callSite of fn.callSites) {
+    if (isFsCall(callSite.expression)) {
+      markers.push({
+        type: "fs-call",
+        detail: callSite.expression,
+        line: callSite.line
+      });
+    }
+  }
+}
+function isFsCall(expression) {
+  const parts = expression.split(".");
+  return parts.some(
+    (part) => part === "fs" || part === "readFile" || part === "writeFile"
+  );
+}
+function detectEnvMarkers(fn, markers) {
+  for (const chain of fn.propertyAccessChains) {
+    if (chain.startsWith("process.env")) {
+      markers.push({
+        type: "env-access",
+        detail: chain
+      });
+    }
+  }
+}
+function detectLoggingMarkers(fn, _context, markers) {
+  for (const callSite of fn.callSites) {
+    if (isConsoleLog(callSite.expression)) {
+      markers.push({
+        type: "console-log",
+        detail: callSite.expression,
+        line: callSite.line
+      });
+    }
+    if (isLoggerCall(callSite.expression)) {
+      markers.push({
+        type: "logging",
+        detail: callSite.expression,
+        line: callSite.line
+      });
+    }
+  }
+}
+function isConsoleLog(expression) {
+  return expression === "console.log" || expression === "console.error" || expression === "console.warn" || expression === "console.info" || expression === "console.debug";
+}
+function isLoggerCall(expression) {
+  const parts = expression.split(".");
+  if (parts.length < 2) {
+    return expression === "log";
+  }
+  const base = parts[0];
+  const method = parts[parts.length - 1];
+  if (base === "logger" || base === "log") {
+    return true;
+  }
+  const logMethods = /* @__PURE__ */ new Set([
+    "info",
+    "warn",
+    "error",
+    "debug",
+    "trace",
+    "fatal"
+  ]);
+  return (parts.includes("logger") || parts.includes("log")) && method !== void 0 && logMethods.has(method);
+}
+function detectTelemetryMarkers(fn, markers) {
+  for (const callSite of fn.callSites) {
+    if (isTelemetryCall(callSite.expression)) {
+      markers.push({
+        type: "telemetry",
+        detail: callSite.expression,
+        line: callSite.line
+      });
+    }
+  }
+}
+function isTelemetryCall(expression) {
+  return TELEMETRY_PATTERNS.some((pattern) => pattern.test(expression));
+}
+function detectQueueMarkers(fn, markers) {
+  for (const callSite of fn.callSites) {
+    if (isQueueCall(callSite.expression)) {
+      markers.push({
+        type: "queue-enqueue",
+        detail: callSite.expression,
+        line: callSite.line
+      });
+    }
+  }
+}
+function isQueueCall(expression) {
+  return expression.endsWith(".enqueue") || expression.endsWith(".add") || expression.endsWith(".publish") || expression.includes("queue.") || expression.includes("Queue.");
+}
+function detectEventMarkers(fn, markers) {
+  for (const callSite of fn.callSites) {
+    if (isEventEmit(callSite.expression)) {
+      markers.push({
+        type: "event-emit",
+        detail: callSite.expression,
+        line: callSite.line
+      });
+    }
+  }
+}
+function isEventEmit(expression) {
+  return expression.endsWith(".emit") || expression.endsWith(".dispatch") || expression.endsWith(".trigger") || expression.endsWith(".fire");
+}
+function createDetectionContext(imports) {
+  const pureFileImports = /* @__PURE__ */ new Set();
+  for (const imp of imports.imports) {
+    if (imp.moduleSpecifier.endsWith(".pure") || imp.moduleSpecifier.includes(".pure/")) {
+      pureFileImports.add(imp.moduleSpecifier);
+    }
+  }
+  return {
+    imports,
+    pureFileImports
+  };
+}
+function getPureImportedFunctions(context) {
+  const pureFunctions = /* @__PURE__ */ new Set();
+  for (const imp of context.imports.imports) {
+    if (context.pureFileImports.has(imp.moduleSpecifier)) {
+      for (const name of imp.namedImports) {
+        pureFunctions.add(name);
+      }
+    }
+  }
+  return pureFunctions;
+}
+
+// src/classification/classifier.ts
+var TRIVIAL_STATEMENT_THRESHOLD = 3;
+function classifyFunction(_fn, markers) {
+  if (markers.length === 0) {
+    return "pure";
+  }
+  return "impure";
+}
+function shouldExcludeFunction(fn) {
+  if (fn.statementCount < TRIVIAL_STATEMENT_THRESHOLD && !fn.hasConditionals) {
+    return true;
+  }
+  return false;
+}
+function createClassifiedFunction(fn, markers, qualityScore, status) {
+  const classification = classifyFunction(fn, markers);
+  return {
+    ...fn,
+    markers,
+    classification,
+    qualityScore,
+    status
+  };
+}
+
+// src/classification/quality-scorer.ts
+var QUALITY_WEIGHTS = {
+  // Positive signals (additive)
+  callsPureFile: 30,
+  // Calls a function from .pure.ts file
+  callsPureNamingConvention: 20,
+  // Calls plan*/derive*/compute*/calculate*/transform*
+  ioConcentratedAtStart: 15,
+  // I/O calls concentrated at start (GATHER pattern)
+  ioConcentratedAtEnd: 15,
+  // I/O calls concentrated at end (EXECUTE pattern)
+  lowComplexity: 10,
+  // Low cyclomatic complexity (≤ 5)
+  shellNamingConvention: 5,
+  // Function name matches shell conventions
+  callsPredicateFunctions: 5,
+  // Calls is*/has*/should* functions
+  // Negative signals (penalties)
+  ioInterleaved: -20,
+  // I/O calls interleaved throughout
+  highComplexity: -15,
+  // High cyclomatic complexity (> 10)
+  multipleIoTypes: -10,
+  // Multiple I/O types in same function
+  noPureFunctionCalls: -10,
+  // No pure function calls at all
+  veryLongFunction: -10
+  // > 100 lines
+};
+var PURE_FUNCTION_PATTERNS = [
+  /^plan[A-Z]/,
+  /^derive[A-Z]/,
+  /^compute[A-Z]/,
+  /^calculate[A-Z]/,
+  /^transform[A-Z]/,
+  /^build[A-Z]/,
+  /^create[A-Z](?!.*Service)/,
+  // createX but not createXService
+  /^parse[A-Z]/,
+  /^format[A-Z]/,
+  /^validate[A-Z]/,
+  /^normalize[A-Z]/,
+  /^convert[A-Z]/,
+  /^map[A-Z]/,
+  /^filter[A-Z]/,
+  /^reduce[A-Z]/,
+  /^merge[A-Z]/,
+  /^extract[A-Z]/,
+  /^to[A-Z]/
+  // toPublicX, toDTO, etc.
+];
+var PREDICATE_PATTERNS = [
+  /^is[A-Z]/,
+  /^has[A-Z]/,
+  /^should[A-Z]/,
+  /^can[A-Z]/,
+  /^will[A-Z]/,
+  /^was[A-Z]/,
+  /^did[A-Z]/,
+  /^are[A-Z]/,
+  /^does[A-Z]/,
+  /^needs[A-Z]/
+];
+var SHELL_FUNCTION_PATTERNS = [
+  /^handle[A-Z]/,
+  /^fetch[A-Z]/,
+  /^save[A-Z]/,
+  /^send[A-Z]/,
+  /^load[A-Z]/,
+  /^get[A-Z]/,
+  // getData, getUser, etc.
+  /^set[A-Z]/,
+  /^update[A-Z]/,
+  /^delete[A-Z]/,
+  /^remove[A-Z]/,
+  /^create[A-Z].*Service/,
+  // createXService
+  /^init[A-Z]/,
+  /^process[A-Z]/,
+  /^execute[A-Z]/,
+  /^run[A-Z]/,
+  /^perform[A-Z]/
+];
+var IO_MARKER_TYPES = /* @__PURE__ */ new Set([
+  "await-expression",
+  "database-call",
+  "network-fetch",
+  "network-http",
+  "fs-call"
+]);
+function computeQualityScore(fn, markers, context) {
+  let score = 50;
+  const analysis = analyzeFunction(fn, markers, context);
+  if (analysis.callsPureFile) {
+    score += QUALITY_WEIGHTS.callsPureFile;
+  }
+  if (analysis.callsPureNamingConvention) {
+    score += QUALITY_WEIGHTS.callsPureNamingConvention;
+  }
+  if (analysis.ioConcentratedAtStart) {
+    score += QUALITY_WEIGHTS.ioConcentratedAtStart;
+  }
+  if (analysis.ioConcentratedAtEnd) {
+    score += QUALITY_WEIGHTS.ioConcentratedAtEnd;
+  }
+  if (analysis.lowComplexity) {
+    score += QUALITY_WEIGHTS.lowComplexity;
+  }
+  if (analysis.shellNamingConvention) {
+    score += QUALITY_WEIGHTS.shellNamingConvention;
+  }
+  if (analysis.callsPredicateFunctions) {
+    score += QUALITY_WEIGHTS.callsPredicateFunctions;
+  }
+  if (analysis.ioInterleaved) {
+    score += QUALITY_WEIGHTS.ioInterleaved;
+  }
+  if (analysis.highComplexity) {
+    score += QUALITY_WEIGHTS.highComplexity;
+  }
+  if (analysis.multipleIoTypes) {
+    score += QUALITY_WEIGHTS.multipleIoTypes;
+  }
+  if (analysis.noPureFunctionCalls) {
+    score += QUALITY_WEIGHTS.noPureFunctionCalls;
+  }
+  if (analysis.veryLongFunction) {
+    score += QUALITY_WEIGHTS.veryLongFunction;
+  }
+  return Math.max(0, Math.min(100, score));
+}
+function analyzeFunction(fn, markers, context) {
+  const ioMarkers = markers.filter(
+    (m) => IO_MARKER_TYPES.has(m.type) && m.line !== void 0
+  );
+  const uniqueIoTypes = new Set(markers.map((m) => m.type));
+  const callsPureFile = checkCallsPureFile(fn, context);
+  const { callsPureNaming, pureCallCount } = checkCallsPureNamingConvention(
+    fn.callSites
+  );
+  const { callsPredicates, predicateCallCount } = checkCallsPredicateFunctions(
+    fn.callSites
+  );
+  const { concentratedAtStart, concentratedAtEnd, interleaved } = analyzeIoConcentration(fn, ioMarkers);
+  const estimatedComplexity = estimateCyclomaticComplexity(fn);
+  const shellNamingConvention = checkShellNamingConvention(fn.name);
+  return {
+    callsPureFile,
+    callsPureNamingConvention: callsPureNaming,
+    ioConcentratedAtStart: concentratedAtStart,
+    ioConcentratedAtEnd: concentratedAtEnd,
+    lowComplexity: estimatedComplexity <= 5,
+    shellNamingConvention,
+    callsPredicateFunctions: callsPredicates,
+    ioInterleaved: interleaved,
+    highComplexity: estimatedComplexity > 10,
+    multipleIoTypes: uniqueIoTypes.size >= 3,
+    noPureFunctionCalls: pureCallCount === 0 && predicateCallCount === 0,
+    veryLongFunction: fn.bodyLineCount > 100,
+    estimatedComplexity,
+    ioMarkerCount: ioMarkers.length,
+    uniqueIoTypes,
+    pureCallCount,
+    predicateCallCount
+  };
+}
+function checkCallsPureFile(fn, context) {
+  const pureImports = /* @__PURE__ */ new Set();
+  for (const imp of context.imports.imports) {
+    if (context.pureFileImports.has(imp.moduleSpecifier)) {
+      for (const name of imp.namedImports) {
+        pureImports.add(name);
+      }
+    }
+  }
+  for (const callSite of fn.callSites) {
+    const calledFn = extractFunctionName(callSite.expression);
+    if (pureImports.has(calledFn)) {
+      return true;
+    }
+  }
+  return false;
+}
+function checkCallsPureNamingConvention(callSites) {
+  let pureCallCount = 0;
+  for (const callSite of callSites) {
+    const calledFn = extractFunctionName(callSite.expression);
+    if (matchesAnyPattern(calledFn, PURE_FUNCTION_PATTERNS)) {
+      pureCallCount++;
+    }
+  }
+  return {
+    callsPureNaming: pureCallCount > 0,
+    pureCallCount
+  };
+}
+function checkCallsPredicateFunctions(callSites) {
+  let predicateCallCount = 0;
+  for (const callSite of callSites) {
+    const calledFn = extractFunctionName(callSite.expression);
+    if (matchesAnyPattern(calledFn, PREDICATE_PATTERNS)) {
+      predicateCallCount++;
+    }
+  }
+  return {
+    callsPredicates: predicateCallCount > 0,
+    predicateCallCount
+  };
+}
+function analyzeIoConcentration(fn, ioMarkers) {
+  if (ioMarkers.length === 0) {
+    return {
+      concentratedAtStart: false,
+      concentratedAtEnd: false,
+      interleaved: false
+    };
+  }
+  const positions = ioMarkers.map((m) => (m.line ?? 0) / Math.max(fn.bodyLineCount, 1)).sort((a, b) => a - b);
+  const startThreshold = 0.33;
+  const endThreshold = 0.67;
+  const atStart = positions.filter((p) => p <= startThreshold).length;
+  const atEnd = positions.filter((p) => p >= endThreshold).length;
+  const inMiddle = positions.filter(
+    (p) => p > startThreshold && p < endThreshold
+  ).length;
+  const total = positions.length;
+  const concentratedAtStart = atStart >= total * 0.6 && inMiddle <= 1;
+  const concentratedAtEnd = atEnd >= total * 0.6 && inMiddle <= 1;
+  const interleaved = inMiddle >= 2 || atStart > 0 && atEnd > 0 && inMiddle > 0 || total >= 4 && !concentratedAtStart && !concentratedAtEnd;
+  return {
+    concentratedAtStart,
+    concentratedAtEnd,
+    interleaved
+  };
+}
+function estimateCyclomaticComplexity(fn) {
+  let complexity = 1;
+  if (fn.hasConditionals) {
+    complexity += Math.ceil(fn.statementCount / 10);
+  }
+  if (fn.bodyLineCount > 50) {
+    complexity += Math.floor((fn.bodyLineCount - 50) / 25);
+  }
+  return complexity;
+}
+function checkShellNamingConvention(name) {
+  if (!name) return false;
+  return matchesAnyPattern(name, SHELL_FUNCTION_PATTERNS);
+}
+function extractFunctionName(expression) {
+  const parts = expression.split(".");
+  return parts[parts.length - 1] ?? expression;
+}
+function matchesAnyPattern(str, patterns) {
+  return patterns.some((pattern) => pattern.test(str));
+}
+
+// src/classification/derive-status.ts
+function deriveStatus(classification, qualityScore, thresholds = DEFAULT_QUALITY_THRESHOLDS) {
+  if (classification === "pure") {
+    return "ok";
+  }
+  if (qualityScore === null) {
+    return "review";
+  }
+  if (qualityScore >= thresholds.okThreshold) {
+    return "ok";
+  }
+  if (qualityScore >= thresholds.reviewThreshold) {
+    return "review";
+  }
+  return "refactor";
+}
+function getStatusDescription(status) {
+  switch (status) {
+    case "ok":
+      return "No action needed";
+    case "review":
+      return "Consider improving if touching this code";
+    case "refactor":
+      return "Tangled code, prioritize cleanup";
+  }
+}
+function getStatusEmoji(status) {
+  switch (status) {
+    case "ok":
+      return "\u2713";
+    case "review":
+      return "\u25D0";
+    case "refactor":
+      return "\u2717";
+  }
+}
+function getStatusColor(status) {
+  switch (status) {
+    case "ok":
+      return "green";
+    case "review":
+      return "yellow";
+    case "refactor":
+      return "red";
+  }
+}
+
+// src/scoring/scorer.ts
+function scoreFile(filePath, functions, isTypeOnly = false) {
+  if (isTypeOnly) {
+    return {
+      filePath,
+      purity: 100,
+      impurityQuality: null,
+      health: 100,
+      pureCount: 0,
+      impureCount: 0,
+      excludedCount: 0,
+      statusBreakdown: { ok: 0, review: 0, refactor: 0 },
+      pureLineCount: 0,
+      impureLineCount: 0,
+      functions: [],
+      refactoringCandidates: [],
+      typeOnly: true
+    };
+  }
+  const pureFunctions = functions.filter((f) => f.classification === "pure");
+  const impureFunctions = functions.filter((f) => f.classification === "impure");
+  const pureCount = pureFunctions.length;
+  const impureCount = impureFunctions.length;
+  const total = pureCount + impureCount;
+  if (total === 0) {
+    return {
+      filePath,
+      purity: 100,
+      impurityQuality: null,
+      health: 100,
+      pureCount: 0,
+      impureCount: 0,
+      excludedCount: 0,
+      statusBreakdown: { ok: 0, review: 0, refactor: 0 },
+      pureLineCount: 0,
+      impureLineCount: 0,
+      functions: [],
+      refactoringCandidates: [],
+      allExcluded: true
+    };
+  }
+  const purity = pureCount / total * 100;
+  let impurityQuality = null;
+  if (impureCount > 0) {
+    const totalQuality = impureFunctions.reduce(
+      (sum, f) => sum + (f.qualityScore ?? 0),
+      0
+    );
+    impurityQuality = totalQuality / impureCount;
+  }
+  const statusBreakdown = {
+    ok: functions.filter((f) => f.status === "ok").length,
+    review: functions.filter((f) => f.status === "review").length,
+    refactor: functions.filter((f) => f.status === "refactor").length
+  };
+  const health = statusBreakdown.ok / total * 100;
+  const pureLineCount = pureFunctions.reduce(
+    (sum, f) => sum + f.bodyLineCount,
+    0
+  );
+  const impureLineCount = impureFunctions.reduce(
+    (sum, f) => sum + f.bodyLineCount,
+    0
+  );
+  const refactoringCandidates = impureFunctions.filter((f) => f.status === "refactor").map((f) => ({
+    name: f.name,
+    startLine: f.startLine,
+    bodyLineCount: f.bodyLineCount,
+    qualityScore: f.qualityScore ?? 0,
+    markers: f.markers.map((m) => m.type)
+  })).sort((a, b) => {
+    const impactA = a.bodyLineCount * (100 - a.qualityScore);
+    const impactB = b.bodyLineCount * (100 - b.qualityScore);
+    return impactB - impactA;
+  });
+  return {
+    filePath,
+    purity,
+    impurityQuality,
+    health,
+    pureCount,
+    impureCount,
+    excludedCount: 0,
+    statusBreakdown,
+    pureLineCount,
+    impureLineCount,
+    functions,
+    refactoringCandidates
+  };
+}
+function scoreDirectory(dirPath, fileScores) {
+  const scorableFiles = fileScores.filter(
+    (f) => !f.typeOnly && !f.allExcluded && f.pureCount + f.impureCount > 0
+  );
+  if (scorableFiles.length === 0) {
+    return {
+      dirPath,
+      purity: 100,
+      impurityQuality: null,
+      health: 100,
+      pureCount: 0,
+      impureCount: 0,
+      excludedCount: fileScores.reduce((sum, f) => sum + f.excludedCount, 0),
+      statusBreakdown: { ok: 0, review: 0, refactor: 0 },
+      pureLineCount: 0,
+      impureLineCount: 0,
+      fileScores
+    };
+  }
+  const totalPure = scorableFiles.reduce((sum, f) => sum + f.pureCount, 0);
+  const totalImpure = scorableFiles.reduce((sum, f) => sum + f.impureCount, 0);
+  const total = totalPure + totalImpure;
+  const purity = total > 0 ? totalPure / total * 100 : 100;
+  let impurityQuality = null;
+  if (totalImpure > 0) {
+    const weightedQuality = scorableFiles.reduce((sum, f) => {
+      if (f.impurityQuality !== null && f.impureCount > 0) {
+        return sum + f.impurityQuality * f.impureCount;
+      }
+      return sum;
+    }, 0);
+    impurityQuality = weightedQuality / totalImpure;
+  }
+  const statusBreakdown = {
+    ok: scorableFiles.reduce((sum, f) => sum + f.statusBreakdown.ok, 0),
+    review: scorableFiles.reduce((sum, f) => sum + f.statusBreakdown.review, 0),
+    refactor: scorableFiles.reduce(
+      (sum, f) => sum + f.statusBreakdown.refactor,
+      0
+    )
+  };
+  const health = total > 0 ? statusBreakdown.ok / total * 100 : 100;
+  const pureLineCount = scorableFiles.reduce(
+    (sum, f) => sum + f.pureLineCount,
+    0
+  );
+  const impureLineCount = scorableFiles.reduce(
+    (sum, f) => sum + f.impureLineCount,
+    0
+  );
+  return {
+    dirPath,
+    purity,
+    impurityQuality,
+    health,
+    pureCount: totalPure,
+    impureCount: totalImpure,
+    excludedCount: fileScores.reduce((sum, f) => sum + f.excludedCount, 0),
+    statusBreakdown,
+    pureLineCount,
+    impureLineCount,
+    fileScores
+  };
+}
+function scoreProject(directoryScores, options = {}) {
+  const {
+    timestamp = (/* @__PURE__ */ new Date()).toISOString(),
+    commitHash = null,
+    subset = false,
+    filesGlob,
+    errors = []
+  } = options;
+  const scorableDirs = directoryScores.filter(
+    (d) => d.pureCount + d.impureCount > 0
+  );
+  if (scorableDirs.length === 0) {
+    return {
+      purity: 100,
+      impurityQuality: null,
+      health: 100,
+      pureCount: 0,
+      impureCount: 0,
+      excludedCount: directoryScores.reduce(
+        (sum, d) => sum + d.excludedCount,
+        0
+      ),
+      statusBreakdown: { ok: 0, review: 0, refactor: 0 },
+      pureLineCount: 0,
+      impureLineCount: 0,
+      directoryScores,
+      timestamp,
+      commitHash,
+      refactoringCandidates: [],
+      allExcluded: true,
+      ...subset && { subset: true, filesGlob },
+      ...errors.length > 0 && { errors }
+    };
+  }
+  const totalPure = scorableDirs.reduce((sum, d) => sum + d.pureCount, 0);
+  const totalImpure = scorableDirs.reduce((sum, d) => sum + d.impureCount, 0);
+  const total = totalPure + totalImpure;
+  const purity = total > 0 ? totalPure / total * 100 : 100;
+  let impurityQuality = null;
+  if (totalImpure > 0) {
+    const weightedQuality = scorableDirs.reduce((sum, d) => {
+      if (d.impurityQuality !== null && d.impureCount > 0) {
+        return sum + d.impurityQuality * d.impureCount;
+      }
+      return sum;
+    }, 0);
+    impurityQuality = weightedQuality / totalImpure;
+  }
+  const statusBreakdown = {
+    ok: scorableDirs.reduce((sum, d) => sum + d.statusBreakdown.ok, 0),
+    review: scorableDirs.reduce((sum, d) => sum + d.statusBreakdown.review, 0),
+    refactor: scorableDirs.reduce(
+      (sum, d) => sum + d.statusBreakdown.refactor,
+      0
+    )
+  };
+  const health = total > 0 ? statusBreakdown.ok / total * 100 : 100;
+  const pureLineCount = scorableDirs.reduce(
+    (sum, d) => sum + d.pureLineCount,
+    0
+  );
+  const impureLineCount = scorableDirs.reduce(
+    (sum, d) => sum + d.impureLineCount,
+    0
+  );
+  const allCandidates = [];
+  for (const dir of directoryScores) {
+    for (const file of dir.fileScores) {
+      for (const candidate of file.refactoringCandidates) {
+        allCandidates.push({
+          ...candidate,
+          filePath: file.filePath
+        });
+      }
+    }
+  }
+  const refactoringCandidates = allCandidates.sort((a, b) => {
+    const impactA = a.bodyLineCount * (100 - a.qualityScore);
+    const impactB = b.bodyLineCount * (100 - b.qualityScore);
+    return impactB - impactA;
+  });
+  const result = {
+    purity,
+    impurityQuality,
+    health,
+    pureCount: totalPure,
+    impureCount: totalImpure,
+    excludedCount: directoryScores.reduce((sum, d) => sum + d.excludedCount, 0),
+    statusBreakdown,
+    pureLineCount,
+    impureLineCount,
+    directoryScores,
+    timestamp,
+    commitHash,
+    refactoringCandidates
+  };
+  if (subset && filesGlob !== void 0) {
+    result.subset = true;
+    result.filesGlob = filesGlob;
+  }
+  if (errors.length > 0) {
+    result.errors = errors;
+  }
+  return result;
+}
+function groupFilesByDirectory(fileScores) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const fileScore of fileScores) {
+    const dirPath = getDirectoryPath(fileScore.filePath);
+    const existing = groups.get(dirPath);
+    if (existing) {
+      existing.push(fileScore);
+    } else {
+      groups.set(dirPath, [fileScore]);
+    }
+  }
+  return groups;
+}
+function getDirectoryPath(filePath) {
+  const lastSlash = filePath.lastIndexOf("/");
+  if (lastSlash === -1) return ".";
+  return filePath.slice(0, lastSlash);
+}
+function calculateDelta(current, previous) {
+  return {
+    purityDelta: current.purity - previous.purity,
+    impurityQualityDelta: current.impurityQuality !== null && previous.impurityQuality !== null ? current.impurityQuality - previous.impurityQuality : null,
+    healthDelta: current.health - previous.health,
+    pureCountDelta: current.pureCount - previous.pureCount,
+    impureCountDelta: current.impureCount - previous.impureCount
+  };
+}
+function getDiagnosticInsights(score) {
+  const insights = [];
+  if (score.purity >= 60 && score.impurityQuality !== null && score.impurityQuality < 50) {
+    insights.push(
+      "Most code is pure, but the impure code is tangled. Focus on improving the structure of impure functions."
+    );
+  }
+  if (score.purity < 40 && score.impurityQuality !== null && score.impurityQuality >= 70) {
+    insights.push(
+      "Lots of I/O code, but it's well-structured. Consider extracting more pure business logic."
+    );
+  }
+  if (score.purity < 40 && score.impurityQuality !== null && score.impurityQuality < 50) {
+    insights.push(
+      "Significant technical debt in I/O code. Both purity and structure need improvement."
+    );
+  }
+  if (score.health >= 80 && score.purity < 50) {
+    insights.push(
+      "Despite low purity, impure functions are well-structured. Good FCIS patterns in shell code."
+    );
+  }
+  if (score.health < 50) {
+    insights.push(
+      "More than half of functions need attention. Prioritize refactoring candidates."
+    );
+  }
+  return insights;
+}
+
+// src/analyzer.ts
+async function analyze(config) {
+  const errors = [];
+  const extractorOptions = {
+    tsconfigPath: config.tsconfigPath
+  };
+  if (config.filesGlob !== void 0) {
+    extractorOptions.filesGlob = config.filesGlob;
+  }
+  const { sourceFiles } = loadProject(extractorOptions);
+  if (sourceFiles.length === 0) {
+    throw new Error("No source files found to analyze");
+  }
+  const fileScores = [];
+  for (const sourceFile of sourceFiles) {
+    try {
+      const fileScore = analyzeFile(sourceFile);
+      fileScores.push(fileScore);
+    } catch (error) {
+      errors.push({
+        filePath: sourceFile.getFilePath(),
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  if (fileScores.length === 0 && errors.length > 0) {
+    throw new Error(
+      `Failed to analyze any files. ${errors.length} files had errors.`
+    );
+  }
+  const directoryGroups = groupFilesByDirectory(fileScores);
+  const directoryScores = [];
+  for (const [dirPath, files] of directoryGroups) {
+    const dirScore = scoreDirectory(dirPath, files);
+    directoryScores.push(dirScore);
+  }
+  directoryScores.sort((a, b) => a.dirPath.localeCompare(b.dirPath));
+  const projectOptions = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    commitHash: getCommitHash()
+  };
+  if (config.filesGlob !== void 0) {
+    projectOptions.subset = true;
+    projectOptions.filesGlob = config.filesGlob;
+  }
+  if (errors.length > 0) {
+    projectOptions.errors = errors;
+  }
+  const projectScore = scoreProject(directoryScores, projectOptions);
+  return projectScore;
+}
+function analyzeFile(sourceFile) {
+  const filePath = sourceFile.getFilePath();
+  if (isTypeOnlyFile(sourceFile)) {
+    return scoreFile(filePath, [], true);
+  }
+  const functions = extractFunctions(sourceFile);
+  const imports = extractImports(sourceFile);
+  const context = createDetectionContext(imports);
+  const classifiedFunctions = [];
+  for (const fn of functions) {
+    if (shouldExcludeFunction(fn)) {
+      continue;
+    }
+    const markers = detectMarkers(fn, context);
+    const classification = classifyFunction(fn, markers);
+    let qualityScore = null;
+    if (classification === "impure") {
+      qualityScore = computeQualityScore(fn, markers, context);
+    }
+    const status = deriveStatus(
+      classification,
+      qualityScore,
+      DEFAULT_QUALITY_THRESHOLDS
+    );
+    const classifiedFn = createClassifiedFunction(
+      fn,
+      markers,
+      qualityScore,
+      status
+    );
+    classifiedFunctions.push(classifiedFn);
+  }
+  return scoreFile(filePath, classifiedFunctions, false);
+}
+async function analyzeFilePath(tsconfigPath, filePath) {
+  const { sourceFiles } = loadProject({
+    tsconfigPath,
+    filesGlob: filePath
+  });
+  if (sourceFiles.length === 0) {
+    return null;
+  }
+  const sourceFile = sourceFiles[0];
+  if (!sourceFile) {
+    return null;
+  }
+  return analyzeFile(sourceFile);
+}
+function checkThresholds(score, config) {
+  const failures = [];
+  if (config.minHealth !== void 0 && score.health < config.minHealth) {
+    failures.push(
+      `Health ${score.health.toFixed(1)}% is below minimum ${config.minHealth}%`
+    );
+  }
+  if (config.minPurity !== void 0 && score.purity < config.minPurity) {
+    failures.push(
+      `Purity ${score.purity.toFixed(1)}% is below minimum ${config.minPurity}%`
+    );
+  }
+  if (config.minQuality !== void 0 && score.impurityQuality !== null && score.impurityQuality < config.minQuality) {
+    failures.push(
+      `Impurity Quality ${score.impurityQuality.toFixed(1)}% is below minimum ${config.minQuality}%`
+    );
+  }
+  return {
+    passed: failures.length === 0,
+    failures
+  };
+}
+
+// src/detection/markers.ts
+var MARKER_CATALOG = {
+  "await-expression": {
+    type: "await-expression",
+    description: "Await expression indicates I/O suspension point",
+    category: "io",
+    severity: "high"
+  },
+  "database-call": {
+    type: "database-call",
+    description: "Database operation (Prisma/similar ORM call)",
+    category: "io",
+    severity: "high"
+  },
+  "network-fetch": {
+    type: "network-fetch",
+    description: "Native fetch() call for HTTP requests",
+    category: "io",
+    severity: "high"
+  },
+  "network-http": {
+    type: "network-http",
+    description: "HTTP client library call (axios, got, etc.)",
+    category: "io",
+    severity: "high"
+  },
+  "fs-import": {
+    type: "fs-import",
+    description: "Import from file system module",
+    category: "io",
+    severity: "medium"
+  },
+  "fs-call": {
+    type: "fs-call",
+    description: "File system operation call",
+    category: "io",
+    severity: "high"
+  },
+  "env-access": {
+    type: "env-access",
+    description: "Access to process.env environment variables",
+    category: "environment",
+    severity: "medium"
+  },
+  "console-log": {
+    type: "console-log",
+    description: "Console logging call",
+    category: "side-effect",
+    severity: "low"
+  },
+  logging: {
+    type: "logging",
+    description: "Logger service call",
+    category: "side-effect",
+    severity: "low"
+  },
+  telemetry: {
+    type: "telemetry",
+    description: "Analytics/tracking/telemetry call",
+    category: "side-effect",
+    severity: "low"
+  },
+  "queue-enqueue": {
+    type: "queue-enqueue",
+    description: "Message queue enqueue operation",
+    category: "io",
+    severity: "high"
+  },
+  "event-emit": {
+    type: "event-emit",
+    description: "Event emitter emit call",
+    category: "side-effect",
+    severity: "medium"
+  }
+};
+function getMarkerDefinition(type) {
+  return MARKER_CATALOG[type];
+}
+function getAllMarkerTypes() {
+  return Object.keys(MARKER_CATALOG);
+}
+function generateJsonReport(score, options = {}) {
+  const { pretty = true, includeFunction = false } = options;
+  const reportData = prepareReportData(score, includeFunction);
+  if (pretty) {
+    return JSON.stringify(reportData, null, 2);
+  }
+  return JSON.stringify(reportData);
+}
+function prepareReportData(score, includeFunctions) {
+  if (includeFunctions) {
+    return score;
+  }
+  return {
+    ...score,
+    directoryScores: score.directoryScores.map((dir) => ({
+      ...dir,
+      fileScores: dir.fileScores.map((file) => ({
+        ...file,
+        functions: []
+        // Strip function details to reduce size
+      }))
+    }))
+  };
+}
+function writeJsonReport(score, outputPath, options = {}) {
+  const json = generateJsonReport(score, options);
+  const dir = path.dirname(outputPath);
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
+  }
+  fs2.writeFileSync(outputPath, json, "utf-8");
+}
+function readJsonReport(inputPath) {
+  if (!fs2.existsSync(inputPath)) {
+    return null;
+  }
+  const content = fs2.readFileSync(inputPath, "utf-8");
+  return JSON.parse(content);
+}
+function createSummaryJson(score) {
+  return {
+    health: Math.round(score.health * 10) / 10,
+    purity: Math.round(score.purity * 10) / 10,
+    impurityQuality: score.impurityQuality !== null ? Math.round(score.impurityQuality * 10) / 10 : null,
+    pureCount: score.pureCount,
+    impureCount: score.impureCount,
+    statusBreakdown: score.statusBreakdown,
+    timestamp: score.timestamp,
+    commitHash: score.commitHash,
+    topRefactoringCandidates: score.refactoringCandidates.slice(0, 5).map((c) => ({
+      name: c.name,
+      filePath: c.filePath,
+      qualityScore: c.qualityScore
+    }))
+  };
+}
+function generateComparisonReport(current, previous) {
+  const currentSummary = createSummaryJson(current);
+  const previousSummary = createSummaryJson(previous);
+  const delta = {
+    health: Math.round((current.health - previous.health) * 10) / 10,
+    purity: Math.round((current.purity - previous.purity) * 10) / 10,
+    impurityQuality: current.impurityQuality !== null && previous.impurityQuality !== null ? Math.round(
+      (current.impurityQuality - previous.impurityQuality) * 10
+    ) / 10 : null,
+    pureCount: current.pureCount - previous.pureCount,
+    impureCount: current.impureCount - previous.impureCount
+  };
+  const currentCandidateKeys = new Set(
+    current.refactoringCandidates.map((c) => `${c.filePath}:${c.name}`)
+  );
+  const previousCandidateKeys = new Set(
+    previous.refactoringCandidates.map((c) => `${c.filePath}:${c.name}`)
+  );
+  const newRefactoringCandidates = current.refactoringCandidates.filter((c) => !previousCandidateKeys.has(`${c.filePath}:${c.name}`)).map((c) => ({ name: c.name, filePath: c.filePath }));
+  const resolvedRefactoringCandidates = previous.refactoringCandidates.filter((c) => !currentCandidateKeys.has(`${c.filePath}:${c.name}`)).map((c) => ({ name: c.name, filePath: c.filePath }));
+  const improved = delta.health > 0 || delta.health >= 0 && delta.purity > 0 || delta.health >= 0 && delta.impurityQuality !== null && delta.impurityQuality > 0;
+  return {
+    current: currentSummary,
+    previous: previousSummary,
+    delta,
+    improved,
+    newRefactoringCandidates,
+    resolvedRefactoringCandidates
+  };
+}
+function printConsoleReport(score, options = {}) {
+  const { verbose = false } = options;
+  printHeader();
+  printProjectSummary(score);
+  printStatusBreakdown(
+    score.statusBreakdown,
+    score.pureCount + score.impureCount
+  );
+  printInsights(score);
+  if (verbose) {
+    printDirectoryBreakdown(score.directoryScores);
+  } else {
+    printWorstDirectories(score.directoryScores);
+  }
+  printRefactoringCandidates(score.refactoringCandidates.slice(0, 10));
+  if (score.errors && score.errors.length > 0) {
+    printErrors(score.errors);
+  }
+  printFooter(score);
+}
+function printHeader() {
+  console.log();
+  console.log(chalk.bold("FCIS Analysis"));
+  console.log(
+    chalk.gray("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550")
+  );
+  console.log();
+}
+function printProjectSummary(score) {
+  const healthBar = createProgressBar(score.health, 25);
+  const healthColor = score.health >= 70 ? chalk.green : score.health >= 50 ? chalk.yellow : chalk.red;
+  const purityColor = score.purity >= 70 ? chalk.green : score.purity >= 50 ? chalk.yellow : chalk.red;
+  console.log(
+    `Project Health: ${healthColor(score.health.toFixed(0) + "%")} ${healthBar}`
+  );
+  console.log(
+    `  Purity:           ${purityColor(score.purity.toFixed(0) + "%")} (${score.pureCount} pure / ${score.pureCount + score.impureCount} total)`
+  );
+  if (score.impurityQuality !== null) {
+    const qualityColor = score.impurityQuality >= 70 ? chalk.green : score.impurityQuality >= 50 ? chalk.yellow : chalk.red;
+    console.log(
+      `  Impurity Quality: ${qualityColor(score.impurityQuality.toFixed(0) + "%")} average`
+    );
+  }
+  console.log();
+}
+function printStatusBreakdown(breakdown, total) {
+  console.log("Status Breakdown:");
+  const okPercent = total > 0 ? (breakdown.ok / total * 100).toFixed(0) : "0";
+  const reviewPercent = total > 0 ? (breakdown.review / total * 100).toFixed(0) : "0";
+  const refactorPercent = total > 0 ? (breakdown.refactor / total * 100).toFixed(0) : "0";
+  console.log(
+    `  ${chalk.green("\u2713 OK:")}       ${String(breakdown.ok).padStart(4)} functions (${okPercent}%)  \u2014 no action needed`
+  );
+  console.log(
+    `  ${chalk.yellow("\u25D0 Review:")}   ${String(breakdown.review).padStart(4)} functions (${reviewPercent}%)  \u2014 could be improved`
+  );
+  console.log(
+    `  ${chalk.red("\u2717 Refactor:")} ${String(breakdown.refactor).padStart(4)} functions (${refactorPercent}%)  \u2014 tangled, needs work`
+  );
+  console.log();
+}
+function printInsights(score) {
+  const insights = getDiagnosticInsights(score);
+  if (insights.length > 0) {
+    console.log(chalk.bold("Insights:"));
+    for (const insight of insights) {
+      console.log(`  ${chalk.cyan("\u2192")} ${insight}`);
+    }
+    console.log();
+  }
+}
+function printDirectoryBreakdown(directories) {
+  const sorted = [...directories].filter((d) => d.pureCount + d.impureCount > 0).sort((a, b) => a.health - b.health);
+  if (sorted.length === 0) return;
+  console.log(chalk.bold("Directory Breakdown:"));
+  console.log(chalk.gray("\u2500".repeat(80)));
+  console.log(
+    chalk.gray(
+      padEnd("Directory", 45) + padEnd("Health", 10) + padEnd("Purity", 10) + padEnd("Functions", 15)
+    )
+  );
+  console.log(chalk.gray("\u2500".repeat(80)));
+  for (const dir of sorted) {
+    const healthColor = dir.health >= 70 ? chalk.green : dir.health >= 50 ? chalk.yellow : chalk.red;
+    const purityColor = dir.purity >= 70 ? chalk.green : dir.purity >= 50 ? chalk.yellow : chalk.red;
+    const relativePath = toRelativePath(dir.dirPath);
+    const total = dir.pureCount + dir.impureCount;
+    console.log(
+      padEnd(relativePath, 45) + healthColor(padEnd(dir.health.toFixed(0) + "%", 10)) + purityColor(padEnd(dir.purity.toFixed(0) + "%", 10)) + padEnd(`${dir.pureCount}/${total}`, 15)
+    );
+  }
+  console.log();
+}
+function printWorstDirectories(directories) {
+  const sorted = [...directories].filter((d) => d.pureCount + d.impureCount > 0 && d.health < 70).sort((a, b) => a.health - b.health).slice(0, 5);
+  if (sorted.length === 0) return;
+  console.log(chalk.bold("Directories Needing Attention:"));
+  for (const dir of sorted) {
+    const healthColor = dir.health >= 50 ? chalk.yellow : chalk.red;
+    const total = dir.pureCount + dir.impureCount;
+    const relativePath = toRelativePath(dir.dirPath);
+    console.log(
+      `  ${healthColor(dir.health.toFixed(0).padStart(3) + "%")} ` + chalk.gray(`(${dir.pureCount}/${total} pure)`) + ` ${relativePath}`
+    );
+  }
+  console.log();
+}
+function printRefactoringCandidates(candidates) {
+  if (candidates.length === 0) {
+    console.log(chalk.green("No refactoring candidates found. Great job!"));
+    console.log();
+    return;
+  }
+  console.log(chalk.bold("Top Refactoring Candidates:"));
+  console.log(chalk.gray("(Sorted by impact: size \xD7 complexity)"));
+  console.log();
+  for (let i = 0; i < candidates.length; i++) {
+    const candidate = candidates[i];
+    if (!candidate) continue;
+    const qualityColor = candidate.qualityScore >= 40 ? chalk.yellow : chalk.red;
+    const relativePath = toRelativePath(candidate.filePath);
+    console.log(
+      chalk.gray(`${(i + 1).toString().padStart(2)}.`) + ` ${qualityColor(candidate.qualityScore.toFixed(0).padStart(3))}` + chalk.gray("/100") + ` ${chalk.cyan(candidate.name ?? "<anonymous>")}` + chalk.gray(` (${candidate.bodyLineCount} lines)`)
+    );
+    console.log(chalk.gray(`      ${relativePath}:${candidate.startLine}`));
+    if (candidate.markers.length > 0) {
+      const markerStr = candidate.markers.slice(0, 3).join(", ");
+      const more = candidate.markers.length > 3 ? ` +${candidate.markers.length - 3} more` : "";
+      console.log(chalk.gray(`      Markers: ${markerStr}${more}`));
+    }
+    console.log();
+  }
+}
+function printErrors(errors) {
+  console.log(chalk.yellow.bold(`Errors (${errors.length} files skipped):`));
+  for (const err of errors.slice(0, 5)) {
+    console.log(`  ${chalk.yellow("!")} ${err.filePath}`);
+    console.log(chalk.gray(`      ${err.error}`));
+  }
+  if (errors.length > 5) {
+    console.log(chalk.gray(`  ... and ${errors.length - 5} more`));
+  }
+  console.log();
+}
+function printFooter(score) {
+  console.log(
+    chalk.gray("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550")
+  );
+  const timestamp = new Date(score.timestamp).toLocaleString();
+  console.log(chalk.gray(`Generated: ${timestamp}`));
+  if (score.commitHash) {
+    console.log(chalk.gray(`Commit: ${score.commitHash.slice(0, 8)}`));
+  }
+  if (score.subset) {
+    console.log(chalk.yellow(`Subset analysis: ${score.filesGlob}`));
+  }
+  console.log();
+}
+function createProgressBar(percent, width) {
+  const filled = Math.round(percent / 100 * width);
+  const empty = width - filled;
+  const filledChar = "\u2588";
+  const emptyChar = "\u2591";
+  const bar = filledChar.repeat(filled) + emptyChar.repeat(empty);
+  if (percent >= 70) {
+    return chalk.green(bar);
+  } else if (percent >= 50) {
+    return chalk.yellow(bar);
+  } else {
+    return chalk.red(bar);
+  }
+}
+function generateSummaryLine(score) {
+  const parts = [
+    `FCIS Health: ${score.health.toFixed(0)}%`,
+    `Purity: ${score.purity.toFixed(0)}%`
+  ];
+  if (score.impurityQuality !== null) {
+    parts.push(`Impurity Quality: ${score.impurityQuality.toFixed(0)}%`);
+  }
+  return parts.join(" | ");
+}
+function toRelativePath(absolutePath) {
+  const cwd = process.cwd();
+  if (absolutePath.startsWith(cwd)) {
+    const relative2 = path.relative(cwd, absolutePath);
+    return relative2 || ".";
+  }
+  return absolutePath;
+}
+function padEnd(str, length) {
+  if (str.length >= length) return str.slice(0, length);
+  return str + " ".repeat(length - str.length);
+}
+function printFileReport(fileScore) {
+  const healthColor = fileScore.health >= 70 ? chalk.green : fileScore.health >= 50 ? chalk.yellow : chalk.red;
+  const total = fileScore.pureCount + fileScore.impureCount;
+  const relativePath = toRelativePath(fileScore.filePath);
+  console.log();
+  console.log(chalk.bold(relativePath));
+  console.log(
+    `  Health: ${healthColor(fileScore.health.toFixed(0) + "%")} | Purity: ${fileScore.purity.toFixed(0)}% | Functions: ${fileScore.pureCount}/${total} pure`
+  );
+  if (fileScore.functions.length > 0 && fileScore.impureCount > 0) {
+    console.log();
+    console.log("  Functions:");
+    for (const fn of fileScore.functions) {
+      const statusEmoji = getStatusEmoji(fn.status);
+      const statusColor = getStatusColor(fn.status);
+      const colorFn = statusColor === "green" ? chalk.green : statusColor === "yellow" ? chalk.yellow : chalk.red;
+      const name = fn.name ?? "<anonymous>";
+      const classification = fn.classification === "pure" ? chalk.green("pure") : chalk.yellow("impure");
+      const quality = fn.qualityScore !== null ? ` (${fn.qualityScore})` : "";
+      console.log(
+        `    ${colorFn(statusEmoji)} ${name} \u2014 ${classification}${quality}`
+      );
+    }
+  }
+}
+
+export { DEFAULT_QUALITY_THRESHOLDS, MARKER_CATALOG, QUALITY_WEIGHTS, analyze, analyzeFile, analyzeFilePath, analyzeFunction as analyzeFunctionQuality, calculateDelta, checkThresholds, classifyFunction, computeQualityScore, createClassifiedFunction, createDetectionContext, createSummaryJson, deriveStatus, detectMarkers, extractFunctions, extractImports, generateComparisonReport, generateJsonReport, generateSummaryLine, getAllMarkerTypes, getCommitHash, getDiagnosticInsights, getMarkerDefinition, getPureImportedFunctions, getStatusColor, getStatusDescription, getStatusEmoji, groupFilesByDirectory, isTypeOnlyFile, loadProject, printConsoleReport, printFileReport, readJsonReport, scoreDirectory, scoreFile, scoreProject, shouldExcludeFunction, writeJsonReport };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map