logwork-cli 1.1.1 → 1.2.0

package/lib/reminder-scheduler.mjs

@@ -119,7 +119,8 @@ export async function getReminderSchedulerStatus({
   userHome = homedir(),
   uid = userInfo().uid,
   run = runCommand,
-  accessFile = fs.access
+  accessFile = fs.access,
+  readFile = fs.readFile
 } = {}) {
   if (platform === 'darwin') {
     const plistPath = macosReminderPlistPath(userHome);
@@ -130,7 +131,8 @@ export async function getReminderSchedulerStatus({
       installed: fileExists && result.code === 0,
       scheduler: 'launchd',
       identifier: MACOS_REMINDER_LABEL,
-      path: plistPath
+      path: plistPath,
+      nodePath: fileExists ? await readReminderSchedulerNodePath({ platform, userHome, run, readFile }) : null
     };
   }
 
@@ -141,13 +143,53 @@ export async function getReminderSchedulerStatus({
       installed: result.code === 0,
       scheduler: 'Task Scheduler',
       identifier: WINDOWS_REMINDER_TASK_NAME,
-      path: null
+      path: null,
+      nodePath: result.code === 0 ? await readReminderSchedulerNodePath({ platform, userHome, run, readFile }) : null
     };
   }
 
   throw unsupportedReminderPlatform(platform);
 }
 
+// The node binary the installed schedule runs: the first ProgramArguments
+// entry of the launchd plist, or the <Command> of the Windows task. Returns
+// null when no schedule is installed or it cannot be read. Read-only.
+export async function readReminderSchedulerNodePath({
+  platform = process.platform,
+  userHome = homedir(),
+  run = runCommand,
+  readFile = fs.readFile
+} = {}) {
+  try {
+    if (platform === 'darwin') {
+      const plist = await readFile(macosReminderPlistPath(userHome), 'utf8');
+      return parseMacosPlistNodePath(plist);
+    }
+    if (platform === 'win32') {
+      const result = await run('schtasks.exe', ['/Query', '/TN', WINDOWS_REMINDER_TASK_NAME, '/XML']);
+      return result.code === 0 ? parseWindowsTaskNodePath(result.stdout) : null;
+    }
+  } catch {
+    // Missing or unreadable schedule: nothing to compare.
+  }
+  return null;
+}
+
+export function parseMacosPlistNodePath(plist) {
+  const match = /<key>ProgramArguments<\/key>\s*<array>\s*<string>([^<]*)<\/string>/.exec(String(plist || ''));
+  return match ? unescapeXml(match[1]).trim() || null : null;
+}
+
+export function parseWindowsTaskNodePath(xml) {
+  // schtasks may write the XML as UTF-16; decoded as UTF-8 that leaves NULs.
+  const match = /<Command>([^<]*)<\/Command>/i.exec(String(xml || '').replaceAll('\0', ''));
+  if (!match) {
+    return null;
+  }
+  // schtasks keeps the quotes /TR put around a path with spaces.
+  return unescapeXml(match[1]).trim().replace(/^"(.*)"$/, '$1') || null;
+}
+
 export function buildMacosReminderPlist({ config, nodePath, runnerPath, home }) {
   const normalized = normalizeReminderConfig({ ...config, enabled: true });
   const [hour, minute] = normalized.time.split(':').map(Number);
@@ -296,6 +338,15 @@ function escapeXml(value) {
     .replaceAll("'", '&apos;');
 }
 
+function unescapeXml(value) {
+  return String(value)
+    .replaceAll('&lt;', '<')
+    .replaceAll('&gt;', '>')
+    .replaceAll('&quot;', '"')
+    .replaceAll('&apos;', "'")
+    .replaceAll('&amp;', '&');
+}
+
 function unsupportedReminderPlatform(platform) {
   return new Error(`Reminder scheduling is unsupported on ${platform}. Supported platforms are macOS and Windows.`);
 }

package/lib/reminder-service.mjs

@@ -1,6 +1,8 @@
+import { formatNodePathIssue, inspectNodePath } from './node-runtime.mjs';
 import {
   loadReminderConfig,
   normalizeReminderConfig,
+  normalizeReminderRepos,
   saveReminderConfig
 } from './reminder-config.mjs';
 import {
@@ -11,9 +13,12 @@ import {
 import { loadReminderState } from './reminder-state.mjs';
 import { sendTestReminderNotification } from './reminder-workflow.mjs';
 
+// repos: undefined keeps the configured commit repos; an array (even empty)
+// replaces them.
 export async function enableLogworkReminder({
   time,
   target,
+  repos,
   confirm,
   loadConfig = loadReminderConfig,
   saveConfig = saveReminderConfig,
@@ -26,7 +31,8 @@ export async function enableLogworkReminder({
     ...current,
     enabled: true,
     ...(time ? { time } : {}),
-    ...(target ? { target } : {})
+    ...(target ? { target } : {}),
+    ...(repos !== undefined ? { repos: normalizeReminderRepos(repos) } : {})
   });
 
   const scheduler = await installScheduler(config);
@@ -41,7 +47,12 @@ export async function enableLogworkReminder({
     status: 'enabled',
     config,
     scheduler,
-    summary: `Enabled ${config.target} logwork reminder at ${config.time}, Monday-Friday, using ${scheduler.scheduler}.`
+    summary: [
+      `Enabled ${config.target} logwork reminder at ${config.time}, Monday-Friday, using ${scheduler.scheduler}.`,
+      config.repos.length
+        ? `Commit summary repos: ${config.repos.join(', ')}.`
+        : 'No reminder repos set; add --repo <path> to include today\'s commits (repos on project mappings are also used).'
+    ].join('\n')
   };
 }
 
@@ -69,7 +80,8 @@ export async function disableLogworkReminder({
 export async function getLogworkReminderStatus({
   loadConfig = loadReminderConfig,
   loadState = loadReminderState,
-  schedulerStatus = getReminderSchedulerStatus
+  schedulerStatus = getReminderSchedulerStatus,
+  inspectNode = inspectNodePath
 } = {}) {
   const [config, state, scheduler] = await Promise.all([
     loadConfig(),
@@ -82,9 +94,21 @@ export async function getLogworkReminderStatus({
     `Schedule: Monday-Friday at ${config.time}; target ${config.target}.`,
     `OS scheduler: ${scheduler.scheduler} ${scheduler.installed ? 'installed' : 'not installed'}.`
   ];
+  if (config.repos?.length) {
+    lines.push(`Commit summary repos: ${config.repos.join(', ')}.`);
+  }
   if (!consistent) {
     lines.push('Warning: reminder config and OS scheduler are out of sync; run reminder enable or disable again.');
   }
+  // The schedule stores an absolute node path; nvm or Homebrew can remove it
+  // while the schedule still looks installed.
+  const nodeCheck = scheduler.nodePath
+    ? await inspectNode(scheduler.nodePath).catch(() => ({ status: 'unknown', recordedPath: scheduler.nodePath }))
+    : null;
+  const nodeIssue = nodeCheck ? formatNodePathIssue('reminder', nodeCheck) : '';
+  if (nodeIssue) {
+    lines.push(`Warning: ${nodeIssue}`);
+  }
   if (state?.lastRunAt) {
     lines.push(`Last run: ${state.lastRunAt}, status ${state.lastStatus || 'unknown'}.`);
   }
@@ -94,6 +118,7 @@ export async function getLogworkReminderStatus({
     scheduler,
     state,
     consistent,
+    ...(nodeCheck ? { nodeCheck } : {}),
     summary: lines.join('\n')
   };
 }

package/lib/reminder-workflow.mjs

@@ -1,26 +1,37 @@
 import { isAuthRequiredError } from './auth-errors.mjs';
 import { redactText } from './auth-redaction.mjs';
+import { draftLogworkFromCommits } from './commit-workflow.mjs';
 import { withFileLock } from './file-lock.mjs';
 import { searchJiraIssues } from './jira-api.mjs';
 import {
   getStoredJiraSession,
   isJiraAuthRequiredError
 } from './jira-auth.mjs';
+import { loadLocalConfig } from './logwork-config.mjs';
 import { sendOsNotification } from './os-notification.mjs';
-import { reminderStatePath } from './paths.mjs';
+import { helperHome, reminderStatePath } from './paths.mjs';
 import { queryLogwork } from './query-workflow.mjs';
-import { loadReminderConfig } from './reminder-config.mjs';
+import { loadReminderConfig, normalizeReminderRepos } from './reminder-config.mjs';
 import {
   loadReminderState,
   saveReminderState
 } from './reminder-state.mjs';
 import { todayLocalDateISO } from './util.mjs';
 
+const REMINDER_HEADER = 'Logwork hôm nay chưa hoàn tất';
+const DEFAULT_ACTION_LINE = 'Mở Terminal và chạy: logwork';
+const COMMITS_ACTION_LINE = 'Mở Terminal và chạy: logwork commits today (bản nháp từ commit)';
+const COMMIT_SUMMARY_TIMEOUT_MS = 20_000;
+
+// repos: git repos whose commits back up a missing-RO reminder. Without repos,
+// or when reading them fails, the message is the plain RO/Jira one.
 export async function checkLogworkReminder({
   target = 'both',
   date = todayLocalDateISO(),
+  repos = [],
   queryRo = queryResourceOptimiserDay,
-  queryJira = queryJiraWorklogDay
+  queryJira = queryJiraWorklogDay,
+  summarizeCommits = summarizeTodayCommits
 } = {}) {
   const checks = {};
   const jobs = [];
@@ -42,15 +53,16 @@ export async function checkLogworkReminder({
 
   const problemLines = buildProblemLines(checks);
   const notify = problemLines.length > 0;
-  const notification = notify ? {
-    title: 'Logwork',
-    message: [
-      'Logwork hôm nay chưa hoàn tất',
-      ...problemLines,
-      '',
-      'Mở Terminal và chạy: logwork'
-    ].join('\n')
-  } : null;
+  let commits = null;
+  if (notify && checks.ro?.status === 'incomplete' && repos?.length) {
+    // Commit evidence is a bonus: any failure keeps the plain message.
+    try {
+      commits = await summarizeCommits({ date, repos });
+    } catch (error) {
+      commits = { status: 'unavailable', error: redactText(error.message || String(error)).slice(0, 300) };
+    }
+  }
+  const notification = notify ? buildReminderNotification({ problemLines, commits }) : null;
 
   return {
     date,
@@ -58,6 +70,7 @@ export async function checkLogworkReminder({
     status: notify ? 'notification_required' : 'complete',
     notify,
     checks,
+    ...(commits ? { commits } : {}),
     notification,
     summary: notify
       ? `Logwork reminder requires attention: ${problemLines.join(' | ')}`
@@ -117,8 +130,81 @@ export async function queryJiraWorklogDay({
   };
 }
 
+// Counts today's commits in the given repos with the read-only commit draft
+// (no RO query: the reminder already has the RO totals). Throws when no repo
+// could be read, so the caller falls back to the plain message.
+export async function summarizeTodayCommits({
+  date,
+  repos,
+  draft = draftLogworkFromCommits,
+  cwd = helperHome(),
+  timeoutMs = COMMIT_SUMMARY_TIMEOUT_MS
+} = {}) {
+  const result = await withTimeout(
+    draft({ from: date, repos, useBookings: false, cwd }),
+    timeoutMs,
+    'Reading commits timed out.'
+  );
+  const repoResults = Array.isArray(result?.repos) ? result.repos : [];
+  const readable = repoResults.filter((repo) => !repo.error);
+  if (!readable.length) {
+    throw new Error('None of the reminder repos could be read.');
+  }
+  return {
+    status: 'ok',
+    commitCount: Number(result.commitCount || 0),
+    repoCount: readable.filter((repo) => Number(repo.commitCount || 0) > 0).length,
+    readRepoCount: readable.length,
+    failedRepoCount: repoResults.length - readable.length
+  };
+}
+
+// Reminder repos plus any `repos` listed on project mappings in the local
+// config. Mapping repos are optional and read defensively.
+export async function collectReminderRepos({
+  config,
+  loadMappings = loadLocalConfig,
+  cwd = helperHome()
+} = {}) {
+  const repos = [...(Array.isArray(config?.repos) ? config.repos : [])];
+  let mappings = [];
+  try {
+    mappings = (await loadMappings(cwd))?.projectMappings || [];
+  } catch {
+    mappings = [];
+  }
+  for (const mapping of Array.isArray(mappings) ? mappings : []) {
+    if (!Array.isArray(mapping?.repos)) {
+      continue;
+    }
+    for (const repo of mapping.repos) {
+      try {
+        repos.push(...normalizeReminderRepos([repo], { cwd }));
+      } catch {
+        // Skip a malformed mapping path.
+      }
+    }
+  }
+  return [...new Set(repos)];
+}
+
+export function buildReminderNotification({ header = REMINDER_HEADER, problemLines = [], commits = null } = {}) {
+  const hasCommits = commits?.status === 'ok' && commits.commitCount > 0;
+  return {
+    title: 'Logwork',
+    message: [
+      header,
+      ...problemLines,
+      ...(hasCommits ? [`Hôm nay: ${commits.commitCount} commit trong ${commits.repoCount} repo`] : []),
+      '',
+      hasCommits ? COMMITS_ACTION_LINE : DEFAULT_ACTION_LINE
+    ].join('\n')
+  };
+}
+
 export async function runScheduledReminder({
   loadConfig = loadReminderConfig,
+  collectRepos = collectReminderRepos,
   loadState = loadReminderState,
   saveState = saveReminderState,
   check = checkLogworkReminder,
@@ -165,9 +251,11 @@ export async function runScheduledReminder({
       return result;
     }
 
+    const repos = await collectRepos({ config }).catch(() => []);
     const checkResult = await check({
       target: config.target,
-      date
+      date,
+      repos
     });
     if (!checkResult.notify) {
       const result = {
@@ -219,15 +307,13 @@ export async function sendTestReminderNotification({
   if (!lines.length) {
     throw new Error('Reminder target must be ro, jira, or both.');
   }
-  const notification = {
-    title: 'Logwork',
-    message: [
-      'Đây là notification thử nghiệm',
-      ...lines,
-      '',
-      'Mở Terminal và chạy: logwork'
-    ].join('\n')
-  };
+  // Sample data in the real message format, including the commit line a
+  // reminder with repos shows when RO hours are missing.
+  const notification = buildReminderNotification({
+    header: 'Đây là notification thử nghiệm',
+    problemLines: lines,
+    commits: target === 'jira' ? null : { status: 'ok', commitCount: 5, repoCount: 2 }
+  });
   const result = await notify(notification);
   return {
     status: 'sent',
@@ -292,6 +378,16 @@ function formatHours(value) {
   return Number(value || 0).toFixed(2).replace(/\.00$/, '').replace(/(\.\d)0$/, '$1');
 }
 
+function withTimeout(promise, timeoutMs, message) {
+  let timer;
+  return Promise.race([
+    promise,
+    new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+    })
+  ]).finally(() => clearTimeout(timer));
+}
+
 function assertDateOnly(value) {
   if (!/^\d{4}-\d{2}-\d{2}$/.test(String(value || ''))) {
     throw new Error('Reminder date must use YYYY-MM-DD format.');

package/lib/ro-api-diagnostics.mjs

@@ -0,0 +1,109 @@
+// Normalization diagnostics attached (non-enumerable) to normalized RO record lists.
+
+const NORMALIZATION_DIAGNOSTICS_KEY = 'normalization';
+
+const MAX_DIAGNOSTIC_ITEMS = 25;
+
+export function getNormalizationDiagnostics(value) {
+  return value?.[NORMALIZATION_DIAGNOSTICS_KEY] || emptyNormalizationDiagnostics();
+}
+
+export function createNormalizationDiagnostics(sourceShape = 'unknown') {
+  return {
+    status: 'ok',
+    sourceShape,
+    rowsRead: 0,
+    rowsAccepted: 0,
+    droppedRowCount: 0,
+    warningCount: 0,
+    warnings: [],
+    droppedRows: []
+  };
+}
+
+function emptyNormalizationDiagnostics() {
+  return createNormalizationDiagnostics('unknown');
+}
+
+export function attachNormalizationDiagnostics(value, diagnostics) {
+  Object.defineProperty(value, NORMALIZATION_DIAGNOSTICS_KEY, {
+    value: finalizeNormalizationDiagnostics(diagnostics),
+    enumerable: false,
+    configurable: true
+  });
+  return value;
+}
+
+function finalizeNormalizationDiagnostics(diagnostics) {
+  const warningCount = diagnostics.warnings.length;
+  const droppedRowCount = diagnostics.droppedRows.length;
+  return {
+    ...diagnostics,
+    status: warningCount || droppedRowCount ? 'warning' : 'ok',
+    warningCount,
+    droppedRowCount
+  };
+}
+
+export function combineNormalizationDiagnostics(...items) {
+  const diagnostics = createNormalizationDiagnostics('combined');
+  for (const item of items) {
+    const current = item?.warnings || item?.droppedRows
+      ? item
+      : getNormalizationDiagnostics(item);
+    if (!current) {
+      continue;
+    }
+    diagnostics.rowsRead += Number(current.rowsRead || 0);
+    diagnostics.rowsAccepted += Number(current.rowsAccepted || 0);
+    for (const warning of current.warnings || []) {
+      pushDiagnostic(diagnostics.warnings, warning);
+    }
+    for (const dropped of current.droppedRows || []) {
+      pushDiagnostic(diagnostics.droppedRows, dropped);
+    }
+  }
+  return finalizeNormalizationDiagnostics(diagnostics);
+}
+
+export function addWarning(diagnostics, reason, details = {}) {
+  if (!diagnostics) {
+    return;
+  }
+  pushDiagnostic(diagnostics.warnings, compactDiagnostic({
+    reason,
+    ...details
+  }));
+}
+
+export function addDroppedRow(diagnostics, reason, details = {}) {
+  if (!diagnostics) {
+    return;
+  }
+  pushDiagnostic(diagnostics.droppedRows, compactDiagnostic({
+    reason,
+    ...details
+  }));
+}
+
+function pushDiagnostic(items, item) {
+  if (items.length < MAX_DIAGNOSTIC_ITEMS) {
+    items.push(item);
+  }
+}
+
+function compactDiagnostic(details) {
+  return Object.fromEntries(Object.entries(details).filter(([, value]) => (
+    value !== undefined &&
+    value !== null &&
+    value !== ''
+  )));
+}
+
+export function diagnosticProjectFields({ projectMemberId, projectId, projectName } = {}) {
+  return compactDiagnostic({
+    projectMemberId,
+    projectId,
+    projectName
+  });
+}