lody 0.63.2 → 0.64.0

package/dist/chunks/{review-viewer-doJoIJ3d.js → review-viewer-DB_tqQOE.js}

@@ -1,14 +1,14 @@
 import { createHash } from "node:crypto";
 import { readFile, mkdir, writeFile, rename } from "node:fs/promises";
-import os__default from "node:os";
+import os from "node:os";
 import path__default from "node:path";
 import process from "node:process";
-const reviewViewerVersion = "0.63.2";
+const reviewViewerVersion = "0.64.0";
 const reviewViewerSha256 = "50ab599b652bdf4b959b539ea948454dd588703039bd4c5c037c7877ce10696f";
 const reviewViewerFileName = "standalone.html";
 const DEFAULT_CDN_BASES = ["https://cdn.jsdelivr.net/npm", "https://unpkg.com"];
 function cacheDir() {
-  return path__default.join(os__default.homedir(), ".lody", "code-review-viewer");
+  return path__default.join(os.homedir(), ".lody", "code-review-viewer");
 }
 function cachePath() {
   return path__default.join(cacheDir(), `${reviewViewerVersion}.html`);

package/dist/diff-worker.js

@@ -1,4 +1,4 @@
-import { c as computeLineCounts } from "./chunks/diff-line-counts-BLxwWP6r.js";
+import { c as computeLineCounts } from "./chunks/diff-line-counts-ftjiViPL.js";
 import "node:child_process";
 import "node:fs";
 import "node:os";

package/dist/file-index-scan-worker.js

@@ -0,0 +1,208 @@
+import { opendir } from "node:fs/promises";
+import path__default from "node:path";
+import { K as buildCodeCollabFileIndexState, M as scanGitDirectoryEntries, a6 as joinWorkspacePath, a7 as isInsideGitWorktree, J as computeAllChanges, a8 as pathSegmentComparisonKey, O as closeDirectoryQuietly } from "./chunks/directory-handle-GsTHlZO7.js";
+import "node:child_process";
+import "node:util";
+import "./chunks/diff-line-counts-ftjiViPL.js";
+import "node:fs";
+import "node:os";
+const DEFAULT_IGNORED_DIRECTORY_NAMES = /* @__PURE__ */ new Set([
+  ".git",
+  "node_modules",
+  ".next",
+  "dist",
+  "build",
+  "target"
+]);
+async function fileIndexScanWorker(input) {
+  if (input.kind === "full-state") {
+    return await computeFullFileIndexState(input);
+  }
+  const entries = await scanDirectoryEntries(input);
+  return { kind: "scan", entries: [...entries] };
+}
+async function computeFullFileIndexState(input) {
+  const startedAtMs = Date.now();
+  const allChangesResult = await resolveFullStateAllChanges(input);
+  if (allChangesResult.status !== "ok") {
+    return {
+      kind: "full-state",
+      status: "needs-provided-all-changes",
+      reason: allChangesResult.reason
+    };
+  }
+  const scanStartedAtMs = Date.now();
+  const fileTreeEntries = await scanDirectoryEntries({
+    directoryAbsolutePath: input.workspaceRoot,
+    directoryWorkspacePath: "",
+    maxRawTextBytes: input.maxRawTextBytes,
+    entryBudget: input.entryBudget,
+    recursive: true
+  });
+  const scanMs = Date.now() - scanStartedAtMs;
+  const fileTree = Object.fromEntries(fileTreeEntries);
+  const buildStartedAtMs = Date.now();
+  const fileIndex = buildCodeCollabFileIndexState(fileTree, allChangesResult.allChanges);
+  const buildMs = Date.now() - buildStartedAtMs;
+  return {
+    kind: "full-state",
+    status: "ok",
+    fileTreeEntries: [...fileTreeEntries],
+    allChanges: allChangesResult.allChanges,
+    fileIndex,
+    allChangesSource: allChangesResult.source,
+    changedPaths: Object.keys(allChangesResult.allChanges).length,
+    pathCount: Object.keys(fileIndex).length,
+    durationMs: Date.now() - startedAtMs,
+    scanMs,
+    allChangesMs: allChangesResult.allChangesMs,
+    buildMs
+  };
+}
+async function resolveFullStateAllChanges(input) {
+  if (input.providedAllChanges) {
+    return {
+      status: "ok",
+      source: input.providedAllChanges.source,
+      allChanges: input.providedAllChanges.state,
+      allChangesMs: input.providedAllChanges.computeMs
+    };
+  }
+  if (!await isInsideGitWorktree(input.workspaceRoot)) {
+    return { status: "needs-provided-all-changes", reason: "not-git" };
+  }
+  const allChangesStartedAtMs = Date.now();
+  const allChanges = await computeAllChanges(input.workspaceRoot, {
+    preferredBaseBranch: input.preferredBaseBranch
+  });
+  return {
+    status: "ok",
+    source: "git",
+    allChanges,
+    allChangesMs: Date.now() - allChangesStartedAtMs
+  };
+}
+async function scanDirectoryEntries(options) {
+  const gitEntries = await scanGitDirectoryEntries(options);
+  if (gitEntries) {
+    return gitEntries;
+  }
+  const entries = /* @__PURE__ */ new Map();
+  const queue = [
+    {
+      absolutePath: options.directoryAbsolutePath,
+      workspacePath: options.directoryWorkspacePath
+    }
+  ];
+  let remainingEntries = Math.max(0, options.entryBudget);
+  while (queue.length > 0 && remainingEntries > 0) {
+    const currentDirectory = queue.shift();
+    if (!currentDirectory) {
+      break;
+    }
+    const directoryEntries = await readDirectoryEntriesForScan(currentDirectory).catch(
+      (error) => {
+        if (currentDirectory.workspacePath === options.directoryWorkspacePath) {
+          throw error;
+        }
+        entries.set(currentDirectory.workspacePath, scanDirectoryReadErrorValue(error));
+        return null;
+      }
+    );
+    if (!directoryEntries) {
+      continue;
+    }
+    const collisionKeys = findDirectoryEntryCollisionKeys(directoryEntries);
+    for (const { entry, comparisonKey } of directoryEntries) {
+      if (remainingEntries <= 0) {
+        break;
+      }
+      const workspacePath = joinWorkspacePath(currentDirectory.workspacePath, entry.name);
+      const absolutePath = path__default.join(currentDirectory.absolutePath, entry.name);
+      const value = collisionKeys.has(comparisonKey) ? { kind: "skipped", reason: "path_conflict" } : classifyDirectoryEntry(entry);
+      if (value === void 0) {
+        continue;
+      }
+      entries.set(workspacePath, value);
+      remainingEntries -= 1;
+      if (options.recursive && isLazyDirectoryValue(value) && remainingEntries > 0) {
+        queue.push({ absolutePath, workspacePath });
+      }
+    }
+  }
+  return entries;
+}
+function scanDirectoryReadErrorValue(error) {
+  const code = errorCode(error);
+  if (code === "EACCES" || code === "EPERM") {
+    return { kind: "skipped", reason: "permission_denied" };
+  }
+  if (code === "ENOENT" || code === "ENOTDIR") {
+    return { kind: "skipped", reason: "not_found" };
+  }
+  return { kind: "skipped", reason: "transient_io" };
+}
+function errorCode(error) {
+  if (!error || typeof error !== "object" || !("code" in error)) {
+    return void 0;
+  }
+  const code = error.code;
+  return typeof code === "string" ? code : void 0;
+}
+async function readDirectoryEntriesForScan(directoryPath) {
+  const directory = await opendir(directoryPath.absolutePath);
+  try {
+    const directoryEntries = [];
+    for await (const entry of directory) {
+      if (entry.name === "." || entry.name === "..") {
+        continue;
+      }
+      directoryEntries.push({
+        entry,
+        comparisonKey: pathSegmentComparisonKey(entry.name)
+      });
+    }
+    return directoryEntries.sort((left, right) => {
+      const keyOrder = left.comparisonKey.localeCompare(right.comparisonKey);
+      return keyOrder === 0 ? left.entry.name.localeCompare(right.entry.name) : keyOrder;
+    });
+  } finally {
+    await closeDirectoryQuietly(directory);
+  }
+}
+function classifyDirectoryEntry(entry) {
+  if (entry.isDirectory()) {
+    return DEFAULT_IGNORED_DIRECTORY_NAMES.has(entry.name) ? void 0 : { kind: "lazy" };
+  }
+  if (entry.isSymbolicLink()) {
+    return { kind: "skipped", reason: "symlink" };
+  }
+  if (!entry.isFile()) {
+    return { kind: "skipped", reason: "special" };
+  }
+  return true;
+}
+function findDirectoryEntryCollisionKeys(entries) {
+  const namesByKey = /* @__PURE__ */ new Map();
+  for (const { entry, comparisonKey } of entries) {
+    const names = namesByKey.get(comparisonKey);
+    if (names) {
+      names.add(entry.name);
+    } else {
+      namesByKey.set(comparisonKey, /* @__PURE__ */ new Set([entry.name]));
+    }
+  }
+  const collisionKeys = /* @__PURE__ */ new Set();
+  for (const [comparisonKey, names] of namesByKey) {
+    if (names.size > 1) {
+      collisionKeys.add(comparisonKey);
+    }
+  }
+  return collisionKeys;
+}
+function isLazyDirectoryValue(value) {
+  return value !== void 0 && value !== true && value.kind === "lazy";
+}
+export {
+  fileIndexScanWorker as default
+};