getdoorman 1.0.0

package/src/metrics.js

@@ -0,0 +1,126 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+
+const METRICS_DIR = '.doorman';
+const METRICS_FILE = 'metrics.json';
+
+function getMetricsPath(targetPath) {
+  return join(targetPath, METRICS_DIR, METRICS_FILE);
+}
+
+function ensureDir(targetPath) {
+  const dir = join(targetPath, METRICS_DIR);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+
+export function loadMetrics(targetPath) {
+  const path = getMetricsPath(targetPath);
+  if (!existsSync(path)) {
+    return { scans: [], fixes: [], scores: [] };
+  }
+  return JSON.parse(readFileSync(path, 'utf-8'));
+}
+
+export function recordScan(targetPath, { score, findings, stack }) {
+  ensureDir(targetPath);
+  const metrics = loadMetrics(targetPath);
+
+  const scan = {
+    timestamp: new Date().toISOString(),
+    score,
+    totalFindings: findings.length,
+    bySeverity: {
+      critical: findings.filter(f => f.severity === 'critical').length,
+      high: findings.filter(f => f.severity === 'high').length,
+      medium: findings.filter(f => f.severity === 'medium').length,
+      low: findings.filter(f => f.severity === 'low').length,
+    },
+    byCategory: {},
+    fixable: findings.filter(f => f.fix).length,
+    stack: stack.framework || stack.language || 'unknown',
+  };
+
+  // Count by category
+  for (const f of findings) {
+    scan.byCategory[f.category] = (scan.byCategory[f.category] || 0) + 1;
+  }
+
+  metrics.scans.push(scan);
+
+  // Keep last 100 scans
+  if (metrics.scans.length > 100) metrics.scans = metrics.scans.slice(-100);
+
+  // Track score history
+  metrics.scores.push({ timestamp: scan.timestamp, score });
+  if (metrics.scores.length > 100) metrics.scores = metrics.scores.slice(-100);
+
+  writeFileSync(getMetricsPath(targetPath), JSON.stringify(metrics, null, 2));
+  return scan;
+}
+
+export function recordFix(targetPath, { applied, offered, accepted }) {
+  ensureDir(targetPath);
+  const metrics = loadMetrics(targetPath);
+
+  metrics.fixes.push({
+    timestamp: new Date().toISOString(),
+    offered,
+    applied,
+    accepted,
+    rate: offered > 0 ? Math.round((accepted / offered) * 100) : 0,
+  });
+
+  if (metrics.fixes.length > 100) metrics.fixes = metrics.fixes.slice(-100);
+
+  writeFileSync(getMetricsPath(targetPath), JSON.stringify(metrics, null, 2));
+}
+
+export function getScoreHistory(targetPath) {
+  const metrics = loadMetrics(targetPath);
+  return metrics.scores;
+}
+
+export function getFixAcceptanceRate(targetPath) {
+  const metrics = loadMetrics(targetPath);
+  if (metrics.fixes.length === 0) return null;
+
+  const totalOffered = metrics.fixes.reduce((sum, f) => sum + f.offered, 0);
+  const totalAccepted = metrics.fixes.reduce((sum, f) => sum + f.accepted, 0);
+
+  return {
+    totalOffered,
+    totalAccepted,
+    rate: totalOffered > 0 ? Math.round((totalAccepted / totalOffered) * 100) : 0,
+    history: metrics.fixes,
+  };
+}
+
+export function printMetricsSummary(targetPath) {
+  const metrics = loadMetrics(targetPath);
+
+  if (metrics.scans.length === 0) {
+    console.log('  No scan history yet. Run `doorman check` first.');
+    return;
+  }
+
+  const latest = metrics.scans[metrics.scans.length - 1];
+  const first = metrics.scans[0];
+  const scoreDelta = latest.score - first.score;
+
+  console.log('');
+  console.log('  Doorman Metrics');
+  console.log('  ═══════════════════');
+  console.log(`  Total scans: ${metrics.scans.length}`);
+  console.log(`  Current score: ${latest.score}/100`);
+  if (metrics.scans.length > 1) {
+    console.log(`  Score trend: ${scoreDelta >= 0 ? '+' : ''}${scoreDelta} since first scan`);
+  }
+  console.log(`  Total findings: ${latest.totalFindings}`);
+  console.log(`  Auto-fixable: ${latest.fixable}`);
+
+  if (metrics.fixes.length > 0) {
+    const fixRate = getFixAcceptanceRate(targetPath);
+    console.log(`  Fix acceptance rate: ${fixRate.rate}%`);
+  }
+  console.log('');
+}

package/src/monorepo.js

@@ -0,0 +1,65 @@
+// Monorepo detection and workspace root discovery
+import { existsSync, readFileSync } from 'fs';
+import { join, resolve } from 'path';
+
+/**
+ * Detect monorepo workspaces and return workspace roots.
+ * Supports: npm workspaces, yarn, pnpm, turborepo, nx, lerna
+ */
+export function detectWorkspaces(targetPath) {
+  const workspaces = [];
+
+  // npm/yarn workspaces
+  const pkgPath = join(targetPath, 'package.json');
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+      const ws = pkg.workspaces;
+      if (Array.isArray(ws)) {
+        workspaces.push(...ws);
+      } else if (ws && Array.isArray(ws.packages)) {
+        workspaces.push(...ws.packages);
+      }
+    } catch {}
+  }
+
+  // pnpm workspaces
+  const pnpmWs = join(targetPath, 'pnpm-workspace.yaml');
+  if (existsSync(pnpmWs)) {
+    try {
+      const content = readFileSync(pnpmWs, 'utf-8');
+      const matches = content.match(/- ['"]?([^'":\n]+)['"]?/g);
+      if (matches) {
+        workspaces.push(...matches.map(m => m.replace(/^- ['"]?/, '').replace(/['"]?$/, '')));
+      }
+    } catch {}
+  }
+
+  // turborepo
+  if (existsSync(join(targetPath, 'turbo.json'))) {
+    // turbo uses package.json workspaces — already handled above
+  }
+
+  // nx
+  if (existsSync(join(targetPath, 'nx.json'))) {
+    if (workspaces.length === 0) {
+      // Default nx layout
+      if (existsSync(join(targetPath, 'apps'))) workspaces.push('apps/*');
+      if (existsSync(join(targetPath, 'libs'))) workspaces.push('libs/*');
+      if (existsSync(join(targetPath, 'packages'))) workspaces.push('packages/*');
+    }
+  }
+
+  // lerna
+  const lernaPath = join(targetPath, 'lerna.json');
+  if (existsSync(lernaPath) && workspaces.length === 0) {
+    try {
+      const lerna = JSON.parse(readFileSync(lernaPath, 'utf-8'));
+      if (Array.isArray(lerna.packages)) {
+        workspaces.push(...lerna.packages);
+      }
+    } catch {}
+  }
+
+  return { isMonorepo: workspaces.length > 0, workspaces };
+}

package/src/presets.js

@@ -0,0 +1,54 @@
+// ---------------------------------------------------------------------------
+// Built-in configuration presets for Doorman
+// ---------------------------------------------------------------------------
+
+/**
+ * "recommended" — sensible defaults for most projects.
+ * All categories, medium+ severity, common ignore patterns.
+ */
+const recommended = {
+  rules: {},
+  categories: [],               // empty = all categories
+  severity: 'medium',
+  ignore: ['test/**', 'vendor/**', '*.min.js'],
+};
+
+/**
+ * "strict" — everything, no mercy.
+ * All categories, all severities, no extra ignore patterns.
+ */
+const strict = {
+  rules: {},
+  categories: [],               // all categories
+  severity: 'low',
+  ignore: [],
+};
+
+/**
+ * "minimal" — only the critical stuff.
+ * Security + reliability only, high+ severity.
+ */
+const minimal = {
+  rules: {},
+  categories: ['security', 'reliability'],
+  severity: 'high',
+  ignore: ['test/**', 'vendor/**', '*.min.js'],
+};
+
+const PRESETS = { recommended, strict, minimal };
+
+/**
+ * Resolve a preset by name. Returns a shallow copy or null if unknown.
+ */
+export function getPreset(name) {
+  const preset = PRESETS[name];
+  if (!preset) return null;
+  return {
+    ...preset,
+    rules: { ...preset.rules },
+    categories: [...preset.categories],
+    ignore: [...preset.ignore],
+  };
+}
+
+export { PRESETS };