@kolatts/pncli 1.25.1 → 2.0.0

package/dist/cli.js

@@ -4,15 +4,18 @@ import {
   loadConfig,
   loadJsonFile,
   maskConfig,
+  normalizeBaseUrl,
   setConfigValue,
   setRepoConfigValue,
   writeGlobalConfig,
   writeRepoConfig
-} from "./chunk-JOAWUILY.js";
+} from "./chunk-PXKUQPPF.js";
+import {
+  createHttpClient
+} from "./chunk-ZDJYOI3W.js";
 import {
   ExitCode,
   PncliError,
-  createHttpClient,
   fail,
   log,
   setGlobalOptions,
@@ -20,7 +23,7 @@ import {
   success,
   warn,
   writeRawOutput
-} from "./chunk-ABHLES5M.js";
+} from "./chunk-HZF6WQPU.js";
 import {
   AdoCoreClient
 } from "./chunk-VDL32PSG.js";
@@ -2368,6 +2371,232 @@ var GitHubClient = class {
     const data = await this.http.githubGraphQL(mutation, { threadId });
     return data.resolveReviewThread.thread;
   }
+  // ── Auto-merge ─────────────────────────────────────────────────────
+  /** Returns the GraphQL node ID of a PR, needed for mutations. */
+  async getPRNodeId(owner, repo, pullNumber) {
+    const pr = await this.getPR(owner, repo, pullNumber);
+    return pr.node_id;
+  }
+  async enableAutoMerge(opts) {
+    const nodeId = await this.getPRNodeId(opts.owner, opts.repo, opts.pullNumber);
+    const mutation = `
+      mutation($pullRequestId: ID!, $mergeMethod: PullRequestMergeMethod, $expectedHeadOid: GitObjectID) {
+        enablePullRequestAutoMerge(input: {
+          pullRequestId: $pullRequestId
+          mergeMethod: $mergeMethod
+          expectedHeadOid: $expectedHeadOid
+        }) {
+          pullRequest {
+            number
+            autoMergeRequest {
+              mergeMethod
+              enabledAt
+              enabledBy { login }
+            }
+          }
+        }
+      }
+    `;
+    const variables = { pullRequestId: nodeId };
+    if (opts.mergeMethod) variables.mergeMethod = opts.mergeMethod;
+    if (opts.expectedHeadOid) variables.expectedHeadOid = opts.expectedHeadOid;
+    const data = await this.http.githubGraphQL(mutation, variables);
+    return data.enablePullRequestAutoMerge.pullRequest;
+  }
+  async disableAutoMerge(owner, repo, pullNumber) {
+    const nodeId = await this.getPRNodeId(owner, repo, pullNumber);
+    const mutation = `
+      mutation($pullRequestId: ID!) {
+        disablePullRequestAutoMerge(input: { pullRequestId: $pullRequestId }) {
+          pullRequest {
+            number
+            autoMergeRequest {
+              mergeMethod
+              enabledAt
+              enabledBy { login }
+            }
+          }
+        }
+      }
+    `;
+    const data = await this.http.githubGraphQL(mutation, { pullRequestId: nodeId });
+    return data.disablePullRequestAutoMerge.pullRequest;
+  }
+  async enqueuePR(opts) {
+    const nodeId = await this.getPRNodeId(opts.owner, opts.repo, opts.pullNumber);
+    const mutation = `
+      mutation($pullRequestId: ID!, $expectedHeadOid: GitObjectID, $mergeMethod: PullRequestMergeMethod) {
+        addPullRequestToMergeQueue(input: {
+          pullRequestId: $pullRequestId
+          expectedHeadOid: $expectedHeadOid
+          mergeMethod: $mergeMethod
+        }) {
+          mergeQueue {
+            url
+          }
+        }
+      }
+    `;
+    const variables = { pullRequestId: nodeId };
+    if (opts.expectedHeadOid) variables.expectedHeadOid = opts.expectedHeadOid;
+    if (opts.mergeMethod) variables.mergeMethod = opts.mergeMethod;
+    const data = await this.http.githubGraphQL(mutation, variables);
+    return { mergeQueueUrl: data.addPullRequestToMergeQueue.mergeQueue.url };
+  }
+  // ── PR status aggregation ──────────────────────────────────────────
+  async getPRStatus(owner, repo, pullNumber) {
+    const query = `
+      query($owner: String!, $repo: String!, $number: Int!) {
+        repository(owner: $owner, name: $repo) {
+          pullRequest(number: $number) {
+            number
+            title
+            state
+            isDraft
+            merged
+            mergeable
+            mergeStateStatus
+            reviewDecision
+            autoMergeRequest {
+              mergeMethod
+              enabledAt
+              enabledBy { login }
+            }
+            commits(last: 1) {
+              nodes {
+                commit {
+                  statusCheckRollup {
+                    contexts(first: 100) {
+                      nodes {
+                        ... on CheckRun {
+                          __typename
+                          name
+                          status
+                          conclusion
+                        }
+                        ... on StatusContext {
+                          __typename
+                          context
+                          state
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    `;
+    const data = await this.http.githubGraphQL(query, { owner, repo, number: pullNumber });
+    const pr = data.repository.pullRequest;
+    const checkNodes = pr.commits.nodes[0]?.commit.statusCheckRollup?.contexts.nodes ?? [];
+    const details = checkNodes.map((n) => {
+      if (n.__typename === "CheckRun") {
+        return { name: n.name, status: n.status, conclusion: n.conclusion };
+      }
+      return { name: n.context, status: n.state, conclusion: null };
+    });
+    const passed = details.filter((d) => d.conclusion === "success" || d.status === "success").length;
+    const failed = details.filter(
+      (d) => d.conclusion === "failure" || d.conclusion === "timed_out" || d.conclusion === "action_required" || d.status === "failure" || d.status === "error"
+    ).length;
+    const pending = details.filter(
+      (d) => d.status === "queued" || d.status === "in_progress" || d.status === "pending"
+    ).length;
+    const other = details.length - passed - failed - pending;
+    return {
+      number: pr.number,
+      title: pr.title,
+      state: pr.state,
+      isDraft: pr.isDraft,
+      merged: pr.merged,
+      mergeable: pr.mergeable,
+      mergeStateStatus: pr.mergeStateStatus,
+      reviewDecision: pr.reviewDecision,
+      autoMergeRequest: pr.autoMergeRequest ? {
+        mergeMethod: pr.autoMergeRequest.mergeMethod,
+        enabledAt: pr.autoMergeRequest.enabledAt,
+        enabledBy: pr.autoMergeRequest.enabledBy.login
+      } : null,
+      checks: { total: details.length, passed, failed, pending, other, details }
+    };
+  }
+  // ── Draft / ready-for-review ───────────────────────────────────────
+  async convertToDraft(owner, repo, pullNumber) {
+    const nodeId = await this.getPRNodeId(owner, repo, pullNumber);
+    const mutation = `
+      mutation($pullRequestId: ID!) {
+        convertPullRequestToDraft(input: { pullRequestId: $pullRequestId }) {
+          pullRequest { number isDraft }
+        }
+      }
+    `;
+    const data = await this.http.githubGraphQL(mutation, { pullRequestId: nodeId });
+    return data.convertPullRequestToDraft.pullRequest;
+  }
+  async markReadyForReview(owner, repo, pullNumber) {
+    const nodeId = await this.getPRNodeId(owner, repo, pullNumber);
+    const mutation = `
+      mutation($pullRequestId: ID!) {
+        markPullRequestReadyForReview(input: { pullRequestId: $pullRequestId }) {
+          pullRequest { number isDraft }
+        }
+      }
+    `;
+    const data = await this.http.githubGraphQL(mutation, { pullRequestId: nodeId });
+    return data.markPullRequestReadyForReview.pullRequest;
+  }
+  // ── Reopen ─────────────────────────────────────────────────────────
+  async reopenPR(owner, repo, pullNumber) {
+    return this.updatePR({ owner, repo, pullNumber, state: "open" });
+  }
+  // ── Labels ─────────────────────────────────────────────────────────
+  async addLabels(owner, repo, issueNumber, labels) {
+    return this.http.github(
+      `/repos/${owner}/${repo}/issues/${issueNumber}/labels`,
+      { method: "POST", body: { labels } }
+    );
+  }
+  async removeLabel(owner, repo, issueNumber, label) {
+    await this.http.github(
+      `/repos/${owner}/${repo}/issues/${issueNumber}/labels/${label}`,
+      { method: "DELETE" }
+    );
+  }
+  // ── Reviewers ──────────────────────────────────────────────────────
+  async addReviewers(opts) {
+    const body = {};
+    if (opts.reviewers?.length) body.reviewers = opts.reviewers;
+    if (opts.teamReviewers?.length) body.team_reviewers = opts.teamReviewers;
+    return this.http.github(
+      `/repos/${opts.owner}/${opts.repo}/pulls/${opts.pullNumber}/requested_reviewers`,
+      { method: "POST", body }
+    );
+  }
+  async removeReviewers(opts) {
+    const body = {};
+    if (opts.reviewers?.length) body.reviewers = opts.reviewers;
+    if (opts.teamReviewers?.length) body.team_reviewers = opts.teamReviewers;
+    await this.http.github(
+      `/repos/${opts.owner}/${opts.repo}/pulls/${opts.pullNumber}/requested_reviewers`,
+      { method: "DELETE", body }
+    );
+  }
+  // ── Assignees ─────────────────────────────────────────────────────
+  async addAssignees(owner, repo, issueNumber, assignees) {
+    return this.http.github(
+      `/repos/${owner}/${repo}/issues/${issueNumber}/assignees`,
+      { method: "POST", body: { assignees } }
+    );
+  }
+  async removeAssignees(owner, repo, issueNumber, assignees) {
+    return this.http.github(
+      `/repos/${owner}/${repo}/issues/${issueNumber}/assignees`,
+      { method: "DELETE", body: { assignees } }
+    );
+  }
 };
 
 // src/services/github/commands.ts
@@ -2506,7 +2735,7 @@ function registerGitHubCommands(program2) {
       fail(err, "github", "update-pr", start);
     }
   });
