@agentmemory/agentmemory 0.8.11 → 0.8.12

package/dist/{src-M6V9yZW5.mjs → src-68MXysnV.mjs}

@@ -1,8 +1,8 @@
 import { a as jaccardSimilarity, i as generateId, n as STREAM, r as fingerprintId, t as KV } from "./cli.mjs";
-import { a as getEnvVar, c as isConsolidationEnabled, d as loadClaudeBridgeConfig, f as loadConfig, g as loadTeamConfig, h as loadSnapshotConfig, i as getConsolidationDecayDays, l as isContextInjectionEnabled, m as loadFallbackConfig, n as VERSION, p as loadEmbeddingConfig, r as detectEmbeddingProvider, s as isAutoCompressEnabled, t as getVisibleTools, u as isGraphExtractionEnabled } from "./tools-registry-DmTkd0if.mjs";
+import { a as getEnvVar, c as isConsolidationEnabled, d as loadClaudeBridgeConfig, f as loadConfig, g as loadTeamConfig, h as loadSnapshotConfig, i as getConsolidationDecayDays, l as isContextInjectionEnabled, m as loadFallbackConfig, n as VERSION, p as loadEmbeddingConfig, r as detectEmbeddingProvider, s as isAutoCompressEnabled, t as getVisibleTools, u as isGraphExtractionEnabled } from "./tools-registry-D96ukJg4.mjs";
 import { execFile } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join, resolve, sep } from "node:path";
+import { basename, dirname, extname, join, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";
 import { createHash, createHmac, randomBytes, timingSafeEqual } from "node:crypto";
@@ -12,7 +12,7 @@ import { z } from "zod";
 import { promisify } from "node:util";
 import { lookup } from "node:dns/promises";
 import { isIP } from "node:net";
-import { mkdir, writeFile } from "node:fs/promises";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { createServer } from "node:http";
 
 //#region src/providers/agent-sdk.ts
@@ -2041,6 +2041,17 @@ function registerSearchFunction(sdk, kv) {
 		}
 		const projectFilter = typeof data.project === "string" && data.project.length > 0 ? data.project : void 0;
 		const cwdFilter = typeof data.cwd === "string" && data.cwd.length > 0 ? data.cwd : void 0;
+		const format = typeof data.format === "string" ? data.format : "full";
+		if (![
+			"full",
+			"compact",
+			"narrative"
+		].includes(format)) throw new Error("mem::search: format must be one of 'full', 'compact', or 'narrative'");
+		let tokenBudget;
+		if (data.token_budget !== void 0) {
+			if (!Number.isInteger(data.token_budget) || data.token_budget < 1) throw new Error("mem::search: token_budget must be a positive integer");
+			tokenBudget = data.token_budget;
+		}
 		if (idx.size === 0) {
 			const count = await rebuildIndex(kv);
 			logger.info("Search index rebuilt", { entries: count });
@@ -2077,13 +2088,81 @@ function registerSearchFunction(sdk, kv) {
 			});
 		}
 		recordAccessBatch(kv, enriched.map((r) => r.observation.id));
