wip: Strongly Typed Path strings and therefore fix all mismatch/normalisation issues on windows

packages/app/src/components/dialog-select-directory.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, test } from "bun:test"
+import {
+  getParentPath,
+  joinPath,
+  getPathDisplay,
+  getPathDisplaySeparator,
+  getPathRoot,
+  getPathScope,
+  getPathSearchText,
+  trimPrettyPath,
+} from "@opencode-ai/util/path"
+
+describe("dialog select directory display", () => {
+  test("keeps posix paths looking posix", () => {
+    expect(getPathDisplay("/Users/dev/repo", "", "/Users/dev")).toBe("~/repo")
+    expect(getPathDisplaySeparator("~/repo", "/Users/dev")).toBe("/")
+  })
+
+  test("renders windows home paths with native separators", () => {
+    expect(getPathDisplay("C:/Users/dev/repo", "", "C:\\Users\\dev")).toBe("~\\repo")
+    expect(getPathDisplaySeparator("~\\repo", "C:\\Users\\dev")).toBe("\\")
+  })
+
+  test("renders absolute windows paths with backslashes", () => {
+    expect(getPathDisplay("C:/Users/dev/repo", "C:\\", "C:\\Users\\dev")).toBe("C:\\Users\\dev\\repo")
+    expect(getPathDisplay("//server/share/repo", "\\\\server\\", "C:\\Users\\dev")).toBe(
+      "\\\\server\\share\\repo",
+    )
+  })
+
+  test("preserves UNC share roots for navigation helpers", () => {
+    expect(getPathRoot("\\\\server\\share\\repo")).toBe("//server/share")
+    expect(getPathRoot("\\\\server\\share")).toBe("//server/share")
+    expect(getParentPath("//server/share/repo")).toBe("//server/share")
+    expect(getParentPath("\\\\server\\share")).toBe("//server/share")
+  })
+
+  test("keeps UNC scoped search rooted at the share", () => {
+    expect(getPathScope("\\\\server\\share", "C:/Users/dev", "C:/Users/dev")).toEqual({
+      directory: "\\\\server\\share",
+      path: "",
+    })
+    expect(getPathScope("\\\\server\\share\\repo", "C:/Users/dev", "C:/Users/dev")).toEqual({
+      directory: "\\\\server\\share",
+      path: "repo",
+    })
+  })
+
+  test("keeps pretty paths native while joining search results", () => {
+    expect(trimPrettyPath("C:/Users/dev/repo/")).toBe("C:\\Users\\dev\\repo")
+    expect(joinPath("C:\\Users\\dev", "repo/src")).toBe("C:\\Users\\dev\\repo\\src")
+    expect(joinPath("\\\\server\\share", "repo")).toBe("\\\\server\\share\\repo")
+  })
+
+  test("indexes UNC paths in slash and native forms", () => {
+    const search = getPathSearchText("//server/share/repo", "C:\\Users\\dev")
+    expect(search).toContain("//server/share/repo")
+    expect(search).toContain("\\\\server\\share\\repo")
+    expect(search).toContain("repo")
+  })
+})

packages/app/src/components/dialog-select-directory.tsx

@@ -3,11 +3,24 @@ import { Dialog } from "@opencode-ai/ui/dialog"
 import { FileIcon } from "@opencode-ai/ui/file-icon"
 import { List } from "@opencode-ai/ui/list"
 import type { ListRef } from "@opencode-ai/ui/list"
-import { getDirectory, getFilename } from "@opencode-ai/util/path"
+import {
+  getDirectory,
+  getFilename,
+  joinPath,
+  normalizeInputPath,
+  getParentPath,
+  getPathDisplay,
+  getPathDisplaySeparator,
+  getPathRoot,
+  getPathScope,
+  getPathSearchText,
+  trimPrettyPath,
+} from "@opencode-ai/util/path"
 import fuzzysort from "fuzzysort"
 import { createMemo, createResource, createSignal } from "solid-js"
 import { useGlobalSDK } from "@/context/global-sdk"
 import { useGlobalSync } from "@/context/global-sync"
+import { workspacePathKey } from "@/context/file/path"
 import { useLayout } from "@/context/layout"
 import { useLanguage } from "@/context/language"
 
@@ -28,101 +41,27 @@ function cleanInput(value: string) {
   return first.replace(/[\u0000-\u001F\u007F]/g, "").trim()
 }
 
