clean up some horrible claude code

bcpeinhardt · bcpeinhardt · commit b2f6bb86492d · 2025-03-18T15:55:40.000-05:00
diff --git a/src/api.ts b/src/api.ts
@@ -276,32 +276,3 @@ export async function waitForBuild(
   writeEmitter.fire(`Workspace is now ${updatedWorkspace.latest_build.status}\r\n`)
   return updatedWorkspace
 }
-
-// 1. First, get a workspace by owner and name
-export async function getAITasksForWorkspace(
-  restClient: Api,
-  writeEmitter: vscode.EventEmitter<string>,
-  workspace: Workspace,
-): Promise<WorkspaceAgentTask[]> {
-  // We need to build up tasks
-  let awaiting_tasks: WorkspaceAgentTask[] = [];
-
-  // The workspace will include agents, and within each agent you can find tasks
-  // You can access the agents from the workspace resource
-  const resources = workspace.latest_build.resources;
-
-  // Go through each resource
-  for (const resource of resources) {
-    if (!resource.agents) {
-      continue
-    }
-
-    resource.agents.forEach((agent) => {
-      for (const task of agent.tasks) {
-        awaiting_tasks.push(task);
-      }
-    })
-  }
-
-  return awaiting_tasks;
-}
diff --git a/src/commands.ts b/src/commands.ts
@@ -2,7 +2,7 @@ import { Api } from "coder/site/src/api/api"
 import { getErrorMessage } from "coder/site/src/api/errors"
 import { User, Workspace, WorkspaceAgent } from "coder/site/src/api/typesGenerated"
 import * as vscode from "vscode"
-import { getAITasksForWorkspace, makeCoderSdk, needToken } from "./api"
+import { makeCoderSdk, needToken } from "./api"
 import { extractAgents } from "./api-helper"
 import { CertificateError } from "./error"
 import { Storage } from "./storage"
@@ -295,7 +295,6 @@ export class Commands {
     const doc = await vscode.workspace.openTextDocument(uri)
     await vscode.window.showTextDocument(doc)
   }
