devgrowth 1.0.1 → 1.1.0

package/src/core/schedule.js

@@ -1,70 +1 @@
-const DAY_MAP = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'];
-const DAYS = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
-const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
-
-export function formatDate(date) {
-  return `${DAYS[date.getDay()]}, ${MONTHS[date.getMonth()]} ${date.getDate()}`;
-}
-
-export function formatShortDate(date) {
-  return `${MONTHS[date.getMonth()]} ${date.getDate()}`;
-}
-
-export function getWeekStart(date) {
-  const d = new Date(date);
-  const day = d.getDay();
-  const diff = d.getDate() - day + (day === 0 ? -6 : 1);
-  d.setDate(diff);
-  d.setHours(0, 0, 0, 0);
-  return d;
-}
-
-export function getWeekFileName(date) {
-  const week = getWeekNumber(date);
-  return `week${week}.md`;
-}
-
-export function getSessionDate(date = new Date()) {
-  const hours = date.getHours();
-  // After midnight (00:00 - 04:00) counts as the previous day's session
-  return (hours >= 0 && hours < 4)
-    ? new Date(date.getTime() - 24 * 60 * 60 * 1000)
-    : date;
-}
-
-export function getTodaySkill(config, date = new Date()) {
-  const sessionDate = getSessionDate(date);
-  const dayIndex = sessionDate.getDay();
-  const dayKey = DAY_MAP[dayIndex];
-  const session = config.schedule[dayKey];
-
-  return {
-    day: dayKey,
-    ...session
-  };
-}
-
-export function getWeekBounds(date) {
-  const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
-  const day = d.getUTCDay();
-  const diff = d.getUTCDate() - day + (day === 0 ? -6 : 1); // adjust when day is Sunday
-  const start = new Date(d.setUTCDate(diff));
-  start.setUTCHours(0, 0, 0, 0);
-  const end = new Date(start);
-  end.setUTCDate(start.getUTCDate() + 6);
-  end.setUTCHours(23, 59, 59, 999);
-  return { start, end };
-}
-
-export function getWeekNumber(date) {
-  const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
-  const dayNum = d.getUTCDay() || 7;
-  d.setUTCDate(d.getUTCDate() + 4 - dayNum);
-  const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
-  return Math.ceil((((d - yearStart) / 86400000) + 1) / 7);
-}
-
-export function getCurrentWeekFileName(date) {
-  const week = getWeekNumber(date);
-  return `week${week}.md`;
-}
+export * from 'devgrowth-core/schedule';

package/src/core/stats.js

