@tanishqkancharla/diffmap 0.1.3

package/src/serve.ts

@@ -0,0 +1,350 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createServer, type ViteDevServer } from "vite";
+import { diffmapContentPlugin } from "./contentPlugin.js";
+import { DiffmapFileError, DiffmapServeError } from "./errors.js";
+import { extractTitle } from "./extractDocument.js";
+import { findDefinition, readSourceReference } from "./definitions.js";
+import {
+  registerRunningDiffmap,
+  unregisterRunningDiffmap,
+} from "./registry.js";
+
+export type DiffmapServer = {
+  url: string;
+  filePath: string;
+  shutdown: () => Promise<void>;
+  closed: Promise<void>;
+};
+
+export type StartServerInput = {
+  filePath: string;
+  workspaceRoot: string;
+  port: number;
+};
+
+const packageRoot = path.resolve(fileURLToPath(new URL("..", import.meta.url)));
+
+function noop() {}
+
+function createClosedBarrier() {
+  let resolveFn = noop;
+  const closed = new Promise<void>((resolve) => {
+    resolveFn = resolve;
+  });
+  return {
+    closed,
+    resolve() {
+      resolveFn();
+    },
+  };
+}
+
+export async function startServer(input: StartServerInput) {
+  const filePath = path.resolve(input.filePath);
+  const workspaceRoot = path.resolve(input.workspaceRoot);
+  const source = await fs.readFile(filePath, "utf8").catch(
+    (cause) =>
+      new DiffmapFileError({
+        path: filePath,
+        reason: "read",
+        cause,
+      }),
+  );
+  if (source instanceof Error) return source;
+
+  const title = extractTitle(source);
+
+  let vite: ViteDevServer | undefined;
+  let registryPath: string | undefined;
+  const closedBarrier = createClosedBarrier();
+  let shuttingDown = false;
+  let inactivityTimer: ReturnType<typeof setTimeout> | undefined;
+
+  async function shutdown() {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    clearTimeout(inactivityTimer);
+    if (vite !== undefined) await vite.close();
+    if (registryPath !== undefined) {
+      const removed = await unregisterRunningDiffmap(registryPath);
+      if (removed instanceof Error) console.error(removed.message);
+    }
+    closedBarrier.resolve();
+  }
+
+  vite = await createServer({
+    configFile: path.join(packageRoot, "vite.config.ts"),
+    root: packageRoot,
+    server: {
+      port: input.port,
+      host: "127.0.0.1",
+      strictPort: input.port !== 0,
+      fs: {
+        allow: [packageRoot, workspaceRoot, path.dirname(filePath)],
+      },
+    },
+    plugins: [
+      diffmapContentPlugin({ filePath, title }),
+      {
+        name: "diffmap-api",
+        configureServer(server) {
+          server.middlewares.use((req, res, next) => {
+            const url = req.url;
+            const pathname =
+              url === undefined
+                ? undefined
+                : new URL(url, "http://127.0.0.1").pathname;
+            if (
+              req.method === "GET" &&
+              (pathname === "/" ||
+                pathname === "/__diffmap/file" ||
+                pathname === "/__diffmap/definition" ||
+                pathname === "/__diffmap/source")
+            ) {
+              inactivityTimer?.refresh();
+            }
+            if (
+              req.method === "GET" &&
+              pathname === "/" &&
+              acceptsMarkdown(req.headers.accept)
+            ) {
+              // oxlint-disable-next-line typescript/no-floating-promises -- Connect middleware callbacks cannot await response handling.
+              void serveMarkdown({ filePath, res });
+              return;
+            }
+            if (url === undefined || !url.startsWith("/__diffmap")) {
+              next();
+              return;
+            }
+            // oxlint-disable-next-line typescript/no-floating-promises -- Connect middleware callbacks cannot await response handling.
+            void handleDiffmapRequest({
+              url,
+              method: req.method === undefined ? "GET" : req.method,
+              workspaceRoot,
+              title,
+              filePath,
+              shutdown,
+              res,
+            });
+          });
+        },
+      },
+    ],
+  });
+
+  await vite.listen(input.port);
+  const localUrl = vite.resolvedUrls?.local[0];
+  if (localUrl === undefined) {
+    await shutdown();
+    return new DiffmapServeError({ reason: "no listen url" });
+  }
+  const url = localUrl.replace(/\/$/, "");
+  const registered = await registerRunningDiffmap({
+    pid: process.pid,
+    title,
+    url,
+    file: filePath,
+  });
+  if (registered instanceof Error) {
+    await shutdown();
+    return registered;
+  }
+  registryPath = registered;
+  inactivityTimer = setTimeout(
+    () => {
+      // oxlint-disable-next-line typescript/no-floating-promises -- Timer callbacks cannot await shutdown.
+      void shutdown();
+    },
+    24 * 60 * 60 * 1_000,
+  );
+
+  process.once("SIGINT", () => {
+    // oxlint-disable-next-line typescript/no-floating-promises -- Process signal callbacks cannot await shutdown.
+    void shutdown();
+  });
+  process.once("SIGTERM", () => {
+    // oxlint-disable-next-line typescript/no-floating-promises -- Process signal callbacks cannot await shutdown.
+    void shutdown();
+  });
+
+  return {
+    url,
+    filePath,
+    shutdown,
+    closed: closedBarrier.closed,
+  };
+}
+
+type DiffmapResponse = {
+  statusCode: number;
+  setHeader: (name: string, value: string) => void;
+  end: (chunk: string) => void;
+};
+
+function acceptsMarkdown(accept: string | undefined) {
+  if (accept === undefined) return false;
+  return accept
+    .split(",")
+    .some(
+      (mediaRange) =>
+        mediaRange.trim().split(";", 1)[0]?.trim() === "text/markdown",
+    );
+}
+
+async function serveMarkdown(input: {
+  filePath: string;
+  res: DiffmapResponse;
+}) {
+  const source = await fs.readFile(input.filePath, "utf8").catch(
+    (cause) =>
+      new DiffmapFileError({
+        path: input.filePath,
+        reason: "read",
+        cause,
+      }),
+  );
+  if (source instanceof Error) {
+    input.res.statusCode = 500;
+    input.res.setHeader("content-type", "text/plain; charset=utf-8");
+    input.res.end(source.message);
+    return;
+  }
+  input.res.statusCode = 200;
+  input.res.setHeader("content-type", "text/markdown; charset=utf-8");
+  input.res.setHeader("vary", "Accept");
+  input.res.end(source);
+}
+
+async function handleDiffmapRequest(input: {
+  url: string;
+  method: string;
+  workspaceRoot: string;
+  title: string;
+  filePath: string;
+  shutdown: () => Promise<void>;
+  res: DiffmapResponse;
+}) {
+  const parsed = new URL(input.url, "http://127.0.0.1");
+  if (
+    (parsed.pathname === "/__diffmap/definition" ||
+      parsed.pathname === "/__diffmap/source") &&
+    input.method === "GET"
+  ) {
+    const definition =
+      parsed.pathname === "/__diffmap/source"
+        ? readSourceReference(input.workspaceRoot, parsed.searchParams)
+        : findDefinition(input.workspaceRoot, parsed.searchParams);
+    input.res.statusCode = definition instanceof Error ? 400 : 200;
+    input.res.setHeader("content-type", "application/json; charset=utf-8");
+    input.res.end(
+      JSON.stringify(
+        definition instanceof Error
+          ? { error: definition.message }
+          : { definition },
+      ),
+    );
+    return;
+  }
+  if (parsed.pathname === "/__diffmap/shutdown" && input.method === "POST") {
+    input.res.statusCode = 200;
+    input.res.setHeader("content-type", "text/plain; charset=utf-8");
+    input.res.end("ok");
+    setTimeout(() => {
+      // oxlint-disable-next-line typescript/no-floating-promises -- The response must finish before the delayed shutdown begins.
+      void input.shutdown();
+    }, 250);
+    return;
+  }
+  if (parsed.pathname === "/__diffmap/meta" && input.method === "GET") {
+    input.res.statusCode = 200;
+    input.res.setHeader("content-type", "application/json; charset=utf-8");
+    input.res.end(
+      JSON.stringify({
+        title: input.title,
+        file: input.filePath,
+        pid: process.pid,
+      }),
+    );
+    return;
+  }
+  if (parsed.pathname === "/__diffmap/file" && input.method === "GET") {
+    const excerpt = await readWorkspaceExcerpt({
+      workspaceRoot: input.workspaceRoot,
+      requestedPath: parsed.searchParams.get("path"),
+      start: parsed.searchParams.get("start"),
+      end: parsed.searchParams.get("end"),
+    });
+    if (excerpt instanceof Error) {
+      input.res.statusCode = 400;
+      input.res.setHeader("content-type", "application/json; charset=utf-8");
+      input.res.end(JSON.stringify({ error: excerpt.message }));
+      return;
+    }
+    input.res.statusCode = 200;
+    input.res.setHeader("content-type", "application/json; charset=utf-8");
+    input.res.end(JSON.stringify(excerpt));
+    return;
+  }
+  input.res.statusCode = 404;
+  input.res.end("not found");
+}
+
+export type FileExcerpt = {
+  path: string;
+  start: number;
+  end: number;
+  contents: string;
+};
+
+async function readWorkspaceExcerpt(input: {
+  workspaceRoot: string;
+  requestedPath: string | null;
+  start: string | null;
+  end: string | null;
+}) {
+  if (input.requestedPath === null || input.requestedPath.length === 0) {
+    return new DiffmapFileError({
+      path: "",
+      reason: "missing path",
+    });
+  }
+  const requestedPath = input.requestedPath;
+  const resolvedRoot = path.resolve(input.workspaceRoot);
+  const resolved = path.resolve(resolvedRoot, requestedPath);
+  const prefix = resolvedRoot.endsWith(path.sep)
+    ? resolvedRoot
+    : resolvedRoot + path.sep;
+  if (resolved !== resolvedRoot && !resolved.startsWith(prefix)) {
+    return new DiffmapFileError({
+      path: requestedPath,
+      reason: "path escapes workspace",
+    });
+  }
+  const contents = await fs.readFile(resolved, "utf8").catch(
+    (cause) =>
+      new DiffmapFileError({
+        path: requestedPath,
+        reason: "read",
+        cause,
+      }),
+  );
+  if (contents instanceof Error) return contents;
+  const lines = contents.split("\n");
+  const start = parseLine(input.start, 1);
+  const end = parseLine(input.end, lines.length);
+  return {
+    path: requestedPath,
+    start,
+    end,
+    contents: lines.slice(start - 1, end).join("\n"),
+  };
+}
+
+function parseLine(value: string | null, fallback: number) {
+  if (value === null || value.length === 0) return fallback;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1) return fallback;
+  return parsed;
+}

