@baique/pi-web-sky 0.1.35 → 0.1.36

package/lib/file-links.ts

@@ -0,0 +1,148 @@
+function safeDecode(value: string): string {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+
+function normalizeFilePathSlashes(filePath: string): string {
+  if (/^[a-zA-Z]:[\\/]/.test(filePath) || filePath.startsWith("\\\\")) {
+    return filePath.replace(/\\/g, "/");
+  }
+  return filePath;
+}
+
+function stripLineSuffix(filePath: string): string {
+  return filePath.replace(/:\d+(?::\d+)?$/, "");
+}
+
+function normalizeLocalPath(filePath: string): string {
+  const normalized = normalizeFilePathSlashes(filePath);
+  const isWindowsDrive = /^[a-zA-Z]:\//.test(normalized);
+  const isUnc = normalized.startsWith("//");
+  const leadingSlash = normalized.startsWith("/") && !isWindowsDrive && !isUnc;
+  const parts: string[] = [];
+
+  for (const part of normalized.split("/")) {
+    if (!part || part === ".") continue;
+    if (part === "..") {
+      if (parts.length > 0 && parts[parts.length - 1] !== "..") {
+        parts.pop();
+      } else if (!leadingSlash && !isWindowsDrive && !isUnc) {
+        parts.push(part);
+      }
+      continue;
+    }
+    parts.push(part);
+  }
+
+  const joined = parts.join("/");
+  if (isWindowsDrive) return joined;
+  if (isUnc) return `//${joined}`;
+  return leadingSlash ? `/${joined}` : joined;
+}
+
+function isPathInside(candidate: string, root: string): boolean {
+  const normalizedCandidate = normalizeLocalPath(candidate).replace(/\/+$/, "");
+  const normalizedRoot = normalizeLocalPath(root).replace(/\/+$/, "");
+  const useCaseInsensitive = /^[a-zA-Z]:\//.test(normalizedCandidate) || /^[a-zA-Z]:\//.test(normalizedRoot);
+  const filePath = useCaseInsensitive ? normalizedCandidate.toLowerCase() : normalizedCandidate;
+  const rootPath = useCaseInsensitive ? normalizedRoot.toLowerCase() : normalizedRoot;
+  return filePath === rootPath || filePath.startsWith(`${rootPath}/`);
+}
+
+function looksLikeRelativeFileHref(href: string): boolean {
+  if (href.startsWith("#") || href.startsWith("?")) return false;
+  if (href.startsWith("./") || href.startsWith("../")) return true;
+  if (href.includes("/")) return true;
+  return /(^|\/)\.?[^/]+\.[^/.]+$/.test(href);
+}
+
+function fileUrlToPath(href: string): string | null {
+  try {
+    const url = new URL(href);
+    if (url.protocol !== "file:") return null;
+    const pathname = safeDecode(url.pathname);
+    if (url.hostname) {
+      return `//${url.hostname}${pathname.startsWith("/") ? pathname : `/${pathname}`}`;
+    }
+    if (/^\/[a-zA-Z]:\//.test(pathname)) return pathname.slice(1);
+    return pathname;
+  } catch {
+    return null;
+  }
+}
+
+export function resolveLocalFileHref(
+  href: string | undefined,
+  baseDir?: string,
+  relativeRoot = baseDir,
+): string | null {
+  if (!href) return null;
+
+  const cleanHref = href.split("#", 1)[0].split("?", 1)[0].trim();
+  if (!cleanHref) return null;
+
+  let candidate: string | null = null;
+  let candidateKind: "absolute" | "relative" | null = null;
+  const decodedHref = safeDecode(cleanHref);
+  const isBackslashUncPath = decodedHref.startsWith("\\\\");
+  const normalizedHref = normalizeFilePathSlashes(decodedHref);
+  const lowerHref = normalizedHref.toLowerCase();
+
+  if (lowerHref.startsWith("/api/") || lowerHref.startsWith("/_next/")) return null;
+  if (!isBackslashUncPath && normalizedHref.startsWith("//")) return null;
+  if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/i.test(normalizedHref) && !lowerHref.startsWith("file:") && !/^[a-zA-Z]:\//.test(normalizedHref)) {
+    return null;
+  }
+
+  if (lowerHref.startsWith("file:")) {
+    candidate = fileUrlToPath(normalizedHref);
+    candidateKind = candidate ? "absolute" : null;
+  } else if (/^[a-zA-Z]:\//.test(normalizedHref)) {
+    candidate = normalizedHref;
+    candidateKind = "absolute";
+  } else if (normalizedHref.startsWith("/")) {
+    candidate = normalizedHref;
+    candidateKind = "absolute";
+  } else if (baseDir && looksLikeRelativeFileHref(normalizedHref)) {
+    candidate = `${normalizeFilePathSlashes(baseDir).replace(/\/+$/, "")}/${normalizedHref}`;
+    candidateKind = "relative";
+  }
+
+  if (!candidate) return null;
+
+  const filePath = stripLineSuffix(normalizeLocalPath(candidate));
+  if (candidateKind === "relative" && relativeRoot && !isPathInside(filePath, relativeRoot)) return null;
+  return filePath;
+}
+
+/** Resolve a filesystem path without applying URL or source-location syntax. */
+export function resolveLocalFilePath(filePath: string | undefined, baseDir?: string): string | null {
+  if (!filePath) return null;
+
+  const windowsStyle = /^[a-zA-Z]:[\\/]/.test(filePath) ||
+    filePath.startsWith("\\\\") ||
+    (baseDir !== undefined && (/^[a-zA-Z]:[\\/]/.test(baseDir) || baseDir.startsWith("\\\\")));
+  const normalizeSlashes = (value: string) => windowsStyle ? value.replace(/\\/g, "/") : value;
+  const normalizedPath = normalizeSlashes(filePath);
+  const normalizedBase = baseDir ? normalizeSlashes(baseDir).replace(/\/+$/, "") : undefined;
+
+  const isDriveAbsolute = /^[a-zA-Z]:\//.test(normalizedPath);
+  const isUncAbsolute = normalizedPath.startsWith("//");
+  let candidate: string;
+
+  if (isDriveAbsolute || isUncAbsolute) {
+    candidate = normalizedPath;
+  } else if (normalizedPath.startsWith("/")) {
+    const windowsRoot = normalizedBase?.match(/^([a-zA-Z]:)(?:\/|$)/)?.[1]
+      ?? normalizedBase?.match(/^(\/\/[^/]+\/[^/]+)(?:\/|$)/)?.[1];
+    candidate = windowsRoot ? `${windowsRoot}${normalizedPath}` : normalizedPath;
+  } else {
+    if (!normalizedBase) return null;
+    candidate = `${normalizedBase}/${normalizedPath}`;
+  }
+
+  return normalizeLocalPath(candidate);
+}

package/lib/file-paths.ts

@@ -0,0 +1,43 @@
+export function normalizeFilePathSlashes(filePath: string): string {
+  if (/^[a-zA-Z]:[\\/]/.test(filePath) || filePath.startsWith("\\\\")) {
+    return filePath.replace(/\\/g, "/");
+  }
+  return filePath;
+}
+
+export function encodeFilePathForApi(filePath: string): string {
+  return normalizeFilePathSlashes(filePath)
+    .split("/")
+    .filter(Boolean)
+    .map(encodeURIComponent)
+    .join("/");
+}
+
+export function getFileName(filePath: string): string {
+  const normalized = normalizeFilePathSlashes(filePath).replace(/\/+$/, "");
+  return normalized.split("/").pop() ?? normalized;
+}
+
+export function getFileDirectory(filePath: string): string {
+  const normalized = normalizeFilePathSlashes(filePath).replace(/\/+$/, "");
+  const lastSlash = normalized.lastIndexOf("/");
+  if (lastSlash < 0) return "";
+  if (lastSlash === 0) return "/";
+  if (lastSlash === 2 && /^[a-zA-Z]:\//.test(normalized)) return normalized.slice(0, 3);
+  return normalized.slice(0, lastSlash);
+}
+
+export function getRelativeFilePath(filePath: string, cwd?: string): string {
+  if (!cwd) return filePath;
+
+  const normalizedFile = normalizeFilePathSlashes(filePath);
+  const normalizedCwd = normalizeFilePathSlashes(cwd).replace(/\/$/, "");
+  if (normalizedFile.startsWith(normalizedCwd + "/")) {
+    return normalizedFile.slice(normalizedCwd.length + 1);
+  }
+  return filePath;
+}
+
+export function joinFilePath(parent: string, child: string): string {
+  return `${normalizeFilePathSlashes(parent).replace(/\/$/, "")}/${child}`;
+}

package/lib/file-types.test.mjs

@@ -0,0 +1,34 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+async function loadSubject() {
+  return import("./file-types.ts");
+}
+
+test("detects image, audio, and document preview paths", async () => {
+  const {
+    getAudioMime,
+    getDocumentMime,
+    getImageMime,
+    isAudioPath,
+    isDocumentPreviewPath,
+    isImagePath,
+  } = await loadSubject();
+
+  assert.equal(getImageMime("/tmp/screenshot.PNG"), "image/png");
+  assert.equal(getAudioMime("C:\\Users\\me\\voice.OPUS"), "audio/ogg");
+  assert.equal(getDocumentMime("/tmp/report.docx"), "application/vnd.openxmlformats-officedocument.wordprocessingml.document");
+  assert.equal(isImagePath("/tmp/screenshot.PNG"), true);
+  assert.equal(isAudioPath("C:\\Users\\me\\voice.OPUS"), true);
+  assert.equal(isDocumentPreviewPath("/tmp/report.pdf"), true);
+  assert.equal(isDocumentPreviewPath("/tmp/report.txt"), false);
+});
+
+test("extracts extensions from mixed path styles", async () => {
+  const { documentPreviewKind, getFileExt } = await loadSubject();
+
+  assert.equal(getFileExt("/tmp/archive.tar.gz"), "gz");
+  assert.equal(getFileExt("C:\\Users\\me\\photo.AVIF"), "avif");
+  assert.equal(documentPreviewKind("/tmp/manual.PDF"), "pdf");
+  assert.equal(documentPreviewKind("/tmp/manual.md"), null);
+});

package/lib/file-types.ts

@@ -0,0 +1,73 @@
+export const TEXT_PREVIEW_MAX_BYTES = 256 * 1024;
+export const IMAGE_PREVIEW_MAX_BYTES = 10 * 1024 * 1024;
+export const DOCX_PREVIEW_MAX_BYTES = 10 * 1024 * 1024;
+
+export type DocumentPreviewKind = "pdf" | "docx";
+
+export const IMAGE_EXT_TO_MIME: Record<string, string> = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  svg: "image/svg+xml",
+  bmp: "image/bmp",
+  ico: "image/x-icon",
+  avif: "image/avif",
+};
+
+export const AUDIO_EXT_TO_MIME: Record<string, string> = {
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  ogg: "audio/ogg",
+  oga: "audio/ogg",
+  opus: "audio/ogg",
+  m4a: "audio/mp4",
+  aac: "audio/aac",
+  flac: "audio/flac",
+  weba: "audio/webm",
+  webm: "audio/webm",
+};
+
+export const DOCUMENT_EXT_TO_MIME: Record<DocumentPreviewKind, string> = {
+  pdf: "application/pdf",
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+};
+
+function getBaseName(filePath: string): string {
+  return filePath.replace(/\\/g, "/").split("/").pop() ?? "";
+}
+
+export function getFileExt(filePath: string): string {
+  return getBaseName(filePath).toLowerCase().split(".").pop() ?? "";
+}
+
+export function getImageMime(filePath: string): string | null {
+  return IMAGE_EXT_TO_MIME[getFileExt(filePath)] ?? null;
+}
+
+export function getAudioMime(filePath: string): string | null {
+  return AUDIO_EXT_TO_MIME[getFileExt(filePath)] ?? null;
+}
+
+export function getDocumentMime(filePath: string): string | null {
+  return DOCUMENT_EXT_TO_MIME[getFileExt(filePath) as DocumentPreviewKind] ?? null;
+}
+
+export function documentPreviewKind(filePath: string): DocumentPreviewKind | null {
+  const ext = getFileExt(filePath);
+  if (ext === "pdf" || ext === "docx") return ext;
+  return null;
+}
+
+export function isImagePath(filePath: string): boolean {
+  return getImageMime(filePath) !== null;
+}
+
+export function isAudioPath(filePath: string): boolean {
+  return getAudioMime(filePath) !== null;
+}
+
+export function isDocumentPreviewPath(filePath: string): boolean {
+  return documentPreviewKind(filePath) !== null;
+}

package/lib/file-upload.test.mjs

@@ -0,0 +1,70 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+async function loadSubject() {
+  return import("./file-upload.ts");
+}
+
+test("validates upload names without accepting paths or duplicates", async () => {
+  const { validateUploadFileNames } = await loadSubject();
+
+  assert.equal(validateUploadFileNames(["one.txt", "two file.md"]), null);
+  assert.match(validateUploadFileNames(["../secret.txt"]), /must not contain a path/);
+  assert.match(validateUploadFileNames(["folder\\secret.txt"]), /must not contain a path/);
+  assert.match(validateUploadFileNames(["same.txt", "same.txt"]), /Duplicate/);
+  assert.match(validateUploadFileNames([]), /No files/);
+});
+
+test("finds conflicts and prevents replacing directories", async (t) => {
+  const { inspectUploadTargets } = await loadSubject();
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-web-upload-"));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+
+  fs.writeFileSync(path.join(root, "file.txt"), "old");
+  fs.mkdirSync(path.join(root, "directory"));
+
+  assert.deepEqual(
+    inspectUploadTargets(root, ["new.txt", "file.txt", "directory"]),
+    {
+      conflicts: ["file.txt", "directory"],
+      nonReplaceable: ["directory"],
+    },
+  );
+});
+
+test("prevents replacing symbolic links", async (t) => {
+  const { inspectUploadTargets } = await loadSubject();
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-web-upload-link-"));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+
+  fs.writeFileSync(path.join(root, "file.txt"), "old");
+  try {
+    fs.symlinkSync("file.txt", path.join(root, "link.txt"));
+  } catch (error) {
+    if (error?.code === "EPERM") {
+      t.skip("Creating symbolic links requires additional privileges on this platform");
+      return;
+    }
+    throw error;
+  }
+
+  assert.deepEqual(
+    inspectUploadTargets(root, ["link.txt"]),
+    {
+      conflicts: ["link.txt"],
+      nonReplaceable: ["link.txt"],
+    },
+  );
+});
+
+test("parses only supported conflict strategies", async () => {
+  const { parseUploadConflictStrategy } = await loadSubject();
+
+  assert.equal(parseUploadConflictStrategy(null), "error");
+  assert.equal(parseUploadConflictStrategy("overwrite"), "overwrite");
+  assert.equal(parseUploadConflictStrategy("skip"), "skip");
+  assert.equal(parseUploadConflictStrategy("rename"), null);
+});

package/lib/file-upload.ts

@@ -0,0 +1,59 @@
+import fs from "fs";
+import path from "path";
+
+export const UPLOAD_CONFLICT_STRATEGIES = ["error", "overwrite", "skip"] as const;
+export type UploadConflictStrategy = typeof UPLOAD_CONFLICT_STRATEGIES[number];
+
+const UPLOAD_CONFLICT_STRATEGY_SET = new Set<string>(UPLOAD_CONFLICT_STRATEGIES);
+
+export interface UploadTargetInspection {
+  conflicts: string[];
+  nonReplaceable: string[];
+}
+
+export function parseUploadConflictStrategy(value: string | null): UploadConflictStrategy | null {
+  const candidate = value ?? "error";
+  return UPLOAD_CONFLICT_STRATEGY_SET.has(candidate)
+    ? candidate as UploadConflictStrategy
+    : null;
+}
+
+export function validateUploadFileNames(fileNames: string[]): string | null {
+  if (fileNames.length === 0) return "No files selected";
+
+  const seen = new Set<string>();
+  for (const fileName of fileNames) {
+    if (!fileName || fileName === "." || fileName === ".." || fileName.includes("\0")) {
+      return `Invalid file name: ${fileName || "(empty)"}`;
+    }
+    if (fileName.includes("/") || fileName.includes("\\") || path.basename(fileName) !== fileName) {
+      return `File names must not contain a path: ${fileName}`;
+    }
+    if (seen.has(fileName)) return `Duplicate file name in upload: ${fileName}`;
+    seen.add(fileName);
+  }
+
+  return null;
+}
+
+export function inspectUploadTargets(directory: string, fileNames: string[]): UploadTargetInspection {
+  const conflicts: string[] = [];
+  const nonReplaceable: string[] = [];
+
+  for (const fileName of fileNames) {
+    const destination = path.join(directory, fileName);
+    let stat: fs.Stats;
+    try {
+      stat = fs.lstatSync(destination);
+    } catch (error) {
+      const code = (error as NodeJS.ErrnoException).code;
+      if (code === "ENOENT") continue;
+      throw error;
+    }
+
+    conflicts.push(fileName);
+    if (!stat.isFile() || stat.isSymbolicLink()) nonReplaceable.push(fileName);
+  }
+
+  return { conflicts, nonReplaceable };
+}

package/lib/file-viewer-state.test.mjs

@@ -0,0 +1,20 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { resolveInitialFileDisplayMode } from "./file-viewer-state.ts";
+
+test("a restored display mode wins over a stale open hint", () => {
+  const state = {
+    displayMode: "source",
+    wrapLines: true,
+    scrollTop: 80,
+    scrollLeft: 0,
+  };
+
+  assert.equal(resolveInitialFileDisplayMode(state, "diff"), "source");
+});
+
+test("the open hint is used only before viewer state has been saved", () => {
+  assert.equal(resolveInitialFileDisplayMode(undefined, "diff"), "diff");
+  assert.equal(resolveInitialFileDisplayMode(), "source");
+});

package/lib/file-viewer-state.ts

@@ -0,0 +1,15 @@
+export type FileViewerDisplayMode = "source" | "preview" | "diff";
+
+export interface FileViewerState {
+  displayMode: FileViewerDisplayMode;
+  wrapLines: boolean;
+  scrollTop: number;
+  scrollLeft: number;
+}
+
+export function resolveInitialFileDisplayMode(
+  initialState?: FileViewerState,
+  initialDisplayMode?: FileViewerDisplayMode,
+): FileViewerDisplayMode {
+  return initialState?.displayMode ?? initialDisplayMode ?? "source";
+}

package/lib/frontmatter.test.mjs

@@ -0,0 +1,55 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+import {
+  formatFrontmatterValue,
+  getFrontmatterTitle,
+  parseFrontmatter,
+} from "./frontmatter.ts";
+
+describe("parseFrontmatter", () => {
+  it("accepts the same common fence variants as remark-frontmatter", () => {
+    const cases = [
+      "---\ntitle: Demo\n---\nbody",
+      "\uFEFF---\ntitle: Demo\n---\nbody",
+      "---   \ntitle: Demo\n---\t\nbody",
+      "---\r\ntitle: Demo\r\n---\r\nbody",
+      "---\rtitle: Demo\r---\rbody",
+    ];
+
+    for (const markdown of cases) {
+      assert.deepEqual(parseFrontmatter(markdown), {
+        data: { title: "Demo" },
+        rest: "body",
+      });
+    }
+  });
+
+  it("removes an empty or malformed fenced block from the returned body", () => {
+    assert.deepEqual(parseFrontmatter("---\n---\nbody"), { data: null, rest: "body" });
+    assert.deepEqual(parseFrontmatter("---\n[invalid\n---\nbody"), {
+      data: null,
+      rest: "body",
+    });
+  });
+
+  it("leaves documents without a leading frontmatter block untouched", () => {
+    const markdown = "body\n---\ntitle: Not frontmatter\n---";
+    assert.deepEqual(parseFrontmatter(markdown), { data: null, rest: markdown });
+  });
+});
+
+describe("frontmatter value formatting", () => {
+  it("does not recurse forever through YAML aliases", () => {
+    const { data } = parseFrontmatter("---\nloop: &loop\n  - *loop\n---\n");
+    assert.ok(data);
+    assert.equal(formatFrontmatterValue(data.loop), "[Circular]");
+  });
+
+  it("uses scalar titles and leaves structured titles for the metadata rows", () => {
+    assert.equal(getFrontmatterTitle("  Demo  "), "Demo");
+    assert.equal(getFrontmatterTitle(1984), "1984");
+    assert.equal(getFrontmatterTitle(false), "false");
+    assert.equal(getFrontmatterTitle(["Demo"]), null);
+  });
+});

package/lib/frontmatter.ts

@@ -0,0 +1,87 @@
+import { load as parseYaml } from "js-yaml";
+
+const FRONTMATTER_OPEN_RE = /^(?:\uFEFF)?---[ \t]*(?:\r\n|\n|\r)/;
+
+export interface FrontmatterResult {
+  data: Record<string, unknown> | null;
+  rest: string;
+}
+
+interface FrontmatterBlock {
+  yaml: string;
+  rest: string;
+}
+
+function extractFrontmatter(markdown: string): FrontmatterBlock | null {
+  const opening = FRONTMATTER_OPEN_RE.exec(markdown);
+  if (!opening) return null;
+
+  const closingPattern = /^---[ \t]*(?:(?:\r\n|\n|\r)|$)/gm;
+  closingPattern.lastIndex = opening[0].length;
+  const closing = closingPattern.exec(markdown);
+  if (!closing) return null;
+
+  const yaml = markdown
+    .slice(opening[0].length, closing.index)
+    .replace(/(?:\r\n|\n|\r)$/, "");
+
+  return {
+    yaml,
+    rest: markdown.slice(closing.index + closing[0].length),
+  };
+}
+
+export function parseFrontmatter(markdown: string): FrontmatterResult {
+  const block = extractFrontmatter(markdown);
+  if (!block) return { data: null, rest: markdown };
+
+  try {
+    const parsed = parseYaml(block.yaml);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return { data: parsed as Record<string, unknown>, rest: block.rest };
+    }
+  } catch {
+    // The remark plugin still hides a syntactically fenced malformed block.
+  }
+
+  return { data: null, rest: block.rest };
+}
+
+export function formatFrontmatterValue(value: unknown): string {
+  return formatValue(value, new WeakSet<object>());
+}
+
+function formatValue(value: unknown, ancestors: WeakSet<object>): string {
+  if (value === null || value === undefined) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+
+  if (Array.isArray(value)) {
+    if (ancestors.has(value)) return "[Circular]";
+    ancestors.add(value);
+    try {
+      return value
+        .map((item) => formatValue(item, ancestors))
+        .filter(Boolean)
+        .join(", ");
+    } finally {
+      ancestors.delete(value);
+    }
+  }
+
+  if (typeof value === "object") {
+    try {
+      return JSON.stringify(value) ?? Object.prototype.toString.call(value);
+    } catch {
+      return Object.prototype.toString.call(value);
+    }
+  }
+
+  return String(value);
+}
+
+export function getFrontmatterTitle(value: unknown): string | null {
+  if (typeof value === "string") return value.trim() || null;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return null;
+}

