@dewtech/dare-cli 3.10.0 → 3.12.0

package/skills/dare-quality-telemetry/tsconfig.json

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

package/skills/dare-quality-telemetry/types.ts

@@ -0,0 +1,41 @@
+/**
+ * dare-quality-telemetry — shared types
+ * License: MIT
+ */
+
+export interface MetricResult {
+  id: string;          // "M-01"
+  pass: boolean;
+  description: string;
+  details: string;
+}
+
+export interface SkillMetricReport {
+  skillName: string;
+  timestamp: string;   // ISO 8601
+  commit: string;      // git SHA or "unknown"
+  metrics: MetricResult[];
+  summary: { passed: number; total: number; score: string; allPass: boolean };
+}
+
+export interface ProjectMetricReport {
+  timestamp: string;
+  commit: string;
+  projectPath: string;
+  skills: SkillMetricReport[];
+  overall: { passed: number; total: number; score: string; allPass: boolean };
+}
+
+export interface CollectorConfig {
+  projectPath: string;
+  skills: string[];    // which skills to validate
+  baselineFile?: string; // path to previous baseline (regression detection)
+}
+
+export interface RegressionResult {
+  skill: string;
+  metricId: string;
+  baseline: boolean;
+  current: boolean;
+  regressed: boolean;
+}

package/skills/dare-realtime/event_registry.ts

@@ -0,0 +1,101 @@
+/**
+ * dare-realtime — EventRegistry
+ * Central registry for real-time event types and their schemas.
+ * License: MIT
+ */
+
+import type { EventSchema, RegisteredEvent, ValidationResult } from './types.js';
+import { SchemaValidator } from './schema_validator.js';
+
+export class EventRegistry {
+  private readonly events: Map<string, RegisteredEvent> = new Map();
+  private readonly validator: SchemaValidator = new SchemaValidator();
+
+  /**
+   * Register an event type with its schema.
+   * Throws if the event type is already registered.
+   */
+  register(type: string, schema: EventSchema): void {
+    if (this.events.has(type)) {
+      throw new Error(`EventRegistry: event type "${type}" is already registered`);
+    }
+    this.events.set(type, {
+      type,
+      schema,
+      registeredAt: Date.now(),
+    });
+  }
+
+  /**
+   * Register or overwrite an event type.
+   */
+  registerOrUpdate(type: string, schema: EventSchema): void {
+    this.events.set(type, {
+      type,
+      schema,
+      registeredAt: Date.now(),
+    });
+  }
+
+  /**
+   * Validate a payload against the schema for a given event type.
+   * Returns an error if the event type is not registered.
+   */
+  validate(type: string, payload: unknown): ValidationResult {
+    const event = this.events.get(type);
+    if (!event) {
+      return {
+        ok: false,
+        errors: [
+          {
+            field: '$type',
+            message: `Unknown event type: "${type}". Register it first with registry.register().`,
+          },
+        ],
+      };
+    }
+    return this.validator.validate(payload, event.schema);
+  }
+
+  /**
+   * Get the schema for an event type, or null if not registered.
+   */
+  getSchema(type: string): EventSchema | null {
+    return this.events.get(type)?.schema ?? null;
+  }
+
+  /**
+   * Check if an event type is registered.
+   */
+  has(type: string): boolean {
+    return this.events.has(type);
+  }
+
+  /**
+   * List all registered event types.
+   */
+  listTypes(): string[] {
+    return Array.from(this.events.keys());
+  }
+
+  /**
+   * Number of registered event types.
+   */
+  get size(): number {
+    return this.events.size;
+  }
+
+  /**
+   * Remove an event type from the registry.
+   */
+  unregister(type: string): boolean {
+    return this.events.delete(type);
+  }
+
+  /**
+   * Clear all registered events.
+   */
+  clear(): void {
+    this.events.clear();
+  }
+}

package/skills/dare-realtime/index.ts

@@ -0,0 +1,30 @@
+/**
+ * dare-realtime — public API
+ * License: MIT
+ */
+
+// Types
+export type {
+  ValidationResult,
+  ValidationError,
+  EventSchema,
+  RegisteredEvent,
+  RealtimeMetricsInput,
+  MetricResult,
+} from './types.js';
+
+// Schema validator
+export { SchemaValidator } from './schema_validator.js';
+
+// Event registry
+export { EventRegistry } from './event_registry.js';
+
+// Reconnect strategy
+export { ReconnectStrategy } from './reconnect_strategy.js';
+export type { ReconnectStrategyConfig } from './reconnect_strategy.js';
+
+// Subscription manager
+export { SubscriptionManager } from './subscription_manager.js';
+
+// Metrics
+export { collectRealtimeMetrics } from './metrics.js';

package/skills/dare-realtime/metrics.ts

@@ -0,0 +1,84 @@
+/**
+ * dare-realtime — Metrics collector
+ * Evaluates M-01 to M-04 for the dare-realtime skill.
+ * License: MIT
+ */
+
+import type { MetricResult, RealtimeMetricsInput } from './types.js';
+
+export function collectRealtimeMetrics(input: RealtimeMetricsInput): MetricResult[] {
+  return [
+    checkM01(input),
+    checkM02(input),
+    checkM03(input),
+    checkM04(input),
+  ];
+}
+
+/**
+ * M-01: 100% of event types have JSON Schema defined.
+ */
+function checkM01(input: RealtimeMetricsInput): MetricResult {
+  const pass = input.totalEventTypes === 0 || input.eventTypesWithSchema === input.totalEventTypes;
+
+  return {
+    id: 'M-01',
+    pass,
+    description: '100% of event types have JSON Schema defined',
+    detail: input.totalEventTypes === 0
+      ? 'No event types registered'
+      : pass
+        ? `All ${input.totalEventTypes} event type(s) have schemas`
+        : `${input.totalEventTypes - input.eventTypesWithSchema} event type(s) missing schema`,
+  };
+}
+
+/**
+ * M-02: 100% of subscriptions are authorized.
+ */
+function checkM02(input: RealtimeMetricsInput): MetricResult {
+  const pass = input.totalSubscriptions === 0 || input.authorizedSubscriptions === input.totalSubscriptions;
+
+  return {
+    id: 'M-02',
+    pass,
+    description: '100% of subscriptions are authorized',
+    detail: input.totalSubscriptions === 0
+      ? 'No subscriptions recorded'
+      : pass
+        ? `All ${input.totalSubscriptions} subscription(s) are authorized`
+        : `${input.totalSubscriptions - input.authorizedSubscriptions} subscription(s) lack authorization check`,
+  };
+}
+
+/**
+ * M-03: 0% ghost listeners.
+ */
+function checkM03(input: RealtimeMetricsInput): MetricResult {
+  const pass = input.ghostListenerCount === 0;
+
+  return {
+    id: 'M-03',
+    pass,
+    description: '0 ghost listeners after disconnect (no memory leaks)',
+    detail: pass
+      ? 'No ghost listeners detected'
+      : `${input.ghostListenerCount} ghost listener(s) detected — call unsubscribeAll() on disconnect`,
+  };
+}
+
+/**
+ * M-04: Reconnection strategy configured.
+ */
+function checkM04(input: RealtimeMetricsInput): MetricResult {
+  const pass = input.reconnectConfigured;
+
+  return {
+    id: 'M-04',
+    pass,
+    description: 'Reconnection strategy configured (exponential backoff)',
+    detail: pass
+      ? 'Reconnect strategy is configured'
+      : 'No reconnect strategy configured — use ReconnectStrategy for exponential backoff',
+  };
+}