dep-brain 0.1.4 → 0.2.1

package/README.md

@@ -41,6 +41,7 @@ dep-brain analyze
 
 npx dep-brain analyze
 npx dep-brain analyze --json
+npx dep-brain analyze --md
 npx dep-brain analyze ./path-to-project
 npx dep-brain analyze --config depbrain.config.json
 npx dep-brain analyze --min-score 90 --fail-on-risks
@@ -90,6 +91,12 @@ Suggestions:
 dep-brain analyze --json
 ```
 
+## Markdown Output
+
+```bash
+dep-brain analyze --md
+```
+
 ## Config File
 
 Create a `depbrain.config.json` file in the project root:
@@ -107,6 +114,12 @@ Create a `depbrain.config.json` file in the project root:
   },
   "report": {
     "maxSuggestions": 3
+  },
+  "scoring": {
+    "duplicateWeight": 5,
+    "outdatedWeight": 1,
+    "unusedWeight": 2,
+    "riskWeight": 6
   }
 }
 ```
@@ -125,6 +138,10 @@ Supported sections:
 - `policy.failOnOutdated`
 - `policy.failOnRisks`
 - `report.maxSuggestions`
+- `scoring.duplicateWeight`
+- `scoring.outdatedWeight`
+- `scoring.unusedWeight`
+- `scoring.riskWeight`
 
 Sample config file:
 

package/depbrain.config.json

@@ -16,5 +16,11 @@
   },
   "report": {
     "maxSuggestions": 5
+  },
+  "scoring": {
+    "duplicateWeight": 5,
+    "outdatedWeight": 3,
+    "unusedWeight": 4,
+    "riskWeight": 10
   }
 }

package/depbrain.config.schema.json

@@ -33,6 +33,16 @@
       "properties": {
         "maxSuggestions": { "type": "number" }
       }
+    },
+    "scoring": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "duplicateWeight": { "type": "number" },
+        "outdatedWeight": { "type": "number" },
+        "unusedWeight": { "type": "number" },
+        "riskWeight": { "type": "number" }
+      }
     }
   }
 }

package/dist/cli.js

@@ -2,6 +2,7 @@
 import { analyzeProject } from "./core/analyzer.js";
 import { renderConsoleReport } from "./reporters/console.js";
 import { renderJsonReport } from "./reporters/json.js";
