yandecode 0.1.1 → 0.2.0

package/dist/chunks/runtime-WAFQWW4M.js

@@ -0,0 +1,755 @@
+import { createRequire as __yandecodeCreateRequire } from 'node:module';
+const require = __yandecodeCreateRequire(import.meta.url);
+import {
+  splitSections
+} from "./chunk-KPDBXQ62.js";
+import {
+  parseSettings
+} from "./chunk-QCQC73WX.js";
+import {
+  forgetInput,
+  getInput2 as getInput,
+  knowledgeSettings,
+  parseMemory,
+  searchInput3 as searchInput,
+  serializeMemory,
+  writeInput
+} from "./chunk-7L6DD2VD.js";
+import {
+  fitRows
+} from "./chunk-OIAMKDTQ.js";
+import {
+  listCandidatePaths
+} from "./chunk-2S6B3DDQ.js";
+import {
+  external_exports,
+  openDatabase,
+  openModuleDb,
+  resolveInsideRoot,
+  toFtsQuery,
+  writeFileAtomic
+} from "./chunk-Y2MIXROU.js";
+
+// packages/cli/src/modules/knowledge/runtime.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "node:fs";
+import { isAbsolute as isAbsolute2, join as join4, relative as relative2 } from "node:path";
+
+// packages/cli/src/modules/knowledge/index-store.ts
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, sep } from "node:path";
+var MIGRATIONS = [
+  `
+  CREATE TABLE docs (path TEXT PRIMARY KEY, mtime_ms INTEGER NOT NULL, size INTEGER NOT NULL);
+  CREATE TABLE sections (
+    id INTEGER PRIMARY KEY,
+    source TEXT NOT NULL,
+    memory_id TEXT,
+    heading TEXT NOT NULL,
+    start_line INTEGER NOT NULL,
+    end_line INTEGER NOT NULL
+  );
+  CREATE INDEX sections_source ON sections (source);
+  CREATE VIRTUAL TABLE sections_fts USING fts5 (content, heading, title, tokenize = 'porter unicode61');
+  CREATE TABLE memories (
+    id TEXT PRIMARY KEY,
+    title TEXT NOT NULL,
+    kind TEXT NOT NULL,
+    durability TEXT NOT NULL,
+    updated TEXT NOT NULL,
+    superseded_by TEXT,
+    sources TEXT NOT NULL
+  );
+  CREATE TABLE meta (key TEXT PRIMARY KEY, value TEXT NOT NULL);
+  CREATE TABLE journal (
+    session_id TEXT NOT NULL,
+    at TEXT NOT NULL,
+    tool TEXT NOT NULL,
+    detail TEXT NOT NULL,
+    failed INTEGER NOT NULL DEFAULT 0
+  );
+  CREATE INDEX journal_session ON journal (session_id);
+  `
+];
+var MARKDOWN = /\.(md|mdx|markdown)$/i;
+function toPosix(path) {
+  return path.split(sep).join("/");
+}
+function walkMarkdown(dir) {
+  if (!existsSync(dir)) return [];
+  const out = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+    const abs = join(dir, entry.name);
+    if (entry.isDirectory()) out.push(...walkMarkdown(abs));
+    else if (MARKDOWN.test(entry.name)) out.push(abs);
+  }
+  return out;
+}
+function repoPathOf(source) {
+  if (/^[a-z]+:\/\//i.test(source) || /^[0-9a-f]{7,40}$/i.test(source) || /^o[0-9a-f]{6}$/.test(source))
+    return null;
+  const path = source.replace(/:\d+(-\d+)?$/, "");
+  return /[./]/.test(path) && !/\s/.test(path) ? path : null;
+}
+var KnowledgeIndex = class _KnowledgeIndex {
+  constructor(db, options) {
+    this.db = db;
+    this.options = options;
+  }
+  db;
+  options;
+  static open(file, options) {
+    mkdirSync(dirname(file), { recursive: true });
+    return new _KnowledgeIndex(openModuleDb(file, MIGRATIONS), options);
+  }
+  close() {
+    this.db.close();
+  }
+  memoryDirRelative() {
+    const rel = relative(this.options.root, this.options.memories.dir);
+    return rel.startsWith("..") || isAbsolute(rel) ? null : toPosix(rel);
+  }
+  docPaths() {
+    const memoryDir = this.memoryDirRelative();
+    const docs = /* @__PURE__ */ new Map();
+    for (const rel of listCandidatePaths(this.options.root)) {
+      if (!MARKDOWN.test(rel)) continue;
+      if (memoryDir && (rel === memoryDir || rel.startsWith(`${memoryDir}/`))) continue;
+      if (rel.startsWith(".claude/")) continue;
+      docs.set(rel, join(this.options.root, rel));
+    }
+    for (const dir of this.options.extraDirs ?? []) {
+      for (const abs of walkMarkdown(dir)) docs.set(toPosix(abs), abs);
+    }
+    return docs;
+  }
+  deleteSource(source) {
+    const ids = this.db.prepare("SELECT id FROM sections WHERE source = ?").all(source);
+    const del = this.db.prepare("DELETE FROM sections_fts WHERE rowid = ?");
+    for (const { id } of ids) del.run(id);
+    this.db.prepare("DELETE FROM sections WHERE source = ?").run(source);
+  }
+  insertSections(source, title, text, memoryId) {
+    const insert = this.db.prepare(
+      "INSERT INTO sections (source, memory_id, heading, start_line, end_line) VALUES (?, ?, ?, ?, ?)"
+    );
+    const fts = this.db.prepare(
+      "INSERT INTO sections_fts (rowid, content, heading, title) VALUES (?, ?, ?, ?)"
+    );
+    for (const s of splitSections(text)) {
+      const id = insert.run(source, memoryId, s.heading, s.startLine, s.endLine).lastInsertRowid;
+      fts.run(id, s.content, s.heading, title);
+    }
+  }
+  syncDocs() {
+    const wanted = this.docPaths();
+    const known = new Map(
+      this.db.prepare("SELECT path, mtime_ms, size FROM docs").all().map((r) => [r.path, r])
+    );
+    for (const path of known.keys()) {
+      if (wanted.has(path)) continue;
+      this.deleteSource(path);
+      this.db.prepare("DELETE FROM docs WHERE path = ?").run(path);
+    }
+    for (const [path, abs] of wanted) {
+      const st = statSync(abs, { throwIfNoEntry: false });
+      if (!st) continue;
+      const prev = known.get(path);
+      if (prev && prev.mtime_ms === Math.trunc(st.mtimeMs) && prev.size === st.size) continue;
+      this.deleteSource(path);
+      this.insertSections(path, path, readFileSync(abs, "utf8"), null);
+      this.db.prepare("INSERT OR REPLACE INTO docs (path, mtime_ms, size) VALUES (?, ?, ?)").run(path, Math.trunc(st.mtimeMs), st.size);
+    }
+  }
+  /** Memories are few: rebuild them whenever the directory's content signature changes. */
+  syncMemories(memories) {
+    const signature = memories.map((m) => `${m.id}@${m.updated}@${m.supersedes.join(",")}`).join("|");
+    const previous = this.db.prepare("SELECT value FROM meta WHERE key = 'memories'").get();
+    if (previous?.value === signature) return;
+    const supersededBy = /* @__PURE__ */ new Map();
+    for (const m of memories) for (const old of m.supersedes) supersededBy.set(old, m.id);
+    for (const { id } of this.db.prepare("SELECT id FROM memories").all()) {
+      this.deleteSource(`memory:${id}`);
+    }
+    this.db.prepare("DELETE FROM memories").run();
+    const insert = this.db.prepare(
+      "INSERT INTO memories (id, title, kind, durability, updated, superseded_by, sources) VALUES (?, ?, ?, ?, ?, ?, ?)"
+    );
+    for (const m of memories) {
+      insert.run(
+        m.id,
+        m.title,
+        m.kind,
+        m.durability,
+        m.updated,
+        supersededBy.get(m.id) ?? null,
+        JSON.stringify(m.sources)
+      );
+      this.insertSections(
+        `memory:${m.id}`,
+        m.title,
+        `${m.title}
+${m.tags.join(" ")}
+${m.body}`,
+        m.id
+      );
+    }
+    this.db.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES ('memories', ?)").run(signature);
+  }
+  /** Repository paths a memory cites that no longer exist (evaluated now: the repo changes). */
+  missingSources(sources) {
+    return sources.filter((source) => {
+      const path = repoPathOf(source);
+      return path !== null && !existsSync(join(this.options.root, path));
+    });
+  }
+  sync() {
+    this.options.memories.pruneExpired();
+    const memories = this.options.memories.list();
+    this.db.transaction(() => {
+      this.syncDocs();
+      this.syncMemories(memories);
+    })();
+  }
+  search(query, options = {}) {
+    const fts = toFtsQuery(query);
+    if (!fts) return [];
+    const limit = options.limit ?? 10;
+    const rows = this.db.prepare(
+      `SELECT s.source, s.memory_id, s.heading, s.start_line, s.end_line,
+                snippet(sections_fts, 0, '', '', ' \u2026 ', 14) AS snippet,
+                m.title, m.kind, m.updated, m.superseded_by, m.sources
+         FROM sections_fts JOIN sections s ON s.id = sections_fts.rowid
+         LEFT JOIN memories m ON m.id = s.memory_id
+         WHERE sections_fts MATCH ? ORDER BY bm25(sections_fts, 1.0, 2.0, 3.0) LIMIT ?`
+    ).all(fts, limit * 5);
+    const hits = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const row of rows) {
+      const hit = this.toHit(row, options.scope ?? "all", options.includeSuperseded ?? false);
+      const key = hit?.type === "memory" ? `m:${hit.id}` : hit ? `d:${hit.path}` : "";
+      if (!hit || seen.has(key)) continue;
+      seen.add(key);
+      hits.push(hit);
+      if (hits.length >= limit) break;
+    }
+    return hits;
+  }
+  /** A search row as a hit, or null when scope/supersession filters it out. */
+  toHit(row, scope, includeSuperseded) {
+    const snippet = row.snippet.replace(/\s+/g, " ").trim().slice(0, 140);
+    if (row.memory_id === null) {
+      if (scope === "memory") return null;
+      return {
+        type: "doc",
+        path: row.source,
+        heading: row.heading,
+        startLine: row.start_line,
+        endLine: row.end_line,
+        snippet
+      };
+    }
+    if (scope === "docs" || row.superseded_by && !includeSuperseded) return null;
+    return {
+      type: "memory",
+      id: row.memory_id,
+      title: row.title ?? "",
+      kind: row.kind ?? "note",
+      updated: row.updated ?? "",
+      stale: this.missingSources(JSON.parse(row.sources ?? "[]")),
+      snippet
+    };
+  }
+  /** Active durable knowledge, newest first, for the SessionStart index. */
+  activeMemories() {
+    return this.db.prepare(
+      "SELECT id, title, kind, updated, durability FROM memories WHERE superseded_by IS NULL ORDER BY updated DESC"
+    ).all();
+  }
+  record(sessionId, entry) {
+    this.db.prepare("INSERT INTO journal (session_id, at, tool, detail, failed) VALUES (?, ?, ?, ?, ?)").run(sessionId, entry.at, entry.tool, entry.detail, entry.failed ? 1 : 0);
+  }
+  /** Returns and clears the activity recorded for a session. */
+  drainJournal(sessionId) {
+    const rows = this.db.prepare("SELECT at, tool, detail, failed FROM journal WHERE session_id = ? ORDER BY rowid").all(sessionId);
+    this.db.prepare("DELETE FROM journal WHERE session_id = ?").run(sessionId);
+    return rows.map((r) => ({ at: r.at, tool: r.tool, detail: r.detail, failed: r.failed === 1 }));
+  }
+};
+
+// packages/cli/src/modules/knowledge/legacy.ts
+import { existsSync as existsSync2, writeFileSync } from "node:fs";
+import { join as join2 } from "node:path";
+var KIND_BY_NAMESPACE = {
+  decisions: "decision",
+  patterns: "pattern",
+  solutions: "fact",
+  failures: "failure",
+  tasks: "note",
+  feedback: "note"
+};
+function importLegacyMemories(legacyDb, repo) {
+  const marker = join2(repo.dir, ".imported-v0");
+  if (!existsSync2(legacyDb) || existsSync2(marker)) return 0;
+  const db = openDatabase(legacyDb);
+  try {
+    const table = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'memories'").get();
+    const rows = table ? db.prepare(
+      "SELECT id, namespace, content, summary FROM memories WHERE archived_at IS NULL ORDER BY created_at"
+    ).all() : [];
+    for (const row of rows) {
+      const firstLine = row.content.split("\n")[0].slice(0, 80);
+      repo.write({
+        title: row.summary?.trim() || firstLine,
+        body: row.content,
+        kind: KIND_BY_NAMESPACE[row.namespace] ?? "note",
+        sources: [`yandecode-v0-memory:${row.id}`],
+        tags: ["imported-v0"]
+      });
+    }
+    writeFileSync(marker, `${(/* @__PURE__ */ new Date()).toISOString()}
+`);
+    return rows.length;
+  } finally {
+    db.close();
+  }
+}
+
+// packages/cli/src/modules/knowledge/memories.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, statSync as statSync2, unlinkSync } from "node:fs";
+import { join as join3 } from "node:path";
+var DAY_MS = 864e5;
+var DUPLICATE_JACCARD = 0.8;
+function words(text) {
+  return new Set(text.toLowerCase().match(/[\p{L}\p{N}]{3,}/gu) ?? []);
+}
+function jaccard(a, b) {
+  if (a.size === 0 && b.size === 0) return 1;
+  let shared = 0;
+  for (const w of a) if (b.has(w)) shared++;
+  return shared / (a.size + b.size - shared);
+}
+function slug(title) {
+  const base = title.normalize("NFKD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 50).replace(/-$/, "");
+  return base || "memory";
+}
+var union = (a, b = []) => [
+  .../* @__PURE__ */ new Set([...a, ...b])
+];
+var MemoryRepository = class {
+  constructor(dir, clock = () => /* @__PURE__ */ new Date()) {
+    this.dir = dir;
+    this.clock = clock;
+  }
+  dir;
+  clock;
+  file(id) {
+    return join3(this.dir, `${id}.md`);
+  }
+  files() {
+    return existsSync3(this.dir) ? readdirSync2(this.dir).filter((f) => f.endsWith(".md")).sort() : [];
+  }
+  read(fileName) {
+    const path = join3(this.dir, fileName);
+    try {
+      const memory = parseMemory(readFileSync2(path, "utf8"));
+      if (memory.created !== "") return memory;
+      const mtime = statSync2(path).mtime.toISOString();
+      return { ...memory, created: mtime, updated: memory.updated || mtime };
+    } catch {
+      return null;
+    }
+  }
+  get(id) {
+    return existsSync3(this.file(id)) ? this.read(`${id}.md`) : null;
+  }
+  /** Valid memories, most recently updated first. */
+  list() {
+    return this.files().flatMap((f) => this.read(f) ?? []).sort((a, b) => b.updated.localeCompare(a.updated));
+  }
+  invalidFiles() {
+    return this.files().filter((f) => this.read(f) === null);
+  }
+  write(input) {
+    mkdirSync2(this.dir, { recursive: true });
+    const now = this.clock().toISOString();
+    const durability = input.durability ?? (input.kind === "session" ? "ephemeral" : "durable");
+    const expires = durability === "ephemeral" ? new Date(this.clock().getTime() + (input.expiresInDays ?? 14) * DAY_MS).toISOString() : null;
+    const fingerprint = words(`${input.title} ${input.body}`);
+    const duplicate = (input.dedupe ?? true) && this.list().find(
+      (m) => m.kind === input.kind && jaccard(words(`${m.title} ${m.body}`), fingerprint) >= DUPLICATE_JACCARD
+    );
+    if (duplicate) {
+      writeFileAtomic(
+        this.file(duplicate.id),
+        serializeMemory({
+          ...duplicate,
+          title: input.title,
+          body: input.body,
+          updated: now,
+          expires: durability === "ephemeral" ? expires : duplicate.expires,
+          tags: union(duplicate.tags, input.tags),
+          sources: union(duplicate.sources, input.sources),
+          supersedes: union(duplicate.supersedes, input.supersedes)
+        })
+      );
+      return { id: duplicate.id, action: "updated" };
+    }
+    const base = `${now.slice(0, 10).replace(/-/g, "")}-${slug(input.title)}`;
+    let id = base;
+    for (let n = 2; existsSync3(this.file(id)); n++) id = `${base}-${n}`;
+    writeFileAtomic(
+      this.file(id),
+      serializeMemory({
+        id,
+        title: input.title,
+        kind: input.kind,
+        durability,
+        created: now,
+        updated: now,
+        expires,
+        supersedes: [...input.supersedes ?? []],
+        tags: [...input.tags ?? []],
+        sources: [...input.sources ?? []],
+        body: input.body
+      })
+    );
+    return { id, action: "created" };
+  }
+  forget(id) {
+    if (!existsSync3(this.file(id))) return false;
+    unlinkSync(this.file(id));
+    return true;
+  }
+  /** Deletes ephemeral memories past their expiry; returns their ids. */
+  pruneExpired() {
+    const now = this.clock().toISOString();
+    const expired = this.list().filter((m) => m.expires !== null && m.expires < now);
+    for (const m of expired) unlinkSync(this.file(m.id));
+    return expired.map((m) => m.id);
+  }
+};
+
+// packages/cli/src/modules/knowledge/session.ts
+var LISTED_FILES = 15;
+var EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+var COMMAND_TOOLS = /* @__PURE__ */ new Set(["Bash", "ctx_run"]);
+function toolUsage(entries) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const e of entries.filter((e2) => !EDIT_TOOLS.has(e2.tool) && e2.tool !== "Bash")) {
+    counts.set(e.tool, (counts.get(e.tool) ?? 0) + 1);
+  }
+  return [...counts].map(([tool, n]) => `${tool} \xD7${n}`).join(", ");
+}
+function summarizeSession(entries, endedAt) {
+  if (entries.length === 0) return null;
+  const edited = [...new Set(entries.filter((e) => EDIT_TOOLS.has(e.tool)).map((e) => e.detail))];
+  const commands = entries.filter((e) => COMMAND_TOOLS.has(e.tool));
+  const failed = [...new Set(commands.filter((e) => e.failed).map((e) => e.detail))];
+  const usage = toolUsage(entries);
+  const when = endedAt.toISOString().slice(0, 16).replace("T", " ");
+  const title = edited.length > 0 ? `Session ${when}: edited ${edited.slice(0, 3).join(", ")}${edited.length > 3 ? ` +${edited.length - 3}` : ""}` : `Session ${when}: ${commands.length} command(s)`;
+  const failing = failed.length > 0 ? `; failing: ${failed.slice(0, 5).map((c) => `\`${c}\``).join(", ")}` : "";
+  const lines = [
+    `Started ${entries[0].at}, ended ${endedAt.toISOString()}.`,
+    edited.length > 0 ? `Edited ${edited.length} file(s): ${edited.slice(0, LISTED_FILES).join(", ")}${edited.length > LISTED_FILES ? ", \u2026" : ""}.` : "No files edited.",
+    `Ran ${commands.length} command(s)${failing}.`,
+    ...usage ? [`yandecode tools: ${usage}.`] : []
+  ];
+  return { title, body: lines.join("\n"), sources: edited.slice(0, LISTED_FILES) };
+}
+function sessionStartIndex(index, repo, maxChars) {
+  const active = index.activeMemories();
+  const durable = active.filter((m) => m.durability === "durable");
+  const lastSession = active.find((m) => m.kind === "session");
+  if (durable.length === 0 && !lastSession) return "";
+  const header = "Project memory (YandeCode) \u2014 titles only; read bodies with knowledge_get(ids):";
+  const lines = durable.map((m) => `- [${m.id}] (${m.kind}) ${m.title}`);
+  const last = lastSession ? repo.get(lastSession.id) : null;
+  const tail = last ? [`Last session [${last.id}]: ${last.body.replace(/\n/g, " ")}`] : [];
+  let kept = lines;
+  const render = () => [
+    header,
+    ...kept,
+    ...kept.length < lines.length ? [`\u2026 ${lines.length - kept.length} older memory(ies): knowledge_search to find them`] : [],
+    ...tail
+  ].join("\n");
+  while (render().length > maxChars && kept.length > 0) kept = kept.slice(0, -1);
+  const text = render();
+  return text.length > maxChars ? text.slice(0, maxChars) : text;
+}
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "with",
+  "this",
+  "that",
+  "from",
+  "what",
+  "where",
+  "como",
+  "para",
+  "uma",
+  "que",
+  "com",
+  "por",
+  "n\xE3o",
+  "isso",
+  "esse",
+  "essa",
+  "have",
+  "does",
+  "should",
+  "please",
+  "can",
+  "you"
+]);
+function promptRecall(index, prompt, maxItems = 3) {
+  const terms = [
+    ...new Set(
+      (prompt.toLowerCase().match(/[\p{L}\p{N}_]{4,}/gu) ?? []).filter((w) => !STOPWORDS.has(w))
+    )
+  ];
+  if (terms.length < 2) return "";
+  const hits = index.search(terms.join(" "), { scope: "memory", limit: 8 }).filter((h) => h.type === "memory").filter((h) => {
+    const text = `${h.title} ${h.snippet}`.toLowerCase();
+    return terms.filter((t) => text.includes(t)).length >= 2;
+  }).slice(0, maxItems);
+  if (hits.length === 0) return "";
+  return [
+    "Possibly relevant project memory (knowledge_get for details):",
+    ...hits.map((h) => `- [${h.id}] (${h.kind}) ${h.title}`)
+  ].join("\n");
+}
+
+// packages/cli/src/modules/knowledge/runtime.ts
+var SYNC_INTERVAL_MS = 1500;
+var states = /* @__PURE__ */ new Map();
+function stateFor(ctx) {
+  let state = states.get(ctx.root);
+  if (!state) {
+    const settings = parseSettings("knowledge", knowledgeSettings, ctx.settings);
+    const memoryDir = isAbsolute2(settings.memoryDir) ? settings.memoryDir : join4(ctx.root, settings.memoryDir);
+    const repo = new MemoryRepository(memoryDir);
+    const imported = importLegacyMemories(ctx.paths.legacyStateDb, repo);
+    if (imported > 0) ctx.log("imported_v0_memories", { count: imported });
+    const index = KnowledgeIndex.open(join4(ctx.paths.yandecodeDir, "knowledge.db"), {
+      root: ctx.root,
+      memories: repo,
+      extraDirs: settings.extraDirs
+    });
+    state = { settings, repo, index, lastSync: 0 };
+    states.set(ctx.root, state);
+  }
+  return state;
+}
+function fresh(ctx) {
+  const state = stateFor(ctx);
+  if (Date.now() - state.lastSync > SYNC_INTERVAL_MS) {
+    state.index.sync();
+    state.lastSync = Date.now();
+  }
+  return state;
+}
+function hitRow(hit) {
+  if (hit.type === "doc") {
+    return `${hit.path}:${hit.startLine}-${hit.endLine}${hit.heading ? ` \xA7 ${hit.heading}` : ""} \u2014 ${hit.snippet}`;
+  }
+  const stale = hit.stale.length > 0 ? ` (stale: ${hit.stale.join(", ")} missing)` : "";
+  return `[${hit.id}] ${hit.kind} \xB7 ${hit.updated.slice(0, 10)} \xB7 ${hit.title}${stale}`;
+}
+function renderMemory(m, index) {
+  const missing = index.missingSources(m.sources);
+  return [
+    `# ${m.title}`,
+    `[${m.id}] ${m.kind} \xB7 ${m.durability} \xB7 updated ${m.updated.slice(0, 10)}${m.expires ? ` \xB7 expires ${m.expires.slice(0, 10)}` : ""}`,
+    ...m.tags.length > 0 ? [`tags: ${m.tags.join(", ")}`] : [],
+    ...m.sources.length > 0 ? [`sources: ${m.sources.join(", ")}`] : [],
+    ...m.supersedes.length > 0 ? [`supersedes: ${m.supersedes.join(", ")}`] : [],
+    ...missing.length > 0 ? [`WARNING: sources no longer exist (${missing.join(", ")}); verify before relying on this.`] : [],
+    "",
+    m.body
+  ].join("\n");
+}
+function renderDoc(ref, ctx, settings) {
+  const match = /^(.*?)(?::(\d+)(?:-(\d+))?)?$/.exec(ref);
+  const path = match[1];
+  const inExtra = isAbsolute2(path) && settings.extraDirs.some((d) => !relative2(d, path).startsWith(".."));
+  let abs;
+  try {
+    abs = inExtra ? path : resolveInsideRoot(ctx.root, path);
+  } catch {
+    return null;
+  }
+  if (!existsSync4(abs)) return null;
+  const lines = readFileSync3(abs, "utf8").split("\n");
+  const start = match[2] ? Number(match[2]) : 1;
+  const end = match[3] ? Number(match[3]) : match[2] ? start : lines.length;
+  return [`## ${path}:${start}-${end}`, ...lines.slice(start - 1, end)].join("\n");
+}
+function knowledgeSearch(raw, ctx) {
+  const args = external_exports.object(searchInput).parse(raw);
+  const { index } = fresh(ctx);
+  const hits = index.search(args.query, {
+    scope: args.scope ?? "all",
+    limit: args.limit ?? 6,
+    includeSuperseded: args.include_superseded ?? false
+  });
+  if (hits.length === 0)
+    return Promise.resolve({ text: `No docs or memories match "${args.query}".` });
+  return Promise.resolve({
+    text: fitRows(
+      `knowledge_search "${args.query}" \u2014 knowledge_get(ids) for details`,
+      hits.map(hitRow),
+      3e3
+    )
+  });
+}
+function knowledgeGet(raw, ctx) {
+  const args = external_exports.object(getInput).parse(raw);
+  const state = fresh(ctx);
+  const blocks = args.ids.map((id) => {
+    const memory = state.repo.get(id);
+    if (memory) return renderMemory(memory, state.index);
+    return renderDoc(id, ctx, state.settings) ?? `## ${id}
+not found (unknown memory id or document path)`;
+  });
+  return Promise.resolve({
+    text: fitRows(`${blocks.length} item(s)`, blocks, args.max_chars ?? 8e3)
+  });
+}
+function memoryWrite(raw, ctx) {
+  const args = external_exports.object(writeInput).parse(raw);
+  const state = stateFor(ctx);
+  const result = state.repo.write({
+    title: args.title,
+    body: args.body,
+    kind: args.kind,
+    ...args.durability ? { durability: args.durability } : {},
+    ...args.tags ? { tags: args.tags } : {},
+    ...args.sources ? { sources: args.sources } : {},
+    ...args.supersedes ? { supersedes: args.supersedes } : {},
+    ...args.expires_in_days ? { expiresInDays: args.expires_in_days } : {}
+  });
+  state.lastSync = 0;
+  ctx.log("memory_write", { id: result.id, action: result.action });
+  const verb = result.action === "created" ? "Saved" : "Updated near-duplicate";
+  return Promise.resolve({
+    text: `${verb} memory [${result.id}] (${relative2(ctx.root, join4(state.repo.dir, `${result.id}.md`))}).`
+  });
+}
+function memoryForget(raw, ctx) {
+  const args = external_exports.object(forgetInput).parse(raw);
+  const state = stateFor(ctx);
+  const removed = state.repo.forget(args.id);
+  state.lastSync = 0;
+  return Promise.resolve(
+    removed ? { text: `Forgot memory [${args.id}].` } : { isError: true, text: `No memory with id "${args.id}".` }
+  );
+}
+function failedTool(response) {
+  if (typeof response !== "object" || response === null) return false;
+  const r = response;
+  if (r.is_error === true || r.interrupted === true) return true;
+  return ["exit_code", "exitCode", "returnCode"].some(
+    (k) => typeof r[k] === "number" && r[k] !== 0
+  );
+}
+var YANDECODE_TOOL = "mcp__yandecode__";
+var EDIT_TOOLS2 = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+var str = (value) => typeof value === "string" ? value : null;
+function bashEntry(input) {
+  const command = str(input.tool_input?.command);
+  return command ? { tool: "Bash", detail: command.slice(0, 200), failed: failedTool(input.tool_response) } : null;
+}
+function editEntry(input, root) {
+  const path = str(input.tool_input?.file_path) ?? str(input.tool_input?.notebook_path);
+  return path ? { tool: input.tool_name, detail: relative2(root, path) || path, failed: false } : null;
+}
+function yandecodeEntry(input) {
+  const name = input.tool_name.slice(YANDECODE_TOOL.length);
+  const args = input.tool_input ?? {};
+  const detail = str(args.command) ?? str(args.title) ?? str(args.query) ?? name;
+  const exit = /\(exit (\d+)/.exec(JSON.stringify(input.tool_response ?? ""))?.[1];
+  return { tool: name, detail: detail.slice(0, 200), failed: exit !== void 0 && exit !== "0" };
+}
+function journalEntry(input, root) {
+  const tool = input.tool_name ?? "";
+  if (tool === "Bash") return bashEntry(input);
+  if (EDIT_TOOLS2.has(tool)) return editEntry(input, root);
+  return tool.startsWith(YANDECODE_TOOL) ? yandecodeEntry(input) : null;
+}
+function onPostToolUse(input, ctx) {
+  const state = stateFor(ctx);
+  if (!state.settings.capture || !input.session_id) return Promise.resolve({ kind: "none" });
+  const entry = journalEntry(input, ctx.root);
+  if (entry) state.index.record(input.session_id, { at: (/* @__PURE__ */ new Date()).toISOString(), ...entry });
+  return Promise.resolve({ kind: "none" });
+}
+function onSessionEnd(input, ctx) {
+  const state = stateFor(ctx);
+  if (!input.session_id) return Promise.resolve({ kind: "none" });
+  const summary = summarizeSession(state.index.drainJournal(input.session_id), /* @__PURE__ */ new Date());
+  if (summary) {
+    const { id } = state.repo.write({
+      ...summary,
+      kind: "session",
+      durability: "ephemeral",
+      expiresInDays: state.settings.sessionTtlDays,
+      dedupe: false
+    });
+    ctx.log("session_summary", { id });
+  }
+  return Promise.resolve({ kind: "none" });
+}
+var runtime = {
+  tools: {
+    knowledge_search: knowledgeSearch,
+    knowledge_get: knowledgeGet,
+    memory_write: memoryWrite,
+    memory_forget: memoryForget
+  },
+  hooks: {
+    SessionStart: (_input, ctx) => {
+      const state = fresh(ctx);
+      const text = sessionStartIndex(state.index, state.repo, state.settings.sessionStartChars);
+      return Promise.resolve(text ? { kind: "context", text } : { kind: "none" });
+    },
+    UserPromptSubmit: (input, ctx) => {
+      const state = fresh(ctx);
+      if (!state.settings.promptRecall || typeof input.prompt !== "string")
+        return Promise.resolve({ kind: "none" });
+      const text = promptRecall(state.index, input.prompt);
+      return Promise.resolve(text ? { kind: "context", text } : { kind: "none" });
+    },
+    PostToolUse: onPostToolUse,
+    SessionEnd: onSessionEnd
+  },
+  doctor: (ctx) => {
+    const state = fresh(ctx);
+    const invalid = state.repo.invalidFiles();
+    return Promise.resolve([
+      {
+        name: "memories",
+        status: "ok",
+        detail: `${state.repo.list().length} in ${relative2(ctx.root, state.repo.dir) || state.repo.dir}`
+      },
+      invalid.length > 0 ? {
+        name: "memory files",
+        status: "warn",
+        detail: `unreadable: ${invalid.join(", ")}`,
+        fix: "fix their front matter (id, title) or delete them"
+      } : { name: "memory files", status: "ok", detail: "all parse" }
+    ]);
+  },
+  dispose: () => {
+    for (const state of states.values()) state.index.close();
+    states.clear();
+    return Promise.resolve();
+  }
+};
+export {
+  runtime
+};
+//# sourceMappingURL=runtime-WAFQWW4M.js.map