@damian87/omp 0.12.0 → 0.14.0

package/scripts/lib/memory-review-trigger.mjs

@@ -0,0 +1,59 @@
+import { spawn as nodeSpawn } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { ompRoot } from "./omp-root.mjs";
+
+// sessionEnd hook → end-of-session memory review. The hook must return fast
+// (5s timeout), so this only DETACHES `omp memory-review` and returns. The
+// downstream claim guard de-dupes against the wrapper fallback. Fail-open:
+// any error means "don't trigger", never throw into the hook.
+
+function readMemoryMode(cwd) {
+  const env = process.env.OMP_MEMORY_MODE;
+  if (env === "on") return "on";
+  if (env === "off") return "off";
+  try {
+    const p = join(ompRoot(cwd), ".omp", "config.json");
+    if (!existsSync(p)) return "off";
+    const raw = JSON.parse(readFileSync(p, "utf8"));
+    return raw && raw.memoryMode === "on" ? "on" : "off";
+  } catch {
+    return "off";
+  }
+}
+
+function defaultDistPath() {
+  // scripts/lib/ -> packageRoot/dist/src/cli.js (present in the npm package and
+  // dev builds, but NOT in a plugin installed from GitHub — dist is gitignored).
+  const here = dirname(fileURLToPath(import.meta.url));
+  return join(here, "..", "..", "dist", "src", "cli.js");
+}
+
+/** Decide how to invoke the omp CLI. An explicit cliPath (tests/dev) or a
+ *  bundled dist runs via `node <path>`; otherwise — the normal install, where
+ *  the plugin (from GitHub) has no dist but `omp` is installed globally via npm —
+ *  invoke `omp` from PATH. Exported for testing. */
+export function resolveMemoryReviewInvocation({ sessionId, cwd, cliPath, distPath = defaultDistPath(), exists = existsSync } = {}) {
+  const args = ["memory-review", "--session", sessionId, "--root", cwd];
+  if (cliPath) return { command: process.execPath, args: [cliPath, ...args] };
+  if (exists(distPath)) return { command: process.execPath, args: [distPath, ...args] };
+  return { command: "omp", args }; // plugin-from-GitHub: rely on the global omp CLI
+}
+
+export function triggerMemoryReview(options = {}) {
+  const { cwd, sessionId, spawn = nodeSpawn, cliPath, mode } = options;
+  const resolvedMode = mode ?? readMemoryMode(cwd);
+  if (resolvedMode !== "on") return { triggered: false, reason: "memory-mode off" };
+  if (!sessionId || sessionId === "unknown") return { triggered: false, reason: "no session id" };
+  try {
+    const { command, args } = resolveMemoryReviewInvocation({ sessionId, cwd, cliPath });
+    const child = spawn(command, args, { detached: true, stdio: "ignore" });
+    // Handle async spawn errors so they never surface as unhandled (fail-open).
+    if (child && typeof child.on === "function") child.on("error", () => {});
+    if (child && typeof child.unref === "function") child.unref();
+    return { triggered: true };
+  } catch (err) {
+    return { triggered: false, reason: String(err?.message ?? err) };
+  }
+}

package/scripts/lib/pending-directives.mjs

@@ -0,0 +1,36 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { ompRoot } from "./omp-root.mjs";
+
+// Memory-review writes proposed directives to a GATED pending queue (never
+// auto-applied). Without a nudge that queue is invisible and rots, so the
+// sessionStart hook surfaces a count + how to promote. Promotion stays manual:
+// `omp project-memory add-directive "<rule>"` then remove the line.
+
+function pendingPath(cwd) {
+  return join(ompRoot(cwd), ".oh-my-copilot", "memory-review", "pending-directives.md");
+}
+
+/** Count unchecked ("- [ ]") items in the pending-directives queue. */
+export function countPendingDirectives(cwd) {
+  const p = pendingPath(cwd);
+  if (!existsSync(p)) return 0;
+  try {
+    return readFileSync(p, "utf8")
+      .split("\n")
+      .filter((line) => /^\s*-\s*\[\s*\]\s+\S/.test(line)).length;
+  } catch {
+    return 0;
+  }
+}
+
+/** SessionStart nudge string, or "" when nothing is pending. */
+export function pendingDirectivesNudge(cwd) {
+  const n = countPendingDirectives(cwd);
+  if (n === 0) return "";
+  return (
+    `[MEMORY REVIEW] ${n} proposed directive${n === 1 ? "" : "s"} await your review in ` +
+    `.oh-my-copilot/memory-review/pending-directives.md — promote the ones you want with ` +
+    "`omp project-memory add-directive \"<rule>\"`, then delete the line."
+  );
+}

package/scripts/session-end.mjs

@@ -6,6 +6,7 @@ import { endSession } from "./lib/daily-log.mjs";
 import { ompRoot } from "./lib/omp-root.mjs";
 import { failOpen } from "./lib/hook-output.mjs";
 import { parseHookInput } from "./lib/hook-input.mjs";
+import { triggerMemoryReview } from "./lib/memory-review-trigger.mjs";
 
 const HOOK_NAME = "SessionEnd";
 
@@ -28,6 +29,13 @@ const HOOK_NAME = "SessionEnd";
     // Arm a daily-log nudge for the next session if this one did work but
     // logged nothing. endSession never throws.
     endSession(directory);
+    // Memory mode (opt-in): detach the cheap-model end-of-session review.
+    // Best-effort and non-blocking — never delays the hook return.
+    try {
+      triggerMemoryReview({ cwd: directory, sessionId });
+    } catch {
+      // never block session end on the review trigger
+    }
     failOpen();
   } catch (err) {
     console.error(`[hook ${HOOK_NAME}] failed: ${err?.message ?? err}`);

package/scripts/session-start.mjs

@@ -7,6 +7,7 @@ import { checkForUpdate, formatUpdateNotice } from "./lib/version-check.mjs";
 import { scanScheduleResults } from "./lib/schedule-results.mjs";
 import { readRepoGoal, readTodayGoal, recentEntryStats, startSession } from "./lib/daily-log.mjs";
 import { readDirectives } from "./lib/project-memory.mjs";
+import { pendingDirectivesNudge } from "./lib/pending-directives.mjs";
 import { ompRoot } from "./lib/omp-root.mjs";
 import { parseHookInput } from "./lib/hook-input.mjs";
 
@@ -78,6 +79,9 @@ function buildDailyLogBreadcrumb(directory) {
     }
     const repoGoal = readRepoGoal(directory);
     if (repoGoal) parts.push(`[REPO GOAL] ${repoGoal}`);
+    // Memory-review's gated directive queue is invisible without a nudge.
+    const pendingNudge = pendingDirectivesNudge(directory);
+    if (pendingNudge) parts.push(pendingNudge);
     const breadcrumb = buildDailyLogBreadcrumb(directory);
     if (breadcrumb) parts.push(breadcrumb);
     // Resets the per-session baseline and flushes a nudge when the prior session