@jaimanm/resumake 1.0.0

package/.github/workflows/cli-tests.yml

@@ -0,0 +1,27 @@
+name: CLI Tests
+
+on:
+  push:
+    branches:
+      - develop
+      - 'feature/*'
+      - 'bugfix/*'
+      - 'fix/*'
+      - 'bug/*'
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+      - name: Install dependencies
+        run: npm ci
+      - name: Run tests
+        run: npm test

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,30 @@
+name: Publish Package to npmjs
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          registry-url: 'https://registry.npmjs.org/'
+          
+      - name: Install dependencies
+        run: npm ci
+        
+      - name: Run tests before publishing
+        run: npm test
+        
+      - name: Publish to NPM with Provenance
+        run: npm publish --provenance --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/CONTRIBUTING.md

@@ -0,0 +1,31 @@
+# Contributing Guidelines
+
+First off, thanks for taking the time to contribute!
+
+All types of contributions are encouraged and valued. See the Table of Contents for different ways to help and details about how this project handles them. Please make sure to read the relevant section before making your contribution. It will make it a lot easier for us maintainers and smooth out the experience for all involved.
+
+## Development Workflow
+
+We strictly adhere to a Git Flow process. **Direct pushes to the `main` branch are strictly prohibited**, even for repository administrators and AI assistants.
+
+To contribute, you must follow these exact steps:
+
+1. **Create an Issue:**
+   Before writing code, create an issue describing the bug you intend to fix or the feature you intend to build.
+
+2. **Branch off from `main`:**
+   Use a semantic naming convention for your branch:
+   - `feat/description` for new features
+   - `fix/description` for bug fixes
+   - `chore/description` for non-functional tasks (docs, CI/CD, etc.)
+
+3. **Write Tests:**
+   If you are contributing to the Node.js CLI logic in `src-cli`, ensure that your logic is fully covered by Jest tests in `src-cli/tests/index.test.js`. Execute `npm test` inside `src-cli` to verify.
+
+4. **Submit a Pull Request:**
+   Push your branch and open a Pull Request against `main`. Ensure your PR description links back to the issue it resolves (e.g., "Closes #5").
+
+5. **Wait for CI / Review:**
+   The `main` branch is protected. All GitHub Action status checks (such as the `test` workflow) must pass before a merge is permitted.
+
+By following these guidelines, we ensure that the `main` branch remains perfectly stable for end-users relying on our CLI tool!

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jaiman Munshi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,35 @@
+# ResuMake
+
+A magical, fully-automated LaTeX resume workflow. Write your resume in LaTeX, and automatically compile it, release it, and sync it to Google Drive every time you push.
+
+## Why ResuMake?
+The core philosophy behind ResuMake is to treat your resume like a professional software engineering project:
+1. **Local Live-Editing:** Use `resumake dev` to instantly see your PDF update as you make local LaTeX code changes.
+2. **Version Control for Code:** Push your changes to GitHub to maintain a perfect, branched version history of the raw LaTeX code.
+3. **Version Control for PDFs:** GitHub Actions automatically compiles and creates historical GitHub Releases, giving you version control for the actual compiled PDFs.
+4. **Frictionless "Production" Access:** The CI/CD pipeline syncs the compiled releases directly to your Google Drive Desktop. You always have immediate, one-click access to your most up-to-date "production" PDF when applying for jobs, without manually downloading or moving files.
+
+## Features
+- 🚀 **Interactive CLI Setup:** Automatically scaffolds a private GitHub repo and sets up Google Drive Sync.
+- 🔄 **Live Reloading:** Watch mode that automatically recompiles your PDFs instantly on file save.
+- ☁️ **Cloud CI/CD & Sync:** Uses GitHub actions to safely store your compiled PDF resume in Google Drive and create GitHub releases!
+- 🎨 **Multiple Templates:** Choose from Modular Multi-Resume, Awesome-CV, and Jake's Resume!
+
+## Getting Started
+
+1. Install the CLI globally via NPM:
+   ```bash
+   npm install -g @jaimanm/resumake
+   ```
+2. Run the interactive setup wizard anywhere on your machine:
+   ```bash
+   resumake setup
+   ```
+3. Follow the CLI instructions to authenticate with Google Drive, pick a template, and it will scaffold your new private resume repository!
+
+## Local Development
+After setup, navigate to your **newly created private repository** and run:
+```bash
+resumake dev
+```
+This will start a watcher that instantly rebuilds your `.pdf` using local LaTeX tools every time you save a `.tex` file.

