ccmanager 4.3.0 → 4.3.2

package/dist/utils/worktreeInclude.js

@@ -0,0 +1,100 @@
+import { execSync } from 'child_process';
+import { existsSync, statSync, mkdirSync, cpSync } from 'fs';
+import path from 'path';
+import { logger } from './logger.js';
+/**
+ * Filename for the convention shared across worktree-aware tools (Claude Code,
+ * Conductor, OpenAI Codex, git-worktreeinclude, worktrunk): a gitignore-syntax
+ * file at the repository root that lists gitignored files to carry into every
+ * new worktree.
+ */
+export const WORKTREE_INCLUDE_FILENAME = '.worktreeinclude';
+/**
+ * Resolves which files a `.worktreeinclude` file selects, relative to `gitRoot`.
+ *
+ * A file is selected only when both hold:
+ * - it matches a pattern in `.worktreeinclude` (gitignore syntax: comments,
+ *   negation with `!`, anchoring with `/`, `**` globs)
+ * - Git already ignores it (nested `.gitignore` files, `.git/info/exclude`,
+ *   and `core.excludesfile` all apply)
+ *
+ * This mirrors the safety rule every tool that supports `.worktreeinclude`
+ * documents: listing a pattern never makes a tracked file eligible, and it
+ * never makes an otherwise-untracked-but-not-ignored file eligible either.
+ *
+ * @param gitRoot - Absolute path to the main checkout (repository root)
+ * @returns Repository-relative paths (forward-slash separated, as Git reports them)
+ */
+export function resolveWorktreeIncludeFiles(gitRoot) {
+    const includeFilePath = path.join(gitRoot, WORKTREE_INCLUDE_FILENAME);
+    if (!existsSync(includeFilePath) || !statSync(includeFilePath).isFile()) {
+        return [];
+    }
+    let candidatesOutput;
+    try {
+        // --exclude-from applies ONLY .worktreeinclude's own patterns (no
+        // --exclude-standard), so this lists untracked files matching those
+        // patterns regardless of whether the repository's real .gitignore
+        // covers them.
+        candidatesOutput = execSync(`git ls-files --others --ignored --exclude-from="${WORKTREE_INCLUDE_FILENAME}" -z`, { cwd: gitRoot, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+    }
+    catch (error) {
+        logger.error('Failed to resolve .worktreeinclude candidates', {
+            gitRoot,
+            error: String(error),
+        });
+        return [];
+    }
+    const candidates = candidatesOutput
+        .split('\0')
+        .filter(entry => entry.length > 0);
+    if (candidates.length === 0) {
+        return [];
+    }
+    // Confirm each candidate against the repository's real ignore rules.
+    // git check-ignore --stdin echoes back only the paths it is asked about
+    // that ARE ignored, so this is the second half of the intersection.
+    let ignoredOutput;
+    try {
+        ignoredOutput = execSync('git check-ignore --stdin -z', {
+            cwd: gitRoot,
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            input: candidates.join('\0') + '\0',
+        });
+    }
+    catch (error) {
+        // Exit code 1 (no matches) surfaces as a thrown error; anything already
+        // written to stdout before that is still the correct partial result.
+        const execError = error;
+        ignoredOutput = execError.stdout ?? '';
+    }
+    return ignoredOutput.split('\0').filter(entry => entry.length > 0);
+}
+/**
+ * Copies the files a `.worktreeinclude` file selects from the main checkout
+ * into a freshly created worktree. No-ops when no `.worktreeinclude` file
+ * exists. Never overwrites a file that already exists at the destination.
+ *
+ * @param gitRoot - Absolute path to the main checkout (repository root)
+ * @param targetWorktreePath - Absolute path to the newly created worktree
+ */
+export function copyWorktreeIncludeFiles(gitRoot, targetWorktreePath) {
+    const relativePaths = resolveWorktreeIncludeFiles(gitRoot);
+    for (const relativePath of relativePaths) {
+        const sourcePath = path.join(gitRoot, relativePath);
+        const targetPath = path.join(targetWorktreePath, relativePath);
+        if (!existsSync(sourcePath)) {
+            continue;
+        }
+        if (existsSync(targetPath)) {
+            logger.warn('Skipping .worktreeinclude copy, destination already exists', {
+                relativePath,
+                targetPath,
+            });
+            continue;
+        }
+        mkdirSync(path.dirname(targetPath), { recursive: true });
+        cpSync(sourcePath, targetPath, { recursive: true, preserveTimestamps: true });
+    }
+}

package/dist/utils/worktreeInclude.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/worktreeInclude.test.js

@@ -0,0 +1,91 @@
+import { describe, it, expect, beforeEach, afterAll } from 'vitest';
+import { execSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import { resolveWorktreeIncludeFiles, copyWorktreeIncludeFiles, } from './worktreeInclude.js';
+describe('worktreeInclude', () => {
+    const testDir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'ccmanager-worktreeinclude-test-')));
+    let repoCount = 0;
+    let gitRoot;
+    beforeEach(() => {
+        repoCount += 1;
+        gitRoot = path.join(testDir, `repo-${repoCount}`);
+        fs.mkdirSync(gitRoot, { recursive: true });
+        execSync('git init', { cwd: gitRoot });
+        execSync('git config user.email "test@test.com"', { cwd: gitRoot });
+        execSync('git config user.name "Test User"', { cwd: gitRoot });
+        fs.writeFileSync(path.join(gitRoot, 'README.md'), '# repo');
+        execSync('git add README.md', { cwd: gitRoot });
+        execSync('git commit -m "initial commit"', { cwd: gitRoot });
+    });
+    afterAll(() => {
+        fs.rmSync(testDir, { recursive: true, force: true });
+    });
+    it('returns an empty list when no .worktreeinclude file exists', () => {
+        fs.writeFileSync(path.join(gitRoot, '.env'), 'SECRET=1');
+        expect(resolveWorktreeIncludeFiles(gitRoot)).toEqual([]);
+    });
+    it('selects a file that matches .worktreeinclude and is gitignored', () => {
+        fs.writeFileSync(path.join(gitRoot, '.gitignore'), '.env\n');
+        fs.writeFileSync(path.join(gitRoot, '.worktreeinclude'), '.env\n');
+        fs.writeFileSync(path.join(gitRoot, '.env'), 'SECRET=1');
+        expect(resolveWorktreeIncludeFiles(gitRoot)).toEqual(['.env']);
+    });
+    it('excludes a file that matches .worktreeinclude but is not gitignored', () => {
+        fs.writeFileSync(path.join(gitRoot, '.worktreeinclude'), 'notes.txt\n');
+        fs.writeFileSync(path.join(gitRoot, 'notes.txt'), 'not ignored');
+        expect(resolveWorktreeIncludeFiles(gitRoot)).toEqual([]);
+    });
+    it('excludes a tracked file even when it matches .worktreeinclude', () => {
+        fs.writeFileSync(path.join(gitRoot, '.gitignore'), 'tracked.env\n');
+        fs.writeFileSync(path.join(gitRoot, '.worktreeinclude'), 'tracked.env\n');
+        fs.writeFileSync(path.join(gitRoot, 'tracked.env'), 'SECRET=1');
+        execSync('git add -f tracked.env', { cwd: gitRoot });
+        execSync('git commit -m "track tracked.env"', { cwd: gitRoot });
+        expect(resolveWorktreeIncludeFiles(gitRoot)).toEqual([]);
+    });
+    it('resolves every file under a directory glob pattern', () => {
+        fs.writeFileSync(path.join(gitRoot, '.gitignore'), 'certs/\n');
+        fs.writeFileSync(path.join(gitRoot, '.worktreeinclude'), 'certs/local/**\n');
+        fs.mkdirSync(path.join(gitRoot, 'certs', 'local', 'nested'), {
+            recursive: true,
+        });
+        fs.writeFileSync(path.join(gitRoot, 'certs', 'local', 'cert.pem'), 'cert');
+        fs.writeFileSync(path.join(gitRoot, 'certs', 'local', 'nested', 'key.pem'), 'key');
+        expect(resolveWorktreeIncludeFiles(gitRoot).sort()).toEqual([
+            'certs/local/cert.pem',
+            'certs/local/nested/key.pem',
+        ]);
+    });
+    describe('copyWorktreeIncludeFiles', () => {
+        it('copies selected files into the target worktree, recreating nested directories', () => {
+            fs.writeFileSync(path.join(gitRoot, '.gitignore'), '.env\ncerts/\n');
+            fs.writeFileSync(path.join(gitRoot, '.worktreeinclude'), '.env\ncerts/local/**\n');
+            fs.writeFileSync(path.join(gitRoot, '.env'), 'SECRET=1');
+            fs.mkdirSync(path.join(gitRoot, 'certs', 'local'), { recursive: true });
+            fs.writeFileSync(path.join(gitRoot, 'certs', 'local', 'cert.pem'), 'cert');
+            const targetWorktreePath = path.join(testDir, `target-${repoCount}`);
+            fs.mkdirSync(targetWorktreePath, { recursive: true });
+            copyWorktreeIncludeFiles(gitRoot, targetWorktreePath);
+            expect(fs.readFileSync(path.join(targetWorktreePath, '.env'), 'utf8')).toBe('SECRET=1');
+            expect(fs.readFileSync(path.join(targetWorktreePath, 'certs', 'local', 'cert.pem'), 'utf8')).toBe('cert');
+        });
+        it('does not overwrite a file that already exists at the destination', () => {
+            fs.writeFileSync(path.join(gitRoot, '.gitignore'), '.env\n');
+            fs.writeFileSync(path.join(gitRoot, '.worktreeinclude'), '.env\n');
+            fs.writeFileSync(path.join(gitRoot, '.env'), 'SOURCE');
+            const targetWorktreePath = path.join(testDir, `target-${repoCount}`);
+            fs.mkdirSync(targetWorktreePath, { recursive: true });
+            fs.writeFileSync(path.join(targetWorktreePath, '.env'), 'EXISTING');
+            copyWorktreeIncludeFiles(gitRoot, targetWorktreePath);
+            expect(fs.readFileSync(path.join(targetWorktreePath, '.env'), 'utf8')).toBe('EXISTING');
+        });
+        it('is a no-op when no .worktreeinclude file exists', () => {
+            const targetWorktreePath = path.join(testDir, `target-${repoCount}`);
+            fs.mkdirSync(targetWorktreePath, { recursive: true });
+            expect(() => copyWorktreeIncludeFiles(gitRoot, targetWorktreePath)).not.toThrow();
+            expect(fs.readdirSync(targetWorktreePath)).toEqual([]);
+        });
+    });
+});