-  gh.command("merge-pr").description("Merge a pull request").requiredOption("--number <n>", "Pull request number").addOption(new Option("--method <method>", "Merge method").choices(["merge", "squash", "rebase"]).default("merge")).option("--commit-title <title>", "Commit title for merge/squash").option("--commit-message <msg>", "Commit message for merge/squash").action(async (opts) => {
+  gh.command("merge-pr").description("Merge a pull request (immediate merge \u2014 use enable-auto-merge for auto-merge)").requiredOption("--number <n>", "Pull request number").addOption(new Option("--method <method>", "Merge method").choices(["merge", "squash", "rebase"]).default("merge")).option("--commit-title <title>", "Commit title for merge/squash").option("--commit-message <msg>", "Commit message for merge/squash").action(async (opts) => {
     const start = Date.now();
     try {
       const { client, owner, repo } = getClient3(gh);
@@ -2523,6 +2752,48 @@ function registerGitHubCommands(program2) {
       fail(err, "github", "merge-pr", start);
     }
   });
+  gh.command("enable-auto-merge").description("Enable auto-merge on a pull request (merges automatically when all requirements are met)").requiredOption("--number <n>", "Pull request number").addOption(new Option("--method <method>", "Merge method").choices(["merge", "squash", "rebase"])).option("--match-head-commit <sha>", "Only enable if the PR head matches this SHA (prevents race conditions)").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const { client, owner, repo } = getClient3(gh);
+      const data = await client.enableAutoMerge({
+        owner,
+        repo,
+        pullNumber: parseInt(opts.number, 10),
+        mergeMethod: opts.method?.toUpperCase(),
+        expectedHeadOid: opts.matchHeadCommit
+      });
+      success(data, "github", "enable-auto-merge", start);
+    } catch (err) {
+      fail(err, "github", "enable-auto-merge", start);
+    }
+  });
+  gh.command("disable-auto-merge").description("Disable auto-merge on a pull request").requiredOption("--number <n>", "Pull request number").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const { client, owner, repo } = getClient3(gh);
+      const data = await client.disableAutoMerge(owner, repo, parseInt(opts.number, 10));
+      success(data, "github", "disable-auto-merge", start);
+    } catch (err) {
+      fail(err, "github", "disable-auto-merge", start);
+    }
+  });
+  gh.command("enqueue-pr").description("Add a pull request to the repository merge queue").requiredOption("--number <n>", "Pull request number").addOption(new Option("--method <method>", "Merge method").choices(["merge", "squash", "rebase"])).option("--match-head-commit <sha>", "Only enqueue if the PR head matches this SHA (prevents race conditions)").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const { client, owner, repo } = getClient3(gh);
+      const data = await client.enqueuePR({
+        owner,
+        repo,
+        pullNumber: parseInt(opts.number, 10),
+        mergeMethod: opts.method?.toUpperCase(),
+        expectedHeadOid: opts.matchHeadCommit
+      });
+      success(data, "github", "enqueue-pr", start);
+    } catch (err) {
+      fail(err, "github", "enqueue-pr", start);
+    }
+  });
   gh.command("close-pr").description("Close a pull request").requiredOption("--number <n>", "Pull request number").action(async (opts) => {
     const start = Date.now();
     try {
@@ -2724,6 +2995,148 @@ function registerGitHubCommands(program2) {
       fail(err, "github", "list-checks", start);
     }
   });
+  gh.command("pr-status").description("Aggregated PR status: review decision, checks, mergeability, draft state, and auto-merge").requiredOption("--number <n>", "Pull request number").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const { client, owner, repo } = getClient3(gh);
+      const data = await client.getPRStatus(owner, repo, parseInt(opts.number, 10));
+      success(data, "github", "pr-status", start);
+    } catch (err) {
+      fail(err, "github", "pr-status", start);
+    }
+  });
+  gh.command("convert-to-draft").description("Convert an open pull request to a draft").requiredOption("--number <n>", "Pull request number").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const { client, owner, repo } = getClient3(gh);
+      const data = await client.convertToDraft(owner, repo, parseInt(opts.number, 10));
+      success(data, "github", "convert-to-draft", start);
+    } catch (err) {
+      fail(err, "github", "convert-to-draft", start);
+    }
+  });
+  gh.command("ready-for-review").description("Mark a draft pull request as ready for review").requiredOption("--number <n>", "Pull request number").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const { client, owner, repo } = getClient3(gh);
+      const data = await client.markReadyForReview(owner, repo, parseInt(opts.number, 10));
+      success(data, "github", "ready-for-review", start);
+    } catch (err) {
+      fail(err, "github", "ready-for-review", start);
+    }
+  });
+  gh.command("reopen-pr").description("Reopen a closed pull request").requiredOption("--number <n>", "Pull request number").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const { client, owner, repo } = getClient3(gh);
+      const data = await client.reopenPR(owner, repo, parseInt(opts.number, 10));
+      success(data, "github", "reopen-pr", start);
+    } catch (err) {
+      fail(err, "github", "reopen-pr", start);
+    }
+  });
+  gh.command("add-labels").description("Add labels to a pull request or issue").requiredOption("--number <n>", "PR or issue number").option("--label <label>", "Label to add (repeatable)", (v, acc) => {
+    acc.push(v);
+    return acc;
+  }, []).action(async (opts) => {
+    const start = Date.now();
+    try {
+      const { client, owner, repo } = getClient3(gh);
+      if (!opts.label.length) throw new PncliError("At least one --label is required", 1);
+      const data = await client.addLabels(owner, repo, parseInt(opts.number, 10), opts.label);
+      success(data, "github", "add-labels", start);
+    } catch (err) {
+      fail(err, "github", "add-labels", start);
+    }
+  });
+  gh.command("remove-label").description("Remove a label from a pull request or issue").requiredOption("--number <n>", "PR or issue number").requiredOption("--label <label>", "Label name to remove").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const { client, owner, repo } = getClient3(gh);
+      await client.removeLabel(owner, repo, parseInt(opts.number, 10), opts.label);
+      success({ removed: true, label: opts.label }, "github", "remove-label", start);
+    } catch (err) {
+      fail(err, "github", "remove-label", start);
+    }
+  });
+  gh.command("add-reviewers").description("Request reviewers on a pull request").requiredOption("--number <n>", "Pull request number").option("--reviewer <login>", "User reviewer login (repeatable)", (v, acc) => {
+    acc.push(v);
+    return acc;
+  }, []).option("--team-reviewer <slug>", "Team slug to request (repeatable)", (v, acc) => {
+    acc.push(v);
+    return acc;
+  }, []).action(async (opts) => {
+    const start = Date.now();
+    try {
+      const { client, owner, repo } = getClient3(gh);
+      if (!opts.reviewer.length && !opts.teamReviewer.length) {
+        throw new PncliError("At least one --reviewer or --team-reviewer is required", 1);
+      }
+      const data = await client.addReviewers({
+        owner,
+        repo,
+        pullNumber: parseInt(opts.number, 10),
+        reviewers: opts.reviewer.length ? opts.reviewer : void 0,
+        teamReviewers: opts.teamReviewer.length ? opts.teamReviewer : void 0
+      });
+      success(data, "github", "add-reviewers", start);
+    } catch (err) {
+      fail(err, "github", "add-reviewers", start);
+    }
+  });
+  gh.command("remove-reviewers").description("Remove requested reviewers from a pull request").requiredOption("--number <n>", "Pull request number").option("--reviewer <login>", "User reviewer login to remove (repeatable)", (v, acc) => {
+    acc.push(v);
+    return acc;
+  }, []).option("--team-reviewer <slug>", "Team slug to remove (repeatable)", (v, acc) => {
+    acc.push(v);
+    return acc;
+  }, []).action(async (opts) => {
+    const start = Date.now();
+    try {
+      const { client, owner, repo } = getClient3(gh);
+      if (!opts.reviewer.length && !opts.teamReviewer.length) {
+        throw new PncliError("At least one --reviewer or --team-reviewer is required", 1);
+      }
+      await client.removeReviewers({
+        owner,
+        repo,
+        pullNumber: parseInt(opts.number, 10),
+        reviewers: opts.reviewer.length ? opts.reviewer : void 0,
+        teamReviewers: opts.teamReviewer.length ? opts.teamReviewer : void 0
+      });
+      success({ removed: true }, "github", "remove-reviewers", start);
+    } catch (err) {
+      fail(err, "github", "remove-reviewers", start);
+    }
+  });
+  gh.command("add-assignees").description("Add assignees to a pull request or issue").requiredOption("--number <n>", "PR or issue number").option("--assignee <login>", "Assignee login (repeatable)", (v, acc) => {
+    acc.push(v);
+    return acc;
+  }, []).action(async (opts) => {
+    const start = Date.now();
+    try {
+      const { client, owner, repo } = getClient3(gh);
+      if (!opts.assignee.length) throw new PncliError("At least one --assignee is required", 1);
+      const data = await client.addAssignees(owner, repo, parseInt(opts.number, 10), opts.assignee);
+      success(data, "github", "add-assignees", start);
+    } catch (err) {
+      fail(err, "github", "add-assignees", start);
+    }
+  });
+  gh.command("remove-assignees").description("Remove assignees from a pull request or issue").requiredOption("--number <n>", "PR or issue number").option("--assignee <login>", "Assignee login to remove (repeatable)", (v, acc) => {
+    acc.push(v);
+    return acc;
+  }, []).action(async (opts) => {
+    const start = Date.now();
+    try {
+      const { client, owner, repo } = getClient3(gh);
+      if (!opts.assignee.length) throw new PncliError("At least one --assignee is required", 1);
+      const data = await client.removeAssignees(owner, repo, parseInt(opts.number, 10), opts.assignee);
+      success(data, "github", "remove-assignees", start);
+    } catch (err) {
+      fail(err, "github", "remove-assignees", start);
+    }
+  });
 }
 
 // src/services/confluence/commands.ts
@@ -5901,16 +6314,6 @@ function registerConfigCommands(program2) {
       } else {
         results.artifactory = { ok: null, message: "not configured" };
       }