package/bin/index.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../src/index.js');

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@jaimanm/resumake",
+  "version": "1.0.0",
+  "description": "CLI to scaffold a magical LaTeX resume environment",
+  "main": "index.js",
+  "bin": {
+    "resumake": "./bin/index.js"
+  },
+  "scripts": {
+    "test": "jest"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "jest": "^29.0.0"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "chokidar": "^3.6.0",
+    "commander": "^15.0.0",
+    "execa": "^5.1.1",
+    "inquirer": "^8.2.7",
+    "ora": "^5.4.1"
+  }
+}

package/src/commands/config.js

@@ -0,0 +1,101 @@
+const inquirer = require('inquirer');
+const execa = require('execa');
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+const ora = require('ora');
+
+module.exports = async function configCommand() {
+  const answers = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'setting',
+      message: 'What would you like to configure?',
+      choices: [
+        { name: 'Google Drive Sync Folder', value: 'driveFolder' },
+        { name: 'Exported PDF Filename', value: 'pdfName' }
+      ]
+    }
+  ]);
+
+  const { setting } = answers;
+  const spinner = ora();
+
+  try {
+    if (setting === 'driveFolder') {
+      const actionPath = path.join(process.cwd(), '.github/workflows/build-resume.yml');
+      if (!fs.existsSync(actionPath)) {
+        console.log(chalk.red('Error: Could not find .github/workflows/build-resume.yml. Are you in the project root?'));
+        process.exit(1);
+      }
+
+      let actionContent = fs.readFileSync(actionPath, 'utf8');
+      const driveMatch = actionContent.match(/rclone sync PDF_Exports\/ gdrive:(.*?)\//);
+      const currentDriveFolder = driveMatch ? driveMatch[1] : 'Resumes';
+
+      const { driveFolder } = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'driveFolder',
+          message: 'What folder in Google Drive should your PDFs sync to?',
+          default: currentDriveFolder
+        }
+      ]);
+
+      if (driveFolder === currentDriveFolder) {
+        console.log(chalk.green('\nConfiguration is already up to date. No changes made.'));
+        return;
+      }
+
+      spinner.start('Updating configuration and syncing to GitHub...');
+      actionContent = actionContent.replace(new RegExp(`gdrive:${currentDriveFolder}\/`, 'g'), `gdrive:${driveFolder}/`);
+      actionContent = actionContent.replace(new RegExp(`Google Drive '${currentDriveFolder}' folder`, 'g'), `Google Drive '${driveFolder}' folder`);
+      fs.writeFileSync(actionPath, actionContent);
+      
+      await execa('git', ['add', actionPath]);
+      await execa('git', ['commit', '-m', `chore: update google drive sync folder to ${driveFolder}`]);
+      await execa('git', ['push']);
+      
+      spinner.succeed(`Successfully updated Google Drive sync folder to "${driveFolder}"!`);
+      
+    } else if (setting === 'pdfName') {
+      const buildPath = path.join(process.cwd(), 'build_all.sh');
+      if (!fs.existsSync(buildPath)) {
+        console.log(chalk.red('Error: Could not find build_all.sh. Are you in the project root?'));
+        process.exit(1);
+      }
+
+      let buildContent = fs.readFileSync(buildPath, 'utf8');
+      const jobNameMatch = buildContent.match(/-jobname="(.*?)"/);
+      const currentPdfName = jobNameMatch ? jobNameMatch[1] : 'Resume';
+
+      const { pdfName } = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'pdfName',
+          message: 'What should your output PDF be named (without .pdf)?',
+          default: currentPdfName
+        }
+      ]);
+
+      if (pdfName === currentPdfName) {
+        console.log(chalk.green('\nConfiguration is already up to date. No changes made.'));
+        return;
+      }
+
+      spinner.start('Updating build script and syncing to GitHub...');
+      buildContent = buildContent.replace(/-jobname=".*?"/g, `-jobname="${pdfName}"`);
+      fs.writeFileSync(buildPath, buildContent);
+      
+      await execa('git', ['add', buildPath]);
+      await execa('git', ['commit', '-m', `chore: update output PDF filename to ${pdfName}.pdf`]);
+      await execa('git', ['push']);
+      
+      spinner.succeed(`Successfully updated Exported PDF Filename to "${pdfName}.pdf"!`);
+    }
+  } catch (err) {
+    if (spinner.isSpinning) spinner.fail('Failed to update configuration.');
+    console.error(chalk.red(err.message));
+    process.exit(1);
+  }
+};

