clawt 3.5.3 → 3.6.1

package/src/commands/resume.ts

@@ -1,5 +1,6 @@
 import type { Command } from 'commander';
 import { logger } from '../logger/index.js';
+import { ClawtError } from '../errors/index.js';
 import { MESSAGES } from '../constants/index.js';
 import type { ResumeOptions } from '../types/index.js';
 import type { WorktreeInfo } from '../types/index.js';
@@ -12,10 +13,14 @@ import {
   hasClaudeSessionHistory,
   resolveTargetWorktrees,
   promptGroupedMultiSelectBranches,
+  findExactMatch,
   printInfo,
   printSuccess,
   confirmAction,
   getConfigValue,
+  parseConcurrency,
+  loadTaskFile,
+  executeBatchTasks,
 } from '../utils/index.js';
 import type { WorktreeMultiResolveMessages } from '../utils/index.js';
 
@@ -36,6 +41,9 @@ export function registerResumeCommand(program: Command): void {
     .command('resume')
     .description('在已有 worktree 中恢复 Claude Code 会话（支持多选批量恢复）')
     .option('-b, --branch <branchName>', '要恢复的分支名（支持模糊匹配，不传则列出所有分支）')
+    .option('--prompt <content>', '非交互式追问（需配合 -b 指定分支）')
+    .option('-f, --file <path>', '从任务文件批量追问（通过 branch 名匹配已有 worktree）')
+    .option('-c, --concurrency <n>', '批量追问最大并发数，0 表示不限制')
     .action(async (options: ResumeOptions) => {
       await handleResume(options);
     });
@@ -49,6 +57,25 @@ export function registerResumeCommand(program: Command): void {
 async function handleResume(options: ResumeOptions): Promise<void> {
   await runPreChecks(PRE_CHECK_RESUME);
 
+  // 非交互式追问逻辑分支
+  if (options.prompt && options.file) {
+    throw new ClawtError(MESSAGES.RESUME_PROMPT_FILE_CONFLICT);
+  }
+
+  if (options.prompt) {
+    if (!options.branch) {
+      throw new ClawtError(MESSAGES.RESUME_PROMPT_REQUIRES_BRANCH);
+    }
+    const worktrees = getProjectWorktrees();
+    const worktree = resolveWorktreeByBranch(options.branch, worktrees);
+    return handleNonInteractiveSingleResume(worktree, options.prompt);
+  }
+
+  if (options.file) {
+    return handleNonInteractiveBatchResume(options.file, options);
+  }
+
+  // 原有交互式逻辑
   logger.info(`resume 命令执行，分支过滤: ${options.branch ?? '(无)'}`);
   const worktrees = getProjectWorktrees();
 
@@ -82,6 +109,70 @@ async function handleResume(options: ResumeOptions): Promise<void> {
   }
 }
 
+/**
+ * 精确匹配分支对应的 worktree
+ * 找不到时抛出包含可用分支列表的错误
+ * @param {string} branch - 目标分支名
+ * @param {WorktreeInfo[]} worktrees - 可用的 worktree 列表
+ * @returns {WorktreeInfo} 匹配的 worktree
+ * @throws {ClawtError} 未找到匹配分支时抛出
+ */
+function resolveWorktreeByBranch(branch: string, worktrees: WorktreeInfo[]): WorktreeInfo {
+  const match = findExactMatch(worktrees, branch);
+  if (!match) {
+    const available = worktrees.map((wt) => wt.branch);
+    throw new ClawtError(MESSAGES.RESUME_WORKTREE_NOT_FOUND(branch, available));
+  }
+  return match;
+}
+
+/**
+ * 非交互式单分支追问
+ * 检查 worktree 是否有历史会话，有则通过 --continue 继续最新会话
+ * @param {WorktreeInfo} worktree - 目标 worktree
+ * @param {string} prompt - 追问内容
+ */
+async function handleNonInteractiveSingleResume(worktree: WorktreeInfo, prompt: string): Promise<void> {
+  // 检查是否有历史会话，有则追加 --continue
+  const hasPrevious = hasClaudeSessionHistory(worktree.path);
+  await executeBatchTasks([worktree], [prompt], 0, [hasPrevious]);
+}
+
+/**
+ * 非交互式批量追问
+ * 从任务文件解析追问内容，按 branch 名精确匹配已有 worktree，批量执行
+ * @param {string} filePath - 追问任务文件路径
+ * @param {ResumeOptions} options - 命令选项（含并发数配置）
+ */
+async function handleNonInteractiveBatchResume(filePath: string, options: ResumeOptions): Promise<void> {
+  // 解析追问文件，branch 为必填字段
+  const entries = loadTaskFile(filePath, { branchRequired: true });
+  printSuccess(MESSAGES.RESUME_FOLLOW_UP_FILE_LOADED(entries.length, filePath));
+
+  // 获取所有已有 worktree
+  const allWorktrees = getProjectWorktrees();
+
+  // 按 branch 名精确匹配 worktree，构建执行参数
+  const worktrees: WorktreeInfo[] = [];
+  const tasks: string[] = [];
+  const continueFlags: boolean[] = [];
+
+  for (const entry of entries) {
+    const worktree = resolveWorktreeByBranch(entry.branch!, allWorktrees);
+    worktrees.push(worktree);
+    tasks.push(entry.task);
+    // 按 worktree 独立检查是否有历史会话
+    continueFlags.push(hasClaudeSessionHistory(worktree.path));
+  }
+
+  // 解析并发数
+  const concurrency = parseConcurrency(options.concurrency, getConfigValue('maxConcurrency'));
+
+  logger.info(`resume 命令（批量追问模式）执行，任务数: ${entries.length}，并发数: ${concurrency || '不限制'}`);
+
+  await executeBatchTasks(worktrees, tasks, concurrency, continueFlags);
+}
+
 /**
  * 输出即将恢复的分支列表（含会话状态：继续/新对话）
  * @param {WorktreeInfo[]} worktrees - 待恢复的 worktree 列表

package/src/constants/messages/home.ts

@@ -4,4 +4,6 @@ export const HOME_MESSAGES = {
   HOME_ALREADY_ON_MAIN: (branch: string) => `已在主工作分支 ${branch} 上，无需切换`,
   /** 切换成功 */
   HOME_SWITCH_SUCCESS: (from: string, to: string) => `✓ 已从 ${from} 切换到主工作分支 ${to}`,
+  /** 当前在子 worktree，提示用户手动 cd 到主 worktree */
+  HOME_NOT_IN_MAIN_WORKTREE: (mainPath: string) => `当前不在主 worktree，请先切换到主 worktree：\n\n  cd ${mainPath}`,
 } as const;

package/src/constants/messages/resume.ts

@@ -18,4 +18,14 @@ export const RESUME_MESSAGES = {
   RESUME_ALL_PLATFORM_UNSUPPORTED: '批量 resume 目前仅支持 macOS 平台（通过 AppleScript 打开终端 Tab）',
   /** 批量 resume 无匹配分支提示 */
   RESUME_ALL_NO_MATCH: (keyword: string) => `未找到与 "${keyword}" 匹配的分支`,
+
+  /** --prompt 必须配合 -b 指定目标分支 */
+  RESUME_PROMPT_REQUIRES_BRANCH: '--prompt 必须配合 -b 指定目标分支',
+  /** --prompt 和 -f 不能同时使用 */
+  RESUME_PROMPT_FILE_CONFLICT: '--prompt 和 -f 不能同时使用',
+  /** 未找到对应 worktree */
+  RESUME_WORKTREE_NOT_FOUND: (branch: string, available: string[]) =>
+    `未找到分支 "${branch}" 对应的 worktree\n  可用分支：\n${available.map((b) => `    - ${b}`).join('\n')}`,
+  /** 追问文件加载完成 */
+  RESUME_FOLLOW_UP_FILE_LOADED: (count: number, path: string) => `从 ${path} 加载了 ${count} 个追问任务`,
 } as const;

package/src/types/command.ts

@@ -52,6 +52,12 @@ export interface RemoveOptions {
 export interface ResumeOptions {
   /** 要恢复的分支名（可选，不传则列出所有分支供选择） */
   branch?: string;
+  /** 非交互式追问内容（需配合 -b 指定分支） */
+  prompt?: string;
+  /** 从任务文件批量追问（通过 branch 名匹配已有 worktree） */
+  file?: string;
+  /** 批量追问最大并发数，0 表示不限制（Commander 传入为字符串） */
+  concurrency?: string;
 }
 
 /** sync 命令选项 */
@@ -88,6 +94,12 @@ export interface InitOptions {
   branch?: string;
 }
 
+/** init show 子命令选项 */
+export interface InitShowOptions {
+  /** 以 JSON 格式输出 */
+  json?: boolean;
+}
+
 /** tasks init 命令选项 */
 export interface TasksInitOptions {
   /** 输出文件路径（可选，默认 tasks.md） */

package/src/types/index.ts

@@ -1,5 +1,5 @@
 export type { ClawtConfig, ConfigItemDefinition, ConfigDefinitions } from './config.js';
-export type { CreateOptions, RunOptions, ValidateOptions, MergeOptions, RemoveOptions, ResumeOptions, SyncOptions, ListOptions, StatusOptions, ProjectsOptions, InitOptions, TasksInitOptions } from './command.js';
+export type { CreateOptions, RunOptions, ValidateOptions, MergeOptions, RemoveOptions, ResumeOptions, SyncOptions, ListOptions, StatusOptions, ProjectsOptions, InitOptions, InitShowOptions, TasksInitOptions } from './command.js';
 export type { WorktreeInfo, WorktreeStatus } from './worktree.js';
 export type { ClaudeCodeResult } from './claudeCode.js';
 export type { TaskResult, TaskSummary } from './taskResult.js';

package/src/utils/git-core.ts

@@ -12,6 +12,34 @@ export function getGitCommonDir(cwd?: string): string {
   return execCommand('git rev-parse --git-common-dir', { cwd });
 }
 
+/**
+ * 判断当前是否在主 worktree 中
+ * 条件：git rev-parse --git-common-dir === ".git"
+ * @param {string} [cwd] - 工作目录
+ * @returns {boolean} 是否在主 worktree 中
+ */
+export function isMainWorktree(cwd?: string): boolean {
+  try {
+    return getGitCommonDir(cwd) === '.git';
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * 判断当前是否在 git 仓库中
+ * @param {string} [cwd] - 工作目录
+ * @returns {boolean} 是否在 git 仓库中
+ */
+export function isInsideGitRepo(cwd?: string): boolean {
+  try {
+    execCommand('git rev-parse --is-inside-work-tree', { cwd });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * 获取 git 仓库根目录的绝对路径
  * @param {string} cwd - 工作目录
@@ -21,6 +49,18 @@ export function getGitTopLevel(cwd?: string): string {
   return execCommand('git rev-parse --show-toplevel', { cwd });
 }
 
+/**
+ * 获取主 worktree 的绝对路径
+ * 通过 git worktree list --porcelain 解析第一行（始终为主 worktree）
+ * @param {string} [cwd] - 工作目录
+ * @returns {string} 主 worktree 的绝对路径
+ */
+export function getMainWorktreePath(cwd?: string): string {
+  const output = execCommand('git worktree list --porcelain', { cwd });
+  const firstLine = output.split('\n')[0] || '';
+  return firstLine.replace('worktree ', '');
+}
+
 /**
  * 获取项目名（仓库根目录名称）
  * @param {string} cwd - 工作目录

package/src/utils/index.ts

@@ -3,7 +3,10 @@ export type { ParallelCommandResult, CommandResultWithStderr, ParallelCommandRes
 export { copyToClipboard } from './clipboard.js';
 export {
   getGitCommonDir,
+  isMainWorktree,
+  isInsideGitRepo,
   getGitTopLevel,
+  getMainWorktreePath,
   getProjectName,
   checkBranchExists,
   createWorktree,

package/src/utils/task-executor.ts

@@ -9,6 +9,7 @@ import { printSuccess, printWarning, printInfo, printDoubleSeparator, confirmAct
 import { ProgressRenderer } from './progress.js';
 import { createLineBuffer, parseStreamLine, parseStreamEvent, truncateText } from './stream-parser.js';
 import { RESULT_PREVIEW_MAX_LENGTH } from '../constants/index.js';
+import { ClawtError } from '../errors/index.js';
 
 /** executeClaudeTask 的返回结构，包含子进程引用和结果 Promise */
 interface ClaudeTaskHandle {
@@ -29,13 +30,21 @@ type ActivityCallback = (activityText: string) => void;
  * @param {WorktreeInfo} worktree - worktree 信息
  * @param {string} task - 任务描述
  * @param {ActivityCallback} [onActivity] - 活动更新回调（可选）
+ * @param {boolean} [continueSession] - 是否继续该 worktree 目录下最新的会话
  * @returns {ClaudeTaskHandle} 包含子进程引用和结果 Promise
  */
-function executeClaudeTask(worktree: WorktreeInfo, task: string, onActivity?: ActivityCallback): ClaudeTaskHandle {
+function executeClaudeTask(worktree: WorktreeInfo, task: string, onActivity?: ActivityCallback, continueSession?: boolean): ClaudeTaskHandle {
   // 旧版使用 --output-format json，现改为 stream-json --verbose 以支持实时活动信息
+  const args = ['-p', task, '--output-format', 'stream-json', '--verbose', '--permission-mode', 'bypassPermissions'];
+
+  // 追问模式：追加 --continue 继续该目录下最新会话
+  if (continueSession) {
+    args.push('--continue');
+  }
+
   const child = spawnProcess(
     'claude',
-    ['-p', task, '--output-format', 'stream-json', '--verbose', '--permission-mode', 'bypassPermissions'],
+    args,
     {
       cwd: worktree.path,
       // stdin 必须设置为 'ignore'，不能用 'pipe'
@@ -198,6 +207,7 @@ function updateRendererStatus(renderer: ProgressRenderer, index: number, result:
  * @param {number} startTime - 任务批次启动时间戳
  * @param {() => boolean} isInterrupted - 检查是否已中断的函数
  * @param {ChildProcess[]} childProcesses - 共享子进程数组，执行过程中动态追加
+ * @param {boolean[]} [continueFlags] - 按索引对应每个任务是否继续已有会话（追问模式，追加 --continue）
  * @returns {Promise<TaskResult[]>} 所有任务结果
  */
 async function executeWithConcurrency(
@@ -208,6 +218,7 @@ async function executeWithConcurrency(
   startTime: number,
   isInterrupted: () => boolean,
   childProcesses: ChildProcess[],
+  continueFlags?: boolean[],
 ): Promise<TaskResult[]> {
   const total = tasks.length;
   const results: TaskResult[] = new Array(total);
@@ -234,7 +245,7 @@ async function executeWithConcurrency(
 
       const handle = executeClaudeTask(wt, task, (activityText) => {
         renderer.updateActivityText(index, activityText);
-      });
+      }, continueFlags?.[index]);
       childProcesses.push(handle.child);
 
       handle.promise.then((result) => {
@@ -272,6 +283,7 @@ async function executeWithConcurrency(
  * @param {number} startTime - 任务批次启动时间戳
  * @param {() => boolean} isInterrupted - 检查是否已中断的函数
  * @param {ChildProcess[]} childProcesses - 共享子进程数组，启动时追加
+ * @param {boolean[]} [continueFlags] - 按索引对应每个任务是否继续已有会话（追问模式，追加 --continue）
  * @returns {Promise<TaskResult[]>} 所有任务结果
  */
 async function executeAllParallel(
@@ -281,13 +293,14 @@ async function executeAllParallel(
   startTime: number,
   isInterrupted: () => boolean,
   childProcesses: ChildProcess[],
+  continueFlags?: boolean[],
 ): Promise<TaskResult[]> {
   const handles = worktrees.map((wt, index) => {
     const task = tasks[index];
     logger.info(`启动任务 ${index + 1}: ${task} (worktree: ${wt.path})`);
     const handle = executeClaudeTask(wt, task, (activityText) => {
       renderer.updateActivityText(index, activityText);
-    });
+    }, continueFlags?.[index]);
     childProcesses.push(handle.child);
 
     return handle;
@@ -314,14 +327,25 @@ async function executeAllParallel(
  * @param {WorktreeInfo[]} worktrees - worktree 列表
  * @param {string[]} tasks - 任务描述列表
  * @param {number} concurrency - 最大并发数，0 表示不限制
+ * @param {boolean[]} [continueFlags] - 按索引对应每个任务是否继续已有会话（追问模式，追加 --continue）
+ * @returns {Promise<TaskResult[]>} 所有任务的执行结果
+ * @throws {ClawtError} continueFlags 长度与任务数不一致时抛出
  */
 export async function executeBatchTasks(
   worktrees: WorktreeInfo[],
   tasks: string[],
   concurrency: number,
-): Promise<void> {
+  continueFlags?: boolean[],
+): Promise<TaskResult[]> {
   const count = tasks.length;
 
+  // 校验 continueFlags 长度与 worktrees 一致，防止调用方传入不匹配的数组
+  if (continueFlags && continueFlags.length !== count) {
+    throw new ClawtError(
+      `continueFlags 长度 (${continueFlags.length}) 与任务数 (${count}) 不一致`,
+    );
+  }
+
   // 有并发限制时输出提示
   if (concurrency > 0) {
     printInfo(MESSAGES.CONCURRENCY_INFO(concurrency, count));
@@ -374,15 +398,15 @@ export async function executeBatchTasks(
 
   // 根据并发限制选择执行模式
   const results = concurrency > 0
-    ? await executeWithConcurrency(worktrees, tasks, concurrency, renderer, startTime, isInterrupted, childProcesses)
-    : await executeAllParallel(worktrees, tasks, renderer, startTime, isInterrupted, childProcesses);
+    ? await executeWithConcurrency(worktrees, tasks, concurrency, renderer, startTime, isInterrupted, childProcesses, continueFlags)
+    : await executeAllParallel(worktrees, tasks, renderer, startTime, isInterrupted, childProcesses, continueFlags);
 
   // 正常完成，停止进度面板并移除 SIGINT 监听器
   renderer.stop();
   process.removeListener('SIGINT', sigintHandler);
 
   // 被中断时不输出汇总（已在 sigintHandler 中处理退出）
-  if (interrupted) return;
+  if (interrupted) return [];
 
   const totalDurationMs = Date.now() - startTime;
 
@@ -396,4 +420,6 @@ export async function executeBatchTasks(
   };
 
   printTaskSummary(summary);
+
+  return results;
 }

package/src/utils/validation.ts

@@ -26,7 +26,7 @@ export interface PreCheckOptions {
 /**
  * 校验当前目录是否为主 worktree 的根目录
  * 条件：git rev-parse --git-common-dir === ".git"
- * @throws {ClawtError} 不在主 worktree 根目录时抛出
+ * @throws {ClawtError} 不在主 worktree 根目录时抛出（包括不在 git 仓库中的情况）
  */
 export function validateMainWorktree(): void {
   try {