@vitest-agent/engine 2.1.0 → 3.0.1

package/stores.js

@@ -1,5 +1,4 @@
-import { Context, Effect } from "effect";
-import { SqlClient } from "effect/sql/SqlClient";
+import { Context } from "effect";
 
 // src/stores.ts
 /**
@@ -10,24 +9,34 @@ import { SqlClient } from "effect/sql/SqlClient";
 */
 const LEDGER_OPTIONS = { adoptMigratorLedger: true };
 /**
-* Convert a {@link MigrationRecord} to the `StoreMigration` list `Store` runs,
-* parsing each key exactly as effect/sql's `Migrator.fromRecord` does
-* (`/^(\d+)_(.+)$/`: `"0001_initial"` → id `1`, name `"initial"`), so the ids
-* and names line up with an adopted `effect_sql_migrations` ledger. A key that
-* does not match is skipped, as effect/sql skips it.
+* How long a connection waits on a locked database before `SQLITE_BUSY`:
+* five seconds, the value the 2.x migrations set with `PRAGMA busy_timeout`.
+* Passed as the driver's `busyTimeout`, which applies it on every open.
 *
 * @internal
 */
-const toStoreMigrations = (migrations) => Object.entries(migrations).flatMap(([key, migration]) => {
-	const match = key.match(/^(\d+)_(.+)$/);
-	if (match === null) return [];
-	const [, id, name] = match;
-	return [{
-		id: Number(id),
-		name,
-		up: (sql) => Effect.provideService(migration, SqlClient, sql)
-	}];
-}).sort((a, b) => a.id - b.id);
+const BUSY_TIMEOUT = "5 seconds";
+/**
+* The per-connection settings every database applies as its connection
+* opens, before any migration: foreign-key enforcement on. The 2.x
+* migrations set `foreign_keys` / `busy_timeout` themselves, which a
+* migration can only do for the one connection that runs it; the
+* `node:sqlite` driver happens to default both today, and this pins them
+* so a driver default change cannot silently drop them.
+*
+* @internal
+*/
+const applyConnectionPragmas = (sql) => sql`PRAGMA foreign_keys = ON`;
+/**
+* The connection options every keyed store opens with: the driver's
+* `busyTimeout` and {@link applyConnectionPragmas} as `onConnect`.
+*
+* @internal
+*/
+const CONNECTION_OPTIONS = {
+	client: { busyTimeout: BUSY_TIMEOUT },
+	onConnect: applyConnectionPragmas
+};
 /**
 * The global discovery registry (`<XDG data>/vitest-agent/registry.db`).
 * @internal
@@ -39,4 +48,4 @@ var RegistryStore = class extends Context.Service()("vitest-agent/RegistryStore"
 */
 var SessionMapStore = class extends Context.Service()("vitest-agent/SessionMapStore") {};
 
-export { LEDGER_OPTIONS, RegistryStore, SessionMapStore, toStoreMigrations };
+export { BUSY_TIMEOUT, CONNECTION_OPTIONS, LEDGER_OPTIONS, RegistryStore, SessionMapStore, applyConnectionPragmas };

package/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.59.4"
+      "packageVersion": "7.60.0"
     }
   ]
 }

package/utils/ensure-migrated.js

@@ -1,24 +1,32 @@
 import { LoggerLive } from "../layers/LoggerLive.js";
-import { NodePlatformLayer, makeSqliteStack } from "../platform.js";
-import { Effect, Layer } from "effect";
-import { SqlClient } from "effect/sql/SqlClient";
+import { PROJECT_MIGRATIONS } from "../migrations/index.js";
+import { BUSY_TIMEOUT, LEDGER_OPTIONS, applyConnectionPragmas } from "../stores.js";
+import { NodePlatformLayer } from "../platform.js";
+import { Effect } from "effect";
+import { Store } from "@effected/store";
 
 // src/utils/ensure-migrated.ts
