logwork-cli 1.2.0 → 1.3.0

package/lib/manual-repl.mjs

@@ -1,6 +1,6 @@
 import { stdin as defaultInput, stdout as defaultOutput } from 'node:process';
 import { resolve as resolvePath } from 'node:path';
-import { confirm, isCancel } from '@clack/prompts';
+import { confirm, isCancel, select } from '@clack/prompts';
 import { getStoredAuthStatus, loginResourceOptimiser } from './auth.mjs';
 import { queryApplyLedger } from './apply-ledger.mjs';
 import { isAuthRequiredError } from './auth-errors.mjs';
@@ -49,8 +49,11 @@ import {
 import {
   enrichRoPreviewWithJiraProjects,
   listLogworkProjects,
+  resolveProjectSelection,
   upsertProjectMapping
 } from './project-mapping-workflow.mjs';
+import { suggestProjectsForRepo } from './commit-workflow.mjs';
+import { repoProjectFromOption, repoProjectSelectOptions } from './ui.mjs';
 import { queryLogwork } from './query-workflow.mjs';
 import { parseRoEditArgs } from './ro-edit-args.mjs';
 import {
@@ -366,26 +369,7 @@ export async function executeManualCommand(command, session, context) {
   }
 
   if (command.type === 'map') {
-    const subject = [
-      ...command.tickets,
-      ...(command.repos || []).map((repo) => `repo ${resolvePath(cwd, repo)}`)
-    ].join(', ');
-    const ok = await prompts.confirm(`Map ${subject} to projectMemberId ${command.projectMemberId}?`);
-    if (!ok) {
-      print('Mapping cancelled.');
-      return { exit: false };
-    }
-
-    const result = await runWithInlineAuth(() => workflows.upsertProjectMapping({
-      projectMemberId: command.projectMemberId,
-      tickets: command.tickets,
-      keywords: [],
-      ...(command.repos?.length ? { repos: command.repos } : {}),
-      scope: 'user',
-      confirm: true,
-      cwd
-    }), { workflows, print });
-    print(result.summary);
+    await executeMapCommand(command, { cwd, workflows, prompts, print });
     return { exit: false };
   }
 
@@ -506,10 +490,115 @@ export function createManualPrompts() {
         throw new Error('Cancelled.');
       }
       return Boolean(answer);
+    },
+    // { message, options: [{ value, label, hint }], initialValue } -> value,
+    // or null when cancelled.
+    async select({ message, options, initialValue }) {
+      const answer = await select({ message, options, initialValue });
+      return isCancel(answer) ? null : answer;
     }
   };
 }
 
