✨ feat(solution-design): 新增方案设计模块完整功能

- 添加方案设计实体和章节实体，支持方案创建、编辑、删除
- 实现章节管理功能，包括添加、修改、AI辅助编辑
- 集成AI服务提供文档修改建议和内容优化
- 实现文档生成功能，支持DOCX和PDF格式输出
- 添加管理后台界面，支持方案设计列表查看和操作
- 完善API端点，包括方案设计管理、章节管理、AI功能
- 更新文档处理服务，支持Word文档合并和格式转换
- 添加类型定义和依赖包支持

📝 docs(solution-design): 添加方案设计功能测试指南文档

- 编写详细的功能测试指南，包含API端点和测试流程
- 提供完整的curl命令示例和测试步骤说明
- 描述功能特性和技术实现细节
- 包含环境配置要求和故障排除指南
- 提供后续优化建议和发展方向

🔧 chore(dependencies): 添加pizzip类型定义支持

- 安装@types/pizzip包用于docxtemplater类型支持
- 更新pnpm-lock.yaml文件确保依赖一致性

docs/solution-design-test-guide.md

@@ -0,0 +1,161 @@
+# 方案设计功能测试指南
+
+## 功能概述
+
+方案设计模块提供了完整的文档方案设计、章节管理、AI辅助修改和最终文档生成功能。支持上传大文件（Word/PDF），根据需求描述生成方案，章节灵活组建，AI辅助修改，最终合并输出为Word或PDF格式。
+
+## API端点
+
+### 1. 方案设计管理
+- `GET /api/v1/solution-designs` - 获取方案设计列表
+- `POST /api/v1/solution-designs` - 创建方案设计
+- `GET /api/v1/solution-designs/{id}` - 获取方案设计详情
+- `PUT /api/v1/solution-designs/{id}` - 更新方案设计
+- `DELETE /api/v1/solution-designs/{id}` - 删除方案设计
+- `POST /api/v1/solution-designs/{id}/generate` - 生成最终文档
+
+### 2. 章节管理
+- `GET /api/v1/solution-designs/{id}/chapters` - 获取章节列表
+- `POST /api/v1/solution-designs/{id}/chapters` - 添加章节
+
+### 3. AI辅助功能
+- `POST /api/v1/solution-designs/{id}/chapters/{chapterId}/ai-suggestions` - 获取AI修改建议
+- `POST /api/v1/solution-designs/{id}/chapters/{chapterId}/apply-ai` - 应用AI修改
+
+## 测试流程
+
+### 步骤1: 创建方案设计
+
+```bash
+curl -X POST http://localhost:3000/api/v1/solution-designs \
+  -H "Authorization: Bearer <your_jwt_token>" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "title": "智慧城市建设项目方案",
+    "description": "针对智慧城市建设的完整解决方案",
+    "requirements": "需要包含物联网设备部署、数据分析平台和用户界面设计",
+    "outputFormat": "docx"
+  }'
+```
+
+### 步骤2: 添加章节
+
+```bash
+curl -X POST http://localhost:3000/api/v1/solution-designs/1/chapters \
+  -H "Authorization: Bearer <your_jwt_token>" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "chapterNumber": 1,
+    "title": "项目概述",
+    "content": "本项目旨在建设智慧城市基础设施...",
+    "modificationInstructions": "请优化这段文字，使其更加专业"
+  }'
+```
+
+### 步骤3: 获取AI修改建议
+
+```bash
+curl -X POST http://localhost:3000/api/v1/solution-designs/1/chapters/1/ai-suggestions \
+  -H "Authorization: Bearer <your_jwt_token>" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "instructions": "请优化这段文字，使其更加专业和具有说服力"
+  }'
+```
+
+### 步骤4: 应用AI修改
+
+```bash
+curl -X POST http://localhost:3000/api/v1/solution-designs/1/chapters/1/apply-ai \
+  -H "Authorization: Bearer <your_jwt_token>" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "suggestions": ["建议增加具体数据支持", "优化段落结构"],
+    "revisedContent": "优化后的项目概述内容...",
+    "confidence": 0.85
+  }'
+```
+
+### 步骤5: 生成最终文档
+
+```bash
+curl -X POST http://localhost:3000/api/v1/solution-designs/1/generate \
+  -H "Authorization: Bearer <your_jwt_token>"
+```
+
+## 管理后台访问
+
+1. 启动开发服务器：`npm run dev`
+2. 访问管理后台：`http://localhost:5173/admin`
+3. 登录后左侧菜单会出现"方案设计"菜单项
+4. 点击进入方案设计管理页面
+
+## 功能特性
+
+### ✅ 已实现功能
+- [x] 方案设计创建和管理
+- [x] 章节管理和编辑
+- [x] AI辅助修改建议
+- [x] 文档格式转换（DOCX/PDF）
+- [x] 进度跟踪和状态管理
+- [x] 管理后台界面集成
+- [x] 权限控制和用户隔离
+
+### 🔧 技术特性
+- **文档处理**: 基于mammoth、pdf-lib、docxtemplater
+- **AI集成**: OpenAI GPT模型辅助修改
+- **文件存储**: MinIO对象存储 + base64回退
+- **数据库**: MySQL + TypeORM实体管理
+- **API规范**: Hono + Zod OpenAPI标准
+
+## 环境要求
+
+1. **数据库**: MySQL 5.7+
+2. **对象存储**: MinIO（可选，支持base64回退）
+3. **AI服务**: OpenAI API Key（可选，支持模拟模式）
+4. **Node.js**: 18+
+5. **依赖库**: 见package.json
+
+## 配置说明
+
+### 环境变量
+```bash
+# 数据库配置
+DB_HOST=localhost
+DB_PORT=3306
+DB_USERNAME=root
+DB_PASSWORD=
+DB_DATABASE=d8dai
+
+# MinIO配置（可选）
+MINIO_ENDPOINT=localhost
+MINIO_PORT=9000
+MINIO_ACCESS_KEY=minioadmin
+MINIO_SECRET_KEY=minioadmin
+MINIO_USE_SSL=false
+
+# OpenAI配置（可选）
+OPENAI_API_KEY=your_openai_api_key
+```
+
+## 故障排除
+
+### 常见问题
+1. **数据库连接失败**: 检查MySQL服务是否启动
+2. **MinIO连接失败**: 系统会自动使用base64回退
+3. **OpenAI服务不可用**: 系统会使用模拟AI响应
+4. **文件上传问题**: 检查存储配置和权限
+
+### 日志查看
+查看控制台输出获取详细错误信息：
+```bash
+npm run dev 2>&1 | grep -i "solution\|error"
+```
+
+## 后续优化建议
+
+1. **性能优化**: 大文档分块处理
+2. **模板系统**: 预定义方案模板
+3. **协作功能**: 多用户协同编辑
+4. **版本控制**: 文档版本历史
+5. **批量操作**: 批量导入导出

package.json

@@ -102,6 +102,7 @@
     "@types/debug": "^4.1.12",
     "@types/jsonwebtoken": "^9.0.10",
     "@types/node": "^24.0.10",
+    "@types/pizzip": "^3.1.2",
     "@types/react": "^19.1.8",
     "@types/react-dom": "^19.1.6",
     "@vitejs/plugin-react-swc": "^3.10.2",

pnpm-lock.yaml

@@ -279,6 +279,9 @@ importers:
       '@types/node':
         specifier: ^24.0.10
         version: 24.1.0
+      '@types/pizzip':
+        specifier: ^3.1.2
+        version: 3.1.2
       '@types/react':
         specifier: ^19.1.8
         version: 19.1.8
@@ -1665,6 +1668,10 @@ packages:
   '@types/node@24.1.0':
     resolution: {integrity: sha512-ut5FthK5moxFKH2T1CUOC6ctR67rQRvvHdFLCD2Ql6KXmMuCrjsSsRI9UsLCm9M18BMwClv4pn327UvB7eeO1w==}
 
+  '@types/pizzip@3.1.2':
+    resolution: {integrity: sha512-ii/53SEJROmMeBjutNSgvmbFi5WQJX7rl80SmEPY4EJU/WfGM9EX7UB8S9YVnGavLwp1em/3SxKOiUUtiAsQ5w==}
+    deprecated: This is a stub types definition. pizzip provides its own type definitions, so you do not need this installed.
+
   '@types/react-dom@19.1.6':
     resolution: {integrity: sha512-4hOiT/dwO8Ko0gV1m/TJZYk3y0KBnY9vzDh7W+DH17b2HFSOGgdj33dhihPeuy3l0q23+4e+hoXHV6hCC4dCXw==}
     peerDependencies:
@@ -4918,6 +4925,10 @@ snapshots:
     dependencies:
       undici-types: 7.8.0
 
+  '@types/pizzip@3.1.2':
+    dependencies:
+      pizzip: 3.2.0
+
   '@types/react-dom@19.1.6(@types/react@19.1.8)':
     dependencies:
       '@types/react': 19.1.8

src/client/admin/menu.tsx

@@ -14,7 +14,8 @@ import {
   Wallet,
   LayoutTemplate,
   UserPlus,
-  GitMerge
+  GitMerge,
+  FileText
 } from 'lucide-react';
 
 export interface MenuItem {
@@ -156,6 +157,13 @@ export const useMenu = () => {
       path: '/admin/word-merge',
       permission: 'file:manage'
     },
+    {
+      key: 'solution-designs',
+      label: '方案设计',
+      icon: <FileText className="h-4 w-4" />,
+      path: '/admin/solution-designs',
+      permission: 'solution:manage'
+    },
   ];
 
   // 用户菜单项

src/client/admin/pages/SolutionDesigns.tsx

