logwork-cli 1.1.1 → 1.3.0

package/lib/jira-api.mjs

@@ -1,4 +1,4 @@
-import { CONFIG } from './config.mjs';
+import { CONFIG, isDryRun } from './config.mjs';
 import { ApiError } from './api.mjs';
 import { fetchWithPolicy, redactedExcerpt } from './http.mjs';
 import { safeJsonParse } from './util.mjs';
@@ -15,6 +15,11 @@ export async function jiraApiFetch(token, path, {
 } = {}) {
   assertJiraToken(token);
   const url = buildJiraUrl(baseUrl, path);
+  // Every Jira write goes through here, so this one gate covers worklog create
+  // and any write added later. The result never carries the token or headers.
+  if (!isIdempotentMethod(method) && isDryRun()) {
+    return createJiraDryRunRequest(method, path, body);
+  }
   const response = await fetchWithPolicy(url.toString(), {
     fetchImpl,
     timeoutMs,
@@ -123,12 +128,29 @@ export async function addJiraIssueWorklog(token, issueKey, worklog, options = {}
   assertIssueKey(issueKey);
   const qs = new URLSearchParams({ adjustEstimate: 'leave' });
   const path = `/rest/api/2/issue/${encodeURIComponent(issueKey)}/worklog?${qs}`;
-  return normalizeJiraWorklog(await jiraApiFetch(token, path, {
+  const data = await jiraApiFetch(token, path, {
     ...options,
     method: 'POST',
     retries: 0,
     body: worklog
-  }));
+  });
+  return isJiraDryRunResult(data) ? data : normalizeJiraWorklog(data);
+}
+
+export function isJiraDryRunResult(value) {
+  return value?.dryRun === true;
+}
+
+function createJiraDryRunRequest(method, path, body) {
+  const request = {
+    dryRun: true,
+    method: String(method).toUpperCase(),
+    path: String(path)
+  };
+  if (body !== undefined) {
+    request.body = structuredClone(body);
+  }
+  return request;
 }
 
 export function normalizeJiraIssue(issue = {}) {

package/lib/jira-workflow.mjs

@@ -2,11 +2,12 @@ import { createHash } from 'node:crypto';
 import { CONFIG } from './config.mjs';
 import { recordApplyResult, recordApplyResultSafely } from './apply-ledger.mjs';
 import { parseWeeklyLogText } from './batch-parser.mjs';
-import { ApiError } from './api.mjs';
+import { ApiError } from './ro-api-http.mjs';
 import {
   addJiraIssueWorklog,
   getJiraIssue,
-  getJiraIssueWorklogs
+  getJiraIssueWorklogs,
+  isJiraDryRunResult
 } from './jira-api.mjs';
 import {
   createJiraAuthRequiredError,
@@ -148,6 +149,25 @@ export async function applyJiraWorklogBatch({
     const payload = entry.worklog || buildJiraWorklogPayload(entry);
     try {
       const worklog = await submitter(entry.issueKey, payload);
+      if (isJiraDryRunResult(worklog)) {
+        // LOGWORK_DRY_RUN=1: Jira was not called. Keep only the request so the
+        // caller can see what apply would send.
+        results.push({
+          entryId: entry.id,
+          issueKey: entry.issueKey,
+          date: entry.date,
+          hours: entry.hours,
+          taskName: entry.taskName,
+          status: 'dry_run',
+          dryRun: true,
+          request: {
+            method: worklog.method,
+            path: worklog.path,
+            body: worklog.body
+          }
+        });
+        continue;
+      }
       results.push({
         entryId: entry.id,
         issueKey: entry.issueKey,
@@ -173,9 +193,13 @@ export async function applyJiraWorklogBatch({
   }
 
   const failed = results.some((result) => result.status === 'failed');
+  const dryRun = results.some((result) => result.dryRun);
   const output = {
     batchId: batch.batchId,
-    status: failed ? (results.some((result) => result.status === 'submitted') ? 'partial_failed' : 'failed') : 'submitted',
+    status: failed
+      ? (results.some((result) => result.status === 'submitted') ? 'partial_failed' : 'failed')
+      : (dryRun ? 'dry_run' : 'submitted'),
+    dryRun,
     results,
     summary: formatJiraApplySummary(results)
   };
@@ -395,9 +419,15 @@ function formatJiraApplyBlockedSummary(blockedEntries) {
 function formatJiraApplySummary(results) {
   const submitted = results.filter((result) => result.status === 'submitted');
   const failed = results.filter((result) => result.status === 'failed');
-  const lines = [
-    `Jira worklog apply: submitted ${submitted.length}, failed ${failed.length}.`
-  ];
+  const dryRun = results.filter((result) => result.dryRun);
+  const lines = dryRun.length
+    ? [
+      'DRY RUN (LOGWORK_DRY_RUN=1): Jira worklog requests generated; nothing was written to Jira.',
+      `Jira worklog dry run: ${dryRun.length} request${dryRun.length === 1 ? '' : 's'}, submitted ${submitted.length}, failed ${failed.length}.`
+    ]
+    : [
+      `Jira worklog apply: submitted ${submitted.length}, failed ${failed.length}.`
+    ];
   for (const result of results) {
     lines.push(`- ${result.date}: ${result.issueKey} +${formatHours(result.hours)}h -> ${result.status}${result.error ? ` (${result.error})` : ''}`);
   }

package/lib/launcher.mjs

@@ -0,0 +1,303 @@
+import { spawn } from 'node:child_process';
+import { constants as fsConstants, promises as fs } from 'node:fs';
+import { posix, win32 } from 'node:path';
+import { atomicWriteFile } from './atomic-file.mjs';
+import { helperHome } from './paths.mjs';
+
+// IDE MCP configs and the reminder schedule must keep working after nvm,
+// Homebrew or a Node installer upgrade, without the user editing anything.
+//
+// - macOS/Linux: `logwork setup` writes <home>/bin/logwork-launch, a POSIX sh
+//   script that finds a usable Node 22+ at start time and runs
+//   <home>/bin/logwork.mjs with it. Configs point at the script, which never
+//   moves.
+// - Windows: GUI clients would need `cmd /c` for a .cmd launcher, so configs
+//   use a stable node.exe instead: the nvm-windows symlink when Node runs from
+//   an nvm-windows version folder, otherwise the running node.exe (usually
+//   C:\Program Files\nodejs\node.exe, which an installer upgrade keeps).
+
+export const LAUNCHER_FILE_NAME = 'logwork-launch';
+export const MIN_NODE_MAJOR = 22;
+// Makes the launcher print the Node it would use and exit, without starting
+// logwork. Used by `logwork doctor`.
+export const LAUNCHER_PRINT_NODE_ENV = 'LOGWORK_LAUNCHER_PRINT_NODE';
+const ENTRY_RELATIVE = ['bin', 'logwork.mjs'];
+
+export function launcherPath(home = helperHome()) {
+  return posix.join(home, 'bin', LAUNCHER_FILE_NAME);
+}
+
+export function entryPath(home = helperHome(), platform = process.platform) {
+  return pathApi(platform).join(home, ...ENTRY_RELATIVE);
+}
+
+// The command every MCP config and the reminder schedule run. MCP args are
+// [...argsPrefix, 'mcp'].
+// stable: true when the command survives a Node upgrade without re-running
+// `logwork setup`.
+export function resolveLaunchCommand({
+  platform = process.platform,
+  home = helperHome(),
+  execPath = process.execPath,
+  env = process.env
+} = {}) {
+  if (platform !== 'win32') {
+    return {
+      command: launcherPath(home),
+      argsPrefix: [],
+      kind: 'launcher',
+      stable: true
+    };
+  }
+  const entry = win32.join(home, ...ENTRY_RELATIVE);
+  const symlink = String(readEnv(env, 'NVM_SYMLINK') || '').trim();
+  if (symlink && isNvmWindowsNode(execPath, env)) {
+    return {
+      command: win32.join(symlink, 'node.exe'),
+      argsPrefix: [entry],
+      kind: 'nvm-symlink',
+      stable: true
+    };
+  }
+  return {
+    command: String(execPath),
+    argsPrefix: [entry],
+    kind: 'node',
+    stable: isStandardWindowsInstall(execPath)
+  };
+}
+
+export function mcpArgs(launch) {
+  return [...(launch?.argsPrefix || []), 'mcp'];
+}
+
+// Node inside an nvm-windows version folder, e.g. C:\Users\me\AppData\Roaming\nvm\v22.11.0\node.exe.
+export function isNvmWindowsNode(execPath, env = process.env) {
+  const path = String(execPath || '').toLowerCase().replaceAll('/', '\\');
+  const nvmHome = String(readEnv(env, 'NVM_HOME') || '').toLowerCase().replaceAll('/', '\\').replace(/\\+$/, '');
+  if (nvmHome && path.startsWith(`${nvmHome}\\`)) {
+    return true;
+  }
+  return /\\nvm\\v\d+\.\d+\.\d+[^\\]*\\node\.exe$/.test(path);
+}
+
+// The official installer keeps node.exe at <Program Files>\nodejs\node.exe
+// across upgrades.
+export function isStandardWindowsInstall(execPath) {
+  return /\\nodejs\\node\.exe$/i.test(String(execPath || '').replaceAll('/', '\\'));
+}
+
+export function buildPosixLauncherScript({ home, nodePath }) {
+  const entry = posix.join(home, ...ENTRY_RELATIVE);
+  return `#!/bin/sh
+# Generated by \`logwork setup\`; it is rewritten on every setup, so do not edit.
+# Starts logwork with the first usable Node.js ${MIN_NODE_MAJOR}+, so IDE MCP configs and the
+# reminder keep working after nvm, Homebrew or installer upgrades.
+LOGWORK_ENTRY=${quoteSh(entry)}
+LOGWORK_RECORDED_NODE=${quoteSh(nodePath || '')}
+
+logwork_node_ok() {
+  [ -n "$1" ] && [ -f "$1" ] && [ -x "$1" ] || return 1
+  "$1" -e 'process.exit(+process.versions.node.split(".")[0]>=${MIN_NODE_MAJOR}?0:1)' >/dev/null 2>&1
+}
+
+logwork_run() {
+  logwork_node=$1
+  shift
+  if [ "\${${LAUNCHER_PRINT_NODE_ENV}:-}" = "1" ]; then
+    printf '%s\\n' "$logwork_node"
+    exit 0
+  fi
+  exec "$logwork_node" "$LOGWORK_ENTRY" "$@"
+}
+
+logwork_newest_nvm_node() {
+  logwork_best=''
+  logwork_best_key=0
+  for logwork_dir in "$@"; do
+    [ -n "$logwork_dir" ] && [ -d "$logwork_dir/versions/node" ] || continue
+    for logwork_candidate in "$logwork_dir"/versions/node/v*/bin/node; do
+      [ -x "$logwork_candidate" ] || continue
+      logwork_version=\${logwork_candidate%/bin/node}
+      logwork_version=\${logwork_version##*/v}
+      logwork_major=\${logwork_version%%.*}
+      logwork_rest=\${logwork_version#*.}
+      logwork_minor=\${logwork_rest%%.*}
+      logwork_patch=\${logwork_rest#*.}
+      logwork_patch=\${logwork_patch%%[!0-9]*}
+      case "$logwork_major.$logwork_minor.$logwork_patch" in
+        *[!0-9.]*|.*|*..*|*.) continue ;;
+      esac
+      [ "$logwork_major" -ge ${MIN_NODE_MAJOR} ] || continue
+      logwork_key=$((logwork_major * 1000000 + logwork_minor * 1000 + logwork_patch))
+      if [ "$logwork_key" -gt "$logwork_best_key" ]; then
+        logwork_best=$logwork_candidate
+        logwork_best_key=$logwork_key
+      fi
+    done
+  done
+  printf '%s' "$logwork_best"
+}
+
+# 1. The Node recorded by setup. Its path names its version, so an existing
+#    file is still that Node: skip the version check for a fast start.
+if [ -n "$LOGWORK_RECORDED_NODE" ] && [ -f "$LOGWORK_RECORDED_NODE" ] && [ -x "$LOGWORK_RECORDED_NODE" ]; then
+  logwork_run "$LOGWORK_RECORDED_NODE" "$@"
+fi
+
+# 2. node on PATH.
+logwork_candidate=$(command -v node 2>/dev/null || true)
+if logwork_node_ok "$logwork_candidate"; then
+  logwork_run "$logwork_candidate" "$@"
+fi
+
+# 3. The newest nvm Node ${MIN_NODE_MAJOR}+.
+logwork_candidate=$(logwork_newest_nvm_node "\${NVM_DIR:-}" "\${HOME:-}/.nvm")
+if logwork_node_ok "$logwork_candidate"; then
+  logwork_run "$logwork_candidate" "$@"
+fi
+
+# 4. Volta and fnm defaults, then 5. Homebrew and /usr/local.
+for logwork_candidate in \\
+  "\${HOME:-}/.volta/bin/node" \\
+  "\${HOME:-}/.local/share/fnm/aliases/default/bin/node" \\
+  "\${HOME:-}/Library/Application Support/fnm/aliases/default/bin/node" \\
+  /opt/homebrew/bin/node \\
+  /usr/local/bin/node
+do
+  if logwork_node_ok "$logwork_candidate"; then
+    logwork_run "$logwork_candidate" "$@"
+  fi
+done
+
+echo "logwork: no usable Node.js ${MIN_NODE_MAJOR}+ found. Install Node.js ${MIN_NODE_MAJOR} or newer, or run \\\`logwork setup\\\` again." >&2
+exit 127
+`;
+}
+
+// Writes the launcher on macOS/Linux. A no-op on Windows (returns null).
+export async function writeLauncher({
+  home = helperHome(),
+  nodePath = process.execPath,
+  platform = process.platform,
+  writeFile = atomicWriteFile,
+  chmod = fs.chmod
+} = {}) {
+  if (platform === 'win32') {
+    return null;
+  }
+  const path = launcherPath(home);
+  await writeFile(path, buildPosixLauncherScript({ home, nodePath }), { mode: 0o755 });
+  // atomicWriteFile applies the mode through the umask; make it explicit.
+  await chmod(path, 0o755);
+  return { path, nodePath };
+}
+
+// Checks the command MCP configs and the reminder run. Read-only: it runs the
+// command with `--version` (which prints the logwork version through
+// bin/logwork.mjs) and, for the launcher, asks which Node it would pick.
+export async function checkLaunchCommand(launch = resolveLaunchCommand(), {
+  platform = process.platform,
+  access = fs.access,
+  run = runProcess,
+  env = process.env
+} = {}) {
+  const result = {
+    command: launch.command,
+    kind: launch.kind,
+    status: 'ok',
+    node: launch.kind === 'launcher' ? '' : launch.command,
+    version: ''
+  };
+  try {
+    await access(launch.command, fsConstants.F_OK);
+  } catch {
+    return { ...result, status: 'missing' };
+  }
+  if (platform !== 'win32') {
+    try {
+      await access(launch.command, fsConstants.X_OK);
+    } catch {
+      return { ...result, status: 'not_executable' };
+    }
+  }
+  const childEnv = withoutLogworkEnv(env);
+  if (launch.kind === 'launcher') {
+    const picked = await run(launch.command, [], { env: { ...childEnv, [LAUNCHER_PRINT_NODE_ENV]: '1' } }).catch((error) => ({ code: 1, stdout: '', stderr: error.message }));
+    if (picked.code !== 0) {
+      return { ...result, status: 'no_node', detail: firstLine(picked.stderr || picked.stdout) };
+    }
+    result.node = firstLine(picked.stdout);
+  }
+  const version = await run(launch.command, [...launch.argsPrefix, '--version'], { env: childEnv }).catch((error) => ({ code: 1, stdout: '', stderr: error.message }));
+  if (version.code !== 0) {
+    return { ...result, status: 'failed', detail: firstLine(version.stderr || version.stdout) };
+  }
+  result.version = firstLine(version.stdout);
+  return result;
+}
+
+export function formatLaunchCheckIssue(check) {
+  switch (check?.status) {
+    case 'missing':
+      return check.kind === 'launcher'
+        ? `Launcher: ${check.command} is missing, so IDE MCP configs and the reminder cannot start. Fix: run \`logwork setup\`.`
+        : `Node: ${check.command} no longer exists, so IDE MCP configs and the reminder cannot start. Fix: run \`logwork setup\`.`;
+    case 'not_executable':
+      return `Launcher: ${check.command} is not executable. Fix: run \`logwork setup\`.`;
+    case 'no_node':
+      return `Launcher: found no usable Node.js ${MIN_NODE_MAJOR}+. Fix: install Node.js ${MIN_NODE_MAJOR} or newer, then run \`logwork setup\`.`;
+    case 'failed':
+      return `Launcher: ${check.command} --version failed${check.detail ? ` (${check.detail})` : ''}. Fix: run \`logwork setup\`.`;
+    default:
+      return '';
+  }
+}
+
+export function runProcess(command, args, { env = process.env, cwd } = {}) {
+  return new Promise((resolveValue, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      env,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      windowsHide: true
+    });
+    let stdout = '';
+    let stderr = '';
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+    child.stdout.on('data', (chunk) => { stdout += chunk; });
+    child.stderr.on('data', (chunk) => { stderr += chunk; });
+    child.on('error', reject);
+    child.on('close', (code, signal) => resolveValue({ code: signal ? 1 : (code ?? 1), stdout, stderr }));
+  });
+}
+
+export function pathApi(platform = process.platform) {
+  return platform === 'win32' ? win32 : posix;
+}
+
+// The launcher must not inherit a test or dev LOGWORK_HOME that points at a
+// different runtime than the one it launches.
+function withoutLogworkEnv(env) {
+  return Object.fromEntries(Object.entries(env || {}).filter(([key]) => !key.startsWith('LOGWORK_')));
+}
+
+function firstLine(value) {
+  return String(value || '').trim().split(/\r?\n/)[0] || '';
+}
+
+function quoteSh(value) {
+  return `'${String(value).replaceAll("'", "'\\''")}'`;
+}
+
+function readEnv(env, name) {
+  if (!env) {
+    return undefined;
+  }
+  if (env[name] !== undefined) {
+    return env[name];
+  }
+  const key = Object.keys(env).find((item) => item.toUpperCase() === name);
+  return key ? env[key] : undefined;
+}

package/lib/logwork-config.mjs

@@ -1,4 +1,6 @@
 import { promises as fs } from 'node:fs';
+import { homedir } from 'node:os';
+import path from 'node:path';
 import {
   legacyUserConfigPath,
   projectConfigPath,
@@ -29,6 +31,7 @@ export async function upsertProjectMappingConfig({
   project,
   tickets = [],
   keywords = [],
+  repos = [],
   lockOptions = {}
 }) {
   const path = scope === 'project' ? projectConfigPath(cwd) : userConfigPath();
@@ -39,25 +42,19 @@ export async function upsertProjectMappingConfig({
         normalizeConfig(await readRawConfigPath(legacyUserConfigPath())),
         normalizeConfig(await readRawConfigPath(path))
       );
-    const mapping = {
+    const mapping = withRepos({
       projectName: project.projectName,
       projectMemberId: project.projectMemberId,
       tickets: normalizeTickets(tickets),
       keywords: normalizeKeywords(keywords)
-    };
+    }, normalizeRepos(repos));
     const existingIndex = config.projectMappings.findIndex((candidate) => (
       sameProjectIdentity(candidate, mapping)
     ));
 
     const projectMappings = [...config.projectMappings];
     if (existingIndex >= 0) {
-      const existing = projectMappings[existingIndex];
-      projectMappings[existingIndex] = {
-        projectName: mapping.projectName || existing.projectName,
-        projectMemberId: mapping.projectMemberId ?? existing.projectMemberId,
-        tickets: uniqueStrings([...existing.tickets, ...mapping.tickets], { uppercase: true }),
-        keywords: uniqueStrings([...existing.keywords, ...mapping.keywords])
-      };
+      projectMappings[existingIndex] = mergeMapping(projectMappings[existingIndex], mapping);
     } else {
       projectMappings.push(mapping);
     }
@@ -133,21 +130,75 @@ function mappingKey(mapping) {
 }
 
 function normalizeMapping(mapping) {
-  return {
+  return withRepos({
     projectName: stringOrEmpty(mapping.projectName),
     projectMemberId: optionalId(mapping.projectMemberId),
     tickets: normalizeTickets(mapping.tickets),
     keywords: normalizeKeywords(mapping.keywords)
-  };
+  }, normalizeRepos(mapping.repos));
 }
 
 function mergeMapping(existing, next) {
-  return {
+  return withRepos({
     projectName: next.projectName || existing.projectName,
     projectMemberId: next.projectMemberId ?? existing.projectMemberId,
     tickets: uniqueStrings([...existing.tickets, ...next.tickets], { uppercase: true }),
     keywords: uniqueStrings([...existing.keywords, ...next.keywords])
-  };
+  }, normalizeRepos([...(existing.repos || []), ...(next.repos || [])]));
+}
+
+// repos is optional: a mapping without repos keeps its old shape on disk.
+function withRepos(mapping, repos) {
+  return repos.length ? { ...mapping, repos } : mapping;
+}
+
+// Git repo roots are stored resolved and without trailing separators. Windows
+// paths compare case-insensitively (see repoPathKey).
+export function normalizeRepoPath(value, platform = process.platform) {
+  const text = typeof value === 'string' ? value.trim() : '';
+  if (!text) {
+    return '';
+  }
+  const pathApi = platform === 'win32' ? path.win32 : path.posix;
+  const expanded = text === '~' || /^~[\\/]/.test(text) ? `${homedir()}${text.slice(1)}` : text;
+  const resolved = pathApi.resolve(expanded);
+  const root = pathApi.parse(resolved).root;
+  let trimmed = resolved;
+  while (trimmed.length > root.length && /[\\/]$/.test(trimmed)) {
+    trimmed = trimmed.slice(0, -1);
+  }
+  return trimmed;
+}
+
+export function repoPathKey(value, platform = process.platform) {
+  const normalized = normalizeRepoPath(value, platform);
+  return platform === 'win32' ? normalized.toLowerCase() : normalized;
+}
+
+export function normalizeRepos(value, platform = process.platform) {
+  const seen = new Set();
+  const results = [];
+  for (const item of stringArray(value)) {
+    const normalized = normalizeRepoPath(item, platform);
+    const key = repoPathKey(normalized, platform);
+    if (!normalized || seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    results.push(normalized);
+  }
+  return results;
+}
+
+// The mapping whose repos list contains this git repo root, if any.
+export function findRepoMapping(mappings, repoRoot, platform = process.platform) {
+  const key = repoPathKey(repoRoot, platform);
+  if (!key) {
+    return null;
+  }
+  return (mappings || []).find((mapping) => (
+    (mapping.repos || []).some((repo) => repoPathKey(repo, platform) === key)
+  )) || null;
 }
 
 function stringOrEmpty(value) {

package/lib/manual-apply-state.mjs

@@ -30,6 +30,21 @@ export function manualUnbookedEntryCount(preview) {
   return preview?.unbookedEntries?.length || 0;
 }
 
+export function buildManualDuplicateConfirmation(preview) {
+  const duplicates = (preview?.entries || []).filter((entry) => entry.possibleDuplicate);
+  const list = duplicates.map((entry) => {
+    const duplicate = entry.possibleDuplicate;
+    return duplicate.source === 'batch'
+      ? `${entry.id} repeats ${duplicate.entryId}`
+      : `${entry.id} matches RO logwork ${duplicate.logworkId ?? '(no id)'}`;
+  }).join(', ');
+  return `This preview contains ${duplicates.length} possible duplicate entries (${list}). Submit them anyway?`;
+}
+
+export function manualDuplicateEntryCount(preview) {
+  return (preview?.entries || []).filter((entry) => entry.possibleDuplicate).length;
+}
+
 export function totalPreviewHours(preview) {
   return (preview?.entries || []).reduce((sum, entry) => sum + Number(entry.hours || 0), 0);
 }

package/lib/manual-commands.mjs

@@ -74,8 +74,8 @@ export const MANUAL_COMMANDS = [
   },
   {
     name: '/map',
-    description: 'Map ticket prefix to projectMemberId',
-    usage: '/map SCB 5234',
+    description: 'Map ticket prefix or git repo to an RO project (picker)',
+    usage: '/map SCB [project] | /map --repo [path] [project]',
     aliases: []
   }
 ];