gitwrit 0.1.0

package/src/commands/init.js

@@ -0,0 +1,172 @@
+import { checkbox, select, confirm, input } from '@inquirer/prompts';
+import { mkdir } from 'fs/promises';
+import { resolve } from 'path';
+import { cwd } from 'process';
+
+import { print } from '../ui.js';
+import {
+  DEFAULTS,
+  globalConfigExists,
+  loadGlobalConfig,
+  saveGlobalConfig,
+  addWatchPath,
+} from '../settings.js';
+import { GITWRIT_DIR } from '../paths.js';
+import { isGitRepo, hasRemote } from '../git.js';
+
+// ─── main ─────────────────────────────────────────────────────────────────────
+
+export async function init() {
+  const dir = resolve(cwd());
+  const isFirstRun = !(await globalConfigExists());
+
+  // ── first-run: global setup ────────────────────────────────────────────────
+
+  if (isFirstRun) {
+    print.brand("Welcome to gitwrit. Let's get you set up.");
+    print.gap();
+    print.divider('Global defaults');
+    print.hint('These apply to every directory you watch.');
+    print.gap();
+
+    await mkdir(GITWRIT_DIR, { recursive: true });
+
+    const fileTypes = await checkbox({
+      message: 'Which file types should gitwrit watch?',
+      choices: [
+        { name: '.md',   value: '.md',   checked: true },
+        { name: '.mdx',  value: '.mdx',  checked: true },
+        { name: '.txt',  value: '.txt',  checked: false },
+        { name: '.rst',  value: '.rst',  checked: false },
+      ],
+    });
+
+    const debounceChoice = await select({
+      message: 'How long should gitwrit wait after a save before committing?',
+      choices: [
+        { name: '3 seconds  (recommended)', value: 3000 },
+        { name: '5 seconds',                value: 5000 },
+        { name: '10 seconds',               value: 10000 },
+        { name: 'Custom',                   value: 'custom' },
+      ],
+    });
+
+    let debounce = debounceChoice;
+    if (debounceChoice === 'custom') {
+      const raw = await input({ message: 'Seconds to wait after a save:' });
+      debounce = parseFloat(raw) * 1000;
+    }
+
+    const pushChoice = await select({
+      message: 'How often should gitwrit push to remote?',
+      choices: [
+        { name: 'Every 5 minutes  (recommended)', value: 300000 },
+        { name: 'Every 10 minutes',               value: 600000 },
+        { name: 'Every 30 minutes',               value: 1800000 },
+        { name: 'Custom',                         value: 'custom' },
+      ],
+    });
+
+    let pushInterval = pushChoice;
+    if (pushChoice === 'custom') {
+      const raw = await input({ message: 'Minutes between pushes:' });
+      pushInterval = parseFloat(raw) * 60000;
+    }
+
+    const branchMode = await select({
+      message: 'Default branch mode?',
+      choices: [
+        {
+          name: "Current branch   — commit to whatever branch you're on",
+          value: 'current',
+        },
+        {
+          name: 'Autogenerated    — create a fresh named branch each session  (e.g. crimson-walrus-stumbling)',
+          value: 'autogenerated',
+        },
+      ],
+    });
+
+    const globalConfig = {
+      ...DEFAULTS,
+      fileTypes,
+      debounce,
+      pushInterval,
+      branchMode,
+      watch: [],
+    };
+
+    await saveGlobalConfig(globalConfig);
+    print.gap();
+    print.good('Global defaults saved.');
+  }
+
+  // ── register current directory ────────────────────────────────────────────
+
+  print.gap();
+  print.divider(`Registering ${dir}`);
+  print.gap();
+
+  // hard gate: must be a git repo
+  const repoValid = await isGitRepo(dir);
+  if (!repoValid) {
+    print.bad(`${dir} is not a Git repo.`);
+    print.hint('Run git init here first, then run gitwrit init again.');
+    print.gap();
+    process.exit(1);
+  }
+
+  // hard gate: must have a remote
+  const remoteValid = await hasRemote(dir);
+  if (!remoteValid) {
+    print.bad('No Git remote configured.');
+    print.hint('gitwrit pushes your work to a remote repository to keep it safe.');
+    print.hint('Add one first:  git remote add origin <url>');
+    print.hint('Then run gitwrit init again.');
+    print.gap();
+    process.exit(1);
+  }
+
+  print.good('Valid Git repo found.');
+  print.good('Remote origin configured.');
+  print.gap();
+
+  // local overrides — only ask if not first run (first run just inherits global)
+  let useGlobalDefaults = true;
+  if (!isFirstRun) {
+    useGlobalDefaults = await confirm({
+      message: 'Use global defaults for this directory?',
+      default: true,
+    });
+  }
+
+  if (!useGlobalDefaults) {
+    print.hint('Local overrides can be set anytime with gitwrit config.');
+  }
+
+  // register the directory in global watch list
+  const added = await addWatchPath({ type: 'directory', path: dir });
+
+  print.gap();
+
+  if (!added) {
+    print.warn(`${dir} is already in your watch list.`);
+    print.gap();
+    return;
+  }
+
+  // ── confirmation summary ───────────────────────────────────────────────────
+
+  const config = await loadGlobalConfig();
+
+  print.brand(isFirstRun ? 'All set.' : `${dir} added.`);
+  print.gap();
+  print.row('Watching',   dir);
+  print.row('Files',      config.fileTypes.join(', '));
+  print.row('Branch',     config.branchMode);
+  print.row('Committing', `${config.debounce / 1000}s after last save`);
+  print.row('Pushing',    `Every ${config.pushInterval / 60000} min`);
+  print.gap();
+  print.hint("Run gitwrit start whenever you're ready.");
+  print.gap();
+}