-  
 
   /**
    * Log out from the currently logged-in deployment.
@@ -409,12 +408,11 @@ export class Commands {
   }
 
   public async openAISession(): Promise<void> {
-    
     // Then launch an integrated terminal with screen session
     const terminal = vscode.window.createTerminal({
       name: "Claude Code Session",
     })
-    
+
     // Show the terminal and run the screen command
     terminal.show(true)
     terminal.sendText("screen -xRR claude-code")
diff --git a/src/workspacesProvider.ts b/src/workspacesProvider.ts
@@ -3,7 +3,7 @@ import { Workspace, WorkspaceAgent, WorkspaceAgentTask } from "coder/site/src/ap
 import { EventSource } from "eventsource"
 import * as path from "path"
 import * as vscode from "vscode"
-import { createStreamingFetchAdapter, getAITasksForWorkspace } from "./api"
+import { createStreamingFetchAdapter } from "./api"
 import {
   AgentMetadataEvent,
   AgentMetadataEventSchemaArray,
@@ -147,29 +147,28 @@ export class WorkspaceProvider implements vscode.TreeDataProvider<vscode.TreeIte
     })
 
     // Create tree items for each workspace
-    const workspaceTreeItems = await Promise.all(resp.workspaces.map(async (workspace) => {
-      const workspaceTreeItem = new WorkspaceTreeItem(
-        workspace, 
-        this.getWorkspacesQuery === WorkspaceQuery.All, 
-        showMetadata
-      )
-      
-      // Fetch AI tasks for the workspace
-      try {
-        // Create a dummy emitter for logs
-        const emitter = new vscode.EventEmitter<string>()
-        const aiTasks = await getAITasksForWorkspace(restClient, emitter, workspace)
-        workspaceTreeItem.aiTasks = aiTasks
-        this.storage.writeToCoderOutputChannel(aiTasks.length.toString())
-        console.log(aiTasks.length.toString())
-      } catch (error) {
-        // Log the error but continue - we don't want to fail the whole tree if AI tasks fail
-        this.storage.writeToCoderOutputChannel(`Failed to fetch AI tasks for workspace ${workspace.name}: ${errToStr(error, "unknown error")}`)
-        
-      }
-      
-      return workspaceTreeItem
-    }))
+    const workspaceTreeItems = await Promise.all(
+      resp.workspaces.map(async (workspace) => {
+        const workspaceTreeItem = new WorkspaceTreeItem(
+          workspace,
+          this.getWorkspacesQuery === WorkspaceQuery.All,
+          showMetadata,
+        )
+
+        // Fetch AI tasks for the workspace
+        try {
+          // Create a dummy emitter for logs
+          const emitter = new vscode.EventEmitter<string>()
+        } catch (error) {
+          // Log the error but continue - we don't want to fail the whole tree if AI tasks fail
+          this.storage.writeToCoderOutputChannel(
+            `Failed to fetch AI tasks for workspace ${workspace.name}: ${errToStr(error, "unknown error")}`,
+          )
+        }
+
+        return workspaceTreeItem
+      }),
+    )
 
     return workspaceTreeItems
   }
@@ -230,24 +229,25 @@ export class WorkspaceProvider implements vscode.TreeDataProvider<vscode.TreeIte
         const agentTreeItems = agents.map(
           (agent) => new AgentTreeItem(agent, element.workspaceOwner, element.workspaceName, element.watchMetadata),
         )
-        
-        // Add AI task items to the workspace children if there are any
-        const aiTaskItems = element.aiTasks.map(task => new AITaskTreeItem(task))
-        
-        // If there are AI tasks, add them at the beginning of the list
-        if (aiTaskItems.length == 0) {
-          return Promise.resolve(agentTreeItems)
-        }
-        
-        // Return AI task items first, then a separator, then agent items
-        return Promise.resolve([...aiTaskItems, ...agentTreeItems])
+
+        return Promise.resolve(agentTreeItems)
       } else if (element instanceof AgentTreeItem) {
         const watcher = this.agentWatchers[element.agent.id]
         if (watcher?.error) {
           return Promise.resolve([new ErrorTreeItem(watcher.error)])
         }
+        
+        const items: vscode.TreeItem[] = []
+        
+        // Add AI tasks first, if the agent has any associated tasks
+        const agentTasks = element.agent.tasks.map((task) => new AITaskTreeItem(task))
+        items.push(...agentTasks)
+        
+        // Add agent metadata
         const savedMetadata = watcher?.metadata || []
-        return Promise.resolve(savedMetadata.map((metadata) => new AgentMetadataTreeItem(metadata)))
+        items.push(...savedMetadata.map((metadata) => new AgentMetadataTreeItem(metadata)))
+        
+        return Promise.resolve(items)
       }
 
       return Promise.resolve([])
@@ -320,18 +320,16 @@ class AgentMetadataTreeItem extends vscode.TreeItem {
 
 class AITaskTreeItem extends vscode.TreeItem {
   constructor(public readonly task: WorkspaceAgentTask) {
-    super(task.summary, vscode.TreeItemCollapsibleState.None)
+    // Add a hand raise emoji (✋) to indicate tasks awaiting user input
+    super(task.icon, vscode.TreeItemCollapsibleState.None)
     this.description = task.summary
     this.contextValue = "coderAITask"
-    
-    // Add an icon using VSCode's built-in Codicons
-    this.iconPath = new vscode.ThemeIcon("sparkle")
-    
+
     // Add command to handle clicking on the task
     this.command = {
-      command: "coder.openAITask", 
+      command: "coder.openAITask",
       title: "Open AI Task",
-      arguments: [task]
+      arguments: [task],
     }
   }
 }
@@ -382,12 +380,16 @@ class AgentTreeItem extends OpenableTreeItem {
       agent.expanded_directory,
       "coderAgent",
     )
+
+    if (agent.task_waiting_for_user_input) {
+      this.label = "🙋 " + this.label;
+    }
   }
 }
 
 export class WorkspaceTreeItem extends OpenableTreeItem {
-  public aiTasks: WorkspaceAgentTask[] = []
-  
+  public aiTasks: {waiting: boolean, tasks: WorkspaceAgentTask[]}[] = []
+
   constructor(
     public readonly workspace: Workspace,
     public readonly showOwner: boolean,
