@sns-myagent/cli 0.2.0 → 0.3.1

package/src/tbm/response-cache.ts

@@ -0,0 +1,220 @@
+/**
+ * Response Cache — exact and semantic match for cached responses.
+ *
+ * - Exact match: hash(query) → cached response
+ * - Semantic match: embedding similarity > 0.95
+ * - TTL-based expiry
+ */
+
+import { createHash } from "node:crypto";
+import { estimateTokens } from "./context-delta";
+
+export interface CacheEntry {
+	/** Hash of the query for exact match. */
+	queryHash: string;
+	/** Original query text. */
+	query: string;
+	/** Cached response. */
+	response: string;
+	/** When this entry was created. */
+	createdAt: number;
+	/** When this entry expires. */
+	expiresAt: number;
+	/** How many times this cache was hit. */
+	hitCount: number;
+	/** Token count of the cached response. */
+	responseTokens: number;
+}
+
+export interface ResponseCacheStats {
+	/** Total queries processed. */
+	totalQueries: number;
+	/** Exact cache hits. */
+	exactHits: number;
+	/** Semantic cache hits. */
+	semanticHits: number;
+	/** Cache misses. */
+	misses: number;
+	/** Total tokens saved by cache hits. */
+	tokensSaved: number;
+	/** Current cache size. */
+	cacheSize: number;
+	/** Hit rate (exact + semantic / total). */
+	hitRate: number;
+}
+
+function hashQuery(query: string): string {
+	return createHash("sha256").update(query.trim().toLowerCase()).digest("hex").slice(0, 16);
+}
+
+/**
+ * Simple Jaccard similarity for semantic matching.
+ * Uses word-level n-grams (bigrams) for comparison.
+ */
+function jaccardSimilarity(a: string, b: string): number {
+	const bigramsA = getBigrams(a);
+	const bigramsB = getBigrams(b);
+
+	if (bigramsA.size === 0 && bigramsB.size === 0) return 1;
+	if (bigramsA.size === 0 || bigramsB.size === 0) return 0;
+
+	let intersection = 0;
+	for (const bg of bigramsA) {
+		if (bigramsB.has(bg)) intersection++;
+	}
+
+	const union = bigramsA.size + bigramsB.size - intersection;
+	return union > 0 ? intersection / union : 0;
+}
+
+function getBigrams(text: string): Set<string> {
+	const words = text.toLowerCase().trim().split(/\s+/);
+	const bigrams = new Set<string>();
+	for (let i = 0; i < words.length - 1; i++) {
+		bigrams.add(`${words[i]}_${words[i + 1]}`);
+	}
+	return bigrams;
+}
+
+export class ResponseCache {
+	#cache: Map<string, CacheEntry> = new Map();
+	#ttlMs: number;
+	#maxEntries: number;
+	#similarityThreshold: number;
+	#stats: ResponseCacheStats = {
+		totalQueries: 0,
+		exactHits: 0,
+		semanticHits: 0,
+		misses: 0,
+		tokensSaved: 0,
+		cacheSize: 0,
+		hitRate: 0,
+	};
+
+	constructor(ttlSeconds: number = 3600, maxEntries: number = 100, similarityThreshold: number = 0.95) {
+		this.#ttlMs = ttlSeconds * 1000;
+		this.#maxEntries = maxEntries;
+		this.#similarityThreshold = similarityThreshold;
+	}
+
+	/**
+	 * Look up a cached response for a query.
+	 * Tries exact match first, then semantic match.
+	 */
+	get(query: string): { hit: boolean; response?: string; matchType?: "exact" | "semantic" } {
+		this.#stats.totalQueries++;
+		const now = Date.now();
+
+		// Clean expired entries lazily
+		this.#cleanExpired(now);
+
+		const qHash = hashQuery(query);
+
+		// 1. Exact match
+		const exact = this.#cache.get(qHash);
+		if (exact && exact.expiresAt > now) {
+			exact.hitCount++;
+			this.#stats.exactHits++;
+			this.#stats.tokensSaved += exact.responseTokens;
+			this.#updateHitRate();
+			return { hit: true, response: exact.response, matchType: "exact" };
+		}
+
+		// 2. Semantic match (Jaccard on bigrams)
+		for (const [, entry] of this.#cache) {
+			if (entry.expiresAt <= now) continue;
+			const sim = jaccardSimilarity(query, entry.query);
+			if (sim >= this.#similarityThreshold) {
+				entry.hitCount++;
+				this.#stats.semanticHits++;
+				this.#stats.tokensSaved += entry.responseTokens;
+				this.#updateHitRate();
+				return { hit: true, response: entry.response, matchType: "semantic" };
+			}
+		}
+
+		this.#stats.misses++;
+		this.#updateHitRate();
+		return { hit: false };
+	}
+
+	/**
+	 * Store a response in the cache.
+	 */
+	set(query: string, response: string): void {
+		const now = Date.now();
+		const qHash = hashQuery(query);
+
+		// Evict oldest if at capacity
+		if (this.#cache.size >= this.#maxEntries) {
+			this.#evictOldest();
+		}
+
+		this.#cache.set(qHash, {
+			queryHash: qHash,
+			query,
+			response,
+			createdAt: now,
+			expiresAt: now + this.#ttlMs,
+			hitCount: 0,
+			responseTokens: estimateTokens(response),
+		});
+
+		this.#stats.cacheSize = this.#cache.size;
+	}
+
+	/** Get stats snapshot. */
+	get stats(): Readonly<ResponseCacheStats> {
+		return { ...this.#stats };
+	}
+
+	/** Clear all cache entries. */
+	clear(): void {
+		this.#cache.clear();
+		this.#stats.cacheSize = 0;
+	}
+
+	/** Reset stats and cache. */
+	reset(): void {
+		this.#cache.clear();
+		this.#stats = {
+			totalQueries: 0,
+			exactHits: 0,
+			semanticHits: 0,
+			misses: 0,
+			tokensSaved: 0,
+			cacheSize: 0,
+			hitRate: 0,
+		};
+	}
+
+	#cleanExpired(now: number): void {
+		for (const [key, entry] of this.#cache) {
+			if (entry.expiresAt <= now) {
+				this.#cache.delete(key);
+			}
+		}
+		this.#stats.cacheSize = this.#cache.size;
+	}
+
+	#evictOldest(): void {
+		let oldestKey: string | null = null;
+		let oldestTime = Infinity;
+
+		for (const [key, entry] of this.#cache) {
+			if (entry.createdAt < oldestTime) {
+				oldestTime = entry.createdAt;
+				oldestKey = key;
+			}
+		}
+
+		if (oldestKey) {
+			this.#cache.delete(oldestKey);
+		}
+	}
+
+	#updateHitRate(): void {
+		const hits = this.#stats.exactHits + this.#stats.semanticHits;
+		this.#stats.hitRate = this.#stats.totalQueries > 0 ? hits / this.#stats.totalQueries : 0;
+	}
+}

