hamster-wheel-cli 0.1.0 → 0.2.0-beta.2

package/src/monitor.ts

@@ -1,6 +1,6 @@
 import fs from 'fs-extra';
 import path from 'node:path';
-import { CurrentRegistryEntry, getLogsDir, readCurrentRegistry } from './logs';
+import { CurrentRegistryEntry, getLogsDir, readCurrentRegistry, removeCurrentRegistry } from './logs';
 
 interface TaskView {
   readonly key: string;
@@ -9,16 +9,30 @@ interface TaskView {
   readonly lines: string[];
 }
 
+interface ConfirmState {
+  readonly key: string;
+}
+
+interface TerminationResult {
+  readonly message: string;
+  readonly isError: boolean;
+  readonly removed: boolean;
+}
+
 interface MonitorState {
   tasks: TaskView[];
   selectedIndex: number;
   selectedKey?: string;
-  pageOffsets: Map<string, number>;
+  lineOffsets: Map<string, number>;
   stickToBottom: Map<string, boolean>;
   lastError?: string;
+  confirm?: ConfirmState;
+  statusMessage?: string;
+  statusIsError?: boolean;
 }
 
 const REFRESH_INTERVAL = 1000;
+const TERMINATE_GRACE_MS = 800;
 
 function getTerminalSize(): { rows: number; columns: number } {
   const rows = process.stdout.rows ?? 24;
@@ -32,6 +46,81 @@ function truncateLine(line: string, width: number): string {
   return line.slice(0, width);
 }
 
+function padLine(text: string, width: number): string {
+  if (width <= 0) return '';
+  const truncated = text.length > width ? text.slice(0, width) : text;
+  const padding = width - truncated.length;
+  const left = Math.floor(padding / 2);
+  const right = padding - left;
+  return `${' '.repeat(left)}${truncated}${' '.repeat(right)}`;
+}
+
+export function buildConfirmDialogLines(taskKey: string, columns: number): string[] {
+  if (columns <= 0) return [];
+  const message = `确认终止任务 ${taskKey}?`;
+  const hint = 'y 确认 / n 取消';
+  const minWidth = Math.max(message.length, hint.length, 4);
+  const innerWidth = Math.min(columns - 2, minWidth);
+  if (innerWidth <= 0) {
+    return [truncateLine(message, columns), truncateLine(hint, columns)];
+  }
+  const border = `+${'-'.repeat(innerWidth)}+`;
+  const lines = [
+    border,
+    `|${padLine(message, innerWidth)}|`,
+    `|${padLine(hint, innerWidth)}|`,
+    border
+  ];
+  return lines.map(line => truncateLine(line, columns));
+}
+
+function applyDialogOverlay(lines: string[], dialogLines: string[]): void {
+  if (lines.length === 0 || dialogLines.length === 0) return;
+  const start = Math.max(0, Math.floor((lines.length - dialogLines.length) / 2));
+  for (let i = 0; i < dialogLines.length && start + i < lines.length; i += 1) {
+    lines[start + i] = dialogLines[i];
+  }
+}
+
+export function resolveTerminationTarget(pid: number, platform: NodeJS.Platform = process.platform): number {
+  return platform === 'win32' ? pid : -pid;
+}
+
+function isProcessAlive(pid: number): boolean {
+  if (!Number.isFinite(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const err = error as NodeJS.ErrnoException;
+    if (err?.code === 'ESRCH') return false;
+    return true;
+  }
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => {
+    setTimeout(resolve, ms);
+  });
+}
+
+function setStatus(state: MonitorState, message?: string, isError = false): void {
+  state.statusMessage = message;
+  state.statusIsError = message ? isError : false;
+}
+
+function findTaskByKey(state: MonitorState, key: string): TaskView | undefined {
+  return state.tasks.find(task => task.key === key);
+}
+
+async function safeRemoveRegistry(logFile: string): Promise<void> {
+  try {
+    await removeCurrentRegistry(logFile);
+  } catch {
+    // 忽略清理失败，避免阻断 monitor 刷新
+  }
+}
+
 async function readLogLines(logFile: string): Promise<string[]> {
   try {
     const content = await fs.readFile(logFile, 'utf8');
@@ -47,7 +136,17 @@ async function readLogLines(logFile: string): Promise<string[]> {
 async function loadTasks(logsDir: string): Promise<TaskView[]> {
   const registry = await readCurrentRegistry();
   const entries = Object.entries(registry).sort(([a], [b]) => a.localeCompare(b));
-  const tasks = await Promise.all(entries.map(async ([key, meta]) => {
+  const aliveEntries: Array<[string, CurrentRegistryEntry]> = [];
+  for (const [key, meta] of entries) {
+    const pid = typeof meta.pid === 'number' ? meta.pid : undefined;
+    if (pid && !isProcessAlive(pid)) {
+      const logFile = meta.logFile ?? path.join(logsDir, key);
+      await safeRemoveRegistry(logFile);
+      continue;
+    }
+    aliveEntries.push([key, meta]);
+  }
+  const tasks = await Promise.all(aliveEntries.map(async ([key, meta]) => {
     const logFile = meta.logFile ?? path.join(logsDir, key);
     const lines = await readLogLines(logFile);
     return {
@@ -67,7 +166,7 @@ function buildHeader(state: MonitorState, columns: number): string {
   const current = state.tasks[state.selectedIndex];
   const total = state.tasks.length;
   const index = state.selectedIndex + 1;
-  const title = `任务 ${index}/${total} ｜ ${current.key} ｜ ←/→ 切换任务  ↑/↓ 翻页  q 退出`;
+  const title = `任务 ${index}/${total} ｜ ${current.key} ｜ ←/→ 切换任务  ↑/↓ 上下 1 行  PageUp/PageDown 翻页  t 终止  q 退出`;
   return truncateLine(title, columns);
 }
 
@@ -75,11 +174,20 @@ function buildStatus(
   task: TaskView,
   page: { current: number; total: number },
   columns: number,
-  errorMessage?: string
+  errorMessage?: string,
+  statusMessage?: string,
+  statusIsError?: boolean
 ): string {
   const meta = task.meta;
   const status = `轮次 ${meta.round} ｜ Token ${meta.tokenUsed} ｜ 页 ${page.current}/${page.total} ｜ 项目 ${meta.path}`;
-  const suffix = errorMessage ? ` ｜ 刷新失败：${errorMessage}` : '';
+  const extras: string[] = [];
+  if (errorMessage) {
+    extras.push(`刷新失败：${errorMessage}`);
+  }
+  if (statusMessage) {
+    extras.push(statusIsError ? `操作失败：${statusMessage}` : statusMessage);
+  }
+  const suffix = extras.length > 0 ? ` ｜ ${extras.join(' ｜ ')}` : '';
   return truncateLine(`${status}${suffix}`, columns);
 }
 
@@ -94,7 +202,11 @@ function render(state: MonitorState): void {
 
   if (state.tasks.length === 0) {
     const filler = Array.from({ length: pageSize }, () => '');
-    const statusText = state.lastError ? `刷新失败：${state.lastError}` : '等待后台任务启动…';
+    const statusText = state.lastError
+      ? `刷新失败：${state.lastError}`
+      : state.statusMessage
+      ? (state.statusIsError ? `操作失败：${state.statusMessage}` : state.statusMessage)
+      : '等待后台任务启动…';
     const status = truncateLine(statusText, columns);
     const content = [header, ...filler, status].join('\n');
     process.stdout.write(`\u001b[2J\u001b[H${content}`);
@@ -103,25 +215,33 @@ function render(state: MonitorState): void {
 
   const current = state.tasks[state.selectedIndex];
   const lines = current.lines;
-  const maxOffset = Math.max(0, Math.ceil(lines.length / pageSize) - 1);
-  const offset = state.pageOffsets.get(current.key) ?? maxOffset;
+  const maxOffset = Math.max(0, lines.length - pageSize);
+  const offset = state.lineOffsets.get(current.key) ?? maxOffset;
   const stick = state.stickToBottom.get(current.key) ?? true;
   const nextOffset = Math.min(Math.max(stick ? maxOffset : offset, 0), maxOffset);
-  state.pageOffsets.set(current.key, nextOffset);
+  state.lineOffsets.set(current.key, nextOffset);
   state.stickToBottom.set(current.key, nextOffset === maxOffset);
 
-  const start = nextOffset * pageSize;
+  const start = nextOffset;
   const pageLines = lines.slice(start, start + pageSize).map(line => truncateLine(line, columns));
   while (pageLines.length < pageSize) {
     pageLines.push('');
   }
 
+  const totalPages = Math.max(1, Math.ceil(lines.length / pageSize));
+  const currentPage = Math.min(totalPages, Math.floor(nextOffset / pageSize) + 1);
   const status = buildStatus(
     current,
-    { current: nextOffset + 1, total: Math.max(1, maxOffset + 1) },
+    { current: currentPage, total: totalPages },
     columns,
-    state.lastError
+    state.lastError,
+    state.statusMessage,
+    state.statusIsError
   );
+  if (state.confirm) {
+    const dialogLines = buildConfirmDialogLines(state.confirm.key, columns);
+    applyDialogOverlay(pageLines, dialogLines);
+  }
   const content = [header, ...pageLines, status].join('\n');
   process.stdout.write(`\u001b[2J\u001b[H${content}`);
 }
@@ -148,9 +268,9 @@ function updateSelection(state: MonitorState, tasks: TaskView[]): void {
   state.selectedKey = tasks[state.selectedIndex]?.key;
 
   const existing = new Set(tasks.map(task => task.key));
-  for (const key of state.pageOffsets.keys()) {
+  for (const key of state.lineOffsets.keys()) {
     if (!existing.has(key)) {
-      state.pageOffsets.delete(key);
+      state.lineOffsets.delete(key);
     }
   }
   for (const key of state.stickToBottom.keys()) {
@@ -158,6 +278,9 @@ function updateSelection(state: MonitorState, tasks: TaskView[]): void {
       state.stickToBottom.delete(key);
     }
   }
+  if (state.confirm && !existing.has(state.confirm.key)) {
+    state.confirm = undefined;
+  }
 }
 
 function moveSelection(state: MonitorState, direction: -1 | 1): void {
@@ -167,26 +290,99 @@ function moveSelection(state: MonitorState, direction: -1 | 1): void {
   state.selectedKey = state.tasks[state.selectedIndex]?.key;
 }
 
+function moveLine(state: MonitorState, direction: -1 | 1): void {
+  if (state.tasks.length === 0) return;
+  const current = state.tasks[state.selectedIndex];
+  const lines = current.lines;
+  const { rows } = getTerminalSize();
+  const pageSize = getPageSize(rows);
+  const maxOffset = Math.max(0, lines.length - pageSize);
+  const offset = state.lineOffsets.get(current.key) ?? maxOffset;
+  const nextOffset = Math.min(Math.max(offset + direction, 0), maxOffset);
+  state.lineOffsets.set(current.key, nextOffset);
+  state.stickToBottom.set(current.key, nextOffset === maxOffset);
+}
+
 function movePage(state: MonitorState, direction: -1 | 1): void {
   if (state.tasks.length === 0) return;
   const { rows } = getTerminalSize();
   const pageSize = getPageSize(rows);
   const current = state.tasks[state.selectedIndex];
   const lines = current.lines;
-  const maxOffset = Math.max(0, Math.ceil(lines.length / pageSize) - 1);
-  const offset = state.pageOffsets.get(current.key) ?? maxOffset;
-  const nextOffset = Math.min(Math.max(offset + direction, 0), maxOffset);
-  state.pageOffsets.set(current.key, nextOffset);
+  const maxOffset = Math.max(0, lines.length - pageSize);
+  const offset = state.lineOffsets.get(current.key) ?? maxOffset;
+  const nextOffset = Math.min(Math.max(offset + direction * pageSize, 0), maxOffset);
+  state.lineOffsets.set(current.key, nextOffset);
   state.stickToBottom.set(current.key, nextOffset === maxOffset);
 }
 
+async function terminateTask(task: TaskView): Promise<TerminationResult> {
+  const pid = typeof task.meta.pid === 'number' ? task.meta.pid : undefined;
+  if (!pid || pid <= 0) {
+    return { message: '任务未记录 PID，无法终止', isError: true, removed: false };
+  }
+  const target = resolveTerminationTarget(pid);
+  try {
+    process.kill(target, 'SIGTERM');
+  } catch (error) {
+    const err = error as NodeJS.ErrnoException;
+    if (err?.code === 'ESRCH') {
+      await safeRemoveRegistry(task.logFile);
+      return { message: `任务 ${task.key} 已结束`, isError: false, removed: true };
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return { message: `发送终止信号失败：${message}`, isError: true, removed: false };
+  }
+
+  await sleep(TERMINATE_GRACE_MS);
+  if (!isProcessAlive(pid)) {
+    await safeRemoveRegistry(task.logFile);
+    return { message: `任务 ${task.key} 已终止`, isError: false, removed: true };
+  }
+  return { message: `已发送终止信号，任务仍在运行`, isError: false, removed: false };
+}
+
+async function terminateTaskByKey(state: MonitorState, key: string, refresh: () => Promise<void>): Promise<void> {
+  const task = findTaskByKey(state, key);
+  if (!task) {
+    setStatus(state, `任务 ${key} 已不存在`, true);
+    render(state);
+    return;
+  }
+  const result = await terminateTask(task);
+  setStatus(state, result.message, result.isError);
+  if (result.removed) {
+    await refresh();
+    render(state);
+    return;
+  }
+  render(state);
+}
+
 function shouldExit(input: string): boolean {
   if (input === '\u0003') return true;
   if (input.toLowerCase() === 'q') return true;
   return false;
 }
 
-function handleInput(state: MonitorState, input: string): void {
+function handleInput(state: MonitorState, input: string, refresh: () => Promise<void>): void {
+  const lower = input.toLowerCase();
+  if (state.confirm) {
+    if (lower.includes('y')) {
+      const key = state.confirm.key;
+      state.confirm = undefined;
+      setStatus(state, `正在终止任务 ${key}...`);
+      void terminateTaskByKey(state, key, refresh);
+      return;
+    }
+    if (lower.includes('n') || input === '\u001b') {
+      state.confirm = undefined;
+      setStatus(state, '已取消终止');
+      return;
+    }
+    return;
+  }
+
   if (input.includes('\u001b[D')) {
     moveSelection(state, -1);
     return;
@@ -196,13 +392,34 @@ function handleInput(state: MonitorState, input: string): void {
     return;
   }
   if (input.includes('\u001b[A')) {
-    movePage(state, -1);
+    moveLine(state, -1);
     return;
   }
   if (input.includes('\u001b[B')) {
+    moveLine(state, 1);
+    return;
+  }
+  if (input.includes('\u001b[5~')) {
+    movePage(state, -1);
+    return;
+  }
+  if (input.includes('\u001b[6~')) {
     movePage(state, 1);
     return;
   }
+  if (lower.includes('t')) {
+    if (state.tasks.length === 0) {
+      setStatus(state, '暂无可终止的任务', true);
+      return;
+    }
+    const current = state.tasks[state.selectedIndex];
+    if (typeof current.meta.pid !== 'number' || current.meta.pid <= 0) {
+      setStatus(state, '任务未记录 PID，无法终止', true);
+      return;
+    }
+    state.confirm = { key: current.key };
+    setStatus(state, undefined);
+  }
 }
 
 function setupCleanup(cleanup: () => void): void {
@@ -231,7 +448,7 @@ export async function runMonitor(): Promise<void> {
   const state: MonitorState = {
     tasks: [],
     selectedIndex: 0,
-    pageOffsets: new Map(),
+    lineOffsets: new Map(),
     stickToBottom: new Map()
   };
 
@@ -281,7 +498,7 @@ export async function runMonitor(): Promise<void> {
       cleanup();
       process.exit(0);
     }
-    handleInput(state, input);
+    handleInput(state, input, refresh);
     render(state);
   });
 

package/src/multi-task.ts

@@ -0,0 +1,117 @@
+import path from 'node:path';
+
+export type MultiTaskMode = 'relay' | 'serial' | 'serial-continue' | 'parallel';
+
+const MODE_ALIASES: Record<string, MultiTaskMode> = {
+  relay: 'relay',
+  serial: 'serial',
+  'serial-continue': 'serial-continue',
+  parallel: 'parallel',
+  接力模式: 'relay',
+  接力: 'relay',
+  串行执行: 'serial',
+  串行: 'serial',
+  串行执行但是失败也继续: 'serial-continue',
+  串行继续: 'serial-continue',
+  并行执行: 'parallel',
+  并行: 'parallel'
+};
+
+/**
+ * 解析多任务执行模式。
+ */
+export function parseMultiTaskMode(raw?: string): MultiTaskMode {
+  if (!raw) return 'relay';
+  const trimmed = raw.trim();
+  if (!trimmed) return 'relay';
+  const resolved = MODE_ALIASES[trimmed];
+  if (!resolved) {
+    throw new Error(`未知 multi-task 模式: ${raw}`);
+  }
+  return resolved;
+}
+
+/**
+ * 规范化任务列表（去空白、剔除空项）。
+ */
+export function normalizeTaskList(input: string[] | string | undefined): string[] {
+  if (Array.isArray(input)) {
+    return input.map(task => task.trim()).filter(task => task.length > 0);
+  }
+  if (typeof input === 'string') {
+    const trimmed = input.trim();
+    return trimmed.length > 0 ? [trimmed] : [];
+  }
+  return [];
+}
+
+export interface TaskPlanInput {
+  readonly tasks: string[];
+  readonly mode: MultiTaskMode;
+  readonly useWorktree: boolean;
+  readonly baseBranch: string;
+  readonly branchInput?: string;
+  readonly worktreePath?: string;
+  readonly logFile?: string;
+}
+
+export interface TaskPlan {
+  readonly task: string;
+  readonly index: number;
+  readonly branchName?: string;
+  readonly baseBranch: string;
+  readonly worktreePath?: string;
+  readonly logFile?: string;
+}
+
+function buildBranchNameSeries(branchInput: string | undefined, total: number): Array<string | undefined> {
+  if (total <= 0) return [];
+  if (!branchInput) {
+    return Array.from({ length: total }, () => undefined);
+  }
+  const baseName = branchInput;
+  const names: Array<string | undefined> = [baseName];
+  for (let i = 1; i < total; i += 1) {
+    names.push(`${baseName}-${i + 1}`);
+  }
+  return names;
+}
+
+function appendPathSuffix(filePath: string, suffix: string): string {
+  const parsed = path.parse(filePath);
+  const nextName = parsed.name ? `${parsed.name}-${suffix}` : suffix;
+  return path.join(parsed.dir, `${nextName}${parsed.ext}`);
+}
+
+function deriveIndexedPath(basePath: string | undefined, index: number, total: number, label: string): string | undefined {
+  if (!basePath) return undefined;
+  if (total <= 1 || index === 0) return basePath;
+  return appendPathSuffix(basePath, `${label}-${index + 1}`);
+}
+
+/**
+ * 构建多任务执行计划。
+ */
+export function buildTaskPlans(input: TaskPlanInput): TaskPlan[] {
+  const total = input.tasks.length;
+  if (total === 0) return [];
+
+  const branchNames: Array<string | undefined> = input.useWorktree
+    ? buildBranchNameSeries(input.branchInput, total)
+    : input.tasks.map(() => input.branchInput);
+
+  return input.tasks.map((task, index) => {
+    const relayBaseBranch = input.useWorktree && input.mode === 'relay' && index > 0
+      ? branchNames[index - 1] ?? input.baseBranch
+      : input.baseBranch;
+
+    return {
+      task,
+      index,
+      branchName: branchNames[index],
+      baseBranch: relayBaseBranch,
+      worktreePath: deriveIndexedPath(input.worktreePath, index, total, 'task'),
+      logFile: deriveIndexedPath(input.logFile, index, total, 'task')
+    };
+  });
+}

package/src/plan.ts

@@ -0,0 +1,61 @@
+export interface PlanItem {
+  readonly index: number;
+  readonly raw: string;
+  readonly text: string;
+  readonly completed: boolean;
+}
+
+const ITEM_PATTERN = /^(\s*)([-*+]|\d+\.)\s+(.*)$/;
+
+function isCompleted(content: string): boolean {
+  if (content.includes('✅')) return true;
+  if (/\[[xX]\]/.test(content)) return true;
+  return false;
+}
+
+function normalizeText(content: string): string {
+  return content
+    .replace(/\[[xX ]\]\s*/g, '')
+    .replace(/✅/g, '')
+    .trim();
+}
+
+/**
+ * 解析 plan.md 中的计划项。
+ */
+export function parsePlanItems(plan: string): PlanItem[] {
+  const lines = plan.split(/\r?\n/);
+  const items: PlanItem[] = [];
+
+  lines.forEach((line, index) => {
+    const match = line.match(ITEM_PATTERN);
+    if (!match) return;
+    const content = match[3] ?? '';
+    const text = normalizeText(content);
+    if (!text) return;
+    items.push({
+      index,
+      raw: line,
+      text,
+      completed: isCompleted(content)
+    });
+  });
+
+  return items;
+}
+
+/**
+ * 获取尚未完成的计划项。
+ */
+export function getPendingPlanItems(plan: string): PlanItem[] {
+  return parsePlanItems(plan).filter(item => !item.completed);
+}
+
+/**
+ * 获取最后一条未完成的计划项。
+ */
+export function getLastPendingPlanItem(plan: string): PlanItem | null {
+  const pending = getPendingPlanItems(plan);
+  if (pending.length === 0) return null;
+  return pending[pending.length - 1] ?? null;
+}

package/src/quality.ts

@@ -0,0 +1,48 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+
+export interface QualityCommand {
+  readonly name: string;
+  readonly command: string;
+}
+
+function hasScript(scripts: Record<string, string>, name: string): boolean {
+  return typeof scripts[name] === 'string' && scripts[name].trim().length > 0;
+}
+
+/**
+ * 读取 package.json，解析可用的代码质量检查命令。
+ */
+export async function detectQualityCommands(workDir: string): Promise<QualityCommand[]> {
+  const packagePath = path.join(workDir, 'package.json');
+  const exists = await fs.pathExists(packagePath);
+  if (!exists) return [];
+
+  const pkg = await fs.readJson(packagePath);
+  const scripts = typeof pkg === 'object' && pkg && typeof (pkg as { scripts?: unknown }).scripts === 'object'
+    ? ((pkg as { scripts: Record<string, string> }).scripts ?? {})
+    : {};
+
+  const commands: QualityCommand[] = [];
+  const seen = new Set<string>();
+
+  const append = (name: string, command: string): void => {
+    if (seen.has(name)) return;
+    if (!hasScript(scripts, name)) return;
+    commands.push({ name, command });
+    seen.add(name);
+  };
+
+  append('lint', 'yarn lint');
+  append('lint:ci', 'yarn lint:ci');
+  append('lint:check', 'yarn lint:check');
+  append('typecheck', 'yarn typecheck');
+  append('format:check', 'yarn format:check');
+  append('format:ci', 'yarn format:ci');
+
+  if (!hasScript(scripts, 'format:check') && !hasScript(scripts, 'format:ci')) {
+    append('format', 'yarn format');
+  }
+
+  return commands;
+}

package/src/runtime-tracker.ts

@@ -49,7 +49,8 @@ export async function createRunTracker(options: RunTrackerOptions): Promise<RunT
       command,
       round,
       tokenUsed,
-      path
+      path,
+      pid: process.pid
     };
     await safeWrite(logFile, metadata, logger);
   };

package/src/types.ts

@@ -91,6 +91,7 @@ export interface PrConfig {
   readonly bodyPath?: string;
   readonly draft?: boolean;
   readonly reviewers?: string[];
+  readonly autoMerge?: boolean;
 }
 
 /**
@@ -131,6 +132,7 @@ export interface LoopConfig {
   readonly autoCommit: boolean;
   readonly autoPush: boolean;
   readonly skipInstall: boolean;
+  readonly skipQuality: boolean;
 }
 
 /**
@@ -169,8 +171,29 @@ export interface StreamOptions {
  */
 export interface IterationRecord {
   readonly iteration: number;
+  readonly stage?: string;
   readonly prompt: string;
   readonly aiOutput: string;
   readonly timestamp: string;
   readonly testResults?: TestRunResult[];
+  readonly checkResults?: CheckRunResult[];
+}
+
+/**
+ * 代码质量检查结果。
+ */
+export interface CheckRunResult {
+  readonly name: string;
+  readonly command: string;
+  readonly success: boolean;
+  readonly exitCode: number;
+  readonly stdout: string;
+  readonly stderr: string;
+}
+
+/**
+ * 主流程返回信息。
+ */
+export interface LoopResult {
+  readonly branchName?: string;
 }