@hypercodingdev/zit 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+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,151 @@
+# zit
+
+A folder-based Git identity manager. Associate workspace folders with Git accounts — SSH keys, author name, and email are applied automatically to every repo inside.
+
+**No manual switching.** No ssh-agent. No shell hooks. Uses git's native `includeIf` to make it work everywhere — terminal, VS Code, JetBrains, any git client.
+
+## How It Works
+
+1. Register your git accounts with `zit add`
+2. Create workspace folders linked to accounts with `zit workspace init`
+3. Clone repos inside workspace folders with `zit clone`
+4. After that, `git push`, `git pull`, `git commit` — everything uses the correct identity automatically
+
+Under the hood, `zit` uses:
+- **`includeIf "gitdir:"`** — git's native conditional config that auto-loads identity settings based on repo location
+- **`core.sshCommand`** — tells git which SSH key to use, no ssh-agent needed
+
+## Installation
+
+```shell
+npm install -g zit-cli
+```
+
+Requires Node.js >= 18, `git`, and `ssh-keygen`.
+
+## Quick Start
+
+```shell
+# Register an account
+zit add
+# Account name: work
+# Git user name: John Doe
+# Git email: john@company.com
+# → Generates SSH key, prints public key to paste into GitHub/GitLab
+
+# Create a workspace folder linked to that account
+zit workspace init ~/work work
+# → Creates ~/work/, configures git includeIf
+
+# Clone a repo inside the workspace
+cd ~/work
+zit clone git@github.com:my-org/my-repo.git
+
+# From now on, git just works — no zit needed
+cd ~/work/my-repo
+git commit -m "uses work identity automatically"
+git push  # uses work SSH key automatically
+```
+
+## Commands
+
+### `zit add`
+
+Register a new git account interactively. Generates an SSH keypair.
+
+```shell
+zit add              # default: ed25519
+zit add -t rsa       # specify key type
+```
+
+Supported key types: `ed25519` (default), `rsa`, `ecdsa`, `ecdsa-sk`, `ed25519-sk`, `dsa`
+
+### `zit remove <account>`
+
+Remove an account and its SSH keys.
+
+```shell
+zit remove work
+zit remove work --force  # also removes linked workspaces
+```
+
+### `zit list`
+
+List all registered accounts with their emails.
+
+```shell
+$ zit list
+Registered accounts:
+
+  personal    john@personal.com
+  work        john@company.com
+```
+
+### `zit workspace init <path> <account>`
+
+Create a workspace folder linked to an account.
+
+```shell
+zit workspace init ~/work work
+zit workspace init ~/personal personal
+```
+
+### `zit workspace list`
+
+List all workspaces.
+
+```shell
+$ zit workspace list
+Workspaces:
+
+  work        ~/work          work
+  personal    ~/personal      personal
+```
+
+### `zit workspace remove <name>`
+
+Unlink a workspace. Keeps the folder and repos, but removes the identity link.
+
+```shell
+zit workspace remove work
+```
+
+### `zit clone <url>`
+
+Clone a repo using the current workspace's SSH key. Must be run inside a workspace folder.
+
+```shell
+cd ~/work
+zit clone git@github.com:org/repo.git
+zit clone git@github.com:org/repo.git --depth 1  # extra git clone flags work
+```
+
+### `zit status`
+
+Show the current directory's workspace and account info.
+
+```shell
+$ cd ~/work/my-repo && zit status
+Workspace: work
+Path:      ~/work
+Account:   work
+Name:      John Doe
+Email:     john@company.com
+SSH Key:   ~/.ssh/id_ed25519_work
+```
+
+## What zit Does to Your System
+
+- **`~/.config/zit/config`** — stores registered accounts and workspace mappings
+- **`~/.config/zit/workspaces/*.gitconfig`** — per-workspace git config files
+- **`~/.gitconfig`** — adds `includeIf` entries (one per workspace)
+- **`~/.ssh/id_<type>_<name>`** — SSH keypairs for each account
+
+## Platform Support
+
+- Linux
+- macOS
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const add_js_1 = require("./commands/add.js");
+const remove_js_1 = require("./commands/remove.js");
+const list_js_1 = require("./commands/list.js");
+const workspace_js_1 = require("./commands/workspace.js");
+const clone_js_1 = require("./commands/clone.js");
+const status_js_1 = require("./commands/status.js");
+const program = new commander_1.Command();
+program
+    .name("zit")
+    .description("Folder-based Git identity manager. Associate workspace folders with Git accounts.")
+    .version("1.0.0");
+(0, add_js_1.registerAddCommand)(program);
+(0, remove_js_1.registerRemoveCommand)(program);
+(0, list_js_1.registerListCommand)(program);
+(0, workspace_js_1.registerWorkspaceCommand)(program);
+(0, clone_js_1.registerCloneCommand)(program);
+(0, status_js_1.registerStatusCommand)(program);
+program.parse();

