@clinebot/core 0.0.35 → 0.0.36

package/src/services/telemetry/TelemetryService.test.ts

@@ -1,134 +0,0 @@
-import type { BasicLogger } from "@clinebot/shared";
-import { describe, expect, it, vi } from "vitest";
-import type { ITelemetryAdapter } from "./ITelemetryAdapter";
-import { TelemetryService } from "./TelemetryService";
-
-describe("TelemetryService", () => {
-	it("merges metadata and forwards calls to adapters", async () => {
-		const { adapter, emit, recordCounter } = createAdapter();
-		const service = new TelemetryService({
-			adapters: [adapter],
-			metadata: {
-				extension_version: "1.2.3",
-				cline_type: "cli",
-			},
-			distinctId: "distinct-1",
-			commonProperties: {
-				organization_id: "org-1",
-			},
-		});
-
-		service.capture({
-			event: "session.started",
-			properties: { sessionId: "session-1" },
-		});
-		service.recordCounter("cline.session.starts.total", 1, {
-			sessionId: "session-1",
-		});
-		await service.flush();
-		await service.dispose();
-
-		expect(emit).toHaveBeenCalledWith(
-			"session.started",
-			expect.objectContaining({
-				sessionId: "session-1",
-				organization_id: "org-1",
-				extension_version: "1.2.3",
-				cline_type: "cli",
-				distinct_id: "distinct-1",
-			}),
-		);
-		expect(recordCounter).toHaveBeenCalledWith(
-			"cline.session.starts.total",
-			1,
-			expect.objectContaining({
-				sessionId: "session-1",
-				distinct_id: "distinct-1",
-			}),
-			undefined,
-			false,
-		);
-	});
-
-	it("mirrors telemetry events into the logger when provided", () => {
-		const logger: BasicLogger = {
-			debug: vi.fn(),
-			log: vi.fn(),
-			error: vi.fn(),
-		};
-		const service = new TelemetryService({
-			logger,
-			metadata: {
-				extension_version: "1.2.3",
-				cline_type: "cli",
-			},
-			distinctId: "distinct-1",
-		});
-
-		service.capture({
-			event: "session.started",
-			properties: { sessionId: "session-1" },
-		});
-		service.captureRequired("user.opt_out", { reason: "manual" });
-		service.recordCounter("cline.session.starts.total", 1, {
-			sessionId: "session-1",
-		});
-
-		expect(logger.log).toHaveBeenCalledWith(
-			"telemetry.event",
-			expect.objectContaining({
-				telemetrySink: "TelemetryLoggerSink",
-				event: "session.started",
-				properties: expect.objectContaining({
-					sessionId: "session-1",
-					extension_version: "1.2.3",
-					distinct_id: "distinct-1",
-				}),
-			}),
-		);
-		expect(logger.log).toHaveBeenCalledWith(
-			"telemetry.required_event",
-			expect.objectContaining({
-				telemetrySink: "TelemetryLoggerSink",
-				severity: "warn",
-				event: "user.opt_out",
-				properties: expect.objectContaining({
-					reason: "manual",
-					extension_version: "1.2.3",
-				}),
-			}),
-		);
-		expect(logger.debug).toHaveBeenCalledWith(
-			"telemetry.metric",
-			expect.objectContaining({
-				telemetrySink: "TelemetryLoggerSink",
-				instrument: "counter",
-				name: "cline.session.starts.total",
-			}),
-		);
-	});
-});
-
-function createAdapter(): {
-	adapter: ITelemetryAdapter;
-	emit: ReturnType<typeof vi.fn>;
-	recordCounter: ReturnType<typeof vi.fn>;
-} {
-	const emit = vi.fn();
-	const recordCounter = vi.fn();
-	return {
-		adapter: {
-			name: "test",
-			emit,
-			emitRequired: vi.fn(),
-			recordCounter,
-			recordHistogram: vi.fn(),
-			recordGauge: vi.fn(),
-			isEnabled: vi.fn(() => true),
-			flush: vi.fn().mockResolvedValue(undefined),
-			dispose: vi.fn().mockResolvedValue(undefined),
-		},
-		emit,
-		recordCounter,
-	};
-}

