fix(app): open relative chat links inside nested repositories (#8361)

* fix(app): open a nested-repo file when the workspace-root path is missing A workspace that contains another git repo often gets paths written relative to that nested repo. `schema/x.md` is really `repo-a/schema/x.md`. A markdown link was joined onto the workspace root and opened a missing file. Inline code already asked the daemon for a suffix match. Resolved workspace-relative paths that contain a slash now use that same lookup before opening. An exact hit stays on the original path. A suffix hit replaces it and keeps the line range. A failed lookup still opens the original path. Bare names, absolute paths, and `~/` paths are unchanged. Example: - Input: workspace `/repo`, link `schema/x.md`, file at `repo-a/schema/x.md` - Before: open `/repo/schema/x.md` (missing) - After: open `/repo/repo-a/schema/x.md` * fix(app): preserve explicit destinations when finding nested files Relative chat links can name a file inside a nested repository. Retain the suffix lookup while using the original href and document base to preserve absolute paths, preview links, and folder destinations. Co-authored-by: Ouyang Xingyuan <galaxyroaming@qq.com> * fix(app): keep network share links on their absolute destination Use the shared absolute-path classifier so network share hrefs retain their destination alongside drive and POSIX paths. * fix(app): keep nested-file lookup inside ordered path opening Resolve the original directory before considering suffix matches, and allocate click ordering before asynchronous lookup. The existing opener now owns the complete operation so a slow earlier click cannot replace a later selection. * test(app): load UI modules before test lifecycle hooks Cold module transformation exceeded the lifecycle hook deadline before these suites could run. Complete module initialization before registering the tests, retaining their assertions and timeout settings. --------- Co-authored-by: Ouyang Xingyuan <galaxyroaming@qq.com> Co-authored-by: paseo-bot[bot] <266920839+paseo-bot[bot]@users.noreply.github.com>
2026-10-31 13:42:50 +00:00 · 2026-10-31 11:05:06 +00:00
parent a7d9bb34fc
commit 0e5bcbd9f5
9 changed files with 364 additions and 34 deletions
@@ -1,4 +1,5 @@
-import { writeFile } from "node:fs/promises";
+import { execFileSync } from "node:child_process";
+import { mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { test, expect, type Page } from "../support/fixtures";
 import { openAgentRoute, seedMockAgentWorkspace } from "../support/helpers/mock-agent";
@@ -67,3 +68,54 @@ test("opening an assistant file link dismisses its tooltip over the file tab", a
    await agent.cleanup();
  }
 });
