@ricky-stevens/context-guardian 2.1.0

package/test/estimate.test.mjs

@@ -0,0 +1,262 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import { estimateSavings } from "../lib/estimate.mjs";
+
+let tmpDir;
+
+beforeEach(() => {
+	tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "cg-estimate-test-"));
+});
+
+afterEach(() => {
+	fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+
+/** Write a JSONL transcript file from an array of objects. */
+function writeTranscript(name, lines) {
+	const p = path.join(tmpDir, name);
+	fs.writeFileSync(p, `${lines.map((l) => JSON.stringify(l)).join("\n")}\n`);
+	return p;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers for building transcript lines
+// ---------------------------------------------------------------------------
+
+function userText(text) {
+	return { type: "user", message: { role: "user", content: text } };
+}
+
+function userBlocks(blocks) {
+	return { type: "user", message: { role: "user", content: blocks } };
+}
+
+function assistantText(text) {
+	return {
+		type: "assistant",
+		message: {
+			role: "assistant",
+			content: [{ type: "text", text }],
+		},
+	};
+}
+
+function systemMsg(text) {
+	return { type: "system", message: { content: text } };
+}
+
+function progressMsg(text) {
+	return { type: "progress", message: { content: text } };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("estimateSavings", () => {
+	it("returns zeros when transcriptPath is null", () => {
+		const result = estimateSavings(null, 50000, 200000);
+		assert.deepStrictEqual(result, { smartPct: 0, recentPct: 0 });
+	});
+
+	it("returns zeros when transcriptPath does not exist", () => {
+		const result = estimateSavings("/nonexistent/path.jsonl", 50000, 200000);
+		assert.deepStrictEqual(result, { smartPct: 0, recentPct: 0 });
+	});
+
+	it("returns zeros when transcript is empty", () => {
+		const p = path.join(tmpDir, "empty.jsonl");
+		fs.writeFileSync(p, "");
+		const result = estimateSavings(p, 50000, 200000);
+		assert.deepStrictEqual(result, { smartPct: 0, recentPct: 0 });
+	});
+
+	it("system/progress messages are all removable — estimates lower than raw percentage", () => {
+		const p = writeTranscript("sys-progress.jsonl", [
+			systemMsg("System prompt content here with some length to it"),
+			progressMsg("Loading tools..."),
+			systemMsg("Another system message with extra content padding"),
+			progressMsg("Still loading more tools and resources..."),
+		]);
+
+		const rawPct = (50000 / 200000) * 100; // 25%
+		const result = estimateSavings(p, 50000, 200000);
+		assert.ok(result.smartPct <= rawPct);
+		assert.ok(result.recentPct <= rawPct);
+		assert.equal(result.smartPct, result.recentPct);
+	});
+
+	it("user text + assistant text — both kept, estimates reflect kept content", () => {
+		const p = writeTranscript("text-only.jsonl", [
+			userText("Please help me refactor the auth module"),
+			assistantText(
+				"I will refactor the auth module by extracting the token validation into a separate function.",
+			),
+		]);
+
+		const result = estimateSavings(p, 50000, 200000);
+		assert.ok(result.smartPct > 10);
+		assert.ok(result.recentPct > 0);
+	});
+
+	it("large tool_result content is mostly removed — low estimate", () => {
+		const bigContent = "x".repeat(50000);
+		const p = writeTranscript("tool-result.jsonl", [
+			userText("Read the config file"),
+			assistantText("I will read the config file for you."),
+			userBlocks([
+				{ type: "text", text: "Here is the result" },
+				{
+					type: "tool_result",
+					tool_use_id: "toolu_123",
+					content: bigContent,
+				},
+			]),
+		]);
+
+		const rawPct = (80000 / 200000) * 100; // 40%
+		const result = estimateSavings(p, 80000, 200000);
+		assert.ok(result.smartPct < rawPct);
+	});
+
+	it("baselineOverhead parameter affects the result", () => {
+		const bigContent = "y".repeat(20000);
+		const p = writeTranscript("overhead.jsonl", [
+			userText("Analyse the file"),
+			assistantText("I will read and analyse the file."),
+			userBlocks([
+				{ type: "text", text: "Result" },
+				{
+					type: "tool_result",
+					tool_use_id: "toolu_oh1",
+					content: bigContent,
+				},
+			]),
+			assistantText("The file looks good."),
+		]);
+
+		const withoutOverhead = estimateSavings(p, 80000, 200000, 0);
+		const withOverhead = estimateSavings(p, 80000, 200000, 40000);
+		assert.notEqual(withoutOverhead.smartPct, withOverhead.smartPct);
+	});
+
+	it("returns zeros when maxTokens is zero or NaN", () => {
+		const p = writeTranscript("zero-max.jsonl", [
+			userText("hello"),
+			assistantText("hi"),
+		]);
+		assert.deepStrictEqual(estimateSavings(p, 1000, 0), {
+			smartPct: 0,
+			recentPct: 0,
+		});
+		assert.deepStrictEqual(estimateSavings(p, 1000, NaN), {
+			smartPct: 0,
+			recentPct: 0,
+		});
+		assert.deepStrictEqual(estimateSavings(p, 1000, -100), {
+			smartPct: 0,
+			recentPct: 0,
+		});
+	});
+
+	it("thinking blocks are categorised as removable", () => {
+		const p = writeTranscript("thinking.jsonl", [
+			userText("solve this problem"),
+			{
+				type: "assistant",
+				message: {
+					role: "assistant",
+					content: [
+						{
+							type: "thinking",
+							thinking: "Let me think about this carefully... ".repeat(100),
+						},
+						{ type: "text", text: "The answer is 42." },
+					],
+				},
+			},
+		]);
+
+		const rawPct = (50000 / 200000) * 100;
+		const result = estimateSavings(p, 50000, 200000);
+		assert.ok(result.smartPct < rawPct);
+	});
+
+	it("tool_use blocks are partially kept (summary ratio)", () => {
+		const p = writeTranscript("tool-use.jsonl", [
+			userText("read the file"),
+			{
+				type: "assistant",
+				message: {
+					role: "assistant",
+					content: [
+						{
+							type: "tool_use",
+							id: "t1",
+							name: "Read",
+							input: { file_path: "/some/very/long/path/to/file.js" },
+						},
+						{ type: "text", text: "Here is the file content." },
+					],
+				},
+			},
+		]);
+
+		const result = estimateSavings(p, 50000, 200000);
+		assert.ok(result.smartPct > 0);
+	});
+
+	it("assistant string content (non-array) is categorised as kept", () => {
+		const p = writeTranscript("string-content.jsonl", [
+			userText("hello"),
+			{
+				type: "assistant",
+				message: { role: "assistant", content: "Simple string response" },
+			},
+		]);
+
+		const result = estimateSavings(p, 50000, 200000);
+		assert.ok(result.smartPct > 0);
+	});
+
+	it("redacted_thinking blocks are categorised as removable", () => {
+		const p = writeTranscript("redacted.jsonl", [
+			userText("think about this"),
+			{
+				type: "assistant",
+				message: {
+					role: "assistant",
+					content: [
+						{ type: "redacted_thinking" },
+						{ type: "text", text: "Done thinking." },
+					],
+				},
+			},
+		]);
+
+		const result = estimateSavings(p, 50000, 200000);
+		assert.ok(result.smartPct > 0);
+	});
+
+	it("userExchanges counting — 20 exchanges makes recentPct less than smartPct", () => {
+		const padding = "A".repeat(5000);
+		const lines = [];
+		for (let i = 0; i < 20; i++) {
+			lines.push(userText(`User message ${i + 1}: ${padding}`));
+			lines.push(assistantText(`Response ${i + 1}: ${padding}`));
+		}
+		const p = writeTranscript("twenty-exchanges.jsonl", lines);
+
+		const result = estimateSavings(p, 60000, 200000);
+		assert.ok(result.smartPct > 0);
+		assert.ok(result.recentPct > 0);
+		assert.ok(result.recentPct < result.smartPct);
+
+		const ratio = result.recentPct / result.smartPct;
+		assert.ok(ratio < 0.85);
+		assert.ok(ratio > 0.4);
+	});
+});

package/test/extract-helpers-coverage.test.mjs

@@ -0,0 +1,333 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+	addSectionHeaders,
+	generateConversationIndex,
+} from "../lib/extract-helpers.mjs";
+
+// Helper: build alternating user/assistant exchanges.
+// generateConversationIndex skips exchanges with no extractable facts or tool work,
+// so we support richUser (entity-laden text) and withTools (edit tool lines) options.
+function buildExchanges(count, opts = {}) {
+	const messages = [];
+	for (let i = 1; i <= count; i++) {
+		if (opts.richUser) {
+			messages.push(`**User:** Fix ZEP-${1000 + i} which costs $${10000 + i}`);
+		} else {
+			messages.push(`**User:** User message ${i}`);
+		}
+		messages.push(`**Assistant:** Assistant response ${i}`);
+		if (opts.withTools) {
+			messages.push(`\u2192 Edit \`file${i}.js\``);
+			messages.push(`\u2190 success`);
+		}
+	}
+	return messages;
+}
+
+describe("generateConversationIndex", () => {
+	it("returns empty string for fewer than 10 messages", () => {
+		const messages = buildExchanges(2, { withTools: true }); // 8 messages
+		const result = generateConversationIndex(messages);
+		assert.equal(result, "");
+	});
+
+	it("returns empty string for exactly 9 messages", () => {
+		const messages = buildExchanges(2, { withTools: true }); // 8 messages
+		messages.push("**User:** One more question");
+		assert.equal(messages.length, 9);
+		const result = generateConversationIndex(messages);
+		assert.equal(result, "");
+	});
+
+	it("returns empty string when no exchanges produce facts or work", () => {
+		// 20 messages but all generic — no entities, no tool lines
+		const messages = buildExchanges(10);
+		const result = generateConversationIndex(messages);
+		assert.equal(
+			result,
+			"",
+			"Generic user/assistant pairs without entities or tools should produce empty index",
+		);
+	});
+
+	it("generates index entries for exchanges with tool work", () => {
+		const messages = buildExchanges(6, { withTools: true }); // 24 messages
+		const result = generateConversationIndex(messages);
+		assert.notEqual(result, "");
+		assert.ok(
+			result.includes("## Conversation Index"),
+			"Should have index header",
+		);
+		assert.ok(
+			result.includes("Compact reference"),
+			"Should have description line",
+		);
+		assert.ok(result.includes("[1]"), "Should have first exchange entry");
+		assert.ok(result.includes("[6]"), "Should have last exchange entry");
+	});
+
+	it("generates index entries for entity-rich user messages without tools", () => {
+		const messages = buildExchanges(6, { richUser: true }); // 12 messages, entities in user text
+		const result = generateConversationIndex(messages);
+		assert.notEqual(result, "");
+		assert.ok(result.includes("## Conversation Index"));
+		assert.ok(
+			result.includes("ZEP-"),
+			"Should include ticket IDs from user messages",
+		);
+		assert.ok(result.includes("$"), "Should include money references");
+	});
+
+	it("includes decisions section when user messages contain decision patterns", () => {
+		const messages = [
+			"**User:** I chose to use PostgreSQL instead of MySQL",
+			"**Assistant:** Great choice.",
+			"\u2192 Edit `db.js`",
+			"\u2190 success",
+			"**User:** I rejected the caching approach",
+			"**Assistant:** Understood.",
+			"\u2192 Edit `cache.js`",
+			"\u2190 success",
+			"**User:** I decided to go with REST over GraphQL",
+			"**Assistant:** REST it is.",
+			"\u2192 Edit `api.js`",
+			"\u2190 success",
+		];
+		const result = generateConversationIndex(messages);
+		assert.notEqual(result, "");
+		assert.ok(
+			result.includes("**Decisions:**"),
+			"Should have decisions section",
+		);
+		assert.ok(result.includes("chose"), "Should include 'chose' decision");
+		assert.ok(
+			result.includes("rejected"),
+			"Should include 'rejected' decision",
+		);
+		assert.ok(result.includes("decided"), "Should include 'decided' decision");
+	});
+
+	it("includes error-resolution pairs", () => {
+		const messages = [
+			"**User:** Run the build",
+			"**Assistant:** Running the build now.",
+			"\u2192 Bash `npm run build`",
+			"\u2190 Error: Module not found lodash",
+			"**User:** Fix the missing dependency",
+			"**Assistant:** I'll install lodash.",
+			"\u2192 Bash `npm install lodash`",
+			"\u2190 added 1 package",
+			"**User:** Try the build again",
+			"**Assistant:** Running build again.",
+			"\u2192 Bash `npm run build`",
+			"\u2190 Build successful",
+		];
+		const result = generateConversationIndex(messages);
+		assert.notEqual(result, "");
+		assert.ok(
+			result.includes("**Errors resolved:**"),
+			"Should have error resolution section",
+		);
+		assert.ok(
+			result.includes("Module not found"),
+			"Should include the error text",
+		);
+		assert.ok(result.includes("\u2192"), "Should include resolution arrow");
+	});
+
+	it("truncates long facts to 250 chars and appends entity tags", () => {
+		const longText = "A".repeat(300);
+		const messages = [
+			`**User:** ${longText} and also reference ZEP-4471 and $184,000`,
+			"**Assistant:** Understood.",
+			"\u2192 Edit `big.js`",
+			"\u2190 success",
+			"**User:** Continue with port 5433 configuration",
+			"**Assistant:** Configuring.",
+			"\u2192 Edit `port.js`",
+			"\u2190 success",
+			"**User:** Update for March 29th deadline",
+			"**Assistant:** Noted.",
+			"\u2192 Edit `deadline.js`",
+			"\u2190 success",
+		];
+		const result = generateConversationIndex(messages);
+		assert.notEqual(result, "");
+		// The long user message should be truncated: 250 chars + "..." + entity tags
+		const lines = result.split("\n");
+		const longLine = lines.find((l) => l.includes("AAA"));
+		assert.ok(longLine, "Should have a line with the truncated A's");
+		assert.ok(
+			longLine.includes("..."),
+			"Truncated line should end with ellipsis",
+		);
+		// Entity tags should be appended in braces
+		assert.ok(longLine.includes("{"), "Should have entity tag block");
+		assert.ok(longLine.includes("ZEP-4471"), "Should tag ZEP-4471 entity");
+		assert.ok(longLine.includes("$184,000"), "Should tag $184,000 entity");
+		// The full 300-char string should NOT appear (truncated at 250)
+		assert.ok(
+			!longLine.includes("A".repeat(300)),
+			"Should not contain full 300-char string",
+		);
+	});
+
+	it("entity extraction pulls IDs, money, dates, and ports into index entries", () => {
+		const messages = [
+			"**User:** Fix ZEP-4471 which involves $184,000 payment on March 29th using port 5433",
+			"**Assistant:** I'll handle it.",
+			"\u2192 Edit `payment.js`",
+			"\u2190 success",
+			"**User:** Also check PROJ-9999 for $50,000 budget",
+			"**Assistant:** Looking into it.",
+			"\u2192 Edit `budget.js`",
+			"\u2190 success",
+			"**User:** Deploy on port 8080 by January 15th",
+			"**Assistant:** Will target that.",
+			"\u2192 Edit `deploy.js`",
+			"\u2190 success",
+		];
+		const result = generateConversationIndex(messages);
+		assert.notEqual(result, "");
+		// Entities should appear directly in the facts (short enough to not be truncated)
+		assert.ok(result.includes("ZEP-4471"), "Should include ticket ID ZEP-4471");
+		assert.ok(
+			result.includes("$184,000"),
+			"Should include money amount $184,000",
+		);
+		assert.ok(result.includes("port 5433"), "Should include port reference");
+		assert.ok(
+			result.includes("PROJ-9999"),
+			"Should include ticket ID PROJ-9999",
+		);
+	});
+
+	it("handles mixed content with tools, decisions, errors, and entities", () => {
+		const messages = [
+			"**User:** Implement auth for PROJ-2000 with budget $10,000",
+			"**Assistant:** Starting auth implementation.",
+			"\u2192 Edit `auth.js`",
+			"\u2190 success",
+			"**User:** I chose JWT over session tokens",
+			"**Assistant:** Using JWT approach.",
+			"\u2192 Edit `jwt.js`",
+			"\u2190 success",
+			"**User:** Run tests on port 3000",
+			"**Assistant:** Running tests.",
+			"\u2192 Bash `npm test`",
+			"\u2190 Error: Connection refused on port 3000",
+			"**User:** Fix the connection issue",
+			"**Assistant:** Fixing the port configuration.",
+			"\u2192 Edit `config.js`",
+			"\u2190 success",
+			"**User:** I rejected using OAuth for now",
+			"**Assistant:** Skipping OAuth.",
+			"**User:** Deploy by April 1st deadline",
+			"**Assistant:** Targeting April 1st.",
+		];
+		const result = generateConversationIndex(messages);
+		assert.notEqual(result, "");
+		assert.ok(
+			result.includes("## Conversation Index"),
+			"Should have index header",
+		);
+		assert.ok(
+			result.includes("**Decisions:**"),
+			"Should have decisions section",
+		);
+		assert.ok(
+			result.includes("**Errors resolved:**"),
+			"Should have error resolution section",
+		);
+		assert.ok(
+			result.includes("PROJ-2000"),
+			"Should include entity from first exchange",
+		);
+	});
+});
+
+describe("addSectionHeaders", () => {
+	it("returns unchanged array for fewer than 20 messages", () => {
+		const messages = buildExchanges(5); // 10 messages
+		const result = addSectionHeaders(messages);
+		assert.deepEqual(result, messages);
+	});
+
+	it("returns unchanged array for exactly 19 messages", () => {
+		const messages = buildExchanges(9); // 18 messages
+		messages.push("**User:** One more");
+		assert.equal(messages.length, 19);
+		const result = addSectionHeaders(messages);
+		assert.deepEqual(result, messages);
+	});
+
+	it("inserts section headers every 10 exchanges for 25+ exchange sessions", () => {
+		const messages = buildExchanges(25); // 50 messages
+		const result = addSectionHeaders(messages, 10);
+		assert.ok(
+			result.length > messages.length,
+			"Should have added header elements",
+		);
+		// Find all section headers
+		const headers = result.filter((m) => m.startsWith("### Exchanges"));
+		assert.ok(
+			headers.length >= 2,
+			`Should have at least 2 section headers, got ${headers.length}`,
+		);
+		// Check header format
+		for (const header of headers) {
+			assert.match(
+				header,
+				/^### Exchanges \d+-\d+$/,
+				`Header should match format, got: ${header}`,
+			);
+		}
+	});
+
+	it("first header starts at exchange 1", () => {
+		const messages = buildExchanges(25);
+		const result = addSectionHeaders(messages, 10);
+		const headers = result.filter((m) => m.startsWith("### Exchanges"));
+		assert.ok(headers.length > 0, "Should have headers");
+		assert.ok(
+			headers[0].startsWith("### Exchanges 1-"),
+			`First header should start at 1, got: ${headers[0]}`,
+		);
+	});
+
+	it("uses default groupSize when not specified", () => {
+		const messages = buildExchanges(25); // 50 messages
+		const result = addSectionHeaders(messages);
+		const headers = result.filter((m) => m.startsWith("### Exchanges"));
+		assert.ok(
+			headers.length >= 1,
+			"Should insert headers with default groupSize",
+		);
+	});
+
+	it("handles messages with tool lines between exchanges", () => {
+		const messages = buildExchanges(12, { withTools: true }); // 48 messages
+		const result = addSectionHeaders(messages, 5);
+		const headers = result.filter((m) => m.startsWith("### Exchanges"));
+		assert.ok(
+			headers.length >= 1,
+			`Should have section headers, got ${headers.length}`,
+		);
+		// All original messages should still be present
+		for (const msg of messages) {
+			assert.ok(
+				result.includes(msg),
+				`Original message should be preserved: ${msg.substring(0, 50)}`,
+			);
+		}
+	});
+
+	it("preserves message order after inserting headers", () => {
+		const messages = buildExchanges(15); // 30 messages
+		const result = addSectionHeaders(messages, 5);
+		// Filter out headers and verify original order is preserved
+		const withoutHeaders = result.filter((m) => !m.startsWith("### Exchanges"));
+		assert.deepEqual(withoutHeaders, messages);
+	});
+});