@simonfestl/husky-cli 0.5.2 → 0.6.1

package/README.md

@@ -160,6 +160,8 @@ husky roadmap create "Q1 2025" --description "..."
 husky roadmap update <roadmap-id> --name "Updated"
 husky roadmap delete <roadmap-id>
 husky roadmap add-phase <roadmap-id> --name "Phase 1"
+husky roadmap update-phase <roadmap-id> <phase-id> --name "Updated"
+husky roadmap delete-phase <roadmap-id> <phase-id> --force
 husky roadmap add-feature <roadmap-id> --phase <id> --title "Feature"
 husky roadmap list-features <roadmap-id>
 husky roadmap update-feature <roadmap-id> <feature-id> --status done
@@ -187,6 +189,20 @@ husky vm-config update <config-id> --machine-type e2-standard-2
 husky vm-config delete <config-id>
 ```
 
+### Git Worktree Management
+
+```bash
+husky worktree list                          # List all worktrees
+husky worktree create <session-name>         # Create worktree
+husky worktree info <session-name>           # Show details
+husky worktree status [session-name]         # Show status
+husky worktree cd <session-name>             # Print path
+husky worktree merge <session-name>          # Merge to base
+husky worktree remove <session-name>         # Remove worktree
+husky worktree branches                      # List husky/* branches
+husky worktree cleanup                       # Clean stale worktrees
+```
+
 ### Settings
 
 ```bash
@@ -283,6 +299,13 @@ husky --version
 
 ## Changelog
 
+### v0.6.0 (2026-01-06)
+- Added: Git Worktree support for multi-agent isolation
+- Added: `husky worktree` commands (create, list, merge, remove, etc.)
+- Added: MergeLock mechanism for safe concurrent operations
+- Refactored: Interactive mode into modular components
+- Improved: Based on Auto-Claude's worktree architecture
+
 ### v0.5.0 (2026-01-06)
 - Full Dashboard feature parity (69 new commands)
 - Added: project, workflow, idea, department, vm, jules, process, strategy, settings, vm-config commands

package/dist/commands/interactive/worktrees.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Interactive Mode: Worktrees Module
+ *
+ * Provides menu-based worktree management for isolated agent workspaces.
+ */
+export declare function worktreesMenu(): Promise<void>;

package/dist/commands/interactive/worktrees.js