package/src/share.ts

@@ -0,0 +1,94 @@
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+import { DiffmapFileError, DiffmapShareError } from "./errors.js";
+import { extractTitle } from "./extractDocument.js";
+import { extractGistId, gistViewerUrl } from "./gist/route.ts";
+
+const execFileAsync = promisify(execFile);
+
+export type ShareResult = {
+  gistId: string;
+  gistUrl: string;
+  viewerUrl: string;
+};
+
+export async function shareMarkdownFile(input: {
+  filePath: string;
+  isPublic: boolean;
+}): Promise<ShareResult | DiffmapFileError | DiffmapShareError> {
+  const filePath = path.resolve(input.filePath);
+  const source = await fs.readFile(filePath, "utf8").catch(
+    (cause) =>
+      new DiffmapFileError({
+        path: filePath,
+        reason: "read",
+        cause,
+      }),
+  );
+  if (source instanceof Error) return source;
+
+  const auth = await runGh(["auth", "status"]);
+  if (auth instanceof DiffmapShareError) return auth;
+
+  const args = ["gist", "create"];
+  if (input.isPublic) args.push("--public");
+  args.push("--desc", extractTitle(source), filePath);
+
+  const created = await runGh(args);
+  if (created instanceof DiffmapShareError) return created;
+
+  const combined = `${created.stderr}\n${created.stdout}`;
+  const gistUrl = combined.match(/https:\/\/gist\.github\.com\/[^\s]+/)?.[0];
+  if (gistUrl === undefined) {
+    return new DiffmapShareError({
+      reason: "gh did not print a gist URL",
+    });
+  }
+  const gistId = extractGistId(gistUrl);
+  if (gistId === undefined) {
+    return new DiffmapShareError({
+      reason: `could not parse gist id from ${gistUrl}`,
+    });
+  }
+  return {
+    gistId,
+    gistUrl,
+    viewerUrl: gistViewerUrl(gistId, undefined, process.env.DIFFMAP_ORIGIN),
+  };
+}
+
+async function runGh(args: string[]) {
+  try {
+    return await execFileAsync("gh", args, {
+      encoding: "utf8",
+      maxBuffer: 10_000_000,
+    });
+  } catch (cause) {
+    if (isErrnoException(cause) && cause.code === "ENOENT") {
+      return new DiffmapShareError({
+        reason:
+          "gh is not installed. Install GitHub CLI and run gh auth login.",
+      });
+    }
+    const stderr = execStderr(cause);
+    if (stderr.length > 0) {
+      return new DiffmapShareError({ reason: stderr.trim() });
+    }
+    return new DiffmapShareError({
+      reason: cause instanceof Error ? cause.message : "gh failed",
+    });
+  }
+}
+
+function isErrnoException(cause: unknown): cause is NodeJS.ErrnoException {
+  if (typeof cause !== "object" || !cause) return false;
+  return "code" in cause && typeof cause.code === "string";
+}
+
+function execStderr(cause: unknown) {
+  if (typeof cause !== "object" || !cause) return "";
+  if (!("stderr" in cause) || typeof cause.stderr !== "string") return "";
+  return cause.stderr;
+}

