@vitest-agent/sdk 1.0.0

package/schemas/Thresholds.js

@@ -0,0 +1,30 @@
+import { Schema } from "effect";
+
+//#region src/schemas/Thresholds.ts
+/**
+* Per-metric threshold values. All optional -- only set metrics are enforced.
+* @public
+*/
+const MetricThresholds = Schema.Struct({
+	lines: Schema.optional(Schema.Number),
+	functions: Schema.optional(Schema.Number),
+	branches: Schema.optional(Schema.Number),
+	statements: Schema.optional(Schema.Number)
+}).annotations({ identifier: "MetricThresholds" });
+/**
+* A glob pattern paired with its metric thresholds.
+* @public
+*/
+const PatternThresholds = Schema.Tuple(Schema.String, MetricThresholds).annotations({ identifier: "PatternThresholds" });
+/**
+* Fully resolved thresholds ready for evaluation.
+* @public
+*/
+const ResolvedThresholds = Schema.Struct({
+	global: MetricThresholds,
+	perFile: Schema.optionalWith(Schema.Boolean, { default: () => false }),
+	patterns: Schema.optionalWith(Schema.Array(PatternThresholds), { default: () => [] })
+}).annotations({ identifier: "ResolvedThresholds" });
+
+//#endregion
+export { MetricThresholds, PatternThresholds, ResolvedThresholds };

package/schemas/Transport.js

@@ -0,0 +1,16 @@
+import { Schema } from "effect";
+
+//#region src/schemas/Transport.ts
+/**
+* Transport binding for the persistence layer.
+*
+* 2.x ships only `{ kind: "local" }`. Modeled as a single-member
+* discriminated union so the 3.0 cloud-backend swap (D1, Turso, etc.)
+* lands as a pure addition of new union members — no schema-shape
+* diff and no breaking API change at the call site.
+* @public
+*/
+const Transport = Schema.Union(Schema.Struct({ kind: Schema.Literal("local") })).annotations({ identifier: "Transport" });
+
+//#endregion
+export { Transport };

package/schemas/Trends.js

@@ -0,0 +1,23 @@
+import { CoverageTotals } from "./Coverage.js";
+import { Schema } from "effect";
+
+//#region src/schemas/Trends.ts
+/**
+* A single coverage trend data point recorded on a full test run.
+* @public
+*/
+const TrendEntry = Schema.Struct({
+	timestamp: Schema.String,
+	coverage: CoverageTotals,
+	delta: CoverageTotals,
+	direction: Schema.Literal("improving", "regressing", "stable"),
+	targetsHash: Schema.optional(Schema.String)
+}).annotations({ identifier: "TrendEntry" });
+/**
+* Per-project trend record with sliding window of entries.
+* @public
+*/
+const TrendRecord = Schema.Struct({ entries: Schema.Array(TrendEntry) }).annotations({ identifier: "TrendRecord" });
+
+//#endregion
+export { TrendEntry, TrendRecord };

package/schemas/turns/FileEditPayload.js

@@ -0,0 +1,15 @@
+import { Schema } from "effect";
+
+//#region src/schemas/turns/FileEditPayload.ts
+/** @public */
+const FileEditPayload = Schema.Struct({
+	type: Schema.Literal("file_edit"),
+	file_path: Schema.String,
+	edit_kind: Schema.Literal("write", "edit", "multi_edit"),
+	lines_added: Schema.optional(Schema.Number),
+	lines_removed: Schema.optional(Schema.Number),
+	diff: Schema.optional(Schema.String)
+});
+
+//#endregion
+export { FileEditPayload };

package/schemas/turns/HookFirePayload.js

@@ -0,0 +1,13 @@
+import { Schema } from "effect";
+
+//#region src/schemas/turns/HookFirePayload.ts
+/** @public */
+const HookFirePayload = Schema.Struct({
+	type: Schema.Literal("hook_fire"),
+	hook_kind: Schema.Literal("SessionStart", "SessionEnd", "Stop", "StopFailure", "SubagentStart", "SubagentStop", "PreCompact", "PostCompact", "PreToolUse", "PostToolUse", "PostToolUseFailure", "UserPromptSubmit", "FileChanged"),
+	chat_id: Schema.optional(Schema.String),
+	previous_record_failures: Schema.optional(Schema.Array(Schema.String))
+});
+
+//#endregion
+export { HookFirePayload };

