cluttry 1.0.0

package/src/commands/doctor.ts

@@ -0,0 +1,222 @@
+/**
+ * cry doctor command
+ *
+ * Check and diagnose cry configuration and setup.
+ */
+
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import {
+  isGitRepo,
+  getRepoRoot,
+  isTracked,
+  isIgnored,
+  commandExists,
+} from '../lib/git.js';
+import {
+  CONFIG_FILE,
+  LOCAL_CONFIG_FILE,
+  configExists,
+  loadConfig,
+  loadLocalConfig,
+  getMergedConfig,
+} from '../lib/config.js';
+import { expandIncludePatterns, checkFileSafety } from '../lib/secrets.js';
+import * as out from '../lib/output.js';
+
+interface CheckResult {
+  name: string;
+  status: 'pass' | 'warn' | 'fail';
+  message: string;
+}
+
+export async function doctor(): 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 checks: CheckResult[] = [];
+
+  out.header('cry Doctor');
+  out.log('Checking your cry configuration...');
+  out.newline();
+
+  // Check 1: Config file exists
+  if (configExists(repoRoot)) {
+    checks.push({
+      name: 'Config file',
+      status: 'pass',
+      message: `${CONFIG_FILE} exists`,
+    });
+  } else {
+    checks.push({
+      name: 'Config file',
+      status: 'warn',
+      message: `${CONFIG_FILE} not found. Run 'cry init' to create one.`,
+    });
+  }
+
+  // Check 2: Local config is gitignored
+  const localConfigPath = path.join(repoRoot, LOCAL_CONFIG_FILE);
+  if (existsSync(localConfigPath)) {
+    if (isIgnored(LOCAL_CONFIG_FILE, repoRoot)) {
+      checks.push({
+        name: 'Local config ignored',
+        status: 'pass',
+        message: `${LOCAL_CONFIG_FILE} is properly gitignored`,
+      });
+    } else if (isTracked(LOCAL_CONFIG_FILE, repoRoot)) {
+      checks.push({
+        name: 'Local config ignored',
+        status: 'fail',
+        message: `${LOCAL_CONFIG_FILE} is TRACKED by git! Remove it from tracking.`,
+      });
+    } else {
+      checks.push({
+        name: 'Local config ignored',
+        status: 'warn',
+        message: `${LOCAL_CONFIG_FILE} exists but is not in .gitignore`,
+      });
+    }
+  } else {
+    checks.push({
+      name: 'Local config',
+      status: 'pass',
+      message: `${LOCAL_CONFIG_FILE} not present (optional)`,
+    });
+  }
+
+  // Check 3: .worktrees directory is gitignored
+  const worktreesDir = '.worktrees';
+  const worktreesDirPath = path.join(repoRoot, worktreesDir);
+  if (existsSync(worktreesDirPath)) {
+    if (isIgnored(worktreesDir, repoRoot) || isIgnored(worktreesDir + '/', repoRoot)) {
+      checks.push({
+        name: 'Worktrees dir ignored',
+        status: 'pass',
+        message: `${worktreesDir}/ is properly gitignored`,
+      });
+    } else {
+      checks.push({
+        name: 'Worktrees dir ignored',
+        status: 'fail',
+        message: `${worktreesDir}/ is NOT gitignored! Add it to .gitignore.`,
+      });
+    }
+  } else {
+    if (isIgnored(worktreesDir, repoRoot) || isIgnored(worktreesDir + '/', repoRoot)) {
+      checks.push({
+        name: 'Worktrees dir ignored',
+        status: 'pass',
+        message: `${worktreesDir}/ will be gitignored when created`,
+      });
+    } else {
+      checks.push({
+        name: 'Worktrees dir ignored',
+        status: 'warn',
+        message: `${worktreesDir}/ not in .gitignore (add it before spawning)`,
+      });
+    }
+  }
+
+  // Check 4: Include files are safe
+  if (configExists(repoRoot)) {
+    const config = getMergedConfig(repoRoot);
+    const files = await expandIncludePatterns(config.include, repoRoot);
+
+    let allSafe = true;
+    const problems: string[] = [];
+
+    for (const file of files) {
+      const result = checkFileSafety(file, repoRoot);
+      if (!result.safe && result.exists) {
+        allSafe = false;
+        problems.push(`${file}: ${result.reason}`);
+      }
+    }
+
+    if (files.length === 0) {
+      checks.push({
+        name: 'Include patterns',
+        status: 'pass',
+        message: 'No files matched include patterns (this is fine)',
+      });
+    } else if (allSafe) {
+      checks.push({
+        name: 'Include files safety',
+        status: 'pass',
+        message: `All ${files.length} matched file(s) are safely gitignored`,
+      });
+    } else {
+      checks.push({
+        name: 'Include files safety',
+        status: 'fail',
+        message: `Some include files are NOT safe:\n      ${problems.join('\n      ')}`,
+      });
+    }
+  }
+
+  // Check 5: Agent command exists
+  if (configExists(repoRoot)) {
+    const config = getMergedConfig(repoRoot);
+    const agentCmd = config.agentCommand;
+
+    if (commandExists(agentCmd)) {
+      checks.push({
+        name: 'Agent command',
+        status: 'pass',
+        message: `'${agentCmd}' is available`,
+      });
+    } else {
+      checks.push({
+        name: 'Agent command',
+        status: 'warn',
+        message: `'${agentCmd}' not found (optional, but --agent won't work)`,
+      });
+    }
+  }
+
+  // Print results
+  let hasFailures = false;
+  let hasWarnings = false;
+
+  for (const check of checks) {
+    let icon: string;
+    let colorFn: (s: string) => string;
+
+    switch (check.status) {
+      case 'pass':
+        icon = '✓';
+        colorFn = out.fmt.green;
+        break;
+      case 'warn':
+        icon = '⚠';
+        colorFn = out.fmt.yellow;
+        hasWarnings = true;
+        break;
+      case 'fail':
+        icon = '✗';
+        colorFn = out.fmt.red;
+        hasFailures = true;
+        break;
+    }
+
+    out.log(`${colorFn(icon)} ${out.fmt.bold(check.name)}`);
+    out.log(`  ${check.message}`);
+    out.newline();
+  }
+
+  // Summary
+  out.log('─'.repeat(50));
+  if (hasFailures) {
+    out.error('Some checks failed. Please fix the issues above.');
+    process.exit(1);
+  } else if (hasWarnings) {
+    out.warn('Some warnings detected. Consider addressing them.');
+  } else {
+    out.success('All checks passed!');
+  }
+}