-const GLOBAL_KEY = Symbol.for("vitest-agent/migration-promises");
-const getCache = () => {
-	const g = globalThis;
-	let cache = g[GLOBAL_KEY];
-	if (!cache) {
-		cache = /* @__PURE__ */ new Map();
-		g[GLOBAL_KEY] = cache;
-	}
-	return cache;
-};
 /**
-* Ensure the SQLite database at `dbPath` is migrated. Runs migrations at
-* most once per dbPath in the current process; concurrent calls share the
-* same in-flight promise. Subsequent calls (after the first resolves) are
-* no-ops.
+* The project migrations as `Store` runs them, built once so every call
+* hands `Store.migrateOnce` the same list.
+*/
+const PROJECT_STORE_MIGRATIONS = Store.fromMigratorRecord(PROJECT_MIGRATIONS);
+/**
+* Ensure the SQLite database at `dbPath` is migrated to the head of the
+* project migration set.
+*
+* Runs through `@effected/store`'s `Store.migrateOnce`: at most one
+* successful migration run per database per process, shared by every
+* concurrent caller (and by every copy of the kit loaded in the process).
+* The run is keyed on the real path of the file's directory, so a relative,
+* an absolute and a symlinked spelling of one database share it. A failed
+* run (for example `SQLITE_BUSY`) is not remembered: the next call tries
+* again. The connection opens with the same per-connection settings as
+* `makeSqliteStack` (`busy_timeout`, `synchronous = NORMAL`,
+* `foreign_keys = ON`).
+*
+* The parent directory must exist; `dbPath` must name a file (`":memory:"`
+* is a wiring defect).
 *
 * @param dbPath - the SQLite file to migrate
 * @param logLevel - the diagnostics level for the migrator's records; see `LoggerLive`
@@ -28,25 +36,13 @@ const getCache = () => {
 * @public
 */
 function ensureMigrated(dbPath, logLevel, logFile, env) {
-	const cache = getCache();
-	const cached = cache.get(dbPath);
-	if (cached) return cached;
-	const { SqliteLayer, MigratorLayer } = makeSqliteStack(dbPath);
-	const program = Effect.gen(function* () {
-		yield* SqlClient;
-	}).pipe(Effect.provide(MigratorLayer), Effect.provide(Layer.merge(SqliteLayer, NodePlatformLayer)), Effect.provide(LoggerLive(logLevel, logFile, env)));
-	const promise = Effect.runPromise(program);
-	cache.set(dbPath, promise);
-	promise.catch(() => {});
-	return promise;
-}
-/**
-* Reset the migration cache. Test-only.
-*
-* @internal
-*/
-function _resetMigrationCacheForTesting() {
-	getCache().clear();
+	return Effect.runPromise(Store.migrateOnce({
+		filename: dbPath,
+		migrations: PROJECT_STORE_MIGRATIONS,
+		...LEDGER_OPTIONS,
+		client: { busyTimeout: BUSY_TIMEOUT },
+		onConnect: (sql) => Effect.andThen(sql`PRAGMA synchronous = NORMAL`, applyConnectionPragmas(sql))
+	}).pipe(Effect.provide(NodePlatformLayer), Effect.provide(LoggerLive(logLevel, logFile, env))));
 }
 
-export { _resetMigrationCacheForTesting, ensureMigrated };
+export { ensureMigrated };

package/utils/format-fatal-error.js