@@ -1,130 +1,43 @@
-import * as storage from './storage.js';
-import * as path from 'path';
-import { getWeekNumber, getWeekStart, getSessionDate } from './schedule.js';
-
-function getStatsPath() {
-  return path.join(storage.getDevGrowthDir(), 'stats.json');
-}
-
-function formatLocalDate(date) {
-  const year = date.getFullYear();
-  const month = String(date.getMonth() + 1).padStart(2, '0');
-  const day = String(date.getDate()).padStart(2, '0');
-  return `${year}-${month}-${day}`;
-}
-
-export async function getStats() {
-  const statsPath = getStatsPath();
-  const exists = await storage.fileExists(statsPath);
-  if (!exists) {
-    return {
-      currentStreakWeeks: 0,
-      longestStreakWeeks: 0,
-      totalSessions: 0,
-      totalMinutesDeepWork: 0,
-      currentWeek: { completed: 0, total: 5, status: 'not_started' },
-      weeklyHistory: [],
-      lastSessionDate: null,
-      lastFinalizedWeek: null
-    };
-  }
-  return await storage.readJson(statsPath);
-}
-
-export async function saveStats(statsData) {
-  await storage.writeJson(getStatsPath(), statsData);
-}
-
-export async function recordSession(date, skill, duration, status) {
-  const stats = await getStats();
-  const dateStr = formatLocalDate(date);
-  const weekOf = formatLocalDate(getWeekStart(date));
-
-  // Week rollover guard: if review was never run, reset progress instead of
-  // letting currentWeek.completed grow past the end of the week.
-  if (stats.currentWeek?.weekOf !== weekOf) {
-    stats.currentWeek = { completed: 0, total: 5, status: 'not_started', weekOf };
-  }
-
-  stats.totalSessions += 1;
-  if (status === 'Completed') {
-    stats.totalMinutesDeepWork += duration;
-  }
-
-  // A second record on the same day (e.g. interrupted start followed by a log)
-  // counts toward totals but must not double-count the day for the week.
-  if (stats.lastSessionDate !== dateStr) {
-    stats.currentWeek.completed += 1;
-    if (stats.currentWeek.completed >= 4) {
-      stats.currentWeek.status = 'on_track';
-    } else if (stats.currentWeek.completed >= 2) {
-      stats.currentWeek.status = 'behind';
-    } else {
-      stats.currentWeek.status = 'not_started';
-    }
-  }
-
-  stats.lastSessionDate = dateStr;
-  await saveStats(stats);
-  return stats;
-}
-
-/**
- * Current-week progress with the same rollover guard `recordSession` applies,
- * so a week that was never finalized does not report last week's count.
- */
-export function getCurrentWeekProgress(statsData, date = new Date()) {
-  const current = statsData?.currentWeek || {};
-  const total = current.total ?? 5;
-  const weekOf = formatLocalDate(getWeekStart(getSessionDate(date)));
-  if (current.weekOf && current.weekOf !== weekOf) {
-    return { completed: 0, total, status: 'not_started', weekOf };
-  }
-  return { completed: current.completed ?? 0, total, status: current.status ?? 'not_started', weekOf };
-}
-
-export async function getStatus() {
-  return await getStats();
-}
-
-export async function finalizeWeek(date) {
-  const stats = await getStats();
-  const week = getWeekNumber(date);
-  const year = date.getFullYear();
-  const weekOf = formatLocalDate(getWeekStart(date));
-
-  // Idempotency: finalizing the same week twice must not wipe the streak
-  // or append duplicate history entries.
-  if (stats.lastFinalizedWeek === weekOf) {
-    return { ...stats, justFinalized: false };
-  }
-
-  const sessions = stats.currentWeek?.completed || 0;
-
-  // Update streak
-  if (sessions >= 4) {
-    stats.currentStreakWeeks = (stats.currentStreakWeeks || 0) + 1;
-    if (stats.currentStreakWeeks > (stats.longestStreakWeeks || 0)) {
-      stats.longestStreakWeeks = stats.currentStreakWeeks;
-    }
-  } else {
-    stats.currentStreakWeeks = 0;
-  }
-
-  // Add to history
-  const historyEntry = {
-    week,
-    year,
-    sessions,
-    // Skill breakdown would need parsing logs - simplified here
-  };
-  stats.weeklyHistory = stats.weeklyHistory || [];
-  stats.weeklyHistory.push(historyEntry);
-
-  // Reset current week
-  stats.currentWeek = { completed: 0, total: 5, status: 'not_started' };
-  stats.lastFinalizedWeek = weekOf;
-
-  await saveStats(stats);
-  return { ...stats, justFinalized: true };
-}
+import * as storage from './storage.js';
+import * as path from 'path';
+import * as derive from 'devgrowth-core/derive';
+
+// The guard logic (week rollover, same-day dedupe, finalize idempotency) lives
+// in devgrowth-core's pure reducers so the dashboard replays identical rules.
+// This module only loads, reduces and saves.
+export const getCurrentWeekProgress = derive.getCurrentWeekProgress;
+
+function getStatsPath() {
+  return path.join(storage.getDevGrowthDir(), 'stats.json');
+}
+
+export async function getStats() {
+  const statsPath = getStatsPath();
+  const exists = await storage.fileExists(statsPath);
+  if (!exists) {
+    return derive.emptyStats();
+  }
+  return await storage.readJson(statsPath);
+}
+
+export async function saveStats(statsData) {
+  await storage.writeJson(getStatsPath(), statsData);
+}
+
+export async function recordSession(date, skill, duration, status) {
+  const stats = derive.applySession(await getStats(), { ...derive.sessionKeysFor(date), duration, status });
+  await saveStats(stats);
+  return stats;
+}
+
+export async function getStatus() {
+  return await getStats();
+}
+
+export async function finalizeWeek(date) {
+  const { stats, justFinalized } = derive.applyReview(await getStats(), derive.reviewKeysFor(date));
+  if (justFinalized) {
+    await saveStats(stats);
+  }
+  return { ...stats, justFinalized };
+}

