gitshift 2.0.0 → 2.1.0

package/package.json

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

package/src/commands/auto.js

@@ -0,0 +1,51 @@
+
+import {
+    getFolderMappings,
+    getProfile,
+    setCurrentProfile,
+} from "../services/profile.js";
+
+import {
+    setGitUser,
+} from "../services/git.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/link.js

@@ -0,0 +1,146 @@
+import fs from "fs-extra";
+import path from "path";
+
+import {
+    confirm,
+    input,
+    select,
+} from "@inquirer/prompts";
+
+import {
+    addFolderMapping,
+    getProfiles,
+    saveProfile,
+} from "../services/profile.js";
+
+import {
+    generateSSHKey,
+} from "../services/ssh.js";
+
+import ora from "ora";
+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",
+        });
+
+    const username =
+        await input({
+            message: "GitHub Username",
+        });
+
+    const email =
+        await input({
+            message: "Email",
+        });
+
+    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,20 @@
+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/unlink.js

@@ -0,0 +1,17 @@
+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/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);
@@ -113,7 +117,7 @@ async function main() {
     program
         .command("remove <profile>")
         .description(
-            "Delete profile"
+            "Remove profile"
         )
         .action(removeCommand);
 
@@ -124,6 +128,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/profile.js

@@ -57,4 +57,39 @@ 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
+        )
+    );
 }