package/src/commands/dev.js

@@ -0,0 +1,27 @@
+const chokidar = require('chokidar');
+const execa = require('execa');
+const chalk = require('chalk');
+const fs = require('fs');
+
+module.exports = async function devCommand() {
+  console.log(chalk.cyan('Starting live-development server...'));
+  
+  const watcher = chokidar.watch('**/*.tex', {
+    ignored: /(^|[\/\\])\../,
+    persistent: true
+  });
+
+  watcher
+    .on('ready', () => console.log(chalk.green('Watching for changes in .tex files...')))
+    .on('change', async fileChanged => {
+      console.log(chalk.yellow(`\nFile ${fileChanged} has been changed. Rebuilding...`));
+      
+      try {
+        await execa('./build_all.sh');
+        console.log(chalk.green('Build successful!'));
+      } catch (error) {
+        console.log(chalk.red('Build failed! See build.log for details.'));
+        fs.writeFileSync('build.log', (error.stdout || '') + '\n' + (error.stderr || ''));
+      }
+    });
+};

package/src/commands/setup.js

@@ -0,0 +1,189 @@
+const inquirer = require('inquirer');
+const execa = require('execa');
+const ora = require('ora');
+const chalk = require('chalk');
+const fs = require('fs');
+
+async function checkDependencies() {
+  const missing = [];
+  try { await execa('git', ['--version']); } catch { missing.push('git'); }
+  try { await execa('gh', ['--version']); } catch { missing.push('gh'); }
+  try { await execa('rclone', ['--version']); } catch { missing.push('rclone'); }
+
+  if (missing.length > 0) {
+    console.log(chalk.yellow(`Missing required dependencies: ${missing.join(', ')}`));
+    const { install } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'install',
+      message: 'Would you like to automatically install them via Homebrew now?',
+      default: true
+    }]);
+
+    if (install) {
+      const spinner = ora('Installing dependencies...').start();
+      try {
+        await execa('brew', ['install', ...missing]);
+        spinner.succeed('Dependencies installed!');
+      } catch (err) {
+        spinner.fail('Failed to install dependencies automatically. Please install them manually.');
+        process.exit(1);
+      }
+    } else {
+      console.log(chalk.red('Cannot proceed without dependencies.'));
+      process.exit(1);
+    }
+  }
+}
+
+module.exports = async function setupCommand() {
+  console.log(chalk.cyan('\n🚀 Welcome to the ResuMake Setup Wizard!\n'));
+  
+  await checkDependencies();
+
+  const path = require('path');
+
+  // ======================================================================
+  //  PHASE 1: Collect ALL user inputs before doing anything destructive.
+  //  Ctrl+C anywhere in this phase is a clean abort with zero side effects.
+  // ======================================================================
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'targetDir',
+      message: 'Where would you like to clone your new resume repository locally?',
+      default: '..'
+    },
+    {
+      type: 'input',
+      name: 'repoName',
+      message: 'What would you like to name your new private repository?',
+      default: 'my-resume',
+      validate: async (input, answers) => {
+        if (!input) return 'Repository name cannot be empty.';
+        const targetPath = path.resolve(answers.targetDir, input);
+        if (fs.existsSync(targetPath)) {
+            return `A folder named "${input}" already exists at ${targetPath}. Please choose a different name or directory.`;
+        }
+        try {
+            await execa('gh', ['repo', 'view', input]);
+            return `Repository "${input}" already exists on your GitHub account. Please choose a different name.`;
+        } catch {
+            return true;
+        }
+      }
+    },
+    {
+      type: 'list',
+      name: 'template',
+      message: 'Which resume template would you like to use?',
+      choices: [
+        { name: 'Modular Multi-Resume (3 versions)', value: 'modular-multi' },
+        { name: 'Standard (Single version)', value: 'standard' },
+        { name: 'Awesome-CV (Professional)', value: 'awesome-cv' },
+        { name: "Jake's Resume (Classic)", value: 'jakes-resume' },
+        { name: "Jake's CV (Classic + Extended Sections)", value: 'jakes-cv' }
+      ]
+    },
+    {
+      type: 'input',
+      name: 'driveFolder',
+      message: 'What folder in Google Drive should your PDFs sync to?',
+      default: 'Resumes'
+    }
+  ]);
+
+  console.log(chalk.cyan('\nNow, let\'s set up your Google Drive Sync!'));
+  console.log('A browser window will pop open for you to log into Google Drive.');
+  
+  const { ready } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'ready',
+    message: 'Ready to authenticate?',
+    default: true
+  }]);
+
+  const { repoName, template, driveFolder, targetDir } = answers;
+
+  // ======================================================================
+  //  PHASE 2: Execute all side effects. No more prompts from here on out.
+  // ======================================================================
+  console.log(chalk.green(`\nAwesome! Setting up ${repoName} using the ${template} template...\n`));
+  
+  const scaffoldSpinner = ora('Creating GitHub repository and pulling template...').start();
+  let remoteUrl;
+  try {
+    await execa('gh', ['auth', 'status']);
+    // Change to target directory before cloning
+    const absoluteTargetDir = path.resolve(targetDir);
+    if (!fs.existsSync(absoluteTargetDir)) fs.mkdirSync(absoluteTargetDir, { recursive: true });
+    process.chdir(absoluteTargetDir);
+
+    await execa('gh', ['repo', 'create', repoName, '--private', '--clone']);
+    process.chdir(repoName);
+    
+    // Get the exact origin URL for future gh CLI calls (fixes multiple remotes bug)
+    const urlResult = await execa('git', ['config', '--get', 'remote.origin.url']);
+    remoteUrl = urlResult.stdout.trim();
+
+    await execa('git', ['remote', 'add', 'template', 'https://github.com/jaimanm/resumake.git']);
+    await execa('git', ['fetch', 'template']);
+    await execa('git', ['reset', '--hard', `template/template/${template}`]);
+    
+    // Customize the GitHub action with the user's preferred Google Drive folder
+    const actionPath = '.github/workflows/build-resume.yml';
+    if (fs.existsSync(actionPath)) {
+        let actionContent = fs.readFileSync(actionPath, 'utf8');
+        actionContent = actionContent.replace(/gdrive:Resumes\//g, `gdrive:${driveFolder}/`);
+        fs.writeFileSync(actionPath, actionContent);
+    }
+    
+    await execa('git', ['add', '.']);
+    await execa('git', ['commit', '-m', `Scaffold ${template} with custom Drive folder`]);
+    scaffoldSpinner.succeed(`Successfully created ${repoName} and scaffolded template!`);
+  } catch (err) {
+    scaffoldSpinner.fail('Failed to scaffold repository.');
+    console.error(chalk.red(err.message));
+    if (err.message.includes('auth')) {
+      console.log(chalk.yellow('Please run "gh auth login" first to connect your GitHub account.'));
+    }
+    process.exit(1);
+  }
+
+  if (ready) {
+    const driveSpinner = ora('Waiting for Google Drive authentication...').start();
+    try {
+      const { stdout, stderr } = await execa('rclone', ['authorize', 'drive']);
+      const tokenMatch = (stdout + stderr).match(/\{"access_token".*\}/);
+      
+      if (!tokenMatch) {
+        throw new Error('Could not extract token from rclone output.');
+      }
+      
+      const tokenJson = tokenMatch[0];
+      const rcloneConfContent = `[gdrive]\ntype = drive\nscope = drive\ntoken = ${tokenJson}`;
+      
+      driveSpinner.text = 'Uploading token securely to GitHub Secrets...';
+      await execa('gh', ['secret', 'set', 'RCLONE_CONF', '--body', rcloneConfContent, '-R', remoteUrl]);
+      driveSpinner.succeed('Google Drive token successfully secured in GitHub Secrets!');
+    } catch (err) {
+      driveSpinner.fail('Failed to setup Google Drive sync.');
+      console.error(chalk.red(err.message));
+      console.log(chalk.yellow('\nPlease try running the setup again, or open an issue on the repository if the problem persists.'));
+    }
+  }
+
+  const pushSpinner = ora('Pushing initial commit to trigger GitHub Action...').start();
+  try {
+    await execa('git', ['push', '-u', 'origin', 'main', '--force']);
+    pushSpinner.succeed('Initial commit pushed! GitHub Actions is now building and syncing your resume.');
+  } catch (err) {
+    pushSpinner.fail('Failed to push to GitHub.');
+    console.error(chalk.red(err.message));
+  }
+
+  console.log(chalk.green(`\n🎉 All done! Your magical resume environment is ready.`));
+  console.log(chalk.white(`\nNext steps:`));
+  console.log(chalk.cyan(`  cd ${path.join(targetDir, repoName)}`));
+  console.log(chalk.cyan(`  resumake dev`));
+  console.log(chalk.white(`\nTo live-edit your resume!\n`));
+};

