@dewtech/dare-cli 3.11.0 → 3.12.0

package/skills/dare-layered-design/tests/metrics.spec.ts

@@ -0,0 +1,286 @@
+/**
+ * dare-layered-design — metrics tests (M-01 to M-04)
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { LayeredDesignMetrics } from '../metrics.js';
+
+describe('LayeredDesignMetrics', () => {
+  let tmpDir: string;
+  let metrics: LayeredDesignMetrics;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'dare-ld-metrics-test-'));
+    metrics = new LayeredDesignMetrics();
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  // ── M-01 ──────────────────────────────────────────────────────────────
+
+  describe('M-01: Services have unit tests', () => {
+    it('passes when every service has a spec file', () => {
+      const servicesDir = path.join(tmpDir, 'src', 'services');
+      const testsDir = path.join(tmpDir, 'tests');
+      fs.mkdirSync(servicesDir, { recursive: true });
+      fs.mkdirSync(testsDir, { recursive: true });
+
+      fs.writeFileSync(path.join(servicesDir, 'create_user_service.ts'), 'export class CreateUserService {}', 'utf-8');
+      fs.writeFileSync(path.join(testsDir, 'create_user_service.spec.ts'), 'describe("CreateUserService", () => {});', 'utf-8');
+
+      const result = metrics.collectM01(tmpDir);
+
+      expect(result.id).toBe('M-01');
+      expect(result.pass).toBe(true);
+    });
+
+    it('fails when a service has no test file', () => {
+      const servicesDir = path.join(tmpDir, 'src', 'services');
+      fs.mkdirSync(servicesDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(servicesDir, 'create_order_service.ts'),
+        'export class CreateOrderService {}',
+        'utf-8'
+      );
+
+      const result = metrics.collectM01(tmpDir);
+
+      expect(result.pass).toBe(false);
+      expect(result.detail).toContain('create_order_service');
+    });
+
+    it('fails when no services directory exists', () => {
+      const result = metrics.collectM01(tmpDir);
+
+      expect(result.pass).toBe(false);
+      expect(result.detail).toContain('No service files found');
+    });
+
+    it('passes with co-located test file', () => {
+      const servicesDir = path.join(tmpDir, 'src', 'services');
+      fs.mkdirSync(servicesDir, { recursive: true });
+
+      fs.writeFileSync(
+        path.join(servicesDir, 'send_email_service.ts'),
+        'export class SendEmailService {}',
+        'utf-8'
+      );
+      // Co-located spec
+      fs.writeFileSync(
+        path.join(servicesDir, 'send_email_service.spec.ts'),
+        'describe("SendEmailService", () => {});',
+        'utf-8'
+      );
+
+      const result = metrics.collectM01(tmpDir);
+      expect(result.pass).toBe(true);
+    });
+  });
+
+  // ── M-02 ──────────────────────────────────────────────────────────────
+
+  describe('M-02: 0% Handler→Repository calls', () => {
+    it('passes when no handler files exist', () => {
+      const result = metrics.collectM02(tmpDir);
+
+      expect(result.id).toBe('M-02');
+      expect(result.pass).toBe(true);
+    });
+
+    it('passes when handlers only import services', () => {
+      const handlersDir = path.join(tmpDir, 'src', 'handlers');
+      fs.mkdirSync(handlersDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(handlersDir, 'user_handler.ts'),
+        `import { CreateUserService } from '../services/create_user_service';
+export class UserHandler {
+  constructor(private service: CreateUserService) {}
+  async create(req: any, res: any) {
+    const user = await this.service.execute(req.body);
+    res.json(user);
+  }
+}
+`,
+        'utf-8'
+      );
+      fs.writeFileSync(path.join(tmpDir, 'tsconfig.json'), '{}', 'utf-8');
+
+      const result = metrics.collectM02(tmpDir);
+      expect(result.pass).toBe(true);
+    });
+
+    it('fails when handler imports Repository', () => {
+      const handlersDir = path.join(tmpDir, 'src', 'handlers');
+      fs.mkdirSync(handlersDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(handlersDir, 'user_handler.ts'),
+        `import { UserRepository } from '../repositories/user_repository';
+export class UserHandler {
+  async get(req: any, res: any) {
+    const repo = new UserRepository();
+    res.json(await repo.findById(req.params.id));
+  }
+}
+`,
+        'utf-8'
+      );
+      fs.writeFileSync(path.join(tmpDir, 'tsconfig.json'), '{}', 'utf-8');
+
+      const result = metrics.collectM02(tmpDir);
+      expect(result.pass).toBe(false);
+      expect(result.detail).toContain('violation');
+    });
+  });
+
+  // ── M-03 ──────────────────────────────────────────────────────────────
+
+  describe('M-03: Handlers use dependency injection', () => {
+    it('passes when no handlers exist', () => {
+      const result = metrics.collectM03(tmpDir);
+
+      expect(result.id).toBe('M-03');
+      expect(result.pass).toBe(true);
+    });
+
+    it('passes when handler receives service via constructor', () => {
+      const handlersDir = path.join(tmpDir, 'src', 'handlers');
+      fs.mkdirSync(handlersDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(handlersDir, 'order_handler.ts'),
+        `export class OrderHandler {
+  constructor(private readonly createOrderService: CreateOrderService) {}
+  async create(req: any, res: any) {
+    const order = await this.createOrderService.execute(req.body);
+    res.json(order);
+  }
+}
+`,
+        'utf-8'
+      );
+
+      const result = metrics.collectM03(tmpDir);
+      expect(result.pass).toBe(true);
+    });
+
+    it('fails when handler instantiates service with new', () => {
+      const handlersDir = path.join(tmpDir, 'src', 'handlers');
+      fs.mkdirSync(handlersDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(handlersDir, 'product_handler.ts'),
+        `export class ProductHandler {
+  async create(req: any, res: any) {
+    const service = new CreateProductService();  // VIOLATION
+    const product = await service.execute(req.body);
+    res.json(product);
+  }
+}
+`,
+        'utf-8'
+      );
+
+      const result = metrics.collectM03(tmpDir);
+      expect(result.pass).toBe(false);
+      expect(result.detail).toContain('new');
+    });
+  });
+
+  // ── M-04 ──────────────────────────────────────────────────────────────
+
+  describe('M-04: Repositories agnostic to upper layers', () => {
+    it('passes when no repository directories exist', () => {
+      const result = metrics.collectM04(tmpDir);
+
+      expect(result.id).toBe('M-04');
+      expect(result.pass).toBe(true);
+    });
+
+    it('passes when repository has no HTTP concerns', () => {
+      const reposDir = path.join(tmpDir, 'src', 'repositories');
+      fs.mkdirSync(reposDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(reposDir, 'user_repository.ts'),
+        `export class UserRepository {
+  async findById(id: string) {
+    return this.db.query('SELECT * FROM users WHERE id = $1', [id]);
+  }
+  async save(user: any) {
+    return this.db.query('INSERT INTO users ...', [user.id, user.email]);
+  }
+}
+`,
+        'utf-8'
+      );
+
+      const result = metrics.collectM04(tmpDir);
+      expect(result.pass).toBe(true);
+    });
+
+    it('fails when repository returns HTTP status code', () => {
+      const reposDir = path.join(tmpDir, 'src', 'repositories');
+      fs.mkdirSync(reposDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(reposDir, 'order_repository.ts'),
+        `export class OrderRepository {
+  async findById(id: string) {
+    const order = await this.db.query('SELECT * FROM orders WHERE id = $1', [id]);
+    if (!order) {
+      return { status: 404, error: 'Not found' };  // VIOLATION — repo should not know about HTTP
+    }
+    return order;
+  }
+}
+`,
+        'utf-8'
+      );
+
+      const result = metrics.collectM04(tmpDir);
+      expect(result.pass).toBe(false);
+      expect(result.detail).toContain('HTTP');
+    });
+
+    it('fails when repository throws NestJS HttpException', () => {
+      const reposDir = path.join(tmpDir, 'src', 'repositories');
+      fs.mkdirSync(reposDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(reposDir, 'user_repository.ts'),
+        `import { HttpException } from '@nestjs/common';
+export class UserRepository {
+  async findById(id: string) {
+    const user = await this.db.find(id);
+    if (!user) throw new HttpException('Not found', 404);  // VIOLATION
+    return user;
+  }
+}
+`,
+        'utf-8'
+      );
+
+      const result = metrics.collectM04(tmpDir);
+      expect(result.pass).toBe(false);
+    });
+  });
+
+  // ── collect() ─────────────────────────────────────────────────────────
+
+  describe('collect()', () => {
+    it('returns 4 metric results', () => {
+      const results = metrics.collect(tmpDir);
+      expect(results).toHaveLength(4);
+      expect(results.map((r) => r.id)).toEqual(['M-01', 'M-02', 'M-03', 'M-04']);
+    });
+
+    it('M-02, M-03, M-04 pass for empty project (no files to scan)', () => {
+      const results = metrics.collect(tmpDir);
+
+      // M-01 fails (no services), M-02/M-03/M-04 pass (nothing to scan)
+      expect(results.find((r) => r.id === 'M-02')!.pass).toBe(true);
+      expect(results.find((r) => r.id === 'M-03')!.pass).toBe(true);
+      expect(results.find((r) => r.id === 'M-04')!.pass).toBe(true);
+    });
+  });
+});

package/skills/dare-layered-design/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "extends": "../../../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": ".",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": [
+    "*.ts",
+    "tests/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}

package/skills/dare-layered-design/types.ts

@@ -0,0 +1,48 @@
+/**
+ * dare-layered-design — shared types
+ * License: MIT
+ */
+
+export type Language = 'typescript' | 'javascript' | 'ruby' | 'rust' | 'python' | 'go' | 'php' | 'unknown';
+
+export interface LinterViolation {
+  /** File where violation was found */
+  file: string;
+  /** 1-based line number */
+  line: number;
+  /** The violating line content */
+  content: string;
+  /** Violation rule ID */
+  rule: string;
+  /** Human-readable message */
+  message: string;
+}
+
+export interface LinterResult {
+  violations: LinterViolation[];
+  filesScanned: number;
+  pass: boolean;
+}
+
+export interface ScaffoldOptions {
+  /** Root source directory (default: 'src') */
+  srcDir?: string;
+  /** Language (affects file extensions and naming conventions) */
+  language?: Language;
+  /** Whether to create example files (default: false — only .gitkeep) */
+  withExamples?: boolean;
+  /** Entity name for example files (default: 'example') */
+  exampleEntity?: string;
+}
+
+export interface ScaffoldResult {
+  createdDirs: string[];
+  createdFiles: string[];
+}
+
+export interface MetricResult {
+  id: string;
+  pass: boolean;
+  description: string;
+  detail?: string;
+}

