git-cracked 1.2.0 → 1.4.0

package/src/index.js

@@ -3,6 +3,7 @@ import { existsSync } from 'fs';
 import { loadConfig } from './config.js';
 import { runCommit } from './committer.js';
 import { startDashboard } from './dashboard.js';
+import { getActivity } from './logger.js';
 import { CONFIG_PATH } from './paths.js';
 
 const args = process.argv.slice(2);
@@ -21,13 +22,86 @@ if (runNow) {
   process.exit(0);
 }
 
+// How often the catch-up checker runs (ms). Catches scheduled slots that were
+// missed because the machine was asleep / shut down at the exact cron minute.
+const CATCHUP_INTERVAL_MS = 15 * 60 * 1000;
+
 let scheduled = false;
+let committing = false;
+let activeConfig = null;
 const activeTasks = [];
+let catchupTimer = null;
+
+// Single-flight wrapper so the cron jobs and the catch-up checker can never
+// run a commit at the same time (which would risk a double commit).
+async function safeCommit(config, reason) {
+  if (committing) return;
+  committing = true;
+  try {
+    await runCommit(config);
+  } catch (err) {
+    console.error(`${reason} failed:`, err.message);
+  } finally {
+    committing = false;
+  }
+}
+
+// Parse a 5-field cron expression into { h, m, dows } for catch-up math.
+// Returns null for expressions with ranges/lists in the minute or hour field,
+// which the catch-up checker simply skips (the live cron job still covers them).
+function parseExpr(expr) {
+  const parts = expr.trim().split(/\s+/);
+  if (parts.length !== 5) return null;
+  const [min, hour, , , dow] = parts;
+  const m = parseInt(min, 10);
+  const h = parseInt(hour, 10);
+  if (Number.isNaN(m) || Number.isNaN(h)) return null;
+
+  const dows = new Set();
+  if (dow === '*') {
+    for (let i = 0; i <= 6; i++) dows.add(i);
+  } else {
+    for (const p of dow.split(',')) {
+      if (p.includes('-')) {
+        const [a, b] = p.split('-').map(Number);
+        for (let i = a; i <= b; i++) dows.add(i % 7);
+      } else {
+        dows.add(Number(p) % 7);
+      }
+    }
+  }
+  return { h, m, dows };
+}
+
+// If a scheduled slot has already passed today (on a matching weekday) and no
+// commit has happened since, commit once to catch up.
+async function checkMissedCommits(config) {
+  const now = new Date();
+  let latestPassed = null;
+
+  for (const expr of config.schedule) {
+    const p = parseExpr(expr);
+    if (!p || !p.dows.has(now.getDay())) continue;
+    const slot = new Date(now);
+    slot.setHours(p.h, p.m, 0, 0);
+    if (slot <= now && (!latestPassed || slot > latestPassed)) latestPassed = slot;
+  }
+
+  if (!latestPassed) return; // nothing scheduled has passed today
+
+  const commits = getActivity().commits;
+  const last = commits[0] ? new Date(commits[0].timestamp) : null;
+  if (last && last >= latestPassed) return; // already committed since that slot
+
+  console.log(`[${now.toISOString()}] Catching up missed scheduled commit`);
+  await safeCommit(config, 'Catch-up commit');
+}
 
 function startSchedule(config) {
   // Replace any previously registered jobs (e.g. after a settings change)
   for (const task of activeTasks) task.stop();
   activeTasks.length = 0;
+  activeConfig = config;
 
   for (const expression of config.schedule) {
     if (!cron.validate(expression)) {
@@ -36,16 +110,21 @@ function startSchedule(config) {
     }
     const task = cron.schedule(expression, async () => {
       console.log(`[${new Date().toISOString()}] Cron triggered`);
-      try {
-        await runCommit(config);
-      } catch (err) {
-        console.error('Commit failed:', err.message);
-      }
+      await safeCommit(config, 'Scheduled commit');
     });
     activeTasks.push(task);
   }
+
   scheduled = true;
   console.log('Schedule active:', config.schedule.join(', '));
+
+  // Catch up anything missed while the machine was off, then poll periodically.
+  checkMissedCommits(config);
+  if (!catchupTimer) {
+    catchupTimer = setInterval(() => {
+      if (activeConfig) checkMissedCommits(activeConfig);
+    }, CATCHUP_INTERVAL_MS);
+  }
 }
 
 console.log('Git Cracked running.');