azdo-cli 0.3.0 → 0.5.0-010-work-item-comments.149

package/README.md

@@ -12,10 +12,13 @@ Azure DevOps CLI focused on work item read/write workflows.
 - Update work item state (`set-state`)
 - Assign and unassign work items (`assign`)
 - Set any work item field by reference name (`set-field`)
-- Create or update Tasks from markdown documents (`upsert`)
+- Create or update work items from markdown documents (`upsert`)
+- Read and post work item comments (`comments`)
 - Read rich-text fields as markdown (`get-md-field`)
 - Set rich-text fields as markdown from inline text, file, or stdin (`set-md-field`)
+- Check branch pull request status, open PRs to `develop`, and review active comments (`pr`)
 - Persist org/project/default fields in local config (`config`)
+- List all fields of a work item (`list-fields`)
 - Store PAT in OS credential store (or use `AZDO_PAT`)
 
 ## Installation
@@ -24,6 +27,20 @@ Azure DevOps CLI focused on work item read/write workflows.
 npm install -g azdo-cli
 ```
 
+## Utility Scripts
+
+The repository also includes a helper script for syncing local `.env` entries into GitHub Actions secrets for the current repository:
+
+```bash
+./scripts/sync-env-to-gh-secrets.zsh
+```
+
+It walks upward from the current directory until it finds a `.env`, then sets each valid `KEY=VALUE` entry with `gh secret set`. You can also limit the sync to selected keys:
+
+```bash
+./scripts/sync-env-to-gh-secrets.zsh FOO BAR
+```
+
 ## Authentication and Context Resolution
 
 PAT resolution order:
@@ -49,8 +66,12 @@ azdo get-item 12345
 # 3) Update state
 azdo set-state 12345 "Active"
 
-# 4) Create or update a Task from markdown
-azdo upsert --content $'---\nTitle: Improve markdown import UX\nState: New\n---'
+# 4) Create or update a work item from markdown
+azdo upsert --type "User Story" --content $'---\nTitle: Improve markdown import UX\nState: New\n---'
+
+# 5) Review work item discussion and post an update
+azdo comments list 12345
+azdo comments add 12345 "Investigating the root cause now."
 ```
 
 ## Command Cheat Sheet
@@ -61,9 +82,12 @@ azdo upsert --content $'---\nTitle: Improve markdown import UX\nState: New\n---'
 | `azdo set-state <id> <state>` | Change work item state | `--json`, `--org`, `--project` |
 | `azdo assign <id> [name]` | Assign or unassign owner | `--unassign`, `--json`, `--org`, `--project` |
 | `azdo set-field <id> <field> <value>` | Update any field | `--json`, `--org`, `--project` |
-| `azdo upsert [id]` | Create or update a Task from markdown | `--content`, `--file`, `--json`, `--org`, `--project` |
+| `azdo upsert [id]` | Create or update a work item from markdown | `--content`, `--file`, `--type`, `--json`, `--org`, `--project` |
+| `azdo comments <subcommand>` | Read or add work item comments | `list`, `add`, `--json`, `--org`, `--project` |
 | `azdo get-md-field <id> <field>` | Get field as markdown | `--org`, `--project` |
 | `azdo set-md-field <id> <field> [content]` | Set markdown field | `--file`, `--json`, `--org`, `--project` |
+| `azdo list-fields <id>` | List all fields of a work item | `--json`, `--org`, `--project` |
+| `azdo pr <subcommand>` | Manage pull requests for the current branch | `status`, `open`, `comments`, `--json`, `--org`, `--project` |
 | `azdo config <subcommand>` | Manage saved settings | `set`, `get`, `list`, `unset`, `wizard`, `--json` |
 | `azdo clear-pat` | Remove stored PAT | none |
 
@@ -84,8 +108,6 @@ azdo get-item 12345 --fields "System.Tags,Microsoft.VSTS.Common.Priority"
 # Convert rich text fields to markdown
 azdo get-item 12345 --markdown
 
-# Disable markdown even if config is on
-azdo get-item 12345 --no-markdown
 ```
 
 ```bash
@@ -100,11 +122,21 @@ azdo assign 12345 --unassign
 azdo set-field 12345 System.Title "Updated title"
 ```
 
+### List Fields
+
+```bash
+# List all fields with values (rich text fields preview first 5 lines)
+azdo list-fields 12345
+
+# JSON output
+azdo list-fields 12345 --json
+```
+
 ### Markdown Display
 
 The `get-item` command can convert HTML rich-text fields to readable markdown. Resolution order:
 
-1. `--markdown` / `--no-markdown` flag (highest priority)
+1. `--markdown` flag enables markdown for the current call
 2. Config setting: `azdo config set markdown true`
 3. Default: off (HTML stripped to plain text)
 
@@ -124,13 +156,85 @@ azdo set-md-field 12345 System.Description --file ./description.md
 cat description.md | azdo set-md-field 12345 System.Description
 ```
 
+### Pull Request Commands
+
+The `pr` command group uses the current git branch and the Azure DevOps `origin` remote automatically. It requires a PAT with `Code (Read)` scope for read operations and `Code (Read & Write)` for pull request creation.
+
+```bash
+# Check whether the current branch already has pull requests
+azdo pr status
+
+# Open a pull request to develop
+azdo pr open --title "Add PR handling" --description "Implements pr status, pr open, pr comments commands"
+
+# Review active comments for the current branch's active pull request
+azdo pr comments
+```
+
+`azdo pr status`
+
+- Lists pull requests for the current branch
+- Prints `No pull requests found for branch <branch>.` when no PRs exist
+- Supports `--json` for machine-readable output
+
+`azdo pr open`
+
+- Requires both `--title <title>` and `--description <description>`
+- Targets `develop` automatically
+- Creates a new active pull request when none exists
+- Reuses the existing active PR when one already matches the branch and target
+- Fails with a clear error when run from `develop` or when multiple active PRs already exist
+
+`azdo pr comments`
+
+- Resolves the single active pull request for the current branch
+- Returns only active or pending threads with visible, non-deleted comments
+- Groups text output by thread and shows file context when available
+- Prints `Pull request #<id> has no active comments.` when the PR has no active comment threads
+- Fails instead of guessing when no active PR or multiple active PRs exist
+
+### Work Item Comment Commands
+
+The `comments` command group works on a specific work item ID. It requires a PAT with `Work Items (read)` scope for listing comments and `Work Items (Read & Write)` to add a new comment.
+
+```bash
+# Read the visible comment history for a work item
+azdo comments list 12345
+
+# Read the same history as JSON
+azdo comments list 12345 --json
+
+# Post a progress update
+azdo comments add 12345 "Investigation complete. Working on the fix next."
+
+# Post the update and return JSON
+azdo comments add 12345 "Queued validation run." --json
+```
+
+`azdo comments list`
+
+- Resolves the target work item directly from the provided ID
+- Retrieves the full visible comment history and follows Azure DevOps pagination internally
+- Prints comments newest first with comment ID, author, timestamp, and body text
+- Prints `Work item #<id> has no comments.` when the work item has no visible comments
+
+`azdo comments add`
+
+- Requires a non-empty `<text>` positional argument
+- Preserves the supplied comment text as the submitted body
+- Prints `Added comment #<commentId> to work item #<id>` on success
+- Fails locally before any API call when the text is empty or whitespace-only
+
 ## azdo upsert
 
