feat: validate project exists before creating tasks

cmd/task/cli_test.go

@@ -21,6 +21,11 @@ func TestCLICreateTask(t *testing.T) {
 	defer database.Close()
 	defer os.Remove(dbPath)
 
+	// Create the myproject project for testing
+	if err := database.CreateProject(&db.Project{Name: "myproject", Path: tmpDir}); err != nil {
+		t.Fatalf("failed to create myproject: %v", err)
+	}
+
 	tests := []struct {
 		name     string
 		task     *db.Task
@@ -97,6 +102,11 @@ func TestCLIListTasks(t *testing.T) {
 	defer database.Close()
 	defer os.Remove(dbPath)
 
+	// Create the proj1 project for testing
+	if err := database.CreateProject(&db.Project{Name: "proj1", Path: tmpDir}); err != nil {
+		t.Fatalf("failed to create proj1: %v", err)
+	}
+
 	// Create some tasks
 	tasks := []*db.Task{
 		{Title: "Task 1", Status: db.StatusBacklog, Type: db.TypeCode},

internal/db/memories_test.go

@@ -234,6 +234,11 @@ func TestMemoryWithSourceTask(t *testing.T) {
 	defer db.Close()
 	defer os.Remove(dbPath)
 
+	// Create the project first
+	if err := db.CreateProject(&Project{Name: "testproject", Path: tmpDir}); err != nil {
+		t.Fatalf("failed to create project: %v", err)
+	}
+
 	// Create a task first
 	task := &Task{
 		Title:    "Source Task",

internal/db/sqlite_test.go

@@ -19,6 +19,11 @@ func TestTimestampLocalization(t *testing.T) {
 	defer db.Close()
 	defer os.Remove(dbPath)
 
+	// Create the test project first
+	if err := db.CreateProject(&Project{Name: "test", Path: tmpDir}); err != nil {
+		t.Fatalf("failed to create test project: %v", err)
+	}
+
 	// Create a task
 	task := &Task{
 		Title:    "Test Task",

internal/db/tasks.go

@@ -63,13 +63,25 @@ type TaskType struct {
 	CreatedAt    LocalTime
 }
 
+// ErrProjectNotFound is returned when a task is created with a non-existent project.
+var ErrProjectNotFound = fmt.Errorf("project not found")
+
 // CreateTask creates a new task.
 func (db *DB) CreateTask(t *Task) error {
 	// Default to 'personal' project if not specified
 	if t.Project == "" {
 		t.Project = "personal"
 	}
 
+	// Validate that the project exists
+	project, err := db.GetProjectByName(t.Project)
+	if err != nil {
+		return fmt.Errorf("validate project: %w", err)
+	}
+	if project == nil {
+		return fmt.Errorf("%w: %s", ErrProjectNotFound, t.Project)
+	}
+
 	result, err := db.Exec(`
 		INSERT INTO tasks (title, body, status, type, project)
 		VALUES (?, ?, ?, ?, ?)

internal/db/tasks_test.go

@@ -3,6 +3,7 @@ package db
 import (
 	"os"
 	"path/filepath"
+	"strings"
 	"testing"
 )
 
@@ -18,6 +19,11 @@ func TestGetLastQuestion(t *testing.T) {
 	defer db.Close()
 	defer os.Remove(dbPath)
 
+	// Create the test project first
+	if err := db.CreateProject(&Project{Name: "test", Path: tmpDir}); err != nil {
+		t.Fatalf("failed to create test project: %v", err)
+	}
+
 	// Create a task
 	task := &Task{
 		Title:    "Test Task",
@@ -78,6 +84,11 @@ func TestTaskLogsWithQuestion(t *testing.T) {
 	defer db.Close()
 	defer os.Remove(dbPath)
 
+	// Create the test project first
+	if err := db.CreateProject(&Project{Name: "test", Path: tmpDir}); err != nil {
+		t.Fatalf("failed to create test project: %v", err)
+	}
+
 	// Create a task
 	task := &Task{
 		Title:    "Test Task",
@@ -598,6 +609,11 @@ func TestListTasksClosedSortedByCompletedAt(t *testing.T) {
 	defer database.Close()
 	defer os.Remove(dbPath)
 
+	// Create the test project first
+	if err := database.CreateProject(&Project{Name: "test", Path: tmpDir}); err != nil {
+		t.Fatalf("failed to create test project: %v", err)
+	}
+
 	// Create tasks in specific order - older tasks first
 	task1 := &Task{
 		Title:   "First task - closed early",
@@ -755,6 +771,11 @@ func TestCompactionSummaries(t *testing.T) {
 	defer db.Close()
 	defer os.Remove(dbPath)
 
+	// Create the test project first
+	if err := db.CreateProject(&Project{Name: "test", Path: tmpDir}); err != nil {
+		t.Fatalf("failed to create test project: %v", err)
+	}
+
 	// Create a task
 	task := &Task{
 		Title:   "Test Task for Compaction",
@@ -888,6 +909,11 @@ func TestCompactionSummariesCascadeDelete(t *testing.T) {
 	defer db.Close()
 	defer os.Remove(dbPath)
 
+	// Create the test project first
+	if err := db.CreateProject(&Project{Name: "test", Path: tmpDir}); err != nil {
+		t.Fatalf("failed to create test project: %v", err)
+	}
+
 	// Create a task
 	task := &Task{
 		Title:   "Task for Cascade Delete Test",
@@ -1150,3 +1176,169 @@ func TestGetActiveTaskPorts(t *testing.T) {
 		}
 	}
 }
+
+func TestCreateTaskRejectsNonExistentProject(t *testing.T) {
+	// Create temporary database
+	tmpDir := t.TempDir()
+	dbPath := filepath.Join(tmpDir, "test.db")
+
+	db, err := Open(dbPath)
+	if err != nil {
+		t.Fatalf("failed to open database: %v", err)
+	}
+	defer db.Close()
+	defer os.Remove(dbPath)
+
+	// Try to create a task with a non-existent project
+	task := &Task{
+		Title:   "Test Task",
+		Status:  StatusBacklog,
+		Type:    TypeCode,
+		Project: "nonexistent-project",
+	}
+	err = db.CreateTask(task)
+
+	// Should fail with project not found error
+	if err == nil {
+		t.Fatal("expected error when creating task with non-existent project, got nil")
+	}
+	if !strings.Contains(err.Error(), "project not found") {
+		t.Errorf("expected 'project not found' error, got: %v", err)
+	}
+
+	// Verify task was not created
+	tasks, err := db.ListTasks(ListTasksOptions{IncludeClosed: true})
+	if err != nil {
+		t.Fatalf("failed to list tasks: %v", err)
+	}
+	if len(tasks) != 0 {
+		t.Errorf("expected 0 tasks after failed creation, got %d", len(tasks))
+	}
+}
+
+func TestCreateTaskAllowsExistingProject(t *testing.T) {
+	// Create temporary database
+	tmpDir := t.TempDir()
+	dbPath := filepath.Join(tmpDir, "test.db")
+
+	db, err := Open(dbPath)
+	if err != nil {
+		t.Fatalf("failed to open database: %v", err)
+	}
+	defer db.Close()
+	defer os.Remove(dbPath)
+
+	// Create a project first
+	project := &Project{
+		Name: "my-project",
+		Path: tmpDir,
+	}
+	if err := db.CreateProject(project); err != nil {
+		t.Fatalf("failed to create project: %v", err)
+	}
+
+	// Now create a task with that project
+	task := &Task{
+		Title:   "Test Task",
+		Status:  StatusBacklog,
+		Type:    TypeCode,
+		Project: "my-project",
+	}
+	err = db.CreateTask(task)
+
+	// Should succeed
+	if err != nil {
+		t.Fatalf("expected task creation to succeed, got error: %v", err)
+	}
+
+	// Verify task was created with correct project
+	retrieved, err := db.GetTask(task.ID)
+	if err != nil {
+		t.Fatalf("failed to get task: %v", err)
+	}
+	if retrieved.Project != "my-project" {
+		t.Errorf("expected project 'my-project', got '%s'", retrieved.Project)
+	}
+}
+
+func TestCreateTaskAllowsProjectAlias(t *testing.T) {
+	// Create temporary database
+	tmpDir := t.TempDir()
+	dbPath := filepath.Join(tmpDir, "test.db")
+
+	db, err := Open(dbPath)
+	if err != nil {
+		t.Fatalf("failed to open database: %v", err)
+	}
+	defer db.Close()
+	defer os.Remove(dbPath)
+
+	// Create a project with an alias
+	project := &Project{
+		Name:    "my-long-project-name",
+		Path:    tmpDir,
+		Aliases: "myproj, proj",
+	}
+	if err := db.CreateProject(project); err != nil {
+		t.Fatalf("failed to create project: %v", err)
+	}
+
+	// Create a task using the alias
+	task := &Task{
+		Title:   "Test Task",
+		Status:  StatusBacklog,
+		Type:    TypeCode,
+		Project: "myproj",
+	}
+	err = db.CreateTask(task)
+
+	// Should succeed
+	if err != nil {
+		t.Fatalf("expected task creation with alias to succeed, got error: %v", err)
+	}
+
+	// Verify task was created with the alias (not the full name)
+	retrieved, err := db.GetTask(task.ID)
+	if err != nil {
+		t.Fatalf("failed to get task: %v", err)
+	}
+	if retrieved.Project != "myproj" {
+		t.Errorf("expected project 'myproj', got '%s'", retrieved.Project)
+	}
+}
+
+func TestCreateTaskDefaultsToPersonal(t *testing.T) {
+	// Create temporary database
+	tmpDir := t.TempDir()
+	dbPath := filepath.Join(tmpDir, "test.db")
+
+	db, err := Open(dbPath)
+	if err != nil {
+		t.Fatalf("failed to open database: %v", err)
+	}
+	defer db.Close()
+	defer os.Remove(dbPath)
+
+	// Create a task with empty project (should default to 'personal')
+	task := &Task{
+		Title:   "Test Task",
+		Status:  StatusBacklog,
+		Type:    TypeCode,
+		Project: "",
+	}
+	err = db.CreateTask(task)
+
+	// Should succeed because 'personal' project is auto-created
+	if err != nil {
+		t.Fatalf("expected task creation to succeed with default project, got error: %v", err)
+	}
+
+	// Verify task was created with 'personal' project
+	retrieved, err := db.GetTask(task.ID)
+	if err != nil {
+		t.Fatalf("failed to get task: %v", err)
+	}
+	if retrieved.Project != "personal" {
+		t.Errorf("expected project 'personal', got '%s'", retrieved.Project)
+	}
+}

internal/executor/executor_test.go

@@ -103,6 +103,11 @@ func TestInterrupt(t *testing.T) {
 	}
 	defer database.Close()
 
+	// Create the test project first
+	if err := database.CreateProject(&db.Project{Name: "test", Path: "/tmp/test"}); err != nil {
+		t.Fatal(err)
+	}
+
 	cfg := &config.Config{}
 	exec := New(database, cfg)
 
@@ -206,6 +211,11 @@ func TestAttachmentsInPrompt(t *testing.T) {
 	}
 	defer database.Close()
 
+	// Create the test project first
+	if err := database.CreateProject(&db.Project{Name: "test", Path: "/tmp/test"}); err != nil {
+		t.Fatal(err)
+	}
+
 	cfg := &config.Config{}
 	exec := New(database, cfg)
 
@@ -294,6 +304,11 @@ func TestConversationHistory(t *testing.T) {
 	}
 	defer database.Close()
 
+	// Create the test project first
+	if err := database.CreateProject(&db.Project{Name: "test", Path: "/tmp/test"}); err != nil {
+		t.Fatal(err)
+	}
+
 	cfg := &config.Config{}
 	exec := New(database, cfg)
 

internal/mcp/server_test.go

@@ -32,6 +32,11 @@ func testDB(t *testing.T) *db.DB {
 
 // createTestTask creates a task for testing.
 func createTestTask(t *testing.T, database *db.DB) *db.Task {
+	// First create the test-project
+	if err := database.CreateProject(&db.Project{Name: "test-project", Path: "/tmp/test-project"}); err != nil {
+		t.Fatalf("failed to create test-project: %v", err)
+	}
+
 	task := &db.Task{
 		Title:   "Test Task",
 		Status:  db.StatusProcessing,