package/src/index.js

@@ -0,0 +1,28 @@
+const { Command } = require('commander');
+const setupCommand = require('./commands/setup');
+const devCommand = require('./commands/dev');
+const configCommand = require('./commands/config');
+
+const program = new Command();
+
+program
+  .name('resume-env')
+  .description('CLI to automatically setup a magical LaTeX resume environment')
+  .version('1.0.0');
+
+program
+  .command('setup')
+  .description('Scaffold a new resume project from a template')
+  .action(setupCommand);
+
+program
+  .command('dev')
+  .description('Start the local live-reload development server')
+  .action(devCommand);
+
+program
+  .command('config')
+  .description('Configure the CLI settings (e.g., Google Drive sync folder)')
+  .action(configCommand);
+
+program.parse();

package/tests/index.test.js

@@ -0,0 +1,179 @@
+const setupCommand = require('../src/commands/setup');
+const devCommand = require('../src/commands/dev');
+const inquirer = require('inquirer');
+const execa = require('execa');
+const chokidar = require('chokidar');
+const fs = require('fs');
+
+jest.mock('inquirer');
+jest.mock('execa');
+jest.mock('chokidar');
+jest.mock('fs');
+
+describe('CLI Commands', () => {
+  let exitMock, logMock, errorMock, chdirMock;
+
+  beforeEach(() => {
+    exitMock = jest.spyOn(process, 'exit').mockImplementation((code) => {
+      throw new Error(`process.exit(${code}) called`);
+    });
+    chdirMock = jest.spyOn(process, 'chdir').mockImplementation(() => {});
+    logMock = jest.spyOn(console, 'log').mockImplementation(() => {});
+    errorMock = jest.spyOn(console, 'error').mockImplementation(() => {});
+    
+    jest.clearAllMocks();
+  });
+
+  afterAll(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe('setup.js', () => {
+    it('Happy Path: Successfully scaffolds repo, updates action file, and sets Google Drive token', async () => {
+      execa.mockResolvedValueOnce({ stdout: 'git version' });
+      execa.mockResolvedValueOnce({ stdout: 'gh version' });
+      execa.mockResolvedValueOnce({ stdout: 'rclone v1' });
+
+      inquirer.prompt.mockResolvedValueOnce({
+        targetDir: '..',
+        repoName: 'my-test-resume',
+        template: 'modular-multi',
+        driveFolder: 'MyResumes'
+      });
+      inquirer.prompt.mockResolvedValueOnce({ ready: true });
+
+      execa.mockResolvedValueOnce({ stdout: 'Logged in' }); // gh auth status
+      execa.mockResolvedValueOnce({}); // gh repo create
+      execa.mockResolvedValueOnce({ stdout: 'https://github.com/test/repo.git\n' }); // git config --get remote.origin.url
+      execa.mockResolvedValueOnce({}); // git remote add
+      execa.mockResolvedValueOnce({}); // git fetch
+      execa.mockResolvedValueOnce({}); // git reset
+      
+      fs.existsSync.mockImplementation((pathStr) => pathStr.includes('build-resume.yml') ? true : false);
+      fs.readFileSync.mockReturnValueOnce('... rclone sync PDF_Exports/ gdrive:Resumes/ ...');
+      
+      execa.mockResolvedValueOnce({}); // git add
+      execa.mockResolvedValueOnce({}); // git commit
+
+      const fakeToken = `{"access_token":"super-secret-token","token_type":"Bearer"}`;
+      execa.mockResolvedValueOnce({ 
+        stdout: `Paste the following into your remote machine --->\n${fakeToken}\n<---End paste`,
+        stderr: ''
+      });
+
+      execa.mockResolvedValueOnce({}); // gh secret set
+      execa.mockResolvedValueOnce({}); // git push
+
+      await setupCommand();
+
+      expect(fs.writeFileSync).toHaveBeenCalledWith(
+        '.github/workflows/build-resume.yml',
+        expect.stringContaining('gdrive:MyResumes/')
+      );
+      expect(execa).toHaveBeenCalledWith('gh', ['secret', 'set', 'RCLONE_CONF', '--body', expect.stringContaining('super-secret-token'), '-R', 'https://github.com/test/repo.git']);
+      expect(exitMock).not.toHaveBeenCalled();
+    });
+
+    it('Error Path: Logs warning but continues to push if Google Drive sync fails', async () => {
+      execa.mockResolvedValueOnce({ stdout: 'git version' });
+      execa.mockResolvedValueOnce({ stdout: 'gh version' });
+      execa.mockResolvedValueOnce({ stdout: 'rclone v1' });
+
+      inquirer.prompt.mockResolvedValueOnce({
+        targetDir: '..',
+        repoName: 'my-test-resume',
+        template: 'modular-multi',
+        driveFolder: 'Resumes'
+      });
+      inquirer.prompt.mockResolvedValueOnce({ ready: true });
+
+
+      execa.mockResolvedValueOnce({ stdout: 'Logged in' }); // gh auth status
+      execa.mockResolvedValueOnce({}); // gh repo create
+      execa.mockResolvedValueOnce({ stdout: 'https://github.com/test/repo.git\n' }); // git config --get remote.origin.url
+      execa.mockResolvedValueOnce({}); // git remote add
+      execa.mockResolvedValueOnce({}); // git fetch
+      execa.mockResolvedValueOnce({}); // git reset
+      fs.existsSync.mockReturnValue(false);
+      execa.mockResolvedValueOnce({}); // git add
+      execa.mockResolvedValueOnce({}); // git commit
+
+      // Simulate rclone failure
+      execa.mockRejectedValueOnce(new Error('rclone crashed'));
+      
+      execa.mockResolvedValueOnce({}); // git push
+
+      await setupCommand();
+      expect(exitMock).not.toHaveBeenCalled();
+    });
+
+    it('Error Path: Triggers Homebrew installer if dependencies are missing', async () => {
+      execa.mockRejectedValueOnce(new Error('command not found')); // git
+      execa.mockRejectedValueOnce(new Error('command not found')); // gh
+      execa.mockRejectedValueOnce(new Error('command not found')); // rclone
+
+      inquirer.prompt.mockResolvedValueOnce({ install: true });
+
+      execa.mockResolvedValueOnce({}); // brew install git gh rclone
+
+      inquirer.prompt.mockResolvedValueOnce({ targetDir: '..', repoName: 'test', template: 'standard', driveFolder: 'Resumes' });
+      
+      execa.mockResolvedValue({ stdout: 'fake-url' }); // Default for all remaining calls
+      fs.existsSync.mockReturnValue(false);
+      inquirer.prompt.mockResolvedValueOnce({ ready: false }); // Skip drive auth
+
+      await setupCommand();
+
+      expect(execa).toHaveBeenCalledWith('brew', ['install', 'git', 'gh', 'rclone']);
+    });
+
+    it('Error Path: Exits if dependencies are missing and user declines install', async () => {
+      execa.mockRejectedValueOnce(new Error('command not found')); // git
+      execa.mockResolvedValueOnce({ stdout: 'gh version' });
+      execa.mockResolvedValueOnce({ stdout: 'rclone v1' });
+
+      inquirer.prompt.mockResolvedValueOnce({ install: false });
+
+      await expect(setupCommand()).rejects.toThrow('process.exit(1) called');
+      expect(exitMock).toHaveBeenCalledWith(1);
+    });
+
+    it('Error Path: Suggests "gh auth login" if GitHub auth fails', async () => {
+      execa.mockResolvedValueOnce({ stdout: 'git version' });
+      execa.mockResolvedValueOnce({ stdout: 'gh version' });
+      execa.mockResolvedValueOnce({ stdout: 'rclone v1' });
+
+      inquirer.prompt.mockResolvedValueOnce({ targetDir: '..', repoName: 'test', template: 'standard', driveFolder: 'Resumes' });
+      inquirer.prompt.mockResolvedValueOnce({ ready: true });
+
+      // Fail GitHub auth
+      execa.mockRejectedValueOnce(new Error('auth failed'));
+
+      await expect(setupCommand()).rejects.toThrow('process.exit(1) called');
+      expect(exitMock).toHaveBeenCalledWith(1);
+      expect(logMock).toHaveBeenCalledWith(expect.stringContaining('gh auth login'));
+    });
+  });
+
+  describe('dev.js', () => {
+    it('Happy Path: Starts chokidar watcher and rebuilds on file change', async () => {
+      let changeCallback;
+      const fakeWatcher = {
+        on: jest.fn().mockImplementation(function(event, cb) {
+          if (event === 'change') changeCallback = cb;
+          return this;
+        })
+      };
+      chokidar.watch.mockReturnValue(fakeWatcher);
+
+      await devCommand();
+
+      expect(chokidar.watch).toHaveBeenCalledWith('**/*.tex', expect.any(Object));
+
+      execa.mockResolvedValueOnce({}); // simulate build_all.sh succeeding
+      await changeCallback('resume.tex');
+
+      expect(execa).toHaveBeenCalledWith('./build_all.sh');
+    });
+  });
+});

package/tests/setup.test.js

@@ -0,0 +1,86 @@
+const inquirer = require('inquirer');
+const execa = require('execa');
+const setupCommand = require('../src/commands/setup');
+const fs = require('fs');
+
+// Mock dependencies
+jest.mock('inquirer');
+jest.mock('execa');
+jest.mock('fs');
+
+describe('resumake setup command', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    
+    // Mock successful execution for Git, GH, and Rclone version checks
+    execa.mockResolvedValue({ stdout: '', stderr: '' });
+
+    // Mock specific execa calls (like rclone authorize returning a token)
+    execa.mockImplementation((cmd, args) => {
+      if (cmd === 'rclone' && args[0] === 'authorize') {
+        return Promise.resolve({ stdout: '{"access_token": "mock_token_123"}', stderr: '' });
+      }
+      if (cmd === 'git' && args[0] === 'config' && args[1] === '--get') {
+        return Promise.resolve({ stdout: 'https://github.com/jaimanm/mock-repo.git', stderr: '' });
+      }
+      return Promise.resolve({ stdout: '', stderr: '' });
+    });
+
+    // Mock user input
+    inquirer.prompt.mockImplementation((questions) => {
+      // Return answers based on the prompt type/names
+      if (questions[0].name === 'targetDir') {
+        return Promise.resolve({
+          targetDir: '/mock/path',
+          repoName: 'my-resume',
+          template: 'standard',
+          driveFolder: 'Resumes'
+        });
+      }
+      if (questions[0].name === 'ready') {
+        return Promise.resolve({ ready: true });
+      }
+      return Promise.resolve({});
+    });
+    
+    // Mock fs so it doesn't try to read/write real files
+    fs.existsSync.mockReturnValue(true);
+    fs.readFileSync.mockReturnValue('gdrive:Resumes/');
+    fs.writeFileSync.mockReturnValue(true);
+    
+    // Spy on process.chdir to avoid changing test runner directory
+    jest.spyOn(process, 'chdir').mockImplementation(() => {});
+  });
+
+  afterAll(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('executes the correct shell commands to scaffold the template', async () => {
+    // Hide console logs during test
+    const consoleSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+    
+    await setupCommand();
+    
+    // Verify gh repo create was called
+    expect(execa).toHaveBeenCalledWith('gh', ['repo', 'create', 'my-resume', '--private', '--clone']);
+    
+    // Verify template was fetched
+    expect(execa).toHaveBeenCalledWith('git', ['remote', 'add', 'template', 'https://github.com/jaimanm/resumake.git']);
+    expect(execa).toHaveBeenCalledWith('git', ['reset', '--hard', 'template/template/standard']);
+    
+    // Verify rclone was executed
+    expect(execa).toHaveBeenCalledWith('rclone', ['authorize', 'drive']);
+    
+    // Verify GitHub Secret was set with the extracted token
+    expect(execa).toHaveBeenCalledWith(
+      'gh',
+      ['secret', 'set', 'RCLONE_CONF', '--body', expect.stringContaining('mock_token_123'), '-R', 'https://github.com/jaimanm/mock-repo.git']
+    );
+    
+    // Verify final push
+    expect(execa).toHaveBeenCalledWith('git', ['push', '-u', 'origin', 'main', '--force']);
+    
+    consoleSpy.mockRestore();
+  });
+});