llm-content-creator 0.1.0 → 0.1.1

package/src/infrastructure/database/SQLiteTaskRepository.ts

@@ -83,11 +83,15 @@ export class SQLiteTaskRepository {
       CREATE TABLE IF NOT EXISTS quality_checks (
         id TEXT PRIMARY KEY,
         task_id TEXT NOT NULL,
-        check_category TEXT NOT NULL,
+        check_type TEXT NOT NULL,
         score REAL,
         passed BOOLEAN NOT NULL DEFAULT 0,
+        hard_constraints_passed BOOLEAN NOT NULL DEFAULT 0,
         details TEXT,
         fix_suggestions TEXT,
+        rubric_version TEXT,
+        model_name TEXT,
+        prompt_hash TEXT,
         created_at TEXT NOT NULL DEFAULT (datetime('now')),
         FOREIGN KEY (task_id) REFERENCES tasks(id) ON DELETE CASCADE
       );
@@ -97,6 +101,7 @@ export class SQLiteTaskRepository {
         task_id TEXT NOT NULL,
         result_type TEXT NOT NULL,
         content TEXT,
+        file_path TEXT,
         metadata TEXT,
         quality_score REAL,
         created_at TEXT NOT NULL DEFAULT (datetime('now')),
@@ -415,7 +420,7 @@ export class SQLiteTaskRepository {
       WHERE id = ? AND version = ? AND status = ?
     `);
 
-    const result = stmt.run(TaskStatus.RUNNING, workerId, now, taskId, version, TaskStatus.PENDING);
+    const result = stmt.run(TaskStatus.RUNNING, workerId, now, now, taskId, version, TaskStatus.PENDING);
     const claimed = result.changes > 0;
 
     if (claimed) {
@@ -611,6 +616,79 @@ export class SQLiteTaskRepository {
     }
   }
 
+  /**
+   * 查询任务列表（支持过滤和分页）
+   */
+  async findMany(filter?: any, pagination?: any): Promise<Task[]> {
+    const { limit = 50, offset = 0 } = pagination || {};
+
+    const conditions: string[] = [];
+    const values: any[] = [];
+
+    if (filter?.status) {
+      conditions.push('status = ?');
+      values.push(filter.status);
+    }
+    if (filter?.userId) {
+      conditions.push('id = ?'); // SQLite 没有 userId 字段，使用 id
+      values.push(filter.userId);
+    }
+    if (filter?.mode) {
+      conditions.push('mode = ?');
+      values.push(filter.mode);
+    }
+
+    const whereClause = conditions.length > 0
+      ? 'WHERE ' + conditions.join(' AND ')
+      : '';
+
+    const stmt = this.db.prepare(`
+      SELECT * FROM tasks
+      ${whereClause}
+      ORDER BY created_at DESC
+      LIMIT ? OFFSET ?
+    `);
+
+    const rows = stmt.all(...values, limit, offset) as any[];
+    return rows.map((row) => this.mapRowToTask(row));
+  }
+
+  /**
+   * 统计任务数量
+   */
+  async count(filter?: any): Promise<number> {
+    const conditions: string[] = [];
+    const values: any[] = [];
+
+    if (filter?.status) {
+      conditions.push('status = ?');
+      values.push(filter.status);
+    }
+    if (filter?.userId) {
+      conditions.push('id = ?');
+      values.push(filter.userId);
+    }
+    if (filter?.mode) {
+      conditions.push('mode = ?');
+      values.push(filter.mode);
+    }
+
+    const whereClause = conditions.length > 0
+      ? 'WHERE ' + conditions.join(' AND ')
+      : '';
+
+    const stmt = this.db.prepare(`SELECT COUNT(*) as count FROM tasks ${whereClause}`);
+    const result = stmt.get(...values) as { count: number };
+    return result.count;
+  }
+
+  /**
+   * 根据 userId 查询任务列表
+   */
+  async findByUserId(userId: string, pagination?: any): Promise<Task[]> {
+    return this.findMany({ userId }, pagination);
+  }
+
   /**
    * 关闭数据库连接
    */

package/src/infrastructure/database/index.ts

@@ -7,6 +7,9 @@
 import { config } from '../../config/index.js';
 import { MemoryTaskRepository } from './MemoryTaskRepository.js';
 import { SQLiteTaskRepository } from './SQLiteTaskRepository.js';
+import { SQLiteResultRepository } from './SQLiteResultRepository.js';
+import { SQLiteQualityCheckRepository } from './SQLiteQualityCheckRepository.js';
+import { PostgresTaskRepository } from './PostgresTaskRepository.js';
 import { createLogger } from '../logging/logger.js';
 
 const logger = createLogger('Database:Factory');
@@ -54,9 +57,7 @@ export function createTaskRepository(pool?: any, dbPath?: string) {
 
   if (dbType === 'postgres') {
     // PostgreSQL 版本（需要数据库连接）
-    // 动态导入以避免在不需要时加载 pg
     try {
-      const { PostgresTaskRepository } = require('./PostgresTaskRepository.js');
       // 如果提供了 pool，使用提供的；否则由 BaseRepository 自动创建
       logger.info('Using PostgresTaskRepository');
       return new PostgresTaskRepository(pool);
@@ -74,10 +75,46 @@ export function createTaskRepository(pool?: any, dbPath?: string) {
   return new SQLiteTaskRepository(dbPath);
 }
 
+/**
+ * 创建 Result Repository
+ *
+ * 根据配置自动选择合适的实现
+ */
+export function createResultRepository(_pool?: any, dbPath?: string) {
+  const dbType = config.database.type;
+
+  logger.info('Creating Result Repository', { databaseType: dbType });
+
+  // 注意：PostgreSQL 版本需要动态导入，但目前只支持 SQLite
+  // 默认使用 SQLiteResultRepository
+  logger.info('Using SQLiteResultRepository', { dbPath: dbPath || './data/content-creator.db' });
+  return new SQLiteResultRepository(dbPath);
+}
+
+/**
+ * 创建 Quality Check Repository
+ *
+ * 根据配置自动选择合适的实现
+ */
+export function createQualityCheckRepository(_pool?: any, dbPath?: string) {
+  const dbType = config.database.type;
+
+  logger.info('Creating Quality Check Repository', { databaseType: dbType });
+
+  // 注意：PostgreSQL 版本需要动态导入，但目前只支持 SQLite
+  // 默认使用 SQLiteQualityCheckRepository
+  logger.info('Using SQLiteQualityCheckRepository', { dbPath: dbPath || './data/content-creator.db' });
+  return new SQLiteQualityCheckRepository(dbPath);
+}
+
 // 导出具体的 Repository 类（可选使用）
 export { MemoryTaskRepository } from './MemoryTaskRepository.js';
 export { PostgresTaskRepository } from './PostgresTaskRepository.js';
 export { SQLiteTaskRepository } from './SQLiteTaskRepository.js';
+export { PostgresResultRepository } from './ResultRepository.js';
+export { SQLiteResultRepository } from './SQLiteResultRepository.js';
+export { PostgresQualityCheckRepository } from './PostgresQualityCheckRepository.js';
+export { SQLiteQualityCheckRepository } from './SQLiteQualityCheckRepository.js';
 
 // 导出单例（全局使用）
 export const taskRepository = createTaskRepository();

package/src/infrastructure/redis/connection.ts

@@ -81,7 +81,7 @@ export class RedisClient {
         host: redisUrl.hostname,
         port: parseInt(redisUrl.port) || 6379,
         db: config.redis.db,
-        maxRetriesPerRequest: config.redis.maxRetriesPerRequest,
+        maxRetriesPerRequest: null, // BullMQ Worker 要求必须设置为 null
         retryStrategy: (times: number) => {
           const delay = Math.min(times * 50, 2000);
           logger.debug(`Redis retry attempt ${times}, delay: ${delay}ms`);
@@ -131,9 +131,22 @@ export class RedisClient {
       });
 
       // 等待连接就绪
-      await this.client.ready;
+      await new Promise((resolve, reject) => {
+        this.client.on('ready', () => {
+          logger.info('Redis connection established');
+          resolve(this.client);
+        });
+
+        this.client.on('error', (err: Error) => {
+          reject(err);
+        });
+
+        // 超时处理
+        setTimeout(() => {
+          reject(new Error('Redis connection timeout'));
+        }, config.redis.connectTimeout);
+      });
 
-      logger.info('Redis connection established');
       return this.client;
     } catch (error) {
       this.isConnecting = false;

package/src/presentation/cli/commands/cancel.ts

@@ -55,6 +55,7 @@ export const cancelCommand = new Command('cancel')
         success
       });
 
+      process.exit(0);
     } catch (error) {
       spinner.fail('操作失败');
       logger.error('Cancel command failed', error as Error);

package/src/presentation/cli/commands/create.ts

@@ -11,6 +11,7 @@ import { v4 as uuidv4 } from 'uuid';
 import { createSyncExecutor } from '../../../application/workflow/SyncExecutor.js';
 import { MemoryTaskRepository } from '../../../infrastructure/database/MemoryTaskRepository.js';
 import { PostgresTaskRepository } from '../../../infrastructure/database/PostgresTaskRepository.js';
+import { SQLiteTaskRepository } from '../../../infrastructure/database/SQLiteTaskRepository.js';
 import { PostgresResultRepository } from '../../../infrastructure/database/ResultRepository.js';
 import { PostgresQualityCheckRepository } from '../../../infrastructure/database/PostgresQualityCheckRepository.js';
 import { ExecutionMode, TaskPriority } from '../../../domain/entities/Task.js';
@@ -104,6 +105,10 @@ export const createCommand = new Command('create')
         qualityCheckRepo = new PostgresQualityCheckRepository(resources.pool);
 
         console.log('✅ 使用 PostgreSQL 持久化存储');
+      } else if (config.database.type === 'sqlite') {
+        // 使用 SQLite Task Repository，确保任务持久化
+        taskRepo = new SQLiteTaskRepository();
+        console.log('✅ 使用 SQLite 持久化存储');
       } else {
         // 使用内存数据库（仅用于测试）
         taskRepo = new MemoryTaskRepository();
@@ -149,11 +154,11 @@ export const createCommand = new Command('create')
 
         console.log(chalk.yellow.bold('\n💡 后续操作：'));
         console.log(chalk.white('1. 查询任务状态：'));
-        console.log(chalk.gray(`   pnpm cli result --task-id ${taskId}`));
+        console.log(chalk.gray(`   pnpm run cli result --task-id ${taskId}`));
         console.log(chalk.white('\n2. 确保 Worker 正在运行：'));
         console.log(chalk.gray('   pnpm run worker'));
-        console.log(chalk.white('\n3. 查看队列状态：'));
-        console.log(chalk.gray('   pnpm cli worker:status'));
+        console.log(chalk.white('\n3. 查看监控面板：'));
+        console.log(chalk.gray('   pnpm run monitor'));
         printSeparator();
 
         logger.info('Task created via async mode', {
@@ -164,6 +169,14 @@ export const createCommand = new Command('create')
 
       } else {
         // ==================== 同步模式：使用 SyncExecutor ====================
+        // 为 SQLite 模式创建结果和质检仓储
+        if (config.database.type === 'sqlite') {
+          const { SQLiteResultRepository } = await import('../../../infrastructure/database/SQLiteResultRepository.js');
+          const { SQLiteQualityCheckRepository } = await import('../../../infrastructure/database/SQLiteQualityCheckRepository.js');
+          resultRepo = new SQLiteResultRepository();
+          qualityCheckRepo = new SQLiteQualityCheckRepository();
+        }
+
         const executor = createSyncExecutor(taskRepo, {
           databaseType: config.database.type,
           enableLogging: true,
@@ -311,6 +324,9 @@ export const createCommand = new Command('create')
           duration: result.duration
         });
       } // 结束同步模式的 else 块
+
+      // 任务完成后明确退出
+      process.exit(0);
     } catch (error) {
       logger.error('Create command failed', error as Error);
       console.error(chalk.red(`\n❌ 错误: ${error instanceof Error ? error.message : String(error)}`));
@@ -327,15 +343,7 @@ export const createCommand = new Command('create')
       if (resources.servicesInitialized) {
         logger.debug('Starting resource cleanup...');
 
-        // 1. 关闭 Logger（必须在最后）
-        try {
-          await closeLogger();
-          logger.debug('Logger closed');
-        } catch (error) {
-          console.log('Error closing logger (ignored):', error);
-        }
-
-        // 2. 停止 Metrics 服务定时器
+        // 1. 停止 Metrics 服务定时器
         try {
           metricsService.stop();
           console.log('Metrics service stopped');
@@ -343,7 +351,7 @@ export const createCommand = new Command('create')
           console.log('Error stopping metrics service (ignored):', error);
         }
 
-        // 3. 关闭 Redis 客户端连接
+        // 2. 关闭 Redis 客户端连接
         try {
           await redisClient.disconnect();
           console.log('Redis client disconnected');
@@ -351,7 +359,7 @@ export const createCommand = new Command('create')
           console.log('Error disconnecting Redis (ignored):', error);
         }
 
-        // 4. 关闭 PostgreSQL 连接池
+        // 3. 关闭 PostgreSQL 连接池
         try {
           if (resources.pool) {
             await resources.pool.end();
@@ -361,6 +369,14 @@ export const createCommand = new Command('create')
           console.log('Error closing PostgreSQL pool (ignored):', error);
         }
 
+        // 4. 关闭 Logger（必须在最后）
+        try {
+          await closeLogger();
+          logger.debug('Logger closed');
+        } catch (error) {
+          console.log('Error closing logger (ignored):', error);
+        }
+
         console.log('Resource cleanup completed');
       }
     }

package/src/presentation/cli/commands/list.ts

@@ -0,0 +1,172 @@
+/**
+ * CLI List Command
+ *
+ * 列出历史任务
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { createTaskRepository } from '../../../infrastructure/database/index.js';
+import { createLogger } from '../../../infrastructure/logging/logger.js';
+
+const logger = createLogger('CLI:List');
+
+function printSeparator() {
+  console.log(chalk.gray('─'.repeat(100)));
+}
+
+/**
+ * 格式化任务状态显示
+ */
+function formatTaskStatus(status: string): string {
+  const statusMap: Record<string, string> = {
+    pending: chalk.yellow('等待中'),
+    processing: chalk.blue('处理中'),
+    running: chalk.blue('运行中'),
+    completed: chalk.green('已完成'),
+    failed: chalk.red('失败'),
+    cancelled: chalk.gray('已取消'),
+  };
+  return statusMap[status] || status;
+}
+
+/**
+ * 格式化执行模式
+ */
+function formatExecutionMode(mode: string): string {
+  const modeMap: Record<string, string> = {
+    sync: '同步',
+    async: '异步',
+  };
+  return modeMap[mode] || mode;
+}
+
+/**
+ * 格式化时间显示
+ */
+function formatTime(dateStr: string | undefined): string {
+  if (!dateStr) return '-';
+  const date = new Date(dateStr);
+  const now = new Date();
+  const diff = now.getTime() - date.getTime();
+
+  // 小于1分钟
+  if (diff < 60000) {
+    return `${Math.floor(diff / 1000)}秒前`;
+  }
+  // 小于1小时
+  if (diff < 3600000) {
+    return `${Math.floor(diff / 60000)}分钟前`;
+  }
+  // 小于24小时
+  if (diff < 86400000) {
+    return `${Math.floor(diff / 3600000)}小时前`;
+  }
+  // 大于24小时，显示日期
+  return date.toLocaleDateString('zh-CN', {
+    month: '2-digit',
+    day: '2-digit',
+    hour: '2-digit',
+    minute: '2-digit',
+  });
+}
+
+/**
+ * 格式化持续时间
+ */
+function formatDuration(startedAt: string | undefined, completedAt: string | undefined): string {
+  if (!startedAt) return '-';
+  if (!completedAt) return '进行中...';
+
+  const start = new Date(startedAt).getTime();
+  const end = new Date(completedAt).getTime();
+  const duration = end - start;
+
+  if (duration < 1000) return `${duration}ms`;
+  if (duration < 60000) return `${Math.floor(duration / 1000)}s`;
+  return `${Math.floor(duration / 60000)}m ${Math.floor((duration % 60000) / 1000)}s`;
+}
+
+export const listCommand = new Command('list')
+  .description('列出历史任务')
+  .option('-s, --status <status>', '筛选状态 (pending, running, completed, failed, cancelled)')
+  .option('-m, --mode <mode>', '筛选执行模式 (sync, async)')
+  .option('-l, --limit <number>', '显示数量', '20')
+  .option('-o, --offset <number>', '偏移量（用于分页）', '0')
+  .option('--json', '以 JSON 格式输出')
+  .action(async (options) => {
+    try {
+      const repository = createTaskRepository();
+
+      // 解析参数
+      const limit = parseInt(options.limit) || 20;
+      const offset = parseInt(options.offset) || 0;
+
+      // 构建过滤条件
+      const filters: any = {};
+
+      if (options.status) {
+        filters.status = options.status;
+      }
+
+      if (options.mode) {
+        filters.mode = options.mode;
+      }
+
+      // 使用 findMany 方法查询任务列表
+      const tasks = await repository.findMany(filters, { limit, offset });
+
+      // JSON 格式输出
+      if (options.json) {
+        console.log(JSON.stringify(tasks, null, 2));
+        process.exit(0);
+      }
+
+      // 文本格式输出
+      printSeparator();
+      console.log(chalk.bold.blue('📋 历史任务列表'));
+      printSeparator();
+
+      if (tasks.length === 0) {
+        console.log(chalk.yellow('暂无任务记录'));
+        console.log();
+        console.log(chalk.white('💡 提示：使用以下命令创建新任务'));
+        console.log(chalk.gray('  pnpm run cli:create --topic "文章主题" --requirements "创作要求"'));
+        console.log();
+        process.exit(0);
+      }
+
+      // 输出任务列表
+      tasks.forEach((task: any, index: number) => {
+        console.log(chalk.bold.white(`${index + 1}. ${task.topic}`));
+        console.log(chalk.gray(`   ID:        ${task.taskId}`));
+        console.log(chalk.gray(`   状态:      ${formatTaskStatus(task.status)}`));
+        console.log(chalk.gray(`   模式:      ${formatExecutionMode(task.mode)}`));
+        console.log(chalk.gray(`   创建时间:  ${formatTime(task.createdAt?.toISOString())}`));
+        console.log(chalk.gray(`   耗时:      ${formatDuration(task.startedAt?.toISOString(), task.completedAt?.toISOString())}`));
+
+        if (task.errorMessage) {
+          console.log(chalk.red(`   错误:      ${task.errorMessage}`));
+        }
+
+        console.log();
+      });
+
+      // 详细信息提示
+      console.log(chalk.white('💡 查看任务详情：'));
+      console.log(chalk.gray('  pnpm run cli:status --task-id <任务ID>'));
+      console.log(chalk.gray('  pnpm run cli:result --task-id <任务ID>'));
+      console.log();
+
+      logger.info('Listed tasks', {
+        count: tasks.length,
+        filters,
+      });
+
+      process.exit(0);
+    } catch (error) {
+      logger.error('Failed to list tasks', error as Error);
+      console.error(chalk.red('❌ 查询任务列表失败：'), (error as Error).message);
+      process.exit(1);
+    }
+  });

package/src/presentation/cli/commands/result.ts

@@ -44,14 +44,14 @@ export const resultCommand = new Command('result')
       if (task.status !== 'completed') {
         console.log(chalk.yellow(`⚠️  任务尚未完成，当前状态: ${getStatusText(task.status)}`));
         await cleanupResources(taskRepo, resultRepo);
-        return;
+        process.exit(0);
       }
 
       // JSON格式输出
       if (options.format === 'json') {
         console.log(JSON.stringify(task, null, 2));
         await cleanupResources(taskRepo, resultRepo);
-        return;
+        process.exit(0);
       }
 
       // 文本格式输出
@@ -61,7 +61,7 @@ export const resultCommand = new Command('result')
       console.log(chalk.white(`状态: ${getStatusText(task.status)}`));
       printSeparator();
 
-      // 从数据库查询结果（仅 PostgreSQL）
+      // 从数据库查询结果（支持 PostgreSQL 和 SQLite）
       if (config.database.type === 'postgres') {
         const { Pool } = await import('pg');
         pool = new Pool({
@@ -101,6 +101,35 @@ export const resultCommand = new Command('result')
 
         // 关闭结果查询的连接池
         await pool.end();
+      } else if (config.database.type === 'sqlite') {
+        // SQLite 模式：使用 SQLiteResultRepository 查询结果
+        const { SQLiteResultRepository } = await import('../../../infrastructure/database/SQLiteResultRepository.js');
+        resultRepo = new SQLiteResultRepository();
+        const results = await resultRepo.findByTaskId(options.taskId);
+
+        if (results.length === 0) {
+          console.log(chalk.yellow('提示: 该任务未生成结果'));
+        } else {
+          console.log(chalk.blue.bold('\n📋 生成结果'));
+          printSeparator();
+
+          results.forEach((result: any, index: number) => {
+            console.log(chalk.white.bold(`${index + 1}. ${result.resultType.toUpperCase()}`));
+            printSeparator();
+
+            if (result.resultType === 'article') {
+              console.log(chalk.white('内容:'));
+              console.log(chalk.gray(result.content || '(无内容)'));
+              if (result.metadata?.wordCount) {
+                console.log(chalk.gray(`字数: ${result.metadata.wordCount}`));
+              }
+            } else if (result.resultType === 'image') {
+              console.log(chalk.white('图片 URL:'));
+              console.log(chalk.cyan(result.content || '(无 URL)'));
+            }
+            printSeparator();
+          });
+        }
       } else {
         // Memory 模式：提示结果仅实时返回
         console.log(chalk.yellow('\n💡 提示: 当前使用 Memory 模式'));
@@ -111,6 +140,7 @@ export const resultCommand = new Command('result')
 
       // 清理所有资源
       await cleanupResources(taskRepo, resultRepo);
+      process.exit(0);
 
     } catch (error) {
       console.error(chalk.red(`❌ 错误: ${error instanceof Error ? error.message : String(error)}`));