@dewtech/dare-cli 3.10.0 → 3.12.0

package/skills/dare-quality-telemetry/collectors/dare_ax_collector.ts

@@ -0,0 +1,301 @@
+/**
+ * dare-quality-telemetry — DareAx collector
+ * Collects M-01 to M-04 metrics for a project that should comply with dare-ax.
+ * License: MIT
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { MetricResult } from '../types.js';
+
+/** Required sections that must appear in a valid llms.txt */
+const REQUIRED_LLMS_SECTIONS = [
+  'Project Overview',
+  'Tech Stack',
+  'Architecture',
+  'Getting Started',
+  'For AI Agents',
+];
+
+/** Rate-limit patterns to detect */
+const RATE_LIMIT_PATTERNS: RegExp[] = [
+  /rack-attack/i,
+  /express-rate-limit/i,
+  /tower-governor/i,
+  /throttler/i,
+  /RateLimiter/i,
+  /rate[_-]?limit/i,
+  /slowapi/i,
+  /django-ratelimit/i,
+  /ulule\/limiter/i,
+  /golang\.org\/x\/time\/rate/i,
+];
+
+/** Source file extensions for grep operations */
+const SOURCE_EXTENSIONS = ['.ts', '.js', '.mjs', '.rb', '.rs', '.py', '.go', '.php'];
+
+const SKIP_DIRS = new Set(['node_modules', 'target', 'dist', '.git', 'vendor', '__pycache__', 'coverage']);
+
+export function collectDareAx(projectPath: string): Promise<MetricResult[]> {
+  return Promise.resolve([
+    collectM01(projectPath),
+    collectM02(projectPath),
+    collectM03(projectPath),
+    collectM04(projectPath),
+  ]);
+}
+
+/**
+ * M-01: llms.txt exists and has the 5 required sections.
+ */
+function collectM01(projectPath: string): MetricResult {
+  const llmsTxtPath = path.join(projectPath, 'llms.txt');
+
+  if (!fs.existsSync(llmsTxtPath)) {
+    return {
+      id: 'M-01',
+      pass: false,
+      description: 'llms.txt exists and has 5 required sections',
+      details: `llms.txt not found at ${llmsTxtPath}`,
+    };
+  }
+
+  let content: string;
+  try {
+    content = fs.readFileSync(llmsTxtPath, 'utf-8');
+  } catch (err) {
+    return {
+      id: 'M-01',
+      pass: false,
+      description: 'llms.txt exists and has 5 required sections',
+      details: `Failed to read llms.txt: ${(err as Error).message}`,
+    };
+  }
+
+  const missingSections = REQUIRED_LLMS_SECTIONS.filter(
+    (section) => !content.includes(section)
+  );
+
+  if (missingSections.length > 0) {
+    return {
+      id: 'M-01',
+      pass: false,
+      description: 'llms.txt exists and has 5 required sections',
+      details: `Missing required sections: ${missingSections.join(', ')}`,
+    };
+  }
+
+  return {
+    id: 'M-01',
+    pass: true,
+    description: 'llms.txt exists and has 5 required sections',
+    details: 'All 5 required sections present in llms.txt',
+  };
+}
+
+/**
+ * M-02: openapi.json or public/openapi.json exists.
+ */
+function collectM02(projectPath: string): MetricResult {
+  const candidates = [
+    path.join(projectPath, 'openapi.json'),
+    path.join(projectPath, 'public', 'openapi.json'),
+    path.join(projectPath, 'static', 'openapi.json'),
+    path.join(projectPath, 'docs', 'openapi.json'),
+    path.join(projectPath, 'api', 'openapi.json'),
+    path.join(projectPath, 'openapi.yaml'),
+    path.join(projectPath, 'openapi.yml'),
+    path.join(projectPath, 'public', 'openapi.yaml'),
+  ];
+
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return {
+        id: 'M-02',
+        pass: true,
+        description: 'OpenAPI specification exists (openapi.json or public/openapi.json)',
+        details: `Found at ${path.relative(projectPath, candidate)}`,
+      };
+    }
+  }
+
+  return {
+    id: 'M-02',
+    pass: false,
+    description: 'OpenAPI specification exists (openapi.json or public/openapi.json)',
+    details:
+      'No openapi.json or openapi.yaml found in project root, public/, static/, docs/, or api/ directories.',
+  };
+}
+
+/**
+ * M-03: CLI supports --json flag.
+ * Greps for --json in bin/, cli.ts, cli.js, dare.ts.
+ */
+function collectM03(projectPath: string): MetricResult {
+  const JSON_FLAG_PATTERN = /--json/;
+
+  // Priority CLI files to check
+  const cliFileCandidates = [
+    path.join(projectPath, 'cli.ts'),
+    path.join(projectPath, 'cli.js'),
+    path.join(projectPath, 'dare.ts'),
+    path.join(projectPath, 'dare.js'),
+  ];
+
+  for (const candidate of cliFileCandidates) {
+    if (fs.existsSync(candidate) && fileMatchesPattern(candidate, JSON_FLAG_PATTERN)) {
+      return {
+        id: 'M-03',
+        pass: true,
+        description: 'CLI supports --json flag',
+        details: `Found --json flag in ${path.relative(projectPath, candidate)}`,
+      };
+    }
+  }
+
+  // Search in bin/ directory
+  const binDir = path.join(projectPath, 'bin');
+  if (fs.existsSync(binDir)) {
+    const found = searchDirForPattern(binDir, JSON_FLAG_PATTERN, SOURCE_EXTENSIONS, 3);
+    if (found) {
+      return {
+        id: 'M-03',
+        pass: true,
+        description: 'CLI supports --json flag',
+        details: `Found --json flag in ${path.relative(projectPath, found)}`,
+      };
+    }
+  }
+
+  // Search in src/ and lib/ directories
+  for (const dir of ['src', 'lib', 'app', 'cmd', 'cli']) {
+    const fullDir = path.join(projectPath, dir);
+    if (!fs.existsSync(fullDir)) continue;
+    const found = searchDirForPattern(fullDir, JSON_FLAG_PATTERN, SOURCE_EXTENSIONS, 3);
+    if (found) {
+      return {
+        id: 'M-03',
+        pass: true,
+        description: 'CLI supports --json flag',
+        details: `Found --json flag in ${path.relative(projectPath, found)}`,
+      };
+    }
+  }
+
+  return {
+    id: 'M-03',
+    pass: false,
+    description: 'CLI supports --json flag',
+    details:
+      'No --json flag detected in CLI source files (bin/, cli.ts, cli.js, dare.ts). Add --json output flag to CLI commands.',
+  };
+}
+
+/**
+ * M-04: Rate limit configuration detected.
+ * Greps for known rate limit patterns in package manifests and source files.
+ */
+function collectM04(projectPath: string): MetricResult {
+  // Check package manifests first
+  const manifests = [
+    path.join(projectPath, 'package.json'),
+    path.join(projectPath, 'Gemfile'),
+    path.join(projectPath, 'Cargo.toml'),
+    path.join(projectPath, 'go.mod'),
+    path.join(projectPath, 'requirements.txt'),
+    path.join(projectPath, 'pyproject.toml'),
+    path.join(projectPath, 'composer.json'),
+  ];
+
+  for (const manifest of manifests) {
+    if (!fs.existsSync(manifest)) continue;
+    try {
+      const content = fs.readFileSync(manifest, 'utf-8');
+      for (const pattern of RATE_LIMIT_PATTERNS) {
+        if (pattern.test(content)) {
+          const matchedLib = content.match(pattern)?.[0] ?? 'rate-limit';
+          return {
+            id: 'M-04',
+            pass: true,
+            description: 'Rate limit configuration detected',
+            details: `Found rate limit pattern "${matchedLib}" in ${path.relative(projectPath, manifest)}`,
+          };
+        }
+      }
+    } catch {
+      // Skip unreadable files
+    }
+  }
+
+  // Search source directories
+  for (const dir of ['src', 'lib', 'app', 'config']) {
+    const fullDir = path.join(projectPath, dir);
+    if (!fs.existsSync(fullDir)) continue;
+
+    for (const pattern of RATE_LIMIT_PATTERNS) {
+      const found = searchDirForPattern(fullDir, pattern, SOURCE_EXTENSIONS, 4);
+      if (found) {
+        return {
+          id: 'M-04',
+          pass: true,
+          description: 'Rate limit configuration detected',
+          details: `Found rate limit pattern in ${path.relative(projectPath, found)}`,
+        };
+      }
+    }
+  }
+
+  return {
+    id: 'M-04',
+    pass: false,
+    description: 'Rate limit configuration detected',
+    details:
+      'No rate limit library or middleware detected. Add rate limiting (rack-attack, express-rate-limit, tower-governor, etc.) to protect public endpoints.',
+  };
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function fileMatchesPattern(filePath: string, pattern: RegExp): boolean {
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    return pattern.test(content);
+  } catch {
+    return false;
+  }
+}
+
+function searchDirForPattern(
+  dir: string,
+  pattern: RegExp,
+  extensions: string[],
+  maxDepth: number,
+  depth = 0
+): string | null {
+  if (depth > maxDepth) return null;
+
+  let entries: fs.Dirent[];
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+
+  for (const entry of entries) {
+    if (entry.name.startsWith('.') || SKIP_DIRS.has(entry.name)) continue;
+
+    const fullPath = path.join(dir, entry.name);
+
+    if (entry.isDirectory()) {
+      const found = searchDirForPattern(fullPath, pattern, extensions, maxDepth, depth + 1);
+      if (found) return found;
+    } else if (entry.isFile()) {
+      const ext = path.extname(entry.name);
+      if (!extensions.includes(ext)) continue;
+      if (fileMatchesPattern(fullPath, pattern)) return fullPath;
+    }
+  }
+
+  return null;
+}

