feat: fixed some issues with save and load.

Author: dlabaj

package.json

@@ -36,8 +36,12 @@
       ]
     },
     "moduleNameMapper": {
-      "^(\\.\\./.*)\\.js$": "$1"
-    }
+      "^(\\.\\./.*)\\.js$": "$1",
+      "^(\\./.*)\\.js$": "$1"
+    },
+    "transformIgnorePatterns": [
+      "/node_modules/(?!inquirer)"
+    ]
   },
   "dependencies": {
     "0g": "^0.4.2",

src/__tests__/cli.test.ts

@@ -1,3 +1,8 @@
+jest.mock('inquirer', () => ({
+  __esModule: true,
+  default: { prompt: jest.fn() },
+}));
+
 import path from 'path';
 import fs from 'fs-extra';
 import { loadCustomTemplates, mergeTemplates } from '../template-loader.js';

src/__tests__/github.test.ts

@@ -3,6 +3,11 @@ jest.mock('execa', () => ({
   execa: jest.fn(),
 }));
 
+jest.mock('inquirer', () => ({
+  __esModule: true,
+  default: { prompt: jest.fn() },
+}));
+
 import {
   sanitizeRepoName,
   checkGhAuth,
@@ -141,28 +146,36 @@ describe('createRepo', () => {
   });
 
   it('initializes git and calls gh repo create with expected args and returns repo URL', async () => {
+    mockExeca
+      .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+      .mockRejectedValueOnce(new Error('no HEAD'))
+      .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+      .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+      .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 });
+
     const url = await createRepo({
       repoName: 'my-app',
       projectPath,
       username,
     });
 
     expect(url).toBe('https://github.com/octocat/my-app.git');
-    expect(mockExeca).toHaveBeenCalledTimes(4);
+    expect(mockExeca).toHaveBeenCalledTimes(5);
     expect(mockExeca).toHaveBeenNthCalledWith(1, 'git', ['init'], {
       stdio: 'inherit',
       cwd: projectPath,
     });
-    expect(mockExeca).toHaveBeenNthCalledWith(2, 'git', ['add', '.'], {
+    expect(mockExeca).toHaveBeenNthCalledWith(2, 'git', ['rev-parse', '--verify', 'HEAD'], expect.any(Object));
+    expect(mockExeca).toHaveBeenNthCalledWith(3, 'git', ['add', '.'], {
       stdio: 'inherit',
       cwd: projectPath,
     });
-    expect(mockExeca).toHaveBeenNthCalledWith(3, 'git', ['commit', '-m', 'Initial commit'], {
+    expect(mockExeca).toHaveBeenNthCalledWith(4, 'git', ['commit', '-m', 'Initial commit'], {
       stdio: 'inherit',
       cwd: projectPath,
     });
     expect(mockExeca).toHaveBeenNthCalledWith(
-      4,
+      5,
       'gh',
       [
         'repo',
@@ -178,6 +191,13 @@ describe('createRepo', () => {
   });
 
   it('passes description when provided', async () => {
+    mockExeca
+      .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+      .mockRejectedValueOnce(new Error('no HEAD'))
+      .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+      .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+      .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 });
+
     await createRepo({
       repoName: 'my-app',
       projectPath,
@@ -186,7 +206,7 @@ describe('createRepo', () => {
     });
 
     expect(mockExeca).toHaveBeenNthCalledWith(
-      4,
+      5,
       'gh',
       expect.arrayContaining(['--description=My cool project']),
       expect.any(Object),

src/__tests__/save.test.ts

@@ -17,14 +17,20 @@ jest.mock('inquirer', () => ({
   },
 }));
 
+jest.mock('../github.js', () => ({
+  offerAndCreateGitHubRepo: jest.fn(),
+}));
+
 import fs from 'fs-extra';
 import { execa } from 'execa';
 import inquirer from 'inquirer';
+import { offerAndCreateGitHubRepo } from '../github.js';
 import { runSave } from '../save.js';
 
 const mockPathExists = fs.pathExists as jest.MockedFunction<typeof fs.pathExists>;
 const mockExeca = execa as jest.MockedFunction<typeof execa>;
 const mockPrompt = inquirer.prompt as jest.MockedFunction<typeof inquirer.prompt>;
+const mockOfferAndCreateGitHubRepo = offerAndCreateGitHubRepo as jest.MockedFunction<typeof offerAndCreateGitHubRepo>;
 
 const cwd = '/tmp/my-repo';
 
@@ -125,14 +131,15 @@ describe('runSave', () => {
       .mockResolvedValueOnce({ stdout: ' M file.ts', stderr: '', exitCode: 0 })
       .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
       .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+      .mockResolvedValueOnce({ stdout: 'https://github.com/user/repo.git', stderr: '', exitCode: 0 })
       .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 });
     mockPrompt
       .mockResolvedValueOnce({ saveChanges: true })
       .mockResolvedValueOnce({ message: 'Fix bug in save command' });
 
     await runSave(cwd);
 
-    expect(mockExeca).toHaveBeenCalledTimes(4);
+    expect(mockExeca).toHaveBeenCalledTimes(5);
     expect(mockExeca).toHaveBeenNthCalledWith(1, 'git', ['status', '--porcelain'], {
       cwd,
       encoding: 'utf8',
@@ -146,7 +153,8 @@ describe('runSave', () => {
       '-m',
       'Fix bug in save command',
     ], { cwd, stdio: 'inherit' });
-    expect(mockExeca).toHaveBeenNthCalledWith(4, 'git', ['push'], {
+    expect(mockExeca).toHaveBeenNthCalledWith(4, 'git', ['remote', 'get-url', 'origin'], expect.any(Object));
+    expect(mockExeca).toHaveBeenNthCalledWith(5, 'git', ['push'], {
       cwd,
       stdio: 'inherit',
     });
@@ -161,6 +169,7 @@ describe('runSave', () => {
       .mockResolvedValueOnce({ stdout: ' M file.ts', stderr: '', exitCode: 0 })
       .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
       .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+      .mockResolvedValueOnce({ stdout: 'https://github.com/user/repo.git', stderr: '', exitCode: 0 })
       .mockRejectedValueOnce(Object.assign(new Error('push failed'), { exitCode: 128 }));
 
     mockPrompt
@@ -200,6 +209,7 @@ describe('runSave', () => {
       .mockResolvedValueOnce({ stdout: ' M file.ts', stderr: '', exitCode: 0 })
       .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
       .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+      .mockResolvedValueOnce({ stdout: 'https://github.com/user/repo.git', stderr: '', exitCode: 0 })
       .mockRejectedValueOnce(new Error('network error'));
 
     mockPrompt
@@ -215,4 +225,48 @@ describe('runSave', () => {
       expect.stringContaining('network error'),
     );
   });
+
+  it('when no remote origin, offers to create GitHub repo and throws if user does not create', async () => {
+    mockPathExists.mockResolvedValue(true);
+    mockExeca
+      .mockResolvedValueOnce({ stdout: ' M file.ts', stderr: '', exitCode: 0 })
+      .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+      .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+      .mockRejectedValueOnce(new Error('no remote'));
+    mockOfferAndCreateGitHubRepo.mockResolvedValue(false);
+
+    mockPrompt
+      .mockResolvedValueOnce({ saveChanges: true })
+      .mockResolvedValueOnce({ message: 'WIP' });
+
+    await expect(runSave(cwd)).rejects.toThrow('No remote origin');
+    expect(mockOfferAndCreateGitHubRepo).toHaveBeenCalledWith(cwd);
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Set a remote'),
+    );
+    expect(mockExeca).not.toHaveBeenCalledWith('git', ['push'], expect.any(Object));
+  });
+
+  it('when no remote origin and user creates GitHub repo, pushes successfully', async () => {
+    mockPathExists.mockResolvedValue(true);
+    mockExeca
+      .mockResolvedValueOnce({ stdout: ' M file.ts', stderr: '', exitCode: 0 })
+      .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+      .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+      .mockRejectedValueOnce(new Error('no remote'))
+      .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 });
+    mockOfferAndCreateGitHubRepo.mockResolvedValue(true);
+
+    mockPrompt
+      .mockResolvedValueOnce({ saveChanges: true })
+      .mockResolvedValueOnce({ message: 'WIP' });
+
+    await runSave(cwd);
+
+    expect(mockOfferAndCreateGitHubRepo).toHaveBeenCalledWith(cwd);
+    expect(mockExeca).toHaveBeenCalledWith('git', ['push'], { cwd, stdio: 'inherit' });
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Changes saved and pushed to GitHub successfully'),
+    );
+  });
 });

src/cli.ts

@@ -7,7 +7,7 @@ import fs from 'fs-extra';
 import path from 'path';
 import { defaultTemplates } from './templates.js';
 import { mergeTemplates } from './template-loader.js';
-import { checkGhAuth, createRepo, repoExists as ghRepoExists, sanitizeRepoName } from './github.js';
+import { offerAndCreateGitHubRepo } from './github.js';
 import { runSave } from './save.js';
 import { runLoad } from './load.js';
 
@@ -175,84 +175,7 @@ program
       console.log('✅ Dependencies installed.');
 
       // Optional: Create GitHub repository
-      const { createGitHub } = await inquirer.prompt([
-        {
-          type: 'confirm',
-          name: 'createGitHub',
-          message: 'Would you like to create a GitHub repository for this project?',
-          default: false,
-        },
-      ]);
-
-      if (createGitHub) {
-        const auth = await checkGhAuth();
-        if (!auth.ok) {
-          console.log(`\n⚠️  ${auth.message}`);
-          console.log('   Skipping GitHub repository creation.\n');
-        } else {
-          const pkgJsonForGh = await fs.readJson(pkgJsonPath);
-          const projectName = pkgJsonForGh.name as string;
-          let repoName = sanitizeRepoName(projectName);
-
-          // If repo already exists, ask for alternative name until we get one that doesn't exist or user skips
-          while (await ghRepoExists(auth.username, repoName)) {
-            console.log(`\n⚠️  A repository named "${repoName}" already exists on GitHub under your account.\n`);
-            const { alternativeName } = await inquirer.prompt([
-              {
-                type: 'input',
-                name: 'alternativeName',
-                message: 'Enter an alternative repository name (or leave empty to skip creating a GitHub repository):',
-                default: '',
-              },
-            ]);
-            if (!alternativeName?.trim()) {
-              repoName = '';
-              break;
-            }
-            repoName = sanitizeRepoName(alternativeName.trim());
-          }
-
-          if (repoName) {
-            const repoUrl = `https://github.com/${auth.username}/${repoName}`;
-            console.log('\n📋 The following will happen:\n');
-            console.log(`   • A new public repository will be created at: ${repoUrl}`);
-            console.log(`   • The repository will be created under your GitHub account (${auth.username}).`);
-            console.log(`   • The repository URL will be added to your package.json.`);
-            console.log(`   • The remote "origin" will be set to this repository (you can push when ready).\n`);
-
-            const { confirmCreate } = await inquirer.prompt([
-              {
-                type: 'confirm',
-                name: 'confirmCreate',
-                message: 'Do you want to proceed with creating this repository?',
-                default: true,
-              },
-            ]);
-
-            if (!confirmCreate) {
-              console.log('\n❌ GitHub repository was not created. Your local project is ready at:');
-              console.log(`   ${projectPath}\n`);
-            } else {
-              try {
-                const createdUrl = await createRepo({
-                  repoName,
-                  projectPath,
-                  username: auth.username,
-                  ...(pkgJsonForGh.description && { description: String(pkgJsonForGh.description) }),
-                });
-                pkgJsonForGh.repository = { type: 'git', url: createdUrl };
-                await fs.writeJson(pkgJsonPath, pkgJsonForGh, { spaces: 2 });
-                console.log('\n✅ GitHub repository created successfully!');
-                console.log(`   ${repoUrl}`);
-                console.log('   Repository URL has been added to your package.json.\n');
-              } catch (err) {
-                console.error('\n❌ Failed to create GitHub repository:');
-                if (err instanceof Error) console.error(`   ${err.message}\n`);
-              }
-            }
-          }
-        }
-      }
+      await offerAndCreateGitHubRepo(projectPath);
 
       // Let the user know the project was created successfully
       console.log('\n✨ Project created successfully! ✨\n');
@@ -278,6 +201,21 @@ program
     }
   });
 
+/** Command to initialize a project and optionally create a GitHub repository */
+program
+  .command('init')
+  .description('Initialize the current directory (or path) as a git repo and optionally create a GitHub repository')
+  .argument('[path]', 'Path to the project directory (defaults to current directory)')
+  .action(async (dirPath) => {
+    const cwd = dirPath ? path.resolve(dirPath) : process.cwd();
+    const gitDir = path.join(cwd, '.git');
+    if (!(await fs.pathExists(gitDir))) {
+      await execa('git', ['init'], { stdio: 'inherit', cwd });
+      console.log('✅ Git repository initialized.\n');
+    }
+    await offerAndCreateGitHubRepo(cwd);
+  });
+
 /** Command to list all available templates */
 program
   .command('list')