@tsuzuku/arise 1.1.0 → 1.2.0

package/lib/lifecycle/create.js

@@ -4,7 +4,9 @@ const git = require('../git');
 const herdr = require('../herdr');
 const layout = require('../layout');
 const { createContext } = require('../context');
+const { resolveConfiguration } = require('../config');
 const { showUsage } = require('../cli');
+const logger = require('../logger');
 
 async function executeCreate(flags, config, cwd = process.cwd()) {
   const branch = flags.branch;
@@ -19,13 +21,13 @@ async function executeCreate(flags, config, cwd = process.cwd()) {
   const dirname = flags.dirname || sanitizedBranch;
 
   const repoRoot = git.getRepoRootDir(cwd, config.repo.bareRepo);
-  const baseDir = config.repo.worktreesBase || repoRoot;
+  const baseDir = config.repo.worktreesBase || (git.isBareRepo(repoRoot) ? path.dirname(repoRoot) : 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()))
+  let prefix = config.workspace.labelPrefix || '';
+  let sessionName = (prefix && !baseWorkspace.startsWith(prefix.trim()))
     ? `${prefix}${baseWorkspace}`
     : baseWorkspace;
 
@@ -64,30 +66,60 @@ async function executeCreate(flags, config, cwd = process.cwd()) {
         bareRepo: config.repo.bareRepo,
       });
     } catch (err) {
-      console.error(`Failed to create worktree: ${err.message}`);
+      logger.error(`Failed to create worktree: ${err.message}`, err);
       process.exit(1);
     }
   }
 
-  // 5. Initialize Context for Hooks
+  // 5. Re-resolve config using target worktree directory for branch-specific overrides with caller cwd fallback
+  let activeConfig = resolveConfiguration(flags, worktreePathToUse, cwd);
+
+  // If the worktree was freshly created and caller had an active configuration file in cwd, sync it into the new worktree
+  if (!worktreeExists && config.configFile && fs.existsSync(config.configFile)) {
+    try {
+      const targetConfigPath = path.join(worktreePathToUse, path.basename(config.configFile));
+      fs.copyFileSync(config.configFile, targetConfigPath);
+      logger.debug(`Synced configuration file from caller to new worktree: ${config.configFile} -> ${targetConfigPath}`);
+      activeConfig = resolveConfiguration(flags, worktreePathToUse, cwd);
+    } catch (err) {
+      logger.warn(`Could not sync caller config file to new worktree: ${err.message}`);
+    }
+  }
+
+  if (config.layout && config.layout.length > 0 && config.configFile && (!activeConfig.configFile || activeConfig.configFile.includes('.bare'))) {
+    activeConfig.layout = config.layout;
+  }
+
+  logger.debug(`Active configuration for target="${worktreePathToUse}" (caller="${cwd}"):`, {
+    configFile: activeConfig.configFile,
+    layoutCount: activeConfig.layout?.length,
+    panes: activeConfig.layout?.map((p) => ({ id: p.id, title: p.title, from: p.from, split: p.split })),
+  });
+
+  prefix = activeConfig.workspace.labelPrefix || '';
+  sessionName = (prefix && !baseWorkspace.startsWith(prefix.trim()))
+    ? `${prefix}${baseWorkspace}`
+    : baseWorkspace;
+
+  // Initialize Context for Hooks
   const ctx = createContext({
     worktreePath: worktreePathToUse,
     repoRoot,
-    bareRepo: config.repo.bareRepo,
+    bareRepo: activeConfig.repo.bareRepo,
     branch,
-    source: flags.source || config.repo.defaultBaseBranch,
+    source: flags.source || activeConfig.repo.defaultBaseBranch,
     flags,
-    preset: config.preset,
-    config,
+    preset: activeConfig.preset,
+    config: activeConfig,
   });
 
   // 6. Run Preset / Config Hooks
