@metaphorli/pingcode-cli 0.3.2 → 0.3.3

package/scripts/commands/product.js

@@ -0,0 +1,236 @@
+'use strict';
+
+const core = require('../core');
+const shared = require('./shared');
+
+// ── Help ───────────────────────────────────────────────────────────────
+
+function printHelp() {
+  console.log([
+    'PingCode product — Manage products',
+    '',
+    'Usage: pingcode product <subcommand> [options]',
+    '',
+    'Subcommands:',
+    '  list [options]              List products',
+    '    --keywords TEXT           Filter by keywords (matches name and identifier)',
+    '    --limit N                 Max results per page',
+    '',
+    '  get <id|name>               Show a single product by raw id or name',
+    '',
+    'Global options:',
+    '  --base-url URL              PingCode base URL',
+    '  --client-id ID              OAuth client ID',
+    '  --client-secret SECRET      OAuth client secret',
+    '  --token TOKEN               Bearer token (skip OAuth)',
+    '  --user-id ID                Current user ID',
+    '  --user-name NAME            Current user name',
+    '  --workspace-cache PATH      Workspace cache file path',
+    '  --no-workspace-cache        Disable workspace cache',
+    '  --no-token-cache            Disable token cache',
+    '  --dry-run                   Show API request without executing',
+    '  --compact                   Compact output',
+    '  --grant-type TYPE           OAuth grant type: client_credentials, authorization_code, or auto (default; uses cached token type)',
+    '  --help                      Show this help',
+  ].join('\n'));
+}
+
+function printSubcommandHelp(subcommand) {
+  switch (subcommand) {
+    case 'list':
+      console.log([
+        'Usage: pingcode product list [options]',
+        '',
+        'List products.',
+        '',
+        'Options:',
+        '  --keywords TEXT           Filter by keywords (matches name and identifier)',
+        '  --limit N                 Max results per page',
+      ].join('\n'));
+      break;
+    case 'get':
+      console.log([
+        'Usage: pingcode product get <id|name>',
+        '',
+        'Show a single product by raw id or name.',
+        '',
+        'If given a raw id (24-32 hex characters), fetches the product directly.',
+        'Otherwise searches products by keywords and returns the first match.',
+      ].join('\n'));
+      break;
+    default:
+      printHelp();
+  }
+}
+
+// ── List subcommand ───────────────────────────────────────────────────
+
+function parseListArgs(tokens) {
+  const args = {
+    keywords: null,
+    limit: null,
+  };
+  const stringFlags = {
+    '--keywords': 'keywords',
+    '--limit': 'limit',
+  };
+
+  for (let i = 0; i < tokens.length; i++) {
+    const arg = tokens[i];
+    if (arg in stringFlags) {
+      if (i + 1 >= tokens.length) {
+        throw new core.PingCodeError(`Flag ${arg} requires a value`);
+      }
+      args[stringFlags[arg]] = tokens[i + 1];
+      i += 1;
+    } else if (arg.startsWith('--')) {
+      const eqIndex = arg.indexOf('=');
+      if (eqIndex !== -1) {
+        const flag = arg.slice(0, eqIndex);
+        const value = arg.slice(eqIndex + 1);
+        if (flag in stringFlags) {
+          args[stringFlags[flag]] = value;
+        } else {
+          throw new core.PingCodeError(`Unknown option: ${flag}`);
+        }
+      } else {
+        throw new core.PingCodeError(`Unknown option: ${arg}. Use product list --help for usage.`);
+      }
+    } else {
+      throw new core.PingCodeError(`Unexpected argument: ${arg}. Use product list --help for usage.`);
+    }
+  }
+  return args;
+}
+
+async function runList(client, opts, args) {
+  const params = {};
+  if (args.keywords) {
+    params.keywords = args.keywords;
+  }
+  if (args.limit) {
+    params.page_size = String(args.limit);
+  }
+
+  return await client.request(
+    'GET',
+    '/v1/ship/products',
+    params,
+    null,
+    { dry_run: opts.dry_run, use_workspace_cache: true },
+  );
+}
+
+// ── Get subcommand ────────────────────────────────────────────────────
+
+function parseGetArgs(tokens) {
+  let productId = null;
+  for (let i = 0; i < tokens.length; i++) {
+    const arg = tokens[i];
+    if (!arg.startsWith('--')) {
+      if (productId === null) {
+        productId = arg;
+        continue;
+      }
+      throw new core.PingCodeError(`Unexpected argument: ${arg}. Use product get --help for usage.`);
+    }
+    throw new core.PingCodeError(`Unknown option: ${arg}. Use product get --help for usage.`);
+  }
+  if (!productId) {
+    throw new core.PingCodeError('A product id or name is required. Use product get --help for usage.');
+  }
+  return { product_id: productId };
+}
+
+const PRODUCT_RAW_ID_RE = /^[0-9a-fA-F]{24,32}$/;
+
+async function runGet(client, opts, args) {
+  const input = args.product_id;
+  let productId;
+
+  if (PRODUCT_RAW_ID_RE.test(input)) {
+    productId = input;
+  } else {
+    // Search by keywords, resolve to id
+    const listResp = await client.request(
+      'GET',
+      '/v1/ship/products',
+      { keywords: input },
+      null,
+      { dry_run: false, use_workspace_cache: true },
+    );
+    const values = core.pageValues(listResp);
+    if (values.length === 0) {
+      throw new core.PingCodeError(`No product found matching "${input}"`);
+    }
+    productId = values[0].id;
+  }
+
+  return await client.request(
+    'GET',
+    `/v1/ship/products/${productId}`,
+    null,
+    null,
+    { dry_run: opts.dry_run, use_workspace_cache: true },
+  );
+}
+
+// ── Main dispatcher ───────────────────────────────────────────────────────
+
+async function run(argv) {
+  const tokens = argv || [];
+
+  if (tokens.length === 0 || tokens[0] === '--help' || tokens[0] === '-h') {
+    printHelp();
+    return;
+  }
+
+  const subcommand = tokens[0];
+  const remaining = tokens.slice(1);
+
+  if (remaining.includes('--help') || remaining.includes('-h')) {
+    printSubcommandHelp(subcommand);
+    return;
+  }
+
+  const { opts, remaining: subArgs } = shared.parseGlobalOptions(remaining);
+  const client = shared.clientFromOpts(opts);
+
+  try {
+    let result;
+    switch (subcommand) {
+      case 'list': {
+        const listArgs = parseListArgs(subArgs);
+        result = await runList(client, opts, listArgs);
+        break;
+      }
+      case 'get': {
+        const getArgs = parseGetArgs(subArgs);
+        result = await runGet(client, opts, getArgs);
+        break;
+      }
+      default:
+        throw new core.PingCodeError(`Unknown product subcommand: ${subcommand}. Use product --help for usage.`);
+    }
+
+    if (opts.dry_run) {
+      core.printJson(result);
+    } else if (result !== null && result !== undefined) {
+      if (opts.compact) {
+        core.printJson(core.compactResponse(result));
+      } else {
+        core.printJson(result);
+      }
+    }
+  } catch (exc) {
+    throw exc;
+  }
+}
+
+shared.registerModule('product', {
+  name: 'product',
+  description: 'Manage PingCode products',
+  run,
+});
+
+module.exports = { run, printHelp };