package/lib/git-changes.test.mjs

@@ -0,0 +1,52 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+async function loadSubject() {
+  return import("./git-status.ts");
+}
+
+test("parses null-delimited Git status entries including renames", async () => {
+  const { parseGitPorcelainV1 } = await loadSubject();
+  const entries = parseGitPorcelainV1([
+    " M components/App.tsx",
+    "?? notes.txt",
+    "R  src/new-name.ts",
+    "src/old-name.ts",
+    "",
+  ].join("\0"));
+
+  assert.deepEqual(entries, [
+    {
+      path: "components/App.tsx",
+      indexStatus: " ",
+      worktreeStatus: "M",
+    },
+    {
+      path: "notes.txt",
+      indexStatus: "?",
+      worktreeStatus: "?",
+    },
+    {
+      path: "src/new-name.ts",
+      originalPath: "src/old-name.ts",
+      indexStatus: "R",
+      worktreeStatus: " ",
+    },
+  ]);
+});
+
+test("classifies Git status for explorer badges", async () => {
+  const { classifyGitStatus } = await loadSubject();
+  const classify = (pair) => classifyGitStatus({
+    path: "file.ts",
+    indexStatus: pair[0],
+    worktreeStatus: pair[1],
+  });
+
+  assert.deepEqual(classify(" M"), { status: "modified", code: "M" });
+  assert.deepEqual(classify("??"), { status: "untracked", code: "U" });
+  assert.deepEqual(classify("A "), { status: "added", code: "A" });
+  assert.deepEqual(classify("R "), { status: "renamed", code: "R" });
+  assert.deepEqual(classify("UU"), { status: "conflict", code: "C" });
+  assert.deepEqual(classify(" D"), { status: "deleted", code: "D" });
+});