@joe-sh/pj 1.4.0

package/dist/index.cjs

@@ -0,0 +1,1188 @@
+'use strict';
+
+var execa = require('execa');
+var fs = require('fs/promises');
+var path = require('path');
+var fs$1 = require('fs');
+var promises = require('stream/promises');
+var stream = require('stream');
+var tar = require('tar');
+var os = require('os');
+var yaml = require('yaml');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+var tar__namespace = /*#__PURE__*/_interopNamespace(tar);
+var os__namespace = /*#__PURE__*/_interopNamespace(os);
+var yaml__namespace = /*#__PURE__*/_interopNamespace(yaml);
+
+// src/cli/executor.ts
+
+// src/api/types.ts
+var PjBinaryError = class extends Error {
+  constructor(message, cause) {
+    super(message, { cause });
+    this.cause = cause;
+    this.name = "PjBinaryError";
+  }
+};
+var PjExecutionError = class extends Error {
+  exitCode;
+  stderr;
+  constructor(message, exitCode, stderr) {
+    super(message);
+    this.name = "PjExecutionError";
+    this.exitCode = exitCode;
+    this.stderr = stderr;
+  }
+};
+var PjConfigError = class extends Error {
+  constructor(message, cause) {
+    super(message, { cause });
+    this.cause = cause;
+    this.name = "PjConfigError";
+  }
+};
+var PJ_TARGET_VERSION = "1.4";
+var GITHUB_OWNER = "josephschmitt";
+var GITHUB_REPO = "pj";
+var GITHUB_API_URL = "https://api.github.com";
+var RELEASES_URL = `${GITHUB_API_URL}/repos/${GITHUB_OWNER}/${GITHUB_REPO}/releases`;
+var LATEST_RELEASE_URL = `${RELEASES_URL}/latest`;
+var BINARY_NAME = "pj";
+var BINARY_NAME_WIN = "pj.exe";
+function getBinaryName() {
+  return process.platform === "win32" ? BINARY_NAME_WIN : BINARY_NAME;
+}
+function getCacheDir() {
+  const xdgCache = process.env["XDG_CACHE_HOME"];
+  if (xdgCache) {
+    return path__namespace.join(xdgCache, "pj-node");
+  }
+  if (process.platform === "win32") {
+    const localAppData = process.env["LOCALAPPDATA"];
+    if (localAppData) {
+      return path__namespace.join(localAppData, "pj-node", "cache");
+    }
+    return path__namespace.join(os__namespace.homedir(), "AppData", "Local", "pj-node", "cache");
+  }
+  return path__namespace.join(os__namespace.homedir(), ".cache", "pj-node");
+}
+function getBinaryCacheDir() {
+  return path__namespace.join(getCacheDir(), "bin");
+}
+function getMetadataPath() {
+  return path__namespace.join(getCacheDir(), "metadata.json");
+}
+function getPjConfigDir() {
+  const xdgConfig = process.env["XDG_CONFIG_HOME"];
+  if (xdgConfig) {
+    return path__namespace.join(xdgConfig, "pj");
+  }
+  if (process.platform === "win32") {
+    const appData = process.env["APPDATA"];
+    if (appData) {
+      return path__namespace.join(appData, "pj");
+    }
+    return path__namespace.join(os__namespace.homedir(), "AppData", "Roaming", "pj");
+  }
+  return path__namespace.join(os__namespace.homedir(), ".config", "pj");
+}
+function getPjConfigPath() {
+  return path__namespace.join(getPjConfigDir(), "config.yaml");
+}
+function getPjCacheDir() {
+  const xdgCache = process.env["XDG_CACHE_HOME"];
+  if (xdgCache) {
+    return path__namespace.join(xdgCache, "pj");
+  }
+  if (process.platform === "win32") {
+    const localAppData = process.env["LOCALAPPDATA"];
+    if (localAppData) {
+      return path__namespace.join(localAppData, "pj", "cache");
+    }
+    return path__namespace.join(os__namespace.homedir(), "AppData", "Local", "pj", "cache");
+  }
+  return path__namespace.join(os__namespace.homedir(), ".cache", "pj");
+}
+var USER_AGENT = "@joe-sh/pj";
+var HTTP_TIMEOUT = 3e4;
+var UPDATE_CHECK_INTERVAL_DAYS = 7;
+
+// src/binary/platform.ts
+function detectPlatform() {
+  const nodeOs = process.platform;
+  const nodeArch = process.arch;
+  let os3;
+  let pjOs;
+  switch (nodeOs) {
+    case "darwin":
+      os3 = "darwin";
+      pjOs = "darwin";
+      break;
+    case "linux":
+      os3 = "linux";
+      pjOs = "linux";
+      break;
+    case "win32":
+      os3 = "win32";
+      pjOs = "windows";
+      break;
+    default:
+      throw new PjBinaryError(`Unsupported operating system: ${nodeOs}`);
+  }
+  let arch;
+  let pjArch;
+  switch (nodeArch) {
+    case "x64":
+      arch = "x64";
+      pjArch = "amd64";
+      break;
+    case "arm64":
+      arch = "arm64";
+      pjArch = "arm64";
+      break;
+    default:
+      throw new PjBinaryError(`Unsupported architecture: ${nodeArch}`);
+  }
+  return { os: os3, arch, pjOs, pjArch };
+}
+function getAssetFilename(version, platform) {
+  const p = platform ?? detectPlatform();
+  const versionWithoutV = version.startsWith("v") ? version.slice(1) : version;
+  return `pj_${versionWithoutV}_${p.pjOs}_${p.pjArch}.tar.gz`;
+}
+function isPlatformSupported() {
+  try {
+    detectPlatform();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/binary/version.ts
+function parseVersion(version) {
+  const normalized = version.replace(/^v/, "");
+  const match = /^(\d+)\.(\d+)\.(\d+)/.exec(normalized);
+  if (!match || !match[1] || !match[2] || !match[3]) {
+    return null;
+  }
+  return {
+    major: parseInt(match[1], 10),
+    minor: parseInt(match[2], 10),
+    patch: parseInt(match[3], 10),
+    raw: normalized
+  };
+}
+function parseTargetVersion(target) {
+  const match = /^(\d+)\.(\d+)$/.exec(target);
+  if (!match || !match[1] || !match[2]) {
+    return null;
+  }
+  return {
+    major: parseInt(match[1], 10),
+    minor: parseInt(match[2], 10)
+  };
+}
+function isVersionCompatible(version, target = PJ_TARGET_VERSION) {
+  const parsed = parseVersion(version);
+  const targetParsed = parseTargetVersion(target);
+  if (!parsed || !targetParsed) {
+    return false;
+  }
+  return parsed.major === targetParsed.major && parsed.minor === targetParsed.minor;
+}
+function compareVersions(a, b) {
+  const parsedA = parseVersion(a);
+  const parsedB = parseVersion(b);
+  if (!parsedA || !parsedB) {
+    return 0;
+  }
+  if (parsedA.major !== parsedB.major) {
+    return parsedA.major - parsedB.major;
+  }
+  if (parsedA.minor !== parsedB.minor) {
+    return parsedA.minor - parsedB.minor;
+  }
+  return parsedA.patch - parsedB.patch;
+}
+function findHighestCompatibleVersion(versions, target = PJ_TARGET_VERSION) {
+  const compatible = versions.filter((v) => isVersionCompatible(v, target));
+  if (compatible.length === 0) {
+    return null;
+  }
+  compatible.sort((a, b) => compareVersions(b, a));
+  return compatible[0] ?? null;
+}
+
+// src/binary/manager.ts
+var BinaryManager = class {
+  cachedBinaryPath = null;
+  /**
+   * Get the path to the pj binary, downloading if necessary
+   */
+  async getBinaryPath(options) {
+    const envPath = process.env["PJ_BINARY_PATH"];
+    if (envPath) {
+      if (await this.isValidBinary(envPath)) {
+        return envPath;
+      }
+      throw new PjBinaryError(
+        `PJ_BINARY_PATH is set but binary is not valid: ${envPath}`
+      );
+    }
+    const globalPath = await this.findGlobalBinary();
+    if (globalPath) {
+      return globalPath;
+    }
+    const cachedPath = await this.getCachedBinaryPath();
+    if (cachedPath && !options?.force) {
+      const needsUpdate = await this.shouldCheckForUpdate();
+      if (needsUpdate && options?.version === void 0) {
+        try {
+          await this.updateBinary(options);
+        } catch {
+        }
+      }
+      return cachedPath;
+    }
+    return await this.downloadBinary(options);
+  }
+  /**
+   * Get the current binary status
+   */
+  async getStatus() {
+    const envPath = process.env["PJ_BINARY_PATH"];
+    if (envPath && await this.isValidBinary(envPath)) {
+      const version = await this.getVersion(envPath);
+      return {
+        available: true,
+        path: envPath,
+        version,
+        source: "env"
+      };
+    }
+    const globalPath = await this.findGlobalBinary();
+    if (globalPath) {
+      const version = await this.getVersion(globalPath);
+      return {
+        available: true,
+        path: globalPath,
+        version,
+        source: "global"
+      };
+    }
+    const cachedPath = await this.getCachedBinaryPath();
+    if (cachedPath) {
+      const version = await this.getVersion(cachedPath);
+      return {
+        available: true,
+        path: cachedPath,
+        version,
+        source: "cache"
+      };
+    }
+    return {
+      available: false,
+      path: null,
+      version: null,
+      source: null
+    };
+  }
+  /**
+   * Download and install the pj binary.
+   * If no specific version is requested, downloads the highest compatible version
+   * within the target major.minor range.
+   */
+  async downloadBinary(options) {
+    const release = options?.version ? await this.getRelease(options.version) : await this.getCompatibleRelease();
+    const platform = detectPlatform();
+    const assetName = getAssetFilename(release.version, platform);
+    const asset = release.assets.find((a) => a.name === assetName);
+    if (!asset) {
+      throw new PjBinaryError(
+        `No binary available for ${platform.pjOs}/${platform.pjArch}. Expected asset: ${assetName}`
+      );
+    }
+    const cacheDir = getBinaryCacheDir();
+    await fs__namespace.mkdir(cacheDir, { recursive: true });
+    const tarballPath = path__namespace.join(cacheDir, assetName);
+    await this.downloadAsset(asset, tarballPath, options?.onProgress);
+    const binaryName = getBinaryName();
+    await tar__namespace.extract({
+      file: tarballPath,
+      cwd: cacheDir,
+      filter: (entryPath) => path__namespace.basename(entryPath) === binaryName
+    });
+    await fs__namespace.unlink(tarballPath);
+    const binaryPath = path__namespace.join(cacheDir, binaryName);
+    if (process.platform !== "win32") {
+      await fs__namespace.chmod(binaryPath, 493);
+    }
+    if (!await this.isValidBinary(binaryPath)) {
+      throw new PjBinaryError("Downloaded binary failed verification");
+    }
+    await this.saveMetadata({
+      version: release.version,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      lastUpdateCheck: (/* @__PURE__ */ new Date()).toISOString(),
+      source: "download"
+    });
+    this.cachedBinaryPath = binaryPath;
+    return binaryPath;
+  }
+  /**
+   * Update the binary to the highest compatible version within the target range.
+   */
+  async updateBinary(options) {
+    const compatible = await this.getCompatibleRelease();
+    const metadata = await this.getMetadata();
+    if (metadata?.version === compatible.version && !options?.force) {
+      await this.saveMetadata({
+        ...metadata,
+        lastUpdateCheck: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const cachedPath = await this.getCachedBinaryPath();
+      if (cachedPath) {
+        return cachedPath;
+      }
+    }
+    return await this.downloadBinary({
+      ...options,
+      version: compatible.version
+    });
+  }
+  /**
+   * Get the version of a pj binary
+   */
+  async getVersion(binaryPath) {
+    try {
+      const result = await execa.execa(binaryPath, ["--version"], { timeout: 5e3 });
+      const match = /(?:pj\s+)?(?:version\s+)?v?(\d+\.\d+\.\d+)/i.exec(
+        result.stdout
+      );
+      return match?.[1] ?? null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Check if a binary path is a valid pj binary
+   */
+  async isValidBinary(binaryPath) {
+    try {
+      await fs__namespace.access(binaryPath, fs__namespace.constants.X_OK);
+      const version = await this.getVersion(binaryPath);
+      return version !== null;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Find the globally installed pj binary.
+   * Only returns the binary if it's version-compatible with our target.
+   */
+  async findGlobalBinary() {
+    let binaryPath = null;
+    try {
+      const result = await execa.execa("which", ["pj"], { timeout: 5e3 });
+      binaryPath = result.stdout.trim();
+    } catch {
+    }
+    if (!binaryPath && process.platform === "win32") {
+      try {
+        const result = await execa.execa("where", ["pj"], { timeout: 5e3 });
+        binaryPath = result.stdout.trim().split("\n")[0] ?? null;
+      } catch {
+      }
+    }
+    if (!binaryPath) {
+      return null;
+    }
+    if (!await this.isValidBinary(binaryPath)) {
+      return null;
+    }
+    const version = await this.getVersion(binaryPath);
+    if (!version || !isVersionCompatible(version, PJ_TARGET_VERSION)) {
+      return null;
+    }
+    return binaryPath;
+  }
+  /**
+   * Get the path to the cached binary if it exists and is version-compatible.
+   */
+  async getCachedBinaryPath() {
+    if (this.cachedBinaryPath) {
+      if (await this.isValidBinary(this.cachedBinaryPath)) {
+        const version = await this.getVersion(this.cachedBinaryPath);
+        if (version && isVersionCompatible(version, PJ_TARGET_VERSION)) {
+          return this.cachedBinaryPath;
+        }
+      }
+      this.cachedBinaryPath = null;
+    }
+    const binaryPath = path__namespace.join(getBinaryCacheDir(), getBinaryName());
+    if (await this.isValidBinary(binaryPath)) {
+      const version = await this.getVersion(binaryPath);
+      if (version && isVersionCompatible(version, PJ_TARGET_VERSION)) {
+        this.cachedBinaryPath = binaryPath;
+        return binaryPath;
+      }
+    }
+    return null;
+  }
+  /**
+   * Check if we should check for updates
+   */
+  async shouldCheckForUpdate() {
+    const metadata = await this.getMetadata();
+    if (!metadata) {
+      return true;
+    }
+    const lastCheck = new Date(metadata.lastUpdateCheck);
+    const now = /* @__PURE__ */ new Date();
+    const daysSinceCheck = (now.getTime() - lastCheck.getTime()) / (1e3 * 60 * 60 * 24);
+    return daysSinceCheck >= UPDATE_CHECK_INTERVAL_DAYS;
+  }
+  /**
+   * Get cached metadata
+   */
+  async getMetadata() {
+    try {
+      const content = await fs__namespace.readFile(getMetadataPath(), "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Save metadata to cache
+   */
+  async saveMetadata(metadata) {
+    const metadataPath = getMetadataPath();
+    await fs__namespace.mkdir(path__namespace.dirname(metadataPath), { recursive: true });
+    await fs__namespace.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
+  }
+  /**
+   * Get all releases from GitHub (up to 100 most recent)
+   */
+  async getAllReleases() {
+    const response = await fetch(`${RELEASES_URL}?per_page=100`, {
+      headers: {
+        Accept: "application/vnd.github.v3+json",
+        "User-Agent": USER_AGENT
+      },
+      signal: AbortSignal.timeout(HTTP_TIMEOUT)
+    });
+    if (!response.ok) {
+      throw new PjBinaryError(
+        `Failed to fetch releases: ${String(response.status)} ${response.statusText}`
+      );
+    }
+    const data = await response.json();
+    return data.filter((release) => !release.prerelease).map((release) => this.parseRelease(release));
+  }
+  /**
+   * Get the highest compatible release within the target major.minor range.
+   */
+  async getCompatibleRelease() {
+    const releases = await this.getAllReleases();
+    const versions = releases.map((r) => r.version);
+    const compatibleVersion = findHighestCompatibleVersion(
+      versions,
+      PJ_TARGET_VERSION
+    );
+    if (!compatibleVersion) {
+      throw new PjBinaryError(
+        `No compatible pj release found for version range ${PJ_TARGET_VERSION}.x. Available versions: ${versions.join(", ")}`
+      );
+    }
+    const release = releases.find((r) => r.version === compatibleVersion);
+    if (!release) {
+      throw new PjBinaryError(
+        `Failed to find release for version ${compatibleVersion}`
+      );
+    }
+    return release;
+  }
+  /**
+   * Get the latest release from GitHub
+   */
+  async getLatestRelease() {
+    const response = await fetch(LATEST_RELEASE_URL, {
+      headers: {
+        Accept: "application/vnd.github.v3+json",
+        "User-Agent": USER_AGENT
+      },
+      signal: AbortSignal.timeout(HTTP_TIMEOUT)
+    });
+    if (!response.ok) {
+      throw new PjBinaryError(
+        `Failed to fetch latest release: ${String(response.status)} ${response.statusText}`
+      );
+    }
+    const data = await response.json();
+    return this.parseRelease(data);
+  }
+  /**
+   * Get a specific release from GitHub
+   */
+  async getRelease(version) {
+    const tag = version.startsWith("v") ? version : `v${version}`;
+    const url = `${LATEST_RELEASE_URL.replace("/latest", "")}/${tag}`;
+    const response = await fetch(url, {
+      headers: {
+        Accept: "application/vnd.github.v3+json",
+        "User-Agent": USER_AGENT
+      },
+      signal: AbortSignal.timeout(HTTP_TIMEOUT)
+    });
+    if (!response.ok) {
+      throw new PjBinaryError(
+        `Failed to fetch release ${version}: ${String(response.status)} ${response.statusText}`
+      );
+    }
+    const data = await response.json();
+    return this.parseRelease(data);
+  }
+  /**
+   * Parse GitHub release response
+   */
+  parseRelease(data) {
+    return {
+      tagName: data.tag_name,
+      version: data.tag_name.replace(/^v/, ""),
+      name: data.name,
+      prerelease: data.prerelease,
+      assets: data.assets.map((asset) => ({
+        name: asset.name,
+        downloadUrl: asset.browser_download_url,
+        size: asset.size,
+        contentType: asset.content_type
+      }))
+    };
+  }
+  /**
+   * Download an asset to a file
+   */
+  async downloadAsset(asset, destPath, onProgress) {
+    const response = await fetch(asset.downloadUrl, {
+      headers: {
+        "User-Agent": USER_AGENT
+      },
+      signal: AbortSignal.timeout(HTTP_TIMEOUT * 10)
+      // Longer timeout for downloads
+    });
+    if (!response.ok) {
+      throw new PjBinaryError(
+        `Failed to download asset: ${String(response.status)} ${response.statusText}`
+      );
+    }
+    if (!response.body) {
+      throw new PjBinaryError("Response body is empty");
+    }
+    const total = asset.size;
+    let downloaded = 0;
+    const progressStream = new TransformStream({
+      transform(chunk, controller) {
+        downloaded += chunk.length;
+        onProgress?.({
+          downloaded,
+          total,
+          percent: Math.round(downloaded / total * 100)
+        });
+        controller.enqueue(chunk);
+      }
+    });
+    const fileStream = fs$1.createWriteStream(destPath);
+    await promises.pipeline(
+      stream.Readable.fromWeb(response.body.pipeThrough(progressStream)),
+      fileStream
+    );
+  }
+  /**
+   * Clear the binary cache
+   */
+  async clearCache() {
+    const cacheDir = getBinaryCacheDir();
+    try {
+      await fs__namespace.rm(cacheDir, { recursive: true, force: true });
+    } catch {
+    }
+    const metadataPath = getMetadataPath();
+    try {
+      await fs__namespace.unlink(metadataPath);
+    } catch {
+    }
+    this.cachedBinaryPath = null;
+  }
+};
+var binaryManager = null;
+function getBinaryManager() {
+  binaryManager ??= new BinaryManager();
+  return binaryManager;
+}
+
+// src/cli/executor.ts
+function buildArgs(options) {
+  const args = [];
+  if (options?.paths) {
+    for (const p of options.paths) {
+      args.push("--path", p);
+    }
+  }
+  if (options?.markers) {
+    for (const m of options.markers) {
+      args.push("--marker", m);
+    }
+  }
+  if (options?.excludes) {
+    for (const e of options.excludes) {
+      args.push("--exclude", e);
+    }
+  }
+  if (options?.maxDepth !== void 0) {
+    args.push("--max-depth", String(options.maxDepth));
+  }
+  if (options?.noIgnore) {
+    args.push("--no-ignore");
+  }
+  if (options?.nested === false) {
+    args.push("--no-nested");
+  }
+  if (options?.noCache) {
+    args.push("--no-cache");
+  }
+  if (options?.icons) {
+    args.push("--icons");
+  }
+  if (options?.configPath) {
+    args.push("--config", options.configPath);
+  }
+  if (options?.verbose) {
+    args.push("--verbose");
+  }
+  args.push("--json");
+  return args;
+}
+function parseJsonOutput(output) {
+  if (!output.trim()) {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(output);
+    return parsed.map((p) => ({
+      path: p.path,
+      name: p.name,
+      marker: p.marker,
+      icon: p.icon,
+      priority: p.priority
+    }));
+  } catch (error) {
+    throw new PjExecutionError(
+      `Failed to parse pj output: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executePj(args, execaOptions) {
+  const binaryManager2 = getBinaryManager();
+  const binaryPath = await binaryManager2.getBinaryPath();
+  try {
+    const result = await execa.execa(binaryPath, args, {
+      timeout: 6e4,
+      // 1 minute timeout
+      ...execaOptions
+    });
+    return {
+      stdout: String(result.stdout ?? ""),
+      stderr: String(result.stderr ?? ""),
+      exitCode: result.exitCode ?? 0
+    };
+  } catch (error) {
+    if (error instanceof Error && "exitCode" in error) {
+      const execaError = error;
+      throw new PjExecutionError(
+        `pj command failed: ${execaError.message}`,
+        execaError.exitCode,
+        execaError.stderr
+      );
+    }
+    throw error;
+  }
+}
+async function executePjWithStdin(args, stdin, execaOptions) {
+  const binaryManager2 = getBinaryManager();
+  const binaryPath = await binaryManager2.getBinaryPath();
+  try {
+    const result = await execa.execa(binaryPath, args, {
+      input: stdin,
+      timeout: 6e4,
+      ...execaOptions
+    });
+    return {
+      stdout: String(result.stdout ?? ""),
+      stderr: String(result.stderr ?? ""),
+      exitCode: result.exitCode ?? 0
+    };
+  } catch (error) {
+    if (error instanceof Error && "exitCode" in error) {
+      const execaError = error;
+      throw new PjExecutionError(
+        `pj command failed: ${execaError.message}`,
+        execaError.exitCode,
+        execaError.stderr
+      );
+    }
+    throw error;
+  }
+}
+
+// src/api/discover.ts
+async function discover(options) {
+  const args = buildArgs(options);
+  const result = await executePj(args);
+  return parseJsonOutput(result.stdout);
+}
+async function discoverFromPaths(paths, options) {
+  const optsWithoutPaths = {};
+  if (options?.markers !== void 0) optsWithoutPaths.markers = options.markers;
+  if (options?.excludes !== void 0) optsWithoutPaths.excludes = options.excludes;
+  if (options?.maxDepth !== void 0) optsWithoutPaths.maxDepth = options.maxDepth;
+  if (options?.noIgnore !== void 0) optsWithoutPaths.noIgnore = options.noIgnore;
+  if (options?.nested !== void 0) optsWithoutPaths.nested = options.nested;
+  if (options?.noCache !== void 0) optsWithoutPaths.noCache = options.noCache;
+  if (options?.icons !== void 0) optsWithoutPaths.icons = options.icons;
+  if (options?.configPath !== void 0) optsWithoutPaths.configPath = options.configPath;
+  if (options?.verbose !== void 0) optsWithoutPaths.verbose = options.verbose;
+  const args = buildArgs(optsWithoutPaths);
+  const stdin = paths.join("\n");
+  const result = await executePjWithStdin(args, stdin);
+  return parseJsonOutput(result.stdout);
+}
+async function findProject(name, options) {
+  const projects = await discover(options);
+  return projects.find(
+    (p) => p.name === name || p.name.toLowerCase() === name.toLowerCase()
+  );
+}
+async function findProjects(pattern, options) {
+  const projects = await discover(options);
+  const regex = typeof pattern === "string" ? new RegExp(pattern, "i") : pattern;
+  return projects.filter((p) => regex.test(p.name) || regex.test(p.path));
+}
+async function discoverByMarker(options) {
+  const projects = await discover(options);
+  const grouped = /* @__PURE__ */ new Map();
+  for (const project of projects) {
+    const existing = grouped.get(project.marker);
+    if (existing) {
+      existing.push(project);
+    } else {
+      grouped.set(project.marker, [project]);
+    }
+  }
+  return grouped;
+}
+async function countByMarker(options) {
+  const grouped = await discoverByMarker(options);
+  const counts = /* @__PURE__ */ new Map();
+  for (const [marker, projects] of grouped) {
+    counts.set(marker, projects.length);
+  }
+  return counts;
+}
+var DEFAULT_CONFIG = {
+  paths: [
+    path__namespace.join(os__namespace.homedir(), "projects"),
+    path__namespace.join(os__namespace.homedir(), "code"),
+    path__namespace.join(os__namespace.homedir(), "development")
+  ],
+  markers: [
+    ".git",
+    "go.mod",
+    "package.json",
+    "Cargo.toml",
+    "pyproject.toml",
+    ".vscode",
+    ".idea",
+    "Makefile"
+  ],
+  exclude: ["node_modules", "vendor", ".cache", "target", "dist", "build"],
+  maxDepth: 3,
+  cacheTTL: 300,
+  noIgnore: false,
+  noNested: false,
+  icons: {
+    ".git": "\uF1D3 ",
+    //
+    "package.json": "\uE718 ",
+    //
+    "go.mod": "\uE626 ",
+    //
+    "Cargo.toml": "\uE7A8 ",
+    //
+    "pyproject.toml": "\uE73C ",
+    //
+    ".vscode": "\uE70C ",
+    //
+    ".idea": "\uE7B5 ",
+    //
+    Makefile: "\uE779 "
+    //
+  }
+};
+async function loadConfig(configPath) {
+  const filePath = configPath ?? getPjConfigPath();
+  try {
+    const content = await fs__namespace.readFile(filePath, "utf-8");
+    const parsed = yaml__namespace.parse(content);
+    return mergeConfig(parsed);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return { ...DEFAULT_CONFIG };
+    }
+    throw new PjConfigError(
+      `Failed to load config from ${filePath}`,
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+async function saveConfig(config, configPath) {
+  const filePath = configPath ?? getPjConfigPath();
+  const rawConfig = {};
+  if (config.paths !== void 0) rawConfig.paths = config.paths;
+  if (config.markers !== void 0) rawConfig.markers = config.markers;
+  if (config.exclude !== void 0) rawConfig.exclude = config.exclude;
+  if (config.maxDepth !== void 0) rawConfig.max_depth = config.maxDepth;
+  if (config.cacheTTL !== void 0) rawConfig.cache_ttl = config.cacheTTL;
+  if (config.noIgnore !== void 0) rawConfig.no_ignore = config.noIgnore;
+  if (config.noNested !== void 0) rawConfig.no_nested = config.noNested;
+  if (config.icons !== void 0) rawConfig.icons = config.icons;
+  const content = yaml__namespace.stringify(rawConfig, { indent: 2 });
+  await fs__namespace.mkdir(path__namespace.dirname(filePath), { recursive: true });
+  await fs__namespace.writeFile(filePath, content, "utf-8");
+}
+async function configExists(configPath) {
+  const filePath = configPath ?? getPjConfigPath();
+  try {
+    await fs__namespace.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getConfigPath() {
+  return getPjConfigPath();
+}
+function mergeConfig(raw) {
+  return {
+    paths: raw.paths ?? DEFAULT_CONFIG.paths,
+    markers: raw.markers ?? DEFAULT_CONFIG.markers,
+    exclude: raw.exclude ?? DEFAULT_CONFIG.exclude,
+    maxDepth: raw.max_depth ?? DEFAULT_CONFIG.maxDepth,
+    cacheTTL: raw.cache_ttl ?? DEFAULT_CONFIG.cacheTTL,
+    noIgnore: raw.no_ignore ?? DEFAULT_CONFIG.noIgnore,
+    noNested: raw.no_nested ?? DEFAULT_CONFIG.noNested,
+    icons: raw.icons ?? DEFAULT_CONFIG.icons
+  };
+}
+function expandPath(p) {
+  if (p.startsWith("~/")) {
+    return path__namespace.join(os__namespace.homedir(), p.slice(2));
+  }
+  if (p === "~") {
+    return os__namespace.homedir();
+  }
+  return p;
+}
+function expandConfigPaths(config) {
+  return {
+    ...config,
+    paths: config.paths.map(expandPath)
+  };
+}
+async function clearCache() {
+  await executePj(["--clear-cache"]);
+}
+async function getCacheInfo() {
+  const cacheDir = getPjCacheDir();
+  try {
+    const stats = await fs__namespace.stat(cacheDir);
+    if (!stats.isDirectory()) {
+      return {
+        exists: false,
+        path: cacheDir,
+        fileCount: 0,
+        totalSize: 0
+      };
+    }
+    const files = await fs__namespace.readdir(cacheDir);
+    let totalSize = 0;
+    let fileCount = 0;
+    for (const file of files) {
+      if (file.endsWith(".json")) {
+        const filePath = path__namespace.join(cacheDir, file);
+        const fileStats = await fs__namespace.stat(filePath);
+        totalSize += fileStats.size;
+        fileCount++;
+      }
+    }
+    return {
+      exists: true,
+      path: cacheDir,
+      fileCount,
+      totalSize
+    };
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return {
+        exists: false,
+        path: cacheDir,
+        fileCount: 0,
+        totalSize: 0
+      };
+    }
+    throw error;
+  }
+}
+function getCachePath() {
+  return getPjCacheDir();
+}
+
+// src/api/pj.ts
+var Pj = class {
+  config;
+  /**
+   * Create a new Pj instance
+   *
+   * @param config - Optional configuration overrides
+   */
+  constructor(config) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  /**
+   * Discover all projects
+   *
+   * @param options - Discovery options
+   * @returns Array of discovered projects
+   */
+  async discover(options) {
+    return discover(this.mergeOptions(options));
+  }
+  /**
+   * Discover projects from specific paths
+   *
+   * Bypasses configured paths and searches only the provided paths.
+   * Useful for integration with other tools.
+   *
+   * @param paths - Paths to search
+   * @param options - Additional discovery options
+   */
+  async discoverFromPaths(paths, options) {
+    return discoverFromPaths(paths, this.mergeOptions(options));
+  }
+  /**
+   * Find a project by name
+   *
+   * @param name - Project name to find
+   * @param options - Discovery options
+   */
+  async findProject(name, options) {
+    return findProject(name, this.mergeOptions(options));
+  }
+  /**
+   * Find projects matching a pattern
+   *
+   * @param pattern - String or regex pattern to match
+   * @param options - Discovery options
+   */
+  async findProjects(pattern, options) {
+    return findProjects(pattern, this.mergeOptions(options));
+  }
+  /**
+   * Get projects grouped by marker type
+   *
+   * @param options - Discovery options
+   */
+  async discoverByMarker(options) {
+    return discoverByMarker(this.mergeOptions(options));
+  }
+  /**
+   * Count projects by marker type
+   *
+   * @param options - Discovery options
+   */
+  async countByMarker(options) {
+    return countByMarker(this.mergeOptions(options));
+  }
+  /**
+   * Clear the pj project cache
+   */
+  async clearCache() {
+    return clearCache();
+  }
+  /**
+   * Get information about the pj cache
+   */
+  async getCacheInfo() {
+    return getCacheInfo();
+  }
+  /**
+   * Load configuration from file
+   *
+   * @param configPath - Optional path to config file
+   */
+  async loadConfig(configPath) {
+    const loaded = await loadConfig(configPath);
+    this.config = loaded;
+    return loaded;
+  }
+  /**
+   * Save configuration to file
+   *
+   * @param config - Configuration to save (uses current config if not provided)
+   * @param configPath - Optional path to config file
+   */
+  async saveConfig(config, configPath) {
+    const toSave = config ? { ...this.config, ...config } : this.config;
+    await saveConfig(toSave, configPath);
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Update configuration
+   *
+   * @param config - Partial configuration to merge
+   */
+  setConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  /**
+   * Ensure the pj binary is available
+   *
+   * Downloads the binary if not already installed.
+   *
+   * @param options - Binary options
+   * @returns Path to the binary
+   */
+  async ensureBinary(options) {
+    const manager = getBinaryManager();
+    return manager.getBinaryPath(options);
+  }
+  /**
+   * Get the status of the pj binary
+   */
+  async getBinaryStatus() {
+    const manager = getBinaryManager();
+    return manager.getStatus();
+  }
+  /**
+   * Update the pj binary to the latest version
+   *
+   * @param options - Binary options
+   * @returns Path to the updated binary
+   */
+  async updateBinary(options) {
+    const manager = getBinaryManager();
+    return manager.updateBinary(options);
+  }
+  /**
+   * Get the version of the pj binary
+   */
+  async getBinaryVersion() {
+    const manager = getBinaryManager();
+    const status = await manager.getStatus();
+    return status.version;
+  }
+  /**
+   * Merge instance config with provided options
+   */
+  mergeOptions(options) {
+    const merged = {
+      paths: options?.paths ?? this.config.paths,
+      markers: options?.markers ?? this.config.markers,
+      excludes: options?.excludes ?? this.config.exclude,
+      maxDepth: options?.maxDepth ?? this.config.maxDepth,
+      noIgnore: options?.noIgnore ?? this.config.noIgnore,
+      nested: options?.nested ?? !this.config.noNested
+    };
+    if (options?.icons !== void 0) {
+      merged.icons = options.icons;
+    }
+    if (options?.noCache !== void 0) {
+      merged.noCache = options.noCache;
+    }
+    if (options?.configPath !== void 0) {
+      merged.configPath = options.configPath;
+    }
+    if (options?.verbose !== void 0) {
+      merged.verbose = options.verbose;
+    }
+    return merged;
+  }
+};
+
+exports.BinaryManager = BinaryManager;
+exports.DEFAULT_CONFIG = DEFAULT_CONFIG;
+exports.GITHUB_OWNER = GITHUB_OWNER;
+exports.GITHUB_REPO = GITHUB_REPO;
+exports.PJ_TARGET_VERSION = PJ_TARGET_VERSION;
+exports.Pj = Pj;
+exports.PjBinaryError = PjBinaryError;
+exports.PjConfigError = PjConfigError;
+exports.PjExecutionError = PjExecutionError;
+exports.buildArgs = buildArgs;
+exports.clearCache = clearCache;
+exports.compareVersions = compareVersions;
+exports.configExists = configExists;
+exports.countByMarker = countByMarker;
+exports.detectPlatform = detectPlatform;
+exports.discover = discover;
+exports.discoverByMarker = discoverByMarker;
+exports.discoverFromPaths = discoverFromPaths;
+exports.executePj = executePj;
+exports.expandConfigPaths = expandConfigPaths;
+exports.expandPath = expandPath;
+exports.findHighestCompatibleVersion = findHighestCompatibleVersion;
+exports.findProject = findProject;
+exports.findProjects = findProjects;
+exports.getAssetFilename = getAssetFilename;
+exports.getBinaryCacheDir = getBinaryCacheDir;
+exports.getBinaryManager = getBinaryManager;
+exports.getBinaryName = getBinaryName;
+exports.getCacheDir = getCacheDir;
+exports.getCacheInfo = getCacheInfo;
+exports.getCachePath = getCachePath;
+exports.getConfigPath = getConfigPath;
+exports.isPlatformSupported = isPlatformSupported;
+exports.isVersionCompatible = isVersionCompatible;
+exports.loadConfig = loadConfig;
+exports.parseJsonOutput = parseJsonOutput;
+exports.parseTargetVersion = parseTargetVersion;
+exports.parseVersion = parseVersion;
+exports.saveConfig = saveConfig;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map