@noxsoft/anima 2.0.0

package/dist/skills-status-Clq9ZnYu.js

@@ -0,0 +1,166 @@
+import { t as __exportAll } from "./rolldown-runtime-Cbj13DAv.js";
+import { t as createSubsystemLogger } from "./subsystem-Dowf8fSU.js";
+import { t as CONFIG_DIR } from "./utils-Bsw__U-F.js";
+import { d as isBundledSkillAllowed, f as isConfigPathTruthy, i as loadWorkspaceSkillEntries, m as resolveSkillConfig, p as resolveBundledAllowlist, s as resolveBundledSkillsDir, t as resolveSkillsInstallPreferences, x as hasBinary } from "./skills-B-G7UHOa.js";
+import { t as evaluateRequirementsFromMetadata } from "./requirements-DIW1svgA.js";
+import path from "node:path";
+import { loadSkillsFromDir } from "@mariozechner/pi-coding-agent";
+
+//#region src/agents/skills/bundled-context.ts
+const skillsLogger = createSubsystemLogger("skills");
+let hasWarnedMissingBundledDir = false;
+let cachedBundledContext = null;
+function resolveBundledSkillsContext(opts = {}) {
+	const dir = resolveBundledSkillsDir(opts);
+	const names = /* @__PURE__ */ new Set();
+	if (!dir) {
+		if (!hasWarnedMissingBundledDir) {
+			hasWarnedMissingBundledDir = true;
+			skillsLogger.warn("Bundled skills directory could not be resolved; built-in skills may be missing.");
+		}
+		return {
+			dir,
+			names
+		};
+	}
+	if (cachedBundledContext?.dir === dir) return {
+		dir,
+		names: new Set(cachedBundledContext.names)
+	};
+	const result = loadSkillsFromDir({
+		dir,
+		source: "anima-bundled"
+	});
+	for (const skill of result.skills) if (skill.name.trim()) names.add(skill.name);
+	cachedBundledContext = {
+		dir,
+		names: new Set(names)
+	};
+	return {
+		dir,
+		names
+	};
+}
+
+//#endregion
+//#region src/agents/skills-status.ts
+var skills_status_exports = /* @__PURE__ */ __exportAll({ buildWorkspaceSkillStatus: () => buildWorkspaceSkillStatus });
+function resolveSkillKey(entry) {
+	return entry.metadata?.skillKey ?? entry.skill.name;
+}
+function selectPreferredInstallSpec(install, prefs) {
+	if (install.length === 0) return;
+	const indexed = install.map((spec, index) => ({
+		spec,
+		index
+	}));
+	const findKind = (kind) => indexed.find((item) => item.spec.kind === kind);
+	const brewSpec = findKind("brew");
+	const nodeSpec = findKind("node");
+	const goSpec = findKind("go");
+	const uvSpec = findKind("uv");
+	if (prefs.preferBrew && hasBinary("brew") && brewSpec) return brewSpec;
+	if (uvSpec) return uvSpec;
+	if (nodeSpec) return nodeSpec;
+	if (brewSpec) return brewSpec;
+	if (goSpec) return goSpec;
+	return indexed[0];
+}
+function normalizeInstallOptions(entry, prefs) {
+	const requiredOs = entry.metadata?.os ?? [];
+	if (requiredOs.length > 0 && !requiredOs.includes(process.platform)) return [];
+	const install = entry.metadata?.install ?? [];
+	if (install.length === 0) return [];
+	const platform = process.platform;
+	const filtered = install.filter((spec) => {
+		const osList = spec.os ?? [];
+		return osList.length === 0 || osList.includes(platform);
+	});
+	if (filtered.length === 0) return [];
+	const toOption = (spec, index) => {
+		const id = (spec.id ?? `${spec.kind}-${index}`).trim();
+		const bins = spec.bins ?? [];
+		let label = (spec.label ?? "").trim();
+		if (spec.kind === "node" && spec.package) label = `Install ${spec.package} (${prefs.nodeManager})`;
+		if (!label) if (spec.kind === "brew" && spec.formula) label = `Install ${spec.formula} (brew)`;
+		else if (spec.kind === "node" && spec.package) label = `Install ${spec.package} (${prefs.nodeManager})`;
+		else if (spec.kind === "go" && spec.module) label = `Install ${spec.module} (go)`;
+		else if (spec.kind === "uv" && spec.package) label = `Install ${spec.package} (uv)`;
+		else if (spec.kind === "download" && spec.url) {
+			const url = spec.url.trim();
+			const last = url.split("/").pop();
+			label = `Download ${last && last.length > 0 ? last : url}`;
+		} else label = "Run installer";
+		return {
+			id,
+			kind: spec.kind,
+			label,
+			bins
+		};
+	};
+	if (filtered.every((spec) => spec.kind === "download")) return filtered.map((spec, index) => toOption(spec, index));
+	const preferred = selectPreferredInstallSpec(filtered, prefs);
+	if (!preferred) return [];
+	return [toOption(preferred.spec, preferred.index)];
+}
+function buildSkillStatus(entry, config, prefs, eligibility, bundledNames) {
+	const skillKey = resolveSkillKey(entry);
+	const skillConfig = resolveSkillConfig(config, skillKey);
+	const disabled = skillConfig?.enabled === false;
+	const blockedByAllowlist = !isBundledSkillAllowed(entry, resolveBundledAllowlist(config));
+	const always = entry.metadata?.always === true;
+	const emoji = entry.metadata?.emoji ?? entry.frontmatter.emoji;
+	const homepageRaw = entry.metadata?.homepage ?? entry.frontmatter.homepage ?? entry.frontmatter.website ?? entry.frontmatter.url;
+	const homepage = homepageRaw?.trim() ? homepageRaw.trim() : void 0;
+	const bundled = bundledNames && bundledNames.size > 0 ? bundledNames.has(entry.skill.name) : entry.skill.source === "anima-bundled";
+	const { required, missing, eligible: requirementsSatisfied, configChecks } = evaluateRequirementsFromMetadata({
+		always,
+		metadata: entry.metadata,
+		hasLocalBin: hasBinary,
+		hasRemoteBin: eligibility?.remote?.hasBin,
+		hasRemoteAnyBin: eligibility?.remote?.hasAnyBin,
+		localPlatform: process.platform,
+		remotePlatforms: eligibility?.remote?.platforms,
+		isEnvSatisfied: (envName) => Boolean(process.env[envName] || skillConfig?.env?.[envName] || skillConfig?.apiKey && entry.metadata?.primaryEnv === envName),
+		isConfigSatisfied: (pathStr) => isConfigPathTruthy(config, pathStr)
+	});
+	const eligible = !disabled && !blockedByAllowlist && requirementsSatisfied;
+	return {
+		name: entry.skill.name,
+		description: entry.skill.description,
+		source: entry.skill.source,
+		bundled,
+		filePath: entry.skill.filePath,
+		baseDir: entry.skill.baseDir,
+		skillKey,
+		primaryEnv: entry.metadata?.primaryEnv,
+		emoji,
+		homepage,
+		always,
+		disabled,
+		blockedByAllowlist,
+		eligible,
+		requirements: required,
+		missing,
+		configChecks,
+		install: normalizeInstallOptions(entry, prefs ?? resolveSkillsInstallPreferences(config))
+	};
+}
+function buildWorkspaceSkillStatus(workspaceDir, opts) {
+	const managedSkillsDir = opts?.managedSkillsDir ?? path.join(CONFIG_DIR, "skills");
+	const bundledContext = resolveBundledSkillsContext();
+	const skillEntries = opts?.entries ?? loadWorkspaceSkillEntries(workspaceDir, {
+		config: opts?.config,
+		managedSkillsDir,
+		bundledSkillsDir: bundledContext.dir
+	});
+	const prefs = resolveSkillsInstallPreferences(opts?.config);
+	return {
+		workspaceDir,
+		managedSkillsDir,
+		skills: skillEntries.map((entry) => buildSkillStatus(entry, opts?.config, prefs, opts?.eligibility, bundledContext.names))
+	};
+}
+
+//#endregion
+export { skills_status_exports as n, buildWorkspaceSkillStatus as t };