package/skills/dare-llm-integration/cache/llm_cache.ts

@@ -0,0 +1,122 @@
+/**
+ * dare-llm-integration — LLMCache
+ * In-memory cache with TTL per key.
+ * Key: hash(model + prompt)
+ * License: MIT
+ */
+
+import type { CacheEntry, CompletionResponse, EmbeddingResponse } from '../types.js';
+
+export class LLMCache {
+  private readonly store: Map<string, CacheEntry> = new Map();
+  private _hits = 0;
+  private _misses = 0;
+
+  /**
+   * Retrieve a cache entry. Returns null if missing or expired.
+   */
+  get(key: string): CacheEntry | null {
+    const entry = this.store.get(key);
+    if (!entry) {
+      this._misses++;
+      return null;
+    }
+
+    if (Date.now() > entry.expiresAt) {
+      this.store.delete(key);
+      this._misses++;
+      return null;
+    }
+
+    // Increment hit counter on the entry
+    entry.hits++;
+    this._hits++;
+    return entry;
+  }
+
+  /**
+   * Store a value with TTL in milliseconds.
+   */
+  set(key: string, value: CompletionResponse | EmbeddingResponse, ttlMs: number): void {
+    const now = Date.now();
+    this.store.set(key, {
+      value,
+      expiresAt: now + ttlMs,
+      createdAt: now,
+      hits: 0,
+    });
+  }
+
+  /**
+   * Remove a specific key.
+   */
+  invalidate(key: string): void {
+    this.store.delete(key);
+  }
+
+  /**
+   * Remove all entries.
+   */
+  clear(): void {
+    this.store.clear();
+    this._hits = 0;
+    this._misses = 0;
+  }
+
+  /**
+   * Number of entries currently stored (including potentially stale).
+   */
+  get size(): number {
+    return this.store.size;
+  }
+
+  /**
+   * Cache hit count since last clear().
+   */
+  get hits(): number {
+    return this._hits;
+  }
+
+  /**
+   * Cache miss count since last clear().
+   */
+  get misses(): number {
+    return this._misses;
+  }
+
+  /**
+   * Hit rate as a fraction (0–1). Returns 0 if no requests yet.
+   */
+  get hitRate(): number {
+    const total = this._hits + this._misses;
+    return total === 0 ? 0 : this._hits / total;
+  }
+
+  /**
+   * Remove all expired entries.
+   */
+  purgeExpired(): number {
+    const now = Date.now();
+    let purged = 0;
+    for (const [key, entry] of this.store.entries()) {
+      if (now > entry.expiresAt) {
+        this.store.delete(key);
+        purged++;
+      }
+    }
+    return purged;
+  }
+
+  /**
+   * Check if key exists and is not expired.
+   */
+  has(key: string): boolean {
+    const entry = this.store.get(key);
+    if (!entry) return false;
+    if (Date.now() > entry.expiresAt) {
+      this.store.delete(key);
+      return false;
+    }
+    return true;
+  }
+}

