@kolatts/pncli 1.3.0 → 1.6.0

package/README.md

@@ -1,6 +1,7 @@
 # pncli — The Paperwork Nightmare CLI
 
 [![npm](https://img.shields.io/npm/v/%40kolatts%2Fpncli?style=flat-square&color=cb3837&logo=npm)](https://www.npmjs.com/package/@kolatts/pncli)
+[![docs](https://img.shields.io/badge/docs-getting%20started-FF5C39?style=flat-square)](https://kolatts.github.io/pncli/getting-started/)
 
 > One command does what three meetings couldn't.
 
@@ -26,7 +27,7 @@ pncli config init
 pncli config init --repo
 ```
 
-For workflow patterns, command examples, and agent integration, see [`copilot-instructions.md`](./copilot-instructions.md).
+For workflow patterns, command examples, and agent integration, see the [Getting Started page](https://kolatts.github.io/pncli/getting-started/) or the raw [`copilot-instructions.md`](./copilot-instructions.md).
 
 ## Configuration
 
@@ -49,8 +50,7 @@ pncli uses a three-layer config system (highest priority wins):
 | `PNCLI_BITBUCKET_PAT` | Bitbucket personal access token |
 | `PNCLI_SONAR_BASE_URL` | SonarQube Server base URL |
 | `PNCLI_SONAR_TOKEN` | SonarQube personal access token |
-| `PNCLI_SDE_BASE_URL` | SDElements base URL |
-| `PNCLI_SDE_TOKEN` | SDElements API token |
+| `PNCLI_SDE_CONNECTION` | SDElements connection string (`api-token@hostname`, e.g. `mytoken@myorg.sdelements.com`) |
 | `PNCLI_CONFIG_PATH` | Override global config file path |
 
 ## For AI Agents
@@ -88,6 +88,8 @@ This project uses Conventional Commits for automatic versioning:
 | SonarQube | ✅ Active | Server Web API |
 | SDElements | ✅ Active | REST API v2 (cloud + on-prem) |
 | Artifactory | 🔜 Coming | The nightmare never ends |
+| Jenkins | 🔜 Coming | REST API |
+| Azure DevOps Server | ✅ Active | REST API v7.1 (on-prem, Windows auth + PAT) |
 
 ## License
 

package/copilot-instructions.md

@@ -13,8 +13,37 @@ pncli is a CLI tool that provides structured JSON access to Jira, Bitbucket, Con
 - Run all commands from the repository root.
 - Project and repo are auto-detected from git remotes. You rarely need `--project` or `--repo` flags.
 
+## Provider Detection
+
+Before running provider-specific commands, ask the user which tools this repository uses:
+
+1. **Work item tracking:** "Does this repo use **Jira** or **Azure DevOps** for work items and tickets?" — this determines whether to use `pncli jira ...` or `pncli ado work ...` commands.
+2. **Source control:** "Does this repo use **Bitbucket** or **Azure DevOps** for pull requests and code review?" — this determines whether to use `pncli bitbucket ...` or `pncli ado repo ...` commands.
+
+Cache the answers for the session. If the user doesn't know, run `git remote -v` — if a URL contains `/_git/` it's Azure DevOps; if it contains `/scm/` it's Bitbucket.
+
+## Installing Skills
+
+pncli ships with Claude Code skills — step-by-step workflow guides that agents can follow. To install them into your repo:
+
+```
+pncli skills install
+```
+
+This downloads the latest pncli skills from GitHub into `.claude/skills/` and also fetches `copilot-instructions.md` into the repo root. Only pncli-managed skills are replaced — any custom skills you've created in `.claude/skills/` are left untouched.
+
+Use `--skip-instructions` to skip downloading `copilot-instructions.md`.
+
+To see what's installed locally:
+
+```
+pncli skills list
+```
+
 ## Common Workflows
 
+> These workflows are also available as Claude Code skills — run `pncli skills install` to download them into your repo, or copy `.claude/skills/` into `~/.claude/skills/` for global access.
+
 ### Review a Pull Request
 
 1. Find the PR for the current branch:
@@ -189,7 +218,10 @@ pncli bitbucket decline-pr
   --id <pr-id>  Pull request ID
 
 pncli bitbucket list-comments
-  --pr <pr-id>  Pull request ID
+  --pr <pr-id>       Pull request ID
+  --no-with-replies  Exclude replies; return top-level comments only
+  --inline-only      Return only inline file comments
+  --general-only     Return only general (non-inline) PR comments
 
 pncli bitbucket add-comment
   --pr <pr-id>   Pull request ID
@@ -493,8 +525,39 @@ pncli config init
 pncli config show
 
 pncli config set
+  --repo      Write to repo config (.pncli.json) instead of global config
 
 pncli config test
+
+pncli config check
+```
+
+### Ado
+
+```
+pncli ado whoami
+
+pncli ado connection-data
+
+pncli ado project
+
+pncli ado work
+
+pncli ado repo
+
+pncli ado pipeline
+```
+
+### Skills
+
+```
+pncli skills install
+  --target <dir>       Target directory for skills (default: ".claude/skills")
+  --skip-instructions  Skip downloading copilot-instructions.md (always written
+  to repo root)
+
+pncli skills list
+  --target <dir>  Skills directory to scan (default: ".claude/skills")
 ```
 
 <!-- COMMAND-REFERENCE:END -->

package/dist/chunk-HWXXNMGE.js

@@ -0,0 +1,558 @@
+#!/usr/bin/env node
+
+// src/lib/http.ts
+import fs2 from "fs";
+
+// src/lib/errors.ts
+var PncliError = class extends Error {
+  status;
+  url;
+  constructor(message, status = 1, url) {
+    super(message);
+    this.name = "PncliError";
+    this.status = status;
+    this.url = url;
+  }
+};
+
+// src/lib/exitCodes.ts
+var ExitCode = {
+  SUCCESS: 0,
+  GENERAL_ERROR: 1,
+  USAGE_ERROR: 2,
+  NETWORK_ERROR: 69,
+  // EX_UNAVAILABLE from sysexits.h
+  AUTH_ERROR: 77,
+  // EX_NOPERM from sysexits.h
+  CONFIG_ERROR: 78
+  // EX_CONFIG from sysexits.h
+};
+function exitCodeFromStatus(httpStatus) {
+  if (httpStatus === 401 || httpStatus === 403) return ExitCode.AUTH_ERROR;
+  if (httpStatus === 0) return ExitCode.NETWORK_ERROR;
+  return ExitCode.GENERAL_ERROR;
+}
+
+// src/lib/output.ts
+import fs from "fs";
+import chalk from "chalk";
+var globalOptions = { pretty: false, verbose: false };
+var globalUser = { email: void 0, userId: void 0 };
+function setGlobalOptions(opts) {
+  globalOptions = opts;
+}
+function setGlobalUser(user) {
+  globalUser = user;
+}
+function buildMeta(service, action, startTime) {
+  return {
+    service,
+    action,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    duration_ms: Date.now() - startTime,
+    user: globalUser.email ?? globalUser.userId ? globalUser : void 0
+  };
+}
+function success(data, service, action, startTime) {
+  const envelope = {
+    ok: true,
+    data,
+    meta: buildMeta(service, action, startTime)
+  };
+  process.stdout.write(
+    (globalOptions.pretty ? JSON.stringify(envelope, null, 2) : JSON.stringify(envelope)) + "\n"
+  );
+}
+function fail(err, service, action, startTime) {
+  const errorDetail = {
+    status: err instanceof PncliError ? err.status : 1,
+    message: err instanceof Error ? err.message : String(err),
+    url: err instanceof PncliError ? err.url ?? null : null
+  };
+  const envelope = {
+    ok: false,
+    error: errorDetail,
+    meta: buildMeta(service, action, startTime)
+  };
+  const msg = globalOptions.pretty ? chalk.red("\u2717 Error: ") + errorDetail.message : null;
+  if (msg) process.stderr.write(msg + "\n");
+  const output = (globalOptions.pretty ? JSON.stringify(envelope, null, 2) : JSON.stringify(envelope)) + "\n";
+  const exitCode = err instanceof PncliError ? exitCodeFromStatus(err.status) : ExitCode.GENERAL_ERROR;
+  try {
+    fs.writeSync(process.stdout.fd, output);
+  } catch (writeErr) {
+    if (writeErr.code !== "EPIPE") throw writeErr;
+  }
+  process.exitCode = exitCode;
+  throw new PncliError(errorDetail.message, errorDetail.status);
+}
+function log(message) {
+  if (globalOptions.verbose) {
+    process.stderr.write(
+      (globalOptions.pretty ? chalk.gray("\u25B8 ") : "") + message + "\n"
+    );
+  }
+}
+function warn(message) {
+  process.stderr.write(
+    (globalOptions.pretty ? chalk.yellow("\u26A0 ") : "") + message + "\n"
+  );
+}
+
+// src/lib/adoFetch.ts
+async function buildAdoFetcher(config) {
+  const { pat, baseUrl } = config.ado;
+  if (!baseUrl) {
+    throw new PncliError("Azure DevOps baseUrl not configured. Run: pncli config init", 1);
+  }
+  if (!pat) {
+    throw new PncliError(
+      "Azure DevOps PAT not configured. Set a PAT via pncli config init or PNCLI_ADO_PAT env var.",
+      1
+    );
+  }
+  const encoded = Buffer.from(":" + pat).toString("base64");
+  const authHeader = `Basic ${encoded}`;
+  return (url, init) => fetch(url, {
+    ...init,
+    headers: {
+      ...init?.headers,
+      "Authorization": authHeader,
+      "Content-Type": "application/json",
+      "Accept": "application/json"
+    }
+  });
+}
+
+// src/lib/http.ts
+function buildUrl(base, path, params) {
+  const url = new URL(path, base.endsWith("/") ? base : base + "/");
+  if (params) {
+    for (const [key, val] of Object.entries(params)) {
+      if (val !== void 0) {
+        url.searchParams.set(key, String(val));
+      }
+    }
+  }
+  return url.toString();
+}
+async function fetchWithTimeout(url, init, timeoutMs, fetcher = fetch) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetcher(url, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function request(url, init, timeoutMs, fetcher = fetch) {
+  let lastError;
+  for (let attempt = 0; attempt < 3; attempt++) {
+    let response;
+    try {
+      response = await fetchWithTimeout(url, init, timeoutMs, fetcher);
+    } catch (err) {
+      throw new PncliError(
+        `Request failed: ${err instanceof Error ? err.message : String(err)}`,
+        0,
+        url
+      );
+    }
+    if (response.status === 429) {
+      const retryAfter = response.headers.get("Retry-After");
+      const waitMs = retryAfter ? parseInt(retryAfter, 10) * 1e3 : (attempt + 1) * 1e3;
+      log(`Rate limited. Retrying after ${waitMs}ms...`);
+      await new Promise((resolve) => setTimeout(resolve, waitMs));
+      lastError = new PncliError("Rate limited", 429, url);
+      continue;
+    }
+    if (!response.ok) {
+      let message = `HTTP ${response.status} ${response.statusText}`;
+      try {
+        const body = await response.text();
+        const parsed = JSON.parse(body);
+        const parts = [];
+        if (Array.isArray(parsed.errorMessages)) {
+          parts.push(...parsed.errorMessages.filter(Boolean));
+        }
+        if (parsed.errors && typeof parsed.errors === "object" && !Array.isArray(parsed.errors)) {
+          for (const [field, msg] of Object.entries(parsed.errors)) {
+            parts.push(`${field}: ${msg}`);
+          }
+        }
+        if (Array.isArray(parsed.errors)) {
+          for (const e of parsed.errors) {
+            if (e?.message) parts.push(e.message);
+            else if (e?.msg) parts.push(e.msg);
+          }
+        }
+        if (parts.length === 0 && parsed.message) {
+          parts.push(String(parsed.message));
+        }
+        if (parts.length > 0) message = parts.join("; ");
+      } catch {
+      }
+      throw new PncliError(message, response.status, url);
+    }
+    if (response.status === 204) {
+      return void 0;
+    }
+    const text = await response.text();
+    if (!text) return void 0;
+    return JSON.parse(text);
+  }
+  throw lastError ?? new PncliError("Request failed after retries", 1, url);
+}
+var HttpClient = class {
+  config;
+  dryRun;
+  adoFetcher = null;
+  constructor(config, dryRun = false) {
+    this.config = config;
+    this.dryRun = dryRun;
+  }
+  jiraHeaders() {
+    const { apiToken } = this.config.jira;
+    if (!apiToken) throw new PncliError("Jira credentials not configured. Run: pncli config init");
+    return {
+      "Authorization": `Bearer ${apiToken}`,
+      "Content-Type": "application/json",
+      "Accept": "application/json",
+      "Connection": "close"
+    };
+  }
+  bitbucketHeaders() {
+    const { pat } = this.config.bitbucket;
+    if (!pat) throw new PncliError("Bitbucket credentials not configured. Run: pncli config init");
+    return {
+      "Authorization": `Bearer ${pat}`,
+      "Content-Type": "application/json",
+      "Accept": "application/json",
+      "Connection": "close"
+    };
+  }
+  async jira(path, opts = {}) {
+    const baseUrl = this.config.jira.baseUrl;
+    if (!baseUrl) throw new PncliError("Jira baseUrl not configured. Run: pncli config init");
+    const url = buildUrl(baseUrl, path, opts.params);
+    const headers = this.jiraHeaders();
+    const init = {
+      method: opts.method ?? "GET",
+      headers,
+      body: opts.body !== void 0 ? JSON.stringify(opts.body) : void 0
+    };
+    if (this.dryRun) {
+      const safeHeaders = { ...headers, Authorization: "[REDACTED]" };
+      const msg = `DRY RUN: ${init.method} ${url}
+Headers: ${JSON.stringify(safeHeaders, null, 2)}
+` + (opts.body ? `Body: ${JSON.stringify(opts.body, null, 2)}
+` : "");
+      fs2.writeSync(process.stderr.fd, msg);
+      process.exitCode = ExitCode.SUCCESS;
+      throw new PncliError("dry-run", 0);
+    }
+    return request(url, init, opts.timeoutMs ?? 3e4);
+  }
+  async bitbucket(path, opts = {}) {
+    const baseUrl = this.config.bitbucket.baseUrl;
+    if (!baseUrl) throw new PncliError("Bitbucket baseUrl not configured. Run: pncli config init");
+    const url = buildUrl(baseUrl, path, opts.params);
+    const headers = this.bitbucketHeaders();
+    const init = {
+      method: opts.method ?? "GET",
+      headers,
+      body: opts.body !== void 0 ? JSON.stringify(opts.body) : void 0
+    };
+    if (this.dryRun) {
+      const safeHeaders = { ...headers, Authorization: "[REDACTED]" };
+      const msg = `DRY RUN: ${init.method} ${url}
+Headers: ${JSON.stringify(safeHeaders, null, 2)}
+` + (opts.body ? `Body: ${JSON.stringify(opts.body, null, 2)}
+` : "");
+      fs2.writeSync(process.stderr.fd, msg);
+      process.exitCode = ExitCode.SUCCESS;
+      throw new PncliError("dry-run", 0);
+    }
+    return request(url, init, opts.timeoutMs ?? 3e4);
+  }
+  confluenceHeaders() {
+    const { apiToken } = this.config.confluence;
+    if (!apiToken) throw new PncliError("Confluence credentials not configured. Run: pncli config init");
+    return {
+      "Authorization": `Bearer ${apiToken}`,
+      "Content-Type": "application/json",
+      "Accept": "application/json",
+      "Connection": "close"
+    };
+  }
+  async confluence(path, opts = {}) {
+    const baseUrl = this.config.confluence.baseUrl;
+    if (!baseUrl) throw new PncliError("Confluence baseUrl not configured. Run: pncli config init");
+    const url = buildUrl(baseUrl, path, opts.params);
+    const headers = this.confluenceHeaders();
+    const init = {
+      method: opts.method ?? "GET",
+      headers,
+      body: opts.body !== void 0 ? JSON.stringify(opts.body) : void 0
+    };
+    if (this.dryRun) {
+      const safeHeaders = { ...headers, Authorization: "[REDACTED]" };
+      const msg = `DRY RUN: ${init.method} ${url}
+Headers: ${JSON.stringify(safeHeaders, null, 2)}
+` + (opts.body ? `Body: ${JSON.stringify(opts.body, null, 2)}
+` : "");
+      fs2.writeSync(process.stderr.fd, msg);
+      process.exitCode = ExitCode.SUCCESS;
+      throw new PncliError("dry-run", 0);
+    }
+    return request(url, init, opts.timeoutMs ?? 3e4);
+  }
+  sdeHeaders() {
+    const { token } = this.config.sde;
+    if (!token) throw new PncliError("SDElements credentials not configured. Run: pncli config init");
+    return {
+      "Authorization": `Token ${token}`,
+      "Content-Type": "application/json",
+      "Accept": "application/json",
+      "Connection": "close"
+    };
+  }
+  async sde(path, opts = {}) {
+    const baseUrl = this.config.sde.baseUrl;
+    if (!baseUrl) throw new PncliError("SDElements baseUrl not configured. Run: pncli config init");
+    const url = buildUrl(baseUrl, path, opts.params);
+    const headers = this.sdeHeaders();
+    const init = {
+      method: opts.method ?? "GET",
+      headers,
+      body: opts.body !== void 0 ? JSON.stringify(opts.body) : void 0
+    };
+    if (this.dryRun) {
+      const safeHeaders = { ...headers, Authorization: "[REDACTED]" };
+      const msg = `DRY RUN: ${init.method} ${url}
+Headers: ${JSON.stringify(safeHeaders, null, 2)}
+` + (opts.body ? `Body: ${JSON.stringify(opts.body, null, 2)}
+` : "");
+      fs2.writeSync(process.stderr.fd, msg);
+      process.exitCode = ExitCode.SUCCESS;
+      throw new PncliError("dry-run", 0);
+    }
+    return request(url, init, opts.timeoutMs ?? 3e4);
+  }
+  async sdePaginate(fetchPage) {
+    const results = [];
+    let page = 1;
+    const pageSize = 100;
+    while (true) {
+      const response = await fetchPage(page, pageSize);
+      results.push(...response.results);
+      if (results.length >= response.count || response.results.length === 0) break;
+      page++;
+    }
+    return results;
+  }
+  async getAdoFetcher() {
+    if (!this.adoFetcher) {
+      this.adoFetcher = await buildAdoFetcher(this.config);
+    }
+    return this.adoFetcher;
+  }
+  async ado(path, opts = {}) {
+    const baseUrl = this.config.ado.baseUrl;
+    if (!baseUrl) throw new PncliError("Azure DevOps baseUrl not configured. Run: pncli config init");
+    const url = buildUrl(baseUrl, path, opts.params);
+    if (this.dryRun) {
+      const msg = `DRY RUN: ${opts.method ?? "GET"} ${url}
+` + (opts.body ? `Body: ${JSON.stringify(opts.body, null, 2)}
+` : "");
+      fs2.writeSync(process.stderr.fd, msg);
+      process.exitCode = ExitCode.SUCCESS;
+      throw new PncliError("dry-run", 0);
+    }
+    const fetcher = await this.getAdoFetcher();
+    const defaultHeaders = {
+      "Accept": "application/json",
+      "Content-Type": "application/json",
+      ...opts.headers
+    };
+    const init = {
+      method: opts.method ?? "GET",
+      headers: defaultHeaders,
+      body: opts.body !== void 0 ? JSON.stringify(opts.body) : void 0
+    };
+    return request(url, init, opts.timeoutMs ?? 3e4, fetcher);
+  }
+  async adoText(path, opts = {}) {
+    const baseUrl = this.config.ado.baseUrl;
+    if (!baseUrl) throw new PncliError("Azure DevOps baseUrl not configured. Run: pncli config init");
+    const url = buildUrl(baseUrl, path, opts.params);
+    if (this.dryRun) {
+      fs2.writeSync(process.stderr.fd, `DRY RUN: ${opts.method ?? "GET"} ${url}
+`);
+      process.exitCode = ExitCode.SUCCESS;
+      throw new PncliError("dry-run", 0);
+    }
+    const fetcher = await this.getAdoFetcher();
+    const response = await fetchWithTimeout(url, {
+      method: opts.method ?? "GET",
+      headers: { "Accept": "text/plain", ...opts.headers }
+    }, opts.timeoutMs ?? 3e4, fetcher);
+    if (!response.ok) {
+      let message = `HTTP ${response.status} ${response.statusText}`;
+      try {
+        const parsed = JSON.parse(await response.text());
+        if (parsed.message) message = String(parsed.message);
+      } catch {
+      }
+      throw new PncliError(message, response.status, url);
+    }
+    return response.text();
+  }
+  async adoRaw(path, opts = {}) {
+    const baseUrl = this.config.ado.baseUrl;
+    if (!baseUrl) throw new PncliError("Azure DevOps baseUrl not configured. Run: pncli config init");
+    const url = buildUrl(baseUrl, path, opts.params);
+    if (this.dryRun) {
+      fs2.writeSync(process.stderr.fd, `DRY RUN: ${opts.method ?? "GET"} ${url}
+`);
+      process.exitCode = ExitCode.SUCCESS;
+      throw new PncliError("dry-run", 0);
+    }
+    const fetcher = await this.getAdoFetcher();
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), opts.timeoutMs ?? 3e4);
+    let response;
+    try {
+      response = await fetcher(url, {
+        method: opts.method ?? "GET",
+        headers: { "Accept": "application/json", "Content-Type": "application/json", ...opts.headers },
+        body: opts.body !== void 0 ? JSON.stringify(opts.body) : void 0,
+        signal: controller.signal
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+    if (!response.ok) {
+      let message = `HTTP ${response.status} ${response.statusText}`;
+      try {
+        const parsed = JSON.parse(await response.text());
+        if (parsed.message) message = String(parsed.message);
+      } catch {
+      }
+      throw new PncliError(message, response.status, url);
+    }
+    const text = await response.text();
+    const data = text ? JSON.parse(text) : void 0;
+    return { data, headers: response.headers };
+  }
+  async adoPaginate(fetchPage) {
+    const results = [];
+    let token;
+    while (true) {
+      const { data, headers } = await fetchPage(token);
+      results.push(...data.value ?? []);
+      const next = headers.get("x-ms-continuationtoken");
+      if (!next) break;
+      token = next;
+    }
+    return results;
+  }
+  sonarHeaders() {
+    const { token } = this.config.sonar;
+    if (!token) throw new PncliError("SonarQube credentials not configured. Run: pncli config init");
+    return {
+      "Authorization": `Bearer ${token}`,
+      "Content-Type": "application/json",
+      "Accept": "application/json",
+      "Connection": "close"
+    };
+  }
+  async sonar(path, opts = {}) {
+    const baseUrl = this.config.sonar.baseUrl;
+    if (!baseUrl) throw new PncliError("SonarQube baseUrl not configured. Run: pncli config init");
+    const url = buildUrl(baseUrl, path, opts.params);
+    const headers = this.sonarHeaders();
+    const init = {
+      method: opts.method ?? "GET",
+      headers,
+      body: opts.body !== void 0 ? JSON.stringify(opts.body) : void 0
+    };
+    if (this.dryRun) {
+      const safeHeaders = { ...headers, Authorization: "[REDACTED]" };
+      const msg = `DRY RUN: ${init.method} ${url}
+Headers: ${JSON.stringify(safeHeaders, null, 2)}
+` + (opts.body ? `Body: ${JSON.stringify(opts.body, null, 2)}
+` : "");
+      fs2.writeSync(process.stderr.fd, msg);
+      process.exitCode = ExitCode.SUCCESS;
+      throw new PncliError("dry-run", 0);
+    }
+    return request(url, init, opts.timeoutMs ?? 3e4);
+  }
+  async sonarPaginate(fetchPage) {
+    const results = [];
+    let page = 1;
+    const pageSize = 500;
+    while (true) {
+      const response = await fetchPage(page, pageSize);
+      results.push(...response.items);
+      if (results.length >= response.total || response.items.length === 0) break;
+      page++;
+    }
+    return results;
+  }
+  async confluencePaginate(fetchPage) {
+    const results = [];
+    let start = 0;
+    const limit = 25;
+    while (true) {
+      const page = await fetchPage(start, limit);
+      results.push(...page.results);
+      if (!page._links.next) break;
+      start += page.size;
+    }
+    return results;
+  }
+  async paginate(fetchPage) {
+    const results = [];
+    let start = 0;
+    const limit = 100;
+    while (true) {
+      const page = await fetchPage(start, limit);
+      results.push(...page.values);
+      if (page.isLastPage) break;
+      start = page.nextPageStart ?? start + limit;
+    }
+    return results;
+  }
+  async jiraPaginate(fetchPage) {
+    const results = [];
+    let startAt = 0;
+    const maxResults = 100;
+    while (true) {
+      const page = await fetchPage(startAt, maxResults);
+      const items = page.issues ?? page.values ?? [];
+      results.push(...items);
+      startAt += items.length;
+      if (startAt >= page.total || items.length === 0) break;
+    }
+    return results;
+  }
+};
+function createHttpClient(config, dryRun = false) {
+  return new HttpClient(config, dryRun);
+}
+
+export {
+  PncliError,
+  ExitCode,
+  setGlobalOptions,
+  setGlobalUser,
+  success,
+  fail,
+  log,
+  warn,
+  HttpClient,
+  createHttpClient
+};
+//# sourceMappingURL=chunk-HWXXNMGE.js.map