devgrowth 1.0.1 → 1.1.0

package/src/core/configManager.js

@@ -1,70 +1,57 @@
-import * as storage from './storage.js';
-import * as path from 'path';
-
-const DEFAULT_CONFIG = {
-  version: '1.0.0',
-  user: 'Saw Eh Doh Wah',
-  schedule: {
-    mon: { skill: 'laravel', resource: 'Laravel Daily', url: 'https://youtube.com/@LaravelDaily', focus: 'Deepen' },
-    tue: { skill: 'vue',     resource: 'Vue School',   url: 'https://vueschool.io',         focus: 'Sharpen' },
-    wed: { skill: 'rust',    resource: 'The Rust Book',url: 'https://doc.rust-lang.org/book', focus: 'Start' },
-    thu: { skill: 'laravel', resource: 'Laravel Daily', url: 'https://youtube.com/@LaravelDaily', focus: 'Apply to HRMS' },
-    fri: { skill: 'vue',     resource: 'Vue School',   url: 'https://vueschool.io',         focus: 'Build component' },
-    sat: { skill: 'review',  resource: null,           url: null,                           focus: 'Weekly review' },
-    sun: { skill: 'rest',    resource: null,           url: null,                           focus: 'Full off day' }
-  },
-  session: {
-    startTime: '21:00',
-    durationMinutes: 20,
-    warmupMinutes: 5,
-    logMinutes: 5,
-    lateNightMode: true
-  },
-  notification: {
-    enabled: true,
-    reminderMinutesBefore: 5
-  }
-};
-
-export async function createDefaultConfig() {
-  const configPath = path.join(storage.getDevGrowthDir(), 'config.json');
-  await storage.writeJson(configPath, DEFAULT_CONFIG);
-  return DEFAULT_CONFIG;
-}
-
-export async function getConfig() {
-  const configPath = path.join(storage.getDevGrowthDir(), 'config.json');
-  const exists = await storage.fileExists(configPath);
-  if (!exists) {
-    throw new Error('Config not found. Run `devgrowth init` first.');
-  }
-  return await storage.readJson(configPath);
-}
-
-export async function updateConfig(updates) {
-  const config = await getConfig();
-  const merged = { ...config, ...updates };
-  // Deep merge for nested objects (simple version)
-  for (const key of Object.keys(updates)) {
-    if (typeof updates[key] === 'object' && !Array.isArray(updates[key]) && updates[key] !== null) {
-      merged[key] = { ...config[key], ...updates[key] };
-    }
-  }
-  const configPath = path.join(storage.getDevGrowthDir(), 'config.json');
-  await storage.writeJson(configPath, merged);
-}
-
-export async function setConfigValue(keyPath, value) {
-  const config = JSON.parse(JSON.stringify(await getConfig()));
-  const keys = keyPath.split('.');
-  let target = config;
-  for (let i = 0; i < keys.length - 1; i++) {
-    if (typeof target[keys[i]] !== 'object' || target[keys[i]] === null) {
-      throw new Error(`Invalid key path: "${keyPath}" — "${keys[i]}" is not an object.`);
-    }
-    target = target[keys[i]];
-  }
-  target[keys[keys.length - 1]] = value;
-  const configPath = path.join(storage.getDevGrowthDir(), 'config.json');
-  await storage.writeJson(configPath, config);
-}
+import * as storage from './storage.js';
+import * as path from 'path';
+import * as derive from 'devgrowth-core/derive';
+
+export const DEFAULT_CONFIG = derive.DEFAULT_CONFIG;
+
+function getConfigPath() {
+  return path.join(storage.getDevGrowthDir(), 'config.json');
+}
+
+/** Write config.json as-is. Sync notices the change and records it (see sync.js). */
+export async function saveConfig(config) {
+  await storage.writeJson(getConfigPath(), config);
+}
+
+export async function createDefaultConfig() {
+  const configPath = path.join(storage.getDevGrowthDir(), 'config.json');
+  await storage.writeJson(configPath, DEFAULT_CONFIG);
+  return DEFAULT_CONFIG;
+}
+
+export async function getConfig() {
+  const configPath = path.join(storage.getDevGrowthDir(), 'config.json');
+  const exists = await storage.fileExists(configPath);
+  if (!exists) {
+    throw new Error('Config not found. Run `devgrowth init` first.');
+  }
+  return await storage.readJson(configPath);
+}
+
+export async function updateConfig(updates) {
+  const config = await getConfig();
+  const merged = { ...config, ...updates };
+  // Deep merge for nested objects (simple version)
+  for (const key of Object.keys(updates)) {
+    if (typeof updates[key] === 'object' && !Array.isArray(updates[key]) && updates[key] !== null) {
+      merged[key] = { ...config[key], ...updates[key] };
+    }
+  }
+  const configPath = path.join(storage.getDevGrowthDir(), 'config.json');
+  await storage.writeJson(configPath, merged);
+}
+
+export async function setConfigValue(keyPath, value) {
+  const config = JSON.parse(JSON.stringify(await getConfig()));
+  const keys = keyPath.split('.');
+  let target = config;
+  for (let i = 0; i < keys.length - 1; i++) {
+    if (typeof target[keys[i]] !== 'object' || target[keys[i]] === null) {
+      throw new Error(`Invalid key path: "${keyPath}" — "${keys[i]}" is not an object.`);
+    }
+    target = target[keys[i]];
+  }
+  target[keys[keys.length - 1]] = value;
+  const configPath = path.join(storage.getDevGrowthDir(), 'config.json');
+  await storage.writeJson(configPath, config);
+}

