@jhorst11/wt 1.0.0

package/src/git.js

@@ -0,0 +1,351 @@
+import { simpleGit } from 'simple-git';
+import { homedir } from 'os';
+import { join, basename, relative } from 'path';
+import { existsSync, mkdirSync, readdirSync, statSync } from 'fs';
+
+// Configuration - can be overridden via environment variables
+const config = {
+  projectsDir: process.env.W_PROJECTS_DIR || join(homedir(), 'projects'),
+  worktreesDir: process.env.W_WORKTREES_DIR || join(homedir(), 'projects', 'worktrees'),
+  branchPrefix: process.env.W_DEFAULT_BRANCH_PREFIX || '',
+};
+
+export function getConfig() {
+  return { ...config };
+}
+
+export async function getGit(cwd = process.cwd()) {
+  return simpleGit(cwd);
+}
+
+export async function isGitRepo(cwd = process.cwd()) {
+  try {
+    const git = await getGit(cwd);
+    await git.revparse(['--git-dir']);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function getRepoRoot(cwd = process.cwd()) {
+  try {
+    const git = await getGit(cwd);
+    const root = await git.revparse(['--show-toplevel']);
+    return root.trim();
+  } catch {
+    return null;
+  }
+}
+
+export async function getCurrentBranch(cwd = process.cwd()) {
+  try {
+    const git = await getGit(cwd);
+    const branch = await git.revparse(['--abbrev-ref', 'HEAD']);
+    return branch.trim();
+  } catch {
+    return null;
+  }
+}
+
+export async function getLocalBranches(cwd = process.cwd()) {
+  try {
+    const git = await getGit(cwd);
+    const result = await git.branchLocal();
+    return result.all.map((name) => ({
+      name,
+      isCurrent: name === result.current,
+    }));
+  } catch {
+    return [];
+  }
+}
+
+export async function getRemoteBranches(cwd = process.cwd()) {
+  try {
+    const git = await getGit(cwd);
+    // Fetch latest from remote first
+    await git.fetch(['--all', '--prune']).catch(() => {});
+    const result = await git.branch(['-r']);
+    return result.all
+      .filter((name) => !name.includes('HEAD'))
+      .map((name) => ({
+        name: name.replace(/^origin\//, ''),
+        fullName: name,
+        isRemote: true,
+      }));
+  } catch {
+    return [];
+  }
+}
+
+export async function getAllBranches(cwd = process.cwd()) {
+  const [local, remote] = await Promise.all([
+    getLocalBranches(cwd),
+    getRemoteBranches(cwd),
+  ]);
+
+  // Merge and dedupe, preferring local branches
+  const localNames = new Set(local.map((b) => b.name));
+  const uniqueRemote = remote.filter((b) => !localNames.has(b.name));
+
+  return {
+    local,
+    remote: uniqueRemote,
+    all: [...local.map((b) => ({ ...b, type: 'local' })), ...uniqueRemote.map((b) => ({ ...b, type: 'remote' }))],
+  };
+}
+
+export function getWorktreesBase(repoRoot) {
+  const projectsDir = config.projectsDir.replace(/\/$/, '');
+  let repoRel;
+
+  if (repoRoot.startsWith(projectsDir + '/')) {
+    repoRel = repoRoot.slice(projectsDir.length + 1);
+  } else {
+    repoRel = basename(repoRoot);
+  }
+
+  return join(config.worktreesDir, repoRel);
+}
+
+export async function getWorktrees(cwd = process.cwd()) {
+  try {
+    const git = await getGit(cwd);
+    const result = await git.raw(['worktree', 'list', '--porcelain']);
+    const worktrees = [];
+    let current = {};
+
+    for (const line of result.split('\n')) {
+      if (line.startsWith('worktree ')) {
+        if (current.path) worktrees.push(current);
+        current = { path: line.slice(9) };
+      } else if (line.startsWith('branch ')) {
+        current.branch = line.slice(7).replace('refs/heads/', '');
+      } else if (line === 'bare') {
+        current.bare = true;
+      } else if (line === 'detached') {
+        current.detached = true;
+      }
+    }
+    if (current.path) worktrees.push(current);
+
+    // Add name (last part of path) and identify main vs worktrees
+    return worktrees.map((wt, index) => ({
+      ...wt,
+      name: basename(wt.path),
+      isMain: index === 0,
+    }));
+  } catch {
+    return [];
+  }
+}
+
+export async function getWorktreesInBase(repoRoot) {
+  const base = getWorktreesBase(repoRoot);
+  if (!existsSync(base)) return [];
+
+  try {
+    const entries = readdirSync(base);
+    const worktrees = [];
+
+    for (const entry of entries) {
+      const entryPath = join(base, entry);
+      if (statSync(entryPath).isDirectory()) {
+        // Check if it's a valid git worktree
+        const gitFile = join(entryPath, '.git');
+        if (existsSync(gitFile)) {
+          const branch = await getCurrentBranch(entryPath);
+          worktrees.push({
+            name: entry,
+            path: entryPath,
+            branch: branch || 'unknown',
+          });
+        }
+      }
+    }
+
+    return worktrees;
+  } catch {
+    return [];
+  }
+}
+
+export async function getMainRepoPath(cwd = process.cwd()) {
+  try {
+    const git = await getGit(cwd);
+    const result = await git.raw(['worktree', 'list', '--porcelain']);
+    const firstLine = result.split('\n').find((l) => l.startsWith('worktree '));
+    return firstLine ? firstLine.slice(9) : null;
+  } catch {
+    return null;
+  }
+}
+
+export function buildBranchName(leaf, prefix = config.branchPrefix) {
+  const cleanLeaf = leaf.replace(/^\//, '').replace(/ /g, '-');
+  if (prefix) {
+    return `${prefix.replace(/\/$/, '')}/${cleanLeaf}`;
+  }
+  return cleanLeaf;
+}
+
+export async function branchExistsLocal(branchName, cwd = process.cwd()) {
+  try {
+    const git = await getGit(cwd);
+    await git.raw(['show-ref', '--verify', '--quiet', `refs/heads/${branchName}`]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function branchExistsRemote(branchName, cwd = process.cwd()) {
+  try {
+    const git = await getGit(cwd);
+    const result = await git.raw(['ls-remote', '--exit-code', '--heads', 'origin', branchName]);
+    return result.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+export async function ensureBranch(branchName, baseBranch = null, cwd = process.cwd()) {
+  const git = await getGit(cwd);
+
+  // Check if branch exists locally
+  if (await branchExistsLocal(branchName, cwd)) {
+    return { created: false, source: 'local' };
+  }
+
+  // Check if branch exists on remote
+  if (await branchExistsRemote(branchName, cwd)) {
+    await git.fetch(['origin', `${branchName}:${branchName}`]);
+    return { created: false, source: 'remote' };
+  }
+
+  // Create new branch from base
+  if (baseBranch) {
+    // If baseBranch is remote, make sure we have it locally
+    if (baseBranch.startsWith('origin/')) {
+      const localName = baseBranch.replace('origin/', '');
+      await git.fetch(['origin', localName]).catch(() => {});
+    }
+    await git.branch([branchName, baseBranch]);
+  } else {
+    await git.branch([branchName]);
+  }
+
+  return { created: true, source: 'new' };
+}
+
+export async function createWorktree(name, branchName, baseBranch = null, cwd = process.cwd()) {
+  const git = await getGit(cwd);
+  const repoRoot = await getRepoRoot(cwd);
+  const worktreesBase = getWorktreesBase(repoRoot);
+
+  // Ensure worktrees directory exists
+  if (!existsSync(worktreesBase)) {
+    mkdirSync(worktreesBase, { recursive: true });
+  }
+
+  const worktreePath = join(worktreesBase, name);
+
+  // Check if worktree already exists
+  if (existsSync(worktreePath)) {
+    return { success: false, error: 'Worktree directory already exists', path: worktreePath };
+  }
+
+  // Fetch all remotes
+  await git.fetch(['--all', '--prune']).catch(() => {});
+
+  // Ensure branch exists
+  const branchResult = await ensureBranch(branchName, baseBranch, cwd);
+
+  // Create worktree
+  await git.raw(['worktree', 'add', worktreePath, branchName]);
+
+  return {
+    success: true,
+    path: worktreePath,
+    branch: branchName,
+    branchCreated: branchResult.created,
+    branchSource: branchResult.source,
+  };
+}
+
+export async function removeWorktree(path, force = false, cwd = process.cwd()) {
+  const git = await getGit(cwd);
+  const args = ['worktree', 'remove'];
+  if (force) args.push('--force');
+  args.push(path);
+
+  await git.raw(args);
+  return { success: true };
+}
+
+export async function pruneWorktrees(cwd = process.cwd()) {
+  const git = await getGit(cwd);
+  await git.raw(['worktree', 'prune']);
+  return { success: true };
+}
+
+export function isValidBranchName(name) {
+  // Basic validation - git allows most characters but not some special ones
+  if (!name || name.length === 0) return false;
+  if (name.startsWith('-') || name.startsWith('.')) return false;
+  if (name.endsWith('/') || name.endsWith('.')) return false;
+  if (name.includes('..') || name.includes('//')) return false;
+  if (/[\s~^:?*\[\]\\]/.test(name)) return false;
+  return true;
+}
+
+export async function mergeBranch(sourceBranch, targetBranch = null, cwd = process.cwd()) {
+  const git = await getGit(cwd);
+
+  // If target specified, checkout to it first
+  if (targetBranch) {
+    await git.checkout(targetBranch);
+  }
+
+  // Merge the source branch
+  const result = await git.merge([sourceBranch, '--no-edit']);
+
+  return {
+    success: true,
+    merged: sourceBranch,
+    into: targetBranch || await getCurrentBranch(cwd),
+    result,
+  };
+}
+
+export async function getMainBranch(cwd = process.cwd()) {
+  const git = await getGit(cwd);
+
+  // Try common main branch names
+  const candidates = ['main', 'master', 'develop'];
+  const branches = await getLocalBranches(cwd);
+  const branchNames = branches.map(b => b.name);
+
+  for (const candidate of candidates) {
+    if (branchNames.includes(candidate)) {
+      return candidate;
+    }
+  }
+
+  // Fall back to first branch
+  return branchNames[0] || 'main';
+}
+
+export async function hasUncommittedChanges(cwd = process.cwd()) {
+  const git = await getGit(cwd);
+  const status = await git.status();
+  return !status.isClean();
+}
+
+export async function deleteBranch(branchName, force = false, cwd = process.cwd()) {
+  const git = await getGit(cwd);
+  const flag = force ? '-D' : '-d';
+  await git.branch([flag, branchName]);
+  return { success: true };
+}

package/src/setup.js

@@ -0,0 +1,256 @@
+import { select, confirm } from '@inquirer/prompts';
+import { homedir } from 'os';
+import { existsSync, readFileSync, appendFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import {
+  showMiniLogo,
+  success,
+  error,
+  warning,
+  info,
+  heading,
+  spacer,
+  colors,
+  icons,
+  divider,
+} from './ui.js';
+
+// Shell detection
+export function detectShell() {
+  const shell = process.env.SHELL || '';
+
+  if (shell.includes('zsh')) return 'zsh';
+  if (shell.includes('bash')) return 'bash';
+  if (shell.includes('fish')) return 'fish';
+  if (process.env.FISH_VERSION) return 'fish';
+  if (process.env.ZSH_VERSION) return 'zsh';
+  if (process.env.BASH_VERSION) return 'bash';
+
+  return 'unknown';
+}
+
+export function getShellConfig() {
+  const shell = detectShell();
+  const home = homedir();
+
+  const configs = {
+    zsh: {
+      name: 'Zsh',
+      rcFile: join(home, '.zshrc'),
+      wrapper: `
+# wt-cli: Git worktree manager shell integration
+wt() {
+  local wt_cd_file="/tmp/wt_cd_$$"
+  rm -f "$wt_cd_file"
+  WT_WRAPPER=1 WT_CD_FILE="$wt_cd_file" command wt "$@"
+  local exit_code=$?
+  if [[ -f "$wt_cd_file" ]]; then
+    local dir=$(cat "$wt_cd_file")
+    rm -f "$wt_cd_file"
+    [[ -d "$dir" ]] && cd "$dir"
+  fi
+  return $exit_code
+}`,
+    },
+    bash: {
+      name: 'Bash',
+      rcFile: join(home, '.bashrc'),
+      wrapper: `
+# wt-cli: Git worktree manager shell integration
+wt() {
+  local wt_cd_file="/tmp/wt_cd_$$"
+  rm -f "$wt_cd_file"
+  WT_WRAPPER=1 WT_CD_FILE="$wt_cd_file" command wt "$@"
+  local exit_code=$?
+  if [[ -f "$wt_cd_file" ]]; then
+    local dir=$(cat "$wt_cd_file")
+    rm -f "$wt_cd_file"
+    [[ -d "$dir" ]] && cd "$dir"
+  fi
+  return $exit_code
+}`,
+    },
+    fish: {
+      name: 'Fish',
+      rcFile: join(home, '.config/fish/config.fish'),
+      wrapper: `
+# wt-cli: Git worktree manager shell integration
+function wt
+  set -l wt_cd_file "/tmp/wt_cd_fish_$fish_pid"
+  rm -f "$wt_cd_file"
+  env WT_WRAPPER=1 WT_CD_FILE="$wt_cd_file" command wt $argv
+  set -l exit_code $status
+  if test -f "$wt_cd_file"
+    set -l dir (cat "$wt_cd_file")
+    rm -f "$wt_cd_file"
+    test -d "$dir"; and cd "$dir"
+  end
+  return $exit_code
+end`,
+    },
+  };
+
+  return configs[shell] || null;
+}
+
+export function isWrapperInstalled() {
+  // Check if we're running through the wrapper
+  // The wrapper would need to set this env var
+  return process.env.WT_WRAPPER === '1';
+}
+
+export function checkWrapperInRcFile() {
+  const config = getShellConfig();
+  if (!config) return { installed: false, reason: 'unknown-shell' };
+
+  if (!existsSync(config.rcFile)) {
+    return { installed: false, reason: 'no-rc-file', rcFile: config.rcFile };
+  }
+
+  try {
+    const content = readFileSync(config.rcFile, 'utf-8');
+    if (content.includes('wt-cli') || content.includes('__WT_CD__')) {
+      return { installed: true, rcFile: config.rcFile };
+    }
+    return { installed: false, reason: 'not-configured', rcFile: config.rcFile };
+  } catch {
+    return { installed: false, reason: 'read-error', rcFile: config.rcFile };
+  }
+}
+
+export async function setupCommand() {
+  showMiniLogo();
+  heading(`${icons.sparkles} Shell Setup`);
+
+  const shell = detectShell();
+  const config = getShellConfig();
+
+  if (shell === 'unknown' || !config) {
+    warning(`Could not detect your shell type`);
+    info(`SHELL environment variable: ${process.env.SHELL || 'not set'}`);
+    spacer();
+    console.log(`  ${colors.muted('Please manually add the shell wrapper to your shell config.')}`);
+    console.log(`  ${colors.muted('See:')} ${colors.path('https://github.com/your-repo/wt#shell-integration')}`);
+    spacer();
+    return;
+  }
+
+  success(`Detected shell: ${colors.primary(config.name)}`);
+  info(`Config file: ${colors.path(config.rcFile)}`);
+  spacer();
+
+  const status = checkWrapperInRcFile();
+
+  if (status.installed) {
+    success(`Shell integration is already installed! ${icons.check}`);
+    spacer();
+    info(`If directory jumping isn't working, try restarting your terminal`);
+    info(`or run: ${colors.primary(`source ${config.rcFile}`)}`);
+    spacer();
+    return;
+  }
+
+  // Not installed - offer to install
+  divider();
+  spacer();
+
+  console.log(`  ${colors.muted('To enable directory jumping (wt go, wt home), we need to')}`);
+  console.log(`  ${colors.muted('add a small shell function to your')} ${colors.path(config.rcFile)}`);
+  spacer();
+
+  const action = await select({
+    message: 'How would you like to proceed?',
+    choices: [
+      {
+        name: `${icons.sparkles}  Auto-install (append to ${config.rcFile})`,
+        value: 'auto',
+        description: 'Recommended - automatically adds the integration',
+      },
+      {
+        name: `${icons.info}  Show me the code to copy`,
+        value: 'show',
+        description: 'Display the code so you can add it manually',
+      },
+      {
+        name: `${colors.muted(icons.cross + '  Skip for now')}`,
+        value: 'skip',
+      },
+    ],
+    theme: { prefix: icons.tree },
+  });
+
+  if (action === 'auto') {
+    await autoInstall(config);
+  } else if (action === 'show') {
+    showManualInstructions(config);
+  } else {
+    info('Skipped. You can run `wt setup` anytime to configure shell integration.');
+    spacer();
+  }
+}
+
+async function autoInstall(config) {
+  spacer();
+
+  try {
+    appendFileSync(config.rcFile, '\n' + config.wrapper + '\n');
+    success(`Added shell integration to ${colors.path(config.rcFile)}`);
+    spacer();
+
+    console.log(`  ${icons.rocket} ${colors.primary('Almost done!')} Run this to activate:`);
+    spacer();
+    console.log(`     ${colors.secondary(`source ${config.rcFile}`)}`);
+    spacer();
+    console.log(`  ${colors.muted('Or just restart your terminal.')}`);
+    spacer();
+  } catch (err) {
+    error(`Failed to write to ${config.rcFile}`);
+    error(err.message);
+    spacer();
+    showManualInstructions(config);
+  }
+}
+
+function showManualInstructions(config) {
+  spacer();
+  console.log(`  ${colors.muted('Add this to')} ${colors.path(config.rcFile)}${colors.muted(':')}`);
+  spacer();
+  divider();
+  console.log(colors.secondary(config.wrapper));
+  divider();
+  spacer();
+  console.log(`  ${colors.muted('Then run:')} ${colors.primary(`source ${config.rcFile}`)}`);
+  spacer();
+}
+
+// Helper to show a gentle nudge if wrapper isn't set up
+export function showCdHint(path) {
+  // Check if we're running through the shell wrapper with a cd file
+  const cdFile = process.env.WT_CD_FILE;
+  if (cdFile && isWrapperInstalled()) {
+    // Write path to temp file for shell wrapper to read
+    try {
+      writeFileSync(cdFile, path);
+    } catch {
+      // Fall through to show manual instructions
+    }
+    return;
+  }
+
+  // Fall back to checking rc file
+  const status = checkWrapperInRcFile();
+
+  if (status.installed) {
+    // Wrapper is in rc file but not active - show path
+    spacer();
+    console.log(`  ${icons.rocket} ${colors.muted('Switching to:')} ${colors.path(path)}`);
+    spacer();
+  } else {
+    // No wrapper - show a friendly message instead
+    spacer();
+    console.log(`  ${icons.rocket} ${colors.muted('Run:')} ${colors.primary(`cd "${path}"`)}`);
+    spacer();
+    console.log(`  ${colors.muted(`Tip: Run`)} ${colors.secondary('wt setup')} ${colors.muted('to enable auto-navigation')}`);
+    spacer();
+  }
+}