package/schemas/turns/HypothesisPayload.js

@@ -0,0 +1,13 @@
+import { Schema } from "effect";
+
+//#region src/schemas/turns/HypothesisPayload.ts
+/** @public */
+const HypothesisPayload = Schema.Struct({
+	type: Schema.Literal("hypothesis"),
+	content: Schema.String,
+	cited_test_error_id: Schema.optional(Schema.Number),
+	cited_stack_frame_id: Schema.optional(Schema.Number)
+});
+
+//#endregion
+export { HypothesisPayload };

package/schemas/turns/NotePayload.js

@@ -0,0 +1,13 @@
+import { Schema } from "effect";
+
+//#region src/schemas/turns/NotePayload.ts
+/** @public */
+const NotePayload = Schema.Struct({
+	type: Schema.Literal("note"),
+	scope: Schema.String,
+	title: Schema.optional(Schema.String),
+	content: Schema.String
+});
+
+//#endregion
+export { NotePayload };

package/schemas/turns/ToolCallPayload.js

@@ -0,0 +1,13 @@
+import { Schema } from "effect";
+
+//#region src/schemas/turns/ToolCallPayload.ts
+/** @public */
+const ToolCallPayload = Schema.Struct({
+	type: Schema.Literal("tool_call"),
+	tool_name: Schema.String,
+	tool_input: Schema.Unknown,
+	tool_use_id: Schema.optional(Schema.String)
+});
+
+//#endregion
+export { ToolCallPayload };

package/schemas/turns/ToolResultPayload.js

@@ -0,0 +1,15 @@
+import { Schema } from "effect";
+
+//#region src/schemas/turns/ToolResultPayload.ts
+/** @public */
+const ToolResultPayload = Schema.Struct({
+	type: Schema.Literal("tool_result"),
+	tool_name: Schema.String,
+	tool_use_id: Schema.optional(Schema.String),
+	result_summary: Schema.optional(Schema.String),
+	success: Schema.Boolean,
+	duration_ms: Schema.optional(Schema.Number)
+});
+
+//#endregion
+export { ToolResultPayload };

package/schemas/turns/UserPromptPayload.js

@@ -0,0 +1,12 @@
+import { Schema } from "effect";
+
+//#region src/schemas/turns/UserPromptPayload.ts
+/** @public */
+const UserPromptPayload = Schema.Struct({
+	type: Schema.Literal("user_prompt"),
+	prompt: Schema.String,
+	cc_message_id: Schema.optional(Schema.String)
+});
+
+//#endregion
+export { UserPromptPayload };

package/schemas/turns/index.js

@@ -0,0 +1,15 @@
+import { FileEditPayload } from "./FileEditPayload.js";
+import { HookFirePayload } from "./HookFirePayload.js";
+import { HypothesisPayload } from "./HypothesisPayload.js";
+import { NotePayload } from "./NotePayload.js";
+import { ToolCallPayload } from "./ToolCallPayload.js";
+import { ToolResultPayload } from "./ToolResultPayload.js";
+import { UserPromptPayload } from "./UserPromptPayload.js";
+import { Schema } from "effect";
+
+//#region src/schemas/turns/index.ts
+/** @public */
+const TurnPayload = Schema.Union(UserPromptPayload, ToolCallPayload, ToolResultPayload, FileEditPayload, HookFirePayload, NotePayload, HypothesisPayload);
+
+//#endregion
+export { TurnPayload };

package/services/Config.js

@@ -0,0 +1,15 @@
+import { ConfigFile } from "config-file-effect";
+
+//#region src/services/Config.ts
+/**
+* Typed `Context.Tag` for the vitest-agent config file service.
+*
+* Both runtime packages (reporter, MCP) yield this tag to access the loaded
+* `VitestAgentConfig`. The live layer is built per `projectDir` via
+* `ConfigLive(projectDir)`.
+* @public
+*/
+const VitestAgentConfigFile = ConfigFile.Tag("vitest-agent/Config");
+
+//#endregion
+export { VitestAgentConfigFile };

package/services/DataReader.js

