@tsuzuku/arise 1.0.0

package/lib/lifecycle/nuke.js

@@ -0,0 +1,211 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const git = require('../git');
+const herdr = require('../herdr');
+const { createContext } = require('../context');
+const { showUsage } = require('../cli');
+
+async function executeNuke(flags, config, cwd = process.cwd()) {
+  const repoRoot = git.getRepoRootDir(cwd, config.repo.bareRepo);
+  const worktrees = git.getWorktrees({ repoDir: repoRoot, bareRepo: config.repo.bareRepo });
+
+  let target = flags.cleanupTarget || flags.dirname || flags.branch;
+
+  // 1. Auto-detect worktree if invoked inside a worktree directory without arguments
+  if (!target) {
+    const currentCwd = path.resolve(cwd);
+    const matchingWt = worktrees.find(wt => {
+      const resolvedWtPath = path.resolve(wt.path);
+      return resolvedWtPath !== path.resolve(repoRoot) && (
+        currentCwd === resolvedWtPath ||
+        currentCwd.startsWith(resolvedWtPath + path.sep)
+      );
+    });
+
+    if (matchingWt) {
+      target = matchingWt.path;
+      console.log(`Auto-detected current worktree: "${target}"`);
+    } else {
+      console.error('Error: --nuke / --cleanup requires a worktree directory name or branch when run from the root repository.');
+      showUsage();
+      process.exit(1);
+    }
+  }
+
+  // 2. Resolve worktree target path and matching branch
+  const baseDir = config.repo.worktreesBase || repoRoot;
+  const resolvedTarget = path.isAbsolute(target) ? path.resolve(target) : path.resolve(baseDir, target);
+
+  const existingWorktree = worktrees.find(wt => {
+    return (
+      path.resolve(wt.path) === resolvedTarget ||
+      path.basename(wt.path) === target ||
+      (wt.branch && wt.branch === target) ||
+      (flags.branch && wt.branch === flags.branch)
+    );
+  });
+
+  const targetWorktreePath = existingWorktree ? existingWorktree.path : resolvedTarget;
+  const targetDirname = path.basename(targetWorktreePath);
+  const targetSessionName = targetDirname.replace(/[\s.:]/g, '_');
+
+  let targetBranch = flags.branch;
+  if (!targetBranch && existingWorktree && existingWorktree.branch) {
+    targetBranch = existingWorktree.branch;
+  }
+  if (!targetBranch && fs.existsSync(targetWorktreePath)) {
+    try {
+      const detected = execSync(`git -C "${targetWorktreePath}" rev-parse --abbrev-ref HEAD`, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+      if (detected && detected !== 'HEAD') {
+        targetBranch = detected;
+      }
+    } catch (e) {}
+  }
+  if (!targetBranch) {
+    try {
+      const gitCmd = git.getGitPrefix({ repoDir: repoRoot, bareRepo: config.repo.bareRepo });
+      execSync(`${gitCmd} rev-parse --verify "${target}"`, { stdio: 'ignore' });
+      targetBranch = target;
+    } catch (e) {}
+  }
+
+  console.log(`\n=== Starting Worktree Nuke ===`);
+  console.log(`Active Preset:        ${config.preset ? config.preset.name : 'generic'}`);
+  console.log(`Repository Root:      ${repoRoot}`);
+  console.log(`Target Worktree Path: ${targetWorktreePath}`);
+  console.log(`Associated Branch:    ${targetBranch || '(None detected)'}`);
+  console.log(`Directory Only Mode:  ${flags.dirOnly ? 'Yes (branches will be preserved)' : 'No'}`);
+  console.log(`Keep Remote Branch:   ${flags.keepRemote ? 'Yes' : 'No'}\n`);
+
+  // Safety check: Never delete root repository
+  if (path.resolve(targetWorktreePath) === path.resolve(repoRoot)) {
+    console.error(`Error: Cannot delete the repository root directory "${repoRoot}".`);
+    process.exit(1);
+  }
+
+  // If cwd is inside the target worktree, switch to rootDir/baseDir
+  if (path.resolve(process.cwd()).startsWith(path.resolve(targetWorktreePath))) {
+    console.log(`Current working directory is inside target worktree. Switching to: ${baseDir}`);
+    try {
+      process.chdir(baseDir);
+    } catch (e) {}
+  }
+
+  // Initialize context for hooks
+  const ctx = createContext({
+    worktreePath: targetWorktreePath,
+    repoRoot,
+    bareRepo: config.repo.bareRepo,
+    branch: targetBranch,
+    flags,
+    preset: config.preset,
+    config,
+  });
+
+  // Pre-Nuke Hook
+  if (typeof config.hooks.onPreNuke === 'function') {
+    await config.hooks.onPreNuke(ctx);
+  }
+
+  // 1. Close Herdr Workspace if running
+  const prefix = config.workspace.labelPrefix || '';
+  const matchTargets = [
+    targetSessionName,
+    targetDirname,
+    targetBranch,
+    prefix ? `${prefix}${targetSessionName}` : null,
+    prefix ? `${prefix}${targetDirname}` : null,
+  ].filter(Boolean);
+
+  herdr.closeWorkspacesMatching(matchTargets);
+
+  // 2. Remove Worktree & Directory
+  console.log(`\n==> [1/3] Removing git worktree and directory...`);
+  const isRegisteredWorktree = worktrees.some(wt => path.resolve(wt.path) === path.resolve(targetWorktreePath));
+
+  if (isRegisteredWorktree) {
+    git.removeWorktree(targetWorktreePath, {
+      force: flags.force,
+      repoDir: repoRoot,
+      bareRepo: config.repo.bareRepo,
+    });
+  }
+
+  // Prune any stale worktree entries
+  git.pruneWorktrees({ repoDir: repoRoot, bareRepo: config.repo.bareRepo });
+
+  // Remove any remaining files or untracked directory
+  if (fs.existsSync(targetWorktreePath)) {
+    console.log(`Removing remaining directory "${targetWorktreePath}"...`);
+    try {
+      fs.rmSync(targetWorktreePath, { recursive: true, force: true });
+      console.log(`Directory deleted successfully.`);
+    } catch (err) {
+      console.error(`Failed to delete directory "${targetWorktreePath}": ${err.message}`);
+    }
+  } else {
+    console.log(`Worktree directory is clean.`);
+  }
+
+  // 3. Delete Local Branch
+  if (flags.dirOnly) {
+    console.log(`\n==> Skipping branch deletion (--dir-only / --keep-branch).`);
+    if (typeof config.hooks.onPostNuke === 'function') await config.hooks.onPostNuke(ctx);
+    console.log(`\nCleanup complete!`);
+    process.exit(0);
+  }
+
+  const protectedBranches = config.repo.protectedBranches || ['main', 'master', 'develop', 'prod', 'staging', 'production'];
+  if (targetBranch && protectedBranches.includes(targetBranch)) {
+    console.warn(`\n==> WARNING: "${targetBranch}" is a protected branch. Skipping local and remote branch deletion.`);
+    if (typeof config.hooks.onPostNuke === 'function') await config.hooks.onPostNuke(ctx);
+    console.log(`\nCleanup complete!`);
+    process.exit(0);
+  }
+
+  if (!targetBranch) {
+    console.log(`\n==> No branch associated with "${target}". Skipping branch deletion.`);
+    if (typeof config.hooks.onPostNuke === 'function') await config.hooks.onPostNuke(ctx);
+    console.log(`\nCleanup complete!`);
+    process.exit(0);
+  }
+
+  console.log(`\n==> [2/3] Deleting local branch "${targetBranch}"...`);
+  const gitOpts = { repoDir: repoRoot, bareRepo: config.repo.bareRepo };
+  const existsLocally = git.branchExistsLocally(targetBranch, gitOpts);
+
+  if (existsLocally) {
+    git.deleteLocalBranch(targetBranch, gitOpts);
+  } else {
+    console.log(`Local branch "${targetBranch}" does not exist or was already deleted.`);
+  }
+
+  // 4. Delete Remote Branch
+  if (flags.keepRemote) {
+    console.log(`\n==> Skipping remote branch deletion (--keep-remote / --local-only).`);
+    if (typeof config.hooks.onPostNuke === 'function') await config.hooks.onPostNuke(ctx);
+    console.log(`\nCleanup complete!`);
+    process.exit(0);
+  }
+
+  console.log(`\n==> [3/3] Deleting remote branch "${targetBranch}" from origin...`);
+  const existsRemotely = git.branchExistsRemotely(targetBranch, gitOpts);
+
+  if (existsRemotely) {
+    git.deleteRemoteBranch(targetBranch, gitOpts);
+  } else {
+    console.log(`Remote branch "${targetBranch}" does not exist on origin or was already deleted.`);
+  }
+
+  // Post-Nuke Hook
+  if (typeof config.hooks.onPostNuke === 'function') {
+    await config.hooks.onPostNuke(ctx);
+  }
+
+  console.log(`\nCleanup complete!`);
+}
+
+module.exports = {
+  executeNuke,
+};

package/lib/skill.js

@@ -0,0 +1,200 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const SKILL_CONTENT = `---
+name: arise
+description: User guide, CLI reference, and command executor for the \`arise\` utility (Git worktree and Herdr workspace orchestrator). Activate this skill whenever the user asks questions about how to use arise, how worktree orchestration works, how to configure \`.ariserc.json\` or \`.worktreerc.json\`, or asks the assistant to create, switch to, or nuke/clean up Git worktrees and Herdr workspaces on their behalf.
+---
+
+# Arise Operator & Assistant Guide
+
+Use this skill to answer questions about \`arise\` and run worktree management commands on the user's behalf.
+
+---
+
+## 1. CLI Quick Reference & Cheatsheet
+
+### Creating Worktrees
+\`\`\`bash
+# Create or open a worktree for a branch (auto-detects preset, boots Herdr workspace)
+arise --branch <branch-name>
+
+# Create worktree based off a specific base branch (e.g. develop, prod, main)
+arise --branch <branch-name> --base <base-branch>
+
+# Custom directory name or workspace name
+arise -b <branch-name> -d <dir-name> -w <workspace-name>
+
+# Explicit preset or pane focus ('agy', 'vim', 'logs', 'server', 'shell')
+arise -b <branch-name> --preset laravel --focus agy
+\`\`\`
+
+### Nuking / Teardown
+\`\`\`bash
+# Nuke active worktree (when run inside a worktree directory)
+arise --nuke
+
+# Nuke specific worktree by branch or directory name
+arise --nuke <branch-or-dir>
+
+# Remove directory only (keep local and remote git branches)
+arise --nuke <target> --dir-only
+
+# Delete local branch and directory, but keep remote branch on origin
+arise --nuke <target> --keep-remote
+
+# Force removal even if uncommitted changes exist
+arise --nuke <target> --force
+\`\`\`
+
+---
+
+## 2. Configuration (\`.ariserc.json\` / \`.worktreerc.json\` / \`arise.config.js\`)
+
+Projects can configure custom topology, bare repos, and layouts via \`.ariserc.json\` or \`.worktreerc.json\` in the repository root or base directory:
+
+\`\`\`json
+{
+  "preset": "laravel",
+  "repo": {
+    "bareRepo": "/path/to/bare.git",
+    "worktreesBase": "/path/to/worktrees",
+    "defaultBaseBranch": "develop",
+    "protectedBranches": ["main", "master", "develop", "prod", "staging"]
+  },
+  "workspace": {
+    "labelPrefix": "[API] ",
+    "defaultFocus": "agy"
+  },
+  "scaffold": {
+    "envSource": "/path/to/shared/.env",
+    "symlink": "/path/to/webserver/symlink",
+    "install": "composer install --no-interaction"
+  }
+}
+\`\`\`
+
+---
+
+## 3. How to Assist the User
+
+### When the User Asks Questions:
+1. Consult the CLI options and configuration schema above.
+2. If working inside a repository with local documentation or \`.ariserc.json\` / \`.worktreerc.json\`, inspect those files.
+3. Provide clear explanations with executable CLI examples and config snippets.
+
+### When the User Asks You to Perform an Action:
+1. Formulate the appropriate \`arise\` CLI command.
+2. Execute the command on behalf of the user using the available command runner.
+3. Confirm the status of the created or nuked worktree and Herdr workspace.
+`;
+
+function ensureSourceSkillExists(repoRoot) {
+  const sourceDir = path.join(repoRoot, 'skills', 'arise');
+  const sourceFile = path.join(sourceDir, 'SKILL.md');
+  if (fs.existsSync(sourceFile)) {
+    return sourceDir;
+  }
+  try {
+    fs.mkdirSync(sourceDir, { recursive: true });
+    fs.writeFileSync(sourceFile, SKILL_CONTENT, 'utf8');
+  } catch (err) {
+    // Proceed with sourceDir even if write fails (e.g. read-only global node_modules)
+  }
+  return sourceDir;
+}
+
+function safeSymlink(target, linkPath) {
+  try {
+    if (fs.existsSync(linkPath) || fs.lstatSync(linkPath).isSymbolicLink()) {
+      fs.rmSync(linkPath, { recursive: true, force: true });
+    }
+  } catch (err) {
+    // If doesn't exist, proceed
+  }
+  fs.symlinkSync(target, linkPath, 'dir');
+}
+
+function installSkill(options = {}) {
+  const scope = options.scope || 'global';
+  const cwd = options.cwd || process.cwd();
+  const homedir = options.homedir || os.homedir();
+  const repoRoot = options.repoRoot || path.resolve(__dirname, '..');
+
+  const sourceDir = ensureSourceSkillExists(repoRoot);
+  const installedPaths = [];
+
+  if (scope === 'local' || scope === 'workspace') {
+    const localAgentsSkillsDir = path.join(cwd, '.agents', 'skills');
+    fs.mkdirSync(localAgentsSkillsDir, { recursive: true });
+    const localLink = path.join(localAgentsSkillsDir, 'arise');
+
+    try {
+      safeSymlink(sourceDir, localLink);
+      installedPaths.push(localLink);
+      console.log(`✓ Symlinked local agent skill: ${localLink} -> ${sourceDir}`);
+    } catch (err) {
+      // Fallback to direct file copy if symlink creation fails
+      const fallbackFile = path.join(localLink, 'SKILL.md');
+      fs.mkdirSync(localLink, { recursive: true });
+      fs.writeFileSync(fallbackFile, SKILL_CONTENT, 'utf8');
+      installedPaths.push(fallbackFile);
+      console.log(`✓ Installed local agent skill (copy): ${fallbackFile}`);
+    }
+  } else {
+    // Universal ~/.agents/skills/ directory
+    const globalAgentsSkillsDir = path.join(homedir, '.agents', 'skills');
+    fs.mkdirSync(globalAgentsSkillsDir, { recursive: true });
+    const globalAgentsLink = path.join(globalAgentsSkillsDir, 'arise');
+
+    try {
+      safeSymlink(sourceDir, globalAgentsLink);
+      installedPaths.push(globalAgentsLink);
+      console.log(`✓ Symlinked global agent skill: ${globalAgentsLink} -> ${sourceDir}`);
+    } catch (err) {
+      // Fallback to copy if symlink permissions fail
+      const fallbackDir = path.join(globalAgentsSkillsDir, 'arise');
+      fs.mkdirSync(fallbackDir, { recursive: true });
+      const targetFile = path.join(fallbackDir, 'SKILL.md');
+      fs.writeFileSync(targetFile, SKILL_CONTENT, 'utf8');
+      installedPaths.push(targetFile);
+      console.log(`✓ Installed global agent skill (copy): ${targetFile}`);
+    }
+
+    // Link ~/.gemini/skills/arise for Antigravity CLI (agy)
+    const geminiSkillsDir = path.join(homedir, '.gemini', 'skills');
+    try {
+      fs.mkdirSync(geminiSkillsDir, { recursive: true });
+      const geminiLink = path.join(geminiSkillsDir, 'arise');
+      safeSymlink(globalAgentsLink, geminiLink);
+      installedPaths.push(geminiLink);
+      console.log(`✓ Linked to Antigravity skills: ${geminiLink} -> ${globalAgentsLink}`);
+    } catch (err) {
+      // Non-fatal
+    }
+
+    // Link ~/.claude/skills/arise if Claude exists
+    const claudeDir = path.join(homedir, '.claude');
+    if (fs.existsSync(claudeDir)) {
+      try {
+        const claudeSkillsDir = path.join(claudeDir, 'skills');
+        fs.mkdirSync(claudeSkillsDir, { recursive: true });
+        const claudeLink = path.join(claudeSkillsDir, 'arise');
+        safeSymlink(globalAgentsLink, claudeLink);
+        installedPaths.push(claudeLink);
+        console.log(`✓ Linked to Claude skills: ${claudeLink} -> ${globalAgentsLink}`);
+      } catch (err) {
+        // Non-fatal
+      }
+    }
+  }
+
+  return installedPaths;
+}
+
+module.exports = {
+  SKILL_CONTENT,
+  ensureSourceSkillExists,
+  installSkill,
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@tsuzuku/arise",
+  "version": "1.0.0",
+  "description": "Arise - Unified workplace-agnostic Git worktree and Herdr workspace orchestrator with pluggable project presets",
+  "main": "index.js",
+  "bin": {
+    "arise": "bin/cli.js",
+    "herdr-worktree": "bin/cli.js",
+    "herder-worktree": "bin/cli.js",
+    "hwk": "bin/cli.js"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "presets",
+    "skills",
+    "index.js",
+    "types.d.ts",
+    "arise.schema.json",
+    "worktree.schema.json",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "test": "node --test test/*.test.js"
+  },
+  "keywords": [
+    "git",
+    "worktree",
+    "herdr",
+    "workspace",
+    "laravel",
+    "node",
+    "cli"
+  ],
+  "author": "",
+  "license": "ISC"
+}

package/presets/generic.js

@@ -0,0 +1,33 @@
+const fs = require('fs');
+const path = require('path');
+
+module.exports = {
+  name: 'generic',
+
+  detect(cwd) {
+    return true; // Fallback preset
+  },
+
+  repo: {
+    defaultBaseBranch: 'main',
+    protectedBranches: ['main', 'master', 'develop', 'prod', 'staging', 'production'],
+  },
+
+  workspace: {
+    labelPrefix: '',
+    defaultFocus: 'agy',
+  },
+
+  layout: [
+    { id: 'vim', title: 'vim', cmd: 'vim .', position: 'root' },
+    { id: 'shell', title: 'shell', cmd: null, split: 'right', from: 'vim' },
+    { id: 'agy', title: 'agy', cmd: 'agy', split: 'down', from: 'shell', focus: true },
+  ],
+
+  hooks: {
+    async onScaffold(ctx) {
+      // Copy .env from root if available
+      ctx.copyFromRoot('.env', '.env');
+    },
+  },
+};

package/presets/index.js

@@ -0,0 +1,39 @@
+const nodePreset = require('./node');
+const laravelPreset = require('./laravel');
+const genericPreset = require('./generic');
+
+const builtInPresets = [
+  laravelPreset, // Check Laravel/PHP before generic
+  nodePreset,    // Check Node before generic
+  genericPreset, // Catch-all fallback
+];
+
+function getPreset(name) {
+  if (!name) return null;
+  const normalized = name.toLowerCase().trim();
+  if (normalized === 'php' || normalized === 'laravel' || normalized === 'api' || normalized === 'be') {
+    return laravelPreset;
+  }
+  if (normalized === 'node' || normalized === 'js' || normalized === 'ts' || normalized === 'fe' || normalized === 'react') {
+    return nodePreset;
+  }
+  if (normalized === 'generic' || normalized === 'default') {
+    return genericPreset;
+  }
+  return null;
+}
+
+function detectPreset(cwd = process.cwd()) {
+  for (const preset of builtInPresets) {
+    if (typeof preset.detect === 'function' && preset.detect(cwd)) {
+      return preset;
+    }
+  }
+  return genericPreset;
+}
+
+module.exports = {
+  getPreset,
+  detectPreset,
+  builtInPresets,
+};

package/presets/laravel.js

@@ -0,0 +1,115 @@
+const fs = require('fs');
+const path = require('path');
+const git = require('../lib/git');
+
+module.exports = {
+  name: 'laravel',
+
+  detect(cwd) {
+    return fs.existsSync(path.join(cwd, 'artisan')) || fs.existsSync(path.join(cwd, 'composer.json'));
+  },
+
+  repo: {
+    defaultBaseBranch: 'main',
+    protectedBranches: ['staging', 'prod', 'master', 'main', 'develop'],
+  },
+
+  workspace: {
+    labelPrefix: '',
+    defaultFocus: 'agy',
+  },
+
+  layout: [
+    { id: 'vim', title: 'vim', cmd: 'vim .', position: 'root' },
+    { id: 'logs', title: 'logs', cmd: 'tail -f storage/logs/laravel.log', split: 'right', from: 'vim' },
+    { id: 'shell', title: 'shell', cmd: null, split: 'down', from: 'vim' },
+    { id: 'agy', title: 'agy', cmd: 'agy', split: 'down', from: 'logs', focus: true },
+  ],
+
+  hooks: {
+    async onSyncPrimary(ctx) {
+      git.syncPrimaryBranch({
+        branch: ctx.branch,
+        worktreePath: ctx.worktreePath,
+        repoDir: ctx.repoRoot,
+        bareRepo: ctx.bareRepo,
+        protectedBranches: ['staging', 'prod', 'master', 'main', 'develop'],
+      });
+    },
+
+    async onScaffold(ctx) {
+      // 1. Environment (.env) Setup
+      console.log('==> Ensuring .env file...');
+      const rootEnv = ctx.repoRoot ? path.join(ctx.repoRoot, '.env') : null;
+      const targetEnv = path.join(ctx.worktreePath, '.env');
+
+      if (!fs.existsSync(targetEnv)) {
+        if (ctx.config.scaffold && ctx.config.scaffold.envSource && fs.existsSync(ctx.config.scaffold.envSource)) {
+          ctx.copyFile(ctx.config.scaffold.envSource, targetEnv);
+        } else if (rootEnv && fs.existsSync(rootEnv)) {
+          ctx.copyFile(rootEnv, targetEnv);
+        } else {
+          console.warn('==> No .env source found to copy.');
+        }
+      }
+
+      // 2. Dependencies & Initialization
+      console.log('==> Initializing repository (permissions, composer, etc.)...');
+      try {
+        const installCmd = (ctx.config.scaffold && ctx.config.scaffold.install !== undefined)
+          ? ctx.config.scaffold.install
+          : 'composer install --no-interaction';
+
+        if (installCmd) {
+          console.log(`Running dependency installation: "${installCmd}" in "${ctx.worktreePath}"...`);
+          ctx.exec(installCmd);
+        } else {
+          console.log('Skipping composer installation (scaffold.install is disabled).');
+        }
+
+        const permissionsScript = `
+mkdir -p storage/logs
+chmod 777 storage/logs
+touch storage/logs/laravel.log
+chmod 666 storage/logs/laravel.log
+mkdir -p storage/framework/sessions
+chmod o+w storage/framework/sessions
+mkdir -p storage/framework/data
+chmod o+w storage/framework/data
+mkdir -p storage/framework/cache/data
+chmod 777 storage/framework/cache/data
+mkdir -p bootstrap/cache
+chmod 777 bootstrap/cache
+mkdir -p storage/temp
+chmod 777 storage/temp
+if [ -d .githooks ]; then git config core.hooksPath .githooks; fi
+`;
+        ctx.exec(permissionsScript);
+      } catch (err) {
+        console.warn(`==> Warning during repository initialization: ${err.message}`);
+      }
+
+      // 3. Update Web Server Symlink if configured
+      const symlinkPath = ctx.config.scaffold && ctx.config.scaffold.symlink;
+      if (symlinkPath) {
+        ctx.setSymlink(symlinkPath, ctx.worktreePath);
+      }
+    },
+
+    async onPreNuke(ctx) {
+      const symlinkPath = ctx.config.scaffold && ctx.config.scaffold.symlink;
+      if (symlinkPath && fs.existsSync(symlinkPath)) {
+        try {
+          const lstat = fs.lstatSync(symlinkPath);
+          if (lstat.isSymbolicLink()) {
+            const currentTarget = fs.realpathSync(symlinkPath);
+            if (path.resolve(currentTarget) === path.resolve(ctx.worktreePath)) {
+              console.log(`==> Unlinking active web symlink "${symlinkPath}" pointing to nuked worktree...`);
+              fs.unlinkSync(symlinkPath);
+            }
+          }
+        } catch (e) {}
+      }
+    },
+  },
+};

package/presets/node.js

@@ -0,0 +1,50 @@
+const fs = require('fs');
+const path = require('path');
+
+module.exports = {
+  name: 'node',
+
+  detect(cwd) {
+    return fs.existsSync(path.join(cwd, 'package.json'));
+  },
+
+  repo: {
+    defaultBaseBranch: 'develop',
+    protectedBranches: ['main', 'master', 'develop', 'prod', 'staging', 'production'],
+  },
+
+  workspace: {
+    labelPrefix: '',
+    defaultFocus: 'agy',
+  },
+
+  layout: [
+    { id: 'vim', title: 'vim', cmd: 'vim .', position: 'root' },
+    { id: 'server', title: 'npm server', cmd: 'npm run dev', 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 },
+  ],
+
+  hooks: {
+    async onScaffold(ctx) {
+      // 1. Copy .env from root if available
+      ctx.copyFromRoot('.env', '.env');
+
+      // 2. Install dependencies
+      const installCmd = (ctx.config.scaffold && ctx.config.scaffold.install !== undefined)
+        ? ctx.config.scaffold.install
+        : 'npm install';
+
+      if (installCmd) {
+        console.log(`Running dependency installation: "${installCmd}" in "${ctx.worktreePath}"...`);
+        try {
+          ctx.exec(installCmd);
+        } catch (err) {
+          console.warn(`Warning: Dependency installation exited with an error: ${err.message}`);
+        }
+      } else {
+        console.log('Skipping dependency installation (scaffold.install is disabled).');
+      }
+    },
+  },
+};