package/skills/dare-llm-integration/index.ts

@@ -0,0 +1,49 @@
+/**
+ * dare-llm-integration — public API
+ * License: MIT
+ */
+
+// Types
+export type {
+  CompletionRequest,
+  CompletionResponse,
+  EmbedRequest,
+  EmbeddingResponse,
+  LLMProvider,
+  PromptTemplate,
+  CacheEntry,
+  RateLimiterConfig,
+  OutputValidationResult,
+  OutputValidationError,
+  MetricResult,
+  LLMUsageStats,
+} from './types.js';
+
+// Providers
+export { OpenAIProvider } from './providers/openai_provider.js';
+export type { OpenAIProviderConfig } from './providers/openai_provider.js';
+
+export { AnthropicProvider } from './providers/anthropic_provider.js';
+export type { AnthropicProviderConfig } from './providers/anthropic_provider.js';
+
+export { DummyProvider } from './providers/dummy_provider.js';
+export type { DummyProviderConfig } from './providers/dummy_provider.js';
+
+// Cache
+export { LLMCache } from './cache/llm_cache.js';
+
+// Rate limit
+export { TokenBucket } from './rate_limit/token_bucket.js';
+export type { TokenBucketConfig } from './rate_limit/token_bucket.js';
+
+// Prompts
+export { PromptLoader } from './prompts/prompt_loader.js';
+export type { PromptLoaderConfig } from './prompts/prompt_loader.js';
+
+// Validators
+export { OutputValidator } from './validators/output_validator.js';
+export type { JsonSchema } from './validators/output_validator.js';
+
+// Metrics
+export { collectLLMIntegrationMetrics } from './metrics.js';
+export type { LLMIntegrationMetricsInput } from './metrics.js';

