dsh-over-ssh 0.0.0-stage → 0.1.1

package/lib/file-references.js

@@ -0,0 +1,411 @@
+// src/file-references.ts
+import "@deepseek-ai/cordis";
+
+// src/host/integration/fs/file-reference-provider.ts
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import "@deepseek-ai/cordis";
+import FileReferenceService from "@deepseek-ai/dsh-file-reference";
+
+// src/host/domain/errors.ts
+var SshDevError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = "SshDevError";
+    this.code = code;
+    this.details = details;
+  }
+};
+
+// src/host/integration/fs/remote-index.ts
+var DEFAULTS = {
+  ttlMs: 3e4,
+  maxRoots: 8,
+  /**
+   * Cap for {@link RemoteIndex} `#scannedOnce`.
+   *
+   * Larger than `maxRoots` on purpose: a miss there costs one extra full scan (correct, only slower), while a
+   * hit saves one, so it can afford to remember more roots. What matters is that it is **finite** — the key is
+   * a model-supplied path (`remote_glob`), so an unbounded Set grew for the life of the connection.
+   */
+  maxScannedRoots: 256,
+  budgetMs: 900,
+  maxEntries: 2e4,
+  /**
+   * Byte cap for the path cache, alongside {@link DEFAULTS.maxRoots}.
+   *
+   * The repository's own rule (`doc/05-benchmarks/baseline.md`) is that every cache names a **count** cap, a
+   * **byte** cap and an eviction policy. This one had only a count cap and a root cap, so its real footprint
+   * depended on path length and entry count — both of which the *user's* repository decides, not us. Eight
+   * roots at the 20 000-entry cap with ~60-character paths is roughly 22 MB of JS strings; 16 MiB keeps that
+   * bounded while still holding several full-size roots.
+   */
+  maxBytes: 16 * 1024 * 1024,
+  limit: 50,
+  outputCap: 8 * 1024 * 1024
+};
+function rankMatches(paths, query, limit) {
+  const needle = query.trim().toLowerCase();
+  if (needle === "") {
+    const order = [];
+    for (let index = 0; index < paths.length; index += 1) order.push(index);
+    const depths = new Int32Array(paths.length);
+    for (let index = 0; index < paths.length; index += 1) depths[index] = depth(paths[index]);
+    order.sort(
+      (left, right) => depths[left] - depths[right] || (paths[left] < paths[right] ? -1 : 1)
+    );
+    return order.slice(0, limit).map((index) => paths[index]);
+  }
+  const scored = [];
+  for (const path of paths) {
+    const lower = path.toLowerCase();
+    const base = lower.slice(lower.lastIndexOf("/") + 1);
+    let score;
+    if (base.startsWith(needle)) score = 0;
+    else if (base.includes(needle)) score = 1;
+    else if (lower.includes(`/${needle}`)) score = 2;
+    else if (lower.includes(needle)) score = 3;
+    else continue;
+    scored.push({ path, score, depth: depth(path) });
+  }
+  scored.sort(
+    (left, right) => left.score - right.score || left.depth - right.depth || (left.path < right.path ? -1 : 1)
+  );
+  return scored.slice(0, limit).map((entry) => entry.path);
+}
+function depth(path) {
+  let segments = 0;
+  let inSegment = false;
+  for (let index = 0; index < path.length; index += 1) {
+    if (path.charCodeAt(index) === 47) {
+      inSegment = false;
+      continue;
+    }
+    if (!inSegment) {
+      segments += 1;
+      inSegment = true;
+    }
+  }
+  return segments;
+}
+
+// src/shared/root-keys.ts
+function isAbsoluteLocalPath(path) {
+  return /^[A-Za-z]:[\\/]/.test(path) || path.startsWith("/") || path.startsWith("\\\\");
+}
+function normalizeLocalPath(path, options = {}) {
+  const caseInsensitive = options.caseInsensitive ?? false;
+  const unified = path.replace(/\\/g, "/");
+  const unc = unified.startsWith("//");
+  const posixAbsolute = unified.startsWith("/");
+  const driveMatch = /^([A-Za-z]):/.exec(unified);
+  const driveLetter = driveMatch?.[1];
+  const drive = driveLetter === void 0 ? "" : `${driveLetter.toUpperCase()}:`;
+  const rest = unc ? unified.slice(2) : drive === "" ? unified : unified.slice(2);
+  const segments = [];
+  for (const segment of rest.split("/")) {
+    if (segment === "" || segment === ".") continue;
+    if (segment === "..") {
+      segments.pop();
+      continue;
+    }
+    segments.push(segment);
+  }
+  const body = segments.join("/");
+  let normalized;
+  if (unc) normalized = `//${body}`;
+  else if (drive !== "") normalized = body === "" ? `${drive}/` : `${drive}/${body}`;
+  else if (posixAbsolute) normalized = body === "" ? "/" : `/${body}`;
+  else normalized = body === "" ? "." : body;
+  return caseInsensitive ? normalized.toLowerCase() : normalized;
+}
+
+// src/host/domain/roots/root.ts
+function makeLocalRoot(path, options = {}) {
+  const normalized = normalizeLocalPath2(path, { caseInsensitive: false });
+  if (!isAbsoluteLocalPath(normalized)) {
+    throw new SshDevError("ROOT_INVALID", `\u672C\u5730\u6839\u5FC5\u987B\u662F\u7EDD\u5BF9\u8DEF\u5F84\uFF1A${path}`, { path });
+  }
+  return {
+    location: "local",
+    path: normalized,
+    writable: options.writable ?? true,
+    ...options.label === void 0 ? {} : { label: options.label },
+    ...options.workspaces === void 0 ? {} : { workspaces: options.workspaces },
+    ...options.sessions === void 0 ? {} : { sessions: options.sessions },
+    ...options.shared === void 0 ? {} : { shared: options.shared }
+  };
+}
+function normalizeLocalPath2(path, options = {}) {
+  return normalizeLocalPath(path, { caseInsensitive: options.caseInsensitive ?? process.platform === "win32" });
+}
+
+// src/host/integration/session-scope.ts
+var MAX_FORK_DEPTH = 32;
+var ancestorCache = /* @__PURE__ */ new Map();
+var ANCESTOR_CACHE_MAX = 256;
+function readSessionAncestors(ctx, sessionId) {
+  const cached = ancestorCache.get(sessionId);
+  if (cached !== void 0) {
+    ancestorCache.delete(sessionId);
+    ancestorCache.set(sessionId, cached);
+    return cached;
+  }
+  const walked = walkAncestors(ctx, sessionId);
+  if (walked.settled) {
+    ancestorCache.set(sessionId, walked.ancestors);
+    while (ancestorCache.size > ANCESTOR_CACHE_MAX) {
+      const oldest = ancestorCache.keys().next();
+      if (oldest.done === true) break;
+      ancestorCache.delete(oldest.value);
+    }
+  }
+  return walked.ancestors;
+}
+function walkAncestors(ctx, sessionId) {
+  let list;
+  try {
+    const sessions = ctx.get("sessions");
+    list = sessions?.list?.();
+  } catch {
+    return { ancestors: [], settled: false };
+  }
+  if (!Array.isArray(list)) return { ancestors: [], settled: false };
+  const parents = /* @__PURE__ */ new Map();
+  let settled = false;
+  for (const session of list) {
+    const id = session?.header?.id;
+    const parent = session?.header?.parentSession;
+    if (typeof id !== "string" || id === "") continue;
+    if (id === sessionId) settled = true;
+    if (typeof parent === "string" && parent !== "") parents.set(id, parent);
+  }
+  const ancestors = [];
+  let current = parents.get(sessionId);
+  while (current !== void 0 && ancestors.length < MAX_FORK_DEPTH && !ancestors.includes(current)) {
+    ancestors.push(current);
+    current = parents.get(current);
+  }
+  return { ancestors, settled };
+}
+function sessionIdentityOf(ctx, sessionId) {
+  if (sessionId === void 0 || sessionId === "") return {};
+  return { sessionId, ancestors: readSessionAncestors(ctx, sessionId) };
+}
+
+// src/host/integration/fs/file-reference-provider.ts
+var LOCAL_EXCLUDED_DIRECTORIES = [".git", "node_modules", "dist", "lib", "build", ".next", ".venv", "__pycache__"];
+var LOCAL_MAX_ENTRIES = 2e4;
+var LOCAL_MAX_DEPTH = 12;
+var LOCAL_CACHE_TTL_MS = 250;
+var LOCAL_MAX_CACHED_ROOTS = 8;
+var DEFAULT_MAX_RESULTS = 50;
+var RemoteFileReferenceService = class extends FileReferenceService {
+  static inject = ["sshDevRoots", "sshDevIndex"];
+  #options;
+  #localTtlMs;
+  #maxCachedRoots;
+  #now;
+  /**
+   * Recently walked local roots, newest last (insertion order doubles as the LRU order).
+   *
+   * The local branch used to re-walk the whole tree on **every keystroke** while the remote branch was served
+   * from `RemoteIndex`'s 30 s cache — the same seam, two very different costs. Measured at 10 000 entries:
+   * typing `@module` = 6 walks = 413 ms, all on the host's event loop (audit 0057 §11 #1).
+   *
+   * Deliberately **not** an `invalidate()`-driven cache: local backends report `watches: false`
+   * (`local-backend.ts:53`), so there is no change signal to hook — only a short TTL.
+   */
+  #localCache = /* @__PURE__ */ new Map();
+  constructor(ctx, options = {}) {
+    super(ctx);
+    this.#options = options;
+    this.#localTtlMs = options.localTtlMs ?? LOCAL_CACHE_TTL_MS;
+    this.#maxCachedRoots = options.maxCachedRoots ?? LOCAL_MAX_CACHED_ROOTS;
+    this.#now = options.now ?? Date.now;
+  }
+  /**
+   * List candidates for one agent's working directory.
+   *
+   * **The session cwd always answers, even when no registered root covers it** (FR-1.9 / ADR-0012).
+   * Stage 2 mounts this provider as `ctx.fs`, and the workspace a session was opened on need not be a
+   * registered root — the shape that broke it is a root registered *underneath* the cwd (session
+   * `D:\project\x`, the plugin's own root `D:\project\x\dsh-over-ssh`), where no root contains
+   * the cwd and the router answers `ROOT_OUTSIDE`. `@` completion must not go dark in that workspace,
+   * so the cwd itself is used as an **implicit local root** — the same rule `routed-fs` applies to the
+   * filesystem: local only, only the cwd subtree, remote roots unchanged.
+   *
+   * The implicit root is **this session's own directory**, so session isolation (ADR-0012) is not
+   * weakened: the walk starts at the cwd and cannot reach a sibling root, and a path outside the cwd is
+   * still not offered. Containment comes from the walk's root argument rather than a per-entry filter —
+   * a filter would re-normalize up to {@link LOCAL_MAX_ENTRIES} paths on **every keystroke**, which is
+   * exactly the cost audit 0057 removed.
+   *
+   * @param agent - target agent; its session cwd decides which root answers.
+   * @param query - text after `@` (may be empty: "show the shallowest entries").
+   * @param signal - caller cancellation.
+   * @returns ranked candidates, best first; empty when nothing can answer — no registry, a remote cwd
+   *   without an index, or a cwd that is not an absolute host path.
+   */
+  async list(agent, query, signal) {
+    const cwd = agent.session.header.cwd ?? process.cwd();
+    const registry = this.ctx.sshDevRoots;
+    if (registry === void 0) return [];
+    const identity = sessionIdentityOf(this.ctx, agent.session.header.id);
+    const gated = identity.sessionId === void 0 ? registry.routed.tryResolve(cwd) : registry.routed.tryResolve(cwd, { session: identity });
+    const addedTask = this.#addedRemoteCandidates(cwd, identity, query, signal);
+    const ungated = gated.ok ? void 0 : registry.routed.tryResolve(cwd);
+    const implicit = gated.ok || ungated?.ok === true ? void 0 : sessionLocalRoot(cwd);
+    const namedTask = gated.ok ? this.#namedCandidates(gated.target.root, query, signal) : implicit === void 0 ? void 0 : this.#localCandidates(implicit.path, query, signal);
+    const [added, named] = await Promise.all([addedTask, namedTask]);
+    if (gated.ok) return this.#merge(added, named ?? []);
+    if (ungated?.ok === true) return added ?? [];
+    return this.#merge(added, named ?? []);
+  }
+  /** cwd 命名的那个根自己的候选：远端走索引，本地走有界走查。 */
+  #namedCandidates(root, query, signal) {
+    return root.location === "remote" && root.connectionId !== void 0 ? this.#remoteCandidates(root.connectionId, root.path, query, signal) : this.#localCandidates(root.path, query, signal);
+  }
+  /** Remote candidates for one root, or `[]` when the composition has no index. */
+  async #remoteCandidates(connectionId, root, query, signal) {
+    const index = this.ctx.sshDevIndex;
+    if (index === void 0) return [];
+    return [...await index.complete(connectionId, root, query, signal)];
+  }
+  /** Local candidates for one root path (bounded walk, short TTL). */
+  async #localCandidates(rootPath, query, signal) {
+    const walk = this.#options.walk ?? ((root, walkSignal) => this.#walkLocal(root, walkSignal));
+    const entries = await this.#walkCached(rootPath, walk, signal);
+    const ranked = rankMatches(
+      entries.map((entry) => entry.path),
+      query,
+      this.#options.maxResults ?? DEFAULT_MAX_RESULTS
+    );
+    if (ranked.length === 0) return [];
+    const wanted = new Set(ranked);
+    const kinds = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      if (!wanted.has(entry.path)) continue;
+      kinds.set(entry.path, entry.kind);
+      if (kinds.size === wanted.size) break;
+    }
+    return ranked.map((path) => ({ path, kind: kinds.get(path) ?? "file" }));
+  }
+  /**
+   * Candidates from the remote directory this conversation added with 「添加目录」, when there is one.
+   *
+   * `undefined` (not `[]`) means "this session added nothing remote" — the caller then answers with the
+   * cwd's own candidates alone, exactly as before ADR-0013.
+   */
+  async #addedRemoteCandidates(cwd, identity, query, signal) {
+    const sessionRoots = this.ctx.sshDevSessionRoots;
+    if (sessionRoots === void 0) return void 0;
+    const outcome = sessionRoots.outcomeFor(cwd, identity);
+    if (!outcome.ok) return void 0;
+    return await this.#remoteCandidates(outcome.target.connectionId, outcome.target.root, query, signal);
+  }
+  /** Remote first, then the cwd's own candidates; de-duplicated by path and bounded by the result cap. */
+  #merge(added, named) {
+    const seen = /* @__PURE__ */ new Set();
+    const merged = [];
+    for (const candidate of [...added ?? [], ...named]) {
+      if (seen.has(candidate.path)) continue;
+      seen.add(candidate.path);
+      merged.push(candidate);
+    }
+    return merged.slice(0, this.#options.maxResults ?? DEFAULT_MAX_RESULTS);
+  }
+  /**
+   * Enumerate a local root, reusing a very recent walk.
+   *
+   * The **ranking** still runs on every call — only the walk is reused. That matters: the query changes on
+   * every keystroke, so caching the ranked result would answer the wrong question; the expensive, query-
+   * independent part is the tree walk, and that is the only thing cached.
+   *
+   * @param root - the local root to enumerate.
+   * @param walk - the enumerator (injected in tests).
+   * @param signal - caller cancellation; **not** cached, because an aborted walk must stay aborted.
+   * @returns the entries, from cache when the previous walk is still fresh.
+   */
+  async #walkCached(root, walk, signal) {
+    const started = this.#now();
+    const cached = this.#localCache.get(root);
+    if (cached !== void 0) {
+      if (started - cached.at <= this.#localTtlMs) {
+        this.#localCache.delete(root);
+        this.#localCache.set(root, cached);
+        return cached.entries;
+      }
+      this.#localCache.delete(root);
+    }
+    const entries = await walk(root, signal);
+    signal.throwIfAborted();
+    this.#rememberLocal(root, entries, started);
+    return entries;
+  }
+  /** Store one local enumeration, evicting the least recently used root past the cap. */
+  #rememberLocal(root, entries, at) {
+    this.#localCache.set(root, { entries, at });
+    while (this.#localCache.size > this.#maxCachedRoots) {
+      const oldest = this.#localCache.keys().next();
+      if (oldest.done === true) break;
+      this.#localCache.delete(oldest.value);
+    }
+  }
+  /** Bounded breadth-first walk over a local root, excluding the usual noise directories. */
+  async #walkLocal(root, signal) {
+    const maxEntries = this.#options.maxEntries ?? LOCAL_MAX_ENTRIES;
+    const maxDepth = this.#options.maxDepth ?? LOCAL_MAX_DEPTH;
+    const found = [];
+    let frontier = [{ path: root, depth: 0 }];
+    while (frontier.length > 0 && found.length < maxEntries) {
+      signal.throwIfAborted();
+      const next = [];
+      for (const entry of frontier) {
+        if (found.length >= maxEntries) break;
+        if (entry.depth >= maxDepth) continue;
+        let children;
+        try {
+          children = await readdir(entry.path, { withFileTypes: true });
+        } catch {
+          continue;
+        }
+        for (const child of children) {
+          if (found.length >= maxEntries) break;
+          const isDirectory = child.isDirectory();
+          if (isDirectory && LOCAL_EXCLUDED_DIRECTORIES.includes(child.name)) continue;
+          const path = join(entry.path, child.name);
+          found.push({ path, kind: isDirectory ? "directory" : "file" });
+          if (isDirectory) next.push({ path, depth: entry.depth + 1 });
+        }
+      }
+      frontier = next;
+    }
+    return found;
+  }
+};
+function sessionLocalRoot(cwd) {
+  if (cwd === "" || !isAbsoluteLocalPath(cwd)) return void 0;
+  return makeLocalRoot(cwd);
+}
+
+// src/file-references.ts
+function apply(ctx) {
+  if (ctx.get("fileReferences") !== void 0) {
+    ctx.logger?.warn?.(
+      "file-references: ctx.fileReferences \u5DF2\u88AB\u5360\u7528\uFF08\u6838\u5FC3 file-reference-local \u4ECD\u5728\uFF09\uFF0C\u672C\u6B21\u8DF3\u8FC7\u63A5\u7BA1\uFF1B\u8981\u63A5\u7BA1\u8BF7\u540C\u65F6\u7981\u7528\u6838\u5FC3\u884C\uFF08cordis.patch.yml \u9636\u6BB5 2\uFF09"
+    );
+    return void 0;
+  }
+  return ctx.plugin(RemoteFileReferenceService);
+}
+export {
+  DEFAULT_MAX_RESULTS,
+  LOCAL_EXCLUDED_DIRECTORIES,
+  LOCAL_MAX_DEPTH,
+  LOCAL_MAX_ENTRIES,
+  RemoteFileReferenceService,
+  apply as default
+};