package/src/core/eventLog.js

@@ -0,0 +1,112 @@
+import * as storage from './storage.js';
+import * as path from 'path';
+import { randomUUID } from 'crypto';
+import * as coreEvents from 'devgrowth-core/events';
+import * as derive from 'devgrowth-core/derive';
+
+// The local copy of this user's sync events (see packages/core/SYNC_API.md).
+//
+//   events.jsonl  every event, recorded here or pulled from the server, one JSON object per line
+//   sync.json     { cursor, outbox, lastSyncAt }: pull position and ids not yet pushed
+//
+// Events are recorded whether or not the user is logged in, so nothing done
+// offline (or before `devgrowth login`) is lost.
+
+function eventsPath() {
+  return path.join(storage.getDevGrowthDir(), 'events.jsonl');
+}
+
+function syncStatePath() {
+  return path.join(storage.getDevGrowthDir(), 'sync.json');
+}
+
+export async function getSyncState() {
+  const file = syncStatePath();
+  const state = (await storage.fileExists(file)) ? await storage.readJson(file) : {};
+  return { cursor: 0, outbox: [], lastSyncAt: null, ...state };
+}
+
+export async function saveSyncState(state) {
+  await storage.writeJson(syncStatePath(), state);
+}
+
+/** Validate, append and queue an event for the next push. Returns the event. */
+export async function recordEvent(type, payload, occurredAt = new Date()) {
+  const event = coreEvents.assertValidEvent({
+    id: randomUUID(),
+    type,
+    v: coreEvents.SCHEMA_VERSION,
+    occurredAt: occurredAt.toISOString(),
+    payload
+  });
+  await storage.appendFile(eventsPath(), `${JSON.stringify(event)}\n`);
+  const state = await getSyncState();
+  state.outbox.push(event.id);
+  await saveSyncState(state);
+  return event;
+}
+
+/**
+ * Record a session. `date` is the session-adjusted date the command already
+ * uses for its log entry (`schedule.getSessionDate(new Date())`).
+ */
+export async function recordSession(date, { skill, resource, duration, status, message }) {
+  return recordEvent('session', {
+    skill,
+    resource: resource ?? null,
+    duration,
+    status,
+    message,
+    ...derive.sessionKeysFor(date),
+    startedAt: date.toTimeString().slice(0, 5)
+  });
+}
+
+export async function recordReview(date) {
+  return recordEvent('review', derive.reviewKeysFor(date));
+}
+
+/**
+ * Every event, de-duplicated by id. A line that isn't valid JSON (for example a
+ * write cut off by a crash) is skipped rather than breaking every command.
+ */
+export async function readAllEvents() {
+  const file = eventsPath();
+  if (!(await storage.fileExists(file))) return [];
+  const seen = new Set();
+  const events = [];
+  for (const line of (await storage.readFile(file)).split('\n')) {
+    if (!line.trim()) continue;
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!event?.id || seen.has(event.id)) continue;
+    seen.add(event.id);
+    events.push(event);
+  }
+  return events;
+}
+
+/** Append events pulled from the server that aren't already here; returns just those. */
+export async function mergeRemoteEvents(list) {
+  const known = new Set((await readAllEvents()).map(e => e.id));
+  const fresh = [];
+  for (const { id, type, v, occurredAt, payload, deviceId } of list) {
+    if (known.has(id)) continue;
+    known.add(id);
+    fresh.push({ id, type, v, occurredAt, payload, ...(deviceId ? { deviceId } : {}) });
+  }
+  if (fresh.length > 0) {
+    await storage.appendFile(eventsPath(), fresh.map(e => `${JSON.stringify(e)}\n`).join(''));
+  }
+  return fresh;
+}
+
+/** Forget the local event log and sync position (used when adopting an account's history). */
+export async function resetLocalLog() {
+  await storage.removePath(eventsPath());
+  await storage.removePath(syncStatePath());
+}