package/src/tbm/tombstone.ts

@@ -0,0 +1,189 @@
+/**
+ * Conversation Tombstoning — compress old messages to minimal references.
+ *
+ * Old messages are replaced with tombstone entries that reference
+ * the original content. Model can still look up originals if needed.
+ *
+ * Target: 85% context reduction.
+ */
+
+export interface TombstoneEntry {
+	/** Original message index in conversation. */
+	originalIndex: number;
+	/** Role of the original message. */
+	role: "user" | "assistant";
+	/** One-line summary of the original content. */
+	summary: string;
+	/** Token count of original message. */
+	originalTokens: number;
+	/** Token count of tombstone (~10% of original). */
+	tombstoneTokens: number;
+	/** Hash of original content for lookup. */
+	originalHash: string;
+}
+
+export interface TombstoneStats {
+	/** Total messages tombstoned. */
+	messagesTombstoned: number;
+	/** Original total tokens. */
+	originalTokens: number;
+	/** Tombstone total tokens. */
+	tombstoneTokens: number;
+	/** Tokens saved. */
+	tokensSaved: number;
+	/** Compression ratio (tombstone/original). */
+	compressionRatio: number;
+}
+
+import { hashContent, estimateTokens } from "./context-delta";
+
+/**
+ * Generate a one-line summary from message content.
+ * Heuristic: first sentence or first 100 chars.
+ */
+function summarizeMessage(content: string): string {
+	// Take first sentence or first 100 chars
+	const firstSentence = content.match(/^[^.!?\n]{1,150}[.!?]?/);
+	if (firstSentence) {
+		const s = firstSentence[0].trim();
+		return s.length > 120 ? s.slice(0, 117) + "..." : s;
+	}
+	return content.length > 100 ? content.slice(0, 97) + "..." : content;
+}
+
+/**
+ * Build a tombstone line from an original message.
+ * Format: `[Turn N - user/assistant] Summary...`
+ */
+function buildTombstoneLine(entry: TombstoneEntry): string {
+	return `[Turn ${entry.originalIndex + 1} - ${entry.role}] ${entry.summary}`;
+}
+
+export class ConversationTombstoner {
+	#tombstones: TombstoneEntry[] = [];
+	#originals: Map<string, string> = new Map(); // hash → original content
+	#afterTurns: number;
+	#keepRecent: number;
+	#stats: TombstoneStats = {
+		messagesTombstoned: 0,
+		originalTokens: 0,
+		tombstoneTokens: 0,
+		tokensSaved: 0,
+		compressionRatio: 0,
+	};
+
+	constructor(afterTurns: number = 20, keepRecent: number = 5) {
+		this.#afterTurns = afterTurns;
+		this.#keepRecent = keepRecent;
+	}
+
+	/**
+	 * Process conversation messages — tombstone old ones, keep recent.
+	 * Returns the compressed conversation with tombstones replacing old messages.
+	 */
+	tombstone(messages: Array<{ role: "user" | "assistant"; content: string }>): {
+		compressed: Array<{ role: "user" | "assistant"; content: string }>;
+		tombstoned: number;
+		tokensSaved: number;
+	} {
+		if (messages.length <= this.#keepRecent + this.#afterTurns) {
+			return { compressed: messages, tombstoned: 0, tokensSaved: 0 };
+		}
+
+		const cutoff = messages.length - this.#keepRecent;
+		const toTombstone = messages.slice(0, cutoff);
+		const toKeep = messages.slice(cutoff);
+
+		let totalOriginalTokens = 0;
+		let totalTombstoneTokens = 0;
+		let tombstoned = 0;
+
+		const compressedTombstones: Array<{ role: "user" | "assistant"; content: string }> = [];
+
+		for (let i = 0; i < toTombstone.length; i++) {
+			const msg = toTombstone[i];
+			const originalTokens = estimateTokens(msg.content);
+			const summary = summarizeMessage(msg.content);
+			const hash = hashContent(msg.content);
+
+			// Store original for lookup
+			this.#originals.set(hash, msg.content);
+
+			const tombstoneTokens = estimateTokens(summary) + 5; // +5 for formatting
+
+			this.#tombstones.push({
+				originalIndex: i,
+				role: msg.role,
+				summary,
+				originalTokens,
+				tombstoneTokens,
+				originalHash: hash,
+			});
+
+			totalOriginalTokens += originalTokens;
+			totalTombstoneTokens += tombstoneTokens;
+			tombstoned++;
+
+			compressedTombstones.push({
+				role: msg.role,
+				content: buildTombstoneLine(this.#tombstones[this.#tombstones.length - 1]),
+			});
+		}
+
+		const tokensSaved = totalOriginalTokens - totalTombstoneTokens;
+
+		this.#stats.messagesTombstoned += tombstoned;
+		this.#stats.originalTokens += totalOriginalTokens;
+		this.#stats.tombstoneTokens += totalTombstoneTokens;
+		this.#stats.tokensSaved += tokensSaved;
+		this.#stats.compressionRatio = this.#stats.originalTokens > 0
+			? this.#stats.tombstoneTokens / this.#stats.originalTokens
+			: 0;
+
+		return {
+			compressed: [...compressedTombstones, ...toKeep],
+			tombstoned,
+			tokensSaved,
+		};
+	}
+
+	/**
+	 * Look up original content by tombstone hash.
+	 * Returns null if not found.
+	 */
+	lookupOriginal(hash: string): string | null {
+		return this.#originals.get(hash) ?? null;
+	}
+
+	/**
+	 * Look up original by turn index.
+	 */
+	lookupByTurn(turnIndex: number): string | null {
+		const entry = this.#tombstones.find((t) => t.originalIndex === turnIndex);
+		if (!entry) return null;
+		return this.#originals.get(entry.originalHash) ?? null;
+	}
+
+	/** Get stats snapshot. */
+	get stats(): Readonly<TombstoneStats> {
+		return { ...this.#stats };
+	}
+
+	/** Get all tombstone entries. */
+	get entries(): ReadonlyArray<TombstoneEntry> {
+		return this.#tombstones;
+	}
+
+	/** Reset tombstoner state. */
+	reset(): void {
+		this.#tombstones = [];
+		this.#originals.clear();
+		this.#stats = {
+			messagesTombstoned: 0,
+			originalTokens: 0,
+			tombstoneTokens: 0,
+			tokensSaved: 0,
+			compressionRatio: 0,
+		};
+	}
+}

