logwork-cli 1.1.0 → 1.2.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-parser.mjs

@@ -1,6 +1,8 @@
 const DAY_HEADING_RE = /^(Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday),\s+(\d{2})\s+([A-Za-z]{3})\s+(\d{4})$/;
 const ENTRY_RE = /^\+(\d+(?:\.\d+)?)\s+(.+)$/;
 const TICKET_RE = /\b[A-Z][A-Z0-9]+-\d+\b/g;
+const MAX_DAY_HOURS = 24;
+const WEEKDAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
 
 const MONTHS = new Map([
   ['jan', 1],
@@ -67,6 +69,18 @@ export function parseWeeklyLogText(text) {
       });
       continue;
     }
+    // RO rejects more than 24h; catching it here keeps a batch from failing
+    // halfway after earlier entries were written.
+    const dayTotal = entries.filter((item) => item.date === currentDate).reduce((sum, item) => sum + item.hours, 0) + hours;
+    if (hours > MAX_DAY_HOURS || dayTotal > MAX_DAY_HOURS) {
+      errors.push({
+        line: lineNumber,
+        message: hours > MAX_DAY_HOURS
+          ? `Hours ${entry[1]} exceed ${MAX_DAY_HOURS}h for one entry.`
+          : `Entries for ${currentDate} add up to ${dayTotal}h, more than ${MAX_DAY_HOURS}h in one day.`
+      });
+      continue;
+    }
 
     const text = entry[2].trim();
     const { taskName, description, taskExplicit } = splitTaskAndDescription(text);
@@ -137,6 +151,15 @@ function parseHeadingDate(match, lineNumber, errors) {
     return null;
   }
 
+  const weekday = WEEKDAYS[date.getUTCDay()];
+  if (weekday !== match[1]) {
+    errors.push({
+      line: lineNumber,
+      message: `Date heading says ${match[1]} but ${match[2]} ${match[3]} ${match[4]} is a ${weekday}: ${match[0]}`
+    });
+    return null;
+  }
+
   return [
     String(year).padStart(4, '0'),
     String(month).padStart(2, '0'),

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
 }) {
@@ -70,7 +73,155 @@ export async function previewLogworkBatch({
       defaultWorklogTask: normalizedDefaultTask
     }
     : enriched;
-  return typeOfWork ? { ...output, typeOfWork } : output;
+  // typeOfWork also changes what gets written, so it is folded into the
+  // batchId the same way.
+  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>';
@@ -309,9 +460,11 @@ export async function applyLogworkBatch({
   confirm,
   projectOverrides = {},
   allowUnbooked = false,
+  allowDuplicates = false,
   cwd = process.cwd(),
   fetchProjects,
   fetchMembershipProjects,
+  fetchDayEntries,
   submitEntry,
   verifyLogwork,
   recordLedger,
@@ -328,7 +481,8 @@ export async function applyLogworkBatch({
       projectOverrides,
       cwd,
       fetchProjects,
-      fetchMembershipProjects
+      fetchMembershipProjects,
+      fetchDayEntries
     });
 
   if (preview.errors?.length) {
@@ -347,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);
@@ -394,6 +553,16 @@ export async function applyLogworkBatch({
         ok: false,
         error: error.message
       });
+      // Earlier entries are already in RO. Say so plainly: re-applying the same
+      // text would log them twice.
+      const written = results.filter((result) => result.ok);
+      const notTried = preview.entries.slice(results.length).map((item) => item.id);
+      error.message = `Entry ${entry.id} (+${entry.hours}h ${entry.taskName}) failed: ${error.message}` +
+        (written.length
+          ? ` Already written to RO: ${written.map((result) => `${result.entryId} (+${result.hours}h ${result.taskName})`).join(', ')}. Do not apply this batch again; preview only the entries that were not written.`
+          : ' Nothing was written.') +
+        (notTried.length ? ` Not attempted: ${notTried.join(', ')}.` : '');
+      error.partialResults = results;
       error.applyLedger = await recordRoApplyLedger({
         writer: ledgerWriter,
         preview,
@@ -460,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 () => {