package/src/viewer/CallStackDiff.tsx

@@ -0,0 +1,156 @@
+import { backgroundColor, colors, focusRing, spacing, text } from "maui";
+import { style, useStyles } from "purse-styles";
+import { codeFontFamily } from "../codeFont.js";
+import type { SourceAnnotation, SourceNavigation } from "../annotations.js";
+import { pierreShell } from "./pierre.js";
+
+export function CallStackDiff(
+  props: { lines: SourceAnnotation[] } & SourceNavigation,
+) {
+  const shell = useStyles(pierreShell, styles.shell);
+  const row = useStyles(styles.row);
+  return (
+    <div className={shell} data-diffmap-kind="callstack">
+      {props.lines.map((line, index) => {
+        const sign = line.text.startsWith("+")
+          ? "+"
+          : line.text.startsWith("-")
+            ? "-"
+            : " ";
+        const label = line.text.replace(/^[+ -]/, "");
+        const tree = /^[ \t│┃├└─]*/u.exec(label)![0];
+        const description = label.slice(tree.length);
+        const comment = description.indexOf("#");
+        const content = (
+          <>
+            <span className="diff-sign" aria-hidden="true">
+              {sign}
+            </span>
+            <span className="stack-content">
+              <span className="tree-prefix" aria-hidden="true">
+                {[...tree].map((branch, i) => (
+                  <span key={i} data-branch={branch} />
+                ))}
+              </span>
+              <span className="stack-label">
+                {comment === -1 ? description : description.slice(0, comment)}
+                {comment !== -1 && (
+                  <span className="stack-comment">
+                    {description.slice(comment)}
+                  </span>
+                )}
+              </span>
+            </span>
+            {line.references.length > 0 && (
+              <span className="source-indicator" aria-hidden="true">
+                ↗
+              </span>
+            )}
+          </>
+        );
+        if (line.references.length === 0) {
+          return (
+            <div key={index} className={row} data-change={sign}>
+              {content}
+            </div>
+          );
+        }
+        return (
+          <button
+            key={index}
+            type="button"
+            className={row}
+            data-change={sign}
+            aria-pressed={props.selectedAnnotation === line}
+            aria-controls="source-diff-panel"
+            title="Show source changes"
+            aria-label={description}
+            onClick={() => props.onSelectAnnotation(line)}
+          >
+            {content}
+          </button>
+        );
+      })}
+    </div>
+  );
+}
+
+const styles = {
+  shell: style(
+    text({ size: "sm", fontWeight: 500, color: "highContrast" }),
+    spacing.padding({ y: 2 }),
+    {
+      backgroundColor: backgroundColor.app,
+      overflowX: "auto",
+    },
+  ),
+  row: style(
+    spacing.padding({ x: 3 }),
+    {
+      display: "flex",
+      gap: "12px",
+      width: "100%",
+      minWidth: "max-content",
+      textAlign: "left",
+      font: "inherit",
+      lineHeight: "1.6",
+      whiteSpace: "pre",
+      color: "inherit",
+      background: "transparent",
+      border: 0,
+      "&[data-change='+']": { backgroundColor: colors.green[3] },
+      "&[data-change='-']": { backgroundColor: colors.red[3] },
+      "&[aria-pressed]": { cursor: "pointer" },
+      "&[aria-pressed]:hover": { backgroundColor: colors.blue[2] },
+      "&[aria-pressed='true'], &[aria-pressed='true']:hover": {
+        backgroundColor: colors.blue[3],
+        boxShadow: `inset 4px 0 ${colors.blue[9]}`,
+      },
+      "& .stack-content": {
+        display: "flex",
+        alignItems: "stretch",
+        minHeight: "28px",
+      },
+      "& .stack-label": { paddingBlock: "3px" },
+      "& .stack-comment": { color: colors.gray[11], fontWeight: 400 },
+      "& .tree-prefix": { display: "inline-flex", alignSelf: "stretch" },
+      "& [data-branch]": {
+        position: "relative",
+        width: "0.6em",
+        flexShrink: 0,
+      },
+      "& [data-branch='│']::before, & [data-branch='┃']::before, & [data-branch='├']::before, & [data-branch='└']::before":
+        {
+          content: "''",
+          position: "absolute",
+          left: "50%",
+          top: 0,
+          bottom: 0,
+          borderLeft: `1px solid ${colors.gray[9]}`,
+        },
+      "& [data-branch='└']::before": { bottom: "50%" },
+      "& [data-branch='├']::after, & [data-branch='└']::after, & [data-branch='─']::after":
+        {
+          content: "''",
+          position: "absolute",
+          left: "50%",
+          right: 0,
+          top: "50%",
+          borderTop: `1px solid ${colors.gray[9]}`,
+        },
+      "& [data-branch='─']::after": { left: 0 },
+      "& .tree-prefix, & .diff-sign": {
+        fontFamily: codeFontFamily,
+        whiteSpace: "pre",
+        flexShrink: 0,
+      },
+      "& > .diff-sign": { alignSelf: "center" },
+      "& > .source-indicator": {
+        alignSelf: "center",
+        marginLeft: "auto",
+        color: colors.blue[11],
+      },
+    },
+    focusRing(),
+  ),
+};

