@lumenflow/cli 2.1.1 → 2.1.2

package/dist/__tests__/guard-main-branch.test.js

@@ -0,0 +1,79 @@
+/**
+ * @file guard-main-branch.test.ts
+ * @description Tests for guard-main-branch worktree context detection (WU-1130)
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { guardMainBranch } from '../guard-main-branch.js';
+// Mock the core module
+vi.mock('@lumenflow/core', () => ({
+    createGitForPath: vi.fn(),
+    getGitForCwd: vi.fn(),
+    isAgentBranch: vi.fn().mockResolvedValue(false),
+    getConfig: vi.fn().mockReturnValue({
+        git: {
+            mainBranch: 'main',
+            laneBranchPrefix: 'lane/',
+        },
+    }),
+}));
+// Mock the worktree-guard module
+vi.mock('@lumenflow/core/dist/core/worktree-guard.js', () => ({
+    isInWorktree: vi.fn(),
+}));
+import { getGitForCwd, createGitForPath } from '@lumenflow/core';
+import { isInWorktree } from '@lumenflow/core/dist/core/worktree-guard.js';
+describe('guard-main-branch (WU-1130)', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('lane branch worktree detection', () => {
+        it('should allow operations when on lane branch AND in worktree', async () => {
+            // Setup: On lane branch, in worktree
+            const mockGit = {
+                getCurrentBranch: vi.fn().mockResolvedValue('lane/framework-cli/wu-1130'),
+            };
+            vi.mocked(getGitForCwd).mockReturnValue(mockGit);
+            vi.mocked(isInWorktree).mockReturnValue(true);
+            const result = await guardMainBranch({});
+            expect(result.success).toBe(true);
+            expect(result.isProtected).toBe(false);
+            expect(result.currentBranch).toBe('lane/framework-cli/wu-1130');
+        });
+        it('should block operations when on lane branch but NOT in worktree', async () => {
+            // Setup: On lane branch, but not in worktree (e.g., checked out directly)
+            const mockGit = {
+                getCurrentBranch: vi.fn().mockResolvedValue('lane/framework-cli/wu-1130'),
+            };
+            vi.mocked(getGitForCwd).mockReturnValue(mockGit);
+            vi.mocked(isInWorktree).mockReturnValue(false);
+            const result = await guardMainBranch({});
+            expect(result.success).toBe(true);
+            expect(result.isProtected).toBe(true);
+            expect(result.reason).toContain('requires worktree');
+        });
+        it('should use baseDir for worktree detection when provided', async () => {
+            const mockGit = {
+                getCurrentBranch: vi.fn().mockResolvedValue('lane/ops-tooling/wu-2725'),
+            };
+            vi.mocked(createGitForPath).mockReturnValue(mockGit);
+            vi.mocked(isInWorktree).mockReturnValue(true);
+            const result = await guardMainBranch({ baseDir: '/path/to/worktrees/ops-tooling-wu-2725' });
+            expect(isInWorktree).toHaveBeenCalledWith({ cwd: '/path/to/worktrees/ops-tooling-wu-2725' });
+            expect(result.isProtected).toBe(false);
+        });
+    });
+    describe('main branch protection', () => {
+        it('should block operations on main branch', async () => {
+            const mockGit = {
+                getCurrentBranch: vi.fn().mockResolvedValue('main'),
+            };
+            vi.mocked(getGitForCwd).mockReturnValue(mockGit);
+            const result = await guardMainBranch({});
+            expect(result.isProtected).toBe(true);
+            expect(result.reason).toContain("'main' is protected");
+        });
+    });
+});

package/dist/guard-main-branch.js

@@ -13,6 +13,7 @@
  * WU-1109: INIT-003 Phase 4b - Migrate git operations
  */
 import { createGitForPath, getGitForCwd, isAgentBranch, getConfig } from '@lumenflow/core';
+import { isInWorktree } from '@lumenflow/core/dist/core/worktree-guard.js';
 /**
  * Parse command line arguments for guard-main-branch
  */
@@ -90,6 +91,16 @@ export async function guardMainBranch(args) {
         }
         // Check if on a lane branch (requires worktree discipline)
         if (isLaneBranch(currentBranch)) {
+            // If we're actually in a worktree, allow the operation (WU-1130)
+            const cwd = args.baseDir ?? process.cwd();
+            if (isInWorktree({ cwd })) {
+                return {
+                    success: true,
+                    isProtected: false,
+                    currentBranch,
+                };
+            }
+            // On lane branch but not in worktree - block
             return {
                 success: true,
                 isProtected: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumenflow/cli",
-  "version": "2.1.1",
+  "version": "2.1.2",
   "description": "Command-line interface for LumenFlow workflow framework",
   "keywords": [
     "lumenflow",
@@ -132,11 +132,11 @@
     "pretty-ms": "^9.2.0",
     "simple-git": "^3.30.0",
     "yaml": "^2.8.2",
-    "@lumenflow/core": "2.1.1",
-    "@lumenflow/metrics": "2.1.1",
-    "@lumenflow/memory": "2.1.1",
-    "@lumenflow/initiatives": "2.1.1",
-    "@lumenflow/agent": "2.1.1"
+    "@lumenflow/core": "2.1.2",
+    "@lumenflow/metrics": "2.1.2",
+    "@lumenflow/memory": "2.1.2",
+    "@lumenflow/initiatives": "2.1.2",
+    "@lumenflow/agent": "2.1.2"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^4.0.17",