package/dist/utils/worktreeUtils.d.ts

@@ -78,3 +78,16 @@ export declare function calculateColumnPositions(items: SessionItem[]): {
  * Assembles the final worktree label with proper column alignment
  */
 export declare function assembleSessionLabel(item: SessionItem, columns: ReturnType<typeof calculateColumnPositions>): string;
+/**
+ * Whether a worktree may be deleted by CCManager.
+ *
+ * Two worktrees are off limits:
+ * - the main worktree, because git refuses to remove it and the repository
+ *   would be left without a checkout;
+ * - the worktree that contains the current working directory, because removing
+ *   the directory CCManager is running in breaks the running process.
+ *
+ * Single source of truth for the rule, shared by the multi-select delete screen
+ * and the per-row delete action.
+ */
+export declare function isDeletableWorktree(worktree: Pick<Worktree, 'path' | 'isMainWorktree'>, cwd?: string): boolean;

package/dist/utils/worktreeUtils.js

@@ -340,3 +340,26 @@ export function assembleSessionLabel(item, columns) {
     }
     return label;
 }
+/**
+ * Whether a worktree may be deleted by CCManager.
+ *
+ * Two worktrees are off limits:
+ * - the main worktree, because git refuses to remove it and the repository
+ *   would be left without a checkout;
+ * - the worktree that contains the current working directory, because removing
+ *   the directory CCManager is running in breaks the running process.
+ *
+ * Single source of truth for the rule, shared by the multi-select delete screen
+ * and the per-row delete action.
+ */
+export function isDeletableWorktree(worktree, cwd = process.cwd()) {
+    if (worktree.isMainWorktree)
+        return false;
+    const resolvedCwd = path.resolve(cwd);
+    const resolvedPath = path.resolve(worktree.path);
+    if (resolvedCwd === resolvedPath ||
+        resolvedCwd.startsWith(resolvedPath + path.sep)) {
+        return false;
+    }
+    return true;
+}

