@monster-orange/den 0.0.0-stage → 0.1.0

package/src/shared/results/result-reader.ts

@@ -0,0 +1,266 @@
+/**
+ * Result Reader
+ * Reads and queries test results from JSONL files
+ */
+
+import { readFile, readdir } from "fs/promises";
+import { resolve, join } from "path";
+import type {
+  TestResult,
+  TestSummary,
+  FlakyTest,
+  TrendData,
+  Pillar,
+} from "../types/index.js";
+
+export interface QueryFilters {
+  pillar?: Pillar;
+  environment?: string;
+  dateFrom?: Date;
+  dateTo?: Date;
+  status?: "passed" | "failed" | "skipped";
+  user?: string;
+}
+
+export class ResultReader {
+  private resultsDir: string;
+
+  constructor(resultsDir: string = "./results") {
+    this.resultsDir = resolve(resultsDir);
+  }
+
+  /**
+   * Query results with filters
+   */
+  async query(filters: QueryFilters = {}): Promise<TestResult[]> {
+    const files = await this.getRelevantFiles(filters);
+    const results: TestResult[] = [];
+
+    for (const file of files) {
+      try {
+        const fileResults = await this.readJSONLFile(file);
+        const filtered = fileResults.filter((r) =>
+          this.matchesFilters(r, filters),
+        );
+        results.push(...filtered);
+      } catch (error) {
+        console.warn(
+          `Failed to read file ${file}: ${(error as Error).message}`,
+        );
+      }
+    }
+
+    // Sort by timestamp (newest first)
+    return results.sort(
+      (a, b) =>
+        new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime(),
+    );
+  }
+
+  /**
+   * Get summary statistics for a pillar/environment
+   */
+  async getSummary(
+    pillar: Pillar,
+    environment: string,
+    days: number = 7,
+  ): Promise<TestSummary> {
+    const dateFrom = new Date();
+    dateFrom.setDate(dateFrom.getDate() - days);
+
+    const results = await this.query({ pillar, environment, dateFrom });
+
+    const total = results.length;
+    const passed = results.filter((r) => r.status === "passed").length;
+    const failed = results.filter((r) => r.status === "failed").length;
+    const skipped = results.filter((r) => r.status === "skipped").length;
+    const duration = results.reduce((sum, r) => sum + r.duration, 0);
+    const passRate = total > 0 ? (passed / total) * 100 : 0;
+
+    return {
+      pillar,
+      environment,
+      total,
+      passed,
+      failed,
+      skipped,
+      duration,
+      passRate,
+    };
+  }
+
+  /**
+   * Find flaky tests (tests that fail inconsistently)
+   */
+  async getFlakyTests(pillar: Pillar, days: number = 30): Promise<FlakyTest[]> {
+    const dateFrom = new Date();
+    dateFrom.setDate(dateFrom.getDate() - days);
+
+    const results = await this.query({ pillar, dateFrom });
+
+    // Group results by test name
+    const testGroups = results.reduce(
+      (acc, r) => {
+        if (!acc[r.test]) {
+          acc[r.test] = [];
+        }
+        acc[r.test].push(r);
+        return acc;
+      },
+      {} as Record<string, TestResult[]>,
+    );
+
+    // Find tests with both passes and failures
+    const flakyTests: FlakyTest[] = [];
+
+    for (const [testName, testResults] of Object.entries(testGroups)) {
+      const runs = testResults.length;
+      const failures = testResults.filter((r) => r.status === "failed").length;
+
+      // Consider a test flaky if it has both passes and failures
+      if (failures > 0 && failures < runs && runs >= 3) {
+        flakyTests.push({
+          test: testName,
+          runs,
+          failures,
+          flakyRate: (failures / runs) * 100,
+        });
+      }
+    }
+
+    // Sort by flaky rate (most flaky first)
+    return flakyTests.sort((a, b) => b.flakyRate - a.flakyRate);
+  }
+
+  /**
+   * Get trend data for visualization
+   */
+  async getTrends(
+    pillar: Pillar,
+    environment: string,
+    days: number = 30,
+  ): Promise<TrendData[]> {
+    const dateFrom = new Date();
+    dateFrom.setDate(dateFrom.getDate() - days);
+
+    const results = await this.query({ pillar, environment, dateFrom });
+
+    // Group results by date
+    const dateGroups = results.reduce(
+      (acc, r) => {
+        const date = r.timestamp.split("T")[0];
+        if (!acc[date]) {
+          acc[date] = [];
+        }
+        acc[date].push(r);
+        return acc;
+      },
+      {} as Record<string, TestResult[]>,
+    );
+
+    // Calculate metrics for each date
+    const trends: TrendData[] = [];
+
+    for (const [date, dayResults] of Object.entries(dateGroups)) {
+      const total = dayResults.length;
+      const passed = dayResults.filter((r) => r.status === "passed").length;
+      const passRate = total > 0 ? (passed / total) * 100 : 0;
+      const avgDuration =
+        total > 0
+          ? dayResults.reduce((sum, r) => sum + r.duration, 0) / total
+          : 0;
+
+      trends.push({
+        date,
+        passRate,
+        avgDuration,
+        totalTests: total,
+      });
+    }
+
+    // Sort by date (oldest first)
+    return trends.sort((a, b) => a.date.localeCompare(b.date));
+  }
+
+  /**
+   * Read JSONL file and parse results
+   */
+  private async readJSONLFile(filepath: string): Promise<TestResult[]> {
+    const content = await readFile(filepath, "utf-8");
+    const lines = content
+      .trim()
+      .split("\n")
+      .filter((l) => l.length > 0);
+
+    return lines
+      .map((line) => {
+        try {
+          return JSON.parse(line) as TestResult;
+        } catch (error) {
+          console.warn(`Failed to parse line in ${filepath}: ${line}`);
+          return null;
+        }
+      })
+      .filter((r): r is TestResult => r !== null);
+  }
+
+  /**
+   * Get relevant files based on filters
+   */
+  private async getRelevantFiles(filters: QueryFilters): Promise<string[]> {
+    try {
+      const files = await readdir(this.resultsDir);
+
+      return files
+        .filter((f) => f.endsWith(".jsonl"))
+        .filter((f) => {
+          // Filter by pillar if specified
+          if (filters.pillar && !f.startsWith(filters.pillar)) {
+            return false;
+          }
+
+          // Filter by environment if specified
+          if (filters.environment && !f.includes(`-${filters.environment}-`)) {
+            return false;
+          }
+
+          return true;
+        })
+        .map((f) => join(this.resultsDir, f));
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Check if result matches filters
+   */
+  private matchesFilters(result: TestResult, filters: QueryFilters): boolean {
+    if (filters.status && result.status !== filters.status) {
+      return false;
+    }
+
+    if (filters.user && result.user !== filters.user) {
+      return false;
+    }
+
+    if (filters.dateFrom) {
+      const resultDate = new Date(result.timestamp);
+      if (resultDate < filters.dateFrom) {
+        return false;
+      }
+    }
+
+    if (filters.dateTo) {
+      const resultDate = new Date(result.timestamp);
+      if (resultDate > filters.dateTo) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+}
+
+// Export singleton instance
+export const resultReader = new ResultReader();

package/src/shared/results/result-writer.ts

@@ -0,0 +1,168 @@
+/**
+ * Result Writer
+ * Writes test results to JSONL (JSON Lines) format
+ */
+
+import {
+  appendFile,
+  writeFile,
+  readFile,
+  mkdir,
+  rename,
+  unlink,
+} from "fs/promises";
+import { resolve, join } from "path";
+import type { TestResult, Pillar } from "../types/index.js";
+
+export class ResultWriter {
+  private resultsDir: string;
+
+  constructor(resultsDir: string = "./results") {
+    this.resultsDir = resolve(resultsDir);
+  }
+
+  /**
+   * Write a single test result to JSONL file
+   */
+  async writeResult(result: TestResult): Promise<void> {
+    const filename = this.getFilename(result.pillar, result.environment);
+
+    try {
+      // Ensure results directory exists
+      await mkdir(this.resultsDir, { recursive: true });
+
+      // Append result as JSON line
+      const line = JSON.stringify(result) + "\n";
+      await appendFile(filename, line);
+
+      // Update index
+      await this.updateIndex(result.pillar, result.environment);
+    } catch (error) {
+      throw new Error(`Failed to write result: ${(error as Error).message}`);
+    }
+  }
+
+  /**
+   * Write multiple test results in batch
+   */
+  async writeResults(results: TestResult[]): Promise<void> {
+    if (results.length === 0) {
+      return;
+    }
+
+    // Group results by pillar and environment
+    const grouped = this.groupResults(results);
+
+    for (const [key, groupResults] of Object.entries(grouped)) {
+      const [pillar, environment] = key.split(":");
+      const filename = this.getFilename(pillar as Pillar, environment);
+
+      try {
+        // Ensure results directory exists
+        await mkdir(this.resultsDir, { recursive: true });
+
+        // Write all results as JSON lines
+        const lines =
+          groupResults.map((r) => JSON.stringify(r)).join("\n") + "\n";
+        await appendFile(filename, lines);
+
+        // Update index
+        await this.updateIndex(pillar as Pillar, environment);
+      } catch (error) {
+        throw new Error(
+          `Failed to write results for ${pillar}/${environment}: ${(error as Error).message}`,
+        );
+      }
+    }
+  }
+
+  /**
+   * Update results index for quick lookups
+   */
+  private async updateIndex(
+    pillar: Pillar,
+    environment: string,
+  ): Promise<void> {
+    const indexPath = join(this.resultsDir, "index.json");
+
+    try {
+      let index: Record<string, unknown> = {};
+
+      // Load existing index. Distinguish "no index yet" (ENOENT → start fresh)
+      // from a corrupt/unreadable existing file — clobbering a corrupt index
+      // with {} would silently wipe every other pillar/env entry.
+      let content: string | undefined;
+      try {
+        content = await readFile(indexPath, "utf-8");
+      } catch (e) {
+        if ((e as NodeJS.ErrnoException).code !== "ENOENT") throw e;
+      }
+      if (content !== undefined) {
+        const parsed = JSON.parse(content) as unknown;
+        if (
+          parsed === null ||
+          typeof parsed !== "object" ||
+          Array.isArray(parsed)
+        ) {
+          throw new Error("existing index.json is not an object");
+        }
+        index = parsed as Record<string, unknown>;
+      }
+
+      const key = `${pillar}:${environment}`;
+      const date = new Date().toISOString().split("T")[0];
+
+      // Update index entry
+      index[key] = {
+        pillar,
+        environment,
+        lastUpdated: new Date().toISOString(),
+        latestFile: this.getFilename(pillar, environment),
+        date,
+      };
+
+      // Write atomically (temp + rename) so a crash/concurrent worker can't
+      // leave a half-written index.json.
+      const tmp = `${indexPath}.${process.pid}.tmp`;
+      try {
+        await writeFile(tmp, JSON.stringify(index, null, 2));
+        await rename(tmp, indexPath);
+      } catch (err) {
+        // Don't leave an orphaned temp file behind when the write/rename fails.
+        await unlink(tmp).catch(() => {});
+        throw err;
+      }
+    } catch (error) {
+      // Index update is non-critical, just log error
+      console.warn(`Failed to update index: ${(error as Error).message}`);
+    }
+  }
+
+  /**
+   * Get filename for results
+   */
+  private getFilename(pillar: string, environment: string): string {
+    const date = new Date().toISOString().split("T")[0];
+    return join(this.resultsDir, `${pillar}-${environment}-${date}.jsonl`);
+  }
+
+  /**
+   * Group results by pillar and environment
+   */
+  private groupResults(results: TestResult[]): Record<string, TestResult[]> {
+    return results.reduce(
+      (acc, result) => {
+        const key = `${result.pillar}:${result.environment}`;
+        if (!acc[key]) {
+          acc[key] = [];
+        }
+        acc[key].push(result);
+        return acc;
+      },
+      {} as Record<string, TestResult[]>,
+    );
+  }
+}
+
+// Export singleton instance
+export const resultWriter = new ResultWriter();

package/src/shared/secrets/doppler.ts

@@ -0,0 +1,126 @@
+/**
+ * Doppler strategy — reads/writes flat keys with the `doppler` CLI.
+ * Selected with `secrets.provider: doppler` (the default).
+ *
+ * Project/config come from `secrets.doppler.{project,config}` in
+ * config/den.yml, else from the directory's `doppler setup` scope,
+ * else from DOPPLER_PROJECT / DOPPLER_CONFIG / DOPPLER_TOKEN.
+ */
+import { execFile, spawn } from "child_process";
+import { promisify } from "util";
+import { flatKeyFor } from "./keys.js";
+import type { PreflightResult, SecretRef, SecretsProvider } from "./types.js";
+
+import { product } from "../product.js";
+const execFileAsync = promisify(execFile);
+
+export interface DopplerOptions {
+  project?: string;
+  config?: string;
+  keys?: Record<string, string>;
+  timeoutMs?: number;
+}
+
+export class DopplerProvider implements SecretsProvider {
+  readonly name = "doppler" as const;
+  private readonly timeout: number;
+
+  constructor(private readonly opts: DopplerOptions = {}) {
+    this.timeout = opts.timeoutMs ?? 30_000;
+  }
+
+  /** `--project/--config` flags when configured explicitly. */
+  scopeArgs(): string[] {
+    const a: string[] = [];
+    if (this.opts.project) a.push("--project", this.opts.project);
+    if (this.opts.config) a.push("--config", this.opts.config);
+    return a;
+  }
+
+  keyFor(ref: SecretRef): string {
+    return flatKeyFor(ref, this.opts.keys);
+  }
+
+  async isReady(): Promise<boolean> {
+    try {
+      await execFileAsync("doppler", ["me", "--json"], {
+        timeout: this.timeout,
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async get(ref: SecretRef): Promise<string> {
+    const key = this.keyFor(ref);
+    const { stdout } = await execFileAsync(
+      "doppler",
+      ["secrets", "get", key, "--plain", ...this.scopeArgs()],
+      { timeout: this.timeout },
+    );
+    return String(stdout).trim();
+  }
+
+  async tryGet(ref: SecretRef): Promise<string | null> {
+    try {
+      const v = await this.get(ref);
+      return v.length > 0 ? v : null;
+    } catch {
+      return null;
+    }
+  }
+
+  /** Value goes over stdin so it never appears in the process table. */
+  async set(ref: SecretRef, value: string): Promise<void> {
+    const key = this.keyFor(ref);
+    await new Promise<void>((resolve, reject) => {
+      const child = spawn(
+        "doppler",
+        ["secrets", "set", key, "--silent", ...this.scopeArgs()],
+        { stdio: ["pipe", "ignore", "pipe"] },
+      );
+      let stderr = "";
+      child.stderr?.on("data", (d) => (stderr += String(d)));
+      child.on("error", reject);
+      child.on("close", (code) =>
+        code === 0
+          ? resolve()
+          : reject(
+              new Error(`doppler secrets set ${key} failed: ${stderr.trim()}`),
+            ),
+      );
+      child.stdin?.end(value);
+    });
+  }
+
+  async preflight(): Promise<PreflightResult> {
+    if (!(await this.isReady())) {
+      return {
+        ok: false,
+        message:
+          "Doppler CLI is not installed or not logged in.\n" +
+          "Install: brew install dopplerhq/cli/doppler  then: doppler login",
+      };
+    }
+    try {
+      await execFileAsync(
+        "doppler",
+        ["secrets", "--only-names", "--json", ...this.scopeArgs()],
+        { timeout: this.timeout },
+      );
+      return { ok: true };
+    } catch {
+      return {
+        ok: false,
+        message:
+          "Doppler is logged in but no project/config is selected.\n" +
+          `Run \`doppler setup\` in the repo, or set secrets.doppler.project/config in ${product().configFile}.`,
+      };
+    }
+  }
+
+  runPrefix(): string[] {
+    return ["doppler", "run", ...this.scopeArgs(), "--"];
+  }
+}

package/src/shared/secrets/env.ts

@@ -0,0 +1,48 @@
+/**
+ * Environment-variable strategy — reads flat keys from process.env.
+ * Selected with `secrets.provider: env`. Intended for CI and for engineers who
+ * inject secrets themselves (direnv, `doppler run -- den …`, CI secrets).
+ */
+import { flatKeyFor } from "./keys.js";
+import type { PreflightResult, SecretRef, SecretsProvider } from "./types.js";
+
+export class EnvProvider implements SecretsProvider {
+  readonly name = "env" as const;
+
+  constructor(
+    private readonly keys: Record<string, string> = {},
+    private readonly env: NodeJS.ProcessEnv = process.env,
+  ) {}
+
+  keyFor(ref: SecretRef): string {
+    return flatKeyFor(ref, this.keys);
+  }
+
+  async isReady(): Promise<boolean> {
+    return true;
+  }
+
+  async get(ref: SecretRef): Promise<string> {
+    const key = this.keyFor(ref);
+    const v = this.env[key];
+    if (!v) throw new Error(`Secret ${key} is not set in the environment`);
+    return v;
+  }
+
+  async tryGet(ref: SecretRef): Promise<string | null> {
+    return this.env[this.keyFor(ref)] || null;
+  }
+
+  async set(ref: SecretRef, value: string): Promise<void> {
+    // Process-local only: the env backend has no durable store.
+    this.env[this.keyFor(ref)] = value;
+  }
+
+  async preflight(): Promise<PreflightResult> {
+    return { ok: true };
+  }
+
+  runPrefix(): string[] {
+    return [];
+  }
+}