+import { renderMarkdownReport } from "./reporters/markdown.js";
 import { promises as fs } from "node:fs";
 import path from "node:path";
 async function main() {
@@ -80,6 +81,9 @@ async function main() {
         if (flags.has("--json")) {
             process.stdout.write(`${renderJsonReport(result)}\n`);
         }
+        else if (flags.has("--md")) {
+            process.stdout.write(`${renderMarkdownReport(result)}\n`);
+        }
         else {
             const output = renderConsoleReport(result);
             if (!output || output.trim().length === 0) {
@@ -144,13 +148,14 @@ function printHelp() {
     console.log("Dependency Brain");
     console.log("");
     console.log("Usage:");
-    console.log("  dep-brain analyze [path] [--json] [--config path] [--min-score n] [--fail-on-risks] [--fail-on-outdated] [--fail-on-unused] [--fail-on-duplicates]");
+    console.log("  dep-brain analyze [path] [--json] [--md] [--config path] [--min-score n] [--fail-on-risks] [--fail-on-outdated] [--fail-on-unused] [--fail-on-duplicates]");
     console.log("  dep-brain config [path] [--config path]");
     console.log("  dep-brain help");
     console.log("  dep-brain --version");
     console.log("");
     console.log("Options:");
     console.log("  --json              Output JSON for analysis");
+    console.log("  --md                Output Markdown report");
     console.log("  --config <path>     Path to depbrain.config.json");
     console.log("  --min-score <n>     Minimum score required to pass");
     console.log("  --fail-on-risks     Fail when risky dependencies exist");

package/dist/core/analyzer.d.ts

@@ -33,6 +33,7 @@ export interface RiskDependency {
 export interface AnalysisResult {
     rootDir: string;
     score: number;
+    scoreBreakdown: ScoreBreakdown;
     policy: PolicyResult;
     duplicates: DuplicateDependency[];
     unused: UnusedDependency[];
@@ -50,6 +51,7 @@ export interface PackageAnalysisResult {
     name: string;
     rootDir: string;
     score: number;
+    scoreBreakdown: ScoreBreakdown;
     policy: PolicyResult;
     duplicates: DuplicateDependency[];
     unused: UnusedDependency[];
@@ -57,4 +59,17 @@ export interface PackageAnalysisResult {
     risks: RiskDependency[];
     suggestions: string[];
 }
+export interface ScoreBreakdown {
+    baseScore: number;
+    duplicates: number;
+    outdated: number;
+    unused: number;
+    risks: number;
+    weights: {
+        duplicateWeight: number;
+        outdatedWeight: number;
+        unusedWeight: number;
+        riskWeight: number;
+    };
+}
 export declare function analyzeProject(options?: AnalysisOptions): Promise<AnalysisResult>;

package/dist/core/analyzer.js

@@ -32,8 +32,18 @@ export async function analyzeProject(options = {}) {
         duplicates: duplicates.length,
         unused: unused.length,
         outdated: outdated.length,
-        risks: risks.length
+        risks: risks.length,
+        duplicateWeight: config.scoring.duplicateWeight,
+        outdatedWeight: config.scoring.outdatedWeight,
+        unusedWeight: config.scoring.unusedWeight,
+        riskWeight: config.scoring.riskWeight
     });
+    const scoreBreakdown = buildScoreBreakdown({
+        duplicates: duplicates.length,
+        unused: unused.length,
+        outdated: outdated.length,
+        risks: risks.length
+    }, config);
     const suggestions = [
         ...packages.flatMap((pkg) => pkg.suggestions.map((suggestion) => `[${pkg.name}] ${suggestion}`))
     ].slice(0, config.report.maxSuggestions);
@@ -47,6 +57,7 @@ export async function analyzeProject(options = {}) {
     return {
         rootDir,
         score,
+        scoreBreakdown,
         policy,
         duplicates,
         unused,
@@ -79,6 +90,12 @@ function mergeConfig(base, overrides) {
         },
         report: {
             maxSuggestions: overrides.report?.maxSuggestions ?? base.report.maxSuggestions
+        },
+        scoring: {
+            duplicateWeight: overrides.scoring?.duplicateWeight ?? base.scoring.duplicateWeight,
+            outdatedWeight: overrides.scoring?.outdatedWeight ?? base.scoring.outdatedWeight,
+            unusedWeight: overrides.scoring?.unusedWeight ?? base.scoring.unusedWeight,
+            riskWeight: overrides.scoring?.riskWeight ?? base.scoring.riskWeight
         }
     };
 }
@@ -121,8 +138,18 @@ async function analyzeSingleProject(rootDir, config, options = {}) {
         duplicates: duplicates.length,
         unused: unused.length,
         outdated: outdated.length,
-        risks: risks.length
+        risks: risks.length,
+        duplicateWeight: config.scoring.duplicateWeight,
+        outdatedWeight: config.scoring.outdatedWeight,
+        unusedWeight: config.scoring.unusedWeight,
+        riskWeight: config.scoring.riskWeight
     });
+    const scoreBreakdown = buildScoreBreakdown({
+        duplicates: duplicates.length,
+        unused: unused.length,
+        outdated: outdated.length,
+        risks: risks.length
+    }, config);
     const suggestions = [
         ...unused.map((item) => `Remove ${item.name} from ${item.section}`),
         ...duplicates.map((item) => `Consider consolidating ${item.name} to one version`),
@@ -147,6 +174,7 @@ async function analyzeSingleProject(rootDir, config, options = {}) {
     return {
         rootDir,
         score,
+        scoreBreakdown,
         policy,
         duplicates,
         unused: scopedUnused,
@@ -156,3 +184,18 @@ async function analyzeSingleProject(rootDir, config, options = {}) {
         config
     };
 }
+function buildScoreBreakdown(counts, config) {
+    return {
+        baseScore: 100,
+        duplicates: counts.duplicates * config.scoring.duplicateWeight,
+        outdated: counts.outdated * config.scoring.outdatedWeight,
+        unused: counts.unused * config.scoring.unusedWeight,
+        risks: counts.risks * config.scoring.riskWeight,
+        weights: {
+            duplicateWeight: config.scoring.duplicateWeight,
+            outdatedWeight: config.scoring.outdatedWeight,
+            unusedWeight: config.scoring.unusedWeight,
+            riskWeight: config.scoring.riskWeight
+        }
+    };
+}

package/dist/core/scorer.d.ts

@@ -3,5 +3,9 @@ export interface ScoreInputs {
     unused: number;
     outdated: number;
     risks: number;
+    duplicateWeight?: number;
+    unusedWeight?: number;
+    outdatedWeight?: number;
+    riskWeight?: number;
 }
 export declare function calculateHealthScore(inputs: ScoreInputs): number;

package/dist/core/scorer.js

@@ -1,8 +1,12 @@
 export function calculateHealthScore(inputs) {
+    const duplicateWeight = inputs.duplicateWeight ?? 5;
+    const outdatedWeight = inputs.outdatedWeight ?? 3;
+    const unusedWeight = inputs.unusedWeight ?? 4;
+    const riskWeight = inputs.riskWeight ?? 10;
     const rawScore = 100 -
-        inputs.duplicates * 5 -
-        inputs.outdated * 3 -
-        inputs.unused * 4 -
-        inputs.risks * 10;
+        inputs.duplicates * duplicateWeight -
+        inputs.outdated * outdatedWeight -
+        inputs.unused * unusedWeight -
+        inputs.risks * riskWeight;
     return Math.max(0, rawScore);
 }

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export { analyzeProject } from "./core/analyzer.js";
-export type { AnalysisOptions, AnalysisResult, DuplicateDependency, OutdatedDependency, PolicyResult, PackageAnalysisResult, RiskDependency, UnusedDependency } from "./core/analyzer.js";
+export type { AnalysisOptions, AnalysisResult, DuplicateDependency, OutdatedDependency, PolicyResult, PackageAnalysisResult, ScoreBreakdown, RiskDependency, UnusedDependency } from "./core/analyzer.js";
 export type { DepBrainConfig, DepBrainConfigOverrides } from "./utils/config.js";
 export type { WorkspacePackage } from "./utils/workspaces.js";

package/dist/reporters/console.js

@@ -3,6 +3,7 @@ export function renderConsoleReport(result) {
     lines.push(`Project Health: ${result.score}/100`);
     lines.push(`Path: ${result.rootDir}`);
     lines.push(`Policy: ${result.policy.passed ? "PASS" : "FAIL"}`);
+    lines.push(`Score Breakdown: base ${result.scoreBreakdown.baseScore} - dup ${result.scoreBreakdown.duplicates} - outdated ${result.scoreBreakdown.outdated} - unused ${result.scoreBreakdown.unused} - risk ${result.scoreBreakdown.risks}`);
     lines.push("");
     lines.push(summaryLine("Duplicates", result.duplicates.length));
     lines.push(summaryLine("Unused", result.unused.length));

package/dist/reporters/markdown.d.ts

@@ -0,0 +1,2 @@
+import type { AnalysisResult } from "../core/analyzer.js";
+export declare function renderMarkdownReport(result: AnalysisResult): string;

package/dist/reporters/markdown.js

@@ -0,0 +1,52 @@
+export function renderMarkdownReport(result) {
+    const lines = [];
+    lines.push(`# Dependency Brain Report`);
+    lines.push("");
+    lines.push(`- **Project Health:** ${result.score}/100`);
+    lines.push(`- **Path:** ${result.rootDir}`);
+    lines.push(`- **Policy:** ${result.policy.passed ? "PASS" : "FAIL"}`);
+    lines.push(`- **Score Breakdown:** base ${result.scoreBreakdown.baseScore} - dup ${result.scoreBreakdown.duplicates} - outdated ${result.scoreBreakdown.outdated} - unused ${result.scoreBreakdown.unused} - risk ${result.scoreBreakdown.risks}`);
+    lines.push("");
+    if (result.packages && result.packages.length > 0) {
+        lines.push("## Packages");
+        for (const pkg of result.packages) {
+            lines.push(`- ${pkg.name}: ${pkg.score}/100 (D:${pkg.duplicates.length} U:${pkg.unused.length} O:${pkg.outdated.length} R:${pkg.risks.length})`);
+        }
+        lines.push("");
+    }
+    lines.push("## Summary");
+    lines.push(`- Duplicates: ${result.duplicates.length}`);
+    lines.push(`- Unused: ${result.unused.length}`);
+    lines.push(`- Outdated: ${result.outdated.length}`);
+    lines.push(`- Risks: ${result.risks.length}`);
+    lines.push("");
+    appendSection(lines, "Duplicate dependencies", result.duplicates.map((item) => `${item.name}: ${item.versions.join(", ")}`));
+    appendSection(lines, "Unused dependencies", result.unused.map((item) => item.package
+        ? `${item.name} (${item.section}) [${item.package}]`
+        : `${item.name} (${item.section})`));
+    appendSection(lines, "Outdated dependencies", result.outdated.map((item) => item.package
+        ? `${item.name}: ${item.current} -> ${item.latest} [${item.updateType}] [${item.package}]`
+        : `${item.name}: ${item.current} -> ${item.latest} [${item.updateType}]`));
+    appendSection(lines, "Risky dependencies", result.risks.map((item) => item.package
+        ? `${item.name}: ${item.reasons.join("; ")} [${item.package}]`
+        : `${item.name}: ${item.reasons.join("; ")}`));
+    appendSection(lines, "Policy reasons", result.policy.reasons);
+    if (result.suggestions.length > 0) {
+        lines.push("## Suggestions");
+        for (const suggestion of result.suggestions) {
+            lines.push(`- ${suggestion}`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+function appendSection(lines, title, items) {
+    if (items.length === 0) {
+        return;
+    }
+    lines.push(`## ${title}`);
+    for (const item of items) {
+        lines.push(`- ${item}`);
+    }
+    lines.push("");
+}

package/dist/utils/config.d.ts

@@ -17,11 +17,18 @@ export interface DepBrainConfig {
     report: {
         maxSuggestions: number;
     };
+    scoring: {
+        duplicateWeight: number;
+        outdatedWeight: number;
+        unusedWeight: number;
+        riskWeight: number;
+    };
 }
 export interface DepBrainConfigOverrides {
     ignore?: Partial<DepBrainConfig["ignore"]>;
     policy?: Partial<DepBrainConfig["policy"]>;
     report?: Partial<DepBrainConfig["report"]>;
+    scoring?: Partial<DepBrainConfig["scoring"]>;
 }
 export declare const defaultConfig: DepBrainConfig;
 export declare function loadDepBrainConfig(rootDir: string, configPath?: string): Promise<DepBrainConfig>;

package/dist/utils/config.js

@@ -18,6 +18,12 @@ export const defaultConfig = {
     },
     report: {
         maxSuggestions: 5
+    },
+    scoring: {
+        duplicateWeight: 5,
+        outdatedWeight: 3,
+        unusedWeight: 4,
+        riskWeight: 10
     }
 };
 export async function loadDepBrainConfig(rootDir, configPath) {
@@ -49,6 +55,12 @@ function normalizeConfig(loaded) {
         },
         report: {
             maxSuggestions: normalizeNumber(loaded.report?.maxSuggestions, defaultConfig.report.maxSuggestions)
+        },
+        scoring: {
+            duplicateWeight: normalizeNumber(loaded.scoring?.duplicateWeight, defaultConfig.scoring.duplicateWeight),
+            outdatedWeight: normalizeNumber(loaded.scoring?.outdatedWeight, defaultConfig.scoring.outdatedWeight),
+            unusedWeight: normalizeNumber(loaded.scoring?.unusedWeight, defaultConfig.scoring.unusedWeight),
+            riskWeight: normalizeNumber(loaded.scoring?.riskWeight, defaultConfig.scoring.riskWeight)
         }
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dep-brain",
-  "version": "0.1.4",
+  "version": "0.2.1",
   "description": "CLI and library for dependency health analysis",
   "type": "module",
   "main": "dist/index.js",