package/src/commands/logs.js

@@ -0,0 +1,33 @@
+import chalk from 'chalk';
+import { print } from '../ui.js';
+import { tailLog } from '../logger.js';
+
+function colorize(line) {
+  if (line.includes('  commit  '))  return chalk.green(line);
+  if (line.includes('  push    '))  return chalk.blue(line);
+  if (line.includes('  error   '))  return chalk.red(line);
+  if (line.includes('  warn    '))  return chalk.yellow(line);
+  if (line.includes('  pause   '))  return chalk.dim(line);
+  if (line.includes('  resume  '))  return chalk.cyan(line);
+  return chalk.dim(line);
+}
+
+export async function logs(n = 20) {
+  const lines = await tailLog(n);
+
+  print.gap();
+  print.brand(`gitwrit log — last ${n} entries`);
+  print.gap();
+
+  if (lines.length === 0) {
+    print.hint('No activity yet. Run gitwrit start to begin.');
+    print.gap();
+    return;
+  }
+
+  for (const line of lines) {
+    console.log('  ' + colorize(line));
+  }
+
+  print.gap();
+}

package/src/commands/remove.js

@@ -0,0 +1,40 @@
+import { confirm } from '@inquirer/prompts';
+import { resolve } from 'path';
+import { cwd } from 'process';
+import { print } from '../ui.js';
+import { removeWatchPath, globalConfigExists } from '../settings.js';
+
+export async function remove(dirArg) {
+  const dir = resolve(dirArg || cwd());
+
+  if (!(await globalConfigExists())) {
+    print.gap();
+    print.bad('gitwrit is not set up yet.');
+    print.gap();
+    return;
+  }
+
+  print.gap();
+
+  const confirmed = await confirm({
+    message: `Remove ${dir} from your watch list?`,
+    default: false,
+  });
+
+  if (!confirmed) {
+    print.hint('No changes made.');
+    print.gap();
+    return;
+  }
+
+  const removed = await removeWatchPath(dir);
+
+  if (!removed) {
+    print.warn(`${dir} was not in your watch list.`);
+  } else {
+    print.good('Done.');
+    print.hint('Run gitwrit restart to apply.');
+  }
+
+  print.gap();
+}

package/src/commands/restart.js

@@ -0,0 +1,10 @@
+import { print } from '../ui.js';
+import { stop } from './stop.js';
+import { start } from './start.js';
+
+export async function restart() {
+  print.gap();
+  print.brand('Restarting gitwrit...');
+  await stop();
+  await start();
+}

package/src/commands/start.js