@@ -0,0 +1,8 @@
+import { Context } from "effect";
+
+//#region src/services/DataReader.ts
+/** @public */
+var DataReader = class extends Context.Tag("vitest-agent/DataReader")() {};
+
+//#endregion
+export { DataReader };

package/services/DataStore.js

@@ -0,0 +1,8 @@
+import { Context } from "effect";
+
+//#region src/services/DataStore.ts
+/** @public */
+var DataStore = class extends Context.Tag("vitest-agent/DataStore")() {};
+
+//#endregion
+export { DataStore };

package/services/DetailResolver.js

@@ -0,0 +1,8 @@
+import { Context } from "effect";
+
+//#region src/services/DetailResolver.ts
+/** @public */
+var DetailResolver = class extends Context.Tag("vitest-agent/DetailResolver")() {};
+
+//#endregion
+export { DetailResolver };

package/services/DiscoveryRegistry.js

@@ -0,0 +1,8 @@
+import { Context } from "effect";
+
+//#region src/services/DiscoveryRegistry.ts
+/** @public */
+var DiscoveryRegistry = class extends Context.Tag("vitest-agent/DiscoveryRegistry")() {};
+
+//#endregion
+export { DiscoveryRegistry };

package/services/EnvironmentDetector.js

@@ -0,0 +1,8 @@
+import { Context } from "effect";
+
+//#region src/services/EnvironmentDetector.ts
+/** @public */
+var EnvironmentDetector = class extends Context.Tag("vitest-agent/EnvironmentDetector")() {};
+
+//#endregion
+export { EnvironmentDetector };

package/services/ExecutorResolver.js

@@ -0,0 +1,8 @@
+import { Context } from "effect";
+
+//#region src/services/ExecutorResolver.ts
+/** @public */
+var ExecutorResolver = class extends Context.Tag("vitest-agent/ExecutorResolver")() {};
+
+//#endregion
+export { ExecutorResolver };

package/services/FormatSelector.js

@@ -0,0 +1,8 @@
+import { Context } from "effect";
+
+//#region src/services/FormatSelector.ts
+/** @public */
+var FormatSelector = class extends Context.Tag("vitest-agent/FormatSelector")() {};
+
+//#endregion
+export { FormatSelector };

package/services/HistoryTracker.js

@@ -0,0 +1,8 @@
+import { Context } from "effect";
+
+//#region src/services/HistoryTracker.ts
+/** @public */
+var HistoryTracker = class extends Context.Tag("vitest-agent/HistoryTracker")() {};
+
+//#endregion
+export { HistoryTracker };

package/services/OutputRenderer.js

@@ -0,0 +1,8 @@
+import { Context } from "effect";
+
+//#region src/services/OutputRenderer.ts
+/** @public */
+var OutputRenderer = class extends Context.Tag("vitest-agent/OutputRenderer")() {};
+
+//#endregion
+export { OutputRenderer };

package/services/PerClientSessionMap.js

@@ -0,0 +1,22 @@
+import { Context } from "effect";
+
+//#region src/services/PerClientSessionMap.ts
+/**
+* Read-only side of the session map.
+*
+* Provided by `PerClientSessionMapReaderLive` (opens SQLite with
+* `?mode=ro`). MCP server depends on this tag — calls to write
+* methods would be a type error.
+* @public
+*/
+var PerClientSessionMapReader = class extends Context.Tag("vitest-agent/PerClientSessionMapReader")() {};
+/**
+* Read-write side of the session map. Sidecar provides this; the
+* Writer layer also satisfies the Reader tag so consumers of either
+* one resolve.
+* @public
+*/
+var PerClientSessionMapWriter = class extends Context.Tag("vitest-agent/PerClientSessionMapWriter")() {};
+
+//#endregion
+export { PerClientSessionMapReader, PerClientSessionMapWriter };

package/services/ProjectDiscovery.js

@@ -0,0 +1,8 @@
+import { Context } from "effect";
+
+//#region src/services/ProjectDiscovery.ts
+/** @public */
+var ProjectDiscovery = class extends Context.Tag("vitest-agent/ProjectDiscovery")() {};
+
+//#endregion
+export { ProjectDiscovery };

package/services/ProjectIdentity.js

