@patchstack/connect 0.2.7 → 0.2.9

package/dist/index.cjs

@@ -47,8 +47,8 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/parsers/index.ts
-var import_promises5 = require("fs/promises");
-var import_node_path4 = __toESM(require("path"), 1);
+var import_promises6 = require("fs/promises");
+var import_node_path5 = __toESM(require("path"), 1);
 
 // src/types.ts
 var PatchstackError = class extends Error {
@@ -62,13 +62,52 @@ var PatchstackError = class extends Error {
   cause;
 };
 
-// src/parsers/npm.ts
+// src/parsers/consistency.ts
 var import_promises = require("fs/promises");
 var import_node_path = __toESM(require("path"), 1);
+async function readDeclaredDependencyNames(cwd) {
+  let raw;
+  try {
+    raw = await (0, import_promises.readFile)(import_node_path.default.join(cwd, "package.json"), "utf8");
+  } catch {
+    return [];
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return [];
+  }
+  const names = /* @__PURE__ */ new Set();
+  for (const group of ["dependencies", "devDependencies"]) {
+    const deps = parsed[group];
+    if (typeof deps !== "object" || deps === null) {
+      continue;
+    }
+    for (const [name, spec] of Object.entries(deps)) {
+      if (typeof spec === "string" && /^(file|link|workspace|portal):/.test(spec)) {
+        continue;
+      }
+      names.add(name);
+    }
+  }
+  return [...names];
+}
+function missingDependencies(declared, packages) {
+  const present = new Set(packages.map((entry) => entry.name));
+  return declared.filter((name) => !present.has(name));
+}
+
+// src/parsers/npm.ts
+var import_promises2 = require("fs/promises");
+var import_node_path2 = __toESM(require("path"), 1);
 async function parseNpmLockfile(lockfilePath) {
   let raw;
   try {
-    raw = await (0, import_promises.readFile)(lockfilePath, "utf8");
+    raw = await (0, import_promises2.readFile)(lockfilePath, "utf8");
   } catch (cause) {
     throw new PatchstackError(`Could not read lockfile at ${lockfilePath}`, "LOCKFILE_NOT_FOUND", cause);
   }
@@ -126,7 +165,7 @@ function extractFromV1(deps, acc = [], depth = 0) {
   return acc;
 }
 function extractNameFromPath(pkgPath) {
-  const segments = pkgPath.split("node_modules" + import_node_path.default.sep === pkgPath ? import_node_path.default.sep : "/");
+  const segments = pkgPath.split("node_modules" + import_node_path2.default.sep === pkgPath ? import_node_path2.default.sep : "/");
   const parts = pkgPath.split("/");
   const nmIndex = parts.lastIndexOf("node_modules");
   if (nmIndex === -1 || nmIndex >= parts.length - 1) {
@@ -149,12 +188,12 @@ function isDirectV2(pkgPath) {
 }
 
 // src/parsers/node_modules.ts
-var import_promises2 = require("fs/promises");
-var import_node_path2 = __toESM(require("path"), 1);
+var import_promises3 = require("fs/promises");
+var import_node_path3 = __toESM(require("path"), 1);
 async function walkNodeModules(cwd) {
-  const root = import_node_path2.default.join(cwd, "node_modules");
+  const root = import_node_path3.default.join(cwd, "node_modules");
   try {
-    const info = await (0, import_promises2.stat)(root);
+    const info = await (0, import_promises3.stat)(root);
     if (!info.isDirectory()) {
       throw new PatchstackError(
         `${root} exists but is not a directory.`,
@@ -178,7 +217,7 @@ async function walkNodeModules(cwd) {
 async function walk(dir, acc, depth) {
   let names;
   try {
-    names = await (0, import_promises2.readdir)(dir);
+    names = await (0, import_promises3.readdir)(dir);
   } catch {
     return;
   }
@@ -186,14 +225,14 @@ async function walk(dir, acc, depth) {
     if (name.startsWith(".")) {
       continue;
     }
-    const fullPath = import_node_path2.default.join(dir, name);
+    const fullPath = import_node_path3.default.join(dir, name);
     if (!await isPlainDirectory(fullPath)) {
       continue;
     }
     if (name.startsWith("@")) {
       let subNames;
       try {
-        subNames = await (0, import_promises2.readdir)(fullPath);
+        subNames = await (0, import_promises3.readdir)(fullPath);
       } catch {
         continue;
       }
@@ -201,7 +240,7 @@ async function walk(dir, acc, depth) {
         if (sub.startsWith(".")) {
           continue;
         }
-        const scopedDir = import_node_path2.default.join(fullPath, sub);
+        const scopedDir = import_node_path3.default.join(fullPath, sub);
         if (!await isPlainDirectory(scopedDir)) {
           continue;
         }
@@ -217,7 +256,7 @@ async function walk(dir, acc, depth) {
 async function readPackage(pkgDir, depth, acc) {
   let raw;
   try {
-    raw = await (0, import_promises2.readFile)(import_node_path2.default.join(pkgDir, "package.json"), "utf8");
+    raw = await (0, import_promises3.readFile)(import_node_path3.default.join(pkgDir, "package.json"), "utf8");
   } catch {
     return;
   }
@@ -240,7 +279,7 @@ async function readPackage(pkgDir, depth, acc) {
   });
 }
 async function walkNested(pkgDir, acc, depth) {
-  const nested = import_node_path2.default.join(pkgDir, "node_modules");
+  const nested = import_node_path3.default.join(pkgDir, "node_modules");
   if (!await isPlainDirectory(nested)) {
     return;
   }
@@ -248,7 +287,7 @@ async function walkNested(pkgDir, acc, depth) {
 }
 async function isPlainDirectory(dir) {
   try {
-    const info = await (0, import_promises2.lstat)(dir);
+    const info = await (0, import_promises3.lstat)(dir);
     return info.isDirectory() && !info.isSymbolicLink();
   } catch {
     return false;
@@ -256,11 +295,11 @@ async function isPlainDirectory(dir) {
 }
 
 // src/parsers/pnpm.ts
-var import_promises3 = require("fs/promises");
+var import_promises4 = require("fs/promises");
 async function parsePnpmLockfile(lockfilePath) {
   let raw;
   try {
-    raw = await (0, import_promises3.readFile)(lockfilePath, "utf8");
+    raw = await (0, import_promises4.readFile)(lockfilePath, "utf8");
   } catch (cause) {
     throw new PatchstackError(
       `Could not read lockfile at ${lockfilePath}`,
@@ -508,12 +547,12 @@ function extractLeafName(trimmed) {
 }
 
 // src/parsers/yarn.ts
-var import_promises4 = require("fs/promises");
-var import_node_path3 = __toESM(require("path"), 1);
+var import_promises5 = require("fs/promises");
+var import_node_path4 = __toESM(require("path"), 1);
 async function parseYarnLockfile(lockfilePath) {
   let raw;
   try {
-    raw = await (0, import_promises4.readFile)(lockfilePath, "utf8");
+    raw = await (0, import_promises5.readFile)(lockfilePath, "utf8");
   } catch (cause) {
     throw new PatchstackError(
       `Could not read lockfile at ${lockfilePath}`,
@@ -528,7 +567,7 @@ async function parseYarnLockfile(lockfilePath) {
       "LOCKFILE_PARSE_ERROR"
     );
   }
-  const directNames = await readDirectDepNames(import_node_path3.default.dirname(lockfilePath));
+  const directNames = await readDirectDepNames(import_node_path4.default.dirname(lockfilePath));
   const entries = [];
   const seen = /* @__PURE__ */ new Set();
   for (const block of blocks) {
@@ -672,7 +711,7 @@ async function readDirectDepNames(cwd) {
   const names = /* @__PURE__ */ new Set();
   let raw;
   try {
-    raw = await (0, import_promises4.readFile)(import_node_path3.default.join(cwd, "package.json"), "utf8");
+    raw = await (0, import_promises5.readFile)(import_node_path4.default.join(cwd, "package.json"), "utf8");
   } catch {
     return names;
   }
@@ -709,7 +748,7 @@ var LOCKFILE_CANDIDATES = [
 async function detectLockfile(cwd) {
   const probed = await Promise.all(
     LOCKFILE_CANDIDATES.map(async (candidate) => {
-      const filePath = import_node_path4.default.join(cwd, candidate.filename);
+      const filePath = import_node_path5.default.join(cwd, candidate.filename);
       return { ...candidate, filePath, present: await exists(filePath) };
     })
   );
@@ -729,9 +768,69 @@ async function detectLockfile(cwd) {
   );
 }
 async function scanLockfile(cwd) {
-  const detected = await detectLockfile(cwd);
-  const packages = await runStrategy(detected, cwd);
-  return { ecosystem: detected.ecosystem, packages };
+  const candidates = await presentLockfiles(cwd);
+  if (candidates.length === 0) {
+    await detectLockfile(cwd);
+  }
+  const declared = await readDeclaredDependencyNames(cwd);
+  const warnings = [];
+  let firstParsed = null;
+  let walkTried = false;
+  for (const candidate of candidates) {
+    let packages;
+    try {
+      packages = await runStrategy(candidate, cwd);
+    } catch {
+      continue;
+    }
+    walkTried ||= candidate.strategy === "node-modules-walk";
+    firstParsed ??= { packages, filename: candidate.filename };
+    const missing = missingDependencies(declared, packages);
+    if (missing.length === 0) {
+      return manifestWith(packages, warnings);
+    }
+    warnings.push(staleWarning(candidate.filename, missing));
+  }
+  if (!walkTried) {
+    try {
+      const packages = await walkNodeModules(cwd);
+      const missing = missingDependencies(declared, packages);
+      if (missing.length > 0) {
+        warnings.push(staleWarning("node_modules/", missing));
+      }
+      warnings.push("Scanned node_modules/ instead. Delete the stale lockfile to silence this warning.");
+      return manifestWith(packages, warnings);
+    } catch {
+    }
+  }
+  if (firstParsed === null) {
+    const expected = LOCKFILE_CANDIDATES.map((candidate) => candidate.filename).join(", ");
+    throw new PatchstackError(
+      `No readable lockfile found in ${cwd}. Expected one of: ${expected}.`,
+      "LOCKFILE_NOT_FOUND"
+    );
+  }
+  warnings.push(
+    `No fully-consistent source found; reporting ${firstParsed.filename}. The manifest may understate the real dependency set.`
+  );
+  return manifestWith(firstParsed.packages, warnings);
+}
+function manifestWith(packages, warnings) {
+  return warnings.length > 0 ? { ecosystem: "npm", packages, warnings } : { ecosystem: "npm", packages };
+}
+function staleWarning(source, missing) {
+  const sample = missing.slice(0, 3).join(", ");
+  const suffix = missing.length > 3 ? `, +${missing.length - 3} more` : "";
+  return `${source} looks stale: package.json declares ${missing.length} dependenc${missing.length === 1 ? "y" : "ies"} it does not contain (${sample}${suffix}).`;
+}
+async function presentLockfiles(cwd) {
+  const probed = await Promise.all(
+    LOCKFILE_CANDIDATES.map(async (candidate) => {
+      const filePath = import_node_path5.default.join(cwd, candidate.filename);
+      return { ...candidate, filePath, present: await exists(filePath) };
+    })
+  );
+  return probed.filter((candidate) => candidate.present).map(({ filename, strategy, filePath }) => ({ ecosystem: "npm", filename, strategy, filePath }));
 }
 async function runStrategy(detected, cwd) {
   switch (detected.strategy) {
@@ -747,7 +846,7 @@ async function runStrategy(detected, cwd) {
 }
 async function exists(filePath) {
   try {
-    await (0, import_promises5.access)(filePath);
+    await (0, import_promises6.access)(filePath);
     return true;
   } catch {
     return false;
@@ -934,8 +1033,8 @@ function isTimeoutError(cause) {
 }
 
 // src/config.ts
-var import_promises6 = require("fs/promises");
-var import_node_path5 = __toESM(require("path"), 1);
+var import_promises7 = require("fs/promises");
+var import_node_path6 = __toESM(require("path"), 1);
 var CONFIG_FILENAME = ".patchstackrc.json";
 var DEFAULT_ENVIRONMENT = "production";
 async function resolveConfig(options) {
@@ -972,9 +1071,9 @@ async function resolveConfig(options) {
   };
 }
 async function writeConfigFile(cwd, config) {
-  const target = import_node_path5.default.join(cwd, CONFIG_FILENAME);
+  const target = import_node_path6.default.join(cwd, CONFIG_FILENAME);
   const content = JSON.stringify(config, null, 2) + "\n";
-  await (0, import_promises6.writeFile)(target, content, "utf8");
+  await (0, import_promises7.writeFile)(target, content, "utf8");
   return target;
 }
 async function persistSiteUuid(cwd, siteUuid) {
@@ -982,10 +1081,10 @@ async function persistSiteUuid(cwd, siteUuid) {
   return writeConfigFile(cwd, { ...existing, siteUuid });
 }
 async function readConfigFile(cwd) {
-  const target = import_node_path5.default.join(cwd, CONFIG_FILENAME);
+  const target = import_node_path6.default.join(cwd, CONFIG_FILENAME);
   let raw;
   try {
-    raw = await (0, import_promises6.readFile)(target, "utf8");
+    raw = await (0, import_promises7.readFile)(target, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return {};