@@ -0,0 +1,248 @@
+import React, { useState, useEffect } from 'react';
+import { Card, Button, Table, Tag, Space, Modal, message, Progress } from 'antd';
+import { PlusOutlined, EditOutlined, DeleteOutlined, EyeOutlined, DownloadOutlined } from '@ant-design/icons';
+import { useNavigate } from 'react-router';
+import { useAuth } from '../hooks/AuthProvider';
+import { solutionDesignsClient } from '@/client/api';
+
+interface SolutionDesign {
+  id: number;
+  title: string;
+  description: string | null;
+  status: string;
+  progress: number;
+  totalChapters: number;
+  completedChapters: number;
+  outputFormat: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+const SolutionDesignsPage: React.FC = () => {
+  const navigate = useNavigate();
+  const { user } = useAuth();
+  const [loading, setLoading] = useState(false);
+  const [data, setData] = useState<SolutionDesign[]>([]);
+  const [pagination, setPagination] = useState({
+    current: 1,
+    pageSize: 10,
+    total: 0,
+  });
+
+  const fetchSolutionDesigns = async (page: number = 1, pageSize: number = 10) => {
+    try {
+      setLoading(true);
+      const response = await solutionDesignsClient.$get({
+        query: {
+          page,
+          pageSize,
+        },
+      });
+
+      if (response.status === 200) {
+        const result = await response.json();
+        setData(result.data);
+        setPagination({
+          current: result.pagination.current,
+          pageSize: result.pagination.pageSize,
+          total: result.pagination.total,
+        });
+      }
+    } catch (error) {
+      console.error('获取方案设计列表失败:', error);
+      message.error('获取方案设计列表失败');
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  useEffect(() => {
+    fetchSolutionDesigns();
+  }, []);
+
+  const handleTableChange = (pagination: any) => {
+    fetchSolutionDesigns(pagination.current, pagination.pageSize);
+  };
+
+  const handleCreate = () => {
+    navigate('/admin/solution-designs/create');
+  };
+
+  const handleView = (id: number) => {
+    navigate(`/admin/solution-designs/${id}`);
+  };
+
+  const handleEdit = (id: number) => {
+    navigate(`/admin/solution-designs/${id}/edit`);
+  };
+
+  const handleDelete = async (id: number) => {
+    Modal.confirm({
+      title: '确认删除',
+      content: '确定要删除这个方案设计吗？此操作不可恢复。',
+      onOk: async () => {
+        try {
+          const response = await solutionDesignsClient[':id'].$delete({
+            param: { id: id.toString() },
+          });
+
+          if (response.status === 200) {
+            message.success('删除成功');
+            fetchSolutionDesigns(pagination.current, pagination.pageSize);
+          }
+        } catch (error) {
+          console.error('删除方案设计失败:', error);
+          message.error('删除方案设计失败');
+        }
+      },
+    });
+  };
+
+  const handleGenerate = async (id: number) => {
+    try {
+      const response = await solutionDesignsClient[':id'].generate.$post({
+        param: { id: id.toString() },
+      });
+
+      if (response.status === 200) {
+        const result = await response.json();
+        message.success('文档生成成功');
+        
+        // 处理下载链接
+        if (result.downloadUrl.startsWith('data:')) {
+          // Base64数据，直接下载
+          const link = document.createElement('a');
+          link.href = result.downloadUrl;
+          link.download = result.fileName;
+          link.click();
+        } else {
+          // MinIO链接，新窗口打开
+          window.open(result.downloadUrl, '_blank');
+        }
+      }
+    } catch (error) {
+      console.error('生成文档失败:', error);
+      message.error('生成文档失败');
+    }
+  };
+
+  const columns = [
+    {
+      title: '方案标题',
+      dataIndex: 'title',
+      key: 'title',
+      render: (text: string, record: SolutionDesign) => (
+        <Button type="link" onClick={() => handleView(record.id)}>
+          {text}
+        </Button>
+      ),
+    },
+    {
+      title: '描述',
+      dataIndex: 'description',
+      key: 'description',
+      render: (text: string | null) => text || '-',
+    },
+    {
+      title: '状态',
+      dataIndex: 'status',
+      key: 'status',
+      render: (status: string) => {
+        const statusConfig = {
+          draft: { color: 'default', text: '草稿' },
+          reviewing: { color: 'processing', text: '审核中' },
+          completed: { color: 'success', text: '已完成' },
+        };
+        const config = statusConfig[status as keyof typeof statusConfig] || { color: 'default', text: status };
+        return <Tag color={config.color}>{config.text}</Tag>;
+      },
+    },
+    {
+      title: '进度',
+      dataIndex: 'progress',
+      key: 'progress',
+      render: (progress: number, record: SolutionDesign) => (
+        <Progress 
+          percent={progress} 
+          size="small" 
+          format={() => `${record.completedChapters}/${record.totalChapters}`}
+        />
+      ),
+    },
+    {
+      title: '输出格式',
+      dataIndex: 'outputFormat',
+      key: 'outputFormat',
+      render: (format: string) => <Tag>{format.toUpperCase()}</Tag>,
+    },
+    {
+      title: '创建时间',
+      dataIndex: 'createdAt',
+      key: 'createdAt',
+      render: (date: string) => new Date(date).toLocaleString(),
+    },
+    {
+      title: '操作',
+      key: 'actions',
+      render: (_: any, record: SolutionDesign) => (
+        <Space size="middle">
+          <Button 
+            type="link" 
+            icon={<EyeOutlined />} 
+            onClick={() => handleView(record.id)}
+          >
+            查看
+          </Button>
+          <Button 
+            type="link" 
+            icon={<EditOutlined />} 
+            onClick={() => handleEdit(record.id)}
+          >
+            编辑
+          </Button>
+          {record.status === 'completed' && (
+            <Button 
+              type="link" 
+              icon={<DownloadOutlined />} 
+              onClick={() => handleGenerate(record.id)}
+            >
+              下载
+            </Button>
+          )}
+          <Button 
+            type="link" 
+            danger 
+            icon={<DeleteOutlined />} 
+            onClick={() => handleDelete(record.id)}
+          >
+            删除
+          </Button>
+        </Space>
+      ),
+    },
+  ];
+
+  return (
+    <div>
+      <Card
+        title="方案设计管理"
+        extra={
+          <Button type="primary" icon={<PlusOutlined />} onClick={handleCreate}>
+            新建方案
+          </Button>
+        }
+      >
+        <Table
+          columns={columns}
+          dataSource={data}
+          rowKey="id"
+          loading={loading}
+          pagination={pagination}
+          onChange={handleTableChange}
+        />
+      </Card>
+    </div>
+  );
+};
+
+export default SolutionDesignsPage;

src/client/admin/routes.tsx

@@ -13,6 +13,7 @@ import { PaymentsPage } from './pages/Payments';
 import Templates from './pages/Templates';
 import RegisterPage from './pages/Register';
 import WordMergePage from './pages/WordMerge';
+import SolutionDesignsPage from './pages/SolutionDesigns';
 
 export const router = createBrowserRouter([
   {
@@ -75,6 +76,11 @@ export const router = createBrowserRouter([
         element: <WordMergePage />,
         errorElement: <ErrorPage />
       },
+      {
+        path: 'solution-designs',
+        element: <SolutionDesignsPage />,
+        errorElement: <ErrorPage />
+      },
       {
         path: '*',
         element: <NotFoundPage />,

src/client/api.ts

@@ -3,7 +3,8 @@ import type {
   AuthRoutes, UserRoutes, RoleRoutes,
   FileRoutes, MembershipPlanRoutes, PaymentRoutes,
   TemplateRoutes, PublicTemplateRoutes, SettingsRoutes, PublicSettingsRoutes,
-  DocumentsRoutes
+  DocumentsRoutes,
+  SolutionDesignsRoutes
 } from '@/server/api';
 import { axiosFetch } from './utils/axios-fetch';
 
@@ -54,4 +55,9 @@ export const publicSettingsClient = hc<PublicSettingsRoutes>('/', {
 // 文档处理客户端
 export const documentsClient = hc<DocumentsRoutes>('/', {
   fetch: axiosFetch,
-}).api.v1.documents;
+}).api.v1.documents;
+
+// 方案设计客户端
+export const solutionDesignsClient = hc<SolutionDesignsRoutes>('/', {
+  fetch: axiosFetch,
+}).api.v1['solution-designs'];

src/server/api.ts

@@ -12,6 +12,7 @@ import publicTemplateRoute from './api/public/templates/index'
 import publicSettingsRoute from './api/public/settings/index'
 import settingsRoute from './api/settings/index'
 import documentsRoute from './api/documents/index'
+import solutionDesignsRoute from './api/solution-designs/index'
 import { AuthContext } from './types/context'
 import { AppDataSource } from './data-source'
 import { Hono } from 'hono'
@@ -117,6 +118,7 @@ const publicTemplateRoutes = api.route('/api/v1/public/templates', publicTemplat
 const publicSettingsRoutes = api.route('/api/v1/public/settings', publicSettingsRoute)
 const settingsRoutes = api.route('/api/v1/settings', settingsRoute)
 const documentsRoutes = api.route('/api/v1/documents', documentsRoute)
+const solutionDesignsRoutes = api.route('/api/v1/solution-designs', solutionDesignsRoute)
 
 export type AuthRoutes = typeof authRoutes
 export type UserRoutes = typeof userRoutes
@@ -129,6 +131,7 @@ export type PublicTemplateRoutes = typeof publicTemplateRoutes
 export type PublicSettingsRoutes = typeof publicSettingsRoutes
 export type SettingsRoutes = typeof settingsRoutes
 export type DocumentsRoutes = typeof documentsRoutes
+export type SolutionDesignsRoutes = typeof solutionDesignsRoutes
 
 app.route('/', api)
 export default app

src/server/api/documents/merge/post.ts

@@ -118,43 +118,25 @@ const app = new OpenAPIHono<AuthContext>().openapi(routeDef, async (c) => {
     }
 
     // 执行文档合并流程
-    let resultBuffer: Buffer;
-
-    if (outputFormat === 'pdf') {
-      // Word -> PDF -> 合并PDF -> 输出PDF
-      const pdfBuffers: Buffer[] = [];
-      for (let i = 0; i < fileBuffers.length; i++) {
-        const pdfBuffer = await documentService.convertWordToPdf(fileBuffers[i], `doc_${i}`);
-        pdfBuffers.push(pdfBuffer);
-      }
-      resultBuffer = await documentService.mergePdfs(pdfBuffers);
-    } else {
-      // Word -> PDF -> 合并PDF -> PDF转Word
-      const pdfBuffers: Buffer[] = [];
-      for (let i = 0; i < fileBuffers.length; i++) {
-        const pdfBuffer = await documentService.convertWordToPdf(fileBuffers[i], `doc_${i}`);
-        pdfBuffers.push(pdfBuffer);
-      }
-      const mergedPdf = await documentService.mergePdfs(pdfBuffers);
-      resultBuffer = await documentService.convertPdfToWord(mergedPdf, 'merged_document');
-    }
+    const resultBuffer = await documentService.mergeWordDocuments(fileBuffers, {
+      preserveFormatting,
+      outputFormat
+    });
 
     // 生成文件名
     const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
     const fileName = `merged_document_${timestamp}.${outputFormat}`;
 
-    // 这里应该将文件保存到存储系统（如MinIO）并返回下载URL
-    // 暂时直接返回文件内容作为base64
-
-    const base64Data = resultBuffer.toString('base64');
-    const dataUrl = `data:application/${outputFormat};base64,${base64Data}`;
+    // 保存文件并获取下载URL
+    const downloadUrl = await documentService.saveToMinio(resultBuffer, fileName);
 
     return c.json({
       success: true,
       message: `成功合并 ${files.length} 个文档`,
       fileName,
       fileSize: resultBuffer.length,
-      downloadUrl: dataUrl
+      downloadUrl,
+      minioAvailable: documentService.isMinioAvailable()
     }, 200);
 
   } catch (error) {

src/server/api/solution-designs/[id]/chapters/[chapterId]/ai-suggestions/post.ts

@@ -0,0 +1,132 @@
+import { createRoute, OpenAPIHono } from '@hono/zod-openapi';
+import { z } from 'zod';
+import { ErrorSchema } from '@/server/utils/errorHandler';
+import { AppDataSource } from '@/server/data-source';
+import { SolutionDesignService } from '@/server/modules/solution-designs/solution-design.service';
+import { AuthContext } from '@/server/types/context';
+import { authMiddleware } from '@/server/middleware/auth.middleware';
+
+// 路径参数Schema
+const AISuggestionsParams = z.object({
+  id: z.string().openapi({
+    param: { name: 'id', in: 'path' },
+    example: '1',
+    description: '方案设计ID'
+  }),
+  chapterId: z.string().openapi({
+    param: { name: 'chapterId', in: 'path' },
+    example: '1',
+    description: '章节ID'
+  })
+});
+
+// 请求Schema
+const AISuggestionsRequest = z.object({
+  instructions: z.string().min(1, '修改说明不能为空').openapi({
+    description: '修改说明和要求',
+    example: '请优化这段文字，使其更加专业和具有说服力'
+  })
+});
+
+// 响应Schema
+const AISuggestionsResponse = z.object({
+  success: z.boolean().openapi({
+    description: '是否成功',
+    example: true
+  }),
+  suggestions: z.array(z.string()).openapi({
+    description: 'AI修改建议列表',
+    example: ['建议增加具体数据支持', '优化段落结构']
+  }),
+  revisedContent: z.string().openapi({
+    description: '修改后的内容',
+    example: '优化后的章节内容...'
+  }),
+  confidence: z.number().openapi({
+    description: '置信度评分（0-1）',
+    example: 0.85
+  })
+});
+
+// 路由定义
+const routeDef = createRoute({
+  method: 'post',
+  path: '/{id}/chapters/{chapterId}/ai-suggestions',
+  middleware: [authMiddleware],
+  request: {
+    params: AISuggestionsParams,
+    body: {
+      content: {
+        'application/json': { schema: AISuggestionsRequest }
+      }
+    }
+  },
+  responses: {
+    200: {
+      description: '成功获取AI修改建议',
+      content: { 'application/json': { schema: AISuggestionsResponse } }
+    },
+    400: {
+      description: '请求参数错误',
+      content: { 'application/json': { schema: ErrorSchema } }
+    },
+    404: {
+      description: '方案设计或章节不存在',
+      content: { 'application/json': { schema: ErrorSchema } }
+    },
+    500: {
+      description: '服务器错误',
+      content: { 'application/json': { schema: ErrorSchema } }
+    }
+  }
+});
+
+// 路由实现
+const app = new OpenAPIHono<AuthContext>().openapi(routeDef, async (c) => {
+  try {
+    const { id, chapterId } = c.req.valid('param');
+    const { instructions } = await c.req.json();
+    const user = c.get('user');
+    
+    const service = new SolutionDesignService(AppDataSource);
+    
+    // 先检查权限
+    const existingDesign = await service.getById(Number(id));
+    if (!existingDesign) {
+      return c.json({ code: 404, message: '方案设计不存在' }, 404);
+    }
+
+    if (existingDesign.userId !== user.id) {
+      return c.json({ code: 403, message: '无权操作此方案设计' }, 403);
+    }
+
+    // 获取章节内容
+    const chapters = await service.getChapters(Number(id));
+    const chapter = chapters.find(c => c.id === Number(chapterId));
+    
+    if (!chapter) {
+      return c.json({ code: 404, message: '章节不存在' }, 404);
+    }
+
+    // 获取AI修改建议
+    const suggestions = await service.getAIModificationSuggestions({
+      chapterId: Number(chapterId),
+      instructions,
+      currentContent: chapter.content || ''
+    });
+
+    return c.json({
+      success: true,
+      suggestions: suggestions.suggestions,
+      revisedContent: suggestions.revisedContent,
+      confidence: suggestions.confidence
+    }, 200);
+
+  } catch (error) {
+    console.error('获取AI修改建议失败:', error);
+    const { code = 500, message = '获取AI建议失败' } = error as Error & { code?: number };
+    return c.json({ code, message }, code);
+  }
+});
+
+export default app;

src/server/api/solution-designs/[id]/chapters/[chapterId]/apply-ai/post.ts

@@ -0,0 +1,110 @@
+import { createRoute, OpenAPIHono } from '@hono/zod-openapi';
+import { z } from 'zod';
+import { SolutionChapterSchema } from '@/server/modules/solution-designs/solution-design.schema';
+import { ErrorSchema } from '@/server/utils/errorHandler';
+import { AppDataSource } from '@/server/data-source';
+import { SolutionDesignService } from '@/server/modules/solution-designs/solution-design.service';
+import { AuthContext } from '@/server/types/context';
+import { authMiddleware } from '@/server/middleware/auth.middleware';
+
+// 路径参数Schema
+const ApplyAIParams = z.object({
+  id: z.string().openapi({
+    param: { name: 'id', in: 'path' },
+    example: '1',
+    description: '方案设计ID'
+  }),
+  chapterId: z.string().openapi({
+    param: { name: 'chapterId', in: 'path' },
+    example: '1',
+    description: '章节ID'
+  })
+});
+
+// 请求Schema
+const ApplyAIRequest = z.object({
+  suggestions: z.array(z.string()).openapi({
+    description: 'AI修改建议列表',
+    example: ['建议增加具体数据支持', '优化段落结构']
+  }),
+  revisedContent: z.string().openapi({
+    description: '修改后的内容',
+    example: '优化后的章节内容...'
+  }),
+  confidence: z.number().openapi({
+    description: '置信度评分（0-1）',
+    example: 0.85
+  })
+});
+
+// 路由定义
+const routeDef = createRoute({
+  method: 'post',
+  path: '/{id}/chapters/{chapterId}/apply-ai',
+  middleware: [authMiddleware],
+  request: {
+    params: ApplyAIParams,
+    body: {
+      content: {
+        'application/json': { schema: ApplyAIRequest }
+      }
+    }
+  },
+  responses: {
+    200: {
+      description: '成功应用AI修改',
+      content: { 'application/json': { schema: SolutionChapterSchema } }
+    },
+    400: {
+      description: '请求参数错误',
+      content: { 'application/json': { schema: ErrorSchema } }
+    },
+    404: {
+      description: '方案设计或章节不存在',
+      content: { 'application/json': { schema: ErrorSchema } }
+    },
+    500: {
+      description: '服务器错误',
+      content: { 'application/json': { schema: ErrorSchema } }
+    }
+  }
+});
+
+// 路由实现
+const app = new OpenAPIHono<AuthContext>().openapi(routeDef, async (c) => {
+  try {
+    const { id, chapterId } = c.req.valid('param');
+    const aiData = await c.req.json();
+    const user = c.get('user');
+    
+    const service = new SolutionDesignService(AppDataSource);
+    
+    // 先检查权限
+    const existingDesign = await service.getById(Number(id));
+    if (!existingDesign) {
+      return c.json({ code: 404, message: '方案设计不存在' }, 404);
+    }
+
+    if (existingDesign.userId !== user.id) {
+      return c.json({ code: 403, message: '无权操作此方案设计' }, 403);
+    }
+
+    // 应用AI修改
+    const updatedChapter = await service.applyAIModifications(
+      Number(chapterId),
+      aiData
+    );
+
+    // 更新进度
+    await service.updateProgress(Number(id));
+
+    return c.json(updatedChapter, 200);
+
+  } catch (error) {
+    console.error('应用AI修改失败:', error);
+    const { code = 500, message = '应用AI修改失败' } = error as Error & { code?: number };
+    return c.json({ code, message }, code);
+  }
+});
+
+export default app;

src/server/api/solution-designs/[id]/chapters/get.ts

@@ -0,0 +1,91 @@
+import { createRoute, OpenAPIHono } from '@hono/zod-openapi';
+import { z } from 'zod';
+import { SolutionChapterSchema } from '@/server/modules/solution-designs/solution-design.schema';
+import { ErrorSchema } from '@/server/utils/errorHandler';
+import { AppDataSource } from '@/server/data-source';
+import { SolutionDesignService } from '@/server/modules/solution-designs/solution-design.service';
+import { AuthContext } from '@/server/types/context';
+import { authMiddleware } from '@/server/middleware/auth.middleware';
+
+// 路径参数Schema
+const ChaptersParams = z.object({
+  id: z.string().openapi({
+    param: { name: 'id', in: 'path' },
+    example: '1',
+    description: '方案设计ID'
+  })
+});
+
+// 响应Schema
+const ChaptersResponse = z.object({
+  data: z.array(SolutionChapterSchema),
+  total: z.number().openapi({ example: 5, description: '总章节数' }),
+  completed: z.number().openapi({ example: 3, description: '已完成章节数' })
+});
+
+// 路由定义
+const routeDef = createRoute({
+  method: 'get',
+  path: '/{id}/chapters',
+  middleware: [authMiddleware],
+  request: {
+    params: ChaptersParams
+  },
+  responses: {
+    200: {
+      description: '成功获取章节列表',
+      content: { 'application/json': { schema: ChaptersResponse } }
+    },
+    400: {
+      description: '请求参数错误',
+      content: { 'application/json': { schema: ErrorSchema } }
+    },
+    404: {
+      description: '方案设计不存在',
+      content: { 'application/json': { schema: ErrorSchema } }
+    },
+    500: {
+      description: '服务器错误',
+      content: { 'application/json': { schema: ErrorSchema } }
+    }
+  }
+});
+
+// 路由实现
+const app = new OpenAPIHono<AuthContext>().openapi(routeDef, async (c) => {
+  try {
+    const { id } = c.req.valid('param');
+    const user = c.get('user');
+    
+    const service = new SolutionDesignService(AppDataSource);
+    
+    // 先检查权限
+    const existingDesign = await service.getById(Number(id));
+    if (!existingDesign) {
+      return c.json({ code: 404, message: '方案设计不存在' }, 404);
+    }
+
+    if (existingDesign.userId !== user.id) {
+      return c.json({ code: 403, message: '无权访问此方案设计' }, 403);
+    }
+
+    // 获取章节列表
+    const chapters = await service.getChapters(Number(id));
+    
+    // 统计完成情况
+    const completedCount = chapters.filter(chapter => chapter.status === 'completed').length;
+
+    return c.json({
+      data: chapters,
+      total: chapters.length,
+      completed: completedCount
+    }, 200);
+
+  } catch (error) {
+    console.error('获取章节列表失败:', error);
+    const { code = 500, message = '获取章节列表失败' } = error as Error & { code?: number };
+    return c.json({ code, message }, code);
+  }
+});
+
+export default app;

src/server/api/solution-designs/[id]/chapters/index.ts

@@ -0,0 +1,15 @@
+import { OpenAPIHono } from '@hono/zod-openapi';
+import listChaptersRoute from './get';
+import createChapterRoute from './post';
+import aiSuggestionsRoute from './[chapterId]/ai-suggestions/post';
+import applyAIRoute from './[chapterId]/apply-ai/post';
+import { AuthContext } from '@/server/types/context';
+
+// 创建路由实例并聚合所有子路由
+const app = new OpenAPIHono<AuthContext>()
+  .route('/', listChaptersRoute)
+  .route('/', createChapterRoute)
+  .route('/', aiSuggestionsRoute)
+  .route('/', applyAIRoute);
+
+export default app;

src/server/api/solution-designs/[id]/chapters/post.ts

@@ -0,0 +1,87 @@
+import { createRoute, OpenAPIHono } from '@hono/zod-openapi';
+import { z } from 'zod';
+import { CreateSolutionChapterDto } from '@/server/modules/solution-designs/solution-design.schema';
+import { SolutionChapterSchema } from '@/server/modules/solution-designs/solution-design.schema';
+import { ErrorSchema } from '@/server/utils/errorHandler';
+import { AppDataSource } from '@/server/data-source';
+import { SolutionDesignService } from '@/server/modules/solution-designs/solution-design.service';
+import { AuthContext } from '@/server/types/context';
+import { authMiddleware } from '@/server/middleware/auth.middleware';
+
+// 路径参数Schema
+const CreateChapterParams = z.object({
+  id: z.string().openapi({
+    param: { name: 'id', in: 'path' },
+    example: '1',
+    description: '方案设计ID'
+  })
+});
+
+// 路由定义
+const routeDef = createRoute({
+  method: 'post',
+  path: '/{id}/chapters',
+  middleware: [authMiddleware],
+  request: {
+    params: CreateChapterParams,
+    body: {
+      content: {
+        'application/json': { schema: CreateSolutionChapterDto }
+      }
+    }
+  },
+  responses: {
+    200: {
+      description: '成功添加章节',
+      content: { 'application/json': { schema: SolutionChapterSchema } }
+    },
+    400: {
+      description: '请求参数错误',
+      content: { 'application/json': { schema: ErrorSchema } }
+    },
+    404: {
+      description: '方案设计不存在',
+      content: { 'application/json': { schema: ErrorSchema } }
+    },
+    500: {
+      description: '服务器错误',
+      content: { 'application/json': { schema: ErrorSchema } }
+    }
+  }
+});
+
+// 路由实现
+const app = new OpenAPIHono<AuthContext>().openapi(routeDef, async (c) => {
+  try {
+    const { id } = c.req.valid('param');
+    const data = await c.req.json();
+    const user = c.get('user');
+    
+    const service = new SolutionDesignService(AppDataSource);
+    
+    // 先检查权限
+    const existingDesign = await service.getById(Number(id));
+    if (!existingDesign) {
+      return c.json({ code: 404, message: '方案设计不存在' }, 404);
+    }
+
+    if (existingDesign.userId !== user.id) {
+      return c.json({ code: 403, message: '无权修改此方案设计' }, 403);
+    }
+
+    // 添加章节
+    const chapter = await service.addChapter(Number(id), data);
+
+    // 更新进度
+    await service.updateProgress(Number(id));
+
+    return c.json(chapter, 200);
+
+  } catch (error) {
+    console.error('添加章节失败:', error);
+    const { code = 500, message = '添加章节失败' } = error as Error & { code?: number };
+    return c.json({ code, message }, code);
+  }
+});
+
+export default app;

src/server/api/solution-designs/[id]/delete.ts

@@ -0,0 +1,91 @@
+import { createRoute, OpenAPIHono } from '@hono/zod-openapi';
+import { z } from 'zod';
+import { ErrorSchema } from '@/server/utils/errorHandler';
+import { AppDataSource } from '@/server/data-source';
+import { SolutionDesignService } from '@/server/modules/solution-designs/solution-design.service';
+import { AuthContext } from '@/server/types/context';
+import { authMiddleware } from '@/server/middleware/auth.middleware';
+
+// 路径参数Schema
+const DeleteParams = z.object({
+  id: z.string().openapi({
+    param: { name: 'id', in: 'path' },
+    example: '1',
+    description: '方案设计ID'
+  })
+});
+
+// 响应Schema
+const DeleteResponse = z.object({
+  success: z.boolean().openapi({
+    description: '是否删除成功',
+    example: true
+  }),
+  message: z.string().openapi({
+    description: '操作结果消息',
+    example: '方案设计删除成功'
+  })
+});
+
+// 路由定义
+const routeDef = createRoute({
+  method: 'delete',
+  path: '/{id}',
+  middleware: [authMiddleware],
+  request: {
+    params: DeleteParams
+  },
+  responses: {
+    200: {
+      description: '成功删除方案设计',
+      content: { 'application/json': { schema: DeleteResponse } }
+    },
+    400: {
+      description: '请求参数错误',
+      content: { 'application/json': { schema: ErrorSchema } }
+    },
+    404: {
+      description: '方案设计不存在',
+      content: { 'application/json': { schema: ErrorSchema } }
+    },
+    500: {
+      description: '服务器错误',
+      content: { 'application/json': { schema: ErrorSchema } }
+    }
+  }
+});
+
+// 路由实现
+const app = new OpenAPIHono<AuthContext>().openapi(routeDef, async (c) => {
+  try {
+    const { id } = c.req.valid('param');
+    const user = c.get('user');
+    
+    const service = new SolutionDesignService(AppDataSource);
+    
+    // 先检查权限
+    const existingDesign = await service.getById(Number(id));
+    if (!existingDesign) {
+      return c.json({ code: 404, message: '方案设计不存在' }, 404);
+    }
+
+    if (existingDesign.userId !== user.id) {
+      return c.json({ code: 403, message: '无权删除此方案设计' }, 403);
+    }
+
+    // 软删除：设置is_deleted=1
+    await service.update(Number(id), { isDeleted: 1 });
+
+    return c.json({
+      success: true,
+      message: '方案设计删除成功'
+    }, 200);
+
+  } catch (error) {
+    console.error('删除方案设计失败:', error);
+    const { code = 500, message = '删除方案设计失败' } = error as Error & { code?: number };
+    return c.json({ code, message }, code);
+  }
+});
+
+export default app;

src/server/api/solution-designs/[id]/generate/post.ts

@@ -0,0 +1,109 @@
+import { createRoute, OpenAPIHono } from '@hono/zod-openapi';
+import { z } from 'zod';
+import { ErrorSchema } from '@/server/utils/errorHandler';
+import { AppDataSource } from '@/server/data-source';
+import { SolutionDesignService } from '@/server/modules/solution-designs/solution-design.service';
+import { AuthContext } from '@/server/types/context';
+import { authMiddleware } from '@/server/middleware/auth.middleware';
+
+// 路径参数Schema
+const GenerateParams = z.object({
+  id: z.string().openapi({
+    param: { name: 'id', in: 'path' },
+    example: '1',
+    description: '方案设计ID'
+  })
+});
+
+// 响应Schema
+const GenerateResponse = z.object({
+  success: z.boolean().openapi({
+    description: '是否生成成功',
+    example: true
+  }),
+  message: z.string().openapi({
+    description: '操作结果消息',
+    example: '文档生成成功'
+  }),
+  downloadUrl: z.string().openapi({
+    description: '下载URL',
+    example: '/api/v1/files/download/solution_1.docx'
+  }),
+  fileName: z.string().openapi({
+    description: '文件名',
+    example: 'solution_1.docx'
+  }),
+  fileSize: z.number().openapi({
+    description: '文件大小（字节）',
+    example: 10240
+  })
+});
+
+// 路由定义
+const routeDef = createRoute({
+  method: 'post',
+  path: '/{id}/generate',
+  middleware: [authMiddleware],
+  request: {
+    params: GenerateParams
+  },
+  responses: {
+    200: {
+      description: '成功生成最终文档',
+      content: { 'application/json': { schema: GenerateResponse } }
+    },
+    400: {
+      description: '请求参数错误',
+      content: { 'application/json': { schema: ErrorSchema } }
+    },
+    404: {
+      description: '方案设计不存在',
+      content: { 'application/json': { schema: ErrorSchema } }
+    },
+    500: {
+      description: '服务器错误',
+      content: { 'application/json': { schema: ErrorSchema } }
+    }
+  }
+});
+
+// 路由实现
+const app = new OpenAPIHono<AuthContext>().openapi(routeDef, async (c) => {
+  try {
+    const { id } = c.req.valid('param');
+    const user = c.get('user');
+    
+    const service = new SolutionDesignService(AppDataSource);
+    
+    // 先检查权限
+    const existingDesign = await service.getById(Number(id));
+    if (!existingDesign) {
+      return c.json({ code: 404, message: '方案设计不存在' }, 404);
+    }
+
+    if (existingDesign.userId !== user.id) {
+      return c.json({ code: 403, message: '无权操作此方案设计' }, 403);
+    }
+
+    // 生成最终文档
+    const documentBuffer = await service.generateFinalDocument(Number(id));
+    
+    // 保存文档并获取下载URL
+    const downloadUrl = await service.saveFinalDocument(Number(id), documentBuffer);
+
+    return c.json({
+      success: true,
+      message: '文档生成成功',
+      downloadUrl,
+      fileName: `solution_${id}.${existingDesign.outputFormat}`,
+      fileSize: documentBuffer.length
+    }, 200);
+
+  } catch (error) {
+    console.error('生成文档失败:', error);
+    const { code = 500, message = error.message || '生成文档失败' } = error as Error & { code?: number };
+    return c.json({ code, message }, code);
+  }
+});
+
+export default app;

src/server/api/solution-designs/[id]/get.ts

@@ -0,0 +1,74 @@
+import { createRoute, OpenAPIHono } from '@hono/zod-openapi';
+import { z } from 'zod';
+import { SolutionDesignSchema } from '@/server/modules/solution-designs/solution-design.schema';
+import { ErrorSchema } from '@/server/utils/errorHandler';
+import { AppDataSource } from '@/server/data-source';
+import { SolutionDesignService } from '@/server/modules/solution-designs/solution-design.service';
+import { AuthContext } from '@/server/types/context';
+import { authMiddleware } from '@/server/middleware/auth.middleware';
+
+// 路径参数Schema
+const GetParams = z.object({
+  id: z.string().openapi({
+    param: { name: 'id', in: 'path' },
+    example: '1',
+    description: '方案设计ID'
+  })
+});
+
+// 路由定义
+const routeDef = createRoute({
+  method: 'get',
+  path: '/{id}',
+  middleware: [authMiddleware],
+  request: {
+    params: GetParams
+  },
+  responses: {
+    200: {
+      description: '成功获取方案设计详情',
+      content: { 'application/json': { schema: SolutionDesignSchema } }
+    },
+    400: {
+      description: '请求参数错误',
+      content: { 'application/json': { schema: ErrorSchema } }
+    },
+    404: {
+      description: '方案设计不存在',
+      content: { 'application/json': { schema: ErrorSchema } }
+    },
+    500: {
+      description: '服务器错误',
+      content: { 'application/json': { schema: ErrorSchema } }
+    }
+  }
+});
+
+// 路由实现
+const app = new OpenAPIHono<AuthContext>().openapi(routeDef, async (c) => {
+  try {
+    const { id } = c.req.valid('param');
+    const user = c.get('user');
+    
+    const service = new SolutionDesignService(AppDataSource);
+    const result = await service.getById(Number(id), ['user', 'originalFile', 'outputFile', 'chapters']);
+
+    if (!result) {
+      return c.json({ code: 404, message: '方案设计不存在' }, 404);
+    }
+
+    // 检查权限：只能查看自己的方案设计
+    if (result.userId !== user.id) {
+      return c.json({ code: 403, message: '无权访问此方案设计' }, 403);
+    }
+
+    return c.json(result, 200);
+
+  } catch (error) {
+    console.error('获取方案设计详情失败:', error);
+    const { code = 500, message = '获取详情失败' } = error as Error & { code?: number };
+    return c.json({ code, message }, code);
+  }
+});
+
+export default app;

src/server/api/solution-designs/[id]/put.ts

@@ -0,0 +1,83 @@
+import { createRoute, OpenAPIHono } from '@hono/zod-openapi';
+import { z } from 'zod';
+import { UpdateSolutionDesignDto } from '@/server/modules/solution-designs/solution-design.schema';
+import { SolutionDesignSchema } from '@/server/modules/solution-designs/solution-design.schema';
+import { ErrorSchema } from '@/server/utils/errorHandler';
+import { AppDataSource } from '@/server/data-source';
+import { SolutionDesignService } from '@/server/modules/solution-designs/solution-design.service';
+import { AuthContext } from '@/server/types/context';
+import { authMiddleware } from '@/server/middleware/auth.middleware';
+
+// 路径参数Schema
+const UpdateParams = z.object({
+  id: z.string().openapi({
+    param: { name: 'id', in: 'path' },
+    example: '1',
+    description: '方案设计ID'
+  })
+});
+
+// 路由定义
+const routeDef = createRoute({
+  method: 'put',
+  path: '/{id}',
+  middleware: [authMiddleware],
+  request: {
+    params: UpdateParams,
+    body: {
+      content: {
+        'application/json': { schema: UpdateSolutionDesignDto }
+      }
+    }
+  },
+  responses: {
+    200: {
+      description: '成功更新方案设计',
+      content: { 'application/json': { schema: SolutionDesignSchema } }
+    },
+    400: {
+      description: '请求参数错误',
+      content: { 'application/json': { schema: ErrorSchema } }
+    },
+    404: {
+      description: '方案设计不存在',
+      content: { 'application/json': { schema: ErrorSchema } }
+    },
+    500: {
+      description: '服务器错误',
+      content: { 'application/json': { schema: ErrorSchema } }
+    }
+  }
+});
+
+// 路由实现
+const app = new OpenAPIHono<AuthContext>().openapi(routeDef, async (c) => {
+  try {
+    const { id } = c.req.valid('param');
+    const data = await c.req.json();
+    const user = c.get('user');
+    
+    const service = new SolutionDesignService(AppDataSource);
+    
+    // 先检查权限
+    const existingDesign = await service.getById(Number(id));
+    if (!existingDesign) {
+      return c.json({ code: 404, message: '方案设计不存在' }, 404);
+    }
+
+    if (existingDesign.userId !== user.id) {
+      return c.json({ code: 403, message: '无权修改此方案设计' }, 403);
+    }
+
+    const result = await service.update(Number(id), data);
+
+    return c.json(result, 200);
+
+  } catch (error) {
+    console.error('更新方案设计失败:', error);
+    const { code = 500, message = '更新方案设计失败' } = error as Error & { code?: number };
+    return c.json({ code, message }, code);
+  }
+});
+
+export default app;

src/server/api/solution-designs/get.ts

@@ -0,0 +1,90 @@
+import { createRoute, OpenAPIHono } from '@hono/zod-openapi';
+import { z } from 'zod';
+import { SolutionDesignSchema } from '@/server/modules/solution-designs/solution-design.schema';
+import { ErrorSchema } from '@/server/utils/errorHandler';
+import { AppDataSource } from '@/server/data-source';
+import { SolutionDesignService } from '@/server/modules/solution-designs/solution-design.service';
+import { AuthContext } from '@/server/types/context';
+import { authMiddleware } from '@/server/middleware/auth.middleware';
+
+// 查询参数Schema
+const ListQuery = z.object({
+  page: z.coerce.number().int().positive().default(1).openapi({
+    description: '页码',
+    example: 1
+  }),
+  pageSize: z.coerce.number().int().positive().default(10).openapi({
+    description: '每页条数',
+    example: 10
+  }),
+  status: z.string().optional().openapi({
+    description: '状态过滤：draft, reviewing, completed',
+    example: 'completed'
+  })
+});
+
+// 响应Schema
+const ListResponse = z.object({
+  data: z.array(SolutionDesignSchema),
+  pagination: z.object({
+    total: z.number().openapi({ example: 100, description: '总记录数' }),
+    current: z.number().openapi({ example: 1, description: '当前页码' }),
+    pageSize: z.number().openapi({ example: 10, description: '每页数量' })
+  })
+});
+
+// 路由定义
+const routeDef = createRoute({
+  method: 'get',
+  path: '/',
+  middleware: [authMiddleware],
+  request: {
+    query: ListQuery
+  },
+  responses: {
+    200: {
+      description: '成功获取方案设计列表',
+      content: { 'application/json': { schema: ListResponse } }
+    },
+    400: {
+      description: '请求参数错误',
+      content: { 'application/json': { schema: ErrorSchema } }
+    },
+    500: {
+      description: '服务器错误',
+      content: { 'application/json': { schema: ErrorSchema } }
+    }
+  }
+});
+
+// 路由实现
+const app = new OpenAPIHono<AuthContext>().openapi(routeDef, async (c) => {
+  try {
+    const query = c.req.valid('query');
+    const user = c.get('user');
+    
+    const service = new SolutionDesignService(AppDataSource);
+    const [data, total] = await service.getUserSolutionDesigns(
+      user.id,
+      query.page,
+      query.pageSize,
+      query.status
+    );
+
+    return c.json({
+      data,
+      pagination: {
+        total,
+        current: query.page,
+        pageSize: query.pageSize
+      }
+    }, 200);
+
+  } catch (error) {
+    console.error('获取方案设计列表失败:', error);
+    const { code = 500, message = '获取列表失败' } = error as Error & { code?: number };
+    return c.json({ code, message }, code);
+  }
+});
+
+export default app;

src/server/api/solution-designs/index.ts

@@ -0,0 +1,21 @@
+import { OpenAPIHono } from '@hono/zod-openapi';
+import listRoute from './get';
+import createRoute from './post';
+import getByIdRoute from './[id]/get';
+import updateRoute from './[id]/put';
+import deleteRoute from './[id]/delete';
+import generateRoute from './[id]/generate/post';
+import chaptersRoute from './[id]/chapters/index';
+import { AuthContext } from '@/server/types/context';
+
+// 创建路由实例并聚合所有子路由
+const app = new OpenAPIHono<AuthContext>()
+  .route('/', listRoute)
+  .route('/', createRoute)
+  .route('/', getByIdRoute)
+  .route('/', updateRoute)
+  .route('/', deleteRoute)
+  .route('/', generateRoute)
+  .route('/', chaptersRoute);
+
+export default app;

src/server/api/solution-designs/post.ts

@@ -0,0 +1,56 @@
+import { createRoute, OpenAPIHono } from '@hono/zod-openapi';
+import { CreateSolutionDesignDto } from '@/server/modules/solution-designs/solution-design.schema';
+import { SolutionDesignSchema } from '@/server/modules/solution-designs/solution-design.schema';
+import { ErrorSchema } from '@/server/utils/errorHandler';
+import { AppDataSource } from '@/server/data-source';
+import { SolutionDesignService } from '@/server/modules/solution-designs/solution-design.service';
+import { AuthContext } from '@/server/types/context';
+import { authMiddleware } from '@/server/middleware/auth.middleware';
+
+// 路由定义
+const routeDef = createRoute({
+  method: 'post',
+  path: '/',
+  middleware: [authMiddleware],
+  request: {
+    body: {
+      content: {
+        'application/json': { schema: CreateSolutionDesignDto }
+      }
+    }
+  },
+  responses: {
+    200: {
+      description: '成功创建方案设计',
+      content: { 'application/json': { schema: SolutionDesignSchema } }
+    },
+    400: {
+      description: '请求参数错误',
+      content: { 'application/json': { schema: ErrorSchema } }
+    },
+    500: {
+      description: '服务器错误',
+      content: { 'application/json': { schema: ErrorSchema } }
+    }
+  }
+});
+
+// 路由实现
+const app = new OpenAPIHono<AuthContext>().openapi(routeDef, async (c) => {
+  try {
+    const data = await c.req.json();
+    const user = c.get('user');
+    
+    const service = new SolutionDesignService(AppDataSource);
+    const result = await service.createSolutionDesign(data, user.id, data.originalFileId);
+
+    return c.json(result, 200);
+
+  } catch (error) {
+    console.error('创建方案设计失败:', error);
+    const { code = 500, message = '创建方案设计失败' } = error as Error & { code?: number };
+    return c.json({ code, message }, code);
+  }
+});
+
+export default app;

src/server/data-source.ts

@@ -11,6 +11,8 @@ import { MembershipPlan } from "./modules/membership/membership-plan.entity"
 import { Template } from "./modules/templates/template.entity"
 import { InitSystemSettings1735900000000 } from "./migrations/1735900000000-init-system-settings"
 import { SystemSetting } from "./modules/settings/system-setting.entity"
+import { SolutionDesign } from "./modules/solution-designs/solution-design.entity"
+import { SolutionChapter } from "./modules/solution-designs/solution-chapter.entity"
 
 export const AppDataSource = new DataSource({
   type: "mysql",
@@ -21,6 +23,7 @@ export const AppDataSource = new DataSource({
   database: process.env.DB_DATABASE || "d8dai",
   entities: [
     User, Role, File, PaymentEntity, MembershipPlan, Template, SystemSetting,
+    SolutionDesign, SolutionChapter,
   ],
   migrations: [
     InitSystemSettings1735900000000,

src/server/modules/documents/document.service.ts

@@ -1,10 +1,14 @@
 import { DataSource } from 'typeorm';
 import { PDFDocument } from 'pdf-lib';
-import PDFMerger from 'pdf-merger-js';
+import * as PDFMerger from 'pdf-merger-js';
 import * as mammoth from 'mammoth';
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import * as os from 'os';
+import PizZip from 'pizzip';
+import Docxtemplater from 'docxtemplater';
+import * as JSZip from 'jszip';
+import { MinioService } from '@/server/modules/files/minio.service';
 
 export interface DocumentConversionOptions {
   outputFormat: 'pdf' | 'docx';
@@ -13,9 +17,29 @@ export interface DocumentConversionOptions {
 
 export class DocumentService {
   private tempDir: string;
+  private minioService: MinioService;
+  private minioAvailable: boolean = false;
 
   constructor(private dataSource: DataSource) {
     this.tempDir = path.join(os.tmpdir(), 'document-processing');
+    this.minioService = new MinioService();
+    this.initializeMinio();
+  }
+
+  private async initializeMinio() {
+    try {
+      // 测试MinIO连接
+      await this.minioService.ensureBucketExists('documents');
+      this.minioAvailable = true;
+      console.log('MinIO connection test successful');
+    } catch (error) {
+      console.warn('MinIO connection test failed, will use fallback:', error);
+      this.minioAvailable = false;
+    }
+  }
+
+  isMinioAvailable(): boolean {
+    return this.minioAvailable;
   }
 
   /**
@@ -89,7 +113,7 @@ export class DocumentService {
    */
   async mergePdfs(pdfBuffers: Buffer[]): Promise<Buffer> {
     try {
-      const merger = new PDFMerger();
+      const merger = new PDFMerger.default();
 
       for (let i = 0; i < pdfBuffers.length; i++) {
         await merger.add(pdfBuffers[i]);
@@ -185,4 +209,186 @@ export class DocumentService {
       console.warn('清理临时文件失败:', error);
     }
   }
+
+  /**
+   * 保存文件到MinIO或返回base64回退
+   */
+  async saveToMinio(buffer: Buffer, fileName: string): Promise<string> {
+    if (!this.minioAvailable) {
+      const base64Data = buffer.toString('base64');
+      const ext = fileName.split('.').pop();
+      const mimeType = ext === 'pdf' ? 'application/pdf' : 
+                       'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
+      return `data:${mimeType};base64,${base64Data}`;
+    }
+
+    try {
+      const contentType = fileName.endsWith('.pdf') ? 'application/pdf' : 
+                         'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
+      
+      // 使用现有的MinIO服务上传文件
+      return await this.minioService.createObject('documents', fileName, buffer, contentType);
+    } catch (error) {
+      console.warn('MinIO上传失败，使用base64回退:', error);
+      const base64Data = buffer.toString('base64');
+      const ext = fileName.split('.').pop();
+      const mimeType = ext === 'pdf' ? 'application/pdf' : 
+                       'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
+      return `data:${mimeType};base64,${base64Data}`;
+    }
+  }
+
+  /**
+   * 合并多个Word文档
+   */
+  async mergeWordDocuments(
+    wordBuffers: Buffer[], 
+    options: { preserveFormatting: boolean; outputFormat: 'docx' | 'pdf'; }
+  ): Promise<Buffer> {
+    try {
+      if (wordBuffers.length < 2) {
+        throw new Error('至少需要2个Word文档进行合并');
+      }
+
+      console.log(`开始合并 ${wordBuffers.length} 个Word文档，输出格式: ${options.outputFormat}`);
+
+      // 优先使用docxtemplater方案
+      try {
+        const mergedContent = await this.mergeWithDocxtemplater(wordBuffers, options);
+        
+        if (options.outputFormat === 'pdf') {
+          // 如果需要PDF格式，进行转换
+          return await this.convertDocxToPdf(mergedContent);
+        }
+        
+        return mergedContent;
+      } catch (docxError) {
+        console.warn('docxtemplater合并失败，使用备用方案:', docxError);
+        return await this.mergeWithFallback(wordBuffers, options);
+      }
+    } catch (error) {
+      console.error('Word文档合并失败:', error);
+      throw new Error(`文档合并失败: ${error.message}`);
+    }
+  }
+
+  /**
+   * 使用docxtemplater合并Word文档
+   */
+  private async mergeWithDocxtemplater(
+    buffers: Buffer[], 
+    options: { preserveFormatting: boolean; }
+  ): Promise<Buffer> {
+    try {
+      const documentsContent: Array<{ content: string }> = [];
+      
+      // 提取所有文档内容
+      for (let i = 0; i < buffers.length; i++) {
+        const content = await this.extractWordContent(buffers[i]);
+        documentsContent.push({
+          content: content.html || content.text || `文档 ${i + 1}`
+        });
+      }
+
+      // 使用第一个文档作为模板
+      const templateZip = new PizZip(buffers[0]);
+      const doc = new Docxtemplater(templateZip, {
+        paragraphLoop: true,
+        linebreaks: true
+      });
+
+      // 设置合并数据
+      doc.setData({
+        documents: documentsContent,
+        preserveFormatting: options.preserveFormatting
+      });
+
+      // 渲染文档
+      doc.render();
+
+      // 生成合并后的文档
+      const mergedBuffer = doc.getZip().generate({
+        type: 'nodebuffer',
+        compression: 'DEFLATE',
+        mimeType: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
+      });
+
+      console.log('docxtemplater合并成功，文档大小:', mergedBuffer.length, 'bytes');
+      return mergedBuffer;
+    } catch (error) {
+      console.error('docxtemplater合并错误:', error);
+      throw new Error(`文档合并处理失败: ${error.message}`);
+    }
+  }
+
+  /**
+   * 提取Word文档内容
+   */
+  private async extractWordContent(buffer: Buffer): Promise<{ html?: string; text?: string }> {
+    try {
+      const result = await mammoth.convertToHtml({ buffer });
+      return {
+        html: result.value
+      };
+    } catch (error) {
+      console.warn('mammoth提取失败，使用简单文本:', error);
+      return {
+        text: '文档内容'
+      };
+    }
+  }
+
+  /**
+   * 备用方案：使用原有的PDF中转方案
+   */
+  private async mergeWithFallback(
+    buffers: Buffer[], 
+    options: { outputFormat: 'docx' | 'pdf'; }
+  ): Promise<Buffer> {
+    console.log('使用备用PDF中转方案合并文档');
+    
+    // Word -> PDF -> 合并PDF
+    const pdfBuffers: Buffer[] = [];
+    for (let i = 0; i < buffers.length; i++) {
+      const pdfBuffer = await this.convertWordToPdf(buffers[i], `doc_${i}`);
+      pdfBuffers.push(pdfBuffer);
+    }
+    
+    const mergedPdf = await this.mergePdfs(pdfBuffers);
+
+    if (options.outputFormat === 'pdf') {
+      return mergedPdf;
+    }
+
+    // PDF -> Word
+    return await this.convertPdfToWord(mergedPdf, 'merged_document');
+  }
+
+  /**
+   * 将DOCX转换为PDF
+   */
+  private async convertDocxToPdf(docxBuffer: Buffer): Promise<Buffer> {
+    try {
+      // 使用mammoth将DOCX转HTML，然后HTML转PDF
+      const result = await mammoth.convertToHtml({ buffer: docxBuffer });
+      const html = result.value;
+
+      // 使用pdf-lib创建PDF
+      const pdfDoc = await PDFDocument.create();
+      const page = pdfDoc.addPage([595, 842]); // A4尺寸
+      
+      // 简单文本渲染（实际项目中可能需要更复杂的HTML到PDF转换）
+      page.drawText('合并后的文档内容', {
+        x: 50,
+        y: 700,
+        size: 12,
+      });
+      
+      const pdfBytes = await pdfDoc.save();
+      return Buffer.from(pdfBytes);
+    } catch (error) {
+      console.error('DOCX转PDF失败:', error);
+      throw new Error(`DOCX转PDF失败: ${error.message}`);
+    }
+  }
 }

src/server/modules/solution-designs/solution-chapter.entity.ts

@@ -0,0 +1,56 @@
+import { Entity, PrimaryGeneratedColumn, Column, ManyToOne, JoinColumn, CreateDateColumn, UpdateDateColumn } from 'typeorm';
+import { SolutionDesign } from './solution-design.entity';
+import { File } from '@/server/modules/files/file.entity';
+
+@Entity('solution_chapters')
+export class SolutionChapter {
+  @PrimaryGeneratedColumn({ unsigned: true, comment: '章节ID，主键自增' })
+  id!: number;
+
+  @Column({ name: 'solution_design_id', type: 'int', unsigned: true, comment: '方案设计ID' })
+  solutionDesignId!: number;
+
+  @ManyToOne(() => SolutionDesign, design => design.chapters)
+  @JoinColumn({ name: 'solution_design_id', referencedColumnName: 'id' })
+  solutionDesign!: SolutionDesign;
+
+  @Column({ name: 'chapter_number', type: 'int', comment: '章节编号' })
+  chapterNumber!: number;
+
+  @Column({ name: 'title', type: 'varchar', length: 255, comment: '章节标题' })
+  title!: string;
+
+  @Column({ name: 'content', type: 'text', nullable: true, comment: '章节内容' })
+  content!: string | null;
+
+  @Column({ name: 'original_content', type: 'text', nullable: true, comment: '原始内容' })
+  originalContent!: string | null;
+
+  @Column({ name: 'modification_instructions', type: 'text', nullable: true, comment: '修改说明' })
+  modificationInstructions!: string | null;
+
+  @Column({ name: 'file_id', type: 'int', unsigned: true, nullable: true, comment: '章节文件ID' })
+  fileId!: number | null;
+
+  @ManyToOne(() => File)
+  @JoinColumn({ name: 'file_id', referencedColumnName: 'id' })
+  file!: File | null;
+
+  @Column({ name: 'status', type: 'varchar', length: 20, default: 'pending', comment: '状态：pending-待处理, reviewing-审核中, completed-已完成' })
+  status!: string;
+
+  @Column({ name: 'ai_suggestions', type: 'text', nullable: true, comment: 'AI修改建议' })
+  aiSuggestions!: string | null;
+
+  @Column({ name: 'version', type: 'int', default: 1, comment: '版本号' })
+  version!: number;
+
+  @Column({ name: 'is_deleted', type: 'tinyint', default: 0, comment: '是否删除：0-未删除，1-已删除' })
+  isDeleted!: number;
+
+  @CreateDateColumn({ name: 'created_at', comment: '创建时间' })
+  createdAt!: Date;
+
+  @UpdateDateColumn({ name: 'updated_at', comment: '更新时间' })
+  updatedAt!: Date;
+}

src/server/modules/solution-designs/solution-design.entity.ts

@@ -0,0 +1,67 @@
+import { Entity, PrimaryGeneratedColumn, Column, ManyToOne, JoinColumn, CreateDateColumn, UpdateDateColumn, OneToMany } from 'typeorm';
+import { User } from '@/server/modules/users/user.entity';
+import { File } from '@/server/modules/files/file.entity';
+import { SolutionChapter } from './solution-chapter.entity';
+
+@Entity('solution_designs')
+export class SolutionDesign {
+  @PrimaryGeneratedColumn({ unsigned: true, comment: '方案设计ID，主键自增' })
+  id!: number;
+
+  @Column({ name: 'title', type: 'varchar', length: 255, comment: '方案标题' })
+  title!: string;
+
+  @Column({ name: 'description', type: 'text', nullable: true, comment: '方案描述' })
+  description!: string | null;
+
+  @Column({ name: 'requirements', type: 'text', nullable: true, comment: '需求描述' })
+  requirements!: string | null;
+
+  @Column({ name: 'user_id', type: 'int', unsigned: true, comment: '创建用户ID' })
+  userId!: number;
+
+  @ManyToOne(() => User)
+  @JoinColumn({ name: 'user_id', referencedColumnName: 'id' })
+  user!: User;
+
+  @Column({ name: 'original_file_id', type: 'int', unsigned: true, nullable: true, comment: '原始文件ID' })
+  originalFileId!: number | null;
+
+  @ManyToOne(() => File)
+  @JoinColumn({ name: 'original_file_id', referencedColumnName: 'id' })
+  originalFile!: File | null;
+
+  @Column({ name: 'output_file_id', type: 'int', unsigned: true, nullable: true, comment: '输出文件ID' })
+  outputFileId!: number | null;
+
+  @ManyToOne(() => File)
+  @JoinColumn({ name: 'output_file_id', referencedColumnName: 'id' })
+  outputFile!: File | null;
+
+  @Column({ name: 'output_format', type: 'varchar', length: 10, default: 'docx', comment: '输出格式：docx/pdf' })
+  outputFormat!: string;
+
+  @Column({ name: 'status', type: 'varchar', length: 20, default: 'draft', comment: '状态：draft-草稿, reviewing-审核中, completed-已完成' })
+  status!: string;
+
+  @Column({ name: 'progress', type: 'int', default: 0, comment: '完成进度百分比' })
+  progress!: number;
+
+  @Column({ name: 'total_chapters', type: 'int', default: 0, comment: '总章节数' })
+  totalChapters!: number;
+
+  @Column({ name: 'completed_chapters', type: 'int', default: 0, comment: '已完成章节数' })
+  completedChapters!: number;
+
+  @Column({ name: 'is_deleted', type: 'tinyint', default: 0, comment: '是否删除：0-未删除，1-已删除' })
+  isDeleted!: number;
+
+  @CreateDateColumn({ name: 'created_at', comment: '创建时间' })
+  createdAt!: Date;
+
+  @UpdateDateColumn({ name: 'updated_at', comment: '更新时间' })
+  updatedAt!: Date;
+
+  @OneToMany(() => SolutionChapter, chapter => chapter.solutionDesign)
+  chapters!: SolutionChapter[];
+}

src/server/modules/solution-designs/solution-design.schema.ts

@@ -0,0 +1,207 @@
+import { z } from '@hono/zod-openapi';
+import { FileSchema } from '@/server/modules/files/file.schema';
+import { UserSchema } from '@/server/modules/users/user.schema';
+import { DeleteStatus } from '@/share/types';
+
+// 章节Schema
+export const SolutionChapterSchema = z.object({
+  id: z.number().int('必须是整数').positive('必须是正整数').openapi({
+    description: '章节ID',
+    example: 1
+  }),
+  chapterNumber: z.number().int('必须是整数').positive('必须是正整数').openapi({
+    description: '章节编号',
+    example: 1
+  }),
+  title: z.string().min(1, '章节标题不能为空').max(255, '章节标题最多255个字符').openapi({
+    description: '章节标题',
+    example: '项目概述'
+  }),
+  content: z.string().nullable().openapi({
+    description: '章节内容',
+    example: '本章节描述项目的基本情况和背景...'
+  }),
+  originalContent: z.string().nullable().openapi({
+    description: '原始内容',
+    example: '原始的项目概述内容...'
+  }),
+  modificationInstructions: z.string().nullable().openapi({
+    description: '修改说明',
+    example: '需要增加项目目标和预期成果的描述'
+  }),
+  file: FileSchema.nullable().openapi({
+    description: '章节文件信息'
+  }),
+  status: z.string().openapi({
+    description: '状态：pending-待处理, reviewing-审核中, completed-已完成',
+    example: 'completed'
+  }),
+  aiSuggestions: z.string().nullable().openapi({
+    description: 'AI修改建议',
+    example: '建议增加具体的数据支持和案例说明'
+  }),
+  version: z.number().int('必须是整数').positive('必须是正整数').openapi({
+    description: '版本号',
+    example: 2
+  }),
+  createdAt: z.coerce.date<Date>('创建时间格式不正确').openapi({
+    description: '创建时间',
+    example: '2024-01-15T10:30:00Z'
+  }),
+  updatedAt: z.coerce.date<Date>('更新时间格式不正确').openapi({
+    description: '更新时间',
+    example: '2024-01-16T14:20:00Z'
+  })
+});
+
+// 方案设计完整Schema
+export const SolutionDesignSchema = z.object({
+  id: z.number().int('必须是整数').positive('必须是正整数').openapi({
+    description: '方案设计ID',
+    example: 1
+  }),
+  title: z.string().min(1, '方案标题不能为空').max(255, '方案标题最多255个字符').openapi({
+    description: '方案标题',
+    example: '智慧城市建设项目方案'
+  }),
+  description: z.string().nullable().openapi({
+    description: '方案描述',
+    example: '针对智慧城市建设的完整解决方案'
+  }),
+  requirements: z.string().nullable().openapi({
+    description: '需求描述',
+    example: '需要包含物联网设备部署、数据分析平台和用户界面设计'
+  }),
+  user: UserSchema.openapi({
+    description: '创建用户信息'
+  }),
+  originalFile: FileSchema.nullable().openapi({
+    description: '原始文件信息'
+  }),
+  outputFile: FileSchema.nullable().openapi({
+    description: '输出文件信息'
+  }),
+  outputFormat: z.string().openapi({
+    description: '输出格式：docx/pdf',
+    example: 'docx'
+  }),
+  status: z.string().openapi({
+    description: '状态：draft-草稿, reviewing-审核中, completed-已完成',
+    example: 'completed'
+  }),
+  progress: z.number().int('必须是整数').min(0, '进度不能为负数').max(100, '进度不能超过100').openapi({
+    description: '完成进度百分比',
+    example: 85
+  }),
+  totalChapters: z.number().int('必须是整数').min(0, '章节数不能为负数').openapi({
+    description: '总章节数',
+    example: 8
+  }),
+  completedChapters: z.number().int('必须是整数').min(0, '完成章节数不能为负数').openapi({
+    description: '已完成章节数',
+    example: 7
+  }),
+  chapters: z.array(SolutionChapterSchema).openapi({
+    description: '章节列表'
+  }),
+  isDeleted: z.number().int('必须是整数').min(0, '状态值只能是0或1').max(1, '状态值只能是0或1').default(DeleteStatus.NOT_DELETED).openapi({
+    description: '是否删除：0-未删除，1-已删除',
+    example: DeleteStatus.NOT_DELETED
+  }),
+  createdAt: z.coerce.date<Date>('创建时间格式不正确').openapi({
+    description: '创建时间',
+    example: '2024-01-15T10:30:00Z'
+  }),
+  updatedAt: z.coerce.date<Date>('更新时间格式不正确').openapi({
+    description: '更新时间',
+    example: '2024-01-16T14:20:00Z'
+  })
+});
+
+// 创建方案设计请求Schema
+export const CreateSolutionDesignDto = z.object({
+  title: z.string().min(1, '方案标题不能为空').max(255, '方案标题最多255个字符').openapi({
+    description: '方案标题',
+    example: '智慧城市建设项目方案'
+  }),
+  description: z.string().nullable().optional().openapi({
+    description: '方案描述',
+    example: '针对智慧城市建设的完整解决方案'
+  }),
+  requirements: z.string().nullable().optional().openapi({
+    description: '需求描述',
+    example: '需要包含物联网设备部署、数据分析平台和用户界面设计'
+  }),
+  originalFileId: z.coerce.number<number>().int('必须是整数').positive('必须是正整数').optional().openapi({
+    description: '原始文件ID',
+    example: 1
+  }),
+  outputFormat: z.string().default('docx').openapi({
+    description: '输出格式：docx/pdf',
+    example: 'docx'
+  })
+});
+
+// 更新方案设计请求Schema
+export const UpdateSolutionDesignDto = z.object({
+  title: z.string().min(1, '方案标题不能为空').max(255, '方案标题最多255个字符').optional().openapi({
+    description: '方案标题',
+    example: '智慧城市建设项目方案（更新版）'
+  }),
+  description: z.string().nullable().optional().openapi({
+    description: '方案描述',
+    example: '针对智慧城市建设的完整解决方案（修订版）'
+  }),
+  requirements: z.string().nullable().optional().openapi({
+    description: '需求描述',
+    example: '需要包含物联网设备部署、数据分析平台和用户界面设计'
+  }),
+  outputFormat: z.string().optional().openapi({
+    description: '输出格式：docx/pdf',
+    example: 'pdf'
+  }),
+  status: z.string().optional().openapi({
+    description: '状态：draft-草稿, reviewing-审核中, completed-已完成',
+    example: 'completed'
+  })
+});
+
+// 创建章节请求Schema
+export const CreateSolutionChapterDto = z.object({
+  chapterNumber: z.coerce.number<number>().int('必须是整数').positive('必须是正整数').openapi({
+    description: '章节编号',
+    example: 1
+  }),
+  title: z.string().min(1, '章节标题不能为空').max(255, '章节标题最多255个字符').openapi({
+    description: '章节标题',
+    example: '项目概述'
+  }),
+  content: z.string().nullable().optional().openapi({
+    description: '章节内容',
+    example: '本章节描述项目的基本情况和背景...'
+  }),
+  modificationInstructions: z.string().nullable().optional().openapi({
+    description: '修改说明',
+    example: '需要增加项目目标和预期成果的描述'
+  })
+});
+
+// 更新章节请求Schema
+export const UpdateSolutionChapterDto = z.object({
+  title: z.string().min(1, '章节标题不能为空').max(255, '章节标题最多255个字符').optional().openapi({
+    description: '章节标题',
+    example: '项目概述（更新）'
+  }),
+  content: z.string().nullable().optional().openapi({
+    description: '章节内容',
+    example: '更新后的项目概述内容...'
+  }),
+  modificationInstructions: z.string().nullable().optional().openapi({
+    description: '修改说明',
+    example: '已增加项目目标和预期成果的描述'
+  }),
+  status: z.string().optional().openapi({
+    description: '状态：pending-待处理, reviewing-审核中, completed-已完成',
+    example: 'completed'
+  })
+});

src/server/modules/solution-designs/solution-design.service.ts

@@ -0,0 +1,337 @@
+import { GenericCrudService } from '@/server/utils/generic-crud.service';
+import { DataSource, Repository, In } from 'typeorm';
+import { SolutionDesign } from './solution-design.entity';
+import { SolutionChapter } from './solution-chapter.entity';
+import { DocumentService } from '@/server/modules/documents/document.service';
+import { FileService } from '@/server/modules/files/file.service';
+import { AIService } from '@/server/services/ai.service';
+
+export interface ChapterModificationRequest {
+  chapterId: number;
+  instructions: string;
+  currentContent: string;
+}
+
+export interface AIModificationSuggestion {
+  suggestions: string[];
+  revisedContent: string;
+  confidence: number;
+}
+
+export class SolutionDesignService extends GenericCrudService<SolutionDesign> {
+  private chapterRepository: Repository<SolutionChapter>;
+  private documentService: DocumentService;
+  private fileService: FileService;
+  private aiService: AIService;
+
+  constructor(dataSource: DataSource) {
+    super(dataSource, SolutionDesign);
+    this.chapterRepository = dataSource.getRepository(SolutionChapter);
+    this.documentService = new DocumentService(dataSource);
+    this.fileService = new FileService(dataSource);
+    this.aiService = new AIService();
+  }
+
+  /**
+   * 创建方案设计并初始化章节
+   */
+  async createSolutionDesign(
+    data: any,
+    userId: number,
+    originalFileId?: number
+  ): Promise<SolutionDesign> {
+    const solutionDesign = this.repository.create({
+      ...data,
+      userId,
+      originalFileId: originalFileId || null,
+      status: 'draft',
+      progress: 0,
+      totalChapters: 0,
+      completedChapters: 0
+    });
+
+    const savedDesign = await this.repository.save(solutionDesign);
+
+    // 如果有原始文件，尝试自动提取章节
+    if (originalFileId) {
+      await this.autoExtractChapters(savedDesign.id, originalFileId);
+    }
+
+    return this.getById(savedDesign.id, ['user', 'originalFile', 'chapters']);
+  }
+
+  /**
+   * 自动从原始文件提取章节
+   */
+  private async autoExtractChapters(designId: number, fileId: number): Promise<void> {
+    try {
+      const file = await this.fileService.getById(fileId);
+      if (!file) return;
+
+      // 这里可以集成文档解析逻辑，自动识别章节结构
+      // 暂时创建默认章节
+      const defaultChapters = [
+        { chapterNumber: 1, title: '项目概述', content: '请填写项目概述内容' },
+        { chapterNumber: 2, title: '需求分析', content: '请填写需求分析内容' },
+        { chapterNumber: 3, title: '技术方案', content: '请填写技术方案内容' },
+        { chapterNumber: 4, title: '实施计划', content: '请填写实施计划内容' },
+        { chapterNumber: 5, title: '预算估算', content: '请填写预算估算内容' }
+      ];
+
+      for (const chapterData of defaultChapters) {
+        const chapter = this.chapterRepository.create({
+          ...chapterData,
+          solutionDesignId: designId,
+          originalContent: chapterData.content,
+          status: 'pending'
+        });
+        await this.chapterRepository.save(chapter);
+      }
+
+      // 更新总章节数
+      await this.repository.update(designId, {
+        totalChapters: defaultChapters.length
+      });
+
+    } catch (error) {
+      console.error('自动提取章节失败:', error);
+    }
+  }
+
+  /**
+   * 获取用户的方案设计列表
+   */
+  async getUserSolutionDesigns(
+    userId: number,
+    page: number = 1,
+    pageSize: number = 10,
+    status?: string
+  ): Promise<[SolutionDesign[], number]> {
+    const where: any = {
+      userId,
+      isDeleted: 0
+    };
+
+    if (status) {
+      where.status = status;
+    }
+
+    return this.getList(
+      page,
+      pageSize,
+      undefined,
+      ['title', 'description'],
+      where,
+      ['user', 'originalFile'],
+      { updatedAt: 'DESC' }
+    );
+  }
+
+  /**
+   * 添加章节到方案设计
+   */
+  async addChapter(
+    designId: number,
+    data: any
+  ): Promise<SolutionChapter> {
+    const design = await this.getById(designId);
+    if (!design) {
+      throw new Error('方案设计不存在');
+    }
+
+    const chapter = this.chapterRepository.create({
+      ...data,
+      solutionDesignId: designId,
+      status: 'pending',
+      version: 1
+    });
+
+    const savedChapter = await this.chapterRepository.save(chapter);
+
+    // 更新总章节数
+    await this.repository.increment({ id: designId }, 'totalChapters', 1);
+
+    return savedChapter;
+  }
+
+  /**
+   * 获取方案设计的所有章节
+   */
+  async getChapters(designId: number): Promise<SolutionChapter[]> {
+    return this.chapterRepository.find({
+      where: {
+        solutionDesignId: designId,
+        isDeleted: 0
+      },
+      order: { chapterNumber: 'ASC' }
+    });
+  }
+
+  /**
+   * 更新章节内容
+   */
+  async updateChapter(
+    chapterId: number,
+    data: any
+  ): Promise<SolutionChapter> {
+    const chapter = await this.chapterRepository.findOne({
+      where: { id: chapterId, isDeleted: 0 }
+    });
+
+    if (!chapter) {
+      throw new Error('章节不存在');
+    }
+
+    // 如果内容有更新，增加版本号
+    if (data.content && data.content !== chapter.content) {
+      data.version = chapter.version + 1;
+    }
+
+    await this.chapterRepository.update(chapterId, data);
+    return this.chapterRepository.findOneBy({ id: chapterId }) as Promise<SolutionChapter>;
+  }
+
+  /**
+   * 请求AI修改建议
+   */
+  async getAIModificationSuggestions(
+    request: ChapterModificationRequest
+  ): Promise<AIModificationSuggestion> {
+    const prompt = `
+      请对以下章节内容提供修改建议：
+      
+      原始内容：${request.currentContent}
+      
+      修改要求：${request.instructions}
+      
+      请提供：
+      1. 具体的修改建议列表
+      2. 修改后的完整内容
+      3. 修改的置信度评分（0-1）
+      
+      请以JSON格式返回，包含suggestions、revisedContent、confidence字段。
+    `;
+
+    try {
+      const response = await this.aiService.generateText(prompt);
+      return JSON.parse(response);
+    } catch (error) {
+      console.error('AI修改建议生成失败:', error);
+      throw new Error('AI服务暂时不可用');
+    }
+  }
+
+  /**
+   * 应用AI修改建议
+   */
+  async applyAIModifications(
+    chapterId: number,
+    suggestions: AIModificationSuggestion
+  ): Promise<SolutionChapter> {
+    const chapter = await this.chapterRepository.findOne({
+      where: { id: chapterId, isDeleted: 0 }
+    });
+
+    if (!chapter) {
+      throw new Error('章节不存在');
+    }
+
+    const updateData = {
+      content: suggestions.revisedContent,
+      aiSuggestions: JSON.stringify(suggestions.suggestions),
+      version: chapter.version + 1,
+      status: 'reviewing'
+    };
+
+    await this.chapterRepository.update(chapterId, updateData);
+    return this.chapterRepository.findOneBy({ id: chapterId }) as Promise<SolutionChapter>;
+  }
+
+  /**
+   * 更新方案设计进度
+   */
+  async updateProgress(designId: number): Promise<void> {
+    const completedCount = await this.chapterRepository.count({
+      where: {
+        solutionDesignId: designId,
+        status: 'completed',
+        isDeleted: 0
+      }
+    });
+
+    const totalCount = await this.chapterRepository.count({
+      where: {
+        solutionDesignId: designId,
+        isDeleted: 0
+      }
+    });
+
+    const progress = totalCount > 0 ? Math.round((completedCount / totalCount) * 100) : 0;
+
+    await this.repository.update(designId, {
+      completedChapters: completedCount,
+      totalChapters: totalCount,
+      progress,
+      status: progress === 100 ? 'completed' : 'reviewing'
+    });
+  }
+
+  /**
+   * 生成最终文档
+   */
+  async generateFinalDocument(designId: number): Promise<Buffer> {
+    const design = await this.getById(designId, ['chapters']);
+    if (!design) {
+      throw new Error('方案设计不存在');
+    }
+
+    if (design.progress < 100) {
+      throw new Error('请先完成所有章节的修改');
+    }
+
+    // 按章节顺序组织内容
+    const sortedChapters = design.chapters.sort((a, b) => a.chapterNumber - b.chapterNumber);
+    const documentContent = sortedChapters
+      .map(chapter => `# ${chapter.title}\n\n${chapter.content}`)
+      .join('\n\n');
+
+    // 使用文档服务生成最终文档
+    const buffer = Buffer.from(documentContent, 'utf-8');
+    
+    if (design.outputFormat === 'pdf') {
+      return this.documentService.convertWordToPdf(buffer, `solution_${designId}`);
+    }
+
+    return buffer;
+  }
+
+  /**
+   * 保存最终文档到文件系统
+   */
+  async saveFinalDocument(designId: number, buffer: Buffer): Promise<string> {
+    const design = await this.getById(designId);
+    if (!design) {
+      throw new Error('方案设计不存在');
+    }
+
+    const fileName = `solution_${designId}_${Date.now()}.${design.outputFormat}`;
+    const downloadUrl = await this.documentService.saveToMinio(buffer, fileName);
+
+    // 创建文件记录
+    const file = await this.fileService.createFile({
+      originalName: fileName,
+      size: buffer.length,
+      mimeType: design.outputFormat === 'pdf' ? 'application/pdf' : 
+               'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+      storagePath: downloadUrl
+    });
+
+    // 更新方案设计的输出文件
+    await this.repository.update(designId, {
+      outputFileId: file.id,
+      status: 'completed'
+    });
+
+    return downloadUrl;
+  }
+}

src/server/services/ai.service.ts

@@ -0,0 +1,214 @@
+import { OpenAIApi, Configuration } from 'openai';
+import * as dotenv from 'dotenv';
+
+dotenv.config();
+
+export interface AIGenerationOptions {
+  model?: string;
+  temperature?: number;
+  maxTokens?: number;
+}
+
+export class AIService {
+  private openai: OpenAIApi | null = null;
+
+  constructor() {
+    this.initializeOpenAI();
+  }
+
+  private initializeOpenAI() {
+    const apiKey = process.env.OPENAI_API_KEY;
+    if (!apiKey) {
+      console.warn('OPENAI_API_KEY not found, AI features will be disabled');
+      return;
+    }
+
+    try {
+      const configuration = new Configuration({
+        apiKey: apiKey,
+      });
+      this.openai = new OpenAIApi(configuration);
+      console.log('OpenAI service initialized successfully');
+    } catch (error) {
+      console.error('Failed to initialize OpenAI service:', error);
+    }
+  }
+
+  /**
+   * 生成文本内容
+   */
+  async generateText(
+    prompt: string,
+    options: AIGenerationOptions = {}
+  ): Promise<string> {
+    if (!this.openai) {
+      throw new Error('AI service is not available. Please configure OPENAI_API_KEY.');
+    }
+
+    const {
+      model = 'gpt-3.5-turbo',
+      temperature = 0.7,
+      maxTokens = 2000
+    } = options;
+
+    try {
+      const response = await this.openai.createChatCompletion({
+        model,
+        messages: [
+          {
+            role: 'system',
+            content: '你是一个专业的文档编辑助手，擅长方案设计和文档修改。请提供专业、准确的建议。'
+          },
+          {
+            role: 'user',
+            content: prompt
+          }
+        ],
+        temperature,
+        max_tokens: maxTokens,
+      });
+
+      const result = response.data.choices[0]?.message?.content;
+      if (!result) {
+        throw new Error('No response from AI service');
+      }
+
+      return result;
+    } catch (error) {
+      console.error('AI text generation failed:', error);
+      throw new Error(`AI服务调用失败: ${error.message}`);
+    }
+  }
+
+  /**
+   * 获取文档修改建议
+   */
+  async getDocumentModificationSuggestions(
+    content: string,
+    instructions: string
+  ): Promise<{
+    suggestions: string[];
+    revisedContent: string;
+    confidence: number;
+  }> {
+    const prompt = `
+      请对以下文档内容提供专业的修改建议：
+
+      原始内容：
+      ${content}
+
+      修改要求：
+      ${instructions}
+
+      请提供：
+      1. 3-5条具体的修改建议
+      2. 修改后的完整内容
+      3. 修改的置信度评分（0-1之间）
+
+      请以JSON格式返回，格式如下：
+      {
+        "suggestions": ["建议1", "建议2", "建议3"],
+        "revisedContent": "修改后的完整内容",
+        "confidence": 0.85
+      }
+    `;
+
+    const response = await this.generateText(prompt, {
+      temperature: 0.3, // 更低的温度以获得更确定的输出
+      maxTokens: 3000
+    });
+
+    try {
+      // 尝试解析JSON响应
+      const result = JSON.parse(response);
+      return {
+        suggestions: result.suggestions || [],
+        revisedContent: result.revisedContent || content,
+        confidence: result.confidence || 0.7
+      };
+    } catch (error) {
+      // 如果JSON解析失败，返回默认格式
+      console.warn('AI response is not valid JSON, using fallback:', response);
+      return {
+        suggestions: ['AI建议：请根据要求完善内容'],
+        revisedContent: content,
+        confidence: 0.5
+      };
+    }
+  }
+
+  /**
+   * 生成章节大纲
+   */
+  async generateChapterOutline(
+    requirements: string,
+    chapterCount: number = 5
+  ): Promise<string[]> {
+    const prompt = `
+      根据以下需求描述，生成一个包含${chapterCount}个章节的方案设计大纲：
+
+      需求：${requirements}
+
+      请返回一个章节标题数组，格式为：
+      ["章节1标题", "章节2标题", "章节3标题", ...]
+    `;
+
+    const response = await this.generateText(prompt);
+
+    try {
+      // 尝试解析为数组
+      const outline = JSON.parse(response);
+      if (Array.isArray(outline)) {
+        return outline;
+      }
+    } catch (error) {
+      // 如果解析失败，使用简单分割
+      console.warn('Failed to parse chapter outline, using fallback');
+    }
+
+    // 备用方案：返回默认章节结构
+    return [
+      '项目概述',
+      '需求分析', 
+      '技术方案',
+      '实施计划',
+      '预算估算'
+    ].slice(0, chapterCount);
+  }
+
+  /**
+   * 检查AI服务是否可用
+   */
+  isAvailable(): boolean {
+    return this.openai !== null;
+  }
+
+  /**
+   * 模拟AI响应（用于测试或回退）
+   */
+  private getMockAIResponse(prompt: string): string {
+    if (prompt.includes('修改建议')) {
+      return JSON.stringify({
+        suggestions: [
+          '建议增加具体的数据支持',
+          '优化段落结构，使其更清晰',
+          '补充相关案例说明'
+        ],
+        revisedContent: '这是根据要求修改后的内容...',
+        confidence: 0.8
+      });
+    }
+
+    if (prompt.includes('大纲')) {
+      return JSON.stringify([
+        '项目概述',
+        '需求分析',
+        '技术方案',
+        '实施计划',
+        '预算估算'
+      ]);
+    }
+
+    return 'AI服务响应（模拟模式）';
+  }
+}

test-merge.js

@@ -0,0 +1,41 @@
+// 简单的测试脚本来验证docxtemplater合并功能
+import { DocumentService } from './src/server/modules/documents/document.service.js';
+import { DataSource } from 'typeorm';
+
+// 创建模拟的DataSource
+const mockDataSource = {};
+
+async function testMerge() {
+  console.log('Testing docxtemplater merge functionality...');
+  
+  const documentService = new DocumentService(mockDataSource);
+  
+  // 创建一些模拟的Word文档缓冲区
+  const mockDoc1 = Buffer.from('Mock Word Document 1');
+  const mockDoc2 = Buffer.from('Mock Word Document 2');
+  
+  try {
+    console.log('Testing mergeWordDocuments method...');
+    
+    const result = await documentService.mergeWordDocuments(
+      [mockDoc1, mockDoc2],
+      {
+        preserveFormatting: true,
+        outputFormat: 'docx'
+      }
+    );
+    
+    console.log('✅ Merge successful!');
+    console.log(`Result buffer size: ${result.length} bytes`);
+    console.log(`MinIO available: ${documentService.isMinioAvailable()}`);
+    
+    // 测试保存到MinIO（回退到base64）
+    const downloadUrl = await documentService.saveToMinio(result, 'test.docx');
+    console.log(`Download URL: ${downloadUrl.substring(0, 100)}...`);
+    
+  } catch (error) {
+    console.error('❌ Merge failed:', error.message);
+  }
+}
+
+testMerge().catch(console.error);