package/src/core/logger.js

@@ -1,62 +1,62 @@
-import * as storage from './storage.js';
-import * as path from 'path';
-import { formatDate as scheduleFormatDate, getWeekStart, getWeekFileName } from './schedule.js';
-
-function formatTime(date) {
-  return date.toTimeString().slice(0, 5);
-}
-
-export async function writeLogEntry(date, skill, resource, duration, status, message) {
-  // Key the file by the week's Monday so a week straddling a month or year
-  // boundary stays in a single file (e.g. Mon Jul 27 – Sun Aug 2 → 2026/07).
-  const weekStart = getWeekStart(date);
-  const year = weekStart.getFullYear();
-  const month = String(weekStart.getMonth() + 1).padStart(2, '0');
-  const weekFile = getWeekFileName(date);
-  const filePath = path.join(storage.getDevGrowthDir(), 'logs', String(year), month, weekFile);
-
-  const exists = await storage.fileExists(filePath);
-  let content = '';
-
-  if (!exists) {
-    const weekEnd = new Date(weekStart);
-    weekEnd.setDate(weekEnd.getDate() + 6);
-    content = `# DevGrowth Log — ${getWeekFileName(date).replace('.md', '')} (${scheduleFormatDate(weekStart)} – ${scheduleFormatDate(weekEnd)}, ${year})\n\n`;
-  } else {
-    content = await storage.readFile(filePath);
-  }
-
-  // Check for duplicate log warning
-  const dayHeader = `## ${scheduleFormatDate(date)}`;
-  if (content.includes(dayHeader)) {
-    console.warn(`⚠️  Warning: A log for ${scheduleFormatDate(date)} already exists. Appending anyway.`);
-  }
-
-  const statusEmoji = status === 'Completed' ? '✅' : status === 'Light' ? '🟡' : '⏹️';
-  const entry = `## ${scheduleFormatDate(date)}\n- **Skill:** ${skill}\n- **Resource:** ${resource || 'N/A'}\n- **Started:** ${formatTime(date)}\n- **Timer:** ${duration} min\n- **Status:** ${statusEmoji} ${status}\n- **Log:** ${message}\n\n`;
-
-  content += entry;
-  await storage.writeFile(filePath, content);
-  return filePath;
-}
-
-export async function readWeekLogs(year, month, weekFileName) {
-  const filePath = path.join(storage.getDevGrowthDir(), 'logs', String(year), month, weekFileName);
-  const exists = await storage.fileExists(filePath);
-  if (!exists) return '';
-  return await storage.readFile(filePath);
-}
-
-export function parseLogEntries(logs) {
-  const entries = [];
-  const blocks = logs.split(/\n(?=## )/);
-  for (const block of blocks) {
-    const dateMatch = block.match(/^## (.+)\n/);
-    if (!dateMatch) continue;
-    const date = dateMatch[1].trim();
-    const messageMatch = block.match(/- \*\*Log:\*\* (.+)/);
-    const message = messageMatch ? messageMatch[1].trim() : '';
-    entries.push({ date, message });
-  }
-  return entries;
-}
+import * as storage from './storage.js';
+import * as path from 'path';
+import { formatDate as scheduleFormatDate, getWeekStart, getWeekFileName } from './schedule.js';
+
+function formatTime(date) {
+  return date.toTimeString().slice(0, 5);
+}
+
+export async function writeLogEntry(date, skill, resource, duration, status, message, { quiet = false } = {}) {
+  // Key the file by the week's Monday so a week straddling a month or year
+  // boundary stays in a single file (e.g. Mon Jul 27 – Sun Aug 2 → 2026/07).
+  const weekStart = getWeekStart(date);
+  const year = weekStart.getFullYear();
+  const month = String(weekStart.getMonth() + 1).padStart(2, '0');
+  const weekFile = getWeekFileName(date);
+  const filePath = path.join(storage.getDevGrowthDir(), 'logs', String(year), month, weekFile);
+
+  const exists = await storage.fileExists(filePath);
+  let content = '';
+
+  if (!exists) {
+    const weekEnd = new Date(weekStart);
+    weekEnd.setDate(weekEnd.getDate() + 6);
+    content = `# DevGrowth Log — ${getWeekFileName(date).replace('.md', '')} (${scheduleFormatDate(weekStart)} – ${scheduleFormatDate(weekEnd)}, ${year})\n\n`;
+  } else {
+    content = await storage.readFile(filePath);
+  }
+
+  // Check for duplicate log warning
+  const dayHeader = `## ${scheduleFormatDate(date)}`;
+  if (content.includes(dayHeader) && !quiet) {
+    console.warn(`⚠️  Warning: A log for ${scheduleFormatDate(date)} already exists. Appending anyway.`);
+  }
+
+  const statusEmoji = status === 'Completed' ? '✅' : status === 'Light' ? '🟡' : '⏹️';
+  const entry = `## ${scheduleFormatDate(date)}\n- **Skill:** ${skill}\n- **Resource:** ${resource || 'N/A'}\n- **Started:** ${formatTime(date)}\n- **Timer:** ${duration} min\n- **Status:** ${statusEmoji} ${status}\n- **Log:** ${message}\n\n`;
+
+  content += entry;
+  await storage.writeFile(filePath, content);
+  return filePath;
+}
+
+export async function readWeekLogs(year, month, weekFileName) {
+  const filePath = path.join(storage.getDevGrowthDir(), 'logs', String(year), month, weekFileName);
+  const exists = await storage.fileExists(filePath);
+  if (!exists) return '';
+  return await storage.readFile(filePath);
+}
+
+export function parseLogEntries(logs) {
+  const entries = [];
+  const blocks = logs.split(/\n(?=## )/);
+  for (const block of blocks) {
+    const dateMatch = block.match(/^## (.+)\n/);
+    if (!dateMatch) continue;
+    const date = dateMatch[1].trim();
+    const messageMatch = block.match(/- \*\*Log:\*\* (.+)/);
+    const message = messageMatch ? messageMatch[1].trim() : '';
+    entries.push({ date, message });
+  }
+  return entries;
+}

package/src/core/milestones.js

@@ -1,72 +1,62 @@
-import * as storage from './storage.js';
-import * as path from 'path';
-
-export const DEFAULT_MILESTONES = {
-  laravel: {
-    m1: { title: 'Know it deeper', items: { formRequests: false, policies: false, featureTest: false, refactorService: false } },
-    m2: { title: 'Build confidently', items: { queuedJob: false, observer: false, tests3: false, redisCache: false } },
-    m3: { title: 'Own the stack', items: { pipeline: false, package: false, explainArch: false, tests30: false } }
-  },
-  vue: {
-    m1: { title: 'Composition solid', items: { scriptSetup: false, coreApis: false, composable: false, noOptionsApi: false } },
-    m2: { title: 'State & patterns', items: { pinia: false, asyncHandling: false, composables3: false, lazyLoad: false } },
-    m3: { title: 'Performance aware', items: { memoryLeak: false, treeShake: false, unitTests5: false, teachJunior: false } }
-  },
-  rust: {
-    m1: { title: 'Survive the compiler', items: { bookCh6: false, ownership: false, helloWorld: false, fix10Errors: false } },
-    m2: { title: 'Think in Rust', items: { bookCh13: false, rustlings10: false, errorHandling: false, explainBorrowing: false } },
-    m3: { title: 'Ship something small', items: { cliTool: false, traits: false, fileIO: false, githubPush: false } }
-  }
-};
-
-function getMilestonesPath() {
-  return path.join(storage.getDevGrowthDir(), 'milestones.json');
-}
-
-export async function getMilestones() {
-  const milestonesPath = getMilestonesPath();
-  const exists = await storage.fileExists(milestonesPath);
-  if (!exists) {
-    return JSON.parse(JSON.stringify(DEFAULT_MILESTONES));
-  }
-  return await storage.readJson(milestonesPath);
-}
-
-export async function saveMilestones(data) {
-  await storage.writeJson(getMilestonesPath(), data);
-}
-
-export async function checkMilestone(skill, month, item) {
-  const milestones = await getMilestones();
-  if (!milestones[skill]) {
-    throw new Error(`Unknown skill: ${skill}`);
-  }
-  const monthKey = month.toString().toLowerCase();
-  if (!milestones[skill][monthKey]) {
-    throw new Error(`Invalid month: ${month}`);
-  }
-  const items = milestones[skill][monthKey].items;
-  if (!(item in items)) {
-    throw new Error(`Invalid item: ${item}`);
-  }
-  items[item] = true;
-  await saveMilestones(milestones);
-  return milestones[skill];
-}
-
-export async function getProgress(skill) {
-  const milestones = await getMilestones();
-  if (!milestones[skill]) {
-    throw new Error(`Unknown skill: ${skill}`);
-  }
-  let total = 0;
-  let completed = 0;
-  for (const month of Object.values(milestones[skill])) {
-    for (const value of Object.values(month.items)) {
-      total += 1;
-      if (value) completed += 1;
-    }
-  }
-  const percentage = total > 0 ? Math.round((completed / total) * 100) : 0;
-  return { total, completed, percentage };
-}
+import * as storage from './storage.js';
+import * as path from 'path';
+import * as derive from 'devgrowth-core/derive';
+import * as eventLog from './eventLog.js';
+
+// Defaults live in devgrowth-core so milestone events validate identically everywhere.
+export const DEFAULT_MILESTONES = derive.DEFAULT_MILESTONES;
+
+function getMilestonesPath() {
+  return path.join(storage.getDevGrowthDir(), 'milestones.json');
+}
+
+export async function getMilestones() {
+  const milestonesPath = getMilestonesPath();
+  const exists = await storage.fileExists(milestonesPath);
+  if (!exists) {
+    return JSON.parse(JSON.stringify(DEFAULT_MILESTONES));
+  }
+  return await storage.readJson(milestonesPath);
+}
+
+export async function saveMilestones(data) {
+  await storage.writeJson(getMilestonesPath(), data);
+}
+
+export async function checkMilestone(skill, month, item) {
+  const milestones = await getMilestones();
+  // Own-property checks only: `in` and plain lookups also match inherited
+  // names like `toString`, which would write junk keys or crash.
+  if (!Object.hasOwn(milestones, skill)) {
+    throw new Error(`Unknown skill: ${skill}`);
+  }
+  const monthKey = month.toString().toLowerCase();
+  if (!Object.hasOwn(milestones[skill], monthKey)) {
+    throw new Error(`Invalid month: ${month}`);
+  }
+  const items = milestones[skill][monthKey].items;
+  if (!Object.hasOwn(items, item)) {
+    throw new Error(`Invalid item: ${item}`);
+  }
+  items[item] = true;
+  await saveMilestones(milestones);
+  await eventLog.recordEvent('milestone_check', { skill, month: monthKey, item });
+  return milestones[skill];
+}
+
+export async function getProgress(skill) {
+  const milestones = await getMilestones();
+  if (!Object.hasOwn(milestones, skill)) {
+    throw new Error(`Unknown skill: ${skill}`);
+  }
+  let total = 0;
+  let completed = 0;
+  for (const month of Object.values(milestones[skill])) {
+    for (const value of Object.values(month.items)) {
+      total += 1;
+      if (value) completed += 1;
+    }
+  }
+  const percentage = total > 0 ? Math.round((completed / total) * 100) : 0;
+  return { total, completed, percentage };
+}

package/src/core/prompt.js

@@ -0,0 +1,58 @@
+import * as readline from 'readline';
+
+// Terminal prompts for login. When stdin is not a terminal (scripts, CI, tests)
+// answers are read line by line from stdin instead, e.g.
+//   printf 'my password\n' | devgrowth login --email me@example.com
+
+let pipedLines = null;
+
+async function nextPipedLine() {
+  if (pipedLines === null) {
+    let input = '';
+    for await (const chunk of process.stdin) input += chunk;
+    pipedLines = input.split(/\r?\n/);
+  }
+  return pipedLines.length > 0 ? pipedLines.shift() : '';
+}
+
+export async function ask(question) {
+  if (!process.stdin.isTTY) return (await nextPipedLine()).trim();
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return (await new Promise(resolve => rl.question(question, resolve))).trim();
+  } finally {
+    rl.close();
+  }
+}
+
+/** Like `ask`, but typed characters are not echoed. */
+export async function askHidden(question) {
+  if (!process.stdin.isTTY) return nextPipedLine();
+  return new Promise((resolve, reject) => {
+    const stdin = process.stdin;
+    let value = '';
+    process.stdout.write(question);
+    stdin.setRawMode(true);
+    stdin.setEncoding('utf8');
+    stdin.resume();
+
+    function finish(error) {
+      stdin.removeListener('data', onData);
+      stdin.setRawMode(false);
+      stdin.pause();
+      process.stdout.write('\n');
+      if (error) reject(error); else resolve(value);
+    }
+
+    function onData(chunk) {
+      for (const ch of chunk) {
+        if (ch === '\r' || ch === '\n') return finish();
+        if (ch === '\u0003') return finish(new Error('Cancelled.')); // Ctrl+C
+        if (ch === '\u007f' || ch === '\b') value = value.slice(0, -1);
+        else if (ch >= ' ') value += ch;
+      }
+    }
+
+    stdin.on('data', onData);
+  });
+}

package/src/core/rebuild.js

@@ -0,0 +1,37 @@
+import * as derive from 'devgrowth-core/derive';
+import * as eventLog from './eventLog.js';
+import * as stats from './stats.js';
+import * as milestones from './milestones.js';
+import * as configManager from './configManager.js';
+import * as logger from './logger.js';
+
+/** The local Date a session's log entry is written under: its session day at `startedAt`. */
+function logDateFor(payload) {
+  const [y, m, d] = payload.sessionDate.split('-').map(Number);
+  const [hh, mm] = (payload.startedAt || '21:00').split(':').map(Number);
+  return new Date(y, m - 1, d, hh, mm);
+}
+
+/**
+ * Re-derive stats.json, milestones.json and config.json from the full event
+ * log, exactly as every other device and the dashboard do, and append log
+ * entries for sessions that arrived from other devices.
+ *
+ * Markdown logs are only ever appended to, never regenerated, so notes you
+ * typed into a week file by hand survive a sync.
+ */
+export async function rebuild(newRemoteEvents = []) {
+  const state = derive.deriveState(await eventLog.readAllEvents());
+  await stats.saveStats(state.stats);
+  await milestones.saveMilestones(state.milestones);
+  // No config in any event (can't normally happen after a baseline): keep the local file.
+  if (state.config) await configManager.saveConfig(state.config);
+
+  const sessions = newRemoteEvents
+    .filter(e => e.type === 'session')
+    .sort((a, b) => Date.parse(a.occurredAt) - Date.parse(b.occurredAt));
+  for (const { payload: p } of sessions) {
+    await logger.writeLogEntry(logDateFor(p), p.skill, p.resource, p.duration, p.status, p.message, { quiet: true });
+  }
+  return state;
+}