gitshift 2.0.0 → 2.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitshift",
-  "version": "2.0.0",
+  "version": "2.1.1",
   "description": "GitHub Account Switcher CLI",
   "main": "server.js",
   "bin": {

package/src/commands/add.js

@@ -1,23 +1,8 @@
-import {
-    confirm,
-    input,
-} from "@inquirer/prompts";
-
+import { confirm, input } from "@inquirer/prompts";
 import ora from "ora";
-
-import {
-    getProfile,
-    saveProfile,
-} from "../services/profile.js";
-
-import {
-    generateSSHKey,
-} from "../services/ssh.js";
-
-import {
-    error,
-    success,
-} from "../utils/logger.js";
+import { getProfile, saveProfile } from "../services/profile.js";
+import { generateSSHKey } from "../services/ssh.js";
+import { error, success } from "../utils/logger.js";
 
 export async function addCommand() {
     try {
@@ -25,6 +10,12 @@ export async function addCommand() {
             message: "Profile Name",
         });
 
+        if (!name.trim()) {
+            throw new Error(
+                "Profile name is required"
+            );
+        }
+
         if (getProfile(name)) {
             error(`Profile "${name}" already exists`);
 
@@ -36,10 +27,22 @@ export async function addCommand() {
             message: "GitHub Username",
         });
 
+        if (!username.trim()) {
+            throw new Error(
+                "GitHub username is required"
+            );
+        }
+
         const email = await input({
             message: "Email",
         });
 
+        if (!email.trim()) {
+            throw new Error(
+                "Email is required"
+            );
+        }
+
         const createSSH = await confirm({
             message: "Generate SSH key automatically?",
             default: true,
@@ -80,9 +83,7 @@ export async function addCommand() {
             sshKey,
         });
 
-        success(
-            `Profile "${name}" saved locally`
-        );
+        success(`Profile "${name}" saved locally`);
     } catch (err) {
         if (err && err.name === "ExitPromptError") {
             // User canceled the prompt (Ctrl+C / SIGINT). Exit gracefully.

package/src/commands/auto.js

@@ -0,0 +1,39 @@
+
+import { setGitUser } from "../services/git.js";
+import { getFolderMappings, getProfile, setCurrentProfile } from "../services/profile.js";
+import { success } from "../utils/logger.js";
+
+export async function autoCommand() {
+    const cwd = process.cwd();
+
+    const mappings = getFolderMappings();
+
+    const matched = mappings
+        .sort(
+            (a, b) =>
+                b.path.length -
+                a.path.length
+        )
+        .find((mapping) =>
+            cwd.startsWith(
+                mapping.path
+            )
+        );
+
+    if (!matched) {
+        console.log("\nNo matching profile\n");
+        return;
+    }
+
+    const profile = getProfile(matched.profile);
+
+    if (!profile) {
+        return;
+    }
+
+    await setGitUser(profile.username, profile.email);
+
+    setCurrentProfile(profile.name);
+
+    success(`Switched to ${profile.name}`);
+}

package/src/commands/current.js

@@ -1,21 +1,15 @@
-import {
-    getCurrentProfile,
-    getProfile,
-} from "../services/profile.js";
-
+import { getCurrentProfile, getProfile, } from "../services/profile.js";
 import { info } from "../utils/logger.js";
 
 export async function currentCommand() {
-    const current =
-        getCurrentProfile();
+    const current = getCurrentProfile();
 
     if (!current) {
         info("No active profile");
         return;
     }
 
-    const profile =
-        getProfile(current);
+    const profile = getProfile(current);
 
     if (!profile) {
         info("Profile not found");
@@ -23,23 +17,9 @@ export async function currentCommand() {
     }
 
     console.log();
-
-    console.log(
-        `Profile : ${profile.name}`
-    );
-
-    console.log(
-        `Username: ${profile.username}`
-    );
-
-    console.log(
-        `Email   : ${profile.email}`
-    );
-
-    console.log(
-        `SSH Key : ${profile.sshKey || "Not configured"
-        }`
-    );
-
+    console.log(`Profile : ${profile.name}`);
+    console.log(`Username: ${profile.username}`);
+    console.log(`Email   : ${profile.email}`);
+    console.log(`SSH Key : ${profile.sshKey || "Not configured"}`);
     console.log();
 }

package/src/commands/doctor.js

@@ -1,24 +1,13 @@
 import { execa } from "execa";
+import { error, success } from "../utils/logger.js";
 
-import {
-    error,
-    success,
-} from "../utils/logger.js";
-
-async function check(
-    name,
-    command,
-    args = []
-) {
+async function check(name, command, args = []) {
     try {
         await execa(command, args);
-
         success(`${name} installed`);
-
         return true;
     } catch {
         error(`${name} missing`);
-
         return false;
     }
 }
@@ -26,25 +15,14 @@ async function check(
 export async function doctorCommand() {
     console.log();
 
-    await check("Git", "git", [
-        "--version",
-    ]);
-
-    await check("SSH", "ssh", [
-        "-V",
-    ]);
+    await check("Git", "git", ["--version",]);
+    await check("SSH", "ssh", ["-V",]);
 
-    const ghInstalled = await check(
-        "GitHub CLI",
-        "gh",
-        ["--version"]
-    );
+    const ghInstalled = await check("GitHub CLI", "gh", ["--version"]);
 
     if (!ghInstalled) {
         console.log();
-        console.log(
-            "Hint: Install GitHub CLI (macOS): `brew install gh`"
-        );
+        console.log("Hint: Install GitHub CLI (macOS): `brew install gh`");
         console.log("Then authenticate with: `gh auth login`");
     }
 

package/src/commands/link.js

@@ -0,0 +1,136 @@
+import { confirm, input, select } from "@inquirer/prompts";
+import fs from "fs-extra";
+import ora from "ora";
+import path from "path";
+import { addFolderMapping, getProfile, getProfiles, saveProfile } from "../services/profile.js";
+import { generateSSHKey } from "../services/ssh.js";
+import { error, success } from "../utils/logger.js";
+
+export async function linkCommand(folder) {
+
+    const fullPath = path.resolve(folder);
+    const exists = await fs.pathExists(fullPath);
+
+    if (!exists) {
+        error("Folder does not exist");
+        return;
+    }
+
+    let profiles = getProfiles();
+    let selectedProfile;
+
+    if (profiles.length === 0) {
+        console.log("\nNo profiles found.\n");
+        selectedProfile = await createProfile();
+    } else {
+        const choice = await select({
+            message: "Select Profile",
+            choices: [
+                ...profiles.map(
+                    (profile) => ({
+                        name: `${profile.name} (${profile.username})`,
+                        value:
+                            profile.name,
+                    })
+                ),
+                {
+                    name: "+ Create New Profile",
+                    value: "__create__",
+                },
+            ],
+        });
+
+        if (choice === "__create__") {
+            selectedProfile = await createProfile();
+        } else {
+            selectedProfile = choice;
+        }
+    }
+
+    try {
+        addFolderMapping(selectedProfile, fullPath);
+        success(`Linked ${fullPath}`);
+        success(`Profile: ${selectedProfile}`);
+    } catch (err) {
+        error(err.message);
+    }
+}
+
+async function createProfile() {
+    const name = await input({
+        message: "Profile Name",
+    });
+
+    if (!name.trim()) {
+        throw new Error("Profile name is required");
+    }
+
+    if (getProfile(name)) {
+        error(`Profile "${name}" already exists`);
+        process.exitCode = 1;
+        return;
+    }
+
+    const username =
+        await input({
+            message: "GitHub Username",
+        });
+
+    if (!username.trim()) {
+        throw new Error("GitHub username is required");
+    }
+
+    const email =
+        await input({
+            message: "Email",
+        });
+
+    if (!email.trim()) {
+        throw new Error("Email is required");
+    }
+
+    const shouldCreateSSH =
+        await confirm({
+            message: "Generate SSH Key?",
+            default: true,
+        });
+
+    let sshKey = null;
+
+    if (shouldCreateSSH) {
+        const spinner = ora("Generating SSH key...").start();
+
+        try {
+            sshKey = await generateSSHKey(name, email);
+            spinner.succeed("SSH key generated");
+        } catch (err) {
+            spinner.fail("Unable to generate SSH key");
+
+            error("Could not create SSH key. Ensure OpenSSH is installed and available.");
+
+            if (
+                err &&
+                typeof err === "object" &&
+                "shortMessage" in err &&
+                err.shortMessage
+            ) {
+                error(String(err.shortMessage));
+            }
+
+            process.exitCode = 1;
+            return;
+        }
+    }
+
+    saveProfile({
+        name,
+        username,
+        email,
+        sshKey,
+        source: "manual",
+    });
+
+    success(`Profile "${name}" created`);
+
+    return name;
+}

package/src/commands/links.js

@@ -0,0 +1,18 @@
+import { getFolderMappings } from "../services/profile.js";
+
+export async function linksCommand() {
+    const mappings = getFolderMappings();
+
+    if (!mappings.length) {
+        console.log("\nNo folder mappings\n");
+        return;
+    }
+
+    console.log();
+
+    mappings.forEach((mapping) => {
+        console.log(`${mapping.profile} → ${mapping.path}`);
+    });
+
+    console.log();
+}

package/src/commands/remove.js

@@ -1,37 +1,19 @@
-import {
-    getCurrentProfile,
-    getProfile,
-    removeProfile,
-    setCurrentProfile,
-} from "../services/profile.js";
+import { getCurrentProfile, getProfile, removeProfile, setCurrentProfile } from "../services/profile.js";
+import { error, success } from "../utils/logger.js";
 
-import {
-    error,
-    success,
-} from "../utils/logger.js";
-
-export async function removeCommand(
-    profileName
-) {
-    const profile =
-        getProfile(profileName);
+export async function removeCommand(profileName) {
+    const profile = getProfile(profileName);
 
     if (!profile) {
         error("Profile not found");
-
         return;
     }
 
     removeProfile(profileName);
 
-    if (
-        getCurrentProfile() ===
-        profileName
-    ) {
+    if (getCurrentProfile() === profileName) {
         setCurrentProfile(null);
     }
 
-    success(
-        `Profile "${profileName}" removed`
-    );
+    success(`Profile "${profileName}" removed`);
 }

package/src/commands/scan.js

@@ -1,24 +1,8 @@
+import { input, select } from "@inquirer/prompts";
 import path from "path";
-
-import {
-    input,
-    select,
-} from "@inquirer/prompts";
-
-import {
-    findSSHKeys,
-} from "../services/scan.js";
-
-import {
-    getProfiles,
-    saveProfile,
-} from "../services/profile.js";
-
-import {
-    error,
-    info,
-    success,
-} from "../utils/logger.js";
+import { getProfiles, saveProfile } from "../services/profile.js";
+import { findSSHKeys } from "../services/scan.js";
+import { error, info, success } from "../utils/logger.js";
 
 export async function scanCommand() {
     try {
@@ -30,9 +14,7 @@ export async function scanCommand() {
         }
 
         const existing = getProfiles();
-
         const importedPaths = existing.map((profile) => profile.sshKey);
-
         const available = keys.filter((key) => !importedPaths.includes(key));
 
         if (!available.length) {
@@ -57,18 +39,25 @@ export async function scanCommand() {
             message: "GitHub Username",
         });
 
+        if (!username.trim()) {
+            throw new Error("GitHub username is required");
+        }
+
         const email = await input({
             message: "Email",
         });
 
+        if (!email.trim()) {
+            throw new Error("Email is required");
+        }
+
         try {
             saveProfile({
                 name: profileName,
                 username,
                 email,
                 sshKey: selected,
-                source:
-                    "imported",
+                source: "imported",
             });
 
             success(`Existing SSH Key Imported "${profileName}"`);

package/src/commands/unlink.js

@@ -0,0 +1,9 @@
+import path from "path";
+import { removeFolderMapping } from "../services/profile.js";
+import { success } from "../utils/logger.js";
+
+export async function unlinkCommand(folder) {
+    const fullPath = path.resolve(folder);
+    removeFolderMapping(fullPath);
+    success(`Removed ${fullPath}`);
+}

package/src/commands/use.js

@@ -1,57 +1,27 @@
 import ora from "ora";
+import { setGitUser } from "../services/git.js";
+import { getProfile, setCurrentProfile } from "../services/profile.js";
+import { error, success } from "../utils/logger.js";
 
-import {
-    getProfile,
-    setCurrentProfile,
-} from "../services/profile.js";
-
-import {
-    setGitUser,
-} from "../services/git.js";
-
-import {
-    error,
-    success,
-} from "../utils/logger.js";
-
-export async function useCommand(
-    profileName
-) {
-    const profile =
-        getProfile(profileName);
+export async function useCommand(profileName) {
+    const profile = getProfile(profileName);
 
     if (!profile) {
-        error(
-            `Profile "${profileName}" not found`
-        );
-
+        error(`Profile "${profileName}" not found`);
         return;
     }
 
-    const spinner = ora(
-        "Switching profile..."
-    ).start();
+    const spinner = ora("Switching profile...").start();
 
     try {
-        await setGitUser(
-            profile.username,
-            profile.email
-        );
-
+        await setGitUser(profile.username, profile.email);
         setCurrentProfile(profile.name);
 
-        spinner.succeed(
-            "Profile switched"
-        );
+        spinner.succeed("Profile switched");
+        success(`Current profile: ${profile.name}`);
 
-        success(
-            `Current profile: ${profile.name}`
-        );
     } catch (err) {
-        spinner.fail(
-            "Unable to switch profile"
-        );
-
+        spinner.fail("Unable to switch profile");
         error(err.message);
     }
 }

package/src/server.js

@@ -5,11 +5,15 @@ import chalk from "chalk";
 import { Command } from "commander";
 import { createRequire } from "node:module";
 import { addCommand } from "./commands/add.js";
+import { autoCommand } from "./commands/auto.js";
 import { currentCommand } from "./commands/current.js";
 import { doctorCommand } from "./commands/doctor.js";
+import { linkCommand } from "./commands/link.js";
+import { linksCommand } from "./commands/links.js";
 import { listCommand } from "./commands/list.js";
 import { removeCommand } from "./commands/remove.js";
 import { scanCommand } from "./commands/scan.js";
+import { unlinkCommand } from "./commands/unlink.js";
 import { useCommand } from "./commands/use.js";
 
 const require = createRequire(import.meta.url);
@@ -58,9 +62,7 @@ async function checkForUpdates() {
         const latestVersion = response.data.version;
 
         if (latestVersion && compareVersions(version, latestVersion) < 0) {
-            console.log(
-                `A new version of ${name} is available: ${version} -> ${latestVersion}`,
-            );
+            console.log(`A new version of ${name} is available: ${version} -> ${latestVersion}`);
             console.log(`Run: npm install -g ${name}`);
         }
     } catch (error) {
@@ -113,7 +115,7 @@ async function main() {
     program
         .command("remove <profile>")
         .description(
-            "Delete profile"
+            "Remove profile"
         )
         .action(removeCommand);
 
@@ -124,6 +126,36 @@ async function main() {
         )
         .action(scanCommand);
 
+    program
+        .command(
+            "link <folder>"
+        )
+        .description(
+            "Link folder to profile"
+        )
+        .action(linkCommand);
+
+    program
+        .command("unlink <folder>")
+        .description(
+            "Remove folder mapping"
+        )
+        .action(unlinkCommand);
+
+    program
+        .command("links")
+        .description(
+            "List folder mappings"
+        )
+        .action(linksCommand);
+
+    program
+        .command("auto")
+        .description(
+            "Auto switch profile"
+        )
+        .action(autoCommand);
+
     program
         .command("doctor")
         .description(

package/src/services/git.js

@@ -1,9 +1,6 @@
 import { execa } from "execa";
 
-export async function setGitUser(
-    name,
-    email
-) {
+export async function setGitUser(name, email) {
     await execa("git", [
         "config",
         "--global",

package/src/services/profile.js

@@ -9,20 +9,27 @@ export function getProfiles() {
 }
 
 export function saveProfile(profile) {
-    const profiles = getProfiles();
 
+    if (
+        !profile.name?.trim() ||
+        !profile.username?.trim() ||
+        !profile.email?.trim()
+    ) {
+        throw new Error(
+            "Invalid profile data"
+        );
+    }
+
+    const profiles = getProfiles();
     const exists = profiles.find(
         (item) => item.name === profile.name
     );
 
     if (exists) {
-        throw new Error(
-            `Profile "${profile.name}" already exists`
-        );
+        throw new Error(`Profile "${profile.name}" already exists`);
     }
 
     profiles.push(profile);
-
     config.set("profiles", profiles);
 }
 
@@ -44,9 +51,7 @@ export function removeProfile(name) {
     config.set("profiles", filtered);
 }
 
-export function setCurrentProfile(
-    name
-) {
+export function setCurrentProfile(name) {
     if (!name) {
         config.delete("current");
         return;
@@ -57,4 +62,25 @@ export function setCurrentProfile(
 
 export function getCurrentProfile() {
     return config.get("current", null);
+}
+
+export function getFolderMappings() {
+    return config.get("folderMappings", []);
+}
+
+export function addFolderMapping(profile, folderPath) {
+    const mappings = getFolderMappings();
+    const exists = mappings.find((item) => item.path === folderPath);
+
+    if (exists) {
+        throw new Error("Folder already mapped");
+    }
+
+    mappings.push({ profile, path: folderPath, });
+    config.set("folderMappings", mappings);
+}
+
+export function removeFolderMapping(folderPath) {
+    const mappings = getFolderMappings();
+    config.set("folderMappings", mappings.filter((item) => item.path !== folderPath));
 }

package/src/services/scan.js

@@ -5,9 +5,7 @@ import path from "path";
 
 export async function findSSHKeys() {
     const sshDir = path.join(os.homedir(), ".ssh");
-
-    const exists =
-        await fs.pathExists(sshDir);
+    const exists = await fs.pathExists(sshDir);
 
     if (!exists) {
         return [];

package/src/services/ssh.js

@@ -13,32 +13,21 @@ function toSafeKeyName(profileName) {
     return normalized || "profile";
 }
 
-export async function generateSSHKey(
-    profileName,
-    email
-) {
-    const safeProfileName = toSafeKeyName(
-        profileName
-    );
-
+export async function generateSSHKey(profileName, email) {
+    const safeProfileName = toSafeKeyName(profileName);
     const keyPath = path.join(
         os.homedir(),
         ".ssh",
         `gitshift-${safeProfileName}`
     );
 
-    const exists = await fs.pathExists(
-        keyPath
-    );
+    const exists = await fs.pathExists(keyPath);
 
     if (exists) {
         return keyPath;
     }
 
-    await fs.ensureDir(
-        path.dirname(keyPath)
-    );
-
+    await fs.ensureDir(path.dirname(keyPath));
     await execa("ssh-keygen", [
         "-t",
         "ed25519",
@@ -53,14 +42,9 @@ export async function generateSSHKey(
     return keyPath;
 }
 
-export async function getPublicKey(
-    privateKeyPath
-) {
-    const publicKey =
-        `${privateKeyPath}.pub`;
-
-    const exists =
-        await fs.pathExists(publicKey);
+export async function getPublicKey(privateKeyPath) {
+    const publicKey = `${privateKeyPath}.pub`;
+    const exists = await fs.pathExists(publicKey);
 
     if (!exists) {
         return null;

package/src/utils/logger.js

@@ -1,10 +1,7 @@
 import chalk from "chalk";
 
-export const success = (msg) =>
-    console.log(chalk.green(`✓ ${msg}`));
+export const success = (msg) => console.log(chalk.green(`✓ ${msg}`));
 
-export const error = (msg) =>
-    console.log(chalk.red(`✗ ${msg}`));
+export const error = (msg) => console.log(chalk.red(`✗ ${msg}`));
 
-export const info = (msg) =>
-    console.log(chalk.cyan(msg));
+export const info = (msg) => console.log(chalk.cyan(msg));