cluttry 1.0.0

package/src/commands/spawn.ts

@@ -0,0 +1,169 @@
+/**
+ * cry spawn command
+ *
+ * Create a worktree for a branch with optional secrets handling and hooks.
+ */
+
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import {
+  isGitRepo,
+  getRepoRoot,
+  getRepoName,
+  branchExists,
+  addWorktree,
+  listWorktrees,
+  runCommand,
+  commandExists,
+} from '../lib/git.js';
+import { getMergedConfig, configExists } from '../lib/config.js';
+import { getDefaultWorktreePath } from '../lib/paths.js';
+import { processSecrets } from '../lib/secrets.js';
+import * as out from '../lib/output.js';
+import type { SecretMode } from '../lib/types.js';
+
+interface SpawnOptions {
+  new?: boolean;
+  path?: string;
+  base?: string;
+  mode?: SecretMode;
+  run?: string;
+  agent?: string;
+}
+
+export async function spawn(branch: string, options: SpawnOptions): Promise<void> {
+  // Check if we're in a git repo
+  if (!isGitRepo()) {
+    out.error('Not a git repository. Run this command from within a git repo.');
+    process.exit(1);
+  }
+
+  const repoRoot = getRepoRoot();
+  const repoName = getRepoName();
+
+  // Load config
+  const config = configExists(repoRoot) ? getMergedConfig(repoRoot) : {
+    worktreeBaseDir: undefined,
+    defaultMode: 'none' as SecretMode,
+    include: [],
+    hooks: { postCreate: [] },
+    agentCommand: 'claude',
+  };
+
+  // Determine mode
+  const mode: SecretMode = options.mode ?? config.defaultMode;
+
+  // Calculate worktree path
+  const worktreePath = getDefaultWorktreePath(repoRoot, branch, {
+    explicitPath: options.path,
+    baseDir: options.base ?? config.worktreeBaseDir,
+    repoName,
+  });
+
+  // Check if destination already exists
+  if (existsSync(worktreePath)) {
+    out.error(`Destination already exists: ${worktreePath}`);
+    out.info('Remove it first or choose a different path with --path');
+    process.exit(1);
+  }
+
+  // Check if worktree already exists for this branch
+  const existingWorktrees = listWorktrees(repoRoot);
+  const existingForBranch = existingWorktrees.find((w) => w.branch === branch);
+  if (existingForBranch) {
+    out.error(`A worktree already exists for branch '${branch}'`);
+    out.info(`Path: ${existingForBranch.worktree}`);
+    out.info('Remove it first with: cry rm ' + branch);
+    process.exit(1);
+  }
+
+  // Determine if we need to create the branch
+  const needsNewBranch = options.new || !branchExists(branch, repoRoot);
+
+  out.header('Creating worktree');
+  out.log(`  Branch: ${out.fmt.branch(branch)}${needsNewBranch ? out.fmt.gray(' (new)') : ''}`);
+  out.log(`  Path:   ${out.fmt.path(worktreePath)}`);
+  out.log(`  Mode:   ${out.fmt.cyan(mode)}`);
+  out.newline();
+
+  // Create the worktree
+  try {
+    addWorktree(worktreePath, branch, needsNewBranch, repoRoot);
+    out.success('Worktree created');
+  } catch (error) {
+    out.error(`Failed to create worktree: ${(error as Error).message}`);
+    process.exit(1);
+  }
+
+  // Handle secrets
+  if (mode !== 'none' && config.include.length > 0) {
+    out.newline();
+    out.log(`Processing secrets (${mode} mode)...`);
+
+    const { processed, skipped } = await processSecrets(
+      mode,
+      config.include,
+      repoRoot,
+      worktreePath
+    );
+
+    if (processed.length > 0) {
+      out.success(`${mode === 'copy' ? 'Copied' : 'Symlinked'} ${processed.length} file(s):`);
+      for (const file of processed) {
+        out.log(`    ${out.fmt.dim('•')} ${file}`);
+      }
+    }
+
+    if (skipped.length > 0) {
+      out.warn(`Skipped ${skipped.length} file(s) for safety:`);
+      for (const file of skipped) {
+        out.log(`    ${out.fmt.dim('•')} ${file.path}: ${file.reason}`);
+      }
+    }
+  }
+
+  // Run post-create hooks from config
+  const hooks = config.hooks.postCreate;
+  if (hooks.length > 0) {
+    out.newline();
+    out.log('Running post-create hooks...');
+    for (const hook of hooks) {
+      out.log(`  ${out.fmt.dim('$')} ${hook}`);
+      const code = await runCommand(hook, worktreePath);
+      if (code !== 0) {
+        out.warn(`Hook exited with code ${code}`);
+      }
+    }
+  }
+
+  // Run --run command if provided
+  if (options.run) {
+    out.newline();
+    out.log('Running custom command...');
+    out.log(`  ${out.fmt.dim('$')} ${options.run}`);
+    const code = await runCommand(options.run, worktreePath);
+    if (code !== 0) {
+      out.warn(`Command exited with code ${code}`);
+    }
+  }
+
+  // Handle agent launch
+  const agentChoice = options.agent ?? 'none';
+  if (agentChoice === 'claude') {
+    const agentCmd = config.agentCommand;
+    out.newline();
+
+    if (commandExists(agentCmd)) {
+      out.log(`Launching ${agentCmd}...`);
+      await runCommand(agentCmd, worktreePath);
+    } else {
+      out.warn(`Agent command '${agentCmd}' not found.`);
+      out.info('Install Claude Code: https://docs.anthropic.com/claude-code');
+    }
+  }
+
+  // Final summary
+  out.newline();
+  out.header('Worktree ready');
+  out.log(`  ${out.fmt.dim('cd')} ${worktreePath}`);
+}

