hyperclaw 4.0.2 → 5.0.0

package/dist/mcp-loader-DkRBsLpk.js

@@ -0,0 +1,94 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const fs_extra = require_chunk.__toESM(require("fs-extra"));
+const path = require_chunk.__toESM(require("path"));
+const os = require_chunk.__toESM(require("os"));
+
+//#region src/services/mcp-loader.ts
+async function getMCPConfig() {
+	try {
+		const cfg = await fs_extra.default.readJson(path.default.join(HC_DIR, "hyperclaw.json"));
+		const servers = cfg.mcp?.servers ?? [];
+		return Array.isArray(servers) ? servers : [];
+	} catch {
+		return [];
+	}
+}
+/** Load tools from all configured MCP servers. */
+async function loadMCPTools() {
+	const servers = await getMCPConfig();
+	if (servers.length === 0) return [];
+	let Client;
+	let StdioClientTransport;
+	let StreamableHTTPClientTransport;
+	try {
+		const sdk = await import("@modelcontextprotocol/sdk");
+		Client = sdk.Client;
+		StdioClientTransport = sdk.StdioClientTransport;
+		StreamableHTTPClientTransport = sdk.StreamableHTTPClientTransport;
+	} catch {
+		return [];
+	}
+	const tools = [];
+	for (const srv of servers) try {
+		const client = new Client({
+			name: "hyperclaw",
+			version: "5.0.0"
+		});
+		if (srv.url) {
+			const transport = new StreamableHTTPClientTransport(new URL(srv.url));
+			await client.connect(transport);
+		} else if (srv.command) {
+			const transport = new StdioClientTransport({
+				command: srv.command,
+				args: srv.args ?? []
+			});
+			await client.connect(transport);
+		} else continue;
+		const allTools = [];
+		let cursor;
+		do {
+			const res = await client.listTools?.({ cursor }) ?? {
+				tools: [],
+				nextCursor: void 0
+			};
+			allTools.push(...res.tools ?? []);
+			cursor = res.nextCursor;
+		} while (cursor);
+		for (const t of allTools) {
+			const toolName = t.name;
+			const mcpClient = client;
+			tools.push({
+				name: `mcp_${srv.name}_${toolName}`.replace(/[^a-z0-9_]/gi, "_"),
+				description: (t.description ?? toolName).slice(0, 500),
+				input_schema: t.inputSchema && typeof t.inputSchema === "object" && "type" in t.inputSchema && "properties" in t.inputSchema ? t.inputSchema : {
+					type: "object",
+					properties: {}
+				},
+				handler: async (input) => {
+					try {
+						const result = await mcpClient.callTool?.({
+							name: toolName,
+							arguments: input
+						});
+						const content = result?.content;
+						if (Array.isArray(content)) return content.map((c) => c?.text ?? JSON.stringify(c)).join("\n");
+						return typeof content === "string" ? content : JSON.stringify(result ?? {});
+					} catch (e) {
+						return `MCP error: ${e.message}`;
+					}
+				}
+			});
+		}
+	} catch (e) {
+		console.error(`[mcp] Failed to load ${srv.name}:`, e.message);
+	}
+	return tools;
+}
+var HC_DIR;
+var init_mcp_loader = require_chunk.__esm({ "src/services/mcp-loader.ts"() {
+	HC_DIR = path.default.join(os.default.homedir(), ".hyperclaw");
+} });
+
+//#endregion
+init_mcp_loader();
+exports.loadMCPTools = loadMCPTools;

package/dist/memory-BlHL7JCO.js

@@ -0,0 +1,4 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const require_memory = require('./memory-DsS_eFvJ.js');
+
+exports.initWorkspaceFiles = require_memory.initWorkspaceFiles;

package/dist/memory-DsS_eFvJ.js