+		const estimateTokens = (value) => Math.max(1, Math.ceil(JSON.stringify(value).length / 3));
+		const applyTokenBudget = (items) => {
+			if (!tokenBudget) return {
+				items,
+				used: items.reduce((sum, item) => sum + estimateTokens(item), 0),
+				truncated: false
+			};
+			const selected = [];
+			let used = 0;
+			for (const item of items) {
+				const itemTokens = estimateTokens(item);
+				if (used + itemTokens > tokenBudget) return {
+					items: selected,
+					used,
+					truncated: selected.length < items.length
+				};
+				selected.push(item);
+				used += itemTokens;
+			}
+			return {
+				items: selected,
+				used,
+				truncated: false
+			};
+		};
+		if (format === "compact") {
+			const packed = applyTokenBudget(enriched.map((r) => ({
+				obsId: r.observation.id,
+				sessionId: r.sessionId,
+				title: r.observation.title,
+				type: r.observation.type,
+				score: r.score,
+				timestamp: r.observation.timestamp
+			})));
+			return {
+				format,
+				results: packed.items,
+				tokens_used: packed.used,
+				tokens_budget: tokenBudget,
+				truncated: packed.truncated
+			};
+		}
+		if (format === "narrative") {
+			const packed = applyTokenBudget(enriched.map((r) => ({
+				obsId: r.observation.id,
+				sessionId: r.sessionId,
+				title: r.observation.title,
+				narrative: r.observation.narrative,
+				score: r.score,
+				timestamp: r.observation.timestamp
+			})));
+			const text = packed.items.map((r, index) => `${index + 1}. ${r.title}\n${r.narrative}`).join("\n\n");
+			return {
+				format,
+				results: packed.items,
+				text,
+				tokens_used: packed.used,
+				tokens_budget: tokenBudget,
+				truncated: packed.truncated
+			};
+		}
+		const packed = applyTokenBudget(enriched);
 		logger.info("Search completed", {
 			query,
-			results: enriched.length,
+			results: packed.items.length,
 			hasProjectFilter: !!projectFilter,
 			hasCwdFilter: !!cwdFilter
 		});
-		return { results: enriched };
+		return {
+			format,
+			results: packed.items,
+			tokens_used: packed.used,
+			tokens_budget: tokenBudget,
+			truncated: packed.truncated
+		};
 	});
 }
 
@@ -4283,7 +4362,8 @@ function registerExportImportFunction(sdk, kv) {
 			"0.8.8",
 			"0.8.9",
 			"0.8.10",
-			"0.8.11"
+			"0.8.11",
+			"0.8.12"
 		]).has(importData.version)) return {
 			success: false,
 			error: `Unsupported export version: ${importData.version}`
@@ -10702,6 +10782,121 @@ function registerRetentionFunctions(sdk, kv) {
 	});
 }
 