package/src/commands/init.ts

@@ -0,0 +1,120 @@
+/**
+ * cry init command
+ *
+ * Create or update repo-level config files for cry.
+ */
+
+import { existsSync, readFileSync, writeFileSync, appendFileSync } from 'node:fs';
+import path from 'node:path';
+import { isGitRepo, getRepoRoot } from '../lib/git.js';
+import {
+  CONFIG_FILE,
+  LOCAL_CONFIG_FILE,
+  configExists,
+  getDefaultConfig,
+  getDefaultLocalConfig,
+  saveConfig,
+  saveLocalConfig,
+  loadConfig,
+} from '../lib/config.js';
+import * as out from '../lib/output.js';
+
+interface InitOptions {
+  force?: boolean;
+}
+
+/**
+ * Ensure entries exist in .gitignore
+ */
+function ensureGitignoreEntries(repoRoot: string, entries: string[]): string[] {
+  const gitignorePath = path.join(repoRoot, '.gitignore');
+  let content = '';
+
+  if (existsSync(gitignorePath)) {
+    content = readFileSync(gitignorePath, 'utf-8');
+  }
+
+  const lines = content.split('\n').map((l) => l.trim());
+  const added: string[] = [];
+
+  for (const entry of entries) {
+    if (!lines.includes(entry)) {
+      added.push(entry);
+    }
+  }
+
+  if (added.length > 0) {
+    const suffix = content.endsWith('\n') || content === '' ? '' : '\n';
+    const header = content === '' ? '' : '\n# cry\n';
+    appendFileSync(gitignorePath, suffix + header + added.join('\n') + '\n');
+  }
+
+  return added;
+}
+
+export async function init(options: InitOptions): 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 changes: string[] = [];
+
+  // Check if config already exists
+  if (configExists(repoRoot) && !options.force) {
+    out.info(`${CONFIG_FILE} already exists. Use --force to overwrite.`);
+    const existing = loadConfig(repoRoot);
+    if (existing) {
+      out.log('\nCurrent configuration:');
+      out.log(JSON.stringify(existing, null, 2));
+    }
+    return;
+  }
+
+  // Create main config
+  const config = getDefaultConfig();
+  saveConfig(repoRoot, config);
+  changes.push(`Created ${out.fmt.path(CONFIG_FILE)}`);
+
+  // Create local config if it doesn't exist
+  const localConfigPath = path.join(repoRoot, LOCAL_CONFIG_FILE);
+  if (!existsSync(localConfigPath)) {
+    const localConfig = getDefaultLocalConfig();
+    saveLocalConfig(repoRoot, localConfig);
+    changes.push(`Created ${out.fmt.path(LOCAL_CONFIG_FILE)} (gitignored)`);
+  }
+
+  // Ensure .gitignore entries
+  const gitignoreEntries = [
+    LOCAL_CONFIG_FILE,
+    '.worktrees/',
+    '.worktreeinclude',
+  ];
+
+  const addedEntries = ensureGitignoreEntries(repoRoot, gitignoreEntries);
+  if (addedEntries.length > 0) {
+    changes.push(`Added to .gitignore: ${addedEntries.join(', ')}`);
+  }
+
+  // Output summary
+  out.header('cry Initialized');
+  out.newline();
+
+  for (const change of changes) {
+    out.success(change);
+  }
+
+  out.newline();
+  out.log('Configuration created with defaults:');
+  out.log(`  • Default mode: ${out.fmt.cyan(config.defaultMode)}`);
+  out.log(`  • Include patterns: ${config.include.map((p) => out.fmt.gray(p)).join(', ')}`);
+  out.log(`  • Agent command: ${out.fmt.cyan(config.agentCommand ?? 'claude')}`);
+
+  out.newline();
+  out.log('Next steps:');
+  out.log(`  1. Edit ${out.fmt.path(CONFIG_FILE)} to customize patterns`);
+  out.log(`  2. Run ${out.fmt.cyan('cry spawn <branch>')} to create a worktree`);
+  out.log(`  3. Run ${out.fmt.cyan('cry doctor')} to verify your setup`);
+}

