@vitest-agent/sdk 1.0.0

package/testing/layers.js

@@ -0,0 +1,21 @@
+import { DataReaderLive } from "../layers/DataReaderLive.js";
+import { DataStoreLive } from "../layers/DataStoreLive.js";
+import migration from "../migrations/0001_initial.js";
+import { Layer } from "effect";
+import * as NodeContext from "@effect/platform-node/NodeContext";
+import { layer } from "@effect/sql-sqlite-node/SqliteClient";
+import * as SqliteMigrator from "@effect/sql-sqlite-node/SqliteMigrator";
+
+//#region src/testing/layers.ts
+/** @public */
+function makeTestLayer(filename) {
+	const SqliteLayer = layer({ filename });
+	const PlatformLayer = NodeContext.layer;
+	const MigratorLayer = SqliteMigrator.layer({ loader: SqliteMigrator.fromRecord({ "0001_initial": migration }) }).pipe(Layer.provide(Layer.merge(SqliteLayer, PlatformLayer)));
+	return Layer.mergeAll(DataStoreLive.pipe(Layer.provide(SqliteLayer)), DataReaderLive.pipe(Layer.provide(SqliteLayer)), MigratorLayer, SqliteLayer, PlatformLayer);
+}
+/** @public */
+const DataStoreTestLayer = makeTestLayer(":memory:");
+
+//#endregion
+export { DataStoreTestLayer, makeTestLayer };

package/testing.d.ts

@@ -0,0 +1,25 @@
+import { Ft as IllegalStatusTransitionError, It as TddTaskAlreadyEndedError, Lt as TddTaskEndOutcome, Mt as BehaviorNotFoundError, Nt as GoalNotFoundError, Pt as IllegalStatusTransitionEntity, Rt as TddTaskNotFoundError, a as DataReader, j as DataStore, zt as DataStoreError } from "./DataReader-2kJ9I9Hh.js";
+import { Layer } from "effect";
+import * as NodeContext from "@effect/platform-node/NodeContext";
+import * as SqliteMigrator from "@effect/sql-sqlite-node/SqliteMigrator";
+
+//#region src/testing/layers.d.ts
+/** @public */
+declare function makeTestLayer(filename: string): Layer.Layer<DataStore | import("@effect/sql/SqlClient").SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient | DataReader | NodeContext.NodeContext, import("effect/ConfigError").ConfigError | import("@effect/sql/SqlError").SqlError | SqliteMigrator.MigrationError, never>;
+/** @public */
+declare const DataStoreTestLayer: Layer.Layer<DataStore | import("@effect/sql/SqlClient").SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient | DataReader | NodeContext.NodeContext, import("effect/ConfigError").ConfigError | import("@effect/sql/SqlError").SqlError | SqliteMigrator.MigrationError, never>;
+//#endregion
+//#region src/testing/index.d.ts
+/** @public */
+declare function empty(filename: string): Layer.Layer<DataStore | import("@effect/sql/SqlClient").SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient | DataReader | import("@effect/platform-node/NodeContext").NodeContext, import("effect/ConfigError").ConfigError | import("@effect/sql/SqlError").SqlError | import("@effect/sql/Migrator").MigrationError, never>;
+/** @public */
+declare function singlePassingRun(filename: string): Layer.Layer<DataStore | import("@effect/sql/SqlClient").SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient | DataReader | import("@effect/platform-node/NodeContext").NodeContext, import("effect/ConfigError").ConfigError | import("@effect/sql/SqlError").SqlError | import("@effect/sql/Migrator").MigrationError | DataStoreError, never>;
+/** @public */
+declare function withFailures(filename: string): Layer.Layer<DataStore | import("@effect/sql/SqlClient").SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient | DataReader | import("@effect/platform-node/NodeContext").NodeContext, import("effect/ConfigError").ConfigError | import("@effect/sql/SqlError").SqlError | import("@effect/sql/Migrator").MigrationError | DataStoreError, never>;
+/** @public */
+declare function flaky(filename: string): Layer.Layer<DataStore | import("@effect/sql/SqlClient").SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient | DataReader | import("@effect/platform-node/NodeContext").NodeContext, import("effect/ConfigError").ConfigError | import("@effect/sql/SqlError").SqlError | import("@effect/sql/Migrator").MigrationError | DataStoreError, never>;
+/** @public */
+declare function withTddTask(filename: string): Layer.Layer<DataStore | import("@effect/sql/SqlClient").SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient | DataReader | import("@effect/platform-node/NodeContext").NodeContext, import("effect/ConfigError").ConfigError | import("@effect/sql/SqlError").SqlError | import("@effect/sql/Migrator").MigrationError | DataStoreError | TddTaskNotFoundError | TddTaskAlreadyEndedError | GoalNotFoundError | IllegalStatusTransitionError | BehaviorNotFoundError, never>;
+//#endregion
+export { BehaviorNotFoundError, DataReader, DataStore, DataStoreError, DataStoreTestLayer, GoalNotFoundError, type IllegalStatusTransitionEntity, IllegalStatusTransitionError, TddTaskAlreadyEndedError, type TddTaskEndOutcome, TddTaskNotFoundError, empty, flaky, makeTestLayer, singlePassingRun, withFailures, withTddTask };
+//# sourceMappingURL=testing.d.ts.map

