@humanu/orchestra 0.5.2 → 0.5.3

package/install.js

@@ -3,86 +3,166 @@
 const { execSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
-const os = require('os');
 
-const BINARY_NAME = 'gw-tui';
+const BINARY_NAME = 'orchestra';
+const SHELL_SCRIPTS = ['gwr.sh', 'gw.sh', 'gw-bridge.sh', 'commands.sh'];
 const SUPPORTED_PLATFORMS = {
-  'darwin-x64': 'macos-x64',
+  'darwin-x64': 'macos-intel',
   'darwin-arm64': 'macos-arm64',
   'linux-x64': 'linux-x64',
   'linux-arm64': 'linux-arm64'
 };
 
-function getPlatform() {
-  const platform = `${process.platform}-${process.arch}`;
-  if (!SUPPORTED_PLATFORMS[platform]) {
-    console.error(`Unsupported platform: ${platform}`);
-    console.error('Supported platforms:', Object.keys(SUPPORTED_PLATFORMS).join(', '));
+const packageRoot = __dirname;
+const resourcesDir = path.join(packageRoot, 'resources');
+const distDir = path.join(packageRoot, 'dist');
+const scriptsDir = path.join(resourcesDir, 'scripts');
+const apiDir = path.join(resourcesDir, 'api');
+const prebuiltDir = path.join(resourcesDir, 'prebuilt');
+const projectRoot = path.resolve(packageRoot, '..', '..');
+const hasLocalSource = fs.existsSync(path.join(projectRoot, 'gw-tui'));
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+function cleanDir(dir) {
+  if (fs.existsSync(dir)) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+  ensureDir(dir);
+}
+
+function getPlatformKey() {
+  const key = `${process.platform}-${process.arch}`;
+  const mapped = SUPPORTED_PLATFORMS[key];
+  if (!mapped) {
+    console.error(`Unsupported platform: ${key}`);
+    console.error(`Supported platforms: ${Object.keys(SUPPORTED_PLATFORMS).join(', ')}`);
     process.exit(1);
   }
-  return SUPPORTED_PLATFORMS[platform];
+  return mapped;
+}
+
+function copyShellScripts() {
+  let sourceBase = scriptsDir;
+  if (!fs.existsSync(sourceBase)) {
+    if (!hasLocalSource) {
+      console.error('Shell scripts are missing from the package.');
+      process.exit(1);
+    }
+    sourceBase = projectRoot;
+  }
+
+  for (const script of SHELL_SCRIPTS) {
+    const sourcePath = path.join(sourceBase, script);
+    if (!fs.existsSync(sourcePath)) {
+      console.error(`Required script missing: ${sourcePath}`);
+      process.exit(1);
+    }
+    const destinationPath = path.join(distDir, script);
+    fs.copyFileSync(sourcePath, destinationPath);
+    fs.chmodSync(destinationPath, 0o755);
+  }
+}
+
+function copyApiScripts() {
+  let sourceBase = apiDir;
+  if (!fs.existsSync(sourceBase)) {
+    if (!hasLocalSource) {
+      console.error('API scripts are missing from the package.');
+      process.exit(1);
+    }
+    sourceBase = path.join(projectRoot, 'api');
+  }
+
+  ensureDir(path.join(distDir, 'api'));
+  const apiFiles = fs.existsSync(sourceBase) ? fs.readdirSync(sourceBase) : [];
+  for (const file of apiFiles) {
+    if (!file.endsWith('.sh')) {
+      continue;
+    }
+    const sourcePath = path.join(sourceBase, file);
+    const destinationPath = path.join(distDir, 'api', file);
+    fs.copyFileSync(sourcePath, destinationPath);
+    fs.chmodSync(destinationPath, 0o755);
+  }
+}
+
+function linkCompatibilityBinary(binaryPath) {
+  const gwTuiPath = path.join(distDir, 'gw-tui');
+  try {
+    fs.rmSync(gwTuiPath, { force: true });
+  } catch (err) {
+    if (err.code !== 'ENOENT') {
+      throw err;
+    }
+  }
+
+  try {
+    fs.symlinkSync(binaryPath, gwTuiPath);
+  } catch (err) {
+    // Fallback for filesystems that disallow symlinks
+    fs.copyFileSync(binaryPath, gwTuiPath);
+    fs.chmodSync(gwTuiPath, 0o755);
+  }
 }
 
-function downloadPrebuiltBinary() {
-  const platform = getPlatform();
-  const binaryPath = path.join(__dirname, 'dist', BINARY_NAME);
-  const prebuiltPath = path.join(__dirname, 'dist', 'prebuilt', platform, BINARY_NAME);
-  
-  // Check if prebuilt binary exists
-  if (fs.existsSync(prebuiltPath)) {
-    console.log(`Using prebuilt binary for ${platform}`);
-    fs.copyFileSync(prebuiltPath, binaryPath);
-    fs.chmodSync(binaryPath, 0o755);
-    return true;
+function installPrebuiltBinary() {
+  const platform = getPlatformKey();
+  const source = path.join(prebuiltDir, platform, BINARY_NAME);
+  if (!fs.existsSync(source)) {
+    return false;
   }
-  
-  return false;
+
+  const destination = path.join(distDir, BINARY_NAME);
+  fs.copyFileSync(source, destination);
+  fs.chmodSync(destination, 0o755);
+  linkCompatibilityBinary(destination);
+  return true;
 }
 
 function buildFromSource() {
-  console.log('Building from source...');
-  
-  // Check for Rust
+  if (!hasLocalSource) {
+    console.error('No prebuilt binary available and source tree not found.');
+    console.error('Clone the repository and run `cargo build --release` to build locally.');
+    process.exit(1);
+  }
+
   try {
     execSync('cargo --version', { stdio: 'ignore' });
   } catch (error) {
-    console.error('Rust is not installed. Please install Rust from https://rustup.rs/');
+    console.error('Rust toolchain not found. Install Rust from https://rustup.rs/.');
     process.exit(1);
   }
-  
-  // Build the Rust binary
-  try {
-    console.log('Building gw-tui...');
-    // Go up two directories to find gw-tui (npm package is in install/npm/)
-    const projectRoot = path.join(__dirname, '..', '..');
-    execSync('cd gw-tui && cargo build --release', { 
-      stdio: 'inherit',
-      cwd: projectRoot 
-    });
-    
-    // Copy the built binary to dist
-    const sourcePath = path.join(projectRoot, 'gw-tui', 'target', 'release', BINARY_NAME);
-    const destPath = path.join(__dirname, 'dist', BINARY_NAME);
-    
-    fs.copyFileSync(sourcePath, destPath);
-    fs.chmodSync(destPath, 0o755);
-    
-    console.log('Successfully built from source');
-  } catch (error) {
-    console.error('Failed to build from source:', error.message);
+
+  console.log('Building from source...');
+  execSync('cargo build --release', { stdio: 'inherit', cwd: path.join(projectRoot, 'gw-tui') });
+
+  const builtBinary = path.join(projectRoot, 'gw-tui', 'target', 'release', 'gw-tui');
+  if (!fs.existsSync(builtBinary)) {
+    console.error('Build finished but gw-tui binary was not produced.');
     process.exit(1);
   }
+
+  const destination = path.join(distDir, BINARY_NAME);
+  fs.copyFileSync(builtBinary, destination);
+  fs.chmodSync(destination, 0o755);
+  linkCompatibilityBinary(destination);
 }
 
-function setupShellWrappers() {
-  console.log('\n📝 Shell wrapper functions needed for directory switching:');
-  console.log('Add these to your ~/.bashrc or ~/.zshrc:\n');
-  
-  const installPath = __dirname;
-  
+function printShellWrapperInstructions(binaryPath) {
+  const distPathEscaped = distDir.replace(/\/g, '\\');
+  const binaryPathEscaped = binaryPath.replace(/\/g, '\\');
+
+  console.log('\n📝 Shell wrapper functions needed for directory switching:\n');
   console.log(`# GW Orchestrator shell wrappers
 gwr() {
-  local out="$(${path.join(installPath, 'dist', 'gwr.sh')} "$@")"
+  local dist_path="${distPathEscaped}"
+  local bin_path="${binaryPathEscaped}"
+  local out="$(GW_TUI_BIN="$bin_path" bash "$dist_path/gwr.sh" "$@")"
   local status=$?
   local cd_line="$(echo "$out" | grep -m1 '^cd')"
   [[ -n $cd_line ]] && eval "$cd_line"
@@ -91,65 +171,34 @@ gwr() {
 }
 
 gw() {
-  local out="$(${path.join(installPath, 'dist', 'gw.sh')} "$@")"
+  local dist_path="${distPathEscaped}"
+  local out="$(bash "$dist_path/gw.sh" "$@")"
   local status=$?
   local cd_line="$(echo "$out" | grep -m1 '^cd')"
   [[ -n $cd_line ]] && eval "$cd_line"
   echo "$out" | grep -v '^cd'
   return $status
 }`);
-  
-  console.log('\nThen run: source ~/.bashrc  (or source ~/.zshrc)');
+  console.log('\nAdd these to your ~/.bashrc or ~/.zshrc, then run: source ~/.bashrc (or source ~/.zshrc)\n');
 }
 
 function main() {
-  console.log('Installing gw-orchestrator...\n');
-  
-  // Create dist directory if it doesn't exist
-  const distDir = path.join(__dirname, 'dist');
-  if (!fs.existsSync(distDir)) {
-    fs.mkdirSync(distDir, { recursive: true });
-  }
-  
-  // Copy shell scripts to dist (from project root, since npm package is in install/npm/)
-  const projectRoot = path.join(__dirname, '..', '..');
-  const shellScripts = ['gwr.sh', 'gw.sh', 'gw-bridge.sh', 'commands.sh'];
-  const apiDir = path.join(projectRoot, 'api');
-  
-  shellScripts.forEach(script => {
-    const sourcePath = path.join(projectRoot, script);
-    const destPath = path.join(distDir, script);
-    if (fs.existsSync(sourcePath)) {
-      fs.copyFileSync(sourcePath, destPath);
-      fs.chmodSync(destPath, 0o755);
-    }
-  });
-  
-  // Copy api directory
-  const distApiDir = path.join(distDir, 'api');
-  if (!fs.existsSync(distApiDir)) {
-    fs.mkdirSync(distApiDir, { recursive: true });
-  }
-  
-  if (fs.existsSync(apiDir)) {
-    fs.readdirSync(apiDir).forEach(file => {
-      const sourcePath = path.join(apiDir, file);
-      const destPath = path.join(distApiDir, file);
-      fs.copyFileSync(sourcePath, destPath);
-      fs.chmodSync(destPath, 0o755);
-    });
-  }
-  
-  // Try to use prebuilt binary, otherwise build from source
-  if (!downloadPrebuiltBinary()) {
+  console.log('Installing Orchestra...\n');
+
+  cleanDir(distDir);
+
+  copyShellScripts();
+  copyApiScripts();
+
+  const binaryInstalled = installPrebuiltBinary();
+  if (!binaryInstalled) {
     buildFromSource();
   }
-  
+
+  const binaryPath = path.join(distDir, BINARY_NAME);
+
   console.log('\n✅ Installation complete!');
-  
-  // Setup shell wrappers
-  setupShellWrappers();
+  printShellWrapperInstructions(binaryPath);
 }
 
-// Run installation
-main();
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@humanu/orchestra",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "description": "AI-powered Git worktree and tmux session manager with modern TUI",
   "keywords": [
     "git",
@@ -26,12 +26,13 @@
   "author": "Human Unsupervised",
   "main": "install.js",
   "bin": {
-    "orchestra": "./install.js",
-    "gwr": "./install.js",
-    "gw": "./install.js"
+    "orchestra": "install.js",
+    "gwr": "install.js",
+    "gw": "install.js"
   },
   "files": [
     "bin/",
+    "resources/",
     "install.js",
     "README.md"
   ],

package/resources/api/git.sh

@@ -0,0 +1,359 @@
+#!/bin/bash
+
+###############################################################################
+# git.sh – Git Worktree API Module
+# ---------------------------------------------------------------------------
+# This module provides a centralized API for all Git operations used by
+# gw.sh, commands.sh, and gw-bridge.sh. It abstracts Git worktree management
+# and other Git operations into a clean, consistent interface.
+###############################################################################
+
+# --------------------------- Repository Information -------------------------
+
+# Get the Git repository root directory
+git_repo_root() {
+  git rev-parse --show-toplevel 2>/dev/null || true
+}
+
+# Check if current directory is in a Git repository
+git_is_repo() {
+  git rev-parse --git-dir >/dev/null 2>&1
+}
+
+# Get current absolute path (resolved)
+git_current_path() {
+  pwd -P
+}
+
+# Convert branch name to slug (replace / with -)
+git_branch_to_slug() {
+  echo "$1" | tr '/' '-'
+}
+
+# --------------------------- Branch Operations ------------------------------
+
+# Check if a branch exists
+git_branch_exists() {
+  local branch_name="$1"
+  git rev-parse --verify "$branch_name" >/dev/null 2>&1
+}
+
+# Get current branch name (or empty if detached HEAD)
+git_current_branch() {
+  git symbolic-ref --short HEAD 2>/dev/null || true
+}
+
+# Get current commit SHA (short format)
+git_current_commit_short() {
+  git rev-parse --short HEAD 2>/dev/null || true
+}
+
+# Delete a local branch (force delete)
+git_delete_branch() {
+  local branch_name="$1"
+  git branch -D "$branch_name" 2>/dev/null || true
+}
+
+# --------------------------- Worktree Operations ----------------------------
+
+# Ensure ignore rules for worktrees directory exist in both .gitignore and .git/info/exclude
+# Non-destructive and idempotent; creates files if needed
+git_ensure_ignore_worktrees() {
+  local root; root="$(git_repo_root)"
+  [[ -z "$root" ]] && return 1
+
+  # .git/info/exclude (local-only)
+  local exclude_file="$root/.git/info/exclude"
+  mkdir -p "$root/.git/info" 2>/dev/null || true
+  if [[ -f "$exclude_file" ]]; then
+    if ! grep -q -E '^worktrees/(\s*)?$' "$exclude_file" 2>/dev/null; then
+      echo 'worktrees/' >> "$exclude_file"
+    fi
+  else
+    echo 'worktrees/' >> "$exclude_file"
+  fi
+
+  # Top-level .gitignore (shared)
+  local gi_file="$root/.gitignore"
+  if [[ -f "$gi_file" ]]; then
+    if ! grep -q -E '^worktrees/(\s*)?$' "$gi_file" 2>/dev/null; then
+      echo 'worktrees/' >> "$gi_file"
+    fi
+  else
+    echo 'worktrees/' > "$gi_file"
+  fi
+}
+
+# List all worktrees: returns lines with "path\tbranch\tsha_short"
+git_list_worktrees() {
+  local root; root="$(git_repo_root)"
+  [[ -z "$root" ]] && return 1
+  
+  (cd "$root" && git worktree list) | awk '
+    {
+      p=""; for (i=1; i<=NF-2; i++) p=(p==""?$i:p" " $i);
+      sha_full=$(NF-1); sha=substr(sha_full,1,7);
+      b=$NF; gsub(/^\[|\]$/, "", b);
+      print p "\t" b "\t" sha;
+    }'
+}
+
+# Get branch name for a given worktree path
+git_worktree_path_to_branch() {
+  local path="$1"
+  local root; root="$(git_repo_root)"
+  [[ -z "$root" ]] && return 1
+  
+  (cd "$root" && git worktree list) | awk -v target="$path" '
+    {
+      p=""; for (i=1; i<=NF-2; i++) p=(p==""?$i:p" " $i);
+      b=$NF; gsub(/^\[|\]$/, "", b);
+      if (p==target) {print b; exit}
+    }'
+}
+
+# Get worktree path for a given branch name
+git_branch_to_worktree_path() {
+  local branch_name="$1"
+  local root; root="$(git_repo_root)"
+  [[ -z "$root" ]] && return 1
+  
+  (cd "$root" && git worktree list) | awk -v target="[$branch_name]" '
+    {
+      p=""; for (i=1; i<=NF-2; i++) p=(p==""?$i:p" " $i);
+      if ($NF==target) {print p; exit}
+    }'
+}
+
+# Create a new worktree with a new branch
+git_create_worktree_with_branch() {
+  local branch_name="$1"
+  local worktree_path="$2"
+  local root; root="$(git_repo_root)"
+  [[ -z "$root" ]] && return 1
+  
+  local relative_path="${worktree_path#$root/}"
+  (cd "$root" && git worktree add "$relative_path" -b "$branch_name" >&2)
+}
+
+# Create a new worktree from existing branch
+git_create_worktree_from_branch() {
+  local branch_name="$1"
+  local worktree_path="$2"
+  local root; root="$(git_repo_root)"
+  [[ -z "$root" ]] && return 1
+  
+  local relative_path="${worktree_path#$root/}"
+  (cd "$root" && git worktree add "$relative_path" "$branch_name" >&2)
+}
+
+git_create_worktree_for_existing_branch() {
+  local branch_name="$1"
+  local root; root="$(git_repo_root)"
+  [[ -z "$root" ]] && return 1
+
+  git_branch_exists "$branch_name" || { echo "Branch does not exist: $branch_name" >&2; return 1; }
+
+  git_ensure_ignore_worktrees >/dev/null 2>&1 || true
+
+  local worktree_path; worktree_path="$(git_build_worktree_path "$branch_name")"
+  mkdir -p "$(dirname "$worktree_path")"
+
+  git_create_worktree_from_branch "$branch_name" "$worktree_path" || return 1
+
+  echo "$worktree_path"
+}
+
+git_create_worktree_from_remote_branch() {
+  local branch_name="$1"
+  local remote_name="${2:-origin}"
+  local root; root="$(git_repo_root)"
+  [[ -z "$root" ]] && return 1
+
+  git_ensure_ignore_worktrees >/dev/null 2>&1 || true
+
+  local worktree_path; worktree_path="$(git_build_worktree_path "$branch_name")"
+  mkdir -p "$(dirname "$worktree_path")"
+
+  local relative_path="${worktree_path#$root/}"
+  (cd "$root" && git worktree add "$relative_path" -b "$branch_name" "$remote_name/$branch_name" >&2) || return 1
+
+  echo "$worktree_path"
+}
+
+# Remove a worktree (with force fallback)
+git_remove_worktree() {
+  local worktree_path="$1"
+  local root; root="$(git_repo_root)"
+  [[ -z "$root" ]] && return 1
+  
+  local relative_path="${worktree_path#$root/}"
+  (cd "$root" && {
+    git worktree remove "$relative_path" 2>/dev/null || \
+    git worktree remove --force "$relative_path" 2>/dev/null || true
+  })
+}
+
+# Get Git status for current directory
+git_status() {
+  git status "$@"
+}
+
+# Get short Git status for current directory
+git_status_short() {
+  git status --short
+}
+
+# --------------------------- Worktree Path Utilities ------------------------
+
+# Build standard worktree path for a branch
+git_build_worktree_path() {
+  local branch_name="$1"
+  local root; root="$(git_repo_root)"
+  [[ -z "$root" ]] && return 1
+  
+  local slug; slug="$(git_branch_to_slug "$branch_name")"
+  echo "$root/worktrees/$slug"
+}
+
+# Check if a worktree exists for a branch
+git_worktree_exists_for_branch() {
+  local branch_name="$1"
+  local path; path="$(git_branch_to_worktree_path "$branch_name")"
+  [[ -n "$path" ]]
+}
+
+# Get or create worktree path for a branch
+git_ensure_worktree_for_branch() {
+  local branch_name="$1"
+  local root; root="$(git_repo_root)"
+  [[ -z "$root" ]] && return 1
+  
+  # Check if worktree already exists
+  local existing_path; existing_path="$(git_branch_to_worktree_path "$branch_name")"
+  if [[ -n "$existing_path" ]]; then
+    echo "$existing_path"
+    return 0
+  fi
+  
+  # Create worktree if branch exists
+  if git_branch_exists "$branch_name"; then
+    # Ensure ignores before creating worktree
+    git_ensure_ignore_worktrees >/dev/null 2>&1 || true
+    local worktree_path; worktree_path="$(git_build_worktree_path "$branch_name")"
+    mkdir -p "$(dirname "$worktree_path")"
+    git_create_worktree_from_branch "$branch_name" "$worktree_path"
+    echo "$worktree_path"
+    return 0
+  fi
+  
+  return 1
+}
+
+# Create new branch and worktree
+git_create_branch_and_worktree() {
+  local branch_name="$1"
+  local root; root="$(git_repo_root)"
+  [[ -z "$root" ]] && return 1
+  
+  # Ensure ignores before creating worktree
+  git_ensure_ignore_worktrees >/dev/null 2>&1 || true
+  local worktree_path; worktree_path="$(git_build_worktree_path "$branch_name")"
+  mkdir -p "$(dirname "$worktree_path")"
+  git_create_worktree_with_branch "$branch_name" "$worktree_path"
+  echo "$worktree_path"
+}
+
+# --------------------------- Validation Functions ---------------------------
+
+# Validate that we're in a Git repository
+git_require_repo() {
+  git_is_repo || { echo "❌ Not a git repository or git command not found." >&2; return 1; }
+}
+
+# Get repository root with validation
+git_require_repo_root() {
+  local root; root="$(git_repo_root)"
+  [[ -z "$root" ]] && { echo "❌ Not a git repository" >&2; return 1; }
+  echo "$root"
+}
+
+# --------------------------- Merge/Rebase Helpers ----------------------------
+
+# Detect the primary branch name (default remote HEAD), fall back to common names
+# Echoes the branch name on success; returns non-zero on failure
+git_primary_branch() {
+  local head_ref branch
+  # Try origin/HEAD symbolic ref
+  head_ref=$(git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null || true)
+  if [[ -n "$head_ref" ]]; then
+    # refs/remotes/origin/main -> extract last component
+    branch="${head_ref##*/}"
+    [[ -n "$branch" ]] && { echo "$branch"; return 0; }
+  fi
+  # Try parsing `git remote show origin`
+  branch=$(git remote show origin 2>/dev/null | awk -F': ' '/HEAD branch/ {print $2; exit}')
+  if [[ -n "$branch" && "$branch" != "(unknown)" ]]; then
+    echo "$branch"; return 0
+  fi
+  # Fallback candidates
+  for cand in main master trunk; do
+    if git rev-parse --verify "$cand" >/dev/null 2>&1 || git rev-parse --verify "origin/$cand" >/dev/null 2>&1; then
+      echo "$cand"; return 0
+    fi
+  done
+  return 1
+}
+
+# Check if a worktree at path is clean (no changes)
+# Usage: git_is_worktree_clean <path>
+git_is_worktree_clean() {
+  local path="$1"
+  [[ -z "$path" ]] && return 1
+  local out
+  out=$(git -C "$path" status --porcelain 2>/dev/null || true)
+  [[ -z "$out" ]]
+}
+
+# Fetch from origin with prune for a given path
+git_fetch_prune() {
+  local path="$1"
+  git -C "$path" fetch origin --prune 2>&1
+}
+
+# Fast-forward-only pull for the currently checked out branch at path
+# Returns non-zero if not a fast-forward
+# Usage: git_pull_ff_only <path>
+git_pull_ff_only() {
+  local path="$1"
+  git -C "$path" pull --ff-only 2>&1
+}
+
+# Merge a ref into the currently checked out branch at target path
+# Usage: git_merge_into <target_path> <ref>
+git_merge_into() {
+  local target="$1"; local ref="$2"
+  git -C "$target" merge "$ref" 2>&1
+}
+
+# Rebase the current branch at target path onto upstream ref
+# Usage: git_rebase_onto <target_path> <upstream_ref>
+git_rebase_onto() {
+  local target="$1"; local upstream="$2"
+  git -C "$target" rebase "$upstream" 2>&1
+}
+
+# Squash-merge branch into the primary worktree path, then commit if changes staged
+# Usage: git_squash_merge_into <primary_path> <branch>
+git_squash_merge_into() {
+  local primary_path="$1"; local branch="$2"
+  git -C "$primary_path" merge --squash "$branch" 2>&1
+}
+
+# Ensure a primary worktree exists; echoes the path
+# Usage: git_ensure_primary_worktree
+git_ensure_primary_worktree() {
+  local primary
+  primary=$(git_primary_branch) || return 1
+  git_ensure_worktree_for_branch "$primary"
+}