@kridaydave/code-mapper 1.0.0 → 1.0.1

package/src/parser/ComplexityAnalyzer.ts

@@ -1,275 +0,0 @@
-import { SourceFile, Project, SyntaxKind } from "ts-morph";
-import { ParseResult } from "./types.js";
-
-export interface ComplexityResult {
-  filePath: string;
-  relativePath: string;
-  cyclomaticComplexity: number;
-  cognitiveComplexity: number;
-  nestingDepth: number;
-  linesOfCode: number;
-  functionCount: number;
-  classCount: number;
-  overallScore: number;
-  issues: string[];
-}
-
-export class ComplexityAnalyzer {
-  private project: Project;
-  private baseDirectory: string;
-
-  constructor(project: Project, baseDirectory: string) {
-    this.project = project;
-    this.baseDirectory = baseDirectory;
-  }
-
-  analyze(sourceFile: SourceFile): ComplexityResult {
-    const filePath = sourceFile.getFilePath();
-    const relativePath = this.getRelativePath(filePath);
-    const linesOfCode = sourceFile.getEndLineNumber() ?? 0;
-    const functionCount = sourceFile.getFunctions().length;
-    const classCount = sourceFile.getClasses().length;
-
-    const cyclomaticComplexity = this.calculateCyclomaticComplexity(sourceFile);
-    const cognitiveComplexity = this.calculateCognitiveComplexity(sourceFile);
-    const nestingDepth = this.calculateNestingDepth(sourceFile);
-
-    const issues = this.identifyIssues({
-      cyclomaticComplexity,
-      cognitiveComplexity,
-      nestingDepth,
-      linesOfCode,
-      functionCount,
-      classCount,
-    });
-
-    const overallScore = this.calculateOverallScore({
-      cyclomaticComplexity,
-      cognitiveComplexity,
-      nestingDepth,
-      linesOfCode,
-      functionCount,
-      classCount,
-    });
-
-    return {
-      filePath,
-      relativePath,
-      cyclomaticComplexity,
-      cognitiveComplexity,
-      nestingDepth,
-      linesOfCode,
-      functionCount,
-      classCount,
-      overallScore,
-      issues,
-    };
-  }
-
-  analyzeProject(parseResult: ParseResult): ComplexityResult[] {
-    const results: ComplexityResult[] = [];
-
-    for (const fileInfo of parseResult.files) {
-      try {
-        const sourceFile = this.project.getSourceFile(fileInfo.filePath);
-        if (sourceFile) {
-          results.push(this.analyze(sourceFile));
-        }
-      } catch {
-        // Skip files that can't be parsed
-      }
-    }
-
-    return results;
-  }
-
-  getTopComplexFiles(n: number): ComplexityResult[] {
-    const sourceFiles = this.project.getSourceFiles();
-
-    const results: ComplexityResult[] = [];
-    for (const sourceFile of sourceFiles) {
-      results.push(this.analyze(sourceFile));
-    }
-
-    return results
-      .sort((a, b) => b.overallScore - a.overallScore)
-      .slice(0, n);
-  }
-
-  private getRelativePath(target: string): string {
-    const baseParts = this.baseDirectory.replace(/\\/g, "/").split("/").filter(Boolean);
-    const targetParts = target.replace(/\\/g, "/").split("/").filter(Boolean);
-
-    let i = 0;
-    while (i < baseParts.length && i < targetParts.length && baseParts[i] === targetParts[i]) {
-      i++;
-    }
-
-    if (i < baseParts.length) {
-      return targetParts.slice(i).join("/");
-    }
-
-    const up = baseParts.length - i;
-    const down = targetParts.slice(i);
-    return [...Array(up).fill(".."), ...down].join("/");
-  }
-
-  private calculateCyclomaticComplexity(sourceFile: SourceFile): number {
-    let complexity = 1;
-
-    sourceFile.forEachDescendant(node => {
-      const kind = node.getKind();
-      if (
-        kind === SyntaxKind.IfStatement ||
-        kind === SyntaxKind.ForStatement ||
-        kind === SyntaxKind.ForInStatement ||
-        kind === SyntaxKind.ForOfStatement ||
-        kind === SyntaxKind.WhileStatement ||
-        kind === SyntaxKind.SwitchStatement ||
-        kind === SyntaxKind.CatchClause ||
-        kind === SyntaxKind.BinaryExpression
-      ) {
-        if (kind === SyntaxKind.BinaryExpression) {
-          const text = node.getText();
-          if (text.includes("&&") || text.includes("||")) {
-            complexity++;
-          }
-        } else {
-          complexity++;
-        }
-      }
-    });
-
-    return complexity;
-  }
-
-  private calculateCognitiveComplexity(sourceFile: SourceFile): number {
-    let complexity = 0;
-    let nestingLevel = 0;
-
-    const incrementComplexity = (kind: SyntaxKind, text?: string) => {
-      complexity++;
-      if (kind === SyntaxKind.IfStatement ||
-          kind === SyntaxKind.ForStatement ||
-          kind === SyntaxKind.ForInStatement ||
-          kind === SyntaxKind.ForOfStatement ||
-          kind === SyntaxKind.WhileStatement ||
-          kind === SyntaxKind.SwitchStatement ||
-          kind === SyntaxKind.CatchClause ||
-          kind === SyntaxKind.TryStatement ||
-          kind === SyntaxKind.ConditionalExpression) {
-        nestingLevel++;
-      }
-      if (text) {
-        if (text.includes("&&") || text.includes("||")) {
-          complexity += nestingLevel;
-        }
-      }
-    };
-
-    const decrementNesting = (kind: SyntaxKind) => {
-      if (kind === SyntaxKind.IfStatement ||
-          kind === SyntaxKind.ForStatement ||
-          kind === SyntaxKind.ForInStatement ||
-          kind === SyntaxKind.ForOfStatement ||
-          kind === SyntaxKind.WhileStatement ||
-          kind === SyntaxKind.SwitchStatement ||
-          kind === SyntaxKind.CatchClause ||
-          kind === SyntaxKind.TryStatement ||
-          kind === SyntaxKind.ConditionalExpression) {
-        nestingLevel = Math.max(0, nestingLevel - 1);
-      }
-    };
-
-    sourceFile.forEachDescendant(node => {
-      const kind = node.getKind();
-      const text = kind === SyntaxKind.BinaryExpression ? node.getText() : undefined;
-      incrementComplexity(kind, text);
-    });
-
-    return complexity;
-  }
-
-  private calculateNestingDepth(sourceFile: SourceFile): number {
-    let maxNesting = 0;
-    let currentNesting = 0;
-
-    sourceFile.forEachDescendant(node => {
-      const kind = node.getKind();
-      if (this.isControlStructure(kind)) {
-        currentNesting++;
-        maxNesting = Math.max(maxNesting, currentNesting);
-      }
-    });
-
-    return maxNesting;
-  }
-
-  private isControlStructure(kind: SyntaxKind): boolean {
-    return kind === SyntaxKind.IfStatement ||
-           kind === SyntaxKind.ForStatement ||
-           kind === SyntaxKind.ForInStatement ||
-           kind === SyntaxKind.ForOfStatement ||
-           kind === SyntaxKind.WhileStatement ||
-           kind === SyntaxKind.SwitchStatement ||
-           kind === SyntaxKind.TryStatement ||
-           kind === SyntaxKind.CatchClause;
-  }
-
-  private identifyIssues(metrics: {
-    cyclomaticComplexity: number;
-    cognitiveComplexity: number;
-    nestingDepth: number;
-    linesOfCode: number;
-    functionCount: number;
-    classCount: number;
-  }): string[] {
-    const issues: string[] = [];
-
-    if (metrics.cyclomaticComplexity > 10) {
-      issues.push(`Cyclomatic complexity (${metrics.cyclomaticComplexity}) exceeds threshold of 10`);
-    }
-
-    if (metrics.cognitiveComplexity > 15) {
-      issues.push(`Cognitive complexity (${metrics.cognitiveComplexity}) exceeds threshold of 15`);
-    }
-
-    if (metrics.nestingDepth > 4) {
-      issues.push(`Nesting depth (${metrics.nestingDepth}) exceeds threshold of 4`);
-    }
-
-    if (metrics.linesOfCode > 500) {
-      issues.push(`Lines of code (${metrics.linesOfCode}) exceeds 500 - file is large`);
-    }
-
-    if (metrics.functionCount > 20) {
-      issues.push(`Function count (${metrics.functionCount}) exceeds 20 - too many functions`);
-    }
-
-    if (metrics.classCount > 10) {
-      issues.push(`Class count (${metrics.classCount}) exceeds 10 - too many classes`);
-    }
-
-    return issues;
-  }
-
-  private calculateOverallScore(metrics: {
-    cyclomaticComplexity: number;
-    cognitiveComplexity: number;
-    nestingDepth: number;
-    linesOfCode: number;
-    functionCount: number;
-    classCount: number;
-  }): number {
-    let score = 0;
-
-    score += Math.min(metrics.cyclomaticComplexity * 4, 25);
-    score += Math.min(metrics.cognitiveComplexity * 3, 25);
-    score += Math.min(metrics.nestingDepth * 5, 25);
-    score += Math.min((metrics.linesOfCode / 500) * 15, 15);
-    score += Math.min((metrics.functionCount / 20) * 5, 5);
-    score += Math.min((metrics.classCount / 10) * 5, 5);
-
-    return Math.min(Math.round(score), 100);
-  }
-}

