@lakakala/kgit 0.1.1 → 0.2.0

package/dist/commands/append.d.ts

@@ -2,5 +2,5 @@ interface ProjectEntry {
     name: string;
     branch: string;
 }
-export declare function appendCommand(workspaceName: string, projectEntries: ProjectEntry[]): Promise<void>;
+export declare function appendCommand(workspaceName: string, projectEntries: ProjectEntry[], newBranch?: string): Promise<void>;
 export {};

package/dist/commands/append.js

@@ -2,9 +2,10 @@ import path from 'node:path';
 import fs from 'node:fs';
 import { loadConfig, findProject } from '../config.js';
 import { addWorktree, isGitRepo } from '../git.js';
-export async function appendCommand(workspaceName, projectEntries) {
+export async function appendCommand(workspaceName, projectEntries, newBranch) {
     const config = loadConfig();
     const targetDir = path.join(config.workspace, workspaceName);
+    const branchName = newBranch ?? workspaceName;
     if (!fs.existsSync(targetDir)) {
         throw new Error(`Workspace directory does not exist: ${targetDir}. Use "kgit new" to create it first.`);
     }
@@ -18,8 +19,8 @@ export async function appendCommand(workspaceName, projectEntries) {
             console.warn(`Worktree already exists, skipping: ${worktreePath}`);
             continue;
         }
-        console.log(`Adding worktree for "${project.name}" (branch: ${entry.branch}) -> ${worktreePath}`);
-        await addWorktree(project.path, worktreePath, entry.branch);
+        console.log(`Adding worktree for "${project.name}" (new branch: ${branchName}, base: ${entry.branch}) -> ${worktreePath}`);
+        await addWorktree(project.path, worktreePath, branchName, entry.branch);
     }
     console.log(`\nProjects appended to workspace "${workspaceName}" at ${targetDir}`);
 }

package/dist/commands/list.d.ts

@@ -0,0 +1 @@
+export declare function listCommand(): Promise<void>;

package/dist/commands/list.js