package/scripts/commands/shared.js

@@ -1,9 +1,11 @@
-'use strict';
+  'use strict';
 
 // Module registry shared by the dispatcher and command modules.
 // Command modules register themselves here; the dispatcher discovers
 // them without importing command files directly (avoids circular deps).
 
+const core = require('../core');
+
 const registry = new Map();
 
 function registerModule(name, config) {
@@ -38,4 +40,107 @@ function printModulesHelp() {
   console.log(lines.join('\n'));
 }
 
-module.exports = { registerModule, getModule, listModules, printModulesHelp };
+const BASE_GLOBAL_BOOLEAN_FLAGS = new Set([
+  '--dry-run', '--compact', '--no-token-cache', '--no-workspace-cache',
+]);
+
+const BASE_GLOBAL_STRING_FLAGS = {
+  '--base-url': 'base_url',
+  '--client-id': 'client_id',
+  '--client-secret': 'client_secret',
+  '--token': 'token',
+  '--user-id': 'user_id',
+  '--user-name': 'user_name',
+  '--workspace-cache': 'workspace_cache',
+  '--grant-type': 'grant_type',
+};
+
+function defaultGlobalOpts(extraBooleanFlags = []) {
+  const opts = {
+    base_url: process.env.PINGCODE_BASE_URL || core.DEFAULT_BASE_URL,
+    client_id: process.env.PINGCODE_CLIENT_ID || null,
+    client_secret: process.env.PINGCODE_CLIENT_SECRET || null,
+    token: process.env.PINGCODE_ACCESS_TOKEN || null,
+    user_id: process.env.PINGCODE_USER_ID || null,
+    user_name: process.env.PINGCODE_USER_NAME || null,
+    no_token_cache: false,
+    workspace_cache: process.env.PINGCODE_WORKSPACE_CACHE || core.DEFAULT_WORKSPACE_CACHE,
+    no_workspace_cache: false,
+    dry_run: false,
+    compact: false,
+    grant_type: 'auto',
+  };
+  for (const flag of extraBooleanFlags) {
+    const key = flag.replace(/^--/, '').replace(/-/g, '_');
+    opts[key] = false;
+  }
+  return opts;
+}
+
+function parseGlobalOptions(tokens, extraBooleanFlags = []) {
+  const booleanFlags = new Set([...BASE_GLOBAL_BOOLEAN_FLAGS, ...extraBooleanFlags]);
+  const opts = defaultGlobalOpts(extraBooleanFlags);
+  const remaining = [];
+
+  for (let i = 0; i < tokens.length; i++) {
+    const arg = tokens[i];
+    if (arg === '--help' || arg === '-h') {
+      remaining.push(arg);
+      continue;
+    }
+    if (booleanFlags.has(arg)) {
+      const key = arg.replace(/^--/, '').replace(/-/g, '_');
+      opts[key] = true;
+      continue;
+    }
+    const eqIndex = arg.indexOf('=');
+    let flag, value, consumedNext = false;
+    if (eqIndex !== -1) {
+      flag = arg.slice(0, eqIndex);
+      value = arg.slice(eqIndex + 1);
+    } else if (arg.startsWith('--')) {
+      flag = arg;
+      if (i + 1 < tokens.length && !tokens[i + 1].startsWith('--')) {
+        value = tokens[i + 1];
+        consumedNext = true;
+      } else {
+        remaining.push(arg);
+        continue;
+      }
+    } else {
+      remaining.push(arg);
+      continue;
+    }
+    if (flag in BASE_GLOBAL_STRING_FLAGS) {
+      opts[BASE_GLOBAL_STRING_FLAGS[flag]] = value;
+      if (consumedNext) i += 1;
+    } else {
+      remaining.push(arg);
+      if (consumedNext) remaining.push(value);
+      if (consumedNext) i += 1;
+    }
+  }
+  return { opts, remaining };
+}
+
+function clientFromOpts(opts) {
+  const tokenCache = opts.no_token_cache
+    ? null
+    : (process.env.PINGCODE_TOKEN_CACHE || core.DEFAULT_TOKEN_CACHE);
+  const workspaceCache = opts.no_workspace_cache ? null : opts.workspace_cache;
+  return new core.PingCodeClient({
+    base_url: opts.base_url,
+    client_id: opts.client_id,
+    client_secret: opts.client_secret,
+    token: opts.token,
+    token_cache: tokenCache,
+    workspace_cache: workspaceCache,
+    grant_type: opts.grant_type,
+  });
+}
+
+module.exports = {
+  registerModule, getModule, listModules, printModulesHelp,
+  BASE_GLOBAL_BOOLEAN_FLAGS, BASE_GLOBAL_STRING_FLAGS,
+  defaultGlobalOpts, parseGlobalOptions, clientFromOpts,
+};

package/scripts/commands/workitem.js

@@ -3,102 +3,14 @@
 const core = require('../core');
 const shared = require('./shared');
 
-// ── Global option defaults ────────────────────────────────────────────
-const GLOBAL_BOOLEAN_FLAGS = new Set([
-  '--dry-run', '--compact', '--no-token-cache', '--no-workspace-cache',
-  '--all-users', '--all-projects', '--all-sprints',
-]);
+// ── Extra global boolean flags ──────────────────────────────────────
+const EXTRA_BOOLEAN_FLAGS = ['--all-users', '--all-projects', '--all-sprints'];
 
-const GLOBAL_STRING_FLAGS = {
-  '--base-url': 'base_url',
-  '--client-id': 'client_id',
-  '--client-secret': 'client_secret',
-  '--token': 'token',
-  '--user-id': 'user_id',
-  '--user-name': 'user_name',
-  '--workspace-cache': 'workspace_cache',
-  '--grant-type': 'grant_type',
-};
-
-function defaultGlobalOpts() {
-  return {
-    base_url: process.env.PINGCODE_BASE_URL || core.DEFAULT_BASE_URL,
-    client_id: process.env.PINGCODE_CLIENT_ID || null,
-    client_secret: process.env.PINGCODE_CLIENT_SECRET || null,
-    token: process.env.PINGCODE_ACCESS_TOKEN || null,
-    user_id: process.env.PINGCODE_USER_ID || null,
-    user_name: process.env.PINGCODE_USER_NAME || null,
-    no_token_cache: false,
-    workspace_cache: process.env.PINGCODE_WORKSPACE_CACHE || core.DEFAULT_WORKSPACE_CACHE,
-    no_workspace_cache: false,
-    dry_run: false,
-    compact: false,
-    all_users: false,
-    all_projects: false,
-    all_sprints: false,
-    grant_type: 'auto',
-  };
-}
-
-function parseGlobalOptions(tokens) {
-  const opts = defaultGlobalOpts();
-  const remaining = [];
-  for (let i = 0; i < tokens.length; i++) {
-    const arg = tokens[i];
-    if (arg === '--help' || arg === '-h') {
-      remaining.push(arg);
-      continue;
-    }
-    if (GLOBAL_BOOLEAN_FLAGS.has(arg)) {
-      const key = arg.replace(/^--/, '').replace(/-/g, '_');
-      opts[key] = true;
-      continue;
-    }
-    const eqIndex = arg.indexOf('=');
-    let flag, value, consumedNext = false;
-    if (eqIndex !== -1) {
-      flag = arg.slice(0, eqIndex);
-      value = arg.slice(eqIndex + 1);
-    } else if (arg.startsWith('--')) {
-      flag = arg;
-      if (i + 1 < tokens.length && !tokens[i + 1].startsWith('--')) {
-        value = tokens[i + 1];
-        consumedNext = true;
-      } else {
-        // Boolean-like flag with no value — could be a subcommand flag
-        remaining.push(arg);
-        continue;
-      }
-    } else {
-      remaining.push(arg);
-      continue;
-    }
-    if (flag in GLOBAL_STRING_FLAGS) {
-      opts[GLOBAL_STRING_FLAGS[flag]] = value;
-      if (consumedNext) i += 1;
-    } else {
-      // Not a recognized global flag — pass through as subcommand arg
-      remaining.push(arg);
-      if (consumedNext) remaining.push(value);
-      if (consumedNext) i += 1;
-    }
-  }
-  return { opts, remaining };
-}
-
-function clientFromOpts(opts) {
-  const tokenCache = opts.no_token_cache ? null : (process.env.PINGCODE_TOKEN_CACHE || core.DEFAULT_TOKEN_CACHE);
-  const workspaceCache = opts.no_workspace_cache ? null : opts.workspace_cache;
-  return new core.PingCodeClient({
-    base_url: opts.base_url,
-    client_id: opts.client_id,
-    client_secret: opts.client_secret,
-    token: opts.token,
-    token_cache: tokenCache,
-    workspace_cache: workspaceCache,
-    grant_type: opts.grant_type,
-  });
-}
+// Combined set used by sub-parsers to skip globally consumed flags
+const ALL_BOOLEAN_FLAGS = new Set([
+  ...shared.BASE_GLOBAL_BOOLEAN_FLAGS,
+  ...EXTRA_BOOLEAN_FLAGS,
+]);
 
 // ── Cache lookup helpers ──────────────────────────────────────────────
 
@@ -234,7 +146,7 @@ function parseListArgs(tokens) {
         } else {
           throw new core.PingCodeError(`Unknown option: ${flag}`);
         }
-      } else if (!(arg in GLOBAL_BOOLEAN_FLAGS)) {
+      } else if (!ALL_BOOLEAN_FLAGS.has(arg)) {
         throw new core.PingCodeError(`Unknown option: ${arg}. Use workitem list --help for usage.`);
       }
     } else {
@@ -341,7 +253,7 @@ function parseCreateArgs(tokens) {
         } else {
           throw new core.PingCodeError(`Unknown option: ${flag}`);
         }
-      } else if (!(arg in GLOBAL_BOOLEAN_FLAGS)) {
+      } else if (!ALL_BOOLEAN_FLAGS.has(arg)) {
         throw new core.PingCodeError(`Unknown option: ${arg}. Use workitem create --help for usage.`);
       }
     } else {
@@ -441,61 +353,6 @@ async function runCreate(client, opts, args) {
   );
 }
 