@@ -0,0 +1,55 @@
+import { Cause } from "effect";
+import { CliFailure, Render } from "@effected/cli";
+
+// src/utils/format-fatal-error.ts
+const ISSUE_URL = "https://github.com/spencerbeggs/vitest-agent/issues";
+/**
+* Plain text for a person reading stderr: no escapes of any kind, Unicode
+* glyphs, unbounded width (a terminal wraps a long line itself).
+*/
+const CONTEXT = Render.contextOf({ audience: "human" });
+/**
+* Format an unexpected failure for stderr, with the issue URL appended.
+*
+* @remarks
+* Under Effect v4, `Effect.runPromise` / `Effect.runSync` reject with
+* `Cause.squash` of the failure: the error value itself, with no
+* FiberFailure wrapper and no `Cause` attached. So a `Cause` is used as it
+* is (one from `Effect.runPromiseExit` keeps every reason and the span
+* trail), and anything else is rendered as a defect, `Cause.die(err)`: an
+* unexpected throw is a bug to report, and a defect is the shape whose
+* document carries the stack. `@effected/cli`'s `CliFailure.toDoc` keeps
+* the program's own frames, hides `node_modules` and runtime frames,
+* follows an `Error.cause` chain, and renders a non-`Error` value as its
+* text.
+*
+* Total: `CliFailure.toDoc` guards the `stack`, `message`, `cause` and
+* `issue` reads itself, but wrapping a `Proxy` whose traps throw can still
+* throw, so any throw while formatting falls back to a fixed marker naming
+* the value's constructor.
+*
+* @param err - the thrown value, rejection reason, or `Cause`
+* @returns the formatted failure followed by the issue-report line
+* @public
+*/
+const formatFatalError = (err) => {
+	let detail;
+	try {
+		const cause = Cause.isCause(err) ? err : Cause.die(err);
+		detail = Render.plain(CliFailure.toDoc(cause), CONTEXT);
+	} catch {
+		detail = `<unserializable ${constructorName(err)}>`;
+	}
+	return `${detail}\nPlease report at ${ISSUE_URL}`;
+};
+/** The value's constructor name, guarded: an own `constructor` getter or a `Proxy` trap can throw too. */
+const constructorName = (err) => {
+	try {
+		const name = err?.constructor?.name;
+		return typeof name === "string" && name !== "" ? name : "error";
+	} catch {
+		return "error";
+	}
+};
+
+export { formatFatalError };

package/utils/host-metadata.js

@@ -0,0 +1,101 @@
+import { Option } from "effect";
+import { RuntimeEnv } from "@effected/env";
+
+// src/utils/host-metadata.ts
+/**
+* The `ci_provider` string persisted for each CI whose job coordinate is
+* recorded. These are this project's own spellings (`github`, `circle`),
+* stored since 2.0; they are mapped from `CiName` rather than replaced by it
+* so existing rows keep matching.
+*/
+const CI_ROWS = {
+	"github-actions": {
+		provider: "github",
+		variable: "GITHUB_RUN_ID",
+		coordinate: "runId"
+	},
+	buildkite: {
+		provider: "buildkite",
+		variable: "BUILDKITE_JOB_ID",
+		coordinate: "jobId"
+	},
+	circleci: {
+		provider: "circle",
+		variable: "CIRCLE_BUILD_NUM",
+		coordinate: "jobId"
+	},
+	gitlab: {
+		provider: "gitlab",
+		variable: "CI_JOB_ID",
+		coordinate: "jobId"
+	}
+};
+const NONE = {
+	source: null,
+	value: null,
+	metadata: null
+};
+/**
+* The host identity of an environment record, from `@effected/env`'s
+* `RuntimeEnv` snapshot (`session`, `ci` / `ciRun`, `termProgram`).
+*
+* Priority: the terminal session (`TMUX_PANE`, `WT_SESSION`, `WEZTERM_PANE`,
+* `KITTY_WINDOW_ID`, `TERM_SESSION_ID`), then the CI job (GitHub Actions run,
+* Buildkite, CircleCI, GitLab job). The first match is the source; when
+* nothing matches, all three fields are `null`. Every metadata object
+* carries `term_program` / `term_program_version` when they are set, then
+* the source's own keys (`tmux_socket` for a tmux pane, `ci`, `ci_provider`
+* and `github_run_attempt` for CI), in that key order.
+*
+* GNU screen (`STY`) is not a source: the snapshot is taken with `STY`
+* removed, so a screen session falls through to the next source exactly as
+* it did before the kit, and no `STY` row is ever written. The
+* `VSCODE_INJECTION` + parent-pid sources need `process.ppid` and are the
+* caller's.
+*
+* @param env - the environment record to read (the front end passes `process.env`)
+* @public
+*/
+const probeHostMetadataFromEnv = (env) => {
+	const snapshot = RuntimeEnv.fromRecord({
+		...env,
+		STY: void 0
+	});
+	const decoration = (extra) => ({
+		...Option.match(snapshot.termProgram.name, {
+			onNone: () => ({}),
+			onSome: (name) => ({ term_program: name })
+		}),
+		...Option.match(snapshot.termProgram.version, {
+			onNone: () => ({}),
+			onSome: (version) => ({ term_program_version: version })
+		}),
+		...extra
+	});
+	if (Option.isSome(snapshot.session)) {
+		const session = snapshot.session.value;
+		const socket = session.source === "tmux" ? Option.filter(session.multiplexer, (multiplexer) => multiplexer.name === "tmux") : Option.none();
+		return {
+			source: session.variable,
+			value: session.id,
+			metadata: decoration(Option.isSome(socket) ? { tmux_socket: socket.value.value } : {})
+		};
+	}
+	if (Option.isNone(snapshot.ci) || Option.isNone(snapshot.ciRun)) return NONE;
+	const row = CI_ROWS[snapshot.ci.value];
+	if (row === void 0) return NONE;
+	const run = snapshot.ciRun.value;
+	const value = run[row.coordinate];
+	if (Option.isNone(value)) return NONE;
+	return {
+		source: row.variable,
+		value: value.value,
+		metadata: decoration({
+			ci: true,
+			ci_provider: row.provider,
+			...row.provider === "github" && Option.isSome(run.attempt) ? { github_run_attempt: run.attempt.value } : {}
+		})
+	};
+};
+
+export { probeHostMetadataFromEnv };

