mindlink 2.0.4 → 2.2.0

package/dist/cli.js

@@ -2,11 +2,11 @@
 import "./chunk-2H7UOFLK.js";
 
 // src/cli.ts
-import { Command as Command20 } from "commander";
-import chalk20 from "chalk";
+import { Command as Command23 } from "commander";
+import chalk23 from "chalk";
 
 // src/utils/version.ts
-var VERSION = "2.0.4";
+var VERSION = "2.2.0";
 
 // src/commands/init.ts
 import { Command } from "commander";
@@ -228,7 +228,113 @@ function detectProjectInfo(projectPath) {
     if (dirs.length > 0) topDirs = dirs.join(", ");
   } catch {
   }
-  return { name, description, stack, recentActivity, topDirs, date };
+  const git = analyzeGitHistory(projectPath);
+  return { name, description, stack, recentActivity, topDirs, date, git };
+}
+function analyzeGitHistory(projectPath) {
+  const exec = (cmd) => execSync(cmd, { cwd: projectPath, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+  try {
+    exec("git rev-parse HEAD");
+  } catch {
+    return null;
+  }
+  let recentWork = "";
+  let topModules = "";
+  let topDecisions = "";
+  let isTeam = false;
+  let projectAge = "";
+  try {
+    const messages = exec('git log --pretty=format:"%s" -30').split("\n").map((m) => m.trim()).filter((m) => m.length > 0 && m.length < 120);
+    if (messages.length > 0) {
+      recentWork = messages.slice(0, 8).join("\n");
+    }
+  } catch {
+  }
+  try {
+    const diffstat = exec("git log --name-only --pretty=format: -30").split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+    const counts = {};
+    for (const file of diffstat) {
+      const parts = file.split("/");
+      const key = parts.length > 1 ? parts[0] + "/" : file;
+      counts[key] = (counts[key] ?? 0) + 1;
+    }
+    const sorted = Object.entries(counts).sort((a, b) => b[1] - a[1]).slice(0, 5).map(([k]) => k);
+    if (sorted.length > 0) topModules = sorted.join(", ");
+  } catch {
+  }
+  try {
+    const authors = exec('git log --pretty=format:"%ae" -30').split("\n").map((e) => e.trim()).filter((e) => e.length > 0);
+    const unique = new Set(authors);
+    isTeam = unique.size > 1;
+  } catch {
+  }
+  try {
+    const firstDate = exec('git log --pretty=format:"%ad" --date=short | tail -1');
+    if (firstDate) {
+      const ms = Date.now() - new Date(firstDate).getTime();
+      const days = Math.floor(ms / 864e5);
+      if (days < 7) projectAge = `${days}d old`;
+      else if (days < 30) projectAge = `${Math.floor(days / 7)}w old`;
+      else if (days < 365) projectAge = `${Math.floor(days / 30)}mo old`;
+      else projectAge = `${Math.floor(days / 365)}y old`;
+    }
+  } catch {
+  }
+  try {
+    const messages = exec('git log --pretty=format:"%s" -50').split("\n").map((m) => m.trim());
+    const decisionKeywords = ["add", "switch", "replace", "migrate", "refactor", "remove", "use ", "adopt", "drop", "move"];
+    const decisions = messages.filter((m) => decisionKeywords.some((k) => m.toLowerCase().startsWith(k))).slice(0, 4).map((m) => m.slice(0, 80));
+    if (decisions.length > 0) topDecisions = decisions.join("\n");
+  } catch {
+  }
+  if (!recentWork && !topModules && !projectAge) return null;
+  return { recentWork, topModules, topDecisions, isTeam, projectAge };
+}
+function buildStackHints(stack) {
+  const s = stack.toLowerCase();
+  if (s.includes("next.js") || s.includes("nextjs")) {
+    return `Pages: app/ or pages/ router
+API routes: app/api/ or pages/api/
+Components: components/
+State: (fill in \u2014 context, zustand, redux?)`;
+  }
+  if (s.includes("react") && !s.includes("next")) {
+    return `Components: src/components/
+State: (fill in \u2014 context, zustand, redux?)
+Routing: (fill in \u2014 react-router, tanstack?)`;
+  }
+  if (s.includes("express") || s.includes("fastify") || s.includes("koa")) {
+    return `Entry: src/index.ts or server.ts
+Routes: src/routes/
+Middleware: src/middleware/
+DB: (fill in)`;
+  }
+  if (s.includes("python")) {
+    return `Entry: main.py or src/
+Dependencies: requirements.txt or pyproject.toml
+Virtual env: .venv/ or venv/`;
+  }
+  if (s.includes("rust")) {
+    return `Entry: src/main.rs or src/lib.rs
+Key crates: (fill in from Cargo.toml)
+Modules: src/`;
+  }
+  if (s.includes("go")) {
+    return `Entry: main.go or cmd/
+Packages: internal/ or pkg/
+Dependencies: go.mod`;
+  }
+  if (s.includes("java") || s.includes("kotlin")) {
+    return `Entry: src/main/
+Tests: src/test/
+Build: pom.xml or build.gradle`;
+  }
+  if (s.includes("ruby")) {
+    return `Entry: app/ (Rails) or lib/
+Dependencies: Gemfile
+Tests: spec/ or test/`;
+  }
+  return "";
 }
 function memoryHasRealContent(memoryPath) {
   try {
@@ -295,7 +401,14 @@ ${info2.stack}
   }
   const focusLines = [];
   if (info2.topDirs) focusLines.push(`Directories: ${info2.topDirs}`);
-  if (info2.recentActivity) focusLines.push(`Recent commits: ${info2.recentActivity}`);
+  if (info2.git?.recentWork) {
+    const firstLine = info2.git.recentWork.split("\n")[0];
+    focusLines.push(`Recent work: ${firstLine}`);
+  } else if (info2.recentActivity) {
+    focusLines.push(`Recent commits: ${info2.recentActivity}`);
+  }
+  if (info2.git?.projectAge) focusLines.push(`Project age: ${info2.git.projectAge}`);
+  if (info2.git?.isTeam) focusLines.push(`Team project: multiple contributors detected`);
   const focusBlock = focusLines.length > 0 ? focusLines.join("\n") + `
 <!-- Initialized ${info2.date} \u2014 update to reflect the current active focus -->` : `<!-- Initialized ${info2.date} \u2014 ask your AI to fill this in after your first session -->`;
   content = content.replace(
@@ -303,6 +416,28 @@ ${info2.stack}
     `### Current focus
 ${focusBlock}`
   );
+  if (info2.git?.topDecisions) {
+    const decisionLines = info2.git.topDecisions.split("\n").map((d) => `- ${d} <!-- inferred from git history \u2014 verify and update -->`).join("\n");
+    content = content.replace(
+      /### Top decisions\n<!--[^]*?-->/,
+      `### Top decisions
+${decisionLines}
+<!-- The 3\u20135 most important locked-in choices. One line each. -->`
+    );
+  }
+  const stackHints = buildStackHints(info2.stack);
+  const archLines = [];
+  if (info2.git?.topModules) archLines.push(`Most active modules (from git history): ${info2.git.topModules}`);
+  if (stackHints) archLines.push(stackHints);
+  if (archLines.length > 0) {
+    content = content.replace(
+      /## Architecture[^\n]*\n\n<!--[^]*?-->/,
+      `## Architecture  <!-- Read when the task involves project structure -->
+
+` + archLines.join("\n") + `
+<!-- High-level structure: main components and how they relate. Update when the structure changes. -->`
+    );
+  }
   return content;
 }
 var BRAIN_FILES = [
@@ -782,7 +917,8 @@ function extractSection(markdown, heading) {
     if (match) {
       const level = match[1].length;
       const title = match[2].trim();
-      if (title.toLowerCase() === heading.toLowerCase()) {
+      const cleanTitle = title.replace(/<!--.*?-->/g, "").trim();
+      if (cleanTitle.toLowerCase() === heading.toLowerCase()) {
         inSection = true;
         headingLevel = level;
         continue;
@@ -1447,7 +1583,7 @@ var REQUIRED_BRAIN_FILES = ["MEMORY.md", "SESSION.md", "SHARED.md", "LOG.md"];
 async function latestVersion() {
   try {
     const { default: https } = await import("https");
-    return new Promise((resolve17) => {
+    return new Promise((resolve20) => {
       const req = https.get(
         "https://registry.npmjs.org/mindlink/latest",
         { headers: { "User-Agent": "mindlink-cli" } },
@@ -1459,17 +1595,17 @@ async function latestVersion() {
           res.on("end", () => {
             try {
               const parsed = JSON.parse(data);
-              resolve17(parsed.version ?? null);
+              resolve20(parsed.version ?? null);
             } catch {
-              resolve17(null);
+              resolve20(null);
             }
           });
         }
       );
-      req.on("error", () => resolve17(null));
+      req.on("error", () => resolve20(null));
       req.setTimeout(8e3, () => {
         req.destroy();
-        resolve17(null);
+        resolve20(null);
       });
     });
   } catch {
@@ -3422,8 +3558,474 @@ ${summary.trim()}
   await server.connect(transport);
 });
 
+// src/commands/recap.ts
+import { Command as Command20 } from "commander";
+import chalk20 from "chalk";
+import { existsSync as existsSync20, readFileSync as readFileSync18 } from "fs";
+import { join as join20, resolve as resolve17 } from "path";
+var recapCommand = new Command20("recap").description("Summary of everything your AI learned across recent sessions").option("--days <n>", "How many days back to include", "7").option("--sessions <n>", "Max number of sessions to include").addHelpText("after", `
+Examples:
+  mindlink recap
+  mindlink recap --days 30
+  mindlink recap --sessions 5
+  `).action((opts) => {
+  const projectPath = resolve17(process.cwd());
+  const brainDir = join20(projectPath, BRAIN_DIR);
+  if (!existsSync20(brainDir)) {
+    console.log(`  ${chalk20.red("\u2717")}  No .brain/ found in this directory.`);
+    console.log(`     Run ${chalk20.cyan("mindlink init")} to get started.`);
+    console.log("");
+    process.exit(1);
+  }
+  const logPath = join20(brainDir, "LOG.md");
+  const memoryPath = join20(brainDir, "MEMORY.md");
+  if (!existsSync20(logPath)) {
+    console.log(`  ${chalk20.dim("No session history yet.")}`);
+    console.log(`  Start working with your AI \u2014 it will build up a log automatically.`);
+    console.log("");
+    process.exit(0);
+  }
+  const logContent = readFileSync18(logPath, "utf8");
+  const allEntries = parseLogEntries(logContent);
+  if (allEntries.length === 0) {
+    console.log(`  ${chalk20.dim("No sessions logged yet.")}`);
+    console.log("");
+    process.exit(0);
+  }
+  const maxDays = parseInt(opts.days ?? "7", 10);
+  const maxSessions = opts.sessions ? parseInt(opts.sessions, 10) : void 0;
+  const cutoff = Date.now() - maxDays * 864e5;
+  function parseEntryDate(heading) {
+    const clean = heading.replace(/^⭐\s*/, "").trim();
+    const d = new Date(clean);
+    return isNaN(d.getTime()) ? null : d;
+  }
+  let filtered = allEntries.filter((e) => {
+    const d = parseEntryDate(e.heading);
+    if (!d) return true;
+    return d.getTime() >= cutoff;
+  });
+  if (maxSessions && filtered.length > maxSessions) {
+    filtered = filtered.slice(0, maxSessions);
+  }
+  function extractField(body, label) {
+    const lines = body.split("\n");
+    const results = [];
+    const labelLower = label.toLowerCase();
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const lineLower = line.toLowerCase();
+      const inlinePatterns = [
+        new RegExp(`\\*\\*${label}[:\\*s]*\\*\\*:?\\s*(.+)`, "i"),
+        new RegExp(`^${label}:?\\s*(.+)`, "i")
+      ];
+      for (const pat of inlinePatterns) {
+        const m = line.match(pat);
+        if (m?.[1]) {
+          const items = m[1].split(/[·,]/).map((s) => s.trim()).filter((s) => s.length > 0);
+          results.push(...items);
+        }
+      }
+      if (lineLower.includes(labelLower + ":") && !line.includes("\u2192") && results.length === 0) {
+        let j = i + 1;
+        while (j < lines.length) {
+          const next = lines[j].trim();
+          if (!next || next.startsWith("**") || next.startsWith("##")) break;
+          const t = next.replace(/^[-*]\s*/, "").trim();
+          if (t.length > 0) results.push(t);
+          j++;
+        }
+      }
+    }
+    return results;
+  }
+  const completedItems = [];
+  const decisions = [];
+  const nextItems = [];
+  for (const entry of filtered) {
+    completedItems.push(...extractField(entry.body, "completed"));
+    completedItems.push(...extractField(entry.body, "what was completed"));
+    decisions.push(...extractField(entry.body, "decisions"));
+    nextItems.push(...extractField(entry.body, "next"));
+    nextItems.push(...extractField(entry.body, "up next"));
+    nextItems.push(...extractField(entry.body, "what's next"));
+  }
+  const dedup = (arr) => [...new Set(arr)].filter((s) => s.length > 0 && s !== "(none)");
+  const completed = dedup(completedItems).slice(0, 8);
+  const decidedItems = dedup(decisions).slice(0, 6);
+  const upNext = dedup(nextItems).slice(0, 4);
+  let memoryState = "";
+  if (existsSync20(memoryPath)) {
+    const mem = readFileSync18(memoryPath, "utf8");
+    const core = extractSection(mem, "Core");
+    const coreLines = core.split("\n").filter((l) => {
+      const t = l.trim();
+      return t.length > 0 && !t.startsWith("<!--") && !t.startsWith("#") && t !== "---";
+    });
+    if (coreLines.length > 0) memoryState = coreLines.slice(0, 4).join("\n");
+  }
+  console.log("");
+  console.log(`  ${chalk20.bold("\u25C9 MindLink \u2014 Session Recap")}  ${chalk20.dim(`last ${maxDays} days \xB7 ${filtered.length} session${filtered.length !== 1 ? "s" : ""}`)}`);
+  console.log("");
+  if (memoryState) {
+    console.log(`  ${chalk20.cyan("Memory snapshot")}`);
+    for (const line of memoryState.split("\n")) {
+      console.log(`    ${chalk20.dim(line)}`);
+    }
+    console.log("");
+  }
+  if (completed.length > 0) {
+    console.log(`  ${chalk20.green("What got done")}`);
+    for (const item of completed) {
+      console.log(`  ${chalk20.green("\u2192")}  ${item}`);
+    }
+    console.log("");
+  }
+  if (decidedItems.length > 0) {
+    console.log(`  ${chalk20.yellow("Decisions made")}`);
+    for (const item of decidedItems) {
+      console.log(`  ${chalk20.yellow("\u2192")}  ${item}`);
+    }
+    console.log("");
+  }
+  if (upNext.length > 0) {
+    console.log(`  ${chalk20.blue("Up next")}`);
+    for (const item of upNext) {
+      console.log(`  ${chalk20.blue("\u2192")}  ${item}`);
+    }
+    console.log("");
+  }
+  if (completed.length === 0 && decidedItems.length === 0 && upNext.length === 0) {
+    console.log(`  ${chalk20.dim("Sessions found but no structured content extracted.")}`);
+    console.log(`  ${chalk20.dim("Ask your AI to use the standard log format: completed / decisions / next.")}`);
+    console.log("");
+  }
+});
+
+// src/commands/search.ts
+import { Command as Command21 } from "commander";
+import chalk21 from "chalk";
+import { existsSync as existsSync21, readFileSync as readFileSync19 } from "fs";
+import { join as join21, resolve as resolve18 } from "path";
+var MEMORY_SECTIONS = ["Core", "Architecture", "Decisions", "Conventions", "User Profile", "Important Context"];
+function searchFile(filePath, pattern, sectionFilter) {
+  if (!existsSync21(filePath)) return [];
+  const content = readFileSync19(filePath, "utf8");
+  const results = [];
+  const filename = filePath.split("/").pop() ?? "";
+  if (filename === "MEMORY.md") {
+    for (const section of MEMORY_SECTIONS) {
+      if (sectionFilter && section.toLowerCase() !== sectionFilter.toLowerCase()) continue;
+      const sectionContent = extractSection(content, section);
+      const matchingLines2 = sectionContent.split("\n").filter((l) => {
+        const t = l.trim();
+        return t.length > 0 && !t.startsWith("<!--") && !t.startsWith("#") && t !== "---" && pattern.test(l);
+      }).map((l) => l.trim()).slice(0, 3);
+      if (matchingLines2.length > 0) {
+        results.push({ section, lines: matchingLines2 });
+      }
+    }
+    return results;
+  }
+  const matchingLines = content.split("\n").filter((l) => pattern.test(l)).map((l) => l.trim()).filter((l) => l.length > 0).slice(0, 3);
+  if (matchingLines.length > 0) {
+    results.push({ section: "Log", lines: matchingLines });
+  }
+  return results;
+}
+var searchCommand = new Command21("search").description("Search across all project memories").argument("<query>", "Text or pattern to search for").option("--project <name>", "Limit search to a specific project path (partial match)").option("--section <name>", "Limit search to a specific MEMORY.md section (e.g. decisions, architecture)").option("--log", "Also search session logs (LOG.md)").addHelpText("after", `
+Examples:
+  mindlink search "postgres"
+  mindlink search "auth" --section decisions
+  mindlink search "stripe" --project myapp
+  mindlink search "api key" --log
+  `).action((query, opts) => {
+  const cwd = resolve18(process.cwd());
+  const registered = getRegisteredProjects().filter((p) => existsSync21(join21(p, BRAIN_DIR, "config.json")));
+  const projects = registered.includes(cwd) ? registered : existsSync21(join21(cwd, BRAIN_DIR, "config.json")) ? [cwd, ...registered] : registered;
+  if (projects.length === 0) {
+    console.log("");
+    console.log(`  ${chalk21.dim("No MindLink projects found.")}`);
+    console.log(`  Run ${chalk21.cyan("mindlink init")} in a project directory first.`);
+    console.log("");
+    process.exit(0);
+  }
+  const filteredProjects = opts.project ? projects.filter((p) => p.toLowerCase().includes(opts.project.toLowerCase())) : projects;
+  if (filteredProjects.length === 0) {
+    console.log("");
+    console.log(`  ${chalk21.dim(`No projects matching "${opts.project}"`)}`);
+    console.log("");
+    process.exit(0);
+  }
+  let pattern;
+  try {
+    pattern = new RegExp(query, "i");
+  } catch {
+    pattern = new RegExp(query.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i");
+  }
+  const matches = [];
+  for (const projectPath of filteredProjects) {
+    const brainDir = join21(projectPath, BRAIN_DIR);
+    if (!existsSync21(brainDir)) continue;
+    const memoryMatches = searchFile(join21(brainDir, "MEMORY.md"), pattern, opts.section);
+    for (const m of memoryMatches) {
+      matches.push({ projectPath, file: "MEMORY.md", section: m.section, lines: m.lines });
+    }
+    if (opts.log) {
+      const logMatches = searchFile(join21(brainDir, "LOG.md"), pattern, void 0);
+      for (const m of logMatches) {
+        matches.push({ projectPath, file: "LOG.md", section: m.section, lines: m.lines });
+      }
+    }
+  }
+  console.log("");
+  if (matches.length === 0) {
+    console.log(`  ${chalk21.dim(`No matches for "${query}"`)}`);
+    if (!opts.log) {
+      console.log(`  ${chalk21.dim("Add --log to also search session history.")}`);
+    }
+    console.log("");
+    process.exit(0);
+  }
+  const byProject = {};
+  for (const m of matches) {
+    if (!byProject[m.projectPath]) byProject[m.projectPath] = [];
+    byProject[m.projectPath].push(m);
+  }
+  const totalProjects = Object.keys(byProject).length;
+  console.log(`  ${chalk21.bold(`Found in ${totalProjects} project${totalProjects !== 1 ? "s" : ""}:`)}  ${chalk21.dim(`"${query}"`)}`);
+  console.log("");
+  for (const [projectPath, projectMatches] of Object.entries(byProject)) {
+    const parts = projectPath.split("/");
+    const projectName = parts[parts.length - 1] ?? projectPath;
+    console.log(`  ${chalk21.bold(projectName)}  ${chalk21.dim(projectPath)}`);
+    for (const m of projectMatches) {
+      console.log(`    ${chalk21.cyan(m.file)} ${chalk21.dim("\u2192")} ${chalk21.cyan(m.section)}`);
+      for (const line of m.lines) {
+        const highlighted = line.replace(pattern, (match) => chalk21.yellow(match));
+        console.log(`      ${chalk21.dim("\xB7")} ${highlighted}`);
+      }
+    }
+    console.log("");
+  }
+});
+
+// src/commands/learn.ts
+import { Command as Command22 } from "commander";
+import chalk22 from "chalk";
+import { existsSync as existsSync22, readFileSync as readFileSync20, writeFileSync as writeFileSync11 } from "fs";
+import { join as join22, resolve as resolve19, extname as extname2 } from "path";
+function resolveSection(hint) {
+  if (!hint) return "Important Context";
+  const h = hint.toLowerCase();
+  if (h.includes("core")) return "Core";
+  if (h.includes("arch")) return "Architecture";
+  if (h.includes("dec")) return "Decisions";
+  if (h.includes("conv")) return "Conventions";
+  return "Important Context";
+}
+async function fetchUrl(url) {
+  const { default: https } = await (url.startsWith("https") ? import("https") : import("http"));
+  return new Promise((resolve20, reject) => {
+    const req = https.get(url, { headers: { "User-Agent": "mindlink-learn/1.0" } }, (res) => {
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        fetchUrl(res.headers.location).then(resolve20).catch(reject);
+        return;
+      }
+      if (res.statusCode < 200 || res.statusCode >= 300) {
+        reject(new Error(`HTTP ${res.statusCode}`));
+        return;
+      }
+      let data = "";
+      res.on("data", (chunk) => {
+        data += chunk;
+      });
+      res.on("end", () => resolve20(data));
+    });
+    req.on("error", reject);
+    req.setTimeout(15e3, () => {
+      req.destroy();
+      reject(new Error("Request timed out"));
+    });
+  });
+}
+function stripHtml(html) {
+  return html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/\s{2,}/g, " ").replace(/\n{3,}/g, "\n\n").trim();
+}
+function readLocalFile(filePath) {
+  const ext = extname2(filePath).toLowerCase();
+  const raw = readFileSync20(filePath, "utf8");
+  if (ext === ".json") {
+    try {
+      return JSON.stringify(JSON.parse(raw), null, 2).slice(0, 8e3);
+    } catch {
+      return raw;
+    }
+  }
+  return raw;
+}
+function extractFacts(text3, maxLines = 60) {
+  const SKIP_PATTERNS = [
+    /^(cookie|privacy|terms|copyright|all rights reserved|subscribe|sign up|log in|home|menu|search|navigation)/i,
+    /^\s*[\|<>\/\\]\s*$/,
+    /^https?:\/\//
+  ];
+  const lines = text3.split("\n").map((l) => l.trim()).filter(
+    (l) => l.length > 10 && l.length < 300 && !SKIP_PATTERNS.some((p) => p.test(l))
+  );
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const line of lines) {
+    const key = line.toLowerCase().replace(/\s+/g, " ");
+    if (!seen.has(key)) {
+      seen.add(key);
+      deduped.push(line);
+    }
+  }
+  return deduped.slice(0, maxLines).join("\n");
+}
+function appendToMemory(memoryPath, section, facts, source) {
+  let content = readFileSync20(memoryPath, "utf8");
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const entry = `<!-- learned from: ${source} on ${date} -->
+${facts.trim()}`;
+  const lines = content.split("\n");
+  let headingIdx = -1;
+  let nextSectionIdx = lines.length;
+  let headingLevel = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const match = lines[i].match(/^(#{1,6})\s+(.+)/);
+    if (match) {
+      const level = match[1].length;
+      const title = match[2].replace(/<!--.*?-->/g, "").trim();
+      if (headingIdx < 0 && title.toLowerCase() === section.toLowerCase()) {
+        headingIdx = i;
+        headingLevel = level;
+      } else if (headingIdx >= 0 && level <= headingLevel) {
+        nextSectionIdx = i;
+        break;
+      }
+    }
+  }
+  if (headingIdx < 0) {
+    content = content.trimEnd() + `
+
+## ${section}
+
+${entry}
+`;
+  } else {
+    const insertAt = nextSectionIdx > 0 && lines[nextSectionIdx - 1].trim() === "---" ? nextSectionIdx - 1 : nextSectionIdx;
+    lines.splice(insertAt, 0, "", entry, "");
+    content = lines.join("\n");
+  }
+  writeFileSync11(memoryPath, content);
+}
+var learnCommand = new Command22("learn").description("Extract facts from a file or URL and save them into project memory").argument("<source>", "File path or URL to learn from").option("--section <name>", "Target memory section (core, architecture, decisions, conventions, context)", "context").option("--preview", "Show what would be learned without writing anything").addHelpText("after", `
+Examples:
+  mindlink learn ./docs/architecture.md
+  mindlink learn https://example.com/api-docs
+  mindlink learn ./package.json --section architecture
+  mindlink learn ./DECISIONS.md --section decisions
+  mindlink learn https://stripe.com/docs/webhooks --preview
+  `).action(async (source, opts) => {
+  const projectPath = resolve19(process.cwd());
+  const brainDir = join22(projectPath, BRAIN_DIR);
+  if (!existsSync22(brainDir)) {
+    console.log(`  ${chalk22.red("\u2717")}  No .brain/ found in this directory.`);
+    console.log(`     Run ${chalk22.cyan("mindlink init")} to get started.`);
+    console.log("");
+    process.exit(1);
+  }
+  const memoryPath = join22(brainDir, "MEMORY.md");
+  if (!existsSync22(memoryPath)) {
+    console.log(`  ${chalk22.red("\u2717")}  MEMORY.md not found in .brain/.`);
+    console.log(`     Run ${chalk22.cyan("mindlink init")} to set up memory.`);
+    console.log("");
+    process.exit(1);
+  }
+  const section = resolveSection(opts.section);
+  const isUrl = source.startsWith("http://") || source.startsWith("https://");
+  console.log("");
+  let rawText = "";
+  if (isUrl) {
+    process.stdout.write(`  Fetching ${chalk22.dim(source)}...
+`);
+    try {
+      const html = await fetchUrl(source);
+      rawText = stripHtml(html);
+    } catch (err) {
+      console.log(`  ${chalk22.red("\u2717")}  Could not fetch URL: ${err instanceof Error ? err.message : String(err)}`);
+      console.log(`     Check the URL is reachable and try again.`);
+      console.log("");
+      process.exit(1);
+    }
+  } else {
+    const absPath = resolve19(projectPath, source);
+    if (!existsSync22(absPath)) {
+      console.log(`  ${chalk22.red("\u2717")}  File not found: ${absPath}`);
+      console.log("");
+      process.exit(1);
+    }
+    try {
+      rawText = readLocalFile(absPath);
+    } catch (err) {
+      console.log(`  ${chalk22.red("\u2717")}  Could not read file: ${err instanceof Error ? err.message : String(err)}`);
+      console.log("");
+      process.exit(1);
+    }
+  }
+  if (!rawText.trim()) {
+    console.log(`  ${chalk22.yellow("\u2192")}  Source is empty \u2014 nothing to learn.`);
+    console.log("");
+    process.exit(0);
+  }
+  const facts = extractFacts(rawText);
+  if (!facts.trim()) {
+    console.log(`  ${chalk22.yellow("\u2192")}  Could not extract any meaningful content from this source.`);
+    console.log("");
+    process.exit(0);
+  }
+  if (opts.preview) {
+    console.log(`  ${chalk22.bold("Preview")} \u2014 would add to ${chalk22.cyan("## " + section)} in MEMORY.md:`);
+    console.log("");
+    const previewLines = facts.split("\n").slice(0, 20);
+    for (const line of previewLines) {
+      console.log(`  ${chalk22.dim("\xB7")} ${line}`);
+    }
+    if (facts.split("\n").length > 20) {
+      console.log(`  ${chalk22.dim(`... and ${facts.split("\n").length - 20} more lines`)}`);
+    }
+    console.log("");
+    console.log(`  Run without ${chalk22.cyan("--preview")} to save.`);
+    console.log("");
+    process.exit(0);
+  }
+  try {
+    appendToMemory(memoryPath, section, facts, source);
+  } catch (err) {
+    console.log(`  ${chalk22.red("\u2717")}  Failed to write to MEMORY.md: ${err instanceof Error ? err.message : String(err)}`);
+    console.log("");
+    process.exit(1);
+  }
+  const lineCount = facts.split("\n").filter((l) => l.trim()).length;
+  console.log(`  ${chalk22.green("\u2713")}  Learned ${lineCount} lines from ${chalk22.dim(source)}`);
+  console.log(`     Added to ${chalk22.cyan("## " + section)} in MEMORY.md`);
+  console.log("");
+  console.log(`  ${chalk22.dim("Your AI will see this context starting next session.")}`);
+  console.log(`  ${chalk22.dim("Run mindlink verify to check memory health.")}`);
+  console.log("");
+  const existing = extractSection(readFileSync20(memoryPath, "utf8"), section);
+  const existingLines = existing.split("\n").filter((l) => l.trim() && !l.startsWith("<!--")).length;
+  if (existingLines > 80) {
+    console.log(`  ${chalk22.yellow("\u2192")}  ## ${section} is getting large (${existingLines} lines).`);
+    console.log(`     Run ${chalk22.cyan("mindlink prune")} to retire stale entries.`);
+    console.log("");
+  }
+});
+
 // src/cli.ts
-var program = new Command20();
+var program = new Command23();
 program.name("mindlink").description("Give your AI a brain.").version(VERSION, "-v, --version");
 program.addCommand(initCommand);
 program.addCommand(statusCommand);
@@ -3444,9 +4046,12 @@ program.addCommand(verifyCommand);
 program.addCommand(profileCommand);
 program.addCommand(pruneCommand);
 program.addCommand(mcpCommand);
+program.addCommand(recapCommand);
+program.addCommand(searchCommand);
+program.addCommand(learnCommand);
 program.on("command:*", (operands) => {
   const unknown = operands[0];
-  const known = ["init", "status", "log", "clear", "reset", "config", "sync", "update", "summary", "uninstall", "export", "import", "doctor", "version", "diff", "verify", "profile", "prune", "mcp"];
+  const known = ["init", "status", "log", "clear", "reset", "config", "sync", "update", "summary", "uninstall", "export", "import", "doctor", "version", "diff", "verify", "profile", "prune", "mcp", "recap", "search", "learn"];
   function levenshtein(a, b) {
     const m = a.length, n = b.length;
     const dp = Array.from(
@@ -3462,11 +4067,11 @@ program.on("command:*", (operands) => {
   }
   const closest = known.map((cmd) => ({ cmd, dist: levenshtein(unknown, cmd) })).sort((a, b) => a.dist - b.dist)[0];
   console.log("");
-  console.log(`  ${chalk20.red("\u2717")}  Unknown command: ${chalk20.bold(unknown)}`);
+  console.log(`  ${chalk23.red("\u2717")}  Unknown command: ${chalk23.bold(unknown)}`);
   if (closest && closest.dist <= 3) {
-    console.log(`     Did you mean ${chalk20.cyan("mindlink " + closest.cmd)}?`);
+    console.log(`     Did you mean ${chalk23.cyan("mindlink " + closest.cmd)}?`);
   }
-  console.log(`     Run ${chalk20.cyan("mindlink --help")} to see all commands.`);
+  console.log(`     Run ${chalk23.cyan("mindlink --help")} to see all commands.`);
   console.log("");
   process.exit(1);
 });