package/skills/dare-llm-integration/metrics.ts

@@ -0,0 +1,107 @@
+/**
+ * dare-llm-integration — Metrics collector
+ * Evaluates M-01 to M-04 for the dare-llm-integration skill.
+ * License: MIT
+ */
+
+import type { MetricResult } from './types.js';
+import type { LLMCache } from './cache/llm_cache.js';
+import type { TokenBucket } from './rate_limit/token_bucket.js';
+
+export interface LLMIntegrationMetricsInput {
+  /** M-01: total LLM calls made through LLMProvider */
+  totalCallsViaProvider: number;
+  /** M-01: total LLM calls made directly (bypassing LLMProvider) */
+  totalDirectCalls: number;
+  /** M-02: cache instance used (null = cache not configured) */
+  cache: LLMCache | null;
+  /** M-03: rate limiter instance used (null = not configured) */
+  rateLimiter: TokenBucket | null;
+  /** M-04: count of responses that went through output validation */
+  validatedResponseCount: number;
+  /** M-04: count of responses that did NOT go through output validation */
+  unvalidatedResponseCount: number;
+}
+
+export function collectLLMIntegrationMetrics(input: LLMIntegrationMetricsInput): MetricResult[] {
+  return [
+    checkM01(input),
+    checkM02(input),
+    checkM03(input),
+    checkM04(input),
+  ];
+}
+
+/**
+ * M-01: 100% of LLM calls come via LLMProvider injected (no direct SDK calls).
+ */
+function checkM01(input: LLMIntegrationMetricsInput): MetricResult {
+  const total = input.totalCallsViaProvider + input.totalDirectCalls;
+  const pass = total > 0
+    ? input.totalDirectCalls === 0
+    : true; // if no calls at all, trivially pass
+
+  return {
+    id: 'M-01',
+    pass,
+    description: '100% of LLM calls via LLMProvider (no direct SDK calls)',
+    detail: total === 0
+      ? 'No LLM calls recorded'
+      : pass
+        ? `${input.totalCallsViaProvider}/${total} calls via provider`
+        : `${input.totalDirectCalls} direct call(s) detected — use LLMProvider`,
+  };
+}
+
+/**
+ * M-02: Cache is configured and has at least one hit (or is set up for caching).
+ */
+function checkM02(input: LLMIntegrationMetricsInput): MetricResult {
+  const pass = input.cache !== null;
+
+  return {
+    id: 'M-02',
+    pass,
+    description: '100% of LLM responses are cached (cache configured)',
+    detail: pass
+      ? `Cache configured — hit rate: ${(input.cache!.hitRate * 100).toFixed(1)}% (${input.cache!.hits} hits / ${input.cache!.hits + input.cache!.misses} total)`
+      : 'No cache instance provided — configure LLMCache to reduce costs',
+  };
+}
+
+/**
+ * M-03: Rate limiter is configured.
+ */
+function checkM03(input: LLMIntegrationMetricsInput): MetricResult {
+  const pass = input.rateLimiter !== null;
+
+  return {
+    id: 'M-03',
+    pass,
+    description: '100% of LLM requests have rate limit configured',
+    detail: pass
+      ? `Rate limiter configured at ${input.rateLimiter!.requestsPerSecond} req/sec`
+      : 'No rate limiter provided — configure TokenBucket to prevent 429s',
+  };
+}
+
+/**
+ * M-04: 100% of LLM responses are validated against schema.
+ */
+function checkM04(input: LLMIntegrationMetricsInput): MetricResult {
+  const total = input.validatedResponseCount + input.unvalidatedResponseCount;
+  const pass = total > 0
+    ? input.unvalidatedResponseCount === 0
+    : true;
+
+  return {
+    id: 'M-04',
+    pass,
+    description: '100% of LLM responses validated against schema before use',
+    detail: total === 0
+      ? 'No responses recorded'
+      : pass
+        ? `All ${input.validatedResponseCount} response(s) validated`
+        : `${input.unvalidatedResponseCount} response(s) used without validation`,
+  };
+}