package/utils/package-manifest.js

@@ -0,0 +1,21 @@
+import { Option, Schema } from "effect";
+import { Repository } from "@effected/package-json";
+
+// src/utils/package-manifest.ts
+const decodeRepository = Schema.decodeUnknownOption(Repository.FromValue);
+/**
+* The trimmed `repository` URL a manifest names, from the string form or the
+* object form's `url`, or `null` when there is none (absent, blank, an object
+* with no string `url`, or a value of neither form).
+*
+* @internal
+*/
+const repositoryUrlOf = (repository) => repository === void 0 ? null : Option.match(decodeRepository(repository), {
+	onNone: () => null,
+	onSome: (repo) => {
+		const url = repo.url.trim();
+		return url.length > 0 ? url : null;
+	}
+});
+
+export { repositoryUrlOf };

package/utils/resolve-data-path.js

@@ -1,7 +1,7 @@
 import { VitestAgentConfigFile } from "../services/Config.js";
 import { resolveProjectKeyFromCwdEffect } from "./resolve-project-key-from-cwd.js";
-import { VitestAgentConfig, normalizeWorkspaceKey } from "@vitest-agent/sdk";
-import { Effect, FileSystem } from "effect";
+import { ProjectIdentitySourceError, VitestAgentConfig } from "@vitest-agent/sdk";
+import { Effect, FileSystem, Result } from "effect";
 import { AppDirs } from "@effected/xdg";
 import { join } from "node:path";
 
