@byterover/claude-plugin 1.0.0 → 1.1.0

package/dist/resolve-context-tree-age.js

@@ -0,0 +1,82 @@
+import { readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import yaml from "js-yaml";
+/**
+ * Resolve the "age" of a context-tree document for the visible recall summary.
+ *
+ * Resolution order, falling through on any failure:
+ *   1. Frontmatter `updatedAt`   — standard topic files (post-curate timestamp)
+ *   2. Frontmatter `synthesized_at` — synthesis files produced by `brv dream`
+ *   3. Frontmatter `createdAt`   — older standard files that lack updatedAt
+ *   4. File `mtime`              — last resort for files without timestamp frontmatter
+ *   5. `undefined`               — file missing or path is a cross-project shared source
+ *
+ * Cross-project paths in the form `[alias]:relative/path.md` are not resolved here —
+ * they live in another project's `.brv/context-tree/`, which the plugin does not see.
+ */
+export function resolveContextTreeAge(projectRoot, relativePath) {
+    // Shared-source paths point outside this project tree; we have no access to their mtime.
+    if (relativePath.startsWith("["))
+        return undefined;
+    const absolutePath = join(projectRoot, ".brv", "context-tree", relativePath);
+    let mtime;
+    try {
+        mtime = statSync(absolutePath).mtime;
+    }
+    catch {
+        // File missing or unreadable — no age to surface.
+        return undefined;
+    }
+    const frontmatterAge = readFrontmatterAge(absolutePath);
+    return frontmatterAge ?? mtime;
+}
+const FRONTMATTER_REGEX = /^---\s*\n([\s\S]*?)\n---\s*(?:\n|$)/;
+const TIMESTAMP_KEYS_IN_PRIORITY = [
+    "updatedAt",
+    "synthesized_at",
+    "createdAt",
+];
+function readFrontmatterAge(absolutePath) {
+    let head;
+    try {
+        // Frontmatter sits at the top of the file; reading the whole file is fine for context-tree
+        // documents (typically <50KB) and avoids the complexity of streaming a partial read.
+        head = readFileSync(absolutePath, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+    const match = head.match(FRONTMATTER_REGEX);
+    if (!match)
+        return undefined;
+    let parsed;
+    try {
+        parsed = yaml.load(match[1] ?? "");
+    }
+    catch {
+        return undefined;
+    }
+    if (!isPlainObject(parsed))
+        return undefined;
+    for (const key of TIMESTAMP_KEYS_IN_PRIORITY) {
+        const candidate = parsed[key];
+        const date = coerceDate(candidate);
+        if (date)
+            return date;
+    }
+    return undefined;
+}
+function isPlainObject(value) {
+    return value !== null && typeof value === "object";
+}
+function coerceDate(value) {
+    if (value instanceof Date) {
+        return Number.isNaN(value.getTime()) ? undefined : value;
+    }
+    if (typeof value === "string") {
+        const parsed = new Date(value);
+        return Number.isNaN(parsed.getTime()) ? undefined : parsed;
+    }
+    return undefined;
+}
+//# sourceMappingURL=resolve-context-tree-age.js.map

package/dist/state-detector.d.ts

@@ -0,0 +1,31 @@
+export type BrvState = "dreaming" | "curating" | "idle";
+/**
+ * Walk up from `startCwd` looking for a `.brv` directory.
+ * Returns the absolute path to `.brv` when found, or undefined when no
+ * ancestor contains one. Closest match wins.
+ */
+export declare function findBrvDir(startCwd: string): string | undefined;
+/**
+ * Inspect the daemon's persisted activity and classify the project state.
+ * Pure filesystem inspection — no daemon RPC.
+ *
+ * Two storage locations are checked because the daemon writes them in
+ * different baseDirs (project-local vs global):
+ *   - dream-log + dream.lock → `<brvDir>/dream-log/`, `<brvDir>/dream.lock`
+ *   - curate-log              → `<getProjectDataDir(cwd)>/curate-log/`
+ *
+ * Precedence (confident signals first, weak signals last):
+ *   1. dream-log latest === "processing"        → dreaming  (confident)
+ *   2. curate-log latest === "processing"       → curating  (confident)
+ *   3. dream.lock present, fresh, log isn't "completed"  → dreaming  (weak fallback)
+ *   4. otherwise                                → idle
+ *
+ * Confident signals (active log entries) outrank the weak dream.lock fallback
+ * so that an active curate isn't masked by a stale dream.lock. Real concurrent
+ * dream + curate is preserved (rule 1 wins). Stale-lock false-positives are
+ * bounded by `STALE_LOCK_THRESHOLD_MS`.
+ *
+ * `cwd` is needed to resolve the daemon's per-project storage directory; it
+ * defaults to the parent of `brvDir` (the project root).
+ */
+export declare function detectState(brvDir: string, cwd?: string): BrvState;

package/dist/state-detector.js

@@ -0,0 +1,123 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getProjectDataDir } from "./project-data-dir.js";
+/**
+ * Maximum age we will trust the standalone `dream.lock` signal. Beyond this
+ * the lock is treated as stale and discarded — the daemon has been observed
+ * to leave locks behind on abnormal exit, so a very old lock is more likely
+ * to be a leftover than a still-running dream.
+ *
+ * Set to 15 minutes: comfortably above the longest dream observed in this
+ * project's logs (~10 min) plus headroom for slower providers / bigger
+ * trees, but short enough that a stuck false-positive self-heals within a
+ * reasonable window. Tune later if real dreams exceed this on other projects.
+ */
+const STALE_LOCK_THRESHOLD_MS = 15 * 60 * 1000;
+/**
+ * Walk up from `startCwd` looking for a `.brv` directory.
+ * Returns the absolute path to `.brv` when found, or undefined when no
+ * ancestor contains one. Closest match wins.
+ */
+export function findBrvDir(startCwd) {
+    let dir = startCwd;
+    while (true) {
+        const candidate = join(dir, ".brv");
+        if (existsSync(candidate) && statSync(candidate).isDirectory()) {
+            return candidate;
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+}
+/**
+ * Inspect the daemon's persisted activity and classify the project state.
+ * Pure filesystem inspection — no daemon RPC.
+ *
+ * Two storage locations are checked because the daemon writes them in
+ * different baseDirs (project-local vs global):
+ *   - dream-log + dream.lock → `<brvDir>/dream-log/`, `<brvDir>/dream.lock`
+ *   - curate-log              → `<getProjectDataDir(cwd)>/curate-log/`
+ *
+ * Precedence (confident signals first, weak signals last):
+ *   1. dream-log latest === "processing"        → dreaming  (confident)
+ *   2. curate-log latest === "processing"       → curating  (confident)
+ *   3. dream.lock present, fresh, log isn't "completed"  → dreaming  (weak fallback)
+ *   4. otherwise                                → idle
+ *
+ * Confident signals (active log entries) outrank the weak dream.lock fallback
+ * so that an active curate isn't masked by a stale dream.lock. Real concurrent
+ * dream + curate is preserved (rule 1 wins). Stale-lock false-positives are
+ * bounded by `STALE_LOCK_THRESHOLD_MS`.
+ *
+ * `cwd` is needed to resolve the daemon's per-project storage directory; it
+ * defaults to the parent of `brvDir` (the project root).
+ */
+export function detectState(brvDir, cwd) {
+    const lockPath = join(brvDir, "dream.lock");
+    const lockExists = existsSync(lockPath);
+    const latestDream = latestLogStatus(join(brvDir, "dream-log"));
+    // Rule 1 — confident dream signal
+    if (latestDream === "processing")
+        return "dreaming";
+    // Rule 2 — confident curate signal, beats the weak dream.lock fallback
+    const projectCwd = cwd ?? dirname(brvDir);
+    let projectDataDir;
+    try {
+        projectDataDir = getProjectDataDir(projectCwd);
+    }
+    catch {
+        projectDataDir = undefined;
+    }
+    if (projectDataDir !== undefined) {
+        if (latestLogStatus(join(projectDataDir, "curate-log")) === "processing") {
+            return "curating";
+        }
+    }
+    // Rule 3 — dream.lock fallback. Honored only when:
+    //   (a) latest dream-log isn't already "completed" (cross-check)
+    //   (b) lock is fresh (within STALE_LOCK_THRESHOLD_MS)
+    if (lockExists && latestDream !== "completed" && lockIsFresh(lockPath)) {
+        return "dreaming";
+    }
+    return "idle";
+}
+function lockIsFresh(lockPath) {
+    try {
+        const stat = statSync(lockPath);
+        return Date.now() - stat.mtimeMs < STALE_LOCK_THRESHOLD_MS;
+    }
+    catch {
+        return false;
+    }
+}
+/** Returns the `status` field of the lex-most-recent *.json log in `logDir`. */
+function latestLogStatus(logDir) {
+    let entries;
+    try {
+        entries = readdirSync(logDir);
+    }
+    catch {
+        return undefined;
+    }
+    const jsonFiles = entries.filter((e) => e.endsWith(".json")).sort();
+    const latest = jsonFiles.at(-1);
+    if (latest === undefined)
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(join(logDir, latest), "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof parsed === "object" &&
+        parsed !== null &&
+        "status" in parsed &&
+        typeof parsed.status === "string") {
+        return parsed.status;
+    }
+    return undefined;
+}
+//# sourceMappingURL=state-detector.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byterover/claude-plugin",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Native bridge between ByteRover context engine and Claude Code — enriches Claude's auto-memory with BM25-ranked knowledge from brv context tree",
   "type": "module",
   "bin": {
@@ -23,7 +23,8 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@byterover/brv-bridge": "^1.0.2",
+    "@byterover/brv-bridge": "^1.2.0",
+    "@inquirer/prompts": "^7.0.0",
     "commander": "^13.0.0",
     "js-yaml": "^4.1.0",
     "picocolors": "^1.1.0",