@@ -0,0 +1,354 @@
+/**
+ * Interactive Mode: Worktrees Module
+ *
+ * Provides menu-based worktree management for isolated agent workspaces.
+ */
+import { select, input, confirm } from "@inquirer/prompts";
+import { WorktreeManager } from "../../lib/worktree.js";
+import { MergeLock, withMergeLock } from "../../lib/merge-lock.js";
+import { pressEnterToContinue, truncate } from "./utils.js";
+let manager;
+function getManager() {
+    if (!manager) {
+        manager = new WorktreeManager(process.cwd());
+    }
+    return manager;
+}
+export async function worktreesMenu() {
+    const mgr = getManager();
+    const worktrees = mgr.listWorktrees();
+    console.log("\n  WORKTREES");
+    console.log("  " + "-".repeat(50));
+    console.log(`  Base branch: ${mgr.getBaseBranch()}`);
+    console.log(`  Active worktrees: ${worktrees.length}`);
+    console.log("");
+    const menuItems = [
+        { name: "📋 List Worktrees", value: "list" },
+        { name: "➕ Create Worktree", value: "create" },
+        { name: "🔍 View Worktree Details", value: "view" },
+        { name: "📊 Show Status", value: "status" },
+        { name: "🔀 Merge Worktree", value: "merge" },
+        { name: "🗑️  Remove Worktree", value: "remove" },
+        { name: "🧹 Cleanup Stale", value: "cleanup" },
+        { name: "🌿 List Branches", value: "branches" },
+        { name: "← Back", value: "back" },
+    ];
+    const choice = await select({
+        message: "Worktree Action:",
+        choices: menuItems,
+    });
+    switch (choice) {
+        case "list":
+            await listWorktrees();
+            break;
+        case "create":
+            await createWorktree();
+            break;
+        case "view":
+            await viewWorktree();
+            break;
+        case "status":
+            await showStatus();
+            break;
+        case "merge":
+            await mergeWorktree();
+            break;
+        case "remove":
+            await removeWorktree();
+            break;
+        case "cleanup":
+            await cleanup();
+            break;
+        case "branches":
+            await listBranches();
+            break;
+        case "back":
+            return;
+    }
+}
+async function listWorktrees() {
+    const mgr = getManager();
+    const worktrees = mgr.listWorktrees();
+    console.log("\n  WORKTREES");
+    console.log("  " + "-".repeat(70));
+    if (worktrees.length === 0) {
+        console.log("  No worktrees found.");
+        console.log("  Create one with the 'Create Worktree' option.");
+    }
+    else {
+        console.log(`  ${"SESSION".padEnd(20)} ${"BRANCH".padEnd(25)} ${"COMMITS".padEnd(8)} ${"CHANGES"}`);
+        console.log("  " + "-".repeat(70));
+        for (const wt of worktrees) {
+            const changes = `+${wt.stats.additions}/-${wt.stats.deletions} (${wt.stats.filesChanged} files)`;
+            console.log(`  ${truncate(wt.sessionName, 18).padEnd(20)} ${truncate(wt.branch, 23).padEnd(25)} ${String(wt.stats.commitCount).padEnd(8)} ${changes}`);
+        }
+    }
+    console.log("");
+    await pressEnterToContinue();
+}
+async function createWorktree() {
+    const mgr = getManager();
+    const sessionName = await input({
+        message: "Session name:",
+        validate: (val) => {
+            if (!val.trim())
+                return "Session name is required";
+            if (!/^[a-zA-Z0-9_-]+$/.test(val)) {
+                return "Session name can only contain letters, numbers, hyphens, and underscores";
+            }
+            if (mgr.worktreeExists(val)) {
+                return "A worktree with this name already exists";
+            }
+            return true;
+        },
+    });
+    const baseBranch = await input({
+        message: "Base branch (leave empty for default):",
+        default: mgr.getBaseBranch(),
+    });
+    try {
+        // Recreate manager with custom base branch if specified
+        const actualManager = baseBranch !== mgr.getBaseBranch()
+            ? new WorktreeManager(process.cwd(), baseBranch)
+            : mgr;
+        const info = actualManager.createWorktree(sessionName);
+        console.log("\n  ✓ Worktree created successfully!");
+        console.log(`    Session:  ${info.sessionName}`);
+        console.log(`    Branch:   ${info.branch}`);
+        console.log(`    Path:     ${info.path}`);
+        console.log("\n  To work in this worktree:");
+        console.log(`    cd ${info.path}`);
+        console.log("");
+    }
+    catch (error) {
+        console.error("\n  ✗ Error creating worktree:", error instanceof Error ? error.message : error);
+    }
+    await pressEnterToContinue();
+}
+async function selectWorktree(message) {
+    const mgr = getManager();
+    const worktrees = mgr.listWorktrees();
+    if (worktrees.length === 0) {
+        console.log("\n  No worktrees found.");
+        await pressEnterToContinue();
+        return null;
+    }
+    const choices = worktrees.map((wt) => ({
+        name: `${wt.sessionName} (${wt.branch})`,
+        value: wt.sessionName,
+    }));
+    choices.push({ name: "← Cancel", value: "__cancel__" });
+    const sessionName = await select({
+        message,
+        choices,
+    });
+    if (sessionName === "__cancel__")
+        return null;
+    return mgr.getWorktree(sessionName);
+}
+async function viewWorktree() {
+    const mgr = getManager();
+    const info = await selectWorktree("Select worktree to view:");
+    if (!info)
+        return;
+    const changedFiles = mgr.getChangedFiles(info.sessionName);
+    const hasUncommitted = mgr.hasUncommittedChanges(info.sessionName);
+    console.log(`\n  Worktree: ${info.sessionName}`);
+    console.log("  " + "-".repeat(60));
+    console.log(`  Path:       ${info.path}`);
+    console.log(`  Branch:     ${info.branch}`);
+    console.log(`  Base:       ${info.baseBranch}`);
+    console.log(`  Active:     ${info.isActive ? "Yes" : "No"}`);
+    console.log(`\n  Statistics:`);
+    console.log(`    Commits:  ${info.stats.commitCount}`);
+    console.log(`    Files:    ${info.stats.filesChanged}`);
+    console.log(`    Added:    +${info.stats.additions}`);
+    console.log(`    Removed:  -${info.stats.deletions}`);
+    if (hasUncommitted) {
+        console.log(`\n  ⚠ Has uncommitted changes`);
+    }
+    if (changedFiles.length > 0) {
+        console.log(`\n  Changed files:`);
+        const maxFiles = 15;
+        for (const file of changedFiles.slice(0, maxFiles)) {
+            const statusLabel = file.status === "A" ? "[new]" : file.status === "D" ? "[del]" : "[mod]";
+            console.log(`    ${statusLabel.padEnd(6)} ${file.file}`);
+        }
+        if (changedFiles.length > maxFiles) {
+            console.log(`    ... and ${changedFiles.length - maxFiles} more`);
+        }
+    }
+    console.log("");
+    await pressEnterToContinue();
+}
+async function showStatus() {
+    const mgr = getManager();
+    const worktrees = mgr.listWorktrees();
+    console.log("\n  WORKTREE STATUS");
+    console.log("  " + "-".repeat(50));
+    if (worktrees.length === 0) {
+        console.log("  No worktrees found.");
+    }
+    else {
+        for (const wt of worktrees) {
+            const hasUncommitted = mgr.hasUncommittedChanges(wt.sessionName);
+            const statusIcon = hasUncommitted ? "●" : "○";
+            const changes = `+${wt.stats.additions}/-${wt.stats.deletions}`;
+            console.log(`\n  ${statusIcon} ${wt.sessionName}`);
+            console.log(`    Branch: ${wt.branch}`);
+            console.log(`    Commits: ${wt.stats.commitCount} | Files: ${wt.stats.filesChanged} | ${changes}`);
+            if (hasUncommitted) {
+                console.log(`    ⚠ Uncommitted changes`);
+            }
+        }
+    }
+    console.log("");
+    await pressEnterToContinue();
+}
+async function mergeWorktree() {
+    const mgr = getManager();
+    const worktrees = mgr.listWorktrees();
+    // Filter to worktrees with commits
+    const mergeableWorktrees = worktrees.filter((wt) => wt.stats.commitCount > 0);
+    if (mergeableWorktrees.length === 0) {
+        console.log("\n  No worktrees have commits to merge.");
+        await pressEnterToContinue();
+        return;
+    }
+    const choices = mergeableWorktrees.map((wt) => ({
+        name: `${wt.sessionName} (${wt.stats.commitCount} commits, +${wt.stats.additions}/-${wt.stats.deletions})`,
+        value: wt.sessionName,
+    }));
+    choices.push({ name: "← Cancel", value: "__cancel__" });
+    const sessionName = await select({
+        message: "Select worktree to merge:",
+        choices,
+    });
+    if (sessionName === "__cancel__")
+        return;
+    const noCommit = await confirm({
+        message: "Stage only (no commit)?",
+        default: false,
+    });
+    const deleteAfter = await confirm({
+        message: "Delete worktree after successful merge?",
+        default: false,
+    });
+    const info = mgr.getWorktree(sessionName);
+    if (!info) {
+        console.log("\n  Worktree not found.");
+        return;
+    }
+    try {
+        console.log(`\n  Merging ${info.branch} into ${info.baseBranch}...`);
+        const success = await withMergeLock(process.cwd(), sessionName, async () => {
+            return mgr.mergeWorktree(sessionName, {
+                noCommit,
+                deleteAfter,
+            });
+        });
+        if (success) {
+            console.log("\n  ✓ Merge successful!");
+            if (noCommit) {
+                console.log("    Changes are staged. Review and commit when ready.");
+            }
+            if (deleteAfter) {
+                console.log("    Worktree and branch have been removed.");
+            }
+        }
+        else {
+            console.log("\n  ✗ Merge failed. There may be conflicts.");
+        }
+    }
+    catch (error) {
+        console.error("\n  ✗ Error during merge:", error instanceof Error ? error.message : error);
+    }
+    console.log("");
+    await pressEnterToContinue();
+}
+async function removeWorktree() {
+    const mgr = getManager();
+    const worktrees = mgr.listWorktrees();
+    if (worktrees.length === 0) {
+        console.log("\n  No worktrees found.");
+        await pressEnterToContinue();
+        return;
+    }
+    const choices = worktrees.map((wt) => {
+        const hasUncommitted = mgr.hasUncommittedChanges(wt.sessionName);
+        const warning = hasUncommitted ? " ⚠" : "";
+        return {
+            name: `${wt.sessionName} (${wt.branch})${warning}`,
+            value: wt.sessionName,
+        };
+    });
+    choices.push({ name: "← Cancel", value: "__cancel__" });
+    const sessionName = await select({
+        message: "Select worktree to remove:",
+        choices,
+    });
+    if (sessionName === "__cancel__")
+        return;
+    const deleteBranch = await confirm({
+        message: "Also delete the branch?",
+        default: false,
+    });
+    const shouldContinue = await confirm({
+        message: "Are you sure?",
+        default: false,
+    });
+    if (!shouldContinue) {
+        console.log("\n  Cancelled.");
+        return;
+    }
+    const info = mgr.getWorktree(sessionName);
+    try {
+        mgr.removeWorktree(sessionName, deleteBranch);
+        console.log(`\n  ✓ Worktree removed: ${sessionName}`);
+        if (deleteBranch && info) {
+            console.log(`    Branch deleted: ${info.branch}`);
+        }
+    }
+    catch (error) {
+        console.error("\n  ✗ Error removing worktree:", error instanceof Error ? error.message : error);
+    }
+    await pressEnterToContinue();
+}
+async function cleanup() {
+    const mgr = getManager();
+    const projectDir = process.cwd();
+    console.log("\n  Cleaning up stale worktrees and locks...");
+    try {
+        mgr.cleanupStale();
+        const staleLocks = MergeLock.cleanupStale(projectDir);
+        console.log("\n  ✓ Cleanup complete");
+        if (staleLocks > 0) {
+            console.log(`    Removed ${staleLocks} stale lock(s)`);
+        }
+    }
+    catch (error) {
+        console.error("\n  ✗ Error during cleanup:", error instanceof Error ? error.message : error);
+    }
+    await pressEnterToContinue();
+}
+async function listBranches() {
+    const mgr = getManager();
+    const branches = mgr.listBranches();
+    const worktrees = mgr.listWorktrees();
+    const worktreeSessionNames = new Set(worktrees.map((w) => w.sessionName));
+    console.log("\n  HUSKY BRANCHES");
+    console.log("  " + "-".repeat(50));
+    if (branches.length === 0) {
+        console.log("  No husky/* branches found.");
+    }
+    else {
+        for (const branch of branches) {
+            const sessionName = branch.replace("husky/", "");
+            const hasWorktree = worktreeSessionNames.has(sessionName);
+            const marker = hasWorktree ? " [worktree]" : "";
+            console.log(`  ${branch}${marker}`);
+        }
+    }
+    console.log("");
+    await pressEnterToContinue();
+}