package/dist/commands/add.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerAddCommand(program: Command): void;

package/dist/commands/add.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAddCommand = registerAddCommand;
+const config_js_1 = require("../config.js");
+const ssh_js_1 = require("../ssh.js");
+const utils_js_1 = require("../utils.js");
+function registerAddCommand(program) {
+    program
+        .command("add")
+        .description("Register a new git account with SSH key generation")
+        .option("-t, --type <type>", "SSH key type (ed25519, rsa, ecdsa, ...)", "ed25519")
+        .action(async (opts) => {
+        if (!(0, ssh_js_1.isValidKeyType)(opts.type)) {
+            console.log((0, utils_js_1.red)(`Invalid key type: ${opts.type}`));
+            console.log("Valid types: ed25519, rsa, ecdsa, ecdsa-sk, ed25519-sk, dsa");
+            process.exit(1);
+        }
+        const keyType = opts.type;
+        const accountName = await (0, utils_js_1.prompt)("Account name: ");
+        if (!accountName) {
+            console.log((0, utils_js_1.red)("Account name is required."));
+            process.exit(1);
+        }
+        const config = (0, config_js_1.readConfig)();
+        if (config.accounts[accountName]) {
+            const overwrite = await (0, utils_js_1.promptYesNo)(`Account "${accountName}" already exists. Overwrite?`);
+            if (!overwrite) {
+                console.log((0, utils_js_1.yellow)("Cancelled."));
+                return;
+            }
+        }
+        const userName = await (0, utils_js_1.prompt)("Git user name: ");
+        const userEmail = await (0, utils_js_1.prompt)("Git email: ");
+        if (!userName || !userEmail) {
+            console.log((0, utils_js_1.red)("Name and email are required."));
+            process.exit(1);
+        }
+        const { privateKey, publicKey: publicKeyPath } = (0, ssh_js_1.getSshKeyPath)(accountName, keyType);
+        console.log(`\nGenerating ${keyType} SSH key...`);
+        const publicKey = (0, ssh_js_1.generateSshKey)(userEmail, privateKey, keyType);
+        config.accounts[accountName] = {
+            name: userName,
+            email: userEmail,
+            private_key: privateKey,
+            public_key: publicKeyPath,
+        };
+        (0, config_js_1.writeConfig)(config);
+        console.log((0, utils_js_1.green)("\nYour SSH public key:"));
+        console.log(publicKey);
+        console.log((0, utils_js_1.green)("\nPaste this key into your GitHub/GitLab SSH settings."));
+        console.log((0, utils_js_1.green)(`Account "${accountName}" registered successfully.`));
+    });
+}

package/dist/commands/clone.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerCloneCommand(program: Command): void;

