架构师手册：OpenSpec + Superpowers 打造一人极简开发工作流实战指南

propose → apply → archive
  |          |         |
  v          v         v
创建产物    实现任务   合并规格

[OpenSpec 负责]                     [Superpowers 负责]

/opsx:propose
    ↓
生成 proposal / specs / design / tasks
    ↓
架构师审查文档                        brainstorming（自动触发）
    ↓                                    ↓
架构师将文档内容作为上下文，        writing-plans → 自动生成实现计划
告诉 AI "按照这些规格来实现"           ↓
    ↓                               subagent-driven-development
  手动桥接 ──────────────────→       （子代理逐任务执行 TDD）
                                        ↓
                                    finishing-a-development-branch
                                        ↓
架构师回到 OpenSpec 执行 ←──────     实现完成
/opsx:archive

/opsx:propose "创建看板管理系统，包含 Column(name, position) 和 Task(title, description, status) 实体"

# Proposal: Kanban Board System

## Summary
Build a kanban board management system with two core entities:
Column and Task, supporting full CRUD operations.

## Motivation
Need a lightweight project management tool that supports
task organization across customizable columns.

## ADDED Requirements

### Requirement: Column CRUD
The system SHALL support creating, reading, updating,
and deleting board columns.

#### Scenario: Create a new column
- GIVEN no column exists with the name "Todo"
- WHEN the user creates a column with name "Todo"
  and position 1
- THEN the column is persisted with the correct
  name and position

#### Scenario: Reorder columns
- GIVEN two columns exist: "Todo" (position 1),
  "Done" (position 2)
- WHEN the user updates "Todo" position to 2
- THEN "Todo" has position 2 and "Done" shifts
  to position 1

### Requirement: Task CRUD
The system SHALL support creating, reading, updating,
and deleting tasks within columns.

#### Scenario: Create a task in a column
- GIVEN a column "Todo" exists
- WHEN the user creates a task with title "Setup DB"
- THEN the task is linked to "Todo" column
  with status "todo"

# Tasks: Kanban Board System

## Task 1: Database Schema & Models
Create SQLite schema and Go models for Column and Task.

## Task 2: Column API Endpoints
Implement RESTful CRUD endpoints for columns.

## Task 3: Task API Endpoints
Implement RESTful CRUD endpoints for tasks.

## Task 4: Frontend Kanban Board
Build React components for board display and interaction.

请帮我实现这个看板系统，技术栈用 Go + SQLite + React。
我已经用 OpenSpec 定义好了需求，规格文档在 openspec/changes/create-kanban/ 目录下。

# Kanban Board Implementation Plan

> **For agentic workers:** REQUIRED SUB-SKILL:
> Use superpowers:subagent-driven-development

**Goal:** Build a kanban board with Column and Task CRUD,
backed by SQLite, served via Go REST API, rendered in React.

**Architecture:** Three-tier - SQLite storage layer,
Go HTTP API layer, React SPA frontend.

**Tech Stack:** Go 1.22, SQLite3, gorilla/mux,
React 18, TypeScript, React Testing Library

### Task 1: Database Schema & Models

**Files:**
- Create: `internal/models/column.go`
- Create: `internal/models/task.go`
- Create: `internal/db/schema.sql`
- Test: `internal/models/column_test.go`
- Test: `internal/models/task_test.go`

- [ ] Step 1: Write failing tests for Column model
- [ ] Step 2: Run test to verify it fails (RED)
- [ ] Step 3: Write minimal Column model implementation
- [ ] Step 4: Run test to verify it passes (GREEN)
- [ ] Step 5: Repeat for Task model
- [ ] Step 6: Commit

### Task 2: Column API Endpoints
...

> **For agentic workers:** REQUIRED SUB-SKILL:
> Use superpowers:subagent-driven-development

package models

import (
    "database/sql"
    "os"
    "testing"

    _ "github.com/mattn/go-sqlite3"
)

func setupTestDB(t *testing.T) *sql.DB {
    t.Helper()
    db, err := sql.Open("sqlite3", ":memory:")
    if err != nil {
        t.Fatalf("Failed to open test db: %v", err)
    }

    schema, err := os.ReadFile("../../internal/db/schema.sql")
    if err != nil {
        t.Fatalf("Failed to read schema: %v", err)
    }
    if _, err := db.Exec(string(schema)); err != nil {
        t.Fatalf("Failed to exec schema: %v", err)
    }
    return db
}

func TestCreateColumn(t *testing.T) {
    db := setupTestDB(t)
    defer db.Close()

    col := &Column{Name: "Todo", Position: 1}
    err := col.Create(db)
    if err != nil {
        t.Fatalf("Create column failed: %v", err)
    }

    if col.ID == 0 {
        t.Error("Expected non-zero ID after create")
    }
}