@@ -0,0 +1,270 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const chalk = require_chunk.__toESM(require("chalk"));
+const ora = require_chunk.__toESM(require("ora"));
+const fs_extra = require_chunk.__toESM(require("fs-extra"));
+const path = require_chunk.__toESM(require("path"));
+const os = require_chunk.__toESM(require("os"));
+
+//#region src/agents/memory.ts
+var MemoryManager = class {
+	baseDir;
+	agentsFile;
+	memoryFile;
+	logFile;
+	constructor(workspaceDir) {
+		this.baseDir = workspaceDir || path.default.join(os.default.homedir(), ".hyperclaw");
+		this.agentsFile = path.default.join(this.baseDir, "AGENTS.md");
+		this.memoryFile = path.default.join(this.baseDir, "MEMORY.md");
+		this.logFile = path.default.join(this.baseDir, "logs", `${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.md`);
+	}
+	async init(identity) {
+		await fs_extra.default.ensureDir(this.baseDir);
+		await fs_extra.default.ensureDir(path.default.join(this.baseDir, "logs"));
+		const spinner = (0, ora.default)("Initializing memory and agent identity...").start();
+		await this.writeAgentsMd(identity);
+		await this.writeMemoryMd(identity);
+		await this.initDailyLog();
+		spinner.succeed("AGENTS.md, MEMORY.md and daily log created");
+		console.log(chalk.default.gray(`   📁 Workspace: ${this.baseDir}`));
+		console.log(chalk.default.gray(`   📄 AGENTS.md: ${this.agentsFile}`));
+		console.log(chalk.default.gray(`   🧠 MEMORY.md: ${this.memoryFile}`));
+		console.log();
+	}
+	async writeAgentsMd(id) {
+		const content = `# AGENTS.md — HyperClaw Global Agent Rules
+> Generated: ${(/* @__PURE__ */ new Date()).toISOString()}
+> This file is read by ALL sessions and subagents.
+
+## Identity
+- **Agent Name:** ${id.agentName}
+- **User Name:** ${id.userName}
+- **Personality:** ${id.personality}
+- **Language:** ${id.language}
+
+## Global Rules
+${id.rules.map((r, i) => `${i + 1}. ${r}`).join("\n")}
+
+## Subagent Hierarchy
+- Parent: HyperClaw Core
+- Children: Channel Agents (Telegram, Discord, etc.)
+- All subagents MUST inherit these rules
+- No subagent may override global safety rules
+
+## Memory Protocol
+- Write significant events to MEMORY.md
+- Log daily interactions to logs/YYYY-MM-DD.md
+- Always read AGENTS.md at session start
+
+## Safety Boundaries
+- Never reveal the auth token
+- Never execute code outside the sandbox skill
+- Always ask for confirmation before irreversible actions
+- Refuse requests that violate user privacy
+
+## Cross-Session Persistence
+- Session state is stored in ~/.hyperclaw/sessions/
+- Use memory tools to recall past interactions
+`;
+		await fs_extra.default.writeFile(this.agentsFile, content, "utf8");
+	}
+	async writeMemoryMd(id) {
+		const content = `# MEMORY.md — HyperClaw Persistent Memory
+> Initialized: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+## User Profile
+- Name: ${id.userName}
+- Preferred language: ${id.language}
+- Agent alias: ${id.agentName}
+
+## Session History
+*(Populated automatically during sessions)*
+
+## Key Facts
+*(Write important information here for future sessions)*
+
+## Reminders
+*(Active reminders are listed here)*
+`;
+		await fs_extra.default.writeFile(this.memoryFile, content, "utf8");
+	}
+	async initDailyLog() {
+		const today = (/* @__PURE__ */ new Date()).toLocaleDateString("en-US", {
+			weekday: "long",
+			year: "numeric",
+			month: "long",
+			day: "numeric"
+		});
+		const content = `# Daily Log — ${today}
+
+## Sessions
+- ${(/* @__PURE__ */ new Date()).toLocaleTimeString()} — Session initialized
+
+## Notes
+`;
+		await fs_extra.default.ensureDir(path.default.dirname(this.logFile));
+		await fs_extra.default.writeFile(this.logFile, content, "utf8");
+	}
+	async appendRule(rule) {
+		const spinner = (0, ora.default)("Writing rule to AGENTS.md...").start();
+		const content = await fs_extra.default.readFile(this.agentsFile, "utf8");
+		const updated = content.replace("*(Populated automatically during sessions)*", `*(Populated automatically during sessions)*\n\n### Added Rule\n- ${rule}`);
+		await fs_extra.default.writeFile(this.agentsFile, updated, "utf8");
+		spinner.succeed(`Rule added to AGENTS.md`);
+	}
+	async addMemory(fact) {
+		const spinner = (0, ora.default)("Writing to MEMORY.md...").start();
+		const content = await fs_extra.default.readFile(this.memoryFile, "utf8");
+		const entry = `\n- [${(/* @__PURE__ */ new Date()).toISOString()}] ${fact}`;
+		const updated = content.replace("*(Write important information here for future sessions)*", `*(Write important information here for future sessions)*${entry}`);
+		await fs_extra.default.writeFile(this.memoryFile, updated, "utf8");
+		spinner.succeed(`Memory updated`);
+	}
+	async load() {
+		try {
+			const agents = await fs_extra.default.readFile(this.agentsFile, "utf8");
+			const memory = await fs_extra.default.readFile(this.memoryFile, "utf8");
+			return {
+				agents,
+				memory
+			};
+		} catch {
+			return null;
+		}
+	}
+	getBaseDir() {
+		return this.baseDir;
+	}
+};
+async function initWorkspaceFiles(identity, workspaceDir) {
+	const files = {
+		"SOUL.md": generateSoul(identity),
+		"USER.md": generateUser(identity),
+		"TOOLS.md": generateTools(),
+		"HEARTBEAT.md": generateHeartbeat(),
+		"BOOTSTRAP.md": generateBootstrap(identity)
+	};
+	await fs_extra.default.ensureDir(workspaceDir);
+	for (const [fname, content] of Object.entries(files)) {
+		const fpath = path.default.join(workspaceDir, fname);
+		if (!await fs_extra.default.pathExists(fpath)) await fs_extra.default.writeFile(fpath, content, "utf8");
+	}
+}
+function generateSoul(id) {
+	return `# SOUL.md — Agent Personality & Values
+> Generated: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+## Core Identity
+- **Name:** ${id.agentName}
+- **Personality:** ${id.personality}
+- **Primary language:** ${id.language}
+
+## Values
+- Honesty over flattery
+- Brevity — get to the point
+- Respect autonomy — suggest, never demand
+- Always confirm before irreversible actions
+
+## Boundaries
+- Never reveal gateway tokens or API keys
+- Always ask confirmation before destructive actions
+- Never claim to be human when sincerely asked
+`;
+}
+function generateUser(id) {
+	return `# USER.md — About the Person I Work For
+> Generated: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+## Identity
+- **Name:** ${id.userName}
+- **Preferred language:** ${id.language}
+
+## Communication Preferences
+- Tone: casual
+- Response length: auto
+
+## What I'm Working On
+*(Update this regularly — agent uses it for context)*
+
+## My Stack
+*(Add your tools here)*
+
+## Do NOT do these things
+- Pad responses with unnecessary filler
+
+## Always do these things
+- Respond in ${id.language} unless I write in another language
+`;
+}
+function generateTools() {
+	return `# TOOLS.md — Available Skills & Tools
+> Generated: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+## Active Skills
+| ID | Name | Status |
+|----|------|--------|
+| reminders | Smart Reminders | ✅ enabled |
+| translator | Real-time Translator | ✅ enabled |
+
+## Add More Skills
+\`\`\`
+hyperclaw hub         # Browse available skills
+hyperclaw hub --install web-search
+\`\`\`
+
+## MCP Servers
+No MCP servers configured. Add with: \`hyperclaw mcp add\`
+`;
+}
+function generateHeartbeat() {
+	return `# HEARTBEAT.md — System Health Log
+> Initialized: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+Auto-written by the gateway-health hook every 5 minutes.
+Enable with: \`hyperclaw hooks enable gateway-health\`
+
+## Last Status
+Pending first heartbeat...
+`;
+}
+function generateBootstrap(id) {
+	return `# BOOTSTRAP.md β€” Fast Start Context
+> Generated: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+## Mission
+Help ${id.userName} move the current task forward with minimal setup friction.
+
+## First Tasks
+1. Read AGENTS.md, USER.md, TOOLS.md, and MEMORY.md if present.
+2. Confirm the current repo / project shape before editing anything.
+3. Prefer the smallest change that unblocks progress.
+
+## Environment
+- Agent: ${id.agentName}
+- User: ${id.userName}
+- Language: ${id.language}
+
+## Current Constraints
+- Ask before irreversible actions.
+- Keep secrets out of workspace markdown files.
+- Update docs when behavior changes.
+
+## Definition Of Done
+- Requested change is implemented.
+- Relevant checks or verifications are run when available.
+- Important follow-up risks are documented briefly.
+`;
+}
+
+//#endregion
+Object.defineProperty(exports, 'MemoryManager', {
+  enumerable: true,
+  get: function () {
+    return MemoryManager;
+  }
+});
+Object.defineProperty(exports, 'initWorkspaceFiles', {
+  enumerable: true,
+  get: function () {
+    return initWorkspaceFiles;
+  }
+});

