logwork-cli 1.1.1 → 1.3.0

package/lib/apply-ledger.mjs

@@ -211,7 +211,7 @@ function createRecordId(date, random) {
 
 function cleanText(value, maxLength) {
   const text = String(value || '')
-    .replace(/Bearer\s+[A-Za-z0-9._~+\/-]+/gi, 'Bearer <redacted>')
+    .replace(/Bearer\s+[A-Za-z0-9._~+/-]+/gi, 'Bearer <redacted>')
     .replace(/(token|password|secret|otp)\s*[=:]\s*[^\s,;]+/gi, '$1=<redacted>')
     .trim();
   return text ? text.slice(0, maxLength) : '';

package/lib/batch-workflow.mjs

@@ -3,8 +3,10 @@ import {
   ApiError,
   fetchWorklogTasksForProject,
   getBookedProjectsForDate,
+  getLogworkDay,
   getProjects
 } from './api.mjs';
+import { isAuthRequiredError } from './auth-errors.mjs';
 import {
   listAvailableTaskNames,
   listSuggestedTaskNames,
@@ -24,6 +26,7 @@ export async function previewLogworkBatch({
   fetchProjects,
   fetchMembershipProjects,
   fetchWorklogTasks,
+  fetchDayEntries,
   typeOfWork,
   defaultWorklogTask
 }) {
@@ -72,9 +75,153 @@ export async function previewLogworkBatch({
     : enriched;
   // typeOfWork also changes what gets written, so it is folded into the
   // batchId the same way.
-  return typeOfWork
+  const typed = typeOfWork
     ? { ...output, typeOfWork, batchId: `${output.batchId}_${hash(`typeOfWork:${typeOfWork}`)}`, summary: `${output.summary}\n\nType of work for every entry: ${typeOfWork}` }
     : output;
+  return attachDuplicateWarnings(typed, {
+    fetchDayEntries: fetchDayEntries || createDayEntriesFetcher()
+  });
+}
+
+// Duplicate guard: an entry is a possible duplicate when RO already has an
+// entry on the same date with the same worklog task (id, else name), the same
+// hours and the same description (trimmed, whitespace collapsed, any case), or
+// when an earlier line of this batch is identical. Apply refuses those entries
+// unless allowDuplicates: true. A failed day read (other than auth) skips the
+// check for that date and says so; it never blocks the preview.
+export async function attachDuplicateWarnings(preview, { fetchDayEntries } = {}) {
+  const entries = preview.entries || [];
+  if (!entries.length || preview.errors?.length) {
+    return preview;
+  }
+
+  const dates = [...new Set(entries.map((entry) => entry.date).filter(Boolean))].sort();
+  const existingByDate = new Map();
+  const skipped = [];
+  for (const date of dates) {
+    try {
+      existingByDate.set(date, await fetchDayEntries(date));
+    } catch (error) {
+      if (isAuthRequiredError(error) || (error instanceof ApiError && error.status === 401)) {
+        throw error;
+      }
+      skipped.push({ date, error: String(error?.message || error) });
+    }
+  }
+
+  const seen = [];
+  const flagged = entries.map((entry) => {
+    const { possibleDuplicate: _previous, ...base } = entry;
+    const existing = (existingByDate.get(entry.date) || [])
+      .filter((candidate) => !candidate?.raw?.deleted_date && !candidate?.deletedDate)
+      .find((candidate) => isSameLogwork(entry, candidate));
+    const earlier = seen.find((candidate) => isSameLogwork(entry, candidate));
+    seen.push(entry);
+    if (existing) {
+      return {
+        ...base,
+        possibleDuplicate: {
+          source: 'ro',
+          logworkId: existing.id ?? null,
+          date: existing.date || entry.date,
+          hours: Number(existing.hours),
+          taskName: existingTaskName(existing),
+          worklogTaskId: existing.worklogTaskId ?? null,
+          description: existing.description || '',
+          status: existing.status || '',
+          projectName: existing.projectName || ''
+        }
+      };
+    }
+    if (earlier) {
+      return {
+        ...base,
+        possibleDuplicate: {
+          source: 'batch',
+          logworkId: null,
+          entryId: earlier.id,
+          date: earlier.date,
+          hours: earlier.hours,
+          taskName: earlier.taskName,
+          description: earlier.description || ''
+        }
+      };
+    }
+    return base;
+  });
+
+  const duplicateEntries = flagged.filter((entry) => entry.possibleDuplicate);
+  const duplicateCheck = {
+    status: skipped.length ? (skipped.length === dates.length ? 'skipped' : 'partial') : 'checked',
+    checkedDates: dates.filter((date) => existingByDate.has(date)),
+    ...(skipped.length ? { skippedDates: skipped } : {})
+  };
+  const summaryLines = [];
+  if (duplicateEntries.length) {
+    summaryLines.push(`Possible duplicates: ${duplicateEntries.length}. Apply requires allowDuplicates: true.`);
+    summaryLines.push(...duplicateEntries.map(formatDuplicateWarning));
+  }
+  for (const item of skipped) {
+    summaryLines.push(`Note: duplicate check skipped for ${item.date} (could not read RO entries: ${item.error}).`);
+  }
+
+  return {
+    ...preview,
+    entries: flagged,
+    unresolvedEntries: flagged.filter((entry) => entry.status === 'unresolved'),
+    unbookedEntries: flagged.filter((entry) => entry.status === 'resolved_unbooked'),
+    duplicateEntries,
+    duplicateCheck,
+    approvalSummary: {
+      ...preview.approvalSummary,
+      possibleDuplicates: duplicateEntries.length,
+      requiresAllowDuplicates: duplicateEntries.length > 0
+    },
+    summary: summaryLines.length ? `${preview.summary}\n${summaryLines.join('\n')}` : preview.summary
+  };
+}
+
+function formatDuplicateWarning(entry) {
+  const duplicate = entry.possibleDuplicate;
+  const line = `${entry.id}: +${entry.hours}h ${formatTaskAndDescription(entry)}`;
+  if (duplicate.source === 'batch') {
+    return `- WARNING possible duplicate ${line} repeats line ${duplicate.entryId} of this batch.`;
+  }
+  const status = duplicate.status ? `, ${duplicate.status}` : '';
+  const project = duplicate.projectName ? ` on ${duplicate.projectName}` : '';
+  return `- WARNING possible duplicate ${line} matches existing RO logwork ${duplicate.logworkId ?? '(no id)'}${project}${status}.`;
+}
+
+function isSameLogwork(entry, other) {
+  if (!other || (other.date && entry.date && other.date !== entry.date)) {
+    return false;
+  }
+  if (Math.abs(Number(entry.hours) - Number(other.hours)) > 1e-9) {
+    return false;
+  }
+  if (normalizeDuplicateText(entry.description) !== normalizeDuplicateText(other.description)) {
+    return false;
+  }
+  const entryTaskId = entry.worklogTaskId;
+  const otherTaskId = other.worklogTaskId;
+  if (hasId(entryTaskId) && hasId(otherTaskId)) {
+    return String(entryTaskId) === String(otherTaskId);
+  }
+  const entryTask = normalizeDuplicateText(entry.worklogTaskName || entry.taskName);
+  return Boolean(entryTask) && entryTask === normalizeDuplicateText(existingTaskName(other));
+}
+
+function existingTaskName(entry) {
+  const raw = entry?.raw || {};
+  return entry?.worklogTaskName || raw.worklog_task_name || raw.worklog_task?.name || raw.worklogTask?.name || entry?.taskName || '';
+}
+
+function normalizeDuplicateText(value) {
+  return String(value ?? '').trim().replace(/\s+/g, ' ').toLowerCase();
+}
+
+function hasId(value) {
+  return value !== undefined && value !== null && String(value).trim() !== '';
 }
 
 export const LOGWORK_LINE_FORMAT = '+<hours> <worklog task> | <description>';
@@ -313,9 +460,11 @@ export async function applyLogworkBatch({
   confirm,
   projectOverrides = {},
   allowUnbooked = false,
+  allowDuplicates = false,
   cwd = process.cwd(),
   fetchProjects,
   fetchMembershipProjects,
+  fetchDayEntries,
   submitEntry,
   verifyLogwork,
   recordLedger,
@@ -332,7 +481,8 @@ export async function applyLogworkBatch({
       projectOverrides,
       cwd,
       fetchProjects,
-      fetchMembershipProjects
+      fetchMembershipProjects,
+      fetchDayEntries
     });
 
   if (preview.errors?.length) {
@@ -351,6 +501,11 @@ export async function applyLogworkBatch({
     throw new Error(`Cannot apply ${unbookedEntries.length} unbooked entries without allowUnbooked: true. ${blocked}`);
   }
 
+  const duplicateEntries = preview.entries.filter((entry) => entry.possibleDuplicate);
+  if (duplicateEntries.length && allowDuplicates !== true) {
+    throw new Error(`Nothing was written. ${formatDuplicateBlock(duplicateEntries)} Apply requires allowDuplicates: true.`);
+  }
+
   const results = [];
   const taskCache = new Map();
   const entrySubmitter = submitEntry || createLogtimeSubmitter(taskCache);
@@ -474,6 +629,36 @@ function createBookedProjectsFetcher() {
   };
 }
 
+export function formatDuplicateBlock(entries) {
+  const list = entries.map((entry) => {
+    const duplicate = entry.possibleDuplicate || {};
+    const target = duplicate.source === 'batch'
+      ? `line ${duplicate.entryId}`
+      : `RO logwork ${duplicate.logworkId ?? '(no id)'}`;
+    return `${entry.id} (+${entry.hours}h ${entry.taskName}) matches ${target}`;
+  }).join('; ');
+  return `${entries.length} entr${entries.length === 1 ? 'y looks' : 'ies look'} already logged: ${list}.`;
+}
+
+// Existing RO entries for one date, from GET /logwork/day, with one forced
+// re-login on a 401.
+function createDayEntriesFetcher() {
+  const session = createResourceOptimiserSession();
+  return async (localDateISO) => {
+    const { token } = await session.get();
+    try {
+      return (await getLogworkDay(token, { date: localDateISO })).entries || [];
+    } catch (error) {
+      if (!(error instanceof ApiError) || error.status !== 401) {
+        throw error;
+      }
+
+      const refreshed = await session.get({ forceLogin: true });
+      return (await getLogworkDay(refreshed.token, { date: localDateISO })).entries || [];
+    }
+  };
+}
+
 function createMembershipProjectsFetcher() {
   const session = createResourceOptimiserSession();
   return async () => {