deadrule 0.1.0 → 0.2.0

package/dist/analyzers/usage.d.ts

@@ -0,0 +1,12 @@
+import { RuleFile } from "../types.js";
+export interface UsageResult {
+    file: string;
+    domain: string;
+    reason: string;
+}
+export interface UsageStats {
+    sessionsScanned: number;
+    extensionsFound: Map<string, number>;
+    deadRules: UsageResult[];
+}
+export declare function analyzeUsage(files: RuleFile[]): Promise<UsageStats>;

package/dist/analyzers/usage.js

@@ -0,0 +1,118 @@
+import { readdir, readFile } from "node:fs/promises";
+import { join, extname } from "node:path";
+import { homedir } from "node:os";
+import { existsSync } from "node:fs";
+// Map rule files to their target domain
+const DOMAIN_PATTERNS = [
+    { name: "Python", match: /python|pytorch/i, extensions: [".py", ".pyx", ".pyi"] },
+    { name: "TypeScript", match: /typescript/i, extensions: [".ts", ".tsx"] },
+    { name: "JavaScript/Web", match: /javascript|web/i, extensions: [".js", ".jsx", ".ts", ".tsx", ".html", ".css"] },
+    { name: "Rust", match: /rust/i, extensions: [".rs"] },
+    { name: "Go", match: /golang|\/go\//i, extensions: [".go"] },
+    { name: "Java", match: /java\b/i, extensions: [".java"] },
+    { name: "Kotlin", match: /kotlin/i, extensions: [".kt", ".kts"] },
+    { name: "Swift", match: /swift/i, extensions: [".swift"] },
+    { name: "Dart/Flutter", match: /dart|flutter/i, extensions: [".dart"] },
+    { name: "C#", match: /csharp|c#|\.cs/i, extensions: [".cs"] },
+    { name: "C++", match: /cpp|c\+\+/i, extensions: [".cpp", ".cc", ".h", ".hpp"] },
+    { name: "PHP", match: /php/i, extensions: [".php"] },
+    { name: "Perl", match: /perl/i, extensions: [".pl", ".pm"] },
+    { name: "Ruby", match: /ruby/i, extensions: [".rb"] },
+];
+export async function analyzeUsage(files) {
+    const editedExtensions = await collectEditedExtensions();
+    const sessionsScanned = editedExtensions.sessionCount;
+    const extensionsFound = editedExtensions.counts;
+    if (sessionsScanned === 0) {
+        return { sessionsScanned: 0, extensionsFound, deadRules: [] };
+    }
+    const deadRules = [];
+    for (const rule of files) {
+        const domain = detectDomain(rule);
+        if (!domain)
+            continue;
+        const hasActivity = domain.extensions.some((ext) => extensionsFound.has(ext));
+        if (!hasActivity) {
+            deadRules.push({
+                file: rule.filename,
+                domain: domain.name,
+                reason: `No ${domain.name} files edited in ${sessionsScanned} sessions`,
+            });
+        }
+    }
+    return { sessionsScanned, extensionsFound, deadRules };
+}
+function detectDomain(rule) {
+    const text = rule.filename + " " + rule.path;
+    for (const dp of DOMAIN_PATTERNS) {
+        if (dp.match.test(text)) {
+            return { name: dp.name, extensions: dp.extensions };
+        }
+    }
+    return null;
+}
+async function collectEditedExtensions() {
+    const claudeDir = join(homedir(), ".claude", "projects");
+    if (!existsSync(claudeDir)) {
+        return { sessionCount: 0, counts: new Map() };
+    }
+    const counts = new Map();
+    let sessionCount = 0;
+    const projects = await readdir(claudeDir);
+    for (const project of projects) {
+        const projectDir = join(claudeDir, project);
+        const files = await safeReaddir(projectDir);
+        const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
+        for (const jsonlFile of jsonlFiles) {
+            sessionCount++;
+            const filePath = join(projectDir, jsonlFile);
+            const extensions = await extractExtensionsFromLog(filePath);
+            for (const ext of extensions) {
+                counts.set(ext, (counts.get(ext) || 0) + 1);
+            }
+        }
+    }
+    return { sessionCount, counts };
+}
+async function extractExtensionsFromLog(logPath) {
+    const extensions = new Set();
+    try {
+        const content = await readFile(logPath, "utf-8");
+        const lines = content.split("\n").filter(Boolean);
+        for (const line of lines) {
+            try {
+                const obj = JSON.parse(line);
+                if (obj.type !== "assistant" || !obj.message?.content)
+                    continue;
+                for (const block of obj.message.content) {
+                    if (block.type !== "tool_use")
+                        continue;
+                    if (block.name !== "Edit" && block.name !== "Write")
+                        continue;
+                    const filePath = block.input?.file_path;
+                    if (!filePath || typeof filePath !== "string")
+                        continue;
+                    const ext = extname(filePath).toLowerCase();
+                    if (ext && ext !== ".md" && ext !== ".json" && ext !== ".txt") {
+                        extensions.add(ext);
+                    }
+                }
+            }
+            catch {
+                // skip malformed lines
+            }
+        }
+    }
+    catch {
+        // skip unreadable files
+    }
+    return extensions;
+}
+async function safeReaddir(dir) {
+    try {
+        return await readdir(dir);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/index.js

@@ -6,6 +6,7 @@ import { analyzeDefaults } from "./analyzers/defaults.js";
 import { analyzeVagueness } from "./analyzers/vagueness.js";
 import { analyzeCost } from "./analyzers/cost.js";
 import { analyzeStaleness } from "./analyzers/staleness.js";
+import { analyzeUsage } from "./analyzers/usage.js";
 import { printReport } from "./reporter.js";
 async function main() {
     const cwd = process.cwd();
@@ -23,6 +24,7 @@ async function main() {
     const vagueDirectives = analyzeVagueness(files);
     const costBreakdown = analyzeCost(files);
     const staleRules = analyzeStaleness(files);
+    const usageStats = await analyzeUsage(files);
     const result = {
         totalFiles: files.length,
         globalCount: files.filter((f) => f.scope === "global").length,
@@ -34,13 +36,21 @@ async function main() {
         vagueDirectives,
         costBreakdown,
         staleRules,
+        usage: usageStats.sessionsScanned > 0
+            ? {
+                sessionsScanned: usageStats.sessionsScanned,
+                extensionsFound: [...usageStats.extensionsFound.entries()].sort((a, b) => b[1] - a[1]),
+                deadRules: usageStats.deadRules,
+            }
+            : undefined,
     };
     printReport(result);
     const issues = duplicates.length +
         directiveOverlaps.length +
         defaultMatches.length +
         vagueDirectives.length +
-        staleRules.length;
+        staleRules.length +
+        (result.usage?.deadRules.length ?? 0);
     process.exit(issues > 0 ? 1 : 0);
 }
 main().catch((err) => {

package/dist/reporter.js

@@ -7,6 +7,7 @@ export function printReport(result) {
     console.log("");
     console.log(`Scanned: ${totalFiles} rules (${globalCount} global, ${projectCount} project)`);
     console.log(`Total token cost: ~${totalTokens.toLocaleString()} tokens (${((totalTokens / 200_000) * 100).toFixed(1)}% of context)`);
+    printUsage(result);
     printDuplicates(result);
     printDirectiveOverlaps(result);
     printDefaults(result);
@@ -125,18 +126,47 @@ function printStale(r) {
         console.log(`  ... and ${r.staleRules.length - MAX_ITEMS} more`);
     }
 }
+function printUsage(r) {
+    if (!r.usage)
+        return;
+    const { sessionsScanned, extensionsFound, deadRules } = r.usage;
+    console.log("");
+    console.log(`DEAD RULES (based on ${sessionsScanned} sessions across all projects)`);
+    if (extensionsFound.length > 0) {
+        console.log("  Languages you actually use:");
+        const shown = extensionsFound.slice(0, 8);
+        for (const [ext, count] of shown) {
+            console.log(`    ${ext.padEnd(8)} ${count} file edits`);
+        }
+    }
+    if (deadRules.length === 0) {
+        console.log("  No dead rules found — all rules match your usage.");
+    }
+    else {
+        console.log("");
+        console.log("  Rules for languages you NEVER use:");
+        for (const d of deadRules) {
+            console.log(`    ${d.file}`);
+            console.log(`    -> ${d.reason}`);
+        }
+    }
+}
 function printSummary(r) {
     const issues = r.duplicates.length +
         r.directiveOverlaps.length +
         r.defaultMatches.length +
         r.vagueDirectives.length +
-        r.staleRules.length;
+        r.staleRules.length +
+        (r.usage?.deadRules.length ?? 0);
     console.log("");
     console.log("SUMMARY");
     if (issues === 0) {
         console.log("  All rules look healthy!");
     }
     else {
+        if (r.usage && r.usage.deadRules.length > 0) {
+            console.log(`  ${r.usage.deadRules.length} DEAD rule(s) — never relevant to your work`);
+        }
         if (r.duplicates.length > 0) {
             console.log(`  ${r.duplicates.length} duplicate pair(s)`);
         }

package/dist/types.d.ts

@@ -39,6 +39,16 @@ export interface StaleRule {
     file: string;
     daysSinceModified: number;
 }
+export interface DeadByUsage {
+    file: string;
+    domain: string;
+    reason: string;
+}
+export interface UsageSummary {
+    sessionsScanned: number;
+    extensionsFound: [string, number][];
+    deadRules: DeadByUsage[];
+}
 export interface AnalysisResult {
     totalFiles: number;
     globalCount: number;
@@ -50,4 +60,5 @@ export interface AnalysisResult {
     vagueDirectives: VagueDirective[];
     costBreakdown: CostEntry[];
     staleRules: StaleRule[];
+    usage?: UsageSummary;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deadrule",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Find dead rules in your AI coding assistant config",
   "type": "module",
   "bin": {