jiradc-cli 1.0.33 → 1.0.35

package/dist/index.js

@@ -4,6 +4,45 @@
 import { readFileSync, writeFileSync, mkdirSync, statSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
+var DEFAULT_TTL = 36e5;
+function getCacheDir(name) {
+  return join(homedir(), ".cache", name);
+}
+function getCachePath(name, key) {
+  return join(getCacheDir(name), `${key}.json`);
+}
+function cacheGet(options, key) {
+  const ttl = options.ttl ?? DEFAULT_TTL;
+  const path = getCachePath(options.name, key);
+  try {
+    const stat = statSync(path);
+    if (Date.now() - stat.mtimeMs > ttl)
+      return null;
+    const raw = readFileSync(path, "utf-8");
+    const entry = JSON.parse(raw);
+    return entry.data;
+  } catch {
+    return null;
+  }
+}
+function cacheSet(options, key, data) {
+  const dir = getCacheDir(options.name);
+  const path = getCachePath(options.name, key);
+  const entry = { data, timestamp: Date.now() };
+  try {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(path, JSON.stringify(entry));
+  } catch {
+  }
+}
+async function cacheGetOrFetch(options, key, fetcher) {
+  const cached = cacheGet(options, key);
+  if (cached !== null)
+    return cached;
+  const data = await fetcher();
+  cacheSet(options, key, data);
+  return data;
+}
 
 // ../../cli-utils/dist/bootstrap.js
 import { readFileSync as readFileSync2 } from "fs";
@@ -266,6 +305,16 @@ var SubcommandRequiredError = class extends Error {
     this.subcommands = subcommands;
   }
 };
+var UnknownSubcommandError = class extends Error {
+  subcommands;
+  suggestion;
+  constructor(commandPath3, token, subcommands, suggestion) {
+    super(`'${token}' is not a subcommand of '${commandPath3}'`);
+    this.name = "UnknownSubcommandError";
+    this.subcommands = subcommands;
+    this.suggestion = suggestion;
+  }
+};
 var TYPE_EXIT = {
   usage: EXIT.USAGE,
   not_found: EXIT.NOT_FOUND,
@@ -368,6 +417,16 @@ function normalize(err, opts) {
       detail: { subcommands: err.subcommands }
     };
   }
+  if (err instanceof UnknownSubcommandError) {
+    const didYouMean = err.suggestion === void 0 ? "" : `Did you mean '${err.suggestion}'? `;
+    return {
+      type: "usage",
+      message,
+      recovery: `${didYouMean}Valid subcommands: ${err.subcommands.join(", ")}.`,
+      retryable: false,
+      detail: { subcommands: err.subcommands }
+    };
+  }
   if (err instanceof CliAuthError) {
     return { type: "auth", message: message || "Missing credentials", recovery: opts.authRecovery, retryable: false };
   }
@@ -568,11 +627,39 @@ function attachSubcommandGuards(cmd) {
   const hasAction = Boolean(cmd._actionHandler);
   if (hasAction)
     return;
-  cmd.action(() => {
+  cmd.allowExcessArguments(true);
+  cmd.action((...params) => {
+    const invoked = params[params.length - 1];
     const names = cmd.commands.map((c) => c.name()).filter((name) => name !== "help");
-    throw new SubcommandRequiredError(commandPath2(cmd), names);
+    const [token] = invoked.args;
+    if (token === void 0)
+      throw new SubcommandRequiredError(commandPath2(cmd), names);
+    throw new UnknownSubcommandError(commandPath2(cmd), token, names, suggestSubcommand(token, names));
   });
 }
+function editDistance(a, b) {
+  let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    const row = [i];
+    for (let j = 1; j <= b.length; j++) {
+      const substitution = prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1);
+      row[j] = Math.min(row[j - 1] + 1, prev[j] + 1, substitution);
+    }
+    prev = row;
+  }
+  return prev[b.length];
+}
+function suggestSubcommand(token, names) {
+  const MAX_EDITS = 2;
+  let best;
+  for (const name of names) {
+    const distance = editDistance(token.toLowerCase(), name.toLowerCase());
+    if (distance <= MAX_EDITS && distance < token.length && (!best || distance < best.distance)) {
+      best = { name, distance };
+    }
+  }
+  return best?.name;
+}
 async function runCli(program, opts) {
   routeErrors(program);
   attachSubcommandGuards(program);
@@ -805,12 +892,22 @@ function transformIssueLink(l) {
     ...outwardIssue ? { outwardIssue: transformIssueBasic(outwardIssue) } : {}
   };
 }
