ts-analyzer 1.3.0 → 1.3.2

package/README.md

@@ -1,21 +1,28 @@
 # ts-analyzer
 
-ts-analyzer is a static analysis tool for checking TypeScript code quality, focusing on type safety and structural complexity.
+![npm](https://img.shields.io/npm/v/ts-analyzer)
+![coverage](https://img.shields.io/badge/coverage-88%25-brightgreen)
+![license](https://img.shields.io/npm/l/ts-analyzer)
 
-## Features
+`ts-analyzer` is a comprehensive static analysis tool for checking TypeScript and JavaScript code quality, focusing on type safety, structural complexity, and identifying potential anti-patterns.
 
-- TypeScript safety metrics (type coverage, any usage, assertions).
-- Cyclomatic complexity and nesting depth analysis.
-- Detection of anti-patterns like magic numbers, callback hell, and god files.
-- Formatted output in Text, JSON, and HTML.
+## ✨ Features
 
-## Quick Start
+- **TypeScript Safety Metrics**: Calculates your project's true type coverage by tracking `any` usage, explicit generics, optional properties, type assertions, and non-null assertions.
+- **Code Complexity Analysis**: Measures Cyclomatic Complexity and Nesting Depth to ensure your code remains readable and maintainable.
+- **Anti-Pattern & Code Smell Detection**: Highlights potential red flags such as "Magic Numbers", "Callback Hell", "God Files" (>500 lines), and overly complex functions (excessive parameters).
+- **Flexible Reporting**: Generate beautiful HTML dashboards, parsable JSON payloads, or read insights directly in your terminal.
+- **High Reliability**: The tool is extensively tested with a robust **~88% test coverage** powered by Vitest, ensuring calculations remain accurate.
+
+## 🚀 Quick Start
+
+Run it directly on any project using `npx`:
 
 ```bash
 npx ts-analyzer
 ```
 
-## Usage
+## 📦 Usage
 
 Analyze a specific directory:
 ```bash
@@ -23,22 +30,29 @@ ts-analyzer /path/to/project
 ```
 
 Available options:
-- `-f, --format <type>`: `text`, `json`, or `html`.
-- `-e, --exclude <patterns>`: Comma-separated ignore patterns.
-- `--no-safety`: Skip type-safety analysis.
-- `--no-complexity`: Skip complexity analysis.
+- `-f, --format <type>`: Select report format (`text`, `json`, or `html`).
+- `-e, --exclude <patterns>`: Comma-separated ignore patterns (e.g. `node_modules,dist`).
+- `--no-safety`: Skip type-safety analysis to speed up processing.
+- `--no-complexity`: Skip structural complexity analysis.
+
+## 🛠 Development
 
-## Development
+The repository uses modern open-source tooling, and features comprehensive test suites.
+
+Install dependencies:
+```bash
+npm install
+```
 
-Run tests:
+Run tests (powered by Vitest):
 ```bash
 npm test
 ```
 
-Generate coverage:
+Generate coverage reports:
 ```bash
 npm run test:coverage
 ```
 
-## License
+## 📝 License
 MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-analyzer",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "repository": "github:amir-valizadeh/ts-analyzer",
   "description": "Comprehensive TypeScript code analyzer with type safety and complexity metrics",
   "main": "dist/src/index.js",

package/test/html-formatter.test.ts

@@ -59,4 +59,55 @@ describe('generateHtmlReport', () => {
         expect(html).toContain('TypeScript Safety');
         expect(html).toContain('Code Complexity');
     });
+    it('should generate an HTML string without optional stats (branch coverage)', () => {
+        const mockStats: Partial<ProjectStats> = {
+            files: 0,
+            totalLines: 0,
+            codeLines: 0,
+            commentLines: 0,
+            emptyLines: 0,
+            formatNumber: (n) => n.toString(),
+            formattedFileTypes: []
+        };
+        const html = generateHtmlReport(mockStats as ProjectStats);
+        expect(html).not.toContain('TypeScript Safety');
+        expect(html).not.toContain('Code Complexity');
+    });
+
+    it('should cover warning and danger branches for stats', () => {
+        const mockStats: Partial<ProjectStats> = {
+            files: 10,
+            totalLines: 1000,
+            codeLines: 800,
+            commentLines: 100,
+            emptyLines: 100,
+            formatNumber: (n) => n.toString(),
+            formattedFileTypes: [],
+            typescriptSafety: {
+                tsFileCount: 1, tsPercentage: '100', avgTypeCoverage: '50', // < 80 triggers warning
+                totalAnyCount: 15, // > 10 triggers danger
+                totalAssertions: 0, totalNonNullAssertions: 0, avgTypeSafetyScore: 50, overallComplexity: 'High'
+            },
+            codeComplexity: {
+                analyzedFiles: 1, avgComplexity: '10', // > 5 triggers warning
+                maxComplexity: 20, // > 15 triggers danger
+                avgNestingDepth: '1.5', maxNestingDepth: 3, avgFunctionSize: '20', totalFunctions: 1,
+                complexFiles: 1, // > 0 triggers danger
+                overallComplexity: 'High',
+                codeSmells: {
+                    magicNumbers: 5, // > 0
+                    callbackHell: 5, // > 0
+                    godFiles: 5,     // > 0
+                    excessiveParameters: 5 // > 0
+                }
+            }
+        };
+
+        const html = generateHtmlReport(mockStats as ProjectStats);
+        expect(html).toContain('warning');
+        expect(html).toContain('#ffc107'); // magicNumbers uses warning color
+        expect(html).toContain('#dc3545'); // danger color
+    });
 });
+
+

package/test/index.test.ts

@@ -0,0 +1,66 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { analyzeProject } from '../src/index.js';
+import fs from 'fs/promises';
+import path from 'path';
+
+describe('analyzeProject', () => {
+    const testDir = path.join(process.cwd(), 'temp_index_test_dir');
+
+    beforeAll(async () => {
+        await fs.mkdir(testDir, { recursive: true });
+        await fs.writeFile(path.join(testDir, 'file1.ts'), 'const a = 1;\nconsole.log(a);');
+        await fs.writeFile(path.join(testDir, 'file1_duplicate.ts'), 'const b = 2;');
+        await fs.writeFile(path.join(testDir, 'file2.js'), '// comment\nlet b = 2;');
+        await fs.writeFile(path.join(testDir, 'ignored.txt'), 'not counted');
+        
+        const subDir = path.join(testDir, 'subdir');
+        await fs.mkdir(subDir, { recursive: true });
+        await fs.writeFile(path.join(subDir, 'file3.css'), 'body { margin: 0; }');
+        
+        const ignoreDir = path.join(testDir, 'node_modules');
+        await fs.mkdir(ignoreDir, { recursive: true });
+        await fs.writeFile(path.join(ignoreDir, 'lib.ts'), 'const ignored = true;');
+    });
+
+    afterAll(async () => {
+        await fs.rm(testDir, { recursive: true, force: true });
+    });
+
+    it('should correctly analyze a project directory with default options', async () => {
+        const stats = await analyzeProject(testDir, {
+            analyzeSafety: false,
+            analyzeComplexity: false
+        });
+
+        expect(stats.files).toBe(4); // file1.ts, file1_duplicate.ts, file2.js, file3.css
+        expect(stats.fileTypes['.ts']).toBeDefined();
+        expect(stats.fileTypes['.js']).toBeDefined();
+        expect(stats.fileTypes['.css']).toBeDefined();
+        expect(stats.typescriptSafety).toBeNull();
+        expect(stats.codeComplexity).toBeNull();
+    });
+
+    it('should include safety and complexity when requested', async () => {
+        const stats = await analyzeProject(testDir, {
+            analyzeSafety: true,
+            analyzeComplexity: true
+        });
+
+        expect(stats.typescriptSafety).not.toBeNull();
+        expect(stats.codeComplexity).not.toBeNull();
+    });
+
+    it('should respect custom ignore options and extra extensions', async () => {
+        const stats = await analyzeProject(testDir, {
+            excludePatterns: ['subdir'],
+            additionalExtensions: ['.txt'],
+            analyzeSafety: false,
+            analyzeComplexity: false
+        });
+
+        expect(stats.files).toBe(4); // file1.ts, file1_duplicate.ts, file2.js, ignored.txt 
+        // subdir is excluded, so file3.css is skipped
+        expect(stats.fileTypes['.css']).toBeUndefined();
+        expect(stats.fileTypes['.txt']).toBeDefined();
+    });
+});

package/test/line-counting.test.ts

@@ -42,4 +42,10 @@ const b = 2;
     expect(stats.total).toBe(1); // fs.readFile('...') on empty string often gives 1 line array [""]
     expect(stats.code).toBe(0);
   });
