@tsuzuku/arise 0.2.0

package/lib/context.js

@@ -0,0 +1,113 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync, spawnSync } = require('child_process');
+
+function createContext({
+  worktreePath,
+  repoRoot,
+  bareRepo,
+  branch,
+  source,
+  flags = {},
+  preset = {},
+  config = {},
+}) {
+  const ctx = {
+    worktreePath,
+    repoRoot,
+    bareRepo,
+    branch,
+    source,
+    flags,
+    preset,
+    config,
+
+    log(msg) {
+      console.log(msg);
+    },
+
+    warn(msg) {
+      console.warn(msg);
+    },
+
+    error(msg) {
+      console.error(msg);
+    },
+
+    exec(command, options = {}) {
+      const cwd = options.cwd || worktreePath;
+      const shell = options.shell || '/bin/bash';
+      return execSync(command, {
+        cwd,
+        stdio: 'inherit',
+        shell,
+        ...options,
+      });
+    },
+
+    spawn(command, args = [], options = {}) {
+      const cwd = options.cwd || worktreePath;
+      const shell = options.shell !== undefined ? options.shell : true;
+      return spawnSync(command, args, {
+        cwd,
+        stdio: 'inherit',
+        shell,
+        ...options,
+      });
+    },
+
+    copyFile(src, dst) {
+      const resolvedDst = path.isAbsolute(dst) ? dst : path.join(worktreePath, dst);
+      if (fs.existsSync(src)) {
+        console.log(`Copying from "${src}" to "${resolvedDst}"...`);
+        const dstDir = path.dirname(resolvedDst);
+        if (!fs.existsSync(dstDir)) {
+          fs.mkdirSync(dstDir, { recursive: true });
+        }
+        fs.copyFileSync(src, resolvedDst);
+        return true;
+      } else {
+        console.warn(`Source file "${src}" does not exist to copy.`);
+        return false;
+      }
+    },
+
+    copyFromRoot(relativeSrc, relativeDst = relativeSrc) {
+      if (!repoRoot) {
+        console.warn(`Cannot copy from root: no repo root identified.`);
+        return false;
+      }
+      const src = path.join(repoRoot, relativeSrc);
+      const dst = path.join(worktreePath, relativeDst);
+      return ctx.copyFile(src, dst);
+    },
+
+    setSymlink(symlinkPath, target = worktreePath) {
+      console.log(`==> Updating symlink "${symlinkPath}" -> "${target}"...`);
+      try {
+        if (fs.existsSync(symlinkPath) || fs.lstatSync(symlinkPath).isSymbolicLink()) {
+          const lstat = fs.lstatSync(symlinkPath);
+          if (lstat.isSymbolicLink()) {
+            fs.unlinkSync(symlinkPath);
+          } else {
+            const backupPath = `${symlinkPath}_BAK_${Date.now()}`;
+            console.warn(`==> Warning: "${symlinkPath}" is a directory, not a symlink. Backing up to "${backupPath}"`);
+            fs.renameSync(symlinkPath, backupPath);
+          }
+        }
+        fs.symlinkSync(target, symlinkPath);
+        console.log(`==> Symlink updated: ${symlinkPath} -> ${target}`);
+        return true;
+      } catch (err) {
+        console.error(`==> Failed to update symlink: ${err.message}`);
+        return false;
+      }
+    },
+  };
+
+  return ctx;
+}
+
+module.exports = {
+  createContext,
+};

package/lib/git.js

