weaver-work-cli 0.1.28 → 0.1.31

package/dist/shortcuts/workflow/operations/todoSmartConvert/summaryCache.js

@@ -0,0 +1,326 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { stateRoot } from '../../../../core/state.js';
+/**
+ * `todoSmartConvert` 的**单条摘要缓存**（放在 Agent 真实 skill 目录下）。
+ *
+ * 只缓存摘要文本：详情是流水线中的临时事实，需要时重新请求并在本次调用内复用；
+ * 摘要是模型产出的结果，跨任务复用可以减少重复的模型调用。
+ *
+ * 缓存位置不放在项目工作区：
+ *  - 摘要是「这条流程的业务内容」，跟着 skill 走更合理；
+ *  - 缓存优先落在实际使用的 skill 目录，不写入项目工作区；
+ *  - skill 目录随 skill 安装/卸载一起生效，换机器时可由 skill 分发带走（或自然失效）。
+ *
+ * 生命周期：**跨任务 7 天**。key 是 `${requestId}__${lastFeedBackDateTime}`，value 是该条的单条摘要。
+ * 流程有了新反馈（lastFeedBackDateTime 变化）key 就变了，摘要自然失效、重新生成——
+ * 用业务时间做版本号，比记录「摘要生成时间」更准。
+ *
+ * 目录定位顺序：`WEAVER_WORK_CLI_CACHE_DIR`（直接指定缓存目录，测试用）→
+ * `WEAVER_WORK_CLI_SKILL_DIR`（直接指定 skill 目录）→ 已知 Agent 的全局 skill 根目录
+ * （`~/.workbuddy/skills`、`~/.claude/skills` …）→ 全部不存在时退回 CLI 状态目录（并在 warnings 里说明）。
+ */
+/** 与 `skills/` 下发布的目录名一致。 */
+const SKILL_DIR_NAME = 'weaver-e10-workflow';
+/** skill 内的缓存子目录。 */
+const CACHE_DIR_NAME = 'cache';
+/**
+ * 已知 Agent 产物的用户级根目录（按优先级）。
+ *
+ * 只看 `~/<agent>/skills/<skill>/SKILL.md` 是否存在——存在即认为「这个 Agent 装了这个 skill」。
+ * **不看工作区里的 `.workbuddy/skills`**：项目内目录属于「本地项目」，用户明确不让缓存放那儿。
+ */
+const AGENT_HOME_DIRS = ['.workbuddy', '.claude', '.codebuddy', '.codex', '.cursor', '.gemini'];
+/** 单条摘要缓存（跨任务，7 天）。 */
+export const SUMMARY_CACHE_FILE_NAME = 'todo-summary-cache.json';
+/**
+ * 摘要缓存的**规则版本**。
+ *
+ * 版本变化时旧条目整体视为不可用，避免不同摘要字数口径混用。
+ */
+export const SUMMARY_CACHE_VERSION = 2;
+function uniqueDirs(dirs) {
+    return [...new Set(dirs.filter(Boolean))];
+}
+function stateCacheDir(ctx) {
+    return resolve(stateRoot(ctx), CACHE_DIR_NAME);
+}
+/**
+ * 扫已知 Agent 的 skills 根，找「本 skill 的目录」——判据是 `references/todo-smart-convert.md` 存在。
+ * 用于 skill 目录被改名（例如本地测试副本）后仍能定位到已攒的摘要缓存。
+ */
+function discoverThisSkillDirs(home) {
+    const marker = join('references', 'todo-smart-convert.md');
+    const found = [];
+    for (const agent of AGENT_HOME_DIRS) {
+        const root = join(home, agent, 'skills');
+        const entries = (() => {
+            try {
+                return readdirSync(root, { withFileTypes: true });
+            }
+            catch {
+                return [];
+            }
+        })();
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const dir = join(root, entry.name);
+            if (existsSync(join(dir, marker)))
+                found.push(dir);
+        }
+    }
+    return found;
+}
+/** 读文件 mtime（毫秒）；读不到（不存在/无权限）返回 0。 */
+function mtimeOf(file) {
+    try {
+        return statSync(file).mtimeMs;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * 多个候选 skill 目录同时存在时，优先选择已有缓存且安装完整的目录。
+ *
+ * 排序键（依次比较，越小越优先）：
+ *  1. 目录里**已有摘要缓存** ⇒ 优先（连续性：别把攒好的摘要换到另一份安装上）
+ *  2. 有 `references/todo-smart-convert.md` ⇒ 优先（完整安装优于半解压的残目录）
+ *  3. `SKILL.md` 的 mtime 更新 ⇒ 优先（刚复制/刚升级的那份大概率就是正在用的）
+ *  4. 原始顺序（`WEAVER_WORK_CLI_SKILL_DIR` 指定的永远排最前）
+ */
+function rankSkillDirs(dirs) {
+    const scored = dirs.map((dir, index) => ({
+        dir,
+        index,
+        hasCache: existsSync(join(dir, CACHE_DIR_NAME, SUMMARY_CACHE_FILE_NAME)) ? 1 : 0,
+        cacheMtime: mtimeOf(join(dir, CACHE_DIR_NAME, SUMMARY_CACHE_FILE_NAME)),
+        hasMarker: existsSync(join(dir, 'references', 'todo-smart-convert.md')) ? 1 : 0,
+        skillMtime: mtimeOf(join(dir, 'SKILL.md')),
+    }));
+    scored.sort((a, b) => b.hasCache - a.hasCache
+        || b.cacheMtime - a.cacheMtime
+        || b.hasMarker - a.hasMarker
+        || b.skillMtime - a.skillMtime
+        || a.index - b.index);
+    return scored.map((item) => item.dir);
+}
+/** 定位缓存目录（不创建目录，纯路径计算）。 */
+export function cacheRoots(ctx) {
+    const fallback = stateCacheDir(ctx);
+    const explicitCache = process.env.WEAVER_WORK_CLI_CACHE_DIR?.trim();
+    if (explicitCache) {
+        const dir = resolve(explicitCache);
+        return { preferred: dir, fallback: dir, inSkillDir: false, skillDir: null };
+    }
+    const home = homedir();
+    const explicitSkill = process.env.WEAVER_WORK_CLI_SKILL_DIR?.trim();
+    const candidates = [];
+    if (explicitSkill)
+        candidates.push(resolve(explicitSkill));
+    for (const agent of AGENT_HOME_DIRS) {
+        candidates.push(join(home, agent, 'skills', SKILL_DIR_NAME));
+    }
+    // 目录名可能被改（如本地测试副本 `todoSmartGroupTest`）：再按「本 skill 的特征文件」扫一遍，
+    // 避免改名后缓存落到 CLI 状态目录、把已攒的摘要全丢掉。
+    candidates.push(...discoverThisSkillDirs(home));
+    // 只认「装了本 skill」的目录，再在多份安装之间择优（见 rankSkillDirs）。
+    const installed = uniqueDirs(candidates).filter((dir) => existsSync(join(dir, 'SKILL.md')));
+    const [skillDir] = rankSkillDirs(installed);
+    if (skillDir) {
+        return {
+            preferred: join(skillDir, CACHE_DIR_NAME),
+            fallback,
+            inSkillDir: true,
+            skillDir,
+        };
+    }
+    return { preferred: fallback, fallback, inSkillDir: false, skillDir: null };
+}
+export async function readCacheFile(roots, fileName) {
+    for (const dir of uniqueDirs([roots.preferred, roots.fallback])) {
+        const file = join(dir, fileName);
+        if (!existsSync(file))
+            continue;
+        try {
+            return { text: await readFile(file, 'utf8'), file };
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+/**
+ * 写缓存文件。**直接覆盖写，不做 rename 原子替换**（与 `workflow/state.ts` 同一条结论：
+ * 宿主沙箱里 `rename` 恒被拦，还会连带产生删除动作与审批弹窗）。
+ * 首选目录不可写（只读安装、权限不足）时退回 CLI 状态目录；两处都失败返回 null——
+ * 缓存是加速设施，写不进去也绝不能让主流程失败。
+ */
+export async function writeCacheFile(roots, fileName, payload) {
+    for (const dir of uniqueDirs([roots.preferred, roots.fallback])) {
+        const file = join(dir, fileName);
+        try {
+            await mkdir(dir, { recursive: true, mode: 0o700 });
+            await writeFile(file, payload, { mode: 0o600 });
+            if (process.platform !== 'win32')
+                await chmod(file, 0o600).catch(() => undefined);
+            return file;
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// 单条摘要缓存（跨任务）
+// ---------------------------------------------------------------------------
+/** 摘要有效期：7 天。 */
+export const SUMMARY_CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+/**
+ * 物理清理间隔：3 天。
+ *
+ * 读的时候本来就会把过期条目「当作不存在」，但那只是逻辑过期——文件里的脏数据还在长。
+ * 每 3 天在触发（任意一次打开缓存）时做一次按需清理，把过期条目真正从文件里删掉。
+ */
+export const SUMMARY_CACHE_PRUNE_INTERVAL_MS = 3 * 24 * 60 * 60 * 1000;
+/**
+ * 缓存 key：`<requestId>__<lastFeedBackDateTime>`。
+ *
+ * 把**最后反馈时间**拼进 key 是关键设计：流程一旦有新反馈，业务内容就变了，
+ * 旧摘要必须失效、重新生成。用业务时间当版本号，比「摘要生成时间 + TTL」更准，
+ * 也不会因为「刚写完摘要但流程又动了」而给出过期总结。
+ */
+export function summaryCacheKey(requestId, lastFeedBackDateTime) {
+    const stamp = String(lastFeedBackDateTime ?? '').trim();
+    return `${requestId}__${stamp}`;
+}
+/**
+ * 缓存条目是否与当前目标字数口径匹配。
+ *
+ * 不传 `maxChars` 时不按字数过滤；传入后必须与写入口径一致。
+ */
+function entryMatchesMaxChars(entry, maxChars) {
+    if (maxChars === undefined)
+        return true;
+    return (entry.maxChars ?? 50) === maxChars;
+}
+function normalizeSummaryEntry(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const entry = raw;
+    if (typeof entry.summary !== 'string' || !entry.summary.trim())
+        return null;
+    if (typeof entry.cachedAt !== 'number' || !Number.isFinite(entry.cachedAt))
+        return null;
+    const maxChars = typeof entry.maxChars === "number" && Number.isFinite(entry.maxChars) ? entry.maxChars : undefined;
+    return { summary: entry.summary, cachedAt: entry.cachedAt, ...(maxChars === undefined ? {} : { maxChars }) };
+}
+/**
+ * 打开摘要缓存（读 + 按需清理）。
+ *
+ * 清理规则：
+ *  - **逻辑过期 7 天**：`cachedAt` 超过 7 天的条目，读的时候直接当不存在；
+ *  - **物理清理 3 天**：距上次清理超过 3 天，就在这次打开时把过期条目真正写掉（顺带压缩文件）。
+ *    这样文件不会因为「只读不写」永远留着过期数据，也不会每次打开都重写一遍。
+ */
+export async function openSummaryCache(ctx) {
+    const roots = cacheRoots(ctx);
+    const stored = await readCacheFile(roots, SUMMARY_CACHE_FILE_NAME);
+    const now = Date.now();
+    const entries = new Map();
+    let prunedAt = 0;
+    let loadedCount = 0;
+    // 文件不存在（或暂时不可读）就是首次运行：按空缓存继续，不追查原因、不阻塞主流程。
+    if (stored) {
+        try {
+            const parsed = JSON.parse(stored.text);
+            prunedAt = typeof parsed.prunedAt === 'number' ? parsed.prunedAt : 0;
+            // 版本不符 = 旧口径写的摘要，整份当不存在（下一次写会覆盖掉）
+            const versionOk = parsed.version === SUMMARY_CACHE_VERSION;
+            const rawEntries = versionOk && parsed.entries && typeof parsed.entries === 'object'
+                ? parsed.entries
+                : {};
+            for (const [key, raw] of Object.entries(rawEntries)) {
+                const entry = normalizeSummaryEntry(raw);
+                if (!entry)
+                    continue;
+                loadedCount += 1;
+                if (now - entry.cachedAt > SUMMARY_CACHE_TTL_MS)
+                    continue;
+                entries.set(key, entry);
+            }
+        }
+        catch {
+            // 坏文件按空缓存处理（下一次写会整体覆盖掉）
+        }
+    }
+    const pruned = loadedCount - entries.size;
+    // 距上次物理清理超过 3 天（或从未清理过）且文件确实存在 ⇒ 现在就清理。
+    // 文件不存在时不必凭空创建一个空文件。
+    const pruneDue = stored !== null && (prunedAt === 0 || now - prunedAt > SUMMARY_CACHE_PRUNE_INTERVAL_MS);
+    let file = stored?.file ?? null;
+    let dirty = false;
+    const cache = {
+        file,
+        inSkillDir: roots.inSkillDir,
+        size: entries.size,
+        hits: 0,
+        misses: 0,
+        pruned,
+        dirty: false,
+        get(requestId, lastFeedBackDateTime, maxChars) {
+            const key = summaryCacheKey(requestId, lastFeedBackDateTime);
+            const entry = entries.get(key);
+            if (entry && now - entry.cachedAt <= SUMMARY_CACHE_TTL_MS && entryMatchesMaxChars(entry, maxChars)) {
+                cache.hits += 1;
+                return entry.summary;
+            }
+            cache.misses += 1;
+            return null;
+        },
+        has(requestId, lastFeedBackDateTime, maxChars) {
+            const entry = entries.get(summaryCacheKey(requestId, lastFeedBackDateTime));
+            return entry !== undefined && entryMatchesMaxChars(entry, maxChars);
+        },
+        set(requestId, lastFeedBackDateTime, summary, maxChars) {
+            const text = String(summary ?? '').trim();
+            if (!requestId || !text)
+                return false;
+            entries.set(summaryCacheKey(requestId, lastFeedBackDateTime), {
+                summary: text,
+                cachedAt: Date.now(),
+                ...(maxChars === undefined ? {} : { maxChars }),
+            });
+            dirty = true;
+            cache.dirty = true;
+            cache.size = entries.size;
+            return true;
+        },
+        async save() {
+            if (!dirty && !pruneDue)
+                return file;
+            const payload = {
+                version: SUMMARY_CACHE_VERSION,
+                prunedAt: Date.now(),
+                entries: Object.fromEntries(entries),
+            };
+            const written = await writeCacheFile(roots, SUMMARY_CACHE_FILE_NAME, JSON.stringify(payload));
+            if (written) {
+                file = written;
+                cache.file = written;
+                dirty = false;
+                cache.dirty = false;
+            }
+            return written;
+        },
+    };
+    // 清理到期：立刻把过滤后的内容写回（哪怕本次没有新增条目）。
+    if (pruneDue)
+        await cache.save();
+    return cache;
+}

package/dist/shortcuts/workflow/operations/todoSmartConvert/todoDetailCache.js

@@ -0,0 +1,113 @@
+import { cacheRoots, readCacheFile, writeCacheFile, SUMMARY_CACHE_PRUNE_INTERVAL_MS, SUMMARY_CACHE_TTL_MS, } from './summaryCache.js';
+/**
+ * **流程详情数据缓存**（与摘要缓存并存，互不替代）。
+ *
+ * 规则（用户 2026-10-26 定稿）：
+ *  - 键：`requestId__lastFeedBackDateTime`（与该条待办的业务时间绑定——流程一动就换键）；
+ *  - 有效期：7 天，与摘要缓存一致；读的时候逻辑过期，超过清理间隔（3 天）时物理剔除；
+ *  - **不设版本号**：过期条目逐条剔除、新条目直接加入，不做整份失效；
+ *  - 详情为空的条目**也写**（`contextAvailable:false`），否则这类条目每次都要重拉；
+ *  - 缓存文件缺失 ⇒ 视为从未缓存过，正常走接口。
+ *
+ * 位置：与摘要缓存同一个 `cache/` 目录（skill 目录优先，不可写时退回 CLI 状态目录）。
+ */
+export const DETAIL_CACHE_FILE_NAME = 'todo-detail-cache.json';
+/** 与摘要缓存一致：7 天。 */
+export const DETAIL_CACHE_TTL_MS = SUMMARY_CACHE_TTL_MS;
+/** 与摘要缓存一致：清理间隔 3 天。 */
+export const DETAIL_CACHE_PRUNE_INTERVAL_MS = SUMMARY_CACHE_PRUNE_INTERVAL_MS;
+export function detailCacheKey(requestId, lastFeedBackDateTime) {
+    const stamp = String(lastFeedBackDateTime ?? '').trim();
+    return `${requestId}__${stamp}`;
+}
+function normalizeEntry(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const value = raw;
+    if (typeof value.cachedAt !== 'number' || !Number.isFinite(value.cachedAt))
+        return null;
+    if (typeof value.context !== 'string')
+        return null;
+    const fields = Array.isArray(value.fields)
+        ? value.fields
+            .filter((item) => Boolean(item) && typeof item.fieldName === 'string'
+            && typeof item.value === 'string')
+            .map((item) => ({ fieldName: item.fieldName, value: item.value }))
+        : [];
+    const metrics = value.metrics && typeof value.metrics === 'object' ? value.metrics : {};
+    return {
+        context: value.context,
+        contextAvailable: value.contextAvailable === true,
+        metrics,
+        fields,
+        cachedAt: value.cachedAt,
+    };
+}
+export async function openDetailCache(ctx) {
+    const roots = cacheRoots(ctx);
+    const stored = await readCacheFile(roots, DETAIL_CACHE_FILE_NAME);
+    const now = Date.now();
+    const entries = new Map();
+    let prunedAt = 0;
+    let loaded = 0;
+    let pruned = 0;
+    // 文件不存在 = 首次运行：按空缓存继续，不追查原因、不阻塞主流程。
+    if (stored) {
+        try {
+            const parsed = JSON.parse(stored.text);
+            prunedAt = typeof parsed.prunedAt === 'number' ? parsed.prunedAt : 0;
+            for (const [key, raw] of Object.entries(parsed.entries ?? {})) {
+                const entry = normalizeEntry(raw);
+                if (!entry)
+                    continue;
+                // 逻辑过期：超 7 天直接当不存在（并在本轮清理时物理剔除）
+                if (now - entry.cachedAt > DETAIL_CACHE_TTL_MS) {
+                    pruned += 1;
+                    continue;
+                }
+                entries.set(key, entry);
+                loaded += 1;
+            }
+        }
+        catch {
+            // 坏文件等同没有缓存：下一次写入会覆盖
+        }
+    }
+    const cache = {
+        file: stored?.file ?? null,
+        pruned: 0,
+        loaded,
+        get(requestId, lastFeedBackDateTime) {
+            const entry = entries.get(detailCacheKey(requestId, lastFeedBackDateTime));
+            if (!entry)
+                return null;
+            if (Date.now() - entry.cachedAt > DETAIL_CACHE_TTL_MS)
+                return null;
+            return entry;
+        },
+        has(requestId, lastFeedBackDateTime) {
+            return cache.get(requestId, lastFeedBackDateTime) !== null;
+        },
+        set(requestId, lastFeedBackDateTime, entry) {
+            if (!requestId)
+                return false;
+            entries.set(detailCacheKey(requestId, lastFeedBackDateTime), { ...entry, cachedAt: Date.now() });
+            return true;
+        },
+        async save() {
+            // 物理清理：距上次清理超过 3 天才真正重写，避免每次打开都写盘。
+            const shouldPrune = pruned > 0 && Date.now() - prunedAt > DETAIL_CACHE_PRUNE_INTERVAL_MS;
+            const payload = {
+                prunedAt: shouldPrune ? Date.now() : prunedAt,
+                entries: Object.fromEntries(entries),
+            };
+            const file = await writeCacheFile(roots, DETAIL_CACHE_FILE_NAME, JSON.stringify(payload));
+            if (file)
+                cache.file = file;
+            if (shouldPrune)
+                cache.pruned = pruned;
+            return file;
+        },
+    };
+    return cache;
+}