thinkwell 0.5.2 → 0.5.4

package/dist-pkg/cli-dependency-check.cjs

@@ -0,0 +1,312 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// dist/cli/dependency-check.js
+var dependency_check_exports = {};
+__export(dependency_check_exports, {
+  checkDependencies: () => checkDependencies,
+  findProjectRoot: () => findProjectRoot,
+  hasPackageJson: () => hasPackageJson
+});
+module.exports = __toCommonJS(dependency_check_exports);
+var import_node_fs2 = require("node:fs");
+var import_node_path2 = require("node:path");
+var import_node_child_process = require("node:child_process");
+
+// dist/cli/package-manager.js
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var LOCKFILES = [
+  { file: "pnpm-lock.yaml", pm: "pnpm" },
+  { file: "yarn.lock", pm: "yarn" },
+  { file: "package-lock.json", pm: "npm" }
+];
+function detectByLockfile(projectDir) {
+  for (const { file, pm } of LOCKFILES) {
+    const lockfilePath = (0, import_node_path.join)(projectDir, file);
+    if ((0, import_node_fs.existsSync)(lockfilePath)) {
+      return { pm, lockfile: file };
+    }
+  }
+  return null;
+}
+__name(detectByLockfile, "detectByLockfile");
+function parsePackageManagerField(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const atIndex = value.indexOf("@");
+  const name = atIndex > 0 ? value.slice(0, atIndex) : value;
+  if (name === "pnpm" || name === "npm" || name === "yarn") {
+    return name;
+  }
+  return null;
+}
+__name(parsePackageManagerField, "parsePackageManagerField");
+function detectByPackageJson(projectDir) {
+  const pkgPath = (0, import_node_path.join)(projectDir, "package.json");
+  if (!(0, import_node_fs.existsSync)(pkgPath)) {
+    return null;
+  }
+  try {
+    const content = (0, import_node_fs.readFileSync)(pkgPath, "utf-8");
+    const pkg = JSON.parse(content);
+    return parsePackageManagerField(pkg.packageManager);
+  } catch {
+    return null;
+  }
+}
+__name(detectByPackageJson, "detectByPackageJson");
+function createPackageManagerInfo(name, lockfile) {
+  return {
+    name,
+    lockfile,
+    addCommand: /* @__PURE__ */ __name((pkg, dev) => {
+      switch (name) {
+        case "pnpm":
+          return dev ? `pnpm add -D ${pkg}` : `pnpm add ${pkg}`;
+        case "yarn":
+          return dev ? `yarn add -D ${pkg}` : `yarn add ${pkg}`;
+        case "npm":
+          return dev ? `npm install -D ${pkg}` : `npm install ${pkg}`;
+      }
+    }, "addCommand"),
+    whyCommand: /* @__PURE__ */ __name((pkg) => {
+      switch (name) {
+        case "pnpm":
+          return ["pnpm", "why", pkg, "--json"];
+        case "yarn":
+          return ["yarn", "why", pkg, "--json"];
+        case "npm":
+          return ["npm", "why", pkg, "--json"];
+      }
+    }, "whyCommand")
+  };
+}
+__name(createPackageManagerInfo, "createPackageManagerInfo");
+function detectPackageManager(projectDir) {
+  const lockfileResult = detectByLockfile(projectDir);
+  if (lockfileResult) {
+    return createPackageManagerInfo(lockfileResult.pm, lockfileResult.lockfile);
+  }
+  const fromField = detectByPackageJson(projectDir);
+  if (fromField) {
+    return createPackageManagerInfo(fromField, null);
+  }
+  return createPackageManagerInfo("npm", null);
+}
+__name(detectPackageManager, "detectPackageManager");
+
+// dist/cli/dependency-check.js
+function readPackageJson(dir) {
+  const pkgPath = (0, import_node_path2.join)(dir, "package.json");
+  if (!(0, import_node_fs2.existsSync)(pkgPath)) {
+    return null;
+  }
+  try {
+    const content = (0, import_node_fs2.readFileSync)(pkgPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+__name(readPackageJson, "readPackageJson");
+function checkPackageJsonDirect(pkg, packageName) {
+  const depTypes = [
+    pkg.dependencies,
+    pkg.devDependencies,
+    pkg.peerDependencies,
+    pkg.optionalDependencies
+  ];
+  for (const deps of depTypes) {
+    if (deps && packageName in deps) {
+      return {
+        found: true,
+        version: deps[packageName],
+        source: "package.json"
+      };
+    }
+  }
+  return null;
+}
+__name(checkPackageJsonDirect, "checkPackageJsonDirect");
+function execCommand(cmd, cwd) {
+  return new Promise((resolve, reject) => {
+    const [command, ...args] = cmd;
+    const proc = (0, import_node_child_process.spawn)(command, args, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("error", (err) => {
+      reject(err);
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve({ stdout, stderr });
+      } else {
+        reject(new Error(`Command failed with exit code ${code}: ${stderr}`));
+      }
+    });
+  });
+}
+__name(execCommand, "execCommand");
+function parsePnpmWhyOutput(stdout, packageName) {
+  try {
+    const result = JSON.parse(stdout);
+    if (result && typeof result === "object" && packageName in result) {
+      const info = result[packageName];
+      return {
+        found: true,
+        version: info?.version,
+        source: "workspace"
+      };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+__name(parsePnpmWhyOutput, "parsePnpmWhyOutput");
+function parseNpmWhyOutput(stdout, _packageName) {
+  try {
+    const result = JSON.parse(stdout);
+    if (Array.isArray(result) && result.length > 0) {
+      const first = result[0];
+      return {
+        found: true,
+        version: first?.version,
+        source: "workspace"
+      };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+__name(parseNpmWhyOutput, "parseNpmWhyOutput");
+function parseYarnWhyOutput(stdout, _packageName) {
+  if (stdout.trim().length > 0) {
+    let version;
+    try {
+      const lines = stdout.trim().split("\n");
+      for (const line of lines) {
+        const obj = JSON.parse(line);
+        if (obj.type === "info" && obj.data) {
+          const match = obj.data.match(/"[^@]+@([^"]+)"/);
+          if (match) {
+            version = match[1];
+            break;
+          }
+        }
+      }
+    } catch {
+    }
+    return {
+      found: true,
+      version,
+      source: "workspace"
+    };
+  }
+  return null;
+}
+__name(parseYarnWhyOutput, "parseYarnWhyOutput");
+async function checkViaPackageManager(pm, packageName, cwd) {
+  const cmd = pm.whyCommand(packageName);
+  try {
+    const { stdout } = await execCommand(cmd, cwd);
+    switch (pm.name) {
+      case "pnpm":
+        return parsePnpmWhyOutput(stdout, packageName);
+      case "npm":
+        return parseNpmWhyOutput(stdout, packageName);
+      case "yarn":
+        return parseYarnWhyOutput(stdout, packageName);
+    }
+  } catch {
+    return null;
+  }
+}
+__name(checkViaPackageManager, "checkViaPackageManager");
+async function checkDependencies(projectDir) {
+  const pm = detectPackageManager(projectDir);
+  const pkg = readPackageJson(projectDir);
+  let thinkwellStatus = { found: false };
+  let typescriptStatus = { found: false };
+  if (pkg) {
+    const thinkwellDirect = checkPackageJsonDirect(pkg, "thinkwell");
+    if (thinkwellDirect) {
+      thinkwellStatus = thinkwellDirect;
+    }
+    const typescriptDirect = checkPackageJsonDirect(pkg, "typescript");
+    if (typescriptDirect) {
+      typescriptStatus = typescriptDirect;
+    }
+  }
+  if (!thinkwellStatus.found) {
+    const result = await checkViaPackageManager(pm, "thinkwell", projectDir);
+    if (result) {
+      thinkwellStatus = result;
+    }
+  }
+  if (!typescriptStatus.found) {
+    const result = await checkViaPackageManager(pm, "typescript", projectDir);
+    if (result) {
+      typescriptStatus = result;
+    }
+  }
+  return {
+    thinkwell: thinkwellStatus,
+    typescript: typescriptStatus,
+    packageManager: pm
+  };
+}
+__name(checkDependencies, "checkDependencies");
+function hasPackageJson(projectDir) {
+  return (0, import_node_fs2.existsSync)((0, import_node_path2.join)(projectDir, "package.json"));
+}
+__name(hasPackageJson, "hasPackageJson");
+function findProjectRoot(startDir) {
+  let dir = startDir;
+  while (true) {
+    if ((0, import_node_fs2.existsSync)((0, import_node_path2.join)(dir, "package.json"))) {
+      return dir;
+    }
+    const parent = (0, import_node_path2.dirname)(dir);
+    if (parent === dir) {
+      return void 0;
+    }
+    dir = parent;
+  }
+}
+__name(findProjectRoot, "findProjectRoot");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkDependencies,
+  findProjectRoot,
+  hasPackageJson
+});

package/dist-pkg/cli-dependency-errors.cjs

@@ -0,0 +1,92 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// dist/cli/dependency-errors.js
+var dependency_errors_exports = {};
+__export(dependency_errors_exports, {
+  formatMissingDependencyError: () => formatMissingDependencyError,
+  formatMissingDepsError: () => formatMissingDepsError,
+  hasMissingDependencies: () => hasMissingDependencies,
+  hasMissingDeps: () => hasMissingDeps
+});
+module.exports = __toCommonJS(dependency_errors_exports);
+function formatMissingDependencyError(result) {
+  const { thinkwell, typescript, packageManager } = result;
+  const pm = packageManager;
+  const missing = [];
+  if (!thinkwell.found)
+    missing.push("thinkwell");
+  if (!typescript.found)
+    missing.push("typescript");
+  if (missing.length === 0) {
+    return "";
+  }
+  const lines = [];
+  if (missing.length === 1) {
+    lines.push(`Error: This project has a package.json but no dependency on '${missing[0]}'.`);
+  } else {
+    lines.push(`Error: This project has a package.json but is missing required dependencies.`);
+  }
+  lines.push("");
+  lines.push("When a project has explicit configuration, thinkwell expects explicit dependencies.");
+  lines.push("This ensures you get the versions you expect, not versions bundled with the CLI.");
+  lines.push("");
+  lines.push("Run 'thinkwell init' to add the required dependencies, or add them manually:");
+  if (!thinkwell.found) {
+    lines.push(`  ${pm.addCommand("thinkwell")}`);
+  }
+  if (!typescript.found) {
+    lines.push(`  ${pm.addCommand("typescript", true)}`);
+  }
+  return lines.join("\n");
+}
+__name(formatMissingDependencyError, "formatMissingDependencyError");
+function hasMissingDependencies(result) {
+  return !result.thinkwell.found || !result.typescript.found;
+}
+__name(hasMissingDependencies, "hasMissingDependencies");
+function hasMissingDeps(result, options) {
+  if (!result.thinkwell.found)
+    return true;
+  if (options.requireTypescript && !result.typescript.found)
+    return true;
+  return false;
+}
+__name(hasMissingDeps, "hasMissingDeps");
+function formatMissingDepsError(result, options) {
+  if (!options.requireTypescript && result.thinkwell.found) {
+    return "";
+  }
+  if (!options.requireTypescript) {
+    return formatMissingDependencyError({
+      ...result,
+      typescript: { found: true }
+    });
+  }
+  return formatMissingDependencyError(result);
+}
+__name(formatMissingDepsError, "formatMissingDepsError");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatMissingDependencyError,
+  formatMissingDepsError,
+  hasMissingDependencies,
+  hasMissingDeps
+});