package/src/parser/FileAnalyzer.ts

@@ -1,215 +0,0 @@
-import { SourceFile, Project } from "ts-morph";
-import { FileInfo, FunctionInfo, ClassInfo, ImportInfo, ExportInfo, MethodInfo, PropertyInfo } from "./types.js";
-
-export class FileAnalyzer {
-  private project: Project;
-  private baseDirectory: string;
-
-  constructor(project: Project, baseDirectory: string) {
-    this.project = project;
-    this.baseDirectory = baseDirectory;
-  }
-
-  analyze(sourceFile: SourceFile): FileInfo {
-    const filePath = sourceFile.getFilePath();
-    const relativePath = this.relativePath(this.baseDirectory, filePath);
-
-    return {
-      filePath,
-      relativePath,
-      functions: this.extractFunctions(sourceFile),
-      classes: this.extractClasses(sourceFile),
-      imports: this.extractImports(sourceFile),
-      exports: this.extractExports(sourceFile),
-      totalLines: sourceFile.getEndLineNumber() ?? 0,
-    };
-  }
-
-  private relativePath(base: string, target: string): string {
-    const baseParts = base.replace(/\\/g, "/").split("/").filter(Boolean);
-    const targetParts = target.replace(/\\/g, "/").split("/").filter(Boolean);
-
-    // Find common prefix
-    let i = 0;
-    while (i < baseParts.length && i < targetParts.length && baseParts[i] === targetParts[i]) {
-      i++;
-    }
-
-    // Verify target is actually within base directory
-    if (i < baseParts.length) {
-      throw new Error(`Target path is not within base directory: ${target} not in ${base}`);
-    }
-
-    const up = baseParts.length - i;
-    const down = targetParts.slice(i);
-    return [...Array(up).fill(".."), ...down].join("/");
-  }
-
-  private extractFunctions(sourceFile: SourceFile): FunctionInfo[] {
-    return sourceFile.getFunctions().map(fn => {
-      const name = fn.getName() ?? "anonymous";
-      const params = fn.getParameters().map(p => {
-        const paramName = p.getName();
-        const paramType = p.getTypeNode()?.getText() ?? "unknown";
-        return `${paramName}: ${paramType}`;
-      });
-      const returnType = fn.getReturnTypeNode()?.getText() ?? "void";
-       const body = fn.getBody()?.getText() ?? "";
-       const truncatedBody = [...body].slice(0, 200).join("");
-
-       return {
-         name,
-         filePath: sourceFile.getFilePath(),
-         lineNumber: fn.getStartLineNumber(),
-         parameters: params,
-         returnType,
-         isAsync: fn.isAsync(),
-         isExported: fn.isExported(),
-         isDefaultExport: fn.isDefaultExport(),
-         body: truncatedBody,
-       };
-    });
-  }
-
-  private extractClasses(sourceFile: SourceFile): ClassInfo[] {
-    return sourceFile.getClasses().map(cls => {
-      const methods: MethodInfo[] = cls.getMethods().map(m => ({
-        name: m.getName() ?? "anonymous",
-        parameters: m.getParameters().map(p => `${p.getName()}: ${p.getTypeNode()?.getText() ?? "unknown"}`),
-        returnType: m.getReturnTypeNode()?.getText() ?? "void",
-        isStatic: m.isStatic(),
-        isAsync: m.isAsync(),
-        lineNumber: m.getStartLineNumber(),
-      }));
-
-      const properties: PropertyInfo[] = cls.getProperties().map(p => ({
-        name: p.getName(),
-        type: p.getTypeNode()?.getText() ?? "unknown",
-        isStatic: p.isStatic(),
-        isReadonly: p.isReadonly(),
-        lineNumber: p.getStartLineNumber(),
-      }));
-
-      const extendsClause = cls.getExtends();
-      const implementsClauses = cls.getImplements();
-
-      return {
-        name: cls.getName() ?? "anonymous",
-        filePath: sourceFile.getFilePath(),
-        lineNumber: cls.getStartLineNumber(),
-        isExported: cls.isExported(),
-        isDefaultExport: cls.isDefaultExport(),
-        extends: extendsClause?.getText() ?? null,
-        implements: implementsClauses.map(i => i.getText()),
-        methods,
-        properties,
-      };
-    });
-  }
-
-  private extractImports(sourceFile: SourceFile): ImportInfo[] {
-    return sourceFile.getImportDeclarations().map(imp => {
-      const namedImports = imp.getNamedImports().map(n => n.getName());
-      const defaultImport = imp.getDefaultImport()?.getText() ?? null;
-      const namespaceImport = imp.getNamespaceImport()?.getText() ?? null;
-
-      return {
-        namedImports,
-        defaultImport,
-        namespaceImport,
-        moduleSpecifier: imp.getModuleSpecifierValue() ?? null,
-        filePath: sourceFile.getFilePath(),
-        lineNumber: imp.getStartLineNumber(),
-      };
-    });
-  }
-
-  private extractExports(sourceFile: SourceFile): ExportInfo[] {
-    const exports: ExportInfo[] = [];
-
-    sourceFile.getFunctions().forEach(fn => {
-      if (fn.isExported()) {
-        exports.push({
-          name: fn.getName() ?? "anonymous",
-          kind: "function",
-          isDefault: fn.isDefaultExport(),
-          filePath: sourceFile.getFilePath(),
-          lineNumber: fn.getStartLineNumber(),
-        });
-      }
-    });
-
-    sourceFile.getClasses().forEach(cls => {
-      if (cls.isExported()) {
-        exports.push({
-          name: cls.getName() ?? "anonymous",
-          kind: "class",
-          isDefault: cls.isDefaultExport(),
-          filePath: sourceFile.getFilePath(),
-          lineNumber: cls.getStartLineNumber(),
-        });
-      }
-    });
-
-    sourceFile.getExportDeclarations().forEach(exp => {
-      const namedExports = exp.getNamedExports();
-      if (namedExports.length > 0) {
-        namedExports.forEach(ne => {
-          exports.push({
-            name: ne.getName(),
-            kind: "re-export",
-            isDefault: false,
-            filePath: sourceFile.getFilePath(),
-            lineNumber: exp.getStartLineNumber(),
-          });
-        });
-      }
-    });
-
-    sourceFile.getVariableStatements().forEach(stmt => {
-      if (stmt.isExported()) {
-        stmt.getDeclarations().forEach(decl => {
-          exports.push({
-            name: decl.getName(),
-            kind: "variable" as const,
-            isDefault: false,
-            filePath: sourceFile.getFilePath(),
-            lineNumber: stmt.getStartLineNumber(),
-          });
-        });
-      }
-    });
-
-    sourceFile.getTypeAliases().forEach(ta => {
-      if (ta.isExported()) {
-        exports.push({
-          name: ta.getName(),
-          kind: "type" as const,
-          isDefault: false,
-          filePath: sourceFile.getFilePath(),
-          lineNumber: ta.getStartLineNumber(),
-        });
-      }
-    });
-
-    sourceFile.getInterfaces().forEach(iface => {
-      if (iface.isExported()) {
-        exports.push({
-          name: iface.getName(),
-          kind: "interface" as const,
-          isDefault: false,
-          filePath: sourceFile.getFilePath(),
-          lineNumber: iface.getStartLineNumber(),
-        });
-      }
-    });
-
-    const seen = new Set<string>();
-    return exports.filter(exp => {
-      const key = `${exp.name}|${exp.kind}|${exp.lineNumber}`;
-      if (seen.has(key)) return false;
-      seen.add(key);
-      return true;
-    });
-  }
-}