func TestGetColumn(t *testing.T) {
    db := setupTestDB(t)
    defer db.Close()

    col := &Column{Name: "In Progress", Position: 2}
    col.Create(db)

    got, err := GetColumn(db, col.ID)
    if err != nil {
        t.Fatalf("GetColumn failed: %v", err)
    }
    if got.Name != "In Progress" {
        t.Errorf("Expected name 'In Progress', got '%s'", got.Name)
    }
}

func TestListColumns(t *testing.T) {
    db := setupTestDB(t)
    defer db.Close()

    (&Column{Name: "Todo", Position: 1}).Create(db)
    (&Column{Name: "Done", Position: 3}).Create(db)

    cols, err := ListColumns(db)
    if err != nil {
        t.Fatalf("ListColumns failed: %v", err)
    }
    if len(cols) != 2 {
        t.Errorf("Expected 2 columns, got %d", len(cols))
    }
}

CREATE TABLE IF NOT EXISTS columns (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL,
    position INTEGER NOT NULL DEFAULT 0
);

CREATE TABLE IF NOT EXISTS tasks (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    title TEXT NOT NULL,
    description TEXT DEFAULT '',
    status TEXT NOT NULL DEFAULT 'todo',
    column_id INTEGER NOT NULL,
    FOREIGN KEY (column_id) REFERENCES columns(id)
);

package models

import "database/sql"

type Column struct {
    ID       int64  `json:"id"`
    Name     string `json:"name"`
    Position int    `json:"position"`
}

func (c *Column) Create(db *sql.DB) error {
    result, err := db.Exec(
        "INSERT INTO columns (name, position) VALUES (?, ?)",
        c.Name, c.Position,
    )
    if err != nil {
        return err
    }
    id, _ := result.LastInsertId()
    c.ID = id
    return nil
}

func GetColumn(db *sql.DB, id int64) (*Column, error) {
    c := &Column{}
    err := db.QueryRow(
        "SELECT id, name, position FROM columns WHERE id = ?", id,
    ).Scan(&c.ID, &c.Name, &c.Position)
    if err != nil {
        return nil, err
    }
    return c, nil
}

func ListColumns(db *sql.DB) ([]*Column, error) {
    rows, err := db.Query(
        "SELECT id, name, position FROM columns ORDER BY position",
    )
    if err != nil {
        return nil, err
    }
    defer rows.Close()

    var cols []*Column
    for rows.Next() {
        c := &Column{}
        rows.Scan(&c.ID, &c.Name, &c.Position)
        cols = append(cols, c)
    }
    return cols, nil
}

package models

import "database/sql"

type Task struct {
    ID          int64  `json:"id"`
    Title       string `json:"title"`
    Description string `json:"description"`
    Status      string `json:"status"`
    ColumnID    int64  `json:"column_id"`
}

func (t *Task) Create(db *sql.DB) error {
    result, err := db.Exec(
        `INSERT INTO tasks (title, description, status, column_id)
         VALUES (?, ?, ?, ?)`,
        t.Title, t.Description, t.Status, t.ColumnID,
    )
    if err != nil {
        return err
    }
    id, _ := result.LastInsertId()
    t.ID = id
    return nil
}

func ListTasksByColumn(db *sql.DB, columnID int64) ([]*Task, error) {
    rows, err := db.Query(
        `SELECT id, title, description, status, column_id
         FROM tasks WHERE column_id = ?`, columnID,
    )
    if err != nil {
        return nil, err
    }
    defer rows.Close()

    var tasks []*Task
    for rows.Next() {
        t := &Task{}
        rows.Scan(&t.ID, &t.Title, &t.Description,
            &t.Status, &t.ColumnID)
        tasks = append(tasks, t)
    }
    return tasks, nil
}

package api

import (
    "database/sql"
    "encoding/json"
    "net/http"

    "kanban/internal/models"
)

type ColumnHandler struct {
    DB *sql.DB
}

func (h *ColumnHandler) Create(w http.ResponseWriter, r *http.Request) {
    var col models.Column
    if err := json.NewDecoder(r.Body).Decode(&col); err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }
    if err := col.Create(h.DB); err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(col)
}

func (h *ColumnHandler) List(w http.ResponseWriter, r *http.Request) {
    cols, err := models.ListColumns(h.DB)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(cols)
}

/opsx:propose "在 Task 实体中增加 Priority 字段（High/Medium/Low，默认 Medium）；前端 Card 组件需根据优先级渲染边框颜色"

## MODIFIED Requirements

### Requirement: Task Entity
The system SHALL support a Priority field on Task entities.

