@tsuzuku/arise 1.0.0

package/lib/git.js

@@ -0,0 +1,226 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+function getGitPrefix(options = {}) {
+  if (options.bareRepo) {
+    return `git --git-dir="${options.bareRepo}"`;
+  }
+  if (options.repoDir) {
+    return `git -C "${options.repoDir}"`;
+  }
+  return 'git';
+}
+
+function getRepoRootDir(cwd = process.cwd(), bareRepo = null) {
+  if (bareRepo && fs.existsSync(bareRepo)) {
+    return bareRepo;
+  }
+  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);
+    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 branchExistsLocally(branch, options = {}) {
+  const gitCmd = getGitPrefix(options);
+  try {
+    execSync(`${gitCmd} rev-parse --verify "${branch}"`, { stdio: 'ignore' });
+    return true;
+  } catch (e) {
+    try {
+      const list = execSync(`${gitCmd} branch --list "${branch}"`, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+      return list !== '';
+    } catch (err) {
+      return false;
+    }
+  }
+}
+
+function branchExistsRemotely(branch, options = {}) {
+  const gitCmd = getGitPrefix(options);
+  try {
+    execSync(`${gitCmd} rev-parse --verify "origin/${branch}"`, { stdio: 'ignore' });
+    return true;
+  } catch (e) {
+    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 (err) {
+      return false;
+    }
+  }
+}
+
+function createWorktree({ worktreePath, branch, source = 'develop', repoDir, bareRepo }) {
+  const options = { repoDir, bareRepo };
+  const gitCmd = getGitPrefix(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...`);
+    execSync(`${gitCmd} worktree add "${worktreePath}" -b "${branch}" "origin/${branch}"`, { stdio: 'inherit' });
+  } else {
+    // Creating a brand new branch off source
+    console.log('Fetching latest from origin...');
+    try {
+      execSync(`${gitCmd} fetch origin`, { stdio: 'inherit' });
+    } catch (e) {}
+
+    const remoteSourceExists = branchExistsRemotely(source, options);
+    const startPoint = remoteSourceExists ? `origin/${source}` : source;
+
+    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}...`);
+      execSync(`${gitCmd} fetch origin ${branch}`, { stdio: 'inherit' });
+      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,
+  branchExistsLocally,
+  branchExistsRemotely,
+  createWorktree,
+  syncPrimaryBranch,
+  removeWorktree,
+  pruneWorktrees,
+  deleteLocalBranch,
+  deleteRemoteBranch,
+};

package/lib/herdr.js

@@ -0,0 +1,117 @@
+const { execSync, spawnSync } = require('child_process');
+
+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 = {
+  listWorkspaces,
+  createWorkspace,
+  closeWorkspace,
+  focusWorkspace,
+  splitPane,
+  renamePane,
+  runInPane,
+  closeWorkspacesMatching,
+  attachOrSwitchSession,
+};

package/lib/layout.js

@@ -0,0 +1,85 @@
+const herdr = require('./herdr');
+
+/**
+ * Default standard 4-pane quadrant layout recipe
+ */
+const DEFAULT_QUADRANT_LAYOUT = [
+  { id: 'vim', title: 'vim', cmd: 'vim .', position: 'root' },
+  { id: 'server', title: 'server', cmd: null, split: 'right', from: 'vim' },
+  { id: 'shell', title: 'shell', cmd: null, split: 'down', from: 'vim' },
+  { id: 'agy', title: 'agy', cmd: 'agy', split: 'down', from: 'server', focus: true },
+];
+
+/**
+ * Render a declarative layout onto a Herdr workspace
+ * 
+ * @param {Object} options
+ * @param {Array} options.layout Array of pane definitions
+ * @param {string} options.rootPaneId ID of the root pane created with workspace
+ * @param {string} options.cwd Working directory for panes
+ * @param {string} options.focusTarget Name or ID of pane to focus (e.g. 'agy', 'vim', 'logs', 'shell')
+ */
+function renderLayout({ layout = DEFAULT_QUADRANT_LAYOUT, rootPaneId, cwd, focusTarget = 'agy' }) {
+  const paneMap = new Map(); // id -> paneId
+  let targetFocusPaneId = null;
+
+  // 1. First pass: identify which pane is targeted for focus
+  const normalizedFocus = (focusTarget || 'agy').toLowerCase().trim();
+
+  // Helper to check if a pane matches focus target
+  function isFocusMatch(paneDef) {
+    if (!normalizedFocus) return false;
+    const idMatch = paneDef.id && paneDef.id.toLowerCase() === normalizedFocus;
+    const titleMatch = paneDef.title && paneDef.title.toLowerCase() === normalizedFocus;
+    return idMatch || titleMatch;
+  }
+
+  // 2. Iterate through pane definitions
+  for (const paneDef of layout) {
+    let currentPaneId;
+
+    if (paneDef.position === 'root' || !paneDef.from) {
+      currentPaneId = rootPaneId;
+    } else {
+      const parentPaneId = paneMap.get(paneDef.from);
+      if (!parentPaneId) {
+        console.warn(`Layout warning: parent pane "${paneDef.from}" not found for "${paneDef.id}".`);
+        continue;
+      }
+
+      const shouldFocus = isFocusMatch(paneDef);
+      currentPaneId = herdr.splitPane({
+        paneId: parentPaneId,
+        direction: paneDef.split || 'right',
+        cwd,
+        focus: shouldFocus,
+      });
+    }
+
+    if (currentPaneId) {
+      paneMap.set(paneDef.id, currentPaneId);
+
+      if (paneDef.title) {
+        herdr.renamePane(currentPaneId, paneDef.title);
+      }
+
+      if (paneDef.cmd) {
+        herdr.runInPane(currentPaneId, paneDef.cmd);
+      }
+
+      if (isFocusMatch(paneDef)) {
+        targetFocusPaneId = currentPaneId;
+      }
+    }
+  }
+
+  return {
+    paneMap,
+    targetFocusPaneId,
+  };
+}
+
+module.exports = {
+  renderLayout,
+  DEFAULT_QUADRANT_LAYOUT,
+};

package/lib/lifecycle/create.js

@@ -0,0 +1,121 @@
+const fs = require('fs');
+const path = require('path');
+const git = require('../git');
+const herdr = require('../herdr');
+const layout = require('../layout');
+const { createContext } = require('../context');
+const { showUsage } = require('../cli');
+
+async function executeCreate(flags, config, cwd = process.cwd()) {
+  const branch = flags.branch;
+  if (!branch) {
+    console.error('Error: --branch is a required argument for creation.');
+    showUsage();
+    process.exit(1);
+  }
+
+  // 1. Resolve Dirname and Worktree Path
+  const sanitizedBranch = branch.replace(/\//g, '-');
+  const dirname = flags.dirname || sanitizedBranch;
+
+  const repoRoot = git.getRepoRootDir(cwd, config.repo.bareRepo);
+  const baseDir = config.repo.worktreesBase || repoRoot;
+  const worktreePath = path.resolve(baseDir, dirname);
+
+  // 2. Resolve Session / Workspace Name
+  const baseWorkspace = flags.workspaceName || dirname.replace(/[\s.:]/g, '_');
+  const prefix = config.workspace.labelPrefix || '';
+  const sessionName = (prefix && !baseWorkspace.startsWith(prefix.trim()))
+    ? `${prefix}${baseWorkspace}`
+    : baseWorkspace;
+
+  console.log(`\n=== Starting Herdr Worktree Session ===`);
+  console.log(`Active Preset:        ${config.preset ? config.preset.name : 'generic'}`);
+  console.log(`Repository Root:      ${repoRoot}`);
+  console.log(`Target Worktree Path: ${worktreePath}`);
+  console.log(`Workspace Name:       ${sessionName}`);
+  console.log(`Base Branch (Source): ${flags.source || config.repo.defaultBaseBranch}\n`);
+
+  // 3. Determine if Worktree Already Exists
+  const worktrees = git.getWorktrees({ repoDir: repoRoot, bareRepo: config.repo.bareRepo });
+  const existingWorktree = worktrees.find(wt => wt.branch === branch || path.resolve(wt.path) === path.resolve(worktreePath));
+
+  let worktreePathToUse = worktreePath;
+  let worktreeExists = false;
+
+  if (existingWorktree) {
+    worktreeExists = true;
+    worktreePathToUse = existingWorktree.path;
+    console.log(`Worktree already exists for branch "${branch}" at "${worktreePathToUse}".`);
+  } else if (fs.existsSync(worktreePath)) {
+    worktreeExists = true;
+    console.log(`Directory already exists at "${worktreePath}". Skipping git worktree creation.`);
+  }
+
+  // 4. Create Worktree if it doesn't exist
+  if (!worktreeExists) {
+    console.log(`Creating new git worktree for branch "${branch}"...`);
+    try {
+      git.createWorktree({
+        worktreePath,
+        branch,
+        source: flags.source || config.repo.defaultBaseBranch,
+        repoDir: repoRoot,
+        bareRepo: config.repo.bareRepo,
+      });
+    } catch (err) {
+      console.error(`Failed to create worktree: ${err.message}`);
+      process.exit(1);
+    }
+  }
+
+  // 5. Initialize Context for Hooks
+  const ctx = createContext({
+    worktreePath: worktreePathToUse,
+    repoRoot,
+    bareRepo: config.repo.bareRepo,
+    branch,
+    source: flags.source || config.repo.defaultBaseBranch,
+    flags,
+    preset: config.preset,
+    config,
+  });
+
+  // 6. Run Preset / Config Hooks
+  if (typeof config.hooks.onSyncPrimary === 'function') {
+    await config.hooks.onSyncPrimary(ctx);
+  }
+
+  if (!worktreeExists && typeof config.hooks.onScaffold === 'function') {
+    await config.hooks.onScaffold(ctx);
+  }
+
+  // 7. Orchestrate Herdr Workspace
+  console.log(`\n==> Creating Herdr workspace "${sessionName}"...`);
+  let ws;
+  try {
+    ws = herdr.createWorkspace({ label: sessionName, cwd: worktreePathToUse });
+  } catch (err) {
+    console.error(`Failed to create herdr workspace: ${err.message}`);
+    process.exit(1);
+  }
+
+  // 8. Render Terminal Layout
+  console.log(`==> Configuring terminal panes...`);
+  layout.renderLayout({
+    layout: config.layout,
+    rootPaneId: ws.rootPaneId,
+    cwd: worktreePathToUse,
+    focusTarget: flags.focusTarget || config.workspace.defaultFocus,
+  });
+
+  // Focus the workspace
+  herdr.focusWorkspace(ws.workspaceId);
+
+  // 9. Attach or Switch
+  herdr.attachOrSwitchSession(sessionName);
+}
+
+module.exports = {
+  executeCreate,
+};