@lakakala/kgit 0.1.3 → 0.2.1

package/README.md

@@ -1 +1,133 @@
-# kgit
+# kgit
+
+A CLI tool for managing multi-repo workspaces using [git worktree](https://git-scm.com/docs/git-worktree).
+
+## Install
+
+```bash
+npm install -g @lakakala/kgit
+```
+
+## Configuration
+
+Create `~/.config/kgit/config.json`:
+
+```json
+{
+  "workspace": "$HOME/projects",
+  "projects": [
+    {
+      "name": "form",
+      "path": "$HOME/repos/my-form-repo"
+    },
+    {
+      "name": "auth",
+      "path": "$HOME/repos/my-auth-repo"
+    }
+  ]
+}
+```
+
+| Field | Description |
+|-------|-------------|
+| `workspace` | Root directory where workspaces are created |
+| `projects[].name` | Project alias used in `-p` options |
+| `projects[].path` | Absolute path to the git repository |
+
+Environment variables (`$HOME`, `$VAR`, `${VAR}`) are expanded in both `workspace` and `path`.
+
+## Commands
+
+### `kgit new`
+
+Create a new workspace with git worktrees.
+
+```bash
+kgit new <workspace> [-b <branch>] -p <project[:base]> [-p <project[:base]> ...]
+```
+
+The new branch name defaults to `<workspace>` unless overridden with `-b`.  
+`<base>` is the base branch used when creating a new branch (default: `master`).
+
+For each `-p`, kgit resolves the branch using this order:
+
+1. Branch already exists **locally** → check it out directly
+2. Branch exists **on remote** → create a local tracking branch
+3. Branch does not exist → create a new branch from `<base>`
+
+**Examples:**
+
+```bash
+# New branch "feat-login" from master in each project
+kgit new feat-login -p form -p auth
+
+# Specify a different base branch
+kgit new feat-login -p form:develop -p auth:develop
+
+# Explicit branch name (reuses existing or creates from base)
+kgit new feat-login -b my-feature -p form:develop
+
+# Mix projects with different base branches
+kgit new feat-login -p form:master -p auth:develop
+```
+
+Result layout:
+
+```
+$workspace/
+└── feat-login/
+    ├── form/     ← worktree on branch "feat-login"
+    └── auth/     ← worktree on branch "feat-login"
+```
+
+---
+
+### `kgit append`
+
+Add more projects to an existing workspace. Accepts the same options as `new`.
+
+```bash
+kgit append <workspace> [-b <branch>] -p <project[:base]> [-p <project[:base]> ...]
+```
+
+**Example:**
+
+```bash
+kgit append feat-login -p gateway:master
+```
+
+---
+
+### `kgit remove`
+
+Remove an entire workspace or specific projects from it.
+
+```bash
+kgit remove <workspace>                          # remove entire workspace
+kgit remove <workspace> -p <project> [-p ...]   # remove specific projects
+```
+
+**Examples:**
+
+```bash
+kgit remove feat-login           # removes all worktrees and the directory
+kgit remove feat-login -p form   # removes only the "form" worktree
+```
+
+---
+
+### `kgit list`
+
+List all workspaces and their projects with the current branch.
+
+```bash
+kgit list
+```
+
+**Output:**
+
+```
+feat-login
+  └─ form  (feat-login)
+  └─ auth  (feat-login)
+```

package/dist/commands/remove.js

@@ -1,7 +1,30 @@
 import path from 'node:path';
 import fs from 'node:fs';
+import readline from 'node:readline';
 import { loadConfig, findProject } from '../config.js';
-import { removeWorktree } from '../git.js';
+import { removeWorktree, isBranchSyncedToRemote } from '../git.js';
+function confirm(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise(resolve => {
+        rl.question(`${question} (y/N) `, answer => {
+            rl.close();
+            resolve(answer.trim().toLowerCase() === 'y');
+        });
+    });
+}
+async function checkAndRemove(repoPath, worktreePath, projectName) {
+    const synced = await isBranchSyncedToRemote(worktreePath);
+    if (!synced) {
+        console.warn(`  Warning: "${projectName}" has unpushed commits or no remote tracking branch.`);
+        const ok = await confirm(`  Remove worktree "${projectName}" anyway?`);
+        if (!ok) {
+            console.log(`  Skipped "${projectName}".`);
+            return;
+        }
+    }
+    console.log(`Removing worktree "${projectName}" from ${repoPath}`);
+    await removeWorktree(repoPath, worktreePath);
+}
 export async function removeCommand(workspaceName, projectEntries) {
     const config = loadConfig();
     const targetDir = path.join(config.workspace, workspaceName);
@@ -9,18 +32,21 @@ export async function removeCommand(workspaceName, projectEntries) {
         throw new Error(`Workspace directory does not exist: ${targetDir}`);
     }
     if (projectEntries.length === 0) {
-        // Remove entire workspace: prune all worktrees then delete folder
         const entries = fs.readdirSync(targetDir);
         for (const entry of entries) {
             const worktreePath = path.join(targetDir, entry);
             const project = config.projects.find(p => p.name === entry);
             if (project && fs.statSync(worktreePath).isDirectory()) {
-                console.log(`Removing worktree "${entry}" from ${project.path}`);
-                await removeWorktree(project.path, worktreePath);
+                await checkAndRemove(project.path, worktreePath, entry);
             }
         }
-        fs.rmSync(targetDir, { recursive: true, force: true });
-        console.log(`Workspace "${workspaceName}" removed.`);
+        if (fs.readdirSync(targetDir).length === 0) {
+            fs.rmSync(targetDir, { recursive: true, force: true });
+            console.log(`Workspace "${workspaceName}" removed.`);
+        }
+        else {
+            console.log(`Workspace "${workspaceName}" partially removed (some projects were skipped).`);
+        }
     }
     else {
         for (const entry of projectEntries) {
@@ -30,10 +56,8 @@ export async function removeCommand(workspaceName, projectEntries) {
                 console.warn(`Worktree not found, skipping: ${worktreePath}`);
                 continue;
             }
-            console.log(`Removing worktree "${project.name}" from ${project.path}`);
-            await removeWorktree(project.path, worktreePath);
+            await checkAndRemove(project.path, worktreePath, project.name);
         }
-        // Remove workspace dir if now empty
         if (fs.readdirSync(targetDir).length === 0) {
             fs.rmdirSync(targetDir);
             console.log(`Workspace directory is now empty and has been removed.`);

package/dist/git.d.ts

@@ -1,3 +1,4 @@
 export declare function addWorktree(repoPath: string, worktreePath: string, newBranch: string, baseBranch: string): Promise<void>;
+export declare function isBranchSyncedToRemote(worktreePath: string): Promise<boolean>;
 export declare function removeWorktree(repoPath: string, worktreePath: string): Promise<void>;
 export declare function isGitRepo(dirPath: string): Promise<boolean>;

package/dist/git.js

@@ -1,11 +1,50 @@
 import { execa } from 'execa';
 import fs from 'node:fs';
 import path from 'node:path';
+async function localBranchExists(repoPath, branch) {
+    const { stdout } = await execa('git', ['-C', repoPath, 'branch', '--list', branch], { stdio: 'pipe' });
+    return stdout.trim().length > 0;
+}
+async function remoteBranchExists(repoPath, branch) {
+    try {
+        const { stdout } = await execa('git', ['-C', repoPath, 'branch', '-r', '--list', `*/${branch}`], { stdio: 'pipe' });
+        const match = stdout.trim().split('\n').find(l => l.trim().length > 0);
+        return match ? match.trim() : null;
+    }
+    catch {
+        return null;
+    }
+}
 export async function addWorktree(repoPath, worktreePath, newBranch, baseBranch) {
     await fs.promises.mkdir(path.dirname(worktreePath), { recursive: true });
-    await execa('git', ['-C', repoPath, 'worktree', 'add', '-b', newBranch, worktreePath, baseBranch], {
-        stdio: 'inherit',
-    });
+    if (await localBranchExists(repoPath, newBranch)) {
+        // Branch exists locally — use it directly
+        console.log(`  Branch "${newBranch}" exists locally, using it directly.`);
+        await execa('git', ['-C', repoPath, 'worktree', 'add', worktreePath, newBranch], { stdio: 'inherit' });
+        return;
+    }
+    const remoteBranch = await remoteBranchExists(repoPath, newBranch);
+    if (remoteBranch) {
+        // Branch exists on remote — create a tracking local branch
+        console.log(`  Branch "${newBranch}" found on remote (${remoteBranch}), creating tracking branch.`);
+        await execa('git', ['-C', repoPath, 'worktree', 'add', '--track', '-b', newBranch, worktreePath, remoteBranch], { stdio: 'inherit' });
+        return;
+    }
+    // Branch does not exist — create from base branch
+    await execa('git', ['-C', repoPath, 'worktree', 'add', '-b', newBranch, worktreePath, baseBranch], { stdio: 'inherit' });
+}
+export async function isBranchSyncedToRemote(worktreePath) {
+    try {
+        // Check if there is an upstream tracking branch
+        await execa('git', ['-C', worktreePath, 'rev-parse', '--abbrev-ref', '@{u}'], { stdio: 'pipe' });
+    }
+    catch {
+        // No upstream configured — treat as unsynced
+        return false;
+    }
+    // Check for commits not yet pushed to upstream
+    const { stdout } = await execa('git', ['-C', worktreePath, 'rev-list', '--count', '@{u}..HEAD'], { stdio: 'pipe' });
+    return parseInt(stdout.trim(), 10) === 0;
 }
 export async function removeWorktree(repoPath, worktreePath) {
     await execa('git', ['-C', repoPath, 'worktree', 'remove', worktreePath, '--force'], {

package/dist/index.js

@@ -1,9 +1,12 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
+import { createRequire } from 'node:module';
 import { newCommand } from './commands/new.js';
 import { appendCommand } from './commands/append.js';
 import { removeCommand } from './commands/remove.js';
 import { listCommand } from './commands/list.js';
+const require = createRequire(import.meta.url);
+const { version } = require('../package.json');
 function collectProject(value, previous) {
     const colonIdx = value.indexOf(':');
     const name = colonIdx === -1 ? value : value.slice(0, colonIdx);
@@ -14,7 +17,7 @@ const program = new Command();
 program
     .name('kgit')
     .description('Git worktree workspace manager')
-    .version('0.1.0');
+    .version(version);
 program
     .command('new <workspace>')
     .description('Create a new workspace with git worktrees')
@@ -52,6 +55,12 @@ program
     .action(async () => {
     await listCommand();
 });
+program
+    .command('version')
+    .description('Print the current version')
+    .action(() => {
+    console.log(`kgit v${version}`);
+});
 program.parseAsync(process.argv, { from: 'node' }).catch((err) => {
     console.error(`Error: ${err.message}`);
     process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lakakala/kgit",
-  "version": "0.1.3",
+  "version": "0.2.1",
   "description": "Git worktree workspace manager",
   "type": "module",
   "bin": {