package/dist/skills-status-JQluhU-P.js

@@ -0,0 +1,166 @@
+import { t as __exportAll } from "./rolldown-runtime-Cbj13DAv.js";
+import { o as createSubsystemLogger } from "./entry.js";
+import { t as CONFIG_DIR } from "./utils-C9sj30YY.js";
+import { t as evaluateRequirementsFromMetadata } from "./requirements-BzZxj2Wu.js";
+import { d as isBundledSkillAllowed, f as isConfigPathTruthy, i as loadWorkspaceSkillEntries, m as resolveSkillConfig, p as resolveBundledAllowlist, s as resolveBundledSkillsDir, t as resolveSkillsInstallPreferences, x as hasBinary } from "./skills-B5LQx4lT.js";
+import path from "node:path";
+import { loadSkillsFromDir } from "@mariozechner/pi-coding-agent";
+
+//#region src/agents/skills/bundled-context.ts
+const skillsLogger = createSubsystemLogger("skills");
+let hasWarnedMissingBundledDir = false;
+let cachedBundledContext = null;
+function resolveBundledSkillsContext(opts = {}) {
+	const dir = resolveBundledSkillsDir(opts);
+	const names = /* @__PURE__ */ new Set();
+	if (!dir) {
+		if (!hasWarnedMissingBundledDir) {
+			hasWarnedMissingBundledDir = true;
+			skillsLogger.warn("Bundled skills directory could not be resolved; built-in skills may be missing.");
+		}
+		return {
+			dir,
+			names
+		};
+	}
+	if (cachedBundledContext?.dir === dir) return {
+		dir,
+		names: new Set(cachedBundledContext.names)
+	};
+	const result = loadSkillsFromDir({
+		dir,
+		source: "anima-bundled"
+	});
+	for (const skill of result.skills) if (skill.name.trim()) names.add(skill.name);
+	cachedBundledContext = {
+		dir,
+		names: new Set(names)
+	};
+	return {
+		dir,
+		names
+	};
+}
+
+//#endregion
+//#region src/agents/skills-status.ts
+var skills_status_exports = /* @__PURE__ */ __exportAll({ buildWorkspaceSkillStatus: () => buildWorkspaceSkillStatus });
+function resolveSkillKey(entry) {
+	return entry.metadata?.skillKey ?? entry.skill.name;
+}
+function selectPreferredInstallSpec(install, prefs) {
+	if (install.length === 0) return;
+	const indexed = install.map((spec, index) => ({
+		spec,
+		index
+	}));
+	const findKind = (kind) => indexed.find((item) => item.spec.kind === kind);
+	const brewSpec = findKind("brew");
+	const nodeSpec = findKind("node");
+	const goSpec = findKind("go");
+	const uvSpec = findKind("uv");
+	if (prefs.preferBrew && hasBinary("brew") && brewSpec) return brewSpec;
+	if (uvSpec) return uvSpec;
+	if (nodeSpec) return nodeSpec;
+	if (brewSpec) return brewSpec;
+	if (goSpec) return goSpec;
+	return indexed[0];
+}
+function normalizeInstallOptions(entry, prefs) {
+	const requiredOs = entry.metadata?.os ?? [];
+	if (requiredOs.length > 0 && !requiredOs.includes(process.platform)) return [];
+	const install = entry.metadata?.install ?? [];
+	if (install.length === 0) return [];
+	const platform = process.platform;
+	const filtered = install.filter((spec) => {
+		const osList = spec.os ?? [];
+		return osList.length === 0 || osList.includes(platform);
+	});
+	if (filtered.length === 0) return [];
+	const toOption = (spec, index) => {
+		const id = (spec.id ?? `${spec.kind}-${index}`).trim();
+		const bins = spec.bins ?? [];
+		let label = (spec.label ?? "").trim();
+		if (spec.kind === "node" && spec.package) label = `Install ${spec.package} (${prefs.nodeManager})`;
+		if (!label) if (spec.kind === "brew" && spec.formula) label = `Install ${spec.formula} (brew)`;
+		else if (spec.kind === "node" && spec.package) label = `Install ${spec.package} (${prefs.nodeManager})`;
+		else if (spec.kind === "go" && spec.module) label = `Install ${spec.module} (go)`;
+		else if (spec.kind === "uv" && spec.package) label = `Install ${spec.package} (uv)`;
+		else if (spec.kind === "download" && spec.url) {
+			const url = spec.url.trim();
+			const last = url.split("/").pop();
+			label = `Download ${last && last.length > 0 ? last : url}`;
+		} else label = "Run installer";
+		return {
+			id,
+			kind: spec.kind,
+			label,
+			bins
+		};
+	};
+	if (filtered.every((spec) => spec.kind === "download")) return filtered.map((spec, index) => toOption(spec, index));
+	const preferred = selectPreferredInstallSpec(filtered, prefs);
+	if (!preferred) return [];
+	return [toOption(preferred.spec, preferred.index)];
+}
+function buildSkillStatus(entry, config, prefs, eligibility, bundledNames) {
+	const skillKey = resolveSkillKey(entry);
+	const skillConfig = resolveSkillConfig(config, skillKey);
+	const disabled = skillConfig?.enabled === false;
+	const blockedByAllowlist = !isBundledSkillAllowed(entry, resolveBundledAllowlist(config));
+	const always = entry.metadata?.always === true;
+	const emoji = entry.metadata?.emoji ?? entry.frontmatter.emoji;
+	const homepageRaw = entry.metadata?.homepage ?? entry.frontmatter.homepage ?? entry.frontmatter.website ?? entry.frontmatter.url;
+	const homepage = homepageRaw?.trim() ? homepageRaw.trim() : void 0;
+	const bundled = bundledNames && bundledNames.size > 0 ? bundledNames.has(entry.skill.name) : entry.skill.source === "anima-bundled";
+	const { required, missing, eligible: requirementsSatisfied, configChecks } = evaluateRequirementsFromMetadata({
+		always,
+		metadata: entry.metadata,
+		hasLocalBin: hasBinary,
+		hasRemoteBin: eligibility?.remote?.hasBin,
+		hasRemoteAnyBin: eligibility?.remote?.hasAnyBin,
+		localPlatform: process.platform,
+		remotePlatforms: eligibility?.remote?.platforms,
+		isEnvSatisfied: (envName) => Boolean(process.env[envName] || skillConfig?.env?.[envName] || skillConfig?.apiKey && entry.metadata?.primaryEnv === envName),
+		isConfigSatisfied: (pathStr) => isConfigPathTruthy(config, pathStr)
+	});
+	const eligible = !disabled && !blockedByAllowlist && requirementsSatisfied;
+	return {
+		name: entry.skill.name,
+		description: entry.skill.description,
+		source: entry.skill.source,
+		bundled,
+		filePath: entry.skill.filePath,
+		baseDir: entry.skill.baseDir,
+		skillKey,
+		primaryEnv: entry.metadata?.primaryEnv,
+		emoji,
+		homepage,
+		always,
+		disabled,
+		blockedByAllowlist,
+		eligible,
+		requirements: required,
+		missing,
+		configChecks,
+		install: normalizeInstallOptions(entry, prefs ?? resolveSkillsInstallPreferences(config))
+	};
+}
+function buildWorkspaceSkillStatus(workspaceDir, opts) {
+	const managedSkillsDir = opts?.managedSkillsDir ?? path.join(CONFIG_DIR, "skills");
+	const bundledContext = resolveBundledSkillsContext();
+	const skillEntries = opts?.entries ?? loadWorkspaceSkillEntries(workspaceDir, {
+		config: opts?.config,
+		managedSkillsDir,
+		bundledSkillsDir: bundledContext.dir
+	});
+	const prefs = resolveSkillsInstallPreferences(opts?.config);
+	return {
+		workspaceDir,
+		managedSkillsDir,
+		skills: skillEntries.map((entry) => buildSkillStatus(entry, opts?.config, prefs, opts?.eligibility, bundledContext.names))
+	};
+}
+
+//#endregion
+export { skills_status_exports as n, buildWorkspaceSkillStatus as t };

