chatccc 0.2.122 → 0.2.124

package/src/orchestrator.ts

@@ -19,8 +19,6 @@ import {
   CONFIG_FILE,
   GIT_TIMEOUT_MS,
   PROJECT_ROOT,
-  AGENT_MODE_COMMANDS,
-  AGENT_TOOLS,
   anthropicConfigDisplay,
   config,
   fileLog,
@@ -127,85 +125,6 @@ function isNonWechatP2p(platform: PlatformAdapter, chatType: string): boolean {
   return chatType === "p2p" && platform.kind !== "wechat";
 }
 
-/** 根据 Agent 类型构建欢迎卡片中的指令说明 */
-function buildWelcomeCommands(tool: string): string {
-  const lines = [
-    "发送 **/cd** 切换新建会话的默认目录。",
-    "发送 **/model** 查看或切换当前会话的模型。",
-    "发送 **/new** 创建新会话，**/newh** 重置当前会话（沿用工作目录）。",
-    "发送 **/sessions** 查看所有会话状态。",
-  ];
-  const modeCmds = AGENT_MODE_COMMANDS[tool as AgentTool] ?? [];
-  for (const mc of modeCmds) {
-    lines.push(`发送 **${mc.command} <消息>** ${mc.description}。`);
-  }
-  return lines.join("\n");
-}
-
-/** 根据指令名从 AGENT_MODE_COMMANDS 查找对应的 mode 和支持的 agent 列表 */
-function resolveModeCommand(cmd: string): { mode: "plan" | "ask"; supportedTools: string[] } | null {
-  const supportedTools: string[] = [];
-  let mode: "plan" | "ask" | null = null;
-  for (const tool of AGENT_TOOLS) {
-    for (const mc of AGENT_MODE_COMMANDS[tool]) {
-      if (mc.command === cmd) {
-        supportedTools.push(tool);
-        mode = mc.mode;
-        break;
-      }
-    }
-  }
-  return mode ? { mode, supportedTools } : null;
-}
-
-/** 如果当前群名是未命名会话（"新会话" 或 "新会话-xxx"），用消息内容前缀重命名 */
-async function renameUntitledSession(
-  platform: PlatformAdapter,
-  chatId: string,
-  chatType: string,
-  sessionId: string,
-  tool: string,
-  namePrefix: string,
-  description: string | undefined,
-  chatInfo: { name: string } | undefined,
-): Promise<void> {
-  const MAX_PREFIX = 10;
-  const prefix = namePrefix.slice(0, MAX_PREFIX);
-
-  if (chatType !== "p2p" && chatInfo && isUntitledSessionChatName(chatInfo.name)) {
-    const adapter = getAdapterForTool(tool, sessionId);
-    const info = await adapter.getSessionInfo(sessionId).catch(() => undefined);
-    const sessionCwd = info?.cwd ?? (await getDefaultCwd(chatId));
-    const newName = sessionChatName(prefix, sessionCwd);
-    try {
-      await platform.updateChatInfo(chatId, newName, description!);
-      console.log(`[${ts()}] [RENAME] First message → group renamed to "${newName}"`);
-      await recordSessionRegistry({ chatId, sessionId, tool, chatName: newName }).catch(() => {});
-      await saveSessionTool(sessionId, tool, newName).catch(() => {});
-    } catch (err) {
-      console.error(`[${ts()}] [RENAME] Failed: ${(err as Error).message}`);
-    }
-  }
-
-  if (chatType === "p2p" && platform.kind === "wechat") {
-    try {
-      const reg = await loadSessionRegistryForBinding();
-      const rec = reg[chatId];
-      if (rec && rec.sessionId === sessionId && isUntitledSessionChatName(rec.chatName ?? "")) {
-        const adapter = getAdapterForTool(tool, sessionId);
-        const info = await adapter.getSessionInfo(sessionId).catch(() => undefined);
-        const sessionCwd = info?.cwd ?? (await getDefaultCwd(chatId));
-        const newName2 = sessionChatName(prefix, sessionCwd);
-        await recordSessionRegistry({ chatId, sessionId, tool, chatName: newName2 }).catch(() => {});
-        await saveSessionTool(sessionId, tool, newName2).catch(() => {});
-        console.log(`[${ts()}] [RENAME] WeChat P2P → "${newName2}"`);
-      }
-    } catch (err) {
-      console.error(`[${ts()}] [RENAME] WeChat P2P failed: ${(err as Error).message}`);
-    }
-  }
-}
-
 async function cleanupNonWechatP2pBinding(
   platform: PlatformAdapter,
   chatId: string,
@@ -510,7 +429,11 @@ export async function handleCommand(
           `**Session ID:** ${sessionId}\n` +
           `**工作目录:** \`${cwd}\`\n\n` +
           `直接在这里发消息即可与 ${toolLabel} 对话。\n\n` +
-          buildWelcomeCommands(tool),
+          `发送 **/cd** 切换新建会话的默认目录。\n` +
+          `发送 **/model** 查看或切换当前会话的模型。\n` +
+          `发送 **/new** 创建新会话，**/newh** 重置当前会话（沿用工作目录）。\n` +
+          `发送 **/sessions** 查看所有会话状态。\n` +
+          `发送 \`/git <子命令>\` 在本会话工作目录执行 git，例如 \`/git status\`、\`/git log --oneline -n 5\`。`,
         "green",
       );
       console.log(
@@ -592,7 +515,11 @@ export async function handleCommand(
         `**Session ID:** ${sessionId}\n` +
         `**工作目录:** \`${cwd}\`\n\n` +
         `直接在这里发消息即可与 ${toolLabel} 对话。\n\n` +
-        buildWelcomeCommands(tool),
+        `发送 **/cd** 切换新建会话的默认目录。\n` +
+        `发送 **/model** 查看或切换当前会话的模型。\n` +
+        `发送 **/new** 创建新会话，**/newh** 重置当前会话（沿用工作目录）。\n` +
+        `发送 **/sessions** 查看所有会话状态。\n` +
+        `发送 \`/git <子命令>\` 在本会话工作目录执行 git，例如 \`/git status\`、\`/git log --oneline -n 5\`。`,
       "green",
     );
 
@@ -950,8 +877,9 @@ export async function handleCommand(
         `会话已重置为新的 **${toolLabel}** 会话。\n\n` +
           `**Session ID:** ${newSessionId}\n` +
           `**工作目录:** \`${cwd}\`（沿用当前会话目录）\n\n` +
-          `直接在这里发消息即可继续对话。\n\n` +
-          buildWelcomeCommands(descriptionTool),
+          `直接在这里发消息即可继续对话。\n` +
+          `发送 **/cd** 可切换新建会话的默认目录。\n` +
+          `发送 **/model** 查看或切换当前会话的模型。`,
         "green",
       );
 
@@ -1253,134 +1181,6 @@ export async function handleCommand(
       return;
     }
 
-    // /plan <message> — 只读/规划模式
-    if (textLower.startsWith("/plan ")) {
-      const planText = text.slice(6).trim();
-      const resolved = resolveModeCommand("/plan");
-      if (!planText) {
-        await platform.sendText(chatId, "用法：`/plan <消息>` — 在只读/规划模式下提问。").catch(() => {});
-        logTrace(tid, "DONE", { outcome: "plan_no_message" });
-        return;
-      }
-      if (resolved?.supportedTools.includes(descriptionTool) === true) {
-        logTrace(tid, "BRANCH", { cmd: "/plan", sessionId, tool: descriptionTool });
-
-        await renameUntitledSession(
-          platform, chatId, chatType, sessionId, descriptionTool,
-          planText, description, chatInfo,
-        );
-
-        if (isSessionRunning(sessionId)) {
-          const queued = enqueueMessage(sessionId, {
-            text, chatId, openId, msgTimestamp, chatType, traceId: tid,
-          });
-          if (queued) {
-            logTrace(tid, "QUEUED", { sessionId, mode: "plan" });
-            if (platform.kind === "wechat") {
-              await platform.sendText(chatId, "当前会话正在生成中，你的消息已进入缓存队列，生成完成后会立即处理。发送 /cancel 可取消缓存。").catch(() => {});
-            } else {
-              await platform.sendRawCard(chatId, buildQueuedCard(planText)).catch(() => {});
-            }
-          } else {
-            logTrace(tid, "QUEUE_FULL", { sessionId });
-            if (platform.kind === "wechat") {
-              await platform.sendText(chatId, "当前缓存队列中已有消息等待处理，请等待或发送 /stop（停止生成）或 /cancel（取消缓存）。").catch(() => {});
-            } else {
-              await platform.sendRawCard(chatId, buildQueueFullCard()).catch(() => {});
-            }
-          }
-          return;
-        }
-
-        if (shouldSendWechatProcessingAck(platform, planText.toLowerCase(), chatType)) {
-          await platform.sendText(chatId, "生成中...").catch(() => {});
-        }
-
-        try {
-          logTrace(tid, "RESUME", { sessionId, tool: descriptionTool, mode: "plan" });
-          await resumeAndPrompt(
-            sessionId, planText, platform, chatId, msgTimestamp,
-            descriptionTool, tid, "plan",
-          );
-          logTrace(tid, "DONE", { outcome: "plan_done", sessionId });
-        } catch (err) {
-          logTrace(tid, "DONE", { outcome: "plan_fail", error: (err as Error).message });
-          await platform.sendCard(
-            chatId, "Error",
-            `Failed to run plan mode:\n${(err as Error).message}`,
-            "red",
-          );
-        }
-        return;
-      }
-
-      logTrace(tid, "BRANCH", { cmd: "/plan", sessionId, tool: descriptionTool, fallback: "raw_message" });
-    }
-
-    // /ask <message> — 只读/问答模式
-    if (textLower.startsWith("/ask ")) {
-      const askText = text.slice(5).trim();
-      const resolved = resolveModeCommand("/ask");
-      if (!askText) {
-        await platform.sendText(chatId, "用法：`/ask <消息>` — 在只读/问答模式下提问。").catch(() => {});
-        logTrace(tid, "DONE", { outcome: "ask_no_message" });
-        return;
-      }
-      if (resolved?.supportedTools.includes(descriptionTool) === true) {
-        logTrace(tid, "BRANCH", { cmd: "/ask", sessionId, tool: descriptionTool });
-
-        await renameUntitledSession(
-          platform, chatId, chatType, sessionId, descriptionTool,
-          askText, description, chatInfo,
-        );
-
-        if (isSessionRunning(sessionId)) {
-          const queued = enqueueMessage(sessionId, {
-            text, chatId, openId, msgTimestamp, chatType, traceId: tid,
-          });
-          if (queued) {
-            logTrace(tid, "QUEUED", { sessionId, mode: "ask" });
-            if (platform.kind === "wechat") {
-              await platform.sendText(chatId, "当前会话正在生成中，你的消息已进入缓存队列，生成完成后会立即处理。发送 /cancel 可取消缓存。").catch(() => {});
-            } else {
-              await platform.sendRawCard(chatId, buildQueuedCard(askText)).catch(() => {});
-            }
-          } else {
-            logTrace(tid, "QUEUE_FULL", { sessionId });
-            if (platform.kind === "wechat") {
-              await platform.sendText(chatId, "当前缓存队列中已有消息等待处理，请等待或发送 /stop（停止生成）或 /cancel（取消缓存）。").catch(() => {});
-            } else {
-              await platform.sendRawCard(chatId, buildQueueFullCard()).catch(() => {});
-            }
-          }
-          return;
-        }
-
-        if (shouldSendWechatProcessingAck(platform, askText.toLowerCase(), chatType)) {
-          await platform.sendText(chatId, "生成中...").catch(() => {});
-        }
-
-        try {
-          logTrace(tid, "RESUME", { sessionId, tool: descriptionTool, mode: "ask" });
-          await resumeAndPrompt(
-            sessionId, askText, platform, chatId, msgTimestamp,
-            descriptionTool, tid, "ask",
-          );
-          logTrace(tid, "DONE", { outcome: "ask_done", sessionId });
-        } catch (err) {
-          logTrace(tid, "DONE", { outcome: "ask_fail", error: (err as Error).message });
-          await platform.sendCard(
-            chatId, "Error",
-            `Failed to run ask mode:\n${(err as Error).message}`,
-            "red",
-          );
-        }
-        return;
-      }
-
-      logTrace(tid, "BRANCH", { cmd: "/ask", sessionId, tool: descriptionTool, fallback: "raw_message" });
-    }
-
     const lastTs = lastMsgTimestamps.get(chatId);
     if (lastTs !== undefined && msgTimestamp <= lastTs) {
       logTrace(tid, "DONE", {
@@ -1619,7 +1419,8 @@ export async function handleCommand(
         `**Session ID:** ${sessionId}\n` +
         `**工作目录:** \`${cwd}\`\n\n` +
         `下面会自动把你的私聊消息作为第一句话发送给 ${toolLabel}。\n\n` +
-        buildWelcomeCommands(tool),
+        `发送 **/model** 查看或切换当前会话的模型。\n` +
+        `发送 **/new** 创建新会话，**/newh** 重置当前会话（沿用工作目录）。`,
       "green",
     );
     platform.setChatAvatar(newChatId, tool, "new").catch(() => {});

package/src/session.ts

@@ -832,9 +832,8 @@ export async function resumeAndPrompt(
   msgTimestamp: number,
   tool: string,
   traceId?: string,
-  permissionMode?: "plan" | "ask",
 ): Promise<void> {
-  return runAgentSession(sessionId, userText, platform, chatId, msgTimestamp, tool, traceId, permissionMode);
+  return runAgentSession(sessionId, userText, platform, chatId, msgTimestamp, tool, traceId);
 }
 
 // ---------------------------------------------------------------------------
@@ -849,7 +848,6 @@ export async function runAgentSession(
   msgTimestamp: number,
   tool: string,
   traceId?: string,
-  permissionMode?: "plan" | "ask",
 ): Promise<void> {
   const tid = traceId ?? "";
 
@@ -1108,7 +1106,6 @@ export async function runAgentSession(
         clearPromptProcessMonitor(sessionId);
         if (exitInfo.pid !== undefined) unregisterProcess(exitInfo.pid);
       },
-      permissionMode,
     })) {
       for (const block of unifiedMsg.blocks) {
         accumulateBlockContent(block, state, toolCallMap);