@@ -0,0 +1,118 @@
+import { spawn } from 'child_process';
+import { writeFile, mkdir, readFile } from 'fs/promises';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+import { print } from '../ui.js';
+import { PID_FILE, GITWRIT_DIR } from '../paths.js';
+import { globalConfigExists, loadGlobalConfig } from '../settings.js';
+import { readState, STATE } from '../state.js';
+import { generateBranchName } from '../expansions.js';
+
+const DAEMON_SCRIPT = join(dirname(fileURLToPath(import.meta.url)), '../daemon.js');
+
+// ─── random start messages ────────────────────────────────────────────────────
+
+const START_MESSAGES = [
+  'Type all you want, we\'ve got you.',
+  'Happy writing!',
+  'Feel free to type away!',
+];
+
+function randomStartMessage() {
+  return START_MESSAGES[Math.floor(Math.random() * START_MESSAGES.length)];
+}
+
+// ─── stale pid check ──────────────────────────────────────────────────────────
+
+async function getLivePid() {
+  try {
+    const raw = await readFile(PID_FILE, 'utf8');
+    const pid = parseInt(raw.trim(), 10);
+    if (isNaN(pid)) return null;
+    process.kill(pid, 0);
+    return pid;
+  } catch {
+    return null;
+  }
+}
+
+// ─── main ─────────────────────────────────────────────────────────────────────
+
+export async function start() {
+  if (!(await globalConfigExists())) {
+    print.gap();
+    print.bad('gitwrit is not set up yet.');
+    print.hint('Run gitwrit init in a directory to get started.');
+    print.gap();
+    return;
+  }
+
+  const config = await loadGlobalConfig();
+
+  if (config.watch.length === 0) {
+    print.gap();
+    print.bad('No directories registered.');
+    print.hint('Run gitwrit init in a directory to register it.');
+    print.gap();
+    return;
+  }
+
+  const livePid = await getLivePid();
+  if (livePid) {
+    print.gap();
+    print.bad(`gitwrit is already running. (PID ${livePid})`);
+    print.hint('Use gitwrit stop to stop it first.');
+    print.gap();
+    return;
+  }
+
+  const state = await readState();
+  const wasUnclean = state.status === STATE.PAUSED || state.status === STATE.RUNNING;
+
+  let sessionBranch = null;
+  if (config.branchMode === 'autogenerated') {
+    sessionBranch = await generateBranchName();
+  }
+
+  await mkdir(GITWRIT_DIR, { recursive: true });
+
+  const daemon = spawn(process.execPath, [DAEMON_SCRIPT], {
+    detached: true,
+    stdio: 'ignore',
+    env: {
+      ...process.env,
+      GITWRIT_SESSION_BRANCH: sessionBranch || '',
+    },
+  });
+
+  daemon.unref();
+
+  await writeFile(PID_FILE, String(daemon.pid), 'utf8');
+
+  await new Promise(r => setTimeout(r, 300));
+
+  print.gap();
+
+  if (wasUnclean) {
+    print.brand('gitwrit is running — picked up where you left off.');
+  } else {
+    print.brand('gitwrit is running.');
+  }
+
+  print.gap();
+  print.row('Watching',    config.watch.map(w => w.path).join(', '));
+  print.row('Files',       config.fileTypes.join(', '));
+
+  if (sessionBranch) {
+    print.row('Branch', sessionBranch, 'autogenerated');
+  } else {
+    print.row('Branch', 'Current branch');
+  }
+
+  print.row('Committing', `${config.debounce / 1000}s after last save`);
+  print.row('Pushing',    `Every ${config.pushInterval / 60000} min`);
+  print.gap();
+  print.hint(randomStartMessage());
+  print.gap();
+}

package/src/commands/status.js