package/dist/commands/clone.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCloneCommand = registerCloneCommand;
+const node_child_process_1 = require("node:child_process");
+const config_js_1 = require("../config.js");
+const utils_js_1 = require("../utils.js");
+function registerCloneCommand(program) {
+    program
+        .command("clone <url>")
+        .description("Clone a repo using the current workspace's SSH key")
+        .allowUnknownOption(true)
+        .allowExcessArguments(true)
+        .action((url, _opts, cmd) => {
+        const cwd = process.cwd();
+        const match = (0, config_js_1.findWorkspaceByPath)(cwd);
+        if (!match) {
+            console.log((0, utils_js_1.red)("Not inside a zit workspace."));
+            const config = (0, config_js_1.readConfig)();
+            const workspaces = Object.entries(config.workspaces);
+            if (workspaces.length > 0) {
+                console.log("\nAvailable workspaces:");
+                for (const [name, ws] of workspaces) {
+                    console.log(`  ${name}  ${(0, utils_js_1.collapseHome)(ws.path)}`);
+                }
+                console.log((0, utils_js_1.yellow)("\ncd into a workspace folder first, then run `zit clone <url>`."));
+            }
+            else {
+                console.log((0, utils_js_1.yellow)("Create a workspace first: `zit workspace init <path> <account>`"));
+            }
+            process.exit(1);
+        }
+        const { name, workspace } = match;
+        const config = (0, config_js_1.readConfig)();
+        const account = config.accounts[workspace.account];
+        if (!account) {
+            console.log((0, utils_js_1.red)(`Account "${workspace.account}" referenced by workspace "${name}" not found.`));
+            process.exit(1);
+        }
+        // Collect any extra args passed after the url
+        const extraArgs = cmd.args.slice(1).join(" ");
+        const sshCommand = `ssh -i ${account.private_key} -o IdentitiesOnly=yes`;
+        console.log(`Cloning with account "${workspace.account}" (${account.email})...`);
+        try {
+            const fullCmd = `GIT_SSH_COMMAND='${sshCommand}' git clone ${url}${extraArgs ? " " + extraArgs : ""}`;
+            (0, node_child_process_1.execSync)(fullCmd, { stdio: "inherit", cwd });
+            console.log((0, utils_js_1.green)("\nClone complete. Push/pull will use this identity automatically."));
+        }
+        catch {
+            console.log((0, utils_js_1.red)("\nClone failed."));
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/list.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerListCommand(program: Command): void;

package/dist/commands/list.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerListCommand = registerListCommand;
+const config_js_1 = require("../config.js");
+const utils_js_1 = require("../utils.js");
+function registerListCommand(program) {
+    program
+        .command("list")
+        .description("List all registered accounts")
+        .action(() => {
+        const config = (0, config_js_1.readConfig)();
+        const accounts = Object.entries(config.accounts);
+        if (accounts.length === 0) {
+            console.log((0, utils_js_1.yellow)("No accounts registered. Use `zit add` to register one."));
+            return;
+        }
+        console.log((0, utils_js_1.green)("Registered accounts:\n"));
+        const maxNameLen = Math.max(...accounts.map(([key]) => key.length));
+        for (const [key, acc] of accounts) {
+            console.log(`  ${key.padEnd(maxNameLen + 2)} ${acc.email}`);
+        }
+    });
+}

package/dist/commands/remove.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerRemoveCommand(program: Command): void;

package/dist/commands/remove.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerRemoveCommand = registerRemoveCommand;
+const config_js_1 = require("../config.js");
+const ssh_js_1 = require("../ssh.js");
+const gitconfig_js_1 = require("../gitconfig.js");
+const config_js_2 = require("../config.js");
+const utils_js_1 = require("../utils.js");
+function registerRemoveCommand(program) {
+    program
+        .command("remove <account>")
+        .description("Remove a registered git account and its SSH keys")
+        .option("--force", "Remove even if workspaces reference this account")
+        .action((accountName, opts) => {
+        const config = (0, config_js_1.readConfig)();
+        const account = config.accounts[accountName];
+        if (!account) {
+            console.log((0, utils_js_1.red)(`Account "${accountName}" not found.`));
+            process.exit(1);
+        }
+        // Check if any workspaces reference this account
+        const linkedWorkspaces = Object.entries(config.workspaces).filter(([, ws]) => ws.account === accountName);
+        if (linkedWorkspaces.length > 0 && !opts.force) {
+            console.log((0, utils_js_1.red)(`Account "${accountName}" is used by these workspaces:`));
+            for (const [name, ws] of linkedWorkspaces) {
+                console.log(`  - ${name} (${ws.path})`);
+            }
+            console.log((0, utils_js_1.yellow)("\nRemove the workspaces first, or use --force to remove everything."));
+            process.exit(1);
+        }
+        // If --force, also remove linked workspaces
+        if (linkedWorkspaces.length > 0 && opts.force) {
+            for (const [name, ws] of linkedWorkspaces) {
+                (0, gitconfig_js_1.removeIncludeIf)(ws.path);
+                (0, gitconfig_js_1.removeWorkspaceGitconfig)((0, config_js_2.getWorkspaceGitconfigPath)(name));
+                delete config.workspaces[name];
+                console.log((0, utils_js_1.yellow)(`Removed workspace "${name}".`));
+            }
+        }
+        // Remove SSH keys
+        (0, ssh_js_1.removeSshKey)(account.private_key);
+        // Remove from config
+        delete config.accounts[accountName];
+        (0, config_js_1.writeConfig)(config);
+        console.log((0, utils_js_1.green)(`Account "${accountName}" removed.`));
+    });
+}

package/dist/commands/status.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerStatusCommand(program: Command): void;

package/dist/commands/status.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerStatusCommand = registerStatusCommand;
+const config_js_1 = require("../config.js");
+const utils_js_1 = require("../utils.js");
+function registerStatusCommand(program) {
+    program
+        .command("status")
+        .description("Show the current directory's workspace and account info")
+        .action(() => {
+        const cwd = process.cwd();
+        const match = (0, config_js_1.findWorkspaceByPath)(cwd);
+        if (!match) {
+            console.log((0, utils_js_1.yellow)("Not inside a zit workspace."));
+            return;
+        }
+        const { name, workspace } = match;
+        const config = (0, config_js_1.readConfig)();
+        const account = config.accounts[workspace.account];
+        console.log((0, utils_js_1.green)("Workspace: ") + name);
+        console.log((0, utils_js_1.green)("Path:      ") + (0, utils_js_1.collapseHome)(workspace.path));
+        console.log((0, utils_js_1.green)("Account:   ") + workspace.account);
+        if (account) {
+            console.log((0, utils_js_1.green)("Name:      ") + account.name);
+            console.log((0, utils_js_1.green)("Email:     ") + account.email);
+            console.log((0, utils_js_1.green)("SSH Key:   ") + (0, utils_js_1.collapseHome)(account.private_key));
+        }
+        else {
+            console.log((0, utils_js_1.yellow)(`Warning: Account "${workspace.account}" not found in config.`));
+        }
+    });
+}

package/dist/commands/workspace.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerWorkspaceCommand(program: Command): void;

package/dist/commands/workspace.js

@@ -0,0 +1,133 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerWorkspaceCommand = registerWorkspaceCommand;
+const fs = __importStar(require("node:fs"));
+const config_js_1 = require("../config.js");
+const gitconfig_js_1 = require("../gitconfig.js");
+const utils_js_1 = require("../utils.js");
+function registerWorkspaceCommand(program) {
+    const ws = program
+        .command("workspace")
+        .description("Manage workspace folders linked to accounts");
+    ws.command("init <path> <account>")
+        .description("Create a workspace folder linked to an account")
+        .action((wsPath, accountName) => {
+        const config = (0, config_js_1.readConfig)();
+        const account = config.accounts[accountName];
+        if (!account) {
+            console.log((0, utils_js_1.red)(`Account "${accountName}" not found.`));
+            console.log("Use `zit list` to see registered accounts.");
+            process.exit(1);
+        }
+        const resolvedPath = (0, utils_js_1.resolvePath)(wsPath);
+        // Check if a workspace already exists for this path
+        for (const [name, existing] of Object.entries(config.workspaces)) {
+            if ((0, utils_js_1.resolvePath)(existing.path) === resolvedPath) {
+                console.log((0, utils_js_1.yellow)(`Workspace "${name}" already exists for this path. Updating account to "${accountName}".`));
+                // Update existing workspace
+                existing.account = accountName;
+                const gitconfigPath = (0, config_js_1.getWorkspaceGitconfigPath)(name);
+                (0, gitconfig_js_1.writeWorkspaceGitconfig)(gitconfigPath, account.name, account.email, account.private_key);
+                (0, config_js_1.writeConfig)(config);
+                console.log((0, utils_js_1.green)(`Workspace "${name}" updated.`));
+                return;
+            }
+        }
+        // Create the folder
+        fs.mkdirSync(resolvedPath, { recursive: true });
+        // Derive workspace name from the folder name
+        const wsName = resolvedPath.split("/").filter(Boolean).pop();
+        // Check name collision
+        let finalName = wsName;
+        if (config.workspaces[finalName]) {
+            let i = 2;
+            while (config.workspaces[`${wsName}-${i}`])
+                i++;
+            finalName = `${wsName}-${i}`;
+        }
+        // Generate workspace gitconfig
+        const gitconfigPath = (0, config_js_1.getWorkspaceGitconfigPath)(finalName);
+        (0, gitconfig_js_1.writeWorkspaceGitconfig)(gitconfigPath, account.name, account.email, account.private_key);
+        // Add includeIf to ~/.gitconfig
+        (0, gitconfig_js_1.addIncludeIf)(resolvedPath, gitconfigPath);
+        // Save workspace to config
+        config.workspaces[finalName] = {
+            path: resolvedPath,
+            account: accountName,
+        };
+        (0, config_js_1.writeConfig)(config);
+        console.log((0, utils_js_1.green)(`Workspace "${finalName}" created.`));
+        console.log(`  Path:    ${(0, utils_js_1.collapseHome)(resolvedPath)}`);
+        console.log(`  Account: ${accountName} (${account.email})`);
+        console.log(`\nRepos cloned inside ${(0, utils_js_1.collapseHome)(resolvedPath)} will use this identity automatically.`);
+    });
+    ws.command("list")
+        .description("List all workspaces and their linked accounts")
+        .action(() => {
+        const config = (0, config_js_1.readConfig)();
+        const workspaces = Object.entries(config.workspaces);
+        if (workspaces.length === 0) {
+            console.log((0, utils_js_1.yellow)("No workspaces configured. Use `zit workspace init <path> <account>` to create one."));
+            return;
+        }
+        console.log((0, utils_js_1.green)("Workspaces:\n"));
+        const maxNameLen = Math.max(...workspaces.map(([name]) => name.length));
+        const maxPathLen = Math.max(...workspaces.map(([, ws]) => (0, utils_js_1.collapseHome)(ws.path).length));
+        for (const [name, ws] of workspaces) {
+            console.log(`  ${name.padEnd(maxNameLen + 2)} ${(0, utils_js_1.collapseHome)(ws.path).padEnd(maxPathLen + 2)} ${ws.account}`);
+        }
+    });
+    ws.command("remove <name>")
+        .description("Unlink a workspace (keeps the folder and repos)")
+        .action((name) => {
+        const config = (0, config_js_1.readConfig)();
+        const workspace = config.workspaces[name];
+        if (!workspace) {
+            console.log((0, utils_js_1.red)(`Workspace "${name}" not found.`));
+            console.log("Use `zit workspace list` to see available workspaces.");
+            process.exit(1);
+        }
+        // Remove includeIf from ~/.gitconfig
+        (0, gitconfig_js_1.removeIncludeIf)(workspace.path);
+        // Remove workspace gitconfig file
+        (0, gitconfig_js_1.removeWorkspaceGitconfig)((0, config_js_1.getWorkspaceGitconfigPath)(name));
+        // Remove from config
+        delete config.workspaces[name];
+        (0, config_js_1.writeConfig)(config);
+        console.log((0, utils_js_1.green)(`Workspace "${name}" removed.`));
+        console.log((0, utils_js_1.yellow)("The folder and its repos still exist, but they no longer use the linked identity."));
+    });
+}

package/dist/config.d.ts

@@ -0,0 +1,25 @@
+export interface Account {
+    name: string;
+    email: string;
+    private_key: string;
+    public_key: string;
+}
+export interface Workspace {
+    path: string;
+    account: string;
+}
+export interface ZitConfig {
+    accounts: Record<string, Account>;
+    workspaces: Record<string, Workspace>;
+}
+export declare function getConfigPath(): string;
+export declare function getWorkspacesDir(): string;
+export declare function getWorkspaceGitconfigPath(name: string): string;
+export declare function readConfig(): ZitConfig;
+export declare function writeConfig(config: ZitConfig): void;
+export declare function getAccount(name: string): Account | undefined;
+export declare function getWorkspace(name: string): Workspace | undefined;
+export declare function findWorkspaceByPath(dir: string): {
+    name: string;
+    workspace: Workspace;
+} | null;

package/dist/config.js

@@ -0,0 +1,132 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfigPath = getConfigPath;
+exports.getWorkspacesDir = getWorkspacesDir;
+exports.getWorkspaceGitconfigPath = getWorkspaceGitconfigPath;
+exports.readConfig = readConfig;
+exports.writeConfig = writeConfig;
+exports.getAccount = getAccount;
+exports.getWorkspace = getWorkspace;
+exports.findWorkspaceByPath = findWorkspaceByPath;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const ini = __importStar(require("ini"));
+function getConfigDir() {
+    const xdg = process.env.XDG_CONFIG_HOME;
+    const base = xdg || path.join(os.homedir(), ".config");
+    return path.join(base, "zit");
+}
+function getConfigPath() {
+    return path.join(getConfigDir(), "config");
+}
+function getWorkspacesDir() {
+    return path.join(getConfigDir(), "workspaces");
+}
+function getWorkspaceGitconfigPath(name) {
+    return path.join(getWorkspacesDir(), `${name}.gitconfig`);
+}
+function ensureConfigDir() {
+    const dir = getConfigDir();
+    fs.mkdirSync(dir, { recursive: true });
+    fs.mkdirSync(getWorkspacesDir(), { recursive: true });
+}
+function readConfig() {
+    const configPath = getConfigPath();
+    const config = { accounts: {}, workspaces: {} };
+    if (!fs.existsSync(configPath)) {
+        return config;
+    }
+    const raw = fs.readFileSync(configPath, "utf-8");
+    const parsed = ini.parse(raw);
+    for (const [key, value] of Object.entries(parsed)) {
+        if (typeof value === "object" &&
+            value !== null &&
+            "name" in value &&
+            "email" in value) {
+            if ("private_key" in value && "public_key" in value) {
+                config.accounts[key] = value;
+            }
+            else if ("path" in value && "account" in value) {
+                config.workspaces[key] = value;
+            }
+        }
+    }
+    return config;
+}
+function writeConfig(config) {
+    ensureConfigDir();
+    const configPath = getConfigPath();
+    const obj = {};
+    for (const [key, acc] of Object.entries(config.accounts)) {
+        obj[key] = {
+            name: acc.name,
+            email: acc.email,
+            private_key: acc.private_key,
+            public_key: acc.public_key,
+        };
+    }
+    for (const [key, ws] of Object.entries(config.workspaces)) {
+        obj[`workspace "${key}"`] = {
+            path: ws.path,
+            account: ws.account,
+        };
+    }
+    fs.writeFileSync(configPath, ini.stringify(obj), "utf-8");
+}
+function getAccount(name) {
+    const config = readConfig();
+    return config.accounts[name];
+}
+function getWorkspace(name) {
+    const config = readConfig();
+    return config.workspaces[name];
+}
+function findWorkspaceByPath(dir) {
+    const config = readConfig();
+    const resolved = path.resolve(dir);
+    let bestMatch = null;
+    let bestLen = 0;
+    for (const [name, ws] of Object.entries(config.workspaces)) {
+        const wsPath = path.resolve(ws.path);
+        if ((resolved === wsPath || resolved.startsWith(wsPath + "/")) &&
+            wsPath.length > bestLen) {
+            bestMatch = { name, workspace: ws };
+            bestLen = wsPath.length;
+        }
+    }
+    return bestMatch;
+}

package/dist/gitconfig.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Add an includeIf entry to ~/.gitconfig for a workspace.
+ * Format:
+ *   [includeIf "gitdir:<path>/"]
+ *       path = <gitconfig_path>
+ */
+export declare function addIncludeIf(workspacePath: string, gitconfigPath: string): void;
+/**
+ * Remove an includeIf entry from ~/.gitconfig for a workspace.
+ */
+export declare function removeIncludeIf(workspacePath: string): void;
+/**
+ * Write a per-workspace .gitconfig file with user identity and SSH command.
+ */
+export declare function writeWorkspaceGitconfig(gitconfigPath: string, userName: string, userEmail: string, privateKeyPath: string): void;
+/**
+ * Remove a per-workspace .gitconfig file.
+ */
+export declare function removeWorkspaceGitconfig(gitconfigPath: string): void;

package/dist/gitconfig.js

@@ -0,0 +1,130 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addIncludeIf = addIncludeIf;
+exports.removeIncludeIf = removeIncludeIf;
+exports.writeWorkspaceGitconfig = writeWorkspaceGitconfig;
+exports.removeWorkspaceGitconfig = removeWorkspaceGitconfig;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const utils_js_1 = require("./utils.js");
+function getGlobalGitconfigPath() {
+    return path.join(os.homedir(), ".gitconfig");
+}
+/**
+ * Add an includeIf entry to ~/.gitconfig for a workspace.
+ * Format:
+ *   [includeIf "gitdir:<path>/"]
+ *       path = <gitconfig_path>
+ */
+function addIncludeIf(workspacePath, gitconfigPath) {
+    const globalPath = getGlobalGitconfigPath();
+    const dirPattern = (0, utils_js_1.ensureTrailingSlash)(workspacePath);
+    let content = "";
+    if (fs.existsSync(globalPath)) {
+        content = fs.readFileSync(globalPath, "utf-8");
+    }
+    // Check if this includeIf already exists
+    const marker = `[includeIf "gitdir:${dirPattern}"]`;
+    if (content.includes(marker)) {
+        // Update the path in case it changed
+        const lines = content.split("\n");
+        const idx = lines.findIndex((l) => l.trim() === marker);
+        if (idx !== -1 && idx + 1 < lines.length) {
+            lines[idx + 1] = `\tpath = ${gitconfigPath}`;
+        }
+        fs.writeFileSync(globalPath, lines.join("\n"), "utf-8");
+        return;
+    }
+    // Append new entry
+    const entry = `\n${marker}\n\tpath = ${gitconfigPath}\n`;
+    fs.writeFileSync(globalPath, content + entry, "utf-8");
+}
+/**
+ * Remove an includeIf entry from ~/.gitconfig for a workspace.
+ */
+function removeIncludeIf(workspacePath) {
+    const globalPath = getGlobalGitconfigPath();
+    if (!fs.existsSync(globalPath))
+        return;
+    const dirPattern = (0, utils_js_1.ensureTrailingSlash)(workspacePath);
+    const marker = `[includeIf "gitdir:${dirPattern}"]`;
+    const content = fs.readFileSync(globalPath, "utf-8");
+    if (!content.includes(marker))
+        return;
+    const lines = content.split("\n");
+    const result = [];
+    let i = 0;
+    while (i < lines.length) {
+        if (lines[i].trim() === marker) {
+            // Skip this line and any indented lines that follow (the section body)
+            i++;
+            while (i < lines.length && /^\s+/.test(lines[i]) && lines[i].trim()) {
+                i++;
+            }
+            // Skip trailing blank line
+            if (i < lines.length && lines[i].trim() === "") {
+                i++;
+            }
+            continue;
+        }
+        result.push(lines[i]);
+        i++;
+    }
+    fs.writeFileSync(globalPath, result.join("\n"), "utf-8");
+}
+/**
+ * Write a per-workspace .gitconfig file with user identity and SSH command.
+ */
+function writeWorkspaceGitconfig(gitconfigPath, userName, userEmail, privateKeyPath) {
+    const dir = path.dirname(gitconfigPath);
+    fs.mkdirSync(dir, { recursive: true });
+    const content = `[user]
+\tname = ${userName}
+\temail = ${userEmail}
+[core]
+\tsshCommand = ssh -i ${privateKeyPath} -o IdentitiesOnly=yes
+`;
+    fs.writeFileSync(gitconfigPath, content, "utf-8");
+}
+/**
+ * Remove a per-workspace .gitconfig file.
+ */
+function removeWorkspaceGitconfig(gitconfigPath) {
+    if (fs.existsSync(gitconfigPath)) {
+        fs.unlinkSync(gitconfigPath);
+    }
+}

package/dist/ssh.d.ts

@@ -0,0 +1,8 @@
+export type SshKeyType = "ed25519" | "rsa" | "ecdsa" | "ecdsa-sk" | "ed25519-sk" | "dsa";
+export declare function isValidKeyType(t: string): t is SshKeyType;
+export declare function getSshKeyPath(accountName: string, keyType: SshKeyType): {
+    privateKey: string;
+    publicKey: string;
+};
+export declare function generateSshKey(email: string, privateKeyPath: string, keyType: SshKeyType): string;
+export declare function removeSshKey(privateKeyPath: string): void;

package/dist/ssh.js

@@ -0,0 +1,78 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidKeyType = isValidKeyType;
+exports.getSshKeyPath = getSshKeyPath;
+exports.generateSshKey = generateSshKey;
+exports.removeSshKey = removeSshKey;
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const fs = __importStar(require("node:fs"));
+const node_child_process_1 = require("node:child_process");
+const VALID_KEY_TYPES = [
+    "ed25519",
+    "rsa",
+    "ecdsa",
+    "ecdsa-sk",
+    "ed25519-sk",
+    "dsa",
+];
+function isValidKeyType(t) {
+    return VALID_KEY_TYPES.includes(t);
+}
+function getSshKeyPath(accountName, keyType) {
+    const sshDir = path.join(os.homedir(), ".ssh");
+    const base = path.join(sshDir, `id_${keyType}_${accountName}`);
+    return {
+        privateKey: base,
+        publicKey: base + ".pub",
+    };
+}
+function generateSshKey(email, privateKeyPath, keyType) {
+    const sshDir = path.dirname(privateKeyPath);
+    fs.mkdirSync(sshDir, { recursive: true });
+    (0, node_child_process_1.execSync)(`ssh-keygen -t ${keyType} -C "${email}" -f "${privateKeyPath}" -N ""`, { stdio: "inherit" });
+    const publicKey = fs.readFileSync(privateKeyPath + ".pub", "utf-8").trim();
+    return publicKey;
+}
+function removeSshKey(privateKeyPath) {
+    if (fs.existsSync(privateKeyPath)) {
+        fs.unlinkSync(privateKeyPath);
+    }
+    const pubPath = privateKeyPath + ".pub";
+    if (fs.existsSync(pubPath)) {
+        fs.unlinkSync(pubPath);
+    }
+}

package/dist/utils.d.ts

@@ -0,0 +1,12 @@
+export declare function expandHome(p: string): string;
+export declare function resolvePath(p: string): string;
+/** Collapse home directory to ~ for display */
+export declare function collapseHome(p: string): string;
+export declare function ensureTrailingSlash(p: string): string;
+export declare function red(s: string): string;
+export declare function green(s: string): string;
+export declare function yellow(s: string): string;
+export declare function blue(s: string): string;
+export declare function bold(s: string): string;
+export declare function prompt(question: string): Promise<string>;
+export declare function promptYesNo(question: string): Promise<boolean>;

package/dist/utils.js

@@ -0,0 +1,115 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandHome = expandHome;
+exports.resolvePath = resolvePath;
+exports.collapseHome = collapseHome;
+exports.ensureTrailingSlash = ensureTrailingSlash;
+exports.red = red;
+exports.green = green;
+exports.yellow = yellow;
+exports.blue = blue;
+exports.bold = bold;
+exports.prompt = prompt;
+exports.promptYesNo = promptYesNo;
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const readline = __importStar(require("node:readline"));
+function expandHome(p) {
+    if (p.startsWith("~/") || p === "~") {
+        return path.join(os.homedir(), p.slice(1));
+    }
+    return p;
+}
+function resolvePath(p) {
+    return path.resolve(expandHome(p));
+}
+/** Collapse home directory to ~ for display */
+function collapseHome(p) {
+    const home = os.homedir();
+    if (p.startsWith(home + "/") || p === home) {
+        return "~" + p.slice(home.length);
+    }
+    return p;
+}
+function ensureTrailingSlash(p) {
+    return p.endsWith("/") ? p : p + "/";
+}
+const colors = {
+    red: "\x1b[31m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    blue: "\x1b[34m",
+    bold: "\x1b[1m",
+    reset: "\x1b[0m",
+};
+function red(s) {
+    return `${colors.red}${s}${colors.reset}`;
+}
+function green(s) {
+    return `${colors.green}${s}${colors.reset}`;
+}
+function yellow(s) {
+    return `${colors.yellow}${s}${colors.reset}`;
+}
+function blue(s) {
+    return `${colors.blue}${s}${colors.reset}`;
+}
+function bold(s) {
+    return `${colors.bold}${s}${colors.reset}`;
+}
+function prompt(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+function promptYesNo(question) {
+    return prompt(`${yellow(question)} [y/n] `).then((answer) => {
+        const lower = answer.toLowerCase();
+        if (lower === "y" || lower === "yes")
+            return true;
+        if (lower === "n" || lower === "no")
+            return false;
+        console.log(red("Please answer y or n."));
+        return promptYesNo(question);
+    });
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@hypercodingdev/zit",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "1.0.0",
+  "description": "Folder-based Git identity manager. Associate workspace folders with Git accounts — SSH keys, author name, and email are applied automatically.",
+  "main": "dist/cli.js",
+  "bin": {
+    "zit": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/cli.js",
+    "prepare": "tsc"
+  },
+  "keywords": [
+    "git",
+    "ssh",
+    "identity",
+    "account",
+    "workspace",
+    "multi-account"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "commander": "^12.0.0",
+    "ini": "^4.1.0"
+  },
+  "devDependencies": {
+    "@types/ini": "^4.1.0",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.4.0"
+  }
+}