llm-content-creator 0.1.0

package/src/presentation/cli/utils/cleanup.ts

@@ -0,0 +1,65 @@
+/**
+ * CLI 资源清理工具
+ *
+ * 确保所有 CLI 命令执行后正确清理资源，避免进程挂起
+ */
+
+import { closeLogger } from '../../../infrastructure/logging/logger.js';
+
+/**
+ * 清理所有 CLI 资源
+ *
+ * @param repositories - 需要关闭的 Repository 数组
+ */
+export async function cleanupResources(...repositories: Array<{ close?: () => Promise<void> }>): Promise<void> {
+  const errors: Array<Error> = [];
+
+  // 1. 关闭所有 Repository 连接池
+  for (const repo of repositories) {
+    if (repo && typeof repo.close === 'function') {
+      try {
+        await repo.close();
+      } catch (error) {
+        errors.push(error as Error);
+      }
+    }
+  }
+
+  // 2. 停止 Metrics 服务（如果有定时器在运行）
+  try {
+    const { metricsService } = await import('../../../infrastructure/monitoring/MetricsService.js');
+    metricsService.stop();
+  } catch (error) {
+    // Metrics 服务可能未初始化，忽略错误
+  }
+
+  // 3. 关闭 Redis 连接
+  try {
+    const { redisClient } = await import('../../../infrastructure/redis/connection.js');
+    await redisClient.disconnect();
+  } catch (error) {
+    // Redis 可能未连接，忽略错误
+  }
+
+  // 4. 关闭 Logger（必须在最后）
+  try {
+    await closeLogger();
+  } catch (error) {
+    // 忽略 logger 关闭错误
+    errors.push(error as Error);
+  }
+
+  // 5. 如果有错误，输出但不要抛出
+  if (errors.length > 0) {
+    console.warn(`⚠️  资源清理时发生 ${errors.length} 个错误（已忽略）`);
+    errors.forEach((err, index) => {
+      console.warn(`  ${index + 1}. ${err.message}`);
+    });
+  }
+
+  // 6. 强制退出进程，确保没有任何定时器或事件阻止退出
+  // 注意：这是最后手段，正常情况下不需要
+  setTimeout(() => {
+    process.exit(0);
+  }, 100);
+}

package/src/presentation/cli/utils/formatter.ts

@@ -0,0 +1,74 @@
+/**
+ * CLI 格式化工具
+ */
+
+import chalk from 'chalk';
+
+/**
+ * 获取状态显示文本
+ */
+export function getStatusText(status: string): string {
+  const statusMap: Record<string, string> = {
+    'pending': chalk.yellow('⏳ 待处理'),
+    'running': chalk.blue('🔄 运行中'),
+    'waiting': chalk.yellow('⏸️ 等待中'),
+    'completed': chalk.green('✅ 已完成'),
+    'failed': chalk.red('❌ 失败'),
+    'cancelled': chalk.gray('⏹️ 已取消'),
+  };
+  return statusMap[status] || status;
+}
+
+/**
+ * 格式化日期
+ */
+export function formatDate(date: Date): string {
+  return new Date(date).toLocaleString('zh-CN', {
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit',
+  });
+}
+
+/**
+ * 格式化时长
+ */
+export function formatDuration(ms: number): string {
+  const seconds = Math.floor(ms / 1000);
+  if (seconds < 60) {
+    return `${seconds}秒`;
+  }
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  return `${minutes}分${remainingSeconds}秒`;
+}
+
+/**
+ * 格式化Token数量
+ */
+export function formatTokens(tokens: number): string {
+  if (tokens >= 10000) {
+    return `${(tokens / 1000).toFixed(1)}k`;
+  }
+  return tokens.toString();
+}
+
+/**
+ * 格式化成本
+ */
+export function formatCost(cost: number): string {
+  if (cost >= 1) {
+    return `¥${cost.toFixed(2)}`;
+  }
+  return `¥${cost.toFixed(4)}`;
+}
+
+/**
+ * 打印分隔线
+ */
+export function printSeparator(char: string = '─', length: number = 40): void {
+  console.log(chalk.gray(char.repeat(length)));
+}