#### Scenario: Create task with explicit priority
- GIVEN a column "Todo" exists
- WHEN the user creates a task with priority "High"
- THEN the task is persisted with priority "High"

#### Scenario: Create task with default priority
- GIVEN a column "Todo" exists
- WHEN the user creates a task without specifying priority
- THEN the task defaults to priority "Medium"

## ADDED Requirements

### Requirement: Priority-Based Card Styling
The system SHALL render task cards with colored borders
based on priority level.

#### Scenario: High priority card display
- GIVEN a task with priority "High" exists
- WHEN the kanban board is rendered
- THEN the task card displays a red border

# Tasks: Add Priority to Tasks

## Task 1: Add Priority field to Task model and DB schema
## Task 2: Update Task API to handle Priority field
## Task 3: Update frontend Card component for priority colors
## Task 4: Update existing tests to cover Priority logic

-- 变更：新增 priority 列
ALTER TABLE tasks ADD COLUMN priority TEXT NOT NULL DEFAULT 'medium';

-- 更新后的完整 schema
CREATE TABLE IF NOT EXISTS tasks (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    title TEXT NOT NULL,
    description TEXT DEFAULT '',
    status TEXT NOT NULL DEFAULT 'todo',
    priority TEXT NOT NULL DEFAULT 'medium',
    column_id INTEGER NOT NULL,
    FOREIGN KEY (column_id) REFERENCES columns(id)
);

// 变更 diff
type Task struct {
    ID          int64  `json:"id"`
    Title       string `json:"title"`
    Description string `json:"description"`
    Status      string `json:"status"`
+   Priority    string `json:"priority"` // 新增字段
    ColumnID    int64  `json:"column_id"`
}

func (t *Task) Create(db *sql.DB) error {
    result, err := db.Exec(
        `INSERT INTO tasks (title, description, status, priority, column_id)
-        VALUES (?, ?, ?, ?)`,
+        VALUES (?, ?, ?, ?, ?)`,
-       t.Title, t.Description, t.Status, t.ColumnID,
+       t.Title, t.Description, t.Status, t.Priority, t.ColumnID,
    )
    // ...
}

// 新增：校验 Priority 合法性
func isValidPriority(p string) bool {
    return p == "high" || p == "medium" || p == "low"
}

// types/task.ts
export interface Task {
  id: number;
  title: string;
  description: string;
  status: string;
  priority: "high" | "medium" | "low"; // 新增
  columnId: number;
}

// components/TaskCard.tsx
import React from "react";
import { Task } from "../types/task";

const priorityColors: Record<Task["priority"], string> = {
  high: "#ef4444",    // 红色
  medium: "#f59e0b",  // 黄色
  low: "#22c55e",     // 绿色
};

export const TaskCard: React.FC<{ task: Task }> = ({ task }) => {
  return (
    <div
      style={{
        borderLeft: `4px solid ${priorityColors[task.priority]}`,
        padding: "12px",
        borderRadius: "4px",
        backgroundColor: "#fff",
        marginBottom: "8px",
      }}
    >
      <h4>{task.title}</h4>
      <p>{task.description}</p>
      <span style={{ color: priorityColors[task.priority] }}>
        {task.priority.toUpperCase()}
      </span>
    </div>
  );
};

func TestCreateTaskWithPriority(t *testing.T) {
    db := setupTestDB(t)
    defer db.Close()

    // 先创建一个 Column
    col := &Column{Name: "Todo", Position: 1}
    col.Create(db)

    // 测试显式指定 priority
    t.Run("explicit priority", func(t *testing.T) {
        task := &Task{
            Title: "Bug fix", Status: "todo",
            Priority: "high", ColumnID: col.ID,
        }
        err := task.Create(db)
        if err != nil {
            t.Fatalf("Create task failed: %v", err)
        }
        got, _ := GetTask(db, task.ID)
        if got.Priority != "high" {
            t.Errorf("Expected priority 'high', got '%s'", got.Priority)
        }
    })

    // 测试默认 priority
    t.Run("default priority", func(t *testing.T) {
        task := &Task{
            Title: "Refactor", Status: "todo",
            ColumnID: col.ID,
        }
        task.Create(db)
        got, _ := GetTask(db, task.ID)
        if got.Priority != "medium" {
            t.Errorf("Expected default 'medium', got '%s'", got.Priority)
        }
    })

    // 测试非法 priority
    t.Run("invalid priority rejected", func(t *testing.T) {
        task := &Task{
            Title: "Hack", Status: "todo",
            Priority: "urgent", ColumnID: col.ID,
        }
        err := task.Create(db)
        if err == nil {
            t.Error("Expected error for invalid priority")
        }
    })
}

/opsx:archive add-priority