@vitest-agent/engine 1.0.6 → 1.1.0

package/index.d.ts

@@ -2648,6 +2648,35 @@ export declare const normalizeAssertionShape: (message: string) => string | null
 /** @public */
 export declare const computeFailureSignature: (input: FailureSignatureInput) => string;
 //#endregion
+//#region src/utils/persist-transaction.d.ts
+/**
+ * Run `effect` as one SQLite write transaction on the `data.db` connection:
+ * every `DataStore` write inside it commits together or not at all, and a
+ * failure rolls the whole block back before the error propagates.
+ *
+ * Built for the reporter's run-end persist phase, where per-statement
+ * autocommits (one fsync each) dominated wall time. Inside the block
+ * `DataStoreLive` caches tag and file ids and defers `writeHistory`'s
+ * keep-10 prune to one statement per run, executed before commit; the
+ * persisted rows are the same as without the block.
+ *
+ * The fiber does not yield to the scheduler while the block runs. node:sqlite
+ * is synchronous, so the whole transaction executes in one turn of the event
+ * loop: a second connection in the same process (another project's reporter,
+ * or the MCP server's own connection while it runs Vitest in-process) can
+ * neither interleave a write nor block the thread in SQLite's busy handler
+ * while this connection holds the write lock. Keep `effect` free of
+ * genuinely asynchronous work for that reason; CPU-heavy work that needs no
+ * database belongs before the block.
+ *
+ * Nested `withTransaction` calls inside `effect` become savepoints. A
+ * `DataReader` query inside it runs on the transaction's connection.
+ *
+ * @param effect - the writes (and the reads they depend on) to run atomically
+ * @public
+ */
+export declare const withPersistTransaction: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | DataStoreError, R | SqlClient>;
+//#endregion
 //#region src/utils/resolve-data-path.d.ts
 /**
  * Filename of the SQLite database that stores all reporter data.

package/index.js

@@ -4,6 +4,7 @@ import { DataReader } from "./services/DataReader.js";
 import { HistoryTracker, historyKey } from "./services/HistoryTracker.js";
 import { DataReaderLive } from "./layers/DataReaderLive.js";
 import { DataStore, INLINE_ATTACHMENT_BODY_CAP_BYTES } from "./services/DataStore.js";
+import { withPersistTransaction } from "./utils/persist-transaction.js";
 import { DataStoreLive } from "./layers/DataStoreLive.js";
 import { DetailResolver } from "./services/DetailResolver.js";
 import { DetailResolverLive } from "./layers/DetailResolverLive.js";
@@ -56,4 +57,4 @@ import { DATABASE_FILENAME, resolveDataPath } from "./utils/resolve-data-path.js
 import { resolveWorkspaceKey } from "./utils/resolve-workspace-key.js";
 import { CURRENT_ENGINE_VERSION } from "./version.js";
 
-export { APP_NAMESPACE, AgentContext, CURRENT_ENGINE_VERSION, ConfigLive, DATABASE_FILENAME, DATA_DB_FILENAME, DATA_FALLBACK_DIR, DataReader, DataReaderLive, DataStore, DataStoreLive, DetailResolver, DetailResolverLive, DiscoveryRegistry, DiscoveryRegistryLive, EnvironmentDetector, EnvironmentDetectorLive, EnvironmentDetectorTest, ExecutorResolver, ExecutorResolverLive, HistoryTracker, HistoryTrackerLive, HistoryTrackerTest, IDEMPOTENCY_ROOT_SENTINEL, INLINE_ATTACHMENT_BODY_CAP_BYTES, LoggerLive, NodePlatformLayer, OutputPipelineLive, PROJECT_MIGRATIONS, PathResolutionLive, PerClientSessionMapReader, PerClientSessionMapReaderLive, PerClientSessionMapWriter, PerClientSessionMapWriterLive, PlatformLive, ProjectDiscovery, ProjectDiscoveryLive, ProjectDiscoveryTest, ProjectIdentity, ProjectIdentityLive, ProjectIdentityTest, REGISTRY_DB_FILENAME, REGISTRY_STORE_OPTIONS, RunContext, RunContext$, RunContextLive, RunContextService, RunContextTest, SESSIONS_DB_FILENAME, SidecarPlatformLive, VitestAgentConfigFile, _resetMigrationCacheForTesting, assembleHistoryRecord, assembleManifest, classifyEnvironment, computeFailureSignature, deriveIdempotencyKey, dispatchRecordTddArtifactEffect, endAgentEffect, ensureMigrated, formatTriageEffect, formatWrapupEffect, historyKey, makeSqliteStack, migration as migration0001, migration$1 as migration0002, normalizeAssertionShape, parseAndValidateTurnPayload, parseSessionEnvExports, recordRunWorkspaceChangesEffect, recordSessionEnd, recordSessionStart, recordTddArtifactByTaskIdEffect, recordTddArtifactEffect, recordTurnEffect, recoverSessionContextFromSessionEnv, registerAgentEffect, migration$2 as registryMigration0001, resolveDataPath, resolveHookPaths, resolveLogFile, resolveLogLevel, resolveProjectDir, resolveProjectIdentityFromCandidates, resolveProjectKeyFromCwd, resolveProjectKeyFromCwdEffect, resolveSessionForRecording, resolveSessionMapPath, resolveWorkspaceKey, migration$3 as sessionMapMigration0001 };
+export { APP_NAMESPACE, AgentContext, CURRENT_ENGINE_VERSION, ConfigLive, DATABASE_FILENAME, DATA_DB_FILENAME, DATA_FALLBACK_DIR, DataReader, DataReaderLive, DataStore, DataStoreLive, DetailResolver, DetailResolverLive, DiscoveryRegistry, DiscoveryRegistryLive, EnvironmentDetector, EnvironmentDetectorLive, EnvironmentDetectorTest, ExecutorResolver, ExecutorResolverLive, HistoryTracker, HistoryTrackerLive, HistoryTrackerTest, IDEMPOTENCY_ROOT_SENTINEL, INLINE_ATTACHMENT_BODY_CAP_BYTES, LoggerLive, NodePlatformLayer, OutputPipelineLive, PROJECT_MIGRATIONS, PathResolutionLive, PerClientSessionMapReader, PerClientSessionMapReaderLive, PerClientSessionMapWriter, PerClientSessionMapWriterLive, PlatformLive, ProjectDiscovery, ProjectDiscoveryLive, ProjectDiscoveryTest, ProjectIdentity, ProjectIdentityLive, ProjectIdentityTest, REGISTRY_DB_FILENAME, REGISTRY_STORE_OPTIONS, RunContext, RunContext$, RunContextLive, RunContextService, RunContextTest, SESSIONS_DB_FILENAME, SidecarPlatformLive, VitestAgentConfigFile, _resetMigrationCacheForTesting, assembleHistoryRecord, assembleManifest, classifyEnvironment, computeFailureSignature, deriveIdempotencyKey, dispatchRecordTddArtifactEffect, endAgentEffect, ensureMigrated, formatTriageEffect, formatWrapupEffect, historyKey, makeSqliteStack, migration as migration0001, migration$1 as migration0002, normalizeAssertionShape, parseAndValidateTurnPayload, parseSessionEnvExports, recordRunWorkspaceChangesEffect, recordSessionEnd, recordSessionStart, recordTddArtifactByTaskIdEffect, recordTddArtifactEffect, recordTurnEffect, recoverSessionContextFromSessionEnv, registerAgentEffect, migration$2 as registryMigration0001, resolveDataPath, resolveHookPaths, resolveLogFile, resolveLogLevel, resolveProjectDir, resolveProjectIdentityFromCandidates, resolveProjectKeyFromCwd, resolveProjectKeyFromCwdEffect, resolveSessionForRecording, resolveSessionMapPath, resolveWorkspaceKey, migration$3 as sessionMapMigration0001, withPersistTransaction };

package/layers/DataStoreLive.js

@@ -1,4 +1,5 @@
 import { DataStore, INLINE_ATTACHMENT_BODY_CAP_BYTES } from "../services/DataStore.js";
+import { PersistBatch } from "../utils/persist-transaction.js";
 import { Agent, AgentNotFoundError, BehaviorNotFoundError, DataStoreError, GoalNotFoundError, IdempotencyHit, IllegalStatusTransitionError, RegistrationConflictError, TddTaskAlreadyEndedError, TddTaskNotFoundError, coerceErrorText, extractSqlReason } from "@vitest-agent/sdk";
 import { Effect, Layer, Option } from "effect";
 import { SqlClient } from "effect/sql/SqlClient";
@@ -37,8 +38,13 @@ const DataStoreLive = Layer.effect(DataStore, Effect.gen(function* () {
 	yield* sql`PRAGMA foreign_keys=ON`.pipe(Effect.catch(() => Effect.void));
 	const ensureFile = (filePath) => Effect.gen(function* () {
 		yield* Effect.logDebug("ensureFile").pipe(Effect.annotateLogs({ filePath }));
+		const batch = yield* PersistBatch;
+		const cached = batch?.fileIds.get(filePath);
+		if (cached !== void 0) return cached;
 		yield* sql`INSERT OR IGNORE INTO files (path) VALUES (${filePath})`;
-		return (yield* sql`SELECT id FROM files WHERE path = ${filePath}`)[0].id;
+		const rows = yield* sql`SELECT id FROM files WHERE path = ${filePath}`;
+		batch?.fileIds.set(filePath, rows[0].id);
+		return rows[0].id;
 	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
 		operation: "write",
 		table: "files",
@@ -110,14 +116,19 @@ const DataStoreLive = Layer.effect(DataStore, Effect.gen(function* () {
 			count: tests.length
 		}));
 		const ids = [];
+		const tagIds = (yield* PersistBatch)?.tagIds ?? /* @__PURE__ */ new Map();
 		for (const tc of tests) {
 			yield* sql`INSERT INTO test_cases (module_id, suite_id, vitest_id, name, full_name, state, classification, duration, start_time, flaky, slow, retry_count, repeat_count, heap, mode, each, fails, concurrent, shuffle, timeout, skip_note, location_line, location_column, created_turn_id) VALUES (${moduleId}, ${tc.suiteId ?? null}, ${tc.vitestId ?? null}, ${tc.name}, ${tc.fullName}, ${tc.state}, ${tc.classification ?? null}, ${tc.duration ?? null}, ${tc.startTime ?? null}, ${boolToInt(tc.flaky)}, ${boolToInt(tc.slow)}, ${tc.retryCount ?? 0}, ${tc.repeatCount ?? 0}, ${tc.heap ?? null}, ${tc.mode ?? null}, ${boolToInt(tc.each)}, ${boolToInt(tc.fails)}, ${boolToInt(tc.concurrent)}, ${boolToInt(tc.shuffle)}, ${tc.timeout ?? null}, ${tc.skipNote ?? null}, ${tc.locationLine ?? null}, ${tc.locationColumn ?? null}, ${tc.createdTurnId ?? null})`;
 			const testCaseId = (yield* sql`SELECT last_insert_rowid() as id`)[0].id;
 			ids.push(testCaseId);
 			if (tc.tags && tc.tags.length > 0) for (const tag of tc.tags) {
-				yield* sql`INSERT OR IGNORE INTO tags (name) VALUES (${tag})`;
-				const tagRows = yield* sql`SELECT id FROM tags WHERE name = ${tag}`;
-				if (tagRows.length > 0) yield* sql`INSERT OR IGNORE INTO test_case_tags (test_case_id, tag_id) VALUES (${testCaseId}, ${tagRows[0].id})`;
+				let tagId = tagIds.get(tag);
+				if (tagId === void 0) {
+					yield* sql`INSERT OR IGNORE INTO tags (name) VALUES (${tag})`;
+					tagId = (yield* sql`SELECT id FROM tags WHERE name = ${tag}`)[0]?.id;
+					if (tagId !== void 0) tagIds.set(tag, tagId);
+				}
+				if (tagId !== void 0) yield* sql`INSERT OR IGNORE INTO test_case_tags (test_case_id, tag_id) VALUES (${testCaseId}, ${tagId})`;
 			}
 		}
 		return ids;
