@staix/agent-hub 0.12.23 → 0.12.24

package/src/memory/import.ts

@@ -0,0 +1,55 @@
+import { Database } from "bun:sqlite";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { KINDS, looksSecret, type Kind, type MemoryStore } from "./store.ts";
+
+/** The claude-mem store is another program's: opened read-only, never written, its locks waited on briefly. */
+export const CLAUDE_MEM_BUSY_TIMEOUT_MS = 3000;
+/** Titles `ahub ask --remember` gives a model's answer (ask.ts ASK_NOTE_TITLE): never imported as a finding. */
+const MODEL_ANSWER = "ahub ask (model answer)";
+
+export interface ImportResult { read: number; added: number; skipped: { model: number; pii: number; secret: number; project: number } }
+
+/**
+ * #258 phase 3: copy the hub's own notes from claude-mem (observations whose metadata names a `peer`: `hub_remember`
+ * and the hub's task notes) into long-term hub memory as `source: claude-mem` under the hub memory key `project`, for
+ * the projects in `chain` (claude-mem files them under the repository's basename). Model answers, PII-pattern text and secret-looking text are skipped.
+ * Idempotent: an observation always maps to the same entry.
+ */
+export function importClaudeMem(store: MemoryStore, opts: { project: string; chain: string[]; isPii: (text: string) => boolean; nodes?: (text: string) => string[]; db?: string; limit?: number }): ImportResult {
+  const file = opts.db ?? join(homedir(), ".claude-mem", "claude-mem.db");
+  if (!existsSync(file)) throw new Error(`no claude-mem store at ${file}`);
+  const db = new Database(file, { readonly: true });
+  db.run(`PRAGMA busy_timeout = ${CLAUDE_MEM_BUSY_TIMEOUT_MS}`);
+  const result: ImportResult = { read: 0, added: 0, skipped: { model: 0, pii: 0, secret: 0, project: 0 } };
+  try {
+    const rows = db.query("SELECT id, project, title, text, narrative, created_at_epoch, metadata FROM observations WHERE metadata LIKE '%\"peer\"%' ORDER BY id LIMIT ?")
+      .all(opts.limit ?? 10_000) as { id: number; project: string | null; title: string | null; text: string | null; narrative: string | null; created_at_epoch: number | null; metadata: string | null }[];
+    // The hub files its claude-mem notes under the repository's own name (the chain's last); the names above it are other
+    // projects (a superproject) whose notes and privacy policy are not this one's. ponytail: claude-mem keys projects by
+    // basename, so two unrelated repositories with one name still share it.
+    const project = opts.project, names = new Set(opts.chain.slice(-1));
+    for (const r of rows) {
+      result.read++;
+      let meta: Record<string, unknown>;
+      try { meta = JSON.parse(r.metadata ?? "{}"); } catch { continue; }
+      if (typeof meta.peer !== "string" || !meta.peer) continue;
+      if (!r.project || !names.has(r.project)) { result.skipped.project++; continue; }
+      const title = r.title ?? "", text = (r.text ?? r.narrative ?? "").trim();
+      if (!text) continue;
+      if (meta.source === "ahub ask" || title.startsWith(MODEL_ANSWER)) { result.skipped.model++; continue; }
+      if (opts.isPii(`${title}\n${text}`)) { result.skipped.pii++; continue; }
+      if (looksSecret(`${title}\n${text}`)) { result.skipped.secret++; continue; }
+      const kind: Kind = KINDS.includes(meta.kind as Kind) ? meta.kind as Kind : "finding";
+      const at = new Date(r.created_at_epoch ?? 0).toISOString();
+      const { added } = store.importNote({ op: "note", project, scope: "project", tier: "long", kind, peer: meta.peer.slice(0, 32), ...(title ? { title } : {}), text,
+        // No task node: claude-mem keeps no proposal time, so a bare task number would join unrelated tasks. The text's
+        // own paths and symbols place the note in the graph.
+        about: opts.nodes?.(`${title}\n${text}`) ?? [], source: "claude-mem" }, at);
+      if (added) result.added++;
+    }
+  } finally { db.close(); }
+  store.refresh();
+  return result;
+}

