stashes 0.1.19 → 0.1.21

package/dist/mcp.js

@@ -538,6 +538,7 @@ function killAiProcess(id) {
   }
   return false;
 }
+var toolNameMap = new Map;
 async function* parseClaudeStream(proc) {
   const stdout = proc.stdout;
   if (!stdout || typeof stdout === "number") {
@@ -574,15 +575,58 @@ async function* parseClaudeStream(proc) {
             } else if (block.type === "thinking" && block.thinking) {
               yield { type: "thinking", content: block.thinking };
             } else if (block.type === "tool_use") {
-              logger.debug("claude", `tool_use: ${block.name}`);
-              yield { type: "tool_use", content: JSON.stringify({ tool: block.name, input: block.input }) };
+              const toolId = block.id;
+              const toolName = block.name;
+              toolNameMap.set(toolId, toolName);
+              logger.debug("claude", `tool_use: ${toolName}`);
+              yield {
+                type: "tool_use",
+                content: JSON.stringify({ tool: toolName, input: block.input }),
+                toolName,
+                toolInput: block.input,
+                toolUseId: toolId
+              };
             }
           }
         }
+        if (parsed.type === "user" && parsed.message) {
+          const message = parsed.message;
+          for (const block of message.content || []) {
+            if (block.type === "tool_result") {
+              const toolUseId = block.tool_use_id;
+              const isError = block.is_error || false;
+              const toolName = toolNameMap.get(toolUseId) || "unknown";
+              let resultContent;
+              if (typeof block.content === "string") {
+                resultContent = block.content;
+              } else if (Array.isArray(block.content)) {
+                resultContent = block.content.filter((c) => c.type === "text").map((c) => c.text).join(`
+`);
+              } else {
+                resultContent = "";
+              }
+              yield {
+                type: "tool_result",
+                content: resultContent.substring(0, 500),
+                toolName,
+                toolUseId,
+                isError
+              };
+            }
+          }
+        }
+        if (parsed.type === "result") {
+          yield {
+            type: "result",
+            content: "",
+            resultSubtype: parsed.subtype
+          };
+        }
       }
     }
   } finally {
     logger.debug("claude", `stream ended`, { totalChunks: chunkCount });
+    toolNameMap.clear();
     reader.releaseLock();
   }
 }
@@ -964,6 +1008,34 @@ async function remove(projectPath, stashId) {
   } catch {}
   logger.info("manage", `removed stash: ${stashId}`);
 }
+async function show(projectPath, stashId) {
+  const persistence = new PersistenceService(projectPath);
+  let found;
+  for (const project of persistence.listProjects()) {
+    found = persistence.getStash(project.id, stashId);
+    if (found)
+      break;
+  }
+  if (!found)
+    return null;
+  const git = simpleGit4(projectPath);
+  const branch = found.branch || `stashes/${stashId}`;
+  let diff = "";
+  let files = [];
+  try {
+    const base = await git.raw(["merge-base", "HEAD", branch]);
+    diff = await git.raw(["diff", base.trim(), branch, "--stat"]);
+    const fullDiff = await git.raw(["diff", base.trim(), branch]);
+    diff = fullDiff.length > 8000 ? fullDiff.substring(0, 8000) + `
+... (truncated)` : fullDiff;
+    const fileList = await git.raw(["diff", "--name-only", base.trim(), branch]);
+    files = fileList.trim().split(`
+`).filter(Boolean);
+  } catch {
+    diff = "(branch not found or no diff available)";
+  }
+  return { stash: found, diff, files };
+}
 // ../mcp/src/tools/generate.ts
 var generateParams = {
   prompt: z.string().describe('What UI changes to generate (e.g. "make the hero section bolder")'),
@@ -1088,10 +1160,48 @@ async function handleVary(args, projectPath) {
   };
 }
 
-// ../mcp/src/tools/remove.ts
+// ../mcp/src/tools/show.ts
 import { z as z4 } from "zod";
