ts-analyzer 1.2.0 → 1.3.0

package/src/code-complexity.ts

@@ -40,6 +40,12 @@ export interface FileComplexityMetrics {
   functionCount: number;
   complexityScore: number;
   complexityRating: string;
+  codeSmells: {
+    magicNumbers: number;
+    callbackHell: number;
+    godFiles: number; // For God Classes/Files
+    excessiveParameters: number;
+  };
 }
 
 export interface CodeComplexityMetrics {
@@ -52,6 +58,12 @@ export interface CodeComplexityMetrics {
   totalFunctions: number;
   complexFiles: number;
   overallComplexity: string;
+  codeSmells: {
+    magicNumbers: number;
+    callbackHell: number;
+    godFiles: number;
+    excessiveParameters: number;
+  };
 }
 
 // Calculate cyclomatic complexity
@@ -171,8 +183,8 @@ function analyzeFunctions(ast: any): FunctionData[] {
         functions.push({
           type: node.type,
           name: node.id ? node.id.name : 'anonymous',
-          complexity,
-          nestingDepth,
+          complexity: node.complexity || complexity,
+          nestingDepth: node.nestingDepth || nestingDepth,
           paramCount,
           lineCount
         });
@@ -202,6 +214,13 @@ function parseTypeScriptFile(content: string): SimplifiedProgram {
 
     // Function to visit TypeScript nodes and extract function information
     function visit(node: ts.Node) {
+      if (ts.isLiteralExpression(node) && node.kind === ts.SyntaxKind.NumericLiteral) {
+          simplifiedAst.body.push({
+             type: 'Literal',
+             value: parseFloat(node.text)
+          });
+      }
+
       if (ts.isFunctionDeclaration(node) ||
           ts.isMethodDeclaration(node) ||
           ts.isArrowFunction(node) ||
@@ -210,7 +229,47 @@ function parseTypeScriptFile(content: string): SimplifiedProgram {
         const startLine = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
         const endLine = sourceFile.getLineAndCharacterOfPosition(node.getEnd()).line + 1;
 
-        const functionNode = {
+        // Calculate complexity and nesting for this TS function
+        let complexity = 1;
+        let maxNesting = 0;
+        let currentNesting = 0;
+
+        function checkNode(n: ts.Node) {
+            // Complexity
+            if (ts.isIfStatement(n) || ts.isConditionalExpression(n) || ts.isCaseClause(n) ||
+                ts.isForStatement(n) || ts.isForInStatement(n) || ts.isForOfStatement(n) ||
+                ts.isWhileStatement(n) || ts.isDoStatement(n)) {
+                complexity++;
+            }
+            if (ts.isBinaryExpression(n)) {
+                if (n.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken ||
+                    n.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
+                    complexity++;
+                }
+            }
+
+            // Nesting
+            const isNestingNode = ts.isBlock(n) || ts.isIfStatement(n) || ts.isSwitchStatement(n) ||
+                                  ts.isForStatement(n) || ts.isForInStatement(n) || ts.isForOfStatement(n) ||
+                                  ts.isWhileStatement(n) || ts.isDoStatement(n) || ts.isTryStatement(n);
+
+            if (isNestingNode) {
+                currentNesting++;
+                maxNesting = Math.max(maxNesting, currentNesting);
+            }
+
+            ts.forEachChild(n, checkNode);
+
+            if (isNestingNode) {
+                currentNesting--;
+            }
+        }
+
+        if (node.body) {
+            checkNode(node.body);
+        }
+
+        const functionNode: any = {
           type: ts.isFunctionDeclaration(node) ? 'FunctionDeclaration' :
               ts.isArrowFunction(node) ? 'ArrowFunctionExpression' : 'FunctionExpression',
           id: ts.isFunctionDeclaration(node) && node.name ? { name: node.name.text } : undefined,
@@ -219,10 +278,13 @@ function parseTypeScriptFile(content: string): SimplifiedProgram {
           loc: {
             start: { line: startLine },
             end: { line: endLine }
-          }
+          },
+          complexity,
+          nestingDepth: maxNesting
         };
 
         simplifiedAst.body.push(functionNode);
+        return; // Don't recurse into function body for the main visit (already handled by checkNode)
       }
 
       ts.forEachChild(node, visit);
@@ -271,7 +333,8 @@ export async function analyzeFileComplexity(filePath: string): Promise<FileCompl
           avgParams: '0',
           functionCount: 0,
           complexityScore: 0,
-          complexityRating: 'N/A'
+          complexityRating: 'N/A',
+          codeSmells: { magicNumbers: 0, callbackHell: 0, godFiles: 0, excessiveParameters: 0 }
         };
       }
     }
@@ -279,6 +342,29 @@ export async function analyzeFileComplexity(filePath: string): Promise<FileCompl
     // Analyze the functions in the file
     const functions = analyzeFunctions(ast);
 
+    let magicNumbers = 0;
+    estraverse.traverse(ast, {
+      enter(node: any) {
+        if (node.type === 'Literal' && typeof node.value === 'number') {
+          // A magic number could be considered > 10
+          if (node.value > 10 || node.value < -10) {
+            magicNumbers++;
+          }
+        }
+      }
+    });
+
+    // Check for god file (> 500 lines)
+    const lineCount = content.split('\n').length;
+    const godFiles = lineCount > 500 ? 1 : 0;
+
+    let callbackHell = 0;
+    let excessiveParameters = 0;
+    functions.forEach(fn => {
+        if (fn.nestingDepth > 3) callbackHell++;
+        if (fn.paramCount > 4) excessiveParameters++;
+    });
+
     if (functions.length === 0) {
       return {
         avgComplexity: '0',
@@ -289,7 +375,8 @@ export async function analyzeFileComplexity(filePath: string): Promise<FileCompl
         avgParams: '0',
         functionCount: 0,
         complexityScore: 0,
-        complexityRating: 'N/A'
+        complexityRating: 'N/A',
+        codeSmells: { magicNumbers, callbackHell, godFiles, excessiveParameters }
       };
     }
 
@@ -340,7 +427,8 @@ export async function analyzeFileComplexity(filePath: string): Promise<FileCompl
       avgParams: avgParams.toFixed(1),
       functionCount: functions.length,
       complexityScore: Math.round(totalScore),
-      complexityRating
+      complexityRating,
+      codeSmells: { magicNumbers, callbackHell, godFiles, excessiveParameters }
     };
   } catch (error) {
     console.error(`Error analyzing file complexity for ${filePath}:`, error);
@@ -353,7 +441,8 @@ export async function analyzeFileComplexity(filePath: string): Promise<FileCompl
       avgParams: '0',
       functionCount: 0,
       complexityScore: 0,
-      complexityRating: 'N/A'
+      complexityRating: 'N/A',
+      codeSmells: { magicNumbers: 0, callbackHell: 0, godFiles: 0, excessiveParameters: 0 }
     };
   }
 }