@@ -12,6 +12,20 @@ import { join } from "node:path";
 */
 const DATABASE_FILENAME = "data.db";
 /**
+* The data directory name for a `projectKey` from `vitest-agent.config.toml`,
+* or a `ProjectIdentitySourceError` (source `toml`) when it maps to `.` or
+* `..` — the same refusal `ProjectIdentityLive` gives the same key.
+*/
+const configuredKey = (projectKey, projectDir) => Result.match(AppDirs.segment(projectKey), {
+	onSuccess: Effect.succeed,
+	onFailure: (cause) => Effect.fail(new ProjectIdentitySourceError({
+		source: "toml",
+		path: projectDir,
+		detail: `projectKey ${JSON.stringify(projectKey)} is not a usable directory name (${cause.message})`,
+		cause
+	}))
+});
+/**
 * Resolve the absolute path to the SQLite database for `projectDir`.
 *
 * The directory containing the database is ensured to exist before the
@@ -23,7 +37,10 @@ const DATABASE_FILENAME = "data.db";
 *
 * 1. `options.cacheDir` — programmatic override.
 * 2. `cacheDir` from `vitest-agent.config.toml`.
-* 3. `<XDG data>/<normalized projectKey from config>/data.db`.
+* 3. `<XDG data>/<normalized projectKey from config>/data.db`. A
+*    `projectKey` that normalizes to `.` or `..` fails with
+*    `ProjectIdentitySourceError` (source `toml`) rather than writing
+*    outside the data root.
 * 4. `<XDG data>/<projectKey resolved from cwd's package.json>/data.db`.
 *    Source 4 prefers `repository.url` (canonicalized to `host__path`),
 *    falling back to the normalized `name`. This matches the sidecar
@@ -54,7 +71,7 @@ const resolveDataPath = (projectDir, options = {}) => Effect.gen(function* () {
 		return join(loaded.cacheDir, DATABASE_FILENAME);
 	}
 	const dataRoot = yield* (yield* AppDirs).ensureData;
-	const key = loaded.projectKey ? normalizeWorkspaceKey(loaded.projectKey) : yield* resolveProjectKeyFromCwdEffect(projectDir);
+	const key = loaded.projectKey ? yield* configuredKey(loaded.projectKey, projectDir) : yield* resolveProjectKeyFromCwdEffect(projectDir);
 	const dir = join(dataRoot, key);
 	yield* fs.makeDirectory(dir, { recursive: true });
 	return join(dir, DATABASE_FILENAME);

package/utils/resolve-project-key-from-cwd.js

@@ -1,49 +1,40 @@
-import { gitUrlToProjectKey, normalizeWorkspaceKey } from "@vitest-agent/sdk";
-import { Effect, FileSystem } from "effect";
-import { dirname, join } from "node:path";
-import { existsSync, readFileSync } from "node:fs";
+import { repositoryUrlOf } from "./package-manifest.js";
+import { gitUrlToProjectKey } from "@vitest-agent/sdk";
+import { Effect, FileSystem, Option, Path, Result } from "effect";
+import { AppDirs } from "@effected/xdg";
+import { join } from "node:path";
+import { Walker } from "@effected/walker";
+import { LenientManifest } from "@effected/package-json";
+import { readFileSync } from "node:fs";
+import { nodeWalkerSyncOps } from "@effected/walker/node-sync";
 
 // src/utils/resolve-project-key-from-cwd.ts
 const PACKAGE_JSON = "package.json";
 const findNearestPackageJson = (startDir) => {
-	let dir = startDir;
-	while (true) {
-		const candidate = join(dir, PACKAGE_JSON);
-		if (existsSync(candidate)) return candidate;
-		const parent = dirname(dir);
-		if (parent === dir) return null;
-		dir = parent;
-	}
-};
-const readRepositoryUrl = (parsed) => {
-	const repo = parsed.repository;
-	if (typeof repo === "string" && repo.trim().length > 0) return repo.trim();
-	if (repo !== null && typeof repo === "object" && "url" in repo && typeof repo.url === "string") {
-		const url = repo.url.trim();
-		return url.length > 0 ? url : null;
-	}
-	return null;
+	const dirs = Walker.ascendSync(startDir, { path: nodeWalkerSyncOps.path });
+	return Option.getOrNull(Walker.findUpwardSync(dirs, (dir) => [join(dir, PACKAGE_JSON)], nodeWalkerSyncOps));
 };
 /**
 * The key a `package.json` body names: the canonical `host__path` form of
 * `repository.url` when present and canonicalizable, else the normalized
-* `name`, else `null` (no usable field, or malformed JSON).
+* `name`, else `null` (no usable field, malformed JSON, or JSON that is not
+* an object).
 */
 const keyFromPackageJson = (content) => {
-	try {
-		const parsed = JSON.parse(content);
-		const repoUrl = readRepositoryUrl(parsed);
-		if (repoUrl !== null) {
-			const key = gitUrlToProjectKey(repoUrl);
-			if (key !== null) return key;
-		}
-		if (typeof parsed.name === "string" && parsed.name.length > 0) return normalizeWorkspaceKey(parsed.name);
-	} catch {}
+	const parsed = LenientManifest.parseResult(content);
+	if (Result.isFailure(parsed)) return null;
+	const manifest = parsed.success;
+	const repoUrl = repositoryUrlOf(manifest.repository);
+	if (repoUrl !== null) {
+		const key = gitUrlToProjectKey(repoUrl);
+		if (key !== null) return key;
+	}
+	if (manifest.name !== void 0) return Result.getOrNull(AppDirs.segment(manifest.name));
 	return null;
 };
 const basenameKey = (cwd) => {
 	const basename = cwd.split("/").filter((segment) => segment.length > 0).pop() ?? "anonymous-project";
-	return normalizeWorkspaceKey(basename);
+	return Result.getOrElse(AppDirs.segment(basename), () => "anonymous-project");
 };
 /**
 * Compute the project key for a workspace by reading `package.json`
@@ -74,7 +65,8 @@ const resolveProjectKeyFromCwd = (cwd) => {
 /**
 * {@link resolveProjectKeyFromCwd} read through the ambient
 * `FileSystem` service instead of `node:fs` — same upward walk to the
-* nearest `package.json`, same precedence, same basename fallback.
+* nearest `package.json` (`@effected/walker`'s `Walker.ascend` +
+* `Walker.findUpward`), same precedence, same basename fallback.
 *
 * Never fails: a filesystem error while probing or reading is treated like
 * a missing or malformed `package.json`, exactly as the synchronous form
@@ -85,17 +77,11 @@ const resolveProjectKeyFromCwd = (cwd) => {
 */
 const resolveProjectKeyFromCwdEffect = (cwd) => Effect.gen(function* () {
 	const fs = yield* FileSystem.FileSystem;
-	let dir = cwd;
-	while (true) {
-		const candidate = join(dir, PACKAGE_JSON);
-		if (yield* fs.exists(candidate).pipe(Effect.orElseSucceed(() => false))) {
-			const content = yield* fs.readFileString(candidate).pipe(Effect.orElseSucceed(() => null));
-			return (content === null ? null : keyFromPackageJson(content)) ?? basenameKey(cwd);
-		}
-		const parent = dirname(dir);
-		if (parent === dir) return basenameKey(cwd);
-		dir = parent;
-	}
-});
+	const dirs = yield* Walker.ascend(cwd);
+	const found = yield* Walker.findUpward(dirs, (dir) => [join(dir, PACKAGE_JSON)]);
+	if (Option.isNone(found)) return basenameKey(cwd);
+	const content = yield* fs.readFileString(found.value).pipe(Effect.orElseSucceed(() => null));
+	return (content === null ? null : keyFromPackageJson(content)) ?? basenameKey(cwd);
+}).pipe(Effect.provide(Path.layer));
 
 export { resolveProjectKeyFromCwd, resolveProjectKeyFromCwdEffect };