package/src/index.ts

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+/**
+ * cry - Git worktrees made painless for vibecoders
+ *
+ * A CLI tool for managing git worktrees with parallel AI-agent sessions in mind.
+ */
+
+import { Command } from 'commander';
+import { init } from './commands/init.js';
+import { spawn } from './commands/spawn.js';
+import { list } from './commands/list.js';
+import { open } from './commands/open.js';
+import { rm } from './commands/rm.js';
+import { prune } from './commands/prune.js';
+import { doctor } from './commands/doctor.js';
+import type { SecretMode } from './lib/types.js';
+
+const program = new Command();
+
+program
+  .name('cry')
+  .description('Git worktrees made painless for vibecoders running parallel AI-agent sessions')
+  .version('1.0.0');
+
+// cry init
+program
+  .command('init')
+  .description('Initialize cry configuration in the current repository')
+  .option('-f, --force', 'Overwrite existing configuration')
+  .action(async (options) => {
+    await init({ force: options.force });
+  });
+
+// cry spawn <branch>
+program
+  .command('spawn <branch>')
+  .description('Create a worktree for a branch')
+  .option('-n, --new', 'Create a new branch (equivalent to git worktree add -b)')
+  .option('-p, --path <dir>', 'Explicit path for the worktree')
+  .option('-b, --base <dir>', 'Base directory for worktrees')
+  .option('-m, --mode <mode>', 'Secret handling mode: copy, symlink, or none', 'copy')
+  .option('-r, --run <cmd>', 'Command to run after creating worktree')
+  .option('-a, --agent <agent>', 'Launch agent after setup: claude or none', 'none')
+  .action(async (branch: string, options) => {
+    const mode = options.mode as SecretMode;
+    if (!['copy', 'symlink', 'none'].includes(mode)) {
+      console.error(`Invalid mode: ${mode}. Must be 'copy', 'symlink', or 'none'.`);
+      process.exit(1);
+    }
+    await spawn(branch, {
+      new: options.new,
+      path: options.path,
+      base: options.base,
+      mode,
+      run: options.run,
+      agent: options.agent,
+    });
+  });
+
+// cry list
+program
+  .command('list')
+  .alias('ls')
+  .description('List all worktrees with their status')
+  .option('-j, --json', 'Output as JSON')
+  .action(async (options) => {
+    await list({ json: options.json });
+  });
+
+// cry open <branch-or-path>
+program
+  .command('open <branch-or-path>')
+  .description('Open or navigate to a worktree by branch name or path')
+  .option('-c, --cmd <cmd>', 'Command to execute in the worktree directory')
+  .action(async (branchOrPath: string, options) => {
+    await open(branchOrPath, { cmd: options.cmd });
+  });
+
+// cry rm <branch-or-path>
+program
+  .command('rm <branch-or-path>')
+  .alias('remove')
+  .description('Remove a worktree safely')
+  .option('-b, --with-branch', 'Also delete the branch')
+  .option('-f, --force', 'Force removal even if dirty')
+  .option('-y, --yes', 'Skip confirmation prompts')
+  .action(async (branchOrPath: string, options) => {
+    await rm(branchOrPath, {
+      withBranch: options.withBranch,
+      force: options.force,
+      yes: options.yes,
+    });
+  });
+
+// cry prune
+program
+  .command('prune')
+  .description('Clean up stale worktree references')
+  .action(async () => {
+    await prune();
+  });
+
+// cry doctor
+program
+  .command('doctor')
+  .description('Check and diagnose cry configuration and setup')
+  .action(async () => {
+    await doctor();
+  });
+
+// Parse and execute
+program.parse();

package/src/lib/config.ts