package/dist/memory-auto-BkvtSFUw.js

@@ -0,0 +1,5 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const require_memory_auto = require('./memory-auto-Bnz_-1wP.js');
+
+require_memory_auto.init_memory_auto();
+exports.AutoMemory = require_memory_auto.AutoMemory;

package/dist/memory-auto-Bnz_-1wP.js

@@ -0,0 +1,306 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const chalk = require_chunk.__toESM(require("chalk"));
+const fs_extra = require_chunk.__toESM(require("fs-extra"));
+const path = require_chunk.__toESM(require("path"));
+const os = require_chunk.__toESM(require("os"));
+
+//#region packages/core/src/agent/memory-auto.ts
+function isSensitive(text) {
+	return SENSITIVE_PATTERNS.some((p) => p.test(text));
+}
+function extractFactsLocally(turns) {
+	const facts = [];
+	const userMessages = turns.filter((t) => t.role === "user").map((t) => t.content);
+	for (const msg of userMessages) {
+		if (isSensitive(msg)) continue;
+		for (const pattern of PREFERENCE_PATTERNS) {
+			const m = msg.match(pattern);
+			if (m?.[1] && m[1].length > 4) facts.push({
+				fact: `User preference: ${m[1].trim()}`,
+				category: "preference",
+				confidence: "high"
+			});
+		}
+		for (const pattern of IDENTITY_PATTERNS) {
+			const m = msg.match(pattern);
+			if (m?.[1] && m[1].length > 2) facts.push({
+				fact: `About user: ${m[1].trim()}`,
+				category: "identity",
+				confidence: "high"
+			});
+		}
+		for (const pattern of GOAL_PATTERNS) {
+			const m = msg.match(pattern);
+			if (m?.[1] && m[1].length > 8) facts.push({
+				fact: `User goal: ${m[1].trim()}`,
+				category: "goal",
+				confidence: "medium"
+			});
+		}
+	}
+	const seen = /* @__PURE__ */ new Set();
+	return facts.filter((f) => {
+		const key = f.fact.toLowerCase().slice(0, 40);
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
+async function readMemory() {
+	try {
+		return await fs_extra.default.readFile(MEMORY_FILE, "utf8");
+	} catch {
+		return "";
+	}
+}
+async function appendMemory(facts) {
+	if (facts.length === 0) return 0;
+	const existing = await readMemory();
+	const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+	let added = 0;
+	const newLines = [];
+	const addedFacts = [];
+	for (const f of facts) {
+		if (existing.toLowerCase().includes(f.fact.toLowerCase().slice(0, 30))) continue;
+		newLines.push(`- ${today} [${f.category}] ${f.fact}`);
+		addedFacts.push(f);
+		added++;
+	}
+	if (newLines.length === 0) return 0;
+	await fs_extra.default.ensureDir(HC_DIR);
+	if (!await fs_extra.default.pathExists(MEMORY_FILE)) await fs_extra.default.writeFile(MEMORY_FILE, "# HyperClaw Memory\n\n");
+	await fs_extra.default.appendFile(MEMORY_FILE, "\n" + newLines.join("\n") + "\n");
+	try {
+		const { onMemoryAppended } = await Promise.resolve().then(() => require("./memory-integration-cSYkZyEo.js"));
+		await onMemoryAppended(addedFacts.map((f) => ({ fact: f.fact })));
+	} catch {}
+	return added;
+}
+async function saveMemoryDirect(text) {
+	await fs_extra.default.ensureDir(HC_DIR);
+	if (!await fs_extra.default.pathExists(MEMORY_FILE)) await fs_extra.default.writeFile(MEMORY_FILE, "# HyperClaw Memory\n\n");
+	const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+	await fs_extra.default.appendFile(MEMORY_FILE, `\n- ${today} ${text}\n`);
+	try {
+		const { onMemoryAppended } = await Promise.resolve().then(() => require("./memory-integration-cSYkZyEo.js"));
+		await onMemoryAppended([{ fact: text }]);
+	} catch {}
+}
+async function extractFactsWithAI(turns, inferenceOpts) {
+	const totalText = turns.map((t) => t.content).join(" ");
+	if (totalText.length < 100) return [];
+	const localFacts = extractFactsLocally(turns);
+	const hasPersonalContext = /\b(I|my|me|mine|myself)\b/i.test(totalText);
+	if (!hasPersonalContext) return localFacts;
+	try {
+		const { InferenceEngine } = await Promise.resolve().then(() => require("./inference-BKVkBREb.js"));
+		const engine = new InferenceEngine({
+			model: inferenceOpts.model,
+			apiKey: inferenceOpts.apiKey,
+			provider: inferenceOpts.provider,
+			maxTokens: 512,
+			tools: []
+		});
+		const conversationSummary = turns.slice(-6).map((t) => `${t.role === "user" ? "User" : "AI"}: ${t.content.slice(0, 300)}`).join("\n");
+		const result = await engine.run([{
+			role: "user",
+			content: `Extract ONLY concrete, reusable facts about the USER from this conversation. 
+Skip: passwords, API keys, one-off questions, assistant responses.
+Include: name, job, preferences, ongoing projects, locations, recurring tasks.
+
+Conversation:
+${conversationSummary}
+
+Respond with a JSON array of strings, each a short fact starting with "User".
+If nothing worth saving, respond: []
+Example: ["User's name is Alex", "User prefers TypeScript over JavaScript", "User is building a SaaS app"]`
+		}]);
+		const clean = result.text.replace(/```json|```/g, "").trim();
+		const aiFactStrings = JSON.parse(clean);
+		const allFacts = [...localFacts];
+		const existingFactText = localFacts.map((f) => f.fact.toLowerCase());
+		for (const factStr of aiFactStrings) {
+			if (!factStr || factStr.length < 5) continue;
+			if (isSensitive(factStr)) continue;
+			if (existingFactText.some((e) => e.includes(factStr.toLowerCase().slice(0, 20)))) continue;
+			const cat = /prefer|like|hate|always|never|don't/i.test(factStr) ? "preference" : /goal|want|trying|working on|building/i.test(factStr) ? "goal" : /name|job|work|role|from|based/i.test(factStr) ? "identity" : "context";
+			allFacts.push({
+				fact: factStr,
+				category: cat,
+				confidence: "medium"
+			});
+		}
+		return allFacts;
+	} catch {
+		return localFacts;
+	}
+}
+async function showMemory() {
+	const content = await readMemory();
+	if (!content.trim()) {
+		console.log(chalk.default.gray("\n  🧠 MEMORY.md is empty\n"));
+		return;
+	}
+	console.log(chalk.default.bold.cyan("\n  🧠 MEMORY\n"));
+	const lines = content.split("\n").filter((l) => l.trim());
+	for (const line of lines) if (line.startsWith("#")) console.log(chalk.default.bold.white(line));
+	else if (line.startsWith("-")) {
+		const parts = line.match(/^-\s+(\S+)\s+\[(\w+)\]\s+(.+)$/);
+		if (parts) {
+			const [, date, cat, fact] = parts;
+			const catColor = cat === "preference" ? chalk.default.cyan : cat === "identity" ? chalk.default.yellow : cat === "goal" ? chalk.default.green : chalk.default.gray;
+			console.log(`  ${chalk.default.gray(date)} ${catColor(`[${cat}]`)} ${fact}`);
+		} else console.log(`  ${line}`);
+	}
+	console.log();
+}
+async function clearMemory() {
+	await fs_extra.default.writeFile(MEMORY_FILE, "# HyperClaw Memory\n\n");
+	console.log(chalk.default.green("  ✅ Memory cleared\n"));
+}
+async function searchMemory(query) {
+	const content = await readMemory();
+	const lines = content.split("\n").filter((l) => l.toLowerCase().includes(query.toLowerCase()));
+	if (lines.length === 0) {
+		console.log(chalk.default.gray(`  No memories found for: "${query}"\n`));
+		return;
+	}
+	console.log(chalk.default.bold.cyan(`\n  🔍 Memory search: "${query}"\n`));
+	for (const line of lines) console.log(`  ${line}`);
+	console.log();
+}
+var HC_DIR, MEMORY_FILE, SOUL_FILE, PREFERENCE_PATTERNS, IDENTITY_PATTERNS, GOAL_PATTERNS, SENSITIVE_PATTERNS, AutoMemory;
+var init_memory_auto = require_chunk.__esm({ "packages/core/src/agent/memory-auto.ts"() {
+	HC_DIR = path.default.join(os.default.homedir(), ".hyperclaw");
+	MEMORY_FILE = path.default.join(HC_DIR, "MEMORY.md");
+	SOUL_FILE = path.default.join(HC_DIR, "SOUL.md");
+	PREFERENCE_PATTERNS = [
+		/i (?:prefer|like|love|hate|dislike|always|never)\s+(.{5,80})/i,
+		/(?:my favorite|my preferred)\s+(.{5,80})/i,
+		/(?:please )?always\s+((?:use|do|write|respond|answer|format|reply)\s+.{5,60})/i,
+		/don'?t (?:ever )?(.{5,60})/i,
+		/(?:i want you to always)\s+(.{5,80})/i
+	];
+	IDENTITY_PATTERNS = [
+		/(?:my name is|i'?m called|call me)\s+([A-ZΑ-Ωa-zα-ω][a-zα-ω]{1,30})/i,
+		/i(?:'m| am) (?:a |an )?([A-Za-zΑ-Ωα-ω][\w\s]{3,40}?)(?:\.|,|$)/i,
+		/i work (?:at|for|as)\s+(.{5,60})/i,
+		/i(?:'m| am) (?:from|in|based in)\s+(.{3,40})/i,
+		/my (?:job|role|position|title) is\s+(.{5,60})/i
+	];
+	GOAL_PATTERNS = [
+		/i(?:'m| am) (?:working on|building|creating|developing)\s+(.{10,100})/i,
+		/i want to\s+(.{10,100})/i,
+		/my goal is (?:to\s+)?(.{10,100})/i,
+		/i'?m trying to\s+(.{10,100})/i
+	];
+	SENSITIVE_PATTERNS = [
+		/password/i,
+		/passwd/i,
+		/secret key/i,
+		/api.?key/i,
+		/credit.?card/i,
+		/\b\d{4}[\s-]\d{4}[\s-]\d{4}[\s-]\d{4}\b/,
+		/ssn|social security/i,
+		/\b\d{3}-\d{2}-\d{4}\b/
+	];
+	AutoMemory = class {
+		turns = [];
+		turnsSinceLastExtract = 0;
+		extractEveryNTurns;
+		useAI;
+		aiOpts;
+		constructor(opts = {}) {
+			this.extractEveryNTurns = opts.extractEveryNTurns ?? 4;
+			this.useAI = opts.useAI ?? false;
+			this.aiOpts = opts.aiOpts;
+		}
+		addTurn(role, content) {
+			this.turns.push({
+				role,
+				content,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			this.turnsSinceLastExtract++;
+		}
+		async maybeExtract() {
+			if (this.turnsSinceLastExtract < this.extractEveryNTurns) return 0;
+			this.turnsSinceLastExtract = 0;
+			return this.extract();
+		}
+		async extract() {
+			const facts = this.useAI && this.aiOpts ? await extractFactsWithAI(this.turns, this.aiOpts) : extractFactsLocally(this.turns);
+			const saved = await appendMemory(facts);
+			if (saved > 0) console.log(chalk.default.gray(`  🧠 Auto-saved ${saved} fact${saved === 1 ? "" : "s"} to MEMORY.md`));
+			return saved;
+		}
+		clearTurns() {
+			this.turns = [];
+		}
+		getTurns() {
+			return [...this.turns];
+		}
+	};
+} });
+
+//#endregion
+Object.defineProperty(exports, 'AutoMemory', {
+  enumerable: true,
+  get: function () {
+    return AutoMemory;
+  }
+});
+Object.defineProperty(exports, 'appendMemory', {
+  enumerable: true,
+  get: function () {
+    return appendMemory;
+  }
+});
+Object.defineProperty(exports, 'clearMemory', {
+  enumerable: true,
+  get: function () {
+    return clearMemory;
+  }
+});
+Object.defineProperty(exports, 'extractFactsLocally', {
+  enumerable: true,
+  get: function () {
+    return extractFactsLocally;
+  }
+});
+Object.defineProperty(exports, 'extractFactsWithAI', {
+  enumerable: true,
+  get: function () {
+    return extractFactsWithAI;
+  }
+});
+Object.defineProperty(exports, 'init_memory_auto', {
+  enumerable: true,
+  get: function () {
+    return init_memory_auto;
+  }
+});
+Object.defineProperty(exports, 'readMemory', {
+  enumerable: true,
+  get: function () {
+    return readMemory;
+  }
+});
+Object.defineProperty(exports, 'saveMemoryDirect', {
+  enumerable: true,
+  get: function () {
+    return saveMemoryDirect;
+  }
+});
+Object.defineProperty(exports, 'searchMemory', {
+  enumerable: true,
+  get: function () {
+    return searchMemory;
+  }
+});
+Object.defineProperty(exports, 'showMemory', {
+  enumerable: true,
+  get: function () {
+    return showMemory;
+  }
+});