[Init] Initial commit - NetMesh terminal manager

components/terminal/completionEngine.test.ts

@@ -0,0 +1,506 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import type { FigSpec } from "./autocomplete/figSpecLoader.ts";
+
+type LocalStorageMock = {
+  clear(): void;
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+  removeItem(key: string): void;
+};
+
+type MockDirEntry = {
+  name: string;
+  type: "file" | "directory" | "symlink";
+};
+
+function installLocalStorage(): LocalStorageMock {
+  const store = new Map<string, string>();
+  const localStorage: LocalStorageMock = {
+    clear() {
+      store.clear();
+    },
+    getItem(key: string) {
+      return store.has(key) ? store.get(key)! : null;
+    },
+    setItem(key: string, value: string) {
+      store.set(key, String(value));
+    },
+    removeItem(key: string) {
+      store.delete(key);
+    },
+  };
+  Object.defineProperty(globalThis, "localStorage", {
+    value: localStorage,
+    configurable: true,
+  });
+  return localStorage;
+}
+
+const localStorage = installLocalStorage();
+const storySpec: FigSpec = {
+  name: "story",
+  subcommands: [
+    {
+      name: "open",
+      args: { template: "filepaths" },
+    },
+    {
+      name: "pick",
+      args: { name: "item", generators: {} },
+    },
+  ],
+};
+const bridgeState: {
+  localEntries: MockDirEntry[];
+  remoteEntriesByPath: Map<string, MockDirEntry[]>;
+  remoteCalls: string[];
+  remoteDelayMs: number;
+} = {
+  localEntries: [],
+  remoteEntriesByPath: new Map(),
+  remoteCalls: [],
+  remoteDelayMs: 0,
+};
+
+Object.defineProperty(globalThis, "window", {
+  value: {
+    netcatty: {
+      listFigSpecs: async () => ["story"],
+      loadFigSpec: async (commandName: string) => commandName === "story" ? storySpec : null,
+      listAutocompleteLocalDir: async (
+        _path: string,
+        foldersOnly: boolean,
+        filterPrefix?: string,
+        limit?: number,
+      ) => {
+        const prefix = (filterPrefix ?? "").toLowerCase();
+        const entries = bridgeState.localEntries
+          .filter((entry) => !foldersOnly || entry.type === "directory")
+          .filter((entry) => !prefix || entry.name.toLowerCase().startsWith(prefix))
+          .slice(0, limit ?? bridgeState.localEntries.length);
+        return { success: true, entries };
+      },
+      listAutocompleteRemoteDir: async (
+        _sessionId: string,
+        path: string,
+        foldersOnly: boolean,
+        filterPrefix?: string,
+        limit?: number,
+      ) => {
+        bridgeState.remoteCalls.push(path);
+        if (bridgeState.remoteDelayMs > 0) {
+          await new Promise((resolve) => setTimeout(resolve, bridgeState.remoteDelayMs));
+        }
+        const prefix = (filterPrefix ?? "").toLowerCase();
+        const remoteEntries = bridgeState.remoteEntriesByPath.get(path) ?? [];
+        const entries = remoteEntries
+          .filter((entry) => !foldersOnly || entry.type === "directory")
+          .filter((entry) => !prefix || entry.name.toLowerCase().startsWith(prefix))
+          .slice(0, limit ?? remoteEntries.length);
+        return { success: true, entries };
+      },
+    },
+  },
+  configurable: true,
+});
+
+const {
+  getCompletions,
+  getPathSuggestionsWithinBudget,
+} = await import("./autocomplete/completionEngine.ts");
+const {
+  clearHistory,
+  recordCommand,
+  removeCommandHistoryEntry,
+} = await import("./autocomplete/commandHistoryStore.ts");
+const {
+  normalizePathTokenForLookup,
+  shouldPreferRemoteShellCwd,
+} = await import("./autocomplete/remotePathCompleter.ts");
+
+test.beforeEach(() => {
+  localStorage.clear();
+  clearHistory();
+  bridgeState.localEntries = [{ name: "package.json", type: "file" }];
+  bridgeState.remoteEntriesByPath = new Map();
+  bridgeState.remoteCalls = [];
+  bridgeState.remoteDelayMs = 0;
+});
+
+test("getCompletions prioritizes spec-driven path suggestions over history", async () => {
+  recordCommand("story open package-lock.json", "host-1");
+
+  const completions = await getCompletions("story open pa", {
+    hostId: "host-1",
+    protocol: "local",
+    cwd: "/repo",
+  });
+
+  assert.ok(completions.length > 0);
+  assert.equal(completions[0]?.source, "path");
+  assert.equal(completions[0]?.text, "story open package.json");
+
+  const historyIndex = completions.findIndex((entry) =>
+    entry.source === "history" && entry.text === "story open package-lock.json"
+  );
+  assert.ok(historyIndex > 0);
+  assert.equal(completions[historyIndex]?.historyMatch, "path-argument");
+});
+
+test("path completion marks a matching history replacement even when its full line is shorter", async () => {
+  const historyCommand = "story package.json";
+  const input = "story open --number p";
+  recordCommand(historyCommand, "host-1");
+
+  const completions = await getCompletions(input, {
+    hostId: "host-1",
+    protocol: "local",
+    cwd: "/repo",
+  });
+  const history = completions.find((entry) => entry.text === historyCommand);
+
+  assert.ok(history);
+  assert.ok(history.text.length < input.length);
+  assert.equal(history.historyMatch, "path-argument");
+});
+
+test("getCompletions does not treat generator-only spec args as path contexts", async () => {
+  recordCommand("story pick package-choice", "host-1");
+
+  const completions = await getCompletions("story pick pa", {
+    hostId: "host-1",
+    protocol: "local",
+    cwd: "/repo",
+  });
+
+  assert.ok(completions.length > 0);
+  assert.equal(completions[0]?.source, "history");
+  assert.equal(completions[0]?.text, "story pick package-choice");
+  assert.equal(completions.some((entry) => entry.source === "path"), false);
+});
+
+test("history suggestions stop when an edited argument no longer matches the command prefix", async () => {
+  const historyCommand = "python3.14 -m robot -d /home/wx0043/Desktop/suite9";
+  recordCommand(historyCommand, "host-1");
+
+  const matching = await getCompletions("python3.14 -m r", {
+    hostId: "host-1",
+    historyScope: "host",
+    protocol: "ssh",
+    sessionId: "session-1",
+  });
+  assert.equal(
+    matching.some((entry) => entry.source === "history" && entry.text === historyCommand),
+    true,
+  );
+
+  const changedArgument = await getCompletions("python3.14 -m p", {
+    hostId: "host-1",
+    historyScope: "host",
+    protocol: "ssh",
+    sessionId: "session-1",
+  });
+  assert.equal(
+    changedArgument.some((entry) => entry.source === "history" && entry.text === historyCommand),
+    false,
+  );
+});
+
+test("single-token history queries retain fuzzy command-name matching", async () => {
+  const historyCommand = "docker compose up";
+  recordCommand(historyCommand, "host-1");
+
+  const completions = await getCompletions("dcu", {
+    hostId: "host-1",
+    historyScope: "host",
+    protocol: "ssh",
+    sessionId: "session-1",
+  });
+
+  assert.equal(
+    completions.some((entry) => entry.source === "history" && entry.text === historyCommand),
+    true,
+  );
+});
+
+test("removeCommandHistoryEntry removes only the matching host's autocomplete record", async () => {
+  recordCommand("bad-command --flag", "host-1");
+  recordCommand("bad-command --flag", "host-2");
+
+  removeCommandHistoryEntry("bad-command --flag", "host-1");
+
+  const completions = await getCompletions("bad-command", {
+    hostId: "host-1",
+    historyScope: "global",
+    protocol: "local",
+    cwd: "/repo",
+  });
+  assert.equal(
+    completions.some((entry) => entry.source === "history" && entry.text === "bad-command --flag"),
+    true,
+  );
+
+  const hostOnlyCompletions = await getCompletions("bad-command", {
+    hostId: "host-1",
+    historyScope: "host",
+    protocol: "local",
+    cwd: "/repo",
+  });
+  assert.equal(
+    hostOnlyCompletions.some((entry) => entry.source === "history" && entry.text === "bad-command --flag"),
+    false,
+  );
+});
+
+test("removeCommandHistoryEntry trims command text like recordCommand", async () => {
+  recordCommand("padded-cmd", "host-trim");
+  assert.equal(removeCommandHistoryEntry("  padded-cmd  ", "host-trim"), true);
+
+  const hostOnlyCompletions = await getCompletions("padded", {
+    hostId: "host-trim",
+    historyScope: "host",
+    protocol: "local",
+    cwd: "/repo",
+  });
+  assert.equal(
+    hostOnlyCompletions.some((entry) => entry.source === "history" && entry.text === "padded-cmd"),
+    false,
+  );
+});
+
+test("getCompletions uses the remote shell cwd for relative path arguments instead of stale home", async () => {
+  bridgeState.remoteEntriesByPath.set("~", [{ name: "home-only.txt", type: "file" }]);
+  bridgeState.remoteEntriesByPath.set(".", [{ name: "worktree.txt", type: "file" }]);
+
+  const completions = await getCompletions("cat wo", {
+    hostId: "host-1",
+    os: "linux",
+    protocol: "ssh",
+    sessionId: "session-1",
+    cwd: "~",
+  });
+
+  assert.deepEqual(bridgeState.remoteCalls, ["."]);
+  assert.equal(completions[0]?.source, "path");
+  assert.equal(completions[0]?.text, "cat worktree.txt");
+  assert.equal(completions.some((entry) => entry.text.includes("~")), false);
+});
+
+test("getCompletions uses absolute prompt cwd for remote relative path arguments", async () => {
+  bridgeState.remoteEntriesByPath.set(".", [{ name: "old-user-file.txt", type: "file" }]);
+  bridgeState.remoteEntriesByPath.set("/etc", [{ name: "passwd", type: "file" }]);
+
+  const completions = await getCompletions("cat pa", {
+    hostId: "host-1",
+    os: "linux",
+    protocol: "ssh",
+    sessionId: "session-1",
+    cwd: "/etc",
+    cwdSource: "prompt",
+  });
+
+  assert.deepEqual(bridgeState.remoteCalls, ["/etc"]);
+  assert.equal(completions[0]?.source, "path");
+  assert.equal(completions[0]?.text, "cat passwd");
+  assert.equal(completions.some((entry) => entry.text === "cat old-user-file.txt"), false);
+});
+
+test("remote subdirectory lookups keep absolute prompt cwd", () => {
+  const preferRelativeCwd = shouldPreferRemoteShellCwd("ssh", "session-1", "linux", "/etc", "prompt");
+
+  assert.equal(preferRelativeCwd, false);
+  assert.equal(
+    normalizePathTokenForLookup("pam.d/", "/etc", { preferRelativeCwd }),
+    "/etc/pam.d/",
+  );
+});
+
+test("getCompletions keeps remote shell cwd when absolute cwd is only a fallback", async () => {
+  bridgeState.remoteEntriesByPath.set("/old", [{ name: "old-user-file.txt", type: "file" }]);
+  bridgeState.remoteEntriesByPath.set(".", [{ name: "worktree.txt", type: "file" }]);
+
+  const completions = await getCompletions("cat wo", {
+    hostId: "host-1",
+    os: "linux",
+    protocol: "ssh",
+    sessionId: "session-1",
+    cwd: "/old",
+    cwdSource: "fallback",
+  });
+
+  assert.deepEqual(bridgeState.remoteCalls, ["."]);
+  assert.equal(completions[0]?.source, "path");
+  assert.equal(completions[0]?.text, "cat worktree.txt");
+  assert.equal(completions.some((entry) => entry.text === "cat old-user-file.txt"), false);
+});
+
+test("getCompletions does not reuse cached remote relative listings after cwd changes", async () => {
+  bridgeState.remoteEntriesByPath.set(".", [{ name: "home-only.txt", type: "file" }]);
+
+  await getCompletions("cat ", {
+    hostId: "host-1",
+    os: "linux",
+    protocol: "ssh",
+    sessionId: "session-1",
+  });
+
+  bridgeState.remoteEntriesByPath.set(".", [{ name: "worktree.txt", type: "file" }]);
+
+  const completions = await getCompletions("cat wo", {
+    hostId: "host-1",
+    os: "linux",
+    protocol: "ssh",
+    sessionId: "session-1",
+  });
+
+  assert.equal(bridgeState.remoteCalls.length, 2);
+  assert.equal(completions[0]?.text, "cat worktree.txt");
+});
+
+test("getCompletions does not reuse in-flight remote relative listings after cwd changes", async () => {
+  bridgeState.remoteDelayMs = 150;
+  bridgeState.remoteEntriesByPath.set(".", [{ name: "home-only.txt", type: "file" }]);
+
+  const first = getCompletions("cat ", {
+    hostId: "host-1",
+    os: "linux",
+    protocol: "ssh",
+    sessionId: "session-inflight-cwd",
+    pathBudgetMs: Infinity,
+  });
+
+  // First listing must be in flight before the shell cwd listing changes.
+  await new Promise((resolve) => setTimeout(resolve, 20));
+  bridgeState.remoteEntriesByPath.set(".", [{ name: "worktree.txt", type: "file" }]);
+
+  const second = await getCompletions("cat wo", {
+    hostId: "host-1",
+    os: "linux",
+    protocol: "ssh",
+    sessionId: "session-inflight-cwd",
+    pathBudgetMs: Infinity,
+  });
+  await first;
+
+  assert.equal(bridgeState.remoteCalls.length, 2);
+  assert.equal(second[0]?.text, "cat worktree.txt");
+  assert.equal(second.some((entry) => entry.text === "cat home-only.txt"), false);
+});
+
+test("getCompletions returns local history before a slow remote path listing finishes", async () => {
+  recordCommand("cat worktree.txt", "host-1");
+  bridgeState.remoteDelayMs = 250;
+  bridgeState.remoteEntriesByPath.set(".", [{ name: "worktree.txt", type: "file" }]);
+
+  const started = Date.now();
+  const completions = await getCompletions("cat wo", {
+    hostId: "host-1",
+    os: "linux",
+    protocol: "ssh",
+    sessionId: "session-slow-path",
+    cwd: "~",
+    pathBudgetMs: 40,
+  });
+  const elapsed = Date.now() - started;
+
+  assert.ok(elapsed < 200, `expected local suggestions within budget, took ${elapsed}ms`);
+  assert.ok(
+    completions.some((entry) => entry.source === "history" && entry.text === "cat worktree.txt"),
+  );
+  assert.equal(completions.some((entry) => entry.source === "path"), false);
+});
+
+test("getCompletions surfaces late path suggestions for cache-bypassed relative SSH cwd", async () => {
+  recordCommand("cat worktree.txt", "host-1");
+  bridgeState.remoteDelayMs = 250;
+  bridgeState.remoteEntriesByPath.set(".", [{ name: "worktree.txt", type: "file" }]);
+
+  let latePathSuggestions: Awaited<ReturnType<typeof getCompletions>> | null = null;
+  const latePathPromise = new Promise<void>((resolve) => {
+    void getCompletions("cat wo", {
+      hostId: "host-1",
+      os: "linux",
+      protocol: "ssh",
+      sessionId: "session-late-path",
+      cwd: "/stale-fallback",
+      cwdSource: "fallback",
+      pathBudgetMs: 40,
+      onLatePathSuggestions: (suggestions) => {
+        latePathSuggestions = suggestions;
+        resolve();
+      },
+    }).then((completions) => {
+      assert.equal(completions.some((entry) => entry.source === "path"), false);
+      assert.ok(
+        completions.some((entry) => entry.source === "history" && entry.text === "cat worktree.txt"),
+      );
+    });
+  });
+
+  await latePathPromise;
+  assert.ok(latePathSuggestions);
+  assert.equal(latePathSuggestions![0]?.source, "path");
+  assert.equal(latePathSuggestions![0]?.text, "cat worktree.txt");
+});
+
+test("getPathSuggestionsWithinBudget ignores late rejections after the soft timeout", async () => {
+  const unhandled: unknown[] = [];
+  const onUnhandled = (reason: unknown) => {
+    unhandled.push(reason);
+  };
+  process.on("unhandledRejection", onUnhandled);
+  try {
+    const pathPromise = new Promise<{ name: string; type: "file" }[]>((_resolve, reject) => {
+      setTimeout(() => reject(new Error("late path failure")), 80);
+    });
+    const entries = await getPathSuggestionsWithinBudget(pathPromise, 20);
+    assert.deepEqual(entries, []);
+    await new Promise((resolve) => setTimeout(resolve, 120));
+    assert.equal(unhandled.length, 0);
+  } finally {
+    process.off("unhandledRejection", onUnhandled);
+  }
+});
+
+test("getPathSuggestionsWithinBudget delivers late entries after the soft timeout", async () => {
+  const pathPromise = new Promise<{ name: string; type: "file" }[]>((resolve) => {
+    setTimeout(() => resolve([{ name: "late.txt", type: "file" }]), 80);
+  });
+  let lateEntries: { name: string; type: "file" }[] | null = null;
+  const entries = await getPathSuggestionsWithinBudget(pathPromise, 20, (late) => {
+    lateEntries = late as { name: string; type: "file" }[];
+  });
+  assert.deepEqual(entries, []);
+  await new Promise((resolve) => setTimeout(resolve, 120));
+  assert.deepEqual(lateEntries, [{ name: "late.txt", type: "file" }]);
+});
+
+test("getCompletions includes other hosts' history when historyScope is global", async () => {
+  recordCommand("systemctl restart nginx", "host-a");
+  recordCommand("systemctl status nginx", "host-b");
+
+  const hostScoped = await getCompletions("systemctl", {
+    hostId: "host-a",
+    historyScope: "host",
+  });
+  assert.ok(
+    hostScoped.some((entry) => entry.source === "history" && entry.text === "systemctl restart nginx"),
+  );
+  assert.equal(
+    hostScoped.some((entry) => entry.source === "history" && entry.text === "systemctl status nginx"),
+    false,
+  );
+
+  const globalScoped = await getCompletions("systemctl", {
+    hostId: "host-a",
+    historyScope: "global",
+  });
+  assert.ok(
+    globalScoped.some((entry) => entry.source === "history" && entry.text === "systemctl restart nginx"),
+  );
+  assert.ok(
+    globalScoped.some((entry) => entry.source === "history" && entry.text === "systemctl status nginx"),
+  );
+});