@devosurf/tesser 0.1.0-alpha.0

package/src/commands/test.ts

@@ -0,0 +1,149 @@
+// `tesser test` (ADR-0008): the agent's fast pass/fail loop. Colocated tests run via the
+// project's own vitest (subprocess, JSON reporter — never named in our surface); every
+// automation WITHOUT a colocated test gets the auto-generated smoke test. Failures are
+// machine-actionable on stdout with --json; exit 3 on red.
+
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { smokeTest } from "@devosurf/tesser-testing";
+import { EXIT } from "../exit-codes.js";
+import { CliError, Output } from "../output.js";
+import { discoverLocalAutomations, loadAutomationDef } from "../project.js";
+
+const exec = promisify(execFile);
+
+interface TestReport {
+  passed: boolean;
+  colocated: { ran: number; passed: number; failed: number; skippedNoRunner?: boolean };
+  smoke: Array<{ automation: string; passed: boolean; reason?: string; failure?: unknown }>;
+  failures: Array<{
+    kind: "test" | "smoke";
+    automation?: string;
+    file?: string;
+    name?: string;
+    message: string;
+  }>;
+}
+
+function findVitest(projectRoot: string): string | null {
+  let dir = projectRoot;
+  for (;;) {
+    const bin = join(dir, "node_modules", ".bin", process.platform === "win32" ? "vitest.cmd" : "vitest");
+    if (existsSync(bin)) return bin;
+    const parent = join(dir, "..");
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+export async function runTests(
+  out: Output,
+  projectRoot: string,
+  opts: { smokeOnly?: boolean; filter?: string | undefined },
+): Promise<never> {
+  const automations = discoverLocalAutomations(projectRoot).filter(
+    (a) => opts.filter === undefined || a.automationId === opts.filter,
+  );
+  if (automations.length === 0) {
+    throw new CliError(EXIT.USAGE, `no automations found under ${join(projectRoot, "automations")}`);
+  }
+
+  const report: TestReport = {
+    passed: true,
+    colocated: { ran: 0, passed: 0, failed: 0 },
+    smoke: [],
+    failures: [],
+  };
+
+  // ---- colocated tests through the project's test runner ----
+  const withTests = automations.filter((a) => a.hasTests);
+  if (!opts.smokeOnly && withTests.length > 0) {
+    const vitestBin = findVitest(projectRoot);
+    if (!vitestBin) {
+      report.colocated.skippedNoRunner = true;
+      out.log("note: no test runner installed in the project — running smoke tests only");
+    } else {
+      const args = ["run", "--reporter=json", ...withTests.map((a) => a.dir)];
+      const res = await exec(vitestBin, args, {
+        cwd: projectRoot,
+        env: { ...process.env, CI: "1" },
+        maxBuffer: 64 * 1024 * 1024,
+      }).catch((err: { stdout?: string; stderr?: string }) => ({
+        stdout: err.stdout ?? "",
+        stderr: err.stderr ?? "",
+      }));
+      const jsonLine = (res.stdout ?? "").split("\n").find((l) => l.trimStart().startsWith("{"));
+      if (!jsonLine) {
+        report.passed = false;
+        report.failures.push({ kind: "test", message: `test runner produced no JSON report: ${(res.stderr ?? "").slice(0, 800)}` });
+      } else {
+        const parsed = JSON.parse(jsonLine) as {
+          numTotalTests: number;
+          numPassedTests: number;
+          numFailedTests: number;
+          testResults: Array<{
+            name: string;
+            assertionResults: Array<{ status: string; fullName: string; failureMessages: string[] }>;
+          }>;
+        };
+        report.colocated.ran = parsed.numTotalTests;
+        report.colocated.passed = parsed.numPassedTests;
+        report.colocated.failed = parsed.numFailedTests;
+        if (parsed.numFailedTests > 0) {
+          report.passed = false;
+          for (const file of parsed.testResults) {
+            for (const t of file.assertionResults) {
+              if (t.status === "failed") {
+                report.failures.push({
+                  kind: "test",
+                  file: file.name,
+                  name: t.fullName,
+                  message: t.failureMessages.join("\n").slice(0, 2000),
+                });
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // ---- auto smoke for automations without colocated tests (and all, with --smoke-only) ----
+  const smokeTargets = opts.smokeOnly ? automations : automations.filter((a) => !a.hasTests);
+  for (const auto of smokeTargets) {
+    try {
+      const def = await loadAutomationDef(auto.entry);
+      const outcome = await smokeTest(def);
+      report.smoke.push({
+        automation: auto.automationId,
+        passed: outcome.passed,
+        ...(outcome.reason !== undefined ? { reason: outcome.reason } : {}),
+        ...(outcome.passed ? {} : { failure: outcome.result.failure() }),
+      });
+      if (!outcome.passed) {
+        report.passed = false;
+        report.failures.push({
+          kind: "smoke",
+          automation: auto.automationId,
+          message: outcome.reason ?? "smoke test failed",
+        });
+      }
+    } catch (err) {
+      report.passed = false;
+      report.smoke.push({ automation: auto.automationId, passed: false, reason: String(err) });
+      report.failures.push({ kind: "smoke", automation: auto.automationId, message: String(err).slice(0, 2000) });
+    }
+  }
+
+  out.data(report, (r: TestReport) => {
+    const lines = [
+      `colocated: ${r.colocated.passed}/${r.colocated.ran} passed${r.colocated.skippedNoRunner ? " (runner missing)" : ""}`,
+      ...r.smoke.map((s) => `smoke ${s.automation}: ${s.passed ? "✓" : `✗ ${s.reason ?? ""}`}`),
+      r.passed ? "PASS" : `FAIL (${r.failures.length} failure${r.failures.length === 1 ? "" : "s"})`,
+    ];
+    return lines.join("\n");
+  });
+  process.exit(report.passed ? EXIT.OK : EXIT.TESTS_FAILED);
+}

package/src/config.ts

@@ -0,0 +1,87 @@
+// Profiles + the link manifest. Token resolution: --token > TESSER_TOKEN > profile.
+// Instance URL: --url > tesser.json > TESSER_URL > profile > localhost default.
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+export interface Profile {
+  url?: string;
+  token?: string;
+}
+export interface CliConfig {
+  current?: string;
+  profiles?: Record<string, Profile>;
+}
+
+/** tesser.json — the link manifest: ties this repo (Project) to an instance (ADR-0006). */
+export interface LinkManifest {
+  project: string;
+  instance?: string;
+}
+
+const CONFIG_PATH = join(
+  process.env["TESSER_CONFIG_DIR"] ?? join(homedir(), ".config", "tesser"),
+  "config.json",
+);
+
+export function readConfig(): CliConfig {
+  try {
+    return JSON.parse(readFileSync(CONFIG_PATH, "utf8")) as CliConfig;
+  } catch {
+    return {};
+  }
+}
+
+export function writeConfig(config: CliConfig): void {
+  mkdirSync(dirname(CONFIG_PATH), { recursive: true });
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", { mode: 0o600 });
+}
+
+export function activeProfile(config: CliConfig, name?: string): Profile {
+  const profileName = name ?? config.current ?? "default";
+  return config.profiles?.[profileName] ?? {};
+}
+
+export function findProjectRoot(start = process.cwd()): string | null {
+  let dir = start;
+  for (;;) {
+    if (existsSync(join(dir, "tesser.json"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+export function readLinkManifest(root: string): LinkManifest | null {
+  try {
+    return JSON.parse(readFileSync(join(root, "tesser.json"), "utf8")) as LinkManifest;
+  } catch {
+    return null;
+  }
+}
+
+export interface ResolvedTarget {
+  url: string;
+  token: string | undefined;
+  project: string | undefined;
+  projectRoot: string | null;
+}
+
+export function resolveTarget(opts: { url?: string; token?: string; profile?: string }): ResolvedTarget {
+  const config = readConfig();
+  const profile = activeProfile(config, opts.profile);
+  const projectRoot = findProjectRoot();
+  const manifest = projectRoot ? readLinkManifest(projectRoot) : null;
+  return {
+    url:
+      opts.url ??
+      manifest?.instance ??
+      process.env["TESSER_URL"] ??
+      profile.url ??
+      "http://localhost:8377",
+    token: opts.token ?? process.env["TESSER_TOKEN"] ?? profile.token,
+    project: manifest?.project,
+    projectRoot,
+  };
+}

package/src/exit-codes.ts

@@ -0,0 +1,24 @@
+// The deterministic exit-code taxonomy (ADR-0007). Agents branch on these; never reuse
+// a number for a different meaning.
+
+export const EXIT = {
+  OK: 0,
+  /** Unexpected/internal error. */
+  ERROR: 1,
+  /** Usage error — bad arguments or no linked project. */
+  USAGE: 2,
+  /** Tests failed (machine-actionable detail on stdout with --json). */
+  TESTS_FAILED: 3,
+  /** Deploy halted: credentials needed — a connect link is on stdout. */
+  HALTED_CREDENTIALS: 4,
+  /** Could not reach or authenticate against the instance. */
+  AUTH: 5,
+  /** Resource not found. */
+  NOT_FOUND: 6,
+  /** Conflict / invalid state for the requested operation. */
+  CONFLICT: 7,
+  /** Deploy failed (build error or red test gate). */
+  DEPLOY_FAILED: 8,
+} as const;
+
+export type ExitCode = (typeof EXIT)[keyof typeof EXIT];