@@ -0,0 +1,306 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+function isBareRepo(repoPath) {
+  if (!repoPath || !fs.existsSync(repoPath)) return false;
+  try {
+    const isBare = execSync(`git --git-dir="${repoPath}" rev-parse --is-bare-repository`, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    return isBare === 'true';
+  } catch (e) {
+    return false;
+  }
+}
+
+function getGitPrefix(options = {}) {
+  if (options.bareRepo) {
+    return `git --git-dir="${options.bareRepo}"`;
+  }
+  if (options.repoDir) {
+    const dotBare = path.join(options.repoDir, '.bare');
+    if (fs.existsSync(dotBare)) {
+      return `git --git-dir="${dotBare}"`;
+    }
+    if (isBareRepo(options.repoDir)) {
+      return `git --git-dir="${options.repoDir}"`;
+    }
+    return `git -C "${options.repoDir}"`;
+  }
+  return 'git';
+}
+
+function getRepoRootDir(cwd = process.cwd(), bareRepo = null) {
+  if (bareRepo && fs.existsSync(bareRepo)) {
+    return bareRepo;
+  }
+  const dotBare = path.join(cwd, '.bare');
+  if (fs.existsSync(dotBare)) {
+    return cwd;
+  }
+  try {
+    const commonDir = execSync('git rev-parse --git-common-dir', { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    const absoluteCommonDir = path.isAbsolute(commonDir) ? commonDir : path.resolve(cwd, commonDir);
+    if (isBareRepo(absoluteCommonDir)) {
+      return absoluteCommonDir;
+    }
+    return path.dirname(absoluteCommonDir);
+  } catch (err) {
+    return cwd;
+  }
+}
+
+function getWorktrees(options = {}) {
+  const gitCmd = getGitPrefix(options);
+  try {
+    const output = execSync(`${gitCmd} worktree list --porcelain`, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    const worktrees = [];
+    const entries = output.trim().split('\n\n');
+    for (const entry of entries) {
+      if (!entry.trim()) continue;
+      const lines = entry.split('\n');
+      let wtPath = null;
+      let wtBranch = null;
+      let isBare = false;
+      let isDetached = false;
+      for (const line of lines) {
+        if (line.startsWith('worktree ')) {
+          wtPath = line.substring('worktree '.length).trim();
+        } else if (line.startsWith('branch ')) {
+          const ref = line.substring('branch '.length).trim();
+          wtBranch = ref.replace(/^refs\/heads\//, '');
+        } else if (line === 'bare') {
+          isBare = true;
+        } else if (line === 'detached') {
+          isDetached = true;
+        }
+      }
+      if (wtPath) {
+        worktrees.push({ path: wtPath, branch: wtBranch, isBare, isDetached });
+      }
+    }
+    return worktrees;
+  } catch (err) {
+    // Fallback to standard worktree list if porcelain fails
+    try {
+      const output = execSync(`${gitCmd} worktree list`, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+      return output.trim().split('\n').filter(Boolean).map(line => {
+        const parts = line.split(/\s+/);
+        const wtPath = parts[0];
+        const branchMatch = line.match(/\[(.*?)\]/);
+        const wtBranch = branchMatch ? branchMatch[1] : null;
+        return { path: wtPath, branch: wtBranch, isBare: line.includes('(bare)'), isDetached: line.includes('(detached)') };
+      });
+    } catch (e) {
+      return [];
+    }
+  }
+}
+
+function fetchOrigin(options = {}) {
+  const gitCmd = getGitPrefix(options);
+  try {
+    const remotes = execSync(`${gitCmd} remote`, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim().split(/\s+/);
+    if (!remotes.includes('origin')) return;
+
+    // In bare repos, remote.origin.fetch is often not set by default.
+    // Setting or fetching with the standard refspec ensures refs/remotes/origin/* are populated.
+    try {
+      const fetchRefspec = execSync(`${gitCmd} config --get remote.origin.fetch`, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+      if (!fetchRefspec) {
+        execSync(`${gitCmd} config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*"`, { stdio: 'ignore' });
+      }
+    } catch (e) {
+      try {
+        execSync(`${gitCmd} config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*"`, { stdio: 'ignore' });
+      } catch (err) {}
+    }
+
+    execSync(`${gitCmd} fetch origin`, { stdio: 'inherit' });
+  } catch (e) {
+    // Network or remote fetch error - continue gracefully with local refs
+  }
+}
+
+function branchExistsLocally(branch, options = {}) {
+  const gitCmd = getGitPrefix(options);
+  try {
+    execSync(`${gitCmd} rev-parse --verify "refs/heads/${branch}"`, { stdio: 'ignore' });
+    return true;
+  } catch (e) {
+    try {
+      execSync(`${gitCmd} rev-parse --verify "${branch}"`, { stdio: 'ignore' });
+      return true;
+    } catch (err) {
+      try {
+        const list = execSync(`${gitCmd} branch --list "${branch}"`, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+        return list !== '';
+      } catch (err2) {
+        return false;
+      }
+    }
+  }
+}
+
+function branchExistsRemotely(branch, options = {}) {
+  const gitCmd = getGitPrefix(options);
+  try {
+    execSync(`${gitCmd} rev-parse --verify "refs/remotes/origin/${branch}"`, { stdio: 'ignore' });
+    return true;
+  } catch (e) {
+    try {
+      execSync(`${gitCmd} rev-parse --verify "origin/${branch}"`, { stdio: 'ignore' });
+      return true;
+    } catch (err) {
+      try {
+        const remoteList = execSync(`${gitCmd} branch -r --list "origin/${branch}"`, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+        if (remoteList) return true;
+        const lsRemote = execSync(`${gitCmd} ls-remote --heads origin "${branch}"`, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+        return Boolean(lsRemote);
+      } catch (err2) {
+        return false;
+      }
+    }
+  }
+}
+
+function createWorktree({ worktreePath, branch, source = 'develop', repoDir, bareRepo }) {
+  const options = { repoDir, bareRepo };
+  const gitCmd = getGitPrefix(options);
+
+  console.log('Fetching latest from origin...');
+  fetchOrigin(options);
+
+  const localExists = branchExistsLocally(branch, options);
+  const remoteExists = branchExistsRemotely(branch, options);
+
+  if (localExists) {
+    console.log(`Branch "${branch}" exists locally. Adding worktree...`);
+    execSync(`${gitCmd} worktree add "${worktreePath}" "${branch}"`, { stdio: 'inherit' });
+  } else if (remoteExists) {
+    console.log(`Branch "${branch}" exists on remote. Checking out and adding worktree...`);
+    let startPoint = `origin/${branch}`;
+    try {
+      execSync(`${gitCmd} rev-parse --verify "${startPoint}"`, { stdio: 'ignore' });
+    } catch (e) {
+      startPoint = branch;
+    }
+    if (bareRepo) {
+      execSync(`${gitCmd} branch --track "${branch}" "${startPoint}"`, { stdio: 'inherit' });
+      execSync(`${gitCmd} worktree add "${worktreePath}" "${branch}"`, { stdio: 'inherit' });
+    } else {
+      execSync(`${gitCmd} worktree add "${worktreePath}" -b "${branch}" "${startPoint}"`, { stdio: 'inherit' });
+    }
+  } else {
+    // Creating a brand new branch off source
+    let startPoint = null;
+    try {
+      execSync(`${gitCmd} rev-parse --verify "origin/${source}"`, { stdio: 'ignore' });
+      startPoint = `origin/${source}`;
+    } catch (e) {
+      try {
+        execSync(`${gitCmd} rev-parse --verify "${source}"`, { stdio: 'ignore' });
+        startPoint = source;
+      } catch (err) {
+        throw new Error(`Cannot create branch "${branch}" off "${source}": Base branch or ref "${source}" does not exist locally or on remote.`);
+      }
+    }
+
+    console.log(`Creating branch "${branch}" off "${startPoint}" and adding worktree...`);
+    if (bareRepo) {
+      execSync(`${gitCmd} branch --no-track "${branch}" "${startPoint}"`, { stdio: 'inherit' });
+      execSync(`${gitCmd} worktree add "${worktreePath}" "${branch}"`, { stdio: 'inherit' });
+    } else {
+      execSync(`${gitCmd} worktree add "${worktreePath}" -b "${branch}" "${startPoint}"`, { stdio: 'inherit' });
+    }
+  }
+}
+
+function syncPrimaryBranch({ branch, worktreePath, repoDir, bareRepo, protectedBranches = [] }) {
+  if (!protectedBranches.includes(branch)) return;
+
+  console.log(`==> Primary branch "${branch}" detected. Checking for local changes...`);
+  const options = { repoDir, bareRepo };
+  const gitCmd = getGitPrefix(options);
+
+  try {
+    const statusCmd = bareRepo
+      ? `${gitCmd} --work-tree="${worktreePath}" status --porcelain`
+      : `git -C "${worktreePath}" status --porcelain`;
+
+    const isDirty = execSync(statusCmd, { encoding: 'utf8' }).trim() !== '';
+
+    if (isDirty) {
+      console.warn(`==> WARNING: Local changes detected in ${branch}. Skipping hard reset to origin/${branch} to prevent data loss.`);
+      console.warn(`==> Please commit, stash, or discard your changes if you want to sync with origin.`);
+    } else {
+      console.log(`==> Syncing ${branch} with origin/${branch}...`);
+      fetchOrigin(options);
+      const resetCmd = bareRepo
+        ? `${gitCmd} --work-tree="${worktreePath}" reset --hard origin/${branch}`
+        : `git -C "${worktreePath}" reset --hard origin/${branch}`;
+      execSync(resetCmd, { stdio: 'inherit' });
+    }
+  } catch (err) {
+    console.warn(`==> Warning syncing primary branch: ${err.message}`);
+  }
+}
+
+function removeWorktree(worktreePath, options = {}) {
+  const gitCmd = getGitPrefix(options);
+  const forceFlag = options.force ? '--force' : '';
+  try {
+    execSync(`${gitCmd} worktree remove ${forceFlag} "${worktreePath}"`, { stdio: 'inherit' });
+    console.log(`Successfully removed git worktree at "${worktreePath}".`);
+  } catch (err) {
+    console.warn(`"git worktree remove" standard attempt failed. Trying force removal...`);
+    try {
+      execSync(`${gitCmd} worktree remove --force "${worktreePath}"`, { stdio: 'inherit' });
+      console.log(`Successfully force-removed git worktree.`);
+    } catch (e) {
+      console.warn(`Git worktree force remove warning: ${e.message}`);
+    }
+  }
+}
+
+function pruneWorktrees(options = {}) {
+  const gitCmd = getGitPrefix(options);
+  try {
+    execSync(`${gitCmd} worktree prune`, { stdio: 'ignore' });
+  } catch (e) {}
+}
+
+function deleteLocalBranch(branch, options = {}) {
+  const gitCmd = getGitPrefix(options);
+  try {
+    execSync(`${gitCmd} branch -D "${branch}"`, { stdio: 'inherit' });
+    console.log(`Deleted local branch "${branch}".`);
+  } catch (err) {
+    console.error(`Failed to delete local branch "${branch}": ${err.message}`);
+  }
+}
+
+function deleteRemoteBranch(branch, options = {}) {
+  const gitCmd = getGitPrefix(options);
+  try {
+    execSync(`${gitCmd} push origin --delete "${branch}"`, { stdio: 'inherit' });
+    console.log(`Deleted remote branch "${branch}" from origin.`);
+  } catch (err) {
+    console.error(`Failed to delete remote branch "${branch}": ${err.message}`);
+  }
+}
+
+module.exports = {
+  getGitPrefix,
+  getRepoRootDir,
+  getWorktrees,
+  fetchOrigin,
+  branchExistsLocally,
+  branchExistsRemotely,
+  createWorktree,
+  syncPrimaryBranch,
+  removeWorktree,
+  pruneWorktrees,
+  deleteLocalBranch,
+  deleteRemoteBranch,
+  isBareRepo,
+};

package/lib/herdr.js

@@ -0,0 +1,217 @@
+const { execSync, spawnSync } = require('child_process');
+const path = require('path');
+const os = require('os');
+const readline = require('readline');
+
+function isCommandAvailable(cmd) {
+  try {
+    const checkCmd = process.platform === 'win32' ? `where ${cmd}` : `command -v ${cmd}`;
+    execSync(checkCmd, { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isHerdrInstalled() {
+  const localBin = path.join(os.homedir(), '.local', 'bin');
+  if (process.env.PATH && !process.env.PATH.split(path.delimiter).includes(localBin)) {
+    process.env.PATH = `${localBin}${path.delimiter}${process.env.PATH}`;
+  }
+  return isCommandAvailable('herdr');
+}
+
+function getRecommendedInstallCommand() {
+  if (process.platform === 'darwin' && isCommandAvailable('brew')) {
+    return {
+      name: 'Homebrew',
+      cmd: 'brew install herdr',
+      docsUrl: 'https://herdr.dev/docs/install/#install-with-homebrew',
+    };
+  }
+  if (isCommandAvailable('mise')) {
+    return {
+      name: 'mise',
+      cmd: 'mise use -g herdr',
+      docsUrl: 'https://herdr.dev/docs/install/#install-with-mise',
+    };
+  }
+  if (process.platform === 'win32') {
+    return {
+      name: 'PowerShell Installer',
+      cmd: 'powershell -ExecutionPolicy Bypass -c "irm https://herdr.dev/install.ps1 | iex"',
+      docsUrl: 'https://herdr.dev/docs/install/',
+    };
+  }
+  return {
+    name: 'Official Install Script',
+    cmd: 'curl -fsSL https://herdr.dev/install.sh | sh',
+    docsUrl: 'https://herdr.dev/docs/install/',
+  };
+}
+
+function promptUser(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+async function ensureHerdrInstalled(options = {}) {
+  if (isHerdrInstalled()) {
+    return true;
+  }
+
+  const { name, cmd, docsUrl } = getRecommendedInstallCommand();
+  const autoConfirm = Boolean(options.yes);
+
+  if (!autoConfirm && (!process.stdin.isTTY || process.env.CI)) {
+    console.error(`\n[arise] Error: "herdr" is required to manage terminal workspaces but was not found in PATH.`);
+    console.error(`Please install Herdr before running arise:\n  ${cmd}\n`);
+    console.error(`Docs: ${docsUrl || 'https://herdr.dev/docs/install/'}`);
+    process.exit(1);
+  }
+
+  if (!autoConfirm) {
+    console.log(`\n[arise] "herdr" is required to manage terminal workspaces but was not found in PATH.`);
+    const answer = await promptUser(`Would you like arise to install Herdr now via ${name} (\`${cmd}\`)? [Y/n]: `);
+    if (answer && !/^(y|yes)$/i.test(answer)) {
+      console.error('\nCannot proceed without Herdr. Aborting.');
+      process.exit(1);
+    }
+  }
+
+  console.log(`\n==> Installing Herdr via ${name}...`);
+  const result = spawnSync(cmd, { stdio: 'inherit', shell: true });
+
+  if (result.status !== 0 || !isHerdrInstalled()) {
+    console.error(`\n[arise] Failed to automatically install Herdr.`);
+    console.error(`Please visit https://herdr.dev/docs/install/ to install manually.`);
+    process.exit(1);
+  }
+
+  console.log(`[arise] Herdr installed successfully!\n`);
+  return true;
+}
+
+function parseJsonFromOutput(output) {
+  if (!output) return null;
+  const line = output.split('\n').find(l => l.trim().startsWith('{'));
+  if (line) {
+    try {
+      return JSON.parse(line);
+    } catch (e) {}
+  }
+  try {
+    return JSON.parse(output);
+  } catch (e) {
+    return null;
+  }
+}
+
+function listWorkspaces() {
+  try {
+    const listOutput = execSync('herdr workspace list', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    const data = parseJsonFromOutput(listOutput);
+    return (data && data.result && data.result.workspaces) || [];
+  } catch (err) {
+    return [];
+  }
+}
+
+function createWorkspace({ label, cwd }) {
+  const wsOutput = execSync(`herdr workspace create --label "${label}" --cwd "${cwd}"`, { encoding: 'utf8' }).trim();
+  const res = parseJsonFromOutput(wsOutput);
+  if (!res || !res.result || !res.result.workspace) {
+    throw new Error(`Failed to create Herdr workspace "${label}". Raw output: ${wsOutput}`);
+  }
+  return {
+    workspaceId: res.result.workspace.workspace_id,
+    rootPaneId: res.result.root_pane ? res.result.root_pane.pane_id : null,
+  };
+}
+
+function closeWorkspace(workspaceId) {
+  try {
+    execSync(`herdr workspace close ${workspaceId}`, { stdio: 'ignore' });
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+function focusWorkspace(workspaceId) {
+  try {
+    execSync(`herdr workspace focus ${workspaceId}`, { stdio: 'ignore' });
+  } catch (e) {}
+}
+
+function splitPane({ paneId, direction = 'right', cwd, focus = false }) {
+  const focusFlag = focus ? '--focus' : '--no-focus';
+  const cwdFlag = cwd ? `--cwd "${cwd}"` : '';
+  const output = execSync(`herdr pane split --pane ${paneId} --direction ${direction} ${cwdFlag} ${focusFlag}`, { encoding: 'utf8' }).trim();
+  const res = parseJsonFromOutput(output);
+  if (!res || !res.result || !res.result.pane) {
+    throw new Error(`Failed to split pane ${paneId} direction ${direction}`);
+  }
+  return res.result.pane.pane_id;
+}
+
+function renamePane(paneId, name) {
+  try {
+    execSync(`herdr pane rename ${paneId} "${name}"`, { stdio: 'ignore' });
+  } catch (e) {}
+}
+
+function runInPane(paneId, command) {
+  if (!command) return;
+  try {
+    execSync(`herdr pane send-text ${paneId} "${command}"`, { stdio: 'ignore' });
+    execSync(`herdr pane send-keys ${paneId} enter`, { stdio: 'ignore' });
+  } catch (e) {
+    console.error(`Failed to execute command "${command}" in pane ${paneId}: ${e.message}`);
+  }
+}
+
+function closeWorkspacesMatching(matchTargets = []) {
+  const targets = matchTargets.filter(Boolean);
+  if (!targets.length) return;
+
+  const workspaces = listWorkspaces();
+  const matchingWorkspaces = workspaces.filter(w => targets.includes(w.label));
+
+  for (const ws of matchingWorkspaces) {
+    if (ws.workspace_id) {
+      console.log(`Closing Herdr workspace "${ws.label}" (ID: ${ws.workspace_id}) and terminating panes...`);
+      closeWorkspace(ws.workspace_id);
+      console.log(`Herdr workspace "${ws.label}" closed.`);
+    }
+  }
+}
+
+function attachOrSwitchSession(sessionName) {
+  if (process.env.HERDR_ENV === '1') {
+    console.log(`Already inside herdr. Workspace "${sessionName}" created and focused!`);
+  } else {
+    console.log(`Starting herdr session...`);
+    spawnSync('herdr', [], { stdio: 'inherit', shell: true });
+  }
+}
+
+module.exports = {
+  isHerdrInstalled,
+  getRecommendedInstallCommand,
+  ensureHerdrInstalled,
+  listWorkspaces,
+  createWorkspace,
+  closeWorkspace,
+  focusWorkspace,
+  splitPane,
+  renamePane,
+  runInPane,
+  closeWorkspacesMatching,
+  attachOrSwitchSession,
+};