-function normalizePath(input: string) {
-  const v = input.replaceAll("\\", "/")
-  if (v.startsWith("//") && !v.startsWith("///")) return "//" + v.slice(2).replace(/\/+/g, "/")
-  return v.replace(/\/+/g, "/")
-}
-
-function normalizeDriveRoot(input: string) {
-  const v = normalizePath(input)
-  if (/^[A-Za-z]:$/.test(v)) return v + "/"
-  return v
-}
-
-function trimTrailing(input: string) {
-  const v = normalizeDriveRoot(input)
-  if (v === "/") return v
-  if (v === "//") return v
-  if (/^[A-Za-z]:\/$/.test(v)) return v
-  return v.replace(/\/+$/, "")
-}
-
-function joinPath(base: string | undefined, rel: string) {
-  const b = trimTrailing(base ?? "")
-  const r = trimTrailing(rel).replace(/^\/+/, "")
-  if (!b) return r
-  if (!r) return b
-  if (b.endsWith("/")) return b + r
-  return b + "/" + r
-}
-
-function rootOf(input: string) {
-  const v = normalizeDriveRoot(input)
-  if (v.startsWith("//")) return "//"
-  if (v.startsWith("/")) return "/"
-  if (/^[A-Za-z]:\//.test(v)) return v.slice(0, 3)
-  return ""
-}
-
-function parentOf(input: string) {
-  const v = trimTrailing(input)
-  if (v === "/") return v
-  if (v === "//") return v
-  if (/^[A-Za-z]:\/$/.test(v)) return v
-
-  const i = v.lastIndexOf("/")
-  if (i <= 0) return "/"
-  if (i === 2 && /^[A-Za-z]:/.test(v)) return v.slice(0, 3)
-  return v.slice(0, i)
-}
-
-function modeOf(input: string) {
-  const raw = normalizeDriveRoot(input.trim())
-  if (!raw) return "relative" as const
-  if (raw.startsWith("~")) return "tilde" as const
-  if (rootOf(raw)) return "absolute" as const
-  return "relative" as const
-}
-
-function tildeOf(absolute: string, home: string) {
-  const full = trimTrailing(absolute)
-  if (!home) return ""
-
-  const hn = trimTrailing(home)
-  const lc = full.toLowerCase()
-  const hc = hn.toLowerCase()
-  if (lc === hc) return "~"
-  if (lc.startsWith(hc + "/")) return "~" + full.slice(hn.length)
-  return ""
-}
-
-function displayPath(path: string, input: string, home: string) {
-  const full = trimTrailing(path)
-  if (modeOf(input) === "absolute") return full
-  return tildeOf(full, home) || full
-}
-
 function toRow(absolute: string, home: string, group: Row["group"]): Row {
-  const full = trimTrailing(absolute)
-  const tilde = tildeOf(full, home)
-  const withSlash = (value: string) => {
-    if (!value) return ""
-    if (value.endsWith("/")) return value
-    return value + "/"
-  }
-
-  const search = Array.from(
-    new Set([full, withSlash(full), tilde, withSlash(tilde), getFilename(full)].filter(Boolean)),
-  ).join("\n")
-  return { absolute: full, search, group }
+  const full = trimPrettyPath(absolute)
+  return { absolute: full, search: getPathSearchText(full, home), group }
 }
 
 function uniqueRows(rows: Row[]) {
   const seen = new Set<string>()
   return rows.filter((row) => {
-    if (seen.has(row.absolute)) return false
-    seen.add(row.absolute)
+    const key = workspacePathKey(row.absolute)
+    if (seen.has(key)) return false
+    seen.add(key)
+    return true
+  })
+}
+
+function unique(paths: string[]) {
+  const seen = new Set<string>()
+  return paths.filter((path) => {
+    const key = workspacePathKey(path)
+    if (seen.has(key)) return false
+    seen.add(key)
     return true
   })
 }
@@ -135,37 +74,22 @@ function useDirectorySearch(args: {
   const cache = new Map<string, Promise<Array<{ name: string; absolute: string }>>>()
   let current = 0
 
-  const scoped = (value: string) => {
-    const base = args.start()
-    if (!base) return
-
-    const raw = normalizeDriveRoot(value)
-    if (!raw) return { directory: trimTrailing(base), path: "" }
-
-    const h = args.home()
-    if (raw === "~") return { directory: trimTrailing(h || base), path: "" }
-    if (raw.startsWith("~/")) return { directory: trimTrailing(h || base), path: raw.slice(2) }
-
-    const root = rootOf(raw)
-    if (root) return { directory: trimTrailing(root), path: raw.slice(root.length) }
-    return { directory: trimTrailing(base), path: raw }
-  }
-
   const dirs = async (dir: string) => {
-    const key = trimTrailing(dir)
+    const path = trimPrettyPath(dir)
+    const key = workspacePathKey(path)
     const existing = cache.get(key)
     if (existing) return existing
 
     const request = args.sdk.client.file
-      .list({ directory: key, path: "" })
+      .list({ directory: path, path })
       .then((x) => x.data ?? [])
       .catch(() => [])
       .then((nodes) =>
         nodes
           .filter((n) => n.type === "directory")
           .map((n) => ({
             name: n.name,
-            absolute: trimTrailing(normalizeDriveRoot(n.absolute)),
+            absolute: trimPrettyPath(n.absolute),
           })),
       )
 
@@ -184,12 +108,12 @@ function useDirectorySearch(args: {
     const active = () => token === current
 
     const value = cleanInput(filter)
-    const scopedInput = scoped(value)
+    const scopedInput = getPathScope(value, args.start(), args.home())
     if (!scopedInput) return [] as string[]
 
-    const raw = normalizeDriveRoot(value)
-    const isPath = raw.startsWith("~") || !!rootOf(raw) || raw.includes("/")
-    const query = normalizeDriveRoot(scopedInput.path)
+    const raw = normalizeInputPath(value)
+    const isPath = raw.startsWith("~") || !!getPathRoot(raw) || /[\\/]/.test(value)
+    const query = normalizeInputPath(scopedInput.path)
 
     const find = () =>
       args.sdk.client.find
@@ -213,23 +137,23 @@ function useDirectorySearch(args: {
     for (const part of head) {
       if (!active()) return []
       if (part === "..") {
-        paths = paths.map(parentOf)
+        paths = paths.map(getParentPath)
         continue
       }
 
       const next = (await Promise.all(paths.map((p) => match(p, part, branch)))).flat()
       if (!active()) return []
-      paths = Array.from(new Set(next)).slice(0, cap)
+      paths = unique(next).slice(0, cap)
       if (paths.length === 0) return [] as string[]
     }
 
     const out = (await Promise.all(paths.map((p) => match(p, tail, 50)))).flat()
     if (!active()) return []
-    const deduped = Array.from(new Set(out))
-    const base = raw.startsWith("~") ? trimTrailing(scopedInput.directory) : ""
+    const deduped = unique(out)
+    const base = raw.startsWith("~") ? scopedInput.directory : ""
     const expand = !raw.endsWith("/")
     if (!expand || !tail) {
-      const items = base ? Array.from(new Set([base, ...deduped])) : deduped
+      const items = base ? unique([base, ...deduped]) : deduped
       return items.slice(0, 50)
     }
 
@@ -240,8 +164,8 @@ function useDirectorySearch(args: {
 
     const children = await match(target, "", 30)
     if (!active()) return []
-    const items = Array.from(new Set([...deduped, ...children]))
-    return (base ? Array.from(new Set([base, ...items])) : items).slice(0, 50)
+    const items = unique([...deduped, ...children])
+    return (base ? unique([base, ...items]) : items).slice(0, 50)
   }
 }
 
@@ -348,24 +272,27 @@ export function DialogSelectDirectory(props: DialogSelectDirectoryProps) {
           e.preventDefault()
           e.stopPropagation()
 
-          const value = displayPath(item.absolute, filter(), home())
-          list?.setFilter(value.endsWith("/") ? value : value + "/")
+          const value = getPathDisplay(item.absolute, filter(), home())
+          const sep = getPathDisplaySeparator(value, home())
+          list?.setFilter(/[\\/]$/.test(value) ? value : value + sep)
         }}
         onSelect={(path) => {
           if (!path) return
           resolve(path.absolute)
         }}
       >
         {(item) => {
-          const path = displayPath(item.absolute, filter(), home())
+          const path = getPathDisplay(item.absolute, filter(), home())
+          const dir = getDirectory(path)
+          const sep = getPathDisplaySeparator(path, home())
           if (path === "~") {
             return (
               <div class="w-full flex items-center justify-between rounded-md">
                 <div class="flex items-center gap-x-3 grow min-w-0">
                   <FileIcon node={{ path: item.absolute, type: "directory" }} class="shrink-0 size-4" />
                   <div class="flex items-center text-14-regular min-w-0">
                     <span class="text-text-strong whitespace-nowrap">~</span>
-                    <span class="text-text-weak whitespace-nowrap">/</span>
+                    <span class="text-text-weak whitespace-nowrap">{sep}</span>
                   </div>
                 </div>
               </div>
@@ -377,10 +304,10 @@ export function DialogSelectDirectory(props: DialogSelectDirectoryProps) {
                 <FileIcon node={{ path: item.absolute, type: "directory" }} class="shrink-0 size-4" />
                 <div class="flex items-center text-14-regular min-w-0">
                   <span class="text-text-weak whitespace-nowrap overflow-hidden overflow-ellipsis truncate min-w-0">
-                    {getDirectory(path)}
+                    {dir}
                   </span>
                   <span class="text-text-strong whitespace-nowrap">{getFilename(path)}</span>
-                  <span class="text-text-weak whitespace-nowrap">/</span>
+                  <span class="text-text-weak whitespace-nowrap">{sep}</span>
                 </div>
               </div>
             </div>