llm-content-creator 0.1.0

package/src/config/index.ts

@@ -0,0 +1,352 @@
+/**
+ * 配置系统
+ *
+ * 提供类型安全的配置访问，使用 Zod 进行环境变量验证
+ */
+
+import { config as dotenvConfig } from 'dotenv';
+import { z } from 'zod';
+
+// 加载环境变量（如果在非测试环境）
+if (process.env.NODE_ENV !== 'test') {
+  dotenvConfig();
+}
+
+/**
+ * 环境变量 Schema
+ * 使用 Zod 进行运行时验证和类型推导
+ */
+const envSchema = z.object({
+  // Node 环境
+  NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),
+
+  // 数据库类型（根据环境自动选择默认值）
+  DATABASE_TYPE: z.enum(['memory', 'postgres', 'sqlite']).optional(),
+
+  // PostgreSQL 配置（仅在 DATABASE_TYPE='postgres' 时必需）
+  POSTGRES_HOST: z.string().min(1).optional(),
+  POSTGRES_PORT: z.coerce.number().int().positive().default(5432).optional(),
+  POSTGRES_USER: z.string().min(1).optional(),
+  POSTGRES_PASSWORD: z.string().min(1).optional(),
+  POSTGRES_DB: z.string().min(1).optional(),
+  POSTGRES_SSL: z.coerce.boolean().default(false).optional(),
+
+  // Redis 配置（可选，仅在使用队列/缓存/限流时需要）
+  REDIS_URL: z.string().url().optional(),
+  REDIS_PASSWORD: z.string().optional(),
+  REDIS_DB: z.coerce.number().int().nonnegative().default(0).optional(),
+
+  // LLM 服务配置（DeepSeek）
+  LLM_API_KEY: z.string().min(1),
+  LLM_BASE_URL: z.string().url(),
+  LLM_MODEL_NAME: z.string().default('deepseek-chat'),
+  LLM_MAX_TOKENS: z.coerce.number().int().positive().default(4000),
+  LLM_TEMPERATURE: z.coerce.number().min(0).max(2).default(0.7),
+  LLM_ENABLE_CACHE: z.coerce.boolean().default(true).optional(),
+
+  // Tavily API (MCP Search)
+  TAVILY_API_KEY: z.string().min(1),
+
+  // Doubao API (字节跳动)
+  ARK_API_KEY: z.string().min(1),
+  ARK_API_URL: z.string().url().optional(),
+
+  // 存储配置
+  STORAGE_PROVIDER: z.enum(['local', 's3', 'oss', 'minio']).default('local'),
+  STORAGE_PATH: z.string().default('./data/images'),
+
+  // AWS S3 配置（如果使用 S3）
+  AWS_ACCESS_KEY_ID: z.string().optional(),
+  AWS_SECRET_ACCESS_KEY: z.string().optional(),
+  AWS_REGION: z.string().default('us-east-1'),
+  S3_BUCKET: z.string().optional(),
+
+  // Worker 配置
+  WORKER_ID: z.string().default('worker-1'),
+  WORKER_CONCURRENCY: z.coerce.number().int().positive().default(2),
+
+  // 日志配置
+  LOG_LEVEL: z.enum(['error', 'warn', 'info', 'debug']).default('info'),
+  LOG_FILE: z.string().default('./logs/app.log'),
+
+  // 监控配置（可选）
+  SENTRY_DSN: z.string().url().optional(),
+  SENTRY_ENVIRONMENT: z.string().optional(),
+});
+
+/**
+ * 环境变量类型（从 Schema 推导）
+ */
+export type Env = z.infer<typeof envSchema>;
+
+/**
+ * 配置类
+ * 提供统一的配置访问接口
+ */
+class Config {
+  private env: Env;
+  private databaseType: 'memory' | 'postgres' | 'sqlite';
+
+  constructor() {
+    // 加载并验证环境变量
+    const result = envSchema.safeParse(process.env);
+
+    if (!result.success) {
+      console.error('Environment variable validation failed:');
+      console.error(result.error.issues);
+      throw new Error('Configuration validation failed. Please check your environment variables.');
+    }
+
+    this.env = result.data;
+
+    // 智能默认值：根据环境选择数据库类型
+    this.databaseType = this.env.DATABASE_TYPE ?? this.getDefaultDatabaseType();
+
+    // 验证 PostgreSQL 配置（如果使用 postgres）
+    this.validatePostgresConfig();
+
+    // 输出关键配置信息（脱敏）
+    this.logConfig();
+  }
+
+  /**
+   * 根据环境返回默认数据库类型
+   */
+  private getDefaultDatabaseType(): 'memory' | 'postgres' | 'sqlite' {
+    const nodeEnv = this.env.NODE_ENV;
+
+    switch (nodeEnv) {
+      case 'development':
+        return 'sqlite'; // 开发环境默认使用 SQLite
+      case 'production':
+        return 'postgres'; // 生产环境默认使用 PostgreSQL
+      case 'test':
+        return 'memory'; // 测试环境默认使用内存数据库
+      default:
+        return 'sqlite';
+    }
+  }
+
+  /**
+   * 验证 PostgreSQL 配置（当使用 postgres 时）
+   */
+  validatePostgresConfig(): void {
+    if (this.databaseType === 'postgres') {
+      const requiredFields = [
+        'POSTGRES_HOST',
+        'POSTGRES_USER',
+        'POSTGRES_PASSWORD',
+        'POSTGRES_DB',
+      ] as const;
+
+      const missingFields = requiredFields.filter(
+        (field) => !this.env[field]
+      );
+
+      if (missingFields.length > 0) {
+        throw new Error(
+          `PostgreSQL configuration is required when DATABASE_TYPE='postgres'. ` +
+          `Missing environment variables: ${missingFields.join(', ')}`
+        );
+      }
+    }
+  }
+
+  /**
+   * 输出配置信息（脱敏）
+   */
+  private logConfig(): void {
+    console.log('========================================');
+    console.log('Configuration Loaded Successfully');
+    console.log('========================================');
+    console.log(`Environment: ${this.env.NODE_ENV}`);
+    console.log(`Worker ID: ${this.env.WORKER_ID}`);
+    console.log(`Concurrency: ${this.env.WORKER_CONCURRENCY}`);
+    console.log(`Database Type: ${this.databaseType}`);
+
+    // 仅在使用 PostgreSQL 时显示连接信息
+    if (this.databaseType === 'postgres') {
+      console.log(
+        `PostgreSQL: ${this.env.POSTGRES_HOST}:${this.env.POSTGRES_PORT}/${this.env.POSTGRES_DB}`
+      );
+    } else {
+      console.log('PostgreSQL: Not configured (using ' + this.databaseType + ')');
+    }
+
+    // Redis 配置（可选）
+    if (this.env.REDIS_URL) {
+      console.log(`Redis: ${this.maskUrl(this.env.REDIS_URL)}`);
+    } else {
+      console.log('Redis: Not configured (queue/cache/rate-limit will be disabled)');
+    }
+
+    console.log(`LLM: ${this.env.LLM_MODEL_NAME} @ ${this.env.LLM_BASE_URL}`);
+    console.log(`Storage: ${this.env.STORAGE_PROVIDER}`);
+    console.log('========================================');
+  }
+
+  /**
+   * 脱敏 URL（隐藏密码）
+   */
+  private maskUrl(url: string | undefined): string {
+    if (!url) return 'N/A';
+    return url.replace(/:([^:@]+)@/, ':****@');
+  }
+
+  // ========== 通用配置 ==========
+
+  get isDevelopment(): boolean {
+    return this.env.NODE_ENV === 'development';
+  }
+
+  get isProduction(): boolean {
+    return this.env.NODE_ENV === 'production';
+  }
+
+  get isTest(): boolean {
+    return this.env.NODE_ENV === 'test';
+  }
+
+  // ========== PostgreSQL 配置 ==========
+
+  get database() {
+    return {
+      type: this.databaseType,
+      // PostgreSQL 配置（仅在 type='postgres' 时有效）
+      host: this.env.POSTGRES_HOST,
+      port: this.env.POSTGRES_PORT ?? 5432,
+      user: this.env.POSTGRES_USER,
+      password: this.env.POSTGRES_PASSWORD,
+      database: this.env.POSTGRES_DB,
+      ssl: this.env.POSTGRES_SSL ?? false,
+      // 连接池配置
+      poolMax: 25, // 最大连接数
+      poolMin: 2, // 最小连接数
+      idleTimeoutMillis: 30000, // 空闲连接超时
+      connectionTimeoutMillis: 5000, // 连接超时
+    };
+  }
+
+  // 别名：postgres（向后兼容）
+  get postgres() {
+    return {
+      host: this.env.POSTGRES_HOST,
+      port: this.env.POSTGRES_PORT ?? 5432,
+      user: this.env.POSTGRES_USER,
+      password: this.env.POSTGRES_PASSWORD,
+      database: this.env.POSTGRES_DB,
+      ssl: this.env.POSTGRES_SSL ?? false,
+    };
+  }
+
+  // ========== Redis 配置 ==========
+
+  get redis() {
+    return {
+      enabled: !!this.env.REDIS_URL,
+      url: this.env.REDIS_URL,
+      password: this.env.REDIS_PASSWORD,
+      db: this.env.REDIS_DB ?? 0,
+      // 连接池配置
+      maxRetriesPerRequest: 3,
+      retryStrategy: (times: number) => {
+        const delay = Math.min(times * 50, 2000);
+        return delay;
+      },
+      // 连接超时
+      connectTimeout: 10000,
+      // 命令超时
+      commandTimeout: 5000,
+    };
+  }
+
+  // ========== LLM 服务配置 ==========
+
+  get llm() {
+    return {
+      apiKey: this.env.LLM_API_KEY,
+      baseURL: this.env.LLM_BASE_URL,
+      modelName: this.env.LLM_MODEL_NAME,
+      maxTokens: this.env.LLM_MAX_TOKENS,
+      temperature: this.env.LLM_TEMPERATURE,
+      enableCache: this.env.LLM_ENABLE_CACHE ?? true,
+    };
+  }
+
+  // ========== Tavily API 配置 ==========
+
+  get tavily() {
+    return {
+      apiKey: this.env.TAVILY_API_KEY,
+    };
+  }
+
+  // ========== Doubao API 配置 ==========
+
+  get doubao() {
+    return {
+      apiKey: this.env.ARK_API_KEY,
+      apiURL: this.env.ARK_API_URL,
+    };
+  }
+
+  // ========== 存储配置 ==========
+
+  get storage() {
+    return {
+      provider: this.env.STORAGE_PROVIDER,
+      path: this.env.STORAGE_PATH,
+      // S3 配置
+      s3: this.env.STORAGE_PROVIDER === 's3' ? {
+        accessKeyId: this.env.AWS_ACCESS_KEY_ID!,
+        secretAccessKey: this.env.AWS_SECRET_ACCESS_KEY!,
+        region: this.env.AWS_REGION,
+        bucket: this.env.S3_BUCKET!,
+      } : null,
+    };
+  }
+
+  // ========== Worker 配置 ==========
+
+  get worker() {
+    return {
+      id: this.env.WORKER_ID,
+      concurrency: this.env.WORKER_CONCURRENCY,
+    };
+  }
+
+  // ========== 日志配置 ==========
+
+  get logging() {
+    return {
+      level: this.env.LOG_LEVEL,
+      file: this.env.LOG_FILE,
+      // 开发环境使用彩色输出
+      colorize: this.isDevelopment,
+      // 生产环境使用 JSON 格式
+      json: this.isProduction,
+    };
+  }
+
+  // ========== 监控配置 ==========
+
+  get monitoring() {
+    return {
+      sentry: this.env.SENTRY_DSN ? {
+        dsn: this.env.SENTRY_DSN,
+        environment: this.env.SENTRY_ENVIRONMENT || this.env.NODE_ENV,
+      } : null,
+    };
+  }
+}
+
+// ========== 导出单例 ==========
+
+/**
+ * 配置单例
+ * 整个应用共享同一个配置实例
+ */
+export const config = new Config();
+
+// 冻结配置对象，防止运行时修改
+Object.freeze(config);