-  if (typeof config.hooks.onSyncPrimary === 'function') {
-    await config.hooks.onSyncPrimary(ctx);
+  if (typeof activeConfig.hooks.onSyncPrimary === 'function') {
+    await activeConfig.hooks.onSyncPrimary(ctx);
   }
 
-  if (!worktreeExists && typeof config.hooks.onScaffold === 'function') {
-    await config.hooks.onScaffold(ctx);
+  if (!worktreeExists && typeof activeConfig.hooks.onScaffold === 'function') {
+    await activeConfig.hooks.onScaffold(ctx);
   }
 
   // 7. Orchestrate Herdr Workspace
@@ -105,10 +137,10 @@ async function executeCreate(flags, config, cwd = process.cwd()) {
   // 8. Render Terminal Layout
   console.log(`==> Configuring terminal panes...`);
   layout.renderLayout({
-    layout: config.layout,
+    layout: activeConfig.layout,
     rootPaneId: ws.rootPaneId,
     cwd: worktreePathToUse,
-    focusTarget: flags.focusTarget || config.workspace.defaultFocus,
+    focusTarget: flags.focusTarget || activeConfig.workspace.defaultFocus,
   });
 
   // Focus the workspace

package/lib/lifecycle/nuke.js

@@ -4,7 +4,15 @@ const { execSync } = require('child_process');
 const git = require('../git');
 const herdr = require('../herdr');
 const { createContext } = require('../context');
+const { resolveConfiguration } = require('../config');
 const { showUsage } = require('../cli');
+const { promptConfirm } = require('../tui/prompt');
+
+function getRepoDisplayName(repoPath) {
+  if (!repoPath) return 'unknown';
+  const cleaned = repoPath.replace(/[/\\]\.bare$/, '').replace(/[/\\]\.git$/, '');
+  return path.basename(cleaned) || repoPath;
+}
 
 async function executeNuke(flags, config, cwd = process.cwd()) {
   const repoRoot = git.getRepoRootDir(cwd, config.repo.bareRepo);
@@ -16,6 +24,7 @@ async function executeNuke(flags, config, cwd = process.cwd()) {
   if (!target) {
     const currentCwd = path.resolve(cwd);
     const matchingWt = worktrees.find(wt => {
+      if (wt.isBare) return false;
       const resolvedWtPath = path.resolve(wt.path);
       return resolvedWtPath !== path.resolve(repoRoot) && (
         currentCwd === resolvedWtPath ||
@@ -50,6 +59,10 @@ async function executeNuke(flags, config, cwd = process.cwd()) {
   const targetDirname = path.basename(targetWorktreePath);
   const targetSessionName = targetDirname.replace(/[\s.:]/g, '_');
 
+  const activeConfig = fs.existsSync(targetWorktreePath)
+    ? resolveConfiguration(flags, targetWorktreePath)
+    : config;
+
   let targetBranch = flags.branch;
   if (!targetBranch && existingWorktree && existingWorktree.branch) {
     targetBranch = existingWorktree.branch;
@@ -64,26 +77,60 @@ async function executeNuke(flags, config, cwd = process.cwd()) {
   }
   if (!targetBranch) {
     try {
-      const gitCmd = git.getGitPrefix({ repoDir: repoRoot, bareRepo: config.repo.bareRepo });
+      const gitCmd = git.getGitPrefix({ repoDir: repoRoot, bareRepo: activeConfig.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(`Active Preset:        ${activeConfig.preset ? activeConfig.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
+  // Safety check 1: Never delete root repository
   if (path.resolve(targetWorktreePath) === path.resolve(repoRoot)) {
     console.error(`Error: Cannot delete the repository root directory "${repoRoot}".`);
     process.exit(1);
   }
 
+  // Safety check 2: Cross-repository nuke detection
+  const callerRepoRoot = git.getRepoRootDir(cwd, config.repo.bareRepo);
+  const targetRepoRoot = fs.existsSync(targetWorktreePath)
+    ? git.getRepoRootDir(targetWorktreePath, activeConfig.repo.bareRepo)
+    : repoRoot;
+
+  const isCrossRepo = callerRepoRoot && targetRepoRoot &&
+    path.resolve(callerRepoRoot) !== path.resolve(targetRepoRoot);
+
+  if (isCrossRepo) {
+    const callerRepoName = getRepoDisplayName(callerRepoRoot);
+    const targetRepoName = getRepoDisplayName(targetRepoRoot);
+
+    console.warn(`\x1b[1m\x1b[33m⚠️  CROSS-REPOSITORY NUKE DETECTED\x1b[39m\x1b[22m`);
+    console.warn(`─────────────────────────────────────────────────────────────────`);
+    console.warn(`• Caller CWD:         ${cwd} (Repo: ${callerRepoName})`);
+    console.warn(`• Target Worktree:   ${targetWorktreePath} (Repo: ${targetRepoName})`);
+    console.warn(`• Associated Branch: ${targetBranch || '(None detected)'}`);
+    console.warn(`─────────────────────────────────────────────────────────────────`);
+    console.warn(`You are invoking --nuke from a different repository than the target worktree!\n`);
+
+    if (!flags.yes && !flags.force && process.stdin.isTTY && !process.env.CI) {
+      const confirmed = await promptConfirm({
+        question: `Are you sure you want to nuke this worktree from another repository?`,
+        defaultYes: false,
+      });
+
+      if (!confirmed) {
+        console.log(`\nAborted. No worktrees or branches were deleted.`);
+        return;
+      }
+    }
+  }
+
   // 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}`);
@@ -96,16 +143,16 @@ async function executeNuke(flags, config, cwd = process.cwd()) {
   const ctx = createContext({
     worktreePath: targetWorktreePath,
     repoRoot,
-    bareRepo: config.repo.bareRepo,
+    bareRepo: activeConfig.repo.bareRepo,
     branch: targetBranch,
     flags,
-    preset: config.preset,
-    config,
+    preset: activeConfig.preset,
+    config: activeConfig,
   });
 
   // Pre-Nuke Hook
-  if (typeof config.hooks.onPreNuke === 'function') {
-    await config.hooks.onPreNuke(ctx);
+  if (typeof activeConfig.hooks.onPreNuke === 'function') {
+    await activeConfig.hooks.onPreNuke(ctx);
   }
 
   // 1. Remove Worktree & Directory
@@ -139,12 +186,12 @@ async function executeNuke(flags, config, cwd = process.cwd()) {
   // Helper for final cleanup steps (Herdr workspace close + Post-Nuke hook)
   const finishCleanup = async () => {
     // Post-Nuke Hook
-    if (typeof config.hooks.onPostNuke === 'function') {
-      await config.hooks.onPostNuke(ctx);
+    if (typeof activeConfig.hooks.onPostNuke === 'function') {
+      await activeConfig.hooks.onPostNuke(ctx);
     }
 
     // Close Herdr Workspace if running (performed last so active pane is not terminated mid-cleanup)
-    const prefix = config.workspace.labelPrefix || '';
+    const prefix = activeConfig.workspace.labelPrefix || '';
     const matchTargets = [
       targetSessionName,
       targetDirname,
@@ -153,7 +200,7 @@ async function executeNuke(flags, config, cwd = process.cwd()) {
       prefix ? `${prefix}${targetDirname}` : null,
     ].filter(Boolean);
 
-    herdr.closeWorkspacesMatching(matchTargets);
+    herdr.closeWorkspacesForWorktree(targetWorktreePath, matchTargets);
 
     console.log(`\nCleanup complete!`);
   };
@@ -165,7 +212,7 @@ async function executeNuke(flags, config, cwd = process.cwd()) {
     return;
   }
 
-  const protectedBranches = config.repo.protectedBranches || ['main', 'master', 'develop', 'prod', 'staging', 'production'];
+  const protectedBranches = activeConfig.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.`);
     await finishCleanup();

package/lib/logger.js

@@ -0,0 +1,85 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { ANSI } = require('./tui/ansi');
+
+let isDebugEnabled = false;
+let logFilePath = null;
+
+function initLogger(flags = {}) {
+  isDebugEnabled = Boolean(
+    flags.debug ||
+    flags.verbose ||
+    process.env.ARISE_DEBUG === '1' ||
+    process.env.DEBUG === 'arise' ||
+    process.env.DEBUG === '*'
+  );
+
+  try {
+    const logDir = path.join(os.homedir(), '.config', 'arise', 'logs');
+    fs.mkdirSync(logDir, { recursive: true });
+    logFilePath = path.join(logDir, 'arise.log');
+  } catch (e) {
+    logFilePath = path.join(os.tmpdir(), 'arise-debug.log');
+  }
+}
+
+function writeToFile(level, message, details = null) {
+  if (!logFilePath) return;
+  try {
+    const timestamp = new Date().toISOString();
+    let line = `[${timestamp}] [${level.toUpperCase()}] ${message}\n`;
+    if (details) {
+      line += typeof details === 'object' ? JSON.stringify(details, null, 2) + '\n' : String(details) + '\n';
+    }
+    fs.appendFileSync(logFilePath, line, 'utf8');
+  } catch (e) {}
+}
+
+function debug(message, details = null) {
+  writeToFile('DEBUG', message, details);
+  if (isDebugEnabled) {
+    console.log(`  ${ANSI.dim}[DEBUG] ${message}${ANSI.reset}`);
+    if (details) {
+      console.log(ANSI.dim + (typeof details === 'object' ? JSON.stringify(details, null, 2) : details) + ANSI.reset);
+    }
+  }
+}
+
+function info(message) {
+  writeToFile('INFO', message);
+  console.log(message);
+}
+
+function warn(message, details = null) {
+  writeToFile('WARN', message, details);
+  console.warn(`${ANSI.yellow}Warning: ${message}${ANSI.reset}`);
+  if (isDebugEnabled && details) {
+    console.warn(ANSI.dim + (typeof details === 'object' ? JSON.stringify(details, null, 2) : details) + ANSI.reset);
+  }
+}
+
+function error(message, err = null) {
+  writeToFile('ERROR', message, err && err.stack ? err.stack : err);
+  console.error(`${ANSI.red}Error: ${message}${ANSI.reset}`);
+  if (err) {
+    if (isDebugEnabled && err.stack) {
+      console.error(ANSI.dim + err.stack + ANSI.reset);
+    } else if (err.message) {
+      console.error(`${ANSI.dim}Details: ${err.message}${ANSI.reset}`);
+    }
+  }
+  if (!isDebugEnabled && logFilePath) {
+    console.error(`${ANSI.dim}(Detailed logs saved to ${logFilePath})${ANSI.reset}`);
+  }
+}
+
+module.exports = {
+  initLogger,
+  isDebugEnabled: () => isDebugEnabled,
+  getLogFilePath: () => logFilePath,
+  debug,
+  info,
+  warn,
+  error,
+};

package/lib/skill.js

@@ -15,6 +15,12 @@ Use this skill to answer questions about \`arise\` and run worktree management c
 
 ## 1. CLI Quick Reference & Cheatsheet
 
+### Interactive Mode
+\`\`\`bash
+# Launch interactive menu (create, switch/open, list, nuke)
+arise
+\`\`\`
+
 ### Creating Worktrees
 \`\`\`bash
 # Create or open a worktree for a branch (auto-detects preset, boots Herdr workspace)

package/lib/tui/ansi.js

@@ -0,0 +1,294 @@
+const ANSI = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  italic: '\x1b[3m',
+  underline: '\x1b[4m',
+  inverse: '\x1b[7m',
+  hidden: '\x1b[8m',
+  strikethrough: '\x1b[9m',
+
+  // Foreground
+  black: '\x1b[30m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+  gray: '\x1b[90m',
+
+  // Bright Foreground
+  brightRed: '\x1b[91m',
+  brightGreen: '\x1b[92m',
+  brightYellow: '\x1b[93m',
+  brightBlue: '\x1b[94m',
+  brightMagenta: '\x1b[95m',
+  brightCyan: '\x1b[96m',
+  brightWhite: '\x1b[97m',
+
+  // Background
+  bgBlack: '\x1b[40m',
+  bgRed: '\x1b[41m',
+  bgGreen: '\x1b[42m',
+  bgYellow: '\x1b[43m',
+  bgBlue: '\x1b[44m',
+  bgMagenta: '\x1b[45m',
+  bgCyan: '\x1b[46m',
+  bgWhite: '\x1b[47m',
+  bgGray: '\x1b[100m',
+
+  // Cursor & Screen
+  clearScreen: '\x1b[2J\x1b[H',
+  clearLine: '\x1b[2K\r',
+  hideCursor: '\x1b[?25l',
+  showCursor: '\x1b[?25h',
+  altScreenEnter: '\x1b[?1049h',
+  altScreenExit: '\x1b[?1049l',
+};
+
+function stripAnsi(text) {
+  if (typeof text !== 'string') return '';
+  return text
+    // Strip OSC sequences
+    .replace(/\x1b\](?:[^\x07\x1b]|\x1b[^\\])*?(?:\x07|\x1b\\)/g, '')
+    // Strip CSI sequences
+    .replace(/\x1b\[[0-9;?]*[a-zA-Z]/g, '')
+    // Strip other escape sequences
+    .replace(/\x1b[@-Z\\-_]/g, '');
+}
+
+function visibleLength(text) {
+  return stripAnsi(text).length;
+}
+
+class AnsiStyleTracker {
+  constructor() {
+    this.fg = '';
+    this.bg = '';
+    this.bold = false;
+    this.dim = false;
+    this.italic = false;
+    this.underline = false;
+    this.strike = false;
+  }
+
+  processCode(codeStr) {
+    const match = codeStr.match(/^\x1b\[([0-9;?]*)m$/);
+    if (!match) return;
+    const rawCodes = match[1] ? match[1].split(';').map(Number) : [0];
+
+    for (const c of rawCodes) {
+      if (c === 0) {
+        this.fg = '';
+        this.bg = '';
+        this.bold = false;
+        this.dim = false;
+        this.italic = false;
+        this.underline = false;
+        this.strike = false;
+      } else if (c === 1) {
+        this.bold = true;
+      } else if (c === 2) {
+        this.dim = true;
+      } else if (c === 3) {
+        this.italic = true;
+      } else if (c === 4) {
+        this.underline = true;
+      } else if (c === 9) {
+        this.strike = true;
+      } else if (c === 22) {
+        this.bold = false;
+        this.dim = false;
+      } else if (c === 23) {
+        this.italic = false;
+      } else if (c === 24) {
+        this.underline = false;
+      } else if (c === 29) {
+        this.strike = false;
+      } else if (c === 39) {
+        this.fg = '';
+      } else if (c === 49) {
+        this.bg = '';
+      } else if ((c >= 30 && c <= 37) || (c >= 90 && c <= 97)) {
+        this.fg = `\x1b[${c}m`;
+      } else if ((c >= 40 && c <= 47) || (c >= 100 && c <= 107)) {
+        this.bg = `\x1b[${c}m`;
+      }
+    }
+  }
+
+  getActiveCodes() {
+    let result = '';
+    if (this.bold) result += '\x1b[1m';
+    if (this.dim) result += '\x1b[2m';
+    if (this.italic) result += '\x1b[3m';
+    if (this.underline) result += '\x1b[4m';
+    if (this.strike) result += '\x1b[9m';
+    if (this.fg) result += this.fg;
+    if (this.bg) result += this.bg;
+    return result;
+  }
+
+  hasActiveStyles() {
+    return this.bold || this.dim || this.italic || this.underline || this.strike || Boolean(this.fg) || Boolean(this.bg);
+  }
+}
+
+function wrapAnsiLine(line, maxWidth, hangingIndent = '') {
+  if (maxWidth <= 0) return [line];
+  const totalVisible = visibleLength(line);
+  if (totalVisible <= maxWidth) {
+    return [line];
+  }
+
+  const tokenRegex = /(?:\x1b\](?:[^\x07\x1b]|\x1b[^\\])*?(?:\x07|\x1b\\)|\x1b\[[0-9;?]*[a-zA-Z]|\x1b[@-Z\\-_]|[^\s\x1b]+|\s+)/g;
+  const tokens = line.match(tokenRegex) || [line];
+
+  const result = [];
+  const tracker = new AnsiStyleTracker();
+
+  let currentLine = '';
+  let currentVisibleWidth = 0;
+  let isFirstLine = true;
+  const hangingVisibleWidth = visibleLength(hangingIndent);
+
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+
+    if (token.startsWith('\x1b')) {
+      tracker.processCode(token);
+      currentLine += token;
+      continue;
+    }
+
+    const tokenVisibleLen = stripAnsi(token).length;
+    const isWhitespace = /^\s+$/.test(token);
+
+    if (isWhitespace) {
+      if (currentVisibleWidth === hangingVisibleWidth && !isFirstLine) {
+        continue;
+      }
+      if (currentVisibleWidth + tokenVisibleLen <= maxWidth) {
+        currentLine += token;
+        currentVisibleWidth += tokenVisibleLen;
+      } else {
+        if (tracker.hasActiveStyles()) {
+          currentLine += ANSI.reset;
+        }
+        result.push(currentLine);
+        isFirstLine = false;
+        currentLine = hangingIndent + tracker.getActiveCodes();
+        currentVisibleWidth = hangingVisibleWidth;
+      }
+      continue;
+    }
+
+    // Word token
+    if (currentVisibleWidth + tokenVisibleLen <= maxWidth) {
+      currentLine += token;
+      currentVisibleWidth += tokenVisibleLen;
+    } else {
+      if (currentVisibleWidth > (isFirstLine ? 0 : hangingVisibleWidth)) {
+        if (tracker.hasActiveStyles()) {
+          currentLine += ANSI.reset;
+        }
+        result.push(currentLine);
+        isFirstLine = false;
+        currentLine = hangingIndent + tracker.getActiveCodes();
+        currentVisibleWidth = hangingVisibleWidth;
+      }
+
+      if (tokenVisibleLen > maxWidth - currentVisibleWidth) {
+        let remaining = token;
+        while (remaining.length > 0) {
+          const available = Math.max(1, maxWidth - currentVisibleWidth);
+          const chunk = remaining.slice(0, available);
+          remaining = remaining.slice(available);
+
+          currentLine += chunk;
+          currentVisibleWidth += chunk.length;
+
+          if (remaining.length > 0) {
+            if (tracker.hasActiveStyles()) {
+              currentLine += ANSI.reset;
+            }
+            result.push(currentLine);
+            isFirstLine = false;
+            currentLine = hangingIndent + tracker.getActiveCodes();
+            currentVisibleWidth = hangingVisibleWidth;
+          }
+        }
+      } else {
+        currentLine += token;
+        currentVisibleWidth += tokenVisibleLen;
+      }
+    }
+  }
+
+  if (currentLine.length > 0) {
+    if (tracker.hasActiveStyles()) {
+      currentLine += ANSI.reset;
+    }
+    result.push(currentLine);
+  }
+
+  return result.length > 0 ? result : [''];
+}
+
+function truncate(text, maxWidth) {
+  if (maxWidth <= 0) return '';
+  const totalVisible = visibleLength(text);
+  if (totalVisible <= maxWidth) return text;
+
+  const targetWidth = Math.max(1, maxWidth - 1);
+  const tokenRegex = /(?:\x1b\](?:[^\x07\x1b]|\x1b[^\\])*?(?:\x07|\x1b\\)|\x1b\[[0-9;?]*[a-zA-Z]|\x1b[@-Z\\-_]|[^\x1b])/g;
+  const tokens = text.match(tokenRegex) || [];
+
+  let result = '';
+  let currentVisible = 0;
+
+  for (const token of tokens) {
+    if (token.startsWith('\x1b')) {
+      result += token;
+    } else {
+      if (currentVisible + 1 > targetWidth) {
+        break;
+      }
+      result += token;
+      currentVisible += 1;
+    }
+  }
+
+  return result + ANSI.reset + '…';
+}
+
+function drawBox(title, contentLines = [], width = 70) {
+  const safeWidth = Math.max(10, width);
+  const horizontal = '─'.repeat(Math.max(0, safeWidth - 2));
+  const titleFormatted = title ? ` ${ANSI.bold}${title}${ANSI.reset} ` : '';
+  const titleLen = visibleLength(titleFormatted);
+  const topBar = `┌${titleFormatted}${'─'.repeat(Math.max(0, safeWidth - 2 - titleLen))}┐`;
+  const bottomBar = `└${horizontal}┘`;
+
+  const maxInner = Math.max(0, safeWidth - 4);
+  const renderedLines = contentLines.map((line) => {
+    const truncatedLine = truncate(line, maxInner);
+    const plain = visibleLength(truncatedLine);
+    const padding = Math.max(0, maxInner - plain);
+    return `│ ${truncatedLine}${' '.repeat(padding)} │`;
+  });
+
+  return [topBar, ...renderedLines, bottomBar];
+}
+
+module.exports = {
+  ANSI,
+  stripAnsi,
+  visibleLength,
+  AnsiStyleTracker,
+  wrapAnsiLine,
+  truncate,
+  drawBox,
+};