@duckmind/dm-darwin-x64 0.66.4 → 0.66.6

package/extensions/dm-lens/clients/review-graph/builder.js

@@ -5,6 +5,7 @@ import { Worker } from "node:worker_threads";
 import { constants as zlibConstants, gunzipSync, gzipSync } from "node:zlib";
 import { fileURLToPath } from "node:url";
 import { writeFileAtomic } from "../atomic-write.js";
+import { FactStore } from "../dispatch/fact-store.js";
 import { fileContentProvider } from "../dispatch/facts/file-content.js";
 import { lazyEnvNumber } from "../env-utils.js";
 import { featureHintMetadata } from "../feature-hints.js";
@@ -12,7 +13,7 @@ import { detectFileKind, KIND_EXTENSIONS } from "../file-kinds.js";
 import { detectFileRole } from "../file-role.js";
 import { getProjectDataDir } from "../file-utils.js";
 import { collectUntrackedIgnoredIds } from "../git-tracked-ignore.js";
-import { realIsPidAlive } from "../instance-reaper.js";
+import { isStaleStageFile } from "../instance-reaper.js";
 import { logLatency } from "../latency-logger.js";
 import {
   containerNameChain,
@@ -21,6 +22,7 @@ import {
 } from "../lsp-document-symbols.js";
 import {
   isAtOrAboveHomeDir,
+  isUnderDir,
   normalizeFilePath,
   normalizeMapKey,
   toProjectRelativePath
@@ -49,6 +51,9 @@ import {
   makeReviewGraphBuildMetadata
 } from "../review-graph-logger.js";
 import { getSharedTreeSitterClient } from "../tree-sitter-shared.js";
+import {
+  classifyTreeSitterWasmError
+} from "../tree-sitter-client.js";
 import {
   symbolExtractionGrammar,
   TreeSitterSymbolExtractor
@@ -63,6 +68,9 @@ import {
   formatReviewGraphRevisionDriftNote
 } from "./revision-drift.js";
 import { buildSymbolId } from "./symbol-id.js";
+import {
+  readWorkerHeapStatistics
+} from "../persist-worker-stats.js";
 import {
   clearReviewGraphFileIr,
   getFreshReviewGraphFileIr,
@@ -175,6 +183,39 @@ function touchWorkspaceGraph(key) {
   entry.lastUsedAt = Date.now();
   scheduleWorkspaceGraphEviction(key, entry);
 }
+const _wasmTrappedFiles = new Map;
+function stampWasmTrapped(entries, includeCharged) {
+  let stamped;
+  for (const [file, state] of _wasmTrappedFiles) {
+    if ((includeCharged || state === "retry") && entries.has(file)) {
+      stamped ??= new Map(entries);
+      stamped.set(file, "wasm-trapped");
+    }
+  }
+  return stamped ?? entries;
+}
+function stampWasmTrappedFiles(stored, includeCharged) {
+  const fileSignatures = stampWasmTrapped(stored.fileSignatures, includeCharged);
+  if (fileSignatures === stored.fileSignatures)
+    return stored;
+  return {
+    ...stored,
+    signature: sourceSignatureFromMap(fileSignatures),
+    fileSignatures,
+    fileHashes: stored.fileHashes && stampWasmTrapped(stored.fileHashes, includeCharged)
+  };
+}
+function wasmTrappedFileCount(graph) {
+  let count = 0;
+  for (const file of _wasmTrappedFiles.keys()) {
+    if (graph.fileNodes.has(file))
+      count++;
+  }
+  return count;
+}
+export function graphWasmTrapDetail(wasmTrappedFiles) {
+  return `review graph degraded — tree-sitter wasm runtime failure in ${wasmTrappedFiles} file(s)`;
+}
 function setWorkspaceGraph(key, entry, epoch) {
   if (epoch !== undefined && workspaceCacheEpoch(key) !== epoch)
     return false;
@@ -183,7 +224,7 @@ function setWorkspaceGraph(key, entry, epoch) {
     clearWorkspaceGraphTimer(previous);
   const boundedGraph = retainedGraph(key, entry.graph);
   const resident = {
-    ...entry,
+    ...stampWasmTrappedFiles(entry, false),
     graph: boundedGraph,
     lastUsedAt: Date.now()
   };
@@ -990,6 +1031,20 @@ let _persistAttemptId = 0;
 let _workerDisabled = false;
 let _persistWorkerUnavailableReason;
 let _lastWorkerFallbackReasonForTests;
+let _persistWorkerHeapStatistics = null;
+export function refreshReviewGraphPersistWorkerHeapStatistics() {
+  const worker = _persistWorker;
+  if (!worker || typeof worker.getHeapStatistics !== "function") {
+    return Promise.resolve();
+  }
+  return readWorkerHeapStatistics(worker).then((stats) => {
+    if (_persistWorker === worker)
+      _persistWorkerHeapStatistics = stats;
+  }).catch(() => {});
+}
+export function getReviewGraphPersistWorkerHeapStatistics() {
+  return _persistWorkerHeapStatistics;
+}
 const _checkpointGenerations = new Map;
 const _checkpointWorkerRequests = new Map;
 let _checkpointOffloadCountForTests = 0;
@@ -1299,6 +1354,7 @@ function handleCheckpointWorkerResult(cp, result) {
 function handleWorkerDeath(reason) {
   _persistWorkerUnavailableReason = reason;
   _persistWorker = undefined;
+  _persistWorkerHeapStatistics = null;
   _workerDisabled = true;
   const requests = [..._workerRequests.values()];
   _workerRequests.clear();
@@ -1339,7 +1395,8 @@ function handleWorkerDeath(reason) {
 function resolvePersistWorkerPath() {
   const candidates = [
     new URL("./persist-worker.js", import.meta.url),
-    new URL("./clients/review-graph/persist-worker.js", import.meta.url)
+    new URL("./workers/review-graph-persist-worker.js", import.meta.url),
+    new URL("../workers/review-graph-persist-worker.js", import.meta.url)
   ];
   for (const url of candidates) {
     try {
@@ -1372,6 +1429,7 @@ function getPersistWorker() {
         handleWorkerDeath(code !== 0 ? `persist worker exited with code ${code}` : "persist worker exited with pending requests");
       } else {
         _persistWorker = undefined;
+        _persistWorkerHeapStatistics = null;
       }
     });
     worker.unref();
@@ -1439,18 +1497,6 @@ function ensurePersistExitHook() {
 }
 const _sweptStageDirs = new Set;
 const REVIEW_GRAPH_ARTIFACT_PREFIX = "review-graph.";
-const STAGE_PID_PATTERN = /\.stage-(\d+)-/;
-function isStaleReviewGraphStageFile(entry) {
-  if (!entry.startsWith(REVIEW_GRAPH_ARTIFACT_PREFIX))
-    return false;
-  const match = STAGE_PID_PATTERN.exec(entry);
-  if (!match)
-    return false;
-  const pid = Number(match[1]);
-  if (pid === process.pid)
-    return false;
-  return !realIsPidAlive(pid);
-}
 function sweepStaleStageFiles(cacheDir) {
   if (_sweptStageDirs.has(cacheDir))
     return;
@@ -1459,7 +1505,7 @@ function sweepStaleStageFiles(cacheDir) {
     if (err)
       return;
     for (const entry of entries) {
-      if (!isStaleReviewGraphStageFile(entry))
+      if (!isStaleStageFile(entry, REVIEW_GRAPH_ARTIFACT_PREFIX))
         continue;
       fs.rm(path.join(cacheDir, entry), { force: true }, () => {});
     }
@@ -1534,9 +1580,7 @@ function persistGraph(cwd, signature, fileSignatures, fileHashes, graph, options
   const pending = {
     cacheDir,
     cachePath,
-    signature,
-    fileSignatures,
-    fileHashes,
+    ...stampWasmTrappedFiles({ signature, fileSignatures, fileHashes }, true),
     graph: persistedGraph,
     gitStamp,
     elementCount,
@@ -1624,7 +1668,7 @@ function buildReviewGraphCheckpointData(cwd, graph, processedHashes, targetFileC
     builtAt: new Date().toISOString(),
     inProgress: true,
     targetFileCount,
-    processedFiles: Array.from(processedHashes.entries()),
+    processedFiles: Array.from(stampWasmTrapped(processedHashes, true)),
     ignoredIdsHash: hashIgnoredIds(ignoredIds),
     nodes: Array.from(graph.nodes.entries()),
     edges: graph.edges,
@@ -1909,6 +1953,7 @@ export async function terminateReviewGraphPersistWorkerForTests() {
 export function resetReviewGraphPersistWorkerForTests() {
   _workerDisabled = false;
   _persistWorker = undefined;
+  _persistWorkerHeapStatistics = null;
   _persistWorkerUnavailableReason = undefined;
   _lastWorkerFallbackReasonForTests = undefined;
   _checkpointWorkerRequests.clear();
@@ -1955,6 +2000,25 @@ export function flushReviewGraphPersist(cwd, source = "cli") {
       })
     });
   }
+  const currentGeneration = _persistGenerations.get(key);
+  if (pending && pending.generation !== currentGeneration) {
+    logReviewGraph({
+      cwd: key,
+      phase: "persist_skipped",
+      reason: "superseded",
+      observability: persistObservability(pending, {
+        status: "superseded",
+        supersededByGeneration: currentGeneration,
+        reason: "forced_flush_superseded",
+        workerStarted: true,
+        workerCompleted: false
+      })
+    });
+    return {
+      ok: false,
+      reason: `queued snapshot generation ${pending.generation} was superseded by generation ${currentGeneration}`
+    };
+  }
   if (!pending) {
     return {
       ok: false,
@@ -2044,10 +2108,11 @@ function localImportToFile(cwd, filePath, source, ignoredIds) {
   }
   const root = path.resolve(cwd);
   for (const candidate of jsTsCandidatePaths(filePath, source)) {
-    const relative = path.relative(root, candidate);
-    if (relative.startsWith("..") && (relative.length === 2 || relative.startsWith(`..${path.sep}`)) || path.isAbsolute(relative) || !fs.existsSync(candidate))
+    if (!fs.existsSync(candidate))
       continue;
     const normalized = normalizeMapKey(candidate);
+    if (!isUnderDir(normalized, root))
+      continue;
     if (ignoredIds?.has(normalized))
       continue;
     return normalized;
@@ -2316,19 +2381,23 @@ async function extractTreeSitterSymbols(filePath, languageId, contentOverride) {
   if (!extractor)
     return empty;
   const content = contentOverride ?? fs.readFileSync(filePath, "utf-8");
-  const extracted = await treeSitterClient.withParsedTree(filePath, languageId, content, (tree) => extractor.extract(tree, filePath, content));
-  return extracted.parsed ? extracted.value : empty;
+  const extracted = await treeSitterClient.withParsedTree(filePath, languageId, content, (tree) => extractor.extract(tree, filePath, content), "review-graph");
+  return extracted.parsed ? extracted.value : { ...empty, wasmTrap: extracted.wasmTrap };
 }
-export async function captureReviewGraphStructuralIr(filePath, cwd, content, facts) {
+export async function captureReviewGraphStructuralIr(filePath, cwd, content, borrowed) {
   const kind = detectFileKind(filePath);
   if (!kind || !MAIN_KINDS.has(kind) || detectFileRole(filePath) === "test") {
     return { complete: true };
   }
   if (kind === "jsts") {
-    if (!facts.hasFileFact(filePath, "file.imports") || !facts.hasFileFact(filePath, "file.reexports") || !facts.hasFileFact(filePath, "file.functionSummaries")) {
-      await ensureReviewGraphFacts(filePath, cwd, facts, content);
-    }
-    const parsed = await withTreeSitterRoot(filePath, content, () => true);
+    const borrowable = borrowed.hasFileFact(filePath, "file.imports") && borrowed.hasFileFact(filePath, "file.reexports") && borrowed.hasFileFact(filePath, "file.functionSummaries") && borrowed.getFileFact(filePath, "file.content") === content;
+    let facts = borrowed;
+    if (!borrowable) {
+      const run = new FactStore("review-graph-run");
+      await ensureReviewGraphFacts(filePath, cwd, run, content);
+      facts = run;
+    }
+    const parsed = await withTreeSitterRoot(filePath, content, () => true, "review-graph-ir");
     if (!parsed.parsed)
       return { complete: false };
     const functionCoverage = facts.getFileFact(filePath, "file.functionFactsCoverage") ?? "unavailable";
@@ -2362,7 +2431,7 @@ export async function captureReviewGraphStructuralIr(filePath, cwd, content, fac
   const extractor = await getExtractor(languageId);
   if (!extractor)
     return { complete: false };
-  const result = await client.withParsedTree(filePath, languageId, content, (tree) => extractor.extract(tree, filePath, content));
+  const result = await client.withParsedTree(filePath, languageId, content, (tree) => extractor.extract(tree, filePath, content), "review-graph");
   if (!result.parsed)
     return { complete: false };
   return {
@@ -2693,7 +2762,7 @@ function removeFileOwnedGraphData(graph, filePath, removedEdges) {
   }
   return preservedIncomingSymbolEdges;
 }
-async function addFileToGraph(graph, cwd, file, facts, ignoredIds, contentOverride) {
+async function addFileToGraph(graph, cwd, file, ignoredIds, contentOverride) {
   const kind = detectFileKind(file);
   if (!kind || !MAIN_KINDS.has(kind))
     return;
@@ -2702,23 +2771,17 @@ async function addFileToGraph(graph, cwd, file, facts, ignoredIds, contentOverri
   const contentHash = typeof contentOverride === "string" ? reviewGraphIrContentHash(contentOverride) : undefined;
   const sharedIr = contentHash ? getFreshReviewGraphFileIr(cwd, file, contentHash)?.structural : undefined;
   if (kind === "jsts") {
-    const dispatchOwnsContent = facts.getFileFact(file, "file.content") !== undefined && contentOverride == null;
-    try {
-      if (sharedIr?.kind === "jsts") {
-        facts.setFileFact(file, "file.content", contentOverride ?? "");
-        facts.setFileFact(file, "file.imports", sharedIr.imports);
-        facts.setFileFact(file, "file.reexports", sharedIr.reexports);
-        facts.setFileFact(file, "file.functionSummaries", sharedIr.functionSummaries);
-        facts.setFileFact(file, "file.functionFactsCoverage", sharedIr.coverage.calls);
-        facts.setFileFact(file, "file.importFactsCoverage", sharedIr.coverage.imports);
-      } else {
-        await ensureReviewGraphFacts(file, cwd, facts, contentOverride);
-      }
-      addJsTsFile(graph, cwd, file, facts, ignoredIds);
-    } finally {
-      if (!dispatchOwnsContent)
-        facts.deleteFileFact(file, "file.content");
+    const run = new FactStore("review-graph-run");
+    if (sharedIr?.kind === "jsts") {
+      run.setFileFact(file, "file.content", contentOverride ?? "");
+      run.setFileFact(file, "file.imports", sharedIr.imports);
+      run.setFileFact(file, "file.functionSummaries", sharedIr.functionSummaries);
+      run.setFileFact(file, "file.functionFactsCoverage", sharedIr.coverage.calls);
+      run.setFileFact(file, "file.importFactsCoverage", sharedIr.coverage.imports);
+    } else {
+      await ensureReviewGraphFacts(file, cwd, run, contentOverride);
     }
+    addJsTsFile(graph, cwd, file, run, ignoredIds);
     return;
   }
   const languageId = mapKindToTreeSitterLanguage(kind, file);
@@ -2726,6 +2789,10 @@ async function addFileToGraph(graph, cwd, file, facts, ignoredIds, contentOverri
     return;
   const irExtracted = sharedIr?.kind === "tree-sitter" && sharedIr.languageId === languageId ? sharedIr.extracted : undefined;
   const extracted = irExtracted ?? await extractTreeSitterSymbols(file, languageId, contentOverride);
+  if (extracted.wasmTrap)
+    _wasmTrappedFiles.set(file, extracted.wasmTrap);
+  else
+    _wasmTrappedFiles.delete(file);
   addTreeSitterFile(graph, cwd, file, languageId, extracted, ignoredIds);
   if (extracted.symbols.length === 0) {
     const lspSymbols = await getOpenDocumentSymbols(file);
@@ -2838,7 +2905,7 @@ async function updateGraphFiles(graph, cwd, files, facts, ignoredIds) {
   const removedEdges = new Set;
   for (const file of files) {
     preservedIncoming.push(...removeFileOwnedGraphData(graph, file, removedEdges));
-    await addFileToGraph(graph, cwd, file, facts, ignoredIds);
+    await addFileToGraph(graph, cwd, file, ignoredIds);
   }
   if (removedEdges.size > 0) {
     unindexEdges(graph, removedEdges);
@@ -3030,6 +3097,10 @@ async function trySeqFastpath(cwd, buildId, normalizedCwd, normalizedChanged, fa
   const changedSet = new Set(seqHint.getFilesChangedSince(cached.builtAtProjectSeq).map((file) => normalizeMapKey(file)));
   for (const file of normalizedChanged)
     changedSet.add(file);
+  for (const file of _wasmTrappedFiles.keys()) {
+    if (cached.fileSignatures.has(file))
+      changedSet.add(file);
+  }
   const changed = [...changedSet];
   if (changed.length > SEQ_FASTPATH_MAX_CHANGES) {
     return { fallback: "too-many-changes" };
@@ -3055,6 +3126,7 @@ async function trySeqFastpath(cwd, buildId, normalizedCwd, normalizedChanged, fa
     }
     candidateFiles.push(file);
   }
+  const candidateStats = candidateFiles.map((file) => [file, sourceSignatureEntry(file)]);
   const { trulyChanged, hashes } = await confirmContentChanged(candidateFiles, cached.fileHashes);
   if (trulyChanged.length === 0) {
     const graph = cloneGraph(cached.graph);
@@ -3064,8 +3136,8 @@ async function trySeqFastpath(cwd, buildId, normalizedCwd, normalizedChanged, fa
       upsertChangedSymbols(graph, facts, file);
     }
     const nextSignatures = new Map(cached.fileSignatures);
-    for (const file of candidateFiles) {
-      nextSignatures.set(file, sourceSignatureEntry(file));
+    for (const [file, stat] of candidateStats) {
+      nextSignatures.set(file, stat);
     }
     cached.signature = sourceSignatureFromMap(nextSignatures);
     cached.fileSignatures = nextSignatures;
@@ -3093,8 +3165,8 @@ async function trySeqFastpath(cwd, buildId, normalizedCwd, normalizedChanged, fa
   }
   refreshGraphBuiltAt(graph);
   const nextSignatures = new Map(cached.fileSignatures);
-  for (const file of candidateFiles) {
-    nextSignatures.set(file, sourceSignatureEntry(file));
+  for (const [file, stat] of candidateStats) {
+    nextSignatures.set(file, stat);
   }
   const nextSignature = sourceSignatureFromMap(nextSignatures);
   const generation = ++_graphGenerationCounter;
@@ -3344,7 +3416,7 @@ async function _doBuildGraph(cwd, changedFiles, facts, seqHint, buildId) {
         content = null;
         fileHashes.set(file, "missing");
       }
-      await addFileToGraph(graph, cwd, file, facts, ignoredIds, content);
+      await addFileToGraph(graph, cwd, file, ignoredIds, content);
       if (normalizedChangedSet.has(file)) {
         upsertChangedSymbols(graph, facts, file);
       }
@@ -3467,7 +3539,11 @@ export function buildOrUpdateGraph(cwd, changedFiles, facts, seqHint) {
     }
   });
   const promise = _doBuildGraph(cwd, changedFiles, facts, seqHint, buildId).then((graph) => {
-    const buildInfo = getGraphBuildInfoForGraph(graph);
+    let buildInfo = getGraphBuildInfoForGraph(graph);
+    const wasmTrappedFiles = wasmTrappedFileCount(graph);
+    if (wasmTrappedFiles > 0) {
+      buildInfo = updateGraphBuildInfo(graph, { wasmTrappedFiles });
+    }
     if (buildInfo.mode === "skipped") {
       const reason = buildInfo.skipReason ?? "skipped";
       recordBuildAttempt(cwd, "skipped", reason, buildId);
@@ -3514,10 +3590,12 @@ export function buildOrUpdateGraph(cwd, changedFiles, facts, seqHint) {
     return graph;
   }).catch((err) => {
     const reason = err instanceof Error ? err.message : String(err);
+    const wasmFailure = classifyTreeSitterWasmError(err);
     recordBuildAttempt(cwd, "failed", reason, buildId);
     logReviewGraph({
       cwd,
       phase: "build_failed",
+      failureClass: wasmFailure ? `wasm-${wasmFailure}` : "error",
       reason,
       durationMs: Date.now() - startedAt,
       error: reason,

package/extensions/dm-lens/clients/review-graph/git-identity.js

@@ -1,6 +1,12 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { normalizeFilePath, walkUpDirs } from "../path-utils.js";
+import { dirname, join, resolve } from "node:path";
+import {
+  isUnderDir,
+  normalizeFilePath,
+  pathsEqual,
+  walkUpDirs
+} from "../path-utils.js";
 export function createGitIdentityResolver() {
   const memo = new Map;
   return (cwd) => {
@@ -71,6 +77,58 @@ function getResolvedGitDir(cwd) {
   }
   return resolved;
 }
+export function canonicalDirectory(dir) {
+  try {
+    return fs.realpathSync.native(dir);
+  } catch {
+    return dir;
+  }
+}
+export function resolveGitCheckout(startPath) {
+  const resolved = getResolvedGitDir(startPath);
+  return resolved ? {
+    root: canonicalDirectory(resolved.worktreeRoot),
+    spelledRoot: resolved.worktreeRoot,
+    commonDir: canonicalDirectory(resolved.commonDir)
+  } : null;
+}
+export function resolveLinkedWorktreeOwner(session, absoluteFile) {
+  const owner = resolveGitCheckout(dirname(absoluteFile));
+  return owner !== null && !pathsEqual(owner.root, session.root) && pathsEqual(owner.commonDir, session.commonDir) ? owner : null;
+}
+export function listLinkedWorktreeRoots(commonDir) {
+  const roots = [];
+  let names;
+  try {
+    names = fs.readdirSync(join(commonDir, "worktrees"));
+  } catch {
+    return roots;
+  }
+  for (const name of names) {
+    try {
+      const entryDir = join(commonDir, "worktrees", name);
+      const gitFile = fs.readFileSync(join(entryDir, "gitdir"), "utf-8").trim();
+      if (gitFile) {
+        const root = canonicalDirectory(dirname(resolve(entryDir, gitFile)));
+        if (fs.existsSync(join(root, ".git")))
+          roots.push(root);
+      }
+    } catch {}
+  }
+  return roots;
+}
+export function listNestedLinkedWorktreeRoots(scanRoot) {
+  const checkout = resolveGitCheckout(scanRoot);
+  if (!checkout)
+    return [];
+  const base = canonicalDirectory(scanRoot);
+  const nested = [];
+  for (const root of listLinkedWorktreeRoots(checkout.commonDir)) {
+    if (!pathsEqual(root, base) && isUnderDir(root, base))
+      nested.push(root);
+  }
+  return nested;
+}
 function resolveRefToSha(commonDir, ref) {
   try {
     const loose = fs.readFileSync(path.join(commonDir, ref), "utf-8").trim();

package/extensions/dm-lens/clients/review-graph/import-resolvers.js

@@ -1,15 +1,13 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { normalizeMapKey } from "../path-utils.js";
+import { isUnderDir, normalizeMapKey } from "../path-utils.js";
 import {
   aliasedImportTargets,
   referencedProjectImportTarget
 } from "./tsconfig-paths.js";
 import { buildModuleGraph } from "./workspace-modules.js";
 function isWithin(cwd, p) {
-  const root = path.resolve(cwd);
-  const rp = path.resolve(p);
-  return rp === root || rp.startsWith(root + path.sep);
+  return isUnderDir(path.resolve(p), path.resolve(cwd));
 }
 function isFile(p) {
   try {
@@ -27,13 +25,13 @@ function isDir(p) {
 }
 function firstExistingFile(cwd, candidates) {
   for (const c of candidates) {
-    if (isWithin(cwd, c) && isFile(c))
+    if (isFile(c) && isWithin(cwd, c))
       return [normalizeMapKey(c)];
   }
   return [];
 }
 function sourceFilesIn(cwd, dir, ext) {
-  if (!isWithin(cwd, dir) || !isDir(dir))
+  if (!isDir(dir) || !isWithin(cwd, dir))
     return [];
   try {
     return fs.readdirSync(dir).filter((n) => n.endsWith(ext)).map((n) => normalizeMapKey(path.join(dir, n))).sort();
@@ -192,7 +190,7 @@ function resolveCxx(cwd, filePath, source) {
 function pythonRoots(cwd, fileDir) {
   let p = fileDir;
   const root = path.resolve(cwd);
-  while (isWithin(cwd, p) && isFile(path.join(p, "__init__.py"))) {
+  while (isFile(path.join(p, "__init__.py")) && isWithin(cwd, p)) {
     const parent = path.dirname(p);
     if (parent === p)
       break;
@@ -236,7 +234,7 @@ function findGoModule(cwd, filePath) {
   while (true) {
     try {
       const content = fs.readFileSync(path.join(dir, "go.mod"), "utf-8");
-      const m = content.match(/^\s*module\s+(\S+)/m);
+      const m = content.match(/^[^\S\n\r\u2028\u2029]*module\s+(\S+)/m);
       if (m)
         return { moduleDir: dir, modulePath: m[1] };
     } catch {}