devkit-quality 0.1.0

package/dist/scanner.js

@@ -0,0 +1,150 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanRepository = scanRepository;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const discovery_1 = require("./discovery");
+const parse_1 = require("./ast/parse");
+const moduleGraph_1 = require("./moduleGraph");
+const config_1 = require("./config");
+const ignore_1 = require("./ignore");
+const complexity_1 = require("./rules/complexity");
+const deadCode_1 = require("./rules/deadCode");
+const dependencies_1 = require("./rules/dependencies");
+const duplication_1 = require("./rules/duplication");
+const errorHandling_1 = require("./rules/errorHandling");
+const redundancy_1 = require("./rules/redundancy");
+const typescript_2 = require("./rules/typescript");
+const javascript_1 = require("./rules/javascript");
+const security_1 = require("./rules/security");
+const architecture_1 = require("./rules/architecture");
+const hygiene_1 = require("./rules/hygiene");
+const scoring_1 = require("./scoring");
+const suppressions_1 = require("./suppressions");
+function countClassDeclarations(program, files) {
+    let count = 0;
+    for (const file of files) {
+        const sourceFile = program.getSourceFile(file);
+        if (!sourceFile)
+            continue;
+        const visit = (node) => {
+            if (typescript_1.default.isClassDeclaration(node) || typescript_1.default.isClassExpression(node)) {
+                count += 1;
+            }
+            typescript_1.default.forEachChild(node, visit);
+        };
+        visit(sourceFile);
+    }
+    return count;
+}
+function estimateDuplicatedLines(findings) {
+    let total = 0;
+    for (const finding of findings) {
+        if (finding.ruleId !== 'DUP001')
+            continue;
+        const match = finding.description.match(/^Lines (\d+)-(\d+)/);
+        if (match) {
+            total += Number(match[2]) - Number(match[1]) + 1;
+        }
+    }
+    return total;
+}
+function scanRepository(projectRoot) {
+    const config = (0, config_1.loadConfig)(projectRoot);
+    const allFiles = (0, discovery_1.walkDirectory)(projectRoot);
+    const { files, generatedFiles } = (0, discovery_1.filterScannedFiles)(allFiles, projectRoot, config, (0, ignore_1.loadIgnorePatterns)(projectRoot));
+    const packageJsonPath = node_path_1.default.join(projectRoot, 'package.json');
+    const packageJson = node_fs_1.default.existsSync(packageJsonPath) ? JSON.parse((0, discovery_1.readFileSafe)(packageJsonPath)) : null;
+    const program = (0, parse_1.createProgram)(files);
+    const moduleGraph = (0, moduleGraph_1.buildModuleGraph)(projectRoot, files, packageJson, config);
+    const context = { projectRoot, files, allFiles, program, moduleGraph, config, packageJson };
+    const functionMetrics = (0, complexity_1.collectFunctionMetrics)(context);
+    const allFindings = [
+        ...(0, deadCode_1.runDeadCodeRules)(context),
+        ...(0, dependencies_1.runDependencyRules)(context),
+        ...(0, complexity_1.runComplexityRules)(context, functionMetrics),
+        ...(0, duplication_1.runDuplicationRules)(context),
+        ...(0, errorHandling_1.runErrorHandlingRules)(context),
+        ...(0, redundancy_1.runRedundancyRules)(context),
+        ...(0, typescript_2.runTypeScriptRules)(context),
+        ...(0, javascript_1.runJavaScriptRules)(context),
+        ...(0, security_1.runSecurityRules)(context),
+        ...(0, architecture_1.runArchitectureRules)(context),
+        ...(0, hygiene_1.runHygieneRules)(context)
+    ];
+    const findings = allFindings.filter((finding) => {
+        const sourceFile = context.program.getSourceFile(node_path_1.default.resolve(projectRoot, finding.file));
+        return !sourceFile || !(0, suppressions_1.isSuppressed)(sourceFile, finding.line, finding.ruleId);
+    });
+    let sourceLOC = 0;
+    let testLOC = 0;
+    let commentLOC = 0;
+    const largestFiles = [];
+    for (const file of files) {
+        const text = (0, discovery_1.readFileSafe)(file);
+        const relativePath = node_path_1.default.relative(projectRoot, file).replace(/\\/g, '/');
+        const isTest = (0, discovery_1.isTestFile)(relativePath);
+        const loc = (0, discovery_1.countLines)(text);
+        if (isTest) {
+            testLOC += loc;
+        }
+        else {
+            sourceLOC += loc;
+        }
+        commentLOC += (text.match(/^\s*(\/\/|\/\*|\*)/gm) ?? []).length;
+        if (loc > 0) {
+            largestFiles.push({ file: relativePath, loc });
+        }
+    }
+    const sourceFiles = files.filter((file) => !(0, discovery_1.isTestFile)(file)).length;
+    const testFiles = files.filter((file) => (0, discovery_1.isTestFile)(file)).length;
+    const dependencyCount = [
+        ...Object.keys(packageJson?.dependencies ?? {}),
+        ...Object.keys(packageJson?.devDependencies ?? {})
+    ].length;
+    const functionCount = functionMetrics.length;
+    const classCount = countClassDeclarations(program, files);
+    const deadCodeFindingCount = findings.filter((finding) => finding.category === 'deadCode').length;
+    const metrics = {
+        totalFiles: files.length,
+        sourceFiles,
+        testFiles,
+        totalLOC: sourceLOC + testLOC,
+        sourceLOC,
+        testLOC,
+        commentLOC,
+        functionCount,
+        classCount,
+        dependencyCount,
+        averageFunctionSize: functionCount > 0 ? functionMetrics.reduce((sum, metric) => sum + metric.lines, 0) / functionCount : 0,
+        largestFunctions: [...functionMetrics]
+            .sort((a, b) => b.lines - a.lines)
+            .slice(0, 5)
+            .map((metric) => ({ name: metric.name, size: metric.lines, file: metric.file })),
+        largestFiles: largestFiles.sort((a, b) => b.loc - a.loc).slice(0, 5),
+        complexityDistribution: {
+            low: functionMetrics.filter((metric) => metric.cyclomatic <= 10).length,
+            medium: functionMetrics.filter((metric) => metric.cyclomatic > 10 && metric.cyclomatic <= 25).length,
+            high: functionMetrics.filter((metric) => metric.cyclomatic > 25).length
+        },
+        duplicationPercentage: sourceLOC > 0 ? Math.min(100, (estimateDuplicatedLines(findings) / sourceLOC) * 100) : 0,
+        // Normalized against declared functions/classes rather than LOC, since dead code is a count of
+        // unused declarations, not a span of lines.
+        deadCodePercentage: functionCount + classCount > 0 ? Math.min(100, (deadCodeFindingCount / (functionCount + classCount)) * 100) : 0,
+        testToSourceRatio: sourceLOC > 0 ? testLOC / sourceLOC : 0
+    };
+    const { overallScore, categoryScores, securityScore } = (0, scoring_1.computeScores)(findings, sourceLOC);
+    return {
+        repository: projectRoot,
+        score: overallScore,
+        categoryScores,
+        securityScore,
+        findings,
+        metrics,
+        generatedFiles
+    };
+}

