stashes 0.1.11 → 0.1.13

package/dist/cli.js

@@ -52,7 +52,7 @@ var DEFAULT_DIRECTIVES = [
 ];
 // ../server/dist/routes/api.js
 import { Hono } from "hono";
-import { join } from "path";
+import { join, basename } from "path";
 import { existsSync, readFileSync } from "fs";
 var app = new Hono;
 app.get("/health", (c) => c.json({ status: "ok", service: "stashes" }));
@@ -84,14 +84,54 @@ app.get("/projects/:id", (c) => {
   if (!project)
     return c.json({ error: "Project not found" }, 404);
   const stashes = persistence.listStashes(project.id);
-  const chat = persistence.getChatHistory(project.id);
-  return c.json({ data: { ...project, stashes, chat } });
+  const chats = persistence.listChats(project.id);
+  return c.json({ data: { ...project, stashes, chats } });
 });
 app.delete("/projects/:id", (c) => {
   const id = c.req.param("id");
   getPersistence().deleteProject(id);
   return c.json({ data: { deleted: id } });
 });
+app.get("/chats", (c) => {
+  const persistence = getPersistence();
+  const project = ensureProject(persistence);
+  const chats = persistence.listChats(project.id);
+  const stashes = persistence.listStashes(project.id);
+  return c.json({ data: { project, chats, stashCount: stashes.length } });
+});
+app.post("/chats", async (c) => {
+  const persistence = getPersistence();
+  const project = ensureProject(persistence);
+  const { title } = await c.req.json();
+  const chatCount = persistence.listChats(project.id).length;
+  const chat = {
+    id: `chat_${crypto.randomUUID().substring(0, 8)}`,
+    projectId: project.id,
+    title: title?.trim() || `Chat ${chatCount + 1}`,
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString()
+  };
+  persistence.saveChat(chat);
+  return c.json({ data: chat }, 201);
+});
+app.get("/chats/:chatId", (c) => {
+  const persistence = getPersistence();
+  const project = ensureProject(persistence);
+  const chatId = c.req.param("chatId");
+  const chat = persistence.getChat(project.id, chatId);
+  if (!chat)
+    return c.json({ error: "Chat not found" }, 404);
+  const messages = persistence.getChatMessages(project.id, chatId);
+  const stashes = persistence.listStashes(project.id).filter((s) => s.originChatId === chatId);
+  return c.json({ data: { ...chat, messages, stashes } });
+});
+app.delete("/chats/:chatId", (c) => {
+  const persistence = getPersistence();
+  const project = ensureProject(persistence);
+  const chatId = c.req.param("chatId");
+  persistence.deleteChat(project.id, chatId);
+  return c.json({ data: { deleted: chatId } });
+});
 app.get("/screenshots/:filename", (c) => {
   const filename = c.req.param("filename");
   const filePath = join(serverState.projectPath, ".stashes", "screenshots", filename);
@@ -102,6 +142,20 @@ app.get("/screenshots/:filename", (c) => {
     headers: { "content-type": "image/png", "cache-control": "no-cache" }
   });
 });
+function ensureProject(persistence) {
+  const projects = persistence.listProjects();
+  if (projects.length > 0)
+    return projects[0];
+  const project = {
+    id: `proj_${crypto.randomUUID().substring(0, 8)}`,
+    name: basename(serverState.projectPath),
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString()
+  };
+  persistence.saveProject(project);
+  persistence.migrateOldChat(project.id);
+  return project;
+}
 var apiRoutes = app;
 
 // ../core/dist/generation.js
@@ -411,7 +465,7 @@ class WorktreeManager {
 }
 
 // ../core/dist/persistence.js