+//#endregion
+//#region src/functions/compress-file.ts
+const SENSITIVE_PATH_TERMS = [
+	"secret",
+	"credential",
+	"private_key",
+	".env",
+	"id_rsa",
+	"token"
+];
+const COMPRESS_FILE_SYSTEM_PROMPT = `You compress markdown while preserving structure.
+Rules:
+- Keep all headings exactly as-is.
+- Keep all URLs exactly as-is.
+- Keep all fenced code blocks exactly as-is.
+- Do not remove sections; shorten prose under each section.
+- Output only markdown, no wrappers or explanations.`;
+function stripMarkdownFence(text) {
+	const trimmed = text.trim();
+	const match = trimmed.match(/^```(?:markdown|md)?\s*([\s\S]*?)\s*```$/i);
+	return match ? match[1].trim() : trimmed;
+}
+function extractUrls(text) {
+	return Array.from(new Set(text.match(/https?:\/\/[^\s)]+/g) || []));
+}
+function extractHeadings(text) {
+	return text.split("\n").map((line) => line.trim()).filter((line) => /^#{1,6}\s+/.test(line));
+}
+function extractCodeBlocks(text) {
+	return text.match(/```[\s\S]*?```/g) || [];
+}
+function validateCompression(original, compressed) {
+	const errors = [];
+	const originalHeadings = extractHeadings(original);
+	const compressedHeadings = extractHeadings(compressed);
+	for (const heading of originalHeadings) if (!compressedHeadings.includes(heading)) errors.push(`missing heading: ${heading}`);
+	const originalUrls = extractUrls(original).sort();
+	const compressedUrls = extractUrls(compressed).sort();
+	if (originalUrls.length !== compressedUrls.length) errors.push("url count changed");
+	else for (let i = 0; i < originalUrls.length; i++) if (originalUrls[i] !== compressedUrls[i]) {
+		errors.push("url set changed");
+		break;
+	}
+	const originalBlocks = extractCodeBlocks(original);
+	const compressedBlocks = extractCodeBlocks(compressed);
+	if (originalBlocks.length !== compressedBlocks.length) errors.push("code block count changed");
+	else for (let i = 0; i < originalBlocks.length; i++) if (originalBlocks[i] !== compressedBlocks[i]) {
+		errors.push("code block content changed");
+		break;
+	}
+	return errors;
+}
+function resolveBackupPath(filePath) {
+	const base = basename(filePath, extname(filePath));
+	const name = base.endsWith(".original") ? base : `${base}.original`;
+	return join(dirname(filePath), `${name}.md`);
+}
+function registerCompressFileFunction(sdk, kv, provider) {
+	sdk.registerFunction("mem::compress-file", async (data) => {
+		if (!data?.filePath || typeof data.filePath !== "string") return {
+			success: false,
+			error: "filePath is required"
+		};
+		const absolutePath = resolve(data.filePath);
+		const lowerPath = absolutePath.toLowerCase();
+		if (extname(absolutePath).toLowerCase() !== ".md") return {
+			success: false,
+			error: "filePath must point to a .md file"
+		};
+		if (SENSITIVE_PATH_TERMS.some((term) => lowerPath.includes(term))) return {
+			success: false,
+			error: "refusing to process sensitive-looking path"
+		};
+		let original;
+		try {
+			original = await readFile(absolutePath, "utf-8");
+		} catch {
+			return {
+				success: false,
+				error: "failed to read file"
+			};
+		}
+		if (!original.trim()) return {
+			success: true,
+			skipped: true,
+			reason: "file is empty"
+		};
+		const compressed = stripMarkdownFence(await provider.summarize(COMPRESS_FILE_SYSTEM_PROMPT, `Compress this markdown file while preserving structure and code blocks:\n\n${original}`));
+		const validationErrors = validateCompression(original, compressed);
+		if (validationErrors.length > 0) return {
+			success: false,
+			error: "compression validation failed",
+			details: validationErrors
+		};
+		const backupPath = resolveBackupPath(absolutePath);
+		await writeFile(backupPath, original, "utf-8");
+		await writeFile(absolutePath, compressed, "utf-8");
+		try {
+			await recordAudit(kv, "compress", "mem::compress-file", [], {
+				filePath: absolutePath,
+				backupPath,
+				originalChars: original.length,
+				compressedChars: compressed.length
+			});
+		} catch {}
+		return {
+			success: true,
+			filePath: absolutePath,
+			backupPath,
+			originalChars: original.length,
+			compressedChars: compressed.length
+		};
+	});
+}
+
 //#endregion
 //#region src/health/thresholds.ts
 const DEFAULTS = {
@@ -11082,11 +11277,25 @@ function registerApiTriggers(sdk, kv, secret, metricsStore, provider) {
 			status_code: 400,
 			body: { error: "cwd must be a string" }
 		};
+		if (body.format !== void 0 && (typeof body.format !== "string" || ![
+			"full",
+			"compact",
+			"narrative"
+		].includes(body.format.trim().toLowerCase()))) return {
+			status_code: 400,
+			body: { error: "format must be one of: full, compact, narrative" }
+		};
+		if (body.token_budget !== void 0 && (!Number.isInteger(body.token_budget) || body.token_budget < 1)) return {
+			status_code: 400,
+			body: { error: "token_budget must be a positive integer" }
+		};
 		const payload = {
 			query: body.query.trim(),
 			limit: body.limit,
 			project: body.project,
-			cwd: body.cwd
+			cwd: body.cwd,
+			format: typeof body.format === "string" ? body.format.trim().toLowerCase() : void 0,
+			token_budget: body.token_budget
 		};
 		return {
 			status_code: 200,
@@ -11105,6 +11314,30 @@ function registerApiTriggers(sdk, kv, secret, metricsStore, provider) {
 			middleware_function_ids: ["middleware::api-auth"]
 		}
 	});
+	sdk.registerFunction("api::compress-file", async (req) => {
+		const authErr = checkAuth(req, secret);
+		if (authErr) return authErr;
+		const filePath = asNonEmptyString$1((req.body ?? {}).filePath);
+		if (!filePath) return {
+			status_code: 400,
+			body: { error: "filePath is required and must be a non-empty string" }
+		};
+		return {
+			status_code: 200,
+			body: await sdk.trigger({
+				function_id: "mem::compress-file",
+				payload: { filePath }
+			})
+		};
+	});
+	sdk.registerTrigger({
+		type: "http",
+		function_id: "api::compress-file",
+		config: {
+			api_path: "/agentmemory/compress-file",
+			http_method: "POST"
+		}
+	});
 	sdk.registerFunction("api::session::start", async (req) => {
 		const body = req.body ?? {};
 		const sessionId = asNonEmptyString$1(body.sessionId);
@@ -13609,13 +13842,46 @@ function registerMcpEndpoints(sdk, kv, secret) {
 						status_code: 400,
 						body: { error: "query is required for memory_recall" }
 					};
+					const format = typeof args.format === "string" ? args.format.trim().toLowerCase() : "full";
+					if (![
+						"full",
+						"compact",
+						"narrative"
+					].includes(format)) return {
+						status_code: 400,
+						body: { error: "format must be one of: full, compact, narrative" }
+					};
+					const tokenBudget = asNumber(args.token_budget);
+					if (args.token_budget !== void 0 && (!Number.isInteger(tokenBudget) || (tokenBudget ?? 0) < 1)) return {
+						status_code: 400,
+						body: { error: "token_budget must be a positive integer" }
+					};
 					const result = await sdk.trigger({
 						function_id: "mem::search",
 						payload: {
 							query: args.query,
-							limit: typeof args.limit === "number" ? args.limit : 10
+							limit: typeof args.limit === "number" ? args.limit : 10,
+							format,
+							token_budget: tokenBudget
 						}
 					});
+					return {
+						status_code: 200,
+						body: { content: [{
+							type: "text",
+							text: format === "narrative" && result && typeof result === "object" && "text" in result && typeof result.text === "string" ? result.text : JSON.stringify(result, null, 2)
+						}] }
+					};
+				}
+				case "memory_compress_file": {
+					if (typeof args.filePath !== "string" || !args.filePath.trim()) return {
+						status_code: 400,
+						body: { error: "filePath is required for memory_compress_file" }
+					};
+					const result = await sdk.trigger({
+						function_id: "mem::compress-file",
+						payload: { filePath: args.filePath.trim() }
+					});
 					return {
 						status_code: 200,
 						body: { content: [{
@@ -15323,6 +15589,7 @@ async function main() {
 	registerQueryExpansionFunction(sdk, provider);
 	registerTemporalGraphFunctions(sdk, kv, provider);
 	registerRetentionFunctions(sdk, kv);
+	registerCompressFileFunction(sdk, kv, provider);
 	console.log(`[agentmemory] v0.6 advanced retrieval: sliding-window, query-expansion, temporal-graph, retention-scoring`);
 	console.log(`[agentmemory] Orchestration layer: actions, frontier, leases, routines, signals, checkpoints, flow-compress, mesh, branch-aware, sentinels, sketches, crystallize, diagnostics, facets`);
 	const snapshotConfig = loadSnapshotConfig();
@@ -15362,7 +15629,7 @@ async function main() {
 		}
 	}
 	console.log(`[agentmemory] Ready. ${embeddingProvider ? "Triple-stream (BM25+Vector+Graph)" : "BM25+Graph"} search active.`);
-	console.log(`[agentmemory] Endpoints: 103 REST + 43 MCP tools + 6 MCP resources + 3 MCP prompts`);
+	console.log(`[agentmemory] Endpoints: 104 REST + 44 MCP tools + 6 MCP resources + 3 MCP prompts`);
 	const viewerServer = startViewerServer(config.restPort + 2, kv, sdk, secret, config.restPort);
 	const autoForgetIntervalMs = parseInt(process.env.AUTO_FORGET_INTERVAL_MS || "3600000", 10);
 	const consolidationIntervalMs = parseInt(process.env.CONSOLIDATION_INTERVAL_MS || "7200000", 10);
@@ -15429,4 +15696,4 @@ main().catch((err) => {
 
 //#endregion
 export {  };
-//# sourceMappingURL=src-M6V9yZW5.mjs.map
+//# sourceMappingURL=src-68MXysnV.mjs.map