package/src/core/storage.js

@@ -1,33 +1,52 @@
-import fs from 'fs-extra';
-import * as path from 'path';
-import * as os from 'os';
-
-export function getDevGrowthDir() {
-  return path.join(os.homedir(), '.devgrowth');
-}
-
-export async function ensureDir(targetPath) {
-  await fs.ensureDir(targetPath);
-}
-
-export async function readJson(filePath) {
-  return await fs.readJson(filePath);
-}
-
-export async function writeJson(filePath, data) {
-  await fs.ensureDir(path.dirname(filePath));
-  await fs.writeJson(filePath, data, { spaces: 2 });
-}
-
-export async function readFile(filePath) {
-  return await fs.readFile(filePath, 'utf-8');
-}
-
-export async function writeFile(filePath, content) {
-  await fs.ensureDir(path.dirname(filePath));
-  await fs.writeFile(filePath, content, 'utf-8');
-}
-
-export async function fileExists(filePath) {
-  return await fs.pathExists(filePath);
-}
+import fs from 'fs-extra';
+import * as path from 'path';
+import * as os from 'os';
+
+export function getDevGrowthDir() {
+  return path.join(os.homedir(), '.devgrowth');
+}
+
+export async function ensureDir(targetPath) {
+  await fs.ensureDir(targetPath);
+}
+
+export async function readJson(filePath) {
+  return await fs.readJson(filePath);
+}
+
+export async function writeJson(filePath, data, { mode } = {}) {
+  await fs.ensureDir(path.dirname(filePath));
+  await fs.writeJson(filePath, data, { spaces: 2, ...(mode ? { mode } : {}) });
+  // writeJson's mode only applies when the file is created; enforce it on overwrite too.
+  if (mode) await fs.chmod(filePath, mode);
+}
+
+export async function readFile(filePath) {
+  return await fs.readFile(filePath, 'utf-8');
+}
+
+export async function writeFile(filePath, content) {
+  await fs.ensureDir(path.dirname(filePath));
+  await fs.writeFile(filePath, content, 'utf-8');
+}
+
+export async function fileExists(filePath) {
+  return await fs.pathExists(filePath);
+}
+
+export async function appendFile(filePath, content) {
+  await fs.ensureDir(path.dirname(filePath));
+  await fs.appendFile(filePath, content, 'utf-8');
+}
+
+export async function removePath(targetPath) {
+  await fs.remove(targetPath);
+}
+
+export async function copyPath(src, dest, { filter } = {}) {
+  await fs.copy(src, dest, filter ? { filter } : {});
+}
+
+export async function listDir(dirPath) {
+  return (await fs.pathExists(dirPath)) ? await fs.readdir(dirPath) : [];
+}

package/src/core/sync.js