@@ -0,0 +1,63 @@
+import { canonicalizeGitUrl, gitUrlToProjectKey } from "../utils/canonicalize-git-url.js";
+import { normalizeWorkspaceKey } from "../utils/normalize-workspace-key.js";
+import { Context } from "effect";
+
+//#region src/services/ProjectIdentity.ts
+const isUseful = (value) => value !== void 0 && value.trim().length > 0;
+/**
+* Pure priority resolver. Returns `null` when no candidate produces a
+* usable value — the caller wraps `null` into a tagged error.
+*
+* For non-git sources the `canonicalForm` equals the original
+* (un-normalized) input so the discovery registry can display
+* `@spencerbeggs/vitest-agent` rather than the underscored form. For
+* git sources, `canonicalForm` is the slash-preserving `host/path`
+* shape from `canonicalizeGitUrl`.
+* @public
+*/
+const resolveProjectIdentityFromCandidates = (candidates) => {
+	if (isUseful(candidates.explicit)) return {
+		projectKey: normalizeWorkspaceKey(candidates.explicit),
+		canonicalForm: candidates.explicit,
+		source: "explicit"
+	};
+	if (isUseful(candidates.toml)) return {
+		projectKey: normalizeWorkspaceKey(candidates.toml),
+		canonicalForm: candidates.toml,
+		source: "toml"
+	};
+	if (isUseful(candidates.gitRemote)) {
+		const canonical = canonicalizeGitUrl(candidates.gitRemote);
+		const key = gitUrlToProjectKey(candidates.gitRemote);
+		if (canonical !== null && key !== null) return {
+			projectKey: key,
+			canonicalForm: canonical,
+			source: "git-remote"
+		};
+	}
+	if (isUseful(candidates.packageJsonRepoUrl)) {
+		const canonical = canonicalizeGitUrl(candidates.packageJsonRepoUrl);
+		const key = gitUrlToProjectKey(candidates.packageJsonRepoUrl);
+		if (canonical !== null && key !== null) return {
+			projectKey: key,
+			canonicalForm: canonical,
+			source: "package-repository"
+		};
+	}
+	if (isUseful(candidates.packageJsonName)) return {
+		projectKey: normalizeWorkspaceKey(candidates.packageJsonName),
+		canonicalForm: candidates.packageJsonName,
+		source: "package-name"
+	};
+	return null;
+};
+/**
+* Service tag. The Live layer (in `layers/ProjectIdentityLive.ts`)
+* wires up the I/O sources; tests provide a stub that returns a
+* pre-built `ResolvedIdentity`.
+* @public
+*/
+var ProjectIdentity = class extends Context.Tag("vitest-agent/ProjectIdentity")() {};
+
+//#endregion
+export { ProjectIdentity, resolveProjectIdentityFromCandidates };

package/services/RunContext.js

@@ -0,0 +1,53 @@
+import { Context, Schema } from "effect";
+
+//#region src/services/RunContext.ts
+/**
+* Per-run snapshot of the workspace's git state and host context.
+* Every field is nullable: a non-git workspace has all-NULL git
+* fields, a CI run with no terminal probe match has all-NULL host
+* fields, and a worker that can't read upstream info has a NULL
+* `gitUpstream` while everything else is set.
+*
+* Declared as a `Schema.Class` so callers can `new RunContext({...})`
+* and `Schema.encode(...)` for the SQLite row mapping.
+* @public
+*/
+var RunContext = class extends Schema.Class("vitest-agent/RunContext")({
+	gitBranch: Schema.NullOr(Schema.String),
+	gitCommitSha: Schema.NullOr(Schema.String),
+	gitDirty: Schema.NullOr(Schema.Boolean),
+	gitUpstream: Schema.NullOr(Schema.String),
+	gitWorktreeDir: Schema.NullOr(Schema.String),
+	hostSource: Schema.NullOr(Schema.String),
+	hostValue: Schema.NullOr(Schema.String),
+	hostMetadata: Schema.NullOr(Schema.Unknown)
+}) {};
+/**
+* Subset of {@link RunContext} captured at agent registration. Only
+* the inheritable git context — branch, sha, worktree path. Mid-run
+* dirty-tree state and upstream tracking are per-run concerns.
+* @public
+*/
+var AgentContext = class extends Schema.Class("vitest-agent/AgentContext")({
+	startGitBranch: Schema.NullOr(Schema.String),
+	startGitCommitSha: Schema.NullOr(Schema.String),
+	startWorktreeDir: Schema.NullOr(Schema.String)
+}) {};
+/**
+* Service tag. The Live layer captures real I/O; the Test layer
+* returns whatever the test fixture passes.
+* @public
+*/
+var RunContext$ = class extends Context.Tag("vitest-agent/RunContextService")() {};
+/**
+* Re-export the service tag under a less-collision-prone name. The
+* `RunContext` Schema.Class above shares its symbol-name with the
+* service tag concept; the `$` suffix on the Context.Tag class name
+* keeps both addressable from the same module.
+*
+* @public
+*/
+const RunContextService = RunContext$;
+
+//#endregion
+export { AgentContext, RunContext, RunContext$, RunContextService };

