git-cracked 1.2.0

package/src/messages.js

@@ -0,0 +1,197 @@
+const pool = {
+  whitespace: [
+    'style: improve vertical spacing for readability',
+    'style: add whitespace between logical blocks',
+    'style: clean up blank lines for consistency',
+    'style: separate concerns with whitespace',
+    'style: remove unnecessary blank lines',
+    'style: normalize vertical whitespace',
+    'style: tighten up spacing in dense block',
+    'style: improve code breathing room',
+    'refactor: reorganize spacing for clarity',
+    'chore: whitespace cleanup',
+    'style: consolidate blank lines',
+    'style: remove redundant blank line',
+    'style: add breathing room between sections',
+  ],
+
+  trailing: [
+    'style: remove trailing whitespace',
+    'chore: strip trailing spaces',
+    'style: clean up line endings',
+    'style: fix trailing whitespace on modified lines',
+    'chore: normalize line endings',
+    'style: remove invisible trailing characters',
+    'chore: trailing whitespace cleanup',
+  ],
+
+  newline: [
+    'chore: ensure file ends with newline',
+    'style: add missing newline at end of file',
+    'chore: fix missing trailing newline',
+    'style: normalize end-of-file newline',
+    'chore: trim extra trailing newlines',
+    'style: conform to POSIX newline convention',
+  ],
+
+  quotes: [
+    'style: standardise quote style to double quotes',
+    'style: normalise string literals to consistent quote style',
+    'refactor: align quote usage with project convention',
+    'style: use consistent string delimiters',
+    'style: enforce quote style across file',
+    'chore: quote style normalisation',
+    'style: switch to preferred quote style',
+    'refactor: unify quote style for linter compliance',
+  ],
+
+  const: [
+    'refactor: prefer const for non-reassigned bindings',
+    'refactor: use const over let where value is not reassigned',
+    'style: enforce const correctness',
+    'refactor: tighten variable declarations with const',
+    'chore: replace let with const for immutable references',
+    'refactor: mark non-mutated bindings as const',
+    'style: const over let per project convention',
+    'refactor: signal immutability with const',
+    'fix: prevent accidental reassignment with const',
+  ],
+
+  semicolons: [
+    'style: add missing semicolons',
+    'chore: enforce semicolons per style guide',
+    'style: insert missing statement terminators',
+    'style: normalise semicolon usage',
+    'chore: semicolon consistency pass',
+    'style: add semicolons for ASI safety',
+  ],
+
+  equality: [
+    'fix: use strict equality to avoid type coercion',
+    'refactor: prefer === over == for type-safe comparisons',
+    'fix: replace loose equality with strict equality check',
+    'refactor: enforce strict equality throughout',
+    'chore: migrate == to === for correctness',
+    'fix: avoid implicit type coercion in equality check',
+    'refactor: use identity comparison instead of abstract equality',
+    'style: strict equality per lint rules',
+  ],
+
+  arrow: [
+    'refactor: convert to arrow function syntax',
+    'refactor: use arrow function for conciseness',
+    'style: prefer arrow functions for anonymous callbacks',
+    'refactor: modernise function expression to arrow syntax',
+    'chore: align with ES6 arrow function convention',
+    'refactor: simplify with arrow function',
+    'style: arrow function for lexical this binding',
+  ],
+
+  comment_add: [
+    'docs: add clarifying inline comment',
+    'chore: annotate non-obvious logic',
+    'docs: document intent of expression',
+    'chore: add note for future maintainers',
+    'docs: clarify edge case handling',
+    'chore: leave breadcrumb for reviewers',
+    'docs: annotate subtle invariant',
+    'chore: improve code self-documentation',
+  ],
+
+  comment_remove: [
+    'chore: remove stale inline comment',
+    'docs: drop outdated annotation',
+    'chore: clean up obsolete comment',
+    'refactor: remove redundant comment noise',
+    'docs: prune comment that no longer applies',
+    'chore: delete stale TODO resolved elsewhere',
+  ],
+
+  imports: [
+    'chore: sort import statements alphabetically',
+    'style: alphabetise imports for consistency',
+    'refactor: reorder imports to match convention',
+    'chore: organise import block',
+    'style: enforce import sort order',
+    'refactor: normalise import ordering',
+    'chore: keep imports sorted for diff clarity',
+    'style: alphabetical import grouping',
+  ],
+
+  numeric: [
+    'fix: adjust off-by-one in boundary constant',
+    'refactor: update threshold constant',
+    'chore: revise magic number',
+    'fix: correct numeric boundary value',
+    'refactor: adjust timeout constant',
+    'chore: tune numeric parameter',
+    'fix: tweak limit to match updated spec',
+    'refactor: update hardcoded constant',
+    'chore: adjust retry count',
+    'fix: correct range boundary',
+  ],
+
+  python_none: [
+    'fix: use identity check for None comparison',
+    'refactor: prefer is None over == None per PEP 8',
+    'style: replace == None with is None',
+    'fix: correct None check to use identity operator',
+    'chore: align None comparisons with PEP 8',
+    'refactor: use is not None for truthiness check',
+    'fix: avoid equality check against None singleton',
+  ],
+
+  general: [
+    'refactor: minor code quality improvement',
+    'chore: routine maintenance pass',
+    'style: apply formatting fixes',
+    'refactor: small cleanup for readability',
+    'chore: tidy up per code review feedback',
+    'fix: address minor inconsistency',
+    'refactor: simplify expression',
+    'chore: lint and style fixes',
+    'style: formatting pass',
+    'refactor: clean up per style guide',
+    'chore: housekeeping',
+    'fix: correct minor stylistic issue',
+    'refactor: reduce cognitive overhead',
+    'chore: address tech debt',
+    'style: align with project conventions',
+    'refactor: extract repeated pattern',
+    'chore: minor polish pass',
+    'fix: resolve edge case inconsistency',
+    'refactor: improve clarity of intent',
+    'chore: routine code hygiene',
+  ],
+};
+
+const TYPE_MAP = {
+  'improved readability with whitespace': 'whitespace',
+  'removed unnecessary blank line': 'whitespace',
+  'added whitespace for readability': 'whitespace',
+  'removed trailing whitespace': 'trailing',
+  'added missing trailing newline': 'newline',
+  'trimmed extra trailing newlines': 'newline',
+  'ensured trailing newline': 'newline',
+  'normalised quote style': 'quotes',
+  'standardised string quote style': 'quotes',
+  'prefer const over let for immutable binding': 'const',
+  'added missing semicolon': 'semicolons',
+  'prefer strict equality operator': 'equality',
+  'refactored to arrow function syntax': 'arrow',
+  'added clarifying inline comment': 'comment_add',
+  'removed stale inline comment': 'comment_remove',
+  'sorted import statements alphabetically': 'imports',
+  'adjusted numeric constant': 'numeric',
+  'use identity check for None comparison': 'python_none',
+};
+
+function pickRandom(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+export function generateCommitMessage(description) {
+  const matched = Object.entries(TYPE_MAP).find(([key]) => description.toLowerCase().includes(key.toLowerCase()));
+  const bucket = matched ? pool[matched[1]] : pool.general;
+  return pickRandom(bucket ?? pool.general);
+}

package/src/mutator.js

@@ -0,0 +1,373 @@
+import { readdirSync, readFileSync, writeFileSync, statSync } from 'fs';
+import { join, extname, relative } from 'path';
+
+const SUPPORTED_EXTENSIONS = new Set([
+  '.js', '.ts', '.jsx', '.tsx', '.mjs', '.cjs',
+  '.py', '.go', '.java', '.rb', '.cs', '.cpp', '.c', '.rs',
+  '.php', '.swift', '.kt', '.scala', '.sh',
+]);
+
+const IGNORE_DIRS = new Set([
+  'node_modules', '.git', 'dist', 'build', '__pycache__',
+  '.next', 'vendor', 'target', 'out', 'coverage', '.cache',
+  '.turbo', 'tmp', 'temp', '.svelte-kit',
+]);
+
+function collectFiles(dir, files = []) {
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return files;
+  }
+  for (const entry of entries) {
+    if (IGNORE_DIRS.has(entry) || entry.startsWith('.')) continue;
+    const full = join(dir, entry);
+    try {
+      const stat = statSync(full);
+      if (stat.isDirectory()) {
+        collectFiles(full, files);
+      } else if (SUPPORTED_EXTENSIONS.has(extname(entry))) {
+        files.push(full);
+      }
+    } catch {
+      // skip unreadable entries
+    }
+  }
+  return files;
+}
+
+function pickRandom(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+function randomInt(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+// Each mutation: (lines, ext) => { newContent, description } | null
+const mutations = [
+  // ── Whitespace ──────────────────────────────────────────────────────────────
+
+  // Insert blank line between two non-blank lines
+  (lines) => {
+    const candidates = [];
+    for (let i = 1; i < lines.length - 2; i++) {
+      if (lines[i].trim() && lines[i - 1].trim() && lines[i + 1].trim()) {
+        candidates.push(i);
+      }
+    }
+    if (!candidates.length) return null;
+    const idx = pickRandom(candidates);
+    const out = [...lines.slice(0, idx + 1), '', ...lines.slice(idx + 1)];
+    return { newContent: out.join('\n'), description: 'improved readability with whitespace' };
+  },
+
+  // Remove a redundant blank line
+  (lines) => {
+    const blanks = lines.reduce((acc, l, i) => (l.trim() === '' ? [...acc, i] : acc), []);
+    if (blanks.length < 2) return null;
+    const idx = pickRandom(blanks);
+    return { newContent: lines.filter((_, i) => i !== idx).join('\n'), description: 'removed unnecessary blank line' };
+  },
+
+  // Ensure single trailing newline
+  (lines) => {
+    const content = lines.join('\n');
+    if (!content.endsWith('\n')) {
+      return { newContent: content + '\n', description: 'added missing trailing newline' };
+    }
+    if (content.endsWith('\n\n')) {
+      return { newContent: content.replace(/\n+$/, '\n'), description: 'trimmed extra trailing newlines' };
+    }
+    return null;
+  },
+
+  // ── Quote style ─────────────────────────────────────────────────────────────
+
+  // Normalise single → double quotes on one line (JS/TS/Python)
+  (lines, ext) => {
+    if (!['.js', '.ts', '.jsx', '.tsx', '.mjs', '.py'].includes(ext)) return null;
+    const candidates = lines
+      .map((l, i) => ({ l, i }))
+      .filter(({ l }) => /'[^']*'/.test(l) && !l.trim().startsWith('//') && !l.trim().startsWith('#'));
+    if (!candidates.length) return null;
+    const { l, i } = pickRandom(candidates);
+    const newLine = l.replace(/'([^']*)'/g, '"$1"');
+    if (newLine === l) return null;
+    const out = [...lines];
+    out[i] = newLine;
+    return { newContent: out.join('\n'), description: 'standardised string quote style' };
+  },
+
+  // ── const / let ─────────────────────────────────────────────────────────────
+
+  // Change `let x =` to `const x =` where safe-ish (no reassignment heuristic)
+  (lines, ext) => {
+    if (!['.js', '.ts', '.jsx', '.tsx', '.mjs'].includes(ext)) return null;
+    const candidates = lines
+      .map((l, i) => ({ l, i }))
+      .filter(({ l }) => /^\s*let\s+\w+\s*=/.test(l));
+    if (!candidates.length) return null;
+    const { l, i } = pickRandom(candidates);
+    const newLine = l.replace(/\blet\b/, 'const');
+    const out = [...lines];
+    out[i] = newLine;
+    return { newContent: out.join('\n'), description: 'prefer const over let for immutable binding' };
+  },
+
+  // ── Semicolons ───────────────────────────────────────────────────────────────
+
+  // Add missing semicolons (JS/TS)
+  (lines, ext) => {
+    if (!['.js', '.ts', '.jsx', '.tsx', '.mjs'].includes(ext)) return null;
+    const candidates = lines
+      .map((l, i) => ({ l, i }))
+      .filter(({ l }) => {
+        const t = l.trimEnd();
+        return t.length > 0
+          && !t.endsWith(';')
+          && !t.endsWith('{')
+          && !t.endsWith('}')
+          && !t.endsWith(',')
+          && !t.endsWith('(')
+          && !t.trim().startsWith('//')
+          && /^\s+(return|const|let|var|throw)\s/.test(l);
+      });
+    if (!candidates.length) return null;
+    const { l, i } = pickRandom(candidates);
+    const out = [...lines];
+    out[i] = l.trimEnd() + ';';
+    return { newContent: out.join('\n'), description: 'added missing semicolon' };
+  },
+
+  // ── Numeric constants ────────────────────────────────────────────────────────
+
+  // Nudge a numeric literal ±1
+  (lines) => {
+    const candidates = lines
+      .map((l, i) => ({ l, i }))
+      .filter(({ l }) => /\b([1-9]\d{0,3})\b/.test(l) && !l.trim().startsWith('//') && !l.trim().startsWith('#'));
+    if (!candidates.length) return null;
+    const { l, i } = pickRandom(candidates);
+    const newLine = l.replace(/\b([1-9]\d{0,3})\b/, (m) => {
+      const n = parseInt(m, 10);
+      return String(Math.random() < 0.5 ? n + 1 : Math.max(1, n - 1));
+    });
+    if (newLine === l) return null;
+    const out = [...lines];
+    out[i] = newLine;
+    return { newContent: out.join('\n'), description: 'adjusted numeric constant' };
+  },
+
+  // ── Comments ─────────────────────────────────────────────────────────────────
+
+  // Add a short inline comment to a plain assignment line
+  (lines, ext) => {
+    const commentChar = ['.py', '.rb', '.sh'].includes(ext) ? '#' : '//';
+    const comments = [
+      'TODO: revisit this',
+      'edge case handled',
+      'intentional',
+      'perf: hot path',
+      'keep in sync with schema',
+      'zero-indexed',
+      'inclusive range',
+    ];
+    const candidates = lines
+      .map((l, i) => ({ l, i }))
+      .filter(({ l }) => {
+        const t = l.trim();
+        return t.length > 4
+          && !t.startsWith('//')
+          && !t.startsWith('#')
+          && !t.startsWith('*')
+          && !t.startsWith('/*')
+          && !t.includes('//')
+          && !t.includes('#')
+          && (t.includes('=') || t.includes('return'));
+      });
+    if (!candidates.length) return null;
+    const { l, i } = pickRandom(candidates);
+    const out = [...lines];
+    out[i] = l.trimEnd() + ` ${commentChar} ${pickRandom(comments)}`;
+    return { newContent: out.join('\n'), description: 'added clarifying inline comment' };
+  },
+
+  // Remove an existing inline comment
+  (lines, ext) => {
+    const commentChar = ['.py', '.rb', '.sh'].includes(ext) ? '#' : '//';
+    const pattern = new RegExp(`\\s+${commentChar.replace('/', '\\/')}.*$`);
+    const candidates = lines
+      .map((l, i) => ({ l, i }))
+      .filter(({ l }) => {
+        const t = l.trim();
+        return !t.startsWith(commentChar) && pattern.test(l);
+      });
+    if (!candidates.length) return null;
+    const { l, i } = pickRandom(candidates);
+    const out = [...lines];
+    out[i] = l.replace(pattern, '');
+    return { newContent: out.join('\n'), description: 'removed stale inline comment' };
+  },
+
+  // ── Spacing around operators ─────────────────────────────────────────────────
+
+  // Fix missing space after comma on a random line
+  (lines) => {
+    const candidates = lines
+      .map((l, i) => ({ l, i }))
+      .filter(({ l }) => /,\S/.test(l) && !l.trim().startsWith('//') && !l.trim().startsWith('#'));
+    if (!candidates.length) return null;
+    const { l, i } = pickRandom(candidates);
+    const newLine = l.replace(/,(\S)/g, ', $1');
+    if (newLine === l) return null;
+    const out = [...lines];
+    out[i] = newLine;
+    return { newContent: out.join('\n'), description: 'fixed spacing after comma' };
+  },
+
+  // ── Import / require reordering ──────────────────────────────────────────────
+
+  // Sort a block of consecutive import lines alphabetically
+  (lines, ext) => {
+    if (!['.js', '.ts', '.jsx', '.tsx', '.mjs', '.py'].includes(ext)) return null;
+    const importPattern = ext === '.py' ? /^\s*(import |from )/ : /^\s*import /;
+
+    // Find a contiguous block of imports
+    let blockStart = -1;
+    let blockEnd = -1;
+    let inBlock = false;
+    for (let i = 0; i < lines.length; i++) {
+      if (importPattern.test(lines[i])) {
+        if (!inBlock) { blockStart = i; inBlock = true; }
+        blockEnd = i;
+      } else if (inBlock && lines[i].trim() === '') {
+        inBlock = false;
+      } else if (inBlock) {
+        inBlock = false;
+      }
+    }
+    if (blockStart === -1 || blockEnd === blockStart) return null;
+    const block = lines.slice(blockStart, blockEnd + 1);
+    const sorted = [...block].sort((a, b) => a.localeCompare(b));
+    if (sorted.join('\n') === block.join('\n')) return null;
+    const out = [...lines.slice(0, blockStart), ...sorted, ...lines.slice(blockEnd + 1)];
+    return { newContent: out.join('\n'), description: 'sorted import statements alphabetically' };
+  },
+
+  // ── Trailing whitespace ──────────────────────────────────────────────────────
+
+  // Strip trailing spaces from lines that have them
+  (lines) => {
+    const hasTrailing = lines.some(l => / +$/.test(l));
+    if (!hasTrailing) return null;
+    const out = lines.map(l => l.replace(/ +$/, ''));
+    return { newContent: out.join('\n'), description: 'removed trailing whitespace' };
+  },
+
+  // ── Boolean / strict equality ────────────────────────────────────────────────
+
+  // Replace == with === (JS/TS)
+  (lines, ext) => {
+    if (!['.js', '.ts', '.jsx', '.tsx', '.mjs'].includes(ext)) return null;
+    const candidates = lines
+      .map((l, i) => ({ l, i }))
+      .filter(({ l }) => /[^=!<>]={2}[^=]/.test(l) && !l.trim().startsWith('//'));
+    if (!candidates.length) return null;
+    const { l, i } = pickRandom(candidates);
+    const newLine = l.replace(/([^=!<>])==([^=])/g, '$1===$2');
+    if (newLine === l) return null;
+    const out = [...lines];
+    out[i] = newLine;
+    return { newContent: out.join('\n'), description: 'prefer strict equality operator' };
+  },
+
+  // ── Arrow functions ──────────────────────────────────────────────────────────
+
+  // Convert `function foo()` to `const foo = ()` style (JS/TS, single occurrence)
+  (lines, ext) => {
+    if (!['.js', '.ts', '.mjs'].includes(ext)) return null;
+    const candidates = lines
+      .map((l, i) => ({ l, i }))
+      .filter(({ l }) => /^\s*function\s+\w+\s*\(/.test(l));
+    if (!candidates.length) return null;
+    const { l, i } = pickRandom(candidates);
+    const newLine = l.replace(
+      /^(\s*)function\s+(\w+)\s*(\([^)]*\))\s*\{/,
+      '$1const $2 = $3 => {'
+    );
+    if (newLine === l) return null;
+    const out = [...lines];
+    out[i] = newLine;
+    return { newContent: out.join('\n'), description: 'refactored to arrow function syntax' };
+  },
+
+  // ── Python-specific ──────────────────────────────────────────────────────────
+
+  // Replace `== None` with `is None`
+  (lines, ext) => {
+    if (ext !== '.py') return null;
+    const candidates = lines
+      .map((l, i) => ({ l, i }))
+      .filter(({ l }) => /==\s*None/.test(l));
+    if (!candidates.length) return null;
+    const { l, i } = pickRandom(candidates);
+    const out = [...lines];
+    out[i] = l.replace(/==\s*None/g, 'is None');
+    return { newContent: out.join('\n'), description: 'use identity check for None comparison' };
+  },
+
+  // Replace `!= None` with `is not None`
+  (lines, ext) => {
+    if (ext !== '.py') return null;
+    const candidates = lines
+      .map((l, i) => ({ l, i }))
+      .filter(({ l }) => /!=\s*None/.test(l));
+    if (!candidates.length) return null;
+    const { l, i } = pickRandom(candidates);
+    const out = [...lines];
+    out[i] = l.replace(/!=\s*None/g, 'is not None');
+    return { newContent: out.join('\n'), description: 'use identity check for None comparison' };
+  },
+];
+
+export async function mutateRepo(repoPath) {
+  const allFiles = collectFiles(repoPath);
+  if (!allFiles.length) return { changedFiles: [], description: '' };
+
+  const shuffled = [...allFiles].sort(() => Math.random() - 0.5);
+
+  for (const file of shuffled) {
+    let content;
+    try {
+      content = readFileSync(file, 'utf8');
+    } catch {
+      continue;
+    }
+
+    // Skip minified files
+    const lines = content.split('\n');
+    if (lines.length < 5) continue;
+    if (lines.some(l => l.length > 500)) continue;
+
+    const ext = extname(file);
+    const shuffledMutations = [...mutations].sort(() => Math.random() - 0.5);
+
+    for (const mutate of shuffledMutations) {
+      let result;
+      try {
+        result = mutate(lines, ext);
+      } catch {
+        continue;
+      }
+      if (result && result.newContent !== content) {
+        writeFileSync(file, result.newContent, 'utf8');
+        const relPath = relative(repoPath, file);
+        return { changedFiles: [file], description: `${result.description} in ${relPath}`, relPath };
+      }
+    }
+  }
+
+  return { changedFiles: [], description: '' };
+}

package/src/paths.js

@@ -0,0 +1,24 @@
+import { mkdirSync, existsSync, renameSync, readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+import { fileURLToPath } from 'url';
+
+// All user data lives in ~/.git-cracked so it survives npx cache cleanup
+// and package updates.
+export const DATA_DIR = join(homedir(), '.git-cracked');
+export const CONFIG_PATH = join(DATA_DIR, 'config.json');
+export const ACTIVITY_PATH = join(DATA_DIR, 'activity.json');
+
+mkdirSync(DATA_DIR, { recursive: true });
+
+// Migrate config/activity from the old in-package location (pre-1.2.0)
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const oldConfig = join(__dirname, '..', 'config.json');
+const oldActivity = join(__dirname, '..', 'activity.json');
+
+if (!existsSync(CONFIG_PATH) && existsSync(oldConfig)) {
+  try { renameSync(oldConfig, CONFIG_PATH); } catch {}
+}
+if (!existsSync(ACTIVITY_PATH) && existsSync(oldActivity)) {
+  try { renameSync(oldActivity, ACTIVITY_PATH); } catch {}
+}

package/src/setup.js

@@ -0,0 +1,50 @@
+import { createInterface } from 'readline';
+import { writeFileSync, existsSync, readFileSync } from 'fs';
+import { CONFIG_PATH as configPath } from './paths.js';
+
+const rl = createInterface({ input: process.stdin, output: process.stdout });
+const ask = (q) => new Promise((res) => rl.question(q, res));
+
+const platform = process.platform;
+const installCmd =
+  platform === 'win32' ? 'npm run install-windows'
+  : platform === 'darwin' ? 'npm run install-mac'
+  : 'npm run install-linux';
+
+console.log('\n=== Git Cracked Setup ===\n');
+
+const existing = existsSync(configPath)
+  ? JSON.parse(readFileSync(configPath, 'utf8'))
+  : {};
+
+const repoPath = (await ask(`Absolute path to your private repo [${existing.repoPath ?? ''}]: `)).trim()
+  || existing.repoPath;
+
+if (!repoPath) {
+  console.error('Repo path is required.');
+  process.exit(1);
+}
+
+const branch = (await ask(`Branch [${existing.branch ?? 'main'}]: `)).trim()
+  || existing.branch
+  || 'main';
+
+const pushInput = (await ask(`Push to remote after each commit? (y/n) [${existing.pushAfterCommit !== false ? 'y' : 'n'}]: `)).trim().toLowerCase();
+const pushAfterCommit = pushInput ? pushInput === 'y' : existing.pushAfterCommit !== false;
+
+const config = {
+  repoPath,
+  branch,
+  remoteName: existing.remoteName ?? 'origin',
+  pushAfterCommit,
+  schedule: existing.schedule ?? ['0 9 * * 1-5', '0 13 * * 1-5', '0 16 * * 1-5'],
+};
+
+writeFileSync(configPath, JSON.stringify(config, null, 2));
+
+console.log(`\nConfig saved to ${configPath}`);
+console.log('\nNext steps:');
+console.log('  Test a commit right now:  npm run commit-now');
+console.log('  Start the scheduler:      npm start');
+console.log(`  Auto-start on boot:       ${installCmd}`);
+rl.close();