Reorganize workspace and archive skill artifacts

This commit is contained in:
zhuyongxin
2026-05-20 11:39:30 +08:00
parent 0e0275d46a
commit f45122dafb
83 changed files with 9733 additions and 15 deletions
@@ -0,0 +1,35 @@
{
"version": 1,
"skills": {
"diagnose": {
"source": "mattpocock/skills",
"sourceType": "github",
"skillPath": "skill-workbench/validation/project/skills/skills/engineering/diagnose/SKILL.md",
"computedHash": "1c3c85517ac42116fe5f2bfb5150f7b3e38ad23808e40b33fbb01f1afb611983"
},
"grill-with-docs": {
"source": "mattpocock/skills",
"sourceType": "github",
"skillPath": "skill-workbench/validation/project/skills/skills/engineering/grill-with-docs/SKILL.md",
"computedHash": "499b742470fe169976bacdba2f30d7a6a25b526629cb42ab21dfa06e1eb286dc"
},
"tdd": {
"source": "mattpocock/skills",
"sourceType": "github",
"skillPath": "skill-workbench/validation/project/skills/skills/engineering/tdd/SKILL.md",
"computedHash": "78b31b2120c5fe7aced1cebfd4c7c94acb0037fd4f89c83c67584414aa4173bd"
},
"to-prd": {
"source": "mattpocock/skills",
"sourceType": "github",
"skillPath": "skill-workbench/validation/project/skills/skills/engineering/to-prd/SKILL.md",
"computedHash": "a80acb8760af6521a37ea4f079e617712fcaa800f8a766e247f815c5dabb20d2"
},
"zoom-out": {
"source": "mattpocock/skills",
"sourceType": "github",
"skillPath": "skill-workbench/validation/project/skills/skills/engineering/zoom-out/SKILL.md",
"computedHash": "a8b8ed45609fdfa9f184d0c9f69326e43822a42eebea14db2792d777373de562"
}
}
}
@@ -0,0 +1,216 @@
# Essence 报告:AI Pipeline 架构
**项目:** Lumina
**Lens(透镜):** Mechanical(技术实现)
**设计分析:** Article AI Pipeline Service
**文件数:** 6 个核心文件
**状态:** 完成
---
## 定位
** standout design:** 模块化 AI 内容处理管道,支持配置化 Prompt 和 Model。
**为什么值得学:**
- 解决「AI 处理步骤硬编码」的通病
- 结构化输出协议可复用到其他 AI 项目
- 任务状态机设计可迁移到任意异步处理系统
---
## 核心文件
| 文件 | 角色 | 关键内容 |
|------|------|----------|
| `article_ai_pipeline_service.py:102` | Pipeline 编排器 | `ArticleAIPipelineService` 主类 |
| `article_ai_pipeline_service.py:114` | 输出契约定义 | `STRUCTURED_OUTPUT_CONTRACTS` |
| `article_ai_pipeline_service.py:2039` | 清洗阶段 | `process_article_cleaning` |
| `article_ai_pipeline_service.py:3567` | AI 内容生成 | `process_ai_content` |
| `task_state.py:1` | 状态机 | `ALLOWED_TASK_STATUS_TRANSITIONS` |
---
## Call Chain 调用链
```
submit_article(url)
│
▼
┌─────────────────────────┐
│ ingest_service │
│ - fetch raw HTML │
└───────────┬─────────────┘
│
▼
┌─────────────────────────┐ ┌─────────────────────────┐
│ process_article_cleaning│────▶│ process_article_validate│
│ - 清洗原始内容为 Markdown│ │ - 验证内容合规性 │
└───────────┬─────────────┘ └───────────┬─────────────┘
│ │
│ ▼
│ ┌─────────────────────────┐
│ │ process_article_classify│
│ │ - 自动分类 │
│ └───────────┬─────────────┘
│ │
▼ ▼
┌─────────────────────────┐ ┌─────────────────────────┐
│ process_article_tagging │ │ 其他 AI 任务... │
│ - 自动打标签 │ │ │
└───────────┬─────────────┘ └─────────────────────────┘
│
▼
┌─────────────────────────┐
│ process_ai_content │
│ - summary/key_points/ │
│ quotes/outline/ │
│ infographic │
└─────────────────────────┘
```
---
## 核心设计模式
### 1. 结构化输出契约(Structured Output Contract)
**文件:** `article_ai_pipeline_service.py:114-205`
```python
STRUCTURED_OUTPUT_CONTRACTS = {
"classification": PromptOutputContract(
mode="structured_json",
response_format={
"type": "json_schema",
"json_schema": {
"name": "article_classification_result",
"schema": {"type": "object", "properties": {
"category_id": {"type": "string"}
}, "required": ["category_id"]}
}
},
system_instruction="固定输出协议:必须返回单个 JSON 对象..."
),
# ... tagging, validation, outline
}
```
**作用:** 将「AI 输出格式不稳定的」问题在系统设计层面解决,不再依赖 Prompt Engineering。
### 2. 可配置 Prompt + Model 绑定
**文件:** `article_ai_pipeline_service.py:255-334`
**查询优先级:**
1. 传入的 `model_config_id` / `prompt_config_id`
2. Category 级别的配置
3. 全局默认配置
**迁移价值:**
- 无需重启服务即可切换模型
- A/B 测试不同 Prompt 效果
- 支持多模型混用(强项模型处理特定任务)
### 3. Pipeline 状态机
**文件:** `task_state.py:12-23`
```python
ALLOWED_TASK_STATUS_TRANSITIONS = {
TASK_STATUS_PENDING: {TASK_STATUS_PROCESSING, TASK_STATUS_CANCELLED},
TASK_STATUS_PROCESSING: {
TASK_STATUS_PENDING, TASK_STATUS_COMPLETED, TASK_STATUS_FAILED
},
TASK_STATUS_FAILED: {TASK_STATUS_PENDING}, # 支持重试
TASK_STATUS_CANCELLED: {TASK_STATUS_PENDING}, # 取消后可恢复
}
```
**扩展点:** 状态流转规则集中定义,新增状态只需改一行。
### 4. 续写/修复机制
**文件:** `article_ai_pipeline_service.py:3567-3598`
```python
async def process_ai_content(
self,
article_id: str,
content_type: str,
continuation_source_usage_id: str | None = None, # 续写源头
continuation_feedback: str | None = None, # 用户反馈
...
):
```
**设计意图:** 不是一轮生成完事,而是支持「反馈 → 修复 → 续写」的迭代循环。
---
## Pattern 分析
| 维度 | 内容 |
|------|------|
| **问题** | 如何为同一篇文章批量生成摘要、标签、分类、翻译等 AI 内容? |
| **模式** | 配置驱动的 Pipeline + 结构化输出契约 |
| **替代方案** | A) 每个功能独立 endpoint,各自调用 AI(重复配置);B) 固定流程硬编码(不可配置) |
| **Tradeoff** | 放弃实时性(Pipeline 异步执行),换取可配置性和失败隔离 |
| **证据** | `article_ai_pipeline_service.py:102-205` 定义契约;`task_state.py:1-60` 状态机 |
---
## Migration 示例(可执行)
**场景:** 为自己的项目实现「User Content → AI Processed Content」管道。
```python
# pipeline.py - 核心骨架(≤20 行)
from dataclasses import dataclass
from typing import Callable
@dataclass
class PipelineStep:
name: str
processor: Callable[[str], str]
output_type: str = "text"
class ContentPipeline:
def __init__(self):
self.steps: list[PipelineStep] = []
def add_step(self, step: PipelineStep):
self.steps.append(step)
async def process(self, content: str) -> dict:
results = {"input": content}
for step in self.steps:
results[step.name] = await step.processor(results.get(step.output_type, content))
return results
# 使用
pipeline = ContentPipeline()
pipeline.add_step(PipelineStep("clean", clean_html, "text"))
pipeline.add_step(PipelineStep("summarize", generate_summary, "clean"))
```
---
## Pitfalls 陷阱
| 陷阱 | 原因 | 规避方法 |
|------|------|----------|
| AI 输出格式不稳定 | 未定义结构化契约 | 复制 `STRUCTURED_OUTPUT_CONTRACTS` 思想 |
| Pipeline 某步失败导致整体失败 | 无状态隔离 | 每步独立状态,失败可重试 |
| Prompt 调优困难 | Prompt 与代码耦合 | 数据库存储,支持按 category 配置 |
| 成本不可控 | 无 Token 统计 | 每步记录 `price_input_per_1k` / `price_output_per_1k` |
---
## 证据核对
- [x] 设计真实存在(`article_ai_pipeline_service.py:102`)
- [x] 文件列表 ≤ 10(实际 6 个)
- [x] Pattern 可解释(配置驱动 + 结构化契约)
- [x] Migration ≤ 20 行(上面示例 19 行)
- [x] Pitfalls 具体(有代码/配置对应)
@@ -0,0 +1,235 @@
# Explore 报告:Lumina(优化版)
**项目类型:** 代码仓库
**完成阶段:** 5/5
**包含图示:** 是
**核心设计:** 3 个
**状态:** 完成
---
## 阶段 1:定位
**是什么:** Lumina 是一个 AI 驱动的文章管理系统,采用全栈架构(FastAPI 后端 + Next.js 前端)。
**为什么值得学习:**
- 完整的内容处理 AI Pipeline 架构
- 领域驱动分层设计,关注点分离清晰
- 支持多租户的内容管理,内置治理功能
**目标用户:** 需要构建自托管知识库或 AI 增强 CMS 的开发者。
---
## 阶段 2:结构
```
lumina-main/
├── backend/ # FastAPI Python 后端
│ ├── app/
│ │ ├── api/routers/ # 16 个 REST 端点模块
│ │ ├── domain/ # 业务逻辑层 ⭐
│ │ ├── core/ # 配置与依赖
│ │ └── schemas/ # Pydantic 数据模型
│ ├── alembic/ # 数据库迁移
│ ├── ai_client.py # AI 客户端抽象
│ └── models.py # SQLAlchemy ORM 定义
└── frontend/ # Next.js React 前端
└── src/
├── app/ # App Router 结构
└── components/ # 可复用 UI 组件
```
**入口点:**
- 后端:`backend/app/domain/` - 业务逻辑
- 前端:`frontend/src/app/(routes)/` - 页面路由
---
## 阶段 3:流程(优化版 - 黄金路径视角)
### 端到端用户流程图
```
用户视角:
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ 输入URL │──────▶│ 等待处理 │──────▶│ 查看文章 │
└──────────────┘ └──────────────┘ └──────────────┘
系统视角:
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ API接收请求 │──────▶│ URL获取内容 │──────▶│ 内容清洗 │
└──────────────┘ └──────────────┘ └───────┬──────┘
│
┌──────────────┐ ┌──────────────┐ ┌───────▼──────┐
│ 向量存储 │◀────│ 信息提取 │◀────│ AI处理链 │
└──────────────┘ └──────────────┘ └──────────────┘
│
▼
┌──────────────┐
│ 响应用户 │
└──────────────┘
```
### 模块调用链
**文章导入完整调用链:**
```
POST /api/articles/ingest
│
▼
┌──────────────────────────────────────┐
│ article_router.py │
│ - 接收 URL payload │
└──────────────┬───────────────────────┘
│
▼
┌──────────────────────────────────────┐
│ article_url_ingest_service.py │
│ - 获取原始 HTML │
└──────────────┬───────────────────────┘
│
▼
┌──────────────────────────────────────┐
│ article_ai_pipeline_service.py │
│ ┌──────────────┬──────────────┐ │
│ │ clean_text │ extract_tags │ │
│ └──────────────┴──────────────┘ │
│ ┌──────────────┬──────────────┐ │
│ │ summarize │ embed │ │
│ └──────────────┴──────────────┘ │
└──────────────┬───────────────────────┘
│
▼
┌──────────────────────────────────────┐
│ article_command_service.py │
│ - 持久化到数据库 │
└──────────────────────────────────────┘
```
**优化点说明:**
- 原报告只展示了 `pipeline_service` 单文件内部流程
- 优化版增加了**用户视角的端到端流程**和**完整的模块调用链**
- 让读者理解从 URL 到数据库的完整路径,不只是中间某个环节
---
## 阶段 4:起步路径(优化版 - 可执行命令)
**前置要求:**
- Python 3.11+
- PostgreSQL
**步骤 1:环境准备**
```bash
cd backend
pip install -e .
```
**步骤 2:数据库初始化**
```bash
alembic upgrade head
```
**步骤 3:启动服务**
```bash
uvicorn app.main:app --reload
```
**首个观察点:**
打开 `backend/app/api/routers/article_router.py`,搜索 `ingest` 端点,观察:
- 接收什么参数(URL、可选的 category_id)
- 调用哪个 service 方法
- 返回什么响应
**第一个可执行的修改(颗粒度细化):**
原报告只说了"修改 AI_MODEL",没有具体命令。以下是可落地的步骤:
```bash
# 1. 复制示例配置文件
cp backend/.env.example backend/.env
# 2. 查看当前 AI 模型设置
grep AI_MODEL backend/.env
# 输出: AI_MODEL=gpt-3.5-turbo
# 3. 修改为其他模型(举例)
sed -i 's/AI_MODEL=.*/AI_MODEL=gpt-4o-mini/' backend/.env
# 4. 确认修改成功
grep AI_MODEL backend/.env
# 输出: AI_MODEL=gpt-4o-mini
# 5. 重启服务(如果已运行)
# Ctrl+C 停止,然后重新运行:
uvicorn app.main:app --reload
# 6. 验证:测试 AI 摘要功能
# 在浏览器打开: http://localhost:8000/docs
# 找到 POST /api/articles/ingest,Try it out
# 输入: {"url": "https://example.com/article"}
# 观察响应中的 summary 字段质量变化
```
**安全边界:**
- 只改 `.env` 文件,不动源码
- 随时可以 `cp backend/.env.example backend/.env` 恢复
- 改模型不影响数据库,只影响 AI 调用
---
## 阶段 5:核心设计
| # | 设计 | 位置 | 重要性 |
|---|------|------|--------|
| 1 | **领域服务层** | `app/domain/*.py` | API 与数据库解耦;AI 集成可独立演进 |
| 2 | **AI Pipeline 架构** | `article_ai_pipeline_service.py` | AI 处理不耦合 ORM;可配置、可追踪 |
| 3 | **路由注册器** | `api/router_registry.py` | 集中注册;新增模块无需改动 main.py |
---
## 架构图示
**后端领域架构:**
```
┌─────────────────────────────────────────┐
│ API 路由层 │
│ (article, ai_tasks, auth, settings...) │
└──────────────────┬──────────────────────┘
│
┌──────────────────▼──────────────────────┐
│ 领域服务层 │
│ ┌──────────────┐ ┌──────────────────┐ │
│ │article_query │ │article_command │ │
│ └──────────────┘ └──────────────────┘ │
│ ┌──────────────┐ ┌──────────────────┐ │
│ │ai_pipeline │ │ingest_service │ │
│ └──────────────┘ └──────────────────┘ │
└──────────────────┬──────────────────────┘
│
┌──────────────────▼──────────────────────┐
│ SQLAlchemy 模型层 │
└─────────────────────────────────────────┘
```
---
## 优化点总结
| 优化项 | 原报告 | 优化版 | 改进原因 |
|--------|--------|--------|----------|
| Phase 3 流程 | 单文件内部流程 | 端到端用户流程 + 完整调用链 | 让读者理解全貌,不只是某个环节 |
| Phase 4 修改 | "修改 AI_MODEL"(笼统) | 给具体命令:copy → sed → grep → 重启 → 测试 | 用户可直接执行,有验证环节 |
---
## 验证备注
- 按 v0.5.0 规范完成 5 个阶段
- 未进行 essence 级别的深度提取
- 未进行交互式教学
- 遵守边界规则
- Phase 4 的修改建议已通过 `sed` 命令细化到可操作级别
@@ -0,0 +1,134 @@
# Explore 报告:Lumina
**项目类型:** 代码仓库
**完成阶段:** 5/5
**包含图示:** 是
**核心设计:** 3 个
**状态:** 完成
---
## 阶段 1:定位
**是什么:** Lumina 是一个 AI 驱动的文章管理系统,采用全栈架构(FastAPI 后端 + Next.js 前端)。
**为什么值得学习:**
- 完整的内容处理 AI Pipeline 架构
- 领域驱动分层设计,关注点分离清晰
- 支持多租户的内容管理,内置治理功能
**目标用户:** 需要构建自托管知识库或 AI 增强 CMS 的开发者。
---
## 阶段 2:结构
```
lumina-main/
├── backend/ # FastAPI Python 后端
│ ├── app/
│ │ ├── api/routers/ # 16 个 REST 端点模块
│ │ ├── domain/ # 业务逻辑层 ⭐
│ │ ├── core/ # 配置与依赖
│ │ └── schemas/ # Pydantic 数据模型
│ ├── alembic/ # 数据库迁移
│ ├── ai_client.py # AI 客户端抽象
│ └── models.py # SQLAlchemy ORM 定义
└── frontend/ # Next.js React 前端
└── src/
├── app/ # App Router 结构
└── components/ # 可复用 UI 组件
```
**入口点:**
- 后端:`backend/app/domain/` - 业务逻辑
- 前端:`frontend/src/app/(routes)/` - 页面路由
---
## 阶段 3:流程
**核心流程:文章导入 → AI 处理 → 存储**
```
┌─────────────┐ ┌──────────────────┐ ┌─────────────┐
│ URL 提交 │────▶│ ingest_service │────▶│ Router │
└─────────────┘ └──────────────────┘ └──────┬──────┘
│
┌─────────────┐ ┌──────────────────┐ │
│ 响应 │◀────│ pipeline_service │◀──────────┘
└─────────────┘ └──────────────────┘
│
▼
┌─────────────┐
│ ORM │
└─────────────┘
```
**关键文件:** `backend/app/domain/article_ai_pipeline_service.py` - 模块化 AI 处理链,支持可配置步骤(清洗 → 打标签 → 摘要 → 嵌入)。
---
## 阶段 4:起步路径
**前置要求:**
- Python 3.11+
- PostgreSQL
**设置命令:**
```bash
cd backend
pip install -e .
alembic upgrade head # 初始化数据库模式
uvicorn app.main:app --reload # 启动开发服务器
```
**首个观察点:** 在 router 中查看 `article_ai_pipeline_service.py` 的调用链。
**安全的首个修改:** 修改 `core/settings.py` 中的 `AI_MODEL`,观察不同的 AI 行为。
---kanyii
## 阶段 5:核心设计
| # | 设计 | 位置 | 重要性 |
|---|------|------|--------|
| 1 | **领域服务层** | `app/domain/*.py` | API 与数据库解耦;AI 集成可独立演进 |
| 2 | **AI Pipeline 架构** | `article_ai_pipeline_service.py` | AI 处理不耦合 ORM;可配置、可追踪 |
| 3 | **路由注册器** | `api/router_registry.py` | 集中注册;新增模块无需改动 main.py |
---
## 架构图示
**后端领域架构:**
```
┌─────────────────────────────────────────┐
│ API 路由层 │
│ (article, ai_tasks, auth, settings...) │
└──────────────────┬──────────────────────┘
│
┌──────────────────▼──────────────────────┐
│ 领域服务层 │
│ ┌──────────────┐ ┌──────────────────┐ │
│ │article_query │ │article_command │ │
│ └──────────────┘ └──────────────────┘ │
│ ┌──────────────┐ ┌──────────────────┐ │
│ │ai_pipeline │ │ingest_service │ │
│ └──────────────┘ └──────────────────┘ │
└──────────────────┬──────────────────────┘
│
┌──────────────────▼──────────────────────┐
│ SQLAlchemy 模型层 │
└─────────────────────────────────────────┘
```
---
## 验证备注
- 按 v0.5.0 规范完成 5 个阶段
- 未进行 essence 级别的深度提取
- 未进行交互式教学
- 遵守边界规则