deadrule 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 JSK9999
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,110 @@
+# deadrule
+
+Find dead rules in your AI coding assistant config.
+
+AI coding tools (Claude Code, Cursor, Codex) let you define rules and skills. Over time, rules pile up. Some duplicate each other. Some repeat what the AI already does. Some are too vague to follow. **deadrule** finds them.
+
+## Quick Start
+
+```bash
+npx deadrule
+```
+
+No API keys. No setup. No runtime dependencies.
+
+## What it checks
+
+| Check | What it finds |
+|-------|--------------|
+| **Duplicates** | Rules that overlap with each other |
+| **Overlapping directives** | Same instruction copied across multiple files |
+| **Claude defaults** | Rules that repeat Claude's built-in behavior |
+| **Vague directives** | Instructions too abstract to be actionable |
+| **Token cost** | How many tokens each rule file consumes |
+| **Stale rules** | Rules not modified in 90+ days |
+
+## Custom Paths
+
+Scan any directory of rules:
+
+```bash
+# Scan a specific rules directory
+deadrule ./my-rules/
+
+# Scan multiple paths
+deadrule ./rules/ ./agents/
+
+# Scan a cloned rule set
+deadrule ~/everything-claude-code/rules/
+```
+
+## Where it scans (default)
+
+- `~/.claude/rules/*.md` (global rules)
+- `.claude/rules/*.md` (project rules)
+- `CLAUDE.md` (project root)
+- `.cursorrules` (Cursor)
+
+## Real-World Test: Everything Claude Code (136 rules)
+
+```
+$ deadrule ./rules/ ./agents/
+
+deadrule v0.1.0
+================
+
+Scanned: 136 rules (0 global, 136 project)
+Total token cost: ~90,077 tokens (45.0% of context)
+
+DUPLICATES
+  agents/java-build-resolver.md <-> agents/kotlin-build-resolver.md  (51% overlap)
+
+OVERLAPPING DIRECTIVES (50 found, showing top 10)
+  "Surgical fixes only - don't refactor, just fix the error"
+  -> repeated in: agents/cpp-build-resolver.md, agents/dart-build-resolver.md,
+     agents/java-build-resolver.md, agents/rust-build-resolver.md,
+     agents/go-build-resolver.md, agents/kotlin-build-resolver.md,
+     agents/pytorch-build-resolver.md
+
+  "Approve: No CRITICAL or HIGH issues"
+  -> repeated in: common/code-review.md, agents/code-reviewer.md,
+     agents/cpp-reviewer.md, agents/csharp-reviewer.md, ... (11 files)
+
+REDUNDANT WITH CLAUDE DEFAULTS
+  common/security.md: "SQL injection prevention (parameterized queries)"
+  -> Claude already uses parameterized queries by default
+
+  java/security.md: "Always use parameterized queries - never concat..."
+  -> Claude already uses parameterized queries by default
+
+TOKEN COST BREAKDOWN (top 10)
+  agents/flutter-reviewer.md       ~ 3510 tokens  ||||......  4%
+  agents/performance-optimizer.md  ~ 3111 tokens  |||.......  3%
+  agents/code-reviewer.md          ~ 2187 tokens  ||........  2%
+  ... 126 more files (~69,115 tokens)
+
+SUMMARY
+  1 duplicate pair(s)
+  50 overlapping directive(s)
+  13 redundant with Claude defaults
+  25 vague directive(s)
+```
+
+Key finding: **ECC loads ~90K tokens (45% of context window) in rules alone.**
+
+## Roadmap
+
+See [open issues](https://github.com/JSK9999/deadrule/issues) for planned features.
+
+- [ ] Runtime rule tracking via hooks (find truly unused rules)
+- [ ] `--json` output for CI/CD
+- [ ] `--fix` auto-merge duplicate rules
+- [ ] Cross-project rule comparison
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for setup and guidelines.
+
+## License
+
+MIT

package/dist/analyzers/cost.d.ts

@@ -0,0 +1,3 @@
+import { RuleFile, CostEntry } from "../types.js";
+export declare function analyzeCost(files: RuleFile[]): CostEntry[];
+export declare function contextPercent(files: RuleFile[]): string;

package/dist/analyzers/cost.js

@@ -0,0 +1,17 @@
+const CONTEXT_WINDOW = 200_000;
+export function analyzeCost(files) {
+    const totalTokens = files.reduce((sum, f) => sum + f.tokenCount, 0);
+    return files
+        .map((f) => ({
+        file: f.filename,
+        tokens: f.tokenCount,
+        percent: totalTokens > 0
+            ? Math.round((f.tokenCount / totalTokens) * 100)
+            : 0,
+    }))
+        .sort((a, b) => b.tokens - a.tokens);
+}
+export function contextPercent(files) {
+    const total = files.reduce((sum, f) => sum + f.tokenCount, 0);
+    return ((total / CONTEXT_WINDOW) * 100).toFixed(1);
+}

package/dist/analyzers/defaults.d.ts

@@ -0,0 +1,2 @@
+import { RuleFile, DefaultMatch } from "../types.js";
+export declare function analyzeDefaults(files: RuleFile[]): DefaultMatch[];

package/dist/analyzers/defaults.js

@@ -0,0 +1,68 @@
+const CLAUDE_DEFAULTS = [
+    {
+        pattern: /read.*(?:file|code|related).*before/i,
+        reason: "Claude Code already reads files before editing by default",
+    },
+    {
+        pattern: /parameterized\s+quer/i,
+        reason: "Claude already uses parameterized queries by default",
+    },
+    {
+        pattern: /use\s+https/i,
+        reason: "Claude defaults to HTTPS in generated code",
+    },
+    {
+        pattern: /don'?t\s+(?:add|use)\s+emoji/i,
+        reason: "Claude Code does not use emojis unless asked",
+    },
+    {
+        pattern: /avoid\s+(?:unnecessary|premature)\s+(?:abstraction|optimization)/i,
+        reason: "Claude Code system prompt already discourages premature abstraction",
+    },
+    {
+        pattern: /prefer\s+edit.*over.*(?:write|create)/i,
+        reason: "Claude Code already prefers editing existing files",
+    },
+    {
+        pattern: /keep\s+(?:response|output)s?\s+(?:short|concise|brief)/i,
+        reason: "Claude Code already aims for concise responses",
+    },
+    {
+        pattern: /don'?t\s+(?:create|add)\s+(?:unnecessary|extra)\s+files/i,
+        reason: "Claude Code already avoids creating unnecessary files",
+    },
+    {
+        pattern: /validate\s+(?:all\s+)?(?:external\s+)?inputs/i,
+        reason: "Claude validates inputs in generated code by default",
+    },
+    {
+        pattern: /(?:escape|encode|sanitize)\s+(?:output|html)/i,
+        reason: "Claude applies output encoding by default",
+    },
+    {
+        pattern: /don'?t\s+(?:add|include)\s+(?:comments|docstrings)\s+(?:to|for)\s+(?:code\s+)?(?:you\s+)?didn'?t/i,
+        reason: "Claude Code already avoids adding comments to unchanged code",
+    },
+    {
+        pattern: /don'?t\s+(?:make|suggest)\s+(?:changes|improvements)\s+beyond/i,
+        reason: "Claude Code already limits changes to what was requested",
+    },
+];
+export function analyzeDefaults(files) {
+    const matches = [];
+    for (const file of files) {
+        for (const directive of file.directives) {
+            for (const def of CLAUDE_DEFAULTS) {
+                if (def.pattern.test(directive)) {
+                    matches.push({
+                        file: file.filename,
+                        directive,
+                        reason: def.reason,
+                    });
+                    break;
+                }
+            }
+        }
+    }
+    return matches;
+}

package/dist/analyzers/overlap.d.ts

@@ -0,0 +1,5 @@
+import { RuleFile, OverlapResult, DirectiveOverlap } from "../types.js";
+export declare function analyzeOverlap(files: RuleFile[]): {
+    duplicates: OverlapResult[];
+    directiveOverlaps: DirectiveOverlap[];
+};

package/dist/analyzers/overlap.js

@@ -0,0 +1,98 @@
+const STOP_WORDS = new Set([
+    "a", "an", "the", "is", "are", "was", "were", "be", "been", "being",
+    "have", "has", "had", "do", "does", "did", "will", "would", "could",
+    "should", "may", "might", "shall", "can", "to", "of", "in", "for",
+    "on", "with", "at", "by", "from", "as", "into", "through", "during",
+    "before", "after", "and", "but", "or", "not", "no", "if", "then",
+    "than", "that", "this", "it", "its", "all", "each", "every", "any",
+    "use", "using", "used",
+]);
+const MAX_DIRECTIVE_RESULTS = 50;
+export function analyzeOverlap(files) {
+    const duplicates = findDuplicateFiles(files);
+    const directiveOverlaps = findDirectiveOverlaps(files);
+    return { duplicates, directiveOverlaps };
+}
+function findDuplicateFiles(files) {
+    const results = [];
+    for (let i = 0; i < files.length; i++) {
+        for (let j = i + 1; j < files.length; j++) {
+            // Skip if same base filename (intentional per-language copies)
+            const baseA = files[i].filename.split("/").pop();
+            const baseB = files[j].filename.split("/").pop();
+            if (baseA === baseB)
+                continue;
+            const wordsA = extractKeywords(files[i].content);
+            const wordsB = extractKeywords(files[j].content);
+            const sim = jaccard(wordsA, wordsB);
+            if (sim >= 0.5) {
+                results.push({
+                    fileA: files[i].filename,
+                    fileB: files[j].filename,
+                    similarity: Math.round(sim * 100),
+                });
+            }
+        }
+    }
+    return results.sort((a, b) => b.similarity - a.similarity);
+}
+function findDirectiveOverlaps(files) {
+    // Index directives by keyword hash for fast lookup instead of N^2
+    const index = new Map();
+    for (const file of files) {
+        for (const d of file.directives) {
+            const keywords = extractKeywords(d);
+            // Use sorted keywords as a rough hash
+            const key = [...keywords].sort().join("|");
+            if (!key)
+                continue;
+            if (!index.has(key))
+                index.set(key, []);
+            index.get(key).push({ file: file.filename, directive: d });
+        }
+    }
+    const results = [];
+    const seen = new Set();
+    // Exact keyword matches (fastest, highest confidence)
+    for (const [, entries] of index) {
+        if (entries.length < 2)
+            continue;
+        // Only compare across different files
+        for (let i = 0; i < entries.length && results.length < MAX_DIRECTIVE_RESULTS; i++) {
+            for (let j = i + 1; j < entries.length && results.length < MAX_DIRECTIVE_RESULTS; j++) {
+                if (entries[i].file === entries[j].file)
+                    continue;
+                const pairKey = [entries[i].file, entries[j].file, entries[i].directive].sort().join("||");
+                if (seen.has(pairKey))
+                    continue;
+                seen.add(pairKey);
+                results.push({
+                    fileA: entries[i].file,
+                    directiveA: entries[i].directive,
+                    fileB: entries[j].file,
+                    directiveB: entries[j].directive,
+                    similarity: 100,
+                });
+            }
+        }
+    }
+    return results.sort((a, b) => b.similarity - a.similarity);
+}
+function extractKeywords(text) {
+    return new Set(text
+        .toLowerCase()
+        .replace(/[^a-z0-9\s]/g, " ")
+        .split(/\s+/)
+        .filter((w) => w.length > 2 && !STOP_WORDS.has(w)));
+}
+function jaccard(a, b) {
+    if (a.size === 0 && b.size === 0)
+        return 0;
+    let intersection = 0;
+    for (const word of a) {
+        if (b.has(word))
+            intersection++;
+    }
+    const union = a.size + b.size - intersection;
+    return union === 0 ? 0 : intersection / union;
+}

package/dist/analyzers/staleness.d.ts

@@ -0,0 +1,2 @@
+import { RuleFile, StaleRule } from "../types.js";
+export declare function analyzeStaleness(files: RuleFile[]): StaleRule[];

package/dist/analyzers/staleness.js

@@ -0,0 +1,11 @@
+const STALE_DAYS = 90;
+export function analyzeStaleness(files) {
+    const now = Date.now();
+    return files
+        .map((f) => ({
+        file: f.filename,
+        daysSinceModified: Math.floor((now - f.mtime.getTime()) / (1000 * 60 * 60 * 24)),
+    }))
+        .filter((r) => r.daysSinceModified >= STALE_DAYS)
+        .sort((a, b) => b.daysSinceModified - a.daysSinceModified);
+}

package/dist/analyzers/vagueness.d.ts

@@ -0,0 +1,2 @@
+import { RuleFile, VagueDirective } from "../types.js";
+export declare function analyzeVagueness(files: RuleFile[]): VagueDirective[];

package/dist/analyzers/vagueness.js

@@ -0,0 +1,52 @@
+const VAGUE_THRESHOLD = 20;
+const ABSTRACT_WORDS = new Set([
+    "good", "clean", "proper", "appropriate", "suitable", "nice",
+    "better", "best", "right", "correct", "reasonable", "adequate",
+    "effective", "efficient", "optimal", "ideal",
+]);
+export function analyzeVagueness(files) {
+    const results = [];
+    for (const file of files) {
+        for (const directive of file.directives) {
+            const score = scoreActionability(directive);
+            if (score < VAGUE_THRESHOLD) {
+                results.push({ file: file.filename, directive, score });
+            }
+        }
+    }
+    return results.sort((a, b) => a.score - b.score);
+}
+function scoreActionability(directive) {
+    let score = 50; // baseline
+    // Concrete file/tool/pattern names
+    if (/\.[a-z]{2,4}\b/.test(directive))
+        score += 15;
+    if (/[A-Z][a-z]+(?:[A-Z][a-z]+)+/.test(directive))
+        score += 10; // CamelCase
+    // Has measurable threshold
+    if (/\d+/.test(directive))
+        score += 20;
+    if (/[<>]=?\s*\d+/.test(directive))
+        score += 10;
+    // Has code example or format
+    if (/`[^`]+`/.test(directive))
+        score += 15;
+    // NEVER/ALWAYS absolutes
+    if (/\b(?:never|always|must)\b/i.test(directive))
+        score += 10;
+    // Too short without specifics
+    if (directive.split(/\s+/).length < 5)
+        score -= 20;
+    // Too abstract
+    const words = directive.toLowerCase().split(/\s+/);
+    const abstractCount = words.filter((w) => ABSTRACT_WORDS.has(w)).length;
+    if (abstractCount >= 2)
+        score -= 30;
+    if (abstractCount === 1)
+        score -= 10;
+    // No verb (not actionable)
+    if (!/\b(?:use|add|create|remove|avoid|check|run|write|read|test|validate|apply|set|keep|ensure)\b/i.test(directive)) {
+        score -= 15;
+    }
+    return Math.max(0, Math.min(100, score));
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+import { scanRuleFiles } from "./scanner.js";
+import { parseRuleFile } from "./parser.js";
+import { analyzeOverlap } from "./analyzers/overlap.js";
+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 { printReport } from "./reporter.js";
+async function main() {
+    const cwd = process.cwd();
+    const customPaths = process.argv.slice(2).filter((a) => !a.startsWith("-"));
+    const scanResults = await scanRuleFiles(cwd, customPaths);
+    if (scanResults.length === 0) {
+        console.log("No rule files found.");
+        console.log("Usage: deadrule [path...]");
+        console.log("Default: scans ~/.claude/rules/, .claude/rules/, CLAUDE.md");
+        process.exit(0);
+    }
+    const files = await Promise.all(scanResults.map((s) => parseRuleFile(s.path, s.scope)));
+    const { duplicates, directiveOverlaps } = analyzeOverlap(files);
+    const defaultMatches = analyzeDefaults(files);
+    const vagueDirectives = analyzeVagueness(files);
+    const costBreakdown = analyzeCost(files);
+    const staleRules = analyzeStaleness(files);
+    const result = {
+        totalFiles: files.length,
+        globalCount: files.filter((f) => f.scope === "global").length,
+        projectCount: files.filter((f) => f.scope === "project").length,
+        totalTokens: files.reduce((sum, f) => sum + f.tokenCount, 0),
+        duplicates,
+        directiveOverlaps,
+        defaultMatches,
+        vagueDirectives,
+        costBreakdown,
+        staleRules,
+    };
+    printReport(result);
+    const issues = duplicates.length +
+        directiveOverlaps.length +
+        defaultMatches.length +
+        vagueDirectives.length +
+        staleRules.length;
+    process.exit(issues > 0 ? 1 : 0);
+}
+main().catch((err) => {
+    console.error("Error:", err.message);
+    process.exit(2);
+});

package/dist/parser.d.ts

@@ -0,0 +1,2 @@
+import { RuleFile } from "./types.js";
+export declare function parseRuleFile(path: string, scope: "global" | "project"): Promise<RuleFile>;

package/dist/parser.js

@@ -0,0 +1,85 @@
+import { stat, readFile } from "node:fs/promises";
+import { relative } from "node:path";
+import { homedir } from "node:os";
+export async function parseRuleFile(path, scope) {
+    const content = await readFile(path, "utf-8");
+    const filename = shortName(path);
+    const fileStat = await stat(path);
+    const { frontmatter, body } = extractFrontmatter(content);
+    const directives = extractDirectives(body);
+    const tokenCount = Math.ceil(content.length / 4);
+    return {
+        path,
+        filename,
+        scope,
+        content,
+        frontmatter,
+        directives,
+        tokenCount,
+        mtime: fileStat.mtime,
+    };
+}
+function extractFrontmatter(content) {
+    const match = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
+    if (!match)
+        return { frontmatter: {}, body: content };
+    const raw = match[1];
+    const body = match[2];
+    const frontmatter = {};
+    for (const line of raw.split("\n")) {
+        const sep = line.indexOf(":");
+        if (sep === -1)
+            continue;
+        const key = line.slice(0, sep).trim();
+        const value = line.slice(sep + 1).trim();
+        if (key)
+            frontmatter[key] = value;
+    }
+    return { frontmatter, body };
+}
+function shortName(filePath) {
+    const home = homedir();
+    if (filePath.startsWith(home)) {
+        return "~/" + relative(home, filePath);
+    }
+    const cwd = process.cwd();
+    if (filePath.startsWith(cwd)) {
+        return relative(cwd, filePath);
+    }
+    // For custom paths, show last 2 segments
+    const parts = filePath.split("/");
+    return parts.slice(-2).join("/");
+}
+function extractDirectives(body) {
+    const directives = [];
+    let inCodeBlock = false;
+    for (const line of body.split("\n")) {
+        if (line.trim().startsWith("```")) {
+            inCodeBlock = !inCodeBlock;
+            continue;
+        }
+        if (inCodeBlock)
+            continue;
+        const trimmed = line.trim();
+        const match = trimmed.match(/^[-*]\s+(.+)$/) ?? trimmed.match(/^\d+\.\s+(.+)$/);
+        if (match) {
+            let text = match[1].replace(/\*\*/g, "").trim();
+            // Strip checkbox markers
+            text = text.replace(/^\[[ x]\]\s*/i, "").trim();
+            if (text.length > 20 && isDirective(text))
+                directives.push(text);
+        }
+    }
+    return directives;
+}
+function isDirective(text) {
+    // Skip labels/categories (no verb, just a noun phrase)
+    const words = text.split(/\s+/);
+    if (words.length <= 3)
+        return false;
+    // Must contain a verb or actionable keyword
+    const hasVerb = /\b(?:use|add|create|remove|avoid|check|run|write|read|test|validate|apply|set|keep|ensure|never|always|must|should|don't|do not|implement|configure|enable|disable|include|exclude|prefer|require|prevent|handle|return|throw|log|call|pass|send|receive|store|load|save|delete|update|verify|confirm|follow|maintain)\b/i.test(text);
+    // Or contains technical specifics
+    const hasTechnical = /[`<>{}()\[\]\/\\]|=>|->|\.\w+\b/.test(text);
+    return hasVerb || hasTechnical;
+}

package/dist/reporter.d.ts

@@ -0,0 +1,2 @@
+import { AnalysisResult } from "./types.js";
+export declare function printReport(result: AnalysisResult): void;

package/dist/reporter.js

@@ -0,0 +1,164 @@
+const MAX_ITEMS = 10;
+export function printReport(result) {
+    const { totalFiles, globalCount, projectCount, totalTokens } = result;
+    console.log("");
+    console.log("deadrule v0.1.0");
+    console.log("================");
+    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)`);
+    printDuplicates(result);
+    printDirectiveOverlaps(result);
+    printDefaults(result);
+    printVague(result);
+    printCost(result);
+    printStale(result);
+    printSummary(result);
+}
+function printDuplicates(r) {
+    if (r.duplicates.length === 0)
+        return;
+    console.log("");
+    console.log("DUPLICATES");
+    const shown = r.duplicates.slice(0, MAX_ITEMS);
+    for (const d of shown) {
+        console.log(`  ${d.fileA} <-> ${d.fileB}  (${d.similarity}% overlap)`);
+    }
+    if (r.duplicates.length > MAX_ITEMS) {
+        console.log(`  ... and ${r.duplicates.length - MAX_ITEMS} more`);
+    }
+}
+function printDirectiveOverlaps(r) {
+    if (r.directiveOverlaps.length === 0)
+        return;
+    console.log("");
+    console.log(`OVERLAPPING DIRECTIVES (${r.directiveOverlaps.length} found, showing top ${Math.min(r.directiveOverlaps.length, MAX_ITEMS)})`);
+    // Group by directive text to avoid repetitive output
+    const grouped = groupOverlaps(r.directiveOverlaps);
+    let count = 0;
+    for (const [directive, files] of grouped) {
+        if (count >= MAX_ITEMS)
+            break;
+        console.log(`  "${truncate(directive, 60)}"`);
+        console.log(`  -> repeated in: ${files.join(", ")}`);
+        console.log("");
+        count++;
+    }
+    if (grouped.size > MAX_ITEMS) {
+        console.log(`  ... and ${grouped.size - MAX_ITEMS} more patterns`);
+    }
+}
+function groupOverlaps(overlaps) {
+    const groups = new Map();
+    for (const o of overlaps) {
+        // Use the shorter directive as key
+        const key = o.directiveA.length <= o.directiveB.length
+            ? o.directiveA
+            : o.directiveB;
+        if (!groups.has(key))
+            groups.set(key, new Set());
+        const set = groups.get(key);
+        set.add(o.fileA);
+        set.add(o.fileB);
+    }
+    // Sort by number of files (most repeated first)
+    return new Map([...groups.entries()]
+        .sort((a, b) => b[1].size - a[1].size)
+        .map(([k, v]) => [k, [...v]]));
+}
+function printDefaults(r) {
+    if (r.defaultMatches.length === 0)
+        return;
+    console.log("");
+    console.log("REDUNDANT WITH CLAUDE DEFAULTS");
+    const shown = r.defaultMatches.slice(0, MAX_ITEMS);
+    for (const m of shown) {
+        console.log(`  ${m.file}: "${truncate(m.directive, 50)}"`);
+        console.log(`  -> ${m.reason}`);
+        console.log("");
+    }
+    if (r.defaultMatches.length > MAX_ITEMS) {
+        console.log(`  ... and ${r.defaultMatches.length - MAX_ITEMS} more`);
+    }
+}
+function printVague(r) {
+    if (r.vagueDirectives.length === 0)
+        return;
+    console.log("");
+    console.log("VAGUE DIRECTIVES");
+    const shown = r.vagueDirectives.slice(0, MAX_ITEMS);
+    for (const v of shown) {
+        console.log(`  ${v.file}: "${truncate(v.directive, 50)}"  (${v.score}/100)`);
+    }
+    if (r.vagueDirectives.length > MAX_ITEMS) {
+        console.log(`  ... and ${r.vagueDirectives.length - MAX_ITEMS} more`);
+    }
+}
+function printCost(r) {
+    if (r.costBreakdown.length === 0)
+        return;
+    console.log("");
+    console.log("TOKEN COST BREAKDOWN (top 10)");
+    const maxNameLen = Math.max(...r.costBreakdown.slice(0, MAX_ITEMS).map((c) => c.file.length));
+    const shown = r.costBreakdown.slice(0, MAX_ITEMS);
+    for (const c of shown) {
+        const bar = makeBar(c.percent);
+        const name = c.file.padEnd(maxNameLen);
+        console.log(`  ${name}  ~${String(c.tokens).padStart(5)} tokens  ${bar}  ${c.percent}%`);
+    }
+    if (r.costBreakdown.length > MAX_ITEMS) {
+        const rest = r.costBreakdown.slice(MAX_ITEMS);
+        const restTokens = rest.reduce((s, c) => s + c.tokens, 0);
+        console.log(`  ... ${rest.length} more files (~${restTokens.toLocaleString()} tokens)`);
+    }
+}
+function printStale(r) {
+    if (r.staleRules.length === 0)
+        return;
+    console.log("");
+    console.log("STALE RULES (not modified in 90+ days)");
+    const shown = r.staleRules.slice(0, MAX_ITEMS);
+    for (const s of shown) {
+        console.log(`  ${s.file}  (${s.daysSinceModified} days)`);
+    }
+    if (r.staleRules.length > MAX_ITEMS) {
+        console.log(`  ... and ${r.staleRules.length - MAX_ITEMS} more`);
+    }
+}
+function printSummary(r) {
+    const issues = r.duplicates.length +
+        r.directiveOverlaps.length +
+        r.defaultMatches.length +
+        r.vagueDirectives.length +
+        r.staleRules.length;
+    console.log("");
+    console.log("SUMMARY");
+    if (issues === 0) {
+        console.log("  All rules look healthy!");
+    }
+    else {
+        if (r.duplicates.length > 0) {
+            console.log(`  ${r.duplicates.length} duplicate pair(s)`);
+        }
+        if (r.directiveOverlaps.length > 0) {
+            console.log(`  ${r.directiveOverlaps.length} overlapping directive(s)`);
+        }
+        if (r.defaultMatches.length > 0) {
+            console.log(`  ${r.defaultMatches.length} redundant with Claude defaults`);
+        }
+        if (r.vagueDirectives.length > 0) {
+            console.log(`  ${r.vagueDirectives.length} vague directive(s)`);
+        }
+        if (r.staleRules.length > 0) {
+            console.log(`  ${r.staleRules.length} stale rule(s)`);
+        }
+    }
+    console.log("");
+}
+function makeBar(percent) {
+    const filled = Math.round(percent / 10);
+    return "\u2588".repeat(filled) + "\u2591".repeat(10 - filled);
+}
+function truncate(text, max) {
+    return text.length > max ? text.slice(0, max - 3) + "..." : text;
+}

package/dist/scanner.d.ts

@@ -0,0 +1,6 @@
+interface ScanResult {
+    path: string;
+    scope: "global" | "project";
+}
+export declare function scanRuleFiles(cwd: string, customPaths?: string[]): Promise<ScanResult[]>;
+export {};

package/dist/scanner.js

@@ -0,0 +1,68 @@
+import { readdir } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { homedir } from "node:os";
+import { existsSync, statSync } from "node:fs";
+export async function scanRuleFiles(cwd, customPaths = []) {
+    // Custom paths take priority — skip default scanning
+    if (customPaths.length > 0) {
+        const results = [];
+        for (const p of customPaths) {
+            const abs = resolve(p);
+            if (!existsSync(abs))
+                continue;
+            if (statSync(abs).isDirectory()) {
+                const files = await scanDirRecursive(abs, "project");
+                results.push(...files);
+            }
+            else {
+                results.push({ path: abs, scope: "project" });
+            }
+        }
+        return results;
+    }
+    const results = [];
+    // Global rules: ~/.claude/rules/*.md
+    const globalDir = join(homedir(), ".claude", "rules");
+    const globalFiles = await scanDir(globalDir, "global");
+    results.push(...globalFiles);
+    // Project rules: .claude/rules/*.md
+    const projectDir = join(cwd, ".claude", "rules");
+    const projectFiles = await scanDir(projectDir, "project");
+    results.push(...projectFiles);
+    // Project CLAUDE.md
+    const claudeMd = join(cwd, "CLAUDE.md");
+    if (existsSync(claudeMd)) {
+        results.push({ path: claudeMd, scope: "project" });
+    }
+    // Cursor rules
+    const cursorRules = join(cwd, ".cursorrules");
+    if (existsSync(cursorRules)) {
+        results.push({ path: cursorRules, scope: "project" });
+    }
+    return results;
+}
+async function scanDir(dir, scope) {
+    if (!existsSync(dir))
+        return [];
+    const entries = await readdir(dir);
+    return entries
+        .filter((f) => f.endsWith(".md"))
+        .map((f) => ({ path: join(dir, f), scope }));
+}
+async function scanDirRecursive(dir, scope) {
+    if (!existsSync(dir))
+        return [];
+    const entries = await readdir(dir, { withFileTypes: true });
+    const results = [];
+    for (const entry of entries) {
+        const full = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            const sub = await scanDirRecursive(full, scope);
+            results.push(...sub);
+        }
+        else if (entry.name.endsWith(".md")) {
+            results.push({ path: full, scope });
+        }
+    }
+    return results;
+}