package/dist/commands/interactive.js

@@ -12,6 +12,7 @@ import { julesSessionsMenu } from "./interactive/jules-sessions.js";
 import { roadmapsMenu } from "./interactive/roadmaps.js";
 import { strategyMenu } from "./interactive/strategy.js";
 import { changelogMenu } from "./interactive/changelog.js";
+import { worktreesMenu } from "./interactive/worktrees.js";
 import { clearScreen, printHeader, pressEnterToContinue } from "./interactive/utils.js";
 // ============================================
 // MAIN MENU
@@ -33,6 +34,7 @@ export async function runInteractiveMode() {
             { name: "---", value: "separator2", description: "" },
             { name: "VM Sessions", value: "vm", description: "Manage VM sessions" },
             { name: "Jules Sessions", value: "jules", description: "Manage Jules AI sessions" },
+            { name: "Worktrees", value: "worktrees", description: "Manage Git worktrees for agent isolation" },
             { name: "---", value: "separator3", description: "" },
             { name: "Business Strategy", value: "strategy", description: "Manage business strategy" },
             { name: "Changelog", value: "changelog", description: "Generate and manage changelogs" },
@@ -74,6 +76,9 @@ export async function runInteractiveMode() {
                 case "jules":
                     await julesSessionsMenu();
                     break;
+                case "worktrees":
+                    await worktreesMenu();
+                    break;
                 case "strategy":
                     await strategyMenu();
                     break;

package/dist/commands/roadmap.js

@@ -152,6 +152,113 @@ roadmapCommand
         process.exit(1);
     }
 });