package/testing.js

@@ -0,0 +1,243 @@
+import { DataStoreError } from "./errors/DataStoreError.js";
+import { BehaviorNotFoundError, GoalNotFoundError, IllegalStatusTransitionError, TddTaskAlreadyEndedError, TddTaskNotFoundError } from "./errors/TddErrors.js";
+import { DataReader } from "./services/DataReader.js";
+import { DataStore } from "./services/DataStore.js";
+import { DataStoreTestLayer, makeTestLayer } from "./testing/layers.js";
+import { Effect, Layer } from "effect";
+
+//#region src/testing/index.ts
+/** @public */
+function empty(filename) {
+	return makeTestLayer(filename);
+}
+/** @public */
+function singlePassingRun(filename) {
+	const base = makeTestLayer(filename);
+	const seed = Effect.gen(function* () {
+		const store = yield* DataStore;
+		yield* store.writeSettings("hash-preset-spr", {
+			vitestVersion: "4.1.5",
+			pool: "forks"
+		}, {});
+		const runId = yield* store.writeRun({
+			invocationId: "inv-preset-spr-1",
+			project: "default",
+			settingsHash: "hash-preset-spr",
+			timestamp: "2026-01-01T00:00:00.000Z",
+			commitSha: null,
+			branch: null,
+			reason: "passed",
+			duration: 1200,
+			total: 3,
+			passed: 3,
+			failed: 0,
+			skipped: 0,
+			scoped: false
+		});
+		const fileId = yield* store.ensureFile("src/math.test.ts");
+		const [moduleId] = yield* store.writeModules(runId, [{
+			fileId,
+			relativeModuleId: "src/math.test.ts",
+			state: "passed",
+			duration: 1200
+		}]);
+		yield* store.writeTestCases(moduleId, [
+			{
+				name: "adds two numbers",
+				fullName: "math > adds two numbers",
+				state: "passed",
+				duration: 400
+			},
+			{
+				name: "subtracts two numbers",
+				fullName: "math > subtracts two numbers",
+				state: "passed",
+				duration: 400
+			},
+			{
+				name: "multiplies two numbers",
+				fullName: "math > multiplies two numbers",
+				state: "passed",
+				duration: 400
+			}
+		]);
+	});
+	return Layer.effectDiscard(seed).pipe(Layer.provideMerge(base));
+}
+/** @public */
+function withFailures(filename) {
+	const base = makeTestLayer(filename);
+	const seed = Effect.gen(function* () {
+		const store = yield* DataStore;
+		yield* store.writeSettings("hash-preset-wf", {
+			vitestVersion: "4.1.5",
+			pool: "forks"
+		}, {});
+		const runId = yield* store.writeRun({
+			invocationId: "inv-preset-wf-1",
+			project: "default",
+			settingsHash: "hash-preset-wf",
+			timestamp: "2026-01-01T00:00:00.000Z",
+			commitSha: null,
+			branch: null,
+			reason: "failed",
+			duration: 1500,
+			total: 4,
+			passed: 2,
+			failed: 2,
+			skipped: 0,
+			scoped: false
+		});
+		const fileId = yield* store.ensureFile("src/parser.test.ts");
+		const [moduleId] = yield* store.writeModules(runId, [{
+			fileId,
+			relativeModuleId: "src/parser.test.ts",
+			state: "failed",
+			duration: 1500
+		}]);
+		yield* store.writeTestCases(moduleId, [
+			{
+				name: "parses valid input",
+				fullName: "parser > parses valid input",
+				state: "passed",
+				duration: 300
+			},
+			{
+				name: "parses nested structure",
+				fullName: "parser > parses nested structure",
+				state: "passed",
+				duration: 300
+			},
+			{
+				name: "rejects empty input",
+				fullName: "parser > rejects empty input",
+				state: "failed",
+				duration: 450
+			},
+			{
+				name: "rejects malformed input",
+				fullName: "parser > rejects malformed input",
+				state: "failed",
+				duration: 450
+			}
+		]);
+	});
+	return Layer.effectDiscard(seed).pipe(Layer.provideMerge(base));
+}
+/** @public */
+function flaky(filename) {
+	const base = makeTestLayer(filename);
+	const seed = Effect.gen(function* () {
+		const store = yield* DataStore;
+		yield* store.writeSettings("hash-preset-flaky", {
+			vitestVersion: "4.1.5",
+			pool: "forks"
+		}, {});
+		const runId1 = yield* store.writeRun({
+			invocationId: "inv-preset-flaky-1",
+			project: "default",
+			settingsHash: "hash-preset-flaky",
+			timestamp: "2026-01-01T00:00:00.000Z",
+			commitSha: null,
+			branch: null,
+			reason: "failed",
+			duration: 800,
+			total: 2,
+			passed: 1,
+			failed: 1,
+			skipped: 0,
+			scoped: false
+		});
+		const fileId = yield* store.ensureFile("src/async.test.ts");
+		const [moduleId1] = yield* store.writeModules(runId1, [{
+			fileId,
+			relativeModuleId: "src/async.test.ts",
+			state: "failed",
+			duration: 800
+		}]);
+		yield* store.writeTestCases(moduleId1, [{
+			name: "resolves within timeout",
+			fullName: "async > resolves within timeout",
+			state: "failed",
+			duration: 500
+		}, {
+			name: "rejects on error",
+			fullName: "async > rejects on error",
+			state: "passed",
+			duration: 300
+		}]);
+		yield* store.writeHistory("default", "async > resolves within timeout", runId1, "2025-12-31T23:00:00.000Z", "passed", 500, false, 0, null);
+		yield* store.writeHistory("default", "async > resolves within timeout", runId1, "2026-01-01T00:00:00.000Z", "failed", 500, false, 0, null);
+		yield* store.writeHistory("default", "async > rejects on error", runId1, "2026-01-01T00:00:00.000Z", "passed", 300, false, 0, null);
+		const runId2 = yield* store.writeRun({
+			invocationId: "inv-preset-flaky-2",
+			project: "default",
+			settingsHash: "hash-preset-flaky",
+			timestamp: "2026-01-01T01:00:00.000Z",
+			commitSha: null,
+			branch: null,
+			reason: "passed",
+			duration: 700,
+			total: 2,
+			passed: 2,
+			failed: 0,
+			skipped: 0,
+			scoped: false
+		});
+		const [moduleId2] = yield* store.writeModules(runId2, [{
+			fileId,
+			relativeModuleId: "src/async.test.ts",
+			state: "passed",
+			duration: 700
+		}]);
+		yield* store.writeTestCases(moduleId2, [{
+			name: "resolves within timeout",
+			fullName: "async > resolves within timeout",
+			state: "passed",
+			duration: 400
+		}, {
+			name: "rejects on error",
+			fullName: "async > rejects on error",
+			state: "passed",
+			duration: 300
+		}]);
+		yield* store.writeHistory("default", "async > resolves within timeout", runId2, "2026-01-01T01:00:00.000Z", "passed", 400, false, 0, null);
+		yield* store.writeHistory("default", "async > rejects on error", runId2, "2026-01-01T01:00:00.000Z", "passed", 300, false, 0, null);
+	});
+	return Layer.effectDiscard(seed).pipe(Layer.provideMerge(base));
+}
+/** @public */
+function withTddTask(filename) {
+	const base = makeTestLayer(filename);
+	const seed = Effect.gen(function* () {
+		const store = yield* DataStore;
+		const sessionId = yield* store.writeSession({
+			chatId: "chat-preset-tdd",
+			project: "default",
+			cwd: "/workspace",
+			agentKind: "main",
+			startedAt: "2026-01-01T00:00:00.000Z"
+		});
+		const tddTaskId = yield* store.writeTddTask({
+			sessionId,
+			goal: "Implement the parser feature",
+			startedAt: "2026-01-01T00:00:00.000Z"
+		});
+		const goal = yield* store.createGoal({
+			tddTaskId,
+			goal: "Handle edge cases"
+		});
+		yield* store.createBehavior({
+			goalId: goal.id,
+			behavior: "rejects empty input"
+		});
+		yield* store.createBehavior({
+			goalId: goal.id,
+			behavior: "rejects null input"
+		});
+	});
+	return Layer.effectDiscard(seed).pipe(Layer.provideMerge(base));
+}
+
+//#endregion
+export { BehaviorNotFoundError, DataReader, DataStore, DataStoreError, DataStoreTestLayer, GoalNotFoundError, IllegalStatusTransitionError, TddTaskAlreadyEndedError, TddTaskNotFoundError, empty, flaky, makeTestLayer, singlePassingRun, withFailures, withTddTask };