package/dist/sqlite-BukcjdJa.js

@@ -0,0 +1,321 @@
+import { o as createSubsystemLogger, t as installProcessWarningFilter } from "./entry.js";
+import { s as resolveSessionTranscriptsDirForAgent } from "./paths-CxRf2rBG.js";
+import { n as redactSensitiveText } from "./redact-ClVwO7Nn.js";
+import { createRequire } from "node:module";
+import path from "node:path";
+import fs from "node:fs";
+import fs$1 from "node:fs/promises";
+import crypto from "node:crypto";
+
+//#region src/memory/internal.ts
+function ensureDir(dir) {
+	try {
+		fs.mkdirSync(dir, { recursive: true });
+	} catch {}
+	return dir;
+}
+function normalizeRelPath(value) {
+	return value.trim().replace(/^[./]+/, "").replace(/\\/g, "/");
+}
+function normalizeExtraMemoryPaths(workspaceDir, extraPaths) {
+	if (!extraPaths?.length) return [];
+	const resolved = extraPaths.map((value) => value.trim()).filter(Boolean).map((value) => path.isAbsolute(value) ? path.resolve(value) : path.resolve(workspaceDir, value));
+	return Array.from(new Set(resolved));
+}
+function isMemoryPath(relPath) {
+	const normalized = normalizeRelPath(relPath);
+	if (!normalized) return false;
+	if (normalized === "MEMORY.md" || normalized === "memory.md") return true;
+	return normalized.startsWith("memory/");
+}
+async function walkDir(dir, files) {
+	const entries = await fs$1.readdir(dir, { withFileTypes: true });
+	for (const entry of entries) {
+		const full = path.join(dir, entry.name);
+		if (entry.isSymbolicLink()) continue;
+		if (entry.isDirectory()) {
+			await walkDir(full, files);
+			continue;
+		}
+		if (!entry.isFile()) continue;
+		if (!entry.name.endsWith(".md")) continue;
+		files.push(full);
+	}
+}
+async function listMemoryFiles(workspaceDir, extraPaths) {
+	const result = [];
+	const memoryFile = path.join(workspaceDir, "MEMORY.md");
+	const altMemoryFile = path.join(workspaceDir, "memory.md");
+	const memoryDir = path.join(workspaceDir, "memory");
+	const addMarkdownFile = async (absPath) => {
+		try {
+			const stat = await fs$1.lstat(absPath);
+			if (stat.isSymbolicLink() || !stat.isFile()) return;
+			if (!absPath.endsWith(".md")) return;
+			result.push(absPath);
+		} catch {}
+	};
+	await addMarkdownFile(memoryFile);
+	await addMarkdownFile(altMemoryFile);
+	try {
+		const dirStat = await fs$1.lstat(memoryDir);
+		if (!dirStat.isSymbolicLink() && dirStat.isDirectory()) await walkDir(memoryDir, result);
+	} catch {}
+	const normalizedExtraPaths = normalizeExtraMemoryPaths(workspaceDir, extraPaths);
+	if (normalizedExtraPaths.length > 0) for (const inputPath of normalizedExtraPaths) try {
+		const stat = await fs$1.lstat(inputPath);
+		if (stat.isSymbolicLink()) continue;
+		if (stat.isDirectory()) {
+			await walkDir(inputPath, result);
+			continue;
+		}
+		if (stat.isFile() && inputPath.endsWith(".md")) result.push(inputPath);
+	} catch {}
+	if (result.length <= 1) return result;
+	const seen = /* @__PURE__ */ new Set();
+	const deduped = [];
+	for (const entry of result) {
+		let key = entry;
+		try {
+			key = await fs$1.realpath(entry);
+		} catch {}
+		if (seen.has(key)) continue;
+		seen.add(key);
+		deduped.push(entry);
+	}
+	return deduped;
+}
+function hashText(value) {
+	return crypto.createHash("sha256").update(value).digest("hex");
+}
+async function buildFileEntry(absPath, workspaceDir) {
+	const stat = await fs$1.stat(absPath);
+	const hash = hashText(await fs$1.readFile(absPath, "utf-8"));
+	return {
+		path: path.relative(workspaceDir, absPath).replace(/\\/g, "/"),
+		absPath,
+		mtimeMs: stat.mtimeMs,
+		size: stat.size,
+		hash
+	};
+}
+function chunkMarkdown(content, chunking) {
+	const lines = content.split("\n");
+	if (lines.length === 0) return [];
+	const maxChars = Math.max(32, chunking.tokens * 4);
+	const overlapChars = Math.max(0, chunking.overlap * 4);
+	const chunks = [];
+	let current = [];
+	let currentChars = 0;
+	const flush = () => {
+		if (current.length === 0) return;
+		const firstEntry = current[0];
+		const lastEntry = current[current.length - 1];
+		if (!firstEntry || !lastEntry) return;
+		const text = current.map((entry) => entry.line).join("\n");
+		const startLine = firstEntry.lineNo;
+		const endLine = lastEntry.lineNo;
+		chunks.push({
+			startLine,
+			endLine,
+			text,
+			hash: hashText(text)
+		});
+	};
+	const carryOverlap = () => {
+		if (overlapChars <= 0 || current.length === 0) {
+			current = [];
+			currentChars = 0;
+			return;
+		}
+		let acc = 0;
+		const kept = [];
+		for (let i = current.length - 1; i >= 0; i -= 1) {
+			const entry = current[i];
+			if (!entry) continue;
+			acc += entry.line.length + 1;
+			kept.unshift(entry);
+			if (acc >= overlapChars) break;
+		}
+		current = kept;
+		currentChars = kept.reduce((sum, entry) => sum + entry.line.length + 1, 0);
+	};
+	for (let i = 0; i < lines.length; i += 1) {
+		const line = lines[i] ?? "";
+		const lineNo = i + 1;
+		const segments = [];
+		if (line.length === 0) segments.push("");
+		else for (let start = 0; start < line.length; start += maxChars) segments.push(line.slice(start, start + maxChars));
+		for (const segment of segments) {
+			const lineSize = segment.length + 1;
+			if (currentChars + lineSize > maxChars && current.length > 0) {
+				flush();
+				carryOverlap();
+			}
+			current.push({
+				line: segment,
+				lineNo
+			});
+			currentChars += lineSize;
+		}
+	}
+	flush();
+	return chunks;
+}
+/**
+* Remap chunk startLine/endLine from content-relative positions to original
+* source file positions using a lineMap.  Each entry in lineMap gives the
+* 1-indexed source line for the corresponding 0-indexed content line.
+*
+* This is used for session JSONL files where buildSessionEntry() flattens
+* messages into a plain-text string before chunking.  Without remapping the
+* stored line numbers would reference positions in the flattened text rather
+* than the original JSONL file.
+*/
+function remapChunkLines(chunks, lineMap) {
+	if (!lineMap || lineMap.length === 0) return;
+	for (const chunk of chunks) {
+		chunk.startLine = lineMap[chunk.startLine - 1] ?? chunk.startLine;
+		chunk.endLine = lineMap[chunk.endLine - 1] ?? chunk.endLine;
+	}
+}
+function parseEmbedding(raw) {
+	try {
+		const parsed = JSON.parse(raw);
+		return Array.isArray(parsed) ? parsed : [];
+	} catch {
+		return [];
+	}
+}
+function cosineSimilarity(a, b) {
+	if (a.length === 0 || b.length === 0) return 0;
+	const len = Math.min(a.length, b.length);
+	let dot = 0;
+	let normA = 0;
+	let normB = 0;
+	for (let i = 0; i < len; i += 1) {
+		const av = a[i] ?? 0;
+		const bv = b[i] ?? 0;
+		dot += av * bv;
+		normA += av * av;
+		normB += bv * bv;
+	}
+	if (normA === 0 || normB === 0) return 0;
+	return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+async function runWithConcurrency(tasks, limit) {
+	if (tasks.length === 0) return [];
+	const resolvedLimit = Math.max(1, Math.min(limit, tasks.length));
+	const results = Array.from({ length: tasks.length });
+	let next = 0;
+	let firstError = null;
+	const workers = Array.from({ length: resolvedLimit }, async () => {
+		while (true) {
+			if (firstError) return;
+			const index = next;
+			next += 1;
+			if (index >= tasks.length) return;
+			try {
+				results[index] = await tasks[index]();
+			} catch (err) {
+				firstError = err;
+				return;
+			}
+		}
+	});
+	await Promise.allSettled(workers);
+	if (firstError) throw firstError;
+	return results;
+}
+
+//#endregion
+//#region src/memory/session-files.ts
+const log = createSubsystemLogger("memory");
+async function listSessionFilesForAgent(agentId) {
+	const dir = resolveSessionTranscriptsDirForAgent(agentId);
+	try {
+		return (await fs$1.readdir(dir, { withFileTypes: true })).filter((entry) => entry.isFile()).map((entry) => entry.name).filter((name) => name.endsWith(".jsonl")).map((name) => path.join(dir, name));
+	} catch {
+		return [];
+	}
+}
+function sessionPathForFile(absPath) {
+	return path.join("sessions", path.basename(absPath)).replace(/\\/g, "/");
+}
+function normalizeSessionText(value) {
+	return value.replace(/\s*\n+\s*/g, " ").replace(/\s+/g, " ").trim();
+}
+function extractSessionText(content) {
+	if (typeof content === "string") {
+		const normalized = normalizeSessionText(content);
+		return normalized ? normalized : null;
+	}
+	if (!Array.isArray(content)) return null;
+	const parts = [];
+	for (const block of content) {
+		if (!block || typeof block !== "object") continue;
+		const record = block;
+		if (record.type !== "text" || typeof record.text !== "string") continue;
+		const normalized = normalizeSessionText(record.text);
+		if (normalized) parts.push(normalized);
+	}
+	if (parts.length === 0) return null;
+	return parts.join(" ");
+}
+async function buildSessionEntry(absPath) {
+	try {
+		const stat = await fs$1.stat(absPath);
+		const lines = (await fs$1.readFile(absPath, "utf-8")).split("\n");
+		const collected = [];
+		const lineMap = [];
+		for (let jsonlIdx = 0; jsonlIdx < lines.length; jsonlIdx++) {
+			const line = lines[jsonlIdx];
+			if (!line.trim()) continue;
+			let record;
+			try {
+				record = JSON.parse(line);
+			} catch {
+				continue;
+			}
+			if (!record || typeof record !== "object" || record.type !== "message") continue;
+			const message = record.message;
+			if (!message || typeof message.role !== "string") continue;
+			if (message.role !== "user" && message.role !== "assistant") continue;
+			const text = extractSessionText(message.content);
+			if (!text) continue;
+			const safe = redactSensitiveText(text, { mode: "tools" });
+			const label = message.role === "user" ? "User" : "Assistant";
+			collected.push(`${label}: ${safe}`);
+			lineMap.push(jsonlIdx + 1);
+		}
+		const content = collected.join("\n");
+		return {
+			path: sessionPathForFile(absPath),
+			absPath,
+			mtimeMs: stat.mtimeMs,
+			size: stat.size,
+			hash: hashText(content + "\n" + lineMap.join(",")),
+			content,
+			lineMap
+		};
+	} catch (err) {
+		log.debug(`Failed reading session file ${absPath}: ${String(err)}`);
+		return null;
+	}
+}
+
+//#endregion
+//#region src/memory/sqlite.ts
+const require = createRequire(import.meta.url);
+function requireNodeSqlite() {
+	installProcessWarningFilter();
+	try {
+		return require("node:sqlite");
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		throw new Error(`SQLite support is unavailable in this Node runtime (missing node:sqlite). ${message}`, { cause: err });
+	}
+}
+
+//#endregion
+export { buildFileEntry as a, ensureDir as c, listMemoryFiles as d, normalizeExtraMemoryPaths as f, runWithConcurrency as h, sessionPathForFile as i, hashText as l, remapChunkLines as m, buildSessionEntry as n, chunkMarkdown as o, parseEmbedding as p, listSessionFilesForAgent as r, cosineSimilarity as s, requireNodeSqlite as t, isMemoryPath as u };