+function customFieldNames(names, fields) {
+  if (!names) return void 0;
+  const kept = Object.entries(names).filter(
+    ([id]) => id.startsWith("customfield_") && fields[id] !== void 0
+  );
+  return kept.length > 0 ? Object.fromEntries(kept) : void 0;
+}
 function transformIssue(issue) {
-  const { self: _self, expand: _expand, names: _names, schema: _schema, fields, ...rest } = issue;
+  const { self: _self, expand: _expand, names, schema: _schema, fields, ...rest } = issue;
+  const transformed = transformIssueFields(fields, issue.key);
+  const fieldNames = customFieldNames(names, transformed);
   return {
     ...rest,
     url: issueBrowseUrl(issue.key),
-    fields: transformIssueFields(fields)
+    fields: transformed,
+    ...fieldNames ? { names: fieldNames } : {}
   };
 }
 function isEmpty(v) {
@@ -846,6 +943,20 @@ function pruneSentinels(fields) {
   if (watches && watches.watchCount === 0) delete out.watches;
   return out;
 }
+var DEV_STATUS_DUMP = /com\.atlassian\.jira\.plugin\.devstatus/;
+function collapseDevStatus(fields, key) {
+  const out = { ...fields };
+  for (const [field, value] of Object.entries(out)) {
+    if (typeof value === "string" && DEV_STATUS_DUMP.test(value)) {
+      out[field] = `(use: jiradc issue dev-status ${key})`;
+    }
+  }
+  return out;
+}
+function transformInlineComponent(c) {
+  const { self: _self, description: _description, ...rest } = c;
+  return rest;
+}
 var ISSUE_KEY_PATTERN = /^[A-Z][A-Z0-9_]*-\d+$/;
 function asIssueRefKey(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
@@ -869,7 +980,8 @@ function collapseIssueRefs(fields) {
   }
   return out;
 }
-function transformIssueFields(fields) {
+function transformIssueFields(fields, key) {
+  if (!fields) return {};
   const {
     // shaped sub-entities (recursed individually)
     issuetype,
@@ -895,9 +1007,11 @@ function transformIssueFields(fields) {
     // everything else: optional scalars, customfield_*, etc. — gets compacted
     ...rest
   } = fields;
-  const compacted = collapseIssueRefs(pruneSentinels(compactRecord(rest)));
+  const compacted = collapseDevStatus(collapseIssueRefs(pruneSentinels(compactRecord(rest))), key);
+  const components = compacted.components;
   return {
     ...compacted,
+    ...Array.isArray(components) ? { components: components.map(transformInlineComponent) } : {},
     summary,
     project,
     created,
@@ -1881,9 +1995,8 @@ function editmeta(parent) {
 }
 
 // src/utils/constants.ts
-var DEFAULT_FIELDS = [
+var SEARCH_DEFAULT_FIELDS = [
   "summary",
-  "description",
   "status",
   "assignee",
   "reporter",
@@ -1892,13 +2005,117 @@ var DEFAULT_FIELDS = [
   "created",
   "updated",
   "issuetype",
-  "components",
-  "comment"
+  "components"
 ];
+var DEFAULT_FIELDS = [...SEARCH_DEFAULT_FIELDS, "description", "comment"];
+
+// src/utils/field-selectors.ts
+var WILDCARD = "*";
+var NEGATION = "-";
+function buildFieldNameIndex(fields) {
+  const ids = /* @__PURE__ */ new Set();
+  const idsByLower = /* @__PURE__ */ new Map();
+  const byName = /* @__PURE__ */ new Map();
+  const record = (alias, id) => {
+    const key = alias.toLowerCase();
+    const already = byName.get(key);
+    if (!already) {
+      byName.set(key, [id]);
+      return;
+    }
+    if (!already.includes(id)) already.push(id);
+  };
+  for (const field of fields) {
+    ids.add(field.id);
+    idsByLower.set(field.id.toLowerCase(), field.id);
+    record(field.name, field.id);
+    for (const clause of field.clauseNames ?? []) record(clause, field.id);
+  }
+  return { ids, idsByLower, byName };
+}
+function candidatesFor(token, index) {
+  if (index.ids.has(token)) return [token];
+  const byId = index.idsByLower.get(token.toLowerCase());
+  if (byId !== void 0) return [byId];
+  return index.byName.get(token.toLowerCase()) ?? [];
+}
+function resolveFieldSelectors(tokens, index) {
+  const resolved = [];
+  const unresolved = [];
+  const ambiguous = [];
+  for (const token of tokens) {
+    if (token.startsWith(WILDCARD)) {
+      resolved.push(token);
+      continue;
+    }
+    const negated = token.startsWith(NEGATION);
+    const bare = negated ? token.slice(1) : token;
+    const candidates = candidatesFor(bare, index);
+    if (candidates.length === 0) {
+      unresolved.push(token);
+      continue;
+    }
+    if (candidates.length > 1) {
+      ambiguous.push({ name: bare, candidates });
+      continue;
+    }
+    resolved.push(negated ? `${NEGATION}${candidates[0]}` : candidates[0]);
+  }
+  if (unresolved.length > 0 || ambiguous.length > 0) {
+    throw new CliUsageError(describeFailure(unresolved, ambiguous), recoveryFor(unresolved, ambiguous), {
+      ...unresolved.length > 0 ? { unresolved } : {},
+      ...ambiguous.length > 0 ? { ambiguous } : {}
+    });
+  }
+  return [...new Set(resolved)];
+}
+function describeFailure(unresolved, ambiguous) {
+  const parts = [];
+  if (unresolved.length > 0) {
+    parts.push(`Unknown field name${unresolved.length > 1 ? "s" : ""}: ${unresolved.join(", ")}`);
+  }
+  for (const { name, candidates } of ambiguous) {
+    parts.push(`'${name}' matches ${candidates.length} fields on this instance: ${candidates.join(", ")}`);
+  }
+  return parts.join(". ");
+}
+function recoveryFor(unresolved, ambiguous) {
+  const parts = [];
+  if (unresolved.length > 0) {
+    parts.push(
+      "Jira selects fields by id, and these matched no field id, name or JQL clause name on this instance. Run jiradc field search <keyword> to find the right name or id."
+    );
+  }
+  if (ambiguous.length > 0) {
+    parts.push(
+      `Field names are not unique on a Jira instance. Re-run with the id you mean \u2014 ${ambiguous.map((a) => a.candidates.join(" or ")).join("; ")} \u2014 or run jiradc issue get <key> --all-fields to see which one this issue carries. Choosing one for you would return an answer that looks complete and names no field it dropped.`
+    );
+  }
+  return parts.join(" ");
+}
+function parseFieldSelectors(raw) {
+  return raw.split(",").map((token) => token.trim()).filter((token) => token.length > 0);
+}
+var FIELD_CACHE = { name: "jiradc", ttl: 36e5 };
+async function loadFieldNameIndex(client) {
+  const fields = await cacheGetOrFetch(
+    FIELD_CACHE,
+    "field-names",
+    async () => (await client.fields.getAll()).map(({ id, name, clauseNames }) => ({ id, name, clauseNames }))
+  );
+  return buildFieldNameIndex(fields);
+}
+async function selectFields(client, opts, defaults) {
+  if (opts.allFields === true) return void 0;
+  if (opts.fields === void 0) return defaults;
+  const tokens = parseFieldSelectors(opts.fields);
+  if (tokens.length === 0) return defaults;
+  return resolveFieldSelectors(tokens, await loadFieldNameIndex(client));
+}
 
 // src/commands/issue/get.ts
 function get2(parent) {
-  const cmd = parent.command("get").description("Get issue details").argument("<key>", "Issue key", issueKey).option("--fields <fields>", "Comma-separated fields to return (defaults to essential fields)", text).option("--all-fields", "Return all fields instead of defaults").option("--expand <expand>", 'Expand options (e.g., "transitions", "changelog")', text);
+  const cmd = parent.command("get").description("Get issue details").argument("<key>", "Issue key", issueKey).option("--fields <fields>", "Comma-separated fields to return, by name or id", text).option("--all-fields", "Return all fields instead of defaults").option("--expand <expand>", 'Expand options (e.g., "transitions", "changelog")', text);
   examples(cmd, [
     "PROJ-123",
     "PROJ-123 --fields summary,status,assignee",
@@ -1907,7 +2124,7 @@ function get2(parent) {
   ]);
   cmd.action(async (key, opts) => {
     const client = getClient();
-    const fields = opts.allFields ? void 0 : opts.fields?.split(",").map((f) => f.trim()) ?? DEFAULT_FIELDS;
+    const fields = await selectFields(client, opts, DEFAULT_FIELDS);
     const result = await client.issues.get({
       issueKeyOrId: key,
       fields,
@@ -1986,25 +2203,69 @@ function link(parent) {
   });
 }
 
+// src/utils/paging.ts
+var ALL_RESULTS_CAP = 1e3;
+function planSearch(opts, maxPageSize) {
+  const start = opts.start ?? 0;
+  if (opts.all !== true) return { all: false, pageSize: opts.limit, start };
+  if (opts.limitGiven) {
+    throw new CliUsageError(
+      "Pass either --all or --limit, not both",
+      "--all collects every match; --limit caps how many come back. Drop --limit to collect everything, or drop --all and page with --limit and --start."
+    );
+  }
+  return { all: true, pageSize: maxPageSize, start };
+}
+async function fetchEveryPage(fetchPage, opts) {
+  const first = await fetchPage(opts.start, opts.pageSize);
+  const outstanding = first.total - opts.start;
+  if (outstanding > ALL_RESULTS_CAP) {
+    throw new CliUsageError(
+      `--all would collect ${outstanding} issues, above the ${ALL_RESULTS_CAP} limit`,
+      `Narrow the query, or page it yourself with --start and --limit. Returning the first ${ALL_RESULTS_CAP} instead would look like a complete answer and would not be one.`,
+      { total: first.total, cap: ALL_RESULTS_CAP }
+    );
+  }
+  const offsets = [];
+  for (let at = opts.start + first.issues.length; at < first.total; at += opts.pageSize) offsets.push(at);
+  const rest = await Promise.all(offsets.map(async (at) => fetchPage(at, opts.pageSize)));
+  const issues3 = [first, ...rest].flatMap((page) => page.issues);
+  return { startAt: opts.start, maxResults: issues3.length, total: first.total, isLast: true, issues: issues3 };
+}
+
 // src/commands/issue/search.ts
+var MAX_PAGE_SIZE = 50;
 function search2(parent) {
-  const cmd = parent.command("search").description("Search issues using JQL").argument("<jql>", "JQL query string", text).option("--limit <number>", "Max results (1-50, Jira DC caps at 50)", intInRange(1, 50), 25).option("--start <number>", "Starting index for pagination", nonNegativeInt).option("--fields <fields>", "Comma-separated fields to return (defaults to essential fields)", text).option("--all-fields", "Return all fields instead of defaults");
+  const cmd = parent.command("search").description("Search issues using JQL").argument("<jql>", "JQL query string", text).option(
+    "--limit <number>",
+    `Max results (1-${MAX_PAGE_SIZE}, Jira DC caps at ${MAX_PAGE_SIZE})`,
+    intInRange(1, MAX_PAGE_SIZE),
+    25
+  ).option("--start <number>", "Starting index for pagination", nonNegativeInt).option(
+    "--fields <fields>",
+    "Comma-separated fields to return, by name or id (defaults to a lean set without description/comment)",
+    text
+  ).option("--all-fields", "Return all fields instead of defaults").option("--all", `Collect every match, not just one page (up to ${ALL_RESULTS_CAP}; fails above it)`);
   examples(cmd, [
     '"project = PROJ AND status = Open"',
     '"assignee = currentUser()" --limit 10 --fields summary,status',
+    '"project = PROJ AND status = Open" --all',
     '"project = PROJ" --start 50 --limit 50'
   ]);
-  cmd.action(async (jql, opts) => {
-    const client = getClient();
-    const fields = opts.allFields ? void 0 : opts.fields?.split(",").map((f) => f.trim()) ?? DEFAULT_FIELDS;
-    const result = await client.issues.search({
-      jql,
-      startAt: opts.start,
-      maxResults: opts.limit,
-      fields
-    });
-    output(transformPaged(result, transformIssue));
-  });
+  cmd.action(
+    async (jql, opts) => {
+      const client = getClient();
+      const fields = await selectFields(client, opts, SEARCH_DEFAULT_FIELDS);
+      const plan = planSearch({ ...opts, limitGiven: cmd.getOptionValueSource("limit") === "cli" }, MAX_PAGE_SIZE);
+      const page = async (startAt, maxResults) => client.issues.search({ jql, startAt, maxResults, fields });
+      if (!plan.all) {
+        output(transformPaged(await page(plan.start, plan.pageSize), transformIssue));
+        return;
+      }
+      const every = await fetchEveryPage(page, { pageSize: plan.pageSize, start: plan.start });
+      output({ ...every, issues: every.issues.map(transformIssue) });
+    }
+  );
 }
 
 // src/commands/issue/transition.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jiradc-cli",
-  "version": "1.0.33",
+  "version": "1.0.35",
   "publish": true,
   "type": "module",
   "main": "dist/index.js",
@@ -23,9 +23,9 @@
     "tsx": "^4.19.2",
     "typescript": "^5.7.2",
     "vitest": "^4.0.16",
-    "config-typescript": "0.0.0",
     "config-eslint": "0.0.0",
-    "cli-utils": "1.0.0"
+    "cli-utils": "1.0.0",
+    "config-typescript": "0.0.0"
   },
   "engines": {
     "node": ">=22.0.0"