@ohos-cpf/3rdloop 0.0.1

package/vendor/Server/DbUse/stores/TaskExecutionStore.js

@@ -0,0 +1,133 @@
+import { nowCST } from '../../library/cstTime.js';
+
+/**
+ * TaskExecutionStore —— 任务步骤执行记录持久化（JSON 文件）
+ *
+ * 用途：在任务执行过程中，将每个步骤的执行状态、时间、会话 ID 等关键信息
+ * 以 JSON 文件形式持久化到 db/task/{taskId}/ 目录下，方便后续追踪和分析。
+ *
+ * 文件布局：
+ *   db/
+ *     └── task/
+ *         └── {taskId}/
+ *             ├── stepid_{stepId}.json    ← 单个步骤的执行记录
+ *             └── stepid_{stepId}.json
+ *
+ * 单个步骤记录字段：
+ *   {
+ *     taskId, stepId, dependId, nextStepId,
+ *     taskDescription, skillDirectory, inputReport,
+ *     matchedSkillDir, sessionId,
+ *     status, retryTimes, maxRetries,
+ *     startTime, endTime, updatedAt,
+ *     error
+ *   }
+ *
+ * 依赖 JsonAdapter（subDir='task'），整文件读写，幂等覆盖。
+ *
+ * 分层关系：与 SessionStore / TaskStepStore 平级，只依赖适配器接口。
+ */
+class TaskExecutionStore {
+    /**
+     * @param {object} options
+     * @param {import('../adapters/JsonAdapter.js').default} options.json - JSON 适配器（subDir='task'）
+     */
+    constructor(options = {}) {
+        this.json = options.json;
+        if (!this.json) {
+            throw new Error('TaskExecutionStore 需要 json 适配器');
+        }
+    }
+
+    // ─── 路径约定 ──────────────────────────────────────────────────────────────
+
+    /**
+     * 生成步骤记录的存储 key。
+     * JsonAdapter 会在 key 后追加 .json，最终文件为：
+     *   - 有 loopCount: {rootDir}/{taskId}/stepid_{stepId}_loop{L}.json
+     *   - 无 loopCount: {rootDir}/{taskId}/stepid_{stepId}.json（向后兼容）
+     *
+     * @param {string} taskId
+     * @param {string} stepId
+     * @param {number} [loopCount] - 大循环索引（可选）
+     * @returns {string} storage key
+     * @private
+     */
+    _key(taskId, stepId, loopCount) {
+        const base = `${taskId}/stepid_${stepId}`;
+        if (loopCount != null && Number.isFinite(Number(loopCount))) {
+            return `${base}_loop${loopCount}`;
+        }
+        return base;
+    }
+
+    // ─── 读写 ──────────────────────────────────────────────────────────────────
+
+    /**
+     * 写入（覆盖）步骤执行记录。
+     * @param {string} taskId
+     * @param {string} stepId
+     * @param {object} data - 步骤记录
+     * @param {number} [loopCount] - 大循环索引（可选，传入时按轮次独立存储）
+     * @returns {Promise<object>} 写入的数据
+     */
+    async writeStep(taskId, stepId, data, loopCount) {
+        return this.json.write(this._key(taskId, stepId, loopCount), {
+            ...data,
+            taskId,
+            stepId,
+            updatedAt: nowCST()
+        });
+    }
+
+    /**
+     * 读取步骤执行记录。
+     * @param {string} taskId
+     * @param {string} stepId
+     * @param {number} [loopCount] - 大循环索引（可选）
+     * @returns {Promise<object|null>} 步骤记录，不存在时返回 null
+     */
+    async readStep(taskId, stepId, loopCount) {
+        return this.json.read(this._key(taskId, stepId, loopCount));
+    }
+
+    /**
+     * 增量更新步骤记录（合并已有字段）。
+     * 不存在时以 patch 为初始数据创建。
+     *
+     * @param {string} taskId
+     * @param {string} stepId
+     * @param {object} patch - 要合并的字段
+     * @param {number} [loopCount] - 大循环索引（可选，传入时按轮次独立存储）
+     * @returns {Promise<object>} 合并后的完整记录
+     */
+    async patchStep(taskId, stepId, patch, loopCount) {
+        const existing = await this.readStep(taskId, stepId, loopCount) ?? {};
+        const next = { ...existing, ...patch };
+        return this.writeStep(taskId, stepId, next, loopCount);
+    }
+
+    /**
+     * 列出某个 Task 下所有步骤记录。
+     * 依赖 JsonAdapter.list() 按目录前缀过滤。
+     *
+     * @param {string} taskId
+     * @returns {Promise<object[]>} 步骤记录数组（按 startTime 排序）
+     */
+    async listSteps(taskId) {
+        const pattern = `${taskId}/stepid_`;
+        const entries = await this.json.list(pattern).catch(() => []);
+        // JsonAdapter.list() 返回 [{ key, data }] 格式
+        const results = entries
+            .map(e => (e != null && typeof e === 'object' ? (e.data ?? e) : null))
+            .filter(Boolean);
+        results.sort((a, b) => {
+            const ta = a.startTime || '';
+            const tb = b.startTime || '';
+            return ta.localeCompare(tb);
+        });
+        return results;
+    }
+}
+
+export default TaskExecutionStore;

