ts-unused 1.0.0 → 1.0.2

package/dist/index.js

@@ -0,0 +1,1251 @@
+// src/analyzeProject.ts
+import path8 from "node:path";
+import { Project } from "ts-morph";
+
+// src/findNeverReturnedTypes.ts
+import path2 from "node:path";
+import { SyntaxKind as SyntaxKind2 } from "ts-morph";
+
+// src/analyzeFunctionReturnTypes.ts
+import path from "node:path";
+import { SyntaxKind } from "ts-morph";
+function analyzeFunctionReturnTypes(func, sourceFile, tsConfigDir) {
+  const results = [];
+  const functionName = func.getName();
+  if (!functionName) {
+    return results;
+  }
+  const returnTypeNode = func.getReturnTypeNode();
+  if (!returnTypeNode) {
+    return results;
+  }
+  const returnType = returnTypeNode.getType();
+  const unwrappedPromise = unwrapPromiseType(returnType);
+  const typeToCheck = unwrappedPromise || returnType;
+  if (!typeToCheck.isUnion()) {
+    return results;
+  }
+  const unionTypes = typeToCheck.getUnionTypes();
+  if (unionTypes.length < 2) {
+    return results;
+  }
+  const returnStatements = func.getDescendantsOfKind(SyntaxKind.ReturnStatement);
+  const returnedTypes = [];
+  for (const returnStmt of returnStatements) {
+    const expression = returnStmt.getExpression();
+    if (expression) {
+      const exprType = expression.getType();
+      const unwrapped = unwrapPromiseType(exprType);
+      returnedTypes.push(unwrapped || exprType);
+    }
+  }
+  if (returnedTypes.length === 0) {
+    return results;
+  }
+  for (const returnedType of returnedTypes) {
+    if (returnedType.isAssignableTo(typeToCheck)) {
+      let assignableToAnyBranch = false;
+      for (const unionBranch of unionTypes) {
+        if (returnedType.isAssignableTo(unionBranch)) {
+          assignableToAnyBranch = true;
+          break;
+        }
+      }
+      if (!assignableToAnyBranch) {
+        return results;
+      }
+    }
+  }
+  const enumGroups = new Map;
+  const enumsWithReturnedValues = new Set;
+  for (const unionBranch of unionTypes) {
+    if (unionBranch.isEnumLiteral()) {
+      const enumName = getEnumNameFromLiteral(unionBranch);
+      if (enumName) {
+        if (!enumGroups.has(enumName)) {
+          enumGroups.set(enumName, []);
+        }
+        enumGroups.get(enumName)?.push(unionBranch);
+      }
+    }
+  }
+  for (const [enumName, enumBranches] of enumGroups.entries()) {
+    for (const returnedType of returnedTypes) {
+      for (const enumBranch of enumBranches) {
+        if (isTypeAssignableTo(returnedType, enumBranch)) {
+          enumsWithReturnedValues.add(enumName);
+          break;
+        }
+      }
+      if (enumsWithReturnedValues.has(enumName)) {
+        break;
+      }
+    }
+  }
+  const branchMap = new Map;
+  for (const unionBranch of unionTypes) {
+    const displayName = getTypeDisplayName(unionBranch);
+    if (!branchMap.has(displayName)) {
+      branchMap.set(displayName, unionBranch);
+    }
+  }
+  for (const [displayName, unionBranch] of branchMap.entries()) {
+    if (unionBranch.isEnumLiteral()) {
+      const enumName = getEnumNameFromLiteral(unionBranch);
+      if (enumName && enumsWithReturnedValues.has(enumName)) {
+        continue;
+      }
+    }
+    let isReturned = false;
+    for (const returnedType of returnedTypes) {
+      if (isTypeAssignableTo(returnedType, unionBranch)) {
+        isReturned = true;
+        break;
+      }
+    }
+    if (!isReturned) {
+      const relativePath = path.relative(tsConfigDir, sourceFile.getFilePath());
+      const nameNode = func.getNameNode();
+      if (nameNode) {
+        const startPos = nameNode.getStart();
+        const lineStartPos = nameNode.getStartLinePos();
+        const character = startPos - lineStartPos + 1;
+        const endCharacter = character + functionName.length;
+        results.push({
+          filePath: relativePath,
+          functionName,
+          neverReturnedType: displayName,
+          line: nameNode.getStartLineNumber(),
+          character,
+          endCharacter,
+          severity: "error"
+        });
+      }
+    }
+  }
+  return results;
+}
+function unwrapPromiseType(type) {
+  const symbol = type.getSymbol();
+  if (symbol?.getName() === "Promise") {
+    const typeArgs = type.getTypeArguments();
+    if (typeArgs.length > 0 && typeArgs[0]) {
+      return typeArgs[0];
+    }
+  }
+  return null;
+}
+function isTypeAssignableTo(sourceType, targetType) {
+  if (sourceType.isAssignableTo(targetType)) {
+    return true;
+  }
+  const sourceText = sourceType.getText();
+  const targetText = targetType.getText();
+  const isBooleanLiteral = (text) => text === "true" || text === "false";
+  if (isBooleanLiteral(sourceText) && isBooleanLiteral(targetText)) {
+    return true;
+  }
+  return false;
+}
+function getEnumNameFromLiteral(type) {
+  if (!type.isEnumLiteral()) {
+    return null;
+  }
+  const typeText = type.getText();
+  const cleanedText = typeText.replace(/import\([^)]+\)\./g, "");
+  const lastDotIndex = cleanedText.lastIndexOf(".");
+  if (lastDotIndex > 0) {
+    return cleanedText.substring(0, lastDotIndex);
+  }
+  return null;
+}
+function getTypeDisplayName(type) {
+  const symbol = type.getSymbol();
+  if (symbol) {
+    const name = symbol.getName();
+    if (name && name !== "__type") {
+      return name;
+    }
+  }
+  let typeText = type.getText();
+  typeText = typeText.replace(/import\([^)]+\)\./g, "");
+  if (typeText === "string")
+    return "string";
+  if (typeText === "number")
+    return "number";
+  if (typeText === "boolean")
+    return "boolean";
+  if (typeText === "true" || typeText === "false")
+    return "boolean";
+  if (typeText === "null")
+    return "null";
+  if (typeText === "undefined")
+    return "undefined";
+  const MAX_TYPE_LENGTH = 100;
+  if (typeText.length > MAX_TYPE_LENGTH) {
+    return `${typeText.substring(0, MAX_TYPE_LENGTH)}...`;
+  }
+  return typeText;
+}
+
+// src/hasNoCheck.ts
+function hasNoCheck(sourceFile) {
+  const fullText = sourceFile.getFullText();
+  const firstLine = fullText.split(`
+`)[0];
+  if (!firstLine) {
+    return false;
+  }
+  return firstLine.trim() === "// @ts-nocheck";
+}
+
+// src/findNeverReturnedTypes.ts
+function findNeverReturnedTypes(project, tsConfigDir, isTestFile, onProgress, targetFilePath) {
+  const results = [];
+  for (const sourceFile of project.getSourceFiles()) {
+    if (isTestFile(sourceFile)) {
+      continue;
+    }
+    if (hasNoCheck(sourceFile)) {
+      continue;
+    }
+    if (targetFilePath && sourceFile.getFilePath() !== targetFilePath) {
+      continue;
+    }
+    if (onProgress) {
+      const relativePath = path2.relative(tsConfigDir, sourceFile.getFilePath());
+      onProgress(relativePath);
+    }
+    const functions = sourceFile.getDescendantsOfKind(SyntaxKind2.FunctionDeclaration);
+    for (const func of functions) {
+      const funcResults = analyzeFunctionReturnTypes(func, sourceFile, tsConfigDir);
+      results.push(...funcResults);
+    }
+  }
+  return results;
+}
+
+// src/findUnusedExports.ts
+import path4 from "node:path";
+
+// src/checkExportUsage.ts
+import path3 from "node:path";
+import { Node } from "ts-morph";
+function getExportKind(declaration) {
+  if (Node.isFunctionDeclaration(declaration)) {
+    return "function";
+  }
+  if (Node.isClassDeclaration(declaration)) {
+    return "class";
+  }
+  if (Node.isInterfaceDeclaration(declaration)) {
+    return "interface";
+  }
+  if (Node.isTypeAliasDeclaration(declaration)) {
+    return "type";
+  }
+  if (Node.isEnumDeclaration(declaration)) {
+    return "enum";
+  }
+  if (Node.isModuleDeclaration(declaration)) {
+    return "namespace";
+  }
+  if (Node.isVariableDeclaration(declaration)) {
+    const parent = declaration.getParent();
+    if (Node.isVariableDeclarationList(parent)) {
+      const declarationKind = parent.getDeclarationKind();
+      if (declarationKind === "const") {
+        return "const";
+      }
+    }
+    return "variable";
+  }
+  return "export";
+}
+function getNameNode(declaration) {
+  if (Node.isFunctionDeclaration(declaration) || Node.isClassDeclaration(declaration) || Node.isInterfaceDeclaration(declaration) || Node.isTypeAliasDeclaration(declaration) || Node.isEnumDeclaration(declaration) || Node.isVariableDeclaration(declaration)) {
+    return declaration.getNameNode();
+  }
+  return;
+}
+function checkExportUsage(exportName, declarations, sourceFile, tsConfigDir, isTestFile) {
+  const firstDeclaration = declarations[0];
+  if (!firstDeclaration) {
+    return null;
+  }
+  const declarationSourceFile = firstDeclaration.getSourceFile();
+  if (declarationSourceFile.getFilePath() !== sourceFile.getFilePath()) {
+    return null;
+  }
+  if (!Node.isReferenceFindable(firstDeclaration)) {
+    return null;
+  }
+  const references = firstDeclaration.findReferences();
+  let totalReferences = 0;
+  let testReferences = 0;
+  let nonTestReferences = 0;
+  for (const refGroup of references) {
+    const refs = refGroup.getReferences();
+    for (const ref of refs) {
+      const refSourceFile = ref.getSourceFile();
+      totalReferences++;
+      if (isTestFile(refSourceFile)) {
+        testReferences++;
+      } else {
+        nonTestReferences++;
+      }
+    }
+  }
+  const onlyUsedInTests = nonTestReferences === 1 && testReferences > 0;
+  if (totalReferences > 1 && !onlyUsedInTests) {
+    return null;
+  }
+  const kind = getExportKind(firstDeclaration);
+  const relativePath = path3.relative(tsConfigDir, sourceFile.getFilePath());
+  const severity = onlyUsedInTests ? "info" : "error";
+  const nameNode = getNameNode(firstDeclaration);
+  const positionNode = nameNode || firstDeclaration;
+  const startPos = positionNode.getStart();
+  const lineStartPos = positionNode.getStartLinePos();
+  const character = startPos - lineStartPos + 1;
+  const endCharacter = character + exportName.length;
+  const result = {
+    filePath: relativePath,
+    exportName,
+    line: firstDeclaration.getStartLineNumber(),
+    character,
+    endCharacter,
+    kind,
+    severity,
+    onlyUsedInTests
+  };
+  return result;
+}
+
+// src/findUnusedExports.ts
+function findUnusedExports(project, tsConfigDir, isTestFile, onProgress, targetFilePath) {
+  const results = [];
+  for (const sourceFile of project.getSourceFiles()) {
+    if (isTestFile(sourceFile)) {
+      continue;
+    }
+    if (hasNoCheck(sourceFile)) {
+      continue;
+    }
+    if (targetFilePath && sourceFile.getFilePath() !== targetFilePath) {
+      continue;
+    }
+    if (onProgress) {
+      const relativePath = path4.relative(tsConfigDir, sourceFile.getFilePath());
+      onProgress(relativePath);
+    }
+    const exports = sourceFile.getExportedDeclarations();
+    for (const [exportName, declarations] of exports.entries()) {
+      const unusedExport = checkExportUsage(exportName, declarations, sourceFile, tsConfigDir, isTestFile);
+      if (unusedExport) {
+        results.push(unusedExport);
+      }
+    }
+  }
+  return results;
+}
+
+// src/findUnusedProperties.ts
+import path7 from "node:path";
+
+// src/analyzeInterfaces.ts
+import path5 from "node:path";
+
+// src/extractTodoComment.ts
+function extractTodoComment(prop) {
+  const leadingComments = prop.getLeadingCommentRanges();
+  for (const comment of leadingComments) {
+    const commentText = comment.getText();
+    const singleLineMatch = commentText.match(/\/\/\s*TODO\s+(.+)/i);
+    if (singleLineMatch) {
+      const todoText = singleLineMatch[1];
+      if (todoText) {
+        return todoText.trim();
+      }
+    }
+    const multiLineMatch = commentText.match(/\/\*+\s*TODO\s+(.+?)\*\//is);
+    if (multiLineMatch) {
+      const todoText = multiLineMatch[1];
+      if (todoText) {
+        return todoText.trim().replace(/\s+/g, " ");
+      }
+    }
+  }
+  return;
+}
+
+// src/findStructurallyEquivalentProperties.ts
+import { SyntaxKind as SyntaxKind3 } from "ts-morph";
+function checkInterfaceProperties(iface, propName, propType, originalProp, equivalentProps) {
+  const properties = iface.getProperties();
+  for (const p of properties) {
+    if (p === originalProp) {
+      continue;
+    }
+    if (p.getName() === propName) {
+      const pType = p.getType().getText();
+      if (pType === propType) {
+        equivalentProps.push(p);
+      }
+    }
+  }
+}
+function checkTypeAliasProperties(typeAlias, propName, propType, originalProp, equivalentProps) {
+  const typeNode = typeAlias.getTypeNode();
+  if (!typeNode || typeNode.getKind() !== SyntaxKind3.TypeLiteral) {
+    return;
+  }
+  const properties = typeNode.getChildren().filter((child) => child.getKind() === SyntaxKind3.PropertySignature);
+  for (const p of properties) {
+    if (p === originalProp) {
+      continue;
+    }
+    if (p.getKind() === SyntaxKind3.PropertySignature && p.getName() === propName) {
+      const pType = p.getType().getText();
+      if (pType === propType) {
+        equivalentProps.push(p);
+      }
+    }
+  }
+}
+function findStructurallyEquivalentProperties(prop, project) {
+  const propName = prop.getName();
+  const propType = prop.getType().getText();
+  const equivalentProps = [];
+  const sourceFiles = project.getSourceFiles();
+  for (const sourceFile of sourceFiles) {
+    const interfaces = sourceFile.getInterfaces();
+    for (const iface of interfaces) {
+      checkInterfaceProperties(iface, propName, propType, prop, equivalentProps);
+    }
+    const typeAliases = sourceFile.getTypeAliases();
+    for (const typeAlias of typeAliases) {
+      checkTypeAliasProperties(typeAlias, propName, propType, prop, equivalentProps);
+    }
+  }
+  return equivalentProps;
+}
+
+// src/isPropertyUnused.ts
+function countPropertyReferences(prop, isTestFile) {
+  const references = prop.findReferences();
+  let totalReferences = 0;
+  let testReferences = 0;
+  let nonTestReferences = 0;
+  for (const refGroup of references) {
+    const refs = refGroup.getReferences();
+    for (const ref of refs) {
+      const refSourceFile = ref.getSourceFile();
+      totalReferences++;
+      if (isTestFile(refSourceFile)) {
+        testReferences++;
+      } else {
+        nonTestReferences++;
+      }
+    }
+  }
+  const result = {
+    totalReferences,
+    testReferences,
+    nonTestReferences
+  };
+  return result;
+}
+function isPropertyUnused(prop, isTestFile, project) {
+  const counts = countPropertyReferences(prop, isTestFile);
+  const onlyUsedInTests = counts.nonTestReferences === 1 && counts.testReferences > 0;
+  if (counts.totalReferences > 1 && !onlyUsedInTests) {
+    const result2 = { isUnusedOrTestOnly: false, onlyUsedInTests: false };
+    return result2;
+  }
+  const equivalentProps = findStructurallyEquivalentProperties(prop, project);
+  for (const equivalentProp of equivalentProps) {
+    const equivalentCounts = countPropertyReferences(equivalentProp, isTestFile);
+    const equivalentOnlyUsedInTests = equivalentCounts.nonTestReferences === 1 && equivalentCounts.testReferences > 0;
+    if (equivalentCounts.totalReferences > 1 && !equivalentOnlyUsedInTests) {
+      const result2 = { isUnusedOrTestOnly: false, onlyUsedInTests: false };
+      return result2;
+    }
+  }
+  const result = { isUnusedOrTestOnly: true, onlyUsedInTests };
+  return result;
+}
+
+// src/analyzeInterfaces.ts
+function analyzeInterfaces(sourceFile, tsConfigDir, isTestFile, results, project) {
+  const interfaces = sourceFile.getInterfaces();
+  for (const iface of interfaces) {
+    const interfaceName = iface.getName();
+    for (const prop of iface.getProperties()) {
+      const usage = isPropertyUnused(prop, isTestFile, project);
+      if (usage.isUnusedOrTestOnly) {
+        const relativePath = path5.relative(tsConfigDir, sourceFile.getFilePath());
+        const todoComment = extractTodoComment(prop);
+        let severity = "error";
+        if (todoComment) {
+          severity = "warning";
+        } else if (usage.onlyUsedInTests) {
+          severity = "info";
+        }
+        const propertyName = prop.getName();
+        const startPos = prop.getStart();
+        const lineStartPos = prop.getStartLinePos();
+        const character = startPos - lineStartPos + 1;
+        const endCharacter = character + propertyName.length;
+        const result = {
+          filePath: relativePath,
+          typeName: interfaceName,
+          propertyName,
+          line: prop.getStartLineNumber(),
+          character,
+          endCharacter,
+          todoComment,
+          severity,
+          onlyUsedInTests: usage.onlyUsedInTests
+        };
+        results.push(result);
+      }
+    }
+  }
+}
+
+// src/analyzeTypeAliases.ts
+import path6 from "node:path";
+import { Node as Node2 } from "ts-morph";
+function analyzeTypeLiteralMember(member, typeName, sourceFile, tsConfigDir, isTestFile, results, project) {
+  if (!Node2.isPropertySignature(member)) {
+    return;
+  }
+  const usage = isPropertyUnused(member, isTestFile, project);
+  if (!usage.isUnusedOrTestOnly) {
+    return;
+  }
+  const relativePath = path6.relative(tsConfigDir, sourceFile.getFilePath());
+  const todoComment = extractTodoComment(member);
+  let severity = "error";
+  if (todoComment) {
+    severity = "warning";
+  } else if (usage.onlyUsedInTests) {
+    severity = "info";
+  }
+  const propertyName = member.getName();
+  const startPos = member.getStart();
+  const lineStartPos = member.getStartLinePos();
+  const character = startPos - lineStartPos + 1;
+  const endCharacter = character + propertyName.length;
+  const result = {
+    filePath: relativePath,
+    typeName,
+    propertyName,
+    line: member.getStartLineNumber(),
+    character,
+    endCharacter,
+    todoComment,
+    severity,
+    onlyUsedInTests: usage.onlyUsedInTests
+  };
+  results.push(result);
+}
+function analyzeTypeAlias(typeAlias, sourceFile, tsConfigDir, isTestFile, results, project) {
+  const typeName = typeAlias.getName();
+  const typeNode = typeAlias.getTypeNode();
+  if (!typeNode) {
+    return;
+  }
+  if (!Node2.isTypeLiteral(typeNode)) {
+    return;
+  }
+  for (const member of typeNode.getMembers()) {
+    analyzeTypeLiteralMember(member, typeName, sourceFile, tsConfigDir, isTestFile, results, project);
+  }
+}
+function analyzeTypeAliases(sourceFile, tsConfigDir, isTestFile, results, project) {
+  const typeAliases = sourceFile.getTypeAliases();
+  for (const typeAlias of typeAliases) {
+    analyzeTypeAlias(typeAlias, sourceFile, tsConfigDir, isTestFile, results, project);
+  }
+}
+
+// src/findUnusedProperties.ts
+function findUnusedProperties(project, tsConfigDir, isTestFile, onProgress, targetFilePath) {
+  const results = [];
+  for (const sourceFile of project.getSourceFiles()) {
+    if (isTestFile(sourceFile)) {
+      continue;
+    }
+    if (hasNoCheck(sourceFile)) {
+      continue;
+    }
+    if (targetFilePath && sourceFile.getFilePath() !== targetFilePath) {
+      continue;
+    }
+    if (onProgress) {
+      const relativePath = path7.relative(tsConfigDir, sourceFile.getFilePath());
+      onProgress(relativePath);
+    }
+    analyzeInterfaces(sourceFile, tsConfigDir, isTestFile, results, project);
+    analyzeTypeAliases(sourceFile, tsConfigDir, isTestFile, results, project);
+  }
+  return results;
+}
+
+// src/isTestFile.ts
+var TEST_FILE_EXTENSIONS = [".test.ts", ".test.tsx", ".spec.ts", ".spec.tsx"];
+function isTestFile(sourceFile) {
+  const filePath = sourceFile.getFilePath();
+  return filePath.includes("__tests__") || TEST_FILE_EXTENSIONS.some((ext) => filePath.endsWith(ext));
+}
+
+// src/analyzeProject.ts
+function analyzeProject(tsConfigPath, onProgress, targetFilePath, isTestFile2 = isTestFile) {
+  const project = new Project({
+    tsConfigFilePath: tsConfigPath
+  });
+  const tsConfigDir = path8.dirname(tsConfigPath);
+  const allSourceFiles = project.getSourceFiles();
+  const filesToAnalyze = allSourceFiles.filter((sf) => {
+    if (isTestFile2(sf)) {
+      return false;
+    }
+    if (hasNoCheck(sf)) {
+      return false;
+    }
+    if (targetFilePath && sf.getFilePath() !== targetFilePath) {
+      return false;
+    }
+    return true;
+  });
+  const totalFiles = filesToAnalyze.length;
+  let currentFile = 0;
+  const filesProcessed = new Set;
+  const progressCallback = onProgress ? (filePath) => {
+    if (!filesProcessed.has(filePath)) {
+      filesProcessed.add(filePath);
+      currentFile++;
+      onProgress(currentFile, totalFiles, filePath);
+    }
+  } : undefined;
+  const unusedExports = findUnusedExports(project, tsConfigDir, isTestFile2, progressCallback, targetFilePath);
+  const unusedProperties = findUnusedProperties(project, tsConfigDir, isTestFile2, progressCallback, targetFilePath);
+  const neverReturnedTypes = findNeverReturnedTypes(project, tsConfigDir, isTestFile2, progressCallback, targetFilePath);
+  const unusedFiles = [];
+  const fileExportCounts = new Map;
+  for (const sourceFile of filesToAnalyze) {
+    const filePath = path8.relative(tsConfigDir, sourceFile.getFilePath());
+    const exports = sourceFile.getExportedDeclarations();
+    const totalExports = exports.size;
+    if (totalExports > 0) {
+      fileExportCounts.set(filePath, { total: totalExports, unused: 0, testOnly: 0 });
+    }
+  }
+  for (const unusedExport of unusedExports) {
+    const counts = fileExportCounts.get(unusedExport.filePath);
+    if (counts) {
+      counts.unused++;
+      if (unusedExport.onlyUsedInTests) {
+        counts.testOnly++;
+      }
+    }
+  }
+  for (const [filePath, counts] of fileExportCounts.entries()) {
+    const allExportsUnused = counts.total > 0 && counts.unused === counts.total;
+    const hasAnyTestOnlyExports = counts.testOnly > 0;
+    if (allExportsUnused && !hasAnyTestOnlyExports) {
+      unusedFiles.push(filePath);
+    }
+  }
+  const results = {
+    unusedExports,
+    unusedProperties,
+    unusedFiles,
+    neverReturnedTypes
+  };
+  return results;
+}
+// src/fixProject.ts
+import fs from "node:fs";
+import path10 from "node:path";
+import { Project as Project2, SyntaxKind as SyntaxKind4 } from "ts-morph";
+
+// src/checkGitStatus.ts
+import { execSync } from "node:child_process";
+import path9 from "node:path";
+function checkGitStatus(workingDir) {
+  const changedFiles = new Set;
+  try {
+    const gitRoot = execSync("git rev-parse --show-toplevel", {
+      cwd: workingDir,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "ignore"]
+    }).trim();
+    const output = execSync("git status --porcelain", {
+      cwd: workingDir,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+    const lines = output.trim().split(`
+`);
+    for (const line of lines) {
+      if (!line)
+        continue;
+      const filename = line.slice(3).trim();
+      const actualFilename = filename.includes(" -> ") ? filename.split(" -> ")[1] : filename;
+      if (actualFilename) {
+        const absolutePath = path9.resolve(gitRoot, actualFilename);
+        changedFiles.add(absolutePath);
+      }
+    }
+  } catch (_error) {
+    return changedFiles;
+  }
+  return changedFiles;
+}
+
+// src/fixProject.ts
+function fixProject(tsConfigPath, onProgress, isTestFile2 = isTestFile) {
+  const results = {
+    fixedExports: 0,
+    fixedProperties: 0,
+    fixedNeverReturnedTypes: 0,
+    deletedFiles: 0,
+    skippedFiles: [],
+    errors: []
+  };
+  const analysis = analyzeProject(tsConfigPath, undefined, undefined, isTestFile2);
+  const tsConfigDir = path10.dirname(path10.resolve(tsConfigPath));
+  const filesWithChanges = checkGitStatus(tsConfigDir);
+  const project = new Project2({
+    tsConfigFilePath: tsConfigPath
+  });
+  const deletedFiles = new Set;
+  for (const relativeFilePath of analysis.unusedFiles) {
+    const absoluteFilePath = path10.resolve(tsConfigDir, relativeFilePath);
+    if (filesWithChanges.has(absoluteFilePath)) {
+      onProgress?.(`Skipped: ${relativeFilePath} (has local git changes)`);
+      results.skippedFiles.push(relativeFilePath);
+      continue;
+    }
+    try {
+      onProgress?.(`Deleting: ${relativeFilePath} (all exports unused)`);
+      fs.unlinkSync(absoluteFilePath);
+      deletedFiles.add(relativeFilePath);
+      results.deletedFiles++;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      results.errors.push({ file: relativeFilePath, error: errorMessage });
+      onProgress?.(`Error deleting ${relativeFilePath}: ${errorMessage}`);
+    }
+  }
+  if (deletedFiles.size > 0) {
+    cleanupBrokenImports(project, tsConfigDir, deletedFiles, filesWithChanges, onProgress, results);
+  }
+  const neverReturnedByFile = new Map;
+  for (const neverReturned of analysis.neverReturnedTypes || []) {
+    if (neverReturned.severity !== "error") {
+      continue;
+    }
+    if (!neverReturnedByFile.has(neverReturned.filePath)) {
+      neverReturnedByFile.set(neverReturned.filePath, []);
+    }
+    neverReturnedByFile.get(neverReturned.filePath)?.push(neverReturned);
+  }
+  const unusedExportNames = new Set;
+  for (const unusedExport of analysis.unusedExports) {
+    if (unusedExport.severity === "error") {
+      unusedExportNames.add(`${unusedExport.filePath}:${unusedExport.exportName}`);
+    }
+  }
+  for (const [relativeFilePath, neverReturnedItems] of neverReturnedByFile.entries()) {
+    const absoluteFilePath = path10.resolve(tsConfigDir, relativeFilePath);
+    if (analysis.unusedFiles.includes(relativeFilePath)) {
+      continue;
+    }
+    if (filesWithChanges.has(absoluteFilePath)) {
+      if (!results.skippedFiles.includes(relativeFilePath)) {
+        onProgress?.(`Skipped: ${relativeFilePath} (has local git changes)`);
+        results.skippedFiles.push(relativeFilePath);
+      }
+      continue;
+    }
+    try {
+      const sourceFile = project.getSourceFile(absoluteFilePath);
+      if (!sourceFile) {
+        continue;
+      }
+      onProgress?.(`Fixing: ${relativeFilePath}`);
+      if (neverReturnedItems) {
+        for (const neverReturned of neverReturnedItems) {
+          const exportKey = `${relativeFilePath}:${neverReturned.functionName}`;
+          if (unusedExportNames.has(exportKey)) {
+            continue;
+          }
+          if (removeNeverReturnedType(sourceFile, neverReturned.functionName, neverReturned.neverReturnedType)) {
+            onProgress?.(`  ✓ Removed never-returned type '${neverReturned.neverReturnedType}' from ${neverReturned.functionName}`);
+            results.fixedNeverReturnedTypes++;
+          }
+        }
+      }
+      sourceFile.saveSync();
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      results.errors.push({ file: relativeFilePath, error: errorMessage });
+      onProgress?.(`Error fixing ${relativeFilePath}: ${errorMessage}`);
+    }
+  }
+  const exportsByFile = new Map;
+  for (const unusedExport of analysis.unusedExports) {
+    if (unusedExport.severity !== "error") {
+      continue;
+    }
+    if (!exportsByFile.has(unusedExport.filePath)) {
+      exportsByFile.set(unusedExport.filePath, []);
+    }
+    exportsByFile.get(unusedExport.filePath)?.push(unusedExport);
+  }
+  for (const [relativeFilePath, exports] of exportsByFile.entries()) {
+    const absoluteFilePath = path10.resolve(tsConfigDir, relativeFilePath);
+    if (analysis.unusedFiles.includes(relativeFilePath)) {
+      continue;
+    }
+    if (filesWithChanges.has(absoluteFilePath)) {
+      onProgress?.(`Skipped: ${relativeFilePath} (has local git changes)`);
+      results.skippedFiles.push(relativeFilePath);
+      continue;
+    }
+    try {
+      const sourceFile = project.getSourceFile(absoluteFilePath);
+      if (!sourceFile) {
+        continue;
+      }
+      if (!neverReturnedByFile.has(relativeFilePath)) {
+        onProgress?.(`Fixing: ${relativeFilePath}`);
+      }
+      for (const unusedExport of exports) {
+        if (removeExport(sourceFile, unusedExport.exportName)) {
+          onProgress?.(`  ✓ Removed unused export: ${unusedExport.exportName}`);
+          results.fixedExports++;
+        }
+      }
+      sourceFile.saveSync();
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      results.errors.push({ file: relativeFilePath, error: errorMessage });
+      onProgress?.(`Error fixing ${relativeFilePath}: ${errorMessage}`);
+    }
+  }
+  const propertiesByFile = new Map;
+  for (const unusedProperty of analysis.unusedProperties) {
+    if (unusedProperty.severity !== "error") {
+      continue;
+    }
+    if (!propertiesByFile.has(unusedProperty.filePath)) {
+      propertiesByFile.set(unusedProperty.filePath, []);
+    }
+    propertiesByFile.get(unusedProperty.filePath)?.push(unusedProperty);
+  }
+  for (const [relativeFilePath, properties] of propertiesByFile.entries()) {
+    const absoluteFilePath = path10.resolve(tsConfigDir, relativeFilePath);
+    if (analysis.unusedFiles.includes(relativeFilePath)) {
+      continue;
+    }
+    if (filesWithChanges.has(absoluteFilePath)) {
+      if (!results.skippedFiles.includes(relativeFilePath)) {
+        onProgress?.(`Skipped: ${relativeFilePath} (has local git changes)`);
+        results.skippedFiles.push(relativeFilePath);
+      }
+      continue;
+    }
+    try {
+      const sourceFile = project.getSourceFile(absoluteFilePath);
+      if (!sourceFile) {
+        continue;
+      }
+      if (!exportsByFile.has(relativeFilePath) && !neverReturnedByFile.has(relativeFilePath)) {
+        onProgress?.(`Fixing: ${relativeFilePath}`);
+      }
+      for (const unusedProperty of properties) {
+        if (removeProperty(sourceFile, unusedProperty.typeName, unusedProperty.propertyName)) {
+          onProgress?.(`  ✓ Removed unused property: ${unusedProperty.typeName}.${unusedProperty.propertyName}`);
+          results.fixedProperties++;
+        }
+      }
+      sourceFile.saveSync();
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      results.errors.push({ file: relativeFilePath, error: errorMessage });
+      onProgress?.(`Error fixing ${relativeFilePath}: ${errorMessage}`);
+    }
+  }
+  return results;
+}
+function removeExport(sourceFile, exportName) {
+  const exportedDeclarations = sourceFile.getExportedDeclarations();
+  const declarations = exportedDeclarations.get(exportName);
+  if (!declarations || declarations.length === 0) {
+    return false;
+  }
+  for (const declaration of declarations) {
+    if (declaration.getKind() === SyntaxKind4.VariableDeclaration) {
+      const variableStatement = declaration.getFirstAncestorByKind(SyntaxKind4.VariableStatement);
+      if (variableStatement) {
+        variableStatement.remove();
+        continue;
+      }
+    }
+    if ("remove" in declaration && typeof declaration.remove === "function") {
+      declaration.remove();
+    }
+  }
+  return true;
+}
+function removeProperty(sourceFile, typeName, propertyName) {
+  const interfaces = sourceFile.getInterfaces();
+  for (const iface of interfaces) {
+    if (iface.getName() === typeName) {
+      const property = iface.getProperty(propertyName);
+      if (property) {
+        property.remove();
+        return true;
+      }
+    }
+  }
+  const typeAliases = sourceFile.getTypeAliases();
+  for (const typeAlias of typeAliases) {
+    if (typeAlias.getName() === typeName) {
+      const typeNode = typeAlias.getTypeNode();
+      if (typeNode && typeNode.getKind() === SyntaxKind4.TypeLiteral) {
+        const typeLiteral = typeNode.asKindOrThrow(SyntaxKind4.TypeLiteral);
+        const members = typeLiteral.getMembers();
+        for (const member of members) {
+          if (member.getKind() === SyntaxKind4.PropertySignature) {
+            const propSig = member.asKind(SyntaxKind4.PropertySignature);
+            if (propSig?.getName() === propertyName) {
+              propSig.remove();
+              return true;
+            }
+          }
+        }
+      }
+    }
+  }
+  return false;
+}
+function removeNeverReturnedType(sourceFile, functionName, neverReturnedType) {
+  const functions = sourceFile.getFunctions();
+  for (const func of functions) {
+    if (func.getName() === functionName) {
+      const returnTypeNode = func.getReturnTypeNode();
+      if (!returnTypeNode) {
+        return false;
+      }
+      const returnType = returnTypeNode.getType();
+      let typeToCheck = returnType;
+      let isPromise = false;
+      const symbol = returnType.getSymbol();
+      if (symbol?.getName() === "Promise") {
+        const typeArgs = returnType.getTypeArguments();
+        if (typeArgs.length > 0 && typeArgs[0]) {
+          typeToCheck = typeArgs[0];
+          isPromise = true;
+        }
+      }
+      if (!typeToCheck.isUnion()) {
+        return false;
+      }
+      const unionTypes = typeToCheck.getUnionTypes();
+      const hasInlineObjectType = unionTypes.some((ut) => ut.getSymbol()?.getName() === "__type");
+      const hasEnumLiteral = unionTypes.some((ut) => ut.isEnumLiteral());
+      if (hasInlineObjectType || hasEnumLiteral) {
+        const originalTypeText = returnTypeNode.getText();
+        let typeTextToModify = originalTypeText;
+        let promiseWrapper = "";
+        if (isPromise) {
+          const promiseMatch = originalTypeText.match(/^Promise<(.+)>$/s);
+          if (promiseMatch?.[1]) {
+            typeTextToModify = promiseMatch[1];
+            promiseWrapper = "Promise<>";
+          }
+        }
+        const branches = splitUnionType(typeTextToModify);
+        const normalizedRemove = normalizeTypeText(neverReturnedType === "true" || neverReturnedType === "false" ? "boolean" : neverReturnedType);
+        const remainingBranches = branches.filter((branch) => {
+          const trimmed = branch.trim();
+          const normalized = normalizeTypeText(trimmed === "true" || trimmed === "false" ? "boolean" : trimmed);
+          return normalized !== normalizedRemove;
+        });
+        if (remainingBranches.length === 0 || remainingBranches.length === branches.length) {
+          return false;
+        }
+        let newReturnType = remainingBranches.join(" | ");
+        if (promiseWrapper) {
+          newReturnType = `Promise<${newReturnType}>`;
+        }
+        func.setReturnType(newReturnType);
+        return true;
+      } else {
+        const typesToKeep = [];
+        for (const ut of unionTypes) {
+          const symbol2 = ut.getSymbol();
+          const typeName = symbol2?.getName() || ut.getText();
+          const normalizedName = typeName === "true" || typeName === "false" ? "boolean" : typeName;
+          const normalizedRemove = neverReturnedType === "true" || neverReturnedType === "false" ? "boolean" : neverReturnedType;
+          if (normalizedName !== normalizedRemove && !typesToKeep.includes(typeName)) {
+            typesToKeep.push(typeName);
+          }
+        }
+        let newReturnType;
+        if (typesToKeep.length === 1 && typesToKeep[0]) {
+          newReturnType = typesToKeep[0];
+        } else if (typesToKeep.length > 1) {
+          newReturnType = typesToKeep.join(" | ");
+        }
+        if (!newReturnType) {
+          return false;
+        }
+        if (isPromise) {
+          newReturnType = `Promise<${newReturnType}>`;
+        }
+        func.setReturnType(newReturnType);
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function splitUnionType(typeText) {
+  const branches = [];
+  let current = "";
+  let depth = 0;
+  let inString = false;
+  let stringChar = "";
+  for (let i = 0;i < typeText.length; i++) {
+    const char = typeText[i];
+    const prevChar = i > 0 ? typeText[i - 1] : "";
+    if ((char === '"' || char === "'") && prevChar !== "\\") {
+      if (!inString) {
+        inString = true;
+        stringChar = char;
+      } else if (char === stringChar) {
+        inString = false;
+        stringChar = "";
+      }
+    }
+    if (!inString) {
+      if (char === "{" || char === "<" || char === "(") {
+        depth++;
+      } else if (char === "}" || char === ">" || char === ")") {
+        depth--;
+      } else if (char === "|" && depth === 0) {
+        branches.push(current);
+        current = "";
+        continue;
+      }
+    }
+    current += char;
+  }
+  if (current) {
+    branches.push(current);
+  }
+  return branches;
+}
+function normalizeTypeText(typeText) {
+  return typeText.replace(/;\s*([}\]>])/g, " $1").replace(/\s+/g, " ").trim();
+}
+function cleanupBrokenImports(project, tsConfigDir, deletedFiles, filesWithChanges, onProgress, results) {
+  const sourceFiles = project.getSourceFiles();
+  for (const sourceFile of sourceFiles) {
+    const relativePath = path10.relative(tsConfigDir, sourceFile.getFilePath());
+    const absolutePath = sourceFile.getFilePath();
+    if (filesWithChanges.has(absolutePath)) {
+      continue;
+    }
+    const exportDeclarations = sourceFile.getExportDeclarations();
+    let hasValidExports = false;
+    const brokenExports = [];
+    for (const exportDecl of exportDeclarations) {
+      const moduleSpecifier = exportDecl.getModuleSpecifierValue();
+      if (moduleSpecifier) {
+        const resolvedPath = resolveImportPath(sourceFile.getFilePath(), moduleSpecifier);
+        const relativeResolvedPath = resolvedPath ? path10.relative(tsConfigDir, resolvedPath) : null;
+        if (relativeResolvedPath && deletedFiles.has(relativeResolvedPath)) {
+          brokenExports.push(exportDecl);
+        } else {
+          hasValidExports = true;
+        }
+      } else {
+        hasValidExports = true;
+      }
+    }
+    const hasOwnDeclarations = sourceFile.getFunctions().length > 0 || sourceFile.getClasses().length > 0 || sourceFile.getInterfaces().length > 0 || sourceFile.getTypeAliases().length > 0 || sourceFile.getVariableDeclarations().length > 0 || sourceFile.getEnums().length > 0;
+    if (hasOwnDeclarations) {
+      hasValidExports = true;
+    }
+    if (brokenExports.length > 0 && !hasValidExports) {
+      try {
+        onProgress?.(`Deleting: ${relativePath} (only re-exports from deleted files)`);
+        fs.unlinkSync(absolutePath);
+        if (results) {
+          results.deletedFiles++;
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (results) {
+          results.errors.push({ file: relativePath, error: errorMessage });
+        }
+        onProgress?.(`Error deleting ${relativePath}: ${errorMessage}`);
+      }
+    } else if (brokenExports.length > 0) {
+      try {
+        onProgress?.(`Fixing: ${relativePath}`);
+        for (const exportDecl of brokenExports) {
+          const moduleSpec = exportDecl.getModuleSpecifierValue();
+          exportDecl.remove();
+          onProgress?.(`  ✓ Removed broken re-export from: ${moduleSpec}`);
+        }
+        sourceFile.saveSync();
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (results) {
+          results.errors.push({ file: relativePath, error: errorMessage });
+        }
+        onProgress?.(`Error fixing ${relativePath}: ${errorMessage}`);
+      }
+    }
+  }
+}
+function resolveImportPath(fromFile, importPath) {
+  const fromDir = path10.dirname(fromFile);
+  if (importPath.startsWith(".")) {
+    const resolved = path10.resolve(fromDir, importPath);
+    const extensions = [".ts", ".tsx", ".js", ".jsx"];
+    for (const ext of extensions) {
+      const withExt = resolved + ext;
+      if (fs.existsSync(withExt)) {
+        return withExt;
+      }
+    }
+    for (const ext of extensions) {
+      const indexFile = path10.join(resolved, `index${ext}`);
+      if (fs.existsSync(indexFile)) {
+        return indexFile;
+      }
+    }
+    return `${resolved}.ts`;
+  }
+  return null;
+}
+// src/formatResults.ts
+import path11 from "node:path";
+function getSeverityMarker(severity) {
+  const markers = {
+    error: "[ERROR]",
+    warning: "[WARNING]",
+    info: "[INFO]"
+  };
+  return markers[severity];
+}
+function formatExportLine(item) {
+  const marker = getSeverityMarker(item.severity);
+  if (item.onlyUsedInTests) {
+    return `  ${item.exportName}:${item.line}:${item.character}-${item.endCharacter} ${marker} (Used only in tests)`;
+  }
+  return `  ${item.exportName}:${item.line}:${item.character}-${item.endCharacter} ${marker} (Unused ${item.kind})`;
+}
+function formatPropertyLine(item) {
+  const status = item.onlyUsedInTests ? "Used only in tests" : "Unused property";
+  const todoSuffix = item.todoComment ? `: [TODO] ${item.todoComment}` : "";
+  const marker = getSeverityMarker(item.severity);
+  return `  ${item.typeName}.${item.propertyName}:${item.line}:${item.character}-${item.endCharacter} ${marker} (${status}${todoSuffix})`;
+}
+function formatNeverReturnedLine(item) {
+  const marker = getSeverityMarker(item.severity);
+  return `  ${item.functionName}:${item.line}:${item.character}-${item.endCharacter} ${marker} (Type '${item.neverReturnedType}' in return type is never returned)`;
+}
+function formatGroupedItems(items, formatter, tsConfigDir, cwd) {
+  const lines = [];
+  const grouped = groupByFile(items);
+  for (const [filePath, groupItems] of grouped.entries()) {
+    const absolutePath = path11.resolve(tsConfigDir, filePath);
+    const relativePath = path11.relative(cwd, absolutePath);
+    lines.push(relativePath);
+    for (const item of groupItems) {
+      lines.push(formatter(item));
+    }
+    lines.push("");
+  }
+  return lines;
+}
+function formatResults(results, tsConfigDir) {
+  const lines = [];
+  const cwd = process.cwd();
+  const unusedExportNames = new Set;
+  for (const exportItem of results.unusedExports) {
+    unusedExportNames.add(exportItem.exportName);
+  }
+  const propertiesToReport = results.unusedProperties.filter((prop) => !unusedExportNames.has(prop.typeName));
+  const unusedFileSet = new Set(results.unusedFiles);
+  const exportsToReport = results.unusedExports.filter((exp) => !unusedFileSet.has(exp.filePath));
+  if (results.unusedFiles.length > 0) {
+    lines.push("Completely Unused Files:");
+    lines.push("");
+    for (const filePath of results.unusedFiles) {
+      const absolutePath = path11.resolve(tsConfigDir, filePath);
+      const relativePath = path11.relative(cwd, absolutePath);
+      lines.push(relativePath);
+      lines.push("  file:1:1-1 [ERROR] (All exports unused - file can be deleted)");
+      lines.push("");
+    }
+  }
+  if (exportsToReport.length > 0) {
+    lines.push("Unused Exports:");
+    lines.push("");
+    lines.push(...formatGroupedItems(exportsToReport, formatExportLine, tsConfigDir, cwd));
+  }
+  if (propertiesToReport.length > 0) {
+    lines.push("Unused Type/Interface Properties:");
+    lines.push("");
+    lines.push(...formatGroupedItems(propertiesToReport, formatPropertyLine, tsConfigDir, cwd));
+  }
+  const neverReturnedTypes = results.neverReturnedTypes || [];
+  if (neverReturnedTypes.length > 0) {
+    lines.push("Never-Returned Types:");
+    lines.push("");
+    lines.push(...formatGroupedItems(neverReturnedTypes, formatNeverReturnedLine, tsConfigDir, cwd));
+  }
+  if (results.unusedFiles.length === 0 && exportsToReport.length === 0 && propertiesToReport.length === 0 && neverReturnedTypes.length === 0) {
+    lines.push("No unused exports or properties found!");
+  } else {
+    lines.push("Summary:");
+    lines.push(`  Completely unused files: ${results.unusedFiles.length}`);
+    lines.push(`  Unused exports: ${exportsToReport.length}`);
+    lines.push(`  Unused properties: ${propertiesToReport.length}`);
+    lines.push(`  Never-returned types: ${neverReturnedTypes.length}`);
+  }
+  return lines.join(`
+`);
+}
+function groupByFile(items) {
+  const grouped = new Map;
+  for (const item of items) {
+    const existing = grouped.get(item.filePath);
+    if (existing) {
+      existing.push(item);
+    } else {
+      grouped.set(item.filePath, [item]);
+    }
+  }
+  return grouped;
+}
+export {
+  isTestFile,
+  formatResults,
+  fixProject,
+  findUnusedProperties,
+  findUnusedExports,
+  analyzeProject
+};