@@ -372,7 +461,8 @@ export async function calculateProjectComplexity(projectPath: string, fileList:
       avgFunctionSize: '0.0',
       totalFunctions: 0,
       complexFiles: 0,
-      overallComplexity: 'N/A'
+      overallComplexity: 'N/A',
+      codeSmells: { magicNumbers: 0, callbackHell: 0, godFiles: 0, excessiveParameters: 0 }
     };
   }
 
@@ -384,6 +474,8 @@ export async function calculateProjectComplexity(projectPath: string, fileList:
   let totalFunctions = 0;
   let complexFiles = 0;
 
+  let totalSmells = { magicNumbers: 0, callbackHell: 0, godFiles: 0, excessiveParameters: 0 };
+
   for (const file of jsFiles) {
     const filePath = path.join(projectPath, file);
     const metrics = await analyzeFileComplexity(filePath);
@@ -395,6 +487,11 @@ export async function calculateProjectComplexity(projectPath: string, fileList:
     maxNestingDepthGlobal = Math.max(maxNestingDepthGlobal, metrics.maxNestingDepth);
     totalFunctions += metrics.functionCount;
 
+    totalSmells.magicNumbers += metrics.codeSmells.magicNumbers;
+    totalSmells.callbackHell += metrics.codeSmells.callbackHell;
+    totalSmells.godFiles += metrics.codeSmells.godFiles;
+    totalSmells.excessiveParameters += metrics.codeSmells.excessiveParameters;
+
     if (metrics.complexityRating === 'High') {
       complexFiles++;
     }
@@ -426,6 +523,7 @@ export async function calculateProjectComplexity(projectPath: string, fileList:
     avgFunctionSize,
     totalFunctions,
     complexFiles,
-    overallComplexity
+    overallComplexity,
+    codeSmells: totalSmells
   };
 }

package/src/html-formatter.ts

@@ -0,0 +1,159 @@
+import { ProjectStats } from './index.js';
+import process from 'process';
+import path from 'path';
+
+export function generateHtmlReport(stats: ProjectStats): string {
+    return `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>ts-analyzer Report</title>
+    <style>
+        body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif; margin: 0; padding: 20px; background-color: #f8f9fa; color: #212529; }
+        .container { max-width: 1200px; margin: 0 auto; background: white; padding: 30px; border-radius: 8px; box-shadow: 0 4px 6px rgba(0,0,0,0.05); border: 1px solid #e9ecef; }
+        h1, h2, h3 { color: #343a40; }
+        .grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(280px, 1fr)); gap: 20px; margin-bottom: 30px; }
+        .card { background: #fff; padding: 20px; border-radius: 6px; border: 1px solid #dee2e6; box-shadow: 0 2px 4px rgba(0,0,0,0.02); }
+        .card h3 { margin-top: 0; margin-bottom: 10px; font-size: 15px; color: #6c757d; text-transform: uppercase; letter-spacing: 0.5px; }
+        .card .value { font-size: 32px; font-weight: bold; color: #007bff; }
+        table { width: 100%; border-collapse: collapse; margin-bottom: 30px; }
+        th, td { padding: 12px 15px; text-align: left; border-bottom: 1px solid #dee2e6; }
+        th { background-color: #f8f9fa; font-weight: 600; color: #495057; }
+        tr:hover { background-color: #f8f9fa; }
+        .progress-bar { width: 100%; background-color: #e9ecef; border-radius: 4px; height: 24px; overflow: hidden; margin-top: 10px; }
+        .progress { height: 100%; background-color: #28a745; display: flex; align-items: center; justify-content: center; color: white; font-size: 12px; font-weight: bold; }
+        .progress.warning { background-color: #ffc107; color: #212529; }
+        .progress.danger { background-color: #dc3545; }
+        .footer { margin-top: 40px; text-align: center; color: #6c757d; font-size: 14px; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div style="display: flex; justify-content: space-between; align-items: center; border-bottom: 2px solid #f8f9fa; padding-bottom: 20px; margin-bottom: 30px;">
+            <h1 style="margin: 0;">TS Analyzer Report</h1>
+            <div style="color: #6c757d;">Generated: ${new Date().toLocaleString()}</div>
+        </div>
+
+        <h2>Project Summary</h2>
+        <div class="grid">
+            <div class="card">
+                <h3>Total Files</h3>
+                <div class="value">${stats.formatNumber(stats.files)}</div>
+            </div>
+            <div class="card">
+                <h3>Total Lines</h3>
+                <div class="value">${stats.formatNumber(stats.totalLines)}</div>
+            </div>
+            <div class="card">
+                <h3>Code Lines</h3>
+                <div class="value" style="color: #28a745">${stats.formatNumber(stats.codeLines)}</div>
+            </div>
+            <div class="card">
+                <h3>Comment Lines</h3>
+                <div class="value" style="color: #6c757d">${stats.formatNumber(stats.commentLines)}</div>
+            </div>
+        </div>
+
+        <h2>Files by Type</h2>
+        <table>
+            <thead>
+                <tr>
+                    <th>Extension</th>
+                    <th>Files</th>
+                    <th>Total Lines</th>
+                    <th>Code Lines</th>
+                    <th>% of Codebase</th>
+                </tr>
+            </thead>
+            <tbody>
+                ${stats.formattedFileTypes?.map(type => `
+                    <tr>
+                        <td><strong>${type['Extension']}</strong></td>
+                        <td>${type['Files']}</td>
+                        <td>${type['Total Lines']}</td>
+                        <td>${type['Code Lines']}</td>
+                        <td>
+                            <div style="display: flex; align-items: center; gap: 10px;">
+                                <div style="flex-grow: 1; height: 8px; background: #e9ecef; border-radius: 4px; overflow: hidden;">
+                                    <div style="height: 100%; width: ${type['% of Codebase']}; background: #007bff;"></div>
+                                </div>
+                                <span style="font-size: 14px; width: 50px;">${type['% of Codebase']}</span>
+                            </div>
+                        </td>
+                    </tr>
+                `).join('') || ''}
+            </tbody>
+        </table>
+
+        ${stats.typescriptSafety ? `
+            <h2>TypeScript Safety</h2>
+            <div class="grid">
+                <div class="card">
+                    <h3>Type Coverage</h3>
+                    <div class="value">${stats.typescriptSafety.avgTypeCoverage}%</div>
+                    <div class="progress-bar">
+                        <div class="progress ${parseFloat(stats.typescriptSafety.avgTypeCoverage) < 80 ? 'warning' : ''}" style="width: ${stats.typescriptSafety.avgTypeCoverage}%"></div>
+                    </div>
+                </div>
+                <div class="card">
+                    <h3>Type Safety Score</h3>
+                    <div class="value">${stats.typescriptSafety.avgTypeSafetyScore} <span style="font-size: 16px; color: #6c757d">/ 100</span></div>
+                    <div class="progress-bar">
+                        <div class="progress ${stats.typescriptSafety.avgTypeSafetyScore < 80 ? 'warning' : ''}" style="width: ${stats.typescriptSafety.avgTypeSafetyScore}%"></div>
+                    </div>
+                </div>
+                <div class="card">
+                    <h3>'any' Type Usage</h3>
+                    <div class="value" style="color: ${stats.typescriptSafety.totalAnyCount > 10 ? '#dc3545' : '#28a745'}">${stats.formatNumber(stats.typescriptSafety.totalAnyCount)}</div>
+                </div>
+            </div>
+        ` : ''}
+
+        ${stats.codeComplexity ? `
+            <h2>Code Complexity</h2>
+            <div class="grid">
+                <div class="card">
+                    <h3>Average Complexity</h3>
+                    <div class="value" style="color: ${parseFloat(stats.codeComplexity.avgComplexity) > 5 ? '#ffc107' : '#28a745'}">${stats.codeComplexity.avgComplexity}</div>
+                </div>
+                <div class="card">
+                    <h3>Max Complexity</h3>
+                    <div class="value" style="color: ${stats.codeComplexity.maxComplexity > 15 ? '#dc3545' : '#28a745'}">${stats.formatNumber(stats.codeComplexity.maxComplexity)}</div>
+                </div>
+                <div class="card">
+                    <h3>Complex Files</h3>
+                    <div class="value" style="color: ${stats.codeComplexity.complexFiles > 0 ? '#dc3545' : '#28a745'}">${stats.formatNumber(stats.codeComplexity.complexFiles)}</div>
+                </div>
+            </div>
+
+            <h2>Anti-Patterns & Code Smells</h2>
+            <div class="grid">
+                <div class="card">
+                    <h3>Callback Hell</h3>
+                    <div class="value" style="color: ${stats.codeComplexity.codeSmells.callbackHell > 0 ? '#dc3545' : '#28a745'}">${stats.formatNumber(stats.codeComplexity.codeSmells.callbackHell)}</div>
+                </div>
+                <div class="card">
+                    <h3>God Files (> 500 lines)</h3>
+                    <div class="value" style="color: ${stats.codeComplexity.codeSmells.godFiles > 0 ? '#dc3545' : '#28a745'}">${stats.formatNumber(stats.codeComplexity.codeSmells.godFiles)}</div>
+                </div>
+                <div class="card">
+                    <h3>Excessive Params (> 4)</h3>
+                    <div class="value" style="color: ${stats.codeComplexity.codeSmells.excessiveParameters > 0 ? '#dc3545' : '#28a745'}">${stats.formatNumber(stats.codeComplexity.codeSmells.excessiveParameters)}</div>
+                </div>
+                <div class="card">
+                    <h3>Magic Numbers</h3>
+                    <div class="value" style="color: ${stats.codeComplexity.codeSmells.magicNumbers > 0 ? '#ffc107' : '#28a745'}">${stats.formatNumber(stats.codeComplexity.codeSmells.magicNumbers)}</div>
+                </div>
+            </div>
+        ` : ''}
+
+        <div class="footer">
+            Generated by ts-analyzer &bull; A comprehensive TypeScript code analyzer
+        </div>
+    </div>
+</body>
+</html>
+    `;
+}

package/src/typescript-safety.ts

@@ -2,6 +2,7 @@
 import * as ts from 'typescript';
 import fs from 'fs/promises';
 import path from 'path';
+import { constrainedMemory } from 'process';
 
 export interface TypeScriptMetrics {
     totalTypeableNodes: number;
@@ -14,6 +15,7 @@ export interface TypeScriptMetrics {
     genericsCount: number;
     typeSafetyScore: number;
     typeComplexity: string;
+    
 }
 
 export interface TypeScriptSafetyMetrics {
@@ -33,7 +35,7 @@ export interface TypeScriptSafetyMetrics {
 export async function analyzeTypeScriptSafety(filePath: string): Promise<TypeScriptMetrics> {
     try {
         const content = await fs.readFile(filePath, 'utf8');
-
+        
         // Create a source file
         const sourceFile = ts.createSourceFile(
             filePath,

package/test/complexity.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { analyzeFileComplexity } from '../src/code-complexity.js';
+import fs from 'fs/promises';
+import path from 'path';
+
+describe('analyzeFileComplexity', () => {
+    const testFilePath = path.join(process.cwd(), 'temp_complexity_test.ts');
+
+    afterEach(async () => {
+        try {
+            await fs.unlink(testFilePath);
+        } catch (e) {}
+    });
+
+    it('should calculate basic cyclomatic complexity', async () => {
+        const content = `
+function complexFunc(a: number) {
+    if (a > 0) {
+        return 1;
+    } else {
+        return 0;
+    }
+}
+`;
+        await fs.writeFile(testFilePath, content);
+        const metrics = await analyzeFileComplexity(testFilePath);
+
+        expect(metrics.maxComplexity).toBe(2); // One if statement
+        expect(metrics.functionCount).toBe(1);
+    });
+
+    it('should detect callback hell (nesting depth)', async () => {
+        const content = `
+function nestedFunc() {
+    if (a) {
+        if (b) {
+            if (c) {
+                if (d) {
+                    console.log('Deeply nested');
+                }
+            }
+        }
+    }
+}
+`;
+        await fs.writeFile(testFilePath, content);
+        const metrics = await analyzeFileComplexity(testFilePath);
+
+        expect(metrics.maxNestingDepth).toBeGreaterThanOrEqual(4);
+        expect(metrics.codeSmells.callbackHell).toBe(1);
+    });
+
+    it('should detect magic numbers', async () => {
+        const content = `
+const a = 1234; // Magic number (> 10)
+const b = -5678; // Magic number (< -10)
+const c = 5; // Not a magic number
+`;
+        await fs.writeFile(testFilePath, content);
+        const metrics = await analyzeFileComplexity(testFilePath);
+
+        expect(metrics.codeSmells.magicNumbers).toBe(2);
+    });
+
+    it('should detect excessive parameters', async () => {
+        const content = `
+function manyParams(a, b, c, d, e, f) {
+    return a + b + c + d + e + f;
+}
+`;
+        await fs.writeFile(testFilePath, content);
+        const metrics = await analyzeFileComplexity(testFilePath);
+
+        expect(metrics.codeSmells.excessiveParameters).toBe(1);
+    });
+});

package/test/html-formatter.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect } from 'vitest';
+import { generateHtmlReport } from '../src/html-formatter.js';
+import { ProjectStats } from '../src/index.js';
+
+describe('generateHtmlReport', () => {
+    it('should generate an HTML string with stats', () => {
+        const mockStats: Partial<ProjectStats> = {
+            files: 10,
+            totalLines: 1000,
+            codeLines: 800,
+            commentLines: 100,
+            emptyLines: 100,
+            formatNumber: (n) => n.toString(),
+            formattedFileTypes: [
+                {
+                    'Extension': '.ts',
+                    'Files': '10',
+                    'Total Lines': '1000',
+                    'Code Lines': '800',
+                    'Comment Lines': '100',
+                    'Empty Lines': '100',
+                    '% of Codebase': '80%'
+                }
+            ],
+            typescriptSafety: {
+                tsFileCount: 10,
+                tsPercentage: '100',
+                avgTypeCoverage: '90',
+                totalAnyCount: 5,
+                totalAssertions: 2,
+                totalNonNullAssertions: 1,
+                avgTypeSafetyScore: 85,
+                overallComplexity: 'Low'
+            },
+            codeComplexity: {
+                analyzedFiles: 10,
+                avgComplexity: '2',
+                maxComplexity: 5,
+                avgNestingDepth: '1.5',
+                maxNestingDepth: 3,
+                avgFunctionSize: '20',
+                totalFunctions: 50,
+                complexFiles: 0,
+                overallComplexity: 'Low',
+                codeSmells: {
+                    magicNumbers: 0,
+                    callbackHell: 0,
+                    godFiles: 0,
+                    excessiveParameters: 0
+                }
+            }
+        };
+
+        const html = generateHtmlReport(mockStats as ProjectStats);
+
+        expect(typeof html).toBe('string');
+        expect(html).toContain('<!DOCTYPE html>');
+        expect(html).toContain('TS Analyzer Report');
+        expect(html).toContain('TypeScript Safety');
+        expect(html).toContain('Code Complexity');
+    });
+});

package/test/line-counting.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { countLines } from '../src/index.js';
+import fs from 'fs/promises';
+import path from 'path';
+
+describe('countLines', () => {
+  const testFilePath = path.join(process.cwd(), 'temp_test_file.ts');
+
+  afterEach(async () => {
+    try {
+      await fs.unlink(testFilePath);
+    } catch (e) {
+      // Ignore if file doesn't exist
+    }
+  });
+
+  it('should correctly count lines in a simple file', async () => {
+    const content = `// Line 1: Comment
+import { x } from 'y';
+
+/* Line 4: Block comment
+   Line 5: Still block comment */
+
+const a = 1;
+
+// Line 9: Comment
+const b = 2;
+`;
+    await fs.writeFile(testFilePath, content);
+
+    const stats = await countLines(testFilePath);
+
+    expect(stats.total).toBe(11);
+    expect(stats.empty).toBe(4);
+    expect(stats.comments).toBe(3);
+    expect(stats.code).toBe(4);
+  });
+
+  it('should handle empty files', async () => {
+    await fs.writeFile(testFilePath, '');
+    const stats = await countLines(testFilePath);
+    expect(stats.total).toBe(1); // fs.readFile('...') on empty string often gives 1 line array [""]
+    expect(stats.code).toBe(0);
+  });
+});

package/test/ts-safety.test.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { analyzeTypeScriptSafety } from '../src/typescript-safety.js';
+import fs from 'fs/promises';
+import path from 'path';
+
+describe('analyzeTypeScriptSafety', () => {
+    const testFilePath = path.join(process.cwd(), 'temp_safety_test.ts');
+
+    afterEach(async () => {
+        try {
+            await fs.unlink(testFilePath);
+        } catch (e) {}
+    });
+
+    it('should detect basic type coverage', async () => {
+        const content = `
+const a: number = 1;
+function b(x: string): void {}
+let c = 'inferred';
+`;
+        await fs.writeFile(testFilePath, content);
+        const metrics = await analyzeTypeScriptSafety(testFilePath);
+
+        expect(parseFloat(metrics.typeCoverage)).toBeGreaterThan(0);
+        expect(metrics.totalTypeableNodes).toBeGreaterThan(0);
+        expect(metrics.anyTypeCount).toBe(0);
+    });
+
+    it('should detect "any" usage', async () => {
+        const content = `
+const a: any = 1;
+function b(x: any): void {}
+`;
+        await fs.writeFile(testFilePath, content);
+        const metrics = await analyzeTypeScriptSafety(testFilePath);
+
+        expect(metrics.anyTypeCount).toBe(2);
+    });
+
+    it('should detect type assertions', async () => {
+        const content = `
+const a = 1 as any;
+const b = <string>"foo";
+`;
+        await fs.writeFile(testFilePath, content);
+        const metrics = await analyzeTypeScriptSafety(testFilePath);
+
+        expect(metrics.typeAssertions).toBeGreaterThan(0);
+    });
+});

package/vitest.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['test/**/*.test.ts'],
+  },
+});

package/ts-analyzer.config.json

@@ -1,3 +0,0 @@
-{
-  "safety": false
-}