package/vendor/Server/DbUse/stores/TaskRegistryStore.js

@@ -0,0 +1,262 @@
+/**
+ * TaskRegistryStore —— 任务注册表（SQLite）
+ *
+ * 用途：为"历史任务列表"提供高性能分页查询。
+ *
+ * 背景：
+ *   任务详情数据（loop.json / orchestration.json / stepid_*.json）以 JSON 文件
+ *   存储在 db/task/{taskId}/ 下，单任务读写 O(1)，简单可靠。
+ *   但历史列表若逐个扫描 JSON 文件，任务数超过数百后会出现明显卡顿
+ *   （N 次 readFile + JSON.parse + 全量返回）。
+ *
+ * 方案：
+ *   新增一张 SQLite 注册表，仅记录任务的"摘要信息"（taskId / 类型 / 状态 /
+ *   时间 / 描述 / 摘要元数据），供列表查询使用：
+ *     - 列表查询走 SQL 分页（LIMIT/OFFSET），不读任何 JSON 文件
+ *     - COUNT 用 SELECT COUNT(*)，不加载全部数据
+ *     - 任务详情仍从 JSON 文件读取（单文件 O(1)）
+ *
+ * 表结构 (task_registry)：
+ *   task_id      TEXT PRIMARY KEY   - 任务 ID
+ *   task_type    TEXT NOT NULL      - 任务类型（'loop' | 'orchestrator' | 'flexrunner' | ...）
+ *   status       TEXT NOT NULL      - 状态（running / completed / failed / aborted / ...）
+ *   title        TEXT               - 任务标题/描述（截断）
+ *   description  TEXT               - 完整描述（可选）
+ *   created_at   TEXT NOT NULL      - 创建时间（ISO）
+ *   updated_at   TEXT               - 最后更新时间（ISO）
+ *   metadata     TEXT               - 扩展摘要元数据（JSON 字符串，如评分、轮次等）
+ *
+ * 索引：created_at（列表排序）、status（状态过滤）
+ *
+ * 依赖 SqliteAdapter（better-sqlite3）。
+ */
+const DDL = `
+CREATE TABLE IF NOT EXISTS task_registry (
+    task_id     TEXT PRIMARY KEY,
+    task_type   TEXT NOT NULL,
+    status      TEXT NOT NULL,
+    title       TEXT,
+    description TEXT,
+    created_at  TEXT NOT NULL,
+    updated_at  TEXT,
+    metadata    TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_task_registry_created_at ON task_registry(created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_task_registry_status ON task_registry(status);
+`;
+
+class TaskRegistryStore {
+    /**
+     * @param {object} options
+     * @param {import('../adapters/SqliteAdapter.js').default} options.sqlite - SQLite 适配器
+     */
+    constructor(options = {}) {
+        this.sqlite = options.sqlite;
+        if (!this.sqlite) {
+            throw new Error('TaskRegistryStore 需要 sqlite 适配器');
+        }
+        this._initialized = false;
+    }
+
+    /** 幂等建表 */
+    async _init() {
+        if (this._initialized) return;
+        await this.sqlite.exec(DDL);
+        this._initialized = true;
+    }
+
+    /**
+     * 注册（插入或更新）一条任务摘要。
+     * 幂等：同一 taskId 重复调用会覆盖。
+     *
+     * @param {object} entry
+     * @param {string} entry.taskId
+     * @param {string} [entry.taskType='loop'] - 任务类型
+     * @param {string} [entry.status='running'] - 状态
+     * @param {string} [entry.title=''] - 标题/描述（截断到 200 字符）
+     * @param {string} [entry.description=''] - 完整描述
+     * @param {string} [entry.createdAt] - 创建时间（默认 now）
+     * @param {object} [entry.metadata] - 扩展摘要元数据（会 JSON 序列化）
+     * @returns {Promise<object>} 写入的条目
+     */
+    async upsert(entry) {
+        await this._init();
+        const now = new Date().toISOString();
+        const row = {
+            task_id: entry.taskId,
+            task_type: entry.taskType || 'loop',
+            status: entry.status || 'running',
+            title: entry.title ? String(entry.title).slice(0, 200) : '',
+            description: entry.description || '',
+            created_at: entry.createdAt || now,
+            updated_at: now,
+            metadata: entry.metadata ? JSON.stringify(entry.metadata) : null
+        };
+        await this.sqlite.upsert('task_registry', row);
+        return row;
+    }
+
+    /**
+     * 更新任务状态（保留其他字段）。
+     * @param {string} taskId
+     * @param {object} patch - { status?, title?, description?, metadata? }
+     * @returns {Promise<object|null>} 更新后的条目，不存在返回 null
+     */
+    async patch(taskId, patch) {
+        await this._init();
+        const existing = await this.get(taskId);
+        if (!existing) return null;
+
+        const next = {
+            ...existing,
+            ...patch,
+            task_id: taskId,
+            updated_at: new Date().toISOString()
+        };
+        if (next.metadata && typeof next.metadata === 'object') {
+            next.metadata = JSON.stringify(next.metadata);
+        }
+        await this.sqlite.upsert('task_registry', next);
+        return next;
+    }
+
+    /**
+     * 按 taskId 查询单条摘要。
+     * @param {string} taskId
+     * @returns {Promise<object|null>}
+     */
+    async get(taskId) {
+        await this._init();
+        const row = await this.sqlite.get(
+            'SELECT * FROM task_registry WHERE task_id = ?',
+            [taskId]
+        );
+        return row ? this._deserialize(row) : null;
+    }
+
+    /**
+     * 分页查询任务列表（按 created_at 降序）。
+     * @param {object} [opts]
+     * @param {number} [opts.page=1] - 页码，从 1 开始
+     * @param {number} [opts.pageSize=20] - 每页条数
+     * @param {string} [opts.status] - 可选，按状态过滤
+     * @param {string} [opts.taskType] - 可选，按任务类型过滤
+     * @param {string} [opts.taskIdPrefix] - 可选，按 taskId 前缀过滤（如 'fluttercheck_' / 'codecheck_'）
+     * @returns {Promise<{ tasks: object[], total: number, page: number, pageSize: number, totalPages: number }>}
+     */
+    async listPage(opts = {}) {
+        await this._init();
+        const page = Math.max(1, opts.page || 1);
+        const pageSize = Math.min(100, Math.max(1, opts.pageSize || 20));
+        const offset = (page - 1) * pageSize;
+
+        const where = [];
+        const params = [];
+        if (opts.status) {
+            where.push('status = ?');
+            params.push(opts.status);
+        }
+        if (opts.taskType) {
+            where.push('task_type = ?');
+            params.push(opts.taskType);
+        }
+        if (opts.taskIdPrefix) {
+            where.push("task_id LIKE ? ESCAPE '\\'");
+            // LIKE 通配符转义：前缀中的 %/_ 按字面匹配
+            params.push(String(opts.taskIdPrefix).replace(/([%_\\])/g, '\\$1') + '%');
+        }
+        const whereSql = where.length ? `WHERE ${where.join(' AND ')}` : '';
+
+        const countRow = await this.sqlite.get(
+            `SELECT COUNT(*) AS total FROM task_registry ${whereSql}`,
+            params
+        );
+        const total = countRow?.total ?? 0;
+
+        const rows = await this.sqlite.all(
+            `SELECT * FROM task_registry ${whereSql} ORDER BY created_at DESC LIMIT ? OFFSET ?`,
+            [...params, pageSize, offset]
+        );
+
+        return {
+            tasks: rows.map(r => this._deserialize(r)),
+            total,
+            page,
+            pageSize,
+            totalPages: Math.max(1, Math.ceil(total / pageSize))
+        };
+    }
+
+    /**
+     * 查询符合条件的全部 task_id（不分页），供跨页去重判断使用。
+     *
+     * listPage 只返回当前页的 ID，无法判断某 taskId 是否出现在其他页，
+     * 因此提供本方法返回全量 ID 集合（与 listPage 使用相同的 where 过滤条件）。
+     *
+     * @param {object} [opts]
+     * @param {string} [opts.status]
+     * @param {string} [opts.taskType]
+     * @param {string} [opts.taskIdPrefix]
+     * @returns {Promise<string[]>}
+     */
+    async listIds(opts = {}) {
+        await this._init();
+        const where = [];
+        const params = [];
+        if (opts.status) {
+            where.push('status = ?');
+            params.push(opts.status);
+        }
+        if (opts.taskType) {
+            where.push('task_type = ?');
+            params.push(opts.taskType);
+        }
+        if (opts.taskIdPrefix) {
+            where.push("task_id LIKE ? ESCAPE '\\'");
+            params.push(String(opts.taskIdPrefix).replace(/([%_\\])/g, '\\$1') + '%');
+        }
+        const whereSql = where.length ? `WHERE ${where.join(' AND ')}` : '';
+        const rows = await this.sqlite.all(
+            `SELECT task_id FROM task_registry ${whereSql}`,
+            params
+        );
+        return rows.map(r => r.task_id);
+    }
+
+    /**
+     * 删除一条任务摘要。
+     * @param {string} taskId
+     * @returns {Promise<boolean>}
+     */
+    async delete(taskId) {
+        await this._init();
+        await this.sqlite.exec('DELETE FROM task_registry WHERE task_id = ?', [taskId]);
+        return true;
+    }
+
+    /**
+     * 获取任务总数（仅 COUNT，不加载数据）。
+     * @returns {Promise<number>}
+     */
+    async count() {
+        await this._init();
+        const row = await this.sqlite.get('SELECT COUNT(*) AS total FROM task_registry');
+        return row?.total ?? 0;
+    }
+
+    /** 反序列化：metadata JSON 字符串 → 对象 */
+    _deserialize(row) {
+        if (!row) return null;
+        const out = { ...row };
+        if (out.metadata) {
+            try {
+                out.metadata = JSON.parse(out.metadata);
+            } catch {
+                out.metadata = null;
+            }
+        }
+        return out;
+    }
+}
+
+export default TaskRegistryStore;