package/dist/utils/worktreeUtils.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { generateWorktreeDirectory, extractBranchParts, truncateString, prepareSessionItems, calculateColumnPositions, assembleSessionLabel, } from './worktreeUtils.js';
+import { generateWorktreeDirectory, extractBranchParts, truncateString, prepareSessionItems, calculateColumnPositions, assembleSessionLabel, isDeletableWorktree, } from './worktreeUtils.js';
 import { execSync } from 'child_process';
 import { Mutex, createInitialSessionStateData } from './mutex.js';
 import { createStateDetector } from '../services/stateDetector/index.js';
@@ -325,3 +325,22 @@ describe('column alignment', () => {
         expect(plain.indexOf('+10 -5')).toBe(21); // Should start at column 21
     });
 });
+describe('isDeletableWorktree', () => {
+    it('should reject the main worktree', () => {
+        expect(isDeletableWorktree({ path: '/repo', isMainWorktree: true }, '/somewhere/else')).toBe(false);
+    });
+    it('should reject the worktree holding the current working directory', () => {
+        expect(isDeletableWorktree({ path: '/repo/worktrees/feature', isMainWorktree: false }, '/repo/worktrees/feature')).toBe(false);
+    });
+    it('should reject a worktree that is an ancestor of the current working directory', () => {
+        expect(isDeletableWorktree({ path: '/repo/worktrees/feature', isMainWorktree: false }, '/repo/worktrees/feature/src/components')).toBe(false);
+    });
+    it('should accept a sibling worktree with a shared path prefix', () => {
+        // '/repo/worktrees/feature-2' starts with the '/repo/worktrees/feature'
+        // string but is a different directory, so it stays deletable.
+        expect(isDeletableWorktree({ path: '/repo/worktrees/feature', isMainWorktree: false }, '/repo/worktrees/feature-2')).toBe(true);
+    });
+    it('should accept an unrelated linked worktree', () => {
+        expect(isDeletableWorktree({ path: '/repo/worktrees/feature', isMainWorktree: false }, '/repo')).toBe(true);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "4.3.0",
+	"version": "4.3.2",
 	"description": "TUI application for managing multiple Claude Code sessions across Git worktrees",
 	"license": "MIT",
 	"author": "Kodai Kabasawa",
@@ -41,11 +41,11 @@
 		"bin"
 	],
 	"optionalDependencies": {
-		"@kodaikabasawa/ccmanager-darwin-arm64": "4.3.0",
-		"@kodaikabasawa/ccmanager-darwin-x64": "4.3.0",
-		"@kodaikabasawa/ccmanager-linux-arm64": "4.3.0",
-		"@kodaikabasawa/ccmanager-linux-x64": "4.3.0",
-		"@kodaikabasawa/ccmanager-win32-x64": "4.3.0"
+		"@kodaikabasawa/ccmanager-darwin-arm64": "4.3.2",
+		"@kodaikabasawa/ccmanager-darwin-x64": "4.3.2",
+		"@kodaikabasawa/ccmanager-linux-arm64": "4.3.2",
+		"@kodaikabasawa/ccmanager-linux-x64": "4.3.2",
+		"@kodaikabasawa/ccmanager-win32-x64": "4.3.2"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.28.0",