package/utils/resolve-workspace-key.js

@@ -1,6 +1,6 @@
-import { normalizeWorkspaceKey } from "@vitest-agent/sdk";
-import { Effect } from "effect";
+import { Effect, Result } from "effect";
 import { WorkspaceDiscovery, WorkspaceRootNotFoundError } from "@effected/workspaces";
+import { AppDirs } from "@effected/xdg";
 
 // src/utils/resolve-workspace-key.ts
 /**
@@ -8,7 +8,8 @@ import { WorkspaceDiscovery, WorkspaceRootNotFoundError } from "@effected/worksp
 * `projectDir`.
 *
 * The key is the root `package.json`'s `name`, normalized via
-* `normalizeWorkspaceKey`. This becomes the directory segment under
+* `@effected/xdg`'s `AppDirs.segment` (a name that maps to `.` or `..` fails
+* with `AppDirsSegmentError`). This becomes the directory segment under
 * `$XDG_DATA_HOME/vitest-agent/` where the SQLite database lives.
 *
 * Fails with `WorkspaceRootNotFoundError` when no root workspace is
@@ -34,7 +35,10 @@ const resolveWorkspaceKey = (projectDir) => Effect.gen(function* () {
 		searchPath: projectDir,
 		markers: []
 	}));
-	return normalizeWorkspaceKey(root.name);
+	return yield* Result.match(AppDirs.segment(root.name), {
+		onSuccess: Effect.succeed,
+		onFailure: Effect.fail
+	});
 });
 
 export { resolveWorkspaceKey };

package/version.js

@@ -1,5 +1,5 @@
 // src/version.ts
 /** Build-time injected package version (see architecture.md D36). @public */
-const CURRENT_ENGINE_VERSION = "2.1.0";
+const CURRENT_ENGINE_VERSION = "3.0.1";
 
 export { CURRENT_ENGINE_VERSION };