package/src/commands/list.ts

@@ -0,0 +1,133 @@
+/**
+ * cry list command
+ *
+ * List all worktrees with their status.
+ */
+
+import { statSync } from 'node:fs';
+import {
+  isGitRepo,
+  getRepoRoot,
+  listWorktrees,
+  isWorktreeDirty,
+  getShortHead,
+} from '../lib/git.js';
+import * as out from '../lib/output.js';
+import type { WorktreeListItem } from '../lib/types.js';
+
+interface ListOptions {
+  json?: boolean;
+}
+
+function getLastModified(worktreePath: string): Date | null {
+  try {
+    const stats = statSync(worktreePath);
+    return stats.mtime;
+  } catch {
+    return null;
+  }
+}
+
+function formatRelativeTime(date: Date | null): string {
+  if (!date) return 'unknown';
+
+  const now = new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffMins = Math.floor(diffMs / 60000);
+  const diffHours = Math.floor(diffMs / 3600000);
+  const diffDays = Math.floor(diffMs / 86400000);
+
+  if (diffMins < 1) return 'just now';
+  if (diffMins < 60) return `${diffMins}m ago`;
+  if (diffHours < 24) return `${diffHours}h ago`;
+  if (diffDays < 7) return `${diffDays}d ago`;
+  return date.toLocaleDateString();
+}
+
+export async function list(options: ListOptions): 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 worktrees = listWorktrees(repoRoot);
+
+  // Build list items with extra info
+  const items: WorktreeListItem[] = worktrees.map((wt) => ({
+    branch: wt.branch ?? (wt.detached ? '(detached)' : null),
+    path: wt.worktree,
+    headShort: getShortHead(wt.worktree),
+    dirty: isWorktreeDirty(wt.worktree),
+    lastModified: getLastModified(wt.worktree),
+  }));
+
+  // JSON output
+  if (options.json) {
+    const jsonItems = items.map((item) => ({
+      ...item,
+      lastModified: item.lastModified?.toISOString() ?? null,
+    }));
+    out.json(jsonItems);
+    return;
+  }
+
+  // No worktrees
+  if (items.length === 0) {
+    out.info('No worktrees found.');
+    return;
+  }
+
+  // Table output
+  out.header('Worktrees');
+  out.newline();
+
+  // Calculate column widths
+  const branchWidth = Math.max(
+    6,
+    ...items.map((i) => (i.branch ?? '').length)
+  );
+  const pathWidth = Math.max(4, ...items.map((i) => i.path.length));
+
+  // Header row
+  out.log(
+    '  ' +
+      out.fmt.bold('Branch'.padEnd(branchWidth)) +
+      '  ' +
+      out.fmt.bold('SHA'.padEnd(7)) +
+      '  ' +
+      out.fmt.bold('Status'.padEnd(8)) +
+      '  ' +
+      out.fmt.bold('Modified'.padEnd(12)) +
+      '  ' +
+      out.fmt.bold('Path')
+  );
+  out.log('  ' + '─'.repeat(branchWidth + 7 + 8 + 12 + pathWidth + 12));
+
+  // Data rows
+  for (const item of items) {
+    const branch = (item.branch ?? '(none)').padEnd(branchWidth);
+    const sha = item.headShort.padEnd(7);
+    const status = item.dirty
+      ? out.fmt.yellow('dirty'.padEnd(8))
+      : out.fmt.green('clean'.padEnd(8));
+    const modified = formatRelativeTime(item.lastModified).padEnd(12);
+
+    out.log(
+      '  ' +
+        out.fmt.branch(branch) +
+        '  ' +
+        out.fmt.dim(sha) +
+        '  ' +
+        status +
+        '  ' +
+        out.fmt.dim(modified) +
+        '  ' +
+        out.fmt.path(item.path)
+    );
+  }
+
+  out.newline();
+  out.log(`  ${out.fmt.dim(`${items.length} worktree(s)`)}`);
+}