package/src/services/telemetry/distinct-id.test.ts

@@ -1,57 +0,0 @@
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-const machineIdSyncMock = vi.hoisted(() => vi.fn());
-
-vi.mock("node-machine-id", () => ({
-	machineIdSync: machineIdSyncMock,
-}));
-
-describe("resolveCoreDistinctId", () => {
-	beforeEach(() => {
-		vi.resetModules();
-	});
-
-	afterEach(() => {
-		machineIdSyncMock.mockReset();
-		vi.unstubAllEnvs();
-		vi.restoreAllMocks();
-	});
-
-	it("returns the explicit distinct ID override when provided", async () => {
-		const { resolveCoreDistinctId } = await import("./distinct-id");
-
-		expect(resolveCoreDistinctId("  user-provided-id  ")).toBe(
-			"user-provided-id",
-		);
-		expect(machineIdSyncMock).not.toHaveBeenCalled();
-	});
-
-	it("uses node-machine-id when no explicit override is provided", async () => {
-		machineIdSyncMock.mockReturnValue("machine-id-123");
-		const { resolveCoreDistinctId } = await import("./distinct-id");
-
-		expect(resolveCoreDistinctId()).toBe("machine-id-123");
-	});
-
-	it("persists and reuses a generated fallback when machine ID lookup fails", async () => {
-		const tempDir = mkdtempSync(join(tmpdir(), "cline-distinct-id-"));
-		try {
-			vi.stubEnv("CLINE_DATA_DIR", tempDir);
-			machineIdSyncMock.mockImplementation(() => {
-				throw new Error("machine id unavailable");
-			});
-
-			const { resolveCoreDistinctId } = await import("./distinct-id");
-			const first = resolveCoreDistinctId();
-			const second = resolveCoreDistinctId();
-
-			expect(first).toMatch(/^cl-/);
-			expect(second).toBe(first);
-		} finally {
-			rmSync(tempDir, { recursive: true, force: true });
-		}
-	});
-});

package/src/services/workspace/file-indexer.d.ts

@@ -1,11 +0,0 @@
-export interface FastFileIndexOptions {
-	ttlMs?: number;
-}
-export declare function getFileIndex(
-	cwd: string,
-	options?: FastFileIndexOptions,
-): Promise<Set<string>>;
-export declare function prewarmFileIndex(
-	cwd: string,
-	options?: FastFileIndexOptions,
-): Promise<void>;

package/src/services/workspace/file-indexer.test.ts