-`azdo upsert` accepts a single markdown task document and either creates a new Azure DevOps Task or updates an existing one. Omit `[id]` to create; pass `[id]` to update that work item in place.
+`azdo upsert` accepts a single markdown work-item document and either creates a new Azure DevOps work item or updates an existing one. Omit `[id]` to create; pass `[id]` to update that work item in place. Create mode defaults to `Task`, and `--type <work item type>` lets you create `Bug`, `User Story`, `Feature`, `Epic`, and other Azure DevOps work item types.
 
 ```bash
-# Create from inline content
-azdo upsert --content $'---\nTitle: Improve markdown import UX\nAssigned To: user@example.com\nState: New\n---'
+# Create a Bug from inline content
+azdo upsert --type Bug --content $'---\nTitle: Improve markdown import UX\nAssigned To: user@example.com\nState: New\n---'
+
+# Preserve the default Task create behavior
+azdo upsert --content $'---\nTitle: Follow-up task\nAssigned To: user@example.com\nState: New\n---'
 
 # Update from a file
 azdo upsert 12345 --file ./task-import.md
@@ -143,9 +247,16 @@ The command requires exactly one source flag:
 
 - `azdo upsert [id] --content <markdown>`
 - `azdo upsert [id] --file <path>`
+- `azdo upsert --type <work-item-type> --content <markdown>`
 
 If `--file` succeeds, the source file is deleted after the Azure DevOps write completes. If parsing, validation, or the API call fails, the file is preserved. If deletion fails after a successful write, the command still succeeds and prints a warning.
 
+Type rules:
+
+- `--type` is optional for create and defaults to `Task`.
+- `--type` is only valid when creating a new work item.
+- Human-readable and JSON success output include the resulting work item type.
+
 ### Task Document Format
 
 The document starts with YAML front matter for scalar fields, followed by optional `##` heading sections for markdown rich-text fields.
