replicas-cli 0.2.424 → 0.2.425

package/dist/index.mjs

@@ -24492,7 +24492,7 @@ function formatTurnElapsed(ms) {
 }
 
 // ../shared/src/cli-version.ts
-var CLI_VERSION = "0.2.424";
+var CLI_VERSION = "0.2.425";
 
 // ../shared/src/version.ts
 function compareVersions(v1, v2) {
@@ -30365,6 +30365,42 @@ async function serviceLogsCommand(name, options) {
 }
 
 // src/commands/learnings.ts
+import { createHash as createHash2 } from "crypto";
+import { mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, statSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+var SESSIONS_DIR = join2(CONFIG_DIR, "learnings-sessions");
+var REPRINT_AFTER_READS = 50;
+var SESSION_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+function sessionFilePath() {
+  const key = process.env.REPLICAS_CHAT_ID || process.env.CLAUDE_CODE_SESSION_ID;
+  return key ? join2(SESSIONS_DIR, `${key.replace(/[^a-zA-Z0-9_-]/g, "-")}.json`) : null;
+}
+function readSession(path6) {
+  const session = { reads: 0, shown: {} };
+  try {
+    const parsed = JSON.parse(readFileSync2(path6, "utf-8"));
+    if (typeof parsed?.reads === "number") session.reads = parsed.reads;
+    const shown = parsed?.shown ?? {};
+    for (const [id, entry] of Object.entries(shown)) {
+      if (typeof entry?.read === "number" && typeof entry?.hash === "string") {
+        session.shown[id] = { read: entry.read, hash: entry.hash };
+      }
+    }
+  } catch {
+  }
+  return session;
+}
+function writeSession(path6, session) {
+  try {
+    mkdirSync2(SESSIONS_DIR, { recursive: true, mode: 448 });
+    writeFileSync2(path6, JSON.stringify(session), { mode: 384 });
+    for (const entry of readdirSync2(SESSIONS_DIR)) {
+      const file2 = join2(SESSIONS_DIR, entry);
+      if (Date.now() - statSync(file2).mtimeMs > SESSION_TTL_MS) unlinkSync(file2);
+    }
+  } catch {
+  }
+}
 function printBlocks(learnings) {
   for (const learning of learnings) {
     const labels = [
@@ -30385,14 +30421,30 @@ async function learningsReadCommand(options) {
     method: "POST",
     body: { query }
   });
+  const path6 = sessionFilePath();
+  const session = path6 ? readSession(path6) : null;
+  if (session) session.reads += 1;
+  const unseen = response.learnings.filter((learning) => {
+    if (!session) return true;
+    const hash2 = createHash2("sha256").update(learning.content).digest("hex").slice(0, 16);
+    const shown = session.shown[learning.id];
+    if (!options.fresh && shown && shown.hash === hash2 && session.reads - shown.read < REPRINT_AFTER_READS) {
+      return false;
+    }
+    session.shown[learning.id] = { read: session.reads, hash: hash2 };
+    return true;
+  });
   if (response.learnings.length === 0) {
     console.log("No learnings matched this query.");
+  } else if (unseen.length === 0) {
+    console.log("No new learnings \u2014 the matching ones were already shown earlier in this session.");
   } else {
-    printBlocks(response.learnings);
+    printBlocks(unseen);
   }
   if (response.matching_degraded) {
     console.log("Note: trigger matching was unavailable \u2014 only always-apply learnings are shown.");
   }
+  if (path6 && session) writeSession(path6, session);
 }
 async function propose(request) {
   const { proposal } = await agentFetch("/v1/agent/learnings/proposals", {
@@ -30442,14 +30494,14 @@ async function learningsWithdrawCommand(id) {
 
 // src/commands/computer/index.ts
 import { spawn as spawn5, spawnSync as spawnSync3 } from "child_process";
-import { createHash as createHash2 } from "crypto";
-import { closeSync as closeSync2, copyFileSync as copyFileSync2, existsSync as existsSync3, mkdirSync as mkdirSync4, openSync as openSync2, readFileSync as readFileSync4, readSync, rmSync as rmSync4, writeFileSync as writeFileSync4 } from "fs";
+import { createHash as createHash3 } from "crypto";
+import { closeSync as closeSync2, copyFileSync as copyFileSync2, existsSync as existsSync3, mkdirSync as mkdirSync5, openSync as openSync2, readFileSync as readFileSync5, readSync, rmSync as rmSync4, writeFileSync as writeFileSync5 } from "fs";
 import { dirname as dirname3 } from "path";
 import chalk21 from "chalk";
 
 // src/commands/computer/desktop.ts
 import { spawnSync } from "child_process";
-import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2 } from "fs";
+import { existsSync, mkdirSync as mkdirSync3, readFileSync as readFileSync3 } from "fs";
 import { dirname, isAbsolute, resolve as resolve2 } from "path";
 var STATE_DIR = process.env.REPLICAS_DESKTOP_STATE_DIR || "/tmp/replicas-computer";
 var DEFAULT_DISPLAY = process.env.REPLICAS_DESKTOP_DISPLAY || ":99";
@@ -30485,7 +30537,7 @@ function desktopStackHealthy() {
   const pids = {};
   for (const name of ["openbox", "tint2", "x11vnc", "novnc"]) {
     try {
-      const pid = Number.parseInt(readFileSync2(`${STATE_DIR}/${name}.pid`, "utf8").trim(), 10);
+      const pid = Number.parseInt(readFileSync3(`${STATE_DIR}/${name}.pid`, "utf8").trim(), 10);
       if (!Number.isFinite(pid)) return false;
       process.kill(pid, 0);
       pids[name] = pid;
@@ -30528,7 +30580,7 @@ function runDisplayCmd(bin, args) {
   return r.stdout?.toString() ?? "";
 }
 function runDesktopInputCmd(args) {
-  mkdirSync2(dirname(INPUT_LOCK_FILE), { recursive: true });
+  mkdirSync3(dirname(INPUT_LOCK_FILE), { recursive: true });
   return runDisplayCmd("flock", [
     "--exclusive",
     "--wait",
@@ -30603,12 +30655,12 @@ var sleep2 = (ms) => new Promise((resolve3) => setTimeout(resolve3, ms));
 
 // src/commands/computer/recording.ts
 import { spawn as spawn4 } from "child_process";
-import { appendFileSync, existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync3, rmSync as rmSync3, statSync, writeFileSync as writeFileSync3 } from "fs";
+import { appendFileSync, existsSync as existsSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync4, rmSync as rmSync3, statSync as statSync2, writeFileSync as writeFileSync4 } from "fs";
 import { dirname as dirname2 } from "path";
 
 // src/commands/computer/recording/render.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { copyFileSync, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
+import { copyFileSync, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
 
 // src/commands/computer/recording/config.ts
 var cameraMotion = {
@@ -31013,7 +31065,7 @@ function renderRecording(rawPath, target, actions, fps, size) {
   }
   const stamp = `${process.pid}-${Date.now()}`;
   const cursor = cursorAssets(stamp);
-  writeFileSync2(cursor.path, cursorSvg(cursor.size));
+  writeFileSync3(cursor.path, cursorSvg(cursor.size));
   const spans = renderedSegmentSpans(segments);
   const renderedDuration = spans.length ? spans[spans.length - 1].outputEnd : duration3;
   const renderedActions = actionsOnRenderedTimeline(actions, spans);
@@ -31036,7 +31088,7 @@ function renderRecording(rawPath, target, actions, fps, size) {
   const concatInputs = segments.map((_, index) => `[v${index}]`).join("");
   const filter = `${screenSplitFilter};${filters.join(";")};${concatInputs}concat=n=${segments.length}:v=1:a=0[screen];${cursorFilter}`;
   const filterPath = `/tmp/replicas-recording-filter-${stamp}.ffgraph`;
-  writeFileSync2(filterPath, filter);
+  writeFileSync3(filterPath, filter);
   try {
     const r = spawnSync2("ffmpeg", [
       "-y",
@@ -31098,7 +31150,7 @@ function clearRecordingState() {
 }
 function recordingStartedAt() {
   if (!existsSync2(RECORD_STARTED_AT_FILE)) return null;
-  const startedAt = Number.parseInt(readFileSync3(RECORD_STARTED_AT_FILE, "utf8").trim(), 10);
+  const startedAt = Number.parseInt(readFileSync4(RECORD_STARTED_AT_FILE, "utf8").trim(), 10);
   return Number.isFinite(startedAt) ? startedAt : null;
 }
 function logRecordingAction(action) {
@@ -31111,7 +31163,7 @@ function logRecordingAction(action) {
 function readRecordingDimensions() {
   if (!existsSync2(RECORD_DIMENSIONS_FILE)) return configuredDesktopDimensions();
   try {
-    const dimensions = JSON.parse(readFileSync3(RECORD_DIMENSIONS_FILE, "utf8"));
+    const dimensions = JSON.parse(readFileSync4(RECORD_DIMENSIONS_FILE, "utf8"));
     const width = dimensions?.width;
     const height = dimensions?.height;
     if (typeof width === "number" && Number.isFinite(width) && width > 0 && typeof height === "number" && Number.isFinite(height) && height > 0) {
@@ -31129,7 +31181,7 @@ function isOptionalNumber(value) {
 }
 function readRecordingActions() {
   if (!existsSync2(RECORD_ACTIONS_FILE)) return [];
-  return readFileSync3(RECORD_ACTIONS_FILE, "utf8").split("\n").filter(Boolean).flatMap((line) => {
+  return readFileSync4(RECORD_ACTIONS_FILE, "utf8").split("\n").filter(Boolean).flatMap((line) => {
     try {
       const value = JSON.parse(line);
       if (typeof value !== "object" || value === null) return [];
@@ -31151,7 +31203,7 @@ function readRecordingActions() {
 async function computerRecordStartCommand(path6, options) {
   ensureServicesRunning();
   if (existsSync2(RECORD_PID_FILE)) {
-    const pid = parseInt(readFileSync3(RECORD_PID_FILE, "utf8").trim(), 10);
+    const pid = parseInt(readFileSync4(RECORD_PID_FILE, "utf8").trim(), 10);
     if (Number.isFinite(pid)) {
       let alive2 = false;
       try {
@@ -31163,10 +31215,10 @@ async function computerRecordStartCommand(path6, options) {
     }
   }
   const target = resolvePath(path6);
-  mkdirSync3(dirname2(target), { recursive: true });
+  mkdirSync4(dirname2(target), { recursive: true });
   const fps = options.fps ? parseCoord(options.fps, "--fps") : 60;
   const { width, height } = configuredDesktopDimensions();
-  mkdirSync3(STATE_DIR, { recursive: true });
+  mkdirSync4(STATE_DIR, { recursive: true });
   const rawTarget = `${target}.raw-${Date.now()}.mp4`;
   rmSync3(RECORD_ACTIONS_FILE, { force: true });
   const child = spawn4("ffmpeg", [
@@ -31200,17 +31252,17 @@ async function computerRecordStartCommand(path6, options) {
   ], { detached: true, stdio: "ignore" });
   child.unref();
   if (!child.pid) fail("failed to launch ffmpeg");
-  writeFileSync3(RECORD_PID_FILE, String(child.pid));
-  writeFileSync3(RECORD_PATH_FILE, target);
-  writeFileSync3(RECORD_RAW_PATH_FILE, rawTarget);
-  writeFileSync3(RECORD_STARTED_AT_FILE, String(Date.now()));
-  writeFileSync3(RECORD_FPS_FILE, String(fps));
-  writeFileSync3(RECORD_DIMENSIONS_FILE, JSON.stringify({ width, height }));
+  writeFileSync4(RECORD_PID_FILE, String(child.pid));
+  writeFileSync4(RECORD_PATH_FILE, target);
+  writeFileSync4(RECORD_RAW_PATH_FILE, rawTarget);
+  writeFileSync4(RECORD_STARTED_AT_FILE, String(Date.now()));
+  writeFileSync4(RECORD_FPS_FILE, String(fps));
+  writeFileSync4(RECORD_DIMENSIONS_FILE, JSON.stringify({ width, height }));
   const startedAt = Date.now();
   while (Date.now() - startedAt < 5e3) {
     try {
       process.kill(child.pid, 0);
-      if (existsSync2(rawTarget) && statSync(rawTarget).size > 0) {
+      if (existsSync2(rawTarget) && statSync2(rawTarget).size > 0) {
         console.log(`${target} (recording ready in ${Date.now() - startedAt}ms)`);
         return;
       }
@@ -31233,7 +31285,7 @@ async function computerRecordStartCommand(path6, options) {
 async function computerRecordStopCommand() {
   if (!existsSync2(RECORD_PID_FILE) && !existsSync2(RECORD_PATH_FILE)) fail("no recording in progress");
   if (existsSync2(RECORD_PID_FILE)) {
-    const pid = parseInt(readFileSync3(RECORD_PID_FILE, "utf8").trim(), 10);
+    const pid = parseInt(readFileSync4(RECORD_PID_FILE, "utf8").trim(), 10);
     if (!Number.isFinite(pid)) fail("invalid recording pidfile");
     try {
       process.kill(pid, "SIGINT");
@@ -31252,9 +31304,9 @@ async function computerRecordStopCommand() {
     if (alive) fail(`ffmpeg did not finalize recording within 30 seconds (pid ${pid})`);
   }
   if (existsSync2(RECORD_PATH_FILE)) {
-    const target = readFileSync3(RECORD_PATH_FILE, "utf8").trim();
-    const rawPath = existsSync2(RECORD_RAW_PATH_FILE) ? readFileSync3(RECORD_RAW_PATH_FILE, "utf8").trim() : target;
-    const fps = existsSync2(RECORD_FPS_FILE) ? parseInt(readFileSync3(RECORD_FPS_FILE, "utf8").trim(), 10) : 60;
+    const target = readFileSync4(RECORD_PATH_FILE, "utf8").trim();
+    const rawPath = existsSync2(RECORD_RAW_PATH_FILE) ? readFileSync4(RECORD_RAW_PATH_FILE, "utf8").trim() : target;
+    const fps = existsSync2(RECORD_FPS_FILE) ? parseInt(readFileSync4(RECORD_FPS_FILE, "utf8").trim(), 10) : 60;
     const size = readRecordingDimensions();
     const actions = readRecordingActions();
     if (rawPath !== target) {
@@ -31346,7 +31398,7 @@ function loadBrandSvg(canvasW, canvasH) {
       `Brand wallpaper SVG missing at ${path6}. The workspace image is out of date \u2014 \`desktop/brand-wallpaper.svg\` must be installed at $REPLICAS_DESKTOP_TEMPLATES.`
     );
   }
-  return readFileSync4(path6, "utf8").replace(/(<svg[^>]*\s)width="\d+"/, `$1width="${canvasW}"`).replace(/(<svg[^>]*\s)height="\d+"/, `$1height="${canvasH}"`);
+  return readFileSync5(path6, "utf8").replace(/(<svg[^>]*\s)width="\d+"/, `$1width="${canvasW}"`).replace(/(<svg[^>]*\s)height="\d+"/, `$1height="${canvasH}"`);
 }
 var BRAND_PAD_FRACTION = 0.06;
 var SCREENSHOT_CORNER_FRACTION = 0.022;
@@ -31381,7 +31433,7 @@ ${labels.join("\n")}
 </svg>`;
 }
 function overlayGrid(rawPath, target, width, height, gridSize, gridPath) {
-  writeFileSync4(gridPath, buildGridSvg(width, height, gridSize));
+  writeFileSync5(gridPath, buildGridSvg(width, height, gridSize));
   const r = spawnSync3(
     "ffmpeg",
     [
@@ -31409,7 +31461,7 @@ function overlayGrid(rawPath, target, width, height, gridSize, gridPath) {
 }
 async function computerScreenshotCommand(path6, options = {}) {
   const target = resolvePath(path6);
-  mkdirSync4(dirname3(target), { recursive: true });
+  mkdirSync5(dirname3(target), { recursive: true });
   const stamp = `${process.pid}-${Date.now()}`;
   const rawPath = `/tmp/replicas-screenshot-${stamp}.raw.png`;
   const svgPath = `/tmp/replicas-screenshot-${stamp}.brand.svg`;
@@ -31441,12 +31493,12 @@ async function computerScreenshotCommand(path6, options = {}) {
     const shadowMargin = shadowSigma * 3;
     const shadowW = width + shadowMargin * 2;
     const shadowH = height + shadowMargin * 2;
-    writeFileSync4(svgPath, loadBrandSvg(canvasW, canvasH));
-    writeFileSync4(
+    writeFileSync5(svgPath, loadBrandSvg(canvasW, canvasH));
+    writeFileSync5(
       maskPath,
       SCREENSHOT_MASK_TEMPLATE.replace(/__W__/g, String(width)).replace(/__H__/g, String(height)).replace(/__R__/g, String(cornerR))
     );
-    writeFileSync4(
+    writeFileSync5(
       shadowPath,
       SHADOW_MASK_TEMPLATE.replace(/__SW__/g, String(shadowW)).replace(/__SH__/g, String(shadowH)).replace(/__M__/g, String(shadowMargin)).replace(/__W__/g, String(width)).replace(/__H__/g, String(height)).replace(/__R__/g, String(cornerR))
     );
@@ -31488,7 +31540,7 @@ async function computerScreenshotCommand(path6, options = {}) {
   console.log(target);
 }
 function hashFile(path6) {
-  return createHash2("sha256").update(readFileSync4(path6)).digest("hex");
+  return createHash3("sha256").update(readFileSync5(path6)).digest("hex");
 }
 async function captureStableRawScreenshot(target, options) {
   const start = Date.now();
@@ -31539,7 +31591,7 @@ function recordingMousePosition() {
 }
 async function computerObserveCommand(path6, options = {}) {
   const target = resolvePath(path6);
-  mkdirSync4(dirname3(target), { recursive: true });
+  mkdirSync5(dirname3(target), { recursive: true });
   const timeoutMs = options.timeout ? parseCoord(options.timeout, "--timeout") : 3e3;
   const stableMs = options.stableMs ? parseCoord(options.stableMs, "--stable-ms") : 600;
   const pollMs = options.pollMs ? parseCoord(options.pollMs, "--poll-ms") : 200;
@@ -31774,7 +31826,7 @@ function browserStateProperties(node) {
 function readBrowserStateCache(path6) {
   let value;
   try {
-    value = JSON.parse(readFileSync4(path6, "utf8"));
+    value = JSON.parse(readFileSync5(path6, "utf8"));
   } catch {
     return null;
   }
@@ -32120,7 +32172,7 @@ async function captureBrowserSnapshot(page, options) {
       visibleTextLength += Math.min(name.length, remaining) + 1;
     }
   }
-  const revision = createHash2("sha256").update(JSON.stringify([page.url, entries.map(({ key, semantic }) => [key, semantic])])).digest("hex").slice(0, 16);
+  const revision = createHash3("sha256").update(JSON.stringify([page.url, entries.map(({ key, semantic }) => [key, semantic])])).digest("hex").slice(0, 16);
   const snapshot = {
     title: (page.title ?? "").slice(0, 1e3),
     url: (page.url ?? "").slice(0, 2e3),
@@ -32300,7 +32352,7 @@ async function computerBrowserStateCommand(path6, options = {}) {
   const page = await selectChromePage(options);
   const stability = await waitForBrowserStability(page, { timeoutMs, stableMs, pollMs });
   const target = resolvePath(path6);
-  mkdirSync4(dirname3(target), { recursive: true });
+  mkdirSync5(dirname3(target), { recursive: true });
   const [{ snapshot, entries }, screenshotResult] = await Promise.all([
     captureBrowserSnapshot(page, { textLimit, elementLimit }),
     sendChromeCommand(page.webSocketDebuggerUrl, "Page.captureScreenshot", {
@@ -32311,7 +32363,7 @@ async function computerBrowserStateCommand(path6, options = {}) {
   ]);
   const data = screenshotResult.data;
   if (typeof data !== "string") fail("Chrome did not return screenshot data");
-  writeFileSync4(target, Buffer.from(data, "base64"));
+  writeFileSync5(target, Buffer.from(data, "base64"));
   const screenshot = readPngDimensions(target);
   const targetId = page.id ?? "unknown";
   const cachePath = browserStateCachePath(targetId);
@@ -32327,8 +32379,8 @@ async function computerBrowserStateCommand(path6, options = {}) {
       changes = { added: diff.added, changed: diff.changed, removed: diff.removed };
     }
   }
-  mkdirSync4(STATE_DIR, { recursive: true });
-  writeFileSync4(cachePath, JSON.stringify({ url: snapshot.url, documentId: snapshot.documentId, entries }));
+  mkdirSync5(STATE_DIR, { recursive: true });
+  writeFileSync5(cachePath, JSON.stringify({ url: snapshot.url, documentId: snapshot.documentId, entries }));
   const stableState = isRecord(stability.state) ? stability.state : {};
   const state = {
     title: snapshot.title,
@@ -37696,7 +37748,7 @@ if (isAgentMode()) {
     }
   });
   const learnings = program.command("learnings").description("Fetch curated org knowledge and propose changes for human review");
-  learnings.command("read").description("Fetch learnings relevant to a task. Enrich the query with codebase specifics, not the raw user request.").requiredOption("-q, --query <query>", "Enriched task description to match against learning triggers").action(async (options) => {
+  learnings.command("read").description("Fetch learnings relevant to a task. Enrich the query with codebase specifics, not the raw user request.").requiredOption("-q, --query <query>", "Enriched task description to match against learning triggers").option("-f, --fresh", "Print full text even for learnings already shown in this session").action(async (options) => {
     try {
       await learningsReadCommand(options);
     } catch (error51) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replicas-cli",
-  "version": "0.2.424",
+  "version": "0.2.425",
   "description": "CLI for managing Replicas workspaces - SSH into cloud dev environments with automatic port forwarding",
   "main": "dist/index.mjs",
   "bin": {