package/src/presentation/cli.ts

@@ -0,0 +1,8 @@
+/**
+ * CLI 入口文件 (备用)
+ *
+ * 提供对外的CLI接口
+ */
+
+// @ts-ignore - Module resolution issue with NodeNext
+export * from './presentation/cli/index';

package/src/presentation/monitor-cli.ts

@@ -0,0 +1,52 @@
+#!/usr/bin/env tsx
+/**
+ * Monitor CLI
+ *
+ * 启动 Bull Board 监控面板
+ */
+
+import { Command } from 'commander';
+// @ts-ignore - Module resolution issue with NodeNext
+import { startMonitorServer } from '../../monitoring/index';
+// @ts-ignore - Module resolution issue with NodeNext
+import { createLogger } from '../../infrastructure/logging/logger';
+
+const logger = createLogger('MonitorCLI');
+const program = new Command();
+
+program
+  .name('monitor')
+  .description('Content Creator Monitor Server')
+  .version('0.1.0');
+
+program
+  .command('start')
+  .description('启动监控面板')
+  .option('-p, --port <number>', '端口号', '3000')
+  .action(async (options) => {
+    try {
+      const port = parseInt(options.port);
+
+      logger.info('Starting monitor server', { port });
+
+      await startMonitorServer(port);
+
+      // 监听退出信号
+      process.on('SIGTERM', () => {
+        logger.info('SIGTERM received, shutting down monitor');
+        process.exit(0);
+      });
+
+      process.on('SIGINT', () => {
+        logger.info('SIGINT received, shutting down monitor');
+        process.exit(0);
+      });
+
+      logger.info('Monitor server running, press Ctrl+C to stop');
+    } catch (error) {
+      logger.error('Failed to start monitor server', error as Error);
+      process.exit(1);
+    }
+  });
+
+program.parse();

package/src/presentation/worker-cli.ts

@@ -0,0 +1,62 @@
+#!/usr/bin/env tsx
+/**
+ * Worker CLI
+ *
+ * 启动 TaskWorker 处理任务
+ */
+
+import { Command } from 'commander';
+// @ts-ignore - Module resolution issue with NodeNext
+import { createTaskWorker } from '../../workers/index';
+// @ts-ignore - Module resolution issue with NodeNext
+import { createLogger } from '../../infrastructure/logging/logger';
+
+const logger = createLogger('WorkerCLI');
+const program = new Command();
+
+program
+  .name('worker')
+  .description('Content Creator Task Worker')
+  .version('0.1.0');
+
+program
+  .command('start')
+  .description('启动 Worker')
+  .option('-w, --worker-id <id>', 'Worker ID', process.env.WORKER_ID || `worker-${process.pid}`)
+  .option('-c, --concurrency <number>', '并发数', '2')
+  .action(async (options) => {
+    try {
+      const worker = createTaskWorker(
+        options.workerId,
+        parseInt(options.concurrency)
+      );
+
+      logger.info('Starting worker', {
+        workerId: options.workerId,
+        concurrency: options.concurrency,
+      });
+
+      await worker.start();
+
+      // 监听退出信号
+      process.on('SIGTERM', async () => {
+        logger.info('SIGTERM received, shutting down worker');
+        await worker.close();
+        process.exit(0);
+      });
+
+      process.on('SIGINT', async () => {
+        logger.info('SIGINT received, shutting down worker');
+        await worker.close();
+        process.exit(0);
+      });
+
+      // 保持进程运行
+      logger.info('Worker running, press Ctrl+C to stop');
+    } catch (error) {
+      logger.error('Failed to start worker', error as Error);
+      process.exit(1);
+    }
+  });
+
+program.parse();

package/src/schedulers/TaskScheduler.ts