package/dist/scoring.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CATEGORY_WEIGHTS = void 0;
+exports.computeScores = computeScores;
+exports.summarizeTopDeductions = summarizeTopDeductions;
+exports.CATEGORY_WEIGHTS = {
+    deadCode: 0.2,
+    dependencies: 0.1,
+    complexity: 0.15,
+    duplication: 0.1,
+    redundantLogic: 0.1,
+    errorHandling: 0.1,
+    typescript: 0.1,
+    architecture: 0.1,
+    hygiene: 0.05
+};
+const SEVERITY_WEIGHT = {
+    CRITICAL: 3,
+    HIGH: 2.5,
+    MEDIUM: 1.5,
+    LOW: 0.8,
+    INFO: 0.2
+};
+const CONFIDENCE_WEIGHT = {
+    CERTAIN: 1,
+    HIGH: 0.8,
+    MEDIUM: 0.6,
+    LOW: 0.3
+};
+const LOC_CHUNK = 500;
+function findingPenalty(finding) {
+    return SEVERITY_WEIGHT[finding.severity] * CONFIDENCE_WEIGHT[finding.confidence];
+}
+function normalizedCategoryScore(findings, sourceLOC) {
+    const penalty = findings.reduce((sum, finding) => sum + findingPenalty(finding), 0);
+    const normalizer = Math.max(sourceLOC / LOC_CHUNK, 1);
+    return Math.max(0, Math.min(10, 10 - penalty / normalizer));
+}
+function computeScores(findings, sourceLOC) {
+    const categoryScores = {};
+    for (const category of Object.keys(exports.CATEGORY_WEIGHTS)) {
+        const categoryFindings = findings.filter((finding) => finding.category === category);
+        categoryScores[category] = Number(normalizedCategoryScore(categoryFindings, sourceLOC).toFixed(1));
+    }
+    const overallScore = Object.entries(exports.CATEGORY_WEIGHTS).reduce((sum, [category, weight]) => sum + weight * categoryScores[category], 0);
+    const securityFindings = findings.filter((finding) => finding.category === 'security');
+    const securityScore = Number(normalizedCategoryScore(securityFindings, sourceLOC).toFixed(1));
+    return {
+        overallScore: Number(overallScore.toFixed(1)),
+        categoryScores,
+        securityScore
+    };
+}
+function summarizeTopDeductions(findings, limit = 8) {
+    const byRule = new Map();
+    for (const finding of findings) {
+        const existing = byRule.get(finding.ruleId);
+        const penalty = findingPenalty(finding);
+        if (existing) {
+            existing.count += 1;
+            existing.totalPenalty += penalty;
+        }
+        else {
+            byRule.set(finding.ruleId, { ruleId: finding.ruleId, category: finding.category, count: 1, totalPenalty: penalty });
+        }
+    }
+    return [...byRule.values()].sort((a, b) => b.totalPenalty - a.totalPenalty).slice(0, limit);
+}