package/vendor/Server/DbUse/stores/TaskStepStore.js

@@ -0,0 +1,279 @@
+import { randomUUID } from 'node:crypto';
+
+/**
+ * TaskStepStore —— 任务步骤持久化存储（SQLite）
+ *
+ * 用途：记录任务执行过程中的各个步骤信息，支持查询、状态流转、耗时统计。
+ *
+ * 表结构 (task_steps)：
+ *   id          TEXT PRIMARY KEY      - 步骤唯一 ID（自动生成）
+ *   task_id     TEXT NOT NULL          - 所属任务 ID
+ *   seq         INTEGER NOT NULL       - 步骤序号（同任务内递增）
+ *   name        TEXT                   - 步骤名称
+ *   type        TEXT                   - 步骤类型（如 'cli'/'db'/'file'/'custom'）
+ *   status      TEXT NOT NULL DEFAULT 'pending'  - pending/running/completed/error/skipped
+ *   input       TEXT                   - 输入（JSON 字符串）
+ *   output      TEXT                   - 输出（JSON 字符串）
+ *   error       TEXT                   - 错误信息
+ *   started_at  TEXT                   - 开始时间 ISO
+ *   finished_at TEXT                   - 结束时间 ISO
+ *   duration_ms INTEGER               - 耗时毫秒
+ *   created_at  TEXT NOT NULL          - 创建时间 ISO
+ *   updated_at  TEXT                   - 更新时间 ISO
+ *   meta        TEXT                   - 扩展元信息（JSON 字符串）
+ *
+ * 索引：task_id、(task_id, seq)、status
+ *
+ * 依赖 SqliteAdapter（better-sqlite3）。
+ */
+const DDL = `
+CREATE TABLE IF NOT EXISTS task_steps (
+    id          TEXT PRIMARY KEY,
+    task_id     TEXT NOT NULL,
+    seq         INTEGER NOT NULL,
+    name        TEXT,
+    type        TEXT,
+    status      TEXT NOT NULL DEFAULT 'pending',
+    input       TEXT,
+    output      TEXT,
+    error       TEXT,
+    started_at  TEXT,
+    finished_at TEXT,
+    duration_ms INTEGER,
+    created_at  TEXT NOT NULL,
+    updated_at  TEXT,
+    meta        TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_task_steps_task_id ON task_steps(task_id);
+CREATE INDEX IF NOT EXISTS idx_task_steps_task_seq ON task_steps(task_id, seq);
+CREATE INDEX IF NOT EXISTS idx_task_steps_status ON task_steps(status);
+`;
+
+class TaskStepStore {
+    /**
+     * @param {object} options
+     * @param {import('../adapters/SqliteAdapter.js').default} options.sqlite - SQLite 适配器
+     */
+    constructor(options = {}) {
+        this.sqlite = options.sqlite;
+        if (!this.sqlite) {
+            throw new Error('TaskStepStore 需要 sqlite 适配器');
+        }
+        this._initialized = false;
+    }
+
+    /** 幂等建表 */
+    async _init() {
+        if (this._initialized) return;
+        await this.sqlite.exec(DDL);
+        this._initialized = true;
+    }
+
+    /**
+     * 创建一个任务步骤。
+     * @param {object} step
+     * @param {string} step.taskId
+     * @param {string} [step.id] - 指定记录 ID（默认 randomUUID）。传入后幂等 upsert。
+     * @param {string} [step.name]
+     * @param {string} [step.type]
+     * @param {string} [step.status='pending']
+     * @param {object} [step.input]
+     * @param {object} [step.output] - 已知输出（如终态补录场景）
+     * @param {string} [step.startedAt] - 开始时间 ISO（如 running 落库场景）
+     * @param {object} [step.meta]
+     * @returns {Promise<object>} 创建后的步骤记录
+     */
+    async create(step) {
+        await this._init();
+        const now = new Date().toISOString();
+        const id = step.id || randomUUID();
+        const seq = await this._nextSeq(step.taskId);
+        const row = {
+            id,
+            task_id: step.taskId,
+            seq,
+            name: step.name ?? null,
+            type: step.type ?? null,
+            status: step.status ?? 'pending',
+            input: step.input != null ? JSON.stringify(step.input) : null,
+            output: step.output != null ? JSON.stringify(step.output) : null,
+            error: null,
+            started_at: step.startedAt ?? null,
+            finished_at: null,
+            duration_ms: null,
+            created_at: now,
+            updated_at: now,
+            meta: step.meta != null ? JSON.stringify(step.meta) : null
+        };
+        await this.sqlite.upsert('task_steps', row);
+        return this._rowToObj(row);
+    }
+
+    /** 获取同任务内下一个 seq */
+    async _nextSeq(taskId) {
+        const row = await this.sqlite.get(
+            'SELECT MAX(seq) AS max_seq FROM task_steps WHERE task_id = ?',
+            [taskId]
+        );
+        return (row?.max_seq ?? 0) + 1;
+    }
+
+    /**
+     * 按 ID 获取步骤。
+     * @param {string} id
+     * @returns {Promise<object|null>}
+     */
+    async get(id) {
+        await this._init();
+        const row = await this.sqlite.get('SELECT * FROM task_steps WHERE id = ?', [id]);
+        return row ? this._rowToObj(row) : null;
+    }
+
+    /**
+     * 列出某任务的所有步骤（按 seq 升序）。
+     * @param {string} taskId
+     * @returns {Promise<Array<object>>}
+     */
+    async listByTask(taskId) {
+        await this._init();
+        const rows = await this.sqlite.all(
+            'SELECT * FROM task_steps WHERE task_id = ? ORDER BY seq ASC',
+            [taskId]
+        );
+        return rows.map(r => this._rowToObj(r));
+    }
+
+    /**
+     * 按状态查询步骤。
+     * @param {string} status
+     * @returns {Promise<Array<object>>}
+     */
+    async listByStatus(status) {
+        await this._init();
+        const rows = await this.sqlite.all(
+            'SELECT * FROM task_steps WHERE status = ? ORDER BY created_at ASC',
+            [status]
+        );
+        return rows.map(r => this._rowToObj(r));
+    }
+
+    /**
+     * 更新步骤状态（状态流转 + 时间戳 + 耗时）。
+     * @param {string} id
+     * @param {object} patch
+     * @param {string} [patch.status]
+     * @param {object} [patch.output]
+     * @param {string} [patch.error]
+     * @param {object} [patch.meta]
+     * @returns {Promise<object|null>} 更新后的步骤
+     */
+    async update(id, patch) {
+        await this._init();
+        const now = new Date().toISOString();
+        const updates = [];
+        const params = [];
+
+        if (patch.status) {
+            updates.push('status = ?'); params.push(patch.status);
+            // 状态流转时自动维护时间戳
+            if (patch.status === 'running' && !patch.started_at) {
+                updates.push('started_at = ?'); params.push(now);
+            }
+            if (['completed', 'error', 'skipped'].includes(patch.status) && !patch.finished_at) {
+                updates.push('finished_at = ?'); params.push(now);
+                // 计算耗时
+                const cur = await this.get(id);
+                if (cur?.startedAt) {
+                    const dur = Date.parse(now) - Date.parse(cur.startedAt);
+                    updates.push('duration_ms = ?'); params.push(dur);
+                }
+            }
+        }
+        if (patch.output != null) {
+            updates.push('output = ?'); params.push(JSON.stringify(patch.output));
+        }
+        if (patch.error != null) {
+            updates.push('error = ?'); params.push(patch.error);
+        }
+        if (patch.meta != null) {
+            updates.push('meta = ?'); params.push(JSON.stringify(patch.meta));
+        }
+        if (updates.length === 0) return this.get(id);
+
+        updates.push('updated_at = ?'); params.push(now);
+        params.push(id);
+        await this.sqlite.exec(
+            `UPDATE task_steps SET ${updates.join(', ')} WHERE id = ?`,
+            params
+        );
+        return this.get(id);
+    }
+
+    /**
+     * 删除步骤。
+     * @param {string} id
+     */
+    async delete(id) {
+        await this._init();
+        await this.sqlite.exec('DELETE FROM task_steps WHERE id = ?', [id]);
+        return true;
+    }
+
+    /**
+     * 删除某任务的所有步骤。
+     * @param {string} taskId
+     */
+    async deleteByTask(taskId) {
+        await this._init();
+        await this.sqlite.exec('DELETE FROM task_steps WHERE task_id = ?', [taskId]);
+        return true;
+    }
+
+    /**
+     * 任务步骤统计（各状态数量）。
+     * @param {string} taskId
+     * @returns {Promise<object>} { total, pending, running, completed, error, skipped }
+     */
+    async stats(taskId) {
+        await this._init();
+        const rows = await this.sqlite.all(
+            `SELECT status, COUNT(*) AS cnt FROM task_steps WHERE task_id = ? GROUP BY status`,
+            [taskId]
+        );
+        const result = { total: 0, pending: 0, running: 0, completed: 0, error: 0, skipped: 0 };
+        for (const r of rows) {
+            result[r.status] = r.cnt;
+            result.total += r.cnt;
+        }
+        return result;
+    }
+
+    // ─── 内部：行 → 业务对象（解包 JSON 字段，转驼峰）──────────────────────────
+
+    _rowToObj(row) {
+        return {
+            id: row.id,
+            taskId: row.task_id,
+            seq: row.seq,
+            name: row.name,
+            type: row.type,
+            status: row.status,
+            input: this._parseJson(row.input),
+            output: this._parseJson(row.output),
+            error: row.error,
+            startedAt: row.started_at,
+            finishedAt: row.finished_at,
+            durationMs: row.duration_ms,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+            meta: this._parseJson(row.meta)
+        };
+    }
+
+    _parseJson(s) {
+        if (!s) return null;
+        try { return JSON.parse(s); } catch { return s; }
+    }
+}
+
+export default TaskStepStore;