arashi 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Arashi Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,351 @@
+# Arashi
+
+> 嵐 - The eye of the storm for your development workflow
+
+Arashi is a Git worktree manager for meta-repositories that automatically manages worktrees across multiple related repositories. When working on features that span multiple repositories, Arashi simplifies the workflow by ensuring all related repositories maintain synchronized worktrees.
+
+## Documentation
+
+📋 **For complete design documents, specifications, and planning, see the [Arashi Specifications Repository](https://github.com/corwinm/arashi-arashi).**
+
+## Status
+
+🚧 **Under Active Development** - Phase 1 Complete
+
+This project is currently in early development. See the [Design Document](https://github.com/corwinm/arashi-arashi/tree/main/setup/.specify/memory/design.md) in the specs repository for the complete feature roadmap and implementation plan.
+
+## Installation (Coming Soon)
+
+### npm (Recommended)
+
+```bash
+npm install -g arashi
+```
+
+The npm package includes everything you need for full fzf compatibility.
+
+### Direct Binary Download
+
+Download and extract the latest release for your platform from [GitHub Releases](https://github.com/corwinm/arashi/releases):
+
+**macOS (Apple Silicon)**
+```bash
+curl -L https://github.com/corwinm/arashi/releases/latest/download/arashi-macos-arm64.tar.gz -o arashi.tar.gz
+tar xzf arashi.tar.gz
+cd arashi-macos-arm64
+sudo cp arashi arashi.bin /usr/local/bin/
+```
+
+**Linux (x64)**
+```bash
+curl -L https://github.com/corwinm/arashi/releases/latest/download/arashi-linux-x64.tar.gz -o arashi.tar.gz
+tar xzf arashi.tar.gz
+cd arashi-linux-x64
+sudo cp arashi arashi.bin /usr/local/bin/
+```
+
+**Windows (x64)**
+- Windows support coming soon (wrapper script needs PowerShell equivalent)
+
+## Vision
+
+Arashi will enable developers to:
+- Create coordinated worktrees across multiple repositories with a single command
+- Automatically manage branch synchronization across related repos
+- Simplify setup and teardown of development environments
+- Maintain clean git state across meta-repository structures
+
+## Quick Start (Coming Soon)
+
+```bash
+# Initialize arashi in your meta-repository
+arashi init
+
+# Add repositories to manage
+arashi add git@github.com:user/frontend.git
+arashi add git@github.com:user/backend.git
+
+# Create a new feature worktree across all repos
+arashi create feature-new-api
+
+# Check status across all repos
+arashi status
+
+# Remove worktree when done
+arashi remove feature-new-api
+```
+
+## Planned Commands
+
+- `arashi init` - Initialize arashi in current repository
+- `arashi add <git-url>` - Add a repository to the repos folder
+- `arashi create <branch>` - Create coordinated worktrees
+- `arashi list` - List all worktrees
+- `arashi remove <branch>` - Remove worktrees and branches
+- `arashi setup` - Run setup scripts
+- `arashi status` - Show status of all repositories
+
+## Integration with fzf, tmux, and sesh
+
+The `arashi list` command outputs clean, full paths perfect for piping to tools like fzf. Here are powerful workflow integrations:
+
+### Basic: Change Directory with fzf
+
+Navigate to any worktree interactively:
+
+```bash
+# Interactive worktree selection
+cd $(arashi list | fzf)
+```
+
+**Add as a shell keybinding** for instant access:
+
+#### Bash/Zsh
+
+Add to your `~/.bashrc` or `~/.zshrc`:
+
+```bash
+# Ctrl+G to select and navigate to worktree
+bind '"\C-g":"cd \$(arashi list | fzf)\n"'  # Bash
+bindkey -s '^g' 'cd $(arashi list | fzf)\n'  # Zsh
+```
+
+Press `Ctrl+G` from anywhere to fuzzy-find and jump to a worktree.
+
+#### Fish
+
+Add to your `~/.config/fish/config.fish`:
+
+```fish
+# Ctrl+G to select and navigate to worktree
+function __arashi_worktree_jump
+    set -l worktree (arashi list | fzf)
+    and cd $worktree
+    commandline -f repaint
+end
+bind \cg __arashi_worktree_jump
+```
+
+### Advanced: tmux Session Management
+
+Create or switch to a tmux session for a worktree:
+
+```bash
+# Function to create/attach tmux session for worktree
+arashi-tmux() {
+  local worktree=$(arashi list | fzf)
+  if [ -n "$worktree" ]; then
+    # Create session name from last path component
+    local session_name=$(basename "$worktree")
+    
+    # Create session if it doesn't exist
+    if ! tmux has-session -t "$session_name" 2>/dev/null; then
+      tmux new-session -d -s "$session_name" -c "$worktree"
+    fi
+    
+    # Switch to or attach session
+    if [ -n "$TMUX" ]; then
+      tmux switch-client -t "$session_name"
+    else
+      tmux attach-session -t "$session_name"
+    fi
+  fi
+}
+
+# Bind to Ctrl+G
+bind '"\C-g":"arashi-tmux\n"'  # Bash
+bindkey -s '^g' 'arashi-tmux\n'  # Zsh
+```
+
+**What this does:**
+1. Fuzzy-find a worktree with fzf
+2. Create a named tmux session for that worktree (if needed)
+3. Switch to the session, preserving your current context
+
+### Simplified: Using sesh
+
+[sesh](https://github.com/joshmedeski/sesh) is a smart session manager for tmux. Integrate arashi with sesh for the ultimate workflow:
+
+#### Setup
+
+```bash
+# Install sesh
+brew install joshmedeski/sesh/sesh
+
+# Add arashi as a sesh source
+# ~/.config/sesh/sesh.toml
+[sources]
+arashi = "arashi list"
+```
+
+#### Usage
+
+```bash
+# Select from all sessions + arashi worktrees
+sesh connect $(sesh list | fzf)
+
+# Or create a keybinding (Ctrl+A)
+bind '"\C-a":"sesh connect \$(sesh list | fzf)\n"'
+```
+
+**Benefits of sesh:**
+- Unified list of existing tmux sessions + arashi worktrees
+- Smart session naming and path handling
+- Automatic tmux session creation
+- Works seamlessly with zoxide and other tools
+
+### Fish + tmux Integration
+
+For Fish shell users, here's a complete solution:
+
+```fish
+# ~/.config/fish/functions/arashi_session.fish
+function arashi_session
+    set -l worktree (arashi list | fzf \
+        --preview 'cd {} && git status' \
+        --preview-window=right:60% \
+        --height=80%)
+    
+    if test -n "$worktree"
+        set -l session_name (basename $worktree)
+        
+        if not tmux has-session -t $session_name 2>/dev/null
+            tmux new-session -d -s $session_name -c $worktree
+        end
+        
+        if set -q TMUX
+            tmux switch-client -t $session_name
+        else
+            tmux attach-session -t $session_name
+        end
+    end
+end
+
+# Bind to Ctrl+G
+bind \cg arashi_session
+```
+
+This includes:
+- Live git status preview in fzf
+- Automatic session creation with smart naming
+- Works both inside and outside tmux
+
+### Comparison Table
+
+| Method | Setup Complexity | Features | Best For |
+|--------|-----------------|----------|----------|
+| **Basic fzf** | Low | Quick navigation | Simple cd workflows |
+| **tmux function** | Medium | Session management | Multi-project work |
+| **sesh** | Low-Medium | Unified session list | Power users with multiple sources |
+
+### Tips
+
+- **Preview window:** Add `--preview 'cd {} && git status'` to fzf for live status
+- **Layout:** Try `--preview-window=right:60%` for side-by-side preview
+- **Height:** Use `--height=80%` to avoid fullscreen fzf
+- **Multi-select:** Add `--multi` to fzf for batch operations
+
+### Example Workflow
+
+```bash
+# Morning routine:
+1. Press Ctrl+G
+2. Type "feature" to filter worktrees
+3. Select your feature branch worktree
+4. tmux session is created/attached
+5. Start coding immediately!
+
+# No more:
+cd ~/projects/repo
+cd ../feature-worktree
+tmux new -s feature-branch
+cd ~/projects/repo/feature-worktree
+```
+
+## Development
+
+### Prerequisites
+
+- [Bun](https://bun.sh/) >= 1.3.0 (for development)
+- Node.js >= 18.0.0 (for npm installation)
+
+### Setup
+
+```bash
+# Clone the repository
+git clone https://github.com/corwinm/arashi.git
+cd arashi
+
+# Install dependencies
+bun install
+
+# Run in development mode
+bun run dev
+
+# Build single-file executable
+bun run build
+
+# Build for all platforms
+bun run build:all
+
+# Run tests (coming soon)
+bun test
+
+# Type check
+bun run lint
+```
+
+### Contributing
+
+We welcome contributions! Please see our [Specifications Repository](https://github.com/corwinm/arashi-arashi) for:
+- [Design Document](https://github.com/corwinm/arashi-arashi/tree/main/setup/.specify/memory/design.md) - Feature roadmap and technical design
+- [Contributing Guide](https://github.com/corwinm/arashi-arashi/blob/main/setup/CONTRIBUTING.md) - Specs-first development workflow
+
+**Quick Summary:**
+1. Specs are created in the [arashi-arashi repository](https://github.com/corwinm/arashi-arashi) first
+2. Implementation happens in this repository
+3. Use conventional commits
+4. All PRs require review
+5. Squash merge with conventional commit message
+
+**Commit Message Format:**
+We use [Conventional Commits](https://www.conventionalcommits.org/):
+```
+feat: add interactive mode for repo selection
+fix: handle worktrees with uncommitted changes
+docs: update installation instructions
+```
+
+## Architecture
+
+Arashi is built with:
+- **Runtime:** Bun (single-file executable)
+- **Language:** TypeScript
+- **CLI Framework:** Commander.js
+- **User Prompts:** @inquirer/prompts
+
+## Roadmap
+
+See the [Design Document](https://github.com/corwinm/arashi-arashi/tree/main/setup/.specify/memory/design.md) in the specs repository for the complete feature roadmap organized by implementation phases.
+
+### Current Phase: Foundation (Phase 1)
+- [x] Project setup and structure
+- [x] Type definitions
+- [ ] Utility libraries (git, config, filesystem, logger, prompts)
+
+### Next Phase: Core Commands (Phase 2)
+- [ ] `init` command
+- [ ] `add` command
+- [ ] `create` command
+
+## Why "Arashi"?
+
+嵐 (Arashi) means "storm" in Japanese. This tool aims to be the calm center - the eye of the storm - that brings order to the chaos of managing multiple repositories and worktrees.
+
+## License
+
+MIT
+
+---
+
+**Note:** This project is under active development. Features and APIs may change.

package/bin/arashi

@@ -0,0 +1,42 @@
+#!/bin/bash
+# Wrapper for arashi to fix fzf compatibility
+# Bun's compiled executables don't properly close stdin, which blocks fzf
+# from accessing /dev/tty for keyboard input. This wrapper closes stdin (0<&-)
+# before executing the binary.
+
+# Resolve the actual script path, following symlinks
+SCRIPT_SOURCE="${BASH_SOURCE[0]}"
+while [ -L "$SCRIPT_SOURCE" ]; do
+  SCRIPT_DIR="$(cd "$(dirname "$SCRIPT_SOURCE")" && pwd)"
+  SCRIPT_SOURCE="$(readlink "$SCRIPT_SOURCE")"
+  [[ "$SCRIPT_SOURCE" != /* ]] && SCRIPT_SOURCE="$SCRIPT_DIR/$SCRIPT_SOURCE"
+done
+SCRIPT_DIR="$(cd "$(dirname "$SCRIPT_SOURCE")" && pwd)"
+BINARY="$SCRIPT_DIR/arashi.bin"
+
+# Use platform-specific binary if main binary doesn't exist
+if [ ! -f "$BINARY" ]; then
+  PLATFORM=$(uname -s | tr '[:upper:]' '[:lower:]')
+  ARCH=$(uname -m)
+  
+  case "$PLATFORM-$ARCH" in
+    darwin-arm64)
+      BINARY="$SCRIPT_DIR/arashi-macos-arm64"
+      ;;
+    linux-x86_64)
+      BINARY="$SCRIPT_DIR/arashi-linux-x64"
+      ;;
+    *)
+      echo "Error: Unsupported platform $PLATFORM-$ARCH" >&2
+      exit 1
+      ;;
+  esac
+fi
+
+if [ ! -f "$BINARY" ]; then
+  echo "Error: arashi binary not found at $BINARY" >&2
+  exit 1
+fi
+
+# Execute with stdin closed (0<&-) for fzf compatibility
+exec "$BINARY" "$@" 0<&-

package/bin/arashi.bat

@@ -0,0 +1,22 @@
+@echo off
+REM Wrapper for arashi.exe to support piping to tools like fzf on Windows
+REM This closes stdin before executing the binary
+
+REM Get the directory where this script is located
+set "SCRIPT_DIR=%~dp0"
+set "BINARY=%SCRIPT_DIR%arashi.bin.exe"
+
+REM Use platform-specific binary if main binary doesn't exist
+if not exist "%BINARY%" (
+    set "BINARY=%SCRIPT_DIR%arashi-windows-x64.exe"
+)
+
+REM Check if binary exists
+if not exist "%BINARY%" (
+    echo Error: arashi binary not found at %BINARY% 1>&2
+    exit /b 1
+)
+
+REM Execute the binary with stdin closed
+REM In Windows, we use <NUL to close/redirect stdin
+"%BINARY%" %* <NUL

package/bin/arashi.ps1

@@ -0,0 +1,21 @@
+# PowerShell wrapper for arashi.exe to support piping to tools like fzf
+# This closes stdin before executing the binary
+
+$ScriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
+$Binary = Join-Path $ScriptDir "arashi.bin.exe"
+
+# Use platform-specific binary if main binary doesn't exist
+if (-not (Test-Path $Binary)) {
+    $Binary = Join-Path $ScriptDir "arashi-windows-x64.exe"
+}
+
+# Check if binary exists
+if (-not (Test-Path $Binary)) {
+    Write-Error "Error: arashi binary not found at $Binary"
+    exit 1
+}
+
+# PowerShell way to close stdin and execute
+# We redirect stdin from $null which effectively closes it
+$process = Start-Process -FilePath $Binary -ArgumentList $args -NoNewWindow -Wait -PassThru -RedirectStandardInput $null
+exit $process.ExitCode

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "arashi",
+  "version": "1.1.0",
+  "description": "Git worktree manager for meta-repositories - The eye of the storm for your development workflow",
+  "type": "module",
+  "bin": {
+    "arashi": "./bin/arashi"
+  },
+  "files": [
+    "bin/arashi",
+    "bin/arashi.bat",
+    "bin/arashi.ps1",
+    "scripts/postinstall.js",
+    "README.md",
+    "LICENSE"
+  ],
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "dev": "bun run src/index.ts",
+    "build": "bun build src/index.ts --compile --minify --sourcemap --outfile bin/arashi.bin",
+    "build:all": "bun run build:mac && bun run build:linux && bun run build:windows",
+    "build:mac": "bun build src/index.ts --compile --target=bun-darwin-arm64 --outfile bin/arashi-macos-arm64",
+    "build:linux": "bun build src/index.ts --compile --target=bun-linux-x64 --outfile bin/arashi-linux-x64",
+    "build:windows": "bun build src/index.ts --compile --target=bun-windows-x64 --outfile bin/arashi-windows-x64.exe",
+    "test": "bun test",
+    "lint": "tsc --noEmit",
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/corwinm/arashi.git"
+  },
+  "bugs": {
+    "url": "https://github.com/corwinm/arashi/issues"
+  },
+  "homepage": "https://github.com/corwinm/arashi#readme",
+  "keywords": [
+    "git",
+    "worktree",
+    "meta-repo",
+    "monorepo",
+    "cli",
+    "development",
+    "git-worktree",
+    "multi-repo",
+    "development-tools"
+  ],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@inquirer/prompts": "^7.2.0",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@types/bun": "latest",
+    "bun-types": "latest",
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "conventional-changelog-conventionalcommits": "^8.0.0",
+    "js-yaml": "^4.1.1",
+    "ora": "^8.1.1",
+    "semantic-release": "^24.2.0",
+    "typescript": "^5.9.3"
+  }
+}

package/scripts/postinstall.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+
+/**
+ * Post-install script to download the platform-specific arashi binary from GitHub releases
+ * This keeps the npm package size small while providing pre-compiled binaries
+ */
+
+import { createWriteStream, chmodSync } from "node:fs";
+import { mkdir, access, constants } from "node:fs/promises";
+import { get } from "node:https";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const PACKAGE_NAME = "arashi";
+const GITHUB_REPO = "corwinm/arashi";
+
+// Determine platform and binary name
+function getPlatformInfo() {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  let binaryName;
+  if (platform === "darwin" && arch === "arm64") {
+    binaryName = `${PACKAGE_NAME}-macos-arm64`;
+  } else if (platform === "linux" && arch === "x64") {
+    binaryName = `${PACKAGE_NAME}-linux-x64`;
+  } else if (platform === "win32" && arch === "x64") {
+    binaryName = `${PACKAGE_NAME}-windows-x64.exe`;
+  } else {
+    throw new Error(
+      `Unsupported platform: ${platform}-${arch}. Please build from source or file an issue at https://github.com/${GITHUB_REPO}/issues`
+    );
+  }
+
+  return { binaryName, isWindows: platform === "win32" };
+}
+
+// Download file from URL
+function downloadFile(url, dest) {
+  return new Promise((resolve, reject) => {
+    console.log(`Downloading ${url}...`);
+
+    const file = createWriteStream(dest);
+    const request = get(url, (response) => {
+      // Handle redirects
+      if (
+        response.statusCode === 301 ||
+        response.statusCode === 302 ||
+        response.statusCode === 307
+      ) {
+        file.close();
+        downloadFile(response.headers.location, dest)
+          .then(resolve)
+          .catch(reject);
+        return;
+      }
+
+      if (response.statusCode !== 200) {
+        file.close();
+        reject(
+          new Error(
+            `Failed to download: ${response.statusCode} ${response.statusMessage}`
+          )
+        );
+        return;
+      }
+
+      response.pipe(file);
+
+      file.on("finish", () => {
+        file.close(resolve);
+      });
+    });
+
+    request.on("error", (err) => {
+      file.close();
+      reject(err);
+    });
+
+    file.on("error", (err) => {
+      file.close();
+      reject(err);
+    });
+  });
+}
+
+// Main installation logic
+async function install() {
+  try {
+    // Skip postinstall in development (when installing from the repo)
+    // Check if we're in development by looking for src/ directory
+    const srcDir = join(__dirname, "..", "src");
+    try {
+      await access(srcDir, constants.F_OK);
+      console.log("✓ Development environment detected, skipping binary download");
+      console.log("  Run 'bun run build:all' to build binaries locally");
+      return;
+    } catch {
+      // Not in development, continue with download
+    }
+
+    // Get version from package.json
+    const packageJsonPath = join(__dirname, "..", "package.json");
+    const { readFile } = await import("node:fs/promises");
+    const packageJson = JSON.parse(await readFile(packageJsonPath, "utf-8"));
+    const { version } = packageJson;
+
+    const { binaryName, isWindows } = getPlatformInfo();
+    const binDir = join(__dirname, "..", "bin");
+    const binaryPath = join(binDir, binaryName);
+
+    // Check if binary already exists
+    try {
+      await access(binaryPath, constants.F_OK);
+      console.log(`✓ Binary already exists at ${binaryPath}`);
+      return;
+    } catch {
+      // Binary doesn't exist, continue with download
+    }
+
+    // Ensure bin directory exists
+    await mkdir(binDir, { recursive: true });
+
+    // Download binary from GitHub releases
+    const downloadUrl = `https://github.com/${GITHUB_REPO}/releases/download/v${version}/${binaryName}`;
+
+    await downloadFile(downloadUrl, binaryPath);
+
+    // Make binary executable (Unix-like systems)
+    if (!isWindows) {
+      chmodSync(binaryPath, 0o755);
+    }
+
+    console.log(`✓ Successfully installed ${PACKAGE_NAME} v${version}`);
+    console.log(`  Binary location: ${binaryPath}`);
+  } catch (error) {
+    console.error(`✗ Failed to install ${PACKAGE_NAME}:`, error.message);
+    console.error(
+      `\nYou can manually download binaries from: https://github.com/${GITHUB_REPO}/releases`
+    );
+    process.exit(1);
+  }
+}
+
+install();