+
+  it('should handle reading errors gracefully', async () => {
+    const stats = await countLines('/invalid/path/that/does/not/exist.ts');
+    expect(stats.total).toBe(0);
+    expect(stats.code).toBe(0);
+  });
 });

package/test/ts-safety.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, afterEach } from 'vitest';
-import { analyzeTypeScriptSafety } from '../src/typescript-safety.js';
+import { analyzeTypeScriptSafety, calculateProjectTypeSafety } from '../src/typescript-safety.js';
 import fs from 'fs/promises';
 import path from 'path';
 
@@ -47,4 +47,62 @@ const b = <string>"foo";
 
         expect(metrics.typeAssertions).toBeGreaterThan(0);
     });
+    it('should detect complex types, interfaces, non-null assertions, and generics', async () => {
+        const content = `
+interface MyInterface<T> {
+  value?: T;
+}
+const arr: Array<string> = [];
+const obj: MyInterface<number> = {};
+const val = obj.value!;
+const func = <U>(arg: U) => arg;
+class MyClass {
+  prop = 123;
+  method() { return this.prop; }
+}
+export type MyType = string | number;
+import { something } from "somewhere";
+`;
+        await fs.writeFile(testFilePath, content);
+        const metrics = await analyzeTypeScriptSafety(testFilePath);
+
+        expect(metrics.nonNullAssertions).toBeGreaterThan(0);
+        expect(metrics.optionalProperties).toBeGreaterThan(0);
+        expect(metrics.genericsCount).toBeGreaterThan(0);
+    });
+
+    it('should handle un-parseable or missing files gracefully', async () => {
+        const metrics = await analyzeTypeScriptSafety('/non/existent/path/this/should/throw/error.ts');
+        expect(metrics.typeCoverage).toBe('0.0');
+    });
 });
