opencode-self-improvement 0.3.6 → 0.4.1

package/README.md

@@ -231,6 +231,18 @@ as `00:11:25.867`, or a unique substring of its text. Omit it to update the newe
 entry of that scope and type. A `query` matching nothing, or matching several rows,
 writes nothing and says so rather than updating the wrong memory.
 
+## Repo scoping
+
+Memories belong to the repo that wrote them: rows are stamped with your git
+remote (an id that survives re-clones and moves between machines) or, with no
+remote, the repo path. Injection, recall, the frontier block, compaction,
+`memory_forget`, and decay only ever see the current repo plus global rows —
+project A's facts never surface in project B. Preferences and habits that
+should follow you everywhere go in with `memory_remember global: true`.
+Memories written before this existed, and ones restored through the viewer,
+are global (visible everywhere), so upgrading changes nothing; exports carry
+origin stamps, so scoping survives a machine hop.
+
 ## Backup & move between machines
 
 `memory_export` writes the live store as JSONL — one JSON object per line

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-self-improvement",
-  "version": "0.3.6",
+  "version": "0.4.1",
   "description": "Durable memory for opencode: remember facts, decisions, and commands across sessions, plus a one-command per-repo setup (/repo-init).",
   "main": "index.ts",
   "exports": {

package/src/gates.ts

@@ -30,6 +30,11 @@ export interface WriteCandidate {
   issue?: string;
   tags?: string[];
   status?: "open" | "settled";
+  // "global" = cross-project (memory_remember global:true; imports carry a
+  // row's origin stamp). Any other value (including undefined) is resolved by
+  // appendMemory against the live repo scope (issue #8).
+  repo?: string;
+  repoPath?: string;
 }
 
 export interface GateContext {

package/src/index.ts

@@ -17,6 +17,7 @@ import { STATUSES, TYPES } from "./types.ts";
 import {
   clearSuperseded,
   isActive,
+  isVisibleHere,
   loadAll,
   markSuperseded,
   resolveMemoryTarget,
@@ -60,6 +61,7 @@ import {
   onCompacting,
 } from "./triggers.ts";
 import { getCurrent, setCurrent } from "./state.ts";
+import { resolveRepo, setRepoScope } from "./repokey.ts";
 import { readLines } from "./logfmt.ts";
 import { buildCapturePrompt, flattenTranscript, parseCandidates, parseModelRef } from "./capture.ts";
 
@@ -163,6 +165,11 @@ const impl = {
   async setup(ctx: PluginCtx): Promise<Cleanup | void> {
     const liveRoot = ctx?.location?.directory ?? process.cwd();
 
+    // Repo scoping (issue #8): resolve this workspace's identity ONCE. Every
+    // append stamps it; every model-facing read filters by it. Never throws —
+    // a non-git dir simply scopes by path.
+    setRepoScope(resolveRepo(liveRoot));
+
     // Character budget for the epoch-frozen injection block: plugin options
     // (object form in opencode.json(c)) win, then OPENCODE_MEMORY_INJECT_BUDGET,
     // then the 1200 default.
@@ -211,6 +218,10 @@ const impl = {
               en(STATUSES),
               "open = live planning thread / frontier (surfaced at session start); settled or omitted = durable knowledge",
             ),
+            global: withDesc(
+              bool(),
+              "Store cross-project (visible in every repo): user preferences and general tooling habits. Default false = the memory belongs to THIS repo.",
+            ),
           },
           ["type", "scope", "content"],
         ),
@@ -222,6 +233,7 @@ const impl = {
             issue: args.issue,
             tags: args.tags,
             status: args.status,
+            repo: args.global ? "global" : undefined,
           };
           const outcome = await runWriteGate(candidate, gateContext());
           if (outcome.action === "promoted") return { content: `Remembered: ${args.type} in ${args.scope}` };
@@ -256,7 +268,7 @@ const impl = {
         options: direct,
         input: obj({ scope: str(), type: en(TYPES), query: str(), limit: num() }),
         async execute(args: any): Promise<{ content: string }> {
-          let results = (await loadAll()).filter(isActive);
+          let results = (await loadAll()).filter(isActive).filter(isVisibleHere);
           if (!results.length) return { content: "No memories found" };
           const total = results.length;
           if (args.scope) results = results.filter((m) => m.scope.includes(args.scope!));
@@ -305,7 +317,7 @@ const impl = {
         ),
         async execute(args: any): Promise<{ content: string }> {
           const prior = (await loadAll()).filter(
-            (m) => m.scope === args.scope && m.type === args.type && isActive(m),
+            (m) => m.scope === args.scope && m.type === args.type && isActive(m) && isVisibleHere(m),
           );
           // Resolve the row BEFORE the gate: an update that cannot identify its
           // target must write nothing, rather than silently superseding whichever
@@ -369,7 +381,7 @@ const impl = {
         options: direct,
         input: obj({}),
         async execute(): Promise<{ content: string }> {
-          const mems = (await loadAll()).filter(isActive);
+          const mems = (await loadAll()).filter(isActive).filter(isVisibleHere);
           if (!mems.length) return { content: "No memories found" };
           const scopes = new Map<string, number>();
           const types = new Map<string, number>();

package/src/init.ts

@@ -8,7 +8,7 @@
 import { basename, join } from "node:path";
 import { existsSync } from "node:fs";
 import { cbmBin } from "./config.ts";
-import { loadAll, markSuperseded } from "./memory.ts";
+import { isVisibleHere, loadAll, markSuperseded } from "./memory.ts";
 import { runWriteGate, type GateContext } from "./gates.ts";
 import { record } from "./evidence.ts";
 import { evidenceCalls, hasGateCheck } from "./triggers.ts";
@@ -185,7 +185,11 @@ export interface InitStamp {
 }
 
 export async function initStamp(scope: string): Promise<InitStamp | null> {
-  const mems = (await loadAll()).filter((m) => !m.superseded_by);
+  // Issue #8: scope is a basename, so two different repos can share one
+  // ("api" next to "api", a fork beside its upstream). Visibility filtering
+  // makes each repo see only its own stamp — basename collisions no longer
+  // alias init state between repos.
+  const mems = (await loadAll()).filter((m) => !m.superseded_by && isVisibleHere(m));
   for (const m of mems) {
     if (m.type !== "context" || m.scope !== scope) continue;
     if (!m.tags?.some((t) => t === "init-stamp")) continue;

package/src/inject.ts

@@ -5,7 +5,7 @@
 // results. Evidence is never injected (invariant I3). Open threads (status=
 // "open") get a single capped frontier block in the digest so planning sessions
 // start at the previous session's frontier instead of re-deriving it.
-import { isActive, loadAll, type Memory } from "./memory.ts";
+import { isActive, loadAll, visibleHere, type Memory } from "./memory.ts";
 import { record } from "./evidence.ts";
 import { dateStr } from "./config.ts";
 import { bracketList } from "./logfmt.ts";
@@ -93,7 +93,8 @@ export async function systemDigest(
   _input: unknown,
   output: TransformOutput,
 ): Promise<void> {
-  const mems = (await loadAll()).filter(isActive);
+  // Repo-scoped (issue #8): model-facing reads see this repo + global rows.
+  const mems = visibleHere((await loadAll()).filter(isActive));
   if (!mems.length) return;
   const latest = mems.map((m) => m.ts).sort().pop() ?? "?";
   output.system.push(
@@ -143,7 +144,8 @@ export async function systemDigest(
 export async function relevantKnowledge(message: string, limit = 3): Promise<string> {
   const text = message.trim();
   if (!text) return "";
-  const mems = (await loadAll()).filter(isActive);
+  // Repo-scoped (issue #8): model-facing reads see this repo + global rows.
+  const mems = visibleHere((await loadAll()).filter(isActive));
   const top = scoreMemories(text, mems, limit);
   if (!top.length) return "";
   return `## Relevant durable memory\n${top.map(formatMemory).join("\n")}`;
@@ -154,7 +156,8 @@ export async function relevantKnowledge(message: string, limit = 3): Promise<str
 // injection block is recomputed only when this string changes (or after a
 // compaction). Evidence and superseded rows never affect it (I3, memory.ts).
 export async function storeVersion(): Promise<string> {
-  const mems = (await loadAll()).filter(isActive);
+  // Repo-scoped (issue #8): model-facing reads see this repo + global rows.
+  const mems = visibleHere((await loadAll()).filter(isActive));
   let max = "";
   for (const m of mems) if (m.ts > max) max = m.ts;
   return `${mems.length}:${max}`;
@@ -193,7 +196,8 @@ const ANCHOR_SETTLED_LIMIT = 5;
 const ANCHOR_BUDGET = 2500;
 
 export async function compactionAnchor(limit = 12): Promise<string> {
-  const mems = (await loadAll()).filter(isActive);
+  // Repo-scoped (issue #8): model-facing reads see this repo + global rows.
+  const mems = visibleHere((await loadAll()).filter(isActive));
   if (!mems.length) return "";
   const byNewest = (a: Memory, b: Memory) => (a.ts < b.ts ? 1 : a.ts > b.ts ? -1 : 0);
   const open = mems
@@ -218,7 +222,8 @@ export async function contextualPull(input: PullInput, output: PullOutput): Prom
   if (!["grep", "glob", "read"].includes(tool)) return;
   const term = argText(input.args);
   if (!term) return;
-  const mems = (await loadAll()).filter(isActive);
+  // Repo-scoped (issue #8): model-facing reads see this repo + global rows.
+  const mems = visibleHere((await loadAll()).filter(isActive));
   const top = scoreMemories(term, mems, 3);
   if (!top.length) return;
   const block = top.map(formatMemory).join("\n");

package/src/memory.ts

@@ -5,6 +5,7 @@
 import { existsSync } from "node:fs";
 import { join, basename } from "node:path";
 import { memoryRoot, deletionsFile, snapshotDir } from "./config.ts";
+import { repoScope } from "./repokey.ts";
 import { appendLog, ensureDir, formatLine, parseLine, readLines } from "./logfmt.ts";
 import { blockedTs } from "./blocklist.ts";
 
@@ -28,6 +29,12 @@ export interface Memory {
   superseded_by?: string;
   reason?: string;
   status?: MemoryStatus;
+  // Origin repo (issue #8): sha1 of the normalized origin URL, the toplevel
+  // path when the repo had no remote, the literal "global" for cross-project
+  // writes, or absent for legacy/viewer rows — all three read as described
+  // in isVisibleHere().
+  repo?: string;
+  repoPath?: string;
   file: string;
   index: number;
 }
@@ -56,6 +63,8 @@ function toMemory(fields: Record<string, unknown>, file: string, index: number):
     reason: typeof fields.reason === "string" ? fields.reason : undefined,
     status:
       fields.status === "open" || fields.status === "settled" ? fields.status : undefined,
+    repo: typeof fields.repo === "string" ? fields.repo : undefined,
+    repoPath: typeof fields.repoPath === "string" ? fields.repoPath : undefined,
     file,
     index,
   };
@@ -89,7 +98,9 @@ export async function loadAll(): Promise<Memory[]> {
 }
 
 export async function loadScope(scope: string): Promise<Memory[]> {
-  return (await loadAll()).filter((m) => m.scope === scope);
+  // Gate dedup/stale reads are repo-scoped: a row from another repo must not
+  // collapse or supersede a write here (issue #8).
+  return (await loadAll()).filter((m) => m.scope === scope && isVisibleHere(m));
 }
 
 export interface AppendMemoryInput {
@@ -99,6 +110,11 @@ export interface AppendMemoryInput {
   issue?: string;
   tags?: string[];
   status?: MemoryStatus;
+  // "global" for explicit cross-project writes; imports carry the row's own
+  // origin stamp (hash survives the machine hop — see repokey.ts). Any other
+  // value is resolved by appendMemory against the live repo scope.
+  repo?: string;
+  repoPath?: string;
 }
 
 // Existing ts values across all memory files, used to guarantee uniqueness of
@@ -130,6 +146,18 @@ export async function appendMemory(input: AppendMemoryInput): Promise<string> {
   while (taken.has(ts) && guard++ < 1000) {
     ts = new Date(new Date(ts).getTime() + 1).toISOString();
   }
+  // Repo stamp (issue #8) at the single write choke point: gated writes,
+  // viewer restores and edits all pass through here. Explicit "global"
+  // survives; an unscoped process (viewer) stamps nothing = global.
+  let repo = input.repo;
+  let repoPath = input.repoPath;
+  if (repo === undefined) {
+    const cur = repoScope();
+    if (cur) {
+      repo = cur.key;
+      repoPath = cur.path;
+    }
+  }
   const file = join(memoryRoot(), `${ts.split("T")[0]}.logfmt`);
   await appendLog(
     file,
@@ -141,6 +169,8 @@ export async function appendMemory(input: AppendMemoryInput): Promise<string> {
       issue: input.issue,
       tags: input.tags?.length ? input.tags.join(",") : undefined,
       status: input.status,
+      repo,
+      repoPath,
     }),
   );
   return ts;
@@ -333,7 +363,10 @@ export async function prune(scope: string, type: string, reason: string): Promis
     for (const line of lines) {
       const parsed = parseLine(line);
       const m = parsed ? toMemory(parsed, file, 0) : null;
-      if (m && m.scope === scope && m.type === type) {
+      // Repo floor (issue #8): forgetting scope X here must never delete
+      // another repo's row for scope X — same basename collisions are real
+      // (a fork next to its upstream).
+      if (m && m.scope === scope && m.type === type && isVisibleHere(m)) {
         deleted.push({ memory: m, reason });
         await logDeletion(m, reason);
         changed = true;
@@ -349,3 +382,21 @@ export async function prune(scope: string, type: string, reason: string): Promis
 export function isActive(m: Memory): boolean {
   return !m.superseded_by;
 }
+
+// The ONLY repo filter the model-facing paths use (injection sinks, recall,
+// list, update targeting, prune, decay, gate scope reads). A row is visible
+// when it is global (explicit marker OR no stamp — legacy rows and writes by
+// processes with no scope, e.g. the viewer), or was written in this repo.
+// Keeping it one predicate is what stops the filtering from drifting between
+// entry points the way pre-zod validation did.
+export function isVisibleHere(m: Memory): boolean {
+  if (!m.repo || m.repo === "global") return true;
+  const cur = repoScope();
+  if (!cur) return true; // unscoped process: no partitioning
+  return m.repo === cur.key || (!!m.repoPath && m.repoPath === cur.path);
+}
+
+// Rows visible to the current process (active filtering stays with callers).
+export function visibleHere(mems: Memory[]): Memory[] {
+  return mems.filter(isVisibleHere);
+}

package/src/portable.ts

@@ -5,7 +5,7 @@
 // moat. Decay is supersede-not-delete and snapshot-first, mirroring prune.
 import { join } from "node:path";
 import { memoryRoot } from "./config.ts";
-import { isActive, loadAll, type Memory } from "./memory.ts";
+import { isActive, isVisibleHere, loadAll, type Memory } from "./memory.ts";
 import { TYPES } from "./types.ts";
 import type { WriteCandidate } from "./gates.ts";
 
@@ -45,6 +45,10 @@ export async function exportMemories(opts: ExportOptions = {}): Promise<ExportRe
       status: m.status,
       tags: m.tags,
       issue: m.issue,
+      // Origin stamps ride along so scoping survives the machine hop (the
+      // repo key is a remote-URL hash; the path is the secondary match).
+      repo: m.repo,
+      repoPath: m.repoPath,
     }),
   );
   await Bun.write(path, lines.length ? lines.join("\n") + "\n" : "");
@@ -79,6 +83,11 @@ function parseRow(line: string): WriteCandidate | null {
   if (r.status === "open" || r.status === "settled") c.status = r.status;
   if (Array.isArray(r.tags) && r.tags.every((t) => typeof t === "string")) c.tags = r.tags;
   if (typeof r.issue === "string" && r.issue) c.issue = r.issue;
+  // Origin stamps survive an export/import hop (repokey.ts): a row written
+  // for repo X stays visible only where repo X is opened, even on a new
+  // machine. Unstamped rows stay global.
+  if (typeof r.repo === "string" && r.repo) c.repo = r.repo;
+  if (typeof r.repoPath === "string" && r.repoPath) c.repoPath = r.repoPath;
   return c;
 }
 
@@ -116,6 +125,8 @@ export async function importMemories(
 export async function findStaleOpen(days: number): Promise<Memory[]> {
   const cutoff = new Date(Date.now() - days * 86_400_000).toISOString();
   return (await loadAll())
-    .filter((m) => isActive(m) && m.status === "open" && m.ts < cutoff)
+    // Decay is repo-scoped (issue #8): running it here must not retire
+    // another repo's open threads.
+    .filter((m) => isActive(m) && isVisibleHere(m) && m.status === "open" && m.ts < cutoff)
     .sort((a, b) => (a.ts < b.ts ? -1 : a.ts > b.ts ? 1 : 0));
 }

package/src/repokey.ts

@@ -0,0 +1,66 @@
+// Repo identity for memory scoping (issue #8). One plugin process serves one
+// workspace, so the scope resolves ONCE at setup; every store write stamps
+// it and every model-facing read filters by it.
+//
+// Two keys, both cheap, with opposite failure modes:
+//   key  — sha1 of the normalized origin URL: survives re-clone, moves, and
+//          export/import to another machine. Absent when the repo has no
+//          origin (fresh or remote-less), where the path is used as the key.
+//   path — resolved git toplevel: the secondary match, so rows stamped
+//          before an origin was added keep recognizing their repo.
+// Rows carry no stamp when their writer had no scope (viewer process,
+// tests) and legacy rows predate the field: both read as GLOBAL — visible
+// everywhere — which keeps every upgrade non-breaking.
+import { createHash } from "node:crypto";
+
+export interface RepoScope {
+  key: string;
+  path: string;
+}
+
+let current: RepoScope | null = null;
+
+export function setRepoScope(scope: RepoScope | null): void {
+  current = scope;
+}
+
+export function repoScope(): RepoScope | null {
+  return current;
+}
+
+// git@github.com:Owner/Repo.git / https://GitHub.com/owner/repo/ ->
+// github.com/owner/repo — the same repo must hash identically whichever
+// remote form (and case) the clone used.
+export function normalizeRemote(url: string): string {
+  let u = url.trim().toLowerCase();
+  u = u.replace(/^(?:https?:\/\/|ssh:\/\/|git:\/\/)/, "");
+  u = u.replace(/^git@/, "");
+  u = u.replace(/\/$/, "");
+  u = u.replace(/\.git$/, "");
+  // scp-style "github.com:owner/repo" -> slash form, so every transport of
+  // one repo hashes to one id. (First colon only; URL ports in remotes are
+  // rarer than the scp form and merely produce a stable different id.)
+  u = u.replace(":", "/");
+  return u;
+}
+
+function git(args: string[], cwd: string): string | null {
+  try {
+    const p = Bun.spawnSync(args, { cwd, stdout: "pipe", stderr: "ignore" });
+    const out = p.stdout?.toString().trim();
+    return p.exitCode === 0 && out ? out : null;
+  } catch {
+    return null;
+  }
+}
+
+// Resolve the current repo from any start dir (never throws; a non-git dir
+// simply scopes by its own path).
+export function resolveRepo(startDir: string): RepoScope {
+  const path = git(["git", "rev-parse", "--show-toplevel"], startDir) ?? startDir;
+  const remote = git(["git", "remote", "get-url", "origin"], path);
+  const key = remote
+    ? createHash("sha1").update(normalizeRemote(remote)).digest("hex").slice(0, 12)
+    : path;
+  return { key, path };
+}

package/src/resolver.ts

@@ -116,7 +116,11 @@ export function extractCallForms(content: string): CallForm[] {
   return forms;
 }
 
-const PATH_RE = /[A-Za-z0-9_@./-]+\.(?:ts|tsx|js|jsx|mjs|cjs)(?::\d+)?/g;
+// The extension must end the name: without the lookahead `Button.tsx` matched
+// as `Button.ts` and `config.json` as `config.js`, and the existence check then
+// blocked real files. `.tsx.snap` and `.js.map` are other files, not refs; a
+// sentence-ending `.` still ends the ref.
+const PATH_RE = /[A-Za-z0-9_@./-]+\.(?:ts|tsx|js|jsx|mjs|cjs)(?!\w|\.\w)(?::\d+)?/g;
 
 export function extractPathRefs(content: string): string[] {
   if (content.length > REGEX_SCAN_MAX_CHARS) return [];