package/services/idempotency.js

@@ -0,0 +1,57 @@
+import { createHash } from "node:crypto";
+
+//#region src/services/idempotency.ts
+/**
+* Sentinel substituted for `parentAgentId` when the value is `null`.
+* Avoids ambiguity around hashing the literal string "null" or empty
+* string, both of which could collide with caller-supplied values.
+* @public
+*/
+const IDEMPOTENCY_ROOT_SENTINEL = "__ROOT__";
+/**
+* Derive the canonical idempotency key for an `agents` row.
+*
+* Algorithm:
+*   sha256(agentType + "|" + (parentAgentId ?? "__ROOT__") + "|" + clientNonce)
+*   then base32 (RFC 4648 alphabet, lowercased) truncated to 26 chars.
+*
+* 26 base32 chars = 130 bits, far beyond the birthday-bound for the
+* scoping (UNIQUE per session). The base32 alphabet is a-z2-7 — all
+* lowercase to keep the column lexicographically friendly and
+* case-insensitive on filesystems that we never hit but might in
+* future debugging.
+* @public
+*/
+const deriveIdempotencyKey = (input) => {
+	const parent = input.parentAgentId ?? "__ROOT__";
+	const message = `${input.agentType}|${parent}|${input.clientNonce}`;
+	return base32Encode(createHash("sha256").update(message).digest()).slice(0, 26);
+};
+const BASE32_ALPHABET = "abcdefghijklmnopqrstuvwxyz234567";
+/**
+* RFC 4648 base32 encoder, lowercase, no padding. Produces ceil(8n/5)
+* characters from an `n`-byte input. SHA-256 output (32 bytes) yields
+* 52 base32 chars; the caller truncates to 26.
+*/
+const base32Encode = (bytes) => {
+	let output = "";
+	let buffer = 0;
+	let bitsInBuffer = 0;
+	for (const byte of bytes) {
+		buffer = buffer << 8 | byte;
+		bitsInBuffer += 8;
+		while (bitsInBuffer >= 5) {
+			bitsInBuffer -= 5;
+			const index = buffer >> bitsInBuffer & 31;
+			output += BASE32_ALPHABET[index];
+		}
+	}
+	if (bitsInBuffer > 0) {
+		const index = buffer << 5 - bitsInBuffer & 31;
+		output += BASE32_ALPHABET[index];
+	}
+	return output;
+};
+
+//#endregion
+export { IDEMPOTENCY_ROOT_SENTINEL, deriveIdempotencyKey };

package/sidecar-dispatch.js

