feat: implement task plans feature (#131)

This commit is contained in:
João Salavisa
2026-01-31 00:51:17 +00:00
committed by GitHub
parent ecf4ffedf8
commit 6eb24006f9
64 changed files with 3447 additions and 736 deletions
@@ -1,152 +0,0 @@
# File Reference Feature Implementation Plan
## Overview
Implement file referencing in chat input with `@filename` autocomplete. When a user types `@`, they should see autocomplete suggestions for files in the workspace. Selected files are passed as **path references** in the prompt - the agent can then read them from its workspace using its own tools.
**Key insight**: The agent runs in the workspace where files exist. We don't need to embed file contents - just tell the agent which files the user is referring to. The agent can read them itself.
## Requirements Analysis
1. **Frontend: `@filename` Autocomplete**
- Detect `@` prefix followed by path characters in chat input
- Debounce search requests (only search when user stops typing ~300ms)
- Call backend to search/filter files in the workspace
- Display matching files as autocomplete options
- Insert selected file reference into the chat input (keep as `@path/to/file.ts`)
2. **Backend: File Search Endpoint**
- New WebSocket action `workspace.files.search` for searching files
- Accept session_id (to route to correct agentctl) and query string
- Return matching file paths (fuzzy match)
3. **Prompt Format**
- Keep `@filepath` references in the message as-is
- Agent sees: "Look at @src/main.ts and fix the bug"
- Agent uses its tools to read the file when needed
## Architecture Flow
```
User types @main.ts → Frontend debounces 300ms → WS request workspace.files.search
↓
Backend routes to agentctl
↓
agentctl searches worktree (git ls-files)
↓
Returns matching files
↓
Frontend shows autocomplete
↓
User selects file → Insert @src/main.ts in input
↓
User submits → message.add with content "Look at @src/main.ts"
↓
Agent receives prompt, reads file using its tools
```
## Files to Modify/Create
### Backend (Go)
1. **`apps/backend/pkg/websocket/actions.go`**
- Add `ActionWorkspaceFilesSearch = "workspace.files.search"`
2. **`apps/backend/internal/agentctl/server/process/workspace_tracker.go`**
- Add `SearchFiles(query string, limit int) ([]string, error)` method
- Use fuzzy/substring matching on cached file list from `git ls-files`
3. **`apps/backend/internal/agentctl/server/api/workspace.go`**
- Add `handleFileSearch` HTTP endpoint: `GET /api/v1/workspace/search?q=&limit=`
4. **`apps/backend/internal/agentctl/client/client.go`**
- Add `SearchFiles(ctx, query, limit) ([]string, error)` method
5. **`apps/backend/internal/agent/handlers/workspace_file_handlers.go`**
- Add `wsSearchFiles` handler for `workspace.files.search`
6. **`apps/backend/internal/agentctl/types/streams/file.go`**
- Add `FileSearchRequest` and `FileSearchResponse` types
### Frontend (TypeScript)
1. **`apps/web/hooks/use-chat-completions.ts`**
- Add file path completion alongside prompt completions
- Accept sessionId prop for file search context
- Use async completion source with debouncing
2. **`apps/web/lib/ws/workspace-files.ts`**
- Add `searchWorkspaceFiles(client, sessionId, query, limit)` function
3. **`apps/web/lib/types/backend.ts`**
- Add `FileSearchResponse` type
4. **`apps/web/components/task/task-chat-input.tsx`**
- Pass sessionId to useChatCompletions hook
5. **`apps/web/components/task/task-chat-panel.tsx`**
- Pass sessionId down to TaskChatInput
## Implementation Approach
### Phase 1: Backend File Search
1. Add `FileSearchResponse` type in `types/streams/file.go`
2. Add `SearchFiles` method in `workspace_tracker.go` (fuzzy match on git ls-files)
3. Add `handleFileSearch` HTTP endpoint in `workspace.go`
4. Add `SearchFiles` client method in `client.go`
5. Add WS action constant in `actions.go`
6. Add `wsSearchFiles` handler in `workspace_file_handlers.go`
### Phase 2: Frontend Autocomplete
1. Add `searchWorkspaceFiles` function in `workspace-files.ts`
2. Add `FileSearchResponse` type in `backend.ts`
3. Extend `useChatCompletions` to accept sessionId and add file completions
4. Update `TaskChatInput` to receive and pass sessionId
5. Update `TaskChatPanel` to pass sessionId to input
## Fuzzy Search Algorithm
Simple substring matching with scoring:
- Exact filename match: highest score
- Filename contains query: high score
- Path contains query: medium score
- Sort by score, return top N results
```go
func (wt *WorkspaceTracker) SearchFiles(query string, limit int) []string {
query = strings.ToLower(query)
var matches []scoredMatch
for _, file := range wt.currentFiles.Files {
path := strings.ToLower(file.Path)
name := filepath.Base(path)
score := 0
if name == query { score = 100 }
else if strings.Contains(name, query) { score = 50 }
else if strings.Contains(path, query) { score = 25 }
if score > 0 {
matches = append(matches, scoredMatch{path: file.Path, score: score})
}
}
sort.Slice(matches, func(i, j int) bool { return matches[i].score > matches[j].score })
// Return top `limit` results
}
```
## Risks & Considerations
1. **Performance**: Large repos could have many files. Solutions:
- Limit search results (default 20)
- Cache file list on workspace tracker (already done via git ls-files)
- Client-side debouncing (300ms)
2. **Session Requirement**: File search requires an active session. Solutions:
- Only show file completions when sessionId is available
- Gracefully return empty results if no session
3. **Concurrent Searches**: User typing fast could queue many searches. Solutions:
- Debouncing handles this naturally
- Each new search supersedes previous results
+8 -17
View File
@@ -22,7 +22,6 @@ import (
"github.com/kandev/kandev/internal/agentctl/server/instance"
mcpserver "github.com/kandev/kandev/internal/agentctl/server/mcp"
"github.com/kandev/kandev/internal/agentctl/server/process"
"github.com/kandev/kandev/internal/agentctl/server/wsclient"
"github.com/kandev/kandev/internal/common/logger"
"github.com/kandev/kandev/pkg/agent"
"go.uber.org/zap"
@@ -84,24 +83,16 @@ func run(cfg *config.Config, log *logger.Logger) {
// Set the server factory to create API servers for each instance
instMgr.SetServerFactory(func(instCfg *config.InstanceConfig, procMgr *process.Manager, instLog *logger.Logger) http.Handler {
var mcpSrv *mcpserver.Server
// Create MCP backend client for bidirectional communication through agent stream
// MCP requests from agents are sent through the agent stream WebSocket to the backend
mcpBackendClient := mcpserver.NewChannelBackendClient()
// Create MCP server if backend WS URL is configured
if instCfg.BackendWsURL != "" {
wsClient := wsclient.New(instCfg.BackendWsURL, instLog)
if err := wsClient.Connect(context.Background()); err != nil {
instLog.Error("failed to connect MCP WS client to backend",
zap.Error(err),
zap.String("backend_ws_url", instCfg.BackendWsURL))
} else {
mcpSrv = mcpserver.New(wsClient, instCfg.SessionID, instLog)
instLog.Info("MCP server enabled",
zap.String("backend_ws_url", instCfg.BackendWsURL),
zap.String("session_id", instCfg.SessionID))
}
}
// Create MCP server using the channel-based backend client
mcpSrv := mcpserver.New(mcpBackendClient, instCfg.SessionID, instLog)
instLog.Info("MCP server enabled (channel-based)",
zap.String("session_id", instCfg.SessionID))
return api.NewServer(instCfg, procMgr, mcpSrv, instLog).Router()
return api.NewServer(instCfg, procMgr, mcpSrv, mcpBackendClient, instLog).Router()
})
// Create control server
+2 -6
View File
@@ -2,7 +2,6 @@ package main
import (
"context"
"fmt"
"os"
"go.uber.org/zap"
@@ -93,11 +92,8 @@ func provideLifecycleManager(
log,
)
// Set backend WS URL for MCP tunneling
// agentctl instances will connect back to this URL to forward MCP tool calls
backendWsURL := fmt.Sprintf("ws://%s:%d/ws", cfg.Server.Host, cfg.Server.Port)
lifecycleMgr.SetBackendWsURL(backendWsURL)
log.Info("Backend WS URL configured for MCP tunneling", zap.String("url", backendWsURL))
// MCP handler is set later in main.go after MCP handlers are registered
// via lifecycleMgr.SetMCPHandler(gateway.Dispatcher)
if err := lifecycleMgr.Start(ctx); err != nil {
return nil, nil, err
+9 -2
View File
@@ -51,6 +51,7 @@ import (
// Task Service packages
taskcontroller "github.com/kandev/kandev/internal/task/controller"
taskhandlers "github.com/kandev/kandev/internal/task/handlers"
taskservice "github.com/kandev/kandev/internal/task/service"
usercontroller "github.com/kandev/kandev/internal/user/controller"
userhandlers "github.com/kandev/kandev/internal/user/handlers"
@@ -512,7 +513,8 @@ func main() {
// Task Service handlers (HTTP + WebSocket)
taskhandlers.RegisterWorkspaceRoutes(router, gateway.Dispatcher, workspaceController, log)
taskhandlers.RegisterBoardRoutes(router, gateway.Dispatcher, boardController, log)
taskhandlers.RegisterTaskRoutes(router, gateway.Dispatcher, taskController, orchestratorSvc, log)
planService := taskservice.NewPlanService(taskRepo, eventBus, log)
taskhandlers.RegisterTaskRoutes(router, gateway.Dispatcher, taskController, orchestratorSvc, taskRepo, planService, log)
taskhandlers.RegisterRepositoryRoutes(router, gateway.Dispatcher, repositoryController, log)
taskhandlers.RegisterExecutorRoutes(router, gateway.Dispatcher, executorController, log)
taskhandlers.RegisterEnvironmentRoutes(router, gateway.Dispatcher, environmentController, log)
@@ -558,12 +560,17 @@ func main() {
workflowCtrl,
clarificationStore,
msgCreator,
taskRepo,
planService,
log,
)
mcpHandlers.RegisterHandlers(gateway.Dispatcher)
log.Debug("Registered MCP handlers (WebSocket)")
// Set MCP handler for lifecycle manager to dispatch MCP requests from agents
// MCP requests flow: agent -> agentctl -> agent stream (WS) -> backend -> dispatcher
lifecycleMgr.SetMCPHandler(gateway.Dispatcher)
log.Debug("MCP handler configured for agent lifecycle manager")
debughandlers.RegisterRoutes(router, log)
log.Debug("Registered Debug handlers (HTTP)")
@@ -30,7 +30,6 @@ type ContainerConfig struct {
InstanceID string
MainRepoGitDir string // Path to main repo's .git directory (for worktrees)
McpServers []McpServerConfig
BackendWsURL string // WebSocket URL to Kandev backend for MCP tunneling
}
// ContainerManager handles Docker container lifecycle operations
@@ -115,7 +114,6 @@ func (cm *ContainerManager) LaunchContainer(ctx context.Context, config Containe
Env: config.Credentials,
AutoStart: false,
McpServers: mcpServers,
BackendWsURL: config.BackendWsURL,
SessionID: config.SessionID,
}
@@ -72,9 +72,9 @@ type Manager struct {
// Workspace info provider for on-demand instance creation
workspaceInfoProvider WorkspaceInfoProvider
// backendWsURL is the WebSocket URL to the Kandev backend for MCP tunneling
// This is passed to agentctl instances so they can forward MCP tool calls
backendWsURL string
// mcpHandler is the MCP request dispatcher for handling MCP requests
// from agentctl instances through the agent stream.
mcpHandler agentctl.MCPHandler
// Background cleanup
cleanupInterval time.Duration
@@ -140,6 +140,7 @@ func NewManager(
}
// Initialize stream manager with callbacks that delegate to manager methods
// mcpHandler will be set later via SetMCPHandler
mgr.streamManager = NewStreamManager(log, StreamCallbacks{
OnAgentEvent: mgr.handleAgentEvent,
OnGitStatus: mgr.handleGitStatusUpdate,
@@ -150,7 +151,7 @@ func NewManager(
OnShellExit: mgr.handleShellExit,
OnProcessOutput: mgr.handleProcessOutput,
OnProcessStatus: mgr.handleProcessStatus,
})
}, nil)
// Set session manager dependencies for full orchestration
sessionManager.SetDependencies(eventPublisher, mgr.streamManager, executionStore, historyManager)
@@ -174,13 +175,18 @@ func (m *Manager) SetWorktreeManager(worktreeMgr *worktree.Manager) {
m.worktreeMgr = worktreeMgr
}
// SetBackendWsURL sets the WebSocket URL to the Kandev backend for MCP tunneling.
// SetMCPHandler sets the MCP request handler for dispatching MCP tool calls.
//
// This URL is passed to agentctl instances so they can establish a WebSocket connection
// back to the backend and forward MCP tool calls through the tunnel.
// Format: ws://host:port/ws (e.g., ws://localhost:8080/ws)
func (m *Manager) SetBackendWsURL(url string) {
m.backendWsURL = url
// MCP requests from agents flow through the agent stream (WebSocket) to the backend,
// where they are dispatched to this handler. This enables agents to use MCP tools
// like listing workspaces, boards, tasks, and asking user questions.
//
// This must be called before agents start making MCP calls. Typically set during
// initialization after the MCP handlers are created.
func (m *Manager) SetMCPHandler(handler agentctl.MCPHandler) {
m.mcpHandler = handler
// Update the stream manager with the handler
m.streamManager.mcpHandler = handler
}
// SetWorkspaceInfoProvider sets the provider for workspace information.
@@ -455,7 +461,6 @@ func (m *Manager) createExecution(ctx context.Context, taskID string, info *Work
WorkspacePath: info.WorkspacePath,
Protocol: string(agentConfig.Protocol),
AgentConfig: agentConfig,
BackendWsURL: m.backendWsURL,
}
runtimeInstance, err := rt.CreateInstance(ctx, req)
@@ -783,7 +788,6 @@ func (m *Manager) Launch(ctx context.Context, req *LaunchRequest) (*AgentExecuti
Metadata: metadata,
AgentConfig: agentConfig,
McpServers: mcpServers,
BackendWsURL: m.backendWsURL,
}
runtimeInstance, err := rt.CreateInstance(ctx, runtimeReq)
@@ -67,7 +67,6 @@ type RuntimeCreateRequest struct {
Metadata map[string]interface{}
McpServers []McpServerConfig
AgentConfig *registry.AgentTypeConfig // Agent type info needed by runtimes
BackendWsURL string // WebSocket URL to Kandev backend for MCP tunneling
}
// RuntimeInstance represents an agentctl instance created by a runtime.
@@ -70,7 +70,6 @@ func (r *DockerRuntime) CreateInstance(ctx context.Context, req *RuntimeCreateRe
MainRepoGitDir: mainRepoGitDir,
Credentials: req.Env, // Env contains credentials from the caller
McpServers: req.McpServers,
BackendWsURL: req.BackendWsURL,
}
// Use ContainerManager to launch container
@@ -108,7 +108,6 @@ func (r *StandaloneRuntime) CreateInstance(ctx context.Context, req *RuntimeCrea
Env: env,
AutoStart: false,
McpServers: mcpServers,
BackendWsURL: req.BackendWsURL,
SessionID: req.SessionID,
}
@@ -183,12 +183,12 @@ func (sm *SessionManager) getResumeContextPrompt(agentConfig *registry.AgentType
}
// injectSessionContext prepends session context information to the prompt.
// This allows the agent to know which session ID to use when calling MCP tools like ask_user_question.
func (sm *SessionManager) injectSessionContext(sessionID, prompt string) string {
if sessionID == "" {
// This allows the agent to know which session ID and task ID to use when calling MCP tools.
func (sm *SessionManager) injectSessionContext(taskID, sessionID, prompt string) string {
if sessionID == "" && taskID == "" {
return prompt
}
return fmt.Sprintf("<session_context>\nKandev Session ID: %s\nUse this session ID when calling Kandev MCP tools that require a session_id parameter.\n</session_context>\n\n%s", sessionID, prompt)
return fmt.Sprintf("<session_context>\nKandev Task ID: %s\nKandev Session ID: %s\nUse these IDs when calling Kandev MCP tools that require task_id or session_id parameters.\n</session_context>\n\n%s", taskID, sessionID, prompt)
}
// loadSession loads an existing session via ACP session/load
@@ -318,8 +318,8 @@ func (sm *SessionManager) InitializeAndPrompt(
// For resumed sessions (fork_session pattern): If we have session history but no new task description,
// we still need to send a resume context prompt so the agent knows about the prior conversation.
if taskDescription != "" {
// Inject session ID context so the agent knows which session to use for MCP tools
promptWithSessionContext := sm.injectSessionContext(execution.SessionID, taskDescription)
// Inject task and session ID context so the agent knows which IDs to use for MCP tools
promptWithSessionContext := sm.injectSessionContext(execution.TaskID, execution.SessionID, taskDescription)
// Check if we need to inject resume context (fork_session pattern for ACP agents)
effectivePrompt := sm.getResumeContextPrompt(agentConfig, execution.SessionID, promptWithSessionContext)
@@ -25,15 +25,17 @@ type StreamCallbacks struct {
// StreamManager manages WebSocket streams to agent executions
type StreamManager struct {
logger *logger.Logger
callbacks StreamCallbacks
logger *logger.Logger
callbacks StreamCallbacks
mcpHandler agentctl.MCPHandler
}
// NewStreamManager creates a new StreamManager
func NewStreamManager(log *logger.Logger, callbacks StreamCallbacks) *StreamManager {
func NewStreamManager(log *logger.Logger, callbacks StreamCallbacks, mcpHandler agentctl.MCPHandler) *StreamManager {
return &StreamManager{
logger: log.WithFields(zap.String("component", "stream-manager")),
callbacks: callbacks,
logger: log.WithFields(zap.String("component", "stream-manager")),
callbacks: callbacks,
mcpHandler: mcpHandler,
}
}
@@ -94,7 +96,7 @@ func (sm *StreamManager) connectUpdatesStream(execution *AgentExecution, ready c
if sm.callbacks.OnAgentEvent != nil {
sm.callbacks.OnAgentEvent(execution, event)
}
})
}, sm.mcpHandler)
// Signal that the stream connection attempt is complete (success or failure)
// StreamUpdates returns immediately after establishing the WebSocket connection
+45 -1
View File
@@ -6,12 +6,14 @@ import (
"encoding/json"
"fmt"
"net/http"
"sync"
"github.com/coder/acp-go-sdk"
"github.com/gorilla/websocket"
"github.com/kandev/kandev/internal/agentctl/types"
"github.com/kandev/kandev/internal/agentctl/types/streams"
"github.com/kandev/kandev/internal/common/constants"
ws "github.com/kandev/kandev/pkg/websocket"
"go.uber.org/zap"
)
@@ -252,9 +254,16 @@ func (c *Client) Prompt(ctx context.Context, text string) (*PromptResponse, erro
// Note: AgentEvent, PermissionNotification, PermissionOption, and
// PermissionRespondRequest are re-exported from streams package at the top of this file.
// MCPHandler is the interface for handling MCP requests from agentctl.
type MCPHandler interface {
// Dispatch handles an MCP request and returns a response.
Dispatch(ctx context.Context, msg *ws.Message) (*ws.Message, error)
}
// StreamUpdates opens a WebSocket connection for streaming agent events.
// Events include message chunks, reasoning, tool calls, plan updates, and completion/error.
func (c *Client) StreamUpdates(ctx context.Context, handler func(AgentEvent)) error {
// If mcpHandler is provided, MCP requests from agentctl will be dispatched to it and responses sent back.
func (c *Client) StreamUpdates(ctx context.Context, handler func(AgentEvent), mcpHandler MCPHandler) error {
wsURL := "ws" + c.baseURL[4:] + "/api/v1/agent/stream"
conn, _, err := websocket.DefaultDialer.DialContext(ctx, wsURL, nil)
@@ -268,6 +277,14 @@ func (c *Client) StreamUpdates(ctx context.Context, handler func(AgentEvent)) er
c.logger.Info("connected to updates stream", zap.String("url", wsURL))
// Use mutex for writing responses
var writeMu sync.Mutex
writeMessage := func(data []byte) error {
writeMu.Lock()
defer writeMu.Unlock()
return conn.WriteMessage(websocket.TextMessage, data)
}
// Read messages in a goroutine
go func() {
defer func() {
@@ -290,6 +307,33 @@ func (c *Client) StreamUpdates(ctx context.Context, handler func(AgentEvent)) er
return
}
// Try to parse as ws.Message to check if it's an MCP request
var wsMsg ws.Message
if err := json.Unmarshal(message, &wsMsg); err == nil && wsMsg.Type == ws.MessageTypeRequest {
// This is an MCP request - dispatch it
if mcpHandler != nil {
go func(msg ws.Message) {
resp, err := mcpHandler.Dispatch(ctx, &msg)
if err != nil {
c.logger.Error("MCP dispatch error", zap.Error(err))
resp, _ = ws.NewError(msg.ID, msg.Action, ws.ErrorCodeInternalError, err.Error(), nil)
}
if resp != nil {
data, err := json.Marshal(resp)
if err != nil {
c.logger.Error("failed to marshal MCP response", zap.Error(err))
return
}
if err := writeMessage(data); err != nil {
c.logger.Debug("failed to write MCP response", zap.Error(err))
}
}
}(wsMsg)
}
continue
}
// Not an MCP request, parse as agent event
var event AgentEvent
if err := json.Unmarshal(message, &event); err != nil {
c.logger.Warn("failed to parse agent event", zap.Error(err))
@@ -43,8 +43,7 @@ type CreateInstanceRequest struct {
Env map[string]string `json:"env,omitempty"`
AutoStart bool `json:"auto_start,omitempty"`
McpServers []McpServerConfig `json:"mcp_servers,omitempty"`
BackendWsURL string `json:"backend_ws_url,omitempty"` // WebSocket URL to Kandev backend for MCP tunneling
SessionID string `json:"session_id,omitempty"` // Task session ID for MCP tool calls
SessionID string `json:"session_id,omitempty"` // Task session ID for MCP tool calls
}
// CreateInstanceResponse contains the result of creating a new agent instance.
@@ -76,20 +76,26 @@ type AgentInfo struct {
// Lifecycle:
// 1. Create adapter with New*Adapter(cfg, logger)
// 2. Call PrepareEnvironment() before starting the agent process
// 3. Start the agent process and obtain stdin/stdout pipes
// 4. Call Connect(stdin, stdout) to wire up communication
// 5. Call Initialize() to establish protocol handshake
// 6. Use NewSession/LoadSession/Prompt/Cancel for agent interactions
// 7. Call Close() when done
// 3. Call PrepareCommandArgs() to get extra command-line args
// 4. Start the agent process and obtain stdin/stdout pipes
// 5. Call Connect(stdin, stdout) to wire up communication
// 6. Call Initialize() to establish protocol handshake
// 7. Use NewSession/LoadSession/Prompt/Cancel for agent interactions
// 8. Call Close() when done
type AgentAdapter interface {
// PrepareEnvironment performs protocol-specific setup before the agent process starts.
// For Codex, this writes MCP servers to ~/.codex/config.toml.
// For ACP, this is a no-op (MCP servers are passed through the protocol).
// For OpenCode, this returns environment variables for server authentication.
// Must be called before the agent subprocess is started.
// Returns a map of environment variables to add to the subprocess environment.
PrepareEnvironment() (map[string]string, error)
// PrepareCommandArgs returns extra command-line arguments for the agent process.
// For Codex, this returns -c flags for MCP servers and sandbox config.
// For other protocols, this returns nil (no extra args needed).
// Must be called after PrepareEnvironment and before starting the subprocess.
PrepareCommandArgs() []string
// Connect wires up the stdin/stdout pipes from the running agent subprocess.
// Must be called after the subprocess is started and before Initialize.
Connect(stdin io.Writer, stdout io.Reader) error
@@ -96,6 +96,12 @@ func (a *Adapter) PrepareEnvironment() (map[string]string, error) {
return nil, nil
}
// PrepareCommandArgs returns extra command-line arguments for the agent process.
// For ACP, no extra args are needed - MCP servers are passed through the protocol.
func (a *Adapter) PrepareCommandArgs() []string {
return nil
}
// Connect wires up the stdin/stdout pipes from the running agent subprocess.
func (a *Adapter) Connect(stdin io.Writer, stdout io.Reader) error {
a.mu.Lock()
@@ -7,8 +7,6 @@ import (
"encoding/json"
"fmt"
"io"
"os"
"path/filepath"
"strings"
"sync"
@@ -17,7 +15,6 @@ import (
"github.com/kandev/kandev/internal/agentctl/types/streams"
"github.com/kandev/kandev/internal/common/logger"
"github.com/kandev/kandev/pkg/codex"
"github.com/pelletier/go-toml/v2"
"go.uber.org/zap"
)
@@ -114,21 +111,58 @@ func NewAdapter(cfg *shared.Config, log *logger.Logger) *Adapter {
}
}
// PrepareEnvironment writes sandbox settings and MCP servers to the Codex config file.
// Codex reads configuration from ~/.codex/config.toml at startup time.
// This sets sandbox_mode to workspace-write to enable file editing.
// PrepareEnvironment is a no-op for Codex. MCP servers and sandbox settings
// are now passed via command-line -c flags through PrepareCommandArgs().
func (a *Adapter) PrepareEnvironment() (map[string]string, error) {
a.logger.Info("PrepareEnvironment called",
zap.Int("mcp_server_count", len(a.cfg.McpServers)))
for i, srv := range a.cfg.McpServers {
a.logger.Info("MCP server config",
zap.Int("index", i),
zap.String("name", srv.Name),
zap.String("url", srv.URL),
zap.String("type", srv.Type),
zap.String("command", srv.Command))
a.logger.Info("PrepareEnvironment called (no-op for Codex)")
return nil, nil
}
// PrepareCommandArgs returns extra command-line arguments for the Codex process.
// This includes -c flags for MCP servers and sandbox configuration.
// Codex uses -c key=value flags to override config at runtime.
func (a *Adapter) PrepareCommandArgs() []string {
var args []string
// Set sandbox_mode to workspace-write to enable file editing
args = append(args, "-c", "sandbox_mode=\"workspace-write\"")
// Enable network access in sandbox
args = append(args, "-c", "sandbox_workspace_write.network_access=true")
// Add MCP servers as -c flags
for _, server := range a.cfg.McpServers {
safeName := sanitizeCodexServerName(server.Name)
if server.Type == "sse" || server.Type == "http" {
// HTTP/SSE transport - use url field
// Convert SSE URLs (/sse) to streamable HTTP URLs (/mcp) for Codex compatibility
url := server.URL
if url != "" {
url = convertSSEToStreamableHTTP(url)
args = append(args, "-c", fmt.Sprintf("mcp_servers.%s.url=\"%s\"", safeName, url))
}
} else if server.Command != "" {
// STDIO transport - use command field
args = append(args, "-c", fmt.Sprintf("mcp_servers.%s.command=\"%s\"", safeName, server.Command))
// Add args if present
if len(server.Args) > 0 {
// TOML array format: ["arg1", "arg2"]
quotedArgs := make([]string, len(server.Args))
for i, arg := range server.Args {
quotedArgs[i] = fmt.Sprintf("\"%s\"", arg)
}
argsStr := "[" + strings.Join(quotedArgs, ", ") + "]"
args = append(args, "-c", fmt.Sprintf("mcp_servers.%s.args=%s", safeName, argsStr))
}
}
}
return nil, WriteCodexMcpConfig(a.cfg.McpServers, "", a.logger)
a.logger.Info("PrepareCommandArgs",
zap.Int("mcp_server_count", len(a.cfg.McpServers)),
zap.Strings("extra_args", args))
return args
}
// Connect wires up the stdin/stdout pipes from the running agent subprocess.
@@ -145,120 +179,7 @@ func (a *Adapter) Connect(stdin io.Writer, stdout io.Reader) error {
return nil
}
// WriteCodexMcpConfig writes MCP server configuration and sandbox settings to Codex's config.toml.
// It merges with existing config, preserving other settings and existing MCP servers.
// Codex reads configuration from ~/.codex/config.toml at startup time, not through the protocol.
// This function should be called before starting the Codex process.
// If homeDir is empty, it uses os.UserHomeDir().
func WriteCodexMcpConfig(mcpServers []shared.McpServerConfig, homeDir string, log *logger.Logger) error {
// Determine config directory
if homeDir == "" {
var err error
homeDir, err = os.UserHomeDir()
if err != nil {
return fmt.Errorf("failed to get user home directory: %w", err)
}
}
configDir := filepath.Join(homeDir, ".codex")
configPath := filepath.Join(configDir, "config.toml")
// Create config directory if it doesn't exist
if err := os.MkdirAll(configDir, 0o755); err != nil {
return fmt.Errorf("failed to create codex config directory: %w", err)
}
// Read existing config if it exists
existingData, err := os.ReadFile(configPath)
if err != nil && !os.IsNotExist(err) {
return fmt.Errorf("failed to read existing codex config: %w", err)
}
// Parse existing config into a generic map to preserve all fields
var rawConfig map[string]any
if len(existingData) > 0 {
if err := toml.Unmarshal(existingData, &rawConfig); err != nil {
if log != nil {
log.Warn("failed to parse existing codex config, will create new",
zap.String("path", configPath),
zap.Error(err))
}
rawConfig = make(map[string]any)
}
} else {
rawConfig = make(map[string]any)
}
// CRITICAL: Set sandbox_mode to workspace-write to enable file editing.
// This MUST be set in config.toml as it takes precedence over protocol settings.
// Without this, Codex defaults to read-only mode and cannot edit files.
rawConfig["sandbox_mode"] = "workspace-write"
// Configure sandbox workspace-write settings
sandboxConfig, ok := rawConfig["sandbox_workspace_write"].(map[string]any)
if !ok {
sandboxConfig = make(map[string]any)
}
sandboxConfig["network_access"] = true
rawConfig["sandbox_workspace_write"] = sandboxConfig
// Get or create mcp_servers section
mcpServersSection, ok := rawConfig["mcp_servers"].(map[string]any)
if !ok {
mcpServersSection = make(map[string]any)
}
// Add/update our MCP servers
for _, server := range mcpServers {
safeName := sanitizeCodexServerName(server.Name)
serverConfig := make(map[string]any)
if server.Type == "sse" || server.Type == "http" {
// HTTP/SSE transport - use url field
// Codex doesn't support SSE transport - it uses streamable HTTP which requires POST requests.
// Convert SSE URLs (/sse) to streamable HTTP URLs (/mcp) for Codex compatibility.
url := server.URL
if url != "" {
url = convertSSEToStreamableHTTP(url)
serverConfig["url"] = url
}
} else {
// STDIO transport - use command and args
if server.Command != "" {
serverConfig["command"] = server.Command
}
if len(server.Args) > 0 {
serverConfig["args"] = server.Args
}
}
mcpServersSection[safeName] = serverConfig
}
// Update the mcp_servers section in the config
if len(mcpServersSection) > 0 {
rawConfig["mcp_servers"] = mcpServersSection
}
// Marshal back to TOML
output, err := toml.Marshal(rawConfig)
if err != nil {
return fmt.Errorf("failed to marshal codex config: %w", err)
}
// Write config file
if err := os.WriteFile(configPath, output, 0o644); err != nil {
return fmt.Errorf("failed to write codex config: %w", err)
}
if log != nil {
log.Info("wrote Codex config",
zap.String("path", configPath),
zap.String("sandbox_mode", "workspace-write"),
zap.Int("mcp_server_count", len(mcpServers)))
}
return nil
}
// sanitizeCodexServerName converts a server name to a valid TOML table name.
// Replaces spaces and special characters with underscores.
@@ -180,6 +180,12 @@ func (a *Adapter) PrepareEnvironment() (map[string]string, error) {
return env, nil
}
// PrepareCommandArgs returns extra command-line arguments for the agent process.
// For OpenCode, no extra args are needed - MCP is configured via config file.
func (a *Adapter) PrepareCommandArgs() []string {
return nil
}
// Connect wires up the stdout pipe from the running agent subprocess.
// For OpenCode, we only need stdout to parse the server URL.
func (a *Adapter) Connect(stdin io.Writer, stdout io.Reader) error {
@@ -131,6 +131,12 @@ func (a *Adapter) PrepareEnvironment() (map[string]string, error) {
return nil, nil
}
// PrepareCommandArgs returns extra command-line arguments for the agent process.
// For stream-json, no extra args are needed - MCP is configured via config files.
func (a *Adapter) PrepareCommandArgs() []string {
return nil
}
// Connect wires up the stdin/stdout pipes from the running agent subprocess.
func (a *Adapter) Connect(stdin io.Writer, stdout io.Reader) error {
a.mu.Lock()
@@ -5,12 +5,14 @@ import (
"encoding/json"
"fmt"
"net/http"
"sync"
"time"
"github.com/gin-gonic/gin"
"github.com/gorilla/websocket"
"github.com/kandev/kandev/internal/agentctl/types"
"github.com/kandev/kandev/internal/common/constants"
ws "github.com/kandev/kandev/pkg/websocket"
"go.uber.org/zap"
)
@@ -274,35 +276,118 @@ func (s *Server) handleAgentPrompt(c *gin.Context) {
}
// handleAgentStreamWS streams agent session notifications via WebSocket.
// This is a bidirectional stream:
// - agentctl -> backend: agent events, MCP requests
// - backend -> agentctl: MCP responses
func (s *Server) handleAgentStreamWS(c *gin.Context) {
conn, err := s.upgrader.Upgrade(c.Writer, c.Request, nil)
if err != nil {
s.logger.Error("WebSocket upgrade failed", zap.Error(err))
return
}
defer func() {
if err := conn.Close(); err != nil {
s.logger.Debug("failed to close ACP stream websocket", zap.Error(err))
}
}()
s.logger.Info("agent stream WebSocket connected")
ctx, cancel := context.WithCancel(c.Request.Context())
defer cancel()
// Use a mutex for writing to the WebSocket
var writeMu sync.Mutex
writeMessage := func(data []byte) error {
writeMu.Lock()
defer writeMu.Unlock()
return conn.WriteMessage(websocket.TextMessage, data)
}
// Get the session updates channel
updatesCh := s.procMgr.GetUpdates()
// Stream session notifications to WebSocket
for notification := range updatesCh {
data, err := json.Marshal(notification)
if err != nil {
s.logger.Error("failed to marshal notification", zap.Error(err))
continue
}
if err := conn.WriteMessage(websocket.TextMessage, data); err != nil {
return
}
// Get MCP request channel (if MCP is enabled)
var mcpRequestCh <-chan *ws.Message
if s.mcpBackendClient != nil {
mcpRequestCh = s.mcpBackendClient.GetRequestChannel()
}
// WaitGroup for cleanup
var wg sync.WaitGroup
// Read goroutine: reads MCP responses from the backend
wg.Add(1)
go func() {
defer wg.Done()
defer cancel()
for {
_, message, err := conn.ReadMessage()
if err != nil {
if websocket.IsCloseError(err, websocket.CloseNormalClosure, websocket.CloseGoingAway) {
s.logger.Info("agent stream closed normally")
} else {
s.logger.Debug("agent stream read error", zap.Error(err))
}
return
}
// Parse as WebSocket message (MCP response)
var msg ws.Message
if err := json.Unmarshal(message, &msg); err != nil {
s.logger.Warn("failed to parse message", zap.Error(err))
continue
}
// Forward MCP response to the backend client
if s.mcpBackendClient != nil && (msg.Type == ws.MessageTypeResponse || msg.Type == ws.MessageTypeError) {
s.mcpBackendClient.HandleResponse(&msg)
}
}
}()
// Write goroutine: sends agent events and MCP requests to the backend
wg.Add(1)
go func() {
defer wg.Done()
defer func() {
if err := conn.Close(); err != nil {
s.logger.Debug("failed to close agent stream websocket", zap.Error(err))
}
}()
for {
select {
case <-ctx.Done():
return
case notification, ok := <-updatesCh:
if !ok {
return
}
data, err := json.Marshal(notification)
if err != nil {
s.logger.Error("failed to marshal notification", zap.Error(err))
continue
}
if err := writeMessage(data); err != nil {
s.logger.Debug("failed to write notification", zap.Error(err))
return
}
case mcpReq, ok := <-mcpRequestCh:
if !ok {
// MCP channel closed, continue without MCP
mcpRequestCh = nil
continue
}
data, err := json.Marshal(mcpReq)
if err != nil {
s.logger.Error("failed to marshal MCP request", zap.Error(err))
continue
}
if err := writeMessage(data); err != nil {
s.logger.Debug("failed to write MCP request", zap.Error(err))
return
}
}
}
}()
wg.Wait()
}
// PermissionRespondRequest is a request to respond to a permission request
@@ -17,26 +17,29 @@ import (
// Server is the HTTP API server for a single agent instance.
type Server struct {
cfg *config.InstanceConfig
procMgr *process.Manager
mcpServer *mcp.Server
logger *logger.Logger
router *gin.Engine
cfg *config.InstanceConfig
procMgr *process.Manager
mcpServer *mcp.Server
mcpBackendClient *mcp.ChannelBackendClient
logger *logger.Logger
router *gin.Engine
upgrader websocket.Upgrader
}
// NewServer creates a new API server for an agent instance.
// If mcpServer is provided, MCP routes will be registered.
func NewServer(cfg *config.InstanceConfig, procMgr *process.Manager, mcpServer *mcp.Server, log *logger.Logger) *Server {
// If mcpBackendClient is provided, the agent stream becomes bidirectional for MCP.
func NewServer(cfg *config.InstanceConfig, procMgr *process.Manager, mcpServer *mcp.Server, mcpBackendClient *mcp.ChannelBackendClient, log *logger.Logger) *Server {
gin.SetMode(gin.ReleaseMode)
s := &Server{
cfg: cfg,
procMgr: procMgr,
mcpServer: mcpServer,
logger: log.WithFields(zap.String("component", "api-server")),
router: gin.New(),
cfg: cfg,
procMgr: procMgr,
mcpServer: mcpServer,
mcpBackendClient: mcpBackendClient,
logger: log.WithFields(zap.String("component", "api-server")),
router: gin.New(),
upgrader: websocket.Upgrader{
CheckOrigin: func(r *http.Request) bool {
return true // Allow all origins for container-local communication
@@ -137,10 +137,6 @@ type InstanceConfig struct {
// ProcessBufferMaxBytes caps per-process output buffer size
ProcessBufferMaxBytes int64
// BackendWsURL is the WebSocket URL to connect back to the Kandev backend
// for MCP tool requests (e.g., ws://localhost:8080/ws)
BackendWsURL string
// SessionID is the session ID for this agent instance (used in MCP tool calls)
SessionID string
}
@@ -210,14 +206,19 @@ func (c *Config) NewInstanceConfig(port int, overrides *InstanceOverrides) *Inst
if len(overrides.McpServers) > 0 {
cfg.McpServers = overrides.McpServers
}
if overrides.BackendWsURL != "" {
cfg.BackendWsURL = overrides.BackendWsURL
}
if overrides.SessionID != "" {
cfg.SessionID = overrides.SessionID
}
}
// Inject local kandev MCP server for MCP tunneling through the agent stream
// This ensures the kandev MCP server is available for protocols that read MCP config
// at startup time (e.g., Codex via -c flags). The MCP server uses the agent stream
// WebSocket connection (bidirectional) to forward tool calls to the backend.
if port > 0 {
cfg.McpServers = injectKandevMcpServer(cfg.McpServers, port)
}
// Parse agent command into args
cfg.AgentArgs = ParseCommand(cfg.AgentCommand)
@@ -239,7 +240,6 @@ type InstanceOverrides struct {
ApprovalPolicy string
AgentType string
McpServers []McpServerConfig
BackendWsURL string
SessionID string
}
@@ -307,3 +307,24 @@ func getEnvBool(key string, defaultValue bool) bool {
}
return defaultValue
}
// injectKandevMcpServer prepends the local kandev MCP server to the list of MCP servers.
// This replaces any existing kandev server to avoid duplicates.
// The kandev MCP server provides tools like ask_user_question to the agent.
func injectKandevMcpServer(servers []McpServerConfig, port int) []McpServerConfig {
localKandevMcp := McpServerConfig{
Name: "kandev",
Type: "sse",
URL: "http://localhost:" + strconv.Itoa(port) + "/sse",
}
// Filter out any existing kandev server and prepend the local one
result := make([]McpServerConfig, 0, len(servers)+1)
result = append(result, localKandevMcp)
for _, srv := range servers {
if srv.Name != "kandev" {
result = append(result, srv)
}
}
return result
}
@@ -81,10 +81,6 @@ type CreateRequest struct {
// McpServers is a list of MCP servers to configure for the agent.
McpServers []McpServerConfig `json:"mcp_servers,omitempty"`
// BackendWsURL is the WebSocket URL to the Kandev backend for MCP tunneling.
// If set, the MCP server will be enabled and forward tool calls to the backend.
BackendWsURL string `json:"backend_ws_url,omitempty"`
// SessionID is the task session ID for MCP tool calls (used by ask_user_question).
SessionID string `json:"session_id,omitempty"`
}
@@ -133,7 +133,6 @@ func (m *Manager) CreateInstance(ctx context.Context, req *CreateRequest) (*Crea
Env: config.CollectAgentEnv(req.Env),
AgentType: req.AgentType,
McpServers: mcpServers,
BackendWsURL: req.BackendWsURL,
SessionID: req.SessionID,
}
@@ -0,0 +1,126 @@
package mcp
import (
"context"
"encoding/json"
"fmt"
"sync"
"time"
"github.com/google/uuid"
ws "github.com/kandev/kandev/pkg/websocket"
)
// MCPRequest represents an MCP request to be sent to the backend.
type MCPRequest struct {
ID string `json:"id"`
Action string `json:"action"`
Payload json.RawMessage `json:"payload"`
}
// MCPResponse represents an MCP response from the backend.
type MCPResponse struct {
ID string `json:"id"`
Type string `json:"type"` // "response" or "error"
Payload json.RawMessage `json:"payload"`
}
// ChannelBackendClient implements BackendClient using channels.
// It sends MCP requests through a channel that will be read by the agent stream handler,
// and receives responses through a callback mechanism.
type ChannelBackendClient struct {
requestCh chan *ws.Message
pending map[string]chan *ws.Message
pendingMu sync.Mutex
}
// NewChannelBackendClient creates a new channel-based backend client.
func NewChannelBackendClient() *ChannelBackendClient {
return &ChannelBackendClient{
requestCh: make(chan *ws.Message, 100),
pending: make(map[string]chan *ws.Message),
}
}
// GetRequestChannel returns the channel for outgoing MCP requests.
// The agent stream handler should read from this channel and forward to the backend.
func (c *ChannelBackendClient) GetRequestChannel() <-chan *ws.Message {
return c.requestCh
}
// HandleResponse handles an incoming MCP response from the backend.
// This should be called by the agent stream handler when it receives a response.
func (c *ChannelBackendClient) HandleResponse(msg *ws.Message) {
c.pendingMu.Lock()
ch, ok := c.pending[msg.ID]
delete(c.pending, msg.ID)
c.pendingMu.Unlock()
if ok {
ch <- msg
}
}
// RequestPayload sends a request to the backend and unmarshals the response.
func (c *ChannelBackendClient) RequestPayload(ctx context.Context, action string, payload, result interface{}) error {
id := uuid.New().String()
msg, err := ws.NewRequest(id, action, payload)
if err != nil {
return fmt.Errorf("failed to create request: %w", err)
}
// Create response channel
respChan := make(chan *ws.Message, 1)
c.pendingMu.Lock()
c.pending[id] = respChan
c.pendingMu.Unlock()
// Send request through channel
select {
case c.requestCh <- msg:
// Request sent
case <-ctx.Done():
c.pendingMu.Lock()
delete(c.pending, id)
c.pendingMu.Unlock()
return ctx.Err()
case <-time.After(5 * time.Second):
c.pendingMu.Lock()
delete(c.pending, id)
c.pendingMu.Unlock()
return fmt.Errorf("timeout sending request to agent stream")
}
// Wait for response
select {
case resp := <-respChan:
if resp.Type == ws.MessageTypeError {
var ep struct {
Code string `json:"code"`
Message string `json:"message"`
}
if json.Unmarshal(resp.Payload, &ep) == nil {
return fmt.Errorf("backend error [%s]: %s", ep.Code, ep.Message)
}
return fmt.Errorf("backend error: %s", string(resp.Payload))
}
if result != nil && len(resp.Payload) > 0 {
if err := json.Unmarshal(resp.Payload, result); err != nil {
return fmt.Errorf("failed to unmarshal response: %w", err)
}
}
return nil
case <-ctx.Done():
c.pendingMu.Lock()
delete(c.pending, id)
c.pendingMu.Unlock()
return ctx.Err()
}
}
// Close closes the request channel.
func (c *ChannelBackendClient) Close() {
close(c.requestCh)
}
@@ -18,12 +18,16 @@ const (
ActionMCPCreateTask = "mcp.create_task"
ActionMCPUpdateTask = "mcp.update_task"
ActionMCPAskUserQuestion = "mcp.ask_user_question"
ActionMCPCreateTaskPlan = "mcp.create_task_plan"
ActionMCPGetTaskPlan = "mcp.get_task_plan"
ActionMCPUpdateTaskPlan = "mcp.update_task_plan"
ActionMCPDeleteTaskPlan = "mcp.delete_task_plan"
)
func (s *Server) listWorkspacesHandler() server.ToolHandlerFunc {
return func(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
var result []map[string]interface{}
if err := s.wsClient.RequestPayload(ctx, ActionMCPListWorkspaces, nil, &result); err != nil {
if err := s.backend.RequestPayload(ctx, ActionMCPListWorkspaces, nil, &result); err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
data, _ := json.MarshalIndent(result, "", " ")
@@ -39,7 +43,7 @@ func (s *Server) listBoardsHandler() server.ToolHandlerFunc {
}
payload := map[string]string{"workspace_id": workspaceID}
var result []map[string]interface{}
if err := s.wsClient.RequestPayload(ctx, ActionMCPListBoards, payload, &result); err != nil {
if err := s.backend.RequestPayload(ctx, ActionMCPListBoards, payload, &result); err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
data, _ := json.MarshalIndent(result, "", " ")
@@ -55,7 +59,7 @@ func (s *Server) listWorkflowStepsHandler() server.ToolHandlerFunc {
}
payload := map[string]string{"board_id": boardID}
var result []map[string]interface{}
if err := s.wsClient.RequestPayload(ctx, ActionMCPListWorkflowSteps, payload, &result); err != nil {
if err := s.backend.RequestPayload(ctx, ActionMCPListWorkflowSteps, payload, &result); err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
data, _ := json.MarshalIndent(result, "", " ")
@@ -71,7 +75,7 @@ func (s *Server) listTasksHandler() server.ToolHandlerFunc {
}
payload := map[string]string{"board_id": boardID}
var result []map[string]interface{}
if err := s.wsClient.RequestPayload(ctx, ActionMCPListTasks, payload, &result); err != nil {
if err := s.backend.RequestPayload(ctx, ActionMCPListTasks, payload, &result); err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
data, _ := json.MarshalIndent(result, "", " ")
@@ -107,7 +111,7 @@ func (s *Server) createTaskHandler() server.ToolHandlerFunc {
"description": description,
}
var result map[string]interface{}
if err := s.wsClient.RequestPayload(ctx, ActionMCPCreateTask, payload, &result); err != nil {
if err := s.backend.RequestPayload(ctx, ActionMCPCreateTask, payload, &result); err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
data, _ := json.MarshalIndent(result, "", " ")
@@ -132,7 +136,7 @@ func (s *Server) updateTaskHandler() server.ToolHandlerFunc {
payload["state"] = state
}
var result map[string]interface{}
if err := s.wsClient.RequestPayload(ctx, ActionMCPUpdateTask, payload, &result); err != nil {
if err := s.backend.RequestPayload(ctx, ActionMCPUpdateTask, payload, &result); err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
data, _ := json.MarshalIndent(result, "", " ")
@@ -202,7 +206,7 @@ func (s *Server) askUserQuestionHandler() server.ToolHandlerFunc {
"context": questionCtx,
}
var result map[string]interface{}
if err := s.wsClient.RequestPayload(ctx, ActionMCPAskUserQuestion, payload, &result); err != nil {
if err := s.backend.RequestPayload(ctx, ActionMCPAskUserQuestion, payload, &result); err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
@@ -227,3 +231,104 @@ func (s *Server) askUserQuestionHandler() server.ToolHandlerFunc {
}
}
func (s *Server) createTaskPlanHandler() server.ToolHandlerFunc {
return func(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
taskID, err := req.RequireString("task_id")
if err != nil {
return mcp.NewToolResultError("task_id is required"), nil
}
content, err := req.RequireString("content")
if err != nil {
return mcp.NewToolResultError("content is required"), nil
}
title := req.GetString("title", "Plan")
payload := map[string]interface{}{
"task_id": taskID,
"content": content,
"title": title,
"created_by": "agent",
}
var result map[string]interface{}
if err := s.backend.RequestPayload(ctx, ActionMCPCreateTaskPlan, payload, &result); err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
data, _ := json.MarshalIndent(result, "", " ")
return mcp.NewToolResultText(fmt.Sprintf("Plan created successfully:\n%s", string(data))), nil
}
}
func (s *Server) getTaskPlanHandler() server.ToolHandlerFunc {
return func(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
taskID, err := req.RequireString("task_id")
if err != nil {
return mcp.NewToolResultError("task_id is required"), nil
}
payload := map[string]string{"task_id": taskID}
var result map[string]interface{}
if err := s.backend.RequestPayload(ctx, ActionMCPGetTaskPlan, payload, &result); err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
// Check if plan exists
if len(result) == 0 {
return mcp.NewToolResultText("No plan exists for this task yet."), nil
}
// Return the plan content for easy reading
if content, ok := result["content"].(string); ok {
return mcp.NewToolResultText(fmt.Sprintf("# Task Plan\n\n%s", content)), nil
}
data, _ := json.MarshalIndent(result, "", " ")
return mcp.NewToolResultText(string(data)), nil
}
}
func (s *Server) updateTaskPlanHandler() server.ToolHandlerFunc {
return func(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
taskID, err := req.RequireString("task_id")
if err != nil {
return mcp.NewToolResultError("task_id is required"), nil
}
content, err := req.RequireString("content")
if err != nil {
return mcp.NewToolResultError("content is required"), nil
}
title := req.GetString("title", "")
payload := map[string]interface{}{
"task_id": taskID,
"content": content,
"created_by": "agent",
}
if title != "" {
payload["title"] = title
}
var result map[string]interface{}
if err := s.backend.RequestPayload(ctx, ActionMCPUpdateTaskPlan, payload, &result); err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
data, _ := json.MarshalIndent(result, "", " ")
return mcp.NewToolResultText(fmt.Sprintf("Plan updated successfully:\n%s", string(data))), nil
}
}
func (s *Server) deleteTaskPlanHandler() server.ToolHandlerFunc {
return func(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
taskID, err := req.RequireString("task_id")
if err != nil {
return mcp.NewToolResultError("task_id is required"), nil
}
payload := map[string]string{"task_id": taskID}
var result map[string]interface{}
if err := s.backend.RequestPayload(ctx, ActionMCPDeleteTaskPlan, payload, &result); err != nil {
return mcp.NewToolResultError(err.Error()), nil
}
return mcp.NewToolResultText("Plan deleted successfully."), nil
}
}
@@ -1,23 +1,28 @@
// Package mcp provides MCP server functionality for agentctl.
// It exposes MCP tools that forward requests to the Kandev backend via WebSocket.
// It exposes MCP tools that forward requests to the Kandev backend via the agent stream.
package mcp
import (
"context"
"net/http"
"sync"
"github.com/gin-gonic/gin"
"github.com/kandev/kandev/internal/agentctl/server/wsclient"
"github.com/kandev/kandev/internal/common/logger"
"github.com/mark3labs/mcp-go/mcp"
"github.com/mark3labs/mcp-go/server"
"go.uber.org/zap"
)
// Server wraps the MCP server with WebSocket client for backend communication.
// BackendClient is the interface for communicating with the Kandev backend.
// MCP tool handlers use this to forward requests to the backend.
type BackendClient interface {
// RequestPayload sends a request to the backend and unmarshals the response.
RequestPayload(ctx context.Context, action string, payload, result interface{}) error
}
// Server wraps the MCP server with backend client for communication.
type Server struct {
wsClient *wsclient.Client
backend BackendClient
sessionID string
mcpServer *server.MCPServer
sseServer *server.SSEServer
@@ -28,9 +33,9 @@ type Server struct {
}
// New creates a new MCP server for agentctl.
func New(wsClient *wsclient.Client, sessionID string, log *logger.Logger) *Server {
func New(backend BackendClient, sessionID string, log *logger.Logger) *Server {
s := &Server{
wsClient: wsClient,
backend: backend,
sessionID: sessionID,
logger: log.WithFields(zap.String("component", "mcp-server")),
}
@@ -187,13 +192,41 @@ Another example:
s.askUserQuestionHandler(),
)
s.logger.Info("registered MCP tools", zap.Int("count", 7))
}
s.mcpServer.AddTool(
mcp.NewTool("create_task_plan",
mcp.WithDescription("Create or save a task plan. Use this to save your implementation plan for the current task."),
mcp.WithString("task_id", mcp.Required(), mcp.Description("The task ID to create a plan for")),
mcp.WithString("content", mcp.Required(), mcp.Description("The plan content in markdown format")),
mcp.WithString("title", mcp.Description("Optional title for the plan (default: 'Plan')")),
),
s.createTaskPlanHandler(),
)
// WrapHandler wraps a handler function with error handling for gin.
func WrapHandler(h http.Handler) gin.HandlerFunc {
return func(c *gin.Context) {
h.ServeHTTP(c.Writer, c.Request)
}
}
s.mcpServer.AddTool(
mcp.NewTool("get_task_plan",
mcp.WithDescription("Get the current plan for a task. Use this to retrieve an existing plan, including any user edits."),
mcp.WithString("task_id", mcp.Required(), mcp.Description("The task ID to get the plan for")),
),
s.getTaskPlanHandler(),
)
s.mcpServer.AddTool(
mcp.NewTool("update_task_plan",
mcp.WithDescription("Update an existing task plan. Use this to modify the plan during implementation."),
mcp.WithString("task_id", mcp.Required(), mcp.Description("The task ID to update the plan for")),
mcp.WithString("content", mcp.Required(), mcp.Description("The updated plan content in markdown format")),
mcp.WithString("title", mcp.Description("Optional new title for the plan")),
),
s.updateTaskPlanHandler(),
)
s.mcpServer.AddTool(
mcp.NewTool("delete_task_plan",
mcp.WithDescription("Delete a task plan."),
mcp.WithString("task_id", mcp.Required(), mcp.Description("The task ID to delete the plan for")),
),
s.deleteTaskPlanHandler(),
)
s.logger.Info("registered MCP tools", zap.Int("count", 11))
}
@@ -213,42 +213,12 @@ func (m *Manager) Start(ctx context.Context) error {
m.exitCode.Store(-1)
m.exitErr.Store(errorWrapper{err: nil})
// Create command
// Validate command
if len(m.cfg.AgentArgs) == 0 {
m.status.Store(StatusError)
return fmt.Errorf("no agent command configured")
}
// NOTE: We intentionally don't use exec.CommandContext here because we don't want
// the HTTP request context to kill the agent process when the request completes.
m.cmd = exec.Command(m.cfg.AgentArgs[0], m.cfg.AgentArgs[1:]...)
m.cmd.Dir = m.cfg.WorkDir
m.cmd.Env = m.cfg.AgentEnv
// Create a new process group so we can kill all child processes together.
// This is important for adapters like OpenCode that spawn child processes
// (npx -> sh -> node -> opencode binary).
setProcGroup(m.cmd)
// Set up pipes
var err error
m.stdin, err = m.cmd.StdinPipe()
if err != nil {
m.status.Store(StatusError)
return fmt.Errorf("failed to create stdin pipe: %w", err)
}
m.stdout, err = m.cmd.StdoutPipe()
if err != nil {
m.status.Store(StatusError)
return fmt.Errorf("failed to create stdout pipe: %w", err)
}
m.stderr, err = m.cmd.StderrPipe()
if err != nil {
m.status.Store(StatusError)
return fmt.Errorf("failed to create stderr pipe: %w", err)
}
// Build adapter config
mcpServers := make([]adapter.McpServerConfig, len(m.cfg.McpServers))
for i, mcp := range m.cfg.McpServers {
@@ -268,7 +238,7 @@ func (m *Manager) Start(ctx context.Context) error {
AgentID: m.cfg.AgentType, // From registry (e.g., "auggie", "amp", "claude-code")
}
// Create adapter before starting the process so we can call PrepareEnvironment
// Create adapter before starting the process so we can call PrepareEnvironment and PrepareCommandArgs
if err := m.createAdapter(); err != nil {
m.status.Store(StatusError)
return fmt.Errorf("failed to create adapter: %w", err)
@@ -285,9 +255,45 @@ func (m *Manager) Start(ctx context.Context) error {
m.cfg.AgentEnv = append(m.cfg.AgentEnv, fmt.Sprintf("%s=%s", k, v))
}
// Get extra command args from the adapter (e.g., -c flags for Codex MCP config)
extraArgs := m.adapter.PrepareCommandArgs()
// Build final command args
cmdArgs := append(m.cfg.AgentArgs[1:], extraArgs...)
// NOTE: We intentionally don't use exec.CommandContext here because we don't want
// the HTTP request context to kill the agent process when the request completes.
m.cmd = exec.Command(m.cfg.AgentArgs[0], cmdArgs...)
m.cmd.Dir = m.cfg.WorkDir
m.cmd.Env = m.cfg.AgentEnv
// Create a new process group so we can kill all child processes together.
// This is important for adapters like OpenCode that spawn child processes
// (npx -> sh -> node -> opencode binary).
setProcGroup(m.cmd)
// Set up pipes
m.stdin, err = m.cmd.StdinPipe()
if err != nil {
m.status.Store(StatusError)
return fmt.Errorf("failed to create stdin pipe: %w", err)
}
m.stdout, err = m.cmd.StdoutPipe()
if err != nil {
m.status.Store(StatusError)
return fmt.Errorf("failed to create stdout pipe: %w", err)
}
m.stderr, err = m.cmd.StderrPipe()
if err != nil {
m.status.Store(StatusError)
return fmt.Errorf("failed to create stderr pipe: %w", err)
}
// Start the process
m.logger.Info("starting agent process",
zap.Strings("args", m.cfg.AgentArgs),
zap.Strings("extra_args", extraArgs),
zap.String("workdir", m.cfg.WorkDir),
zap.Int("env_count", len(m.cfg.AgentEnv)))
if err := m.cmd.Start(); err != nil {
@@ -1,177 +0,0 @@
// Package wsclient provides a WebSocket client for connecting back to the Kandev backend.
package wsclient
import (
"context"
"encoding/json"
"fmt"
"sync"
"time"
"github.com/google/uuid"
"github.com/gorilla/websocket"
"github.com/kandev/kandev/internal/common/logger"
ws "github.com/kandev/kandev/pkg/websocket"
"go.uber.org/zap"
)
type Client struct {
url string
conn *websocket.Conn
logger *logger.Logger
pending map[string]chan *ws.Message
pendingMu sync.RWMutex
connected bool
connMu sync.RWMutex
writeMu sync.Mutex
reconnectInterval time.Duration
maxReconnectTries int
}
func New(url string, log *logger.Logger) *Client {
return &Client{
url: url,
logger: log.WithFields(zap.String("component", "wsclient")),
pending: make(map[string]chan *ws.Message),
reconnectInterval: 5 * time.Second,
maxReconnectTries: 10,
}
}
func (c *Client) Connect(ctx context.Context) error {
c.connMu.Lock()
defer c.connMu.Unlock()
if c.connected {
return nil
}
conn, _, err := websocket.DefaultDialer.DialContext(ctx, c.url, nil)
if err != nil {
return fmt.Errorf("failed to connect to backend: %w", err)
}
c.conn = conn
c.connected = true
c.logger.Info("connected to backend WebSocket", zap.String("url", c.url))
go c.readLoop()
return nil
}
func (c *Client) Close() error {
c.connMu.Lock()
defer c.connMu.Unlock()
if !c.connected {
return nil
}
c.connected = false
if c.conn != nil {
return c.conn.Close()
}
return nil
}
func (c *Client) IsConnected() bool {
c.connMu.RLock()
defer c.connMu.RUnlock()
return c.connected
}
func (c *Client) Request(ctx context.Context, action string, payload interface{}) (*ws.Message, error) {
if !c.IsConnected() {
return nil, fmt.Errorf("not connected to backend")
}
id := uuid.New().String()
msg, err := ws.NewRequest(id, action, payload)
if err != nil {
return nil, fmt.Errorf("failed to create request: %w", err)
}
respChan := make(chan *ws.Message, 1)
c.pendingMu.Lock()
c.pending[id] = respChan
c.pendingMu.Unlock()
c.writeMu.Lock()
err = c.conn.WriteJSON(msg)
c.writeMu.Unlock()
if err != nil {
c.pendingMu.Lock()
delete(c.pending, id)
c.pendingMu.Unlock()
return nil, fmt.Errorf("failed to send request: %w", err)
}
c.logger.Debug("sent request", zap.String("action", action), zap.String("id", id))
select {
case resp := <-respChan:
return resp, nil
case <-ctx.Done():
c.pendingMu.Lock()
delete(c.pending, id)
c.pendingMu.Unlock()
return nil, ctx.Err()
}
}
func (c *Client) RequestPayload(ctx context.Context, action string, payload, result interface{}) error {
resp, err := c.Request(ctx, action, payload)
if err != nil {
return err
}
if resp.Type == ws.MessageTypeError {
var ep struct{ Code, Message string }
if json.Unmarshal(resp.Payload, &ep) == nil {
return fmt.Errorf("backend error [%s]: %s", ep.Code, ep.Message)
}
return fmt.Errorf("backend error: %s", string(resp.Payload))
}
if result != nil && len(resp.Payload) > 0 {
if err := json.Unmarshal(resp.Payload, result); err != nil {
return fmt.Errorf("failed to unmarshal response: %w", err)
}
}
return nil
}
func (c *Client) readLoop() {
for {
c.connMu.RLock()
conn, connected := c.conn, c.connected
c.connMu.RUnlock()
if !connected || conn == nil {
return
}
var msg ws.Message
if err := conn.ReadJSON(&msg); err != nil {
if !websocket.IsCloseError(err, websocket.CloseNormalClosure, websocket.CloseGoingAway) {
c.logger.Error("read error", zap.Error(err))
}
c.handleDisconnect()
return
}
c.handleMessage(&msg)
}
}
func (c *Client) handleMessage(msg *ws.Message) {
if msg.Type == ws.MessageTypeResponse || msg.Type == ws.MessageTypeError {
c.pendingMu.Lock()
ch, ok := c.pending[msg.ID]
delete(c.pending, msg.ID)
c.pendingMu.Unlock()
if ok {
ch <- msg
}
return
}
}
func (c *Client) handleDisconnect() {
c.connMu.Lock()
c.connected = false
c.conn = nil
c.connMu.Unlock()
c.pendingMu.Lock()
for id, ch := range c.pending {
errMsg, _ := ws.NewError(id, "", ws.ErrorCodeInternalError, "connection lost", nil)
ch <- errMsg
delete(c.pending, id)
}
c.pendingMu.Unlock()
}
+7
View File
@@ -34,6 +34,13 @@ const (
TaskSessionStateChanged = "task_session.state_changed"
)
// Event types for task plans
const (
TaskPlanCreated = "task_plan.created"
TaskPlanUpdated = "task_plan.updated"
TaskPlanDeleted = "task_plan.deleted"
)
// Event types for session turns
const (
TurnStarted = "turn.started"
@@ -35,6 +35,9 @@ func RegisterTaskNotifications(ctx context.Context, eventBus bus.EventBus, hub *
b.subscribe(eventBus, events.TaskUpdated, ws.ActionTaskUpdated)
b.subscribe(eventBus, events.TaskDeleted, ws.ActionTaskDeleted)
b.subscribe(eventBus, events.TaskStateChanged, ws.ActionTaskStateChanged)
b.subscribe(eventBus, events.TaskPlanCreated, ws.ActionTaskPlanCreated)
b.subscribe(eventBus, events.TaskPlanUpdated, ws.ActionTaskPlanUpdated)
b.subscribe(eventBus, events.TaskPlanDeleted, ws.ActionTaskPlanDeleted)
b.subscribe(eventBus, events.RepositoryCreated, ws.ActionRepositoryCreated)
b.subscribe(eventBus, events.RepositoryUpdated, ws.ActionRepositoryUpdated)
b.subscribe(eventBus, events.RepositoryDeleted, ws.ActionRepositoryDeleted)
@@ -112,7 +112,8 @@ func NewTestServer(t *testing.T) *TestServer {
workflowCtrl := workflowcontroller.NewController(workflowSvc)
taskhandlers.RegisterWorkspaceRoutes(router, gateway.Dispatcher, workspaceController, log)
taskhandlers.RegisterBoardRoutes(router, gateway.Dispatcher, boardController, log)
taskhandlers.RegisterTaskRoutes(router, gateway.Dispatcher, taskController, nil, log)
planService := taskservice.NewPlanService(taskRepo, eventBus, log)
taskhandlers.RegisterTaskRoutes(router, gateway.Dispatcher, taskController, nil, taskRepo, planService, log)
taskhandlers.RegisterRepositoryRoutes(router, gateway.Dispatcher, repositoryController, log)
taskhandlers.RegisterExecutorRoutes(router, gateway.Dispatcher, executorController, log)
taskhandlers.RegisterEnvironmentRoutes(router, gateway.Dispatcher, environmentController, log)
@@ -698,7 +698,8 @@ func NewOrchestratorTestServer(t *testing.T) *OrchestratorTestServer {
workflowCtrl := workflowcontroller.NewController(workflowSvc)
taskhandlers.RegisterWorkspaceRoutes(router, gateway.Dispatcher, workspaceController, log)
taskhandlers.RegisterBoardRoutes(router, gateway.Dispatcher, boardController, log)
taskhandlers.RegisterTaskRoutes(router, gateway.Dispatcher, taskController, nil, log)
planService := taskservice.NewPlanService(taskRepo, eventBus, log)
taskhandlers.RegisterTaskRoutes(router, gateway.Dispatcher, taskController, nil, taskRepo, planService, log)
taskhandlers.RegisterRepositoryRoutes(router, gateway.Dispatcher, repositoryController, log)
taskhandlers.RegisterExecutorRoutes(router, gateway.Dispatcher, executorController, log)
taskhandlers.RegisterEnvironmentRoutes(router, gateway.Dispatcher, environmentController, log)
+139 -34
View File
@@ -6,28 +6,18 @@ package handlers
import (
"context"
"encoding/json"
"errors"
"github.com/kandev/kandev/internal/clarification"
"github.com/kandev/kandev/internal/common/logger"
"github.com/kandev/kandev/internal/task/controller"
"github.com/kandev/kandev/internal/task/dto"
"github.com/kandev/kandev/internal/task/repository"
"github.com/kandev/kandev/internal/task/service"
workflowctrl "github.com/kandev/kandev/internal/workflow/controller"
ws "github.com/kandev/kandev/pkg/websocket"
"go.uber.org/zap"
)
// Action constants for MCP WebSocket messages
const (
ActionMCPListWorkspaces = "mcp.list_workspaces"
ActionMCPListBoards = "mcp.list_boards"
ActionMCPListWorkflowSteps = "mcp.list_workflow_steps"
ActionMCPListTasks = "mcp.list_tasks"
ActionMCPCreateTask = "mcp.create_task"
ActionMCPUpdateTask = "mcp.update_task"
ActionMCPAskUserQuestion = "mcp.ask_user_question"
)
// ClarificationService defines the interface for clarification operations.
type ClarificationService interface {
CreateRequest(req *clarification.Request) string
@@ -47,7 +37,7 @@ type Handlers struct {
workflowCtrl *workflowctrl.Controller
clarificationSvc ClarificationService
messageCreator MessageCreator
repo repository.Repository
planService *service.PlanService
logger *logger.Logger
}
@@ -59,7 +49,7 @@ func NewHandlers(
workflowCtrl *workflowctrl.Controller,
clarificationSvc ClarificationService,
messageCreator MessageCreator,
repo repository.Repository,
planService *service.PlanService,
log *logger.Logger,
) *Handlers {
return &Handlers{
@@ -69,22 +59,26 @@ func NewHandlers(
workflowCtrl: workflowCtrl,
clarificationSvc: clarificationSvc,
messageCreator: messageCreator,
repo: repo,
planService: planService,
logger: log.WithFields(zap.String("component", "mcp-handlers")),
}
}
// RegisterHandlers registers all MCP handlers with the dispatcher.
func (h *Handlers) RegisterHandlers(d *ws.Dispatcher) {
d.RegisterFunc(ActionMCPListWorkspaces, h.handleListWorkspaces)
d.RegisterFunc(ActionMCPListBoards, h.handleListBoards)
d.RegisterFunc(ActionMCPListWorkflowSteps, h.handleListWorkflowSteps)
d.RegisterFunc(ActionMCPListTasks, h.handleListTasks)
d.RegisterFunc(ActionMCPCreateTask, h.handleCreateTask)
d.RegisterFunc(ActionMCPUpdateTask, h.handleUpdateTask)
d.RegisterFunc(ActionMCPAskUserQuestion, h.handleAskUserQuestion)
d.RegisterFunc(ws.ActionMCPListWorkspaces, h.handleListWorkspaces)
d.RegisterFunc(ws.ActionMCPListBoards, h.handleListBoards)
d.RegisterFunc(ws.ActionMCPListWorkflowSteps, h.handleListWorkflowSteps)
d.RegisterFunc(ws.ActionMCPListTasks, h.handleListTasks)
d.RegisterFunc(ws.ActionMCPCreateTask, h.handleCreateTask)
d.RegisterFunc(ws.ActionMCPUpdateTask, h.handleUpdateTask)
d.RegisterFunc(ws.ActionMCPAskUserQuestion, h.handleAskUserQuestion)
d.RegisterFunc(ws.ActionMCPCreateTaskPlan, h.handleCreateTaskPlan)
d.RegisterFunc(ws.ActionMCPGetTaskPlan, h.handleGetTaskPlan)
d.RegisterFunc(ws.ActionMCPUpdateTaskPlan, h.handleUpdateTaskPlan)
d.RegisterFunc(ws.ActionMCPDeleteTaskPlan, h.handleDeleteTaskPlan)
h.logger.Info("registered MCP handlers", zap.Int("count", 7))
h.logger.Info("registered MCP handlers", zap.Int("count", 11))
}
// handleListWorkspaces lists all workspaces.
@@ -237,18 +231,8 @@ func (h *Handlers) handleAskUserQuestion(ctx context.Context, msg *ws.Message) (
}
}
// Look up task ID from session if not provided
// Use provided task ID (session -> task lookup is done by caller)
taskID := req.TaskID
if taskID == "" && h.repo != nil {
session, err := h.repo.GetTaskSession(ctx, req.SessionID)
if err != nil {
h.logger.Warn("failed to look up session for task ID",
zap.String("session_id", req.SessionID),
zap.Error(err))
} else {
taskID = session.TaskID
}
}
// Create the clarification request
clarificationReq := &clarification.Request{
@@ -294,3 +278,124 @@ func generateOptionID(questionIndex, optionIndex int) string {
return "q" + string(rune('1'+questionIndex)) + "_opt" + string(rune('1'+optionIndex))
}
// handleCreateTaskPlan creates a new task plan.
func (h *Handlers) handleCreateTaskPlan(ctx context.Context, msg *ws.Message) (*ws.Message, error) {
var req struct {
TaskID string `json:"task_id"`
Title string `json:"title"`
Content string `json:"content"`
CreatedBy string `json:"created_by"`
}
if err := json.Unmarshal(msg.Payload, &req); err != nil {
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeBadRequest, "Invalid payload: "+err.Error(), nil)
}
if req.Content == "" {
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeValidation, "content is required", nil)
}
createdBy := req.CreatedBy
if createdBy == "" {
createdBy = "agent"
}
plan, err := h.planService.CreatePlan(ctx, service.CreatePlanRequest{
TaskID: req.TaskID,
Title: req.Title,
Content: req.Content,
CreatedBy: createdBy,
})
if err != nil {
if errors.Is(err, service.ErrTaskIDRequired) {
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeValidation, "task_id is required", nil)
}
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeInternalError, "Failed to create task plan: "+err.Error(), nil)
}
return ws.NewResponse(msg.ID, msg.Action, dto.TaskPlanFromModel(plan))
}
// handleGetTaskPlan retrieves a task plan.
func (h *Handlers) handleGetTaskPlan(ctx context.Context, msg *ws.Message) (*ws.Message, error) {
var req struct {
TaskID string `json:"task_id"`
}
if err := json.Unmarshal(msg.Payload, &req); err != nil {
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeBadRequest, "Invalid payload: "+err.Error(), nil)
}
plan, err := h.planService.GetPlan(ctx, req.TaskID)
if err != nil {
if errors.Is(err, service.ErrTaskIDRequired) {
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeValidation, "task_id is required", nil)
}
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeInternalError, "Failed to get task plan", nil)
}
if plan == nil {
// Return empty object if no plan exists
return ws.NewResponse(msg.ID, msg.Action, map[string]interface{}{})
}
return ws.NewResponse(msg.ID, msg.Action, dto.TaskPlanFromModel(plan))
}
// handleUpdateTaskPlan updates an existing task plan.
func (h *Handlers) handleUpdateTaskPlan(ctx context.Context, msg *ws.Message) (*ws.Message, error) {
var req struct {
TaskID string `json:"task_id"`
Title string `json:"title"`
Content string `json:"content"`
CreatedBy string `json:"created_by"`
}
if err := json.Unmarshal(msg.Payload, &req); err != nil {
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeBadRequest, "Invalid payload: "+err.Error(), nil)
}
if req.Content == "" {
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeValidation, "content is required", nil)
}
createdBy := req.CreatedBy
if createdBy == "" {
createdBy = "agent"
}
plan, err := h.planService.UpdatePlan(ctx, service.UpdatePlanRequest{
TaskID: req.TaskID,
Title: req.Title,
Content: req.Content,
CreatedBy: createdBy,
})
if err != nil {
if errors.Is(err, service.ErrTaskIDRequired) {
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeValidation, "task_id is required", nil)
}
if errors.Is(err, service.ErrTaskPlanNotFound) {
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeNotFound, "Task plan not found", nil)
}
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeInternalError, "Failed to update task plan: "+err.Error(), nil)
}
return ws.NewResponse(msg.ID, msg.Action, dto.TaskPlanFromModel(plan))
}
// handleDeleteTaskPlan deletes a task plan.
func (h *Handlers) handleDeleteTaskPlan(ctx context.Context, msg *ws.Message) (*ws.Message, error) {
var req struct {
TaskID string `json:"task_id"`
}
if err := json.Unmarshal(msg.Payload, &req); err != nil {
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeBadRequest, "Invalid payload: "+err.Error(), nil)
}
err := h.planService.DeletePlan(ctx, req.TaskID)
if err != nil {
if errors.Is(err, service.ErrTaskIDRequired) {
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeValidation, "task_id is required", nil)
}
if errors.Is(err, service.ErrTaskPlanNotFound) {
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeNotFound, "Task plan not found", nil)
}
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeInternalError, "Failed to delete task plan: "+err.Error(), nil)
}
return ws.NewResponse(msg.ID, msg.Action, map[string]interface{}{"success": true})
}
+27
View File
@@ -451,3 +451,30 @@ type ApproveSessionResponse struct {
Session TaskSessionDTO `json:"session"`
WorkflowStep WorkflowStepDTO `json:"workflow_step,omitempty"` // New step after approval
}
// TaskPlanDTO represents a task plan for API responses
type TaskPlanDTO struct {
ID string `json:"id"`
TaskID string `json:"task_id"`
Title string `json:"title"`
Content string `json:"content"`
CreatedBy string `json:"created_by"`
CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"updated_at"`
}
// TaskPlanFromModel converts a TaskPlan model to a TaskPlanDTO.
func TaskPlanFromModel(plan *models.TaskPlan) *TaskPlanDTO {
if plan == nil {
return nil
}
return &TaskPlanDTO{
ID: plan.ID,
TaskID: plan.TaskID,
Title: plan.Title,
Content: plan.Content,
CreatedBy: plan.CreatedBy,
CreatedAt: plan.CreatedAt,
UpdatedAt: plan.UpdatedAt,
}
}
@@ -339,6 +339,20 @@ func (m *mockRepository) UpdateSessionReviewStatus(ctx context.Context, sessionI
return nil
}
// Task Plan operations
func (m *mockRepository) CreateTaskPlan(ctx context.Context, plan *models.TaskPlan) error {
return nil
}
func (m *mockRepository) GetTaskPlan(ctx context.Context, taskID string) (*models.TaskPlan, error) {
return nil, nil
}
func (m *mockRepository) UpdateTaskPlan(ctx context.Context, plan *models.TaskPlan) error {
return nil
}
func (m *mockRepository) DeleteTaskPlan(ctx context.Context, taskID string) error {
return nil
}
func newTestService(t *testing.T, scripts map[string][]*models.RepositoryScript) *service.Service {
log, err := logger.NewLogger(logger.LoggingConfig{
Level: "error",
@@ -2,6 +2,8 @@ package handlers
import (
"context"
"encoding/json"
"errors"
"net/http"
"github.com/gin-gonic/gin"
@@ -11,6 +13,8 @@ import (
"github.com/kandev/kandev/internal/orchestrator/executor"
"github.com/kandev/kandev/internal/task/controller"
"github.com/kandev/kandev/internal/task/dto"
"github.com/kandev/kandev/internal/task/repository"
"github.com/kandev/kandev/internal/task/service"
v1 "github.com/kandev/kandev/pkg/api/v1"
ws "github.com/kandev/kandev/pkg/websocket"
"go.uber.org/zap"
@@ -19,6 +23,8 @@ import (
type TaskHandlers struct {
controller *controller.TaskController
orchestrator OrchestratorStarter
repo repository.Repository
planService *service.PlanService
logger *logger.Logger
}
@@ -28,16 +34,18 @@ type OrchestratorStarter interface {
StartTask(ctx context.Context, taskID string, agentProfileID string, executorID string, priority int, prompt string, workflowStepID string) (*executor.TaskExecution, error)
}
func NewTaskHandlers(ctrl *controller.TaskController, orchestrator OrchestratorStarter, log *logger.Logger) *TaskHandlers {
func NewTaskHandlers(ctrl *controller.TaskController, orchestrator OrchestratorStarter, repo repository.Repository, planService *service.PlanService, log *logger.Logger) *TaskHandlers {
return &TaskHandlers{
controller: ctrl,
orchestrator: orchestrator,
repo: repo,
planService: planService,
logger: log.WithFields(zap.String("component", "task-task-handlers")),
}
}
func RegisterTaskRoutes(router *gin.Engine, dispatcher *ws.Dispatcher, ctrl *controller.TaskController, orchestrator OrchestratorStarter, log *logger.Logger) {
handlers := NewTaskHandlers(ctrl, orchestrator, log)
func RegisterTaskRoutes(router *gin.Engine, dispatcher *ws.Dispatcher, ctrl *controller.TaskController, orchestrator OrchestratorStarter, repo repository.Repository, planService *service.PlanService, log *logger.Logger) {
handlers := NewTaskHandlers(ctrl, orchestrator, repo, planService, log)
handlers.registerHTTP(router)
handlers.registerWS(dispatcher)
}
@@ -70,6 +78,11 @@ func (h *TaskHandlers) registerWS(dispatcher *ws.Dispatcher) {
dispatcher.RegisterFunc(ws.ActionSessionGitSnapshots, h.wsGetGitSnapshots)
dispatcher.RegisterFunc(ws.ActionSessionGitCommits, h.wsGetSessionCommits)
dispatcher.RegisterFunc(ws.ActionSessionCumulativeDiff, h.wsGetCumulativeDiff)
// Task plan handlers
dispatcher.RegisterFunc(ws.ActionTaskPlanCreate, h.wsCreateTaskPlan)
dispatcher.RegisterFunc(ws.ActionTaskPlanGet, h.wsGetTaskPlan)
dispatcher.RegisterFunc(ws.ActionTaskPlanUpdate, h.wsUpdateTaskPlan)
dispatcher.RegisterFunc(ws.ActionTaskPlanDelete, h.wsDeleteTaskPlan)
}
// HTTP handlers
@@ -685,3 +698,123 @@ func (h *TaskHandlers) wsGetCumulativeDiff(ctx context.Context, msg *ws.Message)
"cumulative_diff": diff,
})
}
// Task Plan Handlers
// wsCreateTaskPlan creates a new task plan
func (h *TaskHandlers) wsCreateTaskPlan(ctx context.Context, msg *ws.Message) (*ws.Message, error) {
var req struct {
TaskID string `json:"task_id"`
Title string `json:"title"`
Content string `json:"content"`
CreatedBy string `json:"created_by"`
}
if err := json.Unmarshal(msg.Payload, &req); err != nil {
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeBadRequest, "Invalid payload: "+err.Error(), nil)
}
// Default to "user" for frontend requests
createdBy := req.CreatedBy
if createdBy == "" {
createdBy = "user"
}
plan, err := h.planService.CreatePlan(ctx, service.CreatePlanRequest{
TaskID: req.TaskID,
Title: req.Title,
Content: req.Content,
CreatedBy: createdBy,
})
if err != nil {
if errors.Is(err, service.ErrTaskIDRequired) {
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeValidation, "task_id is required", nil)
}
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeInternalError, "Failed to create task plan: "+err.Error(), nil)
}
return ws.NewResponse(msg.ID, msg.Action, dto.TaskPlanFromModel(plan))
}
// wsGetTaskPlan retrieves a task plan
func (h *TaskHandlers) wsGetTaskPlan(ctx context.Context, msg *ws.Message) (*ws.Message, error) {
var req struct {
TaskID string `json:"task_id"`
}
if err := json.Unmarshal(msg.Payload, &req); err != nil {
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeBadRequest, "Invalid payload: "+err.Error(), nil)
}
plan, err := h.planService.GetPlan(ctx, req.TaskID)
if err != nil {
if errors.Is(err, service.ErrTaskIDRequired) {
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeValidation, "task_id is required", nil)
}
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeInternalError, "Failed to get task plan", nil)
}
if plan == nil {
return ws.NewResponse(msg.ID, msg.Action, nil)
}
return ws.NewResponse(msg.ID, msg.Action, dto.TaskPlanFromModel(plan))
}
// wsUpdateTaskPlan updates an existing task plan
func (h *TaskHandlers) wsUpdateTaskPlan(ctx context.Context, msg *ws.Message) (*ws.Message, error) {
var req struct {
TaskID string `json:"task_id"`
Title string `json:"title"`
Content string `json:"content"`
CreatedBy string `json:"created_by"`
}
if err := json.Unmarshal(msg.Payload, &req); err != nil {
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeBadRequest, "Invalid payload: "+err.Error(), nil)
}
// Default to "user" for frontend requests
createdBy := req.CreatedBy
if createdBy == "" {
createdBy = "user"
}
plan, err := h.planService.UpdatePlan(ctx, service.UpdatePlanRequest{
TaskID: req.TaskID,
Title: req.Title,
Content: req.Content,
CreatedBy: createdBy,
})
if err != nil {
if errors.Is(err, service.ErrTaskIDRequired) {
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeValidation, "task_id is required", nil)
}
if errors.Is(err, service.ErrTaskPlanNotFound) {
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeNotFound, "Task plan not found", nil)
}
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeInternalError, "Failed to update task plan: "+err.Error(), nil)
}
return ws.NewResponse(msg.ID, msg.Action, dto.TaskPlanFromModel(plan))
}
// wsDeleteTaskPlan deletes a task plan
func (h *TaskHandlers) wsDeleteTaskPlan(ctx context.Context, msg *ws.Message) (*ws.Message, error) {
var req struct {
TaskID string `json:"task_id"`
}
if err := json.Unmarshal(msg.Payload, &req); err != nil {
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeBadRequest, "Invalid payload: "+err.Error(), nil)
}
err := h.planService.DeletePlan(ctx, req.TaskID)
if err != nil {
if errors.Is(err, service.ErrTaskIDRequired) {
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeValidation, "task_id is required", nil)
}
if errors.Is(err, service.ErrTaskPlanNotFound) {
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeNotFound, "Task plan not found", nil)
}
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeInternalError, "Failed to delete task plan: "+err.Error(), nil)
}
return ws.NewResponse(msg.ID, msg.Action, map[string]interface{}{"success": true})
}
@@ -412,6 +412,17 @@ type Environment struct {
DeletedAt *time.Time `json:"deleted_at,omitempty"`
}
// TaskPlan represents a plan associated with a task
type TaskPlan struct {
ID string `json:"id"`
TaskID string `json:"task_id"`
Title string `json:"title"`
Content string `json:"content"`
CreatedBy string `json:"created_by"` // "agent" or "user"
CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"updated_at"`
}
// ToAPI converts internal Task to API type
func (t *Task) ToAPI() *v1.Task {
// Convert TaskRepository models to API types
@@ -137,6 +137,12 @@ type Repository interface {
DeleteEnvironment(ctx context.Context, id string) error
ListEnvironments(ctx context.Context) ([]*models.Environment, error)
// Task Plan operations
CreateTaskPlan(ctx context.Context, plan *models.TaskPlan) error
GetTaskPlan(ctx context.Context, taskID string) (*models.TaskPlan, error)
UpdateTaskPlan(ctx context.Context, plan *models.TaskPlan) error
DeleteTaskPlan(ctx context.Context, taskID string) error
// Close closes the repository (for database connections)
Close() error
}
@@ -209,6 +209,25 @@ func (r *Repository) initSchema() error {
if _, err := r.db.Exec(schema); err != nil {
return err
}
// Task plans table
plansSchema := `
CREATE TABLE IF NOT EXISTS task_plans (
id TEXT PRIMARY KEY,
task_id TEXT NOT NULL UNIQUE,
title TEXT NOT NULL DEFAULT 'Plan',
content TEXT NOT NULL DEFAULT '',
created_by TEXT NOT NULL DEFAULT 'agent',
created_at DATETIME NOT NULL,
updated_at DATETIME NOT NULL,
FOREIGN KEY (task_id) REFERENCES tasks(id) ON DELETE CASCADE
);
CREATE INDEX IF NOT EXISTS idx_task_plans_task_id ON task_plans(task_id);
`
if _, err := r.db.Exec(plansSchema); err != nil {
return err
}
// Session and message tables
sessionSchema := `
CREATE TABLE IF NOT EXISTS task_session_messages (
@@ -0,0 +1,85 @@
package sqlite
import (
"context"
"database/sql"
"fmt"
"time"
"github.com/google/uuid"
"github.com/kandev/kandev/internal/task/models"
)
// CreateTaskPlan creates a new task plan.
func (r *Repository) CreateTaskPlan(ctx context.Context, plan *models.TaskPlan) error {
if plan.ID == "" {
plan.ID = uuid.New().String()
}
now := time.Now().UTC()
plan.CreatedAt = now
plan.UpdatedAt = now
if plan.Title == "" {
plan.Title = "Plan"
}
if plan.CreatedBy == "" {
plan.CreatedBy = "agent"
}
_, err := r.db.ExecContext(ctx, `
INSERT INTO task_plans (id, task_id, title, content, created_by, created_at, updated_at)
VALUES (?, ?, ?, ?, ?, ?, ?)
`, plan.ID, plan.TaskID, plan.Title, plan.Content, plan.CreatedBy, plan.CreatedAt, plan.UpdatedAt)
return err
}
// GetTaskPlan retrieves a task plan by task ID.
func (r *Repository) GetTaskPlan(ctx context.Context, taskID string) (*models.TaskPlan, error) {
plan := &models.TaskPlan{}
err := r.db.QueryRowContext(ctx, `
SELECT id, task_id, title, content, created_by, created_at, updated_at
FROM task_plans WHERE task_id = ?
`, taskID).Scan(&plan.ID, &plan.TaskID, &plan.Title, &plan.Content, &plan.CreatedBy, &plan.CreatedAt, &plan.UpdatedAt)
if err == sql.ErrNoRows {
return nil, nil // Return nil, nil when no plan exists
}
if err != nil {
return nil, fmt.Errorf("failed to get task plan: %w", err)
}
return plan, nil
}
// UpdateTaskPlan updates an existing task plan.
func (r *Repository) UpdateTaskPlan(ctx context.Context, plan *models.TaskPlan) error {
plan.UpdatedAt = time.Now().UTC()
result, err := r.db.ExecContext(ctx, `
UPDATE task_plans SET title = ?, content = ?, created_by = ?, updated_at = ?
WHERE task_id = ?
`, plan.Title, plan.Content, plan.CreatedBy, plan.UpdatedAt, plan.TaskID)
if err != nil {
return fmt.Errorf("failed to update task plan: %w", err)
}
rows, _ := result.RowsAffected()
if rows == 0 {
return fmt.Errorf("task plan not found for task: %s", plan.TaskID)
}
return nil
}
// DeleteTaskPlan deletes a task plan by task ID.
func (r *Repository) DeleteTaskPlan(ctx context.Context, taskID string) error {
result, err := r.db.ExecContext(ctx, `DELETE FROM task_plans WHERE task_id = ?`, taskID)
if err != nil {
return fmt.Errorf("failed to delete task plan: %w", err)
}
rows, _ := result.RowsAffected()
if rows == 0 {
return fmt.Errorf("task plan not found for task: %s", taskID)
}
return nil
}
@@ -0,0 +1,195 @@
package service
import (
"context"
"errors"
"go.uber.org/zap"
"github.com/kandev/kandev/internal/common/logger"
"github.com/kandev/kandev/internal/events"
"github.com/kandev/kandev/internal/events/bus"
"github.com/kandev/kandev/internal/task/models"
"github.com/kandev/kandev/internal/task/repository"
)
var (
ErrTaskPlanNotFound = errors.New("task plan not found")
ErrTaskIDRequired = errors.New("task_id is required")
ErrContentRequired = errors.New("content is required")
)
// PlanService provides task plan business logic.
type PlanService struct {
repo repository.Repository
eventBus bus.EventBus
logger *logger.Logger
}
// NewPlanService creates a new task plan service.
func NewPlanService(repo repository.Repository, eventBus bus.EventBus, log *logger.Logger) *PlanService {
return &PlanService{
repo: repo,
eventBus: eventBus,
logger: log.WithFields(zap.String("component", "plan-service")),
}
}
// CreatePlanRequest contains parameters for creating a task plan.
type CreatePlanRequest struct {
TaskID string
Title string
Content string
CreatedBy string // "agent" or "user"
}
// CreatePlan creates a new task plan.
func (s *PlanService) CreatePlan(ctx context.Context, req CreatePlanRequest) (*models.TaskPlan, error) {
if req.TaskID == "" {
return nil, ErrTaskIDRequired
}
title := req.Title
if title == "" {
title = "Plan"
}
createdBy := req.CreatedBy
if createdBy == "" {
createdBy = "agent"
}
plan := &models.TaskPlan{
TaskID: req.TaskID,
Title: title,
Content: req.Content,
CreatedBy: createdBy,
}
if err := s.repo.CreateTaskPlan(ctx, plan); err != nil {
s.logger.Error("failed to create task plan", zap.String("task_id", req.TaskID), zap.Error(err))
return nil, err
}
s.logger.Info("created task plan", zap.String("task_id", req.TaskID), zap.String("plan_id", plan.ID))
s.publishEvent(ctx, events.TaskPlanCreated, plan)
return plan, nil
}
// GetPlan retrieves a task plan by task ID.
// Returns nil, nil if no plan exists.
func (s *PlanService) GetPlan(ctx context.Context, taskID string) (*models.TaskPlan, error) {
if taskID == "" {
return nil, ErrTaskIDRequired
}
plan, err := s.repo.GetTaskPlan(ctx, taskID)
if err != nil {
s.logger.Error("failed to get task plan", zap.String("task_id", taskID), zap.Error(err))
return nil, err
}
return plan, nil
}
// UpdatePlanRequest contains parameters for updating a task plan.
type UpdatePlanRequest struct {
TaskID string
Title string // Optional: if empty, preserves existing title
Content string
CreatedBy string // Optional: if empty, preserves existing or defaults to "user"
}
// UpdatePlan updates an existing task plan.
func (s *PlanService) UpdatePlan(ctx context.Context, req UpdatePlanRequest) (*models.TaskPlan, error) {
if req.TaskID == "" {
return nil, ErrTaskIDRequired
}
existing, err := s.repo.GetTaskPlan(ctx, req.TaskID)
if err != nil {
s.logger.Error("failed to get existing task plan", zap.String("task_id", req.TaskID), zap.Error(err))
return nil, err
}
if existing == nil {
return nil, ErrTaskPlanNotFound
}
// Preserve existing values if not provided
title := req.Title
if title == "" {
title = existing.Title
}
createdBy := req.CreatedBy
if createdBy == "" {
createdBy = existing.CreatedBy
}
plan := &models.TaskPlan{
ID: existing.ID,
TaskID: req.TaskID,
Title: title,
Content: req.Content,
CreatedBy: createdBy,
CreatedAt: existing.CreatedAt,
}
if err := s.repo.UpdateTaskPlan(ctx, plan); err != nil {
s.logger.Error("failed to update task plan", zap.String("task_id", req.TaskID), zap.Error(err))
return nil, err
}
s.logger.Info("updated task plan", zap.String("task_id", req.TaskID))
s.publishEvent(ctx, events.TaskPlanUpdated, plan)
return plan, nil
}
// DeletePlan deletes a task plan by task ID.
func (s *PlanService) DeletePlan(ctx context.Context, taskID string) error {
if taskID == "" {
return ErrTaskIDRequired
}
// Get plan before deleting for event payload
existing, err := s.repo.GetTaskPlan(ctx, taskID)
if err != nil {
s.logger.Error("failed to get task plan for delete", zap.String("task_id", taskID), zap.Error(err))
return err
}
if existing == nil {
return ErrTaskPlanNotFound
}
if err := s.repo.DeleteTaskPlan(ctx, taskID); err != nil {
s.logger.Error("failed to delete task plan", zap.String("task_id", taskID), zap.Error(err))
return err
}
s.logger.Info("deleted task plan", zap.String("task_id", taskID))
s.publishEvent(ctx, events.TaskPlanDeleted, existing)
return nil
}
// publishEvent publishes a task plan event to the event bus.
func (s *PlanService) publishEvent(ctx context.Context, eventType string, plan *models.TaskPlan) {
if s.eventBus == nil {
return
}
payload := map[string]interface{}{
"id": plan.ID,
"task_id": plan.TaskID,
"title": plan.Title,
"content": plan.Content,
"created_by": plan.CreatedBy,
"created_at": plan.CreatedAt,
"updated_at": plan.UpdatedAt,
}
if err := s.eventBus.Publish(ctx, eventType, bus.NewEvent(eventType, "plan-service", payload)); err != nil {
s.logger.Error("failed to publish task plan event", zap.String("event_type", eventType), zap.Error(err))
}
}
@@ -266,7 +266,7 @@ func (r *Repository) getDevTemplate(now time.Time) *models.WorkflowTemplate {
TaskState: "IN_PROGRESS",
AutoStartAgent: true,
PlanMode: true,
PromptPrefix: "[PLANNING PHASE]\nAnalyze this task and create a detailed implementation plan.\nDo NOT make any code changes yet - only analyze and plan.\n\nBefore creating the plan, ask the user clarifying questions if anything is unclear or ambiguous about the requirements. Use the ask_user_question_kandev tool to get answers before proceeding.\n\nCreate a plan that includes:\n1. Understanding of the requirements\n2. Files that need to be modified or created\n3. Step-by-step implementation approach\n4. Potential risks or considerations\n\nIMPORTANT: Save your plan to ONLY this file: `.kandev/plans/{task_id}.md`\nDo not create any other files during this phase - only the plan file above.",
PromptPrefix: "[PLANNING PHASE]\nAnalyze this task and create a detailed implementation plan.\nDo NOT make any code changes yet - only analyze and plan.\n\nBefore creating the plan, ask the user clarifying questions if anything is unclear or ambiguous about the requirements. Use the ask_user_question_kandev tool to get answers before proceeding.\n\nCreate a plan that includes:\n1. Understanding of the requirements\n2. Files that need to be modified or created\n3. Step-by-step implementation approach\n4. Potential risks or considerations\n\nIMPORTANT: Save your plan using the create_task_plan_kandev MCP tool with the task_id provided in the session context.\nAfter saving the plan, STOP and wait for user review. The user will review your plan in the UI and may edit it.\nDo not create any other files during this phase - only use the MCP tool to save the plan.",
OnCompleteStepID: "review-plan",
AllowManualMove: true,
},
@@ -290,7 +290,7 @@ func (r *Repository) getDevTemplate(now time.Time) *models.WorkflowTemplate {
Color: "bg-blue-500",
TaskState: "IN_PROGRESS",
AutoStartAgent: true,
PromptPrefix: "[IMPLEMENTATION PHASE]\nRead the plan from `.kandev/plans/{task_id}.md` and implement the task according to the plan.\nFollow the plan step by step.",
PromptPrefix: "[IMPLEMENTATION PHASE]\nBefore starting implementation, retrieve the task plan using get_task_plan_kandev with the task_id from the session context.\nReview the plan carefully, including any edits the user may have made.\nAcknowledge the plan and any user modifications before proceeding.\n\nThen implement the task following the plan step-by-step.\nYou can update the plan during implementation using update_task_plan_kandev if needed.",
OnCompleteStepID: "review-code",
AllowManualMove: true,
},
@@ -349,7 +349,7 @@ func (r *Repository) getArchitectureTemplate(now time.Time) *models.WorkflowTemp
TaskState: "IN_PROGRESS",
AutoStartAgent: true,
PlanMode: true,
PromptPrefix: "[ARCHITECTURE PHASE]\nAnalyze and design the architecture for this task.\n\nBefore creating the design, ask the user clarifying questions if anything is unclear or ambiguous about the requirements. Use the ask_user_question_kandev tool to get answers before proceeding.\n\nIMPORTANT: Document your design in ONLY this file: `.kandev/designs/{task_id}.md`\nDo not create any other files during this phase - only the design file above.",
PromptPrefix: "[ARCHITECTURE PHASE]\nAnalyze and design the architecture for this task.\n\nBefore creating the design, ask the user clarifying questions if anything is unclear or ambiguous about the requirements. Use the ask_user_question_kandev tool to get answers before proceeding.\n\nIMPORTANT: Save your design using the create_task_plan_kandev MCP tool with the task_id provided in the session context.\nAfter saving the plan, STOP and wait for user review. The user will review your design in the UI and may edit it.\nDo not create any other files during this phase - only use the MCP tool to save the plan.",
OnCompleteStepID: "review",
AllowManualMove: true,
},
+11
View File
@@ -55,6 +55,10 @@ const (
ActionTaskDelete = "task.delete"
ActionTaskMove = "task.move"
ActionTaskState = "task.state"
ActionTaskPlanCreate = "task.plan.create"
ActionTaskPlanGet = "task.plan.get"
ActionTaskPlanUpdate = "task.plan.update"
ActionTaskPlanDelete = "task.plan.delete"
ActionTaskSessionList = "task.session.list"
ActionTaskSessionResume = "task.session.resume"
@@ -119,6 +123,9 @@ const (
ActionTaskUpdated = "task.updated"
ActionTaskDeleted = "task.deleted"
ActionTaskStateChanged = "task.state_changed"
ActionTaskPlanCreated = "task.plan.created"
ActionTaskPlanUpdated = "task.plan.updated"
ActionTaskPlanDeleted = "task.plan.deleted"
ActionAgentUpdated = "agent.updated"
ActionAgentAvailableUpdated = "agent.available.updated"
ActionWorkspaceCreated = "workspace.created"
@@ -207,6 +214,10 @@ const (
ActionMCPCreateTask = "mcp.create_task"
ActionMCPUpdateTask = "mcp.update_task"
ActionMCPAskUserQuestion = "mcp.ask_user_question"
ActionMCPCreateTaskPlan = "mcp.create_task_plan"
ActionMCPGetTaskPlan = "mcp.get_task_plan"
ActionMCPUpdateTaskPlan = "mcp.update_task_plan"
ActionMCPDeleteTaskPlan = "mcp.delete_task_plan"
)
// Error codes
+979 -2
View File
File diff suppressed because it is too large Load Diff
+172
View File
@@ -440,3 +440,175 @@
.task-chat-editor .cm-content ::selection {
background: color-mix(in oklab, var(--primary) 30%, var(--background));
}
/* Milkdown Editor Styles */
.milkdown-wrapper {
height: 100%;
overflow: auto;
background: #000000; /* Black background like chat */
border-radius: 0.5rem; /* rounded-lg like chat */
}
.milkdown-wrapper:not(.dark) {
background: #ffffff; /* White background for light mode */
}
.milkdown-wrapper .milkdown {
height: 100%;
background: transparent;
}
.milkdown-wrapper .editor {
padding: 0.75rem;
min-height: 100%;
outline: none;
background: transparent;
}
.milkdown-wrapper .editor:focus {
outline: none;
}
/* Override nord theme colors to match app theme */
.milkdown-wrapper .milkdown {
--nord-background: transparent;
--nord-foreground: var(--foreground);
--nord-outline: var(--border);
--nord-primary: var(--primary);
--nord-secondary: var(--muted);
--nord-neutral: var(--muted-foreground);
--nord-solid: var(--card);
--nord-line: var(--border);
--nord-surface: var(--muted);
--nord-shadow: var(--border);
}
/* Base text styling - match chat text-xs */
.milkdown-wrapper .editor,
.milkdown-wrapper .editor * {
font-size: 0.75rem !important;
line-height: 1.625;
color: var(--foreground);
}
/* Typography - headings */
.milkdown-wrapper .editor h1,
.milkdown-wrapper .editor h2,
.milkdown-wrapper .editor h3,
.milkdown-wrapper .editor h4,
.milkdown-wrapper .editor h5,
.milkdown-wrapper .editor h6 {
font-weight: 700 !important;
color: var(--foreground) !important;
margin-top: 0.5rem !important;
margin-bottom: 0.25rem !important;
line-height: 1.3 !important;
}
.milkdown-wrapper .editor h1 { font-size: 0.875rem !important; }
.milkdown-wrapper .editor h2 { font-size: 0.8125rem !important; }
.milkdown-wrapper .editor h3 { font-size: 0.75rem !important; }
/* Paragraphs */
.milkdown-wrapper .editor p {
margin-top: 0.5rem !important;
margin-bottom: 0.5rem !important;
line-height: 1.625 !important;
font-size: 0.75rem !important;
}
/* Lists */
.milkdown-wrapper .editor ul {
list-style-type: disc !important;
padding-left: 1.25rem !important;
margin-top: 0.375rem !important;
margin-bottom: 0.375rem !important;
font-size: 0.75rem !important;
}
.milkdown-wrapper .editor ol {
list-style-type: decimal !important;
padding-left: 1.25rem !important;
margin-top: 0.375rem !important;
margin-bottom: 0.375rem !important;
font-size: 0.75rem !important;
}
.milkdown-wrapper .editor li {
margin-top: 0.125rem !important;
margin-bottom: 0.125rem !important;
font-size: 0.75rem !important;
line-height: 1.5 !important;
}
/* Inline code - matching chat InlineCode component */
.milkdown-wrapper .editor code {
background: rgb(59 130 246 / 0.2) !important;
color: rgb(96 165 250) !important;
padding: 0.125rem 0.375rem !important;
border-radius: 0.25rem !important;
font-size: 0.675rem !important;
font-family: var(--font-mono) !important;
}
/* Code blocks */
.milkdown-wrapper .editor pre {
background: #000000 !important;
padding: 0.5rem 0.75rem !important;
border-radius: 0.375rem !important;
overflow-x: auto !important;
margin-top: 0.5rem !important;
margin-bottom: 0.5rem !important;
}
.milkdown-wrapper:not(.dark) .editor pre {
background: #f5f5f5 !important;
}
.milkdown-wrapper .editor pre code {
background: transparent !important;
color: #d4d4d4 !important;
padding: 0 !important;
font-size: 0.625rem !important;
font-family: var(--font-mono) !important;
}
.milkdown-wrapper:not(.dark) .editor pre code {
color: #1e1e1e !important;
}
/* Blockquote */
.milkdown-wrapper .editor blockquote {
border-left: 3px solid var(--primary) !important;
padding-left: 0.75rem !important;
margin-left: 0 !important;
margin-top: 0.5rem !important;
margin-bottom: 0.5rem !important;
color: var(--muted-foreground) !important;
font-style: italic !important;
}
/* Links */
.milkdown-wrapper .editor a {
color: var(--primary) !important;
text-decoration: underline !important;
text-underline-offset: 2px !important;
}
/* Strong/Bold */
.milkdown-wrapper .editor strong {
font-weight: 700;
color: var(--foreground);
}
/* Emphasis */
.milkdown-wrapper .editor em {
font-style: italic;
}
/* Horizontal rule */
.milkdown-wrapper .editor hr {
border: none !important;
border-top: 1px solid var(--border) !important;
margin: 1rem 0 !important;
}
@@ -4,7 +4,6 @@ import { useRef, useCallback, useState, type KeyboardEvent as ReactKeyboardEvent
import {
IconArrowUp,
IconBrain,
IconCheck,
IconListCheck,
IconLoader2,
IconPlayerStopFilled,
@@ -43,8 +42,6 @@ type ChatInputContainerProps = {
isStarting: boolean;
isSending: boolean;
onCancel: () => void;
showApproveButton?: boolean;
onApprove?: () => void;
placeholder?: string;
pendingClarification?: Message | null;
onClarificationResolved?: () => void;
@@ -62,8 +59,6 @@ export function ChatInputContainer({
isStarting,
isSending,
onCancel,
showApproveButton,
onApprove,
placeholder,
pendingClarification,
onClarificationResolved,
@@ -235,24 +230,6 @@ export function ChatInputContainer({
<ModelSelector sessionId={sessionId} />
{/* Approve button */}
{showApproveButton && onApprove && (
<Tooltip>
<TooltipTrigger asChild>
<Button
type="button"
size="sm"
className="h-7 cursor-pointer gap-1.5 px-3 bg-emerald-500/15 text-emerald-600 dark:text-emerald-400 border border-emerald-500/30 hover:bg-emerald-500/25 hover:border-emerald-500/50"
onClick={onApprove}
>
<IconCheck className="h-3.5 w-3.5" />
<span className="font-medium">Approve</span>
</Button>
</TooltipTrigger>
<TooltipContent>Approve and move to next step</TooltipContent>
</Tooltip>
)}
{/* Submit/Stop button */}
<div className="ml-1">
<KeyboardShortcutTooltip shortcut={SHORTCUTS.SUBMIT} enabled={!isAgentBusy && !isStarting}>
@@ -0,0 +1,66 @@
'use client';
import { useEffect, useRef, useState } from 'react';
import { useTheme } from 'next-themes';
import { Editor, rootCtx, defaultValueCtx } from '@milkdown/core';
import { nord } from '@milkdown/theme-nord';
import { commonmark } from '@milkdown/preset-commonmark';
import { gfm } from '@milkdown/preset-gfm';
import { listener, listenerCtx } from '@milkdown/plugin-listener';
import { Milkdown, MilkdownProvider, useEditor } from '@milkdown/react';
type MilkdownEditorProps = {
value: string;
onChange: (value: string) => void;
placeholder?: string;
};
function MilkdownEditorInner({ value, onChange }: MilkdownEditorProps) {
const { resolvedTheme } = useTheme();
// Capture initial value at mount - editor manages its own state after that
const initialValueRef = useRef(value);
const onChangeRef = useRef(onChange);
// Keep onChange ref updated
useEffect(() => {
onChangeRef.current = onChange;
}, [onChange]);
const { loading } = useEditor((root) =>
Editor.make()
.config((ctx) => {
ctx.set(rootCtx, root);
ctx.set(defaultValueCtx, initialValueRef.current);
ctx.get(listenerCtx).markdownUpdated((_, markdown) => {
onChangeRef.current(markdown);
});
})
.config(nord)
.use(commonmark)
.use(gfm)
.use(listener)
);
return (
<div className={`milkdown-wrapper h-full relative ${resolvedTheme === 'dark' ? 'dark' : ''}`}>
<Milkdown />
{loading && (
<div className="absolute inset-0 flex items-center justify-center text-muted-foreground text-sm bg-background/80">
Loading editor...
</div>
)}
</div>
);
}
export function MarkdownEditor(props: MilkdownEditorProps) {
// Generate a unique key on each mount to force fresh Milkdown instance
const [instanceId] = useState(() => Math.random().toString(36).slice(2));
return (
<MilkdownProvider key={instanceId}>
<MilkdownEditorInner {...props} />
</MilkdownProvider>
);
}
+94 -5
View File
@@ -6,12 +6,15 @@ import { Textarea } from '@kandev/ui/textarea';
import { SessionPanel } from '@kandev/ui/pannel-session';
import { TaskChatPanel } from './task-chat-panel';
import { TaskChangesPanel } from './task-changes-panel';
import { TaskPlanPanel } from './task-plan-panel';
import { FileViewerContent } from './file-viewer-content';
import { PassthroughTerminal } from './passthrough-terminal';
import type { OpenFileTab } from '@/lib/types/backend';
import { FILE_EXTENSION_COLORS } from '@/lib/types/backend';
import { useAppStore } from '@/components/state-provider';
import { SessionTabs, type SessionTab } from '@/components/session-tabs';
import { approveSessionAction } from '@/app/actions/workspaces';
import { getWebSocketClient } from '@/lib/ws/connection';
import type { SelectedDiff } from './task-layout';
@@ -35,6 +38,10 @@ export const TaskCenterPanel = memo(function TaskCenterPanel({
const activeSession = useAppStore((state) =>
activeSessionId ? state.taskSessions.items[activeSessionId] ?? null : null
);
const setTaskSession = useAppStore((state) => state.setTaskSession);
// Check if agent is currently working
const isAgentWorking = activeSession?.state === 'STARTING' || activeSession?.state === 'RUNNING';
// Check if session is in passthrough mode by looking at the profile snapshot
const isPassthroughMode = useMemo(() => {
@@ -43,11 +50,77 @@ export const TaskCenterPanel = memo(function TaskCenterPanel({
const snapshot = activeSession.agent_profile_snapshot as any;
return snapshot?.cli_passthrough === true;
}, [activeSession?.agent_profile_snapshot]);
// Check if we should show the approve button
// Show when session has a review_status that is not approved (meaning it's in a review step)
// Also hide while agent is working to prevent premature approval
const showApproveButton =
activeSession?.review_status != null && activeSession.review_status !== 'approved' && !isAgentWorking;
// Approve handler - moves session to next workflow step
const handleApprove = useCallback(async () => {
if (!activeSessionId || !activeTaskId) return;
try {
const response = await approveSessionAction(activeSessionId);
// Update the session in the store so the review panel closes
if (response?.session) {
setTaskSession(response.session);
}
// Check if the new step has auto_start_agent enabled
if (response?.workflow_step?.auto_start_agent) {
const client = getWebSocketClient();
if (client) {
client.send({
type: 'request',
action: 'orchestrator.start',
payload: {
task_id: activeTaskId,
session_id: activeSessionId,
workflow_step_id: response.workflow_step.id,
},
});
}
}
} catch (error) {
console.error('Failed to approve session:', error);
}
}, [activeSessionId, activeTaskId, setTaskSession]);
const [leftTab, setLeftTab] = useState('chat');
const [selectedDiff, setSelectedDiff] = useState<SelectedDiff | null>(null);
const [notes, setNotes] = useState('');
const [openFileTabs, setOpenFileTabs] = useState<OpenFileTab[]>([]);
// Track plan updates for notification dot
const plan = useAppStore((state) =>
activeTaskId ? state.taskPlans.byTaskId[activeTaskId] : null
);
// Track the last plan update timestamp the user has seen (when they viewed the Plan tab)
// Key is taskId to handle task switching
const [lastSeenPlanUpdateByTask, setLastSeenPlanUpdateByTask] = useState<Record<string, string | null>>({});
// Derive notification state: show dot if plan was updated by agent and we haven't seen it
const hasUnseenPlanUpdate = useMemo(() => {
if (!activeTaskId || !plan || leftTab === 'plan') return false;
if (plan.created_by !== 'agent') return false;
const lastSeen = lastSeenPlanUpdateByTask[activeTaskId];
return plan.updated_at !== lastSeen;
}, [activeTaskId, plan, leftTab, lastSeenPlanUpdateByTask]);
// Handle tab change - mark plan as seen when switching to plan tab
const handleTabChange = useCallback((tab: string) => {
// If switching to plan tab, mark current plan as seen
if (tab === 'plan' && activeTaskId && plan?.updated_at) {
setLastSeenPlanUpdateByTask(prev => ({
...prev,
[activeTaskId]: plan.updated_at
}));
}
setLeftTab(tab);
}, [activeTaskId, plan]);
// Handle external diff selection
useEffect(() => {
if (externalSelectedDiff) {
@@ -83,12 +156,19 @@ export const TaskCenterPanel = memo(function TaskCenterPanel({
setOpenFileTabs((prev) => prev.filter((t) => t.path !== path));
// If closing the active tab, switch to chat
if (leftTab === `file:${path}`) {
setLeftTab('chat');
handleTabChange('chat');
}
}, [leftTab]);
}, [leftTab, handleTabChange]);
const tabs: SessionTab[] = useMemo(() => {
const staticTabs: SessionTab[] = [
{
id: 'plan',
label: 'Plan',
icon: hasUnseenPlanUpdate ? (
<span className="h-2 w-2 rounded-full bg-primary animate-pulse" />
) : undefined,
},
{ id: 'notes', label: 'Notes' },
{ id: 'changes', label: 'All changes' },
{ id: 'chat', label: 'Chat' },
@@ -111,18 +191,27 @@ export const TaskCenterPanel = memo(function TaskCenterPanel({
});
return [...staticTabs, ...fileTabs];
}, [openFileTabs, handleCloseFileTab]);
}, [openFileTabs, handleCloseFileTab, hasUnseenPlanUpdate]);
return (
<SessionPanel borderSide="right" margin="right">
<SessionTabs
tabs={tabs}
activeTab={leftTab}
onTabChange={setLeftTab}
separatorAfterIndex={openFileTabs.length > 0 ? 2 : undefined}
onTabChange={handleTabChange}
separatorAfterIndex={openFileTabs.length > 0 ? 3 : undefined}
className="flex-1 min-h-0 flex flex-col gap-2"
>
<TabsContent value="plan" className="flex-1 min-h-0" forceMount style={{ display: leftTab === 'plan' ? undefined : 'none' }}>
<TaskPlanPanel
taskId={activeTaskId}
showApproveButton={showApproveButton}
onApprove={handleApprove}
visible={leftTab === 'plan'}
/>
</TabsContent>
<TabsContent value="notes" className="flex-1 min-h-0">
<Textarea
value={notes}
@@ -2,7 +2,6 @@
import { useCallback, useEffect, useRef, useState } from 'react';
import { getWebSocketClient } from '@/lib/ws/connection';
import { useAppStore } from '@/components/state-provider';
import { useSessionMessages } from '@/hooks/domains/session/use-session-messages';
import { useSettingsData } from '@/hooks/domains/settings/use-settings-data';
import { useSessionState } from '@/hooks/domains/session/use-session-state';
@@ -12,7 +11,6 @@ import { useMessageHandler } from '@/hooks/use-message-handler';
import { TodoSummary } from '@/components/task/chat/todo-summary';
import { VirtualizedMessageList } from '@/components/task/chat/virtualized-message-list';
import { ChatInputContainer } from '@/components/task/chat/chat-input-container';
import { approveSessionAction } from '@/app/actions/workspaces';
type TaskChatPanelProps = {
onSend?: (message: string) => void;
@@ -94,50 +92,6 @@ export function TaskChatPanel({
}
}, [resolvedSessionId]);
// Get store action for updating session
const setTaskSession = useAppStore((state) => state.setTaskSession);
// Review panel handlers
const handleApprove = useCallback(async () => {
if (!resolvedSessionId || !taskId) return;
try {
const response = await approveSessionAction(resolvedSessionId);
// Update the session in the store so the review panel closes
if (response?.session) {
setTaskSession(response.session);
}
// Check if the new step has auto_start_agent enabled
// Use fire-and-forget (send) instead of request since resuming session + sending prompt
// can take a long time. Session state updates will come via WebSocket events anyway.
if (response?.workflow_step?.auto_start_agent) {
const client = getWebSocketClient();
if (client) {
client.send({
type: 'request',
action: 'orchestrator.start',
payload: {
task_id: taskId,
session_id: resolvedSessionId,
workflow_step_id: response.workflow_step.id,
},
});
}
}
} catch (error) {
console.error('Failed to approve session:', error);
}
}, [resolvedSessionId, taskId, setTaskSession]);
// Check if we should show the approve button
// Show when session has a review_status that is not approved (meaning it's in a review step)
// Also hide while agent is working to prevent premature approval
const showApproveButton =
session?.review_status != null && session.review_status !== 'approved' && !isWorking;
const handleSubmit = useCallback(async (message: string) => {
if (isSending) return;
setIsSending(true);
@@ -184,8 +138,6 @@ export function TaskChatPanel({
isStarting={isStarting}
isSending={isSending}
onCancel={handleCancelTurn}
showApproveButton={showApproveButton}
onApprove={handleApprove}
placeholder={
agentMessageCount > 0
? 'Continue working on this task...'
@@ -0,0 +1,75 @@
'use client';
import { memo } from 'react';
import {
AlertDialog,
AlertDialogAction,
AlertDialogCancel,
AlertDialogContent,
AlertDialogDescription,
AlertDialogFooter,
AlertDialogHeader,
AlertDialogTitle,
} from '@kandev/ui/alert-dialog';
type TaskPlanDialogsProps = {
showDiscardDialog: boolean;
showClearDialog: boolean;
onDiscardDialogChange: (open: boolean) => void;
onClearDialogChange: (open: boolean) => void;
onDiscard: () => void;
onClear: () => void;
};
export const TaskPlanDialogs = memo(function TaskPlanDialogs({
showDiscardDialog,
showClearDialog,
onDiscardDialogChange,
onClearDialogChange,
onDiscard,
onClear,
}: TaskPlanDialogsProps) {
return (
<>
{/* Discard confirmation dialog */}
<AlertDialog open={showDiscardDialog} onOpenChange={onDiscardDialogChange}>
<AlertDialogContent>
<AlertDialogHeader>
<AlertDialogTitle>Discard changes?</AlertDialogTitle>
<AlertDialogDescription>
You have unsaved changes. Are you sure you want to discard them?
</AlertDialogDescription>
</AlertDialogHeader>
<AlertDialogFooter>
<AlertDialogCancel className="cursor-pointer">Cancel</AlertDialogCancel>
<AlertDialogAction className="cursor-pointer" onClick={onDiscard}>
Discard
</AlertDialogAction>
</AlertDialogFooter>
</AlertDialogContent>
</AlertDialog>
{/* Clear plan confirmation dialog */}
<AlertDialog open={showClearDialog} onOpenChange={onClearDialogChange}>
<AlertDialogContent>
<AlertDialogHeader>
<AlertDialogTitle>Clear plan?</AlertDialogTitle>
<AlertDialogDescription>
This will permanently delete the plan. This action cannot be undone.
</AlertDialogDescription>
</AlertDialogHeader>
<AlertDialogFooter>
<AlertDialogCancel className="cursor-pointer">Cancel</AlertDialogCancel>
<AlertDialogAction
className="cursor-pointer bg-destructive text-destructive-foreground hover:bg-destructive/90"
onClick={onClear}
>
Delete
</AlertDialogAction>
</AlertDialogFooter>
</AlertDialogContent>
</AlertDialog>
</>
);
});
@@ -0,0 +1,185 @@
'use client';
import { memo, useState, useCallback, useEffect, useRef } from 'react';
import dynamic from 'next/dynamic';
import { IconLoader2 } from '@tabler/icons-react';
import { useTaskPlan } from '@/hooks/domains/session/use-task-plan';
import { useAppStore } from '@/components/state-provider';
import { getWebSocketClient } from '@/lib/ws/connection';
import { TaskPlanToolbar } from './task-plan-toolbar';
import { TaskPlanDialogs } from './task-plan-dialogs';
// Dynamic import to avoid SSR issues with Milkdown
const MarkdownEditor = dynamic(
() => import('./markdown-editor').then((mod) => mod.MarkdownEditor),
{ ssr: false, loading: () => <div className="flex h-full items-center justify-center text-muted-foreground text-sm">Loading editor...</div> }
);
type TaskPlanPanelProps = {
taskId: string | null;
showApproveButton?: boolean;
onApprove?: () => void;
visible?: boolean;
};
export const TaskPlanPanel = memo(function TaskPlanPanel({ taskId, showApproveButton, onApprove, visible = true }: TaskPlanPanelProps) {
const { plan, isLoading, isSaving, savePlan, deletePlan } = useTaskPlan(taskId, { visible });
const activeSessionId = useAppStore((state) => state.tasks.activeSessionId);
const activeSession = useAppStore((state) =>
activeSessionId ? state.taskSessions.items[activeSessionId] ?? null : null
);
const isAgentBusy = activeSession?.state === 'STARTING' || activeSession?.state === 'RUNNING';
const [draftContent, setDraftContent] = useState('');
const [showDiscardDialog, setShowDiscardDialog] = useState(false);
const [showClearDialog, setShowClearDialog] = useState(false);
const [isReanalyzing, setIsReanalyzing] = useState(false);
// Key to force editor remount on external content changes
const [editorKey, setEditorKey] = useState(0);
// Track the last known plan content to detect external updates
const lastPlanContentRef = useRef<string | undefined>(plan?.content);
// Sync draft with plan content and force editor remount when plan changes externally
useEffect(() => {
const prevContent = lastPlanContentRef.current;
const newContent = plan?.content;
lastPlanContentRef.current = newContent;
// Only update if the plan content actually changed (external update)
if (newContent !== prevContent) {
if (newContent !== undefined) {
setDraftContent(newContent);
} else {
setDraftContent('');
}
// Force editor remount to reflect new content (Milkdown doesn't respond to prop changes)
setEditorKey(k => k + 1);
}
}, [plan?.content]);
const hasUnsavedChanges = plan ? draftContent !== plan.content : draftContent.length > 0;
const handleSave = useCallback(async () => {
await savePlan(draftContent, plan?.title);
}, [savePlan, draftContent, plan?.title]);
const handleDiscard = useCallback(() => {
setDraftContent(plan?.content || '');
setEditorKey(k => k + 1); // Force editor remount to reset content
setShowDiscardDialog(false);
}, [plan?.content]);
const handleCopy = useCallback(async () => {
if (!draftContent) return;
try {
await navigator.clipboard.writeText(draftContent);
} catch (err) {
console.error('Failed to copy to clipboard:', err);
}
}, [draftContent]);
const handleReanalyze = useCallback(async () => {
if (!taskId || !activeSessionId || isAgentBusy || isReanalyzing) return;
const client = getWebSocketClient();
if (!client) return;
setIsReanalyzing(true);
try {
await client.request(
'message.add',
{
task_id: taskId,
session_id: activeSessionId,
content: 'Please review and update the plan based on the current state of the task. Consider what has been completed and what still needs to be done.',
},
10000
);
} catch (err) {
console.error('Failed to send re-analyze request:', err);
} finally {
setIsReanalyzing(false);
}
}, [taskId, activeSessionId, isAgentBusy, isReanalyzing]);
const handleClear = useCallback(async () => {
setShowClearDialog(false);
const success = await deletePlan();
if (success) {
setDraftContent('');
setEditorKey(k => k + 1);
}
}, [deletePlan]);
// Ctrl+S to save
useEffect(() => {
const handleKeyDown = (e: KeyboardEvent) => {
if ((e.ctrlKey || e.metaKey) && e.key === 's') {
e.preventDefault();
if (hasUnsavedChanges && !isSaving) {
handleSave();
}
}
};
window.addEventListener('keydown', handleKeyDown);
return () => window.removeEventListener('keydown', handleKeyDown);
}, [hasUnsavedChanges, isSaving, handleSave]);
if (isLoading) {
return (
<div className="flex h-full items-center justify-center text-muted-foreground">
<IconLoader2 className="h-5 w-5 animate-spin mr-2" />
<span className="text-sm">Loading plan...</span>
</div>
);
}
if (!taskId) {
return (
<div className="flex h-full items-center justify-center text-muted-foreground">
<span className="text-sm">No task selected</span>
</div>
);
}
return (
<div className="flex flex-col h-full">
{/* Content - Markdown Editor */}
<div className="flex-1 min-h-0">
<MarkdownEditor
key={`${taskId}-${editorKey}`}
value={draftContent}
onChange={setDraftContent}
placeholder="Start typing your plan..."
/>
</div>
{/* Bottom toolbar */}
<TaskPlanToolbar
plan={plan}
hasUnsavedChanges={hasUnsavedChanges}
hasDraftContent={draftContent.length > 0}
isSaving={isSaving}
isAgentBusy={isAgentBusy}
isReanalyzing={isReanalyzing}
hasActiveSession={!!activeSessionId}
showApproveButton={showApproveButton}
onSave={handleSave}
onDiscard={() => setShowDiscardDialog(true)}
onCopy={handleCopy}
onReanalyze={handleReanalyze}
onClear={() => setShowClearDialog(true)}
onApprove={onApprove}
/>
{/* Confirmation dialogs */}
<TaskPlanDialogs
showDiscardDialog={showDiscardDialog}
showClearDialog={showClearDialog}
onDiscardDialogChange={setShowDiscardDialog}
onClearDialogChange={setShowClearDialog}
onDiscard={handleDiscard}
onClear={handleClear}
/>
</div>
);
});
@@ -0,0 +1,220 @@
'use client';
import { memo } from 'react';
import {
IconDeviceFloppy,
IconX,
IconLoader2,
IconRobot,
IconUser,
IconArrowRight,
IconCopy,
IconRefresh,
IconTrash,
} from '@tabler/icons-react';
import { Button } from '@kandev/ui/button';
import { Tooltip, TooltipContent, TooltipTrigger } from '@kandev/ui/tooltip';
import { cn, formatRelativeTime } from '@/lib/utils';
import type { TaskPlan } from '@/lib/types/http';
type TaskPlanToolbarProps = {
plan: TaskPlan | null;
hasUnsavedChanges: boolean;
hasDraftContent: boolean;
isSaving: boolean;
isAgentBusy: boolean;
isReanalyzing: boolean;
hasActiveSession: boolean;
showApproveButton?: boolean;
onSave: () => void;
onDiscard: () => void;
onCopy: () => void;
onReanalyze: () => void;
onClear: () => void;
onApprove?: () => void;
};
export const TaskPlanToolbar = memo(function TaskPlanToolbar({
plan,
hasUnsavedChanges,
hasDraftContent,
isSaving,
isAgentBusy,
isReanalyzing,
hasActiveSession,
showApproveButton,
onSave,
onDiscard,
onCopy,
onReanalyze,
onClear,
onApprove,
}: TaskPlanToolbarProps) {
return (
<div className="mt-2">
<div
className={cn(
'rounded-2xl border border-border bg-background shadow-sm overflow-hidden',
hasUnsavedChanges && 'border-amber-500/50 border-dashed'
)}
>
<div className="flex items-center gap-1 px-2 py-2">
{/* Left: Status info */}
<div className="flex items-center gap-1 flex-1">
{plan && (
<Tooltip>
<TooltipTrigger asChild>
<div className="flex items-center gap-1.5 px-2 py-1 rounded-md text-xs text-muted-foreground hover:bg-muted/40 cursor-default">
{plan.created_by === 'agent' ? (
<IconRobot className="h-3.5 w-3.5" />
) : (
<IconUser className="h-3.5 w-3.5" />
)}
<span className="capitalize">{plan.created_by}</span>
</div>
</TooltipTrigger>
<TooltipContent>Created by {plan.created_by}</TooltipContent>
</Tooltip>
)}
{hasUnsavedChanges ? (
<span className="text-xs text-amber-500 px-2">
Unsaved changes <span className="text-amber-500/60">· ⌘S to save</span>
</span>
) : plan?.updated_at ? (
<span className="text-xs text-muted-foreground/60 px-2">
Saved {formatRelativeTime(plan.updated_at)}
</span>
) : null}
</div>
{/* Right: Actions */}
<div className="flex items-center gap-0.5 shrink-0">
{hasUnsavedChanges && (
<>
<Tooltip>
<TooltipTrigger asChild>
<Button
type="button"
variant="ghost"
size="sm"
className="h-7 gap-1.5 px-2 cursor-pointer hover:bg-muted/40 text-muted-foreground hover:text-destructive"
onClick={onDiscard}
disabled={isSaving}
>
<IconX className="h-4 w-4" />
</Button>
</TooltipTrigger>
<TooltipContent>Discard changes</TooltipContent>
</Tooltip>
<Tooltip>
<TooltipTrigger asChild>
<Button
type="button"
variant="ghost"
size="sm"
className="h-7 gap-1.5 px-2 cursor-pointer hover:bg-muted/40"
onClick={onSave}
disabled={isSaving}
>
{isSaving ? (
<IconLoader2 className="h-4 w-4 animate-spin" />
) : (
<IconDeviceFloppy className="h-4 w-4" />
)}
</Button>
</TooltipTrigger>
<TooltipContent>Save plan</TooltipContent>
</Tooltip>
</>
)}
{/* Separator before utility actions */}
{(hasUnsavedChanges || plan || hasDraftContent) && (
<div className="h-4 w-px bg-border mx-1" />
)}
{/* Copy to clipboard */}
<Tooltip>
<TooltipTrigger asChild>
<Button
type="button"
variant="ghost"
size="sm"
className="h-7 gap-1.5 px-2 cursor-pointer hover:bg-muted/40 text-muted-foreground"
onClick={onCopy}
disabled={!hasDraftContent}
>
<IconCopy className="h-4 w-4" />
</Button>
</TooltipTrigger>
<TooltipContent>Copy to clipboard</TooltipContent>
</Tooltip>
{/* Re-analyze with agent */}
<Tooltip>
<TooltipTrigger asChild>
<Button
type="button"
variant="ghost"
size="sm"
className="h-7 gap-1.5 px-2 cursor-pointer hover:bg-muted/40 text-muted-foreground"
onClick={onReanalyze}
disabled={isAgentBusy || !hasActiveSession || isReanalyzing}
>
{isReanalyzing ? (
<IconLoader2 className="h-4 w-4 animate-spin" />
) : (
<IconRefresh className="h-4 w-4" />
)}
</Button>
</TooltipTrigger>
<TooltipContent>Ask agent to review plan</TooltipContent>
</Tooltip>
{/* Clear/Delete plan */}
<Tooltip>
<TooltipTrigger asChild>
<Button
type="button"
variant="ghost"
size="sm"
className="h-7 gap-1.5 px-2 cursor-pointer hover:bg-muted/40 text-muted-foreground hover:text-destructive"
onClick={onClear}
disabled={!plan && !hasDraftContent}
>
<IconTrash className="h-4 w-4" />
</Button>
</TooltipTrigger>
<TooltipContent>Clear plan</TooltipContent>
</Tooltip>
{/* Separator before approve button */}
{showApproveButton && onApprove && (
<div className="h-4 w-px bg-border mx-1" />
)}
{/* Approve button - styled like submit button */}
{showApproveButton && onApprove && (
<div className="ml-1">
<Tooltip>
<TooltipTrigger asChild>
<Button
type="button"
size="icon"
className="h-7 w-7 rounded-full cursor-pointer bg-emerald-500 hover:bg-emerald-600 text-white"
onClick={onApprove}
>
<IconArrowRight className="h-4 w-4" />
</Button>
</TooltipTrigger>
<TooltipContent>Approve plan and continue</TooltipContent>
</Tooltip>
</div>
)}
</div>
</div>
</div>
</div>
);
});
@@ -0,0 +1,131 @@
import { useEffect, useCallback, useState, useRef } from 'react';
import { useAppStore } from '@/components/state-provider';
import {
getTaskPlan,
createTaskPlan,
updateTaskPlan,
deleteTaskPlan,
} from '@/lib/api/domains/plan-api';
import type { TaskPlan } from '@/lib/types/http';
/**
* Hook to fetch and manage the plan for a task.
* Plans are task-scoped (one plan per task, shared across all sessions).
* @param taskId - The task ID to fetch the plan for
* @param options.visible - When true, refetches the plan (use for tab visibility)
*/
export function useTaskPlan(taskId: string | null, options?: { visible?: boolean }) {
const { visible = true } = options ?? {};
const prevVisibleRef = useRef(visible);
const plan = useAppStore((state) =>
taskId ? state.taskPlans.byTaskId[taskId] : undefined
);
const isLoading = useAppStore((state) =>
taskId ? state.taskPlans.loadingByTaskId[taskId] ?? false : false
);
const isLoaded = useAppStore((state) =>
taskId ? state.taskPlans.loadedByTaskId[taskId] ?? false : false
);
const isSaving = useAppStore((state) =>
taskId ? state.taskPlans.savingByTaskId[taskId] ?? false : false
);
const setTaskPlan = useAppStore((state) => state.setTaskPlan);
const setTaskPlanLoading = useAppStore((state) => state.setTaskPlanLoading);
const setTaskPlanSaving = useAppStore((state) => state.setTaskPlanSaving);
const connectionStatus = useAppStore((state) => state.connection.status);
const [error, setError] = useState<string | null>(null);
const fetchPlan = useCallback(async () => {
if (!taskId) return;
setTaskPlanLoading(taskId, true);
setError(null);
try {
const fetchedPlan = await getTaskPlan(taskId);
setTaskPlan(taskId, fetchedPlan);
} catch (err) {
console.error('Failed to fetch task plan:', err);
setError(err instanceof Error ? err.message : 'Failed to fetch plan');
} finally {
setTaskPlanLoading(taskId, false);
}
}, [taskId, setTaskPlan, setTaskPlanLoading]);
// Fetch plan on mount or when taskId changes
useEffect(() => {
if (connectionStatus !== 'connected') return;
if (taskId && !isLoaded && !isLoading) {
fetchPlan();
}
}, [taskId, isLoaded, isLoading, fetchPlan, connectionStatus]);
// Refetch when becoming visible (e.g., tab switch)
useEffect(() => {
const wasHidden = !prevVisibleRef.current;
const isNowVisible = visible;
prevVisibleRef.current = visible;
// Only refetch when transitioning from hidden to visible
if (wasHidden && isNowVisible && connectionStatus === 'connected' && taskId) {
fetchPlan();
}
}, [visible, connectionStatus, taskId, fetchPlan]);
const savePlan = useCallback(
async (content: string, title?: string): Promise<TaskPlan | null> => {
if (!taskId) return null;
setTaskPlanSaving(taskId, true);
setError(null);
try {
let savedPlan: TaskPlan;
if (plan) {
// Update existing plan
savedPlan = await updateTaskPlan(taskId, content, title);
} else {
// Create new plan
savedPlan = await createTaskPlan(taskId, content, title);
}
setTaskPlan(taskId, savedPlan);
return savedPlan;
} catch (err) {
console.error('Failed to save task plan:', err);
setError(err instanceof Error ? err.message : 'Failed to save plan');
return null;
} finally {
setTaskPlanSaving(taskId, false);
}
},
[taskId, plan, setTaskPlan, setTaskPlanSaving]
);
const removePlan = useCallback(async (): Promise<boolean> => {
if (!taskId) return false;
setTaskPlanSaving(taskId, true);
setError(null);
try {
await deleteTaskPlan(taskId);
setTaskPlan(taskId, null);
return true;
} catch (err) {
console.error('Failed to delete task plan:', err);
setError(err instanceof Error ? err.message : 'Failed to delete plan');
return false;
} finally {
setTaskPlanSaving(taskId, false);
}
}, [taskId, setTaskPlan, setTaskPlanSaving]);
return {
plan: plan ?? null,
isLoading,
isSaving,
error,
savePlan,
deletePlan: removePlan,
refetch: fetchPlan,
};
}
+81
View File
@@ -0,0 +1,81 @@
import { getWebSocketClient } from '@/lib/ws/connection';
import type { TaskPlan } from '@/lib/types/http';
/**
* Get the task plan for a specific task.
* Returns null if no plan exists.
*/
export async function getTaskPlan(taskId: string): Promise<TaskPlan | null> {
const client = getWebSocketClient();
if (!client) {
throw new Error('WebSocket client not available');
}
const response = await client.request('task.plan.get', { task_id: taskId });
if (!response || Object.keys(response).length === 0) {
return null;
}
return response as TaskPlan;
}
/**
* Create a new task plan.
*/
export async function createTaskPlan(
taskId: string,
content: string,
title?: string
): Promise<TaskPlan> {
const client = getWebSocketClient();
if (!client) {
throw new Error('WebSocket client not available');
}
const response = await client.request('task.plan.create', {
task_id: taskId,
title: title || 'Plan',
content,
created_by: 'user',
});
return response as TaskPlan;
}
/**
* Update an existing task plan.
*/
export async function updateTaskPlan(
taskId: string,
content: string,
title?: string
): Promise<TaskPlan> {
const client = getWebSocketClient();
if (!client) {
throw new Error('WebSocket client not available');
}
const payload: Record<string, string> = {
task_id: taskId,
content,
created_by: 'user',
};
if (title !== undefined) {
payload.title = title;
}
const response = await client.request('task.plan.update', payload);
return response as TaskPlan;
}
/**
* Delete a task plan.
*/
export async function deleteTaskPlan(taskId: string): Promise<void> {
const client = getWebSocketClient();
if (!client) {
throw new Error('WebSocket client not available');
}
await client.request('task.plan.delete', { task_id: taskId });
}
+1
View File
@@ -54,6 +54,7 @@ export type {
SessionWorktreesState,
PendingModelState,
ActiveModelState,
TaskPlansState,
} from './session/types';
export type {
TerminalState,
@@ -14,6 +14,7 @@ export const defaultSessionState: SessionSliceState = {
sessionWorktreesBySessionId: { itemsBySessionId: {} },
pendingModel: { bySessionId: {} },
activeModel: { bySessionId: {} },
taskPlans: { byTaskId: {}, loadingByTaskId: {}, loadedByTaskId: {}, savingByTaskId: {} },
};
export const createSessionSlice: StateCreator<
@@ -207,4 +208,25 @@ export const createSessionSlice: StateCreator<
set((draft) => {
draft.activeModel.bySessionId[sessionId] = modelId;
}),
setTaskPlan: (taskId, plan) =>
set((draft) => {
draft.taskPlans.byTaskId[taskId] = plan;
draft.taskPlans.loadingByTaskId[taskId] = false;
draft.taskPlans.loadedByTaskId[taskId] = true;
}),
setTaskPlanLoading: (taskId, loading) =>
set((draft) => {
draft.taskPlans.loadingByTaskId[taskId] = loading;
}),
setTaskPlanSaving: (taskId, saving) =>
set((draft) => {
draft.taskPlans.savingByTaskId[taskId] = saving;
}),
clearTaskPlan: (taskId) =>
set((draft) => {
delete draft.taskPlans.byTaskId[taskId];
delete draft.taskPlans.loadingByTaskId[taskId];
delete draft.taskPlans.loadedByTaskId[taskId];
delete draft.taskPlans.savingByTaskId[taskId];
}),
});
+14 -1
View File
@@ -1,4 +1,4 @@
import type { Message, TaskSession, Turn } from '@/lib/types/http';
import type { Message, TaskSession, Turn, TaskPlan } from '@/lib/types/http';
export type MessagesState = {
bySession: Record<string, Message[]>;
@@ -62,6 +62,13 @@ export type ActiveModelState = {
bySessionId: Record<string, string>;
};
export type TaskPlansState = {
byTaskId: Record<string, TaskPlan | null>;
loadingByTaskId: Record<string, boolean>;
loadedByTaskId: Record<string, boolean>;
savingByTaskId: Record<string, boolean>;
};
export type SessionSliceState = {
messages: MessagesState;
turns: TurnsState;
@@ -72,6 +79,7 @@ export type SessionSliceState = {
sessionWorktreesBySessionId: SessionWorktreesState;
pendingModel: PendingModelState;
activeModel: ActiveModelState;
taskPlans: TaskPlansState;
};
export type SessionSliceActions = {
@@ -104,6 +112,11 @@ export type SessionSliceActions = {
setPendingModel: (sessionId: string, modelId: string) => void;
clearPendingModel: (sessionId: string) => void;
setActiveModel: (sessionId: string, modelId: string) => void;
// Task plan actions
setTaskPlan: (taskId: string, plan: TaskPlan | null) => void;
setTaskPlanLoading: (taskId: string, loading: boolean) => void;
setTaskPlanSaving: (taskId: string, saving: boolean) => void;
clearTaskPlan: (taskId: string) => void;
};
export type SessionSlice = SessionSliceState & SessionSliceActions;
+8
View File
@@ -126,6 +126,7 @@ export type AppState = {
sessionWorktreesBySessionId: typeof defaultSessionState['sessionWorktreesBySessionId'];
pendingModel: typeof defaultSessionState['pendingModel'];
activeModel: typeof defaultSessionState['activeModel'];
taskPlans: typeof defaultSessionState['taskPlans'];
// Session Runtime slice
terminal: typeof defaultSessionRuntimeState['terminal'];
@@ -231,6 +232,11 @@ export type AppState = {
setPendingModel: (sessionId: string, modelId: string) => void;
clearPendingModel: (sessionId: string) => void;
setActiveModel: (sessionId: string, modelId: string) => void;
// Task plan actions
setTaskPlan: (taskId: string, plan: import('@/lib/types/http').TaskPlan | null) => void;
setTaskPlanLoading: (taskId: string, loading: boolean) => void;
setTaskPlanSaving: (taskId: string, saving: boolean) => void;
clearTaskPlan: (taskId: string) => void;
};
export type AppStore = ReturnType<typeof createAppStore>;
@@ -262,6 +268,7 @@ const defaultState = {
sessionWorktreesBySessionId: defaultSessionState.sessionWorktreesBySessionId,
pendingModel: defaultSessionState.pendingModel,
activeModel: defaultSessionState.activeModel,
taskPlans: defaultSessionState.taskPlans,
terminal: defaultSessionRuntimeState.terminal,
shell: defaultSessionRuntimeState.shell,
processes: defaultSessionRuntimeState.processes,
@@ -309,6 +316,7 @@ function mergeInitialState(initialState?: Partial<AppState>): typeof defaultStat
sessionWorktreesBySessionId: { ...defaultState.sessionWorktreesBySessionId, ...initialState.sessionWorktreesBySessionId },
pendingModel: { ...defaultState.pendingModel, ...initialState.pendingModel },
activeModel: { ...defaultState.activeModel, ...initialState.activeModel },
taskPlans: { ...defaultState.taskPlans, ...initialState.taskPlans },
terminal: { ...defaultState.terminal, ...initialState.terminal },
shell: { ...defaultState.shell, ...initialState.shell },
processes: { ...defaultState.processes, ...initialState.processes },
+16
View File
@@ -4,6 +4,9 @@ export type BackendMessageType =
| 'task.updated'
| 'task.deleted'
| 'task.state_changed'
| 'task.plan.created'
| 'task.plan.updated'
| 'task.plan.deleted'
| 'agent.updated'
| 'agent.available.updated'
| 'terminal.output'
@@ -292,12 +295,25 @@ export type TurnEventPayload = {
updated_at: string;
};
export type TaskPlanEventPayload = {
id: string;
task_id: string;
title: string;
content: string;
created_by: 'agent' | 'user';
created_at: string;
updated_at: string;
};
export type BackendMessageMap = {
'kanban.update': BackendMessage<'kanban.update', KanbanUpdatePayload>;
'task.created': BackendMessage<'task.created', TaskEventPayload>;
'task.updated': BackendMessage<'task.updated', TaskEventPayload>;
'task.deleted': BackendMessage<'task.deleted', TaskEventPayload>;
'task.state_changed': BackendMessage<'task.state_changed', TaskEventPayload>;
'task.plan.created': BackendMessage<'task.plan.created', TaskPlanEventPayload>;
'task.plan.updated': BackendMessage<'task.plan.updated', TaskPlanEventPayload>;
'task.plan.deleted': BackendMessage<'task.plan.deleted', TaskPlanEventPayload>;
'agent.updated': BackendMessage<'agent.updated', AgentUpdatePayload>;
'agent.available.updated': BackendMessage<'agent.available.updated', AgentAvailableUpdatedPayload>;
'terminal.output': BackendMessage<'terminal.output', TerminalOutputPayload>;
+15
View File
@@ -666,3 +666,18 @@ export type ClarificationResponse = {
rejected?: boolean;
reject_reason?: string;
};
// Task Plan types (for session artifacts)
export type TaskPlan = {
id: string;
task_id: string;
title: string;
content: string;
created_by: 'agent' | 'user';
created_at: string;
updated_at: string;
};
export type TaskPlanResponse = {
plan: TaskPlan | null;
};
+23
View File
@@ -142,3 +142,26 @@ export function selectPreferredBranch(
export const DEFAULT_LOCAL_ENVIRONMENT_KIND = 'local_pc';
export const DEFAULT_LOCAL_EXECUTOR_TYPE = 'local_pc';
/**
* Format a date string as a human-readable relative time (e.g., "2m ago", "1h ago", "yesterday").
* @param dateString - ISO date string
* @returns Formatted relative time string
*/
export function formatRelativeTime(dateString: string): string {
const date = new Date(dateString);
const now = new Date();
const diffMs = now.getTime() - date.getTime();
const diffSec = Math.floor(diffMs / 1000);
const diffMin = Math.floor(diffSec / 60);
const diffHour = Math.floor(diffMin / 60);
const diffDay = Math.floor(diffHour / 24);
if (diffSec < 10) return 'just now';
if (diffSec < 60) return `${diffSec}s ago`;
if (diffMin < 60) return `${diffMin}m ago`;
if (diffHour < 24) return `${diffHour}h ago`;
if (diffDay === 1) return 'yesterday';
if (diffDay < 7) return `${diffDay}d ago`;
return date.toLocaleDateString();
}
+31
View File
@@ -0,0 +1,31 @@
import type { StoreApi } from 'zustand';
import type { AppState } from '@/lib/state/store';
import type { BackendMessageMap } from '@/lib/types/backend';
import type { WsHandlers } from '@/lib/ws/handlers/types';
type PlanMessage = BackendMessageMap['task.plan.created'] | BackendMessageMap['task.plan.updated'];
function handlePlanUpsert(store: StoreApi<AppState>, message: PlanMessage) {
const { task_id, id, title, content, created_by, created_at, updated_at } = message.payload;
store.getState().setTaskPlan(task_id, {
id,
task_id,
title,
content,
created_by,
created_at,
updated_at,
});
}
export function registerTaskPlansHandlers(store: StoreApi<AppState>): WsHandlers {
return {
'task.plan.created': (message) => handlePlanUpsert(store, message),
'task.plan.updated': (message) => handlePlanUpsert(store, message),
'task.plan.deleted': (message) => {
const { task_id } = message.payload;
store.getState().setTaskPlan(task_id, null);
},
};
}
+2
View File
@@ -13,6 +13,7 @@ import { registerGitStatusHandlers } from '@/lib/ws/handlers/git-status';
import { registerKanbanHandlers } from '@/lib/ws/handlers/kanban';
import { registerSystemEventsHandlers } from '@/lib/ws/handlers/system-events';
import { registerTasksHandlers } from '@/lib/ws/handlers/tasks';
import { registerTaskPlansHandlers } from '@/lib/ws/handlers/task-plans';
import { registerTerminalsHandlers } from '@/lib/ws/handlers/terminals';
import { registerTurnsHandlers } from '@/lib/ws/handlers/turns';
import { registerUsersHandlers } from '@/lib/ws/handlers/users';
@@ -22,6 +23,7 @@ export function registerWsHandlers(store: StoreApi<AppState>) {
return {
...registerKanbanHandlers(store),
...registerTasksHandlers(store),
...registerTaskPlansHandlers(store),
...registerBoardsHandlers(store),
...registerWorkspacesHandlers(store),
+9
View File
@@ -35,6 +35,15 @@
"@kandev/types": "workspace:*",
"@kandev/ui": "workspace:*",
"@lezer/highlight": "^1.2.3",
"@milkdown/core": "^7.18.0",
"@milkdown/ctx": "^7.18.0",
"@milkdown/plugin-listener": "^7.18.0",
"@milkdown/preset-commonmark": "^7.18.0",
"@milkdown/preset-gfm": "^7.18.0",
"@milkdown/prose": "^7.18.0",
"@milkdown/react": "^7.18.0",
"@milkdown/theme-nord": "^7.18.0",
"@milkdown/utils": "^7.18.0",
"@tabler/icons-react": "^3.36.1",
"@tanstack/react-virtual": "^3.13.18",
"@uiw/codemirror-theme-vscode": "^4.25.4",