-      if (cfg.udeploy.baseUrl && (cfg.udeploy.pat || cfg.udeploy.username && cfg.udeploy.password)) {
-        try {
-          await http.udeploy("/cli/application");
-          results.udeploy = { ok: true, message: "connected" };
-        } catch (err) {
-          results.udeploy = { ok: false, message: err instanceof Error ? err.message : String(err) };
-        }
-      } else {
-        results.udeploy = { ok: null, message: "not configured" };
-      }
       if (cfg.checkmarx.baseUrl && cfg.checkmarx.tenantName && (cfg.checkmarx.apiKey || cfg.checkmarx.clientId && cfg.checkmarx.clientSecret)) {
         try {
           await http.checkmarx("projects", { params: { limit: 1 } });
@@ -6003,6 +6406,26 @@ function registerConfigCommands(program2) {
       } else {
         results.logscale = { ok: null, message: "not configured" };
       }
+      if (cfg.splitio.baseUrl && cfg.splitio.adminApiKey) {
+        try {
+          await http.splitio("/internal/api/v2/workspaces");
+          results.splitio = { ok: true, message: "connected" };
+        } catch (err) {
+          results.splitio = { ok: false, message: err instanceof Error ? err.message : String(err) };
+        }
+      } else {
+        results.splitio = { ok: null, message: "not configured" };
+      }
+      if (cfg.figma.baseUrl && cfg.figma.token) {
+        try {
+          await http.figma("/v1/me");
+          results.figma = { ok: true, message: "connected" };
+        } catch (err) {
+          results.figma = { ok: false, message: err instanceof Error ? err.message : String(err) };
+        }
+      } else {
+        results.figma = { ok: null, message: "not configured" };
+      }
       success(results, "config", "test", start);
     } catch (err) {
       fail(err, "config", "test", start);
@@ -6127,18 +6550,6 @@ function registerConfigCommands(program2) {
           results.jenkins = categorize2(err);
         }
       }
-      if (!cfg.udeploy.pat && !(cfg.udeploy.username && cfg.udeploy.password)) {
-        results.udeploy = { status: "blank", message: "not configured" };
-      } else if (!cfg.udeploy.baseUrl) {
-        results.udeploy = { status: "error", message: "baseUrl not configured" };
-      } else {
-        try {
-          await http.udeploy("/cli/application", { timeoutMs: 1e4 });
-          results.udeploy = { status: "valid", message: "ok" };
-        } catch (err) {
-          results.udeploy = categorize2(err);
-        }
-      }
       const artResult = await checkArtifactoryConnectivity(cfg.artifactory);
       if (!artResult.configured) {
         results.artifactory = { status: "blank", message: artResult.error ?? "not configured" };
@@ -6259,11 +6670,35 @@ function registerConfigCommands(program2) {
           results.logscale = categorize2(err);
         }
       }
+      if (!cfg.splitio.adminApiKey) {
+        results.splitio = { status: "blank", message: "not configured" };
+      } else if (!cfg.splitio.baseUrl) {
+        results.splitio = { status: "error", message: "baseUrl not configured" };
+      } else {
+        try {
+          await http.splitio("/internal/api/v2/workspaces", { timeoutMs: 1e4 });
+          results.splitio = { status: "valid", message: "ok" };
+        } catch (err) {
+          results.splitio = categorize2(err);
+        }
+      }
+      if (!cfg.figma.token) {
+        results.figma = { status: "blank", message: "not configured" };
+      } else if (!cfg.figma.baseUrl) {
+        results.figma = { status: "error", message: "baseUrl not configured" };
+      } else {
+        try {
+          await http.figma("/v1/me", { timeoutMs: 1e4 });
+          results.figma = { status: "valid", message: "ok" };
+        } catch (err) {
+          results.figma = categorize2(err);
+        }
+      }
       const statuses = Object.values(results).map((r) => r.status);
       if (statuses.includes("invalid")) process.exitCode = ExitCode.AUTH_ERROR;
       else if (statuses.includes("error")) process.exitCode = ExitCode.NETWORK_ERROR;
       if (cmdOpts.output === "table") {
-        const services = ["jira", "bitbucket", "github", "confluence", "sonar", "sde", "ado", "jenkins", "udeploy", "artifactory", "checkmarx", "servicenow", "contrast", "sonatypeiq", "openshift", "dynatrace", "dynatrace_platform", "logscale"];
+        const services = ["jira", "bitbucket", "github", "confluence", "sonar", "sde", "ado", "jenkins", "artifactory", "checkmarx", "servicenow", "contrast", "sonatypeiq", "openshift", "dynatrace", "dynatrace_platform", "logscale", "splitio", "figma"];
         const labelWidth = 14;
         const statusWidth = 9;
         for (const svc of services) {
@@ -6277,7 +6712,7 @@ function registerConfigCommands(program2) {
         process.stdout.write("\n");
       } else {
         if (opts.pretty) {
-          const services = ["jira", "bitbucket", "github", "confluence", "sonar", "sde", "ado", "jenkins", "udeploy", "artifactory", "checkmarx", "servicenow", "contrast", "sonatypeiq", "openshift", "dynatrace", "dynatrace_platform", "logscale"];
+          const services = ["jira", "bitbucket", "github", "confluence", "sonar", "sde", "ado", "jenkins", "artifactory", "checkmarx", "servicenow", "contrast", "sonatypeiq", "openshift", "dynatrace", "dynatrace_platform", "logscale", "splitio", "figma"];
           const labelWidth = 14;
           const statusWidth = 9;
           for (const svc of services) {
@@ -6297,11 +6732,6 @@ function registerConfigCommands(program2) {
     }
   });
 }
-function normalizeBaseUrl(raw) {
-  const trimmed = raw.trim();
-  if (!trimmed) return trimmed;
-  return /^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
-}
 async function initGlobalConfig(start) {
   process.stderr.write("pncli config init \u2014 Global configuration\n\n");
   process.stderr.write("\u2500\u2500 Identity \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
@@ -6529,7 +6959,7 @@ async function initGlobalConfig(start) {
   }
   process.stderr.write("\n\u2500\u2500 Jenkins \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
   const useJenkins = await confirm({
-    message: "Configure Jenkins Data Center for pipeline operations?",
+    message: "Configure Jenkins for pipeline operations?",
     default: false
   });
   let jenkinsBaseUrl = "";
@@ -6548,66 +6978,6 @@ async function initGlobalConfig(start) {
       message: "Jenkins API token:"
     });
   }
-  process.stderr.write("\n\u2500\u2500 IBM UrbanCode Deploy \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
-  const useUdeploy = await confirm({
-    message: "Configure IBM UrbanCode Deploy for component imports and deployment processes?",
-    default: false
-  });
-  let udeployBaseUrl = "";
-  let udeployPat = "";
-  let udeployUsername = "";
-  let udeployPassword = "";
-  let udeployDefaultApp = "";
-  let udeployDefaultEnv = "";
-  if (useUdeploy) {
-    udeployBaseUrl = await input({
-      message: "UDeploy base URL (e.g. ucd.imagile.dev:8443):",
-      default: ""
-    });
-    udeployUsername = await input({
-      message: "UDeploy username (leave blank to use a PAT instead):",
-      default: ""
-    });
-    if (udeployUsername) {
-      udeployPassword = await password({
-        message: "UDeploy password:",
-        validate: (v) => v.length > 0 || "Password cannot be blank"
-      });
-    } else {
-      udeployPat = await password({
-        message: "UDeploy personal access token:"
-      });
-    }
-    udeployDefaultApp = await input({
-      message: "Default application name (optional):",
-      default: ""
-    });
-    udeployDefaultEnv = await input({
-      message: "Default environment name (optional):",
-      default: ""
-    });
-    const hasCredentials = udeployBaseUrl && (udeployPat || udeployUsername && udeployPassword);
-    if (hasCredentials) {
-      process.stderr.write("\n  Verifying connection...\n");
-      try {
-        const tempConfig = {
-          ...loadConfig(),
-          udeploy: {
-            baseUrl: normalizeBaseUrl(udeployBaseUrl),
-            pat: udeployPat || void 0,
-            username: udeployUsername || void 0,
-            password: udeployPassword || void 0
-          }
-        };
-        const tempHttp = createHttpClient(tempConfig);
-        await tempHttp.udeploy("/cli/application");
-        process.stderr.write("  Connected.\n");
-      } catch (err) {
-        warn(`Could not connect to UDeploy: ${err instanceof Error ? err.message : String(err)}`);
-        warn("Config will be saved anyway. Check your URL and credentials and re-run pncli config init or pncli config test.");
-      }
-    }
-  }
   process.stderr.write("\n\u2500\u2500 Checkmarx \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
   const useCheckmarx = await confirm({
     message: "Configure Checkmarx One for vulnerability scanning?",
@@ -6934,16 +7304,80 @@ async function initGlobalConfig(start) {
       }
     }
   }
-  process.stderr.write("\n\u2500\u2500 Defaults \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
-  const jiraProject = await input({
-    message: "Default Jira project key (optional):",
-    default: ""
+  process.stderr.write("\n\u2500\u2500 Split.IO \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
+  const useSplitio = await confirm({
+    message: "Configure Split.IO for feature flag administration?",
+    default: false
   });
-  const sonarProject = useSonar ? await input({
-    message: "Default SonarQube project key (optional):",
-    default: ""
-  }) : "";
-  const sdeProject = useSde ? await input({
+  let splitioBaseUrl = "";
+  let splitioAdminApiKey = "";
+  if (useSplitio) {
+    splitioBaseUrl = await input({
+      message: "Split.IO Admin API base URL (e.g. https://api.split.io):",
+      default: ""
+    });
+    splitioAdminApiKey = await password({
+      message: "Split.IO Admin API key:"
+    });
+    if (splitioBaseUrl && splitioAdminApiKey) {
+      process.stderr.write("\n  Verifying connection...\n");
+      try {
+        const tempConfig = {
+          ...loadConfig(),
+          splitio: {
+            baseUrl: normalizeBaseUrl(splitioBaseUrl),
+            adminApiKey: splitioAdminApiKey
+          }
+        };
+        const tempHttp = createHttpClient(tempConfig);
+        await tempHttp.splitio("/internal/api/v2/workspaces");
+        process.stderr.write("  Connected.\n");
+      } catch (err) {
+        warn(`Could not connect to Split.IO: ${err instanceof Error ? err.message : String(err)}`);
+        warn("Config will be saved anyway. Check your URL and API key and re-run pncli config init or pncli config test.");
+      }
+    }
+  }
+  process.stderr.write("\n\u2500\u2500 Figma \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
+  const useFigma = await confirm({
+    message: "Configure Figma for reading design files and comments?",
+    default: false
+  });
+  let figmaToken = "";
+  if (useFigma) {
+    process.stderr.write("  Generate a personal access token in Figma under Account Settings \u2192 Personal access tokens.\n");
+    figmaToken = await password({
+      message: "Figma personal access token:"
+    });
+    if (figmaToken) {
+      process.stderr.write("\n  Verifying connection...\n");
+      try {
+        const tempConfig = {
+          ...loadConfig(),
+          figma: {
+            baseUrl: "https://api.figma.com",
+            token: figmaToken
+          }
+        };
+        const tempHttp = createHttpClient(tempConfig);
+        await tempHttp.figma("/v1/me");
+        process.stderr.write("  Connected.\n");
+      } catch (err) {
+        warn(`Could not connect to Figma: ${err instanceof Error ? err.message : String(err)}`);
+        warn("Config will be saved anyway. Check your token and re-run pncli config init or pncli config test.");
+      }
+    }
+  }
+  process.stderr.write("\n\u2500\u2500 Defaults \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
+  const jiraProject = await input({
+    message: "Default Jira project key (optional):",
+    default: ""
+  });
+  const sonarProject = useSonar ? await input({
+    message: "Default SonarQube project key (optional):",
+    default: ""
+  }) : "";
+  const sdeProject = useSde ? await input({
     message: "Default SDElements project ID (optional, numeric):",
     default: ""
   }) : "";
@@ -6957,7 +7391,10 @@ async function initGlobalConfig(start) {
     process.exitCode = ExitCode.SUCCESS;
     return;
   }
+  const existingGlobal = loadJsonFile(getGlobalConfigPath());
+  const existingInstances = Array.isArray(existingGlobal?.jenkinsInstances) ? existingGlobal.jenkinsInstances : [];
   writeGlobalConfig({
+    jenkinsInstances: existingInstances,
     user: {
       email: userEmail || void 0,
       userId: userId || void 0
@@ -7018,14 +7455,6 @@ async function initGlobalConfig(start) {
         ...jenkinsApiToken ? { apiToken: jenkinsApiToken } : {}
       }
     } : {},
-    ...useUdeploy && udeployBaseUrl ? {
-      udeploy: {
-        baseUrl: normalizeBaseUrl(udeployBaseUrl),
-        ...udeployPat ? { pat: udeployPat } : {},
-        ...udeployUsername ? { username: udeployUsername } : {},
-        ...udeployPassword ? { password: udeployPassword } : {}
-      }
-    } : {},
     ...useCheckmarx && checkmarxBaseUrl ? {
       checkmarx: {
         baseUrl: normalizeBaseUrl(checkmarxBaseUrl),
@@ -7079,6 +7508,18 @@ async function initGlobalConfig(start) {
         token: logscaleToken || void 0
       }
     } : {},
+    ...useSplitio && splitioBaseUrl ? {
+      splitio: {
+        baseUrl: normalizeBaseUrl(splitioBaseUrl),
+        adminApiKey: splitioAdminApiKey || void 0
+      }
+    } : {},
+    ...useFigma && figmaToken ? {
+      figma: {
+        baseUrl: "https://api.figma.com",
+        token: figmaToken
+      }
+    } : {},
     defaults: {
       jira: {
         project: jiraProject || void 0
@@ -7098,12 +7539,6 @@ async function initGlobalConfig(start) {
           collection: adoCollection || void 0,
           project: adoProject || void 0
         }
-      } : {},
-      ...useUdeploy && (udeployDefaultApp || udeployDefaultEnv) ? {
-        udeploy: {
-          application: udeployDefaultApp || void 0,
-          environment: udeployDefaultEnv || void 0
-        }
       } : {}
     }
   });
@@ -7835,10 +8270,10 @@ function registerAdoWorkCommands(ado) {
       const types = await discoverTypes(workClient, collection, project);
       if (opts.save) {
         const globalConfigPath = getGlobalConfigPath(globalOpts.config);
-        const fs5 = await import("fs");
-        const existing = JSON.parse(fs5.readFileSync(globalConfigPath, "utf8") || "{}");
+        const fs6 = await import("fs");
+        const existing = JSON.parse(fs6.readFileSync(globalConfigPath, "utf8") || "{}");
         existing.ado = { ...existing.ado ?? {}, discoveredTypes: types };
-        fs5.writeFileSync(globalConfigPath, JSON.stringify(existing, null, 2) + "\n", "utf8");
+        fs6.writeFileSync(globalConfigPath, JSON.stringify(existing, null, 2) + "\n", "utf8");
         warn(`Saved ${types.length} types to ${globalConfigPath}`);
       }
       success(types, "ado", "work-types", start);
@@ -7867,11 +8302,11 @@ function registerAdoWorkCommands(ado) {
       ) : allFields;
       if (opts.save) {
         const globalConfigPath = getGlobalConfigPath(globalOpts.config);
-        const fs5 = await import("fs");
-        const existing = JSON.parse(fs5.readFileSync(globalConfigPath, "utf8") || "{}");
+        const fs6 = await import("fs");
+        const existing = JSON.parse(fs6.readFileSync(globalConfigPath, "utf8") || "{}");
         const aliases = buildDefaultAliases(allFields);
         existing.ado = { ...existing.ado ?? {}, discoveredFields: allFields, fieldAliases: aliases };
-        fs5.writeFileSync(globalConfigPath, JSON.stringify(existing, null, 2) + "\n", "utf8");
+        fs6.writeFileSync(globalConfigPath, JSON.stringify(existing, null, 2) + "\n", "utf8");
         warn(`Saved ${allFields.length} fields and ${Object.keys(aliases).length} aliases to ${globalConfigPath}`);
       }
       success(fields, "ado", "work-fields", start);
@@ -8168,11 +8603,11 @@ function registerAdoRepoCommands(ado) {
       const start = Date.now();
       try {
         const globalOpts = ado.optsWithGlobals();
-        const { loadConfig: lc } = await import("./config-SQ3YHJHI.js");
+        const { loadConfig: lc } = await import("./config-YHYQTGKT.js");
         const config = lc({ configPath: globalOpts.config });
         const { collection, project, repo: repo2, gitClient } = getAdoContext(ado, true);
         const { AdoCoreClient: AdoCoreClient2 } = await import("./core-SWYVXOQ4.js");
-        const { createHttpClient: createHttpClient2 } = await import("./http-WCK6AZW6.js");
+        const { createHttpClient: createHttpClient2 } = await import("./http-6QJU2SWP.js");
         const http = createHttpClient2(config, Boolean(globalOpts.dryRun));
         const coreClient = new AdoCoreClient2(http);
         const me = await coreClient.getConnectionData(collection);
@@ -8430,11 +8865,22 @@ var JenkinsClient = class {
 };
 
 // src/services/jenkins/commands.ts
-function getClient7(program2) {
-  const opts = program2.optsWithGlobals();
+function getClient7(cmd) {
+  const opts = cmd.optsWithGlobals();
   const config = loadConfig({ configPath: opts.config });
-  if (!config.jenkins.baseUrl) throw new PncliError("Jenkins not configured. Run: pncli config init");
-  const http = createHttpClient(config, Boolean(opts.dryRun));
+  let jenkins = config.jenkins;
+  if (opts.instance) {
+    const inst = config.jenkinsInstances.find((i) => i.name === opts.instance);
+    if (!inst) throw new PncliError(`Jenkins instance "${opts.instance}" not found. Add it to your global config using pncli config set jenkinsInstances.`);
+    jenkins = { baseUrl: inst.baseUrl, username: inst.username, apiToken: inst.apiToken };
+  }
+  if (!jenkins.baseUrl) {
+    if (opts.instance) {
+      throw new PncliError(`Jenkins instance "${opts.instance}" has no baseUrl configured. Add a baseUrl to that entry in jenkinsInstances.`);
+    }
+    throw new PncliError("Jenkins not configured. Run: pncli config init");
+  }
+  const http = createHttpClient({ ...config, jenkins }, Boolean(opts.dryRun));
   return new JenkinsClient(http);
 }
 async function pollQueueItem(client, queueItemId, pollMs, timeoutMs) {
@@ -8459,12 +8905,70 @@ async function pollBuildComplete(client, jobName, buildNumber, pollMs, timeoutMs
   throw new PncliError(`Timed out waiting for build #${buildNumber} to complete after ${timeoutMs / 1e3}s`, 1);
 }
 function registerJenkinsCommands(program2) {
-  const jenkins = program2.command("jenkins").description("Jenkins Data Center operations");
+  const jenkins = program2.command("jenkins").description("Jenkins operations").option("--instance <name>", "Named Jenkins instance from global config (overrides default jenkins config)");
   const pipeline = jenkins.command("pipeline").description("Pipeline (job/build) operations");
+  const instance = jenkins.command("instance").description("Manage named Jenkins instances in the global config");
+  instance.command("list").description("List configured Jenkins instances (API tokens masked)").action(() => {
+    const start = Date.now();
+    try {
+      const opts = jenkins.optsWithGlobals();
+      const config = loadConfig({ configPath: opts.config });
+      const instances = config.jenkinsInstances.map((i) => ({
+        ...i,
+        apiToken: i.apiToken ? "***" : void 0
+      }));
+      success({ instances }, "jenkins", "instance-list", start);
+    } catch (err) {
+      fail(err, "jenkins", "instance-list", start);
+    }
+  });
+  instance.command("add").description("Add a named Jenkins instance to the global config (appends \u2014 existing instances are preserved)").requiredOption("--name <name>", "Instance name used with --instance").requiredOption("--base-url <url>", "Jenkins base URL (e.g. jenkins.imagile.dev)").option("--username <user>", "Jenkins username").option("--api-token <token>", "Jenkins API token (prompted for when omitted on an interactive terminal, keeping it out of shell history)").option("--force", "Overwrite an instance that already uses this name").action(async (o) => {
+    const start = Date.now();
+    try {
+      const opts = jenkins.optsWithGlobals();
+      const configPath = opts.config;
+      const existing = loadConfig({ configPath }).jenkinsInstances;
+      const idx = existing.findIndex((i) => i.name === o.name);
+      if (idx >= 0 && !o.force) {
+        throw new PncliError(`Jenkins instance "${o.name}" already exists. Pass --force to overwrite it, or run: pncli jenkins instance remove --name ${o.name}`, 1);
+      }
+      let apiToken = o.apiToken;
+      if (!apiToken && process.stdin.isTTY) {
+        const { default: password2 } = await import("@inquirer/password");
+        apiToken = await password2({ message: `API token for "${o.name}" (leave blank to skip):` });
+      }
+      const entry = {
+        name: o.name,
+        baseUrl: normalizeBaseUrl(o.baseUrl),
+        ...o.username ? { username: o.username } : {},
+        ...apiToken ? { apiToken } : {}
+      };
+      const next = idx >= 0 ? existing.map((i, n) => n === idx ? entry : i) : [...existing, entry];
+      setConfigValue("jenkinsInstances", JSON.stringify(next), configPath);
+      success({ name: entry.name, baseUrl: entry.baseUrl, overwritten: idx >= 0 }, "jenkins", "instance-add", start);
+    } catch (err) {
+      fail(err, "jenkins", "instance-add", start);
+    }
+  });
+  instance.command("remove").description("Remove a named Jenkins instance from the global config").requiredOption("--name <name>", "Instance name to remove").action((o) => {
+    const start = Date.now();
+    try {
+      const opts = jenkins.optsWithGlobals();
+      const configPath = opts.config;
+      const existing = loadConfig({ configPath }).jenkinsInstances;
+      if (!existing.some((i) => i.name === o.name)) {
+        throw new PncliError(`Jenkins instance "${o.name}" not found. Run: pncli jenkins instance list`, 1);
+      }
+      setConfigValue("jenkinsInstances", JSON.stringify(existing.filter((i) => i.name !== o.name)), configPath);
+      success({ removed: o.name }, "jenkins", "instance-remove", start);
+    } catch (err) {
+      fail(err, "jenkins", "instance-remove", start);
+    }
+  });
   pipeline.command("list").description("List all jobs on the Jenkins instance (or within a folder)").option("--folder <name>", "Folder name to enumerate (supports nested folders: parentFolder/childFolder)").action(async (opts) => {
     const start = Date.now();
     try {
-      const client = getClient7(program2);
+      const client = getClient7(jenkins);
       const data = await client.listJobs(opts.folder);
       success(data, "jenkins", "pipeline-list", start);
     } catch (err) {
@@ -8474,7 +8978,7 @@ function registerJenkinsCommands(program2) {
   pipeline.command("get").description("Get details for a specific job").requiredOption("--name <job>", "Job name (use folder/job for folder-scoped jobs)").action(async (opts) => {
     const start = Date.now();
     try {
-      const client = getClient7(program2);
+      const client = getClient7(jenkins);
       const data = await client.getJob(opts.name);
       success(data, "jenkins", "pipeline-get", start);
     } catch (err) {
@@ -8487,7 +8991,7 @@ function registerJenkinsCommands(program2) {
   }, []).option("--wait", "Wait for the build to complete before returning").option("--timeout <s>", "Max wait time in seconds per phase (queue-wait and build-wait each get this budget; default 600)", "600").option("--poll <s>", "Poll interval in seconds (default 10)", "10").action(async (opts) => {
     const start = Date.now();
     try {
-      const client = getClient7(program2);
+      const client = getClient7(jenkins);
       for (const p of opts.parameter) {
         if (!p.includes("=")) throw new PncliError(`Invalid --parameter "${p}". Expected format: key=value`, 1);
       }
@@ -8520,7 +9024,7 @@ function registerJenkinsCommands(program2) {
   pipeline.command("list-runs").description("List recent builds for a job").requiredOption("--name <job>", "Job name (use folder/job for folder-scoped jobs)").option("--top <n>", "Maximum number of builds to return (default 25)", "25").action(async (opts) => {
     const start = Date.now();
     try {
-      const client = getClient7(program2);
+      const client = getClient7(jenkins);
       const top = parseInt(opts.top, 10);
       if (isNaN(top) || top <= 0) throw new PncliError(`Invalid --top "${opts.top}". Expected a positive integer.`, 1);
       const data = await client.listBuilds(opts.name, top);
@@ -8532,7 +9036,7 @@ function registerJenkinsCommands(program2) {
   pipeline.command("get-run").description("Get details for a specific build").requiredOption("--name <job>", "Job name (use folder/job for folder-scoped jobs)").requiredOption("--number <n>", "Build number").action(async (opts) => {
     const start = Date.now();
     try {
-      const client = getClient7(program2);
+      const client = getClient7(jenkins);
       const buildNumber = parseInt(opts.number, 10);
       if (isNaN(buildNumber)) throw new PncliError(`Invalid --number "${opts.number}". Expected an integer.`, 1);
       const data = await client.getBuild(opts.name, buildNumber);
@@ -8544,7 +9048,7 @@ function registerJenkinsCommands(program2) {
   pipeline.command("logs").description("Fetch console log for a build (consider --output-file for large logs)").requiredOption("--name <job>", "Job name (use folder/job for folder-scoped jobs)").requiredOption("--number <n>", "Build number").action(async (opts) => {
     const start = Date.now();
     try {
-      const client = getClient7(program2);
+      const client = getClient7(jenkins);
       const buildNumber = parseInt(opts.number, 10);
       if (isNaN(buildNumber)) throw new PncliError(`Invalid --number "${opts.number}". Expected an integer.`, 1);
       const text = await client.getConsoleLog(opts.name, buildNumber);
@@ -8621,7 +9125,7 @@ var ArtifactoryClient = class {
     }));
     const result = { builds, uri: raw.uri };
     if (builds.length === 0) {
-      result.hint = 'No builds are registered in Artifactory Build Integration. Build names may differ from ADO pipeline or uDeploy component names. Use "artifactory repos" to list repositories, then "artifactory search --repo <repo>" to locate artifacts directly.';
+      result.hint = 'No builds are registered in Artifactory Build Integration. Build names may differ from ADO pipeline names. Use "artifactory repos" to list repositories, then "artifactory search --repo <repo>" to locate artifacts directly.';
     }
     return result;
   }
@@ -8724,7 +9228,7 @@ function registerArtifactoryCommands(program2) {
       fail(err, "artifactory", "search", start);
     }
   });
-  art.command("builds").description('List builds registered in Artifactory Build Integration (names may differ from ADO pipeline or uDeploy component names; use "search --repo" when empty)').option("--timeout <s>", "Request timeout in seconds (default 60; increase for large Artifactory instances)", "60").action(async (opts) => {
+  art.command("builds").description('List builds registered in Artifactory Build Integration (names may differ from ADO pipeline names; use "search --repo" when empty)').option("--timeout <s>", "Request timeout in seconds (default 60; increase for large Artifactory instances)", "60").action(async (opts) => {
     const start = Date.now();
     try {
       const client = getClient8(program2);
@@ -8759,226 +9263,6 @@ function registerArtifactoryCommands(program2) {
   });
 }
 
-// src/services/udeploy/client.ts
-var UdeployClient = class {
-  constructor(http) {
-    this.http = http;
-  }
-  http;
-  listApplications() {
-    return this.http.udeploy("/cli/application");
-  }
-  listEnvironments(application) {
-    return this.http.udeploy("/cli/application/environmentsInApplication", {
-      params: { application }
-    });
-  }
-  listComponents() {
-    return this.http.udeploy("/cli/component");
-  }
-  listVersions(component) {
-    return this.http.udeploy("/cli/component/versions", {
-      params: { component }
-    });
-  }
-  createVersion(component, name) {
-    return this.http.udeploy("/cli/version/createVersion", {
-      method: "POST",
-      params: { component, name }
-    });
-  }
-  finishImporting(component, version) {
-    return this.http.udeploy("/cli/version/finishedImporting", {
-      method: "POST",
-      params: { component, version }
-    });
-  }
-  runProcess(opts) {
-    return this.http.udeploy("/cli/applicationProcessRequest/request", {
-      method: "PUT",
-      body: {
-        application: opts.application,
-        applicationProcess: opts.applicationProcess,
-        environment: opts.environment,
-        onlyChanged: opts.onlyChanged ?? false,
-        ...opts.versions ? { versions: opts.versions } : {},
-        ...opts.snapshot ? { snapshot: opts.snapshot } : {},
-        ...opts.properties ? { properties: opts.properties } : {}
-      }
-    });
-  }
-  getRequestStatus(requestId) {
-    return this.http.udeploy("/cli/applicationProcessRequest/requestStatus", {
-      params: { requestId }
-    });
-  }
-  getRequestInfo(requestId) {
-    return this.http.udeploy("/cli/applicationProcessRequest/requestInfo", {
-      params: { requestId }
-    });
-  }
-};
-
-// src/services/udeploy/commands.ts
-var POLL_INTERVAL_MS2 = 5e3;
-var DEFAULT_TIMEOUT_MS = 10 * 60 * 1e3;
-function getClient9(program2) {
-  const opts = program2.optsWithGlobals();
-  const config = loadConfig({ configPath: opts.config });
-  if (!config.udeploy.baseUrl) {
-    throw new PncliError("UDeploy baseUrl not configured. Run: pncli config init", 78);
-  }
-  const http = createHttpClient(config, opts.dryRun);
-  return { client: new UdeployClient(http), config };
-}
-function resolveApplication(config, cliValue) {
-  const app = cliValue ?? config.defaults.udeploy.application;
-  if (!app) throw new PncliError("--application is required (or set defaults.udeploy.application in config)", 2);
-  return app;
-}
-function resolveEnvironment(config, cliValue) {
-  const env = cliValue ?? config.defaults.udeploy.environment;
-  if (!env) throw new PncliError("--environment is required (or set defaults.udeploy.environment in config)", 2);
-  return env;
-}
-function registerUdeployCommands(program2) {
-  const udeploy = program2.command("udeploy").description("IBM UrbanCode Deploy \u2014 component versions and deployment processes").option("--application <name>", "Application name or ID").option("--environment <name>", "Environment name or ID");
-  udeploy.command("apps").description("List all applications").action(async () => {
-    const start = Date.now();
-    try {
-      const { client } = getClient9(program2);
-      const apps = await client.listApplications();
-      success(apps, "udeploy", "apps", start);
-    } catch (err) {
-      fail(err, "udeploy", "apps", start);
-    }
-  });
-  udeploy.command("environments").description("List environments for an application").action(async () => {
-    const start = Date.now();
-    try {
-      const { client, config } = getClient9(program2);
-      const parentOpts = udeploy.opts();
-      const application = resolveApplication(config, parentOpts.application);
-      const envs = await client.listEnvironments(application);
-      success(envs, "udeploy", "environments", start);
-    } catch (err) {
-      fail(err, "udeploy", "environments", start);
-    }
-  });
-  udeploy.command("components").description("List all components").action(async () => {
-    const start = Date.now();
-    try {
-      const { client } = getClient9(program2);
-      const components = await client.listComponents();
-      success(components, "udeploy", "components", start);
-    } catch (err) {
-      fail(err, "udeploy", "components", start);
-    }
-  });
-  udeploy.command("versions").description("List versions for a component").requiredOption("--component <name>", "Component name or ID").action(async (cmdOpts) => {
-    const start = Date.now();
-    try {
-      const { client } = getClient9(program2);
-      const versions = await client.listVersions(cmdOpts.component);
-      success(versions, "udeploy", "versions", start);
-    } catch (err) {
-      fail(err, "udeploy", "versions", start);
-    }
-  });
-  udeploy.command("import-version").description("Create a component version and mark it ready for deployment").requiredOption("--component <name>", "Component name or ID").requiredOption("--name <name>", "Version name").option("--no-finish", "Skip marking the version as finished importing").action(async (cmdOpts) => {
-    const start = Date.now();
-    try {
-      const { client } = getClient9(program2);
-      const created = await client.createVersion(cmdOpts.component, cmdOpts.name);
-      if (cmdOpts.finish) {
-        await client.finishImporting(cmdOpts.component, cmdOpts.name);
-      }
-      success({ ...created, finishedImporting: cmdOpts.finish }, "udeploy", "import-version", start);
-    } catch (err) {
-      fail(err, "udeploy", "import-version", start);
-    }
-  });
-  udeploy.command("run").description("Run an application deployment process").requiredOption("--process <name>", "Application process name or ID").option("--component <name>", "Component name (repeatable)", collect, []).option("--component-version <name>", "Component version (repeatable; positionally paired with --component)", collect, []).option("--snapshot <name>", "Snapshot name or ID (alternative to specifying versions)").option("--only-changed", "Deploy only changed components", false).option("--wait", "Poll until the process completes", false).option("--timeout <ms>", "Max wait time in milliseconds", String(DEFAULT_TIMEOUT_MS)).action(async (cmdOpts) => {
-    const start = Date.now();
-    try {
-      const { client, config } = getClient9(program2);
-      const parentOpts = udeploy.opts();
-      const application = resolveApplication(config, parentOpts.application);
-      const environment = resolveEnvironment(config, parentOpts.environment);
-      const components = cmdOpts.component;
-      const versions = cmdOpts.componentVersion;
-      const versionEntries = components.map((c, i) => ({
-        component: c,
-        version: versions[i] ?? "latest"
-      }));
-      const result = await client.runProcess({
-        application,
-        applicationProcess: cmdOpts.process,
-        environment,
-        onlyChanged: cmdOpts.onlyChanged,
-        ...versionEntries.length > 0 ? { versions: versionEntries } : {},
-        ...cmdOpts.snapshot ? { snapshot: cmdOpts.snapshot } : {}
-      });
-      if (!cmdOpts.wait) {
-        success(result, "udeploy", "run", start);
-        return;
-      }
-      const timeoutMs = parseInt(cmdOpts.timeout, 10);
-      const requestId = result.requestId;
-      log(`Process started. Request ID: ${requestId}. Polling for completion...`);
-      while (true) {
-        const elapsed = Date.now() - start;
-        if (elapsed >= timeoutMs) {
-          throw new PncliError(`Timed out after ${timeoutMs}ms waiting for request ${requestId}`, 1);
-        }
-        await sleep(POLL_INTERVAL_MS2);
-        const status = await client.getRequestStatus(requestId);
-        if (status.status === "CLOSED") {
-          const outcome = { requestId, status: status.status, result: status.result, elapsed_ms: Date.now() - start };
-          if (status.result === "SUCCEEDED") {
-            success(outcome, "udeploy", "run", start);
-          } else {
-            throw new PncliError(
-              `Deployment ${status.result ?? "failed"} (requestId: ${requestId})`,
-              1
-            );
-          }
-          return;
-        }
-        log(`Status: ${status.status} (${Math.round((Date.now() - start) / 1e3)}s elapsed)`);
-      }
-    } catch (err) {
-      fail(err, "udeploy", "run", start);
-    }
-  });
-  udeploy.command("request-status").description("Get the current status of a deployment process request").requiredOption("--request-id <id>", "Request ID returned by udeploy run").action(async (cmdOpts) => {
-    const start = Date.now();
-    try {
-      const { client } = getClient9(program2);
-      const status = await client.getRequestStatus(cmdOpts.requestId);
-      success(status, "udeploy", "request-status", start);
-    } catch (err) {
-      fail(err, "udeploy", "request-status", start);
-    }
-  });
-  udeploy.command("request-info").description("Get full details of a deployment process request").requiredOption("--request-id <id>", "Request ID returned by udeploy run").action(async (cmdOpts) => {
-    const start = Date.now();
-    try {
-      const { client } = getClient9(program2);
-      const info = await client.getRequestInfo(cmdOpts.requestId);
-      success(info, "udeploy", "request-info", start);
-    } catch (err) {
-      fail(err, "udeploy", "request-info", start);
-    }
-  });
-}
-function collect(val, prev) {
-  return [...prev, val];
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
 // src/services/checkmarx/client.ts
 var CheckmarxClient = class {
   constructor(http) {
@@ -9019,7 +9303,7 @@ var CheckmarxClient = class {
 };
 
 // src/services/checkmarx/commands.ts
-function getClient10(program2) {
+function getClient9(program2) {
   const opts = program2.optsWithGlobals();
   const config = loadConfig({ configPath: opts.config });
   if (!config.checkmarx.baseUrl) throw new PncliError("Checkmarx not configured. Run: pncli config init");
@@ -9033,7 +9317,7 @@ function registerCheckmarxCommands(program2) {
   project.command("list").description("List all projects").action(async () => {
     const start = Date.now();
     try {
-      const data = await getClient10(program2).listProjects();
+      const data = await getClient9(program2).listProjects();
       success(data, "checkmarx", "project-list", start);
     } catch (err) {
       fail(err, "checkmarx", "project-list", start);
@@ -9042,7 +9326,7 @@ function registerCheckmarxCommands(program2) {
   project.command("get").description("Get a project by ID").requiredOption("--id <id>", "Project UUID").action(async (opts) => {
     const start = Date.now();
     try {
-      const data = await getClient10(program2).getProject(opts.id);
+      const data = await getClient9(program2).getProject(opts.id);
       success(data, "checkmarx", "project-get", start);
     } catch (err) {
       fail(err, "checkmarx", "project-get", start);
@@ -9053,7 +9337,7 @@ function registerCheckmarxCommands(program2) {
     try {
       const last = opts.last ? parseInt(opts.last, 10) : void 0;
       if (opts.last && isNaN(last)) throw new PncliError(`Invalid --last "${opts.last}". Expected an integer.`, 1);
-      const data = await getClient10(program2).listScans({ projectId: opts.project, last });
+      const data = await getClient9(program2).listScans({ projectId: opts.project, last });
       success(data, "checkmarx", "scan-list", start);
     } catch (err) {
       fail(err, "checkmarx", "scan-list", start);
@@ -9062,7 +9346,7 @@ function registerCheckmarxCommands(program2) {
   scan.command("get").description("Get a scan by ID").requiredOption("--id <id>", "Scan UUID").action(async (opts) => {
     const start = Date.now();
     try {
-      const data = await getClient10(program2).getScan(opts.id);
+      const data = await getClient9(program2).getScan(opts.id);
       success(data, "checkmarx", "scan-get", start);
     } catch (err) {
       fail(err, "checkmarx", "scan-get", start);
@@ -9071,7 +9355,7 @@ function registerCheckmarxCommands(program2) {
   scan.command("stats").description("Get results statistics for a scan").requiredOption("--id <id>", "Scan UUID").action(async (opts) => {
     const start = Date.now();
     try {
-      const data = await getClient10(program2).getScanResultsStatistics(opts.id);
+      const data = await getClient9(program2).getScanResultsStatistics(opts.id);
       success(data, "checkmarx", "scan-stats", start);
     } catch (err) {
       fail(err, "checkmarx", "scan-stats", start);
@@ -10524,9 +10808,32 @@ function podAge(creationTimestamp) {
   if (ageHours < 24) return `${ageHours}h`;
   return `${Math.floor(ageHours / 24)}d`;
 }
+function parseCpuMillicores(cpu) {
+  if (!cpu) return null;
+  if (cpu.endsWith("n")) return Math.round(Number(cpu.slice(0, -1)) / 1e6);
+  if (cpu.endsWith("u")) return Math.round(Number(cpu.slice(0, -1)) / 1e3);
+  if (cpu.endsWith("m")) return Number(cpu.slice(0, -1));
+  const whole = Number(cpu);
+  if (!Number.isNaN(whole)) return Math.round(whole * 1e3);
+  return null;
+}
+function parseMemMiB(mem) {
+  if (!mem) return null;
+  const round2 = (n) => Math.round(n * 100) / 100;
+  if (mem.endsWith("Ki")) return round2(Number(mem.slice(0, -2)) / 1024);
+  if (mem.endsWith("Mi")) return Number(mem.slice(0, -2));
+  if (mem.endsWith("Gi")) return Math.round(Number(mem.slice(0, -2)) * 1024);
+  if (mem.endsWith("Ti")) return Math.round(Number(mem.slice(0, -2)) * 1024 * 1024);
+  if (mem.endsWith("K")) return round2(Number(mem.slice(0, -1)) * 1e3 / (1024 * 1024));
+  if (mem.endsWith("M")) return round2(Number(mem.slice(0, -1)) * 1e3 * 1e3 / (1024 * 1024));
+  if (mem.endsWith("G")) return Math.round(Number(mem.slice(0, -1)) * 1e3 * 1e3 * 1e3 / (1024 * 1024));
+  const bytes = Number(mem);
+  if (!Number.isNaN(bytes)) return round2(bytes / (1024 * 1024));
+  return null;
+}
 function registerOpenShiftCommands(program2) {
   const oc = program2.command("openshift").description("OpenShift / Kubernetes operations");
-  oc.command("pods").description("List pod health summary for a namespace \u2014 pre-processed for LLM analysis").requiredOption("--namespace <ns>", "Kubernetes namespace").option("--label-selector <selector>", "Label selector (e.g. app=my-app)").action(async (opts) => {
+  oc.command("pods").description("List pod health summary for a namespace \u2014 pre-processed for LLM analysis. Use --raw to return the full unmodified Kubernetes pod objects.").requiredOption("--namespace <ns>", "Kubernetes namespace").option("--label-selector <selector>", "Label selector (e.g. app=my-app)").option("--raw", "Return full Kubernetes pod objects without summarization (includes env vars, images, node name, annotations, resources, etc.)", false).action(async (opts) => {
     const start = Date.now();
     try {
       const http = getHttp2(program2);
@@ -10536,6 +10843,15 @@ function registerOpenShiftCommands(program2) {
         `/api/v1/namespaces/${encodeURIComponent(opts.namespace)}/pods`,
         { params }
       );
+      if (opts.raw) {
+        success(
+          { namespace: opts.namespace, count: podList.items.length, pods: podList.items },
+          "openshift",
+          "pods",
+          start
+        );
+        return;
+      }
       const summaryCounters = {
         total: podList.items.length,
         running: 0,
@@ -10712,6 +11028,71 @@ function registerOpenShiftCommands(program2) {
       fail(err, "openshift", "pod-metrics", start);
     }
   });
+  oc.command("resource-usage").description("Combined CPU/memory usage, limits, and requests for all pods in a namespace \u2014 all values normalized to millicores (m) and mebibytes (Mi). Requires metrics-server. Use --csv to emit a spreadsheet-friendly CSV.").requiredOption("--namespace <ns>", "Kubernetes namespace").option("--label-selector <selector>", "Label selector (e.g. app=my-app)").option("--csv", "Output as CSV instead of JSON (suitable for Excel)", false).action(async (opts) => {
+    const start = Date.now();
+    try {
+      const http = getHttp2(program2);
+      const nsEncoded = encodeURIComponent(opts.namespace);
+      const podParams = {};
+      if (opts.labelSelector) podParams["labelSelector"] = opts.labelSelector;
+      const [podList, metricsList] = await Promise.all([
+        http.openshift(`/api/v1/namespaces/${nsEncoded}/pods`, { params: podParams }),
+        http.openshift(`/apis/metrics.k8s.io/v1beta1/namespaces/${nsEncoded}/pods`, { params: podParams })
+      ]);
+      const metricsIndex = /* @__PURE__ */ new Map();
+      for (const pm of metricsList.items) {
+        const containerMap = /* @__PURE__ */ new Map();
+        for (const c of pm.containers) {
+          containerMap.set(c.name, c.usage);
+        }
+        metricsIndex.set(pm.metadata.name, containerMap);
+      }
+      const rows = [];
+      for (const pod of podList.items) {
+        const podName = pod.metadata.name;
+        const podMetrics = metricsIndex.get(podName);
+        const containers = pod.spec.containers ?? [];
+        for (const container of containers) {
+          const usage = podMetrics?.get(container.name);
+          rows.push({
+            pod: podName,
+            container: container.name,
+            cpuUsageMillicores: parseCpuMillicores(usage?.cpu),
+            memUsageMiB: parseMemMiB(usage?.memory),
+            cpuLimitsMillicores: parseCpuMillicores(container.resources?.limits?.cpu),
+            memLimitsMiB: parseMemMiB(container.resources?.limits?.memory),
+            cpuRequestsMillicores: parseCpuMillicores(container.resources?.requests?.cpu),
+            memRequestsMiB: parseMemMiB(container.resources?.requests?.memory)
+          });
+        }
+      }
+      if (opts.csv) {
+        const header = "Pod,Container,CPU Usage (m),Memory Usage (Mi),CPU Limits (m),Memory Limits (Mi),CPU Requests (m),Memory Requests (Mi)";
+        const lines = rows.map(
+          (r) => [
+            r.pod,
+            r.container,
+            r.cpuUsageMillicores ?? "",
+            r.memUsageMiB ?? "",
+            r.cpuLimitsMillicores ?? "",
+            r.memLimitsMiB ?? "",
+            r.cpuRequestsMillicores ?? "",
+            r.memRequestsMiB ?? ""
+          ].join(",")
+        );
+        writeRawOutput([header, ...lines].join("\n") + "\n");
+      } else {
+        success(
+          { namespace: opts.namespace, count: rows.length, units: { cpu: "m", memory: "Mi" }, rows },
+          "openshift",
+          "resource-usage",
+          start
+        );
+      }
+    } catch (err) {
+      fail(err, "openshift", "resource-usage", start);
+    }
+  });
 }
 
 // src/services/dynatrace/commands.ts
@@ -10937,6 +11318,500 @@ function registerLogscaleCommands(program2) {
   });
 }
 
+// src/services/splitio/commands.ts
+import fs5 from "fs";
+import confirm2 from "@inquirer/confirm";
+function getHttp5(program2) {
+  const opts = program2.optsWithGlobals();
+  return createHttpClient(
+    loadConfig({ configPath: opts.config }),
+    Boolean(opts.dryRun)
+  );
+}
+function loadInputFile(filePath) {
+  let raw;
+  if (filePath === "-") {
+    raw = fs5.readFileSync(process.stdin.fd, "utf8");
+  } else {
+    raw = fs5.readFileSync(filePath, "utf8");
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new PncliError(`Could not parse JSON from ${filePath === "-" ? "stdin" : filePath}`);
+  }
+}
+async function confirmWrite(opts, opLabel) {
+  if (opts.yes) return;
+  const proceed = await confirm2({
+    message: `Submit Change Request "${opts.mnemonic}" (${opLabel})? This creates an approval request in Split.`,
+    default: false
+  });
+  if (!proceed) throw new PncliError("Aborted by user.", 0);
+}
+function buildCrBase(opts) {
+  const base = {
+    title: opts.mnemonic,
+    comment: opts.description,
+    crNumber: opts.changeNumber
+  };
+  if (opts.approvers) {
+    base["approvers"] = opts.approvers.split(",").map((s) => s.trim()).filter(Boolean).map((id) => ({ id }));
+  }
+  return base;
+}
+function registerSplitioCommands(program2) {
+  const splitio = program2.command("splitio").description("Split.IO feature flag administration");
+  const workspaces = splitio.command("workspaces").description("Workspace operations");
+  workspaces.command("list").description("List all Split.IO workspaces").action(async () => {
+    const start = Date.now();
+    try {
+      const http = getHttp5(program2);
+      const data = await http.splitio("/internal/api/v2/workspaces");
+      success(
+        { count: data.objects.length, workspaces: data.objects },
+        "splitio",
+        "workspaces list",
+        start
+      );
+    } catch (err) {
+      fail(err, "splitio", "workspaces list", start);
+    }
+  });
+  const environments = splitio.command("environments").description("Environment operations");
+  environments.command("list").description("List environments in a workspace").requiredOption("--workspace <id>", "Workspace ID").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const http = getHttp5(program2);
+      const data = await http.splitio(
+        `/internal/api/v2/workspaces/${encodeURIComponent(opts.workspace)}/environments`
+      );
+      success(
+        { count: data.objects.length, environments: data.objects },
+        "splitio",
+        "environments list",
+        start
+      );
+    } catch (err) {
+      fail(err, "splitio", "environments list", start);
+    }
+  });
+  const flags = splitio.command("flags").description("Feature flag operations");
+  flags.command("list").description("List feature flags in a workspace").requiredOption("--workspace <id>", "Workspace ID").option("--limit <n>", "Maximum number of flags to return", "50").option("--offset <n>", "Pagination offset", "0").option("--flag-set <name>", "Filter by flag set name").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const http = getHttp5(program2);
+      const params = {
+        wsId: opts.workspace,
+        limit: parseInt(opts.limit, 10),
+        offset: parseInt(opts.offset, 10)
+      };
+      if (opts.flagSet) params["flagSetName"] = opts.flagSet;
+      const data = await http.splitio("/internal/api/v2/splits", { params });
+      success(
+        { count: data.objects.length, totalCount: data.totalCount, flags: data.objects },
+        "splitio",
+        "flags list",
+        start
+      );
+    } catch (err) {
+      fail(err, "splitio", "flags list", start);
+    }
+  });
+  flags.command("get").description("Get a flag definition").requiredOption("--workspace <id>", "Workspace ID").requiredOption("--flag <name>", "Feature flag name").option("--environment <id>", "Environment ID \u2014 include targeting rules for this environment").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const http = getHttp5(program2);
+      if (opts.environment) {
+        const data = await http.splitio(
+          `/internal/api/v2/splits/${encodeURIComponent(opts.flag)}/environments/${encodeURIComponent(opts.environment)}`,
+          { params: { wsId: opts.workspace } }
+        );
+        success(data, "splitio", "flags get", start);
+      } else {
+        const data = await http.splitio(
+          `/internal/api/v2/splits/${encodeURIComponent(opts.flag)}`,
+          { params: { wsId: opts.workspace } }
+        );
+        success(data, "splitio", "flags get", start);
+      }
+    } catch (err) {
+      fail(err, "splitio", "flags get", start);
+    }
+  });
+  flags.command("update").description("Submit a Change Request to replace a flag's full definition in an environment").requiredOption("--workspace <id>", "Workspace ID").requiredOption("--flag <name>", "Feature flag name").requiredOption("--environment <id>", "Environment ID").requiredOption("--mnemonic <text>", "Short Change Request title (mnemonic)").requiredOption("--description <text>", "Change Request description").requiredOption("--change-number <CHG>", "ServiceNow change request number (e.g. CHG0001234)").option("--approvers <ids>", "Comma-separated Split user IDs required to approve this CR").option("--input-file <path>", "JSON file with the complete flag definition body (use - for stdin)").option("--yes", "Skip interactive confirmation prompt").action(async (opts) => {
+    const start = Date.now();
+    try {
+      if (!opts.inputFile) throw new PncliError("--input-file is required for flags update");
+      const definition = loadInputFile(opts.inputFile);
+      await confirmWrite(opts, `UPDATE ${opts.flag} in ${opts.environment}`);
+      const http = getHttp5(program2);
+      const body = {
+        ...buildCrBase(opts),
+        operationType: "UPDATE_SPLIT_DEFINITION",
+        split: {
+          name: opts.flag,
+          environment: { id: opts.environment },
+          definition
+        },
+        workspace: { id: opts.workspace }
+      };
+      const data = await http.splitio("/internal/api/v2/changeRequests", {
+        method: "POST",
+        body
+      });
+      success(data, "splitio", "flags update", start);
+    } catch (err) {
+      fail(err, "splitio", "flags update", start);
+    }
+  });
+  flags.command("set-rule").description("Change one targeting rule without altering the rest of the flag definition").requiredOption("--workspace <id>", "Workspace ID").requiredOption("--flag <name>", "Feature flag name").requiredOption("--environment <id>", "Environment ID").requiredOption("--rule-index <n>", "Zero-based index of the targeting rule to update").option("--treatment <name>", "Treatment to assign to the entire rule bucket").option("--weights <json>", "JSON array of {treatment, size} objects for weighted distribution").requiredOption("--mnemonic <text>", "Short Change Request title (mnemonic)").requiredOption("--description <text>", "Change Request description").requiredOption("--change-number <CHG>", "ServiceNow change request number (e.g. CHG0001234)").option("--approvers <ids>", "Comma-separated Split user IDs required to approve this CR").option("--yes", "Skip interactive confirmation prompt").action(async (opts) => {
+    const start = Date.now();
+    try {
+      if (!opts.treatment && !opts.weights) {
+        throw new PncliError("Either --treatment or --weights must be specified");
+      }
+      const http = getHttp5(program2);
+      const current = await http.splitio(
+        `/internal/api/v2/splits/${encodeURIComponent(opts.flag)}/environments/${encodeURIComponent(opts.environment)}`,
+        { params: { wsId: opts.workspace } }
+      );
+      const rules = current.rules ?? [];
+      const idx = parseInt(opts.ruleIndex, 10);
+      if (Number.isNaN(idx) || idx < 0 || idx >= rules.length) {
+        throw new PncliError(`Rule index ${Number.isNaN(idx) ? JSON.stringify(opts.ruleIndex) : idx} is out of range (flag has ${rules.length} rules)`);
+      }
+      if (opts.treatment) {
+        rules[idx] = { ...rules[idx], buckets: [{ treatment: opts.treatment, size: 1e5 }] };
+      } else {
+        const parsed = JSON.parse(opts.weights);
+        rules[idx] = { ...rules[idx], buckets: parsed };
+      }
+      await confirmWrite(opts, `SET_RULE ${idx} on ${opts.flag} in ${opts.environment}`);
+      const body = {
+        ...buildCrBase(opts),
+        operationType: "UPDATE_SPLIT_DEFINITION",
+        split: {
+          name: opts.flag,
+          environment: { id: opts.environment },
+          definition: { ...current, rules }
+        },
+        workspace: { id: opts.workspace }
+      };
+      const data = await http.splitio("/internal/api/v2/changeRequests", {
+        method: "POST",
+        body
+      });
+      success(data, "splitio", "flags set-rule", start);
+    } catch (err) {
+      fail(err, "splitio", "flags set-rule", start);
+    }
+  });
+  flags.command("set-default").description("Update the fallback default rule for traffic matching no targeting rule").requiredOption("--workspace <id>", "Workspace ID").requiredOption("--flag <name>", "Feature flag name").requiredOption("--environment <id>", "Environment ID").requiredOption("--treatment <name>", "Treatment to assign as the default").requiredOption("--mnemonic <text>", "Short Change Request title (mnemonic)").requiredOption("--description <text>", "Change Request description").requiredOption("--change-number <CHG>", "ServiceNow change request number (e.g. CHG0001234)").option("--approvers <ids>", "Comma-separated Split user IDs required to approve this CR").option("--yes", "Skip interactive confirmation prompt").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const http = getHttp5(program2);
+      const current = await http.splitio(
+        `/internal/api/v2/splits/${encodeURIComponent(opts.flag)}/environments/${encodeURIComponent(opts.environment)}`,
+        { params: { wsId: opts.workspace } }
+      );
+      await confirmWrite(opts, `SET_DEFAULT ${opts.treatment} on ${opts.flag} in ${opts.environment}`);
+      const body = {
+        ...buildCrBase(opts),
+        operationType: "UPDATE_SPLIT_DEFINITION",
+        split: {
+          name: opts.flag,
+          environment: { id: opts.environment },
+          definition: {
+            ...current,
+            defaultRule: [{ treatment: opts.treatment, size: 1e5 }]
+          }
+        },
+        workspace: { id: opts.workspace }
+      };
+      const data = await http.splitio("/internal/api/v2/changeRequests", {
+        method: "POST",
+        body
+      });
+      success(data, "splitio", "flags set-default", start);
+    } catch (err) {
+      fail(err, "splitio", "flags set-default", start);
+    }
+  });
+  flags.command("toggle").description("Enable or disable a single flag via a Change Request").requiredOption("--workspace <id>", "Workspace ID").requiredOption("--flag <name>", "Feature flag name").requiredOption("--environment <id>", "Environment ID").requiredOption("--enabled <bool>", "true to restore / false to kill the flag").requiredOption("--mnemonic <text>", "Short Change Request title (mnemonic)").requiredOption("--description <text>", "Change Request description").requiredOption("--change-number <CHG>", "ServiceNow change request number (e.g. CHG0001234)").option("--approvers <ids>", "Comma-separated Split user IDs required to approve this CR").option("--yes", "Skip interactive confirmation prompt").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const enable = opts.enabled.toLowerCase() !== "false" && opts.enabled !== "0";
+      const opType = enable ? "RESTORE_SPLIT" : "KILL_SPLIT";
+      await confirmWrite(opts, `${opType} ${opts.flag} in ${opts.environment}`);
+      const http = getHttp5(program2);
+      const body = {
+        ...buildCrBase(opts),
+        operationType: opType,
+        split: { name: opts.flag, environment: { id: opts.environment } },
+        workspace: { id: opts.workspace }
+      };
+      const data = await http.splitio("/internal/api/v2/changeRequests", {
+        method: "POST",
+        body
+      });
+      success(data, "splitio", "flags toggle", start);
+    } catch (err) {
+      fail(err, "splitio", "flags toggle", start);
+    }
+  });
+  flags.command("batch-toggle").description("Enable or disable multiple flags from a JSON file (each creates its own Change Request)").requiredOption("--workspace <id>", "Workspace ID").requiredOption("--environment <id>", "Environment ID").requiredOption("--mnemonic <text>", "Short Change Request title prefix (mnemonic)").requiredOption("--description <text>", "Change Request description").requiredOption("--change-number <CHG>", "ServiceNow change request number (e.g. CHG0001234)").option("--approvers <ids>", "Comma-separated Split user IDs required to approve each CR").option("--input-file <path>", "JSON file: array of {flag, enabled} objects (use - for stdin)").option("--yes", "Skip interactive confirmation prompt").action(async (opts) => {
+    const start = Date.now();
+    try {
+      if (!opts.inputFile) throw new PncliError("--input-file is required for batch-toggle");
+      const entries = loadInputFile(opts.inputFile);
+      if (!Array.isArray(entries)) throw new PncliError("Input file must be a JSON array of {flag, enabled} objects");
+      await confirmWrite(opts, `BATCH_TOGGLE ${entries.length} flags in ${opts.environment}`);
+      const http = getHttp5(program2);
+      const results = [];
+      for (const entry of entries) {
+        try {
+          const opType = entry.enabled ? "RESTORE_SPLIT" : "KILL_SPLIT";
+          const body = {
+            ...buildCrBase(opts),
+            title: `${opts.mnemonic} \u2014 ${entry.flag}`,
+            operationType: opType,
+            split: { name: entry.flag, environment: { id: opts.environment } },
+            workspace: { id: opts.workspace }
+          };
+          const cr = await http.splitio("/internal/api/v2/changeRequests", {
+            method: "POST",
+            body
+          });
+          results.push({ flag: entry.flag, ok: true, id: cr.id });
+        } catch (err) {
+          results.push({
+            flag: entry.flag,
+            ok: false,
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
+      }
+      success({ submitted: results.length, results }, "splitio", "flags batch-toggle", start);
+    } catch (err) {
+      fail(err, "splitio", "flags batch-toggle", start);
+    }
+  });
+  flags.command("kill").description("Submit a Change Request to kill (disable) a flag").requiredOption("--workspace <id>", "Workspace ID").requiredOption("--flag <name>", "Feature flag name").requiredOption("--environment <id>", "Environment ID").requiredOption("--mnemonic <text>", "Short Change Request title (mnemonic)").requiredOption("--description <text>", "Change Request description").requiredOption("--change-number <CHG>", "ServiceNow change request number (e.g. CHG0001234)").option("--approvers <ids>", "Comma-separated Split user IDs required to approve this CR").option("--yes", "Skip interactive confirmation prompt").action(async (opts) => {
+    const start = Date.now();
+    try {
+      await confirmWrite(opts, `KILL ${opts.flag} in ${opts.environment}`);
+      const http = getHttp5(program2);
+      const body = {
+        ...buildCrBase(opts),
+        operationType: "KILL_SPLIT",
+        split: { name: opts.flag, environment: { id: opts.environment } },
+        workspace: { id: opts.workspace }
+      };
+      const data = await http.splitio("/internal/api/v2/changeRequests", {
+        method: "POST",
+        body
+      });
+      success(data, "splitio", "flags kill", start);
+    } catch (err) {
+      fail(err, "splitio", "flags kill", start);
+    }
+  });
+  flags.command("restore").description("Submit a Change Request to restore a killed flag").requiredOption("--workspace <id>", "Workspace ID").requiredOption("--flag <name>", "Feature flag name").requiredOption("--environment <id>", "Environment ID").requiredOption("--mnemonic <text>", "Short Change Request title (mnemonic)").requiredOption("--description <text>", "Change Request description").requiredOption("--change-number <CHG>", "ServiceNow change request number (e.g. CHG0001234)").option("--approvers <ids>", "Comma-separated Split user IDs required to approve this CR").option("--yes", "Skip interactive confirmation prompt").action(async (opts) => {
+    const start = Date.now();
+    try {
+      await confirmWrite(opts, `RESTORE ${opts.flag} in ${opts.environment}`);
+      const http = getHttp5(program2);
+      const body = {
+        ...buildCrBase(opts),
+        operationType: "RESTORE_SPLIT",
+        split: { name: opts.flag, environment: { id: opts.environment } },
+        workspace: { id: opts.workspace }
+      };
+      const data = await http.splitio("/internal/api/v2/changeRequests", {
+        method: "POST",
+        body
+      });
+      success(data, "splitio", "flags restore", start);
+    } catch (err) {
+      fail(err, "splitio", "flags restore", start);
+    }
+  });
+  flags.command("archive").description("Submit a Change Request to archive (delete definition of) a flag").requiredOption("--workspace <id>", "Workspace ID").requiredOption("--flag <name>", "Feature flag name").requiredOption("--mnemonic <text>", "Short Change Request title (mnemonic)").requiredOption("--description <text>", "Change Request description").requiredOption("--change-number <CHG>", "ServiceNow change request number (e.g. CHG0001234)").option("--yes", "Skip interactive confirmation prompt").action(async (opts) => {
+    const start = Date.now();
+    try {
+      await confirmWrite(opts, `ARCHIVE ${opts.flag}`);
+      const http = getHttp5(program2);
+      const body = {
+        ...buildCrBase(opts),
+        operationType: "ARCHIVE_SPLIT",
+        split: { name: opts.flag },
+        workspace: { id: opts.workspace }
+      };
+      const data = await http.splitio("/internal/api/v2/changeRequests", {
+        method: "POST",
+        body
+      });
+      success(data, "splitio", "flags archive", start);
+    } catch (err) {
+      fail(err, "splitio", "flags archive", start);
+    }
+  });
+  const changeRequests = splitio.command("change-requests").description("Change Request tracking");
+  changeRequests.command("list").description("List Change Requests for a workspace").requiredOption("--workspace <id>", "Workspace ID").option("--environment <id>", "Filter by environment ID").option("--status <status>", "Filter by status (REQUESTED, APPROVED, REJECTED, PUBLISHED)").option("--limit <n>", "Maximum number of results", "25").option("--offset <n>", "Pagination offset", "0").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const http = getHttp5(program2);
+      const params = {
+        wsId: opts.workspace,
+        limit: parseInt(opts.limit, 10),
+        offset: parseInt(opts.offset, 10)
+      };
+      if (opts.environment) params["environmentId"] = opts.environment;
+      if (opts.status) params["status"] = opts.status;
+      const data = await http.splitio(
+        "/internal/api/v2/changeRequests",
+        { params }
+      );
+      success(
+        { count: data.objects.length, totalCount: data.totalCount, changeRequests: data.objects },
+        "splitio",
+        "change-requests list",
+        start
+      );
+    } catch (err) {
+      fail(err, "splitio", "change-requests list", start);
+    }
+  });
+  changeRequests.command("get").description("Get a Change Request by ID").requiredOption("--id <id>", "Change Request ID").action(async (opts) => {
+    const start = Date.now();
+    try {
+      const http = getHttp5(program2);
+      const data = await http.splitio(
+        `/internal/api/v2/changeRequests/${encodeURIComponent(opts.id)}`
+      );
+      success(data, "splitio", "change-requests get", start);
+    } catch (err) {
+      fail(err, "splitio", "change-requests get", start);
+    }
+  });
+}
+
+// src/services/figma/commands.ts
+function parseFileKey(input3) {
+  if (input3.startsWith("http://") || input3.startsWith("https://")) {
+    const match = /figma\.com\/(?:design|file)\/([A-Za-z0-9]+)/i.exec(input3);
+    if (!match?.[1]) {
+      throw new Error(`Could not extract Figma file key from URL: ${input3}
+Expected format: https://www.figma.com/design/<file-key>/...`);
+    }
+    return match[1];
+  }
+  return input3;
+}
+function getHttp6(program2) {
+  const opts = program2.optsWithGlobals();
+  return createHttpClient(
+    loadConfig({ configPath: opts.config }),
+    Boolean(opts.dryRun)
+  );
+}
+function registerFigmaCommands(program2) {
+  const figma = program2.command("figma").description("Figma design operations (files, comments, versions)");
+  figma.command("file").description("Get a Figma file \u2014 metadata, structure, and component/style inventory").argument("<file-key-or-url>", "Figma file key or full Figma URL (https://www.figma.com/design/<key>/...)").option("--document", "Include the full document node tree (can be large; omitted by default)").action(async (fileKeyOrUrl, opts) => {
+    const start = Date.now();
+    const { success: success2, fail: fail2 } = await import("./output-XT3WT5L5.js");
+    try {
+      const fileKey = parseFileKey(fileKeyOrUrl);
+      const params = {};
+      if (!opts.document) {
+        params["geometry"] = "paths";
+        params["depth"] = 0;
+      }
+      const data = await getHttp6(program2).figma(`/v1/files/${encodeURIComponent(fileKey)}`, { params });
+      success2(
+        {
+          fileKey,
+          name: data.name,
+          lastModified: data.lastModified,
+          version: data.version,
+          thumbnailUrl: data.thumbnailUrl,
+          role: data.role,
+          editorType: data.editorType,
+          schemaVersion: data.schemaVersion,
+          ...opts.document ? { document: data.document } : {},
+          componentCount: data.components ? Object.keys(data.components).length : 0,
+          styleCount: data.styles ? Object.keys(data.styles).length : 0
+        },
+        "figma",
+        "file",
+        start
+      );
+    } catch (err) {
+      fail2(err, "figma", "file", start);
+    }
+  });
+  figma.command("comments").description("Get comments on a Figma file").argument("<file-key-or-url>", "Figma file key or full Figma URL").option("--as-of <date>", "ISO 8601 timestamp \u2014 return only comments created before this time").action(async (fileKeyOrUrl, opts) => {
+    const start = Date.now();
+    const { success: success2, fail: fail2 } = await import("./output-XT3WT5L5.js");
+    try {
+      const fileKey = parseFileKey(fileKeyOrUrl);
+      const params = {};
+      if (opts.asOf) params["as_of"] = opts.asOf;
+      const data = await getHttp6(program2).figma(`/v1/files/${encodeURIComponent(fileKey)}/comments`, { params });
+      success2(
+        { fileKey, count: data.comments.length, comments: data.comments },
+        "figma",
+        "comments",
+        start
+      );
+    } catch (err) {
+      fail2(err, "figma", "comments", start);
+    }
+  });
+  figma.command("versions").description("Get the version history of a Figma file").argument("<file-key-or-url>", "Figma file key or full Figma URL").action(async (fileKeyOrUrl) => {
+    const start = Date.now();
+    const { success: success2, fail: fail2 } = await import("./output-XT3WT5L5.js");
+    try {
+      const fileKey = parseFileKey(fileKeyOrUrl);
+      const data = await getHttp6(program2).figma(`/v1/files/${encodeURIComponent(fileKey)}/versions`);
+      success2(
+        { fileKey, count: data.versions.length, versions: data.versions },
+        "figma",
+        "versions",
+        start
+      );
+    } catch (err) {
+      fail2(err, "figma", "versions", start);
+    }
+  });
+  figma.command("project-files").description("List files in a Figma project").argument("<project-id>", "Figma project ID (visible in the project URL)").action(async (projectId) => {
+    const start = Date.now();
+    const { success: success2, fail: fail2 } = await import("./output-XT3WT5L5.js");
+    try {
+      const data = await getHttp6(program2).figma(`/v1/projects/${encodeURIComponent(projectId)}/files`);
+      success2(
+        { projectId, count: data.files.length, files: data.files },
+        "figma",
+        "project-files",
+        start
+      );
+    } catch (err) {
+      fail2(err, "figma", "project-files", start);
+    }
+  });
+  figma.command("me").description("Get the current Figma user (useful for verifying credentials)").action(async () => {
+    const start = Date.now();
+    const { success: success2, fail: fail2 } = await import("./output-XT3WT5L5.js");
+    try {
+      const data = await getHttp6(program2).figma("/v1/me");
+      success2(data, "figma", "me", start);
+    } catch (err) {
+      fail2(err, "figma", "me", start);
+    }
+  });
+}
+
 // src/cli.ts
 if (!process.env.PNCLI_VERIFY_TLS) {
   process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
@@ -10973,7 +11848,6 @@ registerConfigCommands(program);
 registerAdoCommands(program);
 registerJenkinsCommands(program);
 registerArtifactoryCommands(program);
-registerUdeployCommands(program);
 registerCheckmarxCommands(program);
 registerServiceNowCommands(program);
 registerContrastCommands(program);
@@ -10983,6 +11857,8 @@ registerJwtCommands(program);
 registerOpenShiftCommands(program);
 registerDynatraceCommands(program);
 registerLogscaleCommands(program);
+registerSplitioCommands(program);
+registerFigmaCommands(program);
 program.addHelpText("after", `
 Services:
   git          Local git operations (status, diff, log, branch)
@@ -10994,9 +11870,8 @@ Services:
   sonar        SonarQube Server (quality gates, issues, metrics, hotspots)
   sde          SDElements (threat modeling, countermeasures, compliance)
   ado          Azure DevOps Server (work items, repos, PRs, pipelines)
-  jenkins      Jenkins Data Center (jobs, builds, logs)
+  jenkins      Jenkins (jobs, builds, logs, named instances)
   artifactory  Artifactory (repos, artifact search, build info, properties)
-  udeploy      IBM UrbanCode Deploy (component versions, deployment processes)
   checkmarx    Checkmarx One (projects, scans, scan statistics)
   servicenow   ServiceNow (change requests)
   contrast     Contrast IAST (applications, vulnerability findings)
@@ -11004,6 +11879,8 @@ Services:
   openshift    OpenShift / Kubernetes (pods, events, logs, metrics)
   dynatrace    Dynatrace (services, entities, problems, traces, Kubernetes workloads)
   logscale     LogScale (log query, repositories)
+  splitio      Split.IO (feature flags, Change Requests)
+  figma        Figma (files, comments, version history)
   config       Manage pncli configuration
   skills       Download and manage Claude Code skills
   jwt          JWT token utilities (decode header and payload)