-import { readFileSync as readFileSync2, writeFileSync, mkdirSync as mkdirSync2, existsSync as existsSync4, rmSync as rmSync2 } from "fs";
+import { readFileSync as readFileSync2, writeFileSync, mkdirSync as mkdirSync2, existsSync as existsSync4, rmSync as rmSync2, readdirSync } from "fs";
 import { join as join4, dirname } from "path";
 var STASHES_DIR = ".stashes";
 function ensureDir(dirPath) {
@@ -488,14 +542,64 @@ class PersistenceService {
     const filePath = join4(this.basePath, "projects", projectId, "stashes.json");
     writeJson(filePath, stashes);
   }
-  getChatHistory(projectId) {
-    const filePath = join4(this.basePath, "projects", projectId, "chat.json");
-    return readJson(filePath, []);
-  }
-  saveChatMessage(projectId, message) {
-    const messages = [...this.getChatHistory(projectId), message];
-    const filePath = join4(this.basePath, "projects", projectId, "chat.json");
-    writeJson(filePath, messages);
+  listChats(projectId) {
+    const dir = join4(this.basePath, "projects", projectId, "chats");
+    if (!existsSync4(dir))
+      return [];
+    const files = readdirSync(dir).filter((f) => f.endsWith(".json"));
+    return files.map((f) => {
+      const data = readJson(join4(dir, f), null);
+      return data?.chat;
+    }).filter(Boolean).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+  }
+  getChat(projectId, chatId) {
+    const filePath = join4(this.basePath, "projects", projectId, "chats", `${chatId}.json`);
+    const data = readJson(filePath, null);
+    return data?.chat;
+  }
+  saveChat(chat) {
+    const filePath = join4(this.basePath, "projects", chat.projectId, "chats", `${chat.id}.json`);
+    const existing = readJson(filePath, { chat, messages: [] });
+    writeJson(filePath, { ...existing, chat });
+  }
+  deleteChat(projectId, chatId) {
+    const filePath = join4(this.basePath, "projects", projectId, "chats", `${chatId}.json`);
+    if (existsSync4(filePath)) {
+      rmSync2(filePath);
+    }
+  }
+  getChatMessages(projectId, chatId) {
+    const filePath = join4(this.basePath, "projects", projectId, "chats", `${chatId}.json`);
+    const data = readJson(filePath, { messages: [] });
+    return data.messages;
+  }
+  saveChatMessage(projectId, chatId, message) {
+    const filePath = join4(this.basePath, "projects", projectId, "chats", `${chatId}.json`);
+    const data = readJson(filePath, { chat: this.getChat(projectId, chatId), messages: [] });
+    writeJson(filePath, { ...data, messages: [...data.messages, message] });
+  }
+  migrateOldChat(projectId) {
+    const oldPath = join4(this.basePath, "projects", projectId, "chat.json");
+    if (!existsSync4(oldPath))
+      return null;
+    const messages = readJson(oldPath, []);
+    if (messages.length === 0) {
+      rmSync2(oldPath);
+      return null;
+    }
+    const chatId = `chat_${crypto.randomUUID().substring(0, 8)}`;
+    const chat = {
+      id: chatId,
+      projectId,
+      title: "Initial conversation",
+      createdAt: messages[0].createdAt,
+      updatedAt: messages[messages.length - 1].createdAt
+    };
+    const filePath = join4(this.basePath, "projects", projectId, "chats", `${chatId}.json`);
+    writeJson(filePath, { chat, messages });
+    rmSync2(oldPath);
+    logger.info("persistence", `migrated old chat.json \u2192 ${chatId}`);
+    return chatId;
   }
   ensureGitignore(projectPath) {
     const gitignorePath = join4(projectPath, ".gitignore");
@@ -721,7 +825,7 @@ async function allocatePort() {
   throw new Error("No available ports in range 4010-4030");
 }
 async function generate(opts) {
-  const { projectPath, projectId, prompt, component, count = DEFAULT_STASH_COUNT, directives = DEFAULT_DIRECTIVES, onProgress } = opts;
+  const { projectPath, projectId, chatId, prompt, component, count = DEFAULT_STASH_COUNT, directives = DEFAULT_DIRECTIVES, onProgress } = opts;
   const worktreeManager = new WorktreeManager(projectPath);
   const persistence = new PersistenceService(projectPath);
   const selectedDirectives = directives.slice(0, count);
@@ -733,12 +837,17 @@ async function generate(opts) {
     }
   }
   const completedStashes = [];
-  const stashPromises = selectedDirectives.map(async (directive) => {
+  const existingStashes = persistence.listStashes(projectId);
+  const maxNumber = existingStashes.reduce((max, s) => Math.max(max, s.number ?? 0), 0);
+  const stashPromises = selectedDirectives.map(async (directive, idx) => {
     const stashId = `stash_${crypto.randomUUID().substring(0, 8)}`;
+    const stashNumber = maxNumber + idx + 1;
     const worktree = await worktreeManager.createForGeneration(stashId);
     const stash = {
       id: stashId,
+      number: stashNumber,
       projectId,
+      originChatId: chatId,
       prompt,
       componentPath: component?.filePath,
       branch: worktree.branch,
@@ -751,7 +860,7 @@ async function generate(opts) {
       createdAt: new Date().toISOString()
     };
     persistence.saveStash(stash);
-    emit(onProgress, { type: "generating", stashId });
+    emit(onProgress, { type: "generating", stashId, number: stashNumber });
     let stashPrompt;
     if (component?.filePath) {
       stashPrompt = buildStashPrompt({ name: component.exportName || component.filePath, filePath: component.filePath, domSelector: "" }, sourceCode, prompt, directive);
@@ -840,7 +949,7 @@ async function allocatePort2() {
   throw new Error("No available ports in range 4010-4030");
 }
 async function vary(opts) {
-  const { projectPath, sourceStashId, prompt, onProgress } = opts;
+  const { projectPath, sourceStashId, chatId, prompt, onProgress } = opts;
   const persistence = new PersistenceService(projectPath);
   const worktreeManager = new WorktreeManager(projectPath);
   let sourceStash;
@@ -856,10 +965,14 @@ async function vary(opts) {
   if (!sourceStash)
     throw new Error(`Source stash ${sourceStashId} not found`);
   const stashId = `stash_${crypto.randomUUID().substring(0, 8)}`;
+  const existingStashes = persistence.listStashes(projectId);
+  const stashNumber = existingStashes.reduce((max, s) => Math.max(max, s.number ?? 0), 0) + 1;
   const worktree = await worktreeManager.createForVary(stashId, sourceStash.branch);
   const stash = {
     id: stashId,
+    number: stashNumber,
     projectId,
+    originChatId: chatId,
     prompt,
     componentPath: sourceStash.componentPath,
     branch: worktree.branch,
@@ -872,7 +985,7 @@ async function vary(opts) {
     createdAt: new Date().toISOString()
   };
   persistence.saveStash(stash);
-  emit2(onProgress, { type: "generating", stashId });
+  emit2(onProgress, { type: "generating", stashId, number: stashNumber });
   const varyPrompt = `The user wants to vary the current UI. Apply this change: ${prompt}`;
   const aiProcess = startAiProcess(stashId, varyPrompt, worktree.path);
   try {
@@ -1217,8 +1330,8 @@ class StashService {
       });
     }
   }
-  async chat(projectId, message, referenceStashIds) {
-    const component = this.selectedComponent;
+  async message(projectId, chatId, message, referenceStashIds, componentContext) {
+    const component = componentContext ? { name: componentContext.name, filePath: this.selectedComponent?.filePath || "" } : this.selectedComponent;
     let sourceCode = "";
     const filePath = component?.filePath || "";
     if (filePath && filePath !== "auto-detect") {
@@ -1238,8 +1351,11 @@ ${refs.join(`
       }
     }
     const chatPrompt = [
-      "The user is asking about their UI project. Answer concisely.",
-      "Do NOT modify any files.",
+      "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.",
+      "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.",
+      "Otherwise, respond conversationally about their project and stashes.",
       "",
       component ? `Component: ${component.name}` : "",
       filePath !== "auto-detect" ? `File: ${filePath}` : "",
@@ -1250,7 +1366,7 @@ ${sourceCode.substring(0, 3000)}
 \`\`\`` : "",
       stashContext,
       "",
-      `User question: ${message}`
+      `User: ${message}`
     ].filter(Boolean).join(`
 `);
     const aiProcess = startAiProcess("chat", chatPrompt, this.projectPath);
@@ -1259,12 +1375,60 @@ ${sourceCode.substring(0, 3000)}
       for await (const chunk of parseClaudeStream(aiProcess.process)) {
         if (chunk.type === "text") {
           fullResponse += chunk.content;
-          this.broadcast({ type: "ai_stream", content: chunk.content, streamType: "text", source: "chat" });
+          this.broadcast({
+            type: "ai_stream",
+            content: chunk.content,
+            streamType: "text",
+            source: "chat"
+          });
+        } else if (chunk.type === "thinking") {
+          this.broadcast({
+            type: "ai_stream",
+            content: chunk.content,
+            streamType: "thinking",
+            source: "chat"
+          });
+        } else if (chunk.type === "tool_use") {
+          let toolName = "unknown";
+          let toolParams = {};
+          try {
+            const parsed = JSON.parse(chunk.content);
+            toolName = parsed.tool || parsed.name || "unknown";
+            toolParams = parsed.input || parsed.params || {};
+          } catch {}
+          this.broadcast({
+            type: "ai_stream",
+            content: chunk.content,
+            streamType: "tool_start",
+            source: "chat",
+            toolName,
+            toolParams,
+            toolStatus: "running"
+          });
+        } else if (chunk.type === "tool_result") {
+          let toolName = "unknown";
+          let toolResult = "";
+          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);
+          }
+          this.broadcast({
+            type: "ai_stream",
+            content: chunk.content,
+            streamType: "tool_end",
+            source: "chat",
+            toolName,
+            toolStatus: "completed",
+            toolResult
+          });
         }
       }
       await aiProcess.process.exited;
       if (fullResponse) {
-        this.persistence.saveChatMessage(projectId, {
+        this.persistence.saveChatMessage(projectId, chatId, {
           id: crypto.randomUUID(),
           role: "assistant",
           content: fullResponse,
@@ -1275,7 +1439,7 @@ ${sourceCode.substring(0, 3000)}
     } catch (err) {
       this.broadcast({
         type: "ai_stream",
-        content: `Chat error: ${err instanceof Error ? err.message : String(err)}`,
+        content: `Error: ${err instanceof Error ? err.message : String(err)}`,
         streamType: "text",
         source: "chat"
       });
@@ -1288,7 +1452,12 @@ ${sourceCode.substring(0, 3000)}
       case "generating":
       case "screenshotting":
       case "ready":
-        this.broadcast({ type: "stash:status", stashId: event.stashId, status: event.type === "ready" ? "ready" : event.type });
+        this.broadcast({
+          type: "stash:status",
+          stashId: event.stashId,
+          status: event.type === "ready" ? "ready" : event.type,
+          ..."number" in event ? { number: event.number } : {}
+        });
         if (event.type === "ready" && "screenshotPath" in event && event.screenshotPath) {
           this.broadcast({ type: "stash:screenshot", stashId: event.stashId, url: event.screenshotPath });
         }
@@ -1296,9 +1465,11 @@ ${sourceCode.substring(0, 3000)}
       case "error":
         this.broadcast({ type: "stash:error", stashId: event.stashId, error: event.error });
         break;
-      case "ai_stream":
-        this.broadcast({ type: "ai_stream", content: event.content, streamType: event.streamType });
+      case "ai_stream": {
+        const streamType = event.streamType === "tool_use" ? "tool_start" : event.streamType;
+        this.broadcast({ type: "ai_stream", content: event.content, streamType });
         break;
+      }
     }
   }
   async generate(projectId, prompt, stashCount = DEFAULT_STASH_COUNT, referenceStashIds) {
@@ -1373,7 +1544,14 @@ function createWebSocketHandler(projectPath, userDevPort, appProxyPort) {
     open(ws) {
       clients.add(ws);
       logger.info("ws", "client connected", { total: clients.size });
-      ws.send(JSON.stringify({ type: "server_ready", port: userDevPort, appProxyPort }));
+      const project = ensureProject(persistence);
+      ws.send(JSON.stringify({
+        type: "server_ready",
+        port: userDevPort,
+        appProxyPort,
+        projectId: project.id,
+        projectName: project.name
+      }));
     },
     async message(ws, message) {
       const raw = typeof message === "string" ? message : new TextDecoder().decode(message);
@@ -1392,28 +1570,17 @@ function createWebSocketHandler(projectPath, userDevPort, appProxyPort) {
           case "select_component":
             stashService.setSelectedComponent(event.component);
             break;
-          case "chat":
-            persistence.saveChatMessage(event.projectId, {
+          case "message":
+            persistence.saveChatMessage(event.projectId, event.chatId, {
               id: crypto.randomUUID(),
               role: "user",
               content: event.message,
               type: "text",
-              createdAt: new Date().toISOString()
-            });
-            await stashService.chat(event.projectId, event.message, event.referenceStashIds);
-            break;
-          case "generate":
-            persistence.saveChatMessage(event.projectId, {
-              id: crypto.randomUUID(),
-              role: "user",
-              content: event.prompt,
-              type: "text",
-              createdAt: new Date().toISOString()
+              createdAt: new Date().toISOString(),
+              referenceStashIds: event.referenceStashIds,
+              componentContext: event.componentContext
             });
-            await stashService.generate(event.projectId, event.prompt, event.stashCount, event.referenceStashIds);
-            break;
-          case "vary":
-            await stashService.vary(event.sourceStashId, event.prompt);
+            await stashService.message(event.projectId, event.chatId, event.message, event.referenceStashIds, event.componentContext);
             break;
           case "interact":
             await stashService.switchPreview(event.stashId, event.sortedStashIds);