-// ── Show subcommand ──────────────────────────────────────────────────
-
-function parseShowArgs(tokens) {
-  // First non-flag token is the id/identifier
-  let target = null;
-  for (let i = 0; i < tokens.length; i++) {
-    const arg = tokens[i];
-    if (!arg.startsWith('--')) {
-      if (target === null) {
-        target = arg;
-        continue;
-      }
-      throw new core.PingCodeError(`Unexpected argument: ${arg}. Use workitem show --help for usage.`);
-    }
-    // Consume flag+value for global options (already parsed)
-    if (GLOBAL_BOOLEAN_FLAGS.has(arg)) continue;
-    if (GLOBAL_STRING_FLAGS[arg]) {
-      i += 1;
-      continue;
-    }
-    // For --help (already handled in parseGlobalOptions)
-  }
-  if (!target) {
-    throw new core.PingCodeError('A work item id or identifier is required. Use workitem show --help for usage.');
-  }
-  return { target };
-}
-
-async function runShow(client, opts, args) {
-  const params = {};
-  // Detect if target is an identifier (uppercase letters + dash + number)
-  const isIdFormat = /^[A-Z]{3,6}-\d+$/.test(args.target);
-  if (isIdFormat) {
-    params.identifier = args.target;
-  } else {
-    params.id = args.target;
-  }
-
-  const result = await client.request(
-    'GET',
-    '/v1/project/work_items',
-    params,
-    null,
-    { dry_run: opts.dry_run, use_workspace_cache: true },
-  );
-
-  if (opts.dry_run) return result;
-
-  // For real results, compact if requested, otherwise return first match
-  if (opts.compact) {
-    return core.compactResponse(result);
-  }
-  return result;
-}
-
 // ── Get subcommand ───────────────────────────────────────────────────
 
 function parseGetArgs(tokens) {
@@ -509,8 +366,8 @@ function parseGetArgs(tokens) {
       }
       throw new core.PingCodeError(`Unexpected argument: ${arg}. Use workitem get --help for usage.`);
     }