+// husky roadmap update-phase <roadmapId> <phaseId>
+roadmapCommand
+    .command("update-phase <roadmapId> <phaseId>")
+    .description("Update a roadmap phase")
+    .option("-n, --name <name>", "New phase name")
+    .option("-d, --description <description>", "New phase description")
+    .option("--status <status>", "Phase status (planned, in_progress, completed)")
+    .option("--order <order>", "Phase order (0-based)")
+    .action(async (roadmapId, phaseId, options) => {
+    const config = ensureConfig();
+    // Build update payload
+    const updateData = { phaseId };
+    if (options.name)
+        updateData.name = options.name;
+    if (options.description)
+        updateData.description = options.description;
+    if (options.status) {
+        const validStatuses = ["planned", "in_progress", "completed"];
+        if (!validStatuses.includes(options.status)) {
+            console.error(`Error: Invalid status "${options.status}". Must be one of: ${validStatuses.join(", ")}`);
+            process.exit(1);
+        }
+        updateData.status = options.status;
+    }
+    if (options.order !== undefined) {
+        const order = parseInt(options.order, 10);
+        if (isNaN(order) || order < 0) {
+            console.error("Error: Order must be a non-negative integer");
+            process.exit(1);
+        }
+        updateData.order = order;
+    }
+    if (Object.keys(updateData).length === 1) {
+        console.error("Error: No update options provided. Use -n/--name, -d/--description, --status, or --order");
+        process.exit(1);
+    }
+    try {
+        const res = await fetch(`${config.apiUrl}/api/roadmaps/${roadmapId}/phases`, {
+            method: "PATCH",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+            },
+            body: JSON.stringify(updateData),
+        });
+        if (!res.ok) {
+            if (res.status === 404) {
+                console.error(`Error: Roadmap or phase not found`);
+            }
+            else {
+                const errorBody = await res.json().catch(() => ({}));
+                console.error(`Error: API returned ${res.status}`, errorBody.error || "");
+            }
+            process.exit(1);
+        }
+        const roadmap = await res.json();
+        const updatedPhase = roadmap.phases.find((p) => p.id === phaseId);
+        console.log(`✓ Phase updated successfully`);
+        if (updatedPhase) {
+            console.log(`  Name:   ${updatedPhase.name}`);
+            console.log(`  Status: ${updatedPhase.status}`);
+            console.log(`  Order:  ${updatedPhase.order}`);
+        }
+    }
+    catch (error) {
+        console.error("Error updating phase:", error);
+        process.exit(1);
+    }
+});
+// husky roadmap delete-phase <roadmapId> <phaseId>
+roadmapCommand
+    .command("delete-phase <roadmapId> <phaseId>")
+    .description("Delete a phase from a roadmap (including all its features)")
+    .option("--force", "Skip confirmation")
+    .action(async (roadmapId, phaseId, options) => {
+    const config = ensureConfig();
+    if (!options.force) {
+        console.log("Warning: This will permanently delete the phase and all its features.");
+        console.log("Use --force to confirm deletion.");
+        process.exit(1);
+    }
+    try {
+        const url = new URL(`/api/roadmaps/${roadmapId}/phases`, config.apiUrl);
+        url.searchParams.set("phaseId", phaseId);
+        const res = await fetch(url.toString(), {
+            method: "DELETE",
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            if (res.status === 404) {
+                console.error(`Error: Roadmap or phase not found`);
+            }
+            else {
+                const errorBody = await res.json().catch(() => ({}));
+                console.error(`Error: API returned ${res.status}`, errorBody.error || "");
+            }
+            process.exit(1);
+        }
+        const roadmap = await res.json();
+        console.log(`✓ Phase deleted`);
+        console.log(`  Remaining phases: ${roadmap.phases.length}`);
+    }
+    catch (error) {
+        console.error("Error deleting phase:", error);
+        process.exit(1);
+    }
+});
 // husky roadmap add-feature <roadmapId> <phaseId> <title>
 roadmapCommand
     .command("add-feature <roadmapId> <phaseId> <title>")

package/dist/commands/worktree.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const worktreeCommand: Command;