+var showParams = {
+  stashId: z4.string().describe('The stash ID to inspect (e.g. "stash_a1b2c3d4")')
+};
+async function handleShow(args, projectPath) {
+  const { stashId } = args;
+  initLogFile(projectPath);
+  const result = await show(projectPath, stashId);
+  if (!result) {
+    return {
+      content: [{
+        type: "text",
+        text: `No stash found with ID "${stashId}".`
+      }]
+    };
+  }
+  const { stash, diff, files } = result;
+  return {
+    content: [{
+      type: "text",
+      text: JSON.stringify({
+        id: stash.id,
+        number: stash.number,
+        prompt: stash.prompt,
+        status: stash.status,
+        branch: stash.branch,
+        componentPath: stash.componentPath ?? null,
+        screenshotPath: stash.screenshotUrl,
+        relatedTo: stash.relatedTo,
+        createdAt: stash.createdAt,
+        filesChanged: files,
+        diff
+      }, null, 2)
+    }]
+  };
+}
+
+// ../mcp/src/tools/remove.ts
+import { z as z5 } from "zod";
 var removeParams = {
-  stashId: z4.string().describe("The stash ID to remove")
+  stashId: z5.string().describe("The stash ID to remove")
 };
 async function handleRemove(args, projectPath) {
   const { stashId } = args;
@@ -1482,9 +1592,12 @@ ${refs.join(`
     }
     const chatPrompt = [
       "You are helping the user explore UI design variations for their project.",
-      "You have access to stashes MCP tools to generate, list, browse, vary, and apply stashes.",
+      "You have access to stashes MCP tools to generate, list, show, browse, vary, and apply stashes.",
       "If the user asks you to generate, create, or make variations, use the stashes_generate tool.",
       "If the user asks to vary an existing stash, use the stashes_vary tool.",
+      "If the user asks about what a stash changed, its diff, or its contents, use stashes_show to inspect it.",
+      'IMPORTANT: NEVER call stashes_apply unless the user explicitly asks to "apply" or "merge" a stash.',
+      'IMPORTANT: NEVER call stashes_remove unless the user explicitly asks to "delete" or "remove" a stash.',
       "Otherwise, respond conversationally about their project and stashes.",
       "",
       component ? `Component: ${component.name}` : "",
@@ -1500,11 +1613,27 @@ ${sourceCode.substring(0, 3000)}
     ].filter(Boolean).join(`
 `);
     const aiProcess = startAiProcess("chat", chatPrompt, this.projectPath);
-    let fullResponse = "";
+    let thinkingBuf = "";
+    let textBuf = "";
+    const pendingMessages = [];
+    const now = new Date().toISOString();
+    function flushThinking() {
+      if (!thinkingBuf)
+        return;
+      pendingMessages.push({ id: crypto.randomUUID(), role: "assistant", content: thinkingBuf, type: "thinking", createdAt: now });
+      thinkingBuf = "";
+    }
+    function flushText() {
+      if (!textBuf)
+        return;
+      pendingMessages.push({ id: crypto.randomUUID(), role: "assistant", content: textBuf, type: "text", createdAt: now });
+      textBuf = "";
+    }
     try {
       for await (const chunk of parseClaudeStream(aiProcess.process)) {
         if (chunk.type === "text") {
-          fullResponse += chunk.content;
+          flushThinking();
+          textBuf += chunk.content;
           this.broadcast({
             type: "ai_stream",
             content: chunk.content,
@@ -1512,6 +1641,7 @@ ${sourceCode.substring(0, 3000)}
             source: "chat"
           });
         } else if (chunk.type === "thinking") {
+          thinkingBuf += chunk.content;
           this.broadcast({
             type: "ai_stream",
             content: chunk.content,
@@ -1519,13 +1649,25 @@ ${sourceCode.substring(0, 3000)}
             source: "chat"
           });
         } else if (chunk.type === "tool_use") {
+          flushThinking();
+          flushText();
           let toolName = "unknown";
           let toolParams = {};
           try {
             const parsed = JSON.parse(chunk.content);
-            toolName = parsed.tool || parsed.name || "unknown";
-            toolParams = parsed.input || parsed.params || {};
+            toolName = parsed.tool ?? "unknown";
+            toolParams = parsed.input ?? {};
           } catch {}
+          pendingMessages.push({
+            id: crypto.randomUUID(),
+            role: "assistant",
+            content: chunk.content,
+            type: "tool_start",
+            toolName,
+            toolParams,
+            toolStatus: "running",
+            createdAt: now
+          });
           this.broadcast({
             type: "ai_stream",
             content: chunk.content,
@@ -1536,35 +1678,37 @@ ${sourceCode.substring(0, 3000)}
             toolStatus: "running"
           });
         } else if (chunk.type === "tool_result") {
-          let toolName = "unknown";
-          let toolResult = "";
+          let toolResult = chunk.content;
+          let isError = false;
           try {
             const parsed = JSON.parse(chunk.content);
-            toolName = parsed.tool || parsed.name || "unknown";
-            toolResult = typeof parsed.result === "string" ? parsed.result.substring(0, 200) : JSON.stringify(parsed.result).substring(0, 200);
-          } catch {
-            toolResult = chunk.content.substring(0, 200);
-          }
+            toolResult = parsed.result ?? chunk.content;
+            isError = !!parsed.is_error;
+          } catch {}
+          pendingMessages.push({
+            id: crypto.randomUUID(),
+            role: "assistant",
+            content: chunk.content,
+            type: "tool_end",
+            toolStatus: isError ? "error" : "completed",
+            toolResult: toolResult.substring(0, 300),
+            createdAt: now
+          });
           this.broadcast({
             type: "ai_stream",
             content: chunk.content,
             streamType: "tool_end",
             source: "chat",
-            toolName,
-            toolStatus: "completed",
-            toolResult
+            toolStatus: isError ? "error" : "completed",
+            toolResult: toolResult.substring(0, 300)
           });
         }
       }
       await aiProcess.process.exited;
-      if (fullResponse) {
-        this.persistence.saveChatMessage(projectId, chatId, {
-          id: crypto.randomUUID(),
-          role: "assistant",
-          content: fullResponse,
-          type: "text",
-          createdAt: new Date().toISOString()
-        });
+      flushThinking();
+      flushText();
+      for (const msg of pendingMessages) {
+        this.persistence.saveChatMessage(projectId, chatId, msg);
       }
     } catch (err) {
       this.broadcast({
@@ -2196,7 +2340,8 @@ var server = new McpServer({
 });
 server.tool("stashes_generate", "Generate multiple AI-powered UI design explorations (stashes) for a given prompt. Each stash applies a different creative direction.", generateParams, async (args) => handleGenerate(args, projectPath));
 server.tool("stashes_list", "List all existing stashes in the current project. Shows ID, prompt, status, branch, and screenshot path.", listParams, async (args) => handleList(args, projectPath));
-server.tool("stashes_apply", "Merge a stash branch into the current git branch. Applies the AI-generated UI changes and cleans up all worktrees.", applyParams, async (args) => handleApply(args, projectPath));
+server.tool("stashes_show", "Show detailed information about a specific stash including its git diff, changed files, prompt, and metadata. Use this to inspect what a stash changed without applying it.", showParams, async (args) => handleShow(args, projectPath));
+server.tool("stashes_apply", "Merge a stash branch into the current git branch. Applies the AI-generated UI changes and cleans up all worktrees. ONLY use when the user explicitly asks to apply or merge.", applyParams, async (args) => handleApply(args, projectPath));
 server.tool("stashes_vary", "Create a variation of an existing stash by applying additional changes on top of it.", varyParams, async (args) => handleVary(args, projectPath));
 server.tool("stashes_remove", "Delete a stash \u2014 removes its persistence entry and git branch.", removeParams, async (args) => handleRemove(args, projectPath));
 server.tool("stashes_browse", "Start the Stashes web server and open the browser for interactive browsing of generated stashes.", browseParams, async (args) => handleBrowse(args, projectPath));