fcis 0.1.0

package/dist/cli.js

@@ -0,0 +1,1836 @@
+#!/usr/bin/env node
+import { cli } from 'cleye';
+import { z } from 'zod';
+import chalk from 'chalk';
+import * as fs3 from 'fs';
+import * as path4 from 'path';
+import { Project, SyntaxKind } from 'ts-morph';
+
+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 = path4.resolve(tsconfigPath);
+  if (!fs3.existsSync(absoluteTsconfigPath)) {
+    throw new Error(`tsconfig.json not found at: ${absoluteTsconfigPath}`);
+  }
+  try {
+    const content = fs3.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
+  };
+}
+
+// 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";
+}
+
+// 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 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);
+}
+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
+  };
+}
+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 = path4.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 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 = path4.dirname(outputPath);
+  if (!fs3.existsSync(dir)) {
+    fs3.mkdirSync(dir, { recursive: true });
+  }
+  fs3.writeFileSync(outputPath, json, "utf-8");
+}
+
+// src/cli.ts
+var EXIT_SUCCESS = 0;
+var EXIT_THRESHOLD_FAILED = 1;
+var EXIT_CONFIG_ERROR = 2;
+var EXIT_ANALYSIS_ERROR = 3;
+var ThresholdSchema = z.number().min(0).max(100);
+var argv = cli({
+  name: "fcis",
+  version: "0.1.0",
+  flags: {
+    json: {
+      type: Boolean,
+      description: "Output JSON to stdout (for piping/parsing)",
+      default: false
+    },
+    output: {
+      type: String,
+      alias: "o",
+      description: "Write JSON report to file"
+    },
+    minHealth: {
+      type: Number,
+      description: "Exit with code 1 if project health < N (0-100)"
+    },
+    minPurity: {
+      type: Number,
+      description: "Exit with code 1 if purity < N (0-100)"
+    },
+    minQuality: {
+      type: Number,
+      description: "Exit with code 1 if impurity quality < N (0-100)"
+    },
+    files: {
+      type: String,
+      alias: "f",
+      description: "Analyze only files matching glob (for incremental/pre-commit)"
+    },
+    format: {
+      type: String,
+      description: "Output format: console (default), json, summary",
+      default: "console"
+    },
+    quiet: {
+      type: Boolean,
+      alias: "q",
+      description: "Suppress all output except errors; rely on exit code",
+      default: false
+    },
+    verbose: {
+      type: Boolean,
+      alias: "v",
+      description: "Show per-file scores and all classified functions",
+      default: false
+    }
+  },
+  parameters: ["<tsconfig>"],
+  help: {
+    description: "Analyze TypeScript code for Functional Core, Imperative Shell patterns",
+    examples: [
+      "fcis analyze tsconfig.json",
+      "fcis analyze tsconfig.json --min-health 70",
+      "fcis analyze tsconfig.json --format json --output report.json",
+      'fcis analyze tsconfig.json --files "src/services/**/*.ts"'
+    ]
+  }
+});
+async function main() {
+  const { flags, _: args } = argv;
+  const tsconfigPath = args.tsconfig;
+  if (!tsconfigPath) {
+    console.error(chalk.red("Error: tsconfig path is required"));
+    console.error("Usage: fcis <tsconfig> [options]");
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  const absoluteTsconfigPath = path4.resolve(tsconfigPath);
+  if (!fs3.existsSync(absoluteTsconfigPath)) {
+    console.error(
+      chalk.red(`Error: tsconfig.json not found at: ${absoluteTsconfigPath}`)
+    );
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  try {
+    const content = fs3.readFileSync(absoluteTsconfigPath, "utf-8");
+    const strippedContent = stripJsonComments(content);
+    JSON.parse(strippedContent);
+  } catch (e) {
+    console.error(
+      chalk.red(`Error: Invalid tsconfig.json at ${absoluteTsconfigPath}`)
+    );
+    console.error(e instanceof Error ? e.message : String(e));
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  if (flags.minHealth !== void 0) {
+    const result = ThresholdSchema.safeParse(flags.minHealth);
+    if (!result.success) {
+      console.error(
+        chalk.red("Error: --min-health must be a number between 0 and 100")
+      );
+      process.exit(EXIT_CONFIG_ERROR);
+    }
+  }
+  if (flags.minPurity !== void 0) {
+    const result = ThresholdSchema.safeParse(flags.minPurity);
+    if (!result.success) {
+      console.error(
+        chalk.red("Error: --min-purity must be a number between 0 and 100")
+      );
+      process.exit(EXIT_CONFIG_ERROR);
+    }
+  }
+  if (flags.minQuality !== void 0) {
+    const result = ThresholdSchema.safeParse(flags.minQuality);
+    if (!result.success) {
+      console.error(
+        chalk.red("Error: --min-quality must be a number between 0 and 100")
+      );
+      process.exit(EXIT_CONFIG_ERROR);
+    }
+  }
+  const validFormats = ["console", "json", "summary"];
+  if (!validFormats.includes(flags.format)) {
+    console.error(
+      chalk.red(`Error: --format must be one of: ${validFormats.join(", ")}`)
+    );
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  if (flags.output) {
+    const outputDir = path4.dirname(path4.resolve(flags.output));
+    if (!fs3.existsSync(outputDir)) {
+      try {
+        fs3.mkdirSync(outputDir, { recursive: true });
+      } catch (e) {
+        console.error(
+          chalk.red(`Error: Cannot create output directory: ${outputDir}`)
+        );
+        process.exit(EXIT_CONFIG_ERROR);
+      }
+    }
+  }
+  try {
+    if (!flags.quiet && flags.format === "console") {
+      console.log(chalk.gray(`Analyzing ${process.cwd()}...`));
+    }
+    const config = {
+      tsconfigPath: absoluteTsconfigPath,
+      format: flags.format,
+      quiet: flags.quiet,
+      verbose: flags.verbose
+    };
+    if (flags.files !== void 0) {
+      config.filesGlob = flags.files;
+    }
+    if (flags.minHealth !== void 0) {
+      config.minHealth = flags.minHealth;
+    }
+    if (flags.minPurity !== void 0) {
+      config.minPurity = flags.minPurity;
+    }
+    if (flags.minQuality !== void 0) {
+      config.minQuality = flags.minQuality;
+    }
+    if (flags.output !== void 0) {
+      config.outputPath = flags.output;
+    }
+    const score = await analyze(config);
+    if (!flags.quiet) {
+      if (flags.json || flags.format === "json") {
+        console.log(generateJsonReport(score, { pretty: true }));
+      } else if (flags.format === "summary") {
+        console.log(generateSummaryLine(score));
+      } else {
+        printConsoleReport(score, { verbose: flags.verbose });
+      }
+    }
+    if (flags.output) {
+      writeJsonReport(score, flags.output, { pretty: true });
+      if (!flags.quiet && flags.format !== "json") {
+        console.log(chalk.green(`Report written to: ${flags.output}`));
+      }
+    }
+    const thresholdConfig = {};
+    if (flags.minHealth !== void 0) {
+      thresholdConfig.minHealth = flags.minHealth;
+    }
+    if (flags.minPurity !== void 0) {
+      thresholdConfig.minPurity = flags.minPurity;
+    }
+    if (flags.minQuality !== void 0) {
+      thresholdConfig.minQuality = flags.minQuality;
+    }
+    const thresholdResult = checkThresholds(score, thresholdConfig);
+    if (!thresholdResult.passed) {
+      if (!flags.quiet) {
+        console.log();
+        console.log(chalk.red.bold("Threshold check failed:"));
+        for (const failure of thresholdResult.failures) {
+          console.log(chalk.red(`  \u2717 ${failure}`));
+        }
+      }
+      process.exit(EXIT_THRESHOLD_FAILED);
+    }
+    process.exit(EXIT_SUCCESS);
+  } catch (error) {
+    if (!flags.quiet) {
+      console.error(chalk.red("Analysis failed:"));
+      console.error(error instanceof Error ? error.message : String(error));
+    }
+    if (error instanceof Error && error.message.includes("No source files")) {
+      process.exit(EXIT_ANALYSIS_ERROR);
+    }
+    process.exit(EXIT_ANALYSIS_ERROR);
+  }
+}
+main();
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map