package/tsdoc-metadata.json

@@ -0,0 +1,11 @@
+// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
+// It should be published with your NPM package.  It should not be tracked by Git.
+{
+  "tsdocVersion": "0.12",
+  "toolPackages": [
+    {
+      "packageName": "@microsoft/api-extractor",
+      "packageVersion": "7.58.9"
+    }
+  ]
+}

package/utils/ansi.js

@@ -0,0 +1,49 @@
+//#region src/utils/ansi.ts
+const ANSI_CODES = {
+	reset: [0, 0],
+	bold: [1, 22],
+	dim: [2, 22],
+	red: [31, 39],
+	green: [32, 39],
+	yellow: [33, 39],
+	cyan: [36, 39]
+};
+/**
+* Wrap text with an ANSI color/style escape code.
+*
+* No-ops when `options.noColor` is true, keeping output as valid plain
+* markdown when captured by agents or piped to files.
+*
+* @privateRemarks
+* Uses raw ANSI escape sequences (`\x1b[...m`) rather than a dependency
+* like `chalk` or `picocolors` to keep the package zero-dependency. The
+* `noColor` flag respects the `NO_COLOR` environment variable convention.
+*
+* @param text - Text to wrap
+* @param color - ANSI code name: `reset`, `bold`, `dim`, `red`, `green`, `yellow`, `cyan`
+* @param options - Control color output
+* @returns Text with ANSI escape codes, or plain text if noColor
+*
+* @see {@link https://no-color.org/ | NO_COLOR convention}
+* @internal
+*/
+function ansi(text, color, options) {
+	if (options?.noColor) return text;
+	const codes = ANSI_CODES[color];
+	if (!codes) return text;
+	return `\x1b[${codes[0]}m${text}\x1b[${codes[1]}m`;
+}
+/**
+* Strip all ANSI escape codes from a string.
+*
+* @param text - String potentially containing ANSI escape sequences
+* @returns Plain text with all escape sequences removed
+*
+* @internal
+*/
+function stripAnsi(text) {
+	return text.replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+//#endregion
+export { ansi, stripAnsi };

package/utils/build-report.js

@@ -0,0 +1,130 @@
+//#region src/utils/build-report.ts
+/**
+* Format a single Vitest stack frame: strings pass through; ParsedStack
+* objects render as `at <method> (<file>:<line>:<column>)`. An empty
+* `method` falls back to `<anonymous>`.
+*
+* @internal
+*/
+function formatStackFrame(frame) {
+	if (typeof frame === "string") return frame;
+	return `at ${frame.method.length > 0 ? frame.method : "<anonymous>"} (${frame.file}:${frame.line}:${frame.column})`;
+}
+/**
+* Map Vitest error objects to the {@link ReportError} shape.
+*
+* @internal
+*/
+function mapErrors(errors) {
+	if (!errors || errors.length === 0) return void 0;
+	return errors.map((e) => {
+		return {
+			message: e.message,
+			..."diff" in e && e.diff != null ? { diff: e.diff } : {},
+			...e.stacks && e.stacks.length > 0 ? { stack: e.stacks.map(formatStackFrame).join("\n") } : {}
+		};
+	});
+}
+/**
+* Normalize a Vitest state string to one of the four canonical states.
+*
+* @internal
+*/
+function normalizeState(state) {
+	if (state === "passed") return "passed";
+	if (state === "failed") return "failed";
+	if (state === "skipped") return "skipped";
+	return "pending";
+}
+/**
+* Convert Vitest TestModule/TestCase objects into an `AgentReport`.
+*
+* @remarks
+* This is a pure data transformation function with no I/O. It tallies
+* pass/fail/skip counts, extracts error details with diffs, and builds
+* the complete report structure. Only modules with at least one failing
+* test are included in the `failed` array to keep reports compact.
+*
+* @param testModules - All test modules from the Vitest run
+* @param unhandledErrors - Unhandled errors from the run
+* @param reason - Overall run outcome (`"passed"`, `"failed"`, or `"interrupted"`)
+* @param options - Reporter options; only `omitPassingTests` is used
+* @param projectName - Optional project name for monorepo grouping
+* @returns Structured report ready for JSON serialization
+*
+* @public
+*/
+function buildAgentReport(testModules, unhandledErrors, reason, options, projectName) {
+	const omitPassing = options.omitPassingTests !== false;
+	let totalCount = 0;
+	let passedCount = 0;
+	let failedCount = 0;
+	let skippedCount = 0;
+	let totalDuration = 0;
+	const failedModules = [];
+	const failedFiles = [];
+	for (const testModule of testModules) {
+		const moduleDuration = testModule.diagnostic()?.duration ?? 0;
+		totalDuration += moduleDuration;
+		const moduleState = normalizeState(testModule.state());
+		const moduleErrors = mapErrors(testModule.errors());
+		const allTests = [...testModule.children.allTests()];
+		const testReports = [];
+		let moduleHasFailure = false;
+		for (const testCase of allTests) {
+			totalCount++;
+			const result = testCase.result();
+			const diag = testCase.diagnostic();
+			const state = normalizeState(result?.state ?? "pending");
+			if (state === "passed") passedCount++;
+			else if (state === "failed") {
+				failedCount++;
+				moduleHasFailure = true;
+			} else if (state === "skipped") skippedCount++;
+			else skippedCount++;
+			if (!omitPassing || state !== "passed") {
+				const errors = mapErrors(result?.errors);
+				const testReport = {
+					name: testCase.name,
+					fullName: testCase.fullName,
+					state,
+					...diag?.duration !== void 0 ? { duration: diag.duration } : {},
+					...diag?.flaky ? { flaky: true } : {},
+					...diag?.slow ? { slow: true } : {},
+					...errors ? { errors } : {}
+				};
+				testReports.push(testReport);
+			}
+		}
+		if (moduleHasFailure || !moduleHasFailure && moduleState === "failed" && moduleErrors !== void 0) {
+			failedFiles.push(testModule.relativeModuleId);
+			const moduleReport = {
+				file: testModule.relativeModuleId,
+				state: moduleState,
+				duration: moduleDuration,
+				tests: testReports,
+				...moduleErrors ? { errors: moduleErrors } : {}
+			};
+			failedModules.push(moduleReport);
+		}
+	}
+	const mappedUnhandled = mapErrors(unhandledErrors) ?? [];
+	return {
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		...projectName != null ? { project: projectName } : {},
+		reason,
+		summary: {
+			total: totalCount,
+			passed: passedCount,
+			failed: failedCount,
+			skipped: skippedCount,
+			duration: totalDuration
+		},
+		failed: failedModules,
+		unhandledErrors: mappedUnhandled,
+		failedFiles
+	};
+}
+
+//#endregion
+export { buildAgentReport };

package/utils/canonicalize-git-url.js

@@ -0,0 +1,66 @@
+//#region src/utils/canonicalize-git-url.ts
+const SCHEME_PREFIXES = [
+	"git+ssh://",
+	"git+https://",
+	"ssh://",
+	"https://",
+	"http://"
+];
+const SSH_SHORTHAND_REGEX = /^(?:[\w.-]+@)?([\w.-]+):(.+)$/;
+/**
+* Canonicalize a git remote URL.
+*
+* Returns `null` when the input is empty, whitespace-only, or has
+* neither a host nor a path after stripping known prefixes.
+*
+* Steps applied in order:
+*
+* 1. Trim whitespace.
+* 2. If the value starts with `[git+]ssh|https|http://`, strip the
+*    scheme. After stripping, drop any embedded `user@` segment.
+* 3. Otherwise, try the SSH shorthand `user@host:path` pattern; on a
+*    match, rebuild as `host/path` (drop the user).
+* 4. Strip trailing `.git`.
+* 5. Strip trailing `/`.
+* 6. Lowercase the entire string.
+* 7. Reject if the result is empty or has no `/` (no path) — a bare
+*    host like `github.com` is not a project identity.
+* @public
+*/
+const canonicalizeGitUrl = (raw) => {
+	const trimmed = raw.trim();
+	if (trimmed.length === 0) return null;
+	let value = trimmed;
+	const matchedPrefix = SCHEME_PREFIXES.find((prefix) => value.startsWith(prefix));
+	if (matchedPrefix !== void 0) {
+		value = value.slice(matchedPrefix.length);
+		const atIndex = value.indexOf("@");
+		const slashIndex = value.indexOf("/");
+		if (atIndex !== -1 && (slashIndex === -1 || atIndex < slashIndex)) value = value.slice(atIndex + 1);
+	} else {
+		const sshMatch = value.match(SSH_SHORTHAND_REGEX);
+		if (sshMatch !== null) value = `${sshMatch[1]}/${sshMatch[2]}`;
+	}
+	if (value.endsWith(".git")) value = value.slice(0, -4);
+	if (value.endsWith("/")) value = value.slice(0, -1);
+	value = value.toLowerCase();
+	if (value.length === 0 || !value.includes("/")) return null;
+	const slashIndex = value.indexOf("/");
+	if (slashIndex === 0 || slashIndex === value.length - 1) return null;
+	return value;
+};
+/**
+* Convert a (possibly raw) git URL to the filesystem-safe `project_key`
+* form. The canonical `host/path` is mapped 1:1 to `host__path` so it
+* can serve as a single path segment under
+* `$XDG_DATA_HOME/vitest-agent/`.
+* @public
+*/
+const gitUrlToProjectKey = (raw) => {
+	const canonical = canonicalizeGitUrl(raw);
+	if (canonical === null) return null;
+	return canonical.replaceAll("/", "__");
+};
+
+//#endregion
+export { canonicalizeGitUrl, gitUrlToProjectKey };

package/utils/classify-test.js

@@ -0,0 +1,22 @@
+//#region src/utils/classify-test.ts
+/**
+* Classify a test based on its current state and prior run history.
+*
+* @param current - The test's state in the current run
+* @param priorRuns - Previous runs (most recent first), before the current run was prepended
+* @returns The test's classification
+* @public
+*/
+function classifyTest(current, priorRuns) {
+	if (current === "failed") {
+		if (priorRuns.length === 0) return "new-failure";
+		if (priorRuns.every((r) => r.state === "passed")) return "new-failure";
+		if (priorRuns[0].state === "failed") return "persistent";
+		return "flaky";
+	}
+	if (priorRuns.length === 0) return "stable";
+	return priorRuns.some((r) => r.state === "failed") ? "recovered" : "stable";
+}
+
+//#endregion
+export { classifyTest };

package/utils/compress-lines.js

@@ -0,0 +1,45 @@
+//#region src/utils/compress-lines.ts
+/**
+* Compress an array of line numbers into a compact range string.
+*
+* Consecutive line numbers are collapsed into `start-end` ranges,
+* separated by commas. Duplicate values are removed and the input
+* is sorted ascending before processing.
+*
+* @param lines - Array of line numbers to compress
+* @returns Compressed range string, or empty string for empty input
+*
+* @example
+* ```typescript
+* import { compressLines } from "@vitest-agent/sdk/utils";
+*
+* compressLines([1, 2, 3, 5, 10, 11, 12]);
+* // Returns: "1-3,5,10-12"
+*
+* compressLines([42]);
+* // Returns: "42"
+*
+* compressLines([]);
+* // Returns: ""
+* ```
+*
+* @public
+*/
+function compressLines(lines) {
+	if (lines.length === 0) return "";
+	const sorted = [...new Set(lines)].sort((a, b) => a - b);
+	const ranges = [];
+	let start = sorted[0];
+	let end = sorted[0];
+	for (let i = 1; i < sorted.length; i++) if (sorted[i] === end + 1) end = sorted[i];
+	else {
+		ranges.push(start === end ? `${start}` : `${start}-${end}`);
+		start = sorted[i];
+		end = sorted[i];
+	}
+	ranges.push(start === end ? `${start}` : `${start}-${end}`);
+	return ranges.join(",");
+}
+
+//#endregion
+export { compressLines };