@remnic/core 9.3.647 → 9.3.649

package/src/qmd.ts

@@ -2700,8 +2700,7 @@ export class QmdClient implements SearchBackend {
     }
   }
 
-  async ensureCollection(
-    memoryDir: string,
+  async checkCollection(
     collectionOrExecution?: string | SearchExecutionOptions,
     execution?: SearchExecutionOptions,
   ): Promise<"present" | "missing" | "unknown" | "skipped"> {
@@ -2723,6 +2722,7 @@ export class QmdClient implements SearchBackend {
       if (collectionRegex.test(stdout)) {
         return "present";
       }
+      return "missing";
     } catch (err) {
       // Treat command/probe failures as unknown so callers do not disable features
       // permanently after a transient CLI or daemon hiccup.
@@ -2731,12 +2731,58 @@ export class QmdClient implements SearchBackend {
       );
       return "unknown";
     }
+  }
 
-    log.info(
-      `QMD collection "${targetCollection}" not found. ` +
-        `Add it to ~/.config/qmd/index.yml pointing at ${memoryDir}`,
+  async ensureCollection(
+    memoryDir: string,
+    collectionOrExecution?: string | SearchExecutionOptions,
+    execution?: SearchExecutionOptions,
+  ): Promise<"present" | "missing" | "unknown" | "skipped"> {
+    const { collection, execution: effectiveExecution } = resolveEnsureCollectionArgs(
+      collectionOrExecution,
+      execution,
     );
-    return "missing";
+    const targetCollection = collection ?? this.collection;
+    const collectionState = await this.checkCollection(targetCollection, effectiveExecution);
+    if (collectionState !== "missing") return collectionState;
+
+    try {
+      await this.runQmdCommand(
+        ["collection", "add", memoryDir, "--name", targetCollection],
+        QMD_TIMEOUT_MS,
+        effectiveExecution?.signal,
+      );
+      log.info(
+        `QMD collection "${targetCollection}" auto-created at ${memoryDir}`,
+      );
+      return "present";
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (isCallerCancellation(err, effectiveExecution?.signal)) {
+        log.debug(
+          `QMD collection auto-create for "${targetCollection}" was cancelled; keeping collection state unknown`,
+        );
+        return "unknown";
+      }
+      const postCreateState = await this.checkCollection(targetCollection, effectiveExecution);
+      if (postCreateState === "present") {
+        log.info(
+          `QMD collection "${targetCollection}" is present after auto-create failure; continuing`,
+        );
+        return "present";
+      }
+      if (/\balready exists\b|\bexists already\b/i.test(msg)) {
+        log.info(
+          `QMD collection "${targetCollection}" already exists after concurrent auto-create; continuing`,
+        );
+        return "present";
+      }
+      if (postCreateState !== "missing") return postCreateState;
+      log.warn(
+        `QMD collection "${targetCollection}" not found and auto-create failed: ${msg}`,
+      );
+      return "missing";
+    }
   }
 }
 

package/src/search/port.ts

@@ -93,6 +93,15 @@ export interface SearchBackend {
   embedCollection(collection: string): Promise<void>;
 
   // ── Collection management ──
+  /**
+   * Optional non-mutating collection probe. Backends that can distinguish a
+   * missing collection from a transient probe failure should implement this so
+   * callers can avoid auto-creating collections in unsafe layouts.
+   */
+  checkCollection?(
+    collectionOrExecution?: string | SearchExecutionOptions,
+    execution?: SearchExecutionOptions,
+  ): Promise<"present" | "missing" | "unknown" | "skipped">;
   ensureCollection(
     memoryDir: string,
     execution?: SearchExecutionOptions,

package/src/transcript-day-range.test.ts

@@ -0,0 +1,101 @@
+/**
+ * Tests for the CLI transcript day-view window helper `utcDayRange`.
+ *
+ * The `transcript --date <day>` and default "today" CLI views read a single
+ * calendar day via {@link TranscriptManager.readRange}, which uses a half-open
+ * `[start, end)` interval (`entryTime < end`, CLAUDE.md rule #35). The day end
+ * must therefore be the NEXT day's `00:00:00Z`, not `${date}T23:59:59Z`:
+ * a literal `23:59:59Z` end (== `.000Z`) silently drops any entry stamped in
+ * the final second of the day (`23:59:59.000Z`–`23:59:59.999Z`).
+ *
+ * (Pre-existing boundary gap flagged as a P2 on PR #1507, fixed out of band.)
+ */
+
+import assert from "node:assert/strict";
+import { mkdtemp, realpath, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { TranscriptManager, utcDayRange } from "./transcript.js";
+import type { PluginConfig, TranscriptEntry } from "./types.js";
+
+function makeConfig(memoryDir: string): PluginConfig {
+  // TranscriptManager only reads memoryDir + transcriptSkipChannelTypes.
+  return {
+    memoryDir,
+    transcriptSkipChannelTypes: [],
+  } as unknown as PluginConfig;
+}
+
+// On macOS `os.tmpdir()` is a `/var/folders/...` symlink to `/private/var/...`.
+// Canonicalize the test root upfront (issue #691 symlink convention).
+async function makeMemoryDir(): Promise<string> {
+  return realpath(await mkdtemp(path.join(os.tmpdir(), "remnic-tx-dayrange-")));
+}
+
+function entryAt(timestamp: string, turnId: string): TranscriptEntry {
+  return {
+    sessionKey: "agent:generalist:main",
+    turnId,
+    role: "user",
+    content: `content-${turnId}`,
+    timestamp,
+  } as TranscriptEntry;
+}
+
+// ── utcDayRange: half-open [start, next-day-00:00:00Z) ───────────────────────
+
+test("utcDayRange end is the next day's 00:00:00Z (half-open day window)", () => {
+  assert.deepEqual(utcDayRange("2025-03-15"), {
+    start: "2025-03-15T00:00:00Z",
+    end: "2025-03-16T00:00:00Z",
+  });
+});
+
+test("utcDayRange rolls over month boundaries", () => {
+  assert.deepEqual(utcDayRange("2025-01-31"), {
+    start: "2025-01-31T00:00:00Z",
+    end: "2025-02-01T00:00:00Z",
+  });
+});
+
+test("utcDayRange rolls over leap-day and year boundaries", () => {
+  assert.deepEqual(utcDayRange("2024-02-28"), {
+    start: "2024-02-28T00:00:00Z",
+    end: "2024-02-29T00:00:00Z",
+  });
+  assert.deepEqual(utcDayRange("2025-12-31"), {
+    start: "2025-12-31T00:00:00Z",
+    end: "2026-01-01T00:00:00Z",
+  });
+});
+
+// ── Day-view range includes the final second of the day (the bug fix) ────────
+
+test("day-view range returns an entry stamped at 23:59:59.500Z of the queried day", async () => {
+  const memoryDir = await makeMemoryDir();
+  try {
+    const tm = new TranscriptManager(makeConfig(memoryDir));
+    const date = "2025-03-15";
+    const channel = "agent:generalist:main";
+
+    // Entry in the final second of the day — dropped by the old
+    // `${date}T23:59:59Z` (== `.000Z`) exclusive upper bound.
+    await tm.append(entryAt(`${date}T23:59:59.500Z`, "final-second"));
+    // Midday control entry, comfortably inside the window.
+    await tm.append(entryAt(`${date}T12:00:00.000Z`, "midday"));
+    // Start-of-next-day entry must stay OUT — the upper bound is exclusive
+    // (`[start, end)`, rule #35), so `nextDate T00:00:00.000Z` is not the
+    // queried day.
+    await tm.append(entryAt("2025-03-16T00:00:00.000Z", "next-day"));
+
+    const { start, end } = utcDayRange(date);
+    const entries = await tm.readRange(start, end, channel);
+    const ids = entries.map((e) => e.turnId).sort();
+
+    assert.deepEqual(ids, ["final-second", "midday"]);
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});

package/src/transcript.ts

@@ -33,6 +33,32 @@ function makeRawLineDeduper(): (rawLine: string) => boolean {
   };
 }
 
+/**
+ * Compute the half-open UTC instant range `[start, end)` that covers an entire
+ * calendar day, suitable for {@link TranscriptManager.readRange}.
+ *
+ * `readRange` filters with an EXCLUSIVE upper bound (`entryTime < end`, CLAUDE.md
+ * rule #35 / AGENTS.md rule 23). The end is therefore the NEXT day's
+ * `00:00:00Z`, not `${date}T23:59:59Z`: a literal `23:59:59Z` end (== `.000Z`)
+ * would drop any entry stamped in the final second of the day
+ * (`23:59:59.000Z`–`23:59:59.999Z`). Using the next day's midnight keeps the
+ * `[start, end)` semantics intact while including the whole day.
+ *
+ * @param date - A `YYYY-MM-DD` calendar day (UTC).
+ */
+export function utcDayRange(date: string): { start: string; end: string } {
+  const start = `${date}T00:00:00Z`;
+  const startMs = Date.parse(start);
+  if (Number.isNaN(startMs)) {
+    // Malformed date: preserve the pre-existing "empty range" behavior (an
+    // unparseable bound makes `readRange` match nothing) rather than throwing.
+    return { start, end: start };
+  }
+  const next = new Date(startMs);
+  next.setUTCDate(next.getUTCDate() + 1);
+  return { start, end: `${next.toISOString().slice(0, 10)}T00:00:00Z` };
+}
+
 /**
  * Manages conversation transcript storage, checkpointing, and recall formatting.
  *