logwork-cli 1.1.1 → 1.2.0

package/lib/diagnostics.mjs

@@ -1,4 +1,3 @@
-import { spawn } from 'node:child_process';
 import { constants as fsConstants } from 'node:fs';
 import { access, mkdir, readFile, stat, writeFile } from 'node:fs/promises';
 import { EOL, homedir, platform, release, type } from 'node:os';
@@ -11,7 +10,9 @@ import { getStoredAuthStatus } from './auth.mjs';
 import { redactText } from './auth-redaction.mjs';
 import { authDebugLogPath, sanitizeDiagnosticValue } from './auth-diagnostics.mjs';
 import { configPath, loadLocalConfig } from './logwork-config.mjs';
-import { helperHome, manualDraftsPath, userConfigPath } from './paths.mjs';
+import { formatNodePathIssue, inspectNodePath, loadRuntimeInfo } from './node-runtime.mjs';
+import { helperHome, manualDraftsPath, runtimeInfoPath, userConfigPath } from './paths.mjs';
+import { readReminderSchedulerNodePath } from './reminder-scheduler.mjs';
 
 const DIAGNOSTICS_DIR_NAME = 'diagnostics';
 const MAX_AUTH_DEBUG_CHARS = 20_000;
@@ -35,6 +36,7 @@ export async function generateDiagnosticsReport({
   commandFinder = findCommandOnPath,
   authStatusFn = getStoredAuthStatus,
   mcpSmokeFn = runMcpSmoke,
+  nodeRuntimeFn = collectNodeRuntimeCheck,
   readFileFn = readFile,
   statFn = stat,
   writeFileFn = writeFile,
@@ -47,6 +49,8 @@ export async function generateDiagnosticsReport({
   const fileChecks = await collectFileChecks({ statFn, cwd });
   const configSnapshot = await safeCollect('config snapshot', () => collectConfigSnapshot({ cwd, includeMappingDetails }));
   const mcpSmoke = await safeCollect('mcp smoke', () => mcpSmokeFn({ cwd }));
+  const nodeRuntime = await safeCollect('node runtime', () => nodeRuntimeFn());
+  const nodeIssues = Array.isArray(nodeRuntime?.issues) ? nodeRuntime.issues : [];
   const authDebug = await readSanitizedAuthDebug({ readFileFn });
 
   sections.push(formatSection('logwork-cli Diagnostics', [
@@ -64,6 +68,17 @@ export async function generateDiagnosticsReport({
     `home: ${homedir()}`
   ]));
 
+  sections.push(formatSection('Node Path', nodeRuntime?.ok === false
+    ? formatObjectLines(nodeRuntime)
+    : [
+      `runtimeFile: ${nodeRuntime.runtimeFile}`,
+      `recordedNode: ${nodeRuntime.recordedNode || 'none (run logwork setup)'}${nodeRuntime.recordedVersion ? ` (${nodeRuntime.recordedVersion})` : ''}`,
+      `recordedNodeStatus: ${nodeRuntime.recordedStatus}`,
+      `reminderNode: ${nodeRuntime.reminderNode || 'none (no reminder schedule)'}`,
+      `reminderNodeStatus: ${nodeRuntime.reminderStatus}`,
+      ...(nodeIssues.length ? nodeIssues.map((issue) => `warning: ${issue}`) : ['warnings: none'])
+    ]));
+
   sections.push(formatSection('Commands', commandChecks.map((entry) => `${entry.command}: ${entry.available ? 'found' : 'missing'}${entry.path ? ` (${entry.path})` : ''}`)));
   sections.push(formatSection('Files', fileChecks.map((entry) => formatFileCheck(entry))));
   sections.push(formatSection('Config Snapshot', formatObjectLines(configSnapshot)));
@@ -78,7 +93,41 @@ export async function generateDiagnosticsReport({
   return {
     path: outputPath,
     report,
-    summary: `Diagnostics report written to ${outputPath}`
+    nodeIssues: nodeIssues.map((issue) => sanitizeReport(issue)),
+    summary: [
+      ...nodeIssues.map((issue) => sanitizeReport(`Warning: ${issue}`)),
+      `Diagnostics report written to ${outputPath}`
+    ].join(EOL)
+  };
+}
+
+// Compares the node recorded by `logwork setup` (runtime.json) and the node in
+// the installed reminder schedule with the node running now. Read-only.
+export async function collectNodeRuntimeCheck({
+  loadRuntime = loadRuntimeInfo,
+  readSchedulerNodePath = readReminderSchedulerNodePath,
+  inspect = inspectNodePath
+} = {}) {
+  const runtime = await loadRuntime().catch(() => null);
+  const reminderNode = await readSchedulerNodePath().catch(() => null);
+  const recorded = runtime?.nodePath
+    ? await inspect(runtime.nodePath)
+    : { status: 'unknown' };
+  const reminder = reminderNode
+    ? await inspect(reminderNode)
+    : { status: 'unknown' };
+  const issues = [
+    formatNodePathIssue('runtime', recorded),
+    formatNodePathIssue('reminder', reminder)
+  ].filter(Boolean);
+  return {
+    runtimeFile: runtimeInfoPath(),
+    recordedNode: runtime?.nodePath || '',
+    recordedVersion: runtime?.nodeVersion || '',
+    recordedStatus: recorded.status,
+    reminderNode: reminderNode || '',
+    reminderStatus: reminder.status,
+    issues
   };
 }
 
@@ -202,7 +251,7 @@ async function safeCollect(label, fn) {
   }
 }
 
-export async function runMcpSmoke({ cwd = process.cwd(), timeoutMs = MCP_SMOKE_TIMEOUT_MS } = {}) {
+export async function runMcpSmoke({ timeoutMs = MCP_SMOKE_TIMEOUT_MS } = {}) {
   const client = new Client({
     name: 'logwork-diagnostics',
     version: '0.1.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/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 projectMemberId',
+    usage: '/map SCB 5234 | /map --repo [path] 5234',
     aliases: []
   }
 ];