-    if (GLOBAL_BOOLEAN_FLAGS.has(arg)) continue;
-    if (GLOBAL_STRING_FLAGS[arg]) {
+    if (ALL_BOOLEAN_FLAGS.has(arg)) continue;
+    if (shared.BASE_GLOBAL_STRING_FLAGS[arg]) {
       i += 1;
       continue;
     }
@@ -521,6 +378,12 @@ function parseGetArgs(tokens) {
   return { work_item_id: workItemId };
 }
 
+function isIdentifier(arg) {
+  // PingCode identifiers look like: PROJECT_KEY-NUMBER (e.g., SCR-1, TASK-42)
+  // Project keys are typically 3-6 uppercase letters.
+  return /^[A-Z]{3,6}-\d+$/.test(arg);
+}
+
 async function runGet(client, opts, args) {
   if (isIdentifier(args.work_item_id)) {
     const resolutionParams = { identifier: args.work_item_id };
@@ -642,11 +505,11 @@ function parseUpdateArgs(tokens) {
         if (flag in stringFlags) {
           args[stringFlags[flag]] = value;
         } else {
-          if (!(flag in GLOBAL_BOOLEAN_FLAGS) && !(flag in GLOBAL_STRING_FLAGS)) {
+          if (!ALL_BOOLEAN_FLAGS.has(flag) && !(flag in shared.BASE_GLOBAL_STRING_FLAGS)) {
             throw new core.PingCodeError(`Unknown option: ${flag}`);
           }
         }
-      } else if (!(arg in GLOBAL_BOOLEAN_FLAGS)) {
+      } else if (!ALL_BOOLEAN_FLAGS.has(arg)) {
         throw new core.PingCodeError(`Unknown option: ${arg}. Use workitem update --help for usage.`);
       }
     }
@@ -666,12 +529,6 @@ function parseUpdateArgs(tokens) {
   return args;
 }
 
-function isIdentifier(arg) {
-  // PingCode identifiers look like: PROJECT_KEY-NUMBER (e.g., SCR-1, TASK-42)
-  // Project keys are typically 3-6 uppercase letters.
-  return /^[A-Z]{3,6}-\d+$/.test(arg);
-}
-
 function parseNumber(value, label) {
   const parsed = Number(value);
   if (Number.isNaN(parsed)) {
@@ -831,8 +688,6 @@ function printHelp() {
     '    --description TEXT        Description text',
     '    --parent <id|identifier>  Parent work item',
     '',
-    '  show <id|identifier>        Show a single work item',
-    '',
     '  get <id|identifier>         Get a single work item by id or identifier',
     '',
     '  update <id|identifier>      Update a work item',
@@ -913,18 +768,13 @@ function printSubcommandHelp(subcommand) {
         '  --parent <id|identifier>  Parent work item',
       ].join('\n'));
       break;
-    case 'show':
-      console.log([
-        'Usage: pingcode workitem show <id|identifier>',
-        '',
-        'Show a single work item by id or identifier.',
-      ].join('\n'));
-      break;
     case 'get':
       console.log([
         'Usage: pingcode workitem get <id|identifier>',
         '',
         'Get a single work item by id or identifier.',
+        '',
+        'Identifiers (e.g. SCR-123) are resolved to an id, then the single item is fetched.',
       ].join('\n'));
       break;
     case 'update':
@@ -979,10 +829,10 @@ async function run(argv) {
     return;
   }
 
-  // Parse global options from remaining tokens
-  const { opts, remaining: subArgs } = parseGlobalOptions(remaining);
+  // Parse global options from remaining tokens, passing workitem-specific boolean flags
+  const { opts, remaining: subArgs } = shared.parseGlobalOptions(remaining, EXTRA_BOOLEAN_FLAGS);
 
-  const client = clientFromOpts(opts);
+  const client = shared.clientFromOpts(opts);
 
   try {
     let result;
@@ -997,11 +847,6 @@ async function run(argv) {
         result = await runCreate(client, opts, args);
         break;
       }
-      case 'show': {
-        const args = parseShowArgs(subArgs);
-        result = await runShow(client, opts, args);
-        break;
-      }
       case 'get': {
         const args = parseGetArgs(subArgs);
         result = await runGet(client, opts, args);

package/scripts/core.js

@@ -1185,6 +1185,22 @@ function pathIsListWorkItems(rawPath, baseUrl = DEFAULT_BASE_URL) {
   return normalizePath(rawPath, baseUrl) === '/v1/project/work_items';
 }
 
+async function resolveWorkItemIdentifier(client, identifier) {
+  const params = { identifier };
+  const response = await client.request(
+    'GET',
+    '/v1/project/work_items',
+    params,
+    null,
+    { dry_run: false, use_workspace_cache: true },
+  );
+  const values = pageValues(response);
+  if (values.length === 0) {
+    throw new PingCodeError(`No work item found with identifier ${identifier}`);
+  }
+  return values[0].id;
+}
+
 function printJson(data) {
   const sorted = sortKeys(data);
   console.log(JSON.stringify(sorted, null, 2));
@@ -1368,5 +1384,6 @@ module.exports = {
   applyDefaultWorkItemFilters,
   ensureWorkItemWorkspaceContext,
   applyDefaultWorkItemCreateBody,
+  resolveWorkItemIdentifier,
   printJson,
 };

package/scripts/pingcode.js

@@ -13,7 +13,10 @@ module.exports = { ...core };
 // Import command modules so they self-register with the shared registry.
 // (Side-effect imports; no circular dependency because these import from
 // ./shared and ../core, never from ../pingcode.)
+require('./commands/comment');
 require('./commands/context');
+require('./commands/idea');
+require('./commands/product');
 require('./commands/workitem');
 require('./commands/auth');