package/src/parser/ProjectParser.test.ts

@@ -1,96 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { ProjectParser } from "../parser/ProjectParser.js";
-import path from "node:path";
-
-describe("ProjectParser", () => {
-  let parser: ProjectParser;
-
-  beforeEach(() => {
-    parser = new ProjectParser();
-  });
-
-  describe("parse", () => {
-    it("should parse a directory and return file info", async () => {
-      const testDir = path.resolve("./fixtures/test-project");
-      const result = await parser.parse(testDir);
-
-      expect(result.totalFiles).toBe(3);
-      expect(result.totalFunctions).toBeGreaterThan(0);
-      expect(result.files.length).toBe(3);
-    }, 30000);
-
-    it("should count functions correctly", async () => {
-      const testDir = path.resolve("./fixtures/test-project");
-      const result = await parser.parse(testDir);
-
-      expect(result.totalFunctions).toBe(3);
-    });
-
-    it("should count classes correctly", async () => {
-      const testDir = path.resolve("./fixtures/test-project");
-      const result = await parser.parse(testDir);
-
-      expect(result.totalClasses).toBe(1);
-    });
-
-    it("should count imports correctly", async () => {
-      const testDir = path.resolve("./fixtures/test-project");
-      const result = await parser.parse(testDir);
-
-      expect(result.totalImports).toBeGreaterThan(0);
-    });
-
-    it("should count exports correctly", async () => {
-      const testDir = path.resolve("./fixtures/test-project");
-      const result = await parser.parse(testDir);
-
-      expect(result.totalExports).toBeGreaterThan(0);
-    });
-
-    it("should cache results for same directory", async () => {
-      const testDir = path.resolve("./fixtures/test-project");
-      const result1 = await parser.parse(testDir);
-      const result2 = await parser.parse(testDir);
-
-      expect(result1).toBe(result2);
-    });
-
-    it("should throw for non-existent directory", async () => {
-      await expect(parser.parse("/non/existent/path")).rejects.toThrow();
-    });
-
-    it("should return empty result for empty directory", async () => {
-      const emptyDir = path.resolve("./fixtures/empty-project");
-      const fs = await import("node:fs");
-      fs.mkdirSync(emptyDir, { recursive: true });
-      
-      try {
-        const result = await parser.parse(emptyDir);
-        expect(result.totalFiles).toBe(0);
-        expect(result.files).toEqual([]);
-      } finally {
-        fs.rmSync(emptyDir, { recursive: true, force: true });
-      }
-    });
-  });
-
-  describe("clearCache", () => {
-    it("should clear cache for specific directory", async () => {
-      const testDir = path.resolve("./fixtures/test-project");
-      await parser.parse(testDir);
-      
-      parser.clearCache(testDir);
-      const result = await parser.parse(testDir);
-      expect(result.totalFiles).toBe(3);
-    });
-
-    it("should clear all caches when no directory specified", async () => {
-      const testDir = path.resolve("./fixtures/test-project");
-      await parser.parse(testDir);
-      
-      parser.clearCache();
-      const result = await parser.parse(testDir);
-      expect(result.totalFiles).toBe(3);
-    });
-  });
-});