package/dist/suppressions.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectSuppressions = collectSuppressions;
+exports.isSuppressed = isSuppressed;
+const comments_1 = require("./ast/comments");
+function collectSuppressions(sourceFile) {
+    const directives = [];
+    for (const range of (0, comments_1.collectCommentRanges)(sourceFile)) {
+        const text = sourceFile.text.slice(range.pos, range.end);
+        const match = /devkit-disable-next-line(?:\s+([A-Z]{2,}\d{3}(?:\s*,\s*[A-Z]{2,}\d{3})*))?/i.exec(text);
+        if (!match)
+            continue;
+        const line = sourceFile.getLineAndCharacterOfPosition(range.end).line + 2;
+        const ruleIds = match[1] ? new Set(match[1].split(',').map((id) => id.trim().toUpperCase())) : null;
+        directives.push({ line, ruleIds });
+    }
+    return directives;
+}
+function isSuppressed(sourceFile, line, ruleId) {
+    return collectSuppressions(sourceFile).some((directive) => directive.line === line && (!directive.ruleIds || directive.ruleIds.has(ruleId.toUpperCase())));
+}

package/dist/terminal.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Spinner = exports.color = void 0;
+exports.severityColor = severityColor;
+exports.scoreColor = scoreColor;
+exports.scoreLabel = scoreLabel;
+exports.renderScoreBar = renderScoreBar;
+exports.pad = pad;
+exports.padStart = padStart;
+exports.renderCodeFrame = renderCodeFrame;
+exports.waitForNextTick = waitForNextTick;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const colorEnabled = Boolean(process.env.FORCE_COLOR) || (Boolean(process.stdout.isTTY) && !process.env.NO_COLOR);
+function wrap(open, close) {
+    return (text) => (colorEnabled ? `\x1b[${open}m${text}\x1b[${close}m` : text);
+}
+exports.color = {
+    bold: wrap('1', '22'),
+    dim: wrap('2', '22'),
+    red: wrap('31', '39'),
+    green: wrap('32', '39'),
+    yellow: wrap('33', '39'),
+    blue: wrap('34', '39'),
+    magenta: wrap('35', '39'),
+    cyan: wrap('36', '39'),
+    gray: wrap('90', '39'),
+    white: wrap('37', '39')
+};
+function severityColor(severity, text) {
+    switch (severity) {
+        case 'CRITICAL':
+        case 'HIGH':
+            return exports.color.red(text);
+        case 'MEDIUM':
+            return exports.color.yellow(text);
+        case 'LOW':
+            return exports.color.cyan(text);
+        default:
+            return exports.color.gray(text);
+    }
+}
+function scoreColor(score, text) {
+    if (score >= 8)
+        return exports.color.green(text);
+    if (score >= 5)
+        return exports.color.yellow(text);
+    return exports.color.red(text);
+}
+function scoreLabel(score) {
+    if (score >= 9)
+        return 'Excellent';
+    if (score >= 7)
+        return 'Good';
+    if (score >= 5)
+        return 'Needs work';
+    return 'Poor';
+}
+function renderScoreBar(score, width = 28) {
+    const filled = Math.round((Math.max(0, Math.min(10, score)) / 10) * width);
+    const bar = '█'.repeat(filled) + '░'.repeat(width - filled);
+    return scoreColor(score, bar);
+}
+function pad(text, width) {
+    return text.length >= width ? text : text + ' '.repeat(width - text.length);
+}
+function padStart(text, width) {
+    return text.length >= width ? text : ' '.repeat(width - text.length) + text;
+}
+function renderCodeFrame(repository, relativeFile, line, column, severity) {
+    const absolutePath = node_path_1.default.join(repository, relativeFile);
+    let lines;
+    try {
+        lines = node_fs_1.default.readFileSync(absolutePath, 'utf8').split(/\r\n|\r|\n/);
+    }
+    catch {
+        return [];
+    }
+    const startLine = Math.max(1, line - 1);
+    const endLine = Math.min(lines.length, line + 1);
+    const gutterWidth = String(endLine).length;
+    const output = [];
+    const maxWidth = 100;
+    const truncate = (text) => (text.length > maxWidth ? `${text.slice(0, maxWidth)}…` : text);
+    for (let current = startLine; current <= endLine; current += 1) {
+        const rawText = lines[current - 1] ?? '';
+        const text = truncate(rawText);
+        const gutter = padStart(String(current), gutterWidth);
+        const marker = current === line ? severityColor(severity, '>') : ' ';
+        if (current === line) {
+            output.push(`  ${marker} ${exports.color.bold(gutter)} ${exports.color.dim('|')} ${text}`);
+            if (column > 0 && column - 1 < maxWidth) {
+                output.push(`  ${' '.repeat(gutterWidth + 2)} ${exports.color.dim('|')} ${' '.repeat(Math.max(0, column - 1))}${severityColor(severity, '^')}`);
+            }
+        }
+        else {
+            output.push(`  ${marker} ${exports.color.dim(gutter)} ${exports.color.dim('|')} ${exports.color.dim(text)}`);
+        }
+    }
+    return output;
+}
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+class Spinner {
+    frameIndex = 0;
+    timer;
+    text;
+    constructor(text) {
+        this.text = text;
+    }
+    start() {
+        // Written to stderr so it never pollutes piped/redirected stdout (--format json, etc.).
+        if (!process.stderr.isTTY) {
+            process.stderr.write(`${this.text}\n`);
+            return;
+        }
+        this.timer = setInterval(() => {
+            process.stderr.write(`\r${exports.color.cyan(SPINNER_FRAMES[this.frameIndex])} ${this.text}`);
+            this.frameIndex = (this.frameIndex + 1) % SPINNER_FRAMES.length;
+        }, 80);
+    }
+    stop() {
+        if (!this.timer)
+            return;
+        clearInterval(this.timer);
+        this.timer = undefined;
+        process.stderr.write('\r\x1b[K');
+    }
+}
+exports.Spinner = Spinner;
+function waitForNextTick() {
+    return new Promise((resolve) => setImmediate(resolve));
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "devkit-quality",
+  "version": "0.1.0",
+  "description": "Deterministic repository quality scanner for JavaScript and TypeScript projects",
+  "bin": {
+    "devkit-quality": "bin/devkit.js"
+  },
+  "main": "dist/cli.js",
+  "files": [
+    "dist",
+    "bin",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/cli.js",
+    "dev": "tsx src/cli.ts",
+    "scan": "tsx src/cli.ts scan",
+    "test": "vitest run",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Karan071/devkit-cli.git"
+  },
+  "keywords": [
+    "cli",
+    "typescript",
+    "code-quality",
+    "slop-scanner",
+    "static-analysis"
+  ],
+  "license": "MIT",
+  "author": "Karan Chourasia",
+  "type": "commonjs",
+  "dependencies": {
+    "commander": "^12.1.0",
+    "typescript": "^5.7.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "tsx": "^4.19.2",
+    "vitest": "^5.0.3"
+  }
+}