+
+async function readLinkedGuide(page: Page, linkName: string, content: string): Promise<void> {
+  await page.getByRole("link", { name: linkName, exact: true }).click();
+  await expect(page.getByTestId("markdown-preview-frame").filter({ visible: true })).toContainText(
+    content,
+  );
+}
+
+async function returnToNestedLinks(page: Page): Promise<void> {
+  await page.getByRole("button", { name: "Nested file links", exact: true }).click();
+  await expect(page.getByRole("link", { name: "nested guide", exact: true })).toBeVisible();
+}
+
+test("assistant directory paths find nested files and preserve exact workspace paths", async ({
+  page,
+}, testInfo) => {
+  testInfo.setTimeout(120_000);
+  const agent = await seedMockAgentWorkspace({
+    repoPrefix: "nested-file-link-",
+    title: "Nested file links",
+    featureValues: {
+      mockStreamingAssistantResponse:
+        "Read [nested guide](schema/x.md), [exact guide](schema/exact.md), and [missing guide](schema/missing.md).",
+      mockStreamingAssistantIntervalMs: 5,
+    },
+  });
+  try {
+    await mkdir(path.join(agent.cwd, "repo-a/schema"), { recursive: true });
+    execFileSync("git", ["init", "-b", "main"], { cwd: path.join(agent.cwd, "repo-a") });
+    await writeFile(
+      path.join(agent.cwd, "repo-a/schema/x.md"),
+      "# Nested file content\n\nDetails\n",
+    );
+    await mkdir(path.join(agent.cwd, "schema"), { recursive: true });
+    await writeFile(path.join(agent.cwd, "schema/exact.md"), "# Exact file content\n");
+    await writeFile(path.join(agent.cwd, "repo-a/schema/exact.md"), "# Wrong nested content\n");
+    await openAgentRoute(page, agent);
+    await agent.client.sendAgentMessage(agent.agentId, "Show the file links.");
+    await agent.client.waitForFinish(agent.agentId, 30_000);
+
+    await expect(page.getByRole("textbox", { name: "Message agent..." }).first()).toBeEnabled();
+    await readLinkedGuide(page, "nested guide", "Nested file content");
+    await returnToNestedLinks(page);
+    await readLinkedGuide(page, "exact guide", "Exact file content");
+    await returnToNestedLinks(page);
+    await page.getByRole("link", { name: "missing guide", exact: true }).click();
+    await expect(page.getByText("File not found", { exact: true })).toBeVisible();
+  } finally {
+    await agent.cleanup();
+  }
+});
@@ -81,6 +81,8 @@ for (const folder of [
  "docs/guides",
  "docs/guides/",
  "docs/指南",
+  "examples/next.js/",
+  "examples/next.js",
 ]) {
  test(`chat folder link opens folder contents: ${folder}`, async ({ page }) => {
    const session = await seedMockAgentWorkspace({
@@ -92,6 +94,9 @@ for (const folder of [
    try {
      await mkdir(path.join(session.cwd, folder), { recursive: true });
      await writeFile(path.join(session.cwd, folder, "guide.md"), "# Folder link destination\n");
+      const competingFile = path.join(session.cwd, "repo-a", folder.replace(/\/$/, ""));
+      await mkdir(path.dirname(competingFile), { recursive: true });
+      await writeFile(competingFile, "This is a file, not the requested folder.\n");
      await session.client.waitForFinish(session.agentId, 30_000);
      await page.addInitScript(() => {
        localStorage.setItem(
@@ -468,6 +468,7 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
      () =>
        createInlinePathOpener({
          workspaceRoot,
+          resolveRelativeFiles: true,
          client,
          openFile: openInlineFile,
          openDirectory: openInlineDirectory,
@@ -64,7 +64,10 @@ it("ignores an older probe after a newer file link opens", async () => {
  const opened: string[] = [];
  const opener = createInlinePathOpener({
    workspaceRoot: "/repo",
-    client: { listDirectory: () => pendingProbe },
+    client: {
+      listDirectory: () => pendingProbe,
+      getDirectorySuggestions: async () => ({ entries: [], error: null }),
+    },
    openFile: (location) => {
      opened.push(location.path);
    },
@@ -91,7 +94,10 @@ it("ignores a pending probe when its view is left", async () => {
  const opened: string[] = [];
  const opener = createInlinePathOpener({
    workspaceRoot: "/repo",
-    client: { listDirectory: () => pendingProbe },
+    client: {
+      listDirectory: () => pendingProbe,
+      getDirectorySuggestions: async () => ({ entries: [], error: null }),
+    },
    openFile: (location) => {
      opened.push(location.path);
    },
@@ -130,3 +136,45 @@ it("sends folders outside the workspace away from the workspace Files panel", as
  expect(outsideFolders).toEqual(["~/Downloads/contracts", "/tmp/reports"]);
  expect(workspaceFolders).toEqual(["docs"]);
 });
+
+it("keeps a later selection when an earlier nested-file lookup finishes last", async () => {
+  const { createInlinePathOpener } = await import("./path-open");
+  const lookup = Promise.withResolvers<{
+    entries: Array<{ path: string; kind: "file" }>;
+    error: null;
+  }>();
+  const queries: string[] = [];
+  const opened: string[] = [];
+  const opener = createInlinePathOpener({
+    workspaceRoot: "/repo",
+    resolveRelativeFiles: true,
+    client: {
+      listDirectory: async () => {
+        throw new Error("Not a directory");
+      },
+      getDirectorySuggestions: async ({ query }: { query: string }) => {
+        queries.push(query);
+        return lookup.promise;
+      },
+    },
+    openFile: (location) => {
+      opened.push(location.path);
+    },
+    openDirectory: (directory) => {
+      opened.push(directory);
+    },
+    openOutsideDirectory: (directory) => {
+      opened.push(directory);
+    },
+  });
+  const earlier = opener.open(
+    { raw: "schema/x.md:2", path: "/repo/schema/x.md", lineStart: 2 },
+    "side",
+  );
+  await Promise.resolve();
+  expect(queries).toEqual(["schema/x.md"]);
+  await opener.open({ raw: "./guide.md:2", path: "/repo/guide.md", lineStart: 2 }, "side");
+  lookup.resolve({ entries: [{ path: "repo-a/schema/x.md", kind: "file" }], error: null });
+  await earlier;
+  expect(opened).toEqual(["guide.md"]);
+});
@@ -5,6 +5,7 @@ import {
  type OpenFileDisposition,
 } from "@/workspace/file-open";
 import { isAbsolutePath } from "@/utils/path";
+import { resolveMissingNestedRelativeFile, type GetDirectorySuggestions } from "./resolver";

 interface PathOpenInput {
  file?: string;
@@ -50,7 +51,11 @@ export async function resolveInlinePathOpen(input: PathOpenInput): Promise<PathO

 export function createInlinePathOpener(input: {
  workspaceRoot: string;
-  client: PathOpenInput["client"];
+  client: {
+    listDirectory(root: string, path: string): Promise<unknown>;
+    getDirectorySuggestions: GetDirectorySuggestions;
+  } | null;
+  resolveRelativeFiles?: boolean;
  openFile: (location: WorkspaceFileLocation, disposition: OpenFileDisposition) => void;
  openDirectory: (path: string) => void;
  openOutsideDirectory: (path: string) => void;
@@ -73,10 +78,21 @@ export function createInlinePathOpener(input: {
      } else if (destination.kind === "outsideDirectory") {
        input.openOutsideDirectory(destination.directoryPath);
      } else if (normalized.file) {
+        const resolvedTarget =
+          input.resolveRelativeFiles && input.client
+            ? await resolveMissingNestedRelativeFile({
+                target,
+                workspaceRoot: input.workspaceRoot,
+                getDirectorySuggestions: input.client.getDirectorySuggestions.bind(input.client),
+              })
+            : target;
+        if (ownGeneration !== generation) return;
+        const resolved = normalizeInlinePathTarget(resolvedTarget.path, input.workspaceRoot);
+        if (!resolved?.file) return;
        const location = normalizeWorkspaceFileLocation({
-          path: normalized.file,
-          lineStart: target.lineStart,
-          lineEnd: target.lineEnd,
+          path: resolved.file,
+          lineStart: resolvedTarget.lineStart,
+          lineEnd: resolvedTarget.lineEnd,
        });
        if (location) input.openFile(location, disposition);
      }
@@ -7,6 +7,7 @@ import {
  classifyForResolution,
  fetchDaemonResolution,
  getAssistantFileLinkToken,
+  resolveMissingNestedRelativeFile,
  UnresolvedFileLinkError,
  type AssistantFileLinkContext,
  type DirectorySuggestionEntry,
@@ -424,6 +425,174 @@ describe("fetchDaemonResolution", () => {
  });
 });

+describe("resolveMissingNestedRelativeFile", () => {
+  const target = {
+    raw: "schema/x.md:12-14",
+    path: "/Users/test/project/schema/x.md",
+    lineStart: 12,
+    lineEnd: 14,
+  };
+
+  it("opens a nested-repo suffix when the workspace-root path is missing", async () => {
+    const { getDirectorySuggestions, searches } = suggestionsFromMap({
+      "schema/x.md": [{ path: "repo-a/schema/x.md", kind: "file" }],
+    });
+
+    const result = await resolveMissingNestedRelativeFile({
+      target,
+      workspaceRoot: "/Users/test/project",
+      getDirectorySuggestions,
+    });
+
+    expect(searches).toEqual([
+      {
+        query: "schema/x.md",
+        cwd: "/Users/test/project",
+        matchMode: "suffix",
+        limit: 1,
+      },
+    ]);
+    expect(result).toEqual({
+      ...target,
+      path: "/Users/test/project/repo-a/schema/x.md",
+    });
+  });
+
+  it("keeps the exact workspace path when suggestions return that relative path", async () => {
+    const { getDirectorySuggestions } = suggestionsFromMap({
+      "schema/x.md": [{ path: "schema/x.md", kind: "file" }],
+    });
+
+    const result = await resolveMissingNestedRelativeFile({
+      target,
+      workspaceRoot: "/Users/test/project",
+      getDirectorySuggestions,
+    });
+
+    expect(result).toEqual(target);
+  });
+
+  it("keeps the original target when suggestions are empty", async () => {
+    const { getDirectorySuggestions } = suggestionsFromMap({});
+
+    await expect(
+      resolveMissingNestedRelativeFile({
+        target,
+        workspaceRoot: "/Users/test/project",
+        getDirectorySuggestions,
+      }),
+    ).resolves.toEqual(target);
+  });
+
+  it("keeps the original target when the daemon throws", async () => {
+    await expect(
+      resolveMissingNestedRelativeFile({
+        target,
+        workspaceRoot: "/Users/test/project",
+        getDirectorySuggestions: unavailableSuggestions,
+      }),
+    ).resolves.toEqual(target);
+  });
+
+  it.each([
+    ["a bare filename", { ...target, path: "/Users/test/project/file.ts" }],
+    ["a path outside the workspace", { ...target, path: "/tmp/schema/x.md" }],
+    ["a home-relative path", { ...target, path: "~/schema/x.md" }],
+  ])("does not search %s", async (_label, candidate) => {
+    const { getDirectorySuggestions, searches } = suggestionsFromMap({
+      "schema/x.md": [{ path: "repo-a/schema/x.md", kind: "file" }],
+    });
+
+    const result = await resolveMissingNestedRelativeFile({
+      target: candidate,
+      workspaceRoot: "/Users/test/project",
+      getDirectorySuggestions,
+    });
+
+    expect(searches).toEqual([]);
+    expect(result).toEqual(candidate);
+  });
+
+  it("does not search when the workspace root is blank", async () => {
+    const { getDirectorySuggestions, searches } = suggestionsFromMap({});
+
+    const result = await resolveMissingNestedRelativeFile({
+      target,
+      workspaceRoot: "   ",
+      getDirectorySuggestions,
+    });
+
+    expect(searches).toEqual([]);
+    expect(result).toEqual(target);
+  });
+
+  it.each([
+    ["/Users/test/project/schema/x.md", "/Users/test/project"],
+    ["file:///Users/test/project/schema/x.md", "/Users/test/project"],
+    ["C:/repo/schema/x.md", "C:/repo"],
+    ["\\\\server\\share\\schema\\x.md", "//server/share"],
+  ])("keeps absolute destination %s", async (raw, workspaceRoot) => {
+    const { getDirectorySuggestions, searches } = suggestionsFromMap({
+      "schema/x.md": [{ path: "repo-a/schema/x.md", kind: "file" }],
+    });
+    const absoluteTarget = { raw, path: `${workspaceRoot}/schema/x.md` };
+    await expect(
+      resolveMissingNestedRelativeFile({
+        target: absoluteTarget,
+        workspaceRoot,
+        getDirectorySuggestions,
+      }),
+    ).resolves.toEqual(absoluteTarget);
+    expect(searches).toEqual([]);
+  });
+
+  it.each(["docs/guides", "./docs/guides", "docs/guides/"])(
+    "keeps folder href %s direct",
+    async (raw) => {
+      const { getDirectorySuggestions, searches } = suggestionsFromMap({
+        "docs/guides": [{ path: "repo-a/docs/guides", kind: "file" }],
+      });
+      const folderTarget = { raw, path: "/Users/test/project/docs/guides" };
+      await expect(
+        resolveMissingNestedRelativeFile({
+          target: folderTarget,
+          workspaceRoot: "/Users/test/project",
+          getDirectorySuggestions,
+        }),
+      ).resolves.toEqual(folderTarget);
+      expect(searches).toEqual([]);
+    },
+  );
+
+  it("normalizes a Windows workspace root before the suffix lookup", async () => {
+    const windowsTarget = {
+      raw: "schema/x.md",
+      path: "C:\\repo\\schema\\x.md",
+      lineStart: undefined,
+      lineEnd: undefined,
+    };
+    const { getDirectorySuggestions, searches } = suggestionsFromMap({
+      "schema/x.md": [{ path: "repo-a/schema/x.md", kind: "file" }],
+    });
+
+    const result = await resolveMissingNestedRelativeFile({
+      target: windowsTarget,
+      workspaceRoot: "C:\\repo\\",
+      getDirectorySuggestions,
+    });
+
+    expect(searches).toEqual([
+      {
+        query: "schema/x.md",
+        cwd: "C:\\repo\\",
+        matchMode: "suffix",
+        limit: 1,
+      },
+    ]);
+    expect(result.path).toBe("C:/repo/repo-a/schema/x.md");
+  });
+});
+
 describe("getAssistantFileLinkToken", () => {
  it("uses rendered text for markdown-it linkified tokens and href for explicit links", () => {
    expect(
@@ -5,6 +5,7 @@ import {
  type InlinePathTarget,
 } from "./parse";
 import { i18n } from "@/i18n/i18next";
+import { isAbsolutePath } from "@/utils/path";

 export interface AssistantFileLinkSource {
  href: string;
@@ -105,6 +106,62 @@ export async function fetchDaemonResolution({
  };
 }

+/** Only file-looking paths nested inside the workspace need suffix search. */
+function nestedRelativeLookupQuery(
+  targetPath: string,
+  workspaceRoot: string | undefined,
+): string | null {
+  const root = workspaceRoot?.trim();
+  if (!root) {
+    return null;
+  }
+  const normalizedRoot = root.replace(/\\/g, "/").replace(/\/+$/, "");
+  const normalizedPath = targetPath.replace(/\\/g, "/");
+  const prefix = `${normalizedRoot}/`;
+  if (!normalizedPath.startsWith(prefix)) {
+    return null;
+  }
+  const relative = normalizedPath.slice(prefix.length);
+  if (!relative.includes("/") || !isFileLookingAssistantToken(encodeURI(relative))) {
+    return null;
+  }
+  return relative;
+}
+
+/** When a markdown link points at workspaceRoot/schema/x.md and that file is
+ * missing, ask the same suffix lookup bare names already use. An exact hit
+ * stays on that path. A suffix hit such as repo-a/schema/x.md replaces it.
+ * Lookup failure keeps the original target.
+ */
+export async function resolveMissingNestedRelativeFile(input: {
+  target: InlinePathTarget;
+  workspaceRoot?: string;
+  getDirectorySuggestions: GetDirectorySuggestions;
+}): Promise<InlinePathTarget> {
+  if (
+    isAbsoluteInlineCodeToken(input.target.raw) ||
+    input.target.raw.startsWith("~/") ||
+    input.target.raw.endsWith("/")
+  ) {
+    return input.target;
+  }
+  const query = nestedRelativeLookupQuery(input.target.path, input.workspaceRoot);
+  if (!query) {
+    return input.target;
+  }
+  try {
+    return await fetchDaemonResolution({
+      ambiguousQuery: query,
+      token: input.target.raw,
+      target: input.target,
+      workspaceRoot: input.workspaceRoot,
+      getDirectorySuggestions: input.getDirectorySuggestions,
+    });
+  } catch {
+    return input.target;
+  }
+}
+
 export function classifyForResolution(
  source: AssistantFileLinkSource,
  context: AssistantFileLinkContext,
@@ -215,11 +272,7 @@ export function shouldResolveDirectFileThroughSuggestions(input: {
 }

 function isAbsoluteInlineCodeToken(token: string): boolean {
-  return (
-    token.startsWith("/") ||
-    token.toLowerCase().startsWith("file://") ||
-    /^[A-Za-z]:[\\/]/.test(token)
-  );
+  return isAbsolutePath(token) || token.toLowerCase().startsWith("file://");
 }

 function isLinkifiedSource(source: AssistantFileLinkSource): boolean {
@@ -2,7 +2,7 @@
 import React, { act } from "react";
 import { createRoot, type Root } from "react-dom/client";
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
-import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { useDraftStore } from "@/stores/draft-store";
 import type { AttachmentMetadata, ComposerAttachment } from "@/attachments/types";
 import { createWorkspaceFileAttachment } from "@/attachments/workspace-file";
@@ -126,17 +126,13 @@ afterEach(async () => {
  });
 });

-let useAgentInputDraft: typeof import("./input-draft").useAgentInputDraft;
 type DraftRecordForTest = ReturnType<typeof useDraftStore.getState>["drafts"][string];

-beforeAll(async () => {
-  Object.defineProperty(globalThis, "IS_REACT_ACT_ENVIRONMENT", {
-    value: true,
-    configurable: true,
-  });
-
-  ({ useAgentInputDraft } = await import("./input-draft"));
+Object.defineProperty(globalThis, "IS_REACT_ACT_ENVIRONMENT", {
+  value: true,
+  configurable: true,
 });
+const { useAgentInputDraft } = await import("./input-draft");

 describe("useAgentInputDraft live contract", () => {
  beforeEach(() => {
@@ -1,4 +1,4 @@
-import { beforeAll, describe, expect, it } from "vitest";
+import { describe, expect, it } from "vitest";
 import type {
  DaemonClient,
  FetchAgentHistoryEntry,
@@ -13,18 +13,8 @@ import { allAgentHistoryQueryKey } from "./agent-history-query-key";
  }
 ).__DEV__ = false;

-type UseAgentHistoryModule = typeof import("./use-agent-history");
-
-let fetchAgentHistoryBatch: UseAgentHistoryModule["fetchAgentHistoryBatch"];
-let fetchAgentHistoryPage: UseAgentHistoryModule["fetchAgentHistoryPage"];
-let collectAgentHistoryHostErrors: UseAgentHistoryModule["collectAgentHistoryHostErrors"];
-
-beforeAll(async () => {
-  const module = await import("./use-agent-history");
-  fetchAgentHistoryBatch = module.fetchAgentHistoryBatch;
-  fetchAgentHistoryPage = module.fetchAgentHistoryPage;
-  collectAgentHistoryHostErrors = module.collectAgentHistoryHostErrors;
-});
+const { fetchAgentHistoryBatch, fetchAgentHistoryPage, collectAgentHistoryHostErrors } =
+  await import("./use-agent-history");

 type FetchAgentHistory = DaemonClient["fetchAgentHistory"];
 type FetchAgentHistoryResult = Awaited<ReturnType<FetchAgentHistory>>;