logwork-cli 1.1.1 → 1.3.0

package/lib/manual-mcp.mjs

@@ -1,4 +1,5 @@
 import { join } from 'node:path';
+import { mcpArgs, resolveLaunchCommand } from './launcher.mjs';
 import { helperHome } from './paths.mjs';
 
 export const MCP_CLIENTS = [
@@ -39,15 +40,48 @@ export const MCP_CLIENTS = [
   }
 ];
 
-// IDE configs run `node <runtime>/bin/logwork.mjs mcp`. An absolute node entry
-// path is used instead of the `logwork` command because GUI IDEs often start
-// without the npm global bin directory on PATH.
+// IDE configs run the launch command from lib/launcher.mjs: on macOS/Linux
+// the generated <home>/bin/logwork-launch script (it finds a usable Node 22+
+// at start time), on Windows a stable node.exe plus <home>\bin\logwork.mjs.
+// Both are absolute because GUI IDEs (Cursor, VS Code started from the Dock or
+// Finder) often start without the npm global bin directory or nvm's node on
+// PATH, so neither `logwork` nor a bare `node` would be found.
 export const MCP_SERVER_NAME = 'logwork';
 
+// Only printed when the command is a raw Node path that an upgrade can remove.
+export const MCP_NODE_PATH_NOTE = 'The config uses the absolute path of the Node that ran this command. If Node is upgraded or moved (nvm, Homebrew, a new installer), re-run `logwork setup` (it updates the config for you).';
+
+export const MCP_LAUNCHER_NOTE = 'The command is the logwork launcher; it finds Node 22+ itself, so Node upgrades need no config change.';
+
+const INSTALL_CLIENT_KEYS = {
+  cursor: 'cursor',
+  antigravity: 'antigravity',
+  copilot: 'vscode',
+  'claude-code': 'claude',
+  codex: 'codex'
+};
+
 export function defaultMcpServerPath() {
   return join(helperHome(), 'bin', 'logwork.mjs');
 }
 
