devgrowth 1.0.0

package/src/core/banner.js

@@ -0,0 +1,293 @@
+import * as os from 'os';
+import * as path from 'path';
+import chalk from 'chalk';
+import * as configManager from './configManager.js';
+import * as schedule from './schedule.js';
+import * as stats from './stats.js';
+import * as storage from './storage.js';
+
+export const VERSION = '1.0.0';
+export const TAGLINE = 'Zero-friction developer growth';
+
+// Each glyph is an 8-row pixel grid, 5 columns wide. Capitals and ascenders
+// use all 8 rows; lowercase letters occupy the x-height rows (3-7).
+const GLYPHS = {
+  d: ['....#', '....#', '....#', '.####', '#...#', '#...#', '#...#', '.####'],
+  e: ['.....', '.....', '.....', '.###.', '#...#', '#####', '#....', '.###.'],
+  v: ['.....', '.....', '.....', '#...#', '#...#', '#...#', '.#.#.', '..#..'],
+  G: ['.###.', '#...#', '#....', '#....', '#.###', '#...#', '#...#', '.####'],
+  r: ['.....', '.....', '.....', '#.##.', '##...', '#....', '#....', '#....'],
+  o: ['.....', '.....', '.....', '.###.', '#...#', '#...#', '#...#', '.###.'],
+  w: ['.....', '.....', '.....', '#...#', '#...#', '#.#.#', '##.##', '#...#'],
+  t: ['.....', '..#..', '..#..', '.###.', '..#..', '..#..', '..#..', '..###'],
+  h: ['#....', '#....', '#....', '#.##.', '##..#', '#...#', '#...#', '#...#']
+};
+
+const GLYPH_WIDTH = 5;
+const GLYPH_GAP = 1;
+const NAME = 'devGrowth';
+
+// Half blocks pair two pixel rows into one text row, so 8 pixel rows render as
+// 4 lines. Only ▀ ▄ █ are used, which the legacy Windows console also has.
+function halfBlock(top, bottom) {
+  if (top === '#' && bottom === '#') return '█';
+  if (top === '#') return '▀';
+  if (bottom === '#') return '▄';
+  return ' ';
+}
+
+export function renderWordmark(word = NAME) {
+  const rows = [];
+  for (let pair = 0; pair < 4; pair++) {
+    let line = '';
+    for (const ch of word) {
+      const glyph = GLYPHS[ch];
+      if (!glyph) continue;
+      for (let col = 0; col < GLYPH_WIDTH; col++) {
+        line += halfBlock(glyph[pair * 2][col], glyph[pair * 2 + 1][col]);
+      }
+      line += ' '.repeat(GLYPH_GAP);
+    }
+    rows.push(line.slice(0, line.length - GLYPH_GAP));
+  }
+  return rows;
+}
+
+export const WORDMARK = renderWordmark();
+export const WORDMARK_WIDTH = WORDMARK[0].length;
+
+// "dev" is three glyphs wide; the rest is "Growth". Splitting here lets the
+// camelCase read as two tones the way the written name does.
+const DEV_SPLIT = 3 * (GLYPH_WIDTH + GLYPH_GAP);
+
+function colorWordmark() {
+  return WORDMARK.map(line =>
+    chalk.gray(line.slice(0, DEV_SPLIT)) + chalk.green(line.slice(DEV_SPLIT))
+  );
+}
+
+// Stored verbatim — the fullwidth characters (＿ ／ Ｙ ｿ ＃) and the ideographic
+// spaces (U+3000) are load-bearing alignment, not padding. Only the leading
+// newline is stripped: String#trimStart would also eat the U+3000 spaces that
+// indent the first row, shearing the shell off the body.
+export const TURTLE_ART = `
+　　  ＿＿　　＿
+　 ／ ♯ ＃ ＼/･_)
+（ｿ♯ ＃ ♯ ＃Ｙ／
+　(_)――-(_)′`.replace(/^\r?\n/, '');
+
+export const TURTLE_ROWS = TURTLE_ART.split('\n');
+
+// Gap between the wordmark and the turtle riding beside it.
+const MASCOT_GAP = 2;
+
+// Measures printable width, ignoring the ANSI escapes chalk injects.
+const ANSI = /\x1b\[[0-9;]*m/g;
+export function visibleLength(str) {
+  return str.replace(ANSI, '').length;
+}
+
+// Ranges the Unicode East Asian Width table marks Wide or Fullwidth, which a
+// terminal draws in two cells. Covers what the turtle uses: U+3000 (ideographic
+// space) and the fullwidth forms ＿ ／ ＃ ＼ （ Ｙ at U+FF01–FF60. Deliberately
+// excludes U+FF61–FFDC — the halfwidth katakana ｿ and ･ occupy one cell.
+const WIDE = /[ᄀ-ᅟ⺀-〾ぁ-㏿㐀-䶿一-鿿ꀀ-꓏가-힣豈-﫿︰-﹯！-｠￠-￦]/;
+
+/**
+ * Terminal columns a string occupies. `visibleLength` counts code points, which
+ * under-reports any fullwidth character — use this wherever the answer feeds a
+ * layout decision.
+ */
+export function displayWidth(str) {
+  let cells = 0;
+  for (const ch of str.replace(ANSI, '')) {
+    cells += WIDE.test(ch) ? 2 : 1;
+  }
+  return cells;
+}
+
+function terminalWidth(stream = process.stdout) {
+  return stream && stream.columns ? stream.columns : 80;
+}
+
+function tildify(absPath) {
+  const home = os.homedir();
+  const short = absPath.startsWith(home) ? `~${absPath.slice(home.length)}` : absPath;
+  // Display with forward slashes to match the paths the other commands print.
+  return short.split(path.sep).join('/');
+}
+
+export function plural(count, word) {
+  return `${count} ${word}${count === 1 ? '' : 's'}`;
+}
+
+// Caps a raw (uncolored) value so one long resource name cannot blow out the
+// panel width. Must run before chalk wraps the string in escape codes.
+export function clip(str, max) {
+  const value = String(str);
+  return value.length <= max ? value : `${value.slice(0, max - 1)}…`;
+}
+
+export function renderBar(completed, total, width = 5) {
+  if (!total || total <= 0) return '░'.repeat(width);
+  const ratio = Math.max(0, Math.min(1, completed / total));
+  const filled = Math.round(ratio * width);
+  return '█'.repeat(filled) + '░'.repeat(width - filled);
+}
+
+/**
+ * Decides whether the automatic banner should be drawn. Suppressed when output
+ * is piped or redirected so `devgrowth ... | jq` and cron-style runs stay clean.
+ */
+export function shouldShowBanner(env = process.env, stream = process.stdout) {
+  if (env.DEVGROWTH_NO_BANNER) return false;
+  if (env.DEVGROWTH_BANNER) return true;
+  return Boolean(stream && stream.isTTY);
+}
+
+/**
+ * Reads config/stats for the info panel. Never throws — a missing config just
+ * means DevGrowth has not been initialized yet, which the panel reports.
+ */
+export async function gatherContext(now = new Date()) {
+  const ctx = {
+    version: VERSION,
+    user: os.userInfo().username,
+    host: clip(os.hostname(), 24),
+    node: process.version,
+    dataDir: clip(tildify(storage.getDevGrowthDir()), 32),
+    initialized: false
+  };
+
+  let config;
+  try {
+    config = await configManager.getConfig();
+  } catch {
+    return ctx;
+  }
+
+  ctx.initialized = true;
+  ctx.user = config.user || ctx.user;
+
+  try {
+    const today = schedule.getTodaySkill(config, now);
+    ctx.skill = today.skill;
+    ctx.focus = today.focus;
+    ctx.resource = today.resource;
+    ctx.startTime = config.session?.startTime;
+    ctx.durationMinutes = config.session?.durationMinutes;
+  } catch { /* a hand-edited schedule should not break the banner */ }
+
+  try {
+    const s = await stats.getStats();
+    const weekProgress = stats.getCurrentWeekProgress(s, now);
+    ctx.weekNumber = schedule.getWeekNumber(schedule.getSessionDate(now));
+    ctx.weekCompleted = weekProgress.completed;
+    ctx.weekTotal = weekProgress.total;
+    ctx.currentStreakWeeks = s.currentStreakWeeks || 0;
+    ctx.longestStreakWeeks = s.longestStreakWeeks || 0;
+    ctx.totalSessions = s.totalSessions || 0;
+    ctx.totalMinutes = s.totalMinutesDeepWork || 0;
+  } catch { /* unreadable stats.json should not break the banner */ }
+
+  return ctx;
+}
+
+export function buildInfoRows(ctx) {
+  const rows = [];
+
+  if (!ctx.initialized) {
+    rows.push(['Status', chalk.yellow('not initialized')]);
+    rows.push(['Setup', `run ${chalk.bold('devgrowth init')}`]);
+    rows.push(['Data', chalk.gray(ctx.dataDir)]);
+    return rows;
+  }
+
+  if (ctx.skill === 'rest') {
+    rows.push(['Tonight', `${chalk.blue('rest day')} — system still alive`]);
+  } else if (ctx.skill === 'review') {
+    rows.push(['Tonight', `${chalk.blue('weekly review')} — ${ctx.focus || ''}`.trim()]);
+  } else if (ctx.skill) {
+    const focus = ctx.focus ? ` ${chalk.gray('—')} ${ctx.focus}` : '';
+    rows.push(['Tonight', `${chalk.bold.cyan(ctx.skill)}${focus}`]);
+    if (ctx.resource) rows.push(['Resource', clip(ctx.resource, 32)]);
+    if (ctx.startTime) {
+      rows.push(['Session', `${ctx.startTime} · ${ctx.durationMinutes ?? 20} min`]);
+    }
+  }
+
+  if (ctx.weekCompleted !== undefined) {
+    const bar = renderBar(ctx.weekCompleted, ctx.weekTotal);
+    rows.push([
+      `Week ${ctx.weekNumber}`,
+      `${chalk.green(bar)} ${ctx.weekCompleted}/${ctx.weekTotal} sessions`
+    ]);
+    rows.push([
+      'Streak',
+      `${chalk.bold(plural(ctx.currentStreakWeeks, 'week'))} ${chalk.gray(`(best: ${ctx.longestStreakWeeks})`)}`
+    ]);
+    rows.push([
+      'Totals',
+      chalk.gray(`${plural(ctx.totalSessions, 'session')} · ${ctx.totalMinutes} min`)
+    ]);
+  }
+
+  rows.push(['Data', chalk.gray(ctx.dataDir)]);
+  return rows;
+}
+
+function formatRows(rows) {
+  const labelWidth = rows.reduce((max, [label]) => Math.max(max, label.length), 0);
+  // Pad the raw label before colorizing — ANSI codes count toward String#padEnd.
+  return rows.map(([label, value]) => `${chalk.bold.green(label.padEnd(labelWidth))}  ${value}`);
+}
+
+export function renderCompact(ctx) {
+  const name = `${chalk.gray('dev')}${chalk.bold.green('Growth')}`;
+  const trailer = ctx.initialized && ctx.skill && ctx.skill !== 'rest' && ctx.skill !== 'review'
+    ? `${chalk.cyan(ctx.skill)}${ctx.focus ? chalk.gray(` · ${ctx.focus}`) : ''}`
+    : chalk.gray(TAGLINE);
+  return `${name} ${chalk.gray(`v${ctx.version}`)} ${chalk.gray('—')} ${trailer}`;
+}
+
+/**
+ * The wordmark with the turtle riding beside it. Both are four rows tall, so
+ * the two blocks zip line-for-line. Every wordmark row is exactly
+ * WORDMARK_WIDTH, so no padding is needed to keep the turtle's left edge flush.
+ */
+export function renderHeader() {
+  const wordmark = colorWordmark();
+  const gap = ' '.repeat(MASCOT_GAP);
+  return wordmark.map((line, i) => {
+    const shell = TURTLE_ROWS[i];
+    return shell === undefined ? line : `${line}${gap}${chalk.green(shell)}`;
+  });
+}
+
+export const HEADER_WIDTH =
+  WORDMARK_WIDTH + MASCOT_GAP + Math.max(...TURTLE_ROWS.map(displayWidth));
+
+export function renderBanner(ctx, options = {}) {
+  const width = options.width ?? terminalWidth();
+  const identity = ctx.user
+    ? `${chalk.bold.green(ctx.user)}${chalk.gray('@')}${chalk.bold.green(ctx.host)} ${chalk.gray(`· v${ctx.version}`)}`
+    : chalk.gray(`v${ctx.version}`);
+  const body = formatRows(buildInfoRows(ctx));
+
+  // Wordmark plus turtle sets the minimum width; below it the header would wrap.
+  const widest = Math.max(HEADER_WIDTH, ...[identity, ...body].map(visibleLength));
+  if (options.compact || width < widest) return renderCompact(ctx);
+
+  const rule = chalk.gray('─'.repeat(widest));
+  return [...renderHeader(), '', identity, rule, ...body].join('\n');
+}
+
+/**
+ * Draws the banner. `force` bypasses the TTY check (used by `devgrowth banner`).
+ */
+export async function printBanner(options = {}) {
+  if (!options.force && !shouldShowBanner()) return false;
+  const ctx = options.context ?? await gatherContext();
+  console.log(`\n${renderBanner(ctx, options)}\n`);
+  return true;
+}

package/src/core/browser.js

@@ -0,0 +1,6 @@
+import open from 'open';
+
+export async function openUrl(url) {
+  if (!url) return;
+  await open(url);
+}

package/src/core/configManager.js

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

package/src/core/logger.js

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

package/src/core/milestones.js

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

package/src/core/notifier.js

@@ -0,0 +1,18 @@
+import notifier from 'node-notifier';
+
+export async function send(title, message) {
+  return new Promise((resolve, reject) => {
+    notifier.notify(
+      {
+        title,
+        message,
+        sound: false,
+        wait: false
+      },
+      (err) => {
+        if (err) reject(err);
+        else resolve();
+      }
+    );
+  });
+}

package/src/core/schedule.js

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