package/dist/types.d.ts

@@ -0,0 +1,53 @@
+export interface RuleFile {
+    path: string;
+    filename: string;
+    scope: "global" | "project";
+    content: string;
+    frontmatter: Record<string, string>;
+    directives: string[];
+    tokenCount: number;
+    mtime: Date;
+}
+export interface OverlapResult {
+    fileA: string;
+    fileB: string;
+    similarity: number;
+}
+export interface DirectiveOverlap {
+    fileA: string;
+    directiveA: string;
+    fileB: string;
+    directiveB: string;
+    similarity: number;
+}
+export interface DefaultMatch {
+    file: string;
+    directive: string;
+    reason: string;
+}
+export interface VagueDirective {
+    file: string;
+    directive: string;
+    score: number;
+}
+export interface CostEntry {
+    file: string;
+    tokens: number;
+    percent: number;
+}
+export interface StaleRule {
+    file: string;
+    daysSinceModified: number;
+}
+export interface AnalysisResult {
+    totalFiles: number;
+    globalCount: number;
+    projectCount: number;
+    totalTokens: number;
+    duplicates: OverlapResult[];
+    directiveOverlaps: DirectiveOverlap[];
+    defaultMatches: DefaultMatch[];
+    vagueDirectives: VagueDirective[];
+    costBreakdown: CostEntry[];
+    staleRules: StaleRule[];
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "deadrule",
+  "version": "0.1.0",
+  "description": "Find dead rules in your AI coding assistant config",
+  "type": "module",
+  "bin": {
+    "deadrule": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "claude-code",
+    "cursor",
+    "ai-coding",
+    "rules",
+    "linter"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "^5.7.0",
+    "@types/node": "^22.0.0"
+  }
+}