+// /map with a project member id saves it as before. Otherwise the project is
+// chosen by name (case-insensitive, then a unique substring) or, with no name
+// or an ambiguous one, from a picker of member projects; for a repo the
+// picker lists the suggested projects first.
+async function executeMapCommand(command, { cwd, workflows, prompts, print }) {
+  const subject = [
+    ...command.tickets,
+    ...(command.repos || []).map((repo) => `repo ${resolvePath(cwd, repo)}`)
+  ].join(', ');
+  const save = (project) => runWithInlineAuth(() => workflows.upsertProjectMapping({
+    projectMemberId: project.projectMemberId,
+    ...(project.projectMemberId === undefined ? { projectName: project.projectName } : {}),
+    tickets: command.tickets,
+    keywords: [],
+    ...(command.repos?.length ? { repos: command.repos } : {}),
+    scope: 'user',
+    confirm: true,
+    cwd
+  }), { workflows, print });
+
+  if (command.projectMemberId !== undefined) {
+    const ok = await prompts.confirm(`Map ${subject} to projectMemberId ${command.projectMemberId}?`);
+    if (!ok) {
+      print('Mapping cancelled.');
+      return;
+    }
+    print((await save({ projectMemberId: command.projectMemberId })).summary);
+    return;
+  }
+
+  const { projects = [] } = await runWithInlineAuth(() => workflows.listLogworkProjects({ cwd }), { workflows, print });
+  if (!projects.length) {
+    throw new Error('No Resource Optimiser project memberships found to map to.');
+  }
+
+  let project = null;
+  let pickerProjects = projects;
+  let pickerNote = '';
+  if (command.projectQuery) {
+    const resolution = resolveProjectSelection(projects, { projectName: command.projectQuery });
+    project = resolution.project || null;
+    if (!project) {
+      pickerNote = `${resolution.reason}.`;
+      pickerProjects = resolution.candidates?.length ? resolution.candidates : projects;
+    }
+  }
+
+  if (project) {
+    const ok = await prompts.confirm(`Map ${subject} to ${project.projectName}?`);
+    if (!ok) {
+      print('Mapping cancelled.');
+      return;
+    }
+  } else {
+    let suggestions = [];
+    if (command.repos?.length && !command.projectQuery) {
+      const suggested = await runWithInlineAuth(() => workflows.suggestProjectsForRepo({
+        repo: command.repos[0],
+        projects,
+        cwd
+      }), { workflows, print }).catch((error) => {
+        if (isAuthRequiredError(error)) {
+          throw error;
+        }
+        pickerNote = `No suggestions: ${error.message}`;
+        return null;
+      });
+      suggestions = suggested?.suggestions || [];
+    }
+    if (pickerNote) {
+      print(pickerNote);
+    }
+    project = await pickMapProject({ subject, suggestions, projects: pickerProjects, prompts, print });
+    if (!project) {
+      print('Mapping cancelled.');
+      return;
+    }
+  }
+
+  print((await save(project)).summary);
+}
+
+async function pickMapProject({ subject, suggestions, projects, prompts, print }) {
+  const { items, options, initialValue } = repoProjectSelectOptions(suggestions, projects, { skipLabel: 'Cancel' });
+  if (typeof prompts.select === 'function') {
+    return repoProjectFromOption(items, await prompts.select({
+      message: `Which RO project should ${subject} map to?`,
+      options,
+      initialValue
+    }));
+  }
+  // Without a picker, list the projects; the user re-runs /map with a name.
+  print([
+    `Which RO project should ${subject} map to? Re-run /map with the project name:`,
+    ...items.map((item, index) => `  ${index + 1}. ${item.project.projectName}${item.suggestion ? `  (${item.suggestion.reasons.join('; ')})` : ''}`)
+  ].join('\n'));
+  return null;
+}
+
 async function readPasteBlock({ readLine, print, target = RO_TARGET }) {
   if (typeof readLine !== 'function') {
     throw new Error('/logwork requires an interactive terminal.');
@@ -889,26 +978,21 @@ function parseTargetCommand(type, parts, {
   };
 }
 
-const MAP_USAGE = 'Usage: /map <TICKET_PREFIX[,PREFIX...]> <projectMemberId> | /map --repo [path] <projectMemberId>';
+const MAP_USAGE = 'Usage: /map <TICKET_PREFIX[,PREFIX...]> [project name or id] | /map --repo [path] [project name or id]';
+const PATH_LIKE = /^(?:\.{1,2}(?:[\\/]|$)|[\\/]|~(?:[\\/]|$)|[A-Za-z]:[\\/])/;
 
 function parseMapCommand(parts) {
   if (parts[0] === '--repo') {
-    // The repo path defaults to the current folder; a path with spaces may be
-    // quoted.
-    const projectMemberId = parts.length > 1 ? parts[parts.length - 1] : '';
-    const repo = parts.slice(1, -1).join(' ').replace(/^(["'])(.*)\1$/, '$2').trim() || '.';
-    if (!projectMemberId || projectMemberId.startsWith('-')) {
-      throw new Error(MAP_USAGE);
-    }
+    const { repo, project } = splitRepoAndProject(parts.slice(1));
     return {
       type: 'map',
       tickets: [],
       repos: [repo],
-      projectMemberId
+      ...mapProjectFields(project)
     };
   }
 
-  if (parts.length < 2) {
+  if (!parts.length || parts[0].startsWith('-')) {
     throw new Error(MAP_USAGE);
   }
 
@@ -916,19 +1000,47 @@ function parseMapCommand(parts) {
     .split(',')
     .map((ticket) => ticket.trim().toUpperCase())
     .filter(Boolean);
-  const projectMemberId = parts[1];
 
-  if (!tickets.length || !projectMemberId) {
+  if (!tickets.length) {
     throw new Error(MAP_USAGE);
   }
 
   return {
     type: 'map',
     tickets,
-    projectMemberId
+    ...mapProjectFields(parts.slice(1).join(' ').trim())
   };
 }
 
+// "/map --repo [path] [project]": the path defaults to the current folder. A
+// path starts with ".", "/", "~" or a drive letter, or is quoted (for spaces);
+// anything else is the project. The old form "<path> <projectMemberId>" still
+// reads any path.
+function splitRepoAndProject(tokens) {
+  const rest = tokens.join(' ').trim();
+  const quoted = /^(["'])(.*?)\1(?:\s+(.*))?$/.exec(rest);
+  if (quoted) {
+    return { repo: quoted[2].trim() || '.', project: (quoted[3] || '').trim() };
+  }
+  if (tokens.length >= 2 && /^\d+$/.test(tokens.at(-1))) {
+    return { repo: tokens.slice(0, -1).join(' '), project: tokens.at(-1) };
+  }
+  if (tokens.length && PATH_LIKE.test(tokens[0])) {
+    return { repo: tokens[0], project: tokens.slice(1).join(' ').trim() };
+  }
+  return { repo: '.', project: rest };
+}
+
+function mapProjectFields(project) {
+  if (!project) {
+    return {};
+  }
+  if (project.startsWith('-')) {
+    throw new Error(MAP_USAGE);
+  }
+  return /^\d+$/.test(project) ? { projectMemberId: project } : { projectQuery: project };
+}
+
 export function formatProjects(result, weekly = null, projectFilter = undefined) {
   const lines = [result.summary];
   const projects = filterProjects(result.projects || [], projectFilter);
@@ -1064,6 +1176,7 @@ function defaultWorkflows() {
     applyJiraWorklogBatch,
     listLogworkProjects,
     upsertProjectMapping,
+    suggestProjectsForRepo,
     loginResourceOptimiser,
     getStoredAuthStatus,
     getStoredJiraStatus,