package/src/viewer/Check.tsx

@@ -0,0 +1,24 @@
+import type { SVGProps } from "react";
+
+export function Check(props: SVGProps<SVGSVGElement>) {
+  return (
+    <svg
+      focusable="false"
+      aria-hidden="true"
+      role="img"
+      width={24}
+      height={24}
+      fill="none"
+      viewBox="0 0 24 24"
+      {...props}
+    >
+      <path
+        stroke="currentColor"
+        strokeLinecap="round"
+        strokeLinejoin="round"
+        strokeWidth={1.5}
+        d="M5.75 12.5L10 16.75L18.25 7.25"
+      />
+    </svg>
+  );
+}

package/src/viewer/CodeDiff.tsx

@@ -0,0 +1,26 @@
+import { PatchDiff } from "@pierre/diffs/react";
+import { useTheme } from "maui";
+import { useStyles } from "purse-styles";
+import { toUnifiedDiff } from "../normalizeDiff.js";
+import { pierreDiffOptions, pierreShell } from "./pierre.ts";
+
+export function CodeDiff(props: { source: string; path?: string }) {
+  const { resolvedTheme } = useTheme();
+  const shell = useStyles(pierreShell);
+  const path = props.path === undefined ? "diff" : props.path;
+  const patch = toUnifiedDiff(props.source, path);
+  const disableFileHeader = props.path === undefined;
+
+  return (
+    <div className={shell} data-file-path={path} data-diffmap-kind="diff">
+      <PatchDiff
+        patch={patch}
+        disableWorkerPool
+        options={pierreDiffOptions({
+          themeType: resolvedTheme,
+          disableFileHeader,
+        })}
+      />
+    </div>
+  );
+}