package/src/domain/entities/QualityCheck.ts

@@ -0,0 +1,202 @@
+/**
+ * QualityCheck 领域模型
+ *
+ * 表示质量检查记录
+ */
+
+/**
+ * 检查类型
+ */
+export enum CheckType {
+  HARD_RULE = 'hard_rule',       // 硬规则检查
+  LLM = 'llm',                   // LLM 检查
+  TEXT = 'text',                 // 文本质检
+  IMAGE = 'image',               // 图片质检
+}
+
+/**
+ * 检查类别
+ */
+export enum CheckCategory {
+  // 文本检查类别
+  TEXT_LENGTH = 'text_length',           // 文本长度
+  TEXT_FORMAT = 'text_format',           // 文本格式
+  SPELLING = 'spelling',                 // 拼写检查
+  GRAMMAR = 'grammar',                   // 语法检查
+  STYLE = 'style',                       // 风格检查
+  PLAGIARISM = 'plagiarism',             // 原创性检查
+
+  // 图片检查类别
+  IMAGE_SIZE = 'image_size',             // 图片尺寸
+  IMAGE_FORMAT = 'image_format',         // 图片格式
+  IMAGE_QUALITY = 'image_quality',       // 图片质量
+  CONTENT_SAFETY = 'content_safety',     // 内容安全
+
+  // 内容检查类别
+  RELEVANCE = 'relevance',               // 相关性
+  COMPLETENESS = 'completeness',         // 完整性
+  ENGAGEMENT = 'engagement',             // 吸引力
+  BRAND_SAFETY = 'brand_safety',         // 品牌安全
+}
+
+/**
+ * 质量检查实体
+ */
+export interface QualityCheck {
+  // 基础字段
+  id: number;                    // 自增 ID
+  taskId: string;                // 所属任务 ID
+  checkType: CheckType;          // 检查类型 (text/image)
+
+  // 评分
+  score: number;                 // 1-10 分
+  passed: boolean;               // 是否通过
+  hardConstraintsPassed: boolean; // 硬性约束是否通过
+
+  // 详情
+  details: QualityCheckDetails;  // 检查详情
+
+  // 改进建议（用于重写/重生成）
+  fixSuggestions?: string[];     // 改进建议
+
+  // 元数据
+  rubricVersion?: string;        // 评分标准版本
+  modelName?: string;            // 使用的模型
+  promptHash?: string;           // Prompt hash
+
+  // 时间戳
+  checkedAt: Date;               // 检查时间
+
+  // 兼容旧接口（可选）
+  resultId?: string;             // 关联的结果 ID（可选）
+  category?: CheckCategory;      // 检查类别（可选）
+  reason?: string;               // 原因说明（可选）
+  createdAt?: Date;              // 创建时间（可选）
+}
+
+/**
+ * 检查详情
+ */
+export interface QualityCheckDetails {
+  // 硬规则检查结果
+  hardRules?: {
+    wordCount?: { passed: boolean; wordCount: number };
+    keywords?: { passed: boolean; found: string[] };
+    structure?: { passed: boolean; checks: object };
+  };
+
+  // 软评分（LLM）
+  softScores?: {
+    relevance?: { score: number; reason: string };
+    coherence?: { score: number; reason: string };
+    completeness?: { score: number; reason: string };
+    readability?: { score: number; reason: string };
+  };
+
+  // 文本质检
+  wordCount?: number;            // 字数统计
+  keywordsFound?: string[];      // 找到的关键词
+  structureCheck?: {
+    hasTitle: boolean;
+    hasIntro: boolean;
+    hasBody: boolean;
+    hasConclusion: boolean;
+  };
+
+  // 配图质检
+  relevanceScore?: number;       // 相关性评分
+  aestheticScore?: number;       // 美学评分
+  promptMatch?: number;          // 提示词匹配度
+
+  // 其他详情（兼容旧接口）
+  rule?: {
+    name: string;
+    threshold?: any;
+    actual?: any;
+    expected?: any;
+  };
+  llm?: {
+    prompt: string;
+    response: string;
+    reasoning?: string;
+    criteria: string[];
+  };
+  issues?: CheckIssue[];
+
+  // 扩展字段
+  [key: string]: any;
+}
+
+/**
+ * 兼容旧接口的 CheckDetails 类型别名
+ */
+export interface CheckDetails extends QualityCheckDetails {}
+
+/**
+ * 检查问题
+ */
+export interface CheckIssue {
+  severity: 'error' | 'warning' | 'info'; // 严重程度
+  message: string;               // 问题描述
+  location?: string;             // 位置（可选）
+  suggestion?: string;           // 建议修改（可选）
+}
+
+/**
+ * 创建硬规则检查参数
+ */
+export interface CreateHardRuleCheckParams {
+  taskId: string;
+  resultId?: string;
+  category: CheckCategory;
+  rule: {
+    name: string;
+    threshold?: any;
+    expected?: any;
+  };
+  actual: any;
+}
+
+/**
+ * 创建 LLM 检查参数
+ */
+export interface CreateLLMCheckParams {
+  taskId: string;
+  resultId?: string;
+  category: CheckCategory;
+  content: string;
+  criteria: string[];
+  prompt?: string;
+}
+
+/**
+ * 检查结果
+ */
+export interface CheckResult {
+  passed: boolean;
+  score?: number;
+  reason?: string;
+  details?: CheckDetails;
+}
+
+/**
+ * 质量阈值配置
+ */
+export interface QualityThresholds {
+  // 文本质量阈值
+  minLength?: number;            // 最小长度
+  maxLength?: number;            // 最大长度
+  minScore?: number;             // 最低质量分
+
+  // 图片质量阈值
+  minWidth?: number;             // 最小宽度
+  minHeight?: number;            // 最小高度
+  maxWidth?: number;             // 最大宽度
+  maxHeight?: number;            // 最大高度
+  maxSize?: number;              // 最大文件大小（字节）
+
+  // 质量评分阈值
+  passScore?: number;            // 及格分
+  goodScore?: number;            // 良好分
+  excellentScore?: number;       // 优秀分
+}