@@ -0,0 +1,101 @@
+import chalk from 'chalk';
+import * as derive from 'devgrowth-core/derive';
+import * as auth from './auth.js';
+import * as apiClient from './apiClient.js';
+import * as eventLog from './eventLog.js';
+import * as configManager from './configManager.js';
+import * as rebuild from './rebuild.js';
+
+export const PUSH_BATCH = 500;
+
+/**
+ * `config.json` can change without going through a command (`config edit`
+ * opens your editor and returns, or you edit the file by hand). If it no longer
+ * matches the config derived from the event log, record it as a new snapshot.
+ * Must run before pulling, while the file still reflects the last rebuild.
+ */
+async function recordConfigDrift() {
+  let local;
+  try {
+    local = await configManager.getConfig();
+  } catch {
+    return false; // not initialized yet
+  }
+  const synced = derive.deriveState(await eventLog.readAllEvents()).config;
+  if (synced && JSON.stringify(synced) === JSON.stringify(local)) return false;
+  try {
+    await eventLog.recordEvent('config_snapshot', { config: local });
+    return true;
+  } catch {
+    return false; // a hand-broken config (e.g. no schedule) is not worth blocking sync over
+  }
+}
+
+/**
+ * Push queued events, then pull everything new and rebuild local state if
+ * anything arrived. Throws on network or server errors; progress made before
+ * the error (pushed batches, pulled pages) is kept.
+ */
+export async function sync({ timeoutMs = 10000, detectConfigDrift = true } = {}) {
+  const session = await auth.getAuth();
+  if (!session) throw new Error('Not logged in. Run `devgrowth login` first.');
+  const call = (method, apiPath, body) =>
+    apiClient.request(session.apiUrl, method, apiPath, { token: session.token, body, timeoutMs });
+
+  if (detectConfigDrift) await recordConfigDrift();
+
+  const state = await eventLog.getSyncState();
+  let pushed = 0;
+  if (state.outbox.length > 0) {
+    const byId = new Map((await eventLog.readAllEvents()).map(e => [e.id, e]));
+    // An outbox id without an event (log damaged by hand) can never be pushed; drop it.
+    state.outbox = state.outbox.filter(id => byId.has(id));
+    const pending = state.outbox.map(id => byId.get(id));
+    for (let i = 0; i < pending.length; i += PUSH_BATCH) {
+      const batch = pending.slice(i, i + PUSH_BATCH)
+        .map(({ id, type, v, occurredAt, payload }) => ({ id, type, v, occurredAt, payload }));
+      const result = await call('POST', '/v1/events', { events: batch });
+      const done = new Set([...result.accepted, ...result.duplicates]);
+      pushed += result.accepted.length;
+      state.outbox = state.outbox.filter(id => !done.has(id));
+      await eventLog.saveSyncState(state);
+    }
+  }
+
+  const fresh = [];
+  let hasMore = true;
+  while (hasMore) {
+    const page = await call('GET', `/v1/events?since=${state.cursor}`);
+    fresh.push(...await eventLog.mergeRemoteEvents(page.events));
+    state.cursor = page.nextCursor;
+    hasMore = page.hasMore;
+    await eventLog.saveSyncState(state);
+  }
+
+  if (fresh.length > 0) await rebuild.rebuild(fresh);
+
+  state.lastSyncAt = new Date().toISOString();
+  await eventLog.saveSyncState(state);
+  return { pushed, pulled: fresh.length };
+}
+
+/**
+ * Best-effort sync for everyday commands: a no-op when logged out, a short
+ * timeout, and never throws. Offline is normal; the outbox is pushed next time.
+ * The only output is a one-line hint on stderr, and only in a terminal, so
+ * piped output (`devgrowth config show | jq`) stays clean.
+ */
+export async function trySync() {
+  if (!(await auth.isLoggedIn())) return null;
+  try {
+    return await sync({ timeoutMs: 3000 });
+  } catch (err) {
+    if (process.stderr.isTTY) {
+      const hint = err.status === 401
+        ? 'Sync: your login expired or was revoked. Run `devgrowth login` to sync again.'
+        : 'Sync: offline, changes are saved locally and will sync later.';
+      process.stderr.write(`${chalk.gray(hint)}\n`);
+    }
+    return { error: err };
+  }
+}