@@ -224,6 +235,11 @@ const DataStoreLive = Layer.effect(DataStore, Effect.gen(function* () {
 			runId
 		}));
 		yield* sql`INSERT INTO test_history (run_id, project, module_path, full_name, timestamp, state, duration, flaky, retry_count, error_message) VALUES (${runId}, ${project}, ${modulePath}, ${fullName}, ${timestamp}, ${state}, ${duration}, ${flaky ? 1 : 0}, ${retryCount}, ${errorMessage}) ON CONFLICT(project, module_path, full_name, timestamp) DO UPDATE SET run_id = excluded.run_id, state = excluded.state, duration = excluded.duration, flaky = excluded.flaky, retry_count = excluded.retry_count, error_message = excluded.error_message`;
+		const batch = yield* PersistBatch;
+		if (batch !== void 0) {
+			batch.historyRunIds.add(runId);
+			return;
+		}
 		yield* sql`DELETE FROM test_history WHERE id NOT IN (SELECT id FROM test_history WHERE project = ${project} AND module_path = ${modulePath} AND full_name = ${fullName} ORDER BY timestamp DESC LIMIT 10) AND project = ${project} AND module_path = ${modulePath} AND full_name = ${fullName}`;
 	}).pipe(Effect.annotateLogs("service", "DataStore"), Effect.mapError((e) => new DataStoreError({
 		operation: "write",

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vitest-agent/engine",
-	"version": "1.0.6",
+	"version": "1.1.0",
 	"private": false,
 	"description": "Shared services, layers, SQLite data layer, migrations and platform resolution for the vitest-agent CLI and MCP server.",
 	"keywords": [

package/platform.js

@@ -6,7 +6,8 @@ import { OutputPipelineLive } from "./layers/OutputPipelineLive.js";
 import { ProjectDiscoveryLive } from "./layers/ProjectDiscoveryLive.js";
 import { PROJECT_MIGRATIONS } from "./migrations/index.js";
 import { LEDGER_OPTIONS, toStoreMigrations } from "./stores.js";
-import { Effect, Layer } from "effect";
+import { Context, Effect, Layer } from "effect";
+import { SqlClient } from "effect/sql/SqlClient";
 import * as NodeServices from "@effect/platform-node/NodeServices";
 import { layer } from "@effect/sql-sqlite-node/SqliteClient";
 import { Store } from "@effected/store";
@@ -31,7 +32,7 @@ const NodePlatformLayer = NodeServices.layer;
 * @public
 */
 const makeSqliteStack = (filename, migrations = PROJECT_MIGRATIONS) => {
-	const SqliteLayer = layer({ filename });
+	const SqliteLayer = layer({ filename }).pipe(Layer.tap((context) => Context.get(context, SqlClient)`PRAGMA synchronous = NORMAL`));
 	return {
 		SqliteLayer,
 		MigratorLayer: Layer.effectDiscard(Effect.void).pipe(Layer.provide(Store.layer({

package/utils/persist-transaction.js

@@ -0,0 +1,85 @@
+import { DataStoreError, extractSqlReason } from "@vitest-agent/sdk";
+import { Context, Effect, References } from "effect";
+import { SqlClient } from "effect/sql/SqlClient";
+import { isSqlError } from "effect/sql/SqlError";
+
+//#region src/utils/persist-transaction.ts
+/**
+* The open persist batch, or `undefined` outside {@link withPersistTransaction}.
+* Read by `DataStoreLive`; not part of the public surface.
+*
+* @internal
+*/
+const PersistBatch = Context.Reference("@vitest-agent/engine/PersistBatch", { defaultValue: () => void 0 });
+/** Matches the per-write window `DataStoreLive.writeHistory` keeps outside a batch. */
+const HISTORY_WINDOW = 10;
+/**
+* Keep the newest {@link HISTORY_WINDOW} rows of every
+* `(project, module_path, full_name)` series that has a row from `runId`,
+* in one statement. The same rows the per-write prune deletes: a series is
+* unique on `(project, module_path, full_name, timestamp)`, so there are no
+* timestamp ties for `ROW_NUMBER` to break arbitrarily, and every series
+* this run wrote carries `run_id = runId` (the upsert overwrites it).
+*/
+const pruneHistoryForRun = (sql, runId) => sql`DELETE FROM test_history WHERE id IN (
+		SELECT id FROM (
+			SELECT h.id, ROW_NUMBER() OVER (
+				PARTITION BY h.project, h.module_path, h.full_name
+				ORDER BY h.timestamp DESC
+			) AS rn
+			FROM test_history h
+			JOIN (
+				SELECT DISTINCT project, module_path, full_name FROM test_history WHERE run_id = ${runId}
+			) a ON a.project = h.project AND a.module_path = h.module_path AND a.full_name = h.full_name
+		) WHERE rn > ${HISTORY_WINDOW}
+	)`;
+/**
+* Run `effect` as one SQLite write transaction on the `data.db` connection:
+* every `DataStore` write inside it commits together or not at all, and a
+* failure rolls the whole block back before the error propagates.
+*
+* Built for the reporter's run-end persist phase, where per-statement
+* autocommits (one fsync each) dominated wall time. Inside the block
+* `DataStoreLive` caches tag and file ids and defers `writeHistory`'s
+* keep-10 prune to one statement per run, executed before commit; the
+* persisted rows are the same as without the block.
+*
+* The fiber does not yield to the scheduler while the block runs. node:sqlite
+* is synchronous, so the whole transaction executes in one turn of the event
+* loop: a second connection in the same process (another project's reporter,
+* or the MCP server's own connection while it runs Vitest in-process) can
+* neither interleave a write nor block the thread in SQLite's busy handler
+* while this connection holds the write lock. Keep `effect` free of
+* genuinely asynchronous work for that reason; CPU-heavy work that needs no
+* database belongs before the block.
+*
+* Nested `withTransaction` calls inside `effect` become savepoints. A
+* `DataReader` query inside it runs on the transaction's connection.
+*
+* @param effect - the writes (and the reads they depend on) to run atomically
+* @public
+*/
+const withPersistTransaction = (effect) => Effect.gen(function* () {
+	const sql = yield* SqlClient;
+	const batch = {
+		historyRunIds: /* @__PURE__ */ new Set(),
+		tagIds: /* @__PURE__ */ new Map(),
+		fileIds: /* @__PURE__ */ new Map()
+	};
+	return yield* sql.withTransaction(Effect.gen(function* () {
+		const result = yield* effect.pipe(Effect.provideService(PersistBatch, batch));
+		for (const runId of batch.historyRunIds) yield* pruneHistoryForRun(sql, runId).pipe(Effect.mapError((e) => new DataStoreError({
+			operation: "write",
+			table: "test_history",
+			reason: extractSqlReason(e)
+		})));
+		return result;
+	}));
+}).pipe(Effect.provideService(References.PreventSchedulerYield, true), Effect.catchIf(isSqlError, (e) => Effect.fail(new DataStoreError({
+	operation: "write",
+	table: "transaction",
+	reason: extractSqlReason(e)
+}))));
+
+//#endregion
+export { PersistBatch, withPersistTransaction };

package/version.js

@@ -1,6 +1,6 @@
 //#region src/version.ts
 /** Build-time injected package version (see architecture.md D36). @public */
-const CURRENT_ENGINE_VERSION = "1.0.6";
+const CURRENT_ENGINE_VERSION = "1.1.0";
 
 //#endregion
 export { CURRENT_ENGINE_VERSION };