+// Accepts a launch command ({ command, argsPrefix }) or, for older callers, an
+// entry path plus { nodePath }: a raw `<node> <entry>` command.
+export function toLaunchCommand(launchOrServerPath, { nodePath } = {}) {
+  if (launchOrServerPath && typeof launchOrServerPath === 'object') {
+    return launchOrServerPath;
+  }
+  if (launchOrServerPath === undefined && nodePath === undefined) {
+    return resolveLaunchCommand();
+  }
+  return {
+    command: nodePath || process.execPath,
+    argsPrefix: [launchOrServerPath || defaultMcpServerPath()],
+    kind: 'node',
+    stable: false
+  };
+}
+
 export function resolveMcpClient(value) {
   const normalized = normalizeMcpClientValue(value);
   if (!normalized) {
@@ -82,17 +116,22 @@ export function formatMcpClientOptions(clients = MCP_CLIENTS) {
 
 export function formatMcpSetup({
   client,
-  serverPath = defaultMcpServerPath(),
+  launch,
+  serverPath,
+  nodePath,
   platform = process.platform
 } = {}) {
   const resolvedClient = typeof client === 'object' ? client : resolveMcpClient(client);
   if (!resolvedClient) {
     throw new Error('Unknown MCP client. Use: cursor, antigravity, copilot, claude-code, or codex.');
   }
+  const command = launch || (serverPath === undefined && nodePath === undefined
+    ? resolveLaunchCommand({ platform })
+    : toLaunchCommand(serverPath, { nodePath }));
 
   const lines = [
     `MCP setup: ${resolvedClient.label}`,
-    `Entry path: ${serverPath} (run with the "mcp" argument)`,
+    `Command: ${[command.command, ...mcpArgs(command)].join(' ')}`,
     ''
   ];
 
@@ -100,34 +139,38 @@ export function formatMcpSetup({
     lines.push(
       `Copy this TOML into ${resolvedClient.target}:`,
       '',
-      formatCodexToml(serverPath)
+      formatCodexToml(command)
     );
   } else if (resolvedClient.key === 'copilot') {
     lines.push(
       `Copy this JSON into ${resolvedClient.target}:`,
       '',
-      JSON.stringify(vscodeMcpConfig(serverPath), null, 2)
+      JSON.stringify(vscodeMcpConfig(command), null, 2)
     );
   } else if (resolvedClient.key === 'claude-code') {
     lines.push(
       'Recommended command:',
       '',
-      `claude mcp add --transport stdio ${MCP_SERVER_NAME} -- node ${quoteShellArg(serverPath, { platform })} mcp`,
+      formatClaudeMcpAddCommand(command, { platform }),
       '',
       'Or copy this JSON into project .mcp.json:',
       '',
-      JSON.stringify(stdioMcpServersConfig(serverPath), null, 2)
+      JSON.stringify(stdioMcpServersConfig(command), null, 2)
     );
   } else {
     lines.push(
       `Copy this JSON into ${resolvedClient.target}:`,
       '',
-      JSON.stringify(stdioMcpServersConfig(serverPath), null, 2)
+      JSON.stringify(stdioMcpServersConfig(command), null, 2)
     );
   }
 
+  const installKey = INSTALL_CLIENT_KEYS[resolvedClient.key];
+  const note = command.stable ? (command.kind === 'launcher' ? MCP_LAUNCHER_NOTE : '') : MCP_NODE_PATH_NOTE;
   lines.push(
     '',
+    ...(note ? [note] : []),
+    ...(installKey ? [`To let logwork write it for you instead, run: logwork mcp install --client ${installKey}`] : []),
     'After saving, restart or reload the MCP client.',
     'Do not paste passwords, 2FA codes, Bearer tokens, cookies, or raw auth logs into AI chat.'
   );
@@ -142,41 +185,56 @@ function normalizeMcpClientValue(value) {
     .replace(/[\s_]+/g, '-');
 }
 
-export function stdioMcpServersConfig(serverPath) {
+export function stdioMcpServersConfig(launchOrServerPath, options = {}) {
+  const launch = toLaunchCommand(launchOrServerPath, options);
   return {
     mcpServers: {
       [MCP_SERVER_NAME]: {
-        command: 'node',
-        args: [serverPath, 'mcp']
+        command: launch.command,
+        args: mcpArgs(launch)
       }
     }
   };
 }
 
-export function vscodeMcpConfig(serverPath) {
+export function vscodeMcpConfig(launchOrServerPath, options = {}) {
+  const launch = toLaunchCommand(launchOrServerPath, options);
   return {
     servers: {
       [MCP_SERVER_NAME]: {
         type: 'stdio',
-        command: 'node',
-        args: [serverPath, 'mcp']
+        command: launch.command,
+        args: mcpArgs(launch)
       }
     }
   };
 }
 
-export function formatCodexToml(serverPath) {
+export function formatCodexToml(launchOrServerPath, options = {}) {
+  const launch = toLaunchCommand(launchOrServerPath, options);
   return [
     `[mcp_servers.${MCP_SERVER_NAME}]`,
-    'command = "node"',
-    `args = ["${escapeTomlString(serverPath)}", "mcp"]`,
+    `command = "${escapeTomlString(launch.command)}"`,
+    `args = [${mcpArgs(launch).map((arg) => `"${escapeTomlString(arg)}"`).join(', ')}]`,
     'startup_timeout_sec = 20',
     'tool_timeout_sec = 120'
   ].join('\n');
 }
 
+// User scope, so the server is available in every project.
+export function formatClaudeMcpAddCommand(launchOrServerPath, { platform = process.platform, ...options } = {}) {
+  const launch = toLaunchCommand(launchOrServerPath, options);
+  return `claude mcp add --transport stdio --scope user ${MCP_SERVER_NAME} -- ${[launch.command, ...mcpArgs(launch)].map((arg) => (arg === 'mcp' ? arg : quoteShellArg(arg, { platform }))).join(' ')}`;
+}
+
+// TOML basic string: escape backslashes (Windows paths), quotes and control
+// characters.
 function escapeTomlString(value) {
-  return String(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+  return String(value)
+    .replace(/\\/g, '\\\\')
+    .replace(/"/g, '\\"')
+    // eslint-disable-next-line no-control-regex -- TOML needs control characters escaped.
+    .replace(/[\u0000-\u001f\u007f]/g, (char) => `\\u${char.charCodeAt(0).toString(16).padStart(4, '0')}`);
 }
 
 function quoteShellArg(value, { platform = process.platform } = {}) {

package/lib/manual-repl.mjs

@@ -1,5 +1,6 @@
 import { stdin as defaultInput, stdout as defaultOutput } from 'node:process';
-import { confirm, isCancel } from '@clack/prompts';
+import { resolve as resolvePath } from 'node:path';
+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';
@@ -30,8 +31,10 @@ import {
 import { findManualCommand, formatManualHelp } from './manual-commands.mjs';
 import {
   buildManualApplyConfirmation,
+  buildManualDuplicateConfirmation,
   buildManualUnbookedConfirmation,
   getManualApplyBlocker,
+  manualDuplicateEntryCount,
   manualUnbookedEntryCount
 } from './manual-apply-state.mjs';
 import { runManualInkApp } from './manual-ink-app.mjs';
@@ -46,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 {
@@ -363,21 +369,7 @@ export async function executeManualCommand(command, session, context) {
   }
 
   if (command.type === 'map') {
-    const ok = await prompts.confirm(`Map ${command.tickets.join(', ')} 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: [],
-      scope: 'user',
-      confirm: true,
-      cwd
-    }), { workflows, print });
-    print(result.summary);
+    await executeMapCommand(command, { cwd, workflows, prompts, print });
     return { exit: false };
   }
 
@@ -498,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.');
@@ -666,10 +763,20 @@ async function applyManualRoPreview({
     }
   }
 
+  let allowDuplicates = false;
+  if (manualDuplicateEntryCount(preview)) {
+    allowDuplicates = await prompts.confirm(buildManualDuplicateConfirmation(preview), false);
+    if (!allowDuplicates) {
+      print('Resource Optimiser apply cancelled because possible duplicates were not approved. Nothing was written.');
+      return false;
+    }
+  }
+
   const result = await runWithInlineAuth(() => workflows.applyLogworkBatch({
     batch: preview,
     confirm: true,
     allowUnbooked,
+    allowDuplicates,
     cwd,
     ledgerContext: { flowTarget }
   }), { workflows, print });
@@ -871,28 +978,69 @@ function parseTargetCommand(type, parts, {
   };
 }
 
+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.length < 2) {
-    throw new Error('Usage: /map <TICKET_PREFIX[,PREFIX...]> <projectMemberId>');
+  if (parts[0] === '--repo') {
+    const { repo, project } = splitRepoAndProject(parts.slice(1));
+    return {
+      type: 'map',
+      tickets: [],
+      repos: [repo],
+      ...mapProjectFields(project)
+    };
+  }
+
+  if (!parts.length || parts[0].startsWith('-')) {
+    throw new Error(MAP_USAGE);
   }
 
   const tickets = parts[0]
     .split(',')
     .map((ticket) => ticket.trim().toUpperCase())
     .filter(Boolean);
-  const projectMemberId = parts[1];
 
-  if (!tickets.length || !projectMemberId) {
-    throw new Error('Usage: /map <TICKET_PREFIX[,PREFIX...]> <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);
@@ -1028,6 +1176,7 @@ function defaultWorkflows() {
     applyJiraWorklogBatch,
     listLogworkProjects,
     upsertProjectMapping,
+    suggestProjectsForRepo,
     loginResourceOptimiser,
     getStoredAuthStatus,
     getStoredJiraStatus,