From ac3aca893fed718b85c6e162663d85aff2d297cd Mon Sep 17 00:00:00 2001 From: He Zhang Date: Tue, 3 Mar 2026 16:39:42 +0800 Subject: [PATCH 01/14] init with draft plan --- .tmp/discussion0303.md | 44 +++++++++++ .tmp/prd.md | 166 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 210 insertions(+) create mode 100644 .tmp/discussion0303.md create mode 100644 .tmp/prd.md diff --git a/.tmp/discussion0303.md b/.tmp/discussion0303.md new file mode 100644 index 0000000..cbad868 --- /dev/null +++ b/.tmp/discussion0303.md @@ -0,0 +1,44 @@ +0303 Summary + +-Schema Review + +1.super crew kanban的数据源位置: +.supercrew/ + +2. .supercrew/ 目录结构: +.supercrew/ + |-feature-name + |-meta.yaml + |-design.md + |-plan.md + +3.meta.yaml文件： +id/featurename/description/status/priority/team/owner/target_release/tags/dev_branch + +4.design.md +初步设计文档，在dev_branch持续更新，structured markdown，包括两个部分 +a)structured 部分, yml fields包括status/reviewer/approved_by（这个是for design review，是否需要enable这个审查看老板们想法，会加入这个流程是因为个人体验下来前期设计很重要，需要多费心设计，和ai来会讨论，会占据coding工作的30%左右，不建议无脑接受ai的plan） +b)markdown部分，design文档 + +5. plan.md +structured markdown，task breakdown +a)structured 部分，total tasks/complete tasks +b)markdown部分，workitem breakdown，markdown格式，可以考虑类似societas的floating todo bar一样在看板上做visualize + + +-Design Review +1.kanban renderer，基于上述schema做renderer，demo version可见于user/steinsz/supercrew_schema，（需和真实github repo 做 integration test +2.ai integration，创建一个plugin，用于对每个repo setup .supercrew目录结构和对应的文件管理。暂不考虑直接用superpowers，因为过于耦合，相对我们的需求太重。mvp之后会考虑将两者结合，实现过程会借鉴superpowsers。 +3.ai integration trigger。skill/hook/pre-commit等方式都会尝试，理想情况会做成全自动，slash command作为备选方案 +4.user flow: user clone his own repo -> install our plugin -> start coding (.supercrew folder will be created automatically) -> prd discussion and meta.yml be created by ai -> check in it to main/dev branch -> take the task and make plan, check-in plan to dev branch -> finish coding and check in code with final documents in docs/ folder +5.user can use kanban with github oauth see the repo status (read only for now) + +-Open Discussion +1.per user/per agent track, 暂时会放在p2，在schema设计过程中会保留可扩展性以便我们未来可以兼容这个需求，但是没有放在mvp阶段，为了控制复杂度 +2.ado v.s. .supercrew folder，暂时考虑用.supercrew下的文件来管理workitem，主要有两个考量：a)复杂度，在mvp阶段尽量简单。b)适用范围，目录结构更灵活不绑定ado +3. .supercrew下的feature如何和branch link起来，a)优先考虑用worktree，b)次要考虑在meta.yml中配置一个branch来做关联 + +-Next Step +1.add market place with corresponding skills/subagents/plugings to create and maintain .supercrew folder +2.support rendered with new schema +3.integration test with claude code and real repo diff --git a/.tmp/prd.md b/.tmp/prd.md new file mode 100644 index 0000000..6b1c2fb --- /dev/null +++ b/.tmp/prd.md @@ -0,0 +1,166 @@ +# SuperCrew MVP — `.supercrew/` Schema + Kanban + AI Plugin + +**TL;DR:** 基于 `user/steinsz/supercrew_schema` 分支的 demo 实现，将 kanban 从 `.team/` 资源导向 完全迁移到 `.supercrew/features/` feature 导向的数据模型。MVP 包含三大模块：(1) 后端 store + API 替换为 `.supercrew/` schema，(2) 前端看板重构为 feature-centric 视图，(3) AI 集成插件（skills + hooks + pre-commit）实现 `.supercrew/` 目录的自动化管理。参考 [superpowers](https://github.com/obra/superpowers) 的插件架构和 [vibe-kanban](https://github.com/BloopAI/vibe-kanban) 的 issue→workspace 模式。 + +--- + +## Phase 1: Schema 基础设施 — 后端迁移 + +**目标：** 用 `.supercrew/features/` 替换 `.team/`，后端只认 `.supercrew/`。 + +### 1.1 定义 TypeScript 类型与 Schema 校验 +- 基于 commit `62cd395f` 的 `SupercrewStatus`、`FeatureMeta` 类型，在 `kanban/backend/src/types/index.ts` 中替换现有 `Task`/`Sprint` 等类型 +- 新增类型：`FeatureMeta`（meta.yaml）、`DesignDoc`（design.md frontmatter + body）、`PlanDoc`（plan.md frontmatter + tasks breakdown）、`FeatureLog`（log.md） +- 定义 `SupercrewStatus` 枚举：`planning → designing → ready → active → blocked → done` +- 新增 `FeaturePriority`: `P0 | P1 | P2 | P3` +- 使用 `zod` 做运行时校验（meta.yaml 必填字段：`id`, `title`, `status`, `owner`, `priority`） + +### 1.2 重写 Local Store +- 将 `kanban/backend/src/store/index.ts` 改为读写 `.supercrew/features/` 目录 +- 每个子目录 = 一个 feature，读取 `meta.yaml`（用 `js-yaml`）、`design.md`（用 `gray-matter`）、`plan.md`（用 `gray-matter`）、`log.md` +- CRUD：创建 feature = 创建子目录 + 4 个模板文件；更新 = 写入对应文件；删除 = 删除整个子目录 +- Status 流转逻辑放在 store 层（校验合法转换） + +### 1.3 重写 GitHub Store +- 将 `kanban/backend/src/store/github-store.ts` 改为通过 GitHub Contents API 读写 `.supercrew/features/` 路径 +- 复用现有的 `ghGet`/`ghPut`/`ghDelete` pattern，路径从 `.team/tasks/` 改为 `.supercrew/features//` +- Init 端点改为初始化 `.supercrew/features/` 目录（替代 `.team/`） + +### 1.4 重写 API Routes +- 将 `kanban/backend/src/routes/` 下的 `tasks.ts`、`sprints.ts`、`people.ts`、`knowledge.ts`、`decisions.ts` 合并/替换为： + - `features.ts`：`GET/POST/PATCH/DELETE /api/features`，`PUT /api/features/:id/status` + - `GET /api/features/:id/design` — 获取 design.md + - `GET /api/features/:id/plan` — 获取 plan.md（含 progress） + - `GET /api/board` — 聚合 endpoint，将 features 按 status 映射到看板列 +- 保留 auth 路由（`auth.ts`）和 projects 路由不变 +- 移除 `SUPERCREW_DEMO` 环境变量守卫，`.supercrew/` 成为默认唯一模式 +- Init-status 改为检查 `.supercrew/features/` 是否存在 + +### 1.5 删除遗留代码 +- 移除 `.team/` 相关的所有 store 逻辑、路由、类型 +- 移除 `Sprint`、`Person`、`KnowledgeEntry`、`Decision` 类型（MVP 阶段只聚焦 Feature） +- 清理 `index.ts` 中的路由注册 + +--- + +## Phase 2: 前端看板重构 + +**目标：** 用 feature-centric 视图替代现有 task-centric 看板。 + +### 2.1 数据层重构 +- 更新 `kanban/frontend/packages/app-core/src/types.ts`：用 `Feature`（含 meta + design status + plan progress）替代 `Task`/`Sprint` 等 +- 更新 `kanban/frontend/packages/app-core/src/api.ts`：`fetchFeatures()`、`createFeature()`、`updateFeature()`、`updateFeatureStatus()`、`deleteFeature()`、`fetchFeatureDesign()`、`fetchFeaturePlan()` +- 更新 `useBoard()` hook：返回 `{ features, featuresByStatus, isLoading, error }` +- 更新 `useMutations()`：feature CRUD + status 更新 + optimistic updates + +### 2.2 看板主视图 +- 重构 `kanban/frontend/packages/ui/` 中的 `KanbanBoard` 组件 +- 6 列布局对应 status：`Planning | Designing | Ready | Active | Blocked | Done` +- Feature 卡片显示：`title`、`priority` badge（P0 红/P1 橙/P2 蓝/P3 灰）、`owner`、`teams` tags、plan `progress` 进度条 +- 拖拽：保留 `@hello-pangea/dnd`，拖拽 = status 流转（需校验合法转换） +- 参考 vibe-kanban 的卡片 UI 风格：简洁、信息密度高 + +### 2.3 Feature 详情页 +- 新建 `/features/:id` 路由，替代原 `/tasks/:id` +- 三 Tab 布局：**Overview**（meta.yaml 渲染：owner、priority、teams、target_release、tags、dates）、**Design**（design.md markdown 渲染 + status/reviewer 信息）、**Plan**（plan.md 渲染：进度条 + task checklist 可视化，类似 societas floating todo bar） +- Design tab 显示 review status badge（draft/in-review/approved/rejected） +- Plan tab 显示 `completed_tasks/total_tasks` 进度 + 每个 workitem 的完成状态 + +### 2.4 FRE 与 Init 流程更新 +- 更新 Welcome wizard：Select Repo → Initialize `.supercrew/` directory（替代 `.team/`） +- Init API 调用改为 `/api/projects/github/repos/:owner/:repo/init`，创建 `.supercrew/features/` 目录 + +### 2.5 清理遗留页面 +- 移除 `/people`、`/knowledge`、`/decisions` 页面和底部导航对应入口 +- 底部导航简化为：**Board**（feature 看板）、**Features**（列表视图，可选） +- 保留 dark/light theme 和 i18n + +--- + +## Phase 3: AI 集成插件 + +**目标：** 创建独立插件，在用户 repo 中自动管理 `.supercrew/` 目录。参考 superpowers 的 skills/hooks/commands 架构，但独立发布。 + +### 3.1 插件目录结构 +``` +plugins/supercrew/ +├── .claude-plugin/marketplace.json # 发布到 Claude Code marketplace +├── skills/ +│ ├── create-feature/SKILL.md # 创建 feature 目录 + 4 文件 +│ ├── update-status/SKILL.md # 状态流转 +│ ├── sync-plan/SKILL.md # 生成/更新 plan.md +│ └── log-progress/SKILL.md # 追加 log.md +├── commands/ +│ ├── new-feature.md # /new-feature slash command +│ └── feature-status.md # /feature-status slash command +├── hooks/ +│ ├── hooks.json # SessionStart hook +│ └── session-start # 注入 .supercrew context +├── agents/ +│ └── supercrew-manager.md # 综合管理 agent +└── templates/ + ├── meta.yaml.tmpl + ├── design.md.tmpl + ├── plan.md.tmpl + └── log.md.tmpl +``` + +### 3.2 Skills 实现 + +- **`create-feature`**: 用户描述需求 → AI 通过 PRD 讨论提炼 → 生成 `meta.yaml`（自动填充 id、title、owner、priority、status=planning、dates）+ `design.md`（初始 draft 模板）+ `plan.md`（空结构）+ `log.md`（初始化记录） +- **`update-status`**: 根据代码/commit 状态自动判断并更新 `meta.yaml` 中的 status 字段，遵循合法状态转换图 +- **`sync-plan`**: 在 design 完成后，基于 `design.md` 内容生成 `plan.md` 中的 task breakdown；coding 阶段持续更新 `completed_tasks`/`progress` +- **`log-progress`**: 每次 session 结束时自动追加 `log.md`，记录本次工作内容、完成的 tasks、遇到的问题 + +### 3.3 Hooks + +- **SessionStart**: 检测当前 repo 是否有 `.supercrew/features/` → 有则注入所有 feature 的 meta 信息到 context → 提示 AI 当前活跃 feature 和进度 +- **pre-commit hook**: 校验 `.supercrew/features/*/meta.yaml` 的 schema 合法性（必填字段、status 枚举值、priority 枚举值）；校验 `plan.md` frontmatter 的 `total_tasks ≥ completed_tasks` + +### 3.4 Commands + +- **`/new-feature`**: 触发 `create-feature` skill，交互式创建新 feature +- **`/feature-status`**: 显示所有 feature 的当前状态概览（表格形式：id | title | status | progress | owner） + +### 3.5 Agent + +- **`supercrew-manager`**: 综合 agent，可以执行所有 skills，负责在适当时机自动调用 `update-status`、`sync-plan`、`log-progress` + +--- + +## Phase 4: 集成与测试 + +### 4.1 后端测试 +- 为 supercrew-store 写单元测试（vitest）：CRUD、status 流转校验、schema 校验 +- 为 features API 写集成测试：HTTP 层面的 CRUD + auth + +### 4.2 前端测试 +- Feature card 组件测试 +- Board 视图 + 拖拽测试 +- Feature 详情页 Tab 切换测试 + +### 4.3 端到端集成测试 +- 用真实 GitHub repo 测试完整 flow：OAuth → init `.supercrew/` → create feature → update status → view on board +- 用 Claude Code 测试插件 flow：安装插件 → `/new-feature` → coding → plan 自动更新 → commit（pre-commit hook 校验） + +### 4.4 部署验证 +- Vercel 部署验证：确保 GitHub store 正确读写 `.supercrew/` 路径 +- 运行 `kanban/scripts/verify-before-deploy.sh` + +--- + +## Verification +- `cd kanban && bun test` — 后端单元测试 +- `cd kanban/frontend && pnpm test` — 前端测试 +- 手动测试：选择一个 test repo → 通过 kanban FRE 初始化 `.supercrew/` → 创建 feature → 在看板上拖拽 → 查看详情页 +- 插件测试：在 Claude Code 中加载插件 → 执行 `/new-feature` → 验证文件生成 → commit 触发 pre-commit hook + +--- + +## Decisions +- **`.team/` 完全弃用**：MVP 不做兼容，直接替换。简化实现复杂度。 +- **Feature-centric 而非 Task-centric**：看板的最小单位是 feature，不再是 task。Task 作为 plan.md 内的 checklist 存在。 +- **插件独立于 superpowers**：降低耦合，独立发布到 marketplace。Post-MVP 可以与 superpowers 融合。 +- **Sprint/People/Knowledge/Decisions 移除**：MVP 聚焦 feature lifecycle，这些概念不在 `.supercrew/` schema 中，不保留。 +- **log.md 保留**：虽然讨论文档未提及，但 demo 分支已实现，作为 AI context 很有价值，保留。 +- **Design review 纳入 MVP**：`design.md` 的 `status/reviewer/approved_by` 字段保留，在详情页展示。在 pre-commit hook 中不强制校验。 From 7a414eb8b9a2564e22f2d87172a31bcaa4fba7ea Mon Sep 17 00:00:00 2001 From: He Zhang Date: Tue, 3 Mar 2026 17:00:18 +0800 Subject: [PATCH 02/14] update prd --- .tmp/prd.md | 255 ++++++++++++++++++++++++++++++++-------------------- 1 file changed, 158 insertions(+), 97 deletions(-) diff --git a/.tmp/prd.md b/.tmp/prd.md index 6b1c2fb..ed4d1a2 100644 --- a/.tmp/prd.md +++ b/.tmp/prd.md @@ -1,87 +1,38 @@ # SuperCrew MVP — `.supercrew/` Schema + Kanban + AI Plugin -**TL;DR:** 基于 `user/steinsz/supercrew_schema` 分支的 demo 实现，将 kanban 从 `.team/` 资源导向 完全迁移到 `.supercrew/features/` feature 导向的数据模型。MVP 包含三大模块：(1) 后端 store + API 替换为 `.supercrew/` schema，(2) 前端看板重构为 feature-centric 视图，(3) AI 集成插件（skills + hooks + pre-commit）实现 `.supercrew/` 目录的自动化管理。参考 [superpowers](https://github.com/obra/superpowers) 的插件架构和 [vibe-kanban](https://github.com/BloopAI/vibe-kanban) 的 issue→workspace 模式。 +**TL;DR:** 基于 `user/steinsz/supercrew_schema` 分支的 demo 实现，将 kanban 从 `.team/` 资源导向 完全迁移到 `.supercrew/features/` feature 导向的数据模型。MVP 包含三大模块：(1) AI 集成插件（skills + hooks + pre-commit）在用户 repo 中创建和管理 `.supercrew/` 目录，(2) 后端通过 GitHub API（OAuth）只读访问用户 repo 中的 `.supercrew/` 数据，(3) 前端看板以只读方式渲染 feature-centric 视图。参考 [superpowers](https://github.com/obra/superpowers) 的插件架构和 [vibe-kanban](https://github.com/BloopAI/vibe-kanban) 的 issue→workspace 模式。 ---- - -## Phase 1: Schema 基础设施 — 后端迁移 - -**目标：** 用 `.supercrew/features/` 替换 `.team/`，后端只认 `.supercrew/`。 +### 数据流架构 -### 1.1 定义 TypeScript 类型与 Schema 校验 -- 基于 commit `62cd395f` 的 `SupercrewStatus`、`FeatureMeta` 类型，在 `kanban/backend/src/types/index.ts` 中替换现有 `Task`/`Sprint` 等类型 -- 新增类型：`FeatureMeta`（meta.yaml）、`DesignDoc`（design.md frontmatter + body）、`PlanDoc`（plan.md frontmatter + tasks breakdown）、`FeatureLog`（log.md） -- 定义 `SupercrewStatus` 枚举：`planning → designing → ready → active → blocked → done` -- 新增 `FeaturePriority`: `P0 | P1 | P2 | P3` -- 使用 `zod` 做运行时校验（meta.yaml 必填字段：`id`, `title`, `status`, `owner`, `priority`） - -### 1.2 重写 Local Store -- 将 `kanban/backend/src/store/index.ts` 改为读写 `.supercrew/features/` 目录 -- 每个子目录 = 一个 feature，读取 `meta.yaml`（用 `js-yaml`）、`design.md`（用 `gray-matter`）、`plan.md`（用 `gray-matter`）、`log.md` -- CRUD：创建 feature = 创建子目录 + 4 个模板文件；更新 = 写入对应文件；删除 = 删除整个子目录 -- Status 流转逻辑放在 store 层（校验合法转换） - -### 1.3 重写 GitHub Store -- 将 `kanban/backend/src/store/github-store.ts` 改为通过 GitHub Contents API 读写 `.supercrew/features/` 路径 -- 复用现有的 `ghGet`/`ghPut`/`ghDelete` pattern，路径从 `.team/tasks/` 改为 `.supercrew/features//` -- Init 端点改为初始化 `.supercrew/features/` 目录（替代 `.team/`） - -### 1.4 重写 API Routes -- 将 `kanban/backend/src/routes/` 下的 `tasks.ts`、`sprints.ts`、`people.ts`、`knowledge.ts`、`decisions.ts` 合并/替换为： - - `features.ts`：`GET/POST/PATCH/DELETE /api/features`，`PUT /api/features/:id/status` - - `GET /api/features/:id/design` — 获取 design.md - - `GET /api/features/:id/plan` — 获取 plan.md（含 progress） - - `GET /api/board` — 聚合 endpoint，将 features 按 status 映射到看板列 -- 保留 auth 路由（`auth.ts`）和 projects 路由不变 -- 移除 `SUPERCREW_DEMO` 环境变量守卫，`.supercrew/` 成为默认唯一模式 -- Init-status 改为检查 `.supercrew/features/` 是否存在 - -### 1.5 删除遗留代码 -- 移除 `.team/` 相关的所有 store 逻辑、路由、类型 -- 移除 `Sprint`、`Person`、`KnowledgeEntry`、`Decision` 类型（MVP 阶段只聚焦 Feature） -- 清理 `index.ts` 中的路由注册 - ---- - -## Phase 2: 前端看板重构 - -**目标：** 用 feature-centric 视图替代现有 task-centric 看板。 - -### 2.1 数据层重构 -- 更新 `kanban/frontend/packages/app-core/src/types.ts`：用 `Feature`（含 meta + design status + plan progress）替代 `Task`/`Sprint` 等 -- 更新 `kanban/frontend/packages/app-core/src/api.ts`：`fetchFeatures()`、`createFeature()`、`updateFeature()`、`updateFeatureStatus()`、`deleteFeature()`、`fetchFeatureDesign()`、`fetchFeaturePlan()` -- 更新 `useBoard()` hook：返回 `{ features, featuresByStatus, isLoading, error }` -- 更新 `useMutations()`：feature CRUD + status 更新 + optimistic updates - -### 2.2 看板主视图 -- 重构 `kanban/frontend/packages/ui/` 中的 `KanbanBoard` 组件 -- 6 列布局对应 status：`Planning | Designing | Ready | Active | Blocked | Done` -- Feature 卡片显示：`title`、`priority` badge（P0 红/P1 橙/P2 蓝/P3 灰）、`owner`、`teams` tags、plan `progress` 进度条 -- 拖拽：保留 `@hello-pangea/dnd`，拖拽 = status 流转（需校验合法转换） -- 参考 vibe-kanban 的卡片 UI 风格：简洁、信息密度高 - -### 2.3 Feature 详情页 -- 新建 `/features/:id` 路由，替代原 `/tasks/:id` -- 三 Tab 布局：**Overview**（meta.yaml 渲染：owner、priority、teams、target_release、tags、dates）、**Design**（design.md markdown 渲染 + status/reviewer 信息）、**Plan**（plan.md 渲染：进度条 + task checklist 可视化，类似 societas floating todo bar） -- Design tab 显示 review status badge（draft/in-review/approved/rejected） -- Plan tab 显示 `completed_tasks/total_tasks` 进度 + 每个 workitem 的完成状态 - -### 2.4 FRE 与 Init 流程更新 -- 更新 Welcome wizard：Select Repo → Initialize `.supercrew/` directory（替代 `.team/`） -- Init API 调用改为 `/api/projects/github/repos/:owner/:repo/init`，创建 `.supercrew/features/` 目录 +``` +用户 Repo（数据源） Kanban 服务（只读展示） +┌─────────────────────┐ ┌──────────────────────┐ +│ .supercrew/ │ │ Vercel (后端) │ +│ features/ │ │ │ +│ feature-a/ │ │ GitHub API ──读取──►│ +│ meta.yaml │ │ (OAuth) │ +│ design.md │ │ │ +│ plan.md │ │ 前端（只读看板） │ +│ log.md │ │ │ +└─────────────────────┘ └──────────────────────┘ + ▲ ▲ + │ │ + Claude Code 插件 用户浏览器 + (本地写入 → git push) (OAuth 登录 → 查看看板) +``` -### 2.5 清理遗留页面 -- 移除 `/people`、`/knowledge`、`/decisions` 页面和底部导航对应入口 -- 底部导航简化为：**Board**（feature 看板）、**Features**（列表视图，可选） -- 保留 dark/light theme 和 i18n +**关键原则：** +- **写入方唯一：** Claude Code 插件在用户本地 repo 操作 `.supercrew/`，通过 git commit + push 同步 +- **读取方唯一：** Kanban 服务通过 OAuth 获取的 GitHub access_token 调用 GitHub Contents API 读取 +- **Kanban 完全只读：** 不提供任何写入 API，不修改用户 repo 中的数据 --- -## Phase 3: AI 集成插件 +## Phase 1: AI 集成插件（数据写入方） -**目标：** 创建独立插件，在用户 repo 中自动管理 `.supercrew/` 目录。参考 superpowers 的 skills/hooks/commands 架构，但独立发布。 +**目标：** 创建独立插件，在用户 repo 中自动创建和管理 `.supercrew/` 目录。这是唯一的数据写入方。参考 superpowers 的 skills/hooks/commands 架构，独立发布到 marketplace。 -### 3.1 插件目录结构 +### 1.1 插件目录结构 ``` plugins/supercrew/ ├── .claude-plugin/marketplace.json # 发布到 Claude Code marketplace @@ -105,46 +56,152 @@ plugins/supercrew/ └── log.md.tmpl ``` -### 3.2 Skills 实现 - -- **`create-feature`**: 用户描述需求 → AI 通过 PRD 讨论提炼 → 生成 `meta.yaml`（自动填充 id、title、owner、priority、status=planning、dates）+ `design.md`（初始 draft 模板）+ `plan.md`（空结构）+ `log.md`（初始化记录） +### 1.2 Schema 定义（插件内共享） +- 定义 `SupercrewStatus` 枚举：`planning → designing → ready → active → blocked → done` +- 定义 `FeaturePriority`: `P0 | P1 | P2 | P3` +- `.supercrew/features//` 下 4 个文件： + - `meta.yaml`：必填字段 `id`, `title`, `status`, `owner`, `priority`；可选 `teams`, `target_release`, `created`, `updated`, `tags`, `blocked_by` + - `design.md`：YAML frontmatter（`status: draft|in-review|approved|rejected`, `reviewers`, `approved_by`）+ markdown body + - `plan.md`：YAML frontmatter（`total_tasks`, `completed_tasks`, `progress`）+ workitem breakdown markdown + - `log.md`：纯 markdown 追加日志 + +### 1.3 Skills 实现 +- **`create-feature`**: 用户描述需求 → AI 通过 PRD 讨论提炼 → 在 `.supercrew/features//` 下生成 `meta.yaml`（自动填充 id、title、owner、priority、status=planning、dates）+ `design.md`（初始 draft 模板）+ `plan.md`（空结构）+ `log.md`（初始化记录） - **`update-status`**: 根据代码/commit 状态自动判断并更新 `meta.yaml` 中的 status 字段，遵循合法状态转换图 - **`sync-plan`**: 在 design 完成后，基于 `design.md` 内容生成 `plan.md` 中的 task breakdown；coding 阶段持续更新 `completed_tasks`/`progress` - **`log-progress`**: 每次 session 结束时自动追加 `log.md`，记录本次工作内容、完成的 tasks、遇到的问题 -### 3.3 Hooks - +### 1.4 Hooks - **SessionStart**: 检测当前 repo 是否有 `.supercrew/features/` → 有则注入所有 feature 的 meta 信息到 context → 提示 AI 当前活跃 feature 和进度 - **pre-commit hook**: 校验 `.supercrew/features/*/meta.yaml` 的 schema 合法性（必填字段、status 枚举值、priority 枚举值）；校验 `plan.md` frontmatter 的 `total_tasks ≥ completed_tasks` -### 3.4 Commands - +### 1.5 Commands - **`/new-feature`**: 触发 `create-feature` skill，交互式创建新 feature - **`/feature-status`**: 显示所有 feature 的当前状态概览（表格形式：id | title | status | progress | owner） -### 3.5 Agent - +### 1.6 Agent - **`supercrew-manager`**: 综合 agent，可以执行所有 skills，负责在适当时机自动调用 `update-status`、`sync-plan`、`log-progress` --- +## Phase 2: Schema 基础设施 — 后端（只读） + +**目标：** Kanban 后端通过 GitHub API（OAuth）只读访问用户 repo 中的 `.supercrew/features/` 数据。不提供任何写入 API。 + +### 2.1 定义 TypeScript 类型 +- 基于 commit `62cd395f` 的 `SupercrewStatus`、`FeatureMeta` 类型，在 `kanban/backend/src/types/index.ts` 中替换现有 `Task`/`Sprint` 等类型 +- 新增类型：`FeatureMeta`（meta.yaml）、`DesignDoc`（design.md frontmatter + body）、`PlanDoc`（plan.md frontmatter + tasks breakdown）、`FeatureLog`（log.md） +- 定义 `SupercrewStatus`、`FeaturePriority` 类型（与插件 schema 保持一致） +- 使用 `zod` 做读取时的运行时校验（解析 meta.yaml 时验证字段合法性） + +### 2.2 重写 GitHub Store（只读） +- 将 `kanban/backend/src/store/github-store.ts` 改为通过 GitHub Contents API **只读** 访问 `.supercrew/features/` 路径 +- 复用现有的 `ghGet` pattern，路径从 `.team/tasks/` 改为 `.supercrew/features//` +- 实现：`listFeatures()`（列出所有 feature 目录）、`getFeatureMeta(id)`、`getFeatureDesign(id)`、`getFeaturePlan(id)`、`getFeatureLog(id)` +- 移除所有 `ghPut`/`ghDelete` 调用 — Kanban 不写入用户 repo + +### 2.3 重写 Local Store（只读，仅开发调试用） +- 将 `kanban/backend/src/store/index.ts` 改为只读访问本地 `.supercrew/features/` 目录 +- 用于本地开发时 mock 数据（读取本地 `.supercrew/features/` 目录中的文件） +- 不包含任何写入逻辑 + +### 2.4 重写 API Routes（只读） +- 将 `kanban/backend/src/routes/` 下的 `tasks.ts`、`sprints.ts`、`people.ts`、`knowledge.ts`、`decisions.ts` 合并/替换为： + - `features.ts`：**仅 GET 端点** + - `GET /api/features` — 列出所有 features（meta 摘要） + - `GET /api/features/:id` — 获取单个 feature 完整信息 + - `GET /api/features/:id/design` — 获取 design.md + - `GET /api/features/:id/plan` — 获取 plan.md（含 progress） + - `GET /api/board` — 聚合 endpoint，将 features 按 status 映射到看板列 +- 保留 auth 路由（`auth.ts`）和 projects 路由（`projects.ts`：OAuth 绑定 repo）不变 +- 移除 `SUPERCREW_DEMO` 环境变量守卫 +- `GET /api/projects/github/repos/:owner/:repo/init-status` 改为检查 `.supercrew/features/` 是否存在 +- 移除 `POST /api/projects/github/repos/:owner/:repo/init` — 不再由 Kanban 服务初始化 + +### 2.5 删除遗留代码 +- 移除 `.team/` 相关的所有 store 逻辑、路由、类型 +- 移除 `Sprint`、`Person`、`KnowledgeEntry`、`Decision` 类型（MVP 阶段只聚焦 Feature） +- 清理 `index.ts` 中的路由注册 + +--- + +## Phase 3: 前端看板重构（只读） + +**目标：** 用 feature-centric 只读视图替代现有 task-centric 看板。不提供任何数据修改操作。 + +### 3.1 数据层重构 +- 更新 `kanban/frontend/packages/app-core/src/types.ts`：用 `Feature`（含 meta + design status + plan progress）替代 `Task`/`Sprint` 等 +- 更新 `kanban/frontend/packages/app-core/src/api.ts`：仅保留只读 API 调用 + - `fetchFeatures()` — 获取所有 features 列表 + - `fetchFeature(id)` — 获取单个 feature 详情 + - `fetchFeatureDesign(id)` — 获取 design.md + - `fetchFeaturePlan(id)` — 获取 plan.md + - `fetchBoard()` — 获取看板聚合数据 +- 移除所有 `create`/`update`/`delete` 相关的 API 调用和 mutations +- 更新 `useBoard()` hook：返回 `{ features, featuresByStatus, isLoading, error }` +- 移除 `useMutations()` hook — 看板无写操作 + +### 3.2 看板主视图 +- 重构 `kanban/frontend/packages/ui/` 中的 `KanbanBoard` 组件 +- 6 列布局对应 status：`Planning | Designing | Ready | Active | Blocked | Done` +- Feature 卡片显示：`title`、`priority` badge（P0 红/P1 橙/P2 蓝/P3 灰）、`owner`、`teams` tags、plan `progress` 进度条 +- **无拖拽功能** — 看板只读，status 变更由 Claude Code 插件在用户 repo 中完成 +- 参考 vibe-kanban 的卡片 UI 风格：简洁、信息密度高 +- 点击卡片 → 跳转 Feature 详情页 + +### 3.3 Feature 详情页 +- 新建 `/features/:id` 路由，替代原 `/tasks/:id` +- 三 Tab 布局：**Overview**（meta.yaml 渲染：owner、priority、teams、target_release、tags、dates）、**Design**（design.md markdown 渲染 + status/reviewer 信息）、**Plan**（plan.md 渲染：进度条 + task checklist 可视化，类似 societas floating todo bar） +- Design tab 显示 review status badge（draft/in-review/approved/rejected） +- Plan tab 显示 `completed_tasks/total_tasks` 进度 + 每个 workitem 的完成状态 +- 所有内容只读展示，不提供编辑功能 + +### 3.4 FRE 与空状态处理 +- 更新 Welcome wizard：OAuth 登录 → Select Repo（绑定已有 repo） +- **不再提供 Init 功能** — `.supercrew/` 目录由 Claude Code 插件创建 +- 空状态处理： + - repo 中不存在 `.supercrew/features/` → 显示空看板 + 引导提示："请在该 repo 中安装 SuperCrew 插件并使用 `/new-feature` 创建第一个 feature" + - repo 中存在 `.supercrew/features/` 但内容为空 → 类似引导 + +### 3.5 清理遗留页面 +- 移除 `/people`、`/knowledge`、`/decisions` 页面和底部导航对应入口 +- 移除拖拽相关组件和依赖（`@hello-pangea/dnd` 可移除） +- 底部导航简化为：**Board**（feature 看板） +- 保留 dark/light theme 和 i18n + +--- + ## Phase 4: 集成与测试 -### 4.1 后端测试 -- 为 supercrew-store 写单元测试（vitest）：CRUD、status 流转校验、schema 校验 -- 为 features API 写集成测试：HTTP 层面的 CRUD + auth +### 4.1 插件测试 +- 在 Claude Code 中加载插件 → 执行 `/new-feature` → 验证 `.supercrew/features//` 下 4 个文件正确生成 +- 测试 `/feature-status` 输出 +- 测试 `update-status`、`sync-plan`、`log-progress` skills +- 测试 pre-commit hook schema 校验（故意写错 meta.yaml → 应拦截 commit） +- 测试 SessionStart hook 注入 context + +### 4.2 后端测试 +- 为 supercrew GitHub store 写单元测试（vitest）：只读列出 features、解析 meta.yaml/design.md/plan.md +- 为 features API 写集成测试：只读 GET 端点 + auth +- 测试 `.supercrew/` 不存在时返回空数组 -### 4.2 前端测试 +### 4.3 前端测试 - Feature card 组件测试 -- Board 视图 + 拖拽测试 +- Board 视图测试（6 列布局、正确分组） - Feature 详情页 Tab 切换测试 - -### 4.3 端到端集成测试 -- 用真实 GitHub repo 测试完整 flow：OAuth → init `.supercrew/` → create feature → update status → view on board -- 用 Claude Code 测试插件 flow：安装插件 → `/new-feature` → coding → plan 自动更新 → commit（pre-commit hook 校验） - -### 4.4 部署验证 -- Vercel 部署验证：确保 GitHub store 正确读写 `.supercrew/` 路径 +- 空状态 UI 测试（无 `.supercrew/` 时的引导状态） + +### 4.4 端到端集成测试 +- 完整 flow： + 1. 用户 repo A 安装 Claude Code 插件 + 2. 在 repo A 中使用 `/new-feature` 创建 feature + 3. `git commit && git push` 到 main + 4. 在 Kanban 网页中 OAuth 绑定 repo A + 5. 看板正确显示 feature 数据 + 6. 在 repo A 中用插件更新 status/plan → push → 看板数据刷新 + +### 4.5 部署验证 +- Vercel 部署验证：确保 GitHub store 正确只读访问 `.supercrew/` 路径 - 运行 `kanban/scripts/verify-before-deploy.sh` --- @@ -152,8 +209,8 @@ plugins/supercrew/ ## Verification - `cd kanban && bun test` — 后端单元测试 - `cd kanban/frontend && pnpm test` — 前端测试 -- 手动测试：选择一个 test repo → 通过 kanban FRE 初始化 `.supercrew/` → 创建 feature → 在看板上拖拽 → 查看详情页 -- 插件测试：在 Claude Code 中加载插件 → 执行 `/new-feature` → 验证文件生成 → commit 触发 pre-commit hook +- 插件测试：在 Claude Code 中加载插件 → 执行 `/new-feature` → 验证文件生成 → commit 触发 pre-commit hook → push 到 main +- 端到端测试：在 test repo 中用插件创建 feature + push → 在 Kanban 网页 OAuth 绑定该 repo → 看板正确展示 feature 数据 → 查看详情页 --- @@ -164,3 +221,7 @@ plugins/supercrew/ - **Sprint/People/Knowledge/Decisions 移除**：MVP 聚焦 feature lifecycle，这些概念不在 `.supercrew/` schema 中，不保留。 - **log.md 保留**：虽然讨论文档未提及，但 demo 分支已实现，作为 AI context 很有价值，保留。 - **Design review 纳入 MVP**：`design.md` 的 `status/reviewer/approved_by` 字段保留，在详情页展示。在 pre-commit hook 中不强制校验。 +- **Kanban 完全只读**：看板服务不写入用户 repo，所有数据变更由 Claude Code 插件在本地完成后 push。 +- **插件优先开发**：Phase 顺序调整为插件→后端→前端，因为没有插件就没有数据可读。 +- **无 Init API**：Kanban 不负责初始化 `.supercrew/` 目录，由插件负责。看板对未初始化的 repo 显示空状态 + 引导。 +- **无拖拽**：看板只读，不提供拖拽修改 status 的功能。 From fea32c91cf7a2bc82a0ad2956d3cff2334638e78 Mon Sep 17 00:00:00 2001 From: He Zhang Date: Tue, 3 Mar 2026 18:32:39 +0800 Subject: [PATCH 03/14] update prd --- .tmp/prd.md | 123 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 123 insertions(+) diff --git a/.tmp/prd.md b/.tmp/prd.md index ed4d1a2..27c4971 100644 --- a/.tmp/prd.md +++ b/.tmp/prd.md @@ -225,3 +225,126 @@ plugins/supercrew/ - **插件优先开发**：Phase 顺序调整为插件→后端→前端，因为没有插件就没有数据可读。 - **无 Init API**：Kanban 不负责初始化 `.supercrew/` 目录，由插件负责。看板对未初始化的 repo 显示空状态 + 引导。 - **无拖拽**：看板只读，不提供拖拽修改 status 的功能。 +- **MVP 不含 Sprint**：30 人团队未来需要时间节奏，但 MVP 先聚焦 feature lifecycle。Sprint 机制在 Post-MVP 迭代中引入（见 Next Steps）。 +- **上线/Release 协调 Post-MVP**：MVP 不包含 release train 或 deployment 协调功能。Post-MVP 根据团队实际需求决定是否引入。 + +--- + +## Next Steps — Post-MVP 迭代规划 + +MVP 解决了 Layer 2（团队协调层）中"项目管理可见性"和"设计/文档强制性"两大核心缺口。以下迭代聚焦补齐剩余 gap：**跨组协调**、**时间节奏（Sprint）**、**Agent 能力深化**、**上线协调**。 + +### Iteration 1: supercrew-manager Agent 能力增强 + +MVP 的 `supercrew-manager` agent 描述过于简略。参考 `ddd-tech-lead` agent 的设计深度，迭代 1 补充完整的 agent prompt 设计： + +#### 1.1 决策指引框架 +- **Feature 识别**：用户描述需求时，自动判断是新建 feature 还是归属已有 feature +- **状态推断规则**：根据代码变更、commit 内容、test 结果自动推断 status 转换（例：design.md status 从 draft → approved 后，自动建议 feature status 从 designing → ready） +- **优先级升降规则**：根据 `blocked_by` 依赖链和 deadline 接近程度，主动提醒优先级调整 +- **Context 注入策略**：SessionStart 时不只列出 feature 列表，而是智能摘要——突出 blocked features、临近 deadline 的 features、长期无更新的 features + +#### 1.2 自检清单（Self-Verification） +Agent 在每次操作前/后执行自检： +1. 目标 feature 文件夹是否存在？不存在是否应创建？ +2. `meta.yaml` 中所有必填字段是否完整？ +3. `plan.md` 的 `completed_tasks` 是否与实际 checklist 一致？ +4. `log.md` 是否已记录本次 session 的工作内容？ +5. 是否有 `blocked_by` 指向的 feature 已经完成但未更新？ +6. 是否有跨 feature 的架构影响需要在 `design.md` 中记录？ + +#### 1.3 主动行为（Proactive Behaviors） +- 检测到用户长时间在某 feature 上工作但未更新 `log.md` → 主动提醒记录 +- 检测到 `plan.md` 中 `completed_tasks` 落后于实际 commit → 主动建议同步 +- 检测到多个 features 的 `blocked_by` 形成环形依赖 → 告警 +- Session 结束前自动执行 `log-progress` skill +- 检测到新 feature 的 `design.md` 仍为 draft 但 status 已到 active → 警告跳过设计审查 + +#### 1.4 沟通风格 +- 状态更新简洁直接，用结构化格式（表格、列表） +- 关键决策需提供上下文说明 +- 需求模糊时主动提出澄清问题 +- 区分 Critical/Important/Minor 事项 + +### Iteration 2: Sprint 机制引入 + +为 30 人团队引入时间节奏，在 feature 下嵌套 Sprint 结构： + +#### 2.1 Schema 扩展 +``` +.supercrew/ + features/ + feature-a/ + meta.yaml + design.md + plan.md + log.md + sprints/ # 新增 + sprint_260303/ # YYMMDD 格式 + goals.md # Sprint 目标 + tasks.md # 本 Sprint 的 task breakdown + 状态 + retro.md # Sprint 回顾（可选） +``` + +- `meta.yaml` 新增可选字段：`current_sprint: sprint_260303` +- `tasks.md` 结构：YAML frontmatter（`sprint_start`, `sprint_end`, `velocity_planned`, `velocity_actual`）+ task checklist（每项含 assignee、status、estimate） +- `goals.md`：本 Sprint 在该 feature 上要达成的目标 +- `retro.md`：Sprint 结束时由 AI 自动生成回顾摘要 + +#### 2.2 插件新增 Skills +- **`create-sprint`**：在指定 feature 下创建 `sprints/sprint_YYMMDD/` 目录 + 初始文件 +- **`close-sprint`**：汇总完成情况，生成 `retro.md`，更新 `plan.md` progress +- **`sprint-status`**：展示当前 Sprint 的 task 完成情况 + +#### 2.3 看板前端扩展 +- Feature 详情页新增 **Sprint** Tab：展示当前 Sprint 的 task 列表、进度、燃尽图 +- 看板卡片可展示当前 Sprint 进度（可选 toggle） +- Sprint 历史视图：查看历次 Sprint 的 velocity 趋势 + +#### 2.4 Commands +- **`/new-sprint`**：在当前 feature 下创建新 Sprint +- **`/sprint-review`**：展示当前 Sprint 摘要 + 建议关闭 + +### Iteration 3: 跨 Feature 协调与依赖可视化 + +解决"小组之间不通气"的核心问题： + +#### 3.1 依赖图可视化 +- 前端新增 **Dependencies** 视图：基于所有 features 的 `blocked_by` 字段，渲染有向依赖图 +- 高亮环形依赖（红色标注） +- 高亮关键路径（影响最多下游 feature 的上游） + +#### 3.2 `notes.md` 引入 +- 在 feature 文件中新增 `notes.md`：用于非结构化的研究笔记、讨论记录、补充上下文（参考 DDD 的 `notes.md`） +- `log.md` 保持时间线追加语义，`notes.md` 用于随意记录 + +#### 3.3 跨 Feature 变更通知 +- 看板前端新增简单的 **Activity Feed**：聚合所有 features 的最近变更（基于 git commit 时间戳 + log.md 最新条目） +- 按团队（`teams` 字段）筛选 feed，实现"看到其他组在做什么" + +#### 3.4 架构治理 +- 新增 `.supercrew/architecture/` 目录（可选）：存放全局 ADR（Architecture Decision Records） +- Agent 在 `design.md` 涉及跨 feature 架构变更时，自动建议创建/更新 ADR + +### Iteration 4: Release 协调 + +解决"上线难度高"的问题： + +#### 4.1 Release 概念引入 +- 新增 `.supercrew/releases/` 目录：每个 release 一个文件夹 +- `release.yaml`：`version`, `target_date`, `features[]`（包含的 feature id 列表）, `status`（planning/staging/released） +- 看板新增 **Release** 视图：按 release 分组展示 features 及其就绪状态 + +#### 4.2 Release Readiness 检查 +- Agent 新增 **`release-check`** skill：扫描 release 中所有 features，检查是否全部 `status=done`、`design.md` approved、`plan.md` progress=100% +- 前端展示 release readiness dashboard（红/黄/绿信号灯） + +### 迭代优先级与时间线 + +| 迭代 | 聚焦 | 解决的 Layer 2 问题 | 建议时间 | +|---|---|---|---| +| **MVP** | Feature lifecycle + 只读看板 | 项目管理、设计/文档 | 当前 | +| **Iter 1** | Agent 能力增强 | 提升自动化程度，减少人工维护负担 | MVP 后 1-2 周 | +| **Iter 2** | Sprint 机制 | 时间节奏、任务粒度管理 | Iter 1 后 2-3 周 | +| **Iter 3** | 跨 Feature 协调 | 小组不通气、架构治理 | Iter 2 后 2-3 周 | +| **Iter 4** | Release 协调 | 上线难度高 | Iter 3 后 2-3 周 | From 6e07b8fa4e71265cc900184998609b6297b0e982 Mon Sep 17 00:00:00 2001 From: He Zhang Date: Tue, 3 Mar 2026 19:18:26 +0800 Subject: [PATCH 04/14] update prd --- .tmp/prd.md | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/.tmp/prd.md b/.tmp/prd.md index 27c4971..deaf665 100644 --- a/.tmp/prd.md +++ b/.tmp/prd.md @@ -1,6 +1,6 @@ # SuperCrew MVP — `.supercrew/` Schema + Kanban + AI Plugin -**TL;DR:** 基于 `user/steinsz/supercrew_schema` 分支的 demo 实现，将 kanban 从 `.team/` 资源导向 完全迁移到 `.supercrew/features/` feature 导向的数据模型。MVP 包含三大模块：(1) AI 集成插件（skills + hooks + pre-commit）在用户 repo 中创建和管理 `.supercrew/` 目录，(2) 后端通过 GitHub API（OAuth）只读访问用户 repo 中的 `.supercrew/` 数据，(3) 前端看板以只读方式渲染 feature-centric 视图。参考 [superpowers](https://github.com/obra/superpowers) 的插件架构和 [vibe-kanban](https://github.com/BloopAI/vibe-kanban) 的 issue→workspace 模式。 +**TL;DR:** 基于 `user/steinsz/supercrew_schema` 分支的 demo 实现，将 kanban 从 `.team/` 资源导向 完全迁移到 `.supercrew/features/` feature 导向的数据模型。MVP 包含三大模块：(1) AI 集成插件（skills + hooks + pre-commit）在用户 repo 中创建和管理 `.supercrew/` 目录，(2) 后端通过 GitHub API（OAuth）只读访问用户 repo 中的 `.supercrew/` 数据，(3) 前端看板以只读方式渲染 feature-centric 视图。参考 [superpowers](https://github.com/obra/superpowers) 的插件架构和 [vibe-kanban](https://github.com/BloopAI/vibe-kanban) 的 issue→workspace 模式。插件在 monorepo 的 `plugins/supercrew/` 子目录开发，MVP 阶段通过绝对路径加载（`/plugin marketplace add /path/to/supercrew/plugins/supercrew`），Post-MVP 抽取为独立 repo 后发布到 marketplace。 ### 数据流架构 @@ -30,7 +30,12 @@ ## Phase 1: AI 集成插件（数据写入方） -**目标：** 创建独立插件，在用户 repo 中自动创建和管理 `.supercrew/` 目录。这是唯一的数据写入方。参考 superpowers 的 skills/hooks/commands 架构，独立发布到 marketplace。 +**目标：** 在 monorepo 的 `plugins/supercrew/` 子目录下创建 Claude Code 插件，在用户 repo 中自动创建和管理 `.supercrew/` 目录。这是唯一的数据写入方。参考 superpowers 的 skills/hooks/commands 架构。 + +**Monorepo 策略：** 插件代码保留在 `plugins/supercrew/`，与 `kanban/` 共存于同一 repo。Claude Code marketplace 要求 plugin 为独立 repo（整个 repo = plugin 根目录），因此： +- **MVP 阶段**：通过绝对路径加载 — `/plugin marketplace add /path/to/supercrew/plugins/supercrew`（在任意 repo 中均可安装），`plugins/supercrew/` 内含 `.claude-plugin/marketplace.json`（`"source": "./"`），结构与独立 repo 一致 +- **Post-MVP**：将 `plugins/supercrew/` 抽取为独立 repo（如 `supercrew-plugin`），注册到 marketplace，用户可通过 `/plugin install supercrew@marketplace` 安装 +- **目录结构已按独立 repo 标准设计**，抽取时无需重构 ### 1.1 插件目录结构 ``` @@ -217,7 +222,7 @@ plugins/supercrew/ ## Decisions - **`.team/` 完全弃用**：MVP 不做兼容，直接替换。简化实现复杂度。 - **Feature-centric 而非 Task-centric**：看板的最小单位是 feature，不再是 task。Task 作为 plan.md 内的 checklist 存在。 -- **插件独立于 superpowers**：降低耦合，独立发布到 marketplace。Post-MVP 可以与 superpowers 融合。 +- **插件在 monorepo 子目录开发**：`plugins/supercrew/` 保留在 monorepo 中，MVP 通过绝对路径加载 `/plugin marketplace add /path/to/supercrew/plugins/supercrew`（在任意 repo 中均可安装）。目录结构按独立 repo 标准设计（`.claude-plugin/` 在 `plugins/supercrew/` 根），Post-MVP 抽取为独立 repo 后可直接发布到 marketplace，无需重构。 - **Sprint/People/Knowledge/Decisions 移除**：MVP 聚焦 feature lifecycle，这些概念不在 `.supercrew/` schema 中，不保留。 - **log.md 保留**：虽然讨论文档未提及，但 demo 分支已实现，作为 AI context 很有价值，保留。 - **Design review 纳入 MVP**：`design.md` 的 `status/reviewer/approved_by` 字段保留，在详情页展示。在 pre-commit hook 中不强制校验。 From e89048baee61575c23f93153da5d982d8b5d3790 Mon Sep 17 00:00:00 2001 From: He Zhang Date: Tue, 3 Mar 2026 20:17:41 +0800 Subject: [PATCH 05/14] update prd --- .tmp/prd.md | 21 +++++++++++++++++---- 1 file changed, 17 insertions(+), 4 deletions(-) diff --git a/.tmp/prd.md b/.tmp/prd.md index deaf665..0e867b1 100644 --- a/.tmp/prd.md +++ b/.tmp/prd.md @@ -77,12 +77,18 @@ plugins/supercrew/ - **`log-progress`**: 每次 session 结束时自动追加 `log.md`，记录本次工作内容、完成的 tasks、遇到的问题 ### 1.4 Hooks -- **SessionStart**: 检测当前 repo 是否有 `.supercrew/features/` → 有则注入所有 feature 的 meta 信息到 context → 提示 AI 当前活跃 feature 和进度 +- **SessionStart**: 检测当前 repo 是否有 `.supercrew/features/` → 有则执行 **Active Feature 匹配**，确定当前 session 聚焦的 feature： + 1. **Git branch 名匹配**（优先）：当前分支名 `feature/` → 自动关联 `.supercrew/features//`，注入该 feature 的完整 context（meta + design + plan progress + 最近 log）。无论是普通 checkout 还是 git worktree 均适用（均通过 `git branch --show-current` 读取） + 2. **用户显式选择**：无匹配时，列出所有 `status != done` 的 features 摘要表（id | title | status | progress），请求用户确认："当前 session 聚焦哪个 feature？" + 3. 确认后，后续 `update-status`、`sync-plan`、`log-progress` 等 skill 自动作用于该 feature + 4. 始终注入所有 feature 的简要列表到 context（确保 AI 知道全局状态），但仅对 active feature 注入详细信息 + - **注**：MVP 不强制使用 git worktree，branch 匹配对 checkout 和 worktree 均兼容。Worktree 自动化生命周期管理在 Post-MVP 引入（见 Next Steps Iteration 1） - **pre-commit hook**: 校验 `.supercrew/features/*/meta.yaml` 的 schema 合法性（必填字段、status 枚举值、priority 枚举值）；校验 `plan.md` frontmatter 的 `total_tasks ≥ completed_tasks` ### 1.5 Commands - **`/new-feature`**: 触发 `create-feature` skill，交互式创建新 feature - **`/feature-status`**: 显示所有 feature 的当前状态概览（表格形式：id | title | status | progress | owner） +- **`/work-on `**: 切换当前 session 聚焦的 feature（覆盖 SessionStart 的自动匹配结果），后续所有 skill 操作自动作用于该 feature ### 1.6 Agent - **`supercrew-manager`**: 综合 agent，可以执行所有 skills，负责在适当时机自动调用 `update-status`、`sync-plan`、`log-progress` @@ -239,9 +245,9 @@ plugins/supercrew/ MVP 解决了 Layer 2（团队协调层）中"项目管理可见性"和"设计/文档强制性"两大核心缺口。以下迭代聚焦补齐剩余 gap：**跨组协调**、**时间节奏（Sprint）**、**Agent 能力深化**、**上线协调**。 -### Iteration 1: supercrew-manager Agent 能力增强 +### Iteration 1: supercrew-manager Agent 能力增强 + Worktree 自动化 -MVP 的 `supercrew-manager` agent 描述过于简略。参考 `ddd-tech-lead` agent 的设计深度，迭代 1 补充完整的 agent prompt 设计： +MVP 的 `supercrew-manager` agent 描述过于简略。参考 `ddd-tech-lead` agent 的设计深度，迭代 1 补充完整的 agent prompt 设计。同时引入 git worktree 自动化，消除 MVP 阶段手动管理分支的摩擦。 #### 1.1 决策指引框架 - **Feature 识别**：用户描述需求时，自动判断是新建 feature 还是归属已有 feature @@ -271,6 +277,13 @@ Agent 在每次操作前/后执行自检： - 需求模糊时主动提出澄清问题 - 区分 Critical/Important/Minor 事项 +#### 1.5 Git Worktree 自动化 +MVP 阶段用户手动管理分支，Iter 1 引入 worktree 自动化生命周期管理，消除手动操作摩擦： +- **`/new-feature` 增强**：创建 feature 时自动执行 `git worktree add .worktrees/ feature/` + 安装依赖 + 提示用户在新窗口打开该目录 +- **`/close-feature `**（新增 command）：merge/PR + `git worktree remove` + 清理分支，用户无需了解 worktree 命令 +- **SessionStart hook** 在 worktree 下天然准确匹配 active feature（每个 worktree 锁定一个 branch，不存在 session 中途切分支的问题） +- 兼容 superpowers 的 `using-git-worktrees` skill + ### Iteration 2: Sprint 机制引入 为 30 人团队引入时间节奏，在 feature 下嵌套 Sprint 结构： @@ -349,7 +362,7 @@ Agent 在每次操作前/后执行自检： | 迭代 | 聚焦 | 解决的 Layer 2 问题 | 建议时间 | |---|---|---|---| | **MVP** | Feature lifecycle + 只读看板 | 项目管理、设计/文档 | 当前 | -| **Iter 1** | Agent 能力增强 | 提升自动化程度，减少人工维护负担 | MVP 后 1-2 周 | +| **Iter 1** | Agent 能力增强 + Worktree 自动化 | 提升自动化程度，减少人工维护负担，消除分支管理摩擦 | MVP 后 1-2 周 | | **Iter 2** | Sprint 机制 | 时间节奏、任务粒度管理 | Iter 1 后 2-3 周 | | **Iter 3** | 跨 Feature 协调 | 小组不通气、架构治理 | Iter 2 后 2-3 周 | | **Iter 4** | Release 协调 | 上线难度高 | Iter 3 后 2-3 周 | From 9b25b1fe2e9492ecaf279ab4806d4db6cb4cee6b Mon Sep 17 00:00:00 2001 From: He Zhang Date: Tue, 3 Mar 2026 20:29:01 +0800 Subject: [PATCH 06/14] update prd --- .tmp/prd.md | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/.tmp/prd.md b/.tmp/prd.md index 0e867b1..e016cc9 100644 --- a/.tmp/prd.md +++ b/.tmp/prd.md @@ -45,15 +45,14 @@ plugins/supercrew/ │ ├── create-feature/SKILL.md # 创建 feature 目录 + 4 文件 │ ├── update-status/SKILL.md # 状态流转 │ ├── sync-plan/SKILL.md # 生成/更新 plan.md -│ └── log-progress/SKILL.md # 追加 log.md +│ ├── log-progress/SKILL.md # 追加 log.md +│ └── managing-features/SKILL.md # 综合管理 skill，自动协调上述 skills ├── commands/ │ ├── new-feature.md # /new-feature slash command │ └── feature-status.md # /feature-status slash command ├── hooks/ │ ├── hooks.json # SessionStart hook │ └── session-start # 注入 .supercrew context -├── agents/ -│ └── supercrew-manager.md # 综合管理 agent └── templates/ ├── meta.yaml.tmpl ├── design.md.tmpl @@ -90,8 +89,12 @@ plugins/supercrew/ - **`/feature-status`**: 显示所有 feature 的当前状态概览（表格形式：id | title | status | progress | owner） - **`/work-on `**: 切换当前 session 聚焦的 feature（覆盖 SessionStart 的自动匹配结果），后续所有 skill 操作自动作用于该 feature -### 1.6 Agent -- **`supercrew-manager`**: 综合 agent，可以执行所有 skills，负责在适当时机自动调用 `update-status`、`sync-plan`、`log-progress` +### 1.6 Managing-Features Skill（综合管理） +- **`managing-features`**: 综合管理 skill，当 Claude 检测到用户在含 `.supercrew/features/` 的 repo 中工作时自动触发。负责在适当时机协调调用 `update-status`、`sync-plan`、`log-progress` 等子 skill，包括： + - 代码变更后自动建议更新 feature status + - design 完成后自动建议生成 plan + - session 结束前自动提醒记录 log + - 检测到状态不一致时主动提醒（如 `plan.md` progress 与实际 checklist 不符） --- From c83101e875067757d09fc67c48f85d4963d717f4 Mon Sep 17 00:00:00 2001 From: He Zhang Date: Tue, 3 Mar 2026 21:17:16 +0800 Subject: [PATCH 07/14] base implementation for supercrew skills and hooks --- .gitignore | 1 + .../supercrew/.claude-plugin/marketplace.json | 15 ++ plugins/supercrew/.claude-plugin/plugin.json | 12 ++ plugins/supercrew/README.md | 97 +++++++++++++ plugins/supercrew/commands/feature-status.md | 16 ++ plugins/supercrew/commands/new-feature.md | 6 + plugins/supercrew/commands/work-on.md | 21 +++ plugins/supercrew/hooks/hooks.json | 16 ++ plugins/supercrew/hooks/session-start | 137 ++++++++++++++++++ .../supercrew/skills/create-feature/SKILL.md | 126 ++++++++++++++++ .../supercrew/skills/log-progress/SKILL.md | 58 ++++++++ .../skills/managing-features/SKILL.md | 56 +++++++ plugins/supercrew/skills/sync-plan/SKILL.md | 69 +++++++++ .../supercrew/skills/update-status/SKILL.md | 70 +++++++++ .../supercrew/skills/using-supercrew/SKILL.md | 67 +++++++++ plugins/supercrew/templates/design.md.tmpl | 23 +++ plugins/supercrew/templates/log.md.tmpl | 7 + plugins/supercrew/templates/meta.yaml.tmpl | 11 ++ plugins/supercrew/templates/plan.md.tmpl | 14 ++ 19 files changed, 822 insertions(+) create mode 100644 plugins/supercrew/.claude-plugin/marketplace.json create mode 100644 plugins/supercrew/.claude-plugin/plugin.json create mode 100644 plugins/supercrew/README.md create mode 100644 plugins/supercrew/commands/feature-status.md create mode 100644 plugins/supercrew/commands/new-feature.md create mode 100644 plugins/supercrew/commands/work-on.md create mode 100644 plugins/supercrew/hooks/hooks.json create mode 100755 plugins/supercrew/hooks/session-start create mode 100644 plugins/supercrew/skills/create-feature/SKILL.md create mode 100644 plugins/supercrew/skills/log-progress/SKILL.md create mode 100644 plugins/supercrew/skills/managing-features/SKILL.md create mode 100644 plugins/supercrew/skills/sync-plan/SKILL.md create mode 100644 plugins/supercrew/skills/update-status/SKILL.md create mode 100644 plugins/supercrew/skills/using-supercrew/SKILL.md create mode 100644 plugins/supercrew/templates/design.md.tmpl create mode 100644 plugins/supercrew/templates/log.md.tmpl create mode 100644 plugins/supercrew/templates/meta.yaml.tmpl create mode 100644 plugins/supercrew/templates/plan.md.tmpl diff --git a/.gitignore b/.gitignore index cc14105..3881436 100644 --- a/.gitignore +++ b/.gitignore @@ -4,3 +4,4 @@ dist/ .env .env.local *.local +.ref diff --git a/plugins/supercrew/.claude-plugin/marketplace.json b/plugins/supercrew/.claude-plugin/marketplace.json new file mode 100644 index 0000000..397d2a4 --- /dev/null +++ b/plugins/supercrew/.claude-plugin/marketplace.json @@ -0,0 +1,15 @@ +{ + "name": "supercrew-dev", + "description": "Development marketplace for SuperCrew plugin — AI-driven feature lifecycle management", + "owner": { + "name": "steinsz" + }, + "plugins": [ + { + "name": "supercrew", + "description": "AI-driven feature lifecycle management. Creates and manages .supercrew/features/ directories with meta.yaml, design.md, plan.md, and log.md for structured feature development.", + "version": "0.1.0", + "source": "./" + } + ] +} diff --git a/plugins/supercrew/.claude-plugin/plugin.json b/plugins/supercrew/.claude-plugin/plugin.json new file mode 100644 index 0000000..5bd04b6 --- /dev/null +++ b/plugins/supercrew/.claude-plugin/plugin.json @@ -0,0 +1,12 @@ +{ + "name": "supercrew", + "description": "AI-driven feature lifecycle management. Creates and manages .supercrew/features/ directories with meta.yaml, design.md, plan.md, and log.md for structured feature development.", + "version": "0.1.0", + "author": { + "name": "steinsz" + }, + "homepage": "https://github.com/nicepkg/supercrew", + "repository": "https://github.com/nicepkg/supercrew", + "license": "MIT", + "keywords": ["feature-management", "kanban", "lifecycle", "planning", "tracking"] +} diff --git a/plugins/supercrew/README.md b/plugins/supercrew/README.md new file mode 100644 index 0000000..b842b97 --- /dev/null +++ b/plugins/supercrew/README.md @@ -0,0 +1,97 @@ +# SuperCrew Plugin + +AI-driven feature lifecycle management for Claude Code. Track features from idea to done using structured `.supercrew/features/` directories. + +## Quick Start + +### 1. Install the plugin + +```bash +# In Claude Code, run these 3 commands in order: + +# 1) Add the local marketplace (use absolute path to plugins/supercrew) +/plugin marketplace add /path/to/supercrew/plugins/supercrew + +# 2) Install the plugin from the local marketplace +/plugin install supercrew@supercrew-dev + +# 3) Verify installation — you should see supercrew listed +/plugin list +``` + +> Replace `/path/to/supercrew` with the actual absolute path to your supercrew repo clone. + +**Reinstall / Update:** + +```bash +/plugin uninstall supercrew@supercrew-dev +/plugin marketplace remove supercrew-dev +/plugin marketplace add /path/to/supercrew/plugins/supercrew +/plugin install supercrew@supercrew-dev +``` + +### 2. Create your first feature + +``` +/supercrew:new-feature +``` + +This creates `.supercrew/features//` with four files: + +| File | Purpose | +|---|---| +| `meta.yaml` | ID, title, status, priority, owner, dates | +| `design.md` | Requirements, architecture, constraints | +| `plan.md` | Task breakdown with checklist & progress | +| `log.md` | Chronological progress entries | + +### 3. Work on a feature + +``` +/supercrew:work-on +``` + +Or simply check out a matching branch — the SessionStart hook auto-detects `feature/` branches: + +```bash +git checkout -b feature/my-feature +``` + +### 4. Check status + +``` +/supercrew:feature-status +``` + +Displays a table of all tracked features with status, priority, and progress. + +## Feature Lifecycle + +``` +planning → designing → ready → active → blocked → done + ↑ | + └─────────┘ +``` + +## Skills + +| Skill | Triggers on | +|---|---| +| **using-supercrew** | Injected at session start — establishes behavior rules | +| **create-feature** | Creating a new feature | +| **update-status** | Status transitions (e.g. "mark as ready") | +| **sync-plan** | Generating or updating task breakdowns | +| **log-progress** | Recording what was done | +| **managing-features** | Auto-orchestrates lifecycle when `.supercrew/features/` exists | + +## Commands + +| Command | Description | +|---|---| +| `/supercrew:new-feature` | Create a new feature | +| `/supercrew:feature-status` | Show all features status | +| `/supercrew:work-on` | Switch active feature for this session | + +## Hooks + +- **SessionStart** — Scans `.supercrew/features/`, shows summary table, auto-loads active feature context based on current git branch. diff --git a/plugins/supercrew/commands/feature-status.md b/plugins/supercrew/commands/feature-status.md new file mode 100644 index 0000000..b8b7993 --- /dev/null +++ b/plugins/supercrew/commands/feature-status.md @@ -0,0 +1,16 @@ +--- +description: "Show the current status of all features tracked in .supercrew/features/. Displays a summary table with id, title, status, progress, priority, and owner." +disable-model-invocation: true +--- + +List all features in `.supercrew/features/` and display them in a table format: + +| ID | Title | Status | Priority | Progress | Owner | +|---|---|---|---|---|---| + +For each feature directory in `.supercrew/features/`: +1. Read `meta.yaml` for id, title, status, priority, owner +2. Read `plan.md` frontmatter for progress (completed_tasks/total_tasks) +3. Display the row + +If no `.supercrew/features/` directory exists, tell the user to create their first feature with `/supercrew:new-feature`. diff --git a/plugins/supercrew/commands/new-feature.md b/plugins/supercrew/commands/new-feature.md new file mode 100644 index 0000000..9ad63de --- /dev/null +++ b/plugins/supercrew/commands/new-feature.md @@ -0,0 +1,6 @@ +--- +description: "Create a new feature for tracking in .supercrew/features/. Guides through defining title, priority, owner, and generates meta.yaml, design.md, plan.md, and log.md." +disable-model-invocation: true +--- + +Invoke the supercrew:create-feature skill and follow it exactly as presented to you. diff --git a/plugins/supercrew/commands/work-on.md b/plugins/supercrew/commands/work-on.md new file mode 100644 index 0000000..4ee6453 --- /dev/null +++ b/plugins/supercrew/commands/work-on.md @@ -0,0 +1,21 @@ +--- +description: "Switch the active feature for this session. Usage: /work-on . All subsequent supercrew skill operations will target this feature." +disable-model-invocation: true +--- + +The user wants to switch the active feature for this session. + +1. Check if the user provided a feature ID argument. If not, list available features from `.supercrew/features/` and ask them to choose. +2. Verify the feature directory `.supercrew/features//` exists. +3. Read the feature's `meta.yaml`, `plan.md` progress, and last `log.md` entry. +4. Confirm to the user: + +``` +🔄 Switched active feature to: +📋 Title: +🏷️ Status: <status> | Priority: <priority> | Progress: <progress>% + +All supercrew skills will now operate on this feature. +``` + +5. For the rest of this session, treat this feature as the active feature for `update-status`, `sync-plan`, `log-progress`, and `managing-features` skills. diff --git a/plugins/supercrew/hooks/hooks.json b/plugins/supercrew/hooks/hooks.json new file mode 100644 index 0000000..e868739 --- /dev/null +++ b/plugins/supercrew/hooks/hooks.json @@ -0,0 +1,16 @@ +{ + "hooks": { + "SessionStart": [ + { + "matcher": "startup|resume|clear|compact", + "hooks": [ + { + "type": "command", + "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/session-start\"", + "async": false + } + ] + } + ] + } +} diff --git a/plugins/supercrew/hooks/session-start b/plugins/supercrew/hooks/session-start new file mode 100755 index 0000000..4f27726 --- /dev/null +++ b/plugins/supercrew/hooks/session-start @@ -0,0 +1,137 @@ +#!/usr/bin/env bash +# SessionStart hook for supercrew plugin +# Detects .supercrew/features/ and injects active feature context + +set -euo pipefail + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)" +PLUGIN_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)" + +# Read using-supercrew skill content for context injection +using_supercrew_content=$(cat "${PLUGIN_ROOT}/skills/using-supercrew/SKILL.md" 2>&1 || echo "Error reading using-supercrew skill") + +# Escape string for JSON embedding +escape_for_json() { + local s="$1" + s="${s//\\/\\\\}" + s="${s//\"/\\\"}" + s="${s//$'\n'/\\n}" + s="${s//$'\r'/\\r}" + s="${s//$'\t'/\\t}" + printf '%s' "$s" +} + +# Check if .supercrew/features/ exists in the current working directory +features_dir=".supercrew/features" +if [ ! -d "$features_dir" ]; then + # No .supercrew/features/ found — inject skill context with minimal project info + using_escaped=$(escape_for_json "$using_supercrew_content") + context="<EXTREMELY_IMPORTANT>\nYou have supercrew installed.\n\n**Below is the full content of your 'supercrew:using-supercrew' skill — your guide to feature lifecycle management. For all other skills, use the Skill tool:**\n\n${using_escaped}\n\nThis project does not have a .supercrew/features/ directory yet. If the user wants to start tracking features, suggest using /supercrew:new-feature.\n</EXTREMELY_IMPORTANT>" + escaped=$(escape_for_json "$context") + cat <<EOF +{ + "additional_context": "${escaped}", + "hookSpecificOutput": { + "hookEventName": "SessionStart", + "additionalContext": "${escaped}" + } +} +EOF + exit 0 +fi + +# --- .supercrew/features/ exists — build feature context --- + +# Get current branch for active feature matching +current_branch=$(git branch --show-current 2>/dev/null || echo "") +active_feature_id="" + +# Try to match branch name to feature ID (feature/<id> pattern) +if [[ "$current_branch" == feature/* ]]; then + candidate="${current_branch#feature/}" + if [ -d "$features_dir/$candidate" ]; then + active_feature_id="$candidate" + fi +fi + +# Build features summary table +features_summary="| ID | Title | Status | Priority | Progress | Owner |\n|---|---|---|---|---|---|" +feature_count=0 + +for feature_dir in "$features_dir"/*/; do + [ -d "$feature_dir" ] || continue + feature_count=$((feature_count + 1)) + + fid=$(basename "$feature_dir") + meta_file="$feature_dir/meta.yaml" + + if [ -f "$meta_file" ]; then + # Parse meta.yaml with simple grep/sed (no yq dependency) + title=$(grep '^title:' "$meta_file" | sed 's/^title: *"\{0,1\}\(.*\)"\{0,1\}$/\1/' | head -1) + status=$(grep '^status:' "$meta_file" | sed 's/^status: *//' | head -1) + priority=$(grep '^priority:' "$meta_file" | sed 's/^priority: *//' | head -1) + owner=$(grep '^owner:' "$meta_file" | sed 's/^owner: *"\{0,1\}\(.*\)"\{0,1\}$/\1/' | head -1) + + # Get progress from plan.md + plan_file="$feature_dir/plan.md" + progress="N/A" + if [ -f "$plan_file" ]; then + prog_val=$(grep '^progress:' "$plan_file" | sed 's/^progress: *//' | head -1) + if [ -n "$prog_val" ]; then + progress="${prog_val}%" + fi + fi + + features_summary="${features_summary}\n| ${fid} | ${title} | ${status} | ${priority} | ${progress} | ${owner} |" + fi +done + +# Build active feature detail context +active_detail="" +if [ -n "$active_feature_id" ] && [ -d "$features_dir/$active_feature_id" ]; then + active_meta="$features_dir/$active_feature_id/meta.yaml" + active_design="$features_dir/$active_feature_id/design.md" + active_plan="$features_dir/$active_feature_id/plan.md" + active_log="$features_dir/$active_feature_id/log.md" + + active_detail="\\n\\n## Active Feature: ${active_feature_id}\\n\\nMatched via branch: ${current_branch}\\n" + + if [ -f "$active_meta" ]; then + meta_content=$(cat "$active_meta") + active_detail="${active_detail}\\n### meta.yaml\\n\`\`\`yaml\\n$(escape_for_json "$meta_content")\\n\`\`\`" + fi + + # Include last 30 lines of log.md for recent context + if [ -f "$active_log" ]; then + log_tail=$(tail -30 "$active_log") + active_detail="${active_detail}\\n\\n### Recent Log (last 30 lines)\\n$(escape_for_json "$log_tail")" + fi + + # Include plan progress summary + if [ -f "$active_plan" ]; then + plan_header=$(head -10 "$active_plan") + active_detail="${active_detail}\\n\\n### Plan Progress\\n\`\`\`\\n$(escape_for_json "$plan_header")\\n\`\`\`" + fi +fi + +# Build no-match prompt +no_match_prompt="" +if [ -z "$active_feature_id" ] && [ "$feature_count" -gt 0 ]; then + no_match_prompt="\\n\\n**No active feature matched from branch '${current_branch}'.** Ask the user which feature they want to work on, or use /supercrew:work-on <feature-id> to set it." +fi + +# Compose full context with skill injection +using_escaped=$(escape_for_json "$using_supercrew_content") +context="<EXTREMELY_IMPORTANT>\\nYou have supercrew installed.\\n\\n**Below is the full content of your 'supercrew:using-supercrew' skill — your guide to feature lifecycle management. For all other skills, use the Skill tool:**\\n\\n${using_escaped}\\n</EXTREMELY_IMPORTANT>\\n\\n<supercrew-context>\\nThis project has ${feature_count} feature(s) tracked in .supercrew/features/.\\n\\n## All Features\\n${features_summary}${active_detail}${no_match_prompt}\\n</supercrew-context>" + +escaped=$(escape_for_json "$context") + +cat <<EOF +{ + "additional_context": "${escaped}", + "hookSpecificOutput": { + "hookEventName": "SessionStart", + "additionalContext": "${escaped}" + } +} +EOF diff --git a/plugins/supercrew/skills/create-feature/SKILL.md b/plugins/supercrew/skills/create-feature/SKILL.md new file mode 100644 index 0000000..881a445 --- /dev/null +++ b/plugins/supercrew/skills/create-feature/SKILL.md @@ -0,0 +1,126 @@ +--- +name: create-feature +description: "Use when the user wants to create a new feature, start a new project initiative, or when /new-feature command is invoked. Creates the .supercrew/features/<id>/ directory with meta.yaml, design.md, plan.md, and log.md." +--- + +# Create Feature + +## Overview + +Create a new feature in the `.supercrew/features/` directory. This skill guides the user through defining a feature, then generates the 4 required files. + +## Process + +### Step 1: Gather Feature Information + +Ask the user for the following (one question at a time): + +1. **Feature title** — a short, descriptive name (e.g., "User Authentication", "Dashboard Redesign") +2. **Feature ID** — suggest a kebab-case slug derived from the title (e.g., `user-auth`, `dashboard-redesign`). Let the user confirm or override. +3. **Priority** — P0 (critical) | P1 (high) | P2 (medium, default) | P3 (low) +4. **Owner** — who is responsible for this feature (default: current git user name) +5. **Brief description** — one sentence describing what this feature does and why + +### Step 2: Create Feature Directory and Files + +Create the directory `.supercrew/features/<feature-id>/` with 4 files. + +**Use the templates in the plugin's `templates/` directory as reference for file structure.** Read the templates first, then generate files with the gathered information filled in. + +#### File 1: `meta.yaml` + +```yaml +id: <feature-id> +title: "<title>" +status: planning +owner: "<owner>" +priority: <P0|P1|P2|P3> +teams: [] +tags: [] +created: "<YYYY-MM-DD>" +updated: "<YYYY-MM-DD>" +``` + +#### File 2: `design.md` + +```markdown +--- +status: draft +reviewers: [] +--- + +# <title> + +## Background + +<Brief description from user input> + +## Requirements + +<!-- To be refined during brainstorming --> + +## Design + +<!-- To be refined during brainstorming --> + +## Out of Scope + +<!-- To be defined --> +``` + +#### File 3: `plan.md` + +```markdown +--- +total_tasks: 0 +completed_tasks: 0 +progress: 0 +--- + +# <title> — Implementation Plan + +## Tasks + +- [ ] Task 1: (to be defined after design approval) +``` + +#### File 4: `log.md` + +```markdown +# <title> — Progress Log + +## <YYYY-MM-DD> — Feature Created + +- Feature initialized with status: `planning` +- Owner: <owner> +- Priority: <priority> +``` + +### Step 3: Confirm and Summarize + +After creating all files, present a summary: + +``` +✅ Feature created: <feature-id> +📁 Location: .supercrew/features/<feature-id>/ +📄 Files: meta.yaml, design.md, plan.md, log.md +🏷️ Status: planning | Priority: <priority> | Owner: <owner> + +Next steps: +- Use brainstorming to refine the design in design.md +- Once design is approved, use sync-plan to generate the implementation plan +``` + +## Validation Rules + +- Feature ID must be kebab-case (lowercase, hyphens only, no spaces) +- Feature ID must be unique (check `.supercrew/features/` for existing directories) +- Priority must be one of: P0, P1, P2, P3 +- Status is always `planning` for new features +- `created` and `updated` dates use YYYY-MM-DD format (today's date) + +## Important + +- Do NOT start implementation after creating the feature. The next step is brainstorming/design. +- If `.supercrew/features/` directory doesn't exist yet, create it. +- If `.supercrew/` directory doesn't exist yet, create it. diff --git a/plugins/supercrew/skills/log-progress/SKILL.md b/plugins/supercrew/skills/log-progress/SKILL.md new file mode 100644 index 0000000..1998c6d --- /dev/null +++ b/plugins/supercrew/skills/log-progress/SKILL.md @@ -0,0 +1,58 @@ +--- +name: log-progress +description: "Use at the end of a coding session or when significant work has been completed on a feature. Appends a structured entry to log.md recording what was done, tasks completed, and issues encountered." +--- + +# Log Progress + +## Overview + +Append a progress entry to the active feature's `log.md`. This creates a chronological record of work done across sessions. + +## When to Use + +- At the end of a coding session (before the user leaves) +- After completing one or more tasks from `plan.md` +- When encountering a significant blocker or making a key decision +- When the `managing-features` skill prompts you to log + +## Process + +### Step 1: Gather Session Context + +Automatically collect from the current session: + +1. **What was worked on** — summarize the main activities (files changed, features implemented, bugs fixed) +2. **Tasks completed** — which `plan.md` tasks were checked off this session +3. **Issues encountered** — any blockers, unexpected problems, or decisions made +4. **Next steps** — what should be done in the next session + +### Step 2: Append to `log.md` + +Add a new entry at the **end** of the file (entries are chronological): + +```markdown +## <YYYY-MM-DD> — <Brief summary of session> + +### Completed +- <what was accomplished> +- <tasks completed from plan> + +### Issues +- <any blockers or problems encountered> +- (none if no issues) + +### Next Steps +- <what to do next session> +``` + +### Step 3: Update Metadata + +- Update `meta.yaml` `updated` date to today + +## Rules + +- **Never overwrite** existing log entries — always **append** +- Keep entries concise but informative (someone reading the log should understand the feature's journey) +- If no issues were encountered, write "None" under Issues +- Always include Next Steps to give context for the next session diff --git a/plugins/supercrew/skills/managing-features/SKILL.md b/plugins/supercrew/skills/managing-features/SKILL.md new file mode 100644 index 0000000..65a9441 --- /dev/null +++ b/plugins/supercrew/skills/managing-features/SKILL.md @@ -0,0 +1,56 @@ +--- +name: managing-features +description: "Use when working in a project with .supercrew/features/ directory. Guides feature lifecycle management — coordinates status updates, plan syncing, and progress logging automatically throughout the session." +--- + +# Managing Features + +## Overview + +This skill provides lifecycle management guidance when working on a project that uses `.supercrew/features/`. It coordinates when to invoke other supercrew skills (`update-status`, `sync-plan`, `log-progress`) based on what's happening in the session. + +## Active Feature Context + +At session start, the SessionStart hook determines which feature is active. This skill operates on that active feature. Key context to be aware of: + +- **Active feature**: The feature this session is focused on (matched by branch name or user selection) +- **Feature status**: Current status from `meta.yaml` +- **Plan progress**: `completed_tasks / total_tasks` from `plan.md` +- **Last log entry**: Most recent entry from `log.md` + +## When to Trigger Other Skills + +### Trigger `update-status` + +- When `design.md` frontmatter `status` changes (e.g., `draft → approved` → suggest `designing → ready`) +- When user starts writing implementation code and feature is still in `ready` → suggest `ready → active` +- When all `plan.md` tasks are complete → suggest `active → done` +- When user mentions a blocker → suggest `active → blocked` + +### Trigger `sync-plan` + +- After design is approved and `plan.md` has no real tasks → generate task breakdown +- After completing tasks in code → update `plan.md` progress counters +- When user asks for progress update → sync and report + +### Trigger `log-progress` + +- When the session is ending (user says goodbye, wrapping up, etc.) +- When a significant milestone is reached (multiple tasks completed) +- When the user has been working for a while without a log entry + +## Proactive Checks + +During the session, periodically check for inconsistencies: + +1. **Status vs. reality**: Feature status says `planning` but user is writing code → suggest status update +2. **Progress drift**: `plan.md` `completed_tasks` doesn't match actual checked items → suggest sync +3. **Missing log**: Long session with no `log.md` entry → remind user to log before ending +4. **Design skip**: Feature jumped to `active` without `design.md` being `approved` → warn about skipping design review + +## Communication Style + +- Be concise — one-line suggestions, not paragraphs +- Frame as suggestions, not commands: "Would you like me to update the feature status to `active`?" +- Group related updates: "I'll update the status and sync the plan progress." +- Don't interrupt flow — wait for natural pauses (task completion, topic change) to suggest updates diff --git a/plugins/supercrew/skills/sync-plan/SKILL.md b/plugins/supercrew/skills/sync-plan/SKILL.md new file mode 100644 index 0000000..9ab2d1d --- /dev/null +++ b/plugins/supercrew/skills/sync-plan/SKILL.md @@ -0,0 +1,69 @@ +--- +name: sync-plan +description: "Use after design approval to generate or update plan.md with task breakdown, or during implementation to update completed_tasks and progress. Syncs plan.md with the current state of the feature." +--- + +# Sync Plan + +## Overview + +Generate or update `plan.md` for a feature. This skill operates in two modes: + +1. **Generate mode**: After design is approved, create the task breakdown from `design.md` +2. **Update mode**: During implementation, sync `completed_tasks` and `progress` with the actual checklist state + +## Mode 1: Generate Task Breakdown + +**When**: Feature status is `ready` (design approved) and `plan.md` has no real tasks yet. + +### Process + +1. Read `design.md` for the active feature +2. Break down the design into implementation tasks, each task should be: + - Small enough to complete in one coding session (roughly 2-5 minutes for an AI agent) + - Independently verifiable with a clear acceptance criterion + - Ordered by dependency (earlier tasks don't depend on later ones) +3. Write tasks as checkbox items in `plan.md`: + +```markdown +--- +total_tasks: <count> +completed_tasks: 0 +progress: 0 +--- + +# <title> — Implementation Plan + +## Tasks + +- [ ] Task 1: <description> + - File(s): `<file paths>` + - Acceptance: <how to verify this task is done> +- [ ] Task 2: <description> + - File(s): `<file paths>` + - Acceptance: <how to verify> +... +``` + +4. Update `meta.yaml` `updated` date +5. Log the plan generation in `log.md` + +## Mode 2: Update Progress + +**When**: During implementation, tasks have been completed. + +### Process + +1. Read `plan.md` and count checked (`- [x]`) vs unchecked (`- [ ]`) tasks +2. Update the YAML frontmatter: + - `completed_tasks`: count of `[x]` items + - `total_tasks`: total count of task items + - `progress`: `Math.round(completed_tasks / total_tasks * 100)` +3. Update `meta.yaml` `updated` date + +## Validation + +- `total_tasks` must equal the actual count of task checkbox items +- `completed_tasks` must equal the actual count of checked items +- `progress` must be `Math.round(completed_tasks / total_tasks * 100)` +- If `progress` reaches 100, suggest invoking `update-status` to transition to `done` diff --git a/plugins/supercrew/skills/update-status/SKILL.md b/plugins/supercrew/skills/update-status/SKILL.md new file mode 100644 index 0000000..4142c73 --- /dev/null +++ b/plugins/supercrew/skills/update-status/SKILL.md @@ -0,0 +1,70 @@ +--- +name: update-status +description: "Use when a feature's status needs to change — after design approval, when starting implementation, when blocked, or when work is complete. Updates meta.yaml status field following the valid state transition graph." +--- + +# Update Feature Status + +## Overview + +Update the `status` field in a feature's `meta.yaml`. Status changes must follow the valid transition graph. + +## Valid Status Transitions + +``` +planning → designing (design work has started) +designing → ready (design approved, ready for implementation) +designing → planning (design rejected, back to planning) +ready → active (implementation has started) +active → blocked (blocked by dependency or issue) +blocked → active (blocker resolved) +active → done (all tasks complete, verified) +``` + +**Invalid transitions** (e.g., `planning → active`, `done → active`) must be rejected with an explanation of which intermediate steps are needed. + +## Process + +### Step 1: Identify the Feature + +- Use the active feature from the current session context (set by SessionStart hook or `/work-on`) +- If no active feature, ask the user which feature to update + +### Step 2: Determine New Status + +Infer the appropriate status transition based on context: + +| Signal | Suggested Transition | +|--------|---------------------| +| `design.md` frontmatter `status` changed to `approved` | `designing → ready` | +| User says "start implementing" or begins writing code | `ready → active` | +| User mentions a blocker or dependency issue | `active → blocked` | +| Blocker resolved | `blocked → active` | +| All tasks in `plan.md` checked off, tests pass | `active → done` | +| Design rejected or needs rework | `designing → planning` | + +If the transition is ambiguous, ask the user to confirm. + +### Step 3: Update `meta.yaml` + +1. Read the current `meta.yaml` +2. Validate the transition is legal (see graph above) +3. Update `status` to the new value +4. Update `updated` date to today (YYYY-MM-DD) +5. Write the file + +### Step 4: Log the Change + +Append to `log.md`: + +```markdown +## <YYYY-MM-DD> — Status: <old_status> → <new_status> + +- Reason: <brief reason for the transition> +``` + +## Validation + +- Reject any transition not in the valid transitions graph +- Ensure `meta.yaml` required fields remain intact after edit +- `updated` date must be set to today diff --git a/plugins/supercrew/skills/using-supercrew/SKILL.md b/plugins/supercrew/skills/using-supercrew/SKILL.md new file mode 100644 index 0000000..c54ef1a --- /dev/null +++ b/plugins/supercrew/skills/using-supercrew/SKILL.md @@ -0,0 +1,67 @@ +--- +name: using-supercrew +description: "Use at session start to establish how supercrew skills work. Ensures features are tracked with structured lifecycle management." +--- + +<EXTREMELY_IMPORTANT> +You have the supercrew plugin installed. You MUST follow these rules for feature lifecycle management. + +If a supercrew skill applies to the current task, you MUST invoke it. This is not optional. +</EXTREMELY_IMPORTANT> + +# Using SuperCrew + +## The Rule + +**Check for applicable supercrew skills BEFORE taking action.** If the user is discussing features, planning, status updates, or progress — a supercrew skill almost certainly applies. + +## How to Access Skills + +**In Claude Code:** Use the `Skill` tool to invoke supercrew skills by name. When you invoke a skill, its content is loaded — follow it directly. + +## When to Use Each Skill + +| Trigger | Skill to Invoke | +|---------|----------------| +| User wants to create/start a new feature | `supercrew:create-feature` | +| User says "mark as ready/active/done/blocked" or status changes | `supercrew:update-status` | +| User finishes design, wants task breakdown, or tasks change | `supercrew:sync-plan` | +| User completed work, end of session, or checkpoint | `supercrew:log-progress` | +| `.supercrew/features/` exists and general lifecycle orchestration needed | `supercrew:managing-features` | + +## Decision Flow + +``` +User message received + ↓ +Does it involve a feature? ──yes──→ Is there a .supercrew/features/ dir? + │ │ + no yes → Check which skill applies → Invoke it + │ │ + ↓ no → Suggest /supercrew:new-feature +Respond normally +``` + +## Red Flags + +These thoughts mean STOP — you're rationalizing skipping the skill: + +| Thought | Reality | +|---------|---------| +| "I'll just update the file directly" | Use the skill — it ensures consistency | +| "This status change is trivial" | `update-status` validates transitions | +| "I'll log progress later" | Log NOW while context is fresh | +| "The plan doesn't need syncing" | `sync-plan` catches drift you won't notice | +| "I know the meta.yaml format" | Skills evolve. Invoke current version. | + +## Available Commands + +Users can invoke these directly: + +- `/supercrew:new-feature` — Create a new feature +- `/supercrew:feature-status` — Show all features in a table +- `/supercrew:work-on <id>` — Switch active feature for this session + +## Active Feature + +When a feature is active (matched via `feature/<id>` branch or `/supercrew:work-on`), all skill operations target that feature by default. The SessionStart hook provides active feature context automatically. diff --git a/plugins/supercrew/templates/design.md.tmpl b/plugins/supercrew/templates/design.md.tmpl new file mode 100644 index 0000000..1c9f2ba --- /dev/null +++ b/plugins/supercrew/templates/design.md.tmpl @@ -0,0 +1,23 @@ +--- +status: draft +reviewers: [] +# approved_by: "" +--- + +# {{title}} + +## Background + +<!-- Why is this feature needed? What problem does it solve? --> + +## Requirements + +<!-- What must this feature do? List functional requirements. --> + +## Design + +<!-- How will it be implemented? Architecture, data flow, key decisions. --> + +## Out of Scope + +<!-- What is explicitly NOT included in this feature? --> diff --git a/plugins/supercrew/templates/log.md.tmpl b/plugins/supercrew/templates/log.md.tmpl new file mode 100644 index 0000000..f5f683b --- /dev/null +++ b/plugins/supercrew/templates/log.md.tmpl @@ -0,0 +1,7 @@ +# {{title}} — Progress Log + +## {{date}} — Feature Created + +- Feature initialized with status: `planning` +- Owner: {{owner}} +- Priority: P2 diff --git a/plugins/supercrew/templates/meta.yaml.tmpl b/plugins/supercrew/templates/meta.yaml.tmpl new file mode 100644 index 0000000..1c23784 --- /dev/null +++ b/plugins/supercrew/templates/meta.yaml.tmpl @@ -0,0 +1,11 @@ +id: {{id}} +title: "{{title}}" +status: planning +owner: "{{owner}}" +priority: P2 +teams: [] +tags: [] +created: "{{date}}" +updated: "{{date}}" +# target_release: "" +# blocked_by: [] diff --git a/plugins/supercrew/templates/plan.md.tmpl b/plugins/supercrew/templates/plan.md.tmpl new file mode 100644 index 0000000..af1a709 --- /dev/null +++ b/plugins/supercrew/templates/plan.md.tmpl @@ -0,0 +1,14 @@ +--- +total_tasks: 0 +completed_tasks: 0 +progress: 0 +--- + +# {{title}} — Implementation Plan + +<!-- Task breakdown will be generated after design approval. --> +<!-- Each task should be a checkbox item with clear acceptance criteria. --> + +## Tasks + +- [ ] Task 1: (to be defined) From e42037498f4ac18b8cb421d72e26fa98c7d8acfd Mon Sep 17 00:00:00 2001 From: He Zhang <hezhan@microsoft.com> Date: Tue, 3 Mar 2026 22:04:14 +0800 Subject: [PATCH 08/14] update make file --- Makefile | 1 + 1 file changed, 1 insertion(+) diff --git a/Makefile b/Makefile index b1c0cd1..4c6676e 100644 --- a/Makefile +++ b/Makefile @@ -16,6 +16,7 @@ help: # ── Install ────────────────────────────────────────────── install: + cd kanban && npm install cd kanban/backend && bun install cd kanban/frontend && pnpm install From eae23decf07d4fab26fb2975a23b0e6662fedf8f Mon Sep 17 00:00:00 2001 From: He Zhang <hezhan@microsoft.com> Date: Tue, 3 Mar 2026 22:04:19 +0800 Subject: [PATCH 09/14] fix login issue --- kanban/backend/src/routes/projects.ts | 7 ++- kanban/frontend/packages/app-core/src/api.ts | 43 +++++++++++++------ kanban/frontend/packages/app-core/src/auth.ts | 18 ++++++++ .../packages/local-web/src/routes/__root.tsx | 13 +++++- .../packages/local-web/src/routes/welcome.tsx | 9 +++- 5 files changed, 69 insertions(+), 21 deletions(-) diff --git a/kanban/backend/src/routes/projects.ts b/kanban/backend/src/routes/projects.ts index 8b2be2c..23d4481 100644 --- a/kanban/backend/src/routes/projects.ts +++ b/kanban/backend/src/routes/projects.ts @@ -1,8 +1,7 @@ import { Hono } from 'hono' import { verify } from 'hono/jwt' import type { UserRegistry } from '../registry/types.js' - -const JWT_SECRET = process.env.JWT_SECRET! +import { env } from '../lib/env.js' async function getPayload(authHeader: string | undefined) { if (!authHeader?.startsWith('Bearer ')) { @@ -10,9 +9,9 @@ async function getPayload(authHeader: string | undefined) { throw new Error('Unauthorized') } try { - return await verify(authHeader.slice(7), JWT_SECRET, 'HS256') as any + return await verify(authHeader.slice(7), env.JWT_SECRET, 'HS256') as any } catch (e: any) { - console.log('[getPayload] verify failed:', e?.message, 'JWT_SECRET set:', !!JWT_SECRET) + console.log('[getPayload] verify failed:', e?.message, 'JWT_SECRET set:', !!env.JWT_SECRET) throw e } } diff --git a/kanban/frontend/packages/app-core/src/api.ts b/kanban/frontend/packages/app-core/src/api.ts index ccec585..9623db9 100644 --- a/kanban/frontend/packages/app-core/src/api.ts +++ b/kanban/frontend/packages/app-core/src/api.ts @@ -1,77 +1,92 @@ import type { Task, Sprint, Person, Board, TaskStatus } from './types.js' +import { authHeaders, clearToken } from './auth.js' const BASE = '/api' +let redirecting = false + async function json<T>(res: Response): Promise<T> { - if (!res.ok) throw new Error(`${res.status} ${res.statusText}`) + if (!res.ok) { + if (res.status === 401 && !redirecting) { + redirecting = true + clearToken() + window.location.href = '/login' + } + throw new Error(`${res.status} ${res.statusText}`) + } return res.json() as Promise<T> } +/** Merge auth + extra headers */ +function headers(extra?: Record<string, string>): Record<string, string> { + return { ...authHeaders(), ...extra } +} + // ─── Board ──────────────────────────────────────────────────────────────────── export const fetchBoard = (): Promise<Board> => - fetch(`${BASE}/board`).then(json<Board>) + fetch(`${BASE}/board`, { headers: headers() }).then(json<Board>) // ─── Tasks ──────────────────────────────────────────────────────────────────── export const fetchTasks = (): Promise<Task[]> => - fetch(`${BASE}/tasks`).then(json<Task[]>) + fetch(`${BASE}/tasks`, { headers: headers() }).then(json<Task[]>) export const fetchTask = (id: string): Promise<Task> => - fetch(`${BASE}/tasks/${id}`).then(json<Task>) + fetch(`${BASE}/tasks/${id}`, { headers: headers() }).then(json<Task>) export const createTask = (task: Omit<Task, 'created' | 'updated'>): Promise<Task> => fetch(`${BASE}/tasks`, { method: 'POST', - headers: { 'Content-Type': 'application/json' }, + headers: headers({ 'Content-Type': 'application/json' }), body: JSON.stringify(task), }).then(json<Task>) export const updateTask = (id: string, patch: Partial<Task>): Promise<Task> => fetch(`${BASE}/tasks/${id}`, { method: 'PATCH', - headers: { 'Content-Type': 'application/json' }, + headers: headers({ 'Content-Type': 'application/json' }), body: JSON.stringify(patch), }).then(json<Task>) export const updateTaskStatus = (id: string, status: TaskStatus): Promise<Task> => fetch(`${BASE}/tasks/${id}/status`, { method: 'PUT', - headers: { 'Content-Type': 'application/json' }, + headers: headers({ 'Content-Type': 'application/json' }), body: JSON.stringify({ status }), }).then(json<Task>) export const deleteTask = (id: string): Promise<{ ok: boolean }> => - fetch(`${BASE}/tasks/${id}`, { method: 'DELETE' }).then(json<{ ok: boolean }>) + fetch(`${BASE}/tasks/${id}`, { method: 'DELETE', headers: headers() }).then(json<{ ok: boolean }>) // ─── Sprints ────────────────────────────────────────────────────────────────── export const fetchSprints = (): Promise<Sprint[]> => - fetch(`${BASE}/sprints`).then(json<Sprint[]>) + fetch(`${BASE}/sprints`, { headers: headers() }).then(json<Sprint[]>) export const updateSprint = (id: number, patch: Partial<Sprint>): Promise<Sprint> => fetch(`${BASE}/sprints/${id}`, { method: 'PATCH', - headers: { 'Content-Type': 'application/json' }, + headers: headers({ 'Content-Type': 'application/json' }), body: JSON.stringify(patch), }).then(json<Sprint>) // ─── People ─────────────────────────────────────────────────────────────────── export const fetchPeople = (): Promise<Person[]> => - fetch(`${BASE}/people`).then(json<Person[]>) + fetch(`${BASE}/people`, { headers: headers() }).then(json<Person[]>) export const updatePerson = (username: string, patch: Partial<Person>): Promise<Person> => fetch(`${BASE}/people/${username}`, { method: 'PATCH', - headers: { 'Content-Type': 'application/json' }, + headers: headers({ 'Content-Type': 'application/json' }), body: JSON.stringify(patch), }).then(json<Person>) // ─── Knowledge & Decisions ──────────────────────────────────────────────────── export const fetchKnowledge = (): Promise<import('./types.js').KnowledgeEntry[]> => - fetch(`${BASE}/knowledge`).then(json<import('./types.js').KnowledgeEntry[]>) + fetch(`${BASE}/knowledge`, { headers: headers() }).then(json<import('./types.js').KnowledgeEntry[]>) export const fetchDecisions = (): Promise<import('./types.js').Decision[]> => - fetch(`${BASE}/decisions`).then(json<import('./types.js').Decision[]>) + fetch(`${BASE}/decisions`, { headers: headers() }).then(json<import('./types.js').Decision[]>) diff --git a/kanban/frontend/packages/app-core/src/auth.ts b/kanban/frontend/packages/app-core/src/auth.ts index fb61ff7..08196a4 100644 --- a/kanban/frontend/packages/app-core/src/auth.ts +++ b/kanban/frontend/packages/app-core/src/auth.ts @@ -27,3 +27,21 @@ export function authHeaders(): Record<string, string> { const token = getToken() return token ? { Authorization: `Bearer ${token}` } : {} } + +/** + * Server-side token verification via /auth/me. + * Returns true if the token is valid (signature + expiry), false otherwise. + * On failure, automatically clears the invalid token from localStorage. + */ +export async function verifyToken(): Promise<boolean> { + if (!isAuthenticated()) return false + try { + const res = await fetch('/auth/me', { headers: authHeaders() }) + if (res.ok) return true + clearToken() + return false + } catch { + clearToken() + return false + } +} diff --git a/kanban/frontend/packages/local-web/src/routes/__root.tsx b/kanban/frontend/packages/local-web/src/routes/__root.tsx index 82c946c..061c81f 100644 --- a/kanban/frontend/packages/local-web/src/routes/__root.tsx +++ b/kanban/frontend/packages/local-web/src/routes/__root.tsx @@ -8,7 +8,7 @@ import { import { useTranslation } from 'react-i18next' import AppHeader from '@web/components/AppHeader' import Dock from '@web/components/Dock' -import { isAuthenticated, authHeaders, clearToken } from '@vibe/app-core' +import { isAuthenticated, authHeaders, clearToken, verifyToken } from '@vibe/app-core' import type { DockItemConfig } from '@web/components/Dock' const PUBLIC_PATHS = ['/login', '/auth/callback', '/welcome'] @@ -37,10 +37,19 @@ function RootLayout() { const navigate = useNavigate() // Route guard: redirect to /login if not authenticated on protected routes + // Also verifies token server-side on mount to catch JWT_SECRET rotation useEffect(() => { - if (!PUBLIC_PATHS.includes(pathname) && !isAuthenticated()) { + if (PUBLIC_PATHS.includes(pathname)) return + if (!isAuthenticated()) { navigate({ to: '/login', search: { error: undefined, token: undefined } }) + return } + // Server-side verification (runs once on mount + on path change) + verifyToken().then(valid => { + if (!valid) { + navigate({ to: '/login', search: { error: undefined, token: undefined } }) + } + }) }, [pathname]) // FRE detection: if authenticated but no projects, go to /welcome diff --git a/kanban/frontend/packages/local-web/src/routes/welcome.tsx b/kanban/frontend/packages/local-web/src/routes/welcome.tsx index a5bc0b5..2285ffe 100644 --- a/kanban/frontend/packages/local-web/src/routes/welcome.tsx +++ b/kanban/frontend/packages/local-web/src/routes/welcome.tsx @@ -3,7 +3,7 @@ import { useState, useEffect } from 'react' import { useQuery, useQueryClient } from '@tanstack/react-query' import { LightningIcon, MagnifyingGlassIcon, CheckCircleIcon, WarningCircleIcon, CaretDownIcon } from '@phosphor-icons/react' import { Popover, PopoverTrigger, PopoverContent } from '@radix-ui/react-popover' -import { authHeaders } from '@vibe/app-core' +import { authHeaders, isAuthenticated } from '@vibe/app-core' import { useTranslation } from 'react-i18next' import DotGrid from '@web/components/DotGrid' import LangToggle from '@web/components/LangToggle' @@ -358,6 +358,13 @@ function WelcomePage() { const [currentStep, setCurrentStep] = useState(1) const [selectedRepo, setSelectedRepo] = useState<GithubRepo | null>(null) + // Redirect to login if not authenticated + useEffect(() => { + if (!isAuthenticated()) { + navigate({ to: '/login', search: { error: undefined, token: undefined } }) + } + }, []) + return ( <div style={{ position: 'relative', width: '100vw', height: '100vh', overflow: 'hidden', background: '#060010' }}> {/* Language toggle */} From 5cb7576c933a399074101b82c6095a99ca3954ea Mon Sep 17 00:00:00 2001 From: He Zhang <hezhan@microsoft.com> Date: Wed, 4 Mar 2026 00:03:33 +0800 Subject: [PATCH 10/14] ux fix --- kanban/backend/bun.lock | 12 +- kanban/backend/package.json | 2 + .../src/__tests__/github-store.test.ts | 27 +- .../src/__tests__/routes-tasks.test.ts | 4 +- kanban/backend/src/__tests__/store.test.ts | 181 ++++----- kanban/backend/src/index.ts | 24 +- kanban/backend/src/routes/decisions.ts | 19 - kanban/backend/src/routes/features.ts | 81 ++++ kanban/backend/src/routes/knowledge.ts | 19 - kanban/backend/src/routes/people.ts | 70 ---- kanban/backend/src/routes/projects.ts | 39 +- kanban/backend/src/routes/sprints.ts | 46 --- kanban/backend/src/routes/tasks.ts | 104 ------ kanban/backend/src/store/github-store.ts | 252 +++++-------- kanban/backend/src/store/index.ts | 228 ++++-------- kanban/backend/src/types/index.ts | 95 +++-- kanban/frontend/packages/app-core/src/api.ts | 76 +--- .../packages/app-core/src/hooks/useBoard.ts | 15 +- .../app-core/src/hooks/useMutations.ts | 97 +---- .../frontend/packages/app-core/src/index.ts | 1 - .../frontend/packages/app-core/src/types.ts | 75 ++-- .../packages/local-web/src/locales/en.json | 78 ++-- .../packages/local-web/src/locales/zh.json | 78 ++-- .../packages/local-web/src/routeTree.gen.ts | 107 +----- .../packages/local-web/src/routes/__root.tsx | 22 +- .../local-web/src/routes/decisions.tsx | 106 ------ .../local-web/src/routes/features.$id.tsx | 347 ++++++++++++++++++ .../packages/local-web/src/routes/index.tsx | 240 ++++-------- .../local-web/src/routes/knowledge.tsx | 104 ------ .../packages/local-web/src/routes/people.tsx | 157 -------- .../local-web/src/routes/tasks.$id.tsx | 325 ---------------- .../packages/local-web/src/routes/welcome.tsx | 37 +- 32 files changed, 988 insertions(+), 2080 deletions(-) delete mode 100644 kanban/backend/src/routes/decisions.ts create mode 100644 kanban/backend/src/routes/features.ts delete mode 100644 kanban/backend/src/routes/knowledge.ts delete mode 100644 kanban/backend/src/routes/people.ts delete mode 100644 kanban/backend/src/routes/sprints.ts delete mode 100644 kanban/backend/src/routes/tasks.ts delete mode 100644 kanban/frontend/packages/local-web/src/routes/decisions.tsx create mode 100644 kanban/frontend/packages/local-web/src/routes/features.$id.tsx delete mode 100644 kanban/frontend/packages/local-web/src/routes/knowledge.tsx delete mode 100644 kanban/frontend/packages/local-web/src/routes/people.tsx delete mode 100644 kanban/frontend/packages/local-web/src/routes/tasks.$id.tsx diff --git a/kanban/backend/bun.lock b/kanban/backend/bun.lock index 680dae4..52b647d 100644 --- a/kanban/backend/bun.lock +++ b/kanban/backend/bun.lock @@ -10,10 +10,12 @@ "gray-matter": "^4.0.3", "hono": "^4.12.3", "jose": "^6.1.3", + "js-yaml": "^4.1.1", "typescript": "^5.0.0", }, "devDependencies": { "@types/bun": "latest", + "@types/js-yaml": "^4.0.9", "chokidar": "^4.0.3", "vitest": "^3.2.4", }, @@ -132,6 +134,8 @@ "@types/estree": ["@types/estree@1.0.8", "", {}, "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w=="], + "@types/js-yaml": ["@types/js-yaml@4.0.9", "", {}, "sha512-k4MGaQl5TGo/iipqb2UDG2UwjXziSWkh0uysQelTlJpX1qGlpUZYm8PnO4DxG1qBomtJUdYJ6qR6xdIah10JLg=="], + "@types/node": ["@types/node@25.3.3", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-DpzbrH7wIcBaJibpKo9nnSQL0MTRdnWttGyE5haGwK86xgMOkFLp7vEyfQPGLOJh5wNYiJ3V9PmUMDhV9u8kkQ=="], "@upstash/redis": ["@upstash/redis@1.36.3", "", { "dependencies": { "uncrypto": "^0.1.3" } }, "sha512-wxo1ei4OHDHm4UGMgrNVz9QUEela9N/Iwi4p1JlHNSowQiPi+eljlGnfbZVkV0V4PIrjGtGFJt5GjWM5k28enA=="], @@ -152,7 +156,7 @@ "@vitest/utils": ["@vitest/utils@3.2.4", "", { "dependencies": { "@vitest/pretty-format": "3.2.4", "loupe": "^3.1.4", "tinyrainbow": "^2.0.0" } }, "sha512-fB2V0JFrQSMsCo9HiSq3Ezpdv4iYaXRG1Sx8edX3MwxfyNn83mKiGzOcH+Fkxt4MHxr3y42fQi1oeAInqgX2QA=="], - "argparse": ["argparse@1.0.10", "", { "dependencies": { "sprintf-js": "~1.0.2" } }, "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg=="], + "argparse": ["argparse@2.0.1", "", {}, "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q=="], "assertion-error": ["assertion-error@2.0.1", "", {}, "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA=="], @@ -196,7 +200,7 @@ "js-tokens": ["js-tokens@9.0.1", "", {}, "sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ=="], - "js-yaml": ["js-yaml@3.14.2", "", { "dependencies": { "argparse": "^1.0.7", "esprima": "^4.0.0" }, "bin": "bin/js-yaml.js" }, "sha512-PMSmkqxr106Xa156c2M265Z+FTrPl+oxd/rgOQy2tijQeK5TxQ43psO1ZCwhVOSdnn+RzkzlRz/eY4BgJBYVpg=="], + "js-yaml": ["js-yaml@4.1.1", "", { "dependencies": { "argparse": "^2.0.1" }, "bin": { "js-yaml": "bin/js-yaml.js" } }, "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA=="], "kind-of": ["kind-of@6.0.3", "", {}, "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw=="], @@ -265,5 +269,9 @@ "why-is-node-running": ["why-is-node-running@2.3.0", "", { "dependencies": { "siginfo": "^2.0.0", "stackback": "0.0.2" }, "bin": { "why-is-node-running": "cli.js" } }, "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w=="], "bun-types/@types/node": ["@types/node@25.3.2", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-RpV6r/ij22zRRdyBPcxDeKAzH43phWVKEjL2iksqo1Vz3CuBUrgmPpPhALKiRfU7OMCmeeO9vECBMsV0hMTG8Q=="], + + "gray-matter/js-yaml": ["js-yaml@3.14.2", "", { "dependencies": { "argparse": "^1.0.7", "esprima": "^4.0.0" }, "bin": "bin/js-yaml.js" }, "sha512-PMSmkqxr106Xa156c2M265Z+FTrPl+oxd/rgOQy2tijQeK5TxQ43psO1ZCwhVOSdnn+RzkzlRz/eY4BgJBYVpg=="], + + "gray-matter/js-yaml/argparse": ["argparse@1.0.10", "", { "dependencies": { "sprintf-js": "~1.0.2" } }, "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg=="], } } diff --git a/kanban/backend/package.json b/kanban/backend/package.json index 86df596..71c2eba 100644 --- a/kanban/backend/package.json +++ b/kanban/backend/package.json @@ -17,10 +17,12 @@ "gray-matter": "^4.0.3", "hono": "^4.12.3", "jose": "^6.1.3", + "js-yaml": "^4.1.1", "typescript": "^5.0.0" }, "devDependencies": { "@types/bun": "latest", + "@types/js-yaml": "^4.0.9", "chokidar": "^4.0.3", "vitest": "^3.2.4" } diff --git a/kanban/backend/src/__tests__/github-store.test.ts b/kanban/backend/src/__tests__/github-store.test.ts index dd1074d..c74b691 100644 --- a/kanban/backend/src/__tests__/github-store.test.ts +++ b/kanban/backend/src/__tests__/github-store.test.ts @@ -3,7 +3,7 @@ import { describe, it, expect, vi, beforeEach } from 'vitest' const mockFetch = vi.fn() global.fetch = mockFetch as any -import { listTasksGH, readTaskGH } from '../store/github-store.js' +import { listFeaturesGH, getFeatureMetaGH } from '../store/github-store.js' const TOKEN = 'ghp_test' const OWNER = 'testowner' @@ -12,37 +12,38 @@ const REPO = 'testrepo' describe('github-store', () => { beforeEach(() => { mockFetch.mockReset() }) - it('listTasksGH returns empty array when directory missing', async () => { + it('listFeaturesGH returns empty array when directory missing', async () => { mockFetch.mockResolvedValueOnce({ ok: false, status: 404 } as any) - const result = await listTasksGH(TOKEN, OWNER, REPO) + const result = await listFeaturesGH(TOKEN, OWNER, REPO) expect(result).toEqual([]) }) - it('listTasksGH skips template files', async () => { + it('listFeaturesGH lists feature directories and loads meta', async () => { + // First call: list features directory mockFetch.mockResolvedValueOnce({ ok: true, json: async () => [ - { name: '_template.md', type: 'file' }, - { name: 'ENG-001.md', type: 'file' }, + { name: 'feat-001', type: 'dir' }, + { name: 'README.md', type: 'file' }, // should be skipped ], } as any) + // Second call: ghGet for feat-001/meta.yaml mockFetch.mockResolvedValueOnce({ ok: true, json: async () => ({ - content: btoa('---\ntitle: Test Task\nstatus: backlog\npriority: P2\ncreated: 2026-01-01\nupdated: 2026-01-01\ntags: []\nblocks: []\nblocked_by: []\n---\nTask body'), - sha: 'abc123', + content: btoa('id: feat-001\ntitle: Test Feature\nstatus: planning\nowner: alice\npriority: P1\ncreated: "2026-01-01"\nupdated: "2026-01-01"\n'), }), } as any) - const result = await listTasksGH(TOKEN, OWNER, REPO) + const result = await listFeaturesGH(TOKEN, OWNER, REPO) expect(result).toHaveLength(1) - expect(result[0].id).toBe('ENG-001') - expect(result[0].title).toBe('Test Task') + expect(result[0].id).toBe('feat-001') + expect(result[0].title).toBe('Test Feature') }) - it('readTaskGH returns null when file missing', async () => { + it('getFeatureMetaGH returns null when file missing', async () => { mockFetch.mockResolvedValueOnce({ ok: false, status: 404 } as any) - const result = await readTaskGH(TOKEN, OWNER, REPO, 'ENG-999') + const result = await getFeatureMetaGH(TOKEN, OWNER, REPO, 'missing-feat') expect(result).toBeNull() }) }) diff --git a/kanban/backend/src/__tests__/routes-tasks.test.ts b/kanban/backend/src/__tests__/routes-tasks.test.ts index be18251..c602b53 100644 --- a/kanban/backend/src/__tests__/routes-tasks.test.ts +++ b/kanban/backend/src/__tests__/routes-tasks.test.ts @@ -6,9 +6,9 @@ process.env.JWT_SECRET = 'test-jwt-secret' const { app } = await import('../index.js') -describe('GET /api/tasks', () => { +describe('GET /api/features', () => { it('returns 401 without auth', async () => { - const res = await app.request('/api/tasks') + const res = await app.request('/api/features') expect(res.status).toBe(401) }) }) diff --git a/kanban/backend/src/__tests__/store.test.ts b/kanban/backend/src/__tests__/store.test.ts index 8b67f2c..07dea34 100644 --- a/kanban/backend/src/__tests__/store.test.ts +++ b/kanban/backend/src/__tests__/store.test.ts @@ -2,119 +2,132 @@ import { test, expect, beforeEach, afterEach } from 'vitest' import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from 'fs' import { tmpdir } from 'os' import { join } from 'path' -import { readTask, writeTask, updateTaskStatus, readPerson } from '../store/index.js' -import type { Task } from '../types/index.js' +import { listFeatures, getFeatureMeta, getFeatureDesign, getFeaturePlan, getFeature, checkSupercrewExists } from '../store/index.js' let tempDir: string beforeEach(() => { tempDir = mkdtempSync(join(tmpdir(), 'crew-test-')) - process.env.TEAM_DIR = tempDir + process.env.SUPERCREW_DIR = tempDir }) afterEach(() => { rmSync(tempDir, { recursive: true, force: true }) - delete process.env.TEAM_DIR + delete process.env.SUPERCREW_DIR }) -// ─── readTask ──────────────────────────────────────────────────────────────── +// ─── listFeatures ──────────────────────────────────────────────────────────── -test('readTask returns null for non-existent file', () => { - expect(readTask('MISSING-001')).toBeNull() +test('listFeatures returns empty array when features dir missing', () => { + expect(listFeatures()).toEqual([]) }) -test('writeTask + readTask round-trip preserves all fields', () => { - const task: Task = { - id: 'ENG-001', - title: 'Test task', - status: 'todo', - priority: 'P1', - created: '2026-01-01', - updated: '2026-01-01', - tags: ['backend'], - blocks: ['ENG-002'], - blocked_by: [], - body: 'This is the task body.', - } - writeTask(task) - const result = readTask('ENG-001') - expect(result).not.toBeNull() - expect(result!.title).toBe('Test task') - expect(result!.status).toBe('todo') - expect(result!.priority).toBe('P1') - expect(result!.tags).toEqual(['backend']) - expect(result!.blocks).toEqual(['ENG-002']) - expect(result!.body).toBe('This is the task body.') +test('listFeatures reads feature directories', () => { + const featDir = join(tempDir, 'features', 'feat-001') + mkdirSync(featDir, { recursive: true }) + writeFileSync( + join(featDir, 'meta.yaml'), + 'id: feat-001\ntitle: Test Feature\nstatus: planning\nowner: alice\npriority: P1\ncreated: "2026-01-01"\nupdated: "2026-01-01"\n', + ) + const result = listFeatures() + expect(result).toHaveLength(1) + expect(result[0].id).toBe('feat-001') + expect(result[0].title).toBe('Test Feature') + expect(result[0].priority).toBe('P1') +}) + +// ─── getFeatureMeta ────────────────────────────────────────────────────────── + +test('getFeatureMeta returns null for non-existent feature', () => { + expect(getFeatureMeta('MISSING-001')).toBeNull() }) -test('readTask applies default status and priority when frontmatter omits them', () => { - mkdirSync(join(tempDir, 'tasks'), { recursive: true }) +test('getFeatureMeta parses meta.yaml correctly', () => { + const featDir = join(tempDir, 'features', 'feat-002') + mkdirSync(featDir, { recursive: true }) writeFileSync( - join(tempDir, 'tasks', 'MIN-001.md'), - '---\ntitle: Minimal task\n---\n\nBody here.', + join(featDir, 'meta.yaml'), + 'id: feat-002\ntitle: Another Feature\nstatus: active\nowner: bob\npriority: P0\nteams:\n - backend\ntags:\n - infra\ncreated: "2026-01-01"\nupdated: "2026-01-02"\n', ) - const result = readTask('MIN-001') + const result = getFeatureMeta('feat-002') expect(result).not.toBeNull() - expect(result!.status).toBe('backlog') - expect(result!.priority).toBe('P2') - expect(result!.tags).toEqual([]) - expect(result!.blocks).toEqual([]) - expect(result!.blocked_by).toEqual([]) + expect(result!.title).toBe('Another Feature') + expect(result!.status).toBe('active') + expect(result!.priority).toBe('P0') + expect(result!.teams).toEqual(['backend']) + expect(result!.tags).toEqual(['infra']) }) -test('updateTaskStatus changes status and persists to disk', () => { - const task: Task = { - id: 'ENG-002', - title: 'Status test', - status: 'todo', - priority: 'P2', - created: '2026-01-01', - updated: '2026-01-01', - tags: [], - blocks: [], - blocked_by: [], - body: '', - } - writeTask(task) - const updated = updateTaskStatus('ENG-002', 'in-progress') - expect(updated).not.toBeNull() - expect(updated!.status).toBe('in-progress') - expect(readTask('ENG-002')!.status).toBe('in-progress') +// ─── getFeatureDesign ──────────────────────────────────────────────────────── + +test('getFeatureDesign returns null when file missing', () => { + expect(getFeatureDesign('MISSING-001')).toBeNull() }) -test('updateTaskStatus returns null for non-existent task', () => { - expect(updateTaskStatus('MISSING-001', 'done')).toBeNull() +test('getFeatureDesign parses design.md correctly', () => { + const featDir = join(tempDir, 'features', 'feat-003') + mkdirSync(featDir, { recursive: true }) + writeFileSync( + join(featDir, 'design.md'), + '---\nstatus: in-review\nreviewers:\n - carol\n---\nDesign body content.', + ) + const result = getFeatureDesign('feat-003') + expect(result).not.toBeNull() + expect(result!.status).toBe('in-review') + expect(result!.reviewers).toEqual(['carol']) + expect(result!.body).toBe('Design body content.') }) -// ─── readPerson ─────────────────────────────────────────────────────────────── +// ─── getFeaturePlan ────────────────────────────────────────────────────────── -test('readPerson returns null for non-existent file', () => { - expect(readPerson('nobody')).toBeNull() +test('getFeaturePlan returns null when file missing', () => { + expect(getFeaturePlan('MISSING-001')).toBeNull() }) -test('readPerson parses person correctly', () => { - mkdirSync(join(tempDir, 'people'), { recursive: true }) +test('getFeaturePlan parses plan.md correctly', () => { + const featDir = join(tempDir, 'features', 'feat-004') + mkdirSync(featDir, { recursive: true }) writeFileSync( - join(tempDir, 'people', 'alice.md'), - [ - '---', - 'name: Alice', - 'team: eng', - 'updated: "2026-01-01"', - 'current_task: ENG-001', - 'completed_today:', - ' - "Wrote tests"', - '---', - '', - "Alice's notes.", - ].join('\n'), + join(featDir, 'plan.md'), + '---\ntotal_tasks: 5\ncompleted_tasks: 2\nprogress: 40\n---\nPlan body.', ) - const result = readPerson('alice') + const result = getFeaturePlan('feat-004') + expect(result).not.toBeNull() + expect(result!.total_tasks).toBe(5) + expect(result!.completed_tasks).toBe(2) + expect(result!.progress).toBe(40) + expect(result!.body).toBe('Plan body.') +}) + +// ─── getFeature ────────────────────────────────────────────────────────────── + +test('getFeature returns null for non-existent feature', () => { + expect(getFeature('MISSING-001')).toBeNull() +}) + +test('getFeature returns full feature with all documents', () => { + const featDir = join(tempDir, 'features', 'feat-005') + mkdirSync(featDir, { recursive: true }) + writeFileSync(join(featDir, 'meta.yaml'), 'id: feat-005\ntitle: Full Feature\nstatus: designing\nowner: dave\npriority: P2\ncreated: "2026-01-01"\nupdated: "2026-01-01"\n') + writeFileSync(join(featDir, 'design.md'), '---\nstatus: draft\nreviewers: []\n---\nDesign content.') + writeFileSync(join(featDir, 'plan.md'), '---\ntotal_tasks: 3\ncompleted_tasks: 1\nprogress: 33\n---\nPlan content.') + writeFileSync(join(featDir, 'log.md'), 'Log content here.') + + const result = getFeature('feat-005') expect(result).not.toBeNull() - expect(result!.username).toBe('alice') - expect(result!.name).toBe('Alice') - expect(result!.team).toBe('eng') - expect(result!.current_task).toBe('ENG-001') - expect(result!.completed_today).toEqual(['Wrote tests']) - expect(result!.body).toBe("Alice's notes.") + expect(result!.meta.title).toBe('Full Feature') + expect(result!.design!.status).toBe('draft') + expect(result!.plan!.total_tasks).toBe(3) + expect(result!.log!.body).toBe('Log content here.') +}) + +// ─── checkSupercrewExists ──────────────────────────────────────────────────── + +test('checkSupercrewExists returns false when dir missing', () => { + expect(checkSupercrewExists()).toBe(false) +}) + +test('checkSupercrewExists returns true when features dir exists', () => { + mkdirSync(join(tempDir, 'features'), { recursive: true }) + expect(checkSupercrewExists()).toBe(true) }) diff --git a/kanban/backend/src/index.ts b/kanban/backend/src/index.ts index 9e93f53..14f956c 100644 --- a/kanban/backend/src/index.ts +++ b/kanban/backend/src/index.ts @@ -4,13 +4,9 @@ import { KVRegistry } from './registry/kv-registry.js' import { FileRegistry } from './registry/file-registry.js' import { createAuthRouter } from './routes/auth.js' import { createProjectsRouter } from './routes/projects.js' -import { createTasksRouter } from './routes/tasks.js' -import { createSprintsRouter } from './routes/sprints.js' -import { createPeopleRouter } from './routes/people.js' -import { createKnowledgeRouter } from './routes/knowledge.js' -import { createDecisionsRouter } from './routes/decisions.js' +import { createFeaturesRouter, buildFeatureBoard } from './routes/features.js' import { getGitHubContext } from './lib/get-github-context.js' -import { listTasksGH, listSprintsGH, listPeopleGH } from './store/github-store.js' +import { listFeaturesGH } from './store/github-store.js' import { join, dirname } from 'path' import { fileURLToPath } from 'url' import { env } from './lib/env.js' @@ -35,22 +31,14 @@ app.use('*', cors({ app.route('/auth', createAuthRouter(registry)) app.route('/api/projects', createProjectsRouter(registry)) -app.route('/api/tasks', createTasksRouter(registry)) -app.route('/api/sprints', createSprintsRouter(registry)) -app.route('/api/people', createPeopleRouter(registry)) -app.route('/api/knowledge', createKnowledgeRouter(registry)) -app.route('/api/decisions', createDecisionsRouter(registry)) +app.route('/api/features', createFeaturesRouter(registry)) -// Board: aggregate endpoint +// Board: aggregate endpoint — features grouped by status app.get('/api/board', async (c) => { try { const ctx = await getGitHubContext(c.req.header('Authorization'), registry) - const [tasks, sprints, people] = await Promise.all([ - listTasksGH(ctx.accessToken, ctx.owner, ctx.repo), - listSprintsGH(ctx.accessToken, ctx.owner, ctx.repo), - listPeopleGH(ctx.accessToken, ctx.owner, ctx.repo), - ]) - return c.json({ tasks, sprints, people }) + const features = await listFeaturesGH(ctx.accessToken, ctx.owner, ctx.repo) + return c.json(buildFeatureBoard(features)) } catch (e: any) { return c.json({ error: e.message }, e.message === 'Unauthorized' ? 401 : 400) } diff --git a/kanban/backend/src/routes/decisions.ts b/kanban/backend/src/routes/decisions.ts deleted file mode 100644 index 4e2f1c6..0000000 --- a/kanban/backend/src/routes/decisions.ts +++ /dev/null @@ -1,19 +0,0 @@ -import { Hono } from 'hono' -import { listDecisionsGH } from '../store/github-store.js' -import { getGitHubContext } from '../lib/get-github-context.js' -import type { UserRegistry } from '../registry/types.js' - -export function createDecisionsRouter(registry: UserRegistry) { - const app = new Hono() - - app.get('/', async (c) => { - try { - const ctx = await getGitHubContext(c.req.header('Authorization'), registry) - return c.json(await listDecisionsGH(ctx.accessToken, ctx.owner, ctx.repo)) - } catch (e: any) { - return c.json({ error: e.message }, e.message === 'Unauthorized' ? 401 : 400) - } - }) - - return app -} diff --git a/kanban/backend/src/routes/features.ts b/kanban/backend/src/routes/features.ts new file mode 100644 index 0000000..da28e78 --- /dev/null +++ b/kanban/backend/src/routes/features.ts @@ -0,0 +1,81 @@ +import { Hono } from 'hono' +import { + listFeaturesGH, + getFeatureMetaGH, + getFeatureGH, + getFeatureDesignGH, + getFeaturePlanGH, +} from '../store/github-store.js' +import { getGitHubContext } from '../lib/get-github-context.js' +import type { UserRegistry } from '../registry/types.js' +import type { SupercrewStatus } from '../types/index.js' + +const ALL_STATUSES: SupercrewStatus[] = [ + 'planning', 'designing', 'ready', 'active', 'blocked', 'done', +] + +export function createFeaturesRouter(registry: UserRegistry) { + const app = new Hono() + + // GET /api/features — list all features (meta summary) + app.get('/', async (c) => { + try { + const ctx = await getGitHubContext(c.req.header('Authorization'), registry) + const features = await listFeaturesGH(ctx.accessToken, ctx.owner, ctx.repo) + return c.json(features) + } catch (e: any) { + return c.json({ error: e.message }, e.message === 'Unauthorized' ? 401 : 400) + } + }) + + // GET /api/features/:id — get single feature complete info + app.get('/:id', async (c) => { + try { + const ctx = await getGitHubContext(c.req.header('Authorization'), registry) + const feature = await getFeatureGH(ctx.accessToken, ctx.owner, ctx.repo, c.req.param('id')) + if (!feature) return c.json({ error: 'Not found' }, 404) + return c.json(feature) + } catch (e: any) { + return c.json({ error: e.message }, e.message === 'Unauthorized' ? 401 : 400) + } + }) + + // GET /api/features/:id/design — get design.md + app.get('/:id/design', async (c) => { + try { + const ctx = await getGitHubContext(c.req.header('Authorization'), registry) + const design = await getFeatureDesignGH(ctx.accessToken, ctx.owner, ctx.repo, c.req.param('id')) + if (!design) return c.json({ error: 'Not found' }, 404) + return c.json(design) + } catch (e: any) { + return c.json({ error: e.message }, e.message === 'Unauthorized' ? 401 : 400) + } + }) + + // GET /api/features/:id/plan — get plan.md (with progress) + app.get('/:id/plan', async (c) => { + try { + const ctx = await getGitHubContext(c.req.header('Authorization'), registry) + const plan = await getFeaturePlanGH(ctx.accessToken, ctx.owner, ctx.repo, c.req.param('id')) + if (!plan) return c.json({ error: 'Not found' }, 404) + return c.json(plan) + } catch (e: any) { + return c.json({ error: e.message }, e.message === 'Unauthorized' ? 401 : 400) + } + }) + + return app +} + +/** Build board aggregate — features grouped by status */ +export function buildFeatureBoard(features: import('../types/index.js').FeatureMeta[]) { + const featuresByStatus: Record<SupercrewStatus, import('../types/index.js').FeatureMeta[]> = { + planning: [], designing: [], ready: [], active: [], blocked: [], done: [], + } + for (const f of features) { + if (featuresByStatus[f.status]) { + featuresByStatus[f.status].push(f) + } + } + return { features, featuresByStatus } +} diff --git a/kanban/backend/src/routes/knowledge.ts b/kanban/backend/src/routes/knowledge.ts deleted file mode 100644 index 8fa3468..0000000 --- a/kanban/backend/src/routes/knowledge.ts +++ /dev/null @@ -1,19 +0,0 @@ -import { Hono } from 'hono' -import { listKnowledgeGH } from '../store/github-store.js' -import { getGitHubContext } from '../lib/get-github-context.js' -import type { UserRegistry } from '../registry/types.js' - -export function createKnowledgeRouter(registry: UserRegistry) { - const app = new Hono() - - app.get('/', async (c) => { - try { - const ctx = await getGitHubContext(c.req.header('Authorization'), registry) - return c.json(await listKnowledgeGH(ctx.accessToken, ctx.owner, ctx.repo)) - } catch (e: any) { - return c.json({ error: e.message }, e.message === 'Unauthorized' ? 401 : 400) - } - }) - - return app -} diff --git a/kanban/backend/src/routes/people.ts b/kanban/backend/src/routes/people.ts deleted file mode 100644 index f880b69..0000000 --- a/kanban/backend/src/routes/people.ts +++ /dev/null @@ -1,70 +0,0 @@ -import { Hono } from 'hono' -import { listPeopleGH, readPersonGH, writePersonGH } from '../store/github-store.js' -import { getGitHubContext } from '../lib/get-github-context.js' -import type { UserRegistry } from '../registry/types.js' -import type { Person } from '../types/index.js' - -export function createPeopleRouter(registry: UserRegistry) { - const app = new Hono() - - app.get('/', async (c) => { - try { - const ctx = await getGitHubContext(c.req.header('Authorization'), registry) - return c.json(await listPeopleGH(ctx.accessToken, ctx.owner, ctx.repo)) - } catch (e: any) { - return c.json({ error: e.message }, e.message === 'Unauthorized' ? 401 : 400) - } - }) - - app.get('/:username', async (c) => { - try { - const ctx = await getGitHubContext(c.req.header('Authorization'), registry) - const person = await readPersonGH(ctx.accessToken, ctx.owner, ctx.repo, c.req.param('username')) - if (!person) return c.json({ error: 'Not found' }, 404) - return c.json(person) - } catch (e: any) { - return c.json({ error: e.message }, e.message === 'Unauthorized' ? 401 : 400) - } - }) - - app.post('/', async (c) => { - try { - const ctx = await getGitHubContext(c.req.header('Authorization'), registry) - const body = await c.req.json<Partial<Person>>() - if (!body.username) return c.json({ error: 'username is required' }, 400) - const existing = await readPersonGH(ctx.accessToken, ctx.owner, ctx.repo, body.username) - if (existing) return c.json({ error: `Person ${body.username} already exists` }, 409) - const person: Person = { - username: body.username, - name: body.name ?? body.username, - team: body.team ?? '', - updated: new Date().toISOString().split('T')[0], - current_task: body.current_task, - blocked_by: body.blocked_by, - completed_today: body.completed_today ?? [], - body: body.body ?? '', - } - await writePersonGH(ctx.accessToken, ctx.owner, ctx.repo, person) - return c.json(person, 201) - } catch (e: any) { - return c.json({ error: e.message }, e.message === 'Unauthorized' ? 401 : 400) - } - }) - - app.patch('/:username', async (c) => { - try { - const ctx = await getGitHubContext(c.req.header('Authorization'), registry) - const username = c.req.param('username') - const existing = await readPersonGH(ctx.accessToken, ctx.owner, ctx.repo, username) - if (!existing) return c.json({ error: 'Not found' }, 404) - const body = await c.req.json<Partial<Person>>() - const updated = { ...existing, ...body, username } - await writePersonGH(ctx.accessToken, ctx.owner, ctx.repo, updated) - return c.json(updated) - } catch (e: any) { - return c.json({ error: e.message }, e.message === 'Unauthorized' ? 401 : 400) - } - }) - - return app -} diff --git a/kanban/backend/src/routes/projects.ts b/kanban/backend/src/routes/projects.ts index 23d4481..3c1e34d 100644 --- a/kanban/backend/src/routes/projects.ts +++ b/kanban/backend/src/routes/projects.ts @@ -56,7 +56,7 @@ export function createProjectsRouter(registry: UserRegistry) { const payload = await getPayload(c.req.header('Authorization')) const res = await fetch( 'https://api.github.com/user/repos?sort=updated&per_page=100&affiliation=owner,collaborator,organization_member', - { headers: { Authorization: `Bearer ${payload.access_token}`, 'User-Agent': 'jingxia-kanban' } } + { headers: { Authorization: `Bearer ${payload.access_token}`, 'User-Agent': 'supercrew-app' } } ) const repos = await res.json() console.log('[github/repos] status:', res.status, 'count:', Array.isArray(repos) ? repos.length : repos) @@ -64,49 +64,18 @@ export function createProjectsRouter(registry: UserRegistry) { } catch { return c.json({ error: 'Unauthorized' }, 401) } }) - // 检查 repo 是否已有 .team/ 目录 + // 检查 repo 是否已有 .supercrew/features/ 目录 app.get('/github/repos/:owner/:repo/init-status', async (c) => { try { const payload = await getPayload(c.req.header('Authorization')) const { owner, repo } = c.req.param() const res = await fetch( - `https://api.github.com/repos/${owner}/${repo}/contents/.team`, - { headers: { Authorization: `Bearer ${payload.access_token}`, 'User-Agent': 'jingxia-kanban' } } + `https://api.github.com/repos/${owner}/${repo}/contents/.supercrew/features`, + { headers: { Authorization: `Bearer ${payload.access_token}`, 'User-Agent': 'supercrew-app' } } ) return c.json({ initialized: res.ok }) } catch { return c.json({ error: 'Unauthorized' }, 401) } }) - // 初始化 .team/ 目录 - app.post('/github/repos/:owner/:repo/init', async (c) => { - try { - const payload = await getPayload(c.req.header('Authorization')) - const { owner, repo } = c.req.param() - const headers = { - Authorization: `Bearer ${payload.access_token}`, - 'User-Agent': 'jingxia-kanban', - 'Content-Type': 'application/json', - } - const base = `https://api.github.com/repos/${owner}/${repo}/contents` - const readme = btoa(`# .team\n\nThis directory stores project data for Jingxia Kanban.\n\nFiles here are managed automatically. Do not edit manually.\n`) - - const initRes = await fetch(`${base}/.team/README.md`, { - method: 'PUT', - headers, - body: JSON.stringify({ message: 'chore: initialize .team directory', content: readme }), - signal: AbortSignal.timeout(30_000), - }) - - if (!initRes.ok) { - const err = await initRes.json() as any - throw new Error(err.message ?? 'GitHub API error') - } - - return c.json({ ok: true }) - } catch (e: any) { - return c.json({ error: e.message ?? 'Failed to initialize' }, 500) - } - }) - return app } diff --git a/kanban/backend/src/routes/sprints.ts b/kanban/backend/src/routes/sprints.ts deleted file mode 100644 index 3f93769..0000000 --- a/kanban/backend/src/routes/sprints.ts +++ /dev/null @@ -1,46 +0,0 @@ -import { Hono } from 'hono' -import { listSprintsGH, writeSprintGH } from '../store/github-store.js' -import { getGitHubContext } from '../lib/get-github-context.js' -import type { UserRegistry } from '../registry/types.js' -import type { Sprint } from '../types/index.js' - -export function createSprintsRouter(registry: UserRegistry) { - const app = new Hono() - - app.get('/', async (c) => { - try { - const ctx = await getGitHubContext(c.req.header('Authorization'), registry) - return c.json(await listSprintsGH(ctx.accessToken, ctx.owner, ctx.repo)) - } catch (e: any) { - return c.json({ error: e.message }, e.message === 'Unauthorized' ? 401 : 400) - } - }) - - app.post('/', async (c) => { - try { - const ctx = await getGitHubContext(c.req.header('Authorization'), registry) - const body = await c.req.json<Sprint>() - await writeSprintGH(ctx.accessToken, ctx.owner, ctx.repo, body) - return c.json(body, 201) - } catch (e: any) { - return c.json({ error: e.message }, e.message === 'Unauthorized' ? 401 : 400) - } - }) - - app.patch('/:id', async (c) => { - try { - const ctx = await getGitHubContext(c.req.header('Authorization'), registry) - const body = await c.req.json<Partial<Sprint>>() - const sprints = await listSprintsGH(ctx.accessToken, ctx.owner, ctx.repo) - const sprint = sprints.find(s => s.id === parseInt(c.req.param('id'))) - if (!sprint) return c.json({ error: 'Not found' }, 404) - const updated = { ...sprint, ...body } - await writeSprintGH(ctx.accessToken, ctx.owner, ctx.repo, updated) - return c.json(updated) - } catch (e: any) { - return c.json({ error: e.message }, e.message === 'Unauthorized' ? 401 : 400) - } - }) - - return app -} diff --git a/kanban/backend/src/routes/tasks.ts b/kanban/backend/src/routes/tasks.ts deleted file mode 100644 index 7fb6648..0000000 --- a/kanban/backend/src/routes/tasks.ts +++ /dev/null @@ -1,104 +0,0 @@ -import { Hono } from 'hono' -import { listTasksGH, readTaskGH, writeTaskGH, deleteTaskGH } from '../store/github-store.js' -import { getGitHubContext } from '../lib/get-github-context.js' -import type { UserRegistry } from '../registry/types.js' -import type { Task, TaskStatus } from '../types/index.js' - -export function createTasksRouter(registry: UserRegistry) { - const app = new Hono() - - app.get('/', async (c) => { - try { - const ctx = await getGitHubContext(c.req.header('Authorization'), registry) - const tasks = await listTasksGH(ctx.accessToken, ctx.owner, ctx.repo) - return c.json(tasks) - } catch (e: any) { - return c.json({ error: e.message }, e.message === 'Unauthorized' ? 401 : 400) - } - }) - - app.get('/:id', async (c) => { - try { - const ctx = await getGitHubContext(c.req.header('Authorization'), registry) - const task = await readTaskGH(ctx.accessToken, ctx.owner, ctx.repo, c.req.param('id')) - if (!task) return c.json({ error: 'Not found' }, 404) - return c.json(task) - } catch (e: any) { - return c.json({ error: e.message }, e.message === 'Unauthorized' ? 401 : 400) - } - }) - - app.post('/', async (c) => { - try { - const ctx = await getGitHubContext(c.req.header('Authorization'), registry) - const body = await c.req.json<Partial<Task>>() - if (!body.id || !body.title) return c.json({ error: 'id and title are required' }, 400) - const existing = await readTaskGH(ctx.accessToken, ctx.owner, ctx.repo, body.id) - if (existing) return c.json({ error: `Task ${body.id} already exists` }, 409) - const task: Task = { - id: body.id, - title: body.title, - status: body.status ?? 'backlog', - priority: body.priority ?? 'P2', - assignee: body.assignee, - team: body.team, - sprint: body.sprint, - created: new Date().toISOString().split('T')[0], - updated: new Date().toISOString().split('T')[0], - tags: body.tags ?? [], - blocks: body.blocks ?? [], - blocked_by: body.blocked_by ?? [], - plan_doc: body.plan_doc, - pr_url: body.pr_url, - body: body.body ?? '', - } - await writeTaskGH(ctx.accessToken, ctx.owner, ctx.repo, task) - return c.json(task, 201) - } catch (e: any) { - return c.json({ error: e.message }, e.message === 'Unauthorized' ? 401 : 400) - } - }) - - app.patch('/:id', async (c) => { - try { - const ctx = await getGitHubContext(c.req.header('Authorization'), registry) - const id = c.req.param('id') - const existing = await readTaskGH(ctx.accessToken, ctx.owner, ctx.repo, id) - if (!existing) return c.json({ error: 'Not found' }, 404) - const body = await c.req.json<Partial<Task>>() - const updated: Task = { ...existing, ...body, id } - await writeTaskGH(ctx.accessToken, ctx.owner, ctx.repo, updated) - return c.json(updated) - } catch (e: any) { - return c.json({ error: e.message }, e.message === 'Unauthorized' ? 401 : 400) - } - }) - - app.put('/:id/status', async (c) => { - try { - const ctx = await getGitHubContext(c.req.header('Authorization'), registry) - const id = c.req.param('id') - const { status } = await c.req.json<{ status: TaskStatus }>() - const existing = await readTaskGH(ctx.accessToken, ctx.owner, ctx.repo, id) - if (!existing) return c.json({ error: 'Not found' }, 404) - const updated = { ...existing, status } - await writeTaskGH(ctx.accessToken, ctx.owner, ctx.repo, updated) - return c.json(updated) - } catch (e: any) { - return c.json({ error: e.message }, e.message === 'Unauthorized' ? 401 : 400) - } - }) - - app.delete('/:id', async (c) => { - try { - const ctx = await getGitHubContext(c.req.header('Authorization'), registry) - const deleted = await deleteTaskGH(ctx.accessToken, ctx.owner, ctx.repo, c.req.param('id')) - if (!deleted) return c.json({ error: 'Not found' }, 404) - return c.json({ ok: true }) - } catch (e: any) { - return c.json({ error: e.message }, e.message === 'Unauthorized' ? 401 : 400) - } - }) - - return app -} diff --git a/kanban/backend/src/store/github-store.ts b/kanban/backend/src/store/github-store.ts index debe2d8..b36f75b 100644 --- a/kanban/backend/src/store/github-store.ts +++ b/kanban/backend/src/store/github-store.ts @@ -1,5 +1,8 @@ import matter from 'gray-matter' -import type { Task, Sprint, Person, KnowledgeEntry, Decision } from '../types/index.js' +import yaml from 'js-yaml' +import type { + FeatureMeta, DesignDoc, PlanDoc, FeatureLog, Feature, SupercrewStatus, +} from '../types/index.js' const GH_API = 'https://api.github.com' const UA = 'supercrew-app' @@ -28,187 +31,114 @@ async function ghGet(token: string, owner: string, repo: string, path: string) { return res.json() as Promise<{ content: string; sha: string }> } -async function ghPut( - token: string, - owner: string, - repo: string, - path: string, - content: string, - message: string, - sha?: string, -) { - const body: Record<string, string> = { message, content: btoa(unescape(encodeURIComponent(content))) } - if (sha) body.sha = sha - const res = await fetch(`${GH_API}/repos/${owner}/${repo}/contents/${path}`, { - method: 'PUT', - headers: ghHeaders(token), - body: JSON.stringify(body), - }) - if (!res.ok) { - const err = await res.json() as any - throw new Error(err.message ?? 'GitHub write failed') - } -} - -async function ghDelete( - token: string, - owner: string, - repo: string, - path: string, - message: string, -) { - const file = await ghGet(token, owner, repo, path) - if (!file) return false - const res = await fetch(`${GH_API}/repos/${owner}/${repo}/contents/${path}`, { - method: 'DELETE', - headers: ghHeaders(token), - body: JSON.stringify({ message, sha: file.sha }), - }) - return res.ok -} - function decodeContent(b64: string): string { return decodeURIComponent(escape(atob(b64.replace(/\n/g, '')))) } -// ─── Tasks ──────────────────────────────────────────────────────────────────── +// ─── Features (read-only) ───────────────────────────────────────────────────── + +const FEATURES_PATH = '.supercrew/features' -export async function listTasksGH(token: string, owner: string, repo: string): Promise<Task[]> { - const files = await ghList(token, owner, repo, '.team/tasks') - if (!files) return [] - const taskFiles = files.filter(f => f.name.endsWith('.md') && !f.name.startsWith('_')) - const tasks = await Promise.all( - taskFiles.map(f => readTaskGH(token, owner, repo, f.name.replace('.md', ''))) +/** List all feature directories */ +export async function listFeaturesGH( + token: string, owner: string, repo: string, +): Promise<FeatureMeta[]> { + const dirs = await ghList(token, owner, repo, FEATURES_PATH) + if (!dirs) return [] + const featureDirs = dirs.filter(d => d.type === 'dir') + const metas = await Promise.all( + featureDirs.map(d => getFeatureMetaGH(token, owner, repo, d.name)) ) - return tasks.filter(Boolean) as Task[] + return metas.filter(Boolean) as FeatureMeta[] } -export async function readTaskGH(token: string, owner: string, repo: string, id: string): Promise<Task | null> { - const file = await ghGet(token, owner, repo, `.team/tasks/${id}.md`) +/** Read meta.yaml for a single feature */ +export async function getFeatureMetaGH( + token: string, owner: string, repo: string, id: string, +): Promise<FeatureMeta | null> { + const file = await ghGet(token, owner, repo, `${FEATURES_PATH}/${id}/meta.yaml`) + if (!file) return null + const raw = yaml.load(decodeContent(file.content)) as Record<string, any> + return { + id: raw.id ?? id, + title: raw.title ?? '', + status: raw.status ?? 'planning', + owner: raw.owner ?? '', + priority: raw.priority ?? 'P2', + teams: raw.teams ?? [], + target_release: raw.target_release, + created: raw.created ?? '', + updated: raw.updated ?? '', + tags: raw.tags ?? [], + blocked_by: raw.blocked_by ?? [], + } as FeatureMeta +} + +/** Read design.md for a single feature */ +export async function getFeatureDesignGH( + token: string, owner: string, repo: string, id: string, +): Promise<DesignDoc | null> { + const file = await ghGet(token, owner, repo, `${FEATURES_PATH}/${id}/design.md`) if (!file) return null const { data, content } = matter(decodeContent(file.content)) return { - id, - title: data.title ?? '', - status: data.status ?? 'backlog', - priority: data.priority ?? 'P2', - assignee: data.assignee, - team: data.team, - sprint: data.sprint, - created: data.created ?? new Date().toISOString().split('T')[0], - updated: data.updated ?? new Date().toISOString().split('T')[0], - tags: data.tags ?? [], - blocks: data.blocks ?? [], - blocked_by: data.blocked_by ?? [], - plan_doc: data.plan_doc, - pr_url: data.pr_url, + status: data.status ?? 'draft', + reviewers: data.reviewers ?? [], + approved_by: data.approved_by, body: content.trim(), - } as Task + } as DesignDoc } -export async function writeTaskGH(token: string, owner: string, repo: string, task: Task): Promise<void> { - const { body, ...frontmatter } = task as any - frontmatter.updated = new Date().toISOString().split('T')[0] - const clean = Object.fromEntries(Object.entries(frontmatter).filter(([, v]) => v !== undefined)) - const content = matter.stringify(body ?? '', clean) - const existing = await ghGet(token, owner, repo, `.team/tasks/${task.id}.md`) - await ghPut(token, owner, repo, `.team/tasks/${task.id}.md`, content, `chore: update task ${task.id}`, existing?.sha) -} - -export async function deleteTaskGH(token: string, owner: string, repo: string, id: string): Promise<boolean> { - return ghDelete(token, owner, repo, `.team/tasks/${id}.md`, `chore: delete task ${id}`) -} - -// ─── Sprints ────────────────────────────────────────────────────────────────── - -export async function listSprintsGH(token: string, owner: string, repo: string): Promise<Sprint[]> { - const files = await ghList(token, owner, repo, '.team/sprints') - if (!files) return [] - const sprintFiles = files.filter(f => f.name.endsWith('.json')) - const sprints = await Promise.all( - sprintFiles.map(async f => { - const file = await ghGet(token, owner, repo, `.team/sprints/${f.name}`) - if (!file) return null - return JSON.parse(decodeContent(file.content)) as Sprint - }) - ) - return (sprints.filter(Boolean) as Sprint[]).sort((a, b) => b.id - a.id) -} - -export async function writeSprintGH(token: string, owner: string, repo: string, sprint: Sprint): Promise<void> { - const content = JSON.stringify(sprint, null, 2) - const existing = await ghGet(token, owner, repo, `.team/sprints/sprint-${sprint.id}.json`) - await ghPut(token, owner, repo, `.team/sprints/sprint-${sprint.id}.json`, content, `chore: update sprint ${sprint.id}`, existing?.sha) -} - -// ─── People ─────────────────────────────────────────────────────────────────── - -export async function listPeopleGH(token: string, owner: string, repo: string): Promise<Person[]> { - const files = await ghList(token, owner, repo, '.team/people') - if (!files) return [] - const personFiles = files.filter(f => f.name.endsWith('.md') && !f.name.startsWith('_')) - const people = await Promise.all( - personFiles.map(f => readPersonGH(token, owner, repo, f.name.replace('.md', ''))) - ) - return people.filter(Boolean) as Person[] -} - -export async function readPersonGH(token: string, owner: string, repo: string, username: string): Promise<Person | null> { - const file = await ghGet(token, owner, repo, `.team/people/${username}.md`) +/** Read plan.md for a single feature */ +export async function getFeaturePlanGH( + token: string, owner: string, repo: string, id: string, +): Promise<PlanDoc | null> { + const file = await ghGet(token, owner, repo, `${FEATURES_PATH}/${id}/plan.md`) if (!file) return null const { data, content } = matter(decodeContent(file.content)) return { - username, - name: data.name ?? username, - team: data.team ?? '', - updated: data.updated ?? '', - current_task: data.current_task, - blocked_by: data.blocked_by, - completed_today: data.completed_today ?? [], + total_tasks: data.total_tasks ?? 0, + completed_tasks: data.completed_tasks ?? 0, + progress: data.progress ?? 0, body: content.trim(), - } + } as PlanDoc } -export async function writePersonGH(token: string, owner: string, repo: string, person: Person): Promise<void> { - const { body, ...frontmatter } = person - frontmatter.updated = new Date().toISOString().split('T')[0] - const content = matter.stringify(body ?? '', frontmatter) - const existing = await ghGet(token, owner, repo, `.team/people/${person.username}.md`) - await ghPut(token, owner, repo, `.team/people/${person.username}.md`, content, `chore: update person ${person.username}`, existing?.sha) -} - -// ─── Knowledge ──────────────────────────────────────────────────────────────── - -export async function listKnowledgeGH(token: string, owner: string, repo: string): Promise<KnowledgeEntry[]> { - const files = await ghList(token, owner, repo, '.team/knowledge') - if (!files) return [] - const knowledgeFiles = files.filter(f => f.name.endsWith('.md') && !f.name.startsWith('_')) - const entries = await Promise.all( - knowledgeFiles.map(async f => { - const file = await ghGet(token, owner, repo, `.team/knowledge/${f.name}`) - if (!file) return null - const slug = f.name.replace('.md', '') - const { data, content } = matter(decodeContent(file.content)) - return { slug, title: data.title ?? slug, tags: data.tags ?? [], author: data.author ?? '', date: data.date ?? '', body: content.trim() } as KnowledgeEntry - }) - ) - return entries.filter(Boolean) as KnowledgeEntry[] +/** Read log.md for a single feature */ +export async function getFeatureLogGH( + token: string, owner: string, repo: string, id: string, +): Promise<FeatureLog | null> { + const file = await ghGet(token, owner, repo, `${FEATURES_PATH}/${id}/log.md`) + if (!file) return null + return { body: decodeContent(file.content).trim() } as FeatureLog +} + +/** Get full feature with all documents */ +export async function getFeatureGH( + token: string, owner: string, repo: string, id: string, +): Promise<Feature | null> { + const meta = await getFeatureMetaGH(token, owner, repo, id) + if (!meta) return null + const [design, plan, log] = await Promise.all([ + getFeatureDesignGH(token, owner, repo, id), + getFeaturePlanGH(token, owner, repo, id), + getFeatureLogGH(token, owner, repo, id), + ]) + return { + meta, + design: design ?? undefined, + plan: plan ?? undefined, + log: log ?? undefined, + } } -// ─── Decisions ──────────────────────────────────────────────────────────────── - -export async function listDecisionsGH(token: string, owner: string, repo: string): Promise<Decision[]> { - const files = await ghList(token, owner, repo, '.team/decisions') - if (!files) return [] - const decisionFiles = files.filter(f => f.name.endsWith('.md') && !f.name.startsWith('_')) - const decisions = await Promise.all( - decisionFiles.map(async f => { - const file = await ghGet(token, owner, repo, `.team/decisions/${f.name}`) - if (!file) return null - const id = f.name.replace('.md', '') - const { data, content } = matter(decodeContent(file.content)) - return { id, title: data.title ?? '', date: data.date ?? '', author: data.author ?? '', status: data.status ?? 'proposed', body: content.trim() } as Decision - }) +/** Check if .supercrew/features/ exists in a repo */ +export async function checkSupercrewExistsGH( + token: string, owner: string, repo: string, +): Promise<boolean> { + const res = await fetch( + `${GH_API}/repos/${owner}/${repo}/contents/${FEATURES_PATH}`, + { headers: ghHeaders(token) }, ) - return (decisions.filter(Boolean) as Decision[]).sort((a, b) => a.id.localeCompare(b.id)) + return res.ok } diff --git a/kanban/backend/src/store/index.ts b/kanban/backend/src/store/index.ts index 5f372a7..858cd28 100644 --- a/kanban/backend/src/store/index.ts +++ b/kanban/backend/src/store/index.ts @@ -1,184 +1,100 @@ -// File-based store — reads and writes .team/ directory as MD/JSON -// All data lives in the git repo alongside code +// File-based store — reads .supercrew/features/ directory (read-only) +// Used for local development / debug only -import { readFileSync, writeFileSync, readdirSync, existsSync, mkdirSync, unlinkSync } from 'fs' -import { join, basename } from 'path' +import { readFileSync, readdirSync, existsSync } from 'fs' +import { join } from 'path' import matter from 'gray-matter' -import type { Task, Sprint, Person, KnowledgeEntry, Decision, TaskStatus } from '../types/index.js' - -// Root of the .team/ directory — resolved relative to the project being managed -// Can be overridden via TEAM_DIR env var -function getTeamDir(): string { - return process.env.TEAM_DIR ?? join(process.cwd(), '../..', '.team') +import yaml from 'js-yaml' +import type { + FeatureMeta, DesignDoc, PlanDoc, FeatureLog, Feature, SupercrewStatus, +} from '../types/index.js' + +// Root of the .supercrew/ directory — resolved relative to the project being managed +function getSupercrewDir(): string { + return process.env.SUPERCREW_DIR ?? join(process.cwd(), '../..', '.supercrew') } -function ensureDir(path: string) { - if (!existsSync(path)) mkdirSync(path, { recursive: true }) -} +const FEATURES_PATH = 'features' -// ─── Tasks ──────────────────────────────────────────────────────────────────── +// ─── Features (read-only) ───────────────────────────────────────────────────── -export function listTasks(): Task[] { - const dir = join(getTeamDir(), 'tasks') +/** List all features from local .supercrew/features/ */ +export function listFeatures(): FeatureMeta[] { + const dir = join(getSupercrewDir(), FEATURES_PATH) if (!existsSync(dir)) return [] - return readdirSync(dir) - .filter(f => f.endsWith('.md') && !f.startsWith('_')) - .map(f => readTask(basename(f, '.md'))) - .filter(Boolean) as Task[] + return readdirSync(dir, { withFileTypes: true }) + .filter(d => d.isDirectory()) + .map(d => getFeatureMeta(d.name)) + .filter(Boolean) as FeatureMeta[] } -export function readTask(id: string): Task | null { - const file = join(getTeamDir(), 'tasks', `${id}.md`) +/** Read meta.yaml for a single feature */ +export function getFeatureMeta(id: string): FeatureMeta | null { + const file = join(getSupercrewDir(), FEATURES_PATH, id, 'meta.yaml') if (!existsSync(file)) return null + const raw = yaml.load(readFileSync(file, 'utf8')) as Record<string, any> + return { + id: raw.id ?? id, + title: raw.title ?? '', + status: raw.status ?? 'planning', + owner: raw.owner ?? '', + priority: raw.priority ?? 'P2', + teams: raw.teams ?? [], + target_release: raw.target_release, + created: raw.created ?? '', + updated: raw.updated ?? '', + tags: raw.tags ?? [], + blocked_by: raw.blocked_by ?? [], + } as FeatureMeta +} +/** Read design.md for a single feature */ +export function getFeatureDesign(id: string): DesignDoc | null { + const file = join(getSupercrewDir(), FEATURES_PATH, id, 'design.md') + if (!existsSync(file)) return null const { data, content } = matter(readFileSync(file, 'utf8')) return { - id, - title: data.title ?? '', - status: data.status ?? 'backlog', - priority: data.priority ?? 'P2', - assignee: data.assignee, - team: data.team, - sprint: data.sprint, - created: data.created ?? new Date().toISOString().split('T')[0], - updated: data.updated ?? new Date().toISOString().split('T')[0], - tags: data.tags ?? [], - blocks: data.blocks ?? [], - blocked_by: data.blocked_by ?? [], - plan_doc: data.plan_doc, - pr_url: data.pr_url, + status: data.status ?? 'draft', + reviewers: data.reviewers ?? [], + approved_by: data.approved_by, body: content.trim(), - } -} - -export function writeTask(task: Task): void { - ensureDir(join(getTeamDir(), 'tasks')) - const { body, ...frontmatter } = task - frontmatter.updated = new Date().toISOString().split('T')[0] - const clean = Object.fromEntries(Object.entries(frontmatter).filter(([, v]) => v !== undefined)) - const file = join(getTeamDir(), 'tasks', `${task.id}.md`) - writeFileSync(file, matter.stringify(body, clean)) -} - -export function updateTaskStatus(id: string, status: TaskStatus): Task | null { - const task = readTask(id) - if (!task) return null - task.status = status - writeTask(task) - return task -} - -export function deleteTask(id: string): boolean { - const file = join(getTeamDir(), 'tasks', `${id}.md`) - if (!existsSync(file)) return false - unlinkSync(file) - return true -} - -// ─── Sprints ────────────────────────────────────────────────────────────────── - -export function listSprints(): Sprint[] { - const dir = join(getTeamDir(), 'sprints') - if (!existsSync(dir)) return [] - - return readdirSync(dir) - .filter(f => f.endsWith('.json')) - .map(f => { - const raw = readFileSync(join(dir, f), 'utf8') - return JSON.parse(raw) as Sprint - }) - .sort((a, b) => b.id - a.id) -} - -export function activeSprint(): Sprint | null { - return listSprints().find(s => s.status === 'active') ?? null + } as DesignDoc } -export function writeSprint(sprint: Sprint): void { - ensureDir(join(getTeamDir(), 'sprints')) - const file = join(getTeamDir(), 'sprints', `sprint-${sprint.id}.json`) - writeFileSync(file, JSON.stringify(sprint, null, 2)) -} - -// ─── People ─────────────────────────────────────────────────────────────────── - -export function listPeople(): Person[] { - const dir = join(getTeamDir(), 'people') - if (!existsSync(dir)) return [] - - return readdirSync(dir) - .filter(f => f.endsWith('.md') && !f.startsWith('_')) - .map(f => readPerson(basename(f, '.md'))) - .filter(Boolean) as Person[] -} - -export function readPerson(username: string): Person | null { - const file = join(getTeamDir(), 'people', `${username}.md`) +/** Read plan.md for a single feature */ +export function getFeaturePlan(id: string): PlanDoc | null { + const file = join(getSupercrewDir(), FEATURES_PATH, id, 'plan.md') if (!existsSync(file)) return null - const { data, content } = matter(readFileSync(file, 'utf8')) return { - username, - name: data.name ?? username, - team: data.team ?? '', - updated: data.updated ?? '', - current_task: data.current_task, - blocked_by: data.blocked_by, - completed_today: data.completed_today ?? [], + total_tasks: data.total_tasks ?? 0, + completed_tasks: data.completed_tasks ?? 0, + progress: data.progress ?? 0, body: content.trim(), - } + } as PlanDoc } -export function writePerson(person: Person): void { - ensureDir(join(getTeamDir(), 'people')) - const { body, ...frontmatter } = person - frontmatter.updated = new Date().toISOString().split('T')[0] - const file = join(getTeamDir(), 'people', `${person.username}.md`) - writeFileSync(file, matter.stringify(body, frontmatter)) +/** Read log.md for a single feature */ +export function getFeatureLog(id: string): FeatureLog | null { + const file = join(getSupercrewDir(), FEATURES_PATH, id, 'log.md') + if (!existsSync(file)) return null + return { body: readFileSync(file, 'utf8').trim() } as FeatureLog } -// ─── Knowledge ──────────────────────────────────────────────────────────────── - -export function listKnowledge(): KnowledgeEntry[] { - const dir = join(getTeamDir(), 'knowledge') - if (!existsSync(dir)) return [] - - return readdirSync(dir) - .filter(f => f.endsWith('.md') && !f.startsWith('_')) - .map(f => { - const slug = basename(f, '.md') - const { data, content } = matter(readFileSync(join(dir, f), 'utf8')) - return { - slug, - title: data.title ?? slug, - tags: data.tags ?? [], - author: data.author ?? '', - date: data.date ?? '', - body: content.trim(), - } as KnowledgeEntry - }) +/** Get full feature with all documents */ +export function getFeature(id: string): Feature | null { + const meta = getFeatureMeta(id) + if (!meta) return null + return { + meta, + design: getFeatureDesign(id) ?? undefined, + plan: getFeaturePlan(id) ?? undefined, + log: getFeatureLog(id) ?? undefined, + } } -// ─── Decisions (ADR) ────────────────────────────────────────────────────────── - -export function listDecisions(): Decision[] { - const dir = join(getTeamDir(), 'decisions') - if (!existsSync(dir)) return [] - - return readdirSync(dir) - .filter(f => f.endsWith('.md') && !f.startsWith('_')) - .map(f => { - const id = basename(f, '.md') - const { data, content } = matter(readFileSync(join(dir, f), 'utf8')) - return { - id, - title: data.title ?? '', - date: data.date ?? '', - author: data.author ?? '', - status: data.status ?? 'proposed', - body: content.trim(), - } as Decision - }) - .sort((a, b) => a.id.localeCompare(b.id)) +/** Check if .supercrew/features/ exists locally */ +export function checkSupercrewExists(): boolean { + return existsSync(join(getSupercrewDir(), FEATURES_PATH)) } diff --git a/kanban/backend/src/types/index.ts b/kanban/backend/src/types/index.ts index f240485..980114b 100644 --- a/kanban/backend/src/types/index.ts +++ b/kanban/backend/src/types/index.ts @@ -1,67 +1,56 @@ -// Core data types — mirrors what lives in .team/ as MD/JSON files +// ─── SuperCrew Feature-Centric Types ────────────────────────────────────────── +// Data lives in .supercrew/features/ as YAML/MD files in the user's repo -export type TaskStatus = 'backlog' | 'todo' | 'in-progress' | 'in-review' | 'done' -export type TaskPriority = 'P0' | 'P1' | 'P2' | 'P3' +export type SupercrewStatus = 'planning' | 'designing' | 'ready' | 'active' | 'blocked' | 'done' +export type FeaturePriority = 'P0' | 'P1' | 'P2' | 'P3' +export type DesignStatus = 'draft' | 'in-review' | 'approved' | 'rejected' -export interface Task { - id: string // e.g. ENG-001 +/** meta.yaml — feature metadata */ +export interface FeatureMeta { + id: string title: string - status: TaskStatus - priority: TaskPriority - assignee?: string // username - team?: string - sprint?: number - created: string // ISO date - updated: string - tags: string[] - blocks: string[] // task IDs this blocks - blocked_by: string[] // task IDs blocking this - plan_doc?: string // path to docs/plans/<feature-name>/implementation-plan.md - pr_url?: string - body: string // markdown body (background, acceptance criteria, discussion) + status: SupercrewStatus + owner: string + priority: FeaturePriority + teams?: string[] + target_release?: string + created: string // ISO date + updated: string // ISO date + tags?: string[] + blocked_by?: string[] } -export interface Sprint { - id: number - name: string - start: string // ISO date - end: string - goal: string - status: 'planned' | 'active' | 'completed' +/** design.md — frontmatter + markdown body */ +export interface DesignDoc { + status: DesignStatus + reviewers: string[] + approved_by?: string + body: string // markdown body } -export interface Person { - username: string - name: string - team: string - updated: string - current_task?: string // task ID - blocked_by?: string // task ID or description - completed_today: string[] - body: string // markdown notes +/** plan.md — frontmatter + tasks breakdown markdown */ +export interface PlanDoc { + total_tasks: number + completed_tasks: number + progress: number // 0–100 + body: string // markdown body with task checklist } -export interface KnowledgeEntry { - slug: string // filename without .md - title: string - tags: string[] - author: string - date: string - body: string +/** log.md — pure markdown */ +export interface FeatureLog { + body: string // markdown content } -export interface Decision { - id: string // ADR-001 - title: string - date: string - author: string - status: 'proposed' | 'accepted' | 'deprecated' | 'superseded' - body: string +/** Aggregated feature for API responses */ +export interface Feature { + meta: FeatureMeta + design?: DesignDoc + plan?: PlanDoc + log?: FeatureLog } -// API response shapes -export interface KanbanBoard { - tasks: Task[] - sprints: Sprint[] - people: Person[] +/** Board response — features grouped by status */ +export interface FeatureBoard { + features: FeatureMeta[] + featuresByStatus: Record<SupercrewStatus, FeatureMeta[]> } diff --git a/kanban/frontend/packages/app-core/src/api.ts b/kanban/frontend/packages/app-core/src/api.ts index 9623db9..1b1dafe 100644 --- a/kanban/frontend/packages/app-core/src/api.ts +++ b/kanban/frontend/packages/app-core/src/api.ts @@ -1,4 +1,4 @@ -import type { Task, Sprint, Person, Board, TaskStatus } from './types.js' +import type { FeatureBoard, FeatureMeta, Feature, DesignDoc, PlanDoc } from './types.js' import { authHeaders, clearToken } from './auth.js' const BASE = '/api' @@ -22,71 +22,21 @@ function headers(extra?: Record<string, string>): Record<string, string> { return { ...authHeaders(), ...extra } } -// ─── Board ──────────────────────────────────────────────────────────────────── +// ─── Board (aggregate) ─────────────────────────────────────────────────────── -export const fetchBoard = (): Promise<Board> => - fetch(`${BASE}/board`, { headers: headers() }).then(json<Board>) +export const fetchBoard = (): Promise<FeatureBoard> => + fetch(`${BASE}/board`, { headers: headers() }).then(json<FeatureBoard>) -// ─── Tasks ──────────────────────────────────────────────────────────────────── +// ─── Features (read-only) ──────────────────────────────────────────────────── -export const fetchTasks = (): Promise<Task[]> => - fetch(`${BASE}/tasks`, { headers: headers() }).then(json<Task[]>) +export const fetchFeatures = (): Promise<FeatureMeta[]> => + fetch(`${BASE}/features`, { headers: headers() }).then(json<FeatureMeta[]>) -export const fetchTask = (id: string): Promise<Task> => - fetch(`${BASE}/tasks/${id}`, { headers: headers() }).then(json<Task>) +export const fetchFeature = (id: string): Promise<Feature> => + fetch(`${BASE}/features/${id}`, { headers: headers() }).then(json<Feature>) -export const createTask = (task: Omit<Task, 'created' | 'updated'>): Promise<Task> => - fetch(`${BASE}/tasks`, { - method: 'POST', - headers: headers({ 'Content-Type': 'application/json' }), - body: JSON.stringify(task), - }).then(json<Task>) +export const fetchFeatureDesign = (id: string): Promise<DesignDoc> => + fetch(`${BASE}/features/${id}/design`, { headers: headers() }).then(json<DesignDoc>) -export const updateTask = (id: string, patch: Partial<Task>): Promise<Task> => - fetch(`${BASE}/tasks/${id}`, { - method: 'PATCH', - headers: headers({ 'Content-Type': 'application/json' }), - body: JSON.stringify(patch), - }).then(json<Task>) - -export const updateTaskStatus = (id: string, status: TaskStatus): Promise<Task> => - fetch(`${BASE}/tasks/${id}/status`, { - method: 'PUT', - headers: headers({ 'Content-Type': 'application/json' }), - body: JSON.stringify({ status }), - }).then(json<Task>) - -export const deleteTask = (id: string): Promise<{ ok: boolean }> => - fetch(`${BASE}/tasks/${id}`, { method: 'DELETE', headers: headers() }).then(json<{ ok: boolean }>) - -// ─── Sprints ────────────────────────────────────────────────────────────────── - -export const fetchSprints = (): Promise<Sprint[]> => - fetch(`${BASE}/sprints`, { headers: headers() }).then(json<Sprint[]>) - -export const updateSprint = (id: number, patch: Partial<Sprint>): Promise<Sprint> => - fetch(`${BASE}/sprints/${id}`, { - method: 'PATCH', - headers: headers({ 'Content-Type': 'application/json' }), - body: JSON.stringify(patch), - }).then(json<Sprint>) - -// ─── People ─────────────────────────────────────────────────────────────────── - -export const fetchPeople = (): Promise<Person[]> => - fetch(`${BASE}/people`, { headers: headers() }).then(json<Person[]>) - -export const updatePerson = (username: string, patch: Partial<Person>): Promise<Person> => - fetch(`${BASE}/people/${username}`, { - method: 'PATCH', - headers: headers({ 'Content-Type': 'application/json' }), - body: JSON.stringify(patch), - }).then(json<Person>) - -// ─── Knowledge & Decisions ──────────────────────────────────────────────────── - -export const fetchKnowledge = (): Promise<import('./types.js').KnowledgeEntry[]> => - fetch(`${BASE}/knowledge`, { headers: headers() }).then(json<import('./types.js').KnowledgeEntry[]>) - -export const fetchDecisions = (): Promise<import('./types.js').Decision[]> => - fetch(`${BASE}/decisions`, { headers: headers() }).then(json<import('./types.js').Decision[]>) +export const fetchFeaturePlan = (id: string): Promise<PlanDoc> => + fetch(`${BASE}/features/${id}/plan`, { headers: headers() }).then(json<PlanDoc>) diff --git a/kanban/frontend/packages/app-core/src/hooks/useBoard.ts b/kanban/frontend/packages/app-core/src/hooks/useBoard.ts index 3ba05bc..e870f5b 100644 --- a/kanban/frontend/packages/app-core/src/hooks/useBoard.ts +++ b/kanban/frontend/packages/app-core/src/hooks/useBoard.ts @@ -1,11 +1,16 @@ import { useEffect } from 'react' import { useQuery, useQueryClient } from '@tanstack/react-query' import { fetchBoard } from '../api.js' -import type { Board } from '../types.js' +import type { FeatureBoard } from '../types.js' export const BOARD_KEY = ['board'] as const -const EMPTY_BOARD: Board = { tasks: [], sprints: [], people: [] } +const EMPTY_BOARD: FeatureBoard = { + features: [], + featuresByStatus: { + planning: [], designing: [], ready: [], active: [], blocked: [], done: [], + }, +} export function useBoard() { const queryClient = useQueryClient() @@ -27,10 +32,8 @@ export function useBoard() { const board = data ?? EMPTY_BOARD return { board, - tasks: board.tasks, - sprints: board.sprints, - people: board.people, - activeSprint: board.sprints.find(s => s.status === 'active') ?? null, + features: board.features, + featuresByStatus: board.featuresByStatus, isLoading, error, } diff --git a/kanban/frontend/packages/app-core/src/hooks/useMutations.ts b/kanban/frontend/packages/app-core/src/hooks/useMutations.ts index 32ed4cc..66316f2 100644 --- a/kanban/frontend/packages/app-core/src/hooks/useMutations.ts +++ b/kanban/frontend/packages/app-core/src/hooks/useMutations.ts @@ -1,95 +1,4 @@ -import { useMutation, useQueryClient } from '@tanstack/react-query' -import { - createTask, - updateTask, - updateTaskStatus, - deleteTask, - updateSprint, - updatePerson, -} from '../api.js' -import type { Task, TaskStatus } from '../types.js' -import { BOARD_KEY } from './useBoard.js' +// No mutations — kanban is read-only. +// All data changes happen via the Claude Code plugin in the user's repo. -function useInvalidateBoard() { - const qc = useQueryClient() - return () => qc.invalidateQueries({ queryKey: BOARD_KEY }) -} - -// ─── Task mutations ─────────────────────────────────────────────────────────── - -export function useCreateTask() { - const invalidate = useInvalidateBoard() - return useMutation({ - mutationFn: (task: Omit<Task, 'created' | 'updated'>) => createTask(task), - onSuccess: invalidate, - }) -} - -export function useUpdateTask() { - const invalidate = useInvalidateBoard() - return useMutation({ - mutationFn: ({ id, patch }: { id: string; patch: Partial<Task> }) => - updateTask(id, patch), - onSuccess: invalidate, - }) -} - -export function useUpdateTaskStatus() { - const qc = useQueryClient() - return useMutation({ - mutationFn: ({ id, status }: { id: string; status: TaskStatus }) => - updateTaskStatus(id, status), - // Optimistic update — flip status in cache immediately - onMutate: async ({ id, status }) => { - await qc.cancelQueries({ queryKey: BOARD_KEY }) - const prev = qc.getQueryData(BOARD_KEY) - qc.setQueryData(BOARD_KEY, (old: { tasks: Task[] } | undefined) => { - if (!old) return old - return { - ...old, - tasks: old.tasks.map(t => (t.id === id ? { ...t, status } : t)), - } - }) - return { prev } - }, - onError: (_err, _vars, ctx) => { - if (ctx?.prev) qc.setQueryData(BOARD_KEY, ctx.prev) - }, - onSettled: () => qc.invalidateQueries({ queryKey: BOARD_KEY }), - }) -} - -export function useDeleteTask() { - const invalidate = useInvalidateBoard() - return useMutation({ - mutationFn: (id: string) => deleteTask(id), - onSuccess: invalidate, - }) -} - -// ─── Sprint mutations ───────────────────────────────────────────────────────── - -export function useUpdateSprint() { - const invalidate = useInvalidateBoard() - return useMutation({ - mutationFn: ({ id, patch }: { id: number; patch: Parameters<typeof updateSprint>[1] }) => - updateSprint(id, patch), - onSuccess: invalidate, - }) -} - -// ─── Person mutations ───────────────────────────────────────────────────────── - -export function useUpdatePerson() { - const invalidate = useInvalidateBoard() - return useMutation({ - mutationFn: ({ - username, - patch, - }: { - username: string - patch: Parameters<typeof updatePerson>[1] - }) => updatePerson(username, patch), - onSuccess: invalidate, - }) -} +export {} diff --git a/kanban/frontend/packages/app-core/src/index.ts b/kanban/frontend/packages/app-core/src/index.ts index f318328..0108324 100644 --- a/kanban/frontend/packages/app-core/src/index.ts +++ b/kanban/frontend/packages/app-core/src/index.ts @@ -1,6 +1,5 @@ export * from './types.js' export * from './api.js' export * from './hooks/useBoard.js' -export * from './hooks/useMutations.js' export * from './auth.js' export * from './hooks/useAuth.js' diff --git a/kanban/frontend/packages/app-core/src/types.ts b/kanban/frontend/packages/app-core/src/types.ts index cd43bdd..8647a23 100644 --- a/kanban/frontend/packages/app-core/src/types.ts +++ b/kanban/frontend/packages/app-core/src/types.ts @@ -1,66 +1,49 @@ // Mirror of backend types — keep in sync with kanban/backend/src/types/index.ts -export type TaskStatus = 'backlog' | 'todo' | 'in-progress' | 'in-review' | 'done' -export type TaskPriority = 'P0' | 'P1' | 'P2' | 'P3' +export type SupercrewStatus = 'planning' | 'designing' | 'ready' | 'active' | 'blocked' | 'done' +export type FeaturePriority = 'P0' | 'P1' | 'P2' | 'P3' +export type DesignStatus = 'draft' | 'in-review' | 'approved' | 'rejected' -export interface Task { +export interface FeatureMeta { id: string title: string - status: TaskStatus - priority: TaskPriority - assignee?: string - team?: string - sprint?: number + status: SupercrewStatus + owner: string + priority: FeaturePriority + teams?: string[] + target_release?: string created: string updated: string - tags: string[] - blocks: string[] - blocked_by: string[] - plan_doc?: string - pr_url?: string - body: string + tags?: string[] + blocked_by?: string[] } -export interface Sprint { - id: number - name: string - start: string - end: string - goal: string - status: 'planned' | 'active' | 'completed' +export interface DesignDoc { + status: DesignStatus + reviewers: string[] + approved_by?: string + body: string } -export interface Person { - username: string - name: string - team: string - updated: string - current_task?: string - blocked_by?: string - completed_today: string[] +export interface PlanDoc { + total_tasks: number + completed_tasks: number + progress: number body: string } -export interface KnowledgeEntry { - slug: string - title: string - tags: string[] - author: string - date: string +export interface FeatureLog { body: string } -export interface Decision { - id: string - title: string - date: string - author: string - status: 'proposed' | 'accepted' | 'deprecated' | 'superseded' - body: string +export interface Feature { + meta: FeatureMeta + design?: DesignDoc + plan?: PlanDoc + log?: FeatureLog } -export interface Board { - tasks: Task[] - sprints: Sprint[] - people: Person[] +export interface FeatureBoard { + features: FeatureMeta[] + featuresByStatus: Record<SupercrewStatus, FeatureMeta[]> } diff --git a/kanban/frontend/packages/local-web/src/locales/en.json b/kanban/frontend/packages/local-web/src/locales/en.json index a7d71ee..d3b9f9e 100644 --- a/kanban/frontend/packages/local-web/src/locales/en.json +++ b/kanban/frontend/packages/local-web/src/locales/en.json @@ -1,9 +1,6 @@ { "nav": { - "board": "Board", - "people": "People", - "knowledge": "Knowledge", - "decisions": "Decisions" + "board": "Board" }, "sidebar": { "lightMode": "Light mode", @@ -14,13 +11,12 @@ }, "board": { "loading": "Loading…", - "activeSprint": "Active Sprint", - "addTo": "Add to {{name}}", "columns": { - "backlog": "Backlog", - "todo": "To Do", - "inProgress": "In Progress", - "inReview": "In Review", + "planning": "Planning", + "designing": "Designing", + "ready": "Ready", + "active": "Active", + "blocked": "Blocked", "done": "Done" } }, @@ -54,11 +50,11 @@ "private": "private" }, "step3": { - "initializing": "Initializing .team/ directory…", - "success": "Initialized successfully, entering board…", + "binding": "Binding repo…", + "success": "Repo bound successfully, entering board…", "retry": "Retry", "noRepo": "Please go back and select a repo first", - "initFailed": "Initialization failed", + "bindFailed": "Binding failed", "unknownError": "Unknown error" }, "nav": { @@ -66,39 +62,39 @@ "next": "Next" } }, - "people": { - "title": "Team", - "empty": "No people found. Add .md files to .team/people/", - "workingOn": "Working on", - "today": "Today" - }, - "knowledge": { - "title": "Knowledge Base", - "loading": "Loading…", - "empty": "No entries yet. Add .md files to .team/knowledge/" - }, - "decisions": { - "title": "Architecture Decisions", + "feature": { + "notFound": "Feature {{id}} not found", "loading": "Loading…", - "empty": "No ADRs yet. Add .md files to .team/decisions/" - }, - "task": { - "notFound": "Task {{id}} not found", + "tabs": { + "overview": "Overview", + "design": "Design", + "plan": "Plan" + }, "props": { "status": "Status", "priority": "Priority", - "assignee": "Assignee", - "sprint": "Sprint", + "owner": "Owner", + "teams": "Teams", "tags": "Tags", - "pr": "PR", - "blockedBy": "Blocked by", - "blocks": "Blocks" + "targetRelease": "Target Release", + "created": "Created", + "updated": "Updated", + "blockedBy": "Blocked by" + }, + "design": { + "status": "Design Status", + "reviewers": "Reviewers", + "approvedBy": "Approved by", + "noDesign": "No design document yet" }, - "sprintLabel": "Sprint {{n}}", - "description": "Description", - "clickToEdit": "Click to edit", - "addDescription": "Click to add description…", - "save": "Save", - "cancel": "Cancel" + "plan": { + "progress": "Progress", + "tasks": "Tasks", + "noPlan": "No implementation plan yet" + } + }, + "empty": { + "title": "No features yet", + "description": "Install the SuperCrew plugin in your repo and use /new-feature to create your first feature." } } diff --git a/kanban/frontend/packages/local-web/src/locales/zh.json b/kanban/frontend/packages/local-web/src/locales/zh.json index e0eab18..86c22c4 100644 --- a/kanban/frontend/packages/local-web/src/locales/zh.json +++ b/kanban/frontend/packages/local-web/src/locales/zh.json @@ -1,9 +1,6 @@ { "nav": { - "board": "看板", - "people": "成员", - "knowledge": "知识库", - "decisions": "决策记录" + "board": "看板" }, "sidebar": { "lightMode": "亮色模式", @@ -14,13 +11,12 @@ }, "board": { "loading": "加载中…", - "activeSprint": "当前 Sprint", - "addTo": "添加到 {{name}}", "columns": { - "backlog": "Backlog", - "todo": "待办", - "inProgress": "进行中", - "inReview": "审查中", + "planning": "规划中", + "designing": "设计中", + "ready": "就绪", + "active": "进行中", + "blocked": "阻塞", "done": "已完成" } }, @@ -54,11 +50,11 @@ "private": "私有" }, "step3": { - "initializing": "正在初始化 .team/ 目录…", - "success": "初始化成功，即将进入看板…", + "binding": "正在绑定 Repo…", + "success": "绑定成功，即将进入看板…", "retry": "重试", "noRepo": "请先返回上一步选择 Repo", - "initFailed": "初始化失败", + "bindFailed": "绑定失败", "unknownError": "未知错误" }, "nav": { @@ -66,39 +62,39 @@ "next": "下一步" } }, - "people": { - "title": "团队", - "empty": "暂无成员。在 .team/people/ 中添加 .md 文件", - "workingOn": "正在做", - "today": "今日完成" - }, - "knowledge": { - "title": "知识库", - "loading": "加载中…", - "empty": "暂无条目。在 .team/knowledge/ 中添加 .md 文件" - }, - "decisions": { - "title": "架构决策", + "feature": { + "notFound": "找不到 Feature {{id}}", "loading": "加载中…", - "empty": "暂无 ADR。在 .team/decisions/ 中添加 .md 文件" - }, - "task": { - "notFound": "找不到任务 {{id}}", + "tabs": { + "overview": "概览", + "design": "设计", + "plan": "计划" + }, "props": { "status": "状态", "priority": "优先级", - "assignee": "负责人", - "sprint": "Sprint", + "owner": "负责人", + "teams": "团队", "tags": "标签", - "pr": "PR", - "blockedBy": "被阻塞", - "blocks": "阻塞" + "targetRelease": "目标版本", + "created": "创建时间", + "updated": "更新时间", + "blockedBy": "被阻塞" + }, + "design": { + "status": "设计状态", + "reviewers": "审阅者", + "approvedBy": "批准人", + "noDesign": "暂无设计文档" }, - "sprintLabel": "Sprint {{n}}", - "description": "描述", - "clickToEdit": "点击编辑", - "addDescription": "点击添加描述…", - "save": "保存", - "cancel": "取消" + "plan": { + "progress": "进度", + "tasks": "任务", + "noPlan": "暂无实施计划" + } + }, + "empty": { + "title": "暂无 Feature", + "description": "请在你的 repo 中安装 SuperCrew 插件，并使用 /new-feature 创建第一个 feature。" } } diff --git a/kanban/frontend/packages/local-web/src/routeTree.gen.ts b/kanban/frontend/packages/local-web/src/routeTree.gen.ts index 30b2250..2a2fe9e 100644 --- a/kanban/frontend/packages/local-web/src/routeTree.gen.ts +++ b/kanban/frontend/packages/local-web/src/routeTree.gen.ts @@ -10,12 +10,9 @@ import { Route as rootRouteImport } from './routes/__root' import { Route as WelcomeRouteImport } from './routes/welcome' -import { Route as PeopleRouteImport } from './routes/people' import { Route as LoginRouteImport } from './routes/login' -import { Route as KnowledgeRouteImport } from './routes/knowledge' -import { Route as DecisionsRouteImport } from './routes/decisions' import { Route as IndexRouteImport } from './routes/index' -import { Route as TasksIdRouteImport } from './routes/tasks.$id' +import { Route as FeaturesIdRouteImport } from './routes/features.$id' import { Route as AuthCallbackRouteImport } from './routes/auth.callback' const WelcomeRoute = WelcomeRouteImport.update({ @@ -23,34 +20,19 @@ const WelcomeRoute = WelcomeRouteImport.update({ path: '/welcome', getParentRoute: () => rootRouteImport, } as any) -const PeopleRoute = PeopleRouteImport.update({ - id: '/people', - path: '/people', - getParentRoute: () => rootRouteImport, -} as any) const LoginRoute = LoginRouteImport.update({ id: '/login', path: '/login', getParentRoute: () => rootRouteImport, } as any) -const KnowledgeRoute = KnowledgeRouteImport.update({ - id: '/knowledge', - path: '/knowledge', - getParentRoute: () => rootRouteImport, -} as any) -const DecisionsRoute = DecisionsRouteImport.update({ - id: '/decisions', - path: '/decisions', - getParentRoute: () => rootRouteImport, -} as any) const IndexRoute = IndexRouteImport.update({ id: '/', path: '/', getParentRoute: () => rootRouteImport, } as any) -const TasksIdRoute = TasksIdRouteImport.update({ - id: '/tasks/$id', - path: '/tasks/$id', +const FeaturesIdRoute = FeaturesIdRouteImport.update({ + id: '/features/$id', + path: '/features/$id', getParentRoute: () => rootRouteImport, } as any) const AuthCallbackRoute = AuthCallbackRouteImport.update({ @@ -61,77 +43,46 @@ const AuthCallbackRoute = AuthCallbackRouteImport.update({ export interface FileRoutesByFullPath { '/': typeof IndexRoute - '/decisions': typeof DecisionsRoute - '/knowledge': typeof KnowledgeRoute '/login': typeof LoginRoute - '/people': typeof PeopleRoute '/welcome': typeof WelcomeRoute '/auth/callback': typeof AuthCallbackRoute - '/tasks/$id': typeof TasksIdRoute + '/features/$id': typeof FeaturesIdRoute } export interface FileRoutesByTo { '/': typeof IndexRoute - '/decisions': typeof DecisionsRoute - '/knowledge': typeof KnowledgeRoute '/login': typeof LoginRoute - '/people': typeof PeopleRoute '/welcome': typeof WelcomeRoute '/auth/callback': typeof AuthCallbackRoute - '/tasks/$id': typeof TasksIdRoute + '/features/$id': typeof FeaturesIdRoute } export interface FileRoutesById { __root__: typeof rootRouteImport '/': typeof IndexRoute - '/decisions': typeof DecisionsRoute - '/knowledge': typeof KnowledgeRoute '/login': typeof LoginRoute - '/people': typeof PeopleRoute '/welcome': typeof WelcomeRoute '/auth/callback': typeof AuthCallbackRoute - '/tasks/$id': typeof TasksIdRoute + '/features/$id': typeof FeaturesIdRoute } export interface FileRouteTypes { fileRoutesByFullPath: FileRoutesByFullPath - fullPaths: - | '/' - | '/decisions' - | '/knowledge' - | '/login' - | '/people' - | '/welcome' - | '/auth/callback' - | '/tasks/$id' + fullPaths: '/' | '/login' | '/welcome' | '/auth/callback' | '/features/$id' fileRoutesByTo: FileRoutesByTo - to: - | '/' - | '/decisions' - | '/knowledge' - | '/login' - | '/people' - | '/welcome' - | '/auth/callback' - | '/tasks/$id' + to: '/' | '/login' | '/welcome' | '/auth/callback' | '/features/$id' id: | '__root__' | '/' - | '/decisions' - | '/knowledge' | '/login' - | '/people' | '/welcome' | '/auth/callback' - | '/tasks/$id' + | '/features/$id' fileRoutesById: FileRoutesById } export interface RootRouteChildren { IndexRoute: typeof IndexRoute - DecisionsRoute: typeof DecisionsRoute - KnowledgeRoute: typeof KnowledgeRoute LoginRoute: typeof LoginRoute - PeopleRoute: typeof PeopleRoute WelcomeRoute: typeof WelcomeRoute AuthCallbackRoute: typeof AuthCallbackRoute - TasksIdRoute: typeof TasksIdRoute + FeaturesIdRoute: typeof FeaturesIdRoute } declare module '@tanstack/react-router' { @@ -143,13 +94,6 @@ declare module '@tanstack/react-router' { preLoaderRoute: typeof WelcomeRouteImport parentRoute: typeof rootRouteImport } - '/people': { - id: '/people' - path: '/people' - fullPath: '/people' - preLoaderRoute: typeof PeopleRouteImport - parentRoute: typeof rootRouteImport - } '/login': { id: '/login' path: '/login' @@ -157,20 +101,6 @@ declare module '@tanstack/react-router' { preLoaderRoute: typeof LoginRouteImport parentRoute: typeof rootRouteImport } - '/knowledge': { - id: '/knowledge' - path: '/knowledge' - fullPath: '/knowledge' - preLoaderRoute: typeof KnowledgeRouteImport - parentRoute: typeof rootRouteImport - } - '/decisions': { - id: '/decisions' - path: '/decisions' - fullPath: '/decisions' - preLoaderRoute: typeof DecisionsRouteImport - parentRoute: typeof rootRouteImport - } '/': { id: '/' path: '/' @@ -178,11 +108,11 @@ declare module '@tanstack/react-router' { preLoaderRoute: typeof IndexRouteImport parentRoute: typeof rootRouteImport } - '/tasks/$id': { - id: '/tasks/$id' - path: '/tasks/$id' - fullPath: '/tasks/$id' - preLoaderRoute: typeof TasksIdRouteImport + '/features/$id': { + id: '/features/$id' + path: '/features/$id' + fullPath: '/features/$id' + preLoaderRoute: typeof FeaturesIdRouteImport parentRoute: typeof rootRouteImport } '/auth/callback': { @@ -197,13 +127,10 @@ declare module '@tanstack/react-router' { const rootRouteChildren: RootRouteChildren = { IndexRoute: IndexRoute, - DecisionsRoute: DecisionsRoute, - KnowledgeRoute: KnowledgeRoute, LoginRoute: LoginRoute, - PeopleRoute: PeopleRoute, WelcomeRoute: WelcomeRoute, AuthCallbackRoute: AuthCallbackRoute, - TasksIdRoute: TasksIdRoute, + FeaturesIdRoute: FeaturesIdRoute, } export const routeTree = rootRouteImport ._addFileChildren(rootRouteChildren) diff --git a/kanban/frontend/packages/local-web/src/routes/__root.tsx b/kanban/frontend/packages/local-web/src/routes/__root.tsx index 061c81f..cf8d05a 100644 --- a/kanban/frontend/packages/local-web/src/routes/__root.tsx +++ b/kanban/frontend/packages/local-web/src/routes/__root.tsx @@ -2,8 +2,8 @@ import { Outlet, createRootRoute, useRouterState, useNavigate } from '@tanstack/ import { useEffect, useState } from 'react' import { useQuery, useQueryClient } from '@tanstack/react-query' import { - SquaresFourIcon, UsersIcon, BookOpenIcon, - LightbulbIcon, LightningIcon, + SquaresFourIcon, + LightningIcon, } from '@phosphor-icons/react' import { useTranslation } from 'react-i18next' import AppHeader from '@web/components/AppHeader' @@ -120,24 +120,6 @@ function RootLayout() { onClick: () => navigate({ to: '/' }), className: isActive('/', true) ? 'dock-item-active' : '', }, - { - icon: <UsersIcon size={17} weight={iconWeight('/people')} color={iconColor('/people')} />, - label: t('nav.people'), - onClick: () => navigate({ to: '/people' }), - className: isActive('/people') ? 'dock-item-active' : '', - }, - { - icon: <BookOpenIcon size={17} weight={iconWeight('/knowledge')} color={iconColor('/knowledge')} />, - label: t('nav.knowledge'), - onClick: () => navigate({ to: '/knowledge' }), - className: isActive('/knowledge') ? 'dock-item-active' : '', - }, - { - icon: <LightbulbIcon size={17} weight={iconWeight('/decisions')} color={iconColor('/decisions')} />, - label: t('nav.decisions'), - onClick: () => navigate({ to: '/decisions' }), - className: isActive('/decisions') ? 'dock-item-active' : '', - }, ] return ( diff --git a/kanban/frontend/packages/local-web/src/routes/decisions.tsx b/kanban/frontend/packages/local-web/src/routes/decisions.tsx deleted file mode 100644 index 7ab2326..0000000 --- a/kanban/frontend/packages/local-web/src/routes/decisions.tsx +++ /dev/null @@ -1,106 +0,0 @@ -import { createFileRoute } from '@tanstack/react-router' -import { useQuery } from '@tanstack/react-query' -import { useTranslation } from 'react-i18next' -import { fetchDecisions } from '@app/api' -import type { Decision } from '@app/types' - -function DecisionsPage() { - const { t } = useTranslation() - const { data: decisions = [], isLoading } = useQuery({ - queryKey: ['decisions'], - queryFn: fetchDecisions, - }) - - if (isLoading) { - return ( - <div style={{ - display: 'flex', height: '100%', - alignItems: 'center', justifyContent: 'center', - color: 'hsl(var(--text-low))', fontSize: 13, - fontFamily: 'Instrument Sans, sans-serif', - }}> - {t('decisions.loading')} - </div> - ) - } - - return ( - <div className="rb-page" style={{ height: '100%', overflowY: 'auto', padding: '28px 32px' }}> - <div style={{ maxWidth: 760, margin: '0 auto' }}> - <h1 className="rb-display" style={{ - fontSize: 20, fontWeight: 700, - color: 'hsl(var(--text-high))', - marginBottom: 24, - }}> - {t('decisions.title')} - </h1> - - <div style={{ display: 'flex', flexDirection: 'column', gap: 10 }}> - {decisions.map(d => <DecisionCard key={d.id} decision={d} />)} - {decisions.length === 0 && ( - <p style={{ fontSize: 13, color: 'hsl(var(--text-low))', fontFamily: 'Instrument Sans, sans-serif' }}> - {t('decisions.empty')} - </p> - )} - </div> - </div> - </div> - ) -} - -function DecisionCard({ decision }: { decision: Decision }) { - return ( - <div - className="rb-card rb-glass rb-card-hover" - style={{ - background: 'hsl(var(--_bg-secondary-default))', - padding: '16px 20px', - }} - > - {/* Header */} - <div style={{ - display: 'flex', alignItems: 'flex-start', justifyContent: 'space-between', - gap: 12, marginBottom: 10, - }}> - <div style={{ display: 'flex', alignItems: 'center', gap: 10, minWidth: 0 }}> - <span className="rb-mono" style={{ fontSize: 10, color: 'hsl(var(--text-low))', flexShrink: 0 }}> - {decision.id} - </span> - <h2 style={{ - fontSize: 14, fontWeight: 600, - color: 'hsl(var(--text-high))', - margin: 0, lineHeight: 1.3, - fontFamily: 'Instrument Sans, sans-serif', - overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap', - }}> - {decision.title} - </h2> - </div> - - <div style={{ display: 'flex', alignItems: 'center', gap: 9, flexShrink: 0 }}> - <span className={`rb-badge rb-badge-${decision.status}`}> - {decision.status} - </span> - <span className="rb-mono" style={{ fontSize: 10, color: 'hsl(var(--text-low))' }}> - {decision.date} - </span> - </div> - </div> - - {/* Body excerpt */} - <p style={{ - fontSize: 12.5, color: 'hsl(var(--text-low))', - lineHeight: 1.65, margin: 0, - fontFamily: 'Instrument Sans, sans-serif', - display: '-webkit-box', - WebkitLineClamp: 4, - WebkitBoxOrient: 'vertical' as const, - overflow: 'hidden', - }}> - {decision.body.slice(0, 500)}{decision.body.length > 500 && '…'} - </p> - </div> - ) -} - -export const Route = createFileRoute('/decisions')({ component: DecisionsPage }) diff --git a/kanban/frontend/packages/local-web/src/routes/features.$id.tsx b/kanban/frontend/packages/local-web/src/routes/features.$id.tsx new file mode 100644 index 0000000..57e282b --- /dev/null +++ b/kanban/frontend/packages/local-web/src/routes/features.$id.tsx @@ -0,0 +1,347 @@ +import { createFileRoute, useNavigate } from '@tanstack/react-router' +import { useState } from 'react' +import { useQuery } from '@tanstack/react-query' +import { useTranslation } from 'react-i18next' +import { ArrowLeftIcon } from '@phosphor-icons/react' +import { fetchFeature, fetchFeatureDesign, fetchFeaturePlan } from '@app/api' +import type { Feature, SupercrewStatus, DesignStatus, DesignDoc, PlanDoc } from '@app/types' + +export const Route = createFileRoute('/features/$id')({ + component: FeatureDetailPage, +}) + +/* ─── Status helpers ────────────────────────────────────────────────────────── */ + +const STATUS_COLOR: Record<SupercrewStatus, string> = { + planning: '#a78bfa', + designing: '#60a5fa', + ready: '#34d399', + active: '#fbbf24', + blocked: '#f87171', + done: '#6ee7b7', +} + +const DESIGN_STATUS_COLOR: Record<DesignStatus, string> = { + draft: '#9ca3af', + 'in-review': '#60a5fa', + approved: '#34d399', + rejected: '#f87171', +} + +const PRIORITY_COLOR: Record<string, string> = { + P0: '#ef4444', + P1: '#f59e0b', + P2: '#3b82f6', + P3: '#9ca3af', +} + +/* ─── Page ──────────────────────────────────────────────────────────────────── */ + +function FeatureDetailPage() { + const { id } = Route.useParams() + const navigate = useNavigate() + const { t } = useTranslation() + const [tab, setTab] = useState<'overview' | 'design' | 'plan'>('overview') + + const { data: feature, isLoading, error } = useQuery<Feature>({ + queryKey: ['feature', id], + queryFn: () => fetchFeature(id), + }) + + const { data: designDoc } = useQuery<DesignDoc>({ + queryKey: ['feature-design', id], + queryFn: () => fetchFeatureDesign(id), + enabled: tab === 'design', + }) + + const { data: planDoc } = useQuery<PlanDoc>({ + queryKey: ['feature-plan', id], + queryFn: () => fetchFeaturePlan(id), + enabled: tab === 'plan', + }) + + if (isLoading) { + return ( + <div style={{ display: 'flex', justifyContent: 'center', alignItems: 'center', height: '100%', color: '#94a3b8' }}> + {t('common.loading', 'Loading…')} + </div> + ) + } + + if (error || !feature) { + return ( + <div style={{ display: 'flex', justifyContent: 'center', alignItems: 'center', height: '100%', color: '#f87171' }}> + {t('common.error', 'Failed to load feature')} + </div> + ) + } + + const meta = feature.meta + + return ( + <div style={{ height: '100%', display: 'flex', flexDirection: 'column', overflow: 'hidden' }}> + {/* Header */} + <div + style={{ + display: 'flex', + alignItems: 'center', + gap: 12, + padding: '12px 20px', + borderBottom: '1px solid rgba(255,255,255,0.08)', + background: 'rgba(30,41,59,0.6)', + backdropFilter: 'blur(12px)', + }} + > + <button + onClick={() => navigate({ to: '/' })} + style={{ + background: 'none', + border: 'none', + color: '#94a3b8', + cursor: 'pointer', + display: 'flex', + alignItems: 'center', + padding: 4, + }} + > + <ArrowLeftIcon size={20} /> + </button> + + <Badge color={STATUS_COLOR[meta.status]}>{meta.status}</Badge> + {meta.priority && ( + <Badge color={PRIORITY_COLOR[meta.priority] ?? '#9ca3af'}>{meta.priority}</Badge> + )} + + <h1 style={{ margin: 0, fontSize: 18, fontWeight: 600, color: '#e2e8f0', flex: 1 }}> + {meta.title} + </h1> + </div> + + {/* Tab bar */} + <div + style={{ + display: 'flex', + gap: 0, + borderBottom: '1px solid rgba(255,255,255,0.08)', + background: 'rgba(30,41,59,0.4)', + }} + > + {(['overview', 'design', 'plan'] as const).map((t2) => ( + <button + key={t2} + onClick={() => setTab(t2)} + style={{ + padding: '10px 20px', + background: 'none', + border: 'none', + borderBottom: tab === t2 ? '2px solid #60a5fa' : '2px solid transparent', + color: tab === t2 ? '#e2e8f0' : '#64748b', + cursor: 'pointer', + fontWeight: tab === t2 ? 600 : 400, + fontSize: 14, + textTransform: 'capitalize', + }} + > + {t(`feature.tabs.${t2}`, t2)} + </button> + ))} + </div> + + {/* Tab content */} + <div style={{ flex: 1, overflow: 'auto', padding: 20 }}> + {tab === 'overview' && <OverviewTab feature={feature} />} + {tab === 'design' && <MarkdownBody md={designDoc?.body} />} + {tab === 'plan' && <MarkdownBody md={planDoc?.body} />} + </div> + </div> + ) +} + +/* ─── Overview Tab ──────────────────────────────────────────────────────────── */ + +function OverviewTab({ feature }: { feature: Feature }) { + const { t } = useTranslation() + const meta = feature.meta + + return ( + <div style={{ display: 'flex', flexDirection: 'column', gap: 20, maxWidth: 720 }}> + {/* Basic info */} + <Section title={t('feature.overview.basic', 'Basic Info')}> + <PropGrid> + <PropCell label={t('feature.fields.status', 'Status')}> + <Badge color={STATUS_COLOR[meta.status]}>{meta.status}</Badge> + </PropCell> + {meta.priority && ( + <PropCell label={t('feature.fields.priority', 'Priority')}> + <Badge color={PRIORITY_COLOR[meta.priority] ?? '#9ca3af'}>{meta.priority}</Badge> + </PropCell> + )} + {meta.owner && ( + <PropCell label={t('feature.fields.owner', 'Owner')}>{meta.owner}</PropCell> + )} + {meta.tags && meta.tags.length > 0 && ( + <PropCell label={t('feature.fields.tags', 'Tags')}> + <div style={{ display: 'flex', gap: 6, flexWrap: 'wrap' }}> + {meta.tags.map((tag) => ( + <Badge key={tag} color="#475569">{tag}</Badge> + ))} + </div> + </PropCell> + )} + </PropGrid> + </Section> + + {/* Teams & Release */} + {(meta.teams || meta.target_release || meta.blocked_by) && ( + <Section title={t('feature.overview.details', 'Details')}> + <PropGrid> + {meta.teams && meta.teams.length > 0 && ( + <PropCell label={t('feature.fields.teams', 'Teams')}> + {meta.teams.join(', ')} + </PropCell> + )} + {meta.target_release && ( + <PropCell label={t('feature.fields.targetRelease', 'Target Release')}> + {meta.target_release} + </PropCell> + )} + {meta.blocked_by && meta.blocked_by.length > 0 && ( + <PropCell label={t('feature.fields.blockedBy', 'Blocked By')}> + {meta.blocked_by.join(', ')} + </PropCell> + )} + </PropGrid> + </Section> + )} + + {/* Design summary */} + {feature.design && ( + <Section title={t('feature.overview.design', 'Design')}> + <PropGrid> + <PropCell label={t('feature.fields.designStatus', 'Design Status')}> + <Badge color={DESIGN_STATUS_COLOR[feature.design.status] ?? '#9ca3af'}> + {feature.design.status} + </Badge> + </PropCell> + {feature.design.reviewers && feature.design.reviewers.length > 0 && ( + <PropCell label={t('feature.fields.reviewers', 'Reviewers')}> + {feature.design.reviewers.join(', ')} + </PropCell> + )} + </PropGrid> + </Section> + )} + + {/* Plan summary */} + {feature.plan && ( + <Section title={t('feature.overview.plan', 'Plan')}> + <PropGrid> + <PropCell label={t('feature.fields.totalTasks', 'Total Tasks')}> + {feature.plan.total_tasks} + </PropCell> + <PropCell label={t('feature.fields.completedTasks', 'Completed')}> + {feature.plan.completed_tasks} + </PropCell> + <PropCell label={t('feature.fields.progress', 'Progress')}> + {Math.round(feature.plan.progress * 100)}% + </PropCell> + </PropGrid> + </Section> + )} + + {/* Log */} + {feature.log && feature.log.body && ( + <Section title={t('feature.overview.log', 'Activity Log')}> + <div + style={{ + color: '#cbd5e1', + lineHeight: 1.8, + fontSize: 14, + whiteSpace: 'pre-wrap', + }} + > + {feature.log.body} + </div> + </Section> + )} + </div> + ) +} + +/* ─── Shared components ─────────────────────────────────────────────────────── */ + +function Section({ title, children }: { title: string; children: React.ReactNode }) { + return ( + <div> + <h3 style={{ margin: '0 0 12px', fontSize: 15, fontWeight: 600, color: '#94a3b8', textTransform: 'uppercase', letterSpacing: '0.05em' }}> + {title} + </h3> + {children} + </div> + ) +} + +function PropGrid({ children }: { children: React.ReactNode }) { + return ( + <div style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fill, minmax(200px, 1fr))', gap: 12 }}> + {children} + </div> + ) +} + +function PropCell({ label, children }: { label: string; children: React.ReactNode }) { + return ( + <div style={{ display: 'flex', flexDirection: 'column', gap: 4 }}> + <span style={{ fontSize: 12, color: '#64748b', fontWeight: 500 }}>{label}</span> + <span style={{ fontSize: 14, color: '#e2e8f0' }}>{children}</span> + </div> + ) +} + +function Badge({ color, children }: { color: string; children: React.ReactNode }) { + return ( + <span + style={{ + display: 'inline-block', + padding: '2px 10px', + borderRadius: 9999, + fontSize: 12, + fontWeight: 600, + background: `${color}22`, + color, + border: `1px solid ${color}44`, + whiteSpace: 'nowrap', + }} + > + {children} + </span> + ) +} + +function MarkdownBody({ md }: { md?: string }) { + if (!md) { + return <EmptyState /> + } + return ( + <div + style={{ + color: '#cbd5e1', + lineHeight: 1.8, + fontSize: 14, + whiteSpace: 'pre-wrap', + maxWidth: 720, + }} + > + {md} + </div> + ) +} + +function EmptyState() { + const { t } = useTranslation() + return ( + <div style={{ display: 'flex', justifyContent: 'center', alignItems: 'center', height: 200, color: '#475569' }}> + {t('common.empty', 'No content yet')} + </div> + ) +} diff --git a/kanban/frontend/packages/local-web/src/routes/index.tsx b/kanban/frontend/packages/local-web/src/routes/index.tsx index ab54ab3..39d4fbf 100644 --- a/kanban/frontend/packages/local-web/src/routes/index.tsx +++ b/kanban/frontend/packages/local-web/src/routes/index.tsx @@ -1,16 +1,7 @@ import { createFileRoute, useNavigate } from '@tanstack/react-router' -import { useCallback, useEffect, useMemo, useState } from 'react' -import type { DropResult } from '@hello-pangea/dnd' -import { - KanbanProvider, - KanbanCards, - KanbanCard, -} from '@vibe/ui/components/KanbanBoard' -import { PlusIcon } from '@phosphor-icons/react' import { useTranslation } from 'react-i18next' import { useBoard } from '@app/hooks/useBoard' -import { useUpdateTaskStatus } from '@app/hooks/useMutations' -import type { Task, TaskPriority, TaskStatus } from '@app/types' +import type { FeatureMeta, FeaturePriority, SupercrewStatus } from '@app/types' import SpotlightCard from '@web/components/SpotlightCard' import CountUp from '@web/components/CountUp' import ClickSpark from '@web/components/ClickSpark' @@ -18,23 +9,24 @@ import AnimatedCard from '@web/components/AnimatedCard' // ─── Column config ────────────────────────────────────────────────────────── -const STATUS_COLUMN_IDS: TaskStatus[] = ['backlog', 'todo', 'in-progress', 'in-review', 'done'] - -const STATUS_KEY_MAP: Record<TaskStatus, string> = { - 'backlog': 'board.columns.backlog', - 'todo': 'board.columns.todo', - 'in-progress': 'board.columns.inProgress', - 'in-review': 'board.columns.inReview', - 'done': 'board.columns.done', +const STATUS_COLUMN_IDS: SupercrewStatus[] = [ + 'planning', 'designing', 'ready', 'active', 'blocked', 'done', +] + +const STATUS_KEY_MAP: Record<SupercrewStatus, string> = { + 'planning': 'board.columns.planning', + 'designing': 'board.columns.designing', + 'ready': 'board.columns.ready', + 'active': 'board.columns.active', + 'blocked': 'board.columns.blocked', + 'done': 'board.columns.done', } -function getStatusKey(status: TaskStatus): string { - if (status === 'in-progress') return 'progress' - if (status === 'in-review') return 'review' +function getStatusKey(status: SupercrewStatus): string { return status } -const PRI_CLASS: Record<TaskPriority, string> = { +const PRI_CLASS: Record<FeaturePriority, string> = { P0: 'rb-p0', P1: 'rb-p1', P2: 'rb-p2', P3: 'rb-p3', } @@ -42,8 +34,7 @@ const PRI_CLASS: Record<TaskPriority, string> = { function BoardPage() { const { t } = useTranslation() - const { tasks, activeSprint, isLoading } = useBoard() - const updateStatus = useUpdateTaskStatus() + const { featuresByStatus, isLoading } = useBoard() const navigate = useNavigate() const STATUS_COLUMNS = STATUS_COLUMN_IDS.map(id => ({ @@ -51,54 +42,6 @@ function BoardPage() { name: t(STATUS_KEY_MAP[id]), })) - const [columns, setColumns] = useState<Record<string, string[]>>({}) - - useEffect(() => { - const grouped: Record<string, string[]> = {} - for (const col of STATUS_COLUMNS) grouped[col.id] = [] - for (const task of tasks) { - if (grouped[task.status]) grouped[task.status].push(task.id) - } - setColumns(grouped) - }, [tasks]) - - const taskMap = useMemo(() => { - const m: Record<string, Task> = {} - for (const t of tasks) m[t.id] = t - return m - }, [tasks]) - - const handleDragEnd = useCallback( - (result: DropResult) => { - const { source, destination } = result - if (!destination) return - if ( - source.droppableId === destination.droppableId && - source.index === destination.index - ) return - - const srcId = source.droppableId as TaskStatus - const dstId = destination.droppableId as TaskStatus - - setColumns(prev => { - const srcItems = [...(prev[srcId] ?? [])] - const [moved] = srcItems.splice(source.index, 1) - if (srcId === dstId) { - srcItems.splice(destination.index, 0, moved) - return { ...prev, [srcId]: srcItems } - } - const dstItems = [...(prev[dstId] ?? [])] - dstItems.splice(destination.index, 0, moved) - return { ...prev, [srcId]: srcItems, [dstId]: dstItems } - }) - - if (srcId !== dstId) { - updateStatus.mutate({ id: result.draggableId, status: dstId }) - } - }, - [updateStatus], - ) - const isDark = document.documentElement.classList.contains('dark') if (isLoading) { @@ -117,56 +60,26 @@ function BoardPage() { return ( <div className="rb-page" style={{ display: 'flex', flexDirection: 'column', height: '100%', overflow: 'hidden' }}> - {/* ── Sprint header ── */} - {activeSprint && ( - <div style={{ - padding: '13px 22px 11px', - borderBottom: '1px solid hsl(var(--_border))', - flexShrink: 0, - background: 'hsl(var(--_background))', - }}> - <div className="rb-label" style={{ marginBottom: 3 }}>{t('board.activeSprint')}</div> - <div style={{ display: 'flex', alignItems: 'baseline', gap: 10 }}> - <h1 className="rb-display" style={{ - fontSize: 15, fontWeight: 700, - color: 'hsl(var(--text-high))', - margin: 0, - }}> - {activeSprint.name} - </h1> - {activeSprint.goal && ( - <span style={{ fontSize: 12.5, color: 'hsl(var(--text-low))' }}> - {activeSprint.goal} - </span> - )} - </div> - </div> - )} - {/* ── Kanban board with ClickSpark ── */} <div style={{ flex: 1, overflowX: 'auto', overflowY: 'hidden', padding: '16px 18px' }}> - <KanbanProvider onDragEnd={handleDragEnd}> - <ClickSpark - sparkColor={isDark ? '#34d399' : '#10b981'} - sparkCount={7} - sparkRadius={22} - sparkSize={7} - > - <div style={{ display: 'flex', gap: 10, alignItems: 'flex-start', minWidth: 'max-content', padding: 2 }}> - {STATUS_COLUMNS.map(col => ( - <Column - key={col.id} - col={col} - taskIds={columns[col.id] ?? []} - taskMap={taskMap} - isDark={isDark} - onCardClick={id => void navigate({ to: '/tasks/$id', params: { id } })} - onAdd={() => void navigate({ to: '/' })} - /> - ))} - </div> - </ClickSpark> - </KanbanProvider> + <ClickSpark + sparkColor={isDark ? '#34d399' : '#10b981'} + sparkCount={7} + sparkRadius={22} + sparkSize={7} + > + <div style={{ display: 'flex', gap: 10, alignItems: 'flex-start', minWidth: 'max-content', padding: 2 }}> + {STATUS_COLUMNS.map(col => ( + <Column + key={col.id} + col={col} + features={featuresByStatus[col.id] ?? []} + isDark={isDark} + onCardClick={id => void navigate({ to: '/features/$id', params: { id } })} + /> + ))} + </div> + </ClickSpark> </div> </div> ) @@ -176,20 +89,15 @@ function BoardPage() { function Column({ col, - taskIds, - taskMap, + features, isDark, onCardClick, - onAdd, }: { - col: { id: TaskStatus; name: string } - taskIds: string[] - taskMap: Record<string, Task> + col: { id: SupercrewStatus; name: string } + features: FeatureMeta[] isDark: boolean onCardClick: (id: string) => void - onAdd: () => void }) { - const { t } = useTranslation() const sk = getStatusKey(col.id) return ( @@ -215,59 +123,36 @@ function Column({ }}> {col.name} </span> - {/* CountUp — re-triggers animation when count changes */} <span style={{ fontSize: 10, color: 'hsl(var(--text-low))' }}> - <CountUp key={taskIds.length} to={taskIds.length} duration={0.6} className="rb-mono" /> + <CountUp key={features.length} to={features.length} duration={0.6} className="rb-mono" /> </span> </div> - <button - className="rb-btn-icon" - style={{ width: 24, height: 24 }} - onClick={onAdd} - title={t('board.addTo', { name: col.name })} - > - <PlusIcon size={12} weight="bold" /> - </button> </div> - {/* Droppable area */} + {/* Card area (read-only, no drag) */} <div style={{ background: 'hsl(var(--_bg-secondary-default))', border: '1px solid hsl(var(--_border))', borderTop: 'none', borderRadius: '0 0 10px 10px', minHeight: 120, + padding: 7, }}> - <KanbanCards id={col.id}> - <div style={{ padding: 7 }}> - {taskIds.map((taskId, index) => { - const task = taskMap[taskId] - if (!task) return null - return ( - <KanbanCard - key={task.id} - id={task.id} - name={task.title} - index={index} - onClick={() => onCardClick(task.id)} - > - {/* AnimatedCard entry animation (CSS-only, no DnD conflict) */} - <AnimatedCard index={index}> - <TaskCard task={task} statusKey={sk} isDark={isDark} /> - </AnimatedCard> - </KanbanCard> - ) - })} - </div> - </KanbanCards> + {features.map((feature, index) => ( + <AnimatedCard key={feature.id} index={index}> + <div onClick={() => onCardClick(feature.id)} style={{ cursor: 'pointer' }}> + <FeatureCard feature={feature} statusKey={sk} isDark={isDark} /> + </div> + </AnimatedCard> + ))} </div> </div> ) } -// ─── Task card visual (SpotlightCard) ─────────────────────────────────────── +// ─── Feature card visual (SpotlightCard) ──────────────────────────────────── -function TaskCard({ task, statusKey, isDark }: { task: Task; statusKey: string; isDark: boolean }) { +function FeatureCard({ feature, statusKey, isDark }: { feature: FeatureMeta; statusKey: string; isDark: boolean }) { return ( <SpotlightCard className={`rb-card rb-lift rb-glass rb-bar-${statusKey}`} @@ -285,11 +170,11 @@ function TaskCard({ task, statusKey, isDark }: { task: Task; statusKey: string; marginBottom: 5, }}> <span className="rb-mono" style={{ color: 'hsl(var(--text-low))', fontSize: 9.5 }}> - {task.id} + {feature.id} </span> - {task.priority && ( - <span className={`rb-mono ${PRI_CLASS[task.priority]}`} style={{ fontSize: 9.5 }}> - {task.priority} + {feature.priority && ( + <span className={`rb-mono ${PRI_CLASS[feature.priority]}`} style={{ fontSize: 9.5 }}> + {feature.priority} </span> )} </div> @@ -302,20 +187,23 @@ function TaskCard({ task, statusKey, isDark }: { task: Task; statusKey: string; margin: 0, fontFamily: 'Instrument Sans, sans-serif', }}> - {task.title} + {feature.title} </p> - {/* Tags */} - {task.tags.length > 0 && ( + {/* Tags + Teams */} + {((feature.tags && feature.tags.length > 0) || (feature.teams && feature.teams.length > 0)) && ( <div style={{ display: 'flex', flexWrap: 'wrap', gap: 4, marginTop: 7 }}> - {task.tags.slice(0, 3).map(t => ( - <span key={t} className="rb-tag">{t}</span> + {(feature.teams ?? []).slice(0, 2).map(team => ( + <span key={team} className="rb-tag" style={{ opacity: 0.7 }}>{team}</span> + ))} + {(feature.tags ?? []).slice(0, 2).map(tag => ( + <span key={tag} className="rb-tag">{tag}</span> ))} </div> )} - {/* Assignee */} - {task.assignee && ( + {/* Owner */} + {feature.owner && ( <div style={{ display: 'flex', alignItems: 'center', gap: 5, marginTop: 8, paddingTop: 8, @@ -330,10 +218,10 @@ function TaskCard({ task, statusKey, isDark }: { task: Task; statusKey: string; color: 'var(--rb-accent)', flexShrink: 0, }}> - {task.assignee.charAt(0).toUpperCase()} + {feature.owner.charAt(0).toUpperCase()} </div> <span style={{ fontSize: 10.5, color: 'hsl(var(--text-low))', fontFamily: 'Instrument Sans, sans-serif' }}> - {task.assignee} + {feature.owner} </span> </div> )} diff --git a/kanban/frontend/packages/local-web/src/routes/knowledge.tsx b/kanban/frontend/packages/local-web/src/routes/knowledge.tsx deleted file mode 100644 index accc891..0000000 --- a/kanban/frontend/packages/local-web/src/routes/knowledge.tsx +++ /dev/null @@ -1,104 +0,0 @@ -import { createFileRoute } from '@tanstack/react-router' -import { useQuery } from '@tanstack/react-query' -import { useTranslation } from 'react-i18next' -import { fetchKnowledge } from '@app/api' -import type { KnowledgeEntry } from '@app/types' - -function KnowledgePage() { - const { t } = useTranslation() - const { data: entries = [], isLoading } = useQuery({ - queryKey: ['knowledge'], - queryFn: fetchKnowledge, - }) - - if (isLoading) { - return ( - <div style={{ - display: 'flex', height: '100%', - alignItems: 'center', justifyContent: 'center', - color: 'hsl(var(--text-low))', fontSize: 13, - fontFamily: 'Instrument Sans, sans-serif', - }}> - {t('knowledge.loading')} - </div> - ) - } - - return ( - <div className="rb-page" style={{ height: '100%', overflowY: 'auto', padding: '28px 32px' }}> - <div style={{ maxWidth: 760, margin: '0 auto' }}> - <h1 className="rb-display" style={{ - fontSize: 20, fontWeight: 700, - color: 'hsl(var(--text-high))', - marginBottom: 24, - }}> - {t('knowledge.title')} - </h1> - - <div style={{ display: 'flex', flexDirection: 'column', gap: 10 }}> - {entries.map(entry => <KnowledgeCard key={entry.slug} entry={entry} />)} - {entries.length === 0 && ( - <p style={{ fontSize: 13, color: 'hsl(var(--text-low))', fontFamily: 'Instrument Sans, sans-serif' }}> - {t('knowledge.empty')} - </p> - )} - </div> - </div> - </div> - ) -} - -function KnowledgeCard({ entry }: { entry: KnowledgeEntry }) { - return ( - <div - className="rb-card rb-glass rb-card-hover" - style={{ - background: 'hsl(var(--_bg-secondary-default))', - padding: '16px 20px', - }} - > - {/* Header row */} - <div style={{ - display: 'flex', alignItems: 'flex-start', justifyContent: 'space-between', - gap: 12, marginBottom: 10, - }}> - <h2 style={{ - fontSize: 14, fontWeight: 600, - color: 'hsl(var(--text-high))', - margin: 0, - fontFamily: 'Instrument Sans, sans-serif', - lineHeight: 1.3, - }}> - {entry.title} - </h2> - <span className="rb-mono" style={{ fontSize: 10, color: 'hsl(var(--text-low))', flexShrink: 0 }}> - {entry.date} - </span> - </div> - - {/* Tags */} - {entry.tags.length > 0 && ( - <div style={{ display: 'flex', flexWrap: 'wrap', gap: 5, marginBottom: 10 }}> - {entry.tags.map(t => ( - <span key={t} className="rb-tag">{t}</span> - ))} - </div> - )} - - {/* Body excerpt */} - <p style={{ - fontSize: 12.5, color: 'hsl(var(--text-low))', - lineHeight: 1.65, margin: 0, - fontFamily: 'Instrument Sans, sans-serif', - display: '-webkit-box', - WebkitLineClamp: 3, - WebkitBoxOrient: 'vertical' as const, - overflow: 'hidden', - }}> - {entry.body.slice(0, 400)}{entry.body.length > 400 && '…'} - </p> - </div> - ) -} - -export const Route = createFileRoute('/knowledge')({ component: KnowledgePage }) diff --git a/kanban/frontend/packages/local-web/src/routes/people.tsx b/kanban/frontend/packages/local-web/src/routes/people.tsx deleted file mode 100644 index e278a8f..0000000 --- a/kanban/frontend/packages/local-web/src/routes/people.tsx +++ /dev/null @@ -1,157 +0,0 @@ -import { createFileRoute } from '@tanstack/react-router' -import { useTranslation } from 'react-i18next' -import { useBoard } from '@app/hooks/useBoard' -import type { Person, Task } from '@app/types' - -function PeoplePage() { - const { people, tasks } = useBoard() - const { t } = useTranslation() - - return ( - <div className="rb-page" style={{ height: '100%', overflowY: 'auto', padding: '28px 32px' }}> - <div style={{ maxWidth: 900, margin: '0 auto' }}> - <h1 className="rb-display" style={{ - fontSize: 20, fontWeight: 700, - color: 'hsl(var(--text-high))', - marginBottom: 24, - }}> - {t('people.title')} - </h1> - - <div style={{ - display: 'grid', - gridTemplateColumns: 'repeat(auto-fill, minmax(260px, 1fr))', - gap: 12, - }}> - {people.map(person => ( - <PersonCard key={person.username} person={person} tasks={tasks} /> - ))} - {people.length === 0 && ( - <p style={{ fontSize: 13, color: 'hsl(var(--text-low))', gridColumn: '1 / -1', fontFamily: 'Instrument Sans, sans-serif' }}> - {t('people.empty')} - </p> - )} - </div> - </div> - </div> - ) -} - -function PersonCard({ person, tasks }: { person: Person; tasks: Task[] }) { - const { t } = useTranslation() - const currentTask = tasks.find(task => task.id === person.current_task) - const initial = person.name.charAt(0).toUpperCase() - - return ( - <div - className="rb-card rb-glass rb-card-hover" - style={{ - background: 'hsl(var(--_bg-secondary-default))', - padding: '16px', - display: 'flex', flexDirection: 'column', gap: 12, - }} - > - {/* Avatar + name */} - <div style={{ display: 'flex', alignItems: 'center', gap: 11 }}> - <div style={{ - width: 38, height: 38, borderRadius: '50%', - background: 'var(--rb-accent-dim)', - border: '1.5px solid var(--rb-glow)', - display: 'flex', alignItems: 'center', justifyContent: 'center', - fontSize: 15, fontWeight: 700, - color: 'var(--rb-accent)', - flexShrink: 0, - fontFamily: 'Syne, sans-serif', - boxShadow: '0 0 14px var(--rb-glow)', - }}> - {initial} - </div> - <div style={{ minWidth: 0 }}> - <div style={{ - fontSize: 14, fontWeight: 600, - color: 'hsl(var(--text-high))', - fontFamily: 'Instrument Sans, sans-serif', - overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap', - }}> - {person.name} - </div> - <div style={{ display: 'flex', alignItems: 'center', gap: 5, marginTop: 1 }}> - <span className="rb-mono" style={{ fontSize: 10.5, color: 'hsl(var(--text-low))' }}> - @{person.username} - </span> - {person.team && ( - <> - <span style={{ color: 'hsl(var(--text-low))', fontSize: 10 }}>·</span> - <span style={{ fontSize: 11, color: 'hsl(var(--text-low))', fontFamily: 'Instrument Sans, sans-serif' }}> - {person.team} - </span> - </> - )} - </div> - </div> - </div> - - {/* Blocked */} - {person.blocked_by && ( - <div style={{ - display: 'flex', alignItems: 'flex-start', gap: 7, - padding: '7px 10px', - borderRadius: 8, - background: 'rgba(239,68,68,0.08)', - border: '1px solid rgba(239,68,68,0.2)', - }}> - <span style={{ fontSize: 10, color: '#ef4444', fontWeight: 700, marginTop: 1 }}>⊘</span> - <span style={{ fontSize: 12, color: '#ef4444', lineHeight: 1.4, fontFamily: 'Instrument Sans, sans-serif' }}> - {person.blocked_by} - </span> - </div> - )} - - {/* Current task */} - {currentTask && ( - <div style={{ - padding: '8px 10px', - borderRadius: 8, - background: 'hsl(var(--_muted))', - border: '1px solid hsl(var(--_border))', - }}> - <div className="rb-label" style={{ marginBottom: 4 }}>{t('people.workingOn')}</div> - <div style={{ display: 'flex', alignItems: 'baseline', gap: 7 }}> - <span className="rb-mono" style={{ color: 'var(--rb-accent)', fontSize: 10.5 }}> - {currentTask.id} - </span> - <span style={{ - fontSize: 12.5, color: 'hsl(var(--text-normal))', - fontFamily: 'Instrument Sans, sans-serif', - overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap', - }}> - {currentTask.title} - </span> - </div> - </div> - )} - - {/* Completed today */} - {person.completed_today.length > 0 && ( - <div> - <div className="rb-label" style={{ marginBottom: 6 }}>{t('people.today')}</div> - <ul style={{ listStyle: 'none', padding: 0, margin: 0, display: 'flex', flexDirection: 'column', gap: 5 }}> - {person.completed_today.map((item, i) => ( - <li key={i} style={{ - display: 'flex', alignItems: 'flex-start', gap: 7, - fontSize: 12, color: 'hsl(var(--text-normal))', - fontFamily: 'Instrument Sans, sans-serif', - lineHeight: 1.4, - }}> - <span className="rb-dot rb-dot-done" style={{ marginTop: 4 }} /> - {item} - </li> - ))} - </ul> - </div> - )} - </div> - ) -} - -export const Route = createFileRoute('/people')({ component: PeoplePage }) diff --git a/kanban/frontend/packages/local-web/src/routes/tasks.$id.tsx b/kanban/frontend/packages/local-web/src/routes/tasks.$id.tsx deleted file mode 100644 index 5047a93..0000000 --- a/kanban/frontend/packages/local-web/src/routes/tasks.$id.tsx +++ /dev/null @@ -1,325 +0,0 @@ -import { createFileRoute, useNavigate } from '@tanstack/react-router' -import { useState } from 'react' -import { useTranslation } from 'react-i18next' -import { XIcon, PencilSimpleIcon, CheckIcon } from '@phosphor-icons/react' -import { useBoard } from '@app/hooks/useBoard' -import { useUpdateTask, useUpdateTaskStatus } from '@app/hooks/useMutations' -import type { TaskStatus, TaskPriority } from '@app/types' - -const STATUS_OPTIONS: TaskStatus[] = ['backlog', 'todo', 'in-progress', 'in-review', 'done'] -const PRIORITY_OPTIONS: TaskPriority[] = ['P0', 'P1', 'P2', 'P3'] - -function getStatusKey(status: TaskStatus): string { - if (status === 'in-progress') return 'progress' - if (status === 'in-review') return 'review' - return status -} - -const PRIORITY_CLASS: Record<TaskPriority, string> = { - P0: 'rb-p0', P1: 'rb-p1', P2: 'rb-p2', P3: 'rb-p3', -} - -function TaskDetailPage() { - const { id } = Route.useParams() - const navigate = useNavigate() - const { t } = useTranslation() - const { tasks } = useBoard() - const updateTask = useUpdateTask() - const updateStatus = useUpdateTaskStatus() - - const task = tasks.find(tk => tk.id === id) - const [editingTitle, setEditingTitle] = useState(false) - const [titleDraft, setTitleDraft] = useState('') - - if (!task) { - return ( - <div style={{ - display: 'flex', height: '100%', - alignItems: 'center', justifyContent: 'center', - color: 'hsl(var(--text-low))', fontSize: 13, - fontFamily: 'Instrument Sans, sans-serif', - }}> - {t('task.notFound', { id })} - </div> - ) - } - - const sk = getStatusKey(task.status) - - return ( - <div className="rb-page" style={{ height: '100%', overflowY: 'auto', background: 'hsl(var(--_background))' }}> - <div style={{ maxWidth: 680, margin: '0 auto', padding: '28px 32px 48px' }}> - - {/* ── Header ── */} - <div style={{ display: 'flex', alignItems: 'flex-start', justifyContent: 'space-between', gap: 14, marginBottom: 28 }}> - <div style={{ flex: 1, minWidth: 0 }}> - <span className="rb-mono" style={{ color: 'hsl(var(--text-low))', fontSize: 10.5, display: 'block', marginBottom: 6 }}> - {task.id} - </span> - - {editingTitle ? ( - <div style={{ display: 'flex', alignItems: 'center', gap: 10 }}> - <input - autoFocus - className="rb-display" - style={{ - fontSize: 22, fontWeight: 700, - background: 'transparent', - border: 'none', - borderBottom: '2px solid var(--rb-accent)', - outline: 'none', - flex: 1, - color: 'hsl(var(--text-high))', - padding: '2px 0', - }} - value={titleDraft} - onChange={e => setTitleDraft(e.target.value)} - onKeyDown={e => { - if (e.key === 'Enter') { - updateTask.mutate({ id: task.id, patch: { title: titleDraft } }) - setEditingTitle(false) - } - if (e.key === 'Escape') setEditingTitle(false) - }} - /> - <button - className="rb-btn-icon" - onClick={() => { - updateTask.mutate({ id: task.id, patch: { title: titleDraft } }) - setEditingTitle(false) - }} - style={{ color: 'var(--rb-accent)' }} - > - <CheckIcon size={16} weight="bold" /> - </button> - </div> - ) : ( - <h1 - className="rb-display" - style={{ - fontSize: 22, fontWeight: 700, - color: 'hsl(var(--text-high))', - cursor: 'pointer', - margin: 0, lineHeight: 1.3, - transition: 'color 0.15s', - }} - onClick={() => { setTitleDraft(task.title); setEditingTitle(true) }} - title={t('task.clickToEdit')} - > - {task.title} - </h1> - )} - </div> - - <button - className="rb-btn-icon" - onClick={() => void navigate({ to: '/' })} - style={{ marginTop: 2, flexShrink: 0 }} - > - <XIcon size={16} /> - </button> - </div> - - {/* ── Properties grid ── */} - <div - className="rb-card rb-glass" - style={{ - background: 'hsl(var(--_bg-secondary-default))', - display: 'grid', gridTemplateColumns: '1fr 1fr', - gap: '0px', - marginBottom: 28, - }} - > - {/* Status */} - <PropCell label={t('task.props.status')}> - <div style={{ display: 'flex', alignItems: 'center', gap: 7 }}> - <span className={`rb-dot rb-dot-${sk}`} /> - <select - value={task.status} - onChange={e => updateStatus.mutate({ id: task.id, status: e.target.value as TaskStatus })} - className="rb-select" - style={{ color: 'hsl(var(--text-normal))' }} - > - {STATUS_OPTIONS.map(s => <option key={s} value={s}>{s}</option>)} - </select> - </div> - </PropCell> - - {/* Priority */} - <PropCell label={t('task.props.priority')}> - <select - value={task.priority} - onChange={e => updateTask.mutate({ id: task.id, patch: { priority: e.target.value as TaskPriority } })} - className={`rb-select ${PRIORITY_CLASS[task.priority]}`} - style={{ fontWeight: 600 }} - > - {PRIORITY_OPTIONS.map(p => <option key={p} value={p}>{p}</option>)} - </select> - </PropCell> - - {/* Assignee */} - <PropCell label={t('task.props.assignee')}> - <span style={{ fontSize: 13, color: 'hsl(var(--text-normal))', fontFamily: 'Instrument Sans, sans-serif' }}> - {task.assignee ?? '—'} - </span> - </PropCell> - - {/* Sprint */} - <PropCell label={t('task.props.sprint')}> - <span style={{ fontSize: 13, color: 'hsl(var(--text-normal))', fontFamily: 'Instrument Sans, sans-serif' }}> - {task.sprint != null ? t('task.sprintLabel', { n: task.sprint }) : '—'} - </span> - </PropCell> - - {/* Tags */} - {task.tags.length > 0 && ( - <PropCell label={t('task.props.tags')} full> - <div style={{ display: 'flex', flexWrap: 'wrap', gap: 5 }}> - {task.tags.map(t => ( - <span key={t} className="rb-tag">{t}</span> - ))} - </div> - </PropCell> - )} - - {/* PR */} - {task.pr_url && ( - <PropCell label={t('task.props.pr')} full> - <a - href={task.pr_url} - target="_blank" - rel="noreferrer" - style={{ fontSize: 12.5, color: 'var(--rb-accent)', wordBreak: 'break-all', fontFamily: 'Instrument Sans, sans-serif' }} - > - {task.pr_url} - </a> - </PropCell> - )} - - {/* Blocked by */} - {task.blocked_by.length > 0 && ( - <PropCell label={t('task.props.blockedBy')} full> - <span className="rb-mono" style={{ fontSize: 12, color: '#ef4444' }}> - {task.blocked_by.join(', ')} - </span> - </PropCell> - )} - - {/* Blocks */} - {task.blocks.length > 0 && ( - <PropCell label={t('task.props.blocks')} full> - <span className="rb-mono" style={{ fontSize: 12, color: 'hsl(var(--text-normal))' }}> - {task.blocks.join(', ')} - </span> - </PropCell> - )} - </div> - - {/* ── Description ── */} - <div> - <div style={{ - display: 'flex', alignItems: 'center', gap: 7, - marginBottom: 10, - }}> - <span style={{ - fontSize: 12, fontWeight: 600, - color: 'hsl(var(--text-normal))', - fontFamily: 'Instrument Sans, sans-serif', - }}> - {t('task.description')} - </span> - <PencilSimpleIcon size={12} style={{ color: 'hsl(var(--text-low))' }} /> - </div> - <BodyEditor - body={task.body} - onSave={body => updateTask.mutate({ id: task.id, patch: { body } })} - /> - </div> - - </div> - </div> - ) -} - -// ─── PropCell ──────────────────────────────────────────────────────────────── - -function PropCell({ - label, - children, - full, -}: { - label: string - children: React.ReactNode - full?: boolean -}) { - return ( - <div - style={{ - gridColumn: full ? '1 / -1' : undefined, - padding: '11px 14px', - borderBottom: '1px solid hsl(var(--_border))', - borderRight: full ? 'none' : '1px solid hsl(var(--_border))', - }} - > - <div className="rb-label" style={{ marginBottom: 5 }}>{label}</div> - {children} - </div> - ) -} - -// ─── BodyEditor ────────────────────────────────────────────────────────────── - -function BodyEditor({ body, onSave }: { body: string; onSave: (body: string) => void }) { - const { t } = useTranslation() - const [editing, setEditing] = useState(false) - const [draft, setDraft] = useState(body) - - if (!editing) { - return ( - <div - className="rb-card" - style={{ - minHeight: 96, - padding: '10px 12px', - cursor: 'text', - fontSize: 13, - color: body ? 'hsl(var(--text-low))' : 'hsl(var(--text-low))', - whiteSpace: 'pre-wrap', - lineHeight: 1.7, - background: 'hsl(var(--_bg-secondary-default))', - transition: 'border-color 0.15s', - }} - onClick={() => { setDraft(body); setEditing(true) }} - > - {body || <span style={{ fontStyle: 'italic', opacity: 0.6 }}>{t('task.addDescription')}</span>} - </div> - ) - } - - return ( - <div style={{ display: 'flex', flexDirection: 'column', gap: 10 }}> - <textarea - autoFocus - className="rb-textarea" - value={draft} - onChange={e => setDraft(e.target.value)} - /> - <div style={{ display: 'flex', gap: 8 }}> - <button - className="rb-btn-primary" - onClick={() => { onSave(draft); setEditing(false) }} - > - {t('task.save')} - </button> - <button - className="rb-btn-ghost" - onClick={() => setEditing(false)} - > - {t('task.cancel')} - </button> - </div> - </div> - ) -} - -export const Route = createFileRoute('/tasks/$id')({ component: TaskDetailPage }) diff --git a/kanban/frontend/packages/local-web/src/routes/welcome.tsx b/kanban/frontend/packages/local-web/src/routes/welcome.tsx index 2285ffe..30e0d58 100644 --- a/kanban/frontend/packages/local-web/src/routes/welcome.tsx +++ b/kanban/frontend/packages/local-web/src/routes/welcome.tsx @@ -236,11 +236,11 @@ function StepSelectRepo({ ) } -// ─── Step 3: 初始化确认 ─────────────────────────────────────────────────────── +// ─── Step 3: Bind repo ───────────────────────────────────────────────────── -type InitStatus = 'loading' | 'success' | 'error' +type BindStatus = 'loading' | 'success' | 'error' -function StepInit({ +function StepBind({ repo, onSuccess, }: { @@ -249,32 +249,13 @@ function StepInit({ }) { const { t } = useTranslation() const queryClient = useQueryClient() - const [status, setStatus] = useState<InitStatus>('loading') + const [status, setStatus] = useState<BindStatus>('loading') const [errorMsg, setErrorMsg] = useState('') - const runInit = async () => { + const runBind = async () => { setStatus('loading') setErrorMsg('') try { - const [owner, repoName] = repo.full_name.split('/') - - const statusRes = await fetch( - `/api/projects/github/repos/${owner}/${repoName}/init-status`, - { headers: authHeaders() } - ) - const { initialized } = await statusRes.json() - - if (!initialized) { - const initRes = await fetch(`/api/projects/github/repos/${owner}/${repoName}/init`, { - method: 'POST', - headers: authHeaders(), - }) - if (!initRes.ok) { - const err = await initRes.json() - throw new Error(err.error ?? t('welcome.step3.initFailed')) - } - } - await fetch('/api/projects', { method: 'POST', headers: { ...authHeaders(), 'Content-Type': 'application/json' }, @@ -290,7 +271,7 @@ function StepInit({ } } - useEffect(() => { runInit() }, []) + useEffect(() => { runBind() }, []) return ( <div style={{ @@ -316,7 +297,7 @@ function StepInit({ animation: 'spin 0.8s linear infinite', }} /> <p style={{ fontSize: 13, color: 'rgba(255,255,255,0.5)', margin: 0 }}> - {t('welcome.step3.initializing')} + {t('welcome.step3.binding')} </p> </div> )} @@ -335,7 +316,7 @@ function StepInit({ <WarningCircleIcon size={30} color="#f87171" weight="fill" /> <p style={{ fontSize: 13, color: '#fca5a5', margin: 0 }}>{errorMsg}</p> <button - onClick={runInit} + onClick={runBind} style={{ padding: '8px 20px', borderRadius: 8, background: 'var(--rb-accent)', color: '#000', @@ -412,7 +393,7 @@ function WelcomePage() { <Step> {selectedRepo ? ( - <StepInit repo={selectedRepo} onSuccess={() => navigate({ to: '/' })} /> + <StepBind repo={selectedRepo} onSuccess={() => navigate({ to: '/' })} /> ) : ( <div style={{ padding: '20px 0', textAlign: 'center', color: 'rgba(255,255,255,0.45)', fontSize: 13 }}> {t('welcome.step3.noRepo')} From 138804639c27bf2293f126fc35e478e28215a01d Mon Sep 17 00:00:00 2001 From: He Zhang <hezhan@microsoft.com> Date: Wed, 4 Mar 2026 00:09:32 +0800 Subject: [PATCH 11/14] code refine --- .gitignore | 12 +- .tmp/discussion0303.md | 44 ----- .tmp/prd.md | 371 ----------------------------------------- 3 files changed, 11 insertions(+), 416 deletions(-) delete mode 100644 .tmp/discussion0303.md delete mode 100644 .tmp/prd.md diff --git a/.gitignore b/.gitignore index 3881436..f18468e 100644 --- a/.gitignore +++ b/.gitignore @@ -1,7 +1,17 @@ +# Dependencies node_modules/ -.worktrees/ + +# Build output dist/ + +# Environment .env .env.local *.local + +# macOS +.DS_Store + +# Project +.worktrees/ .ref diff --git a/.tmp/discussion0303.md b/.tmp/discussion0303.md deleted file mode 100644 index cbad868..0000000 --- a/.tmp/discussion0303.md +++ /dev/null @@ -1,44 +0,0 @@ -0303 Summary - --Schema Review - -1.super crew kanban的数据源位置: -.supercrew/ - -2. .supercrew/ 目录结构: -.supercrew/ - |-feature-name - |-meta.yaml - |-design.md - |-plan.md - -3.meta.yaml文件： -id/featurename/description/status/priority/team/owner/target_release/tags/dev_branch - -4.design.md -初步设计文档，在dev_branch持续更新，structured markdown，包括两个部分 -a)structured 部分, yml fields包括status/reviewer/approved_by（这个是for design review，是否需要enable这个审查看老板们想法，会加入这个流程是因为个人体验下来前期设计很重要，需要多费心设计，和ai来会讨论，会占据coding工作的30%左右，不建议无脑接受ai的plan） -b)markdown部分，design文档 - -5. plan.md -structured markdown，task breakdown -a)structured 部分，total tasks/complete tasks -b)markdown部分，workitem breakdown，markdown格式，可以考虑类似societas的floating todo bar一样在看板上做visualize - - --Design Review -1.kanban renderer，基于上述schema做renderer，demo version可见于user/steinsz/supercrew_schema，（需和真实github repo 做 integration test -2.ai integration，创建一个plugin，用于对每个repo setup .supercrew目录结构和对应的文件管理。暂不考虑直接用superpowers，因为过于耦合，相对我们的需求太重。mvp之后会考虑将两者结合，实现过程会借鉴superpowsers。 -3.ai integration trigger。skill/hook/pre-commit等方式都会尝试，理想情况会做成全自动，slash command作为备选方案 -4.user flow: user clone his own repo -> install our plugin -> start coding (.supercrew folder will be created automatically) -> prd discussion and meta.yml be created by ai -> check in it to main/dev branch -> take the task and make plan, check-in plan to dev branch -> finish coding and check in code with final documents in docs/ folder -5.user can use kanban with github oauth see the repo status (read only for now) - --Open Discussion -1.per user/per agent track, 暂时会放在p2，在schema设计过程中会保留可扩展性以便我们未来可以兼容这个需求，但是没有放在mvp阶段，为了控制复杂度 -2.ado v.s. .supercrew folder，暂时考虑用.supercrew下的文件来管理workitem，主要有两个考量：a)复杂度，在mvp阶段尽量简单。b)适用范围，目录结构更灵活不绑定ado -3. .supercrew下的feature如何和branch link起来，a)优先考虑用worktree，b)次要考虑在meta.yml中配置一个branch来做关联 - --Next Step -1.add market place with corresponding skills/subagents/plugings to create and maintain .supercrew folder -2.support rendered with new schema -3.integration test with claude code and real repo diff --git a/.tmp/prd.md b/.tmp/prd.md deleted file mode 100644 index e016cc9..0000000 --- a/.tmp/prd.md +++ /dev/null @@ -1,371 +0,0 @@ -# SuperCrew MVP — `.supercrew/` Schema + Kanban + AI Plugin - -**TL;DR:** 基于 `user/steinsz/supercrew_schema` 分支的 demo 实现，将 kanban 从 `.team/` 资源导向 完全迁移到 `.supercrew/features/` feature 导向的数据模型。MVP 包含三大模块：(1) AI 集成插件（skills + hooks + pre-commit）在用户 repo 中创建和管理 `.supercrew/` 目录，(2) 后端通过 GitHub API（OAuth）只读访问用户 repo 中的 `.supercrew/` 数据，(3) 前端看板以只读方式渲染 feature-centric 视图。参考 [superpowers](https://github.com/obra/superpowers) 的插件架构和 [vibe-kanban](https://github.com/BloopAI/vibe-kanban) 的 issue→workspace 模式。插件在 monorepo 的 `plugins/supercrew/` 子目录开发，MVP 阶段通过绝对路径加载（`/plugin marketplace add /path/to/supercrew/plugins/supercrew`），Post-MVP 抽取为独立 repo 后发布到 marketplace。 - -### 数据流架构 - -``` -用户 Repo（数据源） Kanban 服务（只读展示） -┌─────────────────────┐ ┌──────────────────────┐ -│ .supercrew/ │ │ Vercel (后端) │ -│ features/ │ │ │ -│ feature-a/ │ │ GitHub API ──读取──►│ -│ meta.yaml │ │ (OAuth) │ -│ design.md │ │ │ -│ plan.md │ │ 前端（只读看板） │ -│ log.md │ │ │ -└─────────────────────┘ └──────────────────────┘ - ▲ ▲ - │ │ - Claude Code 插件 用户浏览器 - (本地写入 → git push) (OAuth 登录 → 查看看板) -``` - -**关键原则：** -- **写入方唯一：** Claude Code 插件在用户本地 repo 操作 `.supercrew/`，通过 git commit + push 同步 -- **读取方唯一：** Kanban 服务通过 OAuth 获取的 GitHub access_token 调用 GitHub Contents API 读取 -- **Kanban 完全只读：** 不提供任何写入 API，不修改用户 repo 中的数据 - ---- - -## Phase 1: AI 集成插件（数据写入方） - -**目标：** 在 monorepo 的 `plugins/supercrew/` 子目录下创建 Claude Code 插件，在用户 repo 中自动创建和管理 `.supercrew/` 目录。这是唯一的数据写入方。参考 superpowers 的 skills/hooks/commands 架构。 - -**Monorepo 策略：** 插件代码保留在 `plugins/supercrew/`，与 `kanban/` 共存于同一 repo。Claude Code marketplace 要求 plugin 为独立 repo（整个 repo = plugin 根目录），因此： -- **MVP 阶段**：通过绝对路径加载 — `/plugin marketplace add /path/to/supercrew/plugins/supercrew`（在任意 repo 中均可安装），`plugins/supercrew/` 内含 `.claude-plugin/marketplace.json`（`"source": "./"`），结构与独立 repo 一致 -- **Post-MVP**：将 `plugins/supercrew/` 抽取为独立 repo（如 `supercrew-plugin`），注册到 marketplace，用户可通过 `/plugin install supercrew@marketplace` 安装 -- **目录结构已按独立 repo 标准设计**，抽取时无需重构 - -### 1.1 插件目录结构 -``` -plugins/supercrew/ -├── .claude-plugin/marketplace.json # 发布到 Claude Code marketplace -├── skills/ -│ ├── create-feature/SKILL.md # 创建 feature 目录 + 4 文件 -│ ├── update-status/SKILL.md # 状态流转 -│ ├── sync-plan/SKILL.md # 生成/更新 plan.md -│ ├── log-progress/SKILL.md # 追加 log.md -│ └── managing-features/SKILL.md # 综合管理 skill，自动协调上述 skills -├── commands/ -│ ├── new-feature.md # /new-feature slash command -│ └── feature-status.md # /feature-status slash command -├── hooks/ -│ ├── hooks.json # SessionStart hook -│ └── session-start # 注入 .supercrew context -└── templates/ - ├── meta.yaml.tmpl - ├── design.md.tmpl - ├── plan.md.tmpl - └── log.md.tmpl -``` - -### 1.2 Schema 定义（插件内共享） -- 定义 `SupercrewStatus` 枚举：`planning → designing → ready → active → blocked → done` -- 定义 `FeaturePriority`: `P0 | P1 | P2 | P3` -- `.supercrew/features/<feature-id>/` 下 4 个文件： - - `meta.yaml`：必填字段 `id`, `title`, `status`, `owner`, `priority`；可选 `teams`, `target_release`, `created`, `updated`, `tags`, `blocked_by` - - `design.md`：YAML frontmatter（`status: draft|in-review|approved|rejected`, `reviewers`, `approved_by`）+ markdown body - - `plan.md`：YAML frontmatter（`total_tasks`, `completed_tasks`, `progress`）+ workitem breakdown markdown - - `log.md`：纯 markdown 追加日志 - -### 1.3 Skills 实现 -- **`create-feature`**: 用户描述需求 → AI 通过 PRD 讨论提炼 → 在 `.supercrew/features/<id>/` 下生成 `meta.yaml`（自动填充 id、title、owner、priority、status=planning、dates）+ `design.md`（初始 draft 模板）+ `plan.md`（空结构）+ `log.md`（初始化记录） -- **`update-status`**: 根据代码/commit 状态自动判断并更新 `meta.yaml` 中的 status 字段，遵循合法状态转换图 -- **`sync-plan`**: 在 design 完成后，基于 `design.md` 内容生成 `plan.md` 中的 task breakdown；coding 阶段持续更新 `completed_tasks`/`progress` -- **`log-progress`**: 每次 session 结束时自动追加 `log.md`，记录本次工作内容、完成的 tasks、遇到的问题 - -### 1.4 Hooks -- **SessionStart**: 检测当前 repo 是否有 `.supercrew/features/` → 有则执行 **Active Feature 匹配**，确定当前 session 聚焦的 feature： - 1. **Git branch 名匹配**（优先）：当前分支名 `feature/<id>` → 自动关联 `.supercrew/features/<id>/`，注入该 feature 的完整 context（meta + design + plan progress + 最近 log）。无论是普通 checkout 还是 git worktree 均适用（均通过 `git branch --show-current` 读取） - 2. **用户显式选择**：无匹配时，列出所有 `status != done` 的 features 摘要表（id | title | status | progress），请求用户确认："当前 session 聚焦哪个 feature？" - 3. 确认后，后续 `update-status`、`sync-plan`、`log-progress` 等 skill 自动作用于该 feature - 4. 始终注入所有 feature 的简要列表到 context（确保 AI 知道全局状态），但仅对 active feature 注入详细信息 - - **注**：MVP 不强制使用 git worktree，branch 匹配对 checkout 和 worktree 均兼容。Worktree 自动化生命周期管理在 Post-MVP 引入（见 Next Steps Iteration 1） -- **pre-commit hook**: 校验 `.supercrew/features/*/meta.yaml` 的 schema 合法性（必填字段、status 枚举值、priority 枚举值）；校验 `plan.md` frontmatter 的 `total_tasks ≥ completed_tasks` - -### 1.5 Commands -- **`/new-feature`**: 触发 `create-feature` skill，交互式创建新 feature -- **`/feature-status`**: 显示所有 feature 的当前状态概览（表格形式：id | title | status | progress | owner） -- **`/work-on <feature-id>`**: 切换当前 session 聚焦的 feature（覆盖 SessionStart 的自动匹配结果），后续所有 skill 操作自动作用于该 feature - -### 1.6 Managing-Features Skill（综合管理） -- **`managing-features`**: 综合管理 skill，当 Claude 检测到用户在含 `.supercrew/features/` 的 repo 中工作时自动触发。负责在适当时机协调调用 `update-status`、`sync-plan`、`log-progress` 等子 skill，包括： - - 代码变更后自动建议更新 feature status - - design 完成后自动建议生成 plan - - session 结束前自动提醒记录 log - - 检测到状态不一致时主动提醒（如 `plan.md` progress 与实际 checklist 不符） - ---- - -## Phase 2: Schema 基础设施 — 后端（只读） - -**目标：** Kanban 后端通过 GitHub API（OAuth）只读访问用户 repo 中的 `.supercrew/features/` 数据。不提供任何写入 API。 - -### 2.1 定义 TypeScript 类型 -- 基于 commit `62cd395f` 的 `SupercrewStatus`、`FeatureMeta` 类型，在 `kanban/backend/src/types/index.ts` 中替换现有 `Task`/`Sprint` 等类型 -- 新增类型：`FeatureMeta`（meta.yaml）、`DesignDoc`（design.md frontmatter + body）、`PlanDoc`（plan.md frontmatter + tasks breakdown）、`FeatureLog`（log.md） -- 定义 `SupercrewStatus`、`FeaturePriority` 类型（与插件 schema 保持一致） -- 使用 `zod` 做读取时的运行时校验（解析 meta.yaml 时验证字段合法性） - -### 2.2 重写 GitHub Store（只读） -- 将 `kanban/backend/src/store/github-store.ts` 改为通过 GitHub Contents API **只读** 访问 `.supercrew/features/` 路径 -- 复用现有的 `ghGet` pattern，路径从 `.team/tasks/` 改为 `.supercrew/features/<id>/` -- 实现：`listFeatures()`（列出所有 feature 目录）、`getFeatureMeta(id)`、`getFeatureDesign(id)`、`getFeaturePlan(id)`、`getFeatureLog(id)` -- 移除所有 `ghPut`/`ghDelete` 调用 — Kanban 不写入用户 repo - -### 2.3 重写 Local Store（只读，仅开发调试用） -- 将 `kanban/backend/src/store/index.ts` 改为只读访问本地 `.supercrew/features/` 目录 -- 用于本地开发时 mock 数据（读取本地 `.supercrew/features/` 目录中的文件） -- 不包含任何写入逻辑 - -### 2.4 重写 API Routes（只读） -- 将 `kanban/backend/src/routes/` 下的 `tasks.ts`、`sprints.ts`、`people.ts`、`knowledge.ts`、`decisions.ts` 合并/替换为： - - `features.ts`：**仅 GET 端点** - - `GET /api/features` — 列出所有 features（meta 摘要） - - `GET /api/features/:id` — 获取单个 feature 完整信息 - - `GET /api/features/:id/design` — 获取 design.md - - `GET /api/features/:id/plan` — 获取 plan.md（含 progress） - - `GET /api/board` — 聚合 endpoint，将 features 按 status 映射到看板列 -- 保留 auth 路由（`auth.ts`）和 projects 路由（`projects.ts`：OAuth 绑定 repo）不变 -- 移除 `SUPERCREW_DEMO` 环境变量守卫 -- `GET /api/projects/github/repos/:owner/:repo/init-status` 改为检查 `.supercrew/features/` 是否存在 -- 移除 `POST /api/projects/github/repos/:owner/:repo/init` — 不再由 Kanban 服务初始化 - -### 2.5 删除遗留代码 -- 移除 `.team/` 相关的所有 store 逻辑、路由、类型 -- 移除 `Sprint`、`Person`、`KnowledgeEntry`、`Decision` 类型（MVP 阶段只聚焦 Feature） -- 清理 `index.ts` 中的路由注册 - ---- - -## Phase 3: 前端看板重构（只读） - -**目标：** 用 feature-centric 只读视图替代现有 task-centric 看板。不提供任何数据修改操作。 - -### 3.1 数据层重构 -- 更新 `kanban/frontend/packages/app-core/src/types.ts`：用 `Feature`（含 meta + design status + plan progress）替代 `Task`/`Sprint` 等 -- 更新 `kanban/frontend/packages/app-core/src/api.ts`：仅保留只读 API 调用 - - `fetchFeatures()` — 获取所有 features 列表 - - `fetchFeature(id)` — 获取单个 feature 详情 - - `fetchFeatureDesign(id)` — 获取 design.md - - `fetchFeaturePlan(id)` — 获取 plan.md - - `fetchBoard()` — 获取看板聚合数据 -- 移除所有 `create`/`update`/`delete` 相关的 API 调用和 mutations -- 更新 `useBoard()` hook：返回 `{ features, featuresByStatus, isLoading, error }` -- 移除 `useMutations()` hook — 看板无写操作 - -### 3.2 看板主视图 -- 重构 `kanban/frontend/packages/ui/` 中的 `KanbanBoard` 组件 -- 6 列布局对应 status：`Planning | Designing | Ready | Active | Blocked | Done` -- Feature 卡片显示：`title`、`priority` badge（P0 红/P1 橙/P2 蓝/P3 灰）、`owner`、`teams` tags、plan `progress` 进度条 -- **无拖拽功能** — 看板只读，status 变更由 Claude Code 插件在用户 repo 中完成 -- 参考 vibe-kanban 的卡片 UI 风格：简洁、信息密度高 -- 点击卡片 → 跳转 Feature 详情页 - -### 3.3 Feature 详情页 -- 新建 `/features/:id` 路由，替代原 `/tasks/:id` -- 三 Tab 布局：**Overview**（meta.yaml 渲染：owner、priority、teams、target_release、tags、dates）、**Design**（design.md markdown 渲染 + status/reviewer 信息）、**Plan**（plan.md 渲染：进度条 + task checklist 可视化，类似 societas floating todo bar） -- Design tab 显示 review status badge（draft/in-review/approved/rejected） -- Plan tab 显示 `completed_tasks/total_tasks` 进度 + 每个 workitem 的完成状态 -- 所有内容只读展示，不提供编辑功能 - -### 3.4 FRE 与空状态处理 -- 更新 Welcome wizard：OAuth 登录 → Select Repo（绑定已有 repo） -- **不再提供 Init 功能** — `.supercrew/` 目录由 Claude Code 插件创建 -- 空状态处理： - - repo 中不存在 `.supercrew/features/` → 显示空看板 + 引导提示："请在该 repo 中安装 SuperCrew 插件并使用 `/new-feature` 创建第一个 feature" - - repo 中存在 `.supercrew/features/` 但内容为空 → 类似引导 - -### 3.5 清理遗留页面 -- 移除 `/people`、`/knowledge`、`/decisions` 页面和底部导航对应入口 -- 移除拖拽相关组件和依赖（`@hello-pangea/dnd` 可移除） -- 底部导航简化为：**Board**（feature 看板） -- 保留 dark/light theme 和 i18n - ---- - -## Phase 4: 集成与测试 - -### 4.1 插件测试 -- 在 Claude Code 中加载插件 → 执行 `/new-feature` → 验证 `.supercrew/features/<id>/` 下 4 个文件正确生成 -- 测试 `/feature-status` 输出 -- 测试 `update-status`、`sync-plan`、`log-progress` skills -- 测试 pre-commit hook schema 校验（故意写错 meta.yaml → 应拦截 commit） -- 测试 SessionStart hook 注入 context - -### 4.2 后端测试 -- 为 supercrew GitHub store 写单元测试（vitest）：只读列出 features、解析 meta.yaml/design.md/plan.md -- 为 features API 写集成测试：只读 GET 端点 + auth -- 测试 `.supercrew/` 不存在时返回空数组 - -### 4.3 前端测试 -- Feature card 组件测试 -- Board 视图测试（6 列布局、正确分组） -- Feature 详情页 Tab 切换测试 -- 空状态 UI 测试（无 `.supercrew/` 时的引导状态） - -### 4.4 端到端集成测试 -- 完整 flow： - 1. 用户 repo A 安装 Claude Code 插件 - 2. 在 repo A 中使用 `/new-feature` 创建 feature - 3. `git commit && git push` 到 main - 4. 在 Kanban 网页中 OAuth 绑定 repo A - 5. 看板正确显示 feature 数据 - 6. 在 repo A 中用插件更新 status/plan → push → 看板数据刷新 - -### 4.5 部署验证 -- Vercel 部署验证：确保 GitHub store 正确只读访问 `.supercrew/` 路径 -- 运行 `kanban/scripts/verify-before-deploy.sh` - ---- - -## Verification -- `cd kanban && bun test` — 后端单元测试 -- `cd kanban/frontend && pnpm test` — 前端测试 -- 插件测试：在 Claude Code 中加载插件 → 执行 `/new-feature` → 验证文件生成 → commit 触发 pre-commit hook → push 到 main -- 端到端测试：在 test repo 中用插件创建 feature + push → 在 Kanban 网页 OAuth 绑定该 repo → 看板正确展示 feature 数据 → 查看详情页 - ---- - -## Decisions -- **`.team/` 完全弃用**：MVP 不做兼容，直接替换。简化实现复杂度。 -- **Feature-centric 而非 Task-centric**：看板的最小单位是 feature，不再是 task。Task 作为 plan.md 内的 checklist 存在。 -- **插件在 monorepo 子目录开发**：`plugins/supercrew/` 保留在 monorepo 中，MVP 通过绝对路径加载 `/plugin marketplace add /path/to/supercrew/plugins/supercrew`（在任意 repo 中均可安装）。目录结构按独立 repo 标准设计（`.claude-plugin/` 在 `plugins/supercrew/` 根），Post-MVP 抽取为独立 repo 后可直接发布到 marketplace，无需重构。 -- **Sprint/People/Knowledge/Decisions 移除**：MVP 聚焦 feature lifecycle，这些概念不在 `.supercrew/` schema 中，不保留。 -- **log.md 保留**：虽然讨论文档未提及，但 demo 分支已实现，作为 AI context 很有价值，保留。 -- **Design review 纳入 MVP**：`design.md` 的 `status/reviewer/approved_by` 字段保留，在详情页展示。在 pre-commit hook 中不强制校验。 -- **Kanban 完全只读**：看板服务不写入用户 repo，所有数据变更由 Claude Code 插件在本地完成后 push。 -- **插件优先开发**：Phase 顺序调整为插件→后端→前端，因为没有插件就没有数据可读。 -- **无 Init API**：Kanban 不负责初始化 `.supercrew/` 目录，由插件负责。看板对未初始化的 repo 显示空状态 + 引导。 -- **无拖拽**：看板只读，不提供拖拽修改 status 的功能。 -- **MVP 不含 Sprint**：30 人团队未来需要时间节奏，但 MVP 先聚焦 feature lifecycle。Sprint 机制在 Post-MVP 迭代中引入（见 Next Steps）。 -- **上线/Release 协调 Post-MVP**：MVP 不包含 release train 或 deployment 协调功能。Post-MVP 根据团队实际需求决定是否引入。 - ---- - -## Next Steps — Post-MVP 迭代规划 - -MVP 解决了 Layer 2（团队协调层）中"项目管理可见性"和"设计/文档强制性"两大核心缺口。以下迭代聚焦补齐剩余 gap：**跨组协调**、**时间节奏（Sprint）**、**Agent 能力深化**、**上线协调**。 - -### Iteration 1: supercrew-manager Agent 能力增强 + Worktree 自动化 - -MVP 的 `supercrew-manager` agent 描述过于简略。参考 `ddd-tech-lead` agent 的设计深度，迭代 1 补充完整的 agent prompt 设计。同时引入 git worktree 自动化，消除 MVP 阶段手动管理分支的摩擦。 - -#### 1.1 决策指引框架 -- **Feature 识别**：用户描述需求时，自动判断是新建 feature 还是归属已有 feature -- **状态推断规则**：根据代码变更、commit 内容、test 结果自动推断 status 转换（例：design.md status 从 draft → approved 后，自动建议 feature status 从 designing → ready） -- **优先级升降规则**：根据 `blocked_by` 依赖链和 deadline 接近程度，主动提醒优先级调整 -- **Context 注入策略**：SessionStart 时不只列出 feature 列表，而是智能摘要——突出 blocked features、临近 deadline 的 features、长期无更新的 features - -#### 1.2 自检清单（Self-Verification） -Agent 在每次操作前/后执行自检： -1. 目标 feature 文件夹是否存在？不存在是否应创建？ -2. `meta.yaml` 中所有必填字段是否完整？ -3. `plan.md` 的 `completed_tasks` 是否与实际 checklist 一致？ -4. `log.md` 是否已记录本次 session 的工作内容？ -5. 是否有 `blocked_by` 指向的 feature 已经完成但未更新？ -6. 是否有跨 feature 的架构影响需要在 `design.md` 中记录？ - -#### 1.3 主动行为（Proactive Behaviors） -- 检测到用户长时间在某 feature 上工作但未更新 `log.md` → 主动提醒记录 -- 检测到 `plan.md` 中 `completed_tasks` 落后于实际 commit → 主动建议同步 -- 检测到多个 features 的 `blocked_by` 形成环形依赖 → 告警 -- Session 结束前自动执行 `log-progress` skill -- 检测到新 feature 的 `design.md` 仍为 draft 但 status 已到 active → 警告跳过设计审查 - -#### 1.4 沟通风格 -- 状态更新简洁直接，用结构化格式（表格、列表） -- 关键决策需提供上下文说明 -- 需求模糊时主动提出澄清问题 -- 区分 Critical/Important/Minor 事项 - -#### 1.5 Git Worktree 自动化 -MVP 阶段用户手动管理分支，Iter 1 引入 worktree 自动化生命周期管理，消除手动操作摩擦： -- **`/new-feature` 增强**：创建 feature 时自动执行 `git worktree add .worktrees/<id> feature/<id>` + 安装依赖 + 提示用户在新窗口打开该目录 -- **`/close-feature <id>`**（新增 command）：merge/PR + `git worktree remove` + 清理分支，用户无需了解 worktree 命令 -- **SessionStart hook** 在 worktree 下天然准确匹配 active feature（每个 worktree 锁定一个 branch，不存在 session 中途切分支的问题） -- 兼容 superpowers 的 `using-git-worktrees` skill - -### Iteration 2: Sprint 机制引入 - -为 30 人团队引入时间节奏，在 feature 下嵌套 Sprint 结构： - -#### 2.1 Schema 扩展 -``` -.supercrew/ - features/ - feature-a/ - meta.yaml - design.md - plan.md - log.md - sprints/ # 新增 - sprint_260303/ # YYMMDD 格式 - goals.md # Sprint 目标 - tasks.md # 本 Sprint 的 task breakdown + 状态 - retro.md # Sprint 回顾（可选） -``` - -- `meta.yaml` 新增可选字段：`current_sprint: sprint_260303` -- `tasks.md` 结构：YAML frontmatter（`sprint_start`, `sprint_end`, `velocity_planned`, `velocity_actual`）+ task checklist（每项含 assignee、status、estimate） -- `goals.md`：本 Sprint 在该 feature 上要达成的目标 -- `retro.md`：Sprint 结束时由 AI 自动生成回顾摘要 - -#### 2.2 插件新增 Skills -- **`create-sprint`**：在指定 feature 下创建 `sprints/sprint_YYMMDD/` 目录 + 初始文件 -- **`close-sprint`**：汇总完成情况，生成 `retro.md`，更新 `plan.md` progress -- **`sprint-status`**：展示当前 Sprint 的 task 完成情况 - -#### 2.3 看板前端扩展 -- Feature 详情页新增 **Sprint** Tab：展示当前 Sprint 的 task 列表、进度、燃尽图 -- 看板卡片可展示当前 Sprint 进度（可选 toggle） -- Sprint 历史视图：查看历次 Sprint 的 velocity 趋势 - -#### 2.4 Commands -- **`/new-sprint`**：在当前 feature 下创建新 Sprint -- **`/sprint-review`**：展示当前 Sprint 摘要 + 建议关闭 - -### Iteration 3: 跨 Feature 协调与依赖可视化 - -解决"小组之间不通气"的核心问题： - -#### 3.1 依赖图可视化 -- 前端新增 **Dependencies** 视图：基于所有 features 的 `blocked_by` 字段，渲染有向依赖图 -- 高亮环形依赖（红色标注） -- 高亮关键路径（影响最多下游 feature 的上游） - -#### 3.2 `notes.md` 引入 -- 在 feature 文件中新增 `notes.md`：用于非结构化的研究笔记、讨论记录、补充上下文（参考 DDD 的 `notes.md`） -- `log.md` 保持时间线追加语义，`notes.md` 用于随意记录 - -#### 3.3 跨 Feature 变更通知 -- 看板前端新增简单的 **Activity Feed**：聚合所有 features 的最近变更（基于 git commit 时间戳 + log.md 最新条目） -- 按团队（`teams` 字段）筛选 feed，实现"看到其他组在做什么" - -#### 3.4 架构治理 -- 新增 `.supercrew/architecture/` 目录（可选）：存放全局 ADR（Architecture Decision Records） -- Agent 在 `design.md` 涉及跨 feature 架构变更时，自动建议创建/更新 ADR - -### Iteration 4: Release 协调 - -解决"上线难度高"的问题： - -#### 4.1 Release 概念引入 -- 新增 `.supercrew/releases/` 目录：每个 release 一个文件夹 -- `release.yaml`：`version`, `target_date`, `features[]`（包含的 feature id 列表）, `status`（planning/staging/released） -- 看板新增 **Release** 视图：按 release 分组展示 features 及其就绪状态 - -#### 4.2 Release Readiness 检查 -- Agent 新增 **`release-check`** skill：扫描 release 中所有 features，检查是否全部 `status=done`、`design.md` approved、`plan.md` progress=100% -- 前端展示 release readiness dashboard（红/黄/绿信号灯） - -### 迭代优先级与时间线 - -| 迭代 | 聚焦 | 解决的 Layer 2 问题 | 建议时间 | -|---|---|---|---| -| **MVP** | Feature lifecycle + 只读看板 | 项目管理、设计/文档 | 当前 | -| **Iter 1** | Agent 能力增强 + Worktree 自动化 | 提升自动化程度，减少人工维护负担，消除分支管理摩擦 | MVP 后 1-2 周 | -| **Iter 2** | Sprint 机制 | 时间节奏、任务粒度管理 | Iter 1 后 2-3 周 | -| **Iter 3** | 跨 Feature 协调 | 小组不通气、架构治理 | Iter 2 后 2-3 周 | -| **Iter 4** | Release 协调 | 上线难度高 | Iter 3 后 2-3 周 | From 22e4e851397fd39da35a521970dd3cd4bfce704a Mon Sep 17 00:00:00 2001 From: He Zhang <hezhan@microsoft.com> Date: Wed, 4 Mar 2026 00:11:43 +0800 Subject: [PATCH 12/14] update readme --- README.md | 53 +++++++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 49 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 09f25c0..361e806 100644 --- a/README.md +++ b/README.md @@ -1,15 +1,60 @@ # SuperCrew -SuperCrew combines two things: a structured AI development workflow (powered by superpowers skills) and a kanban-style team management app built with those same workflows. +SuperCrew combines two things: a structured AI development workflow (powered by superpowers skills) and a kanban-style feature management app built with those same workflows. ## What's Inside +### `plugins/supercrew/` — The Claude Code Plugin + +AI-driven feature lifecycle management. Track features from idea to done using structured `.supercrew/features/` directories in your repo. + +**Install in Claude Code:** + +```bash +# 1. Add the local marketplace (use absolute path) +/plugin marketplace add /path/to/supercrew/plugins/supercrew + +# 2. Install the plugin +/plugin install supercrew@supercrew-dev + +# 3. Verify +/plugin list +``` + +**Commands:** + +| Command | Description | +|---|---| +| `/supercrew:new-feature` | Create a new feature with meta.yaml, design.md, plan.md, log.md | +| `/supercrew:feature-status` | Show all features status table | +| `/supercrew:work-on` | Switch active feature for this session | + +**Feature lifecycle:** + +``` +planning → designing → ready → active → blocked → done +``` + +Each feature lives in `.supercrew/features/<id>/` with four files: + +| File | Purpose | +|---|---| +| `meta.yaml` | ID, title, status, priority, owner, dates | +| `design.md` | Requirements, architecture, constraints | +| `plan.md` | Task breakdown with checklist & progress | +| `log.md` | Chronological progress entries | + +The plugin's SessionStart hook auto-detects `feature/<id>` branches and loads context. + ### `kanban/` — The Crew App -A lightweight team kanban board with GitHub integration. Features: +A read-only kanban board that visualizes features from `.supercrew/features/`. Connect a GitHub repo and see your feature lifecycle at a glance. + +Features: - GitHub OAuth login -- Connect a GitHub repo to your project -- Board, People, Knowledge, Decisions pages +- Connect a GitHub repo with `.supercrew/features/` +- 6-column kanban board: Planning → Designing → Ready → Active → Blocked → Done +- Feature detail page with Overview / Design / Plan tabs - i18n (English / Chinese) - Dark mode From 01da06ea46519c25d0732ae62d46cdeb7f758156 Mon Sep 17 00:00:00 2001 From: He Zhang <hezhan@microsoft.com> Date: Wed, 4 Mar 2026 00:17:07 +0800 Subject: [PATCH 13/14] fix test --- .../app-core/src/__tests__/api.test.ts | 42 ++++--------------- 1 file changed, 7 insertions(+), 35 deletions(-) diff --git a/kanban/frontend/packages/app-core/src/__tests__/api.test.ts b/kanban/frontend/packages/app-core/src/__tests__/api.test.ts index 04496c7..bc542a5 100644 --- a/kanban/frontend/packages/app-core/src/__tests__/api.test.ts +++ b/kanban/frontend/packages/app-core/src/__tests__/api.test.ts @@ -1,9 +1,14 @@ import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest' -import { fetchBoard, createTask } from '../api.js' +import { fetchBoard } from '../api.js' describe('API error handling', () => { beforeEach(() => { vi.stubGlobal('fetch', vi.fn()) + vi.stubGlobal('localStorage', { + getItem: vi.fn(() => null), + setItem: vi.fn(), + removeItem: vi.fn(), + }) }) afterEach(() => { @@ -18,7 +23,7 @@ describe('API error handling', () => { }) it('returns parsed JSON on 200', async () => { - const board = { tasks: [], sprints: [], people: [] } + const board = { features: [], columns: {} } vi.mocked(globalThis.fetch).mockResolvedValue( new Response(JSON.stringify(board), { status: 200 }), ) @@ -26,36 +31,3 @@ describe('API error handling', () => { expect(result).toEqual(board) }) }) - -describe('createTask', () => { - beforeEach(() => { - vi.stubGlobal('fetch', vi.fn()) - }) - - afterEach(() => { - vi.unstubAllGlobals() - }) - - it('sends POST /api/tasks with JSON body', async () => { - const payload = { - id: 'ENG-001', - title: 'Test task', - status: 'backlog' as const, - priority: 'P2' as const, - tags: [], - blocks: [], - blocked_by: [], - body: '', - } - const mockResponse = { ...payload, created: '2026-01-01', updated: '2026-01-01' } - vi.mocked(globalThis.fetch).mockResolvedValue( - new Response(JSON.stringify(mockResponse), { status: 200 }), - ) - await createTask(payload) - expect(globalThis.fetch).toHaveBeenCalledWith('/api/tasks', { - method: 'POST', - headers: { 'Content-Type': 'application/json' }, - body: JSON.stringify(payload), - }) - }) -}) From c6e8ab4437c0abedc279a86e94147aa902374ded Mon Sep 17 00:00:00 2001 From: He Zhang <hezhan@microsoft.com> Date: Wed, 4 Mar 2026 00:24:21 +0800 Subject: [PATCH 14/14] fix build --- .github/workflows/ci.yml | 3 --- 1 file changed, 3 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 302b0f0..3cc93b8 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -44,6 +44,3 @@ jobs: - name: Test app-core run: cd kanban/frontend/packages/app-core && pnpm run test - - - name: Bundle API (verify esbuild) - run: cd kanban && npm run build:api