@@ -194,6 +305,7 @@ Clear semantics:
 {
   "action": "created",
   "id": 12345,
+  "workItemType": "User Story",
   "fields": {
     "System.Title": "Improve markdown import UX",
     "System.Description": "Implement a single-command task import flow."
@@ -232,10 +344,14 @@ azdo clear-pat
 ## JSON Output
 
 These commands support `--json` for machine-readable output:
+- `list-fields`
 - `set-state`
 - `assign`
 - `set-field`
 - `set-md-field`
+- `upsert`
+- `comments list|add`
+- `pr status|open|comments`
 - `config set|get|list|unset`
 
 ## Development

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command10 } from "commander";
+import { Command as Command13 } from "commander";
 
 // src/version.ts
 import { readFileSync } from "fs";
@@ -39,7 +39,15 @@ async function fetchWithErrors(url, init) {
   }
   if (response.status === 401) throw new Error("AUTH_FAILED");
   if (response.status === 403) throw new Error("PERMISSION_DENIED");
-  if (response.status === 404) throw new Error("NOT_FOUND");
+  if (response.status === 404) {
+    let detail = "";
+    try {
+      const body = await response.text();
+      detail = ` | url=${url} | body=${body}`;
+    } catch {
+    }
+    throw new Error(`NOT_FOUND${detail}`);
+  }
   return response;
 }
 async function readResponseMessage(response) {
@@ -55,12 +63,29 @@ async function readResponseMessage(response) {
 function normalizeFieldList(fields) {
   return Array.from(new Set(fields.map((f) => f.trim()).filter((f) => f.length > 0)));
 }
+function stringifyFieldValue(value) {
+  if (typeof value === "object" && value !== null) {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
 function buildExtraFields(fields, requested) {
   const result = {};
   for (const name of requested) {
-    const val = fields[name];
+    let val = fields[name];
+    let resolvedName = name;
+    if (val === void 0) {
+      const nameSuffix = name.split(".").pop().toLowerCase();
+      const match = Object.keys(fields).find(
+        (k) => k.split(".").pop().toLowerCase() === nameSuffix
+      );
+      if (match !== void 0) {
+        val = fields[match];
+        resolvedName = match;
+      }
+    }
     if (val !== void 0 && val !== null) {
-      result[name] = String(val);
+      result[resolvedName] = stringifyFieldValue(val);
     }
   }
   return Object.keys(result).length > 0 ? result : null;
@@ -71,6 +96,42 @@ function writeHeaders(pat) {
     "Content-Type": "application/json-patch+json"
   };
 }
+function buildWorkItemCommentsListUrl(context, id, continuationToken) {
+  const url = new URL(
+    `https://dev.azure.com/${encodeURIComponent(context.org)}/${encodeURIComponent(context.project)}/_apis/wit/workItems/${id}/comments`
+  );
+  url.searchParams.set("api-version", "7.1-preview.4");
+  url.searchParams.set("order", "desc");
+  if (continuationToken) {
+    url.searchParams.set("continuationToken", continuationToken);
+  }
+  return url;
+}
+function buildWorkItemCommentsUrl(context, id) {
+  const url = new URL(
+    `https://dev.azure.com/${encodeURIComponent(context.org)}/${encodeURIComponent(context.project)}/_apis/wit/workItems/${id}/comments`
+  );
+  url.searchParams.set("api-version", "7.1-preview.4");
+  return url;
+}
+function mapWorkItemComment(comment, fallbackWorkItemId) {
+  return {
+    id: comment.id ?? comment.commentId ?? 0,
+    workItemId: comment.workItemId ?? fallbackWorkItemId,
+    text: typeof comment.text === "string" ? comment.text : "",
+    author: comment.createdBy?.displayName ?? null,
+    createdAt: comment.createdDate ?? null,
+    modifiedAt: comment.modifiedDate ?? null,
+    isDeleted: comment.isDeleted === true
+  };
+}
+function readContinuationToken(response, data) {
+  if (typeof data.continuationToken === "string" && data.continuationToken.trim() !== "") {
+    return data.continuationToken;
+  }
+  const headerToken = response.headers?.get("x-ms-continuationtoken") ?? response.headers?.get("continuationtoken") ?? null;
+  return headerToken && headerToken.trim() !== "" ? headerToken : null;
+}
 async function readWriteResponse(response, errorCode) {
   if (response.status === 400) {
     const serverMessage = await readResponseMessage(response) ?? "Unknown error";
@@ -86,6 +147,25 @@ async function readWriteResponse(response, errorCode) {
     fields: data.fields
   };
 }
+async function getWorkItemFields(context, id, pat) {
+  const url = new URL(
+    `https://dev.azure.com/${encodeURIComponent(context.org)}/${encodeURIComponent(context.project)}/_apis/wit/workitems/${id}`
+  );
+  url.searchParams.set("api-version", "7.1");
+  url.searchParams.set("$expand", "all");
+  const response = await fetchWithErrors(url.toString(), { headers: authHeaders(pat) });
+  if (response.status === 400) {
+    const serverMessage = await readResponseMessage(response);
+    if (serverMessage) {
+      throw new Error(`BAD_REQUEST: ${serverMessage}`);
+    }
+  }
+  if (!response.ok) {
+    throw new Error(`HTTP_${response.status}`);
+  }
+  const data = await response.json();
+  return data.fields;
+}
 async function getWorkItem(context, id, pat, extraFields) {
   const url = new URL(
     `https://dev.azure.com/${encodeURIComponent(context.org)}/${encodeURIComponent(context.project)}/_apis/wit/workitems/${id}`
@@ -119,7 +199,7 @@ async function getWorkItem(context, id, pat, extraFields) {
   }
   let combinedDescription = null;
   if (descriptionParts.length === 1) {
-    combinedDescription = descriptionParts[0].value;
+    combinedDescription = descriptionParts.at(0)?.value ?? null;
   } else if (descriptionParts.length > 1) {
     combinedDescription = descriptionParts.map((p) => `<h3>${p.label}</h3>${p.value}`).join("");
   }
@@ -158,13 +238,62 @@ async function getWorkItemFieldValue(context, id, pat, fieldName) {
   if (value === void 0 || value === null || value === "") {
     return null;
   }
-  return typeof value === "object" ? JSON.stringify(value) : `${value}`;
+  return stringifyFieldValue(value);
+}
+async function listWorkItemComments(context, id, pat) {
+  const comments = [];
+  let continuationToken = null;
+  do {
+    const response = await fetchWithErrors(
+      buildWorkItemCommentsListUrl(context, id, continuationToken ?? void 0).toString(),
+      { headers: authHeaders(pat) }
+    );
+    if (!response.ok) {
+      throw new Error(`HTTP_${response.status}`);
+    }
+    const data = await response.json();
+    comments.push(
+      ...(data.comments ?? []).map((comment) => mapWorkItemComment(comment, id)).filter((comment) => !comment.isDeleted)
+    );
+    continuationToken = readContinuationToken(response, data);
+  } while (continuationToken !== null);
+  return {
+    workItemId: id,
+    count: comments.length,
+    comments
+  };
+}
+async function addWorkItemComment(context, id, pat, text) {
+  const response = await fetchWithErrors(buildWorkItemCommentsUrl(context, id).toString(), {
+    method: "POST",
+    headers: {
+      ...authHeaders(pat),
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ text })
+  });
+  if (response.status === 400) {
+    const serverMessage = await readResponseMessage(response) ?? "Unknown error";
+    throw new Error(`BAD_REQUEST: ${serverMessage}`);
+  }
+  if (!response.ok) {
+    throw new Error(`HTTP_${response.status}`);
+  }
+  const data = await response.json();
+  return {
+    workItemId: data.workItemId ?? id,
+    commentId: data.commentId ?? data.id ?? 0,
+    text: typeof data.text === "string" ? data.text : text,
+    author: data.createdBy?.displayName ?? null,
+    createdAt: data.createdDate ?? null,
+    url: data.url ?? null
+  };
 }
 async function updateWorkItem(context, id, pat, fieldName, operations) {
   const result = await applyWorkItemPatch(context, id, pat, operations);
   const title = result.fields["System.Title"];
-  const lastOp = operations[operations.length - 1];
-  const fieldValue = lastOp.value ?? null;
+  const lastOp = operations.at(-1);
+  const fieldValue = lastOp?.value ?? null;
   return {
     id: result.id,
     rev: result.rev,
@@ -301,19 +430,19 @@ async function resolvePat() {
 import { execSync } from "child_process";
 var patterns = [
   // HTTPS (current): https://dev.azure.com/{org}/{project}/_git/{repo}
-  /^https?:\/\/dev\.azure\.com\/([^/]+)\/([^/]+)\/_git\/.+$/,
+  /^https?:\/\/dev\.azure\.com\/([^/]+)\/([^/]+)\/_git\/([^/]+)$/,
   // HTTPS (legacy + DefaultCollection): https://{org}.visualstudio.com/DefaultCollection/{project}/_git/{repo}
-  /^https?:\/\/([^.]+)\.visualstudio\.com\/DefaultCollection\/([^/]+)\/_git\/.+$/,
+  /^https?:\/\/([^.]+)\.visualstudio\.com\/DefaultCollection\/([^/]+)\/_git\/([^/]+)$/,
   // HTTPS (legacy): https://{org}.visualstudio.com/{project}/_git/{repo}
-  /^https?:\/\/([^.]+)\.visualstudio\.com\/([^/]+)\/_git\/.+$/,
+  /^https?:\/\/([^.]+)\.visualstudio\.com\/([^/]+)\/_git\/([^/]+)$/,
   // SSH (current): git@ssh.dev.azure.com:v3/{org}/{project}/{repo}
-  /^git@ssh\.dev\.azure\.com:v3\/([^/]+)\/([^/]+)\/.+$/,
+  /^git@ssh\.dev\.azure\.com:v3\/([^/]+)\/([^/]+)\/([^/]+)$/,
   // SSH (legacy): {org}@vs-ssh.visualstudio.com:v3/{org}/{project}/{repo}
-  /^[^@]+@vs-ssh\.visualstudio\.com:v3\/([^/]+)\/([^/]+)\/.+$/
+  /^[^@]+@vs-ssh\.visualstudio\.com:v3\/([^/]+)\/([^/]+)\/([^/]+)$/
 ];
 function parseAzdoRemote(url) {
   for (const pattern of patterns) {
-    const match = url.match(pattern);
+    const match = pattern.exec(url);
     if (match) {
       const project = match[2];
       if (/^DefaultCollection$/i.test(project)) {
@@ -337,6 +466,35 @@ function detectAzdoContext() {
   }
   return context;
 }
+function parseRepoName(url) {
+  for (const pattern of patterns) {
+    const match = pattern.exec(url);
+    if (match) {
+      return match[3];
+    }
+  }
+  return null;
+}
+function detectRepoName() {
+  let remoteUrl;
+  try {
+    remoteUrl = execSync("git remote get-url origin", { encoding: "utf-8" }).trim();
+  } catch {
+    throw new Error('Not in a git repository. Check that git remote "origin" exists and try again.');
+  }
+  const repo = parseRepoName(remoteUrl);
+  if (!repo) {
+    throw new Error('Git remote "origin" is not an Azure DevOps URL. Check that origin points to Azure DevOps and try again.');
+  }
+  return repo;
+}
+function getCurrentBranch() {
+  const branch = execSync("git rev-parse --abbrev-ref HEAD", { encoding: "utf-8" }).trim();
+  if (branch === "HEAD") {
+    throw new Error("Not on a named branch. Check out a named branch and try again.");
+  }
+  return branch;
+}
 
 // src/services/config-store.ts
 import fs from "fs";
@@ -568,7 +726,7 @@ function handleCommandError(err, id, context, scope = "write", exit = true) {
       `Error: Access denied. Your PAT may lack ${scope} permissions for project "${context?.project}".
 `
     );
-  } else if (msg === "NOT_FOUND") {
+  } else if (msg.startsWith("NOT_FOUND")) {
     process.stderr.write(
       `Error: Work item ${id} not found in ${context?.org}/${context?.project}.
 `
@@ -609,18 +767,18 @@ function parseRequestedFields(raw) {
 }
 function stripHtml(html) {
   let text = html;
-  text = text.replace(/<h[1-6][^>]*>(.*?)<\/h[1-6]>/gi, "\n--- $1 ---\n");
-  text = text.replace(/<br\s*\/?>/gi, "\n");
-  text = text.replace(/<\/?(p|div)>/gi, "\n");
-  text = text.replace(/<li>/gi, "\n");
-  text = text.replace(/<[^>]*>/g, "");
-  text = text.replace(/&amp;/g, "&");
-  text = text.replace(/&lt;/g, "<");
-  text = text.replace(/&gt;/g, ">");
-  text = text.replace(/&quot;/g, '"');
-  text = text.replace(/&#39;/g, "'");
-  text = text.replace(/&nbsp;/g, " ");
-  text = text.replace(/\n{3,}/g, "\n\n");
+  text = text.replaceAll(/<h[1-6][^>]*>(.*?)<\/h[1-6]>/gi, "\n--- $1 ---\n");
+  text = text.replaceAll(/<br\s*\/?>/gi, "\n");
+  text = text.replaceAll(/<\/?(p|div)>/gi, "\n");
+  text = text.replaceAll(/<li>/gi, "\n");
+  text = text.replaceAll(/<[^>]*>/g, "");
+  text = text.replaceAll("&amp;", "&");
+  text = text.replaceAll("&lt;", "<");
+  text = text.replaceAll("&gt;", ">");
+  text = text.replaceAll("&quot;", '"');
+  text = text.replaceAll("&#39;", "'");
+  text = text.replaceAll("&nbsp;", " ");
+  text = text.replaceAll(/\n{3,}/g, "\n\n");
   return text.trim();
 }
 function convertRichText(html, markdown) {
@@ -641,16 +799,19 @@ function summarizeDescription(text, label) {
   return [`${label("Description:")}${firstThree.join("\n")}${suffix}`];
 }
 function formatWorkItem(workItem, short, markdown = false) {
-  const lines = [];
   const label = (name) => name.padEnd(13);
-  lines.push(`${label("ID:")}${workItem.id}`);
-  lines.push(`${label("Type:")}${workItem.type}`);
-  lines.push(`${label("Title:")}${workItem.title}`);
-  lines.push(`${label("State:")}${workItem.state}`);
-  lines.push(`${label("Assigned To:")}${workItem.assignedTo ?? "Unassigned"}`);
+  const lines = [
+    `${label("ID:")}${workItem.id}`,
+    `${label("Type:")}${workItem.type}`,
+    `${label("Title:")}${workItem.title}`,
+    `${label("State:")}${workItem.state}`,
+    `${label("Assigned To:")}${workItem.assignedTo ?? "Unassigned"}`
+  ];
   if (!short) {
-    lines.push(`${label("Area:")}${workItem.areaPath}`);
-    lines.push(`${label("Iteration:")}${workItem.iterationPath}`);
+    lines.push(
+      `${label("Area:")}${workItem.areaPath}`,
+      `${label("Iteration:")}${workItem.iterationPath}`
+    );
   }
   lines.push(`${label("URL:")}${workItem.url}`);
   if (workItem.extraFields) {
@@ -661,8 +822,7 @@ function formatWorkItem(workItem, short, markdown = false) {
   if (short) {
     lines.push(...summarizeDescription(descriptionText, label));
   } else {
-    lines.push("Description:");
-    lines.push(descriptionText);
+    lines.push("Description:", descriptionText);
   }
   return lines.join("\n");
 }
@@ -676,7 +836,7 @@ function createGetItemCommand() {
       try {
         context = resolveContext(options);
         const credential = await resolvePat();
-        const fieldsList = options.fields !== void 0 ? parseRequestedFields(options.fields) : parseRequestedFields(loadConfig().fields);
+        const fieldsList = options.fields === void 0 ? parseRequestedFields(loadConfig().fields) : parseRequestedFields(options.fields);
         const workItem = await getWorkItem(context, id, credential.pat, fieldsList);
         const markdownEnabled = options.markdown ?? loadConfig().markdown ?? false;
         const output = formatWorkItem(workItem, options.short ?? false, markdownEnabled);
@@ -707,6 +867,63 @@ function createClearPatCommand() {
 // src/commands/config.ts
 import { Command as Command3 } from "commander";
 import { createInterface as createInterface2 } from "readline";
+function formatConfigValue(value, unsetFallback = "") {
+  if (value === void 0) {
+    return unsetFallback;
+  }
+  return Array.isArray(value) ? value.join(",") : value;
+}
+function writeConfigList(cfg) {
+  const keyWidth = 10;
+  const valueWidth = 30;
+  for (const setting of SETTINGS) {
+    const raw = cfg[setting.key];
+    const value = formatConfigValue(raw, "(not set)");
+    const marker = raw === void 0 && setting.required ? " *" : "";
+    process.stdout.write(
+      `${setting.key.padEnd(keyWidth)}${String(value).padEnd(valueWidth)}${setting.description}${marker}
+`
+    );
+  }
+  const hasUnset = SETTINGS.some((s) => s.required && cfg[s.key] === void 0);
+  if (hasUnset) {
+    process.stdout.write(
+      '\n* = required but not configured. Run "azdo config wizard" to set up.\n'
+    );
+  }
+}
+function createAsk(rl) {
+  return (prompt) => new Promise((resolve2) => rl.question(prompt, resolve2));
+}
+async function promptForSetting(cfg, setting, ask) {
+  const currentDisplay = String(formatConfigValue(cfg[setting.key], ""));
+  const requiredTag = setting.required ? " (required)" : " (optional)";
+  process.stderr.write(`${setting.description}${requiredTag}
+`);
+  if (setting.example) {
+    process.stderr.write(`  Example: ${setting.example}
+`);
+  }
+  const defaultHint = currentDisplay ? ` [${currentDisplay}]` : "";
+  const answer = await ask(`  ${setting.key}${defaultHint}: `);
+  const trimmed = answer.trim();
+  if (trimmed) {
+    setConfigValue(setting.key, trimmed);
+    process.stderr.write(`  -> Set "${setting.key}" to "${trimmed}"
+
+`);
+    return;
+  }
+  if (currentDisplay) {
+    process.stderr.write(`  -> Kept "${setting.key}" as "${currentDisplay}"
+
+`);
+    return;
+  }
+  process.stderr.write(`  -> Skipped "${setting.key}"
+
+`);
+}
 function createConfigCommand() {
   const config = new Command3("config");
   config.description("Manage CLI settings");
@@ -759,27 +976,9 @@ function createConfigCommand() {
     const cfg = loadConfig();
     if (options.json) {
       process.stdout.write(JSON.stringify(cfg) + "\n");
-    } else {
-      const keyWidth = 10;
-      const valueWidth = 30;
-      for (const setting of SETTINGS) {
-        const raw = cfg[setting.key];
-        const value = raw === void 0 ? "(not set)" : Array.isArray(raw) ? raw.join(",") : raw;
-        const marker = raw === void 0 && setting.required ? " *" : "";
-        process.stdout.write(
-          `${setting.key.padEnd(keyWidth)}${String(value).padEnd(valueWidth)}${setting.description}${marker}
-`
-        );
-      }
-      const hasUnset = SETTINGS.some(
-        (s) => s.required && cfg[s.key] === void 0
-      );
-      if (hasUnset) {
-        process.stdout.write(
-          '\n* = required but not configured. Run "azdo config wizard" to set up.\n'
-        );
-      }
+      return;
     }
+    writeConfigList(cfg);
   });
   const unset = new Command3("unset");
   unset.description("Remove a configuration value").argument("<key>", "setting key (org, project, fields)").option("--json", "output in JSON format").action((key, options) => {
@@ -811,36 +1010,11 @@ function createConfigCommand() {
       input: process.stdin,
       output: process.stderr
     });
-    const ask = (prompt) => new Promise((resolve2) => rl.question(prompt, resolve2));
+    const ask = createAsk(rl);
     process.stderr.write("Azure DevOps CLI - Configuration Wizard\n");
     process.stderr.write("=======================================\n\n");
     for (const setting of SETTINGS) {
-      const current = cfg[setting.key];
-      const currentDisplay = current === void 0 ? "" : Array.isArray(current) ? current.join(",") : current;
-      const requiredTag = setting.required ? " (required)" : " (optional)";
-      process.stderr.write(`${setting.description}${requiredTag}
-`);
-      if (setting.example) {
-        process.stderr.write(`  Example: ${setting.example}
-`);
-      }
-      const defaultHint = currentDisplay ? ` [${currentDisplay}]` : "";
-      const answer = await ask(`  ${setting.key}${defaultHint}: `);
-      const trimmed = answer.trim();
-      if (trimmed) {
-        setConfigValue(setting.key, trimmed);
-        process.stderr.write(`  -> Set "${setting.key}" to "${trimmed}"
-
-`);
-      } else if (currentDisplay) {
-        process.stderr.write(`  -> Kept "${setting.key}" as "${currentDisplay}"
-
-`);
-      } else {
-        process.stderr.write(`  -> Skipped "${setting.key}"
-
-`);
-      }
+      await promptForSetting(cfg, setting, ask);
     }
     rl.close();
     process.stderr.write("Configuration complete!\n");
@@ -1302,7 +1476,7 @@ function buildAppliedFields(fields) {
 function ensureTitleForCreate(fields) {
   const titleField = fields.find((field) => field.refName === "System.Title");
   if (!titleField || titleField.op === "clear" || titleField.value === null || titleField.value.trim() === "") {
-    fail2("Title is required when creating a task.");
+    fail2("Title is required when creating a work item.");
   }
 }
 function writeSuccess(result, options) {
@@ -1314,7 +1488,7 @@ function writeSuccess(result, options) {
   const verb = result.action === "created" ? "Created" : "Updated";
   const fields = Object.keys(result.fields).join(", ");
   const suffix = fields ? ` (${fields})` : "";
-  process.stdout.write(`${verb} task #${result.id}${suffix}
+  process.stdout.write(`${verb} ${result.workItemType} #${result.id}${suffix}
 `);
 }
 function cleanupSourceFile(sourceFile) {
@@ -1328,16 +1502,31 @@ function cleanupSourceFile(sourceFile) {
 `);
   }
 }
-function buildUpsertResult(action, writeResult, fields) {
+function resolveCreateType(id, options) {
+  if (options.type === void 0) {
+    return "Task";
+  }
+  if (id !== void 0) {
+    fail2("--type can only be used when creating a work item.");
+  }
+  const trimmedType = options.type.trim();
+  if (trimmedType === "") {
+    fail2("--type must be a non-empty work item type.");
+  }
+  return trimmedType;
+}
+function buildUpsertResult(action, writeResult, fields, fallbackWorkItemType) {
   const appliedFields = buildAppliedFields(fields);
+  const workItemType = writeResult.fields["System.WorkItemType"];
   return {
     action,
     id: writeResult.id,
+    workItemType: typeof workItemType === "string" && workItemType.trim() !== "" ? workItemType : fallbackWorkItemType,
     fields: appliedFields
   };
 }
 function isUpdateWriteError(err) {
-  return err.message === "AUTH_FAILED" || err.message === "PERMISSION_DENIED" || err.message === "NOT_FOUND" || err.message === "NETWORK_ERROR" || err.message.startsWith("BAD_REQUEST:") || err.message.startsWith("UPDATE_REJECTED:");
+  return err.message === "AUTH_FAILED" || err.message === "PERMISSION_DENIED" || err.message.startsWith("NOT_FOUND") || err.message === "NETWORK_ERROR" || err.message.startsWith("BAD_REQUEST:") || err.message.startsWith("UPDATE_REJECTED:");
 }
 function isCreateWriteError(err) {
   return err.message === "AUTH_FAILED" || err.message === "PERMISSION_DENIED" || err.message === "NETWORK_ERROR" || err.message.startsWith("BAD_REQUEST:") || err.message.startsWith("HTTP_");
@@ -1367,10 +1556,11 @@ function handleUpsertError(err, id, context) {
 }
 function createUpsertCommand() {
   const command = new Command9("upsert");
-  command.description("Create or update a Task from a markdown document").argument("[id]", "work item ID to update; omit to create a new Task").option("--content <markdown>", "task document content").option("--file <path>", "read task document from file").option("--json", "output result as JSON").option("--org <org>", "Azure DevOps organization").option("--project <project>", "Azure DevOps project").action(async (idStr, options) => {
+  command.description("Create or update a work item from a markdown document").argument("[id]", "work item ID to update; omit to create a new work item").option("--content <markdown>", "task document content").option("--file <path>", "read task document from file").option("--type <workItemType>", "create mode work item type (defaults to Task)").option("--json", "output result as JSON").option("--org <org>", "Azure DevOps organization").option("--project <project>", "Azure DevOps project").action(async (idStr, options) => {
     validateOrgProjectPair(options);
     const id = idStr === void 0 ? void 0 : parseWorkItemId(idStr);
     const { content, sourceFile } = loadSourceContent(options);
+    const createType = resolveCreateType(id, options);
     let context;
     try {
       context = resolveContext(options);
@@ -1383,14 +1573,19 @@ function createUpsertCommand() {
       const credential = await resolvePat();
       let writeResult;
       if (action === "created") {
-        writeResult = await createWorkItem(context, "Task", credential.pat, operations);
+        writeResult = await createWorkItem(context, createType, credential.pat, operations);
       } else {
         if (id === void 0) {
           fail2("Work item ID is required for updates.");
         }
         writeResult = await applyWorkItemPatch(context, id, credential.pat, operations);
       }
-      const result = buildUpsertResult(action, writeResult, document.fields);
+      const result = buildUpsertResult(
+        action,
+        writeResult,
+        document.fields,
+        action === "created" ? createType : "Work item"
+      );
       writeSuccess(result, options);
       cleanupSourceFile(sourceFile);
     } catch (err) {
@@ -1400,8 +1595,459 @@ function createUpsertCommand() {
   return command;
 }
 
+// src/commands/list-fields.ts
+import { Command as Command10 } from "commander";
+function stringifyValue(value) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+function formatRichValue(raw) {
+  const md = htmlToMarkdown(raw);
+  const lines = md.split("\n").filter((l) => l.trim() !== "");
+  const preview = lines.slice(0, 5);
+  const suffix = lines.length > 5 ? `
+  \u2026 (${lines.length - 5} more lines)` : "";
+  return preview.join("\n  ") + suffix;
+}
+function formatFieldList(fields) {
+  const entries = Object.entries(fields).sort(([a], [b]) => a.localeCompare(b));
+  const maxKeyLen = Math.min(
+    Math.max(...entries.map(([k]) => k.length)),
+    50
+  );
+  return entries.map(([key, value]) => {
+    const raw = stringifyValue(value);
+    if (raw === "") return `${key.padEnd(maxKeyLen + 2)}(empty)`;
+    if (typeof value === "string" && isHtml(value)) {
+      const preview = formatRichValue(value);
+      return `${key.padEnd(maxKeyLen + 2)}[rich text]
+  ${preview}`;
+    }
+    return `${key.padEnd(maxKeyLen + 2)}${raw}`;
+  }).join("\n");
+}
+function createListFieldsCommand() {
+  const command = new Command10("list-fields");
+  command.description("List all fields of an Azure DevOps work item").argument("<id>", "work item ID").option("--org <org>", "Azure DevOps organization").option("--project <project>", "Azure DevOps project").option("--json", "output result as JSON").action(
+    async (idStr, options) => {
+      const id = parseWorkItemId(idStr);
+      validateOrgProjectPair(options);
+      let context;
+      try {
+        context = resolveContext(options);
+        const credential = await resolvePat();
+        const fields = await getWorkItemFields(context, id, credential.pat);
+        if (options.json) {
+          process.stdout.write(JSON.stringify({ id, fields }, null, 2) + "\n");
+        } else {
+          process.stdout.write(`Work Item ${id} \u2014 ${Object.keys(fields).length} fields
+
+`);
+          process.stdout.write(formatFieldList(fields) + "\n");
+        }
+      } catch (err) {
+        handleCommandError(err, id, context, "read");
+      }
+    }
+  );
+  return command;
+}
+
+// src/commands/pr.ts
+import { Command as Command11 } from "commander";
+
+// src/services/pr-client.ts
+function buildPullRequestsUrl(context, repo, sourceBranch, opts) {
+  const url = new URL(
+    `https://dev.azure.com/${encodeURIComponent(context.org)}/${encodeURIComponent(context.project)}/_apis/git/repositories/${encodeURIComponent(repo)}/pullrequests`
+  );
+  url.searchParams.set("api-version", "7.1");
+  url.searchParams.set("searchCriteria.sourceRefName", `refs/heads/${sourceBranch}`);
+  if (opts?.status) {
+    url.searchParams.set("searchCriteria.status", opts.status);
+  }
+  if (opts?.targetBranch) {
+    url.searchParams.set("searchCriteria.targetRefName", `refs/heads/${opts.targetBranch}`);
+  }
+  return url;
+}
+function mapPullRequest(repo, pullRequest) {
+  return {
+    id: pullRequest.pullRequestId,
+    title: pullRequest.title,
+    repository: repo,
+    sourceRefName: pullRequest.sourceRefName,
+    targetRefName: pullRequest.targetRefName,
+    status: pullRequest.status,
+    createdBy: pullRequest.createdBy?.displayName ?? null,
+    url: pullRequest._links.web.href
+  };
+}
+function mapComment(comment) {
+  const content = comment.content?.trim();
+  if (comment.isDeleted || !content) {
+    return null;
+  }
+  return {
+    id: comment.id,
+    author: comment.author?.displayName ?? null,
+    content,
+    publishedAt: comment.publishedDate ?? null
+  };
+}
+function mapThread(thread) {
+  if (thread.status !== "active" && thread.status !== "pending") {
+    return null;
+  }
+  const comments = thread.comments.map(mapComment).filter((comment) => comment !== null);
+  if (comments.length === 0) {
+    return null;
+  }
+  return {
+    id: thread.id,
+    status: thread.status,
+    threadContext: thread.threadContext?.filePath ?? null,
+    comments
+  };
+}
+async function readJsonResponse(response) {
+  if (!response.ok) {
+    throw new Error(`HTTP_${response.status}`);
+  }
+  return response.json();
+}
+async function listPullRequests(context, repo, pat, sourceBranch, opts) {
+  const response = await fetchWithErrors(
+    buildPullRequestsUrl(context, repo, sourceBranch, opts).toString(),
+    { headers: authHeaders(pat) }
+  );
+  const data = await readJsonResponse(response);
+  return data.value.map((pullRequest) => mapPullRequest(repo, pullRequest));
+}
+async function openPullRequest(context, repo, pat, sourceBranch, title, description) {
+  const existing = await listPullRequests(context, repo, pat, sourceBranch, {
+    status: "active",
+    targetBranch: "develop"
+  });
+  if (existing.length === 1) {
+    return {
+      branch: sourceBranch,
+      targetBranch: "develop",
+      created: false,
+      pullRequest: existing[0]
+    };
+  }
+  if (existing.length > 1) {
+    throw new Error(`AMBIGUOUS_PRS:${existing.map((pullRequest) => pullRequest.id).join(",")}`);
+  }
+  const payload = {
+    sourceRefName: `refs/heads/${sourceBranch}`,
+    targetRefName: "refs/heads/develop",
+    title,
+    description
+  };
+  const url = new URL(
+    `https://dev.azure.com/${encodeURIComponent(context.org)}/${encodeURIComponent(context.project)}/_apis/git/repositories/${encodeURIComponent(repo)}/pullrequests`
+  );
+  url.searchParams.set("api-version", "7.1");
+  const response = await fetchWithErrors(url.toString(), {
+    method: "POST",
+    headers: {
+      ...authHeaders(pat),
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(payload)
+  });
+  const data = await readJsonResponse(response);
+  return {
+    branch: sourceBranch,
+    targetBranch: "develop",
+    created: true,
+    pullRequest: mapPullRequest(repo, data)
+  };
+}
+async function getPullRequestThreads(context, repo, pat, prId) {
+  const url = new URL(
+    `https://dev.azure.com/${encodeURIComponent(context.org)}/${encodeURIComponent(context.project)}/_apis/git/repositories/${encodeURIComponent(repo)}/pullRequests/${prId}/threads`
+  );
+  url.searchParams.set("api-version", "7.1");
+  const response = await fetchWithErrors(url.toString(), { headers: authHeaders(pat) });
+  const data = await readJsonResponse(response);
+  return data.value.map(mapThread).filter((thread) => thread !== null);
+}
+
+// src/commands/pr.ts
+function formatBranchName(refName) {
+  return refName.startsWith("refs/heads/") ? refName.slice("refs/heads/".length) : refName;
+}
+function writeError(message) {
+  process.stderr.write(`Error: ${message}
+`);
+  process.exit(1);
+}
+function handlePrCommandError(err, context, mode = "read") {
+  const error = err instanceof Error ? err : new Error(String(err));
+  if (error.message === "AUTH_FAILED") {
+    const scopeLabel = mode === "write" ? "Code (Read & Write)" : "Code (Read)";
+    writeError(`Authentication failed. Check that your PAT is valid and has the "${scopeLabel}" scope.`);
+  }
+  if (error.message === "PERMISSION_DENIED") {
+    writeError(`Access denied. Your PAT may lack ${mode} permissions for project "${context?.project}".`);
+  }
+  if (error.message === "NETWORK_ERROR") {
+    writeError("Could not connect to Azure DevOps. Check your network connection.");
+  }
+  if (error.message.startsWith("NOT_FOUND")) {
+    writeError(`Azure DevOps repository not found in ${context?.org}/${context?.project}.`);
+  }
+  if (error.message.startsWith("HTTP_")) {
+    writeError(`Azure DevOps request failed with ${error.message}.`);
+  }
+  writeError(error.message);
+}
+function formatPullRequestBlock(pullRequest) {
+  return [
+    `#${pullRequest.id} [${pullRequest.status}] ${pullRequest.title}`,
+    `${formatBranchName(pullRequest.sourceRefName)} -> ${formatBranchName(pullRequest.targetRefName)}`,
+    pullRequest.url
+  ].join("\n");
+}
+function formatThreads(prId, title, threads) {
+  const lines = [`Active comments for pull request #${prId}: ${title}`];
+  for (const thread of threads) {
+    lines.push("", `Thread #${thread.id} [${thread.status}] ${thread.threadContext ?? "(general)"}`);
+    for (const comment of thread.comments) {
+      lines.push(`  ${comment.author ?? "Unknown"}: ${comment.content}`);
+    }
+  }
+  return lines.join("\n");
+}
+async function resolvePrCommandContext(options) {
+  const context = resolveContext(options);
+  const repo = detectRepoName();
+  const branch = getCurrentBranch();
+  const credential = await resolvePat();
+  return {
+    context,
+    repo,
+    branch,
+    pat: credential.pat
+  };
+}
+function createPrStatusCommand() {
+  const command = new Command11("status");
+  command.description("Check pull requests for the current branch").option("--org <org>", "Azure DevOps organization").option("--project <project>", "Azure DevOps project").option("--json", "output JSON").action(async (options) => {
+    validateOrgProjectPair(options);
+    let context;
+    try {
+      const resolved = await resolvePrCommandContext(options);
+      context = resolved.context;
+      const pullRequests = await listPullRequests(resolved.context, resolved.repo, resolved.pat, resolved.branch);
+      const { branch, repo } = resolved;
+      const result = { branch, repository: repo, pullRequests };
+      if (options.json) {
+        process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+        return;
+      }
+      if (pullRequests.length === 0) {
+        process.stdout.write(`No pull requests found for branch ${branch}.
+`);
+        return;
+      }
+      process.stdout.write(`${pullRequests.map(formatPullRequestBlock).join("\n\n")}
+`);
+    } catch (err) {
+      handlePrCommandError(err, context, "read");
+    }
+  });
+  return command;
+}
+function createPrOpenCommand() {
+  const command = new Command11("open");
+  command.description("Open a pull request from the current branch to develop").option("--title <title>", "pull request title").option("--description <description>", "pull request description").option("--org <org>", "Azure DevOps organization").option("--project <project>", "Azure DevOps project").option("--json", "output JSON").action(async (options) => {
+    validateOrgProjectPair(options);
+    const title = options.title?.trim();
+    if (!title) {
+      writeError("--title is required for pull request creation.");
+    }
+    const description = options.description?.trim();
+    if (!description) {
+      writeError("--description is required for pull request creation.");
+    }
+    let context;
+    try {
+      const resolved = await resolvePrCommandContext(options);
+      context = resolved.context;
+      if (resolved.branch === "develop") {
+        writeError("Pull request creation requires a source branch other than develop.");
+      }
+      const result = await openPullRequest(
+        resolved.context,
+        resolved.repo,
+        resolved.pat,
+        resolved.branch,
+        title,
+        description
+      );
+      if (options.json) {
+        process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+        return;
+      }
+      if (result.created) {
+        process.stdout.write(`Created pull request #${result.pullRequest.id}: ${result.pullRequest.title}
+${result.pullRequest.url}
+`);
+        return;
+      }
+      process.stdout.write(
+        `Active pull request already exists for ${resolved.branch} -> develop: #${result.pullRequest.id}
+${result.pullRequest.url}
+`
+      );
+    } catch (err) {
+      if (err instanceof Error && err.message.startsWith("AMBIGUOUS_PRS:")) {
+        const ids = err.message.replace("AMBIGUOUS_PRS:", "").split(",").map((id) => `#${id}`).join(", ");
+        writeError(`Multiple active pull requests already exist for this branch targeting develop: ${ids}. Use pr status to review them.`);
+      }
+      handlePrCommandError(err, context, "write");
+    }
+  });
+  return command;
+}
+function createPrCommentsCommand() {
+  const command = new Command11("comments");
+  command.description("List active pull request comments for the current branch").option("--org <org>", "Azure DevOps organization").option("--project <project>", "Azure DevOps project").option("--json", "output JSON").action(async (options) => {
+    validateOrgProjectPair(options);
+    let context;
+    try {
+      const resolved = await resolvePrCommandContext(options);
+      context = resolved.context;
+      const pullRequests = await listPullRequests(resolved.context, resolved.repo, resolved.pat, resolved.branch, {
+        status: "active"
+      });
+      if (pullRequests.length === 0) {
+        writeError(`No active pull request found for branch ${resolved.branch}.`);
+      }
+      if (pullRequests.length > 1) {
+        const ids = pullRequests.map((pullRequest2) => `#${pullRequest2.id}`).join(", ");
+        writeError(`Multiple active pull requests found for branch ${resolved.branch}: ${ids}. Use pr status to review them.`);
+      }
+      const pullRequest = pullRequests[0];
+      const threads = await getPullRequestThreads(resolved.context, resolved.repo, resolved.pat, pullRequest.id);
+      const result = { branch: resolved.branch, pullRequest, threads };
+      if (options.json) {
+        process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+        return;
+      }
+      if (threads.length === 0) {
+        process.stdout.write(`Pull request #${pullRequest.id} has no active comments.
+`);
+        return;
+      }
+      process.stdout.write(`${formatThreads(pullRequest.id, pullRequest.title, threads)}
+`);
+    } catch (err) {
+      handlePrCommandError(err, context, "read");
+    }
+  });
+  return command;
+}
+function createPrCommand() {
+  const command = new Command11("pr");
+  command.description("Manage Azure DevOps pull requests");
+  command.addCommand(createPrStatusCommand());
+  command.addCommand(createPrOpenCommand());
+  command.addCommand(createPrCommentsCommand());
+  return command;
+}
+
+// src/commands/comments.ts
+import { Command as Command12 } from "commander";
+function writeError2(message) {
+  process.stderr.write(`Error: ${message}
+`);
+  process.exit(1);
+}
+function formatCommentHeader(comment) {
+  const author = comment.author ?? "Unknown";
+  const timestamp = comment.modifiedAt ?? comment.createdAt ?? "Unknown time";
+  return `Comment #${comment.id} by ${author} at ${timestamp}`;
+}
+function formatComments(result) {
+  const lines = [`Comments for work item #${result.workItemId}`];
+  for (const comment of result.comments) {
+    lines.push("", formatCommentHeader(comment), comment.text);
+  }
+  return lines.join("\n");
+}
+function createCommentsListCommand() {
+  const command = new Command12("list");
+  command.description("List visible comments for a work item").argument("<id>", "work item ID").option("--org <org>", "Azure DevOps organization").option("--project <project>", "Azure DevOps project").option("--json", "output JSON").action(async (idStr, options) => {
+    validateOrgProjectPair(options);
+    const id = parseWorkItemId(idStr);
+    let context;
+    try {
+      context = resolveContext(options);
+      const credential = await resolvePat();
+      const result = await listWorkItemComments(context, id, credential.pat);
+      if (options.json) {
+        process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+        return;
+      }
+      if (result.comments.length === 0) {
+        process.stdout.write(`Work item #${id} has no comments.
+`);
+        return;
+      }
+      process.stdout.write(`${formatComments(result)}
+`);
+    } catch (err) {
+      handleCommandError(err, id, context, "read");
+    }
+  });
+  return command;
+}
+function createCommentsAddCommand() {
+  const command = new Command12("add");
+  command.description("Add a comment to a work item").argument("<id>", "work item ID").argument("<text>", "comment text").option("--org <org>", "Azure DevOps organization").option("--project <project>", "Azure DevOps project").option("--json", "output JSON").action(async (idStr, text, options) => {
+    validateOrgProjectPair(options);
+    const id = parseWorkItemId(idStr);
+    if (text.trim() === "") {
+      writeError2("Comment text must be a non-empty string.");
+    }
+    let context;
+    try {
+      context = resolveContext(options);
+      const credential = await resolvePat();
+      const result = await addWorkItemComment(context, id, credential.pat, text);
+      if (options.json) {
+        process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+        return;
+      }
+      process.stdout.write(`Added comment #${result.commentId} to work item #${result.workItemId}
+`);
+    } catch (err) {
+      handleCommandError(err, id, context, "write");
+    }
+  });
+  return command;
+}
+function createCommentsCommand() {
+  const command = new Command12("comments");
+  command.description("Manage Azure DevOps work item comments");
+  command.addCommand(createCommentsListCommand());
+  command.addCommand(createCommentsAddCommand());
+  return command;
+}
+
 // src/index.ts
-var program = new Command10();
+var program = new Command13();
 program.name("azdo").description("Azure DevOps CLI tool").version(version, "-v, --version");
 program.addCommand(createGetItemCommand());
 program.addCommand(createClearPatCommand());
@@ -1412,6 +2058,9 @@ program.addCommand(createSetFieldCommand());
 program.addCommand(createGetMdFieldCommand());
 program.addCommand(createSetMdFieldCommand());
 program.addCommand(createUpsertCommand());
+program.addCommand(createListFieldsCommand());
+program.addCommand(createPrCommand());
+program.addCommand(createCommentsCommand());
 program.showHelpAfterError();
 program.parse();
 if (process.argv.length <= 2) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "azdo-cli",
-  "version": "0.3.0",
+  "version": "0.5.0-010-work-item-comments.149",
   "description": "Azure DevOps CLI tool",
   "type": "module",
   "bin": {
@@ -14,7 +14,9 @@
     "lint": "eslint src/",
     "typecheck": "tsc --noEmit",
     "format": "prettier --check src/",
-    "test": "npm run build && vitest run"
+    "test": "npm run build && vitest run tests/unit",
+    "test:integration": "npm run build && vitest run tests/integration",
+    "test:integration:full": "bash scripts/setup-keyring.sh && npm run test:integration"
   },
   "repository": {
     "type": "git",