@@ -0,0 +1,94 @@
+import { readFile } from 'fs/promises';
+import { print, timeAgo } from '../ui.js';
+import { PID_FILE } from '../paths.js';
+import { readState, STATE } from '../state.js';
+import { loadGlobalConfig, globalConfigExists } from '../settings.js';
+
+async function getLivePid() {
+  try {
+    const raw = await readFile(PID_FILE, 'utf8');
+    const pid = parseInt(raw.trim(), 10);
+    process.kill(pid, 0);
+    return pid;
+  } catch {
+    return null;
+  }
+}
+
+function formatUptime(startedAt) {
+  if (!startedAt) return 'Unknown';
+  const seconds = Math.floor((Date.now() - new Date(startedAt)) / 1000);
+  if (seconds < 60)   return `${seconds}s`;
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m`;
+  return `${Math.floor(seconds / 3600)}h ${Math.floor((seconds % 3600) / 60)}m`;
+}
+
+export async function status() {
+  if (!(await globalConfigExists())) {
+    print.gap();
+    print.brand('gitwrit is not set up.');
+    print.hint('Run gitwrit init to get started.');
+    print.gap();
+    return;
+  }
+
+  const pid = await getLivePid();
+  const state = await readState();
+  const config = await loadGlobalConfig();
+
+  print.gap();
+
+  if (!pid) {
+    if (state.status === STATE.PAUSED) {
+      print.brand('gitwrit is paused.');
+      print.gap();
+      print.info(`Resumed from sleep — last active ${timeAgo(state.pausedAt)}.`);
+      print.gap();
+      print.hint('Run gitwrit start to resume watching.');
+    } else {
+      print.brand('gitwrit is not running.');
+      print.hint('Run gitwrit start to begin watching.');
+    }
+    print.gap();
+    return;
+  }
+
+  const resumedAfterSleep = state.resumedAt &&
+    (Date.now() - new Date(state.resumedAt)) < 60000;
+
+  if (resumedAfterSleep) {
+    print.brand('gitwrit is running — resumed after sleep.');
+  } else {
+    print.brand('gitwrit is running.');
+  }
+
+  print.gap();
+  print.row('Uptime',      formatUptime(state.startedAt));
+  print.row('Watching',    config.watch.map(w => w.path).join(', '));
+
+  if (state.sessionBranch) {
+    print.row('Branch', state.sessionBranch, 'autogenerated');
+  } else {
+    print.row('Branch', 'Current branch');
+  }
+
+  if (state.sessionCommits > 0) {
+    print.row('Commits', `${state.sessionCommits} this session`);
+  }
+
+  if (state.lastCommittedAt) {
+    const fileLabel = state.lastCommittedFile ? `  (${state.lastCommittedFile})` : '';
+    print.row('Last commit', `${timeAgo(state.lastCommittedAt)}${fileLabel}`);
+  }
+
+  if (state.lastPushedAt) {
+    print.row('Last push', timeAgo(state.lastPushedAt));
+  }
+
+  if (resumedAfterSleep && state.catchUpCommits > 0) {
+    print.gap();
+    print.good(`${state.catchUpCommits} file${state.catchUpCommits !== 1 ? 's' : ''} committed on wake.`);
+  }
+
+  print.gap();
+}

package/src/commands/stop.js

@@ -0,0 +1,57 @@
+import { readFile, unlink } from 'fs/promises';
+import { print, timeAgo } from '../ui.js';
+import { PID_FILE } from '../paths.js';
+import { readState, markStopped } from '../state.js';
+
+export async function stop() {
+  let pid;
+
+  try {
+    const raw = await readFile(PID_FILE, 'utf8');
+    pid = parseInt(raw.trim(), 10);
+  } catch {
+    print.gap();
+    print.bad('gitwrit is not running.');
+    print.gap();
+    return;
+  }
+
+  try {
+    process.kill(pid, 0);
+  } catch {
+    await unlink(PID_FILE).catch(() => {});
+    await markStopped();
+    print.gap();
+    print.bad('gitwrit is not running.');
+    print.gap();
+    return;
+  }
+
+  const state = await readState();
+
+  process.kill(pid, 'SIGTERM');
+  await new Promise(r => setTimeout(r, 500));
+
+  await unlink(PID_FILE).catch(() => {});
+  await markStopped();
+
+  print.gap();
+  print.brand('gitwrit stopped.');
+  print.gap();
+
+  if (state.sessionCommits > 0) {
+    print.row('Committed', `${state.sessionCommits} time${state.sessionCommits !== 1 ? 's' : ''} this session`);
+  }
+
+  if (state.lastPushedAt) {
+    print.row('Last push', timeAgo(state.lastPushedAt));
+  }
+
+  if (state.sessionBranch) {
+    print.row('Branch', state.sessionBranch);
+  }
+
+  print.gap();
+  print.hint('Your work is safe. See you next time.');
+  print.gap();
+}

package/src/daemon.js

@@ -0,0 +1,157 @@
+import { loadGlobalConfig } from './settings.js';
+import { createWatcher } from './watcher.js';
+import { createScheduler } from './scheduler.js';
+import { commitFile, commitAll, createAndCheckoutBranch, branchExists } from './git.js';
+import { logger } from './logger.js';
+import { markRunning, markPaused, markStopped, readState, writeState } from './state.js';
+import { unlink } from 'fs/promises';
+import { PID_FILE } from './paths.js';
+
+// ─── session ──────────────────────────────────────────────────────────────────
+
+const SESSION_BRANCH = process.env.GITWRIT_SESSION_BRANCH || null;
+
+// ─── main ─────────────────────────────────────────────────────────────────────
+
+async function main() {
+  const config = await loadGlobalConfig();
+  const paths  = config.watch.map(w => w.path);
+
+  await markRunning({
+    startedAt:     new Date().toISOString(),
+    sessionBranch: SESSION_BRANCH,
+    sessionCommits: 0,
+  });
+
+  await logger.info('daemon started');
+
+  // ── branch setup ────────────────────────────────────────────────────────────
+
+  if (SESSION_BRANCH) {
+    for (const dir of paths) {
+      const exists = await branchExists(dir, SESSION_BRANCH);
+      if (!exists) {
+        await createAndCheckoutBranch(dir, SESSION_BRANCH);
+        await logger.info(`created branch ${SESSION_BRANCH} in ${dir}`);
+      }
+    }
+  }
+
+  // ── scheduler ───────────────────────────────────────────────────────────────
+
+  const scheduler = createScheduler({
+    interval: config.pushInterval,
+    onPushComplete: async (dir) => {
+      await logger.push(`pushed ${dir}`);
+    },
+  });
+
+  // ── commit handler ──────────────────────────────────────────────────────────
+
+  async function handleSave(filepath, dir) {
+    const shortPath = filepath.replace(dir, '').replace(/^\//, '');
+    const message   = config.commitMessage
+      ? config.commitMessage
+          .replace('{filename}', shortPath)
+          .replace('{timestamp}', new Date().toISOString())
+      : `auto: ${shortPath}`;
+
+    try {
+      const committed = await commitFile(dir, filepath, message);
+      if (!committed) return; // nothing staged — file was already clean
+
+      await logger.commit(`${shortPath}  → ${SESSION_BRANCH || 'current branch'}`);
+
+      const state = await readState();
+      await writeState({
+        sessionCommits:    (state.sessionCommits || 0) + 1,
+        lastCommittedAt:   new Date().toISOString(),
+        lastCommittedFile: shortPath,
+      });
+
+      scheduler.queue(dir);
+    } catch (err) {
+      await logger.error(`commit failed: ${filepath} — ${err.message}`);
+    }
+  }
+
+  // ── watcher ─────────────────────────────────────────────────────────────────
+
+  let watcher = createWatcher({
+    paths,
+    fileTypes:  config.fileTypes,
+    debounce:   config.debounce,
+    onSave:     handleSave,
+  });
+
+  await logger.info(`watching ${paths.join(', ')}`);
+
+  // ── signal: graceful stop (SIGTERM) ─────────────────────────────────────────
+
+  process.on('SIGTERM', async () => {
+    await logger.info('daemon stopped');
+    watcher.close();
+    scheduler.stop();
+    await markStopped();
+    await unlink(PID_FILE).catch(() => {});
+    process.exit(0);
+  });
+
+  // ── signal: sleep/wake (SIGCONT) ─────────────────────────────────────────────
+  // sent by the OS when the machine wakes from sleep.
+  // chokidar watchers can go stale after a long sleep so we restart them
+  // and do a catch-up commit of anything that changed while we were out.
+
+  process.on('SIGCONT', async () => {
+    await logger.resume('woke from sleep — running catch-up scan');
+
+    watcher.close();
+
+    // catch-up: commit any dirty files across all watched dirs
+    let totalCaught = 0;
+    for (const dir of paths) {
+      try {
+        const count = await commitAll(dir, 'auto: catch-up after sleep');
+        totalCaught += count;
+        if (count > 0) {
+          await logger.commit(`catch-up: ${count} file${count !== 1 ? 's' : ''} in ${dir}`);
+          scheduler.queue(dir);
+        }
+      } catch (err) {
+        await logger.error(`catch-up failed in ${dir}: ${err.message}`);
+      }
+    }
+
+    await writeState({
+      resumedAt:     new Date().toISOString(),
+      catchUpCommits: totalCaught,
+    });
+
+    // restart watchers fresh
+    watcher = createWatcher({
+      paths,
+      fileTypes: config.fileTypes,
+      debounce:  config.debounce,
+      onSave:    handleSave,
+    });
+
+    // push anything that accumulated
+    await scheduler.flushNow();
+
+    await logger.resume(`resumed — ${totalCaught} file${totalCaught !== 1 ? 's' : ''} caught up`);
+  });
+
+  // ── signal: pause (SIGTSTP) ──────────────────────────────────────────────────
+  // sent when the user suspends the process (Ctrl+Z) — shouldn't happen to
+  // a detached daemon, but handle it gracefully just in case.
+
+  process.on('SIGTSTP', async () => {
+    await markPaused();
+    await logger.pause('daemon paused');
+  });
+}
+
+main().catch(async (err) => {
+  await logger.error(`daemon crashed: ${err.message}`);
+  process.exit(1);
+});