@@ -0,0 +1,120 @@
+/**
+ * Configuration management for VWT
+ */
+
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import type { MergedConfig, VwtConfig, VwtLocalConfig } from './types.js';
+
+export const CONFIG_FILE = '.vwt.json';
+export const LOCAL_CONFIG_FILE = '.vwt.local.json';
+export const WORKTREE_INCLUDE_FILE = '.worktreeinclude';
+
+const DEFAULT_CONFIG: VwtConfig = {
+  defaultMode: 'copy',
+  include: ['.env', '.env.*', '.env.local'],
+  hooks: {
+    postCreate: [],
+  },
+  agentCommand: 'claude',
+};
+
+/**
+ * Load the main config file
+ */
+export function loadConfig(repoRoot: string): VwtConfig | null {
+  const configPath = path.join(repoRoot, CONFIG_FILE);
+  if (!existsSync(configPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(configPath, 'utf-8');
+    return JSON.parse(content) as VwtConfig;
+  } catch (error) {
+    throw new Error(`Failed to parse ${CONFIG_FILE}: ${(error as Error).message}`);
+  }
+}
+
+/**
+ * Load the local config file
+ */
+export function loadLocalConfig(repoRoot: string): VwtLocalConfig | null {
+  const configPath = path.join(repoRoot, LOCAL_CONFIG_FILE);
+  if (!existsSync(configPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(configPath, 'utf-8');
+    return JSON.parse(content) as VwtLocalConfig;
+  } catch (error) {
+    throw new Error(`Failed to parse ${LOCAL_CONFIG_FILE}: ${(error as Error).message}`);
+  }
+}
+
+/**
+ * Merge main config with local overrides
+ */
+export function mergeConfig(config: VwtConfig | null, localConfig: VwtLocalConfig | null): MergedConfig {
+  const base = config ?? DEFAULT_CONFIG;
+
+  return {
+    worktreeBaseDir: localConfig?.worktreeBaseDir ?? base.worktreeBaseDir,
+    defaultMode: base.defaultMode,
+    include: [...(base.include ?? []), ...(localConfig?.include ?? [])],
+    hooks: {
+      postCreate: [
+        ...(base.hooks?.postCreate ?? []),
+        ...(localConfig?.hooks?.postCreate ?? []),
+      ],
+    },
+    agentCommand: localConfig?.agentCommand ?? base.agentCommand ?? 'claude',
+  };
+}
+
+/**
+ * Get merged configuration
+ */
+export function getMergedConfig(repoRoot: string): MergedConfig {
+  const config = loadConfig(repoRoot);
+  const localConfig = loadLocalConfig(repoRoot);
+  return mergeConfig(config, localConfig);
+}
+
+/**
+ * Save the main config file
+ */
+export function saveConfig(repoRoot: string, config: VwtConfig): void {
+  const configPath = path.join(repoRoot, CONFIG_FILE);
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+}
+
+/**
+ * Save the local config file
+ */
+export function saveLocalConfig(repoRoot: string, config: VwtLocalConfig): void {
+  const configPath = path.join(repoRoot, LOCAL_CONFIG_FILE);
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+}
+
+/**
+ * Check if config exists
+ */
+export function configExists(repoRoot: string): boolean {
+  return existsSync(path.join(repoRoot, CONFIG_FILE));
+}
+
+/**
+ * Get default config
+ */
+export function getDefaultConfig(): VwtConfig {
+  return { ...DEFAULT_CONFIG };
+}
+
+/**
+ * Create default local config
+ */
+export function getDefaultLocalConfig(): VwtLocalConfig {
+  return {
+    include: [],
+  };
+}

package/src/lib/git.ts

@@ -0,0 +1,243 @@
+/**
+ * Git operations for VWT
+ */
+
+import { execSync, spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import type { WorktreeInfo } from './types.js';
+
+/**
+ * Execute a git command and return stdout
+ */
+export function git(args: string[], cwd?: string): string {
+  const options = cwd ? { cwd, encoding: 'utf-8' as const } : { encoding: 'utf-8' as const };
+  try {
+    return execSync(`git ${args.join(' ')}`, { ...options, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+  } catch (error: unknown) {
+    const execError = error as { stderr?: Buffer; message?: string };
+    const stderr = execError.stderr?.toString?.() || execError.message || 'Unknown git error';
+    throw new Error(stderr.trim());
+  }
+}
+
+/**
+ * Check if we're in a git repository
+ */
+export function isGitRepo(cwd?: string): boolean {
+  try {
+    git(['rev-parse', '--git-dir'], cwd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get the root directory of the git repository
+ */
+export function getRepoRoot(cwd?: string): string {
+  return git(['rev-parse', '--show-toplevel'], cwd);
+}
+
+/**
+ * Get the repository name from the root path
+ */
+export function getRepoName(cwd?: string): string {
+  const root = getRepoRoot(cwd);
+  return path.basename(root);
+}
+
+/**
+ * Check if a branch exists
+ */
+export function branchExists(branch: string, cwd?: string): boolean {
+  try {
+    git(['rev-parse', '--verify', `refs/heads/${branch}`], cwd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get the current branch name
+ */
+export function getCurrentBranch(cwd?: string): string | null {
+  try {
+    return git(['rev-parse', '--abbrev-ref', 'HEAD'], cwd);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if a file is tracked by git
+ */
+export function isTracked(filePath: string, cwd?: string): boolean {
+  try {
+    git(['ls-files', '--error-unmatch', filePath], cwd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if a file is ignored by git
+ */
+export function isIgnored(filePath: string, cwd?: string): boolean {
+  try {
+    git(['check-ignore', '-q', filePath], cwd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * List all worktrees using porcelain format
+ */
+export function listWorktrees(cwd?: string): WorktreeInfo[] {
+  const output = git(['worktree', 'list', '--porcelain'], cwd);
+  const worktrees: WorktreeInfo[] = [];
+  let current: Partial<WorktreeInfo> = {};
+
+  for (const line of output.split('\n')) {
+    if (line === '') {
+      if (current.worktree) {
+        worktrees.push(current as WorktreeInfo);
+      }
+      current = {};
+      continue;
+    }
+
+    if (line.startsWith('worktree ')) {
+      current.worktree = line.substring(9);
+    } else if (line.startsWith('HEAD ')) {
+      current.head = line.substring(5);
+    } else if (line.startsWith('branch ')) {
+      current.branch = line.substring(7).replace('refs/heads/', '');
+    } else if (line === 'bare') {
+      current.bare = true;
+    } else if (line === 'detached') {
+      current.detached = true;
+    }
+  }
+
+  // Don't forget the last entry
+  if (current.worktree) {
+    worktrees.push(current as WorktreeInfo);
+  }
+
+  return worktrees;
+}
+
+/**
+ * Add a worktree
+ */
+export function addWorktree(
+  targetPath: string,
+  branch: string,
+  createBranch: boolean,
+  cwd?: string
+): void {
+  const args = ['worktree', 'add'];
+  if (createBranch) {
+    args.push('-b', branch);
+  }
+  args.push(targetPath);
+  if (!createBranch) {
+    args.push(branch);
+  }
+  git(args, cwd);
+}
+
+/**
+ * Remove a worktree
+ */
+export function removeWorktree(worktreePath: string, force: boolean, cwd?: string): void {
+  const args = ['worktree', 'remove'];
+  if (force) {
+    args.push('--force');
+  }
+  args.push(worktreePath);
+  git(args, cwd);
+}
+
+/**
+ * Prune worktrees
+ */
+export function pruneWorktrees(cwd?: string): string {
+  return git(['worktree', 'prune', '--verbose'], cwd);
+}
+
+/**
+ * Delete a branch
+ */
+export function deleteBranch(branch: string, force: boolean, cwd?: string): void {
+  const flag = force ? '-D' : '-d';
+  git(['branch', flag, branch], cwd);
+}
+
+/**
+ * Check if a worktree is dirty (has uncommitted changes)
+ */
+export function isWorktreeDirty(worktreePath: string): boolean {
+  try {
+    const status = git(['status', '--porcelain'], worktreePath);
+    return status.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get short HEAD SHA for a worktree
+ */
+export function getShortHead(worktreePath: string): string {
+  try {
+    return git(['rev-parse', '--short', 'HEAD'], worktreePath);
+  } catch {
+    return 'unknown';
+  }
+}
+
+/**
+ * Run a command in a directory
+ */
+export function runCommand(command: string, cwd: string): Promise<number> {
+  return new Promise((resolve) => {
+    const isWindows = process.platform === 'win32';
+    const shell = isWindows ? 'cmd.exe' : '/bin/sh';
+    const shellArgs = isWindows ? ['/c', command] : ['-c', command];
+
+    const child = spawn(shell, shellArgs, {
+      cwd,
+      stdio: 'inherit',
+      env: process.env,
+    });
+
+    child.on('close', (code) => {
+      resolve(code ?? 1);
+    });
+
+    child.on('error', () => {
+      resolve(1);
+    });
+  });
+}
+
+/**
+ * Check if a command exists
+ */
+export function commandExists(cmd: string): boolean {
+  try {
+    const isWindows = process.platform === 'win32';
+    const checkCmd = isWindows ? `where ${cmd}` : `which ${cmd}`;
+    execSync(checkCmd, { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}