package/src/commands/open.ts

@@ -0,0 +1,70 @@
+/**
+ * cry open command
+ *
+ * Open or navigate to a worktree by branch name or path.
+ */
+
+import {
+  isGitRepo,
+  getRepoRoot,
+  listWorktrees,
+  runCommand,
+} from '../lib/git.js';
+import { resolveBranchOrPath } from '../lib/paths.js';
+import * as out from '../lib/output.js';
+
+interface OpenOptions {
+  cmd?: string;
+}
+
+export async function open(branchOrPath: string, options: OpenOptions): 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 worktrees = listWorktrees(repoRoot);
+
+  // Build lookup list
+  const wtList = worktrees.map((wt) => ({
+    branch: wt.branch ?? null,
+    path: wt.worktree,
+  }));
+
+  // Resolve the worktree
+  const resolved = resolveBranchOrPath(branchOrPath, wtList, repoRoot);
+
+  if (!resolved) {
+    out.error(`Worktree not found: ${branchOrPath}`);
+    out.info('Available worktrees:');
+    for (const wt of wtList) {
+      out.log(`  • ${wt.branch ?? '(detached)'} → ${wt.path}`);
+    }
+    process.exit(1);
+  }
+
+  const { path: wtPath, branch } = resolved;
+
+  // If --cmd is provided, run it
+  if (options.cmd) {
+    out.log(`Running in ${out.fmt.path(wtPath)}:`);
+    out.log(`  ${out.fmt.dim('$')} ${options.cmd}`);
+    const code = await runCommand(options.cmd, wtPath);
+    process.exit(code);
+  }
+
+  // Otherwise, print the path and helper
+  out.success(`Found worktree: ${branch ? out.fmt.branch(branch) : '(detached)'}`);
+  out.newline();
+  out.log(`Path: ${out.fmt.path(wtPath)}`);
+  out.newline();
+  out.log('To navigate there:');
+  out.log(`  ${out.fmt.cyan(`cd "${wtPath}"`)}`);
+
+  // For shell integration hint
+  out.newline();
+  out.log(out.fmt.dim('Tip: Use command substitution in your shell:'));
+  out.log(out.fmt.dim(`  cd "$(vwt open ${branchOrPath} 2>/dev/null | grep "^Path:" | cut -d' ' -f2-)"`));
+}

package/src/commands/prune.ts