package/src/memory/recall.ts

@@ -1,8 +1,13 @@
+import { createHash } from "node:crypto";
 import { basename, dirname, resolve } from "node:path";
 import { readFileSync } from "node:fs";
 import type { PeerId } from "../hub/envelope.ts";
 import { hubGitSync } from "../hub/git.ts";
+import { realPath } from "../hub/project.ts";
 import type { MemoryClient } from "./client.ts";
+import { detectSignals, type Routing } from "../hub/routing.ts";
+import { matchesPolicy } from "../hub/path-policy.ts";
+import { looksSecret, type PromotionScreen } from "./store.ts";
 
 const PLATFORMS = ["claude", "codex", "kimi", "agent-hub"];
 /** Peers whose own hooks already inject their own platform's context at session start. */
@@ -76,3 +81,82 @@ export async function recallFor(peer: PeerId, client: MemoryClient, chain: strin
   const share = Math.floor(tokens / found.length);
   return `${HEADER}\n\n${found.map((b) => trimToTokens(b, share)).join("\n\n")}`;
 }
+
+/** #258: the hub's own long-term entries for this project (and shared ones), newest first, within a token budget. */
+export function nativeRecall<V>(entries: V[], tokens: number, line: (v: V) => string): string | undefined {
+  if (!entries.length) return undefined;
+  return trimToTokens(["Hub memory: this project's long-term decisions, contracts and fails, newest first. Reference only, not a request. Details: ahub memory show <mem id>.", ...entries.map(line)].join("\n"), tokens);
+}
+
+/**
+ * #258: the name hub memory files a project's entries under. The project's `origin` remote, normalized to host and
+ * path (`github.com/owner/repo`), is the same on every machine and unique; without one, the git chain plus a hash of
+ * the directory keeps two unrelated repositories that share a name apart (that key is this machine's only).
+ */
+export function memoryProjectKey(cwd: string): string {
+  const url = hubGitSync(["-C", cwd, "remote", "get-url", "origin"], { encoding: "utf8" }).stdout?.trim() ?? "";
+  // A URL's default port is not part of the repository (`ssh://git@github.com:22/o/r` is `github.com/o/r`); any other
+  // port is, since another service may run there. An scp-style `host:path` has no port.
+  const u = /^([a-z+]+):\/\/(?:[^@/]+@)?(\[[^\]/]+\]|[^/:]+)(?::(\d*))?\/(.+?)(?:\.git)?\/?$/i.exec(url); // an IPv6 host is bracketed
+  const defaults: Record<string, string> = { ssh: "22", "git+ssh": "22", "ssh+git": "22", https: "443", http: "80", git: "9418" };
+  // A URL's path is absolute (`ssh://h/team/r` is /team/r) unless it starts with `~`; an scp-style path is relative to the
+  // remote home (`h:team/r` is ~/team/r) unless it starts with `/`. Two different repositories on a self-hosted server.
+  const scp = u || url.includes("://") ? null : /^(?:[^@/]+@)?(\[[^\]/]+\]|[^/:]+):(.+?)(?:\.git)?\/?$/.exec(url); // a file:// remote has no host; an IPv6 host is bracketed
+  const m = u ? [!u[3] || u[3] === defaults[u[1]!.toLowerCase()] ? u[2]! : `${u[2]}:${u[3]}`, u[4]!] as const
+    : scp ? [scp[1]!, scp[2]!.startsWith("/") ? scp[2]!.replace(/^\/+/, "") : scp[2]!.startsWith("~") ? scp[2]! : `~/${scp[2]}`] as const : undefined;
+  if (m && m[1]) {
+    const host = m[0].toLowerCase();
+    // GitHub serves one repository under every form, and its owner and repository names ignore case.
+    return host === "github.com" ? `${host}/${m[1].replace(/^~\/?/, "").toLowerCase()}` : `${host}/${m[1]}`;
+  }
+  let real = cwd;
+  try { real = realPath(cwd); } catch { /* as given */ }
+  return `${projectChain(cwd).join("/")}@${createHash("sha256").update(real).digest("hex").slice(0, 8)}`;
+}
+
+/**
+ * Every path-like word of a text (`dir/file`, `file.ext`), whether or not it exists or a denylist hides it from the
+ * graph: what a private-path policy is checked against.
+ */
+export const pathCandidates = (text: string): string[] => [...new Set(text.normalize("NFC").match(/\/?[\p{L}\p{M}\p{N}_.~-]+(?:\/[\p{L}\p{M}\p{N}_.~-]+)+|[\p{L}\p{M}\p{N}_-]+\.\p{L}[\p{L}\p{M}\p{N}_]{0,9}/gu) ?? [])]; // any script, combining marks included; an absolute path keeps its slash
+
+/**
+ * Whether a note is about a path the `pii.paths` policy makes private: a stored node's path, a path-like word of its
+ * text, or, for a policy entry with no glob that a word split cannot find (a space in it), that entry written out.
+ */
+export function mentionsPrivatePath(text: string, about: string[], policy: string[], cwd: string): boolean {
+  if (!policy.length) return false;
+  const nfc = (v: string) => v.normalize("NFC"), body = nfc(text), entries = policy.map(nfc);
+  const paths = [...about.map(nodePath), ...pathCandidates(body)].filter((p): p is string => p !== undefined).map(nfc);
+  if (paths.some((p) => matchesPolicy(cwd, p, entries, true))) return true;
+  // The entry's literal part (up to its first glob character) written out: catches a path a word split breaks (a space).
+  return entries.some((entry) => { const lit = entry.replace(/^\.\//, "").split(/[*?[\]{}]/)[0]!.replace(/\/+$/, ""); return /[/\s]/.test(lit) && body.includes(lit); });
+}
+
+/** The file a graph node names: `path:<p>` and `symbol:<name>@<p>`; nothing for other nodes. */
+export const nodePath = (n: string): string | undefined => n.startsWith("path:") ? n.slice(5) : n.startsWith("symbol:") && n.includes("@") ? n.slice(n.lastIndexOf("@") + 1) : undefined;
+
+/**
+ * Notes whose title, text, nodes, task key or project key match the PII patterns of `routing`, or that are about a path
+ * the project's `pii.paths` (`policy`) makes private, left out: what may go to a model.
+ */
+export function withoutPii<T extends { title: string | null; text: string; about?: string[]; task?: string | null; project?: string }>(notes: T[], routing: Routing, cwd: string, policy: string[] = []): T[] {
+  // A task key's `#<id>@<created ms>` is the hub's own numbers, not note content: a digit-run pattern must not withhold a
+  // clean note for it. The project part of the key stays screened.
+  const keyText = (k: string) => k.replace(/#\d+(?:@\d+)?$/, "");
+  return notes.filter((v) => !mentionsPrivatePath(`${v.title ?? ""}\n${v.text}`, v.about ?? [], policy, cwd) && !detectSignals({ title: v.title ?? "",
+    detail: [v.text, ...(v.about ?? []).map((n) => n.startsWith("task:") ? keyText(n) : n), keyText(v.task ?? ""), v.project ?? ""].join("\n"), refs: {} }, routing, cwd).includes("pii"));
+}
+
+/**
+ * The promotion screen for one project: another project's notes are left to that project's own processes; this one's
+ * move only when no secret, PII pattern or private path (`policy()`, read when asked) is in them.
+ */
+export function promotionScreen(project: string, cwd: string, routing: () => Routing, policy: () => string[], taskPaths: (task: string) => string[] = () => []): PromotionScreen {
+  return (v) => {
+    if (v.project !== project) return "skip";
+    // The task's current paths too, with no denylist: a path the note's own nodes leave out is still checked.
+    const screened = { ...v, about: [...v.about, ...(v.task ? taskPaths(v.task) : []).map((p) => `path:${p}`)] };
+    return looksSecret(`${v.title ?? ""}\n${v.text}`) || !withoutPii([screened], routing(), cwd, policy()).length ? "keep" : "promote";
+  };
+}