@mrdrmccoy/xerj-opencode-plugin 0.4.4 → 0.4.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrdrmccoy/xerj-opencode-plugin",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "description": "XERJ integration for OpenCode: local code and docs search, agent memory, and retrieval accounting.",
   "repository": {
     "type": "git",

package/src/hooks/session.ts

@@ -155,6 +155,7 @@ async function retrieve(
 
   try {
     return await search.search(text, {
+      surface: "context",
       k: options.config.context.maxPassages,
       maxTokens: options.config.context.maxTokens,
       signal: controller.signal,

package/src/index/watcher.ts

@@ -47,6 +47,13 @@ const BACKOFF_MS = [1_000, 2_000, 5_000, 15_000, 30_000] as const;
 const MAX_RESTARTS = 5;
 const STOP_GRACE_MS = 3_000;
 const STDERR_TAIL_LINES = 20;
+// The engine refuses a second watcher for the same journal and says so.
+const CONTENTION_MARKER = "already owns";
+const CONTENTION_RETRY_MS = 5_000;
+// A watcher that survives this long is watching, even before its first run
+// document lands: an initial pass over a large corpus takes minutes, and the
+// status would otherwise read "starting" the whole time.
+const WATCH_SETTLE_MS = 3_000;
 
 export class CorpusService {
   readonly layout: CorpusLayout;
@@ -62,6 +69,8 @@ export class CorpusService {
   private timer: ReturnType<typeof setInterval> | null = null;
   private stopped = false;
   private spawning = false;
+  private lastStderr = "";
+  private spawnedAt = 0;
 
   constructor(private readonly options: CorpusServiceOptions) {
     this.layout = corpusLayout(options.projectRoot, options.prefix, options.dataRoot);
@@ -124,8 +133,13 @@ export class CorpusService {
   }
 
   snapshot(): CorpusSnapshot {
+    const settled =
+      this.state === "starting" &&
+      this.child !== null &&
+      Date.now() - this.spawnedAt >= WATCH_SETTLE_MS;
+
     return {
-      state: this.state,
+      state: settled ? "watching" : this.state,
       lastRun: this.lastRun,
       restarts: this.restarts,
       runs: this.runs,
@@ -160,6 +174,8 @@ export class CorpusService {
 
     this.child = child;
     this.spawning = false;
+    this.lastStderr = "";
+    this.spawnedAt = Date.now();
     if (watch) this.state = "starting";
 
     this.attachOutput(child);
@@ -204,8 +220,9 @@ export class CorpusService {
     });
 
     child.once("close", () => {
+      this.lastStderr = stderr.join("").slice(-2000);
       if (stderr.length > 0) {
-        this.options.logger.debug("autoindex stderr", stderr.join("").slice(-2000));
+        this.options.logger.debug("autoindex stderr", this.lastStderr);
       }
     });
   }
@@ -213,6 +230,19 @@ export class CorpusService {
   private handleWatchExit(code: number | null, signal: NodeJS.Signals | null): void {
     const meaning = exitMeaning(code);
 
+    // Another process owns this journal, typically the plugin instance of a
+    // server that is being replaced. Ownership frees when that process exits,
+    // so wait it out instead of counting a failure or burning the restart
+    // budget.
+    if (this.lastStderr.includes(CONTENTION_MARKER)) {
+      this.state = "starting";
+      this.lastError = null;
+      this.options.logger.debug("autoindex watcher journal is owned elsewhere; retrying");
+      this.options.onChange?.();
+      setTimeout(() => this.spawn(true), CONTENTION_RETRY_MS);
+      return;
+    }
+
     // A clean exit from `--watch` is unexpected; it should stay resident.
     if (meaning === "decision") {
       this.state = "idle";

package/src/index.ts

@@ -27,6 +27,7 @@ import {
   environmentFrom,
   externalPrefix,
   indexPrefix,
+  isOverbroadRoot,
   memoryNamespace,
   projectStateDir,
   webPrefix,
@@ -81,6 +82,14 @@ export default Plugin.define({
     // The location may be a subdirectory of the project; index the project root
     // so a session opened in `docs/` does not create a second corpus.
     const projectRoot = ctx.location.project.canonical;
+    const overbroad = isOverbroadRoot(projectRoot);
+    const indexWarnings = [...warnings];
+    if (overbroad) {
+      const refusal =
+        `refusing to index ${projectRoot}: the home directory and filesystem roots are too broad. Open OpenCode inside a project.`;
+      indexWarnings.push(refusal);
+      logger.warn(refusal);
+    }
     const prefix = indexPrefix(projectRoot);
     const brains = brainSpecs(projectRoot, config.index.brain);
     const hiddenRoots = documentRoots(projectRoot, config.index.hidden);
@@ -99,7 +108,7 @@ export default Plugin.define({
       hiddenRoots,
       anomaly: null,
       error: null,
-      warnings: [...warnings],
+      warnings: indexWarnings,
     };
 
     const ledger = new Ledger({
@@ -502,7 +511,7 @@ export default Plugin.define({
               .catch(() => {});
           },
         });
-        await runtime.corpus.start();
+        if (!overbroad) await runtime.corpus.start();
 
         if (runtime.hiddenRoots.length > 0) {
           runtime.hidden = new HiddenIndex({
@@ -521,7 +530,7 @@ export default Plugin.define({
             },
           });
 
-          if (config.index.auto) await runtime.hidden.start();
+          if (config.index.auto && !overbroad) await runtime.hidden.start();
         }
 
         if (runtime.brains.length > 0) {
@@ -544,7 +553,7 @@ export default Plugin.define({
 
           // One-shot: graph indexing cannot run in watch mode. `index.auto`
           // gates startup runs only; an explicit reindex still works.
-          if (config.index.auto) void runtime.brain.runAll();
+          if (config.index.auto && !overbroad) void runtime.brain.runAll();
         }
 
         await registration.events.emit("updated", { updatedAt: Date.now() });

package/src/paths.ts

@@ -12,7 +12,6 @@ export interface Environment {
   readonly HOME?: string;
 }
 
-/** Picks the variables that matter out of a wider process environment. */
 export function environmentFrom(env: Readonly<Record<string, string | undefined>>): Environment {
   return {
     XDG_DATA_HOME: env.XDG_DATA_HOME,
@@ -21,6 +20,22 @@ export function environmentFrom(env: Readonly<Record<string, string | undefined>
   };
 }
 
+/**
+ * True when a directory is too broad to index: the home directory itself or a
+ * filesystem root. Indexing it walks every cache, download and trash folder and
+ * costs minutes of I/O for results nobody asked for.
+ */
+export function isOverbroadRoot(
+  directory: string,
+  home: string = homedir(),
+  platform: NodeJS.Platform = process.platform,
+): boolean {
+  const resolved = resolve(directory);
+  const root = platform === "win32" ? resolve(resolved, sep) : "/";
+  return resolved === root || resolved === resolve(home);
+}
+
+
 const APP_DIR = "opencode/xerj";
 const PREFIX_ROOT = "xop";
 const MAX_SLUG_LENGTH = 24;

package/src/rpc.ts

@@ -247,4 +247,4 @@ const definition = {
 
 export const XerjRpc = Rpc.define(definition);
 
-export const PLUGIN_VERSION = "0.4.4";
+export const PLUGIN_VERSION = "0.4.5";

package/src/search/rank.ts

@@ -59,3 +59,23 @@ export function demoteGenerated(
     })
     .sort((left, right) => right.score - left.score);
 }
+
+/**
+ * Drops generated files the query does not name. Injection shares one small
+ * budget across a whole turn, and a lockfile passage matches on dependency
+ * names that have nothing to do with the question, so it can crowd out the
+ * source that answers it. Tool searches keep them: the caller asked directly.
+ */
+export function dropGenerated(
+  hits: ReadonlyArray<ParsedHit>,
+  query: string,
+): ParsedHit[] {
+  const named = query.toLowerCase();
+
+  return hits.filter((hit) => {
+    if (hit.path === null) return true;
+    if (!isGeneratedPath(hit.path)) return true;
+    const basename = hit.path.toLowerCase().split("/").pop() ?? "";
+    return named.includes(basename);
+  });
+}

package/src/search/service.ts

@@ -14,7 +14,7 @@ import type { Logger } from "../log.ts";
 import { XerjClient } from "../node/client.ts";
 import type { BrainSpec } from "../paths.ts";
 import type { BrainGraph } from "./brains.ts";
-import { demoteGenerated } from "./rank.ts";
+import { demoteGenerated, dropGenerated } from "./rank.ts";
 
 export interface SearchHit {
   readonly index: string;
@@ -36,7 +36,14 @@ export interface SearchResult {
   readonly narrowingBytes: number;
 }
 
+/**
+ * Where the results go. Injection shares a small budget across a whole turn,
+ * so it is stricter than an explicit tool call about generated files.
+ */
+export type SearchSurface = "context" | "tool";
+
 export interface SearchOptions {
+  readonly surface?: SearchSurface;
   readonly k?: number;
   readonly maxTokens?: number;
   readonly signal?: AbortSignal;
@@ -132,7 +139,8 @@ export class SearchService {
 
     const strategy = semantic ? "hybrid" : "lexical";
     const fused = semantic ? fuse([lexical.hits, semantic.hits], k) : lexical.hits.slice(0, k);
-    const located = demoteGenerated(this.locateBrainPaths(fused), trimmed);
+    const ranked = demoteGenerated(this.locateBrainPaths(fused), trimmed);
+    const located = options.surface === "context" ? dropGenerated(ranked, trimmed) : ranked;
     const resolved = await this.resolveLines(located, trimmed);
     const hits = dropShadowedWholeFiles(
       resolved,