verify-grid 0.1.0

package/README.md

@@ -0,0 +1,48 @@
+# verify-grid
+
+Run matrix of tasks across services with parallel execution and status reporting.
+
+## Installation
+
+```bash
+npm install verify-grid
+```
+
+## Quick Start
+
+Create `qa.config.js` or `qa.config.mjs`:
+
+```javascript
+export default {
+  tasks: {
+    unit: { command: 'npm', args: ['test'] },
+    lint: { command: 'npm', args: ['run', 'lint'] },
+  },
+  services: [
+    { name: 'service1', cwd: './services/service1' },
+    { name: 'service2', cwd: './services/service2' },
+  ],
+};
+```
+
+Run tasks:
+
+```bash
+qa run --tasks unit,lint --services all
+qa run --tasks all --services all --fail-fast
+qa run --tasks unit --services all --watch
+```
+
+## Features
+
+- Parallel execution with configurable concurrency
+- Fail-fast mode to stop on first error
+- Watch mode with live updates
+- Multiple output formats (table, minimal, json)
+- Proper exit codes for CI/CD (0=success, 1=errors, 2=config error)
+- Task overrides per service
+- Timeout support
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,641 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { cac } from "cac";
+import { cpus } from "os";
+
+// src/config/loader.ts
+import { pathToFileURL } from "url";
+import { existsSync } from "fs";
+import { resolve, dirname } from "path";
+
+// src/config/schema.ts
+import { z } from "zod";
+var TaskDefSchema = z.object({
+  name: z.string(),
+  command: z.string(),
+  args: z.array(z.string()).optional(),
+  shell: z.boolean().optional(),
+  timeout: z.number().positive().optional(),
+  env: z.record(z.string()).optional()
+});
+var ServiceDefSchema = z.object({
+  name: z.string(),
+  cwd: z.string(),
+  tasks: z.record(z.object({
+    command: z.string().optional(),
+    args: z.array(z.string()).optional(),
+    shell: z.boolean().optional(),
+    timeout: z.number().positive().optional(),
+    env: z.record(z.string()).optional()
+  })).optional(),
+  env: z.record(z.string()).optional()
+});
+var ConfigSchema = z.object({
+  services: z.array(ServiceDefSchema),
+  tasks: z.record(TaskDefSchema.omit({ name: true }))
+});
+
+// src/config/loader.ts
+var CONFIG_FILES = ["qa.config.ts", "qa.config.js", "qa.config.mjs"];
+async function findConfig(startDir = process.cwd()) {
+  let currentDir = resolve(startDir);
+  const root = resolve("/");
+  while (currentDir !== root) {
+    for (const configFile of CONFIG_FILES) {
+      const configPath = resolve(currentDir, configFile);
+      if (existsSync(configPath)) {
+        return configPath;
+      }
+    }
+    currentDir = dirname(currentDir);
+  }
+  for (const configFile of CONFIG_FILES) {
+    const configPath = resolve(root, configFile);
+    if (existsSync(configPath)) {
+      return configPath;
+    }
+  }
+  return null;
+}
+async function loadConfig(configPath) {
+  const path = configPath || await findConfig();
+  if (!path) {
+    throw new Error(
+      "No config file found. Create qa.config.ts or qa.config.js in your project root."
+    );
+  }
+  if (!existsSync(path)) {
+    throw new Error(`Config file not found: ${path}`);
+  }
+  try {
+    const fileUrl = pathToFileURL(path).href;
+    const module = await import(fileUrl);
+    const configData = module.default || module;
+    const result = ConfigSchema.safeParse(configData);
+    if (!result.success) {
+      const errors = result.error.errors.map(
+        (err) => `  - ${err.path.join(".")}: ${err.message}`
+      ).join("\n");
+      throw new Error(`Invalid config:
+${errors}`);
+    }
+    const serviceNames = /* @__PURE__ */ new Set();
+    for (const service of result.data.services) {
+      if (serviceNames.has(service.name)) {
+        throw new Error(`Duplicate service name: ${service.name}`);
+      }
+      serviceNames.add(service.name);
+    }
+    const config = {
+      services: result.data.services,
+      tasks: Object.entries(result.data.tasks).reduce((acc, [name, def]) => {
+        acc[name] = { name, ...def };
+        return acc;
+      }, {})
+    };
+    return config;
+  } catch (error) {
+    if (error instanceof Error) {
+      throw error;
+    }
+    throw new Error(`Failed to load config: ${String(error)}`);
+  }
+}
+
+// src/runner/generator.ts
+import { existsSync as existsSync2 } from "fs";
+function generateJobs(config, taskNames, serviceNames) {
+  const jobs = [];
+  const resolvedServiceNames = serviceNames.includes("all") ? config.services.map((s) => s.name) : serviceNames;
+  const resolvedTaskNames = taskNames.includes("all") ? Object.keys(config.tasks) : taskNames;
+  for (const taskName of resolvedTaskNames) {
+    const globalTask = config.tasks[taskName];
+    if (!globalTask) {
+      throw new Error(`Unknown task: ${taskName}`);
+    }
+    for (const serviceName of resolvedServiceNames) {
+      const service = config.services.find((s) => s.name === serviceName);
+      if (!service) {
+        throw new Error(`Unknown service: ${serviceName}`);
+      }
+      if (!existsSync2(service.cwd)) {
+        jobs.push({
+          id: `${taskName}:${serviceName}`,
+          taskName,
+          serviceName,
+          cwd: service.cwd,
+          command: "",
+          status: "skipped"
+        });
+        continue;
+      }
+      const taskOverride = service.tasks?.[taskName];
+      if (taskOverride && taskOverride.command === void 0 && !globalTask.command) {
+        jobs.push({
+          id: `${taskName}:${serviceName}`,
+          taskName,
+          serviceName,
+          cwd: service.cwd,
+          command: "",
+          status: "skipped"
+        });
+        continue;
+      }
+      const mergedTask = {
+        name: taskName,
+        command: taskOverride?.command ?? globalTask.command,
+        args: taskOverride?.args ?? globalTask.args,
+        shell: taskOverride?.shell ?? globalTask.shell ?? true,
+        timeout: taskOverride?.timeout ?? globalTask.timeout,
+        env: {
+          ...globalTask.env,
+          ...service.env,
+          ...taskOverride?.env
+        }
+      };
+      jobs.push({
+        id: `${taskName}:${serviceName}`,
+        taskName,
+        serviceName,
+        cwd: service.cwd,
+        command: mergedTask.command,
+        args: mergedTask.args,
+        shell: mergedTask.shell,
+        timeout: mergedTask.timeout,
+        env: mergedTask.env,
+        status: "queued"
+      });
+    }
+  }
+  return jobs;
+}
+
+// src/runner/runner.ts
+import PQueue from "p-queue";
+import { EventEmitter } from "events";
+
+// src/runner/executor.ts
+import { execa } from "execa";
+
+// src/utils/log.ts
+var MAX_LOG_LINES = 200;
+function extractErrorSnippet(stderr, stdout, maxLines = 10) {
+  const errorLog = stderr || stdout;
+  const lines = errorLog.split("\n").filter((line) => line.trim());
+  if (lines.length === 0) {
+    return "No error output";
+  }
+  const relevantLines = lines.slice(-maxLines);
+  return relevantLines.join("\n");
+}
+var LogBuffer = class {
+  lines = [];
+  maxLines;
+  constructor(maxLines = MAX_LOG_LINES) {
+    this.maxLines = maxLines;
+  }
+  append(data) {
+    const newLines = data.split("\n");
+    this.lines.push(...newLines);
+    if (this.lines.length > this.maxLines) {
+      this.lines = this.lines.slice(-this.maxLines);
+    }
+  }
+  getContent() {
+    return this.lines.join("\n");
+  }
+  clear() {
+    this.lines = [];
+  }
+};
+
+// src/runner/executor.ts
+async function executeJob(job) {
+  const startTime = Date.now();
+  const stdoutBuffer = new LogBuffer();
+  const stderrBuffer = new LogBuffer();
+  try {
+    const args = job.args || [];
+    const options = {
+      cwd: job.cwd,
+      env: { ...process.env, ...job.env },
+      shell: job.shell,
+      timeout: job.timeout,
+      reject: false,
+      all: true
+    };
+    const result = await execa(job.command, args, options);
+    stdoutBuffer.append(result.stdout || "");
+    stderrBuffer.append(result.stderr || "");
+    const durationMs = Date.now() - startTime;
+    if (result.exitCode === 0) {
+      return {
+        job,
+        exitCode: 0,
+        stdout: stdoutBuffer.getContent(),
+        stderr: stderrBuffer.getContent(),
+        durationMs
+      };
+    }
+    return {
+      job,
+      exitCode: result.exitCode,
+      stdout: stdoutBuffer.getContent(),
+      stderr: stderrBuffer.getContent(),
+      durationMs,
+      errorType: result.signal ? "signal" : "exit",
+      signal: result.signal || void 0
+    };
+  } catch (error) {
+    const durationMs = Date.now() - startTime;
+    const execaError = error;
+    if (execaError.stdout) stdoutBuffer.append(execaError.stdout);
+    if (execaError.stderr) stderrBuffer.append(execaError.stderr);
+    let errorType = "exit";
+    if (execaError.timedOut) {
+      errorType = "timeout";
+    } else if (execaError.signal) {
+      errorType = "signal";
+    } else if (execaError.exitCode === 127 || error.code === "ENOENT") {
+      errorType = "spawn";
+    }
+    return {
+      job,
+      exitCode: execaError.exitCode,
+      stdout: stdoutBuffer.getContent(),
+      stderr: stderrBuffer.getContent(),
+      durationMs,
+      errorType,
+      signal: execaError.signal || void 0
+    };
+  }
+}
+
+// src/runner/runner.ts
+var Runner = class extends EventEmitter {
+  queue;
+  state;
+  shouldStop = false;
+  options;
+  constructor(options) {
+    super();
+    this.options = options;
+    this.queue = new PQueue({ concurrency: options.concurrency });
+    this.state = {
+      jobs: /* @__PURE__ */ new Map(),
+      results: /* @__PURE__ */ new Map(),
+      errors: [],
+      startedAt: Date.now()
+    };
+    process.on("SIGINT", () => this.handleInterrupt());
+    process.on("SIGTERM", () => this.handleInterrupt());
+  }
+  handleInterrupt() {
+    if (this.shouldStop) {
+      process.exit(130);
+    }
+    this.shouldStop = true;
+    this.queue.clear();
+    for (const [id, job] of this.state.jobs) {
+      if (job.status === "queued") {
+        job.status = "canceled";
+        this.state.jobs.set(id, job);
+      }
+    }
+    this.emit("runCanceled");
+  }
+  async run(jobs) {
+    for (const job of jobs) {
+      this.state.jobs.set(job.id, job);
+    }
+    const executableJobs = jobs.filter((j) => j.status === "queued");
+    for (const job of executableJobs) {
+      if (this.shouldStop) {
+        job.status = "canceled";
+        this.state.jobs.set(job.id, job);
+        continue;
+      }
+      this.queue.add(async () => {
+        if (this.shouldStop) {
+          job.status = "canceled";
+          this.state.jobs.set(job.id, job);
+          return;
+        }
+        job.status = "running";
+        job.startedAt = Date.now();
+        this.state.jobs.set(job.id, job);
+        this.emit("jobStart", job);
+        const result = await executeJob(job);
+        job.status = result.exitCode === 0 ? "done" : "error";
+        job.endedAt = Date.now();
+        this.state.jobs.set(job.id, job);
+        this.state.results.set(job.id, result);
+        if (result.exitCode !== 0) {
+          this.emit("jobError", result);
+          if (this.options.failFast) {
+            this.shouldStop = true;
+            this.queue.clear();
+            for (const [id, j] of this.state.jobs) {
+              if (j.status === "queued") {
+                j.status = "canceled";
+                this.state.jobs.set(id, j);
+              }
+            }
+          }
+        } else {
+          this.emit("jobComplete", result);
+        }
+      });
+    }
+    await this.queue.onIdle();
+    this.state.endedAt = Date.now();
+    this.emit("runComplete", this.state);
+    return this.state;
+  }
+  getState() {
+    return this.state;
+  }
+};
+
+// src/render/table.ts
+import Table from "cli-table3";
+
+// src/utils/colors.ts
+import kleur from "kleur";
+var colorsEnabled = true;
+function setColorsEnabled(enabled) {
+  colorsEnabled = enabled;
+  kleur.enabled = enabled;
+}
+function getStatusColor(status) {
+  if (!colorsEnabled) {
+    return (text) => text;
+  }
+  switch (status) {
+    case "done":
+      return kleur.green;
+    case "error":
+      return kleur.red;
+    case "running":
+      return kleur.blue;
+    case "queued":
+      return kleur.yellow;
+    case "skipped":
+    case "canceled":
+      return kleur.gray;
+    default:
+      return (text) => text;
+  }
+}
+var colors = {
+  error: kleur.red,
+  success: kleur.green,
+  warning: kleur.yellow,
+  info: kleur.blue,
+  dim: kleur.gray,
+  bold: kleur.bold
+};
+
+// src/render/table.ts
+function renderTable(state) {
+  const table = new Table({
+    head: ["Task", "Service", "Status"],
+    style: {
+      head: [],
+      border: []
+    }
+  });
+  const taskGroups = groupJobsByTask(state);
+  for (const [taskName, jobs] of taskGroups) {
+    let isFirstRow = true;
+    for (const job of jobs) {
+      const statusColor = getStatusColor(job.status);
+      const statusText = statusColor(job.status);
+      table.push([
+        isFirstRow ? taskName : "",
+        job.serviceName,
+        statusText
+      ]);
+      isFirstRow = false;
+    }
+  }
+  return table.toString();
+}
+function renderMinimal(state) {
+  const lines = [];
+  for (const [, job] of state.jobs) {
+    const statusColor = getStatusColor(job.status);
+    const statusText = statusColor(job.status);
+    lines.push(`${job.taskName}  ${job.serviceName}  ${statusText}`);
+  }
+  return lines.join("\n");
+}
+function renderJson(state) {
+  const matrix = {};
+  for (const [, job] of state.jobs) {
+    if (!matrix[job.taskName]) {
+      matrix[job.taskName] = {};
+    }
+    const result = state.results.get(job.id);
+    const taskMatrix = matrix[job.taskName];
+    if (taskMatrix) {
+      taskMatrix[job.serviceName] = {
+        status: job.status,
+        exitCode: result?.exitCode,
+        durationMs: result?.durationMs
+      };
+    }
+  }
+  const errors = Array.from(state.results.values()).filter((r) => r.job.status === "error").map((r) => ({
+    taskName: r.job.taskName,
+    serviceName: r.job.serviceName,
+    exitCode: r.exitCode,
+    durationMs: r.durationMs,
+    errorType: r.errorType
+  }));
+  const output = {
+    startedAt: state.startedAt,
+    endedAt: state.endedAt,
+    durationMs: state.endedAt ? state.endedAt - state.startedAt : void 0,
+    matrix,
+    errors
+  };
+  return JSON.stringify(output, null, 2);
+}
+function groupJobsByTask(state) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const [, job] of state.jobs) {
+    if (!groups.has(job.taskName)) {
+      groups.set(job.taskName, []);
+    }
+    groups.get(job.taskName).push(job);
+  }
+  return groups;
+}
+
+// src/render/watch.ts
+import logUpdate from "log-update";
+var WatchRenderer = class {
+  updateInterval = null;
+  state = null;
+  start(state) {
+    this.state = state;
+    this.render();
+    this.updateInterval = setInterval(() => {
+      this.render();
+    }, 100);
+  }
+  update(state) {
+    this.state = state;
+  }
+  stop() {
+    if (this.updateInterval) {
+      clearInterval(this.updateInterval);
+      this.updateInterval = null;
+    }
+    logUpdate.done();
+  }
+  render() {
+    if (!this.state) return;
+    const output = renderTable(this.state);
+    logUpdate(output);
+  }
+};
+
+// src/report/aggregator.ts
+function aggregateErrors(state) {
+  const errors = [];
+  for (const [, result] of state.results) {
+    if (result.job.status === "error") {
+      const errorMessage = getErrorMessage(result);
+      const logSnippet = extractErrorSnippet(result.stderr, result.stdout);
+      errors.push({
+        taskName: result.job.taskName,
+        serviceName: result.job.serviceName,
+        exitCode: result.exitCode,
+        durationMs: result.durationMs,
+        message: errorMessage,
+        logSnippet,
+        errorType: result.errorType
+      });
+    }
+  }
+  errors.sort((a, b) => {
+    if (a.taskName !== b.taskName) {
+      return a.taskName.localeCompare(b.taskName);
+    }
+    return a.serviceName.localeCompare(b.serviceName);
+  });
+  return errors;
+}
+function getErrorMessage(result) {
+  if (result.errorType === "timeout") {
+    return `Timeout after ${result.durationMs}ms`;
+  }
+  if (result.errorType === "spawn") {
+    return `Command not found: ${result.job.command}`;
+  }
+  if (result.errorType === "signal") {
+    return `Killed by signal: ${result.signal}`;
+  }
+  return `Exit code ${result.exitCode}`;
+}
+function formatErrors(errors) {
+  if (errors.length === 0) {
+    return "";
+  }
+  const lines = ["", "Errors:"];
+  for (const error of errors) {
+    lines.push(`- ${error.serviceName} has error in ${error.taskName} test:`);
+    const snippet = error.logSnippet.trim();
+    if (snippet) {
+      const snippetLines = snippet.split("\n").slice(0, 10);
+      for (const line of snippetLines) {
+        lines.push(`  ${line}`);
+      }
+    } else {
+      lines.push(`  ${error.message}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/cli.ts
+var cli = cac("qa");
+cli.command("run", "Run tasks across services").option("--tasks <tasks>", 'Comma-separated list of tasks or "all"', { default: "all" }).option("--services <services>", 'Comma-separated list of services or "all"', { default: "all" }).option("--concurrency <n>", "Maximum parallel jobs", { default: cpus().length }).option("--parallel", "Alias for concurrency").option("--fail-fast", "Stop on first error", { default: false }).option("--watch", "Watch mode with live updates", { default: false }).option("--format <format>", "Output format: table, minimal, json", { default: "table" }).option("--output <path>", "Save JSON output to file").option("--verbose", "Verbose output", { default: false }).option("--quiet", "Minimal output", { default: false }).option("--timeout <ms>", "Timeout per task in milliseconds").option("--no-color", "Disable colors").option("--config <path>", "Path to config file").action(async (options) => {
+  try {
+    const isTTY = process.stdout.isTTY;
+    const colorsEnabled2 = options.color !== false && isTTY;
+    setColorsEnabled(colorsEnabled2);
+    const config = await loadConfig(options.config);
+    const tasks = options.tasks === "all" ? ["all"] : options.tasks.split(",").map((t) => t.trim());
+    const services = options.services === "all" ? ["all"] : options.services.split(",").map((s) => s.trim());
+    const runOptions = {
+      tasks,
+      services,
+      concurrency: Number(options.concurrency),
+      failFast: options.failFast,
+      watch: options.watch && isTTY,
+      format: options.format,
+      output: options.output,
+      verbose: options.verbose,
+      quiet: options.quiet,
+      timeout: options.timeout ? Number(options.timeout) : void 0,
+      noColor: !colorsEnabled2
+    };
+    const jobs = generateJobs(config, tasks, services);
+    if (jobs.length === 0) {
+      console.error("No jobs to run");
+      process.exit(2);
+    }
+    const runner = new Runner(runOptions);
+    let watchRenderer = null;
+    if (runOptions.watch) {
+      watchRenderer = new WatchRenderer();
+      watchRenderer.start(runner.getState());
+      runner.on("jobStart", () => {
+        watchRenderer?.update(runner.getState());
+      });
+      runner.on("jobComplete", () => {
+        watchRenderer?.update(runner.getState());
+      });
+      runner.on("jobError", () => {
+        watchRenderer?.update(runner.getState());
+      });
+    }
+    const state = await runner.run(jobs);
+    if (watchRenderer) {
+      watchRenderer.stop();
+    }
+    if (!runOptions.quiet) {
+      let output;
+      if (runOptions.format === "json") {
+        output = renderJson(state);
+      } else if (runOptions.format === "minimal") {
+        output = renderMinimal(state);
+      } else {
+        output = renderTable(state);
+      }
+      console.log(output);
+      const errors = aggregateErrors(state);
+      if (errors.length > 0 && runOptions.format !== "json") {
+        console.log(formatErrors(errors));
+      }
+    }
+    if (options.output) {
+      const { writeFileSync } = await import("fs");
+      writeFileSync(options.output, renderJson(state), "utf-8");
+    }
+    const hasErrors = Array.from(state.jobs.values()).some((j) => j.status === "error");
+    process.exit(hasErrors ? 1 : 0);
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : String(error));
+    process.exit(2);
+  }
+});
+cli.help();
+cli.version("0.1.0");
+cli.parse();
+//# sourceMappingURL=cli.js.map