UI yenileme, setup kaldırma, MCP düzenleme

Author: okurucan

app.go

@@ -175,37 +175,38 @@ func buildArgs(opts ProcessOptions) []string {
 		"--verbose",
 	}
 
+	isResume := opts.SessionID != ""
+
 	// Resume an existing Claude conversation
-	if opts.SessionID != "" {
+	if isResume {
 		args = append(args, "--resume", opts.SessionID)
 	}
 
-	if opts.Model != "" {
-		args = append(args, "--model", opts.Model)
-	}
+	// Only set model and system prompt for new sessions.
+	// Resumed sessions already have these values from the original session;
+	// passing them again can cause CLI errors or unexpected behavior.
+	if !isResume {
+		if opts.Model != "" {
+			args = append(args, "--model", opts.Model)
+		}
 
-	if opts.SystemPrompt != "" {
-		args = append(args, "--system-prompt", opts.SystemPrompt)
-	}
+		if opts.SystemPrompt != "" {
+			args = append(args, "--system-prompt", opts.SystemPrompt)
+		}
 
-	if len(opts.AllowedTools) > 0 {
-		for _, tool := range opts.AllowedTools {
-			args = append(args, "--allowedTools", tool)
+		if len(opts.AllowedTools) > 0 {
+			for _, tool := range opts.AllowedTools {
+				args = append(args, "--allowedTools", tool)
+			}
 		}
 	}
 
-	switch opts.Permissions {
-	case "bypassPermissions":
-		args = append(args, "--dangerously-skip-permissions")
-	case "acceptEdits":
-		args = append(args, "--permission-mode", "acceptEdits")
-	case "default":
-		// use default permission mode
-	case "":
-		args = append(args, "--dangerously-skip-permissions")
-	default:
-		args = append(args, "--permission-mode", opts.Permissions)
-	}
+	// In -p (print/non-interactive) mode, stdin is closed so interactive
+	// permission approval is impossible. Always use --dangerously-skip-permissions
+	// to ensure all tools (Bash, Read, Write, Edit, etc.) can execute.
+	// Without this, modes like "acceptEdits" would silently reject Bash/Read
+	// calls since there's no stdin to approve them.
+	args = append(args, "--dangerously-skip-permissions")
 
 	// Prompt is the final positional argument.
 	// Use "--" to end option parsing so the prompt text isn't misread as a flag.

backend/claude/process.go

@@ -3,12 +3,13 @@ package models
 type TaskStatus string
 
 const (
-	TaskStatusPending   TaskStatus = "pending"
-	TaskStatusQueued    TaskStatus = "queued"
-	TaskStatusRunning   TaskStatus = "running"
-	TaskStatusCompleted TaskStatus = "completed"
-	TaskStatusFailed    TaskStatus = "failed"
-	TaskStatusCancelled TaskStatus = "cancelled"
+	TaskStatusPending       TaskStatus = "pending"
+	TaskStatusQueued        TaskStatus = "queued"
+	TaskStatusRunning       TaskStatus = "running"
+	TaskStatusCompleted     TaskStatus = "completed"
+	TaskStatusFailed        TaskStatus = "failed"
+	TaskStatusCancelled     TaskStatus = "cancelled"
+	TaskStatusAwaitingInput TaskStatus = "awaiting_input"
 )
 
 type SessionStatus string

backend/models/enums.go

@@ -8,7 +8,7 @@ type Project struct {
 	Path         string    `json:"path"`
 	TestCommand  string    `json:"test_command,omitempty"`
 	BuildCommand string    `json:"build_command,omitempty"`
-	SetupCommand string    `json:"setup_command,omitempty"`
+	SetupCommands StringSlice `json:"setup_commands" gorm:"type:text"`
 	CreatedAt    time.Time `json:"created_at"`
 	UpdatedAt    time.Time `json:"updated_at"`
 }

backend/models/project.go

@@ -19,6 +19,9 @@ type Task struct {
 	ResultText   string      `json:"result_text,omitempty"`
 	FilesChanged StringSlice `json:"files_changed" gorm:"type:text"`
 
+	// Agent interaction - set when agent needs user input to continue
+	PendingInputData string `json:"pending_input_data,omitempty" gorm:"type:text"`
+
 	// Test/Build
 	TestPassed  *bool  `json:"test_passed,omitempty"`
 	TestOutput  string `json:"test_output,omitempty"`

backend/models/task.go

@@ -6,6 +6,7 @@ import (
 	"context"
 	"fmt"
 	"log"
+	"strings"
 	"sync"
 
 	wailsRuntime "github.com/wailsapp/wails/v2/pkg/runtime"
@@ -84,14 +85,20 @@ func (ar *AgentRunner) bufferEvent(taskID string, event claude.TaskStreamEvent)
 
 // RunTaskOptions configures a RunTask invocation.
 type RunTaskOptions struct {
-	SessionID    string // Claude session ID for --resume (empty = new session)
-	Prompt       string // Override task prompt (used for follow-ups)
-	OnSessionID  func(sessionID string) // Callback when Claude session_id is received
+	SessionID   string                 // Claude session ID for --resume (empty = new session)
+	Prompt      string                 // Override task prompt (used for follow-ups)
+	OnSessionID func(sessionID string) // Callback when Claude session_id is received
+}
+
+// RunResult carries information about how the task run completed.
+type RunResult struct {
+	NeedsInput bool   // true if the agent's output indicates it needs user input
+	LastText   string // the last text output from the agent (for displaying in the UI)
 }
 
 // RunTask starts a Claude Code process for a task with the given agent configuration.
 // It streams events to the frontend and returns when the process completes.
-func (ar *AgentRunner) RunTask(ctx context.Context, task *models.Task, agent *models.Agent, workDir string, opts ...RunTaskOptions) error {
+func (ar *AgentRunner) RunTask(ctx context.Context, task *models.Task, agent *models.Agent, workDir string, opts ...RunTaskOptions) (*RunResult, error) {
 	var runOpts RunTaskOptions
 	if len(opts) > 0 {
 		runOpts = opts[0]
@@ -113,7 +120,7 @@ func (ar *AgentRunner) RunTask(ctx context.Context, task *models.Task, agent *mo
 		SessionID:    runOpts.SessionID,
 	})
 	if err != nil {
-		return fmt.Errorf("start claude (%s): %w", ar.cliPath, err)
+		return nil, fmt.Errorf("start claude (%s): %w", ar.cliPath, err)
 	}
 
 	ar.mu.Lock()
@@ -126,8 +133,9 @@ func (ar *AgentRunner) RunTask(ctx context.Context, task *models.Task, agent *mo
 		ar.mu.Unlock()
 	}()
 
-	// Stream events to frontend
+	// Stream events to frontend, track last text for question detection
 	eventCount := 0
+	var lastText string
 	for event := range proc.Events() {
 		eventCount++
 		if eventCount <= 3 || eventCount%10 == 0 {
@@ -141,9 +149,20 @@ func (ar *AgentRunner) RunTask(ctx context.Context, task *models.Task, agent *mo
 
 		ar.emitTaskEvent(task.ID, event)
 
+		// Track last text content for question detection
+		if event.Type == "assistant" {
+			text := claude.ExtractTextContent(event)
+			if text != "" {
+				lastText = text
+			}
+		}
+
 		// Capture result text
 		if event.Type == "result" {
 			task.ResultText = event.Result
+			if event.Result != "" {
+				lastText = event.Result
+			}
 		}
 	}
 	log.Printf("[runner] task %s: stream ended after %d events", task.ID[:8], eventCount)
@@ -165,11 +184,60 @@ func (ar *AgentRunner) RunTask(ctx context.Context, task *models.Task, agent *mo
 	if proc.Err() != nil {
 		stderrOutput := proc.Stderr()
 		if stderrOutput != "" {
-			return fmt.Errorf("claude process: %w\nstderr: %s", proc.Err(), stderrOutput)
+			return nil, fmt.Errorf("claude process: %w\nstderr: %s", proc.Err(), stderrOutput)
+		}
+		return nil, fmt.Errorf("claude process: %w", proc.Err())
+	}
+
+	// Detect if the agent's output indicates it needs user input
+	result := &RunResult{
+		LastText:   lastText,
+		NeedsInput: detectNeedsInput(lastText),
+	}
+	return result, nil
+}
+
+// detectNeedsInput checks if the agent's last output looks like it's asking for user input.
+// Only checks the last paragraph to avoid false positives from questions in the middle of output.
+func detectNeedsInput(text string) bool {
+	if text == "" {
+		return false
+	}
+	trimmed := strings.TrimSpace(text)
+
+	// Only look at the last paragraph (after last double newline) to reduce false positives.
+	// Agents often have questions mid-output but the final paragraph is what matters.
+	if idx := strings.LastIndex(trimmed, "\n\n"); idx >= 0 {
+		trimmed = strings.TrimSpace(trimmed[idx:])
+	}
+
+	// Check if the last paragraph ends with a question mark
+	if strings.HasSuffix(trimmed, "?") {
+		return true
+	}
+
+	lower := strings.ToLower(trimmed)
+
+	// Common patterns indicating the agent wants approval/input (checked in last paragraph only)
+	inputPatterns := []string{
+		"approve", "approval", "onay",
+		"ready for review", "ready to proceed",
+		"which option", "hangi seçenek", "hangisini",
+		"should i proceed", "devam edeyim mi",
+		"waiting for", "bekliyor",
+		"please confirm", "lütfen onaylayın",
+		"let me know", "bana bildirin",
+		"what do you think", "ne düşünüyorsun",
+		"do you want", "ister misin",
+		"select one", "birini seç",
+	}
+	for _, pattern := range inputPatterns {
+		if strings.Contains(lower, pattern) {
+			return true
 		}
-		return fmt.Errorf("claude process: %w", proc.Err())
 	}
-	return nil
+
+	return false
 }
 
 // StopTask kills the Claude process for a specific task.

backend/services/agent_runner.go

@@ -104,10 +104,21 @@ func ParseHunks(unifiedDiff string) []DiffHunk {
 	return hunks
 }
 
+// excludeDirs lists directories to skip when computing diffs.
+var excludeDirs = []string{
+	".git", "node_modules", ".next", "__pycache__", "vendor",
+	".venv", ".cache", ".claude", ".turbo",
+}
+
 // ComputeDiff compares a task workspace against the original project directory.
 func (dt *DiffTracker) ComputeDiff(originalPath, workspacePath string) (*DiffResult, error) {
-	// Use diff to find changes
-	cmd := exec.Command("diff", "-rq", originalPath, workspacePath)
+	// Use diff to find changes, excluding VCS and dependency directories
+	args := []string{"-rq"}
+	for _, dir := range excludeDirs {
+		args = append(args, "--exclude="+dir)
+	}
+	args = append(args, originalPath, workspacePath)
+	cmd := exec.Command("diff", args...)
 	output, _ := cmd.CombinedOutput() // diff returns exit code 1 when files differ
 
 	result := &DiffResult{}