package/skills/dare-quality-telemetry/collectors/dare_layered_design_collector.ts

@@ -0,0 +1,406 @@
+/**
+ * dare-quality-telemetry — DareLayeredDesign collector
+ * Collects M-01 to M-04 metrics for a project that should comply with dare-layered-design.
+ * License: MIT
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { MetricResult } from '../types.js';
+
+/** Source file extensions */
+const SOURCE_EXTENSIONS = ['.ts', '.js', '.rb', '.rs', '.py', '.go', '.php'];
+
+/** Test file extensions (same as source but for test detection) */
+const TEST_PATTERNS = ['.spec.ts', '.spec.js', '.test.ts', '.test.js', '_spec.rb', '_spec.ts', '_test.ts', '_test.js'];
+
+const SKIP_DIRS = new Set(['node_modules', 'target', 'dist', '.git', 'vendor', '__pycache__', 'coverage']);
+
+/** DI violation patterns: direct service instantiation inside handlers */
+const DI_VIOLATION_PATTERNS: RegExp[] = [
+  /new\s+\w+Service\s*\(/,
+  /new\s+\w+UseCase\s*\(/,
+  /new\s+Create\w+\s*\(/,
+  /new\s+Update\w+\s*\(/,
+  /new\s+Delete\w+\s*\(/,
+  /\w+Service\.new\b/,       // Ruby
+  /\w+UseCase\.new\b/,       // Ruby
+];
+
+/** DI positive patterns: proper injection mechanisms */
+const DI_POSITIVE_PATTERNS: RegExp[] = [
+  /@Inject\s*\(/,
+  /constructor\s*\(\s*private/,
+  /Extension\s*\(/,
+  /@Injectable/,
+  /@Controller/,
+  /inject\s*\(/i,
+];
+
+/** HTTP concern patterns inside repositories */
+const HTTP_IN_REPO_PATTERNS: RegExp[] = [
+  /status\s*[:=]\s*[45]\d\d/,
+  /http_status|httpStatus|HttpStatus/i,
+  /res\.status\s*\(/,
+  /NotFoundException.*\(\s*[45]\d\d/,
+  /render\s+json.*status:/i,
+  /Response\.\w+\(\s*[45]\d\d/,
+  /throw new HttpException/i,
+  /import.*express/,
+  /import.*fastapi/,
+  /require.*axum/,
+  /rails.*controller/i,
+];
+
+/** Handler→Repository direct call patterns */
+const HANDLER_TO_REPO_PATTERNS: RegExp[] = [
+  /import.*[Rr]epository/,
+  /require.*[Rr]epository/,
+  /\w+Repository\s*\(/,
+  /\w+Repo\s*\./,
+  /\w+repository\s*\./i,
+];
+
+export function collectDareLayeredDesign(projectPath: string): Promise<MetricResult[]> {
+  return Promise.resolve([
+    collectM01(projectPath),
+    collectM02(projectPath),
+    collectM03(projectPath),
+    collectM04(projectPath),
+  ]);
+}
+
+/**
+ * M-01: services/ directory has at least one test file (*.spec.* or *.test.*).
+ */
+function collectM01(projectPath: string): MetricResult {
+  const serviceDirs = findLayerDirs(projectPath, ['services', 'use_cases', 'interactors', 'commands']);
+
+  if (serviceDirs.length === 0) {
+    return {
+      id: 'M-01',
+      pass: false,
+      description: '100% of Services have unit tests',
+      details: 'No services/ directory found in project. Create services layer first.',
+    };
+  }
+
+  // Find all service files (non-test)
+  const serviceFiles: string[] = [];
+  for (const dir of serviceDirs) {
+    collectFilesRecursive(dir, SOURCE_EXTENSIONS, 4).forEach((f) => {
+      if (!isTestFile(f)) serviceFiles.push(f);
+    });
+  }
+
+  if (serviceFiles.length === 0) {
+    return {
+      id: 'M-01',
+      pass: false,
+      description: '100% of Services have unit tests',
+      details: 'services/ directory exists but contains no service files.',
+    };
+  }
+
+  // Check if there are test files somewhere in the project
+  const testRoots = [
+    path.join(projectPath, 'tests'),
+    path.join(projectPath, 'test'),
+    path.join(projectPath, 'spec'),
+    path.join(projectPath, '__tests__'),
+    path.join(projectPath, 'src', '__tests__'),
+    ...serviceDirs, // co-located tests
+  ];
+
+  let testFilesFound = 0;
+  for (const root of testRoots) {
+    if (!fs.existsSync(root)) continue;
+    const files = collectFilesRecursive(root, SOURCE_EXTENSIONS, 5);
+    testFilesFound += files.filter(isTestFile).length;
+  }
+
+  if (testFilesFound === 0) {
+    return {
+      id: 'M-01',
+      pass: false,
+      description: '100% of Services have unit tests',
+      details: `Found ${serviceFiles.length} service file(s) but no test files (*.spec.* or *.test.*) in the project.`,
+    };
+  }
+
+  return {
+    id: 'M-01',
+    pass: true,
+    description: '100% of Services have unit tests',
+    details: `Found ${testFilesFound} test file(s) covering ${serviceFiles.length} service file(s).`,
+  };
+}
+
+/**
+ * M-02: 0% Handler→Repository direct calls.
+ * Scans handler files for direct repository imports/usage.
+ */
+function collectM02(projectPath: string): MetricResult {
+  const handlerDirs = findLayerDirs(projectPath, ['handlers', 'controllers', 'routers', 'routes']);
+
+  if (handlerDirs.length === 0) {
+    return {
+      id: 'M-02',
+      pass: true,
+      description: '0% Handler→Repository direct calls',
+      details: 'No handler/controller directories found.',
+    };
+  }
+
+  const violations: Array<{ file: string; line: number; content: string }> = [];
+
+  for (const dir of handlerDirs) {
+    const files = collectFilesRecursive(dir, SOURCE_EXTENSIONS, 4);
+    for (const file of files) {
+      if (isTestFile(file)) continue;
+      findPatternViolations(file, HANDLER_TO_REPO_PATTERNS, violations);
+    }
+  }
+
+  if (violations.length > 0) {
+    const summary = violations
+      .slice(0, 3)
+      .map((v) => `${path.relative(projectPath, v.file)}:${v.line}`)
+      .join(', ');
+    return {
+      id: 'M-02',
+      pass: false,
+      description: '0% Handler→Repository direct calls',
+      details: `Found ${violations.length} Handler→Repository violation(s). First: ${summary}. Handlers must call Services, not Repositories directly.`,
+    };
+  }
+
+  const totalFiles = handlerDirs.reduce(
+    (sum, d) => sum + collectFilesRecursive(d, SOURCE_EXTENSIONS, 4).filter((f) => !isTestFile(f)).length,
+    0
+  );
+
+  return {
+    id: 'M-02',
+    pass: true,
+    description: '0% Handler→Repository direct calls',
+    details: `No Handler→Repository violations found across ${totalFiles} handler file(s).`,
+  };
+}
+
+/**
+ * M-03: 100% of Handlers use dependency injection.
+ * Checks for DI patterns (@Inject, constructor(private), Extension()).
+ */
+function collectM03(projectPath: string): MetricResult {
+  const handlerDirs = findLayerDirs(projectPath, ['handlers', 'controllers', 'routers', 'routes']);
+
+  if (handlerDirs.length === 0) {
+    return {
+      id: 'M-03',
+      pass: true,
+      description: '100% of Handlers use dependency injection',
+      details: 'No handler/controller directories found.',
+    };
+  }
+
+  const allHandlerFiles: string[] = [];
+  for (const dir of handlerDirs) {
+    collectFilesRecursive(dir, SOURCE_EXTENSIONS, 4).forEach((f) => {
+      if (!isTestFile(f)) allHandlerFiles.push(f);
+    });
+  }
+
+  if (allHandlerFiles.length === 0) {
+    return {
+      id: 'M-03',
+      pass: true,
+      description: '100% of Handlers use dependency injection',
+      details: 'No handler files to scan.',
+    };
+  }
+
+  // Check for DI violations (direct instantiation)
+  const diViolations: Array<{ file: string; line: number; content: string }> = [];
+  for (const file of allHandlerFiles) {
+    findPatternViolations(file, DI_VIOLATION_PATTERNS, diViolations);
+  }
+
+  if (diViolations.length > 0) {
+    const summary = diViolations
+      .slice(0, 3)
+      .map((v) => `${path.relative(projectPath, v.file)}:${v.line}`)
+      .join(', ');
+    return {
+      id: 'M-03',
+      pass: false,
+      description: '100% of Handlers use dependency injection',
+      details: `Found ${diViolations.length} handler(s) that instantiate services directly. Violations: ${summary}. Use @Inject, constructor(private ...) or Extension() instead.`,
+    };
+  }
+
+  // Check that at least some DI patterns exist
+  let diPatternsFound = 0;
+  for (const file of allHandlerFiles) {
+    try {
+      const content = fs.readFileSync(file, 'utf-8');
+      if (DI_POSITIVE_PATTERNS.some((p) => p.test(content))) {
+        diPatternsFound++;
+      }
+    } catch {
+      // skip
+    }
+  }
+
+  return {
+    id: 'M-03',
+    pass: true,
+    description: '100% of Handlers use dependency injection',
+    details: `No direct instantiation found in ${allHandlerFiles.length} handler file(s). ${diPatternsFound} file(s) use DI patterns.`,
+  };
+}
+
+/**
+ * M-04: 100% of Repositories are agnostic to upper layers.
+ * Checks that repositories don't import HTTP modules (express, fastapi, axum, rails).
+ */
+function collectM04(projectPath: string): MetricResult {
+  const repoDirs = findLayerDirs(projectPath, ['repositories', 'repos', 'data_access', 'stores']);
+
+  if (repoDirs.length === 0) {
+    return {
+      id: 'M-04',
+      pass: true,
+      description: '100% of Repositories are agnostic to upper layers (no HTTP imports)',
+      details: 'No repository directories found.',
+    };
+  }
+
+  const violations: Array<{ file: string; line: number; content: string }> = [];
+
+  for (const dir of repoDirs) {
+    const files = collectFilesRecursive(dir, SOURCE_EXTENSIONS, 4);
+    for (const file of files) {
+      if (isTestFile(file)) continue;
+      findPatternViolations(file, HTTP_IN_REPO_PATTERNS, violations);
+    }
+  }
+
+  if (violations.length > 0) {
+    const summary = violations
+      .slice(0, 3)
+      .map((v) => `${path.relative(projectPath, v.file)}:${v.line} — "${v.content.slice(0, 60)}"`)
+      .join('; ');
+    return {
+      id: 'M-04',
+      pass: false,
+      description: '100% of Repositories are agnostic to upper layers (no HTTP imports)',
+      details: `Found ${violations.length} HTTP concern(s) in repository files. Repositories must not import express, fastapi, axum, or return HTTP status codes. Violations: ${summary}`,
+    };
+  }
+
+  const totalFiles = repoDirs.reduce(
+    (sum, d) => sum + collectFilesRecursive(d, SOURCE_EXTENSIONS, 4).filter((f) => !isTestFile(f)).length,
+    0
+  );
+
+  return {
+    id: 'M-04',
+    pass: true,
+    description: '100% of Repositories are agnostic to upper layers (no HTTP imports)',
+    details: `No HTTP concerns found in ${totalFiles} repository file(s).`,
+  };
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function findLayerDirs(projectPath: string, layerNames: string[]): string[] {
+  const results: string[] = [];
+  const searchRoots = [
+    projectPath,
+    ...['src', 'app', 'lib'].map((r) => path.join(projectPath, r)),
+  ];
+
+  for (const root of searchRoots) {
+    if (!fs.existsSync(root)) continue;
+    for (const name of layerNames) {
+      const candidate = path.join(root, name);
+      if (fs.existsSync(candidate)) results.push(candidate);
+    }
+  }
+
+  return results;
+}
+
+function collectFilesRecursive(
+  dir: string,
+  extensions: string[],
+  maxDepth: number,
+  depth = 0
+): string[] {
+  if (depth > maxDepth) return [];
+
+  let entries: fs.Dirent[];
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+
+  const results: string[] = [];
+  for (const entry of entries) {
+    if (entry.name.startsWith('.') || SKIP_DIRS.has(entry.name)) continue;
+    const fp = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...collectFilesRecursive(fp, extensions, maxDepth, depth + 1));
+    } else if (entry.isFile()) {
+      const ext = path.extname(entry.name);
+      if (extensions.includes(ext)) results.push(fp);
+    }
+  }
+  return results;
+}
+
+function isTestFile(file: string): boolean {
+  return (
+    /\.(spec|test)\.[a-z]+$/.test(file) ||
+    /_spec\.[a-z]+$/.test(file) ||
+    /_test\.[a-z]+$/.test(file) ||
+    TEST_PATTERNS.some((p) => file.endsWith(p))
+  );
+}
+
+function findPatternViolations(
+  file: string,
+  patterns: RegExp[],
+  out: Array<{ file: string; line: number; content: string }>
+): void {
+  let content: string;
+  try {
+    content = fs.readFileSync(file, 'utf-8');
+  } catch {
+    return;
+  }
+
+  const lines = content.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    // Skip comments
+    if (
+      trimmed.startsWith('//') ||
+      trimmed.startsWith('#') ||
+      trimmed.startsWith('*') ||
+      trimmed.startsWith('/*')
+    ) {
+      continue;
+    }
+
+    for (const pattern of patterns) {
+      if (pattern.test(line)) {
+        out.push({ file, line: i + 1, content: trimmed });
+        break;
+      }
+    }
+  }
+}