@@ -0,0 +1,84 @@
+import { exitCodeForTag } from "./exit-code-for-tag.js";
+import { injectEnv } from "./internal-inject-env.js";
+
+//#region src/sidecar-dispatch.ts
+/**
+* Parse `--flag value` pairs from an argv slice into a plain record.
+* Bare tokens and unknown shapes are ignored — the subcommand handlers
+* read only the flags they expect.
+*/
+const parseFlags = (argv) => {
+	const flags = {};
+	for (let i = 0; i < argv.length; i += 1) {
+		const token = argv[i];
+		if (token?.startsWith("--")) {
+			const key = token.slice(2);
+			const next = argv[i + 1];
+			if (next !== void 0 && !next.startsWith("--")) {
+				flags[key] = next;
+				i += 1;
+			} else flags[key] = "";
+		}
+	}
+	return flags;
+};
+const tagFromError = (err) => {
+	if (err !== null && typeof err === "object" && "_tag" in err && typeof err._tag === "string") return err._tag;
+	return "Defect";
+};
+const messageFromError = (err) => {
+	if (err instanceof Error) return err.message;
+	if (err !== null && typeof err === "object") {
+		const e = err;
+		if (typeof e.reason === "string") return e.reason;
+		if (typeof e.message === "string") return e.message;
+	}
+	return String(err ?? "unknown error");
+};
+/**
+* Dispatch one argv invocation. `argv` is the post-`node post-bin`
+* slice — i.e. `process.argv.slice(2)`. Never throws: every failure is
+* folded into the returned {@link DispatchResult}.
+* @public
+*/
+const dispatch = async (argv) => {
+	const subcommand = argv[0];
+	const rest = argv.slice(1);
+	if (subcommand === "inject-env") {
+		const flags = parseFlags(rest);
+		const command = flags.command;
+		const cwd = flags.cwd ?? process.cwd();
+		if (command === void 0) return {
+			stdout: "",
+			stderr: `${exitCodeForTag("Defect")} Defect: inject-env requires --command\n`,
+			code: exitCodeForTag("Defect")
+		};
+		try {
+			return {
+				stdout: `${injectEnv({
+					command,
+					cwd,
+					env: process.env
+				})}\n`,
+				stderr: "",
+				code: 0
+			};
+		} catch (err) {
+			const tag = tagFromError(err);
+			return {
+				stdout: "",
+				stderr: `${exitCodeForTag(tag)} ${tag}: ${messageFromError(err)}\n`,
+				code: exitCodeForTag(tag)
+			};
+		}
+	}
+	const label = subcommand ?? "(none)";
+	return {
+		stdout: "",
+		stderr: `${exitCodeForTag("Defect")} Defect: unknown subcommand: ${label}\n`,
+		code: exitCodeForTag("Defect")
+	};
+};
+
+//#endregion
+export { dispatch };

package/sql/assemblers.js

@@ -0,0 +1,59 @@
+//#region src/sql/assemblers.ts
+/**
+* Builds a `CacheManifest` from an array of test_runs aggregation rows.
+*
+* Each row represents the latest run for a project/sub_project pair.
+* The `dbPath` is stored as `cacheDir` so CLI tools can locate the source.
+* @public
+*/
+function assembleManifest(rows, dbPath) {
+	return {
+		updatedAt: rows.reduce((latest, row) => {
+			return row.timestamp > latest ? row.timestamp : latest;
+		}, (/* @__PURE__ */ new Date(0)).toISOString()),
+		cacheDir: dbPath,
+		projects: rows.map((row) => {
+			const projectName = row.sub_project ? `${row.project}:${row.sub_project}` : row.project;
+			const safeProjectName = projectName.replace(/[^a-z0-9@._-]/gi, "_");
+			const reportFile = `sql:reports/${safeProjectName}.json`;
+			const historyFile = `sql:history/${safeProjectName}.history.json`;
+			const lastResult = (() => {
+				if (row.reason === "passed" || row.reason === "failed" || row.reason === "interrupted") return row.reason;
+				return null;
+			})();
+			return {
+				project: projectName,
+				reportFile,
+				historyFile,
+				lastRun: row.timestamp,
+				lastResult
+			};
+		})
+	};
+}
+/**
+* Groups test_history rows by `full_name` into a keyed record.
+*
+* Returns `Record<fullName, { runs: TestRun[] }>` where `runs` are the
+* accumulated test runs for that test, in the order they appear in `rows`.
+*
+* Only rows with state `"passed"` or `"failed"` are included in runs
+* (matching the `TestRun` schema constraint).
+* @public
+*/
+function assembleHistoryRecord(rows) {
+	const record = {};
+	for (const row of rows) {
+		const state = row.state === "passed" || row.state === "failed" ? row.state : null;
+		if (state === null) continue;
+		if (!record[row.full_name]) record[row.full_name] = { runs: [] };
+		record[row.full_name].runs.push({
+			timestamp: row.timestamp,
+			state
+		});
+	}
+	return record;
+}
+
+//#endregion
+export { assembleHistoryRecord, assembleManifest };