@@ -0,0 +1,36 @@
+/**
+ * cry prune command
+ *
+ * Clean up stale worktree references.
+ */
+
+import { isGitRepo, getRepoRoot, pruneWorktrees } from '../lib/git.js';
+import * as out from '../lib/output.js';
+
+export async function prune(): 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();
+
+  out.log('Pruning stale worktree references...');
+  out.newline();
+
+  try {
+    const output = pruneWorktrees(repoRoot);
+
+    if (output.trim()) {
+      out.log(output);
+      out.newline();
+      out.success('Pruned stale worktree references');
+    } else {
+      out.success('No stale worktree references found');
+    }
+  } catch (error) {
+    out.error(`Failed to prune: ${(error as Error).message}`);
+    process.exit(1);
+  }
+}

package/src/commands/rm.ts

@@ -0,0 +1,125 @@
+/**
+ * cry rm command
+ *
+ * Remove a worktree safely with optional branch deletion.
+ */
+
+import { createInterface } from 'node:readline';
+import {
+  isGitRepo,
+  getRepoRoot,
+  listWorktrees,
+  removeWorktree,
+  deleteBranch,
+  isWorktreeDirty,
+  getCurrentBranch,
+} from '../lib/git.js';
+import { resolveBranchOrPath } from '../lib/paths.js';
+import * as out from '../lib/output.js';
+
+interface RmOptions {
+  withBranch?: boolean;
+  force?: boolean;
+  yes?: boolean;
+}
+
+async function confirm(message: string): Promise<boolean> {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(`${message} [y/N] `, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+    });
+  });
+}
+
+export async function rm(branchOrPath: string, options: RmOptions): 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 worktrees = listWorktrees(repoRoot);
+
+  // Build lookup list
+  const wtList = worktrees.map((wt) => ({
+    branch: wt.branch ?? null,
+    path: wt.worktree,
+  }));
+
+  // Resolve the worktree
+  const resolved = resolveBranchOrPath(branchOrPath, wtList, repoRoot);
+
+  if (!resolved) {
+    out.error(`Worktree not found: ${branchOrPath}`);
+    out.info('Available worktrees:');
+    for (const wt of wtList) {
+      out.log(`  • ${wt.branch ?? '(detached)'} → ${wt.path}`);
+    }
+    process.exit(1);
+  }
+
+  const { path: wtPath, branch } = resolved;
+
+  // Check if it's the main worktree (the original checkout)
+  if (wtPath === repoRoot) {
+    out.error('Cannot remove the main worktree.');
+    out.info('This is your primary repository checkout.');
+    process.exit(1);
+  }
+
+  // Check if dirty
+  const dirty = isWorktreeDirty(wtPath);
+  if (dirty && !options.force) {
+    out.error('Worktree has uncommitted changes.');
+    out.info('Use --force to remove anyway (changes will be lost).');
+    process.exit(1);
+  }
+
+  // Warn and confirm if dirty and force
+  if (dirty && options.force && !options.yes) {
+    out.warn('Worktree has uncommitted changes that will be lost!');
+    const confirmed = await confirm('Are you sure you want to remove it?');
+    if (!confirmed) {
+      out.log('Aborted.');
+      process.exit(0);
+    }
+  }
+
+  // Remove the worktree
+  out.log(`Removing worktree: ${out.fmt.path(wtPath)}`);
+  try {
+    removeWorktree(wtPath, options.force ?? false, repoRoot);
+    out.success('Worktree removed');
+  } catch (error) {
+    out.error(`Failed to remove worktree: ${(error as Error).message}`);
+    process.exit(1);
+  }
+
+  // Optionally delete the branch
+  if (options.withBranch && branch) {
+    const currentBranch = getCurrentBranch(repoRoot);
+
+    if (branch === currentBranch) {
+      out.warn(`Cannot delete branch '${branch}' - it's currently checked out in main worktree.`);
+    } else {
+      out.log(`Deleting branch: ${out.fmt.branch(branch)}`);
+      try {
+        deleteBranch(branch, options.force ?? false, repoRoot);
+        out.success('Branch deleted');
+      } catch (error) {
+        out.warn(`Failed to delete branch: ${(error as Error).message}`);
+        out.info('You may need to use --force or delete it manually.');
+      }
+    }
+  }
+
+  out.newline();
+  out.success('Done');
+}