@kolatts/pncli 1.0.1

package/dist/cli.js

@@ -0,0 +1,1536 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import { createRequire } from "module";
+
+// src/lib/output.ts
+import chalk from "chalk";
+
+// 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/output.ts
+var globalOptions = { pretty: false, verbose: false };
+function setGlobalOptions(opts) {
+  globalOptions = opts;
+}
+function buildMeta(service, action, startTime) {
+  return {
+    service,
+    action,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    duration_ms: Date.now() - startTime
+  };
+}
+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");
+  process.stdout.write(
+    (globalOptions.pretty ? JSON.stringify(envelope, null, 2) : JSON.stringify(envelope)) + "\n"
+  );
+  process.exit(1);
+}
+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/services/git/client.ts
+import { execSync, execFileSync } from "child_process";
+var DIFF_LINE_LIMIT = 5e3;
+function exec(cmd, cwd) {
+  return execSync(cmd, { encoding: "utf8", cwd }).trim();
+}
+function getStatus(root) {
+  const output = exec("git status --porcelain", root);
+  const staged = [];
+  const unstaged = [];
+  const untracked = [];
+  if (!output) return { staged, unstaged, untracked };
+  for (const line of output.split("\n")) {
+    if (!line) continue;
+    const x = line[0];
+    const y = line[1];
+    const file = line.slice(3);
+    if (x === "?" && y === "?") {
+      untracked.push(file);
+    } else {
+      if (x !== " " && x !== "?") staged.push(file);
+      if (y !== " " && y !== "?") unstaged.push(file);
+    }
+  }
+  return { staged, unstaged, untracked };
+}
+function parseHunkHeader(header) {
+  const match = header.match(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+  if (!match) return { oldStart: 0, oldCount: 0, newStart: 0, newCount: 0 };
+  return {
+    oldStart: parseInt(match[1], 10),
+    oldCount: parseInt(match[2] ?? "1", 10),
+    newStart: parseInt(match[3], 10),
+    newCount: parseInt(match[4] ?? "1", 10)
+  };
+}
+function parseDiff(rawDiff) {
+  const lines = rawDiff.split("\n");
+  const files = [];
+  let globalTruncated = false;
+  let lineCount = 0;
+  let currentFile = null;
+  let currentHunk = null;
+  for (const line of lines) {
+    lineCount++;
+    if (lineCount > DIFF_LINE_LIMIT) {
+      globalTruncated = true;
+      if (currentFile) currentFile.truncated = true;
+      break;
+    }
+    if (line.startsWith("diff --git ")) {
+      if (currentHunk && currentFile) currentFile.hunks.push(currentHunk);
+      currentHunk = null;
+      if (currentFile) files.push(currentFile);
+      const pathMatch = line.match(/diff --git a\/(.+) b\/.+$/);
+      currentFile = {
+        path: pathMatch ? pathMatch[1] : line,
+        binary: false,
+        truncated: false,
+        hunks: []
+      };
+      continue;
+    }
+    if (!currentFile) continue;
+    if (line.startsWith("Binary files")) {
+      currentFile.binary = true;
+      continue;
+    }
+    if (line.startsWith("@@ ")) {
+      if (currentHunk) currentFile.hunks.push(currentHunk);
+      const { oldStart, oldCount, newStart, newCount } = parseHunkHeader(line);
+      currentHunk = { oldStart, oldCount, newStart, newCount, lines: [] };
+      continue;
+    }
+    if (currentHunk && (line.startsWith("+") || line.startsWith("-") || line.startsWith(" "))) {
+      currentHunk.lines.push(line);
+    }
+  }
+  if (currentHunk && currentFile) currentFile.hunks.push(currentHunk);
+  if (currentFile) files.push(currentFile);
+  return { files, truncated: globalTruncated };
+}
+function getDiff(root, opts) {
+  const args = ["git", "diff"];
+  if (opts.staged) args.push("--staged");
+  if (opts.file) args.push("--", opts.file);
+  try {
+    const raw = exec(args.join(" "), root);
+    if (!raw) return { files: [], truncated: false };
+    return parseDiff(raw);
+  } catch {
+    return { files: [], truncated: false };
+  }
+}
+function getLog(root, opts) {
+  const sep = "";
+  const fmt = `%H${sep}%an${sep}%aI${sep}%s`;
+  const args = [`log`, `--format=${fmt}`];
+  if (opts.count) args.push(`-n`, String(opts.count));
+  if (opts.since) args.push(`--since=${opts.since}`);
+  try {
+    const output = execFileSync("git", args, { encoding: "utf8", cwd: root }).trim();
+    if (!output) return [];
+    return output.split("\n").filter(Boolean).map((line) => {
+      const parts = line.split(sep);
+      return {
+        hash: parts[0] ?? "",
+        author: parts[1] ?? "",
+        date: parts[2] ?? "",
+        message: parts[3] ?? ""
+      };
+    });
+  } catch {
+    return [];
+  }
+}
+function getBranches(root) {
+  const output = exec("git branch -a", root);
+  const local = [];
+  const remote = [];
+  let current = "";
+  for (const line of output.split("\n")) {
+    if (!line.trim()) continue;
+    const isCurrent = line.startsWith("*");
+    const name = line.replace(/^\*?\s+/, "").trim();
+    if (name.startsWith("remotes/")) {
+      remote.push(name.replace("remotes/", ""));
+    } else {
+      if (isCurrent) current = name;
+      local.push(name);
+    }
+  }
+  return { current, local, remote };
+}
+
+// src/lib/git-context.ts
+import { execSync as execSync2 } from "child_process";
+function getRepoRoot() {
+  try {
+    return execSync2("git rev-parse --show-toplevel", { encoding: "utf8" }).trim();
+  } catch {
+    return null;
+  }
+}
+function getCurrentBranch(repoRoot) {
+  try {
+    return execSync2("git rev-parse --abbrev-ref HEAD", {
+      encoding: "utf8",
+      cwd: repoRoot
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+function parseRemote(remoteUrl, bitbucketBaseUrl) {
+  if (!bitbucketBaseUrl) return null;
+  const base = bitbucketBaseUrl.replace(/\/$/, "").replace(/^https?:\/\//, "");
+  const sshMatch = remoteUrl.match(/^git@([^:]+)(?::\d+)?[:/]([^/]+)\/([^/]+?)(?:\.git)?$/);
+  if (sshMatch) {
+    const [, host, project, repo] = sshMatch;
+    if (host && base.includes(host)) {
+      return { project, repo };
+    }
+  }
+  const httpsMatch = remoteUrl.match(/^https?:\/\/([^/]+)\/scm\/([^/]+)\/([^/]+?)(?:\.git)?$/);
+  if (httpsMatch) {
+    const [, host, project, repo] = httpsMatch;
+    if (host && base.includes(host)) {
+      return { project, repo };
+    }
+  }
+  return null;
+}
+function getRemoteUrls(repoRoot) {
+  try {
+    const output = execSync2("git remote -v", { encoding: "utf8", cwd: repoRoot });
+    return output.split("\n").filter((line) => line.includes("(fetch)")).map((line) => line.split("	")[1]?.split(" ")[0] ?? "").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function getGitContext(config) {
+  const root = getRepoRoot();
+  if (!root) return null;
+  const branch = getCurrentBranch(root) ?? "unknown";
+  const remoteUrls = getRemoteUrls(root);
+  let project = null;
+  let repo = null;
+  for (const url of remoteUrls) {
+    const parsed = parseRemote(url, config.bitbucket.baseUrl);
+    if (parsed) {
+      project = parsed.project;
+      repo = parsed.repo;
+      break;
+    }
+  }
+  return { root, branch, project, repo };
+}
+
+// src/lib/config.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { execSync as execSync3 } from "child_process";
+var ENV_KEYS = {
+  JIRA_BASE_URL: "PNCLI_JIRA_BASE_URL",
+  JIRA_EMAIL: "PNCLI_JIRA_EMAIL",
+  JIRA_API_TOKEN: "PNCLI_JIRA_API_TOKEN",
+  BITBUCKET_BASE_URL: "PNCLI_BITBUCKET_BASE_URL",
+  BITBUCKET_PAT: "PNCLI_BITBUCKET_PAT",
+  CONFIG_PATH: "PNCLI_CONFIG_PATH"
+};
+function getGlobalConfigPath(overridePath) {
+  if (overridePath) return overridePath;
+  const envPath = process.env[ENV_KEYS.CONFIG_PATH];
+  if (envPath) return envPath;
+  return path.join(os.homedir(), ".pncli", "config.json");
+}
+function loadJsonFile(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function getRepoRoot2() {
+  try {
+    return execSync3("git rev-parse --show-toplevel", { encoding: "utf8" }).trim();
+  } catch {
+    return null;
+  }
+}
+function mergeDefaults(global, repo) {
+  return {
+    jira: { ...global?.jira, ...repo?.jira },
+    bitbucket: { ...global?.bitbucket, ...repo?.bitbucket }
+  };
+}
+function loadConfig(opts = {}) {
+  const globalConfigPath = getGlobalConfigPath(opts.configPath);
+  const globalConfig = loadJsonFile(globalConfigPath) ?? {};
+  const repoRoot = getRepoRoot2();
+  let repoConfig = {};
+  if (repoRoot) {
+    repoConfig = loadJsonFile(path.join(repoRoot, ".pncli.json")) ?? {};
+  }
+  const mergedDefaults = mergeDefaults(globalConfig.defaults, repoConfig.defaults);
+  return {
+    jira: {
+      baseUrl: process.env[ENV_KEYS.JIRA_BASE_URL] ?? globalConfig.jira?.baseUrl,
+      email: process.env[ENV_KEYS.JIRA_EMAIL] ?? globalConfig.jira?.email,
+      apiToken: process.env[ENV_KEYS.JIRA_API_TOKEN] ?? globalConfig.jira?.apiToken
+    },
+    bitbucket: {
+      baseUrl: process.env[ENV_KEYS.BITBUCKET_BASE_URL] ?? globalConfig.bitbucket?.baseUrl,
+      pat: process.env[ENV_KEYS.BITBUCKET_PAT] ?? globalConfig.bitbucket?.pat
+    },
+    defaults: mergedDefaults
+  };
+}
+function writeGlobalConfig(config, configPath) {
+  const filePath = getGlobalConfigPath(configPath);
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n", "utf8");
+}
+function writeRepoConfig(config) {
+  const repoRoot = getRepoRoot2();
+  const targetDir = repoRoot ?? process.cwd();
+  fs.writeFileSync(path.join(targetDir, ".pncli.json"), JSON.stringify(config, null, 2) + "\n", "utf8");
+}
+function setConfigValue(key, value, configPath) {
+  const filePath = getGlobalConfigPath(configPath);
+  const existing = loadJsonFile(filePath) ?? {};
+  const parts = key.split(".");
+  let current = existing;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (typeof current[part] !== "object" || current[part] === null) {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  current[parts[parts.length - 1]] = value;
+  writeGlobalConfig(existing, configPath);
+}
+function maskConfig(config) {
+  return {
+    ...config,
+    jira: {
+      ...config.jira,
+      apiToken: config.jira.apiToken ? "***" : void 0
+    },
+    bitbucket: {
+      ...config.bitbucket,
+      pat: config.bitbucket.pat ? "***" : void 0
+    }
+  };
+}
+
+// src/lib/http.ts
+function buildUrl(base, path2, params) {
+  const url = new URL(path2, 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) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function request(url, init, timeoutMs) {
+  let lastError;
+  for (let attempt = 0; attempt < 3; attempt++) {
+    let response;
+    try {
+      response = await fetchWithTimeout(url, init, timeoutMs);
+    } 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);
+        if (parsed.message) message = parsed.message;
+        else if (parsed.errors?.[0]?.message) message = parsed.errors[0].message;
+      } catch {
+      }
+      throw new PncliError(message, response.status, url);
+    }
+    if (response.status === 204) {
+      return void 0;
+    }
+    return response.json();
+  }
+  throw lastError ?? new PncliError("Request failed after retries", 1, url);
+}
+var HttpClient = class {
+  config;
+  dryRun;
+  constructor(config, dryRun = false) {
+    this.config = config;
+    this.dryRun = dryRun;
+  }
+  jiraHeaders() {
+    const { email, apiToken } = this.config.jira;
+    if (!email || !apiToken) throw new PncliError("Jira credentials not configured. Run: pncli config init");
+    const token = Buffer.from(`${email}:${apiToken}`).toString("base64");
+    return {
+      "Authorization": `Basic ${token}`,
+      "Content-Type": "application/json",
+      "Accept": "application/json"
+    };
+  }
+  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"
+    };
+  }
+  async jira(path2, opts = {}) {
+    const baseUrl = this.config.jira.baseUrl;
+    if (!baseUrl) throw new PncliError("Jira baseUrl not configured. Run: pncli config init");
+    const url = buildUrl(baseUrl, path2, 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]" };
+      process.stderr.write(`DRY RUN: ${init.method} ${url}
+Headers: ${JSON.stringify(safeHeaders, null, 2)}
+`);
+      if (opts.body) process.stderr.write(`Body: ${JSON.stringify(opts.body, null, 2)}
+`);
+      process.exit(0);
+    }
+    return request(url, init, opts.timeoutMs ?? 3e4);
+  }
+  async bitbucket(path2, opts = {}) {
+    const baseUrl = this.config.bitbucket.baseUrl;
+    if (!baseUrl) throw new PncliError("Bitbucket baseUrl not configured. Run: pncli config init");
+    const url = buildUrl(baseUrl, path2, 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]" };
+      process.stderr.write(`DRY RUN: ${init.method} ${url}
+Headers: ${JSON.stringify(safeHeaders, null, 2)}
+`);
+      if (opts.body) process.stderr.write(`Body: ${JSON.stringify(opts.body, null, 2)}
+`);
+      process.exit(0);
+    }
+    return request(url, init, opts.timeoutMs ?? 3e4);
+  }
+  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);
+}
+
+// src/services/bitbucket/client.ts
+var API = "/rest/api/1.0";
+var BitbucketClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  async listPRs(opts) {
+    return this.http.paginate(
+      (start, limit) => this.http.bitbucket(
+        `${API}/projects/${opts.project}/repos/${opts.repo}/pull-requests`,
+        {
+          params: {
+            state: opts.state ?? "OPEN",
+            ...opts.author ? { "author.username": opts.author } : {},
+            start,
+            limit
+          }
+        }
+      )
+    );
+  }
+  async getPR(project, repo, id) {
+    return this.http.bitbucket(
+      `${API}/projects/${project}/repos/${repo}/pull-requests/${id}`
+    );
+  }
+  async createPR(opts) {
+    return this.http.bitbucket(
+      `${API}/projects/${opts.project}/repos/${opts.repo}/pull-requests`,
+      {
+        method: "POST",
+        body: {
+          title: opts.title,
+          description: opts.description,
+          fromRef: {
+            id: `refs/heads/${opts.source}`,
+            repository: {
+              slug: opts.repo,
+              project: { key: opts.project }
+            }
+          },
+          toRef: {
+            id: `refs/heads/${opts.target}`,
+            repository: {
+              slug: opts.repo,
+              project: { key: opts.project }
+            }
+          },
+          reviewers: (opts.reviewers ?? []).map((slug) => ({ user: { slug } }))
+        }
+      }
+    );
+  }
+  async updatePR(opts) {
+    const body = { version: opts.version };
+    if (opts.title) body.title = opts.title;
+    if (opts.description !== void 0) body.description = opts.description;
+    if (opts.reviewers) body.reviewers = opts.reviewers.map((slug) => ({ user: { slug } }));
+    return this.http.bitbucket(
+      `${API}/projects/${opts.project}/repos/${opts.repo}/pull-requests/${opts.id}`,
+      { method: "PUT", body }
+    );
+  }
+  async mergePR(opts) {
+    const params = {
+      version: opts.version
+    };
+    const body = {};
+    if (opts.strategy) body.strategyId = opts.strategy;
+    if (opts.deleteBranch) body.autoSubject = true;
+    return this.http.bitbucket(
+      `${API}/projects/${opts.project}/repos/${opts.repo}/pull-requests/${opts.id}/merge`,
+      { method: "POST", params, body }
+    );
+  }
+  async declinePR(project, repo, id, version) {
+    return this.http.bitbucket(
+      `${API}/projects/${project}/repos/${repo}/pull-requests/${id}/decline`,
+      { method: "POST", params: { version } }
+    );
+  }
+  async listComments(project, repo, prId) {
+    const activities = await this.http.paginate(
+      (start, limit) => this.http.bitbucket(
+        `${API}/projects/${project}/repos/${repo}/pull-requests/${prId}/activities`,
+        { params: { start, limit } }
+      )
+    );
+    return activities.filter((a) => a.action === "COMMENTED" && a.comment).map((a) => a.comment);
+  }
+  async addComment(project, repo, prId, text) {
+    return this.http.bitbucket(
+      `${API}/projects/${project}/repos/${repo}/pull-requests/${prId}/comments`,
+      { method: "POST", body: { text } }
+    );
+  }
+  async addInlineComment(opts) {
+    return this.http.bitbucket(
+      `${API}/projects/${opts.project}/repos/${opts.repo}/pull-requests/${opts.prId}/comments`,
+      {
+        method: "POST",
+        body: {
+          text: opts.text,
+          anchor: {
+            line: opts.line,
+            lineType: opts.lineType ?? "ADDED",
+            fileType: "TO",
+            path: opts.filePath
+          }
+        }
+      }
+    );
+  }
+  async replyComment(project, repo, prId, commentId, text) {
+    return this.http.bitbucket(
+      `${API}/projects/${project}/repos/${repo}/pull-requests/${prId}/comments`,
+      { method: "POST", body: { text, parent: { id: commentId } } }
+    );
+  }
+  async resolveComment(project, repo, prId, commentId, version) {
+    await this.http.bitbucket(
+      `${API}/projects/${project}/repos/${repo}/pull-requests/${prId}/comments/${commentId}/resolve`,
+      { method: "PUT", params: { version } }
+    );
+  }
+  async deleteComment(project, repo, prId, commentId, version) {
+    await this.http.bitbucket(
+      `${API}/projects/${project}/repos/${repo}/pull-requests/${prId}/comments/${commentId}`,
+      { method: "DELETE", params: { version } }
+    );
+  }
+  async getDiff(project, repo, prId, file, contextLines) {
+    const params = {};
+    if (contextLines !== void 0) params.contextLines = contextLines;
+    if (file) params.path = file;
+    const result = await this.http.bitbucket(
+      `${API}/projects/${project}/repos/${repo}/pull-requests/${prId}/diff`,
+      { params }
+    );
+    return typeof result === "string" ? result : JSON.stringify(result);
+  }
+  async listFiles(project, repo, prId) {
+    const result = await this.http.bitbucket(
+      `${API}/projects/${project}/repos/${repo}/pull-requests/${prId}/changes`,
+      { params: { limit: 1e3 } }
+    );
+    return (result.values ?? []).map((v) => typeof v.path === "string" ? v.path : JSON.stringify(v.path));
+  }
+  async approvePR(project, repo, prId) {
+    return this.http.bitbucket(
+      `${API}/projects/${project}/repos/${repo}/pull-requests/${prId}/participants/~`,
+      { method: "PUT", body: { status: "APPROVED" } }
+    );
+  }
+  async unapprovePR(project, repo, prId) {
+    return this.http.bitbucket(
+      `${API}/projects/${project}/repos/${repo}/pull-requests/${prId}/participants/~`,
+      { method: "DELETE" }
+    );
+  }
+  async needsWorkPR(project, repo, prId) {
+    return this.http.bitbucket(
+      `${API}/projects/${project}/repos/${repo}/pull-requests/${prId}/participants/~`,
+      { method: "PUT", body: { status: "NEEDS_WORK" } }
+    );
+  }
+  async listReviewers(project, repo, prId) {
+    const pr = await this.getPR(project, repo, prId);
+    return pr.reviewers;
+  }
+  async listBuilds(project, repo, prId) {
+    const commits = await this.http.bitbucket(
+      `${API}/projects/${project}/repos/${repo}/pull-requests/${prId}/commits`,
+      { params: { limit: 1 } }
+    );
+    const sha = commits.values[0]?.id;
+    if (!sha) return [];
+    return this.getBuildStatus(sha);
+  }
+  async getBuildStatus(commit) {
+    const result = await this.http.bitbucket(
+      `/rest/build-status/1.0/commits/${commit}`
+    );
+    return result.values ?? [];
+  }
+};
+
+// src/services/git/commands.ts
+function requireRepoRoot() {
+  const root = getRepoRoot();
+  if (!root) throw new PncliError("Not a git repository", 1);
+  return root;
+}
+function registerGitCommands(program2) {
+  const git = program2.command("git").description("Local git operations");
+  git.command("status").description("Show staged, unstaged, and untracked files as JSON").action(() => {
+    const start = Date.now();
+    try {
+      const root = requireRepoRoot();
+      const data = getStatus(root);
+      success(data, "git", "status", start);
+    } catch (err) {
+      fail(err, "git", "status", start);
+    }
+  });
+  git.command("diff").description("Show diff as structured JSON").option("--staged", "Show staged changes only").option("--file <path>", "Limit diff to a specific file").action((opts) => {
+    const start = Date.now();
+    try {
+      const root = requireRepoRoot();
+      const data = getDiff(root, { staged: opts.staged, file: opts.file });
+      success(data, "git", "diff", start);
+    } catch (err) {
+      fail(err, "git", "diff", start);
+    }
+  });
+  git.command("log").description("Show recent commits as JSON").option("--count <n>", "Number of commits to show", "10").option("--since <date>", 'Show commits since date (e.g. "2 weeks ago")').action((opts) => {
+    const start = Date.now();
+    try {
+      const root = requireRepoRoot();
+      const count = opts.count ? parseInt(opts.count, 10) : void 0;
+      const data = getLog(root, { count, since: opts.since });
+      success(data, "git", "log", start);
+    } catch (err) {
+      fail(err, "git", "log", start);
+    }
+  });
+  git.command("branch").description("Show current branch and all local/remote branches").action(() => {
+    const start = Date.now();
+    try {
+      const root = requireRepoRoot();
+      const data = getBranches(root);
+      success(data, "git", "branch", start);
+    } catch (err) {
+      fail(err, "git", "branch", start);
+    }
+  });
+  git.command("current-pr").description("Find the open PR for the current branch").action(async () => {
+    const start = Date.now();
+    try {
+      const opts = program2.optsWithGlobals();
+      const config = loadConfig({ configPath: opts.config });
+      if (!config.bitbucket.baseUrl || !config.bitbucket.pat) {
+        success(
+          { message: "Requires Bitbucket config. Available after pncli config init." },
+          "git",
+          "current-pr",
+          start
+        );
+        return;
+      }
+      const root = requireRepoRoot();
+      const branch = getCurrentBranch(root);
+      if (!branch) throw new PncliError("Could not determine current branch", 1);
+      const ctx = getGitContext(config);
+      const project = ctx?.project ?? config.defaults.bitbucket?.project ?? "";
+      const repo = ctx?.repo ?? config.defaults.bitbucket?.repo ?? "";
+      if (!project || !repo) throw new PncliError("Could not determine Bitbucket project/repo", 1);
+      const http = createHttpClient(config, Boolean(opts.dryRun));
+      const client = new BitbucketClient(http);
+      const prs = await client.listPRs({ project, repo, state: "OPEN" });
+      const match = prs.find((pr) => pr.fromRef.displayId === branch) ?? null;
+      success(match, "git", "current-pr", start);
+    } catch (err) {
+      fail(err, "git", "current-pr", start);
+    }
+  });
+}
+
+// src/services/jira/client.ts
+var API2 = "/rest/api/3";
+var JiraClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  async getIssue(key) {
+    return this.http.jira(`${API2}/issue/${key}`);
+  }
+  async createIssue(opts) {
+    const body = {
+      fields: {
+        project: { key: opts.project },
+        issuetype: { name: opts.issueType },
+        summary: opts.summary,
+        ...opts.description ? {
+          description: {
+            type: "doc",
+            version: 1,
+            content: [{ type: "paragraph", content: [{ type: "text", text: opts.description }] }]
+          }
+        } : {},
+        ...opts.priority ? { priority: { name: opts.priority } } : {},
+        ...opts.assignee ? { assignee: { accountId: opts.assignee } } : {},
+        ...opts.labels?.length ? { labels: opts.labels } : {}
+      }
+    };
+    const created = await this.http.jira(`${API2}/issue`, {
+      method: "POST",
+      body
+    });
+    return this.getIssue(created.key);
+  }
+  async updateIssue(key, opts) {
+    const fields = {};
+    if (opts.summary) fields.summary = opts.summary;
+    if (opts.description) {
+      fields.description = {
+        type: "doc",
+        version: 1,
+        content: [{ type: "paragraph", content: [{ type: "text", text: opts.description }] }]
+      };
+    }
+    if (opts.priority) fields.priority = { name: opts.priority };
+    if (opts.assignee) fields.assignee = { accountId: opts.assignee };
+    if (opts.labels) fields.labels = opts.labels;
+    await this.http.jira(`${API2}/issue/${key}`, {
+      method: "PUT",
+      body: { fields }
+    });
+  }
+  async listTransitions(key) {
+    const result = await this.http.jira(
+      `${API2}/issue/${key}/transitions`
+    );
+    return result.transitions;
+  }
+  async transitionIssue(key, transitionId) {
+    await this.http.jira(`${API2}/issue/${key}/transitions`, {
+      method: "POST",
+      body: { transition: { id: transitionId } }
+    });
+  }
+  async addComment(key, text) {
+    return this.http.jira(`${API2}/issue/${key}/comment`, {
+      method: "POST",
+      body: {
+        body: {
+          type: "doc",
+          version: 1,
+          content: [{ type: "paragraph", content: [{ type: "text", text }] }]
+        }
+      }
+    });
+  }
+  async listComments(key) {
+    return this.http.jiraPaginate(async (startAt, maxResults) => {
+      const result = await this.http.jira(
+        `${API2}/issue/${key}/comment`,
+        { params: { startAt, maxResults } }
+      );
+      return { ...result, values: result.comments };
+    });
+  }
+  async search(jql, maxResults) {
+    if (maxResults !== void 0) {
+      return this.http.jira(`${API2}/search`, {
+        method: "POST",
+        body: { jql, maxResults, fields: ["summary", "status", "priority", "assignee", "issuetype", "project", "created", "updated", "labels", "reporter"] }
+      });
+    }
+    const allIssues = await this.http.jiraPaginate(async (startAt, max) => {
+      const result = await this.http.jira(`${API2}/search`, {
+        method: "POST",
+        body: { jql, startAt, maxResults: max, fields: ["summary", "status", "priority", "assignee", "issuetype", "project", "created", "updated", "labels", "reporter"] }
+      });
+      return { ...result, values: result.issues };
+    });
+    return { issues: allIssues, total: allIssues.length, startAt: 0, maxResults: allIssues.length };
+  }
+  async assignIssue(key, accountId) {
+    await this.http.jira(`${API2}/issue/${key}/assignee`, {
+      method: "PUT",
+      body: { accountId }
+    });
+  }
+  async linkIssue(opts) {
+    let linkTypeId = opts.linkType;
+    if (isNaN(parseInt(opts.linkType, 10))) {
+      const types = await this.http.jira(
+        `${API2}/issueLinkType`
+      );
+      const found = types.issueLinkTypes.find(
+        (t) => t.name.toLowerCase() === opts.linkType.toLowerCase() || t.inward.toLowerCase() === opts.linkType.toLowerCase() || t.outward.toLowerCase() === opts.linkType.toLowerCase()
+      );
+      if (!found) throw new Error(`Link type not found: ${opts.linkType}`);
+      linkTypeId = found.id;
+    }
+    await this.http.jira(`${API2}/issueLink`, {
+      method: "POST",
+      body: {
+        type: { id: linkTypeId },
+        inwardIssue: { key: opts.key },
+        outwardIssue: { key: opts.target }
+      }
+    });
+  }
+};
+
+// src/services/jira/commands.ts
+function getClient(program2) {
+  const opts = program2.optsWithGlobals();
+  const config = loadConfig({ configPath: opts.config });
+  if (!config.jira.baseUrl) throw new PncliError("Jira not configured. Run: pncli config init");
+  const http = createHttpClient(config, Boolean(opts.dryRun));
+  return new JiraClient(http);
+}
+function getDefaults(program2) {
+  const opts = program2.optsWithGlobals();
+  const config = loadConfig({ configPath: opts.config });
+  return {
+    project: config.defaults.jira?.project,
+    issueType: config.defaults.jira?.issueType,
+    priority: config.defaults.jira?.priority
+  };
+}
+function registerJiraCommands(program2) {
+  const jira = program2.command("jira").description("Jira Data Cloud operations");
+  jira.command("get-issue").description("Get a Jira issue by key").requiredOption("--key <issue-key>", "Issue key (e.g. PROJ-123)").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const client = getClient(program2);
+      const data = await client.getIssue(opts.key);
+      success(data, "jira", "get-issue", start);
+    } catch (err) {
+      fail(err, "jira", "get-issue", start);
+    }
+  });
+  jira.command("create-issue").description("Create a Jira issue").option("--project <key>", "Project key").option("--type <type>", "Issue type (Bug, Story, Task, ...)").requiredOption("--summary <text>", "Issue summary").option("--description <text>", "Issue description").option("--priority <name>", "Priority name").option("--assignee <accountId>", "Assignee account ID").option("--labels <labels>", "Comma-separated labels").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const client = getClient(program2);
+      const defaults = getDefaults(program2);
+      const project = opts.project ?? defaults.project;
+      const issueType = opts.type ?? defaults.issueType ?? "Task";
+      const priority = opts.priority ?? defaults.priority;
+      if (!project) throw new PncliError("--project required (or set defaults.jira.project in config)", 1);
+      const labels = opts.labels ? opts.labels.split(",").map((s) => s.trim()) : void 0;
+      const data = await client.createIssue({ project, issueType, summary: opts.summary, description: opts.description, priority, assignee: opts.assignee, labels });
+      success(data, "jira", "create-issue", start);
+    } catch (err) {
+      fail(err, "jira", "create-issue", start);
+    }
+  });
+  jira.command("update-issue").description("Update a Jira issue").requiredOption("--key <issue-key>", "Issue key").option("--summary <text>", "New summary").option("--description <text>", "New description").option("--priority <name>", "New priority").option("--assignee <accountId>", "New assignee account ID").option("--labels <labels>", "Comma-separated labels").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const client = getClient(program2);
+      const labels = opts.labels ? opts.labels.split(",").map((s) => s.trim()) : void 0;
+      await client.updateIssue(opts.key, { summary: opts.summary, description: opts.description, priority: opts.priority, assignee: opts.assignee, labels });
+      success({ updated: opts.key }, "jira", "update-issue", start);
+    } catch (err) {
+      fail(err, "jira", "update-issue", start);
+    }
+  });
+  jira.command("transition-issue").description("Transition a Jira issue to a new status").requiredOption("--key <issue-key>", "Issue key").requiredOption("--transition <name-or-id>", "Transition name or ID").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const client = getClient(program2);
+      let transitionId = opts.transition;
+      if (isNaN(parseInt(opts.transition, 10))) {
+        const transitions = await client.listTransitions(opts.key);
+        const found = transitions.find((t) => t.name.toLowerCase() === opts.transition.toLowerCase());
+        if (!found) throw new PncliError(`Transition not found: ${opts.transition}`, 1);
+        transitionId = found.id;
+      }
+      await client.transitionIssue(opts.key, transitionId);
+      success({ transitioned: opts.key, transition: opts.transition }, "jira", "transition-issue", start);
+    } catch (err) {
+      fail(err, "jira", "transition-issue", start);
+    }
+  });
+  jira.command("list-transitions").description("List available transitions for an issue").requiredOption("--key <issue-key>", "Issue key").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const client = getClient(program2);
+      const data = await client.listTransitions(opts.key);
+      success(data, "jira", "list-transitions", start);
+    } catch (err) {
+      fail(err, "jira", "list-transitions", start);
+    }
+  });
+  jira.command("add-comment").description("Add a comment to a Jira issue").requiredOption("--key <issue-key>", "Issue key").requiredOption("--body <text>", "Comment text").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const client = getClient(program2);
+      const data = await client.addComment(opts.key, opts.body);
+      success(data, "jira", "add-comment", start);
+    } catch (err) {
+      fail(err, "jira", "add-comment", start);
+    }
+  });
+  jira.command("list-comments").description("List comments on a Jira issue").requiredOption("--key <issue-key>", "Issue key").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const client = getClient(program2);
+      const data = await client.listComments(opts.key);
+      success(data, "jira", "list-comments", start);
+    } catch (err) {
+      fail(err, "jira", "list-comments", start);
+    }
+  });
+  jira.command("search").description("Search Jira issues with JQL").requiredOption("--jql <query>", "JQL query string").option("--max-results <n>", "Maximum number of results").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const client = getClient(program2);
+      const maxResults = opts.maxResults ? parseInt(opts.maxResults, 10) : void 0;
+      const data = await client.search(opts.jql, maxResults);
+      success(data, "jira", "search", start);
+    } catch (err) {
+      fail(err, "jira", "search", start);
+    }
+  });
+  jira.command("assign").description("Assign a Jira issue to a user").requiredOption("--key <issue-key>", "Issue key").requiredOption("--assignee <accountId>", "Assignee account ID").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const client = getClient(program2);
+      await client.assignIssue(opts.key, opts.assignee);
+      success({ assigned: opts.key, assignee: opts.assignee }, "jira", "assign", start);
+    } catch (err) {
+      fail(err, "jira", "assign", start);
+    }
+  });
+  jira.command("link-issue").description("Link two Jira issues together").requiredOption("--key <issue-key>", "Source issue key").requiredOption("--link-type <type>", "Link type name or ID").requiredOption("--target <issue-key>", "Target issue key").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const client = getClient(program2);
+      await client.linkIssue({ key: opts.key, linkType: opts.linkType, target: opts.target });
+      success({ linked: opts.key, to: opts.target, type: opts.linkType }, "jira", "link-issue", start);
+    } catch (err) {
+      fail(err, "jira", "link-issue", start);
+    }
+  });
+}
+
+// src/services/bitbucket/commands.ts
+function getClient2(program2) {
+  const opts = program2.optsWithGlobals();
+  const config = loadConfig({ configPath: opts.config });
+  const http = createHttpClient(config, Boolean(opts.dryRun));
+  const client = new BitbucketClient(http);
+  const ctx = getGitContext(config);
+  const project = opts.project ?? ctx?.project ?? config.defaults.bitbucket?.project ?? "";
+  const repo = opts.repo ?? ctx?.repo ?? config.defaults.bitbucket?.repo ?? "";
+  if (!project || !repo) {
+    throw new PncliError(
+      "Could not determine Bitbucket project/repo. Pass --project and --repo, or run pncli config init.",
+      1
+    );
+  }
+  return { client, project, repo };
+}
+function registerBitbucketCommands(program2) {
+  const bb = program2.command("bitbucket").description("Bitbucket Server operations").option("--project <key>", "Bitbucket project key").option("--repo <slug>", "Bitbucket repository slug");
+  bb.command("list-prs").description("List pull requests").option("--state <state>", "PR state: OPEN|MERGED|DECLINED|ALL", "OPEN").option("--author <username>", "Filter by author username").option("--reviewer <username>", "Filter by reviewer username").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const { client, project, repo } = getClient2(program2);
+      const data = await client.listPRs({ project, repo, state: opts.state, author: opts.author, reviewer: opts.reviewer });
+      success(data, "bitbucket", "list-prs", start);
+    } catch (err) {
+      fail(err, "bitbucket", "list-prs", start);
+    }
+  });
+  bb.command("get-pr").description("Get a pull request by ID").requiredOption("--id <pr-id>", "Pull request ID").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const { client, project, repo } = getClient2(program2);
+      const data = await client.getPR(project, repo, parseInt(opts.id, 10));
+      success(data, "bitbucket", "get-pr", start);
+    } catch (err) {
+      fail(err, "bitbucket", "get-pr", start);
+    }
+  });
+  bb.command("create-pr").description("Create a pull request").requiredOption("--title <title>", "PR title").requiredOption("--source <branch>", "Source branch").option("--target <branch>", "Target branch (defaults to config)").option("--description <desc>", "PR description").option("--reviewers <users>", "Comma-separated reviewer usernames").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const { client, project, repo } = getClient2(program2);
+      const config = loadConfig({ configPath: program2.optsWithGlobals().config });
+      const target = opts.target ?? config.defaults.bitbucket?.targetBranch ?? "main";
+      const reviewers = opts.reviewers ? opts.reviewers.split(",").map((s) => s.trim()) : [];
+      const data = await client.createPR({ project, repo, title: opts.title, source: opts.source, target, description: opts.description, reviewers });
+      success(data, "bitbucket", "create-pr", start);
+    } catch (err) {
+      fail(err, "bitbucket", "create-pr", start);
+    }
+  });
+  bb.command("update-pr").description("Update a pull request").requiredOption("--id <pr-id>", "Pull request ID").option("--title <title>", "New title").option("--description <desc>", "New description").option("--reviewers <users>", "Comma-separated reviewer usernames").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const { client, project, repo } = getClient2(program2);
+      const prId = parseInt(opts.id, 10);
+      const pr = await client.getPR(project, repo, prId);
+      const reviewers = opts.reviewers ? opts.reviewers.split(",").map((s) => s.trim()) : void 0;
+      const data = await client.updatePR({ project, repo, id: prId, title: opts.title, description: opts.description, reviewers, version: pr.version });
+      success(data, "bitbucket", "update-pr", start);
+    } catch (err) {
+      fail(err, "bitbucket", "update-pr", start);
+    }
+  });
+  bb.command("merge-pr").description("Merge a pull request").requiredOption("--id <pr-id>", "Pull request ID").option("--strategy <strategy>", "Merge strategy: merge|squash|ff").option("--delete-branch", "Delete source branch after merge").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const { client, project, repo } = getClient2(program2);
+      const prId = parseInt(opts.id, 10);
+      const pr = await client.getPR(project, repo, prId);
+      const data = await client.mergePR({ project, repo, id: prId, version: pr.version, strategy: opts.strategy, deleteBranch: opts.deleteBranch });
+      success(data, "bitbucket", "merge-pr", start);
+    } catch (err) {
+      fail(err, "bitbucket", "merge-pr", start);
+    }
+  });
+  bb.command("decline-pr").description("Decline a pull request").requiredOption("--id <pr-id>", "Pull request ID").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const { client, project, repo } = getClient2(program2);
+      const prId = parseInt(opts.id, 10);
+      const pr = await client.getPR(project, repo, prId);
+      const data = await client.declinePR(project, repo, prId, pr.version);
+      success(data, "bitbucket", "decline-pr", start);
+    } catch (err) {
+      fail(err, "bitbucket", "decline-pr", start);
+    }
+  });
+  bb.command("list-comments").description("List comments on a pull request").requiredOption("--pr <pr-id>", "Pull request ID").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const { client, project, repo } = getClient2(program2);
+      const data = await client.listComments(project, repo, parseInt(opts.pr, 10));
+      success(data, "bitbucket", "list-comments", start);
+    } catch (err) {
+      fail(err, "bitbucket", "list-comments", start);
+    }
+  });
+  bb.command("add-comment").description("Add a comment to a pull request").requiredOption("--pr <pr-id>", "Pull request ID").requiredOption("--body <text>", "Comment text").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const { client, project, repo } = getClient2(program2);
+      const data = await client.addComment(project, repo, parseInt(opts.pr, 10), opts.body);
+      success(data, "bitbucket", "add-comment", start);
+    } catch (err) {
+      fail(err, "bitbucket", "add-comment", start);
+    }
+  });
+  bb.command("add-inline-comment").description("Add an inline comment to a file in a pull request").requiredOption("--pr <pr-id>", "Pull request ID").requiredOption("--file <path>", "File path").requiredOption("--line <n>", "Line number").requiredOption("--body <text>", "Comment text").option("--line-type <type>", "Line type: ADDED|REMOVED|CONTEXT", "ADDED").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const { client, project, repo } = getClient2(program2);
+      const data = await client.addInlineComment({
+        project,
+        repo,
+        prId: parseInt(opts.pr, 10),
+        text: opts.body,
+        filePath: opts.file,
+        line: parseInt(opts.line, 10),
+        lineType: opts.lineType
+      });
+      success(data, "bitbucket", "add-inline-comment", start);
+    } catch (err) {
+      fail(err, "bitbucket", "add-inline-comment", start);
+    }
+  });
+  bb.command("reply-comment").description("Reply to a comment on a pull request").requiredOption("--pr <pr-id>", "Pull request ID").requiredOption("--comment-id <id>", "Comment ID to reply to").requiredOption("--body <text>", "Reply text").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const { client, project, repo } = getClient2(program2);
+      const data = await client.replyComment(project, repo, parseInt(opts.pr, 10), parseInt(opts.commentId, 10), opts.body);
+      success(data, "bitbucket", "reply-comment", start);
+    } catch (err) {
+      fail(err, "bitbucket", "reply-comment", start);
+    }
+  });
+  bb.command("resolve-comment").description("Resolve a comment on a pull request").requiredOption("--pr <pr-id>", "Pull request ID").requiredOption("--comment-id <id>", "Comment ID").option("--version <n>", "Comment version", "0").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const { client, project, repo } = getClient2(program2);
+      await client.resolveComment(project, repo, parseInt(opts.pr, 10), parseInt(opts.commentId, 10), parseInt(opts.version ?? "0", 10));
+      success({ resolved: true }, "bitbucket", "resolve-comment", start);
+    } catch (err) {
+      fail(err, "bitbucket", "resolve-comment", start);
+    }
+  });
+  bb.command("delete-comment").description("Delete a comment on a pull request").requiredOption("--pr <pr-id>", "Pull request ID").requiredOption("--comment-id <id>", "Comment ID").option("--version <n>", "Comment version", "0").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const { client, project, repo } = getClient2(program2);
+      await client.deleteComment(project, repo, parseInt(opts.pr, 10), parseInt(opts.commentId, 10), parseInt(opts.version ?? "0", 10));
+      success({ deleted: true }, "bitbucket", "delete-comment", start);
+    } catch (err) {
+      fail(err, "bitbucket", "delete-comment", start);
+    }
+  });
+  bb.command("diff").description("Get unified diff for a pull request").requiredOption("--pr <pr-id>", "Pull request ID").option("--file <path>", "Limit diff to a specific file").option("--context-lines <n>", "Lines of context around changes").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const { client, project, repo } = getClient2(program2);
+      const contextLines = opts.contextLines ? parseInt(opts.contextLines, 10) : void 0;
+      const diff = await client.getDiff(project, repo, parseInt(opts.pr, 10), opts.file, contextLines);
+      success({ diff }, "bitbucket", "diff", start);
+    } catch (err) {
+      fail(err, "bitbucket", "diff", start);
+    }
+  });
+  bb.command("list-files").description("List files changed in a pull request").requiredOption("--pr <pr-id>", "Pull request ID").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const { client, project, repo } = getClient2(program2);
+      const data = await client.listFiles(project, repo, parseInt(opts.pr, 10));
+      success(data, "bitbucket", "list-files", start);
+    } catch (err) {
+      fail(err, "bitbucket", "list-files", start);
+    }
+  });
+  bb.command("approve").description("Approve a pull request").requiredOption("--pr <pr-id>", "Pull request ID").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const { client, project, repo } = getClient2(program2);
+      const data = await client.approvePR(project, repo, parseInt(opts.pr, 10));
+      success(data, "bitbucket", "approve", start);
+    } catch (err) {
+      fail(err, "bitbucket", "approve", start);
+    }
+  });
+  bb.command("unapprove").description("Remove approval from a pull request").requiredOption("--pr <pr-id>", "Pull request ID").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const { client, project, repo } = getClient2(program2);
+      const data = await client.unapprovePR(project, repo, parseInt(opts.pr, 10));
+      success(data, "bitbucket", "unapprove", start);
+    } catch (err) {
+      fail(err, "bitbucket", "unapprove", start);
+    }
+  });
+  bb.command("needs-work").description("Mark a pull request as needs-work").requiredOption("--pr <pr-id>", "Pull request ID").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const { client, project, repo } = getClient2(program2);
+      const data = await client.needsWorkPR(project, repo, parseInt(opts.pr, 10));
+      success(data, "bitbucket", "needs-work", start);
+    } catch (err) {
+      fail(err, "bitbucket", "needs-work", start);
+    }
+  });
+  bb.command("list-reviewers").description("List reviewers of a pull request").requiredOption("--pr <pr-id>", "Pull request ID").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const { client, project, repo } = getClient2(program2);
+      const data = await client.listReviewers(project, repo, parseInt(opts.pr, 10));
+      success(data, "bitbucket", "list-reviewers", start);
+    } catch (err) {
+      fail(err, "bitbucket", "list-reviewers", start);
+    }
+  });
+  bb.command("list-builds").description("List build statuses for a pull request").requiredOption("--pr <pr-id>", "Pull request ID").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const { client, project, repo } = getClient2(program2);
+      const data = await client.listBuilds(project, repo, parseInt(opts.pr, 10));
+      success(data, "bitbucket", "list-builds", start);
+    } catch (err) {
+      fail(err, "bitbucket", "list-builds", start);
+    }
+  });
+  bb.command("get-build-status").description("Get build status for a commit SHA").requiredOption("--commit <sha>", "Commit SHA").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const { client } = getClient2(program2);
+      const data = await client.getBuildStatus(opts.commit);
+      success(data, "bitbucket", "get-build-status", start);
+    } catch (err) {
+      fail(err, "bitbucket", "get-build-status", start);
+    }
+  });
+}
+
+// src/services/confluence/commands.ts
+function registerConfluenceCommands(program2) {
+  program2.command("confluence").description("Confluence operations").action(() => {
+    success(
+      { message: "Coming soon \u2014 the nightmare never ends." },
+      "confluence",
+      "stub",
+      Date.now()
+    );
+  });
+}
+
+// src/services/sonar/commands.ts
+function registerSonarCommands(program2) {
+  program2.command("sonar").description("SonarQube operations").action(() => {
+    success(
+      { message: "Coming soon \u2014 the nightmare never ends." },
+      "sonar",
+      "stub",
+      Date.now()
+    );
+  });
+}
+
+// src/services/artifactory/commands.ts
+function registerArtifactoryCommands(program2) {
+  program2.command("artifactory").description("Artifactory operations").action(() => {
+    success(
+      { message: "Coming soon \u2014 the nightmare never ends." },
+      "artifactory",
+      "stub",
+      Date.now()
+    );
+  });
+}
+
+// src/services/config/commands.ts
+import { input, password, confirm } from "@inquirer/prompts";
+import fs2 from "fs";
+function registerConfigCommands(program2) {
+  const config = program2.command("config").description("Manage pncli configuration");
+  config.command("init").description("Interactive setup wizard").option("--repo", "Write repo config (.pncli.json) instead of global config").action(async (opts) => {
+    const start = Date.now();
+    try {
+      if (opts.repo) {
+        await initRepoConfig(start);
+      } else {
+        await initGlobalConfig(start);
+      }
+    } catch (err) {
+      if (err instanceof Error && err.message.includes("User force closed")) {
+        process.stderr.write("\nSetup cancelled.\n");
+        process.exit(1);
+      }
+      fail(err, "config", "init", start);
+    }
+  });
+  config.command("show").description("Print fully resolved config (PATs masked)").action(() => {
+    const start = Date.now();
+    try {
+      const resolved = loadConfig();
+      success(maskConfig(resolved), "config", "show", start);
+    } catch (err) {
+      fail(err, "config", "show", start);
+    }
+  });
+  config.command("set").description("Set a config value by dot-notation key (e.g. jira.baseUrl https://...)").argument("<key>", "Config key in dot notation").argument("<value>", "Value to set").action((key, value) => {
+    const start = Date.now();
+    try {
+      const opts = program2.optsWithGlobals();
+      setConfigValue(key, value, opts.config);
+      success({ key, value }, "config", "set", start);
+    } catch (err) {
+      fail(err, "config", "set", start);
+    }
+  });
+  config.command("test").description("Test connectivity to configured services").action(() => {
+    const start = Date.now();
+    success(
+      { message: "Service connectivity test available after Phase 2." },
+      "config",
+      "test",
+      start
+    );
+  });
+}
+async function initGlobalConfig(start) {
+  process.stderr.write("pncli config init \u2014 Global configuration\n\n");
+  const jiraBaseUrl = await input({
+    message: "Jira base URL (e.g. https://your-domain.atlassian.net):",
+    default: ""
+  });
+  const jiraEmail = await input({
+    message: "Jira email address:",
+    default: ""
+  });
+  const jiraApiToken = await password({
+    message: "Jira API token:"
+  });
+  const bitbucketBaseUrl = await input({
+    message: "Bitbucket Server base URL (e.g. https://bitbucket.your-company.com):",
+    default: ""
+  });
+  const bitbucketPat = await password({
+    message: "Bitbucket personal access token:"
+  });
+  const jiraProject = await input({
+    message: "Default Jira project key (optional):",
+    default: ""
+  });
+  const confirmed = await confirm({
+    message: "Write config to ~/.pncli/config.json?",
+    default: true
+  });
+  if (!confirmed) {
+    process.stderr.write("Aborted.\n");
+    process.exit(0);
+  }
+  writeGlobalConfig({
+    jira: {
+      baseUrl: jiraBaseUrl || void 0,
+      email: jiraEmail || void 0,
+      apiToken: jiraApiToken || void 0
+    },
+    bitbucket: {
+      baseUrl: bitbucketBaseUrl || void 0,
+      pat: bitbucketPat || void 0
+    },
+    defaults: {
+      jira: {
+        project: jiraProject || void 0
+      }
+    }
+  });
+  const configPath = getGlobalConfigPath();
+  warn(`Config written to ${configPath}`);
+  success({ written: configPath }, "config", "init", start);
+}
+async function initRepoConfig(start) {
+  process.stderr.write("pncli config init --repo \u2014 Repo configuration\n\n");
+  const jiraProject = await input({
+    message: "Jira project key (e.g. ACME):",
+    default: ""
+  });
+  const jiraIssueType = await input({
+    message: "Default issue type:",
+    default: "Story"
+  });
+  const jiraPriority = await input({
+    message: "Default priority:",
+    default: "Medium"
+  });
+  const targetBranch = await input({
+    message: "Default target branch for PRs:",
+    default: "main"
+  });
+  const confirmed = await confirm({
+    message: "Write config to .pncli.json in repo root?",
+    default: true
+  });
+  if (!confirmed) {
+    process.stderr.write("Aborted.\n");
+    process.exit(0);
+  }
+  if (fs2.existsSync(".pncli.json")) {
+    const overwrite = await confirm({
+      message: ".pncli.json already exists. Overwrite?",
+      default: false
+    });
+    if (!overwrite) {
+      process.stderr.write("Aborted.\n");
+      process.exit(0);
+    }
+  }
+  writeRepoConfig({
+    defaults: {
+      jira: {
+        project: jiraProject || void 0,
+        issueType: jiraIssueType || void 0,
+        priority: jiraPriority || void 0
+      },
+      bitbucket: {
+        targetBranch: targetBranch || void 0
+      }
+    }
+  });
+  success({ written: ".pncli.json" }, "config", "init", start);
+}
+
+// src/cli.ts
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../package.json");
+var TAGLINE = "One command does what three meetings couldn't.";
+var program = new Command();
+program.name("pncli").description(`The Paperwork Nightmare CLI \u2014 ${TAGLINE}`).version(`${pkg.version} \u2014 ${TAGLINE}`, "-v, --version").option("--pretty", "Human-readable formatted output", false).option("--verbose", "Include full response metadata", false).option("--dry-run", "Print API requests without executing", false).option("--config <path>", "Override global config file location");
+program.hook("preAction", (thisCommand) => {
+  const opts = thisCommand.optsWithGlobals();
+  setGlobalOptions({
+    pretty: Boolean(opts.pretty),
+    verbose: Boolean(opts.verbose)
+  });
+});
+registerGitCommands(program);
+registerJiraCommands(program);
+registerBitbucketCommands(program);
+registerConfluenceCommands(program);
+registerSonarCommands(program);
+registerArtifactoryCommands(program);
+registerConfigCommands(program);
+program.addHelpText("after", `
+Services:
+  git          Local git operations (status, diff, log, branch)
+  jira         Jira Data Cloud (coming soon)
+  bitbucket    Bitbucket Server (coming soon)
+  confluence   Confluence (coming soon)
+  sonar        SonarQube (coming soon)
+  artifactory  Artifactory (coming soon)
+  config       Manage pncli configuration
+`);
+program.parseAsync(process.argv).catch((err) => {
+  process.stderr.write(`Fatal: ${err instanceof Error ? err.message : String(err)}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map