+
+describe('calculateProjectTypeSafety', () => {
+    it('should return default zero metrics for no TS files', async () => {
+        const metrics = await calculateProjectTypeSafety('.', ['index.js', 'style.css']);
+        expect(metrics.tsFileCount).toBe(0);
+        expect(metrics.avgTypeSafetyScore).toBe(0);
+    });
+
+    it('should calculate averages across multiple files', async () => {
+        // We will pass the src directory and check if it handles it. 
+        // We can just rely on the existing files in the project or mock files.
+        // Let's create two temp files
+        const tempPath1 = path.join(process.cwd(), 'temp_s_test1.ts');
+        const tempPath2 = path.join(process.cwd(), 'temp_s_test2.tsx');
+        
+        await fs.writeFile(tempPath1, 'const x: number = 1;');
+        await fs.writeFile(tempPath2, 'const y: any = 2;');
+        
+        try {
+            const metrics = await calculateProjectTypeSafety(process.cwd(), ['temp_s_test1.ts', 'temp_s_test2.tsx']);
+            expect(metrics.tsFileCount).toBe(2);
+            expect(metrics.totalAnyCount).toBe(1);
+            expect(metrics.tsPercentage).toBe('100.0');
+        } finally {
+            try { await fs.unlink(tempPath1); } catch(e) {}
+            try { await fs.unlink(tempPath2); } catch(e) {}
+        }
+    });
+});
+