devgrowth 1.0.0

package/src/core/stats.js

@@ -0,0 +1,130 @@
+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 };
+}

package/src/core/storage.js

@@ -0,0 +1,33 @@
+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);
+}

package/src/core/timer.js

@@ -0,0 +1,72 @@
+export async function start(durationSeconds, options = {}) {
+  const {
+    onTick,
+    onWarning,
+    onComplete,
+    tickInterval = 1,
+    abortSignal
+  } = options;
+
+  const durationMs = durationSeconds * 1000;
+  const startTime = Date.now();
+  const warningTime = durationMs - 60000; // 1 minute warning if >= 1 min
+
+  return new Promise((resolve) => {
+    let settled = false;
+    let interval;
+    let completionTimeout;
+
+    function cleanup() {
+      clearInterval(interval);
+      clearTimeout(completionTimeout);
+      process.removeListener('SIGINT', sigintHandler);
+      if (abortSignal) {
+        abortSignal.removeEventListener('abort', abortHandler);
+      }
+    }
+
+    function settle(value) {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve(value);
+    }
+
+    function abortHandler() {
+      settle({ completed: false, interrupted: true });
+    }
+
+    function sigintHandler() {
+      settle({ completed: false, interrupted: true });
+    }
+
+    if (abortSignal) {
+      if (abortSignal.aborted) {
+        settle({ completed: false, interrupted: true });
+        return;
+      }
+      abortSignal.addEventListener('abort', abortHandler);
+    }
+
+    process.once('SIGINT', sigintHandler);
+
+    interval = setInterval(() => {
+      const elapsed = Date.now() - startTime;
+      const remaining = Math.max(0, durationMs - elapsed);
+
+      if (onTick) {
+        onTick(Math.ceil(remaining / 1000));
+      }
+
+      if (onWarning && durationMs >= 60000 && elapsed >= warningTime && elapsed < warningTime + tickInterval * 1000) {
+        onWarning();
+      }
+    }, tickInterval * 1000);
+
+    // Ensure the timer resolves exactly when the duration elapses
+    completionTimeout = setTimeout(() => {
+      if (onComplete) onComplete();
+      settle({ completed: true, interrupted: false });
+    }, durationMs);
+  });
+}

package/src/index.js

@@ -0,0 +1,152 @@
+import { Command } from 'commander';
+import { initCommand } from './commands/init.js';
+import { startCommand } from './commands/start.js';
+import { logCommand } from './commands/log.js';
+import { statusCommand } from './commands/status.js';
+import { reviewCommand } from './commands/review.js';
+import { milestoneCommand } from './commands/milestone.js';
+import { historyCommand } from './commands/history.js';
+import { configCommand } from './commands/config.js';
+import { notifyCommand } from './commands/notify.js';
+import { printBanner } from './core/banner.js';
+
+export const program = new Command();
+
+program
+  .name('devgrowth')
+  .description('Zero-friction developer growth CLI')
+  .version('1.0.0');
+
+// Bare `devgrowth` is the splash screen: banner, then the command list.
+program.action(async () => {
+  await printBanner();
+  program.outputHelp();
+});
+
+program
+  .command('banner')
+  .description('Show the DevGrowth banner and current stats')
+  .option('--compact', 'Render the single-line banner')
+  .action(async (options) => {
+    try {
+      await printBanner({ force: true, compact: options.compact });
+    } catch (err) {
+      console.error('Error:', err.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('init')
+  .description('Initialize DevGrowth configuration and directories')
+  .action(async () => {
+    try {
+      await initCommand();
+    } catch (err) {
+      console.error('Error:', err.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('start')
+  .description('Start tonight\'s session')
+  .option('--light', 'Skip timer for low-energy sessions')
+  .option('--no-banner', 'Skip the startup banner')
+  .action(async (options) => {
+    try {
+      await startCommand(options);
+    } catch (err) {
+      console.error('Error:', err.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('log <message>')
+  .description('Write your 2-sentence session log')
+  .option('--light', 'Mark as light session')
+  .action(async (message, options) => {
+    try {
+      await logCommand(message, options);
+    } catch (err) {
+      console.error('Error:', err.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('status')
+  .description('Show this week\'s progress and streak')
+  .action(async () => {
+    try {
+      await statusCommand();
+    } catch (err) {
+      console.error('Error:', err.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('review')
+  .description('Review this week and finalize streak')
+  .action(async () => {
+    try {
+      await reviewCommand();
+    } catch (err) {
+      console.error('Error:', err.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('milestone <subcommand> [args...]')
+  .description('Milestone tracker: list, check, progress')
+  .action(async (subcommand, args) => {
+    try {
+      await milestoneCommand(subcommand, args || []);
+    } catch (err) {
+      console.error('Error:', err.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('history')
+  .description('Show session history')
+  .option('--week <number>', 'Show specific week')
+  .option('--year <number>', 'Year for --week (defaults to current year)')
+  .option('--skill <name>', 'Filter by skill')
+  .option('--search <query>', 'Full-text search across logs')
+  .action(async (options) => {
+    try {
+      await historyCommand(options);
+    } catch (err) {
+      console.error('Error:', err.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('config <subcommand> [args...]')
+  .description('Configuration: show, set, edit')
+  .action(async (subcommand, args) => {
+    try {
+      await configCommand(subcommand, args || []);
+    } catch (err) {
+      console.error('Error:', err.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('notify')
+  .description('Send tonight\'s desktop notification (internal use)')
+  .action(async () => {
+    try {
+      await notifyCommand();
+    } catch (err) {
+      console.error('Error:', err.message);
+      process.exit(1);
+    }
+  });