@@ -0,0 +1,36 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { loadConfig } from '../config.js';
+import { execa } from 'execa';
+async function getCurrentBranch(worktreePath) {
+    try {
+        const { stdout } = await execa('git', ['-C', worktreePath, 'branch', '--show-current'], { stdio: 'pipe' });
+        return stdout.trim() || 'detached HEAD';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+export async function listCommand() {
+    const config = loadConfig();
+    if (!fs.existsSync(config.workspace)) {
+        console.log('No workspaces found (workspace directory does not exist).');
+        return;
+    }
+    const entries = fs.readdirSync(config.workspace, { withFileTypes: true });
+    const workspaces = entries.filter(e => e.isDirectory());
+    if (workspaces.length === 0) {
+        console.log('No workspaces found.');
+        return;
+    }
+    for (const ws of workspaces) {
+        console.log(`${ws.name}`);
+        const wsPath = path.join(config.workspace, ws.name);
+        const projects = fs.readdirSync(wsPath, { withFileTypes: true }).filter(e => e.isDirectory());
+        for (const proj of projects) {
+            const projPath = path.join(wsPath, proj.name);
+            const branch = await getCurrentBranch(projPath);
+            console.log(`  └─ ${proj.name}  (${branch})`);
+        }
+    }
+}

package/dist/commands/new.d.ts

@@ -2,5 +2,5 @@ interface ProjectEntry {
     name: string;
     branch: string;
 }
-export declare function newCommand(workspaceName: string, projectEntries: ProjectEntry[]): Promise<void>;
+export declare function newCommand(workspaceName: string, projectEntries: ProjectEntry[], newBranch?: string): Promise<void>;
 export {};

package/dist/commands/new.js

@@ -2,9 +2,10 @@ import path from 'node:path';
 import fs from 'node:fs';
 import { loadConfig, findProject } from '../config.js';
 import { addWorktree, isGitRepo } from '../git.js';
-export async function newCommand(workspaceName, projectEntries) {
+export async function newCommand(workspaceName, projectEntries, newBranch) {
     const config = loadConfig();
     const targetDir = path.join(config.workspace, workspaceName);
+    const branchName = newBranch ?? workspaceName;
     if (fs.existsSync(targetDir)) {
         throw new Error(`Workspace directory already exists: ${targetDir}`);
     }
@@ -16,8 +17,8 @@ export async function newCommand(workspaceName, projectEntries) {
             throw new Error(`Not a git repository: ${project.path}`);
         }
         const worktreePath = path.join(targetDir, project.name);
-        console.log(`Adding worktree for "${project.name}" (branch: ${entry.branch}) -> ${worktreePath}`);
-        await addWorktree(project.path, worktreePath, entry.branch);
+        console.log(`Adding worktree for "${project.name}" (new branch: ${branchName}, base: ${entry.branch}) -> ${worktreePath}`);
+        await addWorktree(project.path, worktreePath, branchName, entry.branch);
     }
     console.log(`\nWorkspace "${workspaceName}" created successfully at ${targetDir}`);
 }

package/dist/commands/remove.d.ts

@@ -0,0 +1,5 @@
+interface ProjectEntry {
+    name: string;
+}
+export declare function removeCommand(workspaceName: string, projectEntries: ProjectEntry[]): Promise<void>;
+export {};

package/dist/commands/remove.js

@@ -0,0 +1,42 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { loadConfig, findProject } from '../config.js';
+import { removeWorktree } from '../git.js';
+export async function removeCommand(workspaceName, projectEntries) {
+    const config = loadConfig();
+    const targetDir = path.join(config.workspace, workspaceName);
+    if (!fs.existsSync(targetDir)) {
+        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);
+            }
+        }
+        fs.rmSync(targetDir, { recursive: true, force: true });
+        console.log(`Workspace "${workspaceName}" removed.`);
+    }
+    else {
+        for (const entry of projectEntries) {
+            const project = findProject(config, entry.name);
+            const worktreePath = path.join(targetDir, project.name);
+            if (!fs.existsSync(worktreePath)) {
+                console.warn(`Worktree not found, skipping: ${worktreePath}`);
+                continue;
+            }
+            console.log(`Removing worktree "${project.name}" from ${project.path}`);
+            await removeWorktree(project.path, worktreePath);
+        }
+        // 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,2 +1,3 @@
-export declare function addWorktree(repoPath: string, worktreePath: string, branch: string): Promise<void>;
+export declare function addWorktree(repoPath: string, worktreePath: string, newBranch: string, baseBranch: string): Promise<void>;
+export declare function removeWorktree(repoPath: string, worktreePath: string): Promise<void>;
 export declare function isGitRepo(dirPath: string): Promise<boolean>;

package/dist/git.js

@@ -1,9 +1,40 @@
 import { execa } from 'execa';
 import fs from 'node:fs';
 import path from 'node:path';
-export async function addWorktree(repoPath, worktreePath, branch) {
+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', worktreePath, branch], {
+    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 removeWorktree(repoPath, worktreePath) {
+    await execa('git', ['-C', repoPath, 'worktree', 'remove', worktreePath, '--force'], {
         stdio: 'inherit',
     });
 }

package/dist/index.js

@@ -2,40 +2,12 @@
 import { Command } from 'commander';
 import { newCommand } from './commands/new.js';
 import { appendCommand } from './commands/append.js';
-/**
- * Commander doesn't support two-argument options natively.
- * Pre-process argv to merge `-p project branch` pairs into `-p project:branch`
- * so commander can handle them as single option values.
- */
-function normalizeProjectFlags(argv) {
-    const result = [];
-    let i = 0;
-    while (i < argv.length) {
-        if (argv[i] === '-p') {
-            const name = argv[i + 1];
-            const branch = argv[i + 2];
-            if (!name || name.startsWith('-') || !branch || branch.startsWith('-')) {
-                console.error('Error: -p requires two arguments: <project> <branch>');
-                process.exit(1);
-            }
-            result.push('-p', `${name}:${branch}`);
-            i += 3;
-        }
-        else {
-            result.push(argv[i]);
-            i++;
-        }
-    }
-    return result;
-}
+import { removeCommand } from './commands/remove.js';
+import { listCommand } from './commands/list.js';
 function collectProject(value, previous) {
     const colonIdx = value.indexOf(':');
-    if (colonIdx === -1) {
-        console.error(`Error: internal parse error for value "${value}"`);
-        process.exit(1);
-    }
-    const name = value.slice(0, colonIdx);
-    const branch = value.slice(colonIdx + 1);
+    const name = colonIdx === -1 ? value : value.slice(0, colonIdx);
+    const branch = colonIdx === -1 ? 'master' : value.slice(colonIdx + 1);
     return [...previous, { name, branch }];
 }
 const program = new Command();
@@ -46,26 +18,41 @@ program
 program
     .command('new <workspace>')
     .description('Create a new workspace with git worktrees')
-    .option('-p <project:branch>', 'Add a project with a branch (repeatable)', collectProject, [])
+    .option('-b <branch>', 'New branch name (defaults to workspace name)')
+    .option('-p <project[:branch]>', 'Add a project, optionally with base branch (default: master), repeatable', collectProject, [])
     .action(async (workspace, options) => {
     if (options.p.length === 0) {
-        console.error('Error: at least one -p <project> <branch> is required');
+        console.error('Error: at least one -p <project[:branch]> is required');
         process.exit(1);
     }
-    await newCommand(workspace, options.p);
+    await newCommand(workspace, options.p, options.b);
 });
 program
     .command('append <workspace>')
     .description('Append projects to an existing workspace')
-    .option('-p <project:branch>', 'Add a project with a branch (repeatable)', collectProject, [])
+    .option('-b <branch>', 'New branch name (defaults to workspace name)')
+    .option('-p <project[:branch]>', 'Add a project, optionally with base branch (default: master), repeatable', collectProject, [])
     .action(async (workspace, options) => {
     if (options.p.length === 0) {
-        console.error('Error: at least one -p <project> <branch> is required');
+        console.error('Error: at least one -p <project[:branch]> is required');
         process.exit(1);
     }
-    await appendCommand(workspace, options.p);
+    await appendCommand(workspace, options.p, options.b);
+});
+program
+    .command('remove <workspace>')
+    .description('Remove a workspace or specific projects from it')
+    .option('-p <project>', 'Remove a specific project (repeatable)', (val, prev) => [...prev, { name: val }], [])
+    .action(async (workspace, options) => {
+    await removeCommand(workspace, options.p);
+});
+program
+    .command('list')
+    .description('List all created workspaces and their projects')
+    .action(async () => {
+    await listCommand();
 });
-program.parseAsync(normalizeProjectFlags(process.argv), { from: 'node' }).catch((err) => {
+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.1",
+  "version": "0.2.0",
   "description": "Git worktree workspace manager",
   "type": "module",
   "bin": {