claude-ws 0.1.0 → 0.1.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Claude Kanban Contributors
+Copyright (c) 2026 Claude Workspace Contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-ws",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "private": false,
   "description": "A beautifully crafted workspace interface for Claude Code with real-time streaming and local SQLite database",
   "keywords": ["claude", "claude-code", "workspace", "task-management", "ai", "anthropic", "nextjs", "sqlite"],
@@ -21,7 +21,6 @@
     "bin",
     "src",
     "public",
-    ".next",
     "server.ts",
     "next.config.ts",
     "tsconfig.json",

package/server.ts

@@ -17,6 +17,9 @@ import { eq } from 'drizzle-orm';
 import { nanoid } from 'nanoid';
 import type { AttemptStatus } from './src/types';
 import { processAttachments } from './src/lib/file-processor';
+import { usageTracker } from './src/lib/usage-tracker';
+import { workflowTracker } from './src/lib/workflow-tracker';
+import { gitStatsCache } from './src/lib/git-stats-collector';
 
 const dev = process.env.NODE_ENV !== 'production';
 const hostname = 'localhost';
@@ -191,80 +194,41 @@ app.prepare().then(async () => {
       socket.leave(`attempt:${data.attemptId}`);
     });
 
-    // Handle AskUserQuestion response - start a new attempt with --resume
+    // Handle AskUserQuestion response - resolve pending canUseTool callback
     socket.on(
       'question:answer',
-      async (data: { attemptId: string; answer: string }) => {
-        const { attemptId, answer } = data;
-        console.log(`[Server] Received answer for ${attemptId}: ${answer}`);
-
-        // Get session ID for the original attempt
-        const sessionId = await sessionManager.getSessionId(attemptId);
-
-        if (!sessionId) {
-          console.error(`[Server] Session not found for ${attemptId}`);
-          socket.emit('error', { message: 'Session not found' });
-          return;
-        }
-
-        try {
-          // Get the original attempt to find taskId
-          const originalAttempt = await db.query.attempts.findFirst({
-            where: eq(schema.attempts.id, attemptId),
-          });
-
-          if (!originalAttempt) {
-            socket.emit('error', { message: 'Attempt not found' });
-            return;
+      async (data: { attemptId: string; questions: unknown[]; answers: Record<string, string> }) => {
+        const { attemptId, questions, answers } = data;
+        console.log(`[Server] Received answer for ${attemptId}:`, answers);
+
+        // Check if there's a pending question (canUseTool callback waiting)
+        if (agentManager.hasPendingQuestion(attemptId)) {
+          // Resolve the pending Promise - SDK will resume streaming
+          const success = agentManager.answerQuestion(attemptId, questions, answers);
+          if (success) {
+            console.log(`[Server] Resumed streaming for ${attemptId}`);
+          } else {
+            console.error(`[Server] Failed to answer question for ${attemptId}`);
+            socket.emit('error', { message: 'Failed to answer question' });
           }
+        } else {
+          // Fallback: No pending question (legacy behavior or reconnection)
+          console.warn(`[Server] No pending question for ${attemptId}, attempting legacy flow`);
+          socket.emit('error', { message: 'No pending question found' });
+        }
+      }
+    );
 
-          // Get task and project info
-          const task = await db.query.tasks.findFirst({
-            where: eq(schema.tasks.id, originalAttempt.taskId),
-          });
-
-          if (!task) {
-            socket.emit('error', { message: 'Task not found' });
-            return;
-          }
-
-          const project = await db.query.projects.findFirst({
-            where: eq(schema.projects.id, task.projectId),
-          });
-
-          if (!project) {
-            socket.emit('error', { message: 'Project not found' });
-            return;
-          }
-
-          // Create new attempt with the answer as prompt
-          const newAttemptId = nanoid();
-          await db.insert(schema.attempts).values({
-            id: newAttemptId,
-            taskId: originalAttempt.taskId,
-            prompt: answer,
-            displayPrompt: `Answer: ${answer}`,
-            status: 'running',
-          });
-
-          // Join new attempt room
-          socket.join(`attempt:${newAttemptId}`);
-
-          // Start new query with resume (continuing current conversation)
-          agentManager.start({
-            attemptId: newAttemptId,
-            projectPath: project.path,
-            prompt: answer,
-            sessionOptions: { resume: sessionId },
-          });
-
-          console.log(`[Server] Started continuation attempt ${newAttemptId} with session ${sessionId}`);
-
-          socket.emit('attempt:started', { attemptId: newAttemptId, taskId: originalAttempt.taskId });
-          io.emit('task:started', { taskId: originalAttempt.taskId });
-        } catch (error) {
-          console.error(`[Server] Error starting continuation:`, error);
-          socket.emit('error', { message: 'Failed to continue conversation' });
+    // Handle AskUserQuestion cancellation
+    socket.on(
+      'question:cancel',
+      async (data: { attemptId: string }) => {
+        const { attemptId } = data;
+        console.log(`[Server] Cancelling question for ${attemptId}`);
+
+        if (agentManager.hasPendingQuestion(attemptId)) {
+          agentManager.cancelQuestion(attemptId);
+          console.log(`[Server] Question cancelled for ${attemptId}`);
         }
       }
     );
@@ -540,9 +504,43 @@ app.prepare().then(async () => {
       where: eq(schema.attempts.id, attemptId),
     });
 
+    if (!attempt) {
+      console.error(`[Server] Attempt ${attemptId} not found`);
+      return;
+    }
+
+    // Get usage stats from tracker
+    const usageStats = usageTracker.getUsage(attemptId);
+    const gitStatsData = gitStatsCache.get(attemptId);
+
+    // Update attempt with status and usage stats
     await db
       .update(schema.attempts)
-      .set({ status, completedAt: Date.now() })
+      .set({
+        status,
+        completedAt: Date.now(),
+        // Save usage stats
+        ...(usageStats && {
+          totalTokens: usageStats.totalTokens,
+          inputTokens: usageStats.totalInputTokens,
+          outputTokens: usageStats.totalOutputTokens,
+          cacheCreationTokens: usageStats.totalCacheCreationTokens,
+          cacheReadTokens: usageStats.totalCacheReadTokens,
+          totalCostUSD: usageStats.totalCostUSD.toString(),
+          numTurns: usageStats.numTurns,
+          durationMs: usageStats.durationMs,
+          // Context usage (calculated from cache_read_input_tokens)
+          contextUsed: usageStats.contextUsed,
+          contextLimit: usageStats.contextLimit,
+          contextPercentage: Math.round(usageStats.contextPercentage),
+          baselineContext: usageStats.baselineContext,
+        }),
+        // Save git stats
+        ...(gitStatsData && {
+          diffAdditions: gitStatsData.additions,
+          diffDeletions: gitStatsData.deletions,
+        }),
+      })
       .where(eq(schema.attempts.id, attemptId));
 
     // Create checkpoint on successful completion
@@ -597,12 +595,44 @@ app.prepare().then(async () => {
       code,
     });
 
+    // Emit git stats if available
+    const gitStats = gitStatsCache.get(attemptId);
+    if (gitStats) {
+      console.log(`[Server] Emitting status:git for ${attemptId}: +${gitStats.additions} -${gitStats.deletions}`);
+      io.to(`attempt:${attemptId}`).emit('status:git', {
+        attemptId,
+        stats: gitStats,
+      });
+    }
+
     // Global event for all clients to track completed tasks
     if (attempt?.taskId) {
       io.emit('task:finished', { taskId: attempt.taskId, status });
     }
   });
 
+  // Forward tracking module events to Socket.io clients
+  // Usage tracking (tokens, costs, model usage)
+  usageTracker.on('usage-update', ({ attemptId, usage }) => {
+    console.log(`[Server] Emitting status:usage for ${attemptId}:`, usage.totalTokens, 'tokens');
+    io.to(`attempt:${attemptId}`).emit('status:usage', {
+      attemptId,
+      usage,
+    });
+  });
+
+  // Workflow tracking (subagent execution chain)
+  workflowTracker.on('workflow-update', ({ attemptId, workflow }) => {
+    const summary = workflowTracker.getWorkflowSummary(attemptId);
+    if (summary) {
+      console.log(`[Server] Emitting status:workflow for ${attemptId}:`, summary.chain);
+      io.to(`attempt:${attemptId}`).emit('status:workflow', {
+        attemptId,
+        workflow: summary,
+      });
+    }
+  });
+
   // Extract summary from last assistant message
   function extractSummary(logs: { type: string; content: string }[]): string {
     for (let i = logs.length - 1; i >= 0; i--) {

package/src/app/api/files/route.ts

@@ -17,7 +17,7 @@ export async function GET(request: NextRequest) {
     const searchParams = request.nextUrl.searchParams;
     const basePath = searchParams.get('path');
     const depth = parseInt(searchParams.get('depth') || '10', 10);
-    const showHidden = searchParams.get('showHidden') === 'true';
+    const showHidden = searchParams.get('showHidden') !== 'false';
 
     if (!basePath) {
       return NextResponse.json({ error: 'path parameter is required' }, { status: 400 });

package/src/app/api/files/search/route.ts

@@ -0,0 +1,123 @@
+import { NextRequest, NextResponse } from 'next/server';
+import fs from 'fs';
+import path from 'path';
+
+// Directories to exclude from search
+const EXCLUDED_DIRS = ['node_modules', '.git', '.next', 'dist', 'build', '.turbo', '__pycache__', '.cache'];
+const EXCLUDED_FILES = ['.DS_Store', 'Thumbs.db'];
+
+interface SearchResult {
+  path: string;
+  name: string;
+  type: 'file' | 'directory';
+  relativePath: string;
+}
+
+// GET /api/files/search - Search files by name
+export async function GET(request: NextRequest) {
+  try {
+    const searchParams = request.nextUrl.searchParams;
+    const basePath = searchParams.get('basePath');
+    const query = searchParams.get('query') || '';
+    const limit = parseInt(searchParams.get('limit') || '10', 10);
+
+    if (!basePath) {
+      return NextResponse.json({ error: 'basePath parameter is required' }, { status: 400 });
+    }
+
+    const resolvedPath = path.resolve(basePath);
+
+    if (!fs.existsSync(resolvedPath)) {
+      return NextResponse.json({ error: 'Path does not exist' }, { status: 404 });
+    }
+
+    if (!query) {
+      return NextResponse.json({ results: [] });
+    }
+
+    // Search files recursively
+    const results: SearchResult[] = [];
+    const queryLower = query.toLowerCase();
+
+    searchDirectory(resolvedPath, resolvedPath, queryLower, results, limit);
+
+    // Sort results: exact matches first, then by path length
+    results.sort((a, b) => {
+      const aExact = a.name.toLowerCase() === queryLower;
+      const bExact = b.name.toLowerCase() === queryLower;
+      if (aExact !== bExact) return aExact ? -1 : 1;
+
+      const aStarts = a.name.toLowerCase().startsWith(queryLower);
+      const bStarts = b.name.toLowerCase().startsWith(queryLower);
+      if (aStarts !== bStarts) return aStarts ? -1 : 1;
+
+      return a.relativePath.length - b.relativePath.length;
+    });
+
+    return NextResponse.json({ results: results.slice(0, limit) });
+  } catch (error) {
+    console.error('Error searching files:', error);
+    return NextResponse.json({ error: 'Failed to search files' }, { status: 500 });
+  }
+}
+
+function searchDirectory(
+  dirPath: string,
+  basePath: string,
+  query: string,
+  results: SearchResult[],
+  limit: number,
+  depth: number = 0
+): void {
+  // Limit depth to prevent infinite recursion
+  if (depth > 10 || results.length >= limit * 2) return;
+
+  try {
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (results.length >= limit * 2) break;
+
+      // Skip hidden files and excluded directories
+      if (entry.name.startsWith('.')) continue;
+      if (entry.isDirectory() && EXCLUDED_DIRS.includes(entry.name)) continue;
+      if (entry.isFile() && EXCLUDED_FILES.includes(entry.name)) continue;
+
+      const fullPath = path.join(dirPath, entry.name);
+      const relativePath = path.relative(basePath, fullPath);
+      const nameLower = entry.name.toLowerCase();
+
+      // Check if name matches query (fuzzy match)
+      if (nameLower.includes(query) || fuzzyMatch(nameLower, query)) {
+        results.push({
+          path: fullPath,
+          name: entry.name,
+          type: entry.isDirectory() ? 'directory' : 'file',
+          relativePath,
+        });
+      }
+
+      // Recurse into directories
+      if (entry.isDirectory()) {
+        searchDirectory(fullPath, basePath, query, results, limit, depth + 1);
+      }
+    }
+  } catch (error) {
+    // Ignore permission errors
+  }
+}
+
+// Simple fuzzy matching - checks if all chars of query appear in order
+function fuzzyMatch(text: string, query: string): boolean {
+  let textIndex = 0;
+  let queryIndex = 0;
+
+  while (textIndex < text.length && queryIndex < query.length) {
+    if (text[textIndex] === query[queryIndex]) {
+      queryIndex++;
+    }
+    textIndex++;
+  }
+
+  return queryIndex === query.length;
+}

package/src/app/api/git/commit/route.ts

@@ -11,7 +11,7 @@ const GIT_TIMEOUT = 10000; // Longer timeout for commit
 export async function POST(request: NextRequest) {
   try {
     const body = await request.json();
-    const { projectPath, message } = body;
+    const { projectPath, message, title, description } = body;
 
     if (!projectPath) {
       return NextResponse.json(
@@ -20,7 +20,11 @@ export async function POST(request: NextRequest) {
       );
     }
 
-    if (!message || typeof message !== 'string' || !message.trim()) {
+    // Support both old format (message) and new format (title + description)
+    const commitTitle = title || message;
+    const commitDescription = description || '';
+
+    if (!commitTitle || typeof commitTitle !== 'string' || !commitTitle.trim()) {
       return NextResponse.json(
         { error: 'Commit message is required' },
         { status: 400 }
@@ -35,10 +39,15 @@ export async function POST(request: NextRequest) {
       );
     }
 
+    // Build commit message: title + blank line + description (if provided)
+    const fullMessage = commitDescription.trim()
+      ? `${commitTitle.trim()}\n\n${commitDescription.trim()}`
+      : commitTitle.trim();
+
     // Create commit
     const { stdout } = await execFileAsync(
       'git',
-      ['commit', '-m', message.trim()],
+      ['commit', '-m', fullMessage],
       {
         cwd: resolvedPath,
         timeout: GIT_TIMEOUT,
@@ -52,7 +61,9 @@ export async function POST(request: NextRequest) {
     return NextResponse.json({
       success: true,
       hash,
-      message: message.trim(),
+      message: fullMessage,
+      title: commitTitle.trim(),
+      description: commitDescription.trim(),
     });
   } catch (error: unknown) {
     console.error('Error creating commit:', error);