@@ -1,156 +0,0 @@
-import { chmod, mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { describe, expect, it, vi } from "vitest";
-import { getFileIndex, prewarmFileIndex } from "./file-indexer";
-
-vi.mock("node:worker_threads", async () => {
-	const actual = await vi.importActual<typeof import("node:worker_threads")>(
-		"node:worker_threads",
-	);
-	return {
-		...actual,
-		isMainThread: false,
-		parentPort: null,
-	};
-});
-
-async function createTempWorkspace(): Promise<string> {
-	return mkdtemp(path.join(os.tmpdir(), "core-file-index-"));
-}
-
-describe("file indexer", () => {
-	it("indexes files by relative posix path", async () => {
-		const cwd = await createTempWorkspace();
-		try {
-			await mkdir(path.join(cwd, "src"), { recursive: true });
-			await writeFile(path.join(cwd, "src", "main.ts"), "export {}\n", "utf8");
-			await writeFile(path.join(cwd, "README.md"), "# Demo\n", "utf8");
-
-			const index = await getFileIndex(cwd, { ttlMs: 0 });
-			expect(index.has("src/main.ts")).toBe(true);
-			expect(index.has("README.md")).toBe(true);
-		} finally {
-			await rm(cwd, { recursive: true, force: true });
-		}
-	});
-
-	it("always excludes .git files from index", async () => {
-		const cwd = await createTempWorkspace();
-		try {
-			await mkdir(path.join(cwd, ".git"), { recursive: true });
-			await mkdir(path.join(cwd, "node_modules", "pkg"), { recursive: true });
-			await writeFile(path.join(cwd, ".git", "config"), "[core]\n", "utf8");
-			await writeFile(
-				path.join(cwd, "node_modules", "pkg", "index.js"),
-				"module.exports = {}\n",
-				"utf8",
-			);
-			await writeFile(
-				path.join(cwd, "app.ts"),
-				"export const app = 1\n",
-				"utf8",
-			);
-
-			const index = await getFileIndex(cwd, { ttlMs: 0 });
-			expect(index.has("app.ts")).toBe(true);
-			expect(index.has(".git/config")).toBe(false);
-		} finally {
-			await rm(cwd, { recursive: true, force: true });
-		}
-	});
-
-	it("prewarm rebuilds index and includes new files", async () => {
-		const cwd = await createTempWorkspace();
-		try {
-			await writeFile(
-				path.join(cwd, "first.ts"),
-				"export const first = 1\n",
-				"utf8",
-			);
-			const firstIndex = await getFileIndex(cwd, { ttlMs: 60_000 });
-			expect(firstIndex.has("first.ts")).toBe(true);
-
-			await writeFile(
-				path.join(cwd, "second.ts"),
-				"export const second = 2\n",
-				"utf8",
-			);
-			await prewarmFileIndex(cwd, { ttlMs: 60_000 });
-
-			const rebuilt = await getFileIndex(cwd, { ttlMs: 60_000 });
-			expect(rebuilt.has("second.ts")).toBe(true);
-		} finally {
-			await rm(cwd, { recursive: true, force: true });
-		}
-	});
-
-	it("skips unreadable directories during fallback indexing", async () => {
-		const cwd = await createTempWorkspace();
-		const unreadableDir = path.join(cwd, "private");
-		try {
-			await mkdir(unreadableDir, { recursive: true });
-			await writeFile(
-				path.join(cwd, "visible.ts"),
-				"export const ok = 1\n",
-				"utf8",
-			);
-			await writeFile(
-				path.join(unreadableDir, "hidden.ts"),
-				"export const hidden = 1\n",
-				"utf8",
-			);
-			await chmod(unreadableDir, 0o000);
-
-			await expect(
-				prewarmFileIndex(cwd, { ttlMs: 0 }),
-			).resolves.toBeUndefined();
-
-			const index = await getFileIndex(cwd, { ttlMs: 0 });
-			expect(index.has("visible.ts")).toBe(true);
-		} finally {
-			await chmod(unreadableDir, 0o755).catch(() => undefined);
-			await rm(cwd, { recursive: true, force: true });
-		}
-	});
-
-	it("evicts stale workspace indexes after 10 minutes when multiple workspaces exist", async () => {
-		vi.useFakeTimers();
-		const firstWorkspace = await createTempWorkspace();
-		const secondWorkspace = await createTempWorkspace();
-		try {
-			await writeFile(
-				path.join(firstWorkspace, "first.ts"),
-				"export const first = 1\n",
-				"utf8",
-			);
-			await writeFile(
-				path.join(secondWorkspace, "second.ts"),
-				"export const second = 2\n",
-				"utf8",
-			);
-
-			const firstIndex = await getFileIndex(firstWorkspace, { ttlMs: 60_000 });
-			expect(firstIndex.has("first.ts")).toBe(true);
-
-			await getFileIndex(secondWorkspace, { ttlMs: 60_000 });
-			vi.advanceTimersByTime(10 * 60_000 + 1);
-
-			await getFileIndex(secondWorkspace, { ttlMs: 60_000 });
-			await writeFile(
-				path.join(firstWorkspace, "later.ts"),
-				"export const later = 3\n",
-				"utf8",
-			);
-
-			const rebuiltFirstIndex = await getFileIndex(firstWorkspace, {
-				ttlMs: 60_000,
-			});
-			expect(rebuiltFirstIndex.has("later.ts")).toBe(true);
-		} finally {
-			vi.useRealTimers();
-			await rm(firstWorkspace, { recursive: true, force: true });
-			await rm(secondWorkspace, { recursive: true, force: true });
-		}
-	});
-});

package/src/services/workspace/mention-enricher.test.ts

@@ -1,106 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { describe, expect, it, vi } from "vitest";
-import { enrichPromptWithMentions } from "./mention-enricher";
-
-vi.mock("node:worker_threads", async () => {
-	const actual = await vi.importActual<typeof import("node:worker_threads")>(
-		"node:worker_threads",
-	);
-	return {
-		...actual,
-		isMainThread: false,
-		parentPort: null,
-	};
-});
-
-async function createTempWorkspace(): Promise<string> {
-	return mkdtemp(path.join(os.tmpdir(), "core-mentions-"));
-}
-
-describe("enrichPromptWithMentions", () => {
-	it("returns matched files for matching @path mentions", async () => {
-		const cwd = await createTempWorkspace();
-		try {
-			const sourcePath = path.join(cwd, "src", "index.ts");
-			await mkdir(path.dirname(sourcePath), { recursive: true });
-			await writeFile(sourcePath, "export const answer = 42\n", "utf8");
-
-			const result = await enrichPromptWithMentions(
-				"Review @src/index.ts",
-				cwd,
-			);
-
-			expect(result.mentions).toEqual(["src/index.ts"]);
-			expect(result.matchedFiles).toEqual(["src/index.ts"]);
-			expect(result.ignoredMentions).toEqual([]);
-			expect(result.prompt).toBe("Review @src/index.ts");
-		} finally {
-			await rm(cwd, { recursive: true, force: true });
-		}
-	});
-
-	it("ignores emails and unmatched mentions", async () => {
-		const cwd = await createTempWorkspace();
-		try {
-			await writeFile(path.join(cwd, "README.md"), "# Demo\n", "utf8");
-
-			const result = await enrichPromptWithMentions(
-				"Ping me at test@example.com and check @missing/file.ts.",
-				cwd,
-			);
-
-			expect(result.mentions).toEqual(["missing/file.ts"]);
-			expect(result.matchedFiles).toEqual([]);
-			expect(result.ignoredMentions).toEqual(["missing/file.ts"]);
-			expect(result.prompt).toBe(
-				"Ping me at test@example.com and check @missing/file.ts.",
-			);
-		} finally {
-			await rm(cwd, { recursive: true, force: true });
-		}
-	});
-
-	it("respects maxTotalBytes while keeping prompt unchanged", async () => {
-		const cwd = await createTempWorkspace();
-		try {
-			await writeFile(path.join(cwd, "a.ts"), "123", "utf8");
-			await writeFile(path.join(cwd, "b.ts"), "const b = 2\n", "utf8");
-
-			const result = await enrichPromptWithMentions(
-				"Use @a.ts and @b.ts",
-				cwd,
-				{ maxTotalBytes: 5, maxFiles: 2, maxFileBytes: 5 },
-			);
-
-			expect(result.mentions).toEqual(["a.ts", "b.ts"]);
-			expect(result.matchedFiles).toEqual(["a.ts"]);
-			expect(result.ignoredMentions).toEqual(["b.ts"]);
-			expect(result.prompt).toBe("Use @a.ts and @b.ts");
-		} finally {
-			await rm(cwd, { recursive: true, force: true });
-		}
-	});
-
-	it("does not over-count totalBytes across multiple mentions", async () => {
-		const cwd = await createTempWorkspace();
-		try {
-			await writeFile(path.join(cwd, "a.ts"), "aaa", "utf8");
-			await writeFile(path.join(cwd, "b.ts"), "bbb", "utf8");
-			await writeFile(path.join(cwd, "c.ts"), "ccc", "utf8");
-
-			const result = await enrichPromptWithMentions(
-				"Use @a.ts @b.ts @c.ts",
-				cwd,
-				{ maxTotalBytes: 15, maxFiles: 5, maxFileBytes: 5 },
-			);
-
-			expect(result.mentions).toEqual(["a.ts", "b.ts", "c.ts"]);
-			expect(result.matchedFiles).toEqual(["a.ts", "b.ts", "c.ts"]);
-			expect(result.ignoredMentions).toEqual([]);
-		} finally {
-			await rm(cwd, { recursive: true, force: true });
-		}
-	});
-});