@@ -0,0 +1,314 @@
+/**
+ * TaskScheduler - 任务调度器
+ *
+ * 负责任务的创建和调度
+ */
+
+import { v4 as uuidv4 } from 'uuid';
+import { createTaskQueue } from '../infrastructure/queue/TaskQueue.js';
+import { createTaskRepository } from '../infrastructure/database/index.js';
+import { createLogger } from '../infrastructure/logging/logger.js';
+import type { Task } from '../domain/entities/Task.js';
+import type { TaskJobData } from '../infrastructure/queue/TaskQueue.js';
+
+const logger = createLogger('TaskScheduler');
+
+/**
+ * 创建任务请求接口
+ */
+export interface CreateTaskRequest {
+  userId?: string;
+  mode: 'sync' | 'async';
+  topic: string;
+  requirements: string;
+  hardConstraints?: {
+    minWords?: number;
+    maxWords?: number;
+    keywords?: string[];
+  };
+  scheduleAt?: Date; // 可选：延迟执行
+  priority?: number; // 可选：优先级（1-10，数字越小优先级越高）
+}
+
+/**
+ * 批量创建任务请求接口
+ */
+export interface CreateBatchTasksRequest {
+  userId?: string;
+  tasks: Array<{
+    mode: 'sync' | 'async';
+    topic: string;
+    requirements: string;
+    hardConstraints?: {
+      minWords?: number;
+      maxWords?: number;
+      keywords?: string[];
+    };
+  }>;
+}
+
+/**
+ * 任务调度结果接口
+ */
+export interface ScheduleResult {
+  taskId: string;
+  status: 'pending' | 'scheduled';
+  scheduledAt?: Date;
+}
+
+/**
+ * TaskScheduler 类
+ *
+ * 负责任务的创建、验证和调度
+ */
+export class TaskScheduler {
+  private queue = createTaskQueue();
+  private repository = createTaskRepository();
+  private initialized = false;
+
+  /**
+   * 初始化调度器
+   */
+  async initialize(): Promise<void> {
+    if (this.initialized) {
+      return;
+    }
+
+    try {
+      await this.queue;
+      this.initialized = true;
+      logger.info('TaskScheduler initialized');
+    } catch (error) {
+      logger.error('Failed to initialize TaskScheduler', error as Error);
+      throw error;
+    }
+  }
+
+  /**
+   * 确保调度器已初始化
+   */
+  private async ensureInitialized(): Promise<void> {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+  }
+
+  /**
+   * 创建并调度单个任务
+   */
+  async scheduleTask(request: CreateTaskRequest): Promise<string> {
+    await this.ensureInitialized();
+
+    try {
+      // 1. 验证请求参数
+      this.validateTaskRequest(request);
+
+      // 2. 生成任务 ID
+      const taskId = uuidv4();
+
+      // 3. 创建任务实体
+      const task: Partial<Task> = {
+        id: taskId,
+        taskId: taskId,
+        mode: request.mode as any,
+        type: 'article' as any,
+        topic: request.topic,
+        requirements: request.requirements,
+        hardConstraints: request.hardConstraints,
+        status: 'pending' as any,
+        priority: 2,
+        version: 1,
+        textRetryCount: 0,
+        imageRetryCount: 0,
+        targetAudience: 'general',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      };
+
+      // 4. 保存到数据库
+      await this.repository.create(task as Task);
+
+      logger.info('Task created', {
+        taskId,
+        mode: request.mode,
+        topic: request.topic,
+      });
+
+      // 5. 准备队列数据
+      const jobData: TaskJobData = {
+        taskId: task.id!,
+        mode: task.mode!,
+        topic: task.topic!,
+        requirements: task.requirements!,
+        hardConstraints: task.hardConstraints,
+      };
+
+      // 6. 添加到队列
+      if (request.scheduleAt) {
+        // 延迟任务
+        const delay = request.scheduleAt.getTime() - Date.now();
+        if (delay > 0) {
+          await (await this.queue).addDelayedTask(jobData, delay);
+          logger.info('Task scheduled for delayed execution', {
+            taskId,
+            delay,
+            scheduleAt: request.scheduleAt,
+          });
+        } else {
+          // 时间已过，立即执行
+          await (await this.queue).addTask(jobData, {
+            priority: request.priority,
+          });
+          logger.info('Task scheduled for immediate execution', {
+            taskId,
+          });
+        }
+      } else {
+        // 立即执行
+        await (await this.queue).addTask(jobData, {
+          priority: request.priority,
+        });
+        logger.info('Task scheduled for immediate execution', {
+          taskId,
+        });
+      }
+
+      return taskId;
+    } catch (error) {
+      logger.error('Failed to schedule task', error as Error, {
+        topic: request.topic,
+      });
+      throw error;
+    }
+  }
+
+  /**
+   * 批量创建任务
+   */
+  async scheduleBatchTasks(
+    request: CreateBatchTasksRequest
+  ): Promise<string[]> {
+    await this.ensureInitialized();
+
+    const taskIds: string[] = [];
+
+    try {
+      logger.info('Scheduling batch tasks', {
+        count: request.tasks.length,
+      });
+
+      for (const taskRequest of request.tasks) {
+        const taskId = await this.scheduleTask({
+          ...taskRequest,
+          userId: request.userId,
+        });
+        taskIds.push(taskId);
+      }
+
+      logger.info('Batch tasks scheduled', {
+        count: taskIds.length,
+      });
+
+      return taskIds;
+    } catch (error) {
+      logger.error('Failed to schedule batch tasks', error as Error);
+      throw error;
+    }
+  }
+
+  /**
+   * 验证任务请求参数
+   */
+  private validateTaskRequest(request: CreateTaskRequest): void {
+    if (!request.topic || request.topic.trim().length === 0) {
+      throw new Error('Topic is required');
+    }
+
+    if (!request.requirements || request.requirements.trim().length === 0) {
+      throw new Error('Requirements are required');
+    }
+
+    if (!['sync', 'async'].includes(request.mode)) {
+      throw new Error('Mode must be either sync or async');
+    }
+
+    if (request.hardConstraints) {
+      if (request.hardConstraints.minWords && request.hardConstraints.maxWords) {
+        if (request.hardConstraints.minWords > request.hardConstraints.maxWords) {
+          throw new Error('minWords cannot be greater than maxWords');
+        }
+      }
+    }
+  }
+
+  /**
+   * 取消任务
+   */
+  async cancelTask(taskId: string): Promise<boolean> {
+    try {
+      // 更新数据库中的任务状态
+      const task = await this.repository.findById(taskId);
+
+      if (!task) {
+        logger.warn('Task not found', { taskId });
+        return false;
+      }
+
+      // 只有 pending 状态的任务可以取消
+      if (task.status !== 'pending') {
+        logger.warn('Task cannot be cancelled', {
+          taskId,
+          status: task.status,
+        });
+        return false;
+      }
+
+      await this.repository.update(taskId, {
+        status: 'cancelled',
+        updatedAt: new Date().toISOString(),
+      });
+
+      logger.info('Task cancelled', { taskId });
+
+      return true;
+    } catch (error) {
+      logger.error('Failed to cancel task', error as Error, { taskId });
+      return false;
+    }
+  }
+
+  /**
+   * 获取队列统计信息
+   */
+  async getQueueStats(): Promise<{
+    waiting: number;
+    active: number;
+    completed: number;
+    failed: number;
+    delayed: number;
+    repeat: number;
+  }> {
+    await this.ensureInitialized();
+    return await (await this.queue).getStats();
+  }
+
+  /**
+   * 关闭调度器
+   */
+  async close(): Promise<void> {
+    if (this.initialized) {
+      await (await this.queue).close();
+      this.initialized = false;
+      logger.info('TaskScheduler closed');
+    }
+  }
+}
+
+/**
+ * 创建 TaskScheduler 实例
+ */
+export async function createTaskScheduler(): Promise<TaskScheduler> {
+  const scheduler = new TaskScheduler();
+  await scheduler.initialize();
+  return scheduler;
+}

package/src/schedulers/index.ts

@@ -0,0 +1,11 @@
+/**
+ * Schedulers 导出
+ */
+
+export {
+  TaskScheduler,
+  createTaskScheduler,
+  type CreateTaskRequest,
+  type CreateBatchTasksRequest,
+  type ScheduleResult,
+} from './TaskScheduler.js';