ashlr-plugin 1.36.4

package/servers/_genome-live.ts

@@ -0,0 +1,263 @@
+/**
+ * _genome-live.ts — in-process genome section refresh after ashlr__edit.
+ *
+ * When ashlr__edit writes a file, call refreshGenomeAfterEdit to patch any
+ * genome sections that embed the edited content verbatim. Sections that only
+ * summarize the file (no literal content match) are invalidated (deleted) so
+ * the propose queue regenerates them.
+ *
+ * Design constraints:
+ *   - Never throws — returns {updated:0,skipped:0} on any failure.
+ *   - Fire-and-forget safe: callers use .catch(()=>{}) and never await.
+ *   - Honors ASHLR_GENOME_AUTO=0 as a kill switch.
+ *   - File-level serialization via a simple in-process mutex Map.
+ *   - Calls _clearCache() so the LRU evicts stale genome retrievals.
+ */
+
+import { readFile, writeFile, unlink } from "fs/promises";
+import { existsSync } from "fs";
+import { dirname, basename, join } from "path";
+
+import {
+  genomeExists,
+  loadManifest,
+  saveManifest,
+  sectionPath,
+  type GenomeManifest,
+} from "@ashlr/core-efficiency/genome";
+import { _clearCache } from "./_genome-cache";
+
+const MAX_GENOME_WALK = 8;
+
+/**
+ * Walk up from `startDir` (inclusive) looking for a directory that contains
+ * `.ashlrcode/genome/manifest.json`. No $HOME cap — this is an internal
+ * helper used only after a write, so we trust the path is valid.
+ */
+function findGenomeRoot(startDir: string): string | null {
+  let current = startDir;
+  for (let i = 0; i <= MAX_GENOME_WALK; i++) {
+    if (genomeExists(current)) return current;
+    const parent = dirname(current);
+    if (parent === current) return null; // filesystem root
+    current = parent;
+  }
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+export interface RefreshResult {
+  updated: number;
+  skipped: number;
+}
+
+/**
+ * After a successful ashlr__edit, patch genome sections that reference the
+ * edited file. Verbatim sections get a string-replace; summarized sections
+ * are deleted so the propose queue can regenerate them.
+ *
+ * @param absolutePath  Absolute path of the file that was edited.
+ * @param editBefore    The `search` string that was replaced.
+ * @param editAfter     The `replace` string that was inserted.
+ */
+export async function refreshGenomeAfterEdit(
+  absolutePath: string,
+  editBefore: string,
+  editAfter: string,
+): Promise<RefreshResult> {
+  // Kill switch — same flag genome-auto-propose.ts respects.
+  if (process.env.ASHLR_GENOME_AUTO === "0") {
+    return { updated: 0, skipped: 0 };
+  }
+
+  try {
+    return await _refreshSafe(absolutePath, editBefore, editAfter);
+  } catch {
+    return { updated: 0, skipped: 0 };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Internal implementation
+// ---------------------------------------------------------------------------
+
+/**
+ * Simple per-genomeRoot serialization mutex.
+ * Two concurrent edits to files under the same genome root are sequenced so
+ * both manifest read-modify-writes land coherently.
+ */
+const locks = new Map<string, Promise<unknown>>();
+
+function withLock<T>(key: string, fn: () => Promise<T>): Promise<T> {
+  const prev = locks.get(key) ?? Promise.resolve();
+  const next: Promise<T> = prev.then(fn, fn as () => Promise<T>);
+  // best-effort: this `settled` shadow exists only to break rejection chaining for the *next* lock waiter; the real error still rides on `next` and is returned to the caller.
+  const settled = next.catch(() => {});
+  locks.set(key, settled);
+  settled.then(() => {
+    if (locks.get(key) === settled) locks.delete(key);
+  });
+  return next;
+}
+
+async function _refreshSafe(
+  absolutePath: string,
+  editBefore: string,
+  editAfter: string,
+): Promise<RefreshResult> {
+  // Resolve genome root — walk up from the file's directory checking for a
+  // genome at each level. We check the file's own dir first (unlike
+  // findParentGenome which skips startDir), then ancestors up to 8 levels.
+  // We don't apply the $HOME cap here because edited files may be anywhere
+  // (e.g. tmpdir during tests, or monorepo subdirs outside HOME).
+  const fileDir = dirname(absolutePath) || "/";
+  const genomeRoot = findGenomeRoot(fileDir);
+
+  if (!genomeRoot) return { updated: 0, skipped: 0 };
+
+  return withLock(genomeRoot, () =>
+    _refreshUnderLock(genomeRoot!, absolutePath, editBefore, editAfter),
+  );
+}
+
+async function _refreshUnderLock(
+  genomeRoot: string,
+  absolutePath: string,
+  editBefore: string,
+  editAfter: string,
+): Promise<RefreshResult> {
+  const manifest = await loadManifest(genomeRoot);
+  if (!manifest) return { updated: 0, skipped: 0 };
+
+  // Find sections that reference this file. The heuristic: a section's path
+  // component or its content will mention the file's basename / relative path.
+  // We check section *content* for the actual literal match — not the section
+  // path — because a section can embed any number of files.
+  const matchingSections = await findSectionsForFile(
+    genomeRoot,
+    manifest,
+    absolutePath,
+  );
+
+  if (matchingSections.length === 0) return { updated: 0, skipped: 0 };
+
+  let updated = 0;
+  let skipped = 0;
+  let manifestDirty = false;
+
+  for (const sectionRel of matchingSections) {
+    const absSection = sectionPath(genomeRoot, sectionRel);
+    let sectionContent: string;
+    try {
+      sectionContent = await readFile(absSection, "utf-8");
+    } catch {
+      skipped++;
+      continue;
+    }
+
+    if (isVerbatim(sectionContent, editBefore)) {
+      // Literal content found — patch in place.
+      const patched = sectionContent.split(editBefore).join(editAfter);
+      try {
+        await writeFile(absSection, patched, "utf-8");
+        // Update the section's updatedAt in the manifest.
+        const idx = manifest.sections.findIndex((s) => s.path === sectionRel);
+        if (idx >= 0) {
+          manifest.sections[idx]!.updatedAt = new Date().toISOString();
+          manifestDirty = true;
+        }
+        updated++;
+      } catch {
+        skipped++;
+      }
+    } else {
+      // Summarized section — invalidate by deleting. The propose queue will
+      // regenerate it on the next SessionEnd or ≥3-proposal flush.
+      try {
+        await unlink(absSection);
+        // Remove the section from the manifest.
+        const idx = manifest.sections.findIndex((s) => s.path === sectionRel);
+        if (idx >= 0) {
+          manifest.sections.splice(idx, 1);
+          manifestDirty = true;
+        }
+        skipped++; // counted as skipped (invalidated, not patched)
+      } catch {
+        skipped++;
+      }
+    }
+  }
+
+  if (manifestDirty) {
+    manifest.updatedAt = new Date().toISOString();
+    await saveManifest(genomeRoot, manifest);
+    // Evict in-process LRU so future ashlr__grep calls re-read from disk.
+    _clearCache();
+  }
+
+  return { updated, skipped };
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Find section relative paths whose content references `absolutePath`.
+ *
+ * Strategy: read each section file and check whether it mentions the file
+ * (by absolute path, or by the filename). We only look at sections that have
+ * a non-trivial probability of embedding the file — sections whose title,
+ * summary, or tags contain the filename are strong candidates; we also check
+ * all sections by content to catch unlabeled embeds.
+ */
+async function findSectionsForFile(
+  genomeRoot: string,
+  manifest: GenomeManifest,
+  absolutePath: string,
+): Promise<string[]> {
+  const fileName = basename(absolutePath);
+  const results: string[] = [];
+
+  for (const section of manifest.sections) {
+    const absSection = sectionPath(genomeRoot, section.path);
+    if (!existsSync(absSection)) continue;
+
+    // Fast pre-filter: does the manifest metadata hint at this file?
+    const metaHint =
+      section.title.includes(fileName) ||
+      section.summary.includes(fileName) ||
+      section.tags.some((t) => t.includes(fileName)) ||
+      section.path.includes(fileName);
+
+    let sectionContent: string;
+    try {
+      sectionContent = await readFile(absSection, "utf-8");
+    } catch {
+      continue;
+    }
+
+    // Check if the section content references the file path or filename.
+    if (
+      metaHint ||
+      sectionContent.includes(absolutePath) ||
+      sectionContent.includes(fileName)
+    ) {
+      results.push(section.path);
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Return true when the section content contains a fenced code block that
+ * includes `editBefore` verbatim, OR when `editBefore` appears literally
+ * anywhere in the section content (covers inline snippets too).
+ */
+function isVerbatim(sectionContent: string, editBefore: string): boolean {
+  return sectionContent.includes(editBefore);
+}

package/servers/_genome-prs.ts

@@ -0,0 +1,188 @@
+/**
+ * _genome-prs.ts — surface merged-PR sections in ashlr__grep retrieval.
+ *
+ * Q3 cousin of _genome-commits.ts. PR sections are written by
+ * scripts/genome-cloud-sync.ts when a `pr_merged` cloud delta arrives. The
+ * grep handler calls retrievePrSections() to surface relevant merged PRs
+ * alongside code matches — so `ashlr__grep "auth bug"` can return both the
+ * code and the PR that recently fixed it.
+ *
+ * Unlike commits + discoveries (which gate retrieval on the v2 manifest),
+ * PR retrieval scans the on-disk `sections/prs/` directory directly because
+ * cloud-sync writes those files OUT-OF-BAND from the manifest. This keeps
+ * the cloud path simple — no manifest mutation per delta — and means
+ * retrieval still works when a teammate runs `ashlr-genome-pull` and then
+ * immediately greps before the next save bumps the manifest.
+ *
+ * Best-effort, fails-silent. Any I/O failure returns [].
+ */
+
+import { readFile, readdir, stat } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+import { type PrSection, prsDir } from "./_manifest-v2";
+import { scoreSectionMeta, tokenize } from "./_genome-commits";
+import { formatFreshness } from "./_genome-freshness";
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+export interface RetrievedPr {
+  id: string;
+  title: string;
+  mergedAt: string;
+  author: string;
+  filesChanged: string[];
+  summary: string;
+  url: string;
+  score: number;
+}
+
+/**
+ * Retrieve up to `limit` PR sections from `sections/prs/` matching `query`.
+ *
+ * @param cwd        genome root (the directory containing `.ashlrcode/`)
+ * @param query      keyword query — same scorer the commit + discovery
+ *                   retrievers use (tag/title/summary weighted)
+ * @param limit      max results (default 3)
+ * @param sinceDays  optional freshness filter — drop PRs merged longer than
+ *                   N days ago. `undefined` disables the filter.
+ *
+ * Returns [] when no PRs match, when the dir doesn't exist, when the
+ * manifest is missing — never throws.
+ */
+export async function retrievePrSections(
+  cwd: string,
+  query: string,
+  limit = 3,
+  sinceDays?: number,
+): Promise<RetrievedPr[]> {
+  try {
+    const dir = prsDir(cwd);
+    if (!existsSync(dir)) return [];
+
+    let entries: string[];
+    try {
+      entries = await readdir(dir);
+    } catch {
+      return [];
+    }
+    const files = entries.filter((n) => n.endsWith(".json"));
+    if (files.length === 0) return [];
+
+    const cutoff =
+      typeof sinceDays === "number" && Number.isFinite(sinceDays) && sinceDays > 0
+        ? Date.now() - sinceDays * 24 * 60 * 60 * 1000
+        : null;
+
+    // Load every PR file. The retention limit caps this at PR_RETENTION_LIMIT
+    // (100 default) so even a full scan is cheap. We deliberately don't
+    // route through the v2 manifest: cloud-sync writes PR files out-of-band
+    // (no manifest update per delta) so the manifest may not yet list them.
+    const loaded: Array<{ section: PrSection; mtimeMs: number }> = [];
+    for (const file of files) {
+      const abs = join(dir, file);
+      try {
+        const [raw, st] = await Promise.all([readFile(abs, "utf-8"), stat(abs)]);
+        const section = JSON.parse(raw) as PrSection;
+        if (!section || typeof section !== "object") continue;
+        loaded.push({ section, mtimeMs: st.mtimeMs });
+      } catch {
+        // Skip corrupt file, keep going.
+      }
+    }
+
+    const queryTerms = new Set(tokenize(query));
+
+    // Build a SectionMetaV2-shaped object on the fly so we can reuse the
+    // same scorer the commit + discovery retrievers use. Tags pull from the
+    // PR author + filesChanged so file-path queries can still hit ("login"
+    // → tag "auth/login.ts" → score boost).
+    const scored = loaded
+      .map(({ section, mtimeMs }) => {
+        // Freshness filter — drop PRs older than the cutoff.
+        if (cutoff !== null) {
+          const t = section.mergedAt ? Date.parse(section.mergedAt) : NaN;
+          if (Number.isFinite(t) && t < cutoff) {
+            return null;
+          }
+        }
+        const tags = [
+          "pr",
+          "pull-request",
+          section.id,
+          ...(section.author ? [section.author.toLowerCase()] : []),
+          ...section.filesChanged.slice(0, 10).map((p) => p.toLowerCase()),
+        ];
+        const meta = {
+          path: `prs/${section.id}.json`,
+          title: section.title,
+          summary: section.summary,
+          tags,
+          tokens: Math.ceil((section.title.length + section.summary.length) / 4),
+          updatedAt: section.mergedAt || new Date(mtimeMs).toISOString(),
+        };
+        let score: number;
+        if (queryTerms.size === 0) {
+          // No meaningful query — surface the most recently merged PRs.
+          score = 1;
+        } else {
+          score = scoreSectionMeta(meta, queryTerms);
+        }
+        return { section, score, mtimeMs };
+      })
+      .filter((x): x is { section: PrSection; score: number; mtimeMs: number } => x !== null && x.score > 0);
+
+    if (scored.length === 0) return [];
+
+    // Sort by score desc, then mergedAt desc (most recent wins ties).
+    scored.sort((a, b) => {
+      if (b.score !== a.score) return b.score - a.score;
+      const ad = a.section.mergedAt || new Date(a.mtimeMs).toISOString();
+      const bd = b.section.mergedAt || new Date(b.mtimeMs).toISOString();
+      return bd > ad ? 1 : bd < ad ? -1 : 0;
+    });
+
+    return scored.slice(0, limit).map(({ section, score }) => ({
+      id: section.id,
+      title: section.title,
+      mergedAt: section.mergedAt,
+      author: section.author,
+      filesChanged: section.filesChanged,
+      summary: section.summary,
+      url: section.url,
+      score,
+    }));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Format a list of retrieved PR sections as a markdown block suitable for
+ * prepending to grep output. Each PR gets a distinct `[PR #<n> - <date>]`
+ * header so the model + user know it's GitHub history, not static code.
+ *
+ * Freshness badge is decorated when mergedAt parses. Matches the
+ * `_genome-commits` formatter conventions.
+ */
+export function formatPrsForPrompt(prs: RetrievedPr[], now: Date = new Date()): string {
+  if (prs.length === 0) return "";
+  const parts = prs.map((p) => {
+    const dateShort = p.mergedAt ? p.mergedAt.slice(0, 10) : "unknown";
+    const badge = formatFreshness(p.mergedAt || undefined, now);
+    const badgeFragment = badge ? ` · ${badge.slice(1, -1)}` : "";
+    const files =
+      p.filesChanged.length === 0
+        ? ""
+        : `\n_files: ${p.filesChanged.slice(0, 6).join(", ")}${
+            p.filesChanged.length > 6 ? ` (+${p.filesChanged.length - 6})` : ""
+          }_\n`;
+    const author = p.author ? `_author: ${p.author}_\n` : "";
+    const link = p.url ? `_${p.url}_\n` : "";
+    return `### [PR #${p.id} - ${dateShort}${badgeFragment}] ${p.title}${files}${author}${link}
+${p.summary}`;
+  });
+  return `## Pull Requests\n\n${parts.join("\n\n---\n\n")}`;
+}