package/src/domain/entities/Result.ts

@@ -0,0 +1,130 @@
+/**
+ * Result 领域模型
+ *
+ * 表示任务的生成结果（文本或图片）
+ */
+
+/**
+ * 结果类型
+ */
+export enum ResultType {
+  TEXT = 'text',                 // 文本结果
+  IMAGE = 'image',               // 图片结果
+  ARTICLE = 'article',           // 文章结果（别名）
+}
+
+/**
+ * 结果实体
+ */
+export interface Result {
+  // 基础字段
+  id: number;                    // 自增 ID
+  taskId: string;                // 所属任务 ID
+  resultType: ResultType;        // 结果类型
+
+  // 内容
+  content?: string;              // 文本内容 (Markdown)
+  filePath?: string;             // 文件路径
+
+  // 元数据
+  metadata: ResultMetadata;      // 元数据（JSON）
+
+  // 质量信息（兼容旧接口）
+  qualityScore?: number;         // 质量评分（0-100，可选）
+  qualityChecks?: string[];      // 质量检查 ID 列表（可选）
+
+  // 时间戳
+  createdAt: Date;               // 创建时间
+}
+
+/**
+ * 结果元数据
+ */
+export interface ResultMetadata {
+  // 文章元数据
+  wordCount?: number;            // 字数
+  title?: string;                // 标题
+  keywords?: string[];           // 关键词
+
+  // 配图元数据
+  prompt?: string;               // 生成提示词
+  url?: string;                  // 图片 URL
+  width?: number;                // 图片宽度
+  height?: number;               // 图片高度
+
+  // Token 元数据
+  tokenCount?: number;           // Token 数量
+  characterCount?: number;       // 字符数
+
+  // 生成信息
+  model?: string;                // 使用的模型
+  parameters?: any;              // 生成参数
+
+  // 来源引用
+  sources?: Array<{
+    url: string;
+    title: string;
+    snippet: string;
+  }>;
+
+  // 其他元数据
+  [key: string]: any;
+}
+
+/**
+ * 文本结果元数据
+ */
+export interface TextResultMetadata extends ResultMetadata {
+  tokenCount: number;
+  wordCount: number;
+  characterCount: number;
+  model: string;
+  prompt?: string;
+}
+
+/**
+ * 图片结果元数据
+ */
+export interface ImageResultMetadata extends ResultMetadata {
+  width: number;
+  height: number;
+  format: string;
+  size: number;
+  model: string;
+  prompt: string;
+}
+
+/**
+ * 创建文本结果参数
+ */
+export interface CreateTextResultParams {
+  taskId: string;
+  content: string;
+  tokenCount: number;
+  wordCount?: number;
+  model?: string;
+  prompt?: string;
+}
+
+/**
+ * 创建图片结果参数
+ */
+export interface CreateImageResultParams {
+  taskId: string;
+  imageUrl: string;
+  width?: number;
+  height?: number;
+  format?: string;
+  size?: number;
+  model?: string;
+  prompt?: string;
+}
+
+/**
+ * 更新结果参数
+ */
+export interface UpdateResultParams {
+  qualityScore?: number;
+  qualityChecks?: string[];
+  metadata?: ResultMetadata;
+}