package/src/tbm/tool-compress.ts

@@ -0,0 +1,230 @@
+/**
+ * Tool Output Auto-Compress — truncate/summarize tool output to fit budgets.
+ *
+ * Each tool type has a token budget. Output exceeding the budget is compressed.
+ *
+ * | Tool | Max Budget | Strategy |
+ * |------|-----------|----------|
+ * | terminal | 500 tokens | Truncate + strip ANSI |
+ * | read_file | 800 tokens | Only relevant lines |
+ * | web_extract | 1,000 tokens | Summarize key content |
+ * | search_files | 300 tokens | Top N results only |
+ */
+
+import type { TbmConfig } from "./config";
+import { estimateTokens } from "./context-delta";
+
+export interface CompressStats {
+	/** Total tool outputs processed. */
+	totalOutputs: number;
+	/** Outputs that needed compression. */
+	compressed: number;
+	/** Tokens saved by compression. */
+	tokensSaved: number;
+	/** Per-tool compression counts. */
+	perTool: Record<string, { compressed: number; tokensSaved: number }>;
+}
+
+/** Strip ANSI escape codes from text. */
+function stripAnsi(text: string): string {
+	return text.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "").replace(/\x1B\][^\x07]*\x07/g, "");
+}
+
+/** Strip duplicate blank lines (3+ → 2). */
+function collapseBlankLines(text: string): string {
+	return text.replace(/\n{3,}/g, "\n\n");
+}
+
+/** Truncate text to fit within token budget, preserving start and end. */
+function truncateToBudget(text: string, maxTokens: number): { text: string; truncated: boolean } {
+	const currentTokens = estimateTokens(text);
+	if (currentTokens <= maxTokens) return { text, truncated: false };
+
+	// Keep 70% from start, 30% from end
+	const charBudget = maxTokens * 4;
+	const startChars = Math.floor(charBudget * 0.7);
+	const endChars = charBudget - startChars;
+
+	const start = text.slice(0, startChars);
+	const end = text.slice(-endChars);
+
+	return {
+		text: `${start}\n\n[... ${currentTokens - maxTokens} tokens compressed ...]\n\n${end}`,
+		truncated: true,
+	};
+}
+
+/** Extract top N search results from search_files output. */
+function topNResults(text: string, maxTokens: number): { text: string; truncated: boolean } {
+	const lines = text.split("\n");
+	const resultLines: string[] = [];
+	let tokens = 0;
+
+	for (const line of lines) {
+		const lineTokens = estimateTokens(line);
+		if (tokens + lineTokens > maxTokens) break;
+		resultLines.push(line);
+		tokens += lineTokens;
+	}
+
+	if (resultLines.length === lines.length) return { text, truncated: false };
+
+	return {
+		text: resultLines.join("\n") + `\n\n[... ${lines.length - resultLines.length} more results truncated ...]`,
+		truncated: true,
+	};
+}
+
+/** Compress terminal output: strip ANSI, collapse blanks, truncate. */
+function compressTerminal(text: string, maxTokens: number): { text: string; tokensSaved: number } {
+	let processed = stripAnsi(text);
+	processed = collapseBlankLines(processed);
+
+	const originalTokens = estimateTokens(text);
+	const result = truncateToBudget(processed, maxTokens);
+
+	return {
+		text: result.text,
+		tokensSaved: Math.max(0, originalTokens - estimateTokens(result.text)),
+	};
+}
+
+/** Compress file output: keep relevant lines around the middle. */
+function compressFileOutput(text: string, maxTokens: number): { text: string; tokensSaved: number } {
+	const originalTokens = estimateTokens(text);
+	const result = truncateToBudget(text, maxTokens);
+
+	return {
+		text: result.text,
+		tokensSaved: Math.max(0, originalTokens - estimateTokens(result.text)),
+	};
+}
+
+/** Compress web extract: keep first and last portions. */
+function compressWebExtract(text: string, maxTokens: number): { text: string; tokensSaved: number } {
+	const originalTokens = estimateTokens(text);
+
+	// Remove markdown formatting bloat
+	let processed = text
+		.replace(/\n{3,}/g, "\n\n")
+		.replace(/^\s*[-*]\s*$/gm, ""); // remove empty list items
+
+	const result = truncateToBudget(processed, maxTokens);
+
+	return {
+		text: result.text,
+		tokensSaved: Math.max(0, originalTokens - estimateTokens(result.text)),
+	};
+}
+
+/** Compress search output: keep top results. */
+function compressSearch(text: string, maxTokens: number): { text: string; tokensSaved: number } {
+	const originalTokens = estimateTokens(text);
+	const result = topNResults(text, maxTokens);
+
+	return {
+		text: result.text,
+		tokensSaved: Math.max(0, originalTokens - estimateTokens(result.text)),
+	};
+}
+
+export class ToolOutputCompressor {
+	#budgets: TbmConfig["compress"]["budgets"];
+	#stats: CompressStats = {
+		totalOutputs: 0,
+		compressed: 0,
+		tokensSaved: 0,
+		perTool: {},
+	};
+
+	constructor(budgets: TbmConfig["compress"]["budgets"]) {
+		this.#budgets = budgets;
+	}
+
+	/**
+	 * Compress tool output to fit within its budget.
+	 * Returns the (possibly compressed) output and stats.
+	 */
+	compress(toolName: string, output: string): { output: string; compressed: boolean; tokensSaved: number } {
+		this.#stats.totalOutputs++;
+
+		const budget = this.#getBudget(toolName);
+		const currentTokens = estimateTokens(output);
+
+		if (currentTokens <= budget) {
+			return { output, compressed: false, tokensSaved: 0 };
+		}
+
+		let result: { text: string; tokensSaved: number };
+
+		switch (toolName) {
+			case "terminal":
+			case "execute_command":
+				result = compressTerminal(output, budget);
+				break;
+			case "read_file":
+			case "readFile":
+				result = compressFileOutput(output, budget);
+				break;
+			case "web_extract":
+			case "webExtract":
+				result = compressWebExtract(output, budget);
+				break;
+			case "search_files":
+			case "searchFiles":
+			case "grep":
+				result = compressSearch(output, budget);
+				break;
+			default:
+				result = { text: truncateToBudget(output, budget).text, tokensSaved: Math.max(0, currentTokens - budget) };
+		}
+
+		this.#stats.compressed++;
+		this.#stats.tokensSaved += result.tokensSaved;
+
+		if (!this.#stats.perTool[toolName]) {
+			this.#stats.perTool[toolName] = { compressed: 0, tokensSaved: 0 };
+		}
+		this.#stats.perTool[toolName].compressed++;
+		this.#stats.perTool[toolName].tokensSaved += result.tokensSaved;
+
+		return { output: result.text, compressed: true, tokensSaved: result.tokensSaved };
+	}
+
+	/** Get stats snapshot. */
+	get stats(): Readonly<CompressStats> {
+		return { ...this.#stats };
+	}
+
+	/** Get compression ratio (compressed / total). */
+	get compressionRatio(): number {
+		if (this.#stats.totalOutputs === 0) return 0;
+		return this.#stats.compressed / this.#stats.totalOutputs;
+	}
+
+	#getBudget(toolName: string): number {
+		const budgets = this.#budgets;
+		switch (toolName) {
+			case "terminal":
+			case "execute_command":
+				return budgets.terminal;
+			case "read_file":
+			case "readFile":
+				return budgets.read_file;
+			case "web_extract":
+			case "webExtract":
+				return budgets.web_extract;
+			case "search_files":
+			case "searchFiles":
+			case "grep":
+				return budgets.search_files;
+			default:
+				return budgets.default;
+		}
+	}
+
+	/** Reset stats. */
+	reset(): void {
+		this.#stats = { totalOutputs: 0, compressed: 0, tokensSaved: 0, perTool: {} };
+	}
+}

package/src/tools/ask.ts

@@ -484,7 +484,7 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 		const method = this.session.settings.get("ask.notify");
 		if (method === "off") return;
 		TERMINAL.sendNotification({
-			title: "Oh My Pi",
+			title: "SnsCoder",
 			body: "Waiting for input",
 			type: "ask",
 			urgency: "normal",