dsh-task-ledger 0.0.7 → 0.0.9

package/dist/host/board.d.ts

@@ -1,23 +1,70 @@
 import type { HistoryRecord, LedgerFilter, LedgerWorkspace, TaskRow } from './types.js';
-/** 已结案列表默认分页大小（「加载更多」= 调用方加大 limit 重取）。 */
-export declare const DEFAULT_HISTORY_LIMIT = 500;
-/** 首页统计卡的两个完成类计数。 */
-export interface ClosedCounts {
-    /** 本周已完成（最近 2 个月文件内、创建时间落在本周）。 */
-    readonly weekDone: number;
-    /** 近一年完成（最近 13 个月文件行数；capped = 已触顶，值即下限）。 */
-    readonly yearDone: number;
-    readonly yearCapped: boolean;
+/** 停滞判定阈值：doing / blocked 且 created 至今超过这么多天（2026-10-17 拍板，显示级）。 */
+export declare const STALE_DAYS = 14;
+/** 趋势图桶数：近 8 周（2026-10-17 定稿）。 */
+export declare const WEEKLY_WEEKS = 8;
+/** 一个自然周期内的两个计数（核心永远是「完成」，新增只作对照）。 */
+export interface PeriodCounts {
+    readonly done: number;
+    readonly created: number;
+    /** 周期起（YYYY-MM-DD，含）。 */
+    readonly from: string;
+    /** 周期止（YYYY-MM-DD，含）。 */
+    readonly to: string;
+}
+/** 统计台四个自然周期（用户 2026-10-17 定稿：本周 / 上周 / 本月 / 上月，不用 7/30 天）。 */
+export interface TrendPeriods {
+    readonly thisWeek: PeriodCounts;
+    readonly lastWeek: PeriodCounts;
+    readonly thisMonth: PeriodCounts;
+    readonly lastMonth: PeriodCounts;
+}
+/** 趋势图一桶（一周）：完成 + 新增。 */
+export interface WeeklyBucket {
+    /** 该周周一（YYYY-MM-DD）。 */
+    readonly week: string;
+    readonly done: number;
+    readonly created: number;
+}
+/** 趋势图数据按范围各一份（切换零请求）。 */
+export interface ClosedSummary {
+    readonly weekly: {
+        readonly all: readonly WeeklyBucket[];
+        readonly mine: readonly WeeklyBucket[];
+    };
+}
+/** 首页统计卡的六个面（阈值 / 天数全在 host 算，前端只渲染——单一真源）。 */
+export interface BoardStats {
+    /** 我的 doing + blocked。 */
+    readonly myActive: number;
+    /** 我的 blocked。 */
+    readonly myBlocked: number;
+    /** 待认领（open）。 */
+    readonly open: number;
+    /** 全部 doing。 */
+    readonly doing: number;
+    /** 全部 blocked。 */
+    readonly blocked: number;
+    /** 停滞 = doing|blocked 且 ageDays > STALE_DAYS。 */
+    readonly stale: number;
+    /** 停滞阈值（天）——随响应下发，界面文案不硬编码（单一真源）。 */
+    readonly staleDays: number;
+    /** 最老一条待认领躺了多少天（没有待认领 = null）。 */
+    readonly oldestOpenDays: number | null;
+}
+/** 列表行附加工资字段（host 算，前端不判阈值）。 */
+export interface BoardTask extends TaskRow {
+    /** 认领后未动天数（doing / blocked；open 与解析不了的时间为 null）。 */
+    readonly ageDays: number | null;
+    /** 停滞标记。 */
+    readonly stale: boolean;
 }
 export interface BoardSnapshot {
     readonly at: string;
     readonly workspaces: readonly LedgerWorkspace[];
     /** 全部在办任务（UI 自己筛「我的 / 待认领」——筛选是前端的事）。 */
-    readonly tasks: readonly TaskRow[];
-    readonly stats: {
-        readonly myActive: number;
-        readonly open: number;
-    };
+    readonly tasks: readonly BoardTask[];
+    readonly stats: BoardStats;
     /**
      * 工作区 id → 该工作区的当前 git 身份（取不到为 null）。
      * 「我的待办」在前端按 `owner === identities[workspace.id]` 筛——身份只在 host 侧取得到
@@ -25,6 +72,12 @@ export interface BoardSnapshot {
      */
     readonly identities: Readonly<Record<string, string | null>>;
 }
+/** 首页一次 `/board` 的全部聚合（**每个工作区只读一次** list + history + git 身份）。 */
+export interface HomeAggregate {
+    readonly snapshot: BoardSnapshot;
+    readonly closed: ClosedSummary;
+    readonly trend: TrendPeriods;
+}
 /**
  * 当前 git 身份（cwd = 该工作区）——「我的待办」判定源。
  * 与 agent 在会话里跑 skill 时的取值环境一致；取不到回 null（非 git 目录 / 没配身份），
@@ -32,15 +85,13 @@ export interface BoardSnapshot {
  */
 export declare function getCurrentIdentity(workspace: LedgerWorkspace): Promise<string | null>;
 /**
- * 首页快照（在办路径）：并发跑全部工作区的 list + 身份解析。
- * 与历史量彻底无关——progress.json 只装没结案的任务（close 会移走），永远有界。
+ * 首页一次拿全：在办快照（含停滞 / 天数 / 身份）+ 近 8 周趋势（完成 / 新增 × 所有 / 我的）
+ * + 四个自然周期计数。**每个工作区只读一次**（list + history + git 身份），
+ * 避免「快照读一遍、统计再读一遍」把 5 万行级工作区的 history 解析翻倍。
  */
+export declare function getHomeAggregate(workspaces: readonly LedgerWorkspace[]): Promise<HomeAggregate>;
+/** 只拿在办快照（薄封装：测试 / 其它调用方用；首页走 {@link getHomeAggregate} 一次读全）。 */
 export declare function getBoardSnapshot(workspaces: readonly LedgerWorkspace[]): Promise<BoardSnapshot>;
-/**
- * 完成类统计（数行封顶，与总量脱钩）：本周 = 最近 2 个月文件 + 创建时间落在本周；
- * 近一年 = 最近 13 个月文件行数。任一工作区失败即抛（聚合数部分失败 = 错数，不兜）。
- */
-export declare function getClosedCounts(workspaces: readonly LedgerWorkspace[]): Promise<ClosedCounts>;
 /**
  * 已结案列表：默认近 13 个月 + limit 500，跨工作区合并后按创建时间倒序。
  * shortcut: 分页用「加大 limit 重取」的笨办法（skill 脚本无 offset）；

package/dist/host/board.js

@@ -1,20 +1,67 @@
 import { spawn } from 'node:child_process';
 import { readHistory, readTasks } from './ledger-read.js';
-import { runLedgerScript } from './script.js';
 /** 历史窗口：只读最近 13 个月的文件（2026-10-17 拍板；脚本默认读全部，窗口由插件显式传）。 */
 const RECENT_MONTHS = 13;
 /** 已结案列表默认分页大小（「加载更多」= 调用方加大 limit 重取）。 */
-export const DEFAULT_HISTORY_LIMIT = 500;
-/** 完成类统计的封顶值：超出显示「1万+」（2026-10-17 拍板，显示级封顶，精确值走搜索）。 */
-const COUNT_CAP = 10_000;
-/** 周一所在日期（YYYY-MM-DD）。skill 的 --since 只给日期按当天 00:00 解析。 */
-function mondayDateString(now) {
-    const date = new Date(now);
-    const mondayOffset = (date.getDay() + 6) % 7;
-    date.setDate(date.getDate() - mondayOffset);
-    const pad = (value) => String(value).padStart(2, '0');
+const DEFAULT_HISTORY_LIMIT = 500;
+/** 停滞判定阈值：doing / blocked 且 created 至今超过这么多天（2026-10-17 拍板，显示级）。 */
+export const STALE_DAYS = 14;
+/** 趋势图桶数：近 8 周（2026-10-17 定稿）。 */
+export const WEEKLY_WEEKS = 8;
+/* ── 日期工具（本机时区；skill 脚本同口径：周一为一周之始）───────────────── */
+function pad(value) {
+    return String(value).padStart(2, '0');
+}
+/** Date → `YYYY-MM-DD`。 */
+function ymd(date) {
     return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
 }
+/** 时刻串（`YYYY-MM-DD HH:mm:ss` / `YYYY-MM-DD`）→ 日期部分；解析不了回 null。 */
+function dayOf(stamp) {
+    if (stamp === null || stamp === undefined || stamp === '')
+        return null;
+    const day = String(stamp).slice(0, 10);
+    return /^\d{4}-\d{2}-\d{2}$/.test(day) ? day : null;
+}
+/** 某日期所在周的周一（00:00）。 */
+function mondayOf(day) {
+    const date = new Date(`${day}T00:00:00`);
+    date.setDate(date.getDate() - ((date.getDay() + 6) % 7));
+    return date;
+}
+/** 第 offset 周的起止（offset 0 = 本周，-1 = 上周；返回日期串，含边界）。
+ *  ⚠️ 本周只到今天（周还没结束），上周才是完整周一~周日——否则「本周」会把明天之后的
+ *  日子也画进区间，tooltip 里的截止日撒谎。 */
+function weekWindow(offset, now) {
+    const monday = mondayOf(ymd(now));
+    monday.setDate(monday.getDate() + offset * 7);
+    const sunday = new Date(monday);
+    sunday.setDate(sunday.getDate() + 6);
+    const last = offset === 0 ? now : sunday;
+    return { from: ymd(monday), to: ymd(last < sunday ? last : sunday) };
+}
+/** 第 offset 月的起止（offset 0 = 本月，-1 = 上月；含边界）。
+ *  同 {@link weekWindow}：本月只到今天，上月才是完整自然月。 */
+function monthWindow(offset, now) {
+    const first = new Date(now.getFullYear(), now.getMonth() + offset, 1);
+    const last = new Date(now.getFullYear(), now.getMonth() + offset + 1, 0);
+    const end = offset === 0 ? now : last;
+    return { from: ymd(first), to: ymd(end < last ? end : last) };
+}
+/** 日期是否落在 [from, to]（含边界，字符串比较即可——ISO 字典序即时间序）。 */
+function inWindow(day, window) {
+    return day !== null && day >= window.from && day <= window.to;
+}
+/** 「YYYY-MM-DD HH:mm:ss」→ 距今天数（解析不了 / 未来都按 0；不编造）。 */
+function daysSince(stamp, now) {
+    if (stamp === null || stamp === undefined || stamp === '')
+        return null;
+    const parsed = new Date(String(stamp).replace(' ', 'T'));
+    if (Number.isNaN(parsed.getTime()))
+        return null;
+    const days = Math.floor((now.getTime() - parsed.getTime()) / 86_400_000);
+    return days > 0 ? days : 0;
+}
 /**
  * 当前 git 身份（cwd = 该工作区）——「我的待办」判定源。
  * 与 agent 在会话里跑 skill 时的取值环境一致；取不到回 null（非 git 目录 / 没配身份），
@@ -32,47 +79,133 @@ export function getCurrentIdentity(workspace) {
         });
     });
 }
+/** 一个工作区读全（list + history + git 身份）——首页所有数字的共同原料。 */
+async function readWorkspace(workspace) {
+    const [tasks, history, identity] = await Promise.all([
+        readTasks(workspace),
+        readHistory(workspace, { months: RECENT_MONTHS }),
+        getCurrentIdentity(workspace),
+    ]);
+    return { workspace, tasks, history, identity };
+}
+/** 计数一批记录 / 任务（按范围过滤 owner；`mine` 时 identity 为 null 的一律不计）。 */
+function countPeriod(entries, window) {
+    return entries.filter((entry) => inWindow(entry.day, window)).length;
+}
 /**
- * 首页快照（在办路径）：并发跑全部工作区的 list + 身份解析。
- * 与历史量彻底无关——progress.json 只装没结案的任务（close 会移走），永远有界。
+ * 首页一次拿全：在办快照（含停滞 / 天数 / 身份）+ 近 8 周趋势（完成 / 新增 × 所有 / 我的）
+ * + 四个自然周期计数。**每个工作区只读一次**（list + history + git 身份），
+ * 避免「快照读一遍、统计再读一遍」把 5 万行级工作区的 history 解析翻倍。
  */
-export async function getBoardSnapshot(workspaces) {
-    const perWorkspace = await Promise.all(workspaces.map(async (workspace) => ({
-        workspace,
-        tasks: await readTasks(workspace),
-        identity: await getCurrentIdentity(workspace),
-    })));
-    const tasks = perWorkspace.flatMap((entry) => entry.tasks);
+export async function getHomeAggregate(workspaces) {
+    const now = new Date();
+    const perWorkspace = await Promise.all(workspaces.map(readWorkspace));
+    // ── 快照（在办路径，与历史量无关）────────────────────────────────────
+    const withMeta = perWorkspace.flatMap((entry) => entry.tasks.map((task) => {
+        const working = task.status === 'doing' || task.status === 'blocked';
+        const ageDays = working ? daysSince(task.started ?? task.created, now) : null;
+        return { ...task, ageDays, stale: ageDays !== null && ageDays > STALE_DAYS };
+    }));
+    const openTasks = withMeta.filter((task) => task.status === 'open');
+    const blockedTasks = withMeta.filter((task) => task.status === 'blocked');
     const myActive = perWorkspace.reduce((sum, entry) => sum + entry.tasks.filter((task) => task.owner === entry.identity && (task.status === 'doing' || task.status === 'blocked')).length, 0);
-    const open = tasks.filter((task) => task.status === 'open').length;
+    const myBlocked = perWorkspace.reduce((sum, entry) => sum + entry.tasks.filter((task) => task.owner === entry.identity && task.status === 'blocked').length, 0);
     const identities = {};
     for (const entry of perWorkspace)
         identities[entry.workspace.id] = entry.identity;
-    return { at: new Date().toISOString(), workspaces, tasks, stats: { myActive, open }, identities };
-}
-/**
- * 完成类统计（数行封顶，与总量脱钩）：本周 = 最近 2 个月文件 + 创建时间落在本周；
- * 近一年 = 最近 13 个月文件行数。任一工作区失败即抛（聚合数部分失败 = 错数，不兜）。
- */
-export async function getClosedCounts(workspaces) {
-    const monday = mondayDateString(new Date());
-    const perWorkspace = await Promise.all(workspaces.map(async (workspace) => {
-        const [week, year] = await Promise.all([
-            runLedgerScript('history', ['--repo', workspace.path, '--json', '--count-only', '--months', '2', '--since', monday]),
-            runLedgerScript('history', ['--repo', workspace.path, '--json', '--count-only', '--months', String(RECENT_MONTHS)]),
-        ]);
-        if (!week.ok)
-            throw new Error(`${workspace.title}: ${week.error}`);
-        if (!year.ok)
-            throw new Error(`${workspace.title}: ${year.error}`);
-        return { week: week.data.count ?? 0, year: year.data.count ?? 0, yearCapped: year.data.capped === true };
-    }));
-    const yearCapped = perWorkspace.some((entry) => entry.yearCapped);
-    return {
-        weekDone: perWorkspace.reduce((sum, entry) => sum + entry.week, 0),
-        yearDone: yearCapped ? COUNT_CAP : perWorkspace.reduce((sum, entry) => sum + entry.year, 0),
-        yearCapped,
+    const snapshot = {
+        at: now.toISOString(),
+        workspaces,
+        tasks: withMeta,
+        stats: {
+            myActive,
+            myBlocked,
+            open: openTasks.length,
+            doing: withMeta.filter((task) => task.status === 'doing').length,
+            blocked: blockedTasks.length,
+            stale: withMeta.filter((task) => task.stale).length,
+            staleDays: STALE_DAYS,
+            oldestOpenDays: openTasks.length === 0
+                ? null
+                : openTasks.reduce((max, task) => Math.max(max, daysSince(task.created, now) ?? 0), 0),
+        },
+        identities,
     };
+    // ── 趋势：近 8 周（完成按结案时间、新增按创建时间）× 所有 / 我的 ────────
+    // 新增必须**合并两个来源**：已结案的任务被 close 移出 progress.json，只在 history 里；
+    // 在办的只在 progress.json 里。两者不相交（close 是移动），合并即全集、不会重复计。
+    const weeks = [];
+    for (let offset = WEEKLY_WEEKS - 1; offset >= 0; offset -= 1)
+        weeks.push(weekWindow(-offset, now).from);
+    const bucketsAll = new Map(weeks.map((week) => [week, { done: 0, created: 0 }]));
+    const bucketsMine = new Map(weeks.map((week) => [week, { done: 0, created: 0 }]));
+    const bump = (map, week, field) => {
+        const bucket = map.get(week);
+        if (bucket !== undefined)
+            map.set(week, { ...bucket, [field]: bucket[field] + 1 });
+    };
+    for (const entry of perWorkspace) {
+        for (const task of entry.tasks) {
+            const created = dayOf(task.created);
+            if (created === null)
+                continue;
+            const week = ymd(mondayOf(created));
+            bump(bucketsAll, week, 'created');
+            if (entry.identity !== null && task.owner === entry.identity)
+                bump(bucketsMine, week, 'created');
+        }
+        for (const record of entry.history) {
+            const closed = dayOf(record.time);
+            if (closed !== null) {
+                const week = ymd(mondayOf(closed));
+                bump(bucketsAll, week, 'done');
+                if (entry.identity !== null && record.owner === entry.identity)
+                    bump(bucketsMine, week, 'done');
+            }
+            const created = dayOf(record.created);
+            if (created !== null) {
+                const week = ymd(mondayOf(created));
+                bump(bucketsAll, week, 'created');
+                if (entry.identity !== null && record.owner === entry.identity)
+                    bump(bucketsMine, week, 'created');
+            }
+        }
+    }
+    const closed = {
+        weekly: {
+            all: weeks.map((week) => ({ week, ...bucketsAll.get(week) ?? { done: 0, created: 0 } })),
+            mine: weeks.map((week) => ({ week, ...bucketsMine.get(week) ?? { done: 0, created: 0 } })),
+        },
+    };
+    // ── 统计台：四个自然周期（只算「全部工作区」范围；图表切换不带动卡片）────
+    const windows = {
+        thisWeek: weekWindow(0, now),
+        lastWeek: weekWindow(-1, now),
+        thisMonth: monthWindow(0, now),
+        lastMonth: monthWindow(-1, now),
+    };
+    const doneEntries = perWorkspace.flatMap((entry) => entry.history.map((record) => ({ day: dayOf(record.time), owner: record.owner ?? null })));
+    const createdEntries = perWorkspace.flatMap((entry) => [
+        ...entry.tasks.map((task) => ({ day: dayOf(task.created), owner: task.owner ?? null })),
+        ...entry.history.map((record) => ({ day: dayOf(record.created), owner: record.owner ?? null })),
+    ]);
+    const period = (window) => ({
+        done: countPeriod(doneEntries, window),
+        created: countPeriod(createdEntries, window),
+        from: window.from,
+        to: window.to,
+    });
+    const trend = {
+        thisWeek: period(windows.thisWeek),
+        lastWeek: period(windows.lastWeek),
+        thisMonth: period(windows.thisMonth),
+        lastMonth: period(windows.lastMonth),
+    };
+    return { snapshot, closed, trend };
+}
+/** 只拿在办快照（薄封装：测试 / 其它调用方用；首页走 {@link getHomeAggregate} 一次读全）。 */
+export async function getBoardSnapshot(workspaces) {
+    return (await getHomeAggregate(workspaces)).snapshot;
 }
 /**
  * 已结案列表：默认近 13 个月 + limit 500，跨工作区合并后按创建时间倒序。

package/dist/host/routes.js

@@ -1,4 +1,4 @@
-import { getBoardSnapshot, getClosedCounts, getFilterOptions, queryClosed } from './board.js';
+import { getHomeAggregate, getFilterOptions, queryClosed } from './board.js';
 import { getTask, readTasks, readWorklog } from './ledger-read.js';
 import { resolveWorkspaces } from './workspace.js';
 /** API 前缀（唯一真源就在这一处）。 */
@@ -57,15 +57,14 @@ export function registerRoutes(webServer, deps) {
         path: `${API_PREFIX}/workspaces`,
         handler: (_req, res) => { sendJson(res, 200, { workspaces: workspacesOf(deps) }); },
     });
-    // 首页一次拿全：在办快照 + 两个完成类统计。
+    // 首页一次拿全：在办快照 + 近 8 周趋势 + 四个自然周期计数（host 每个工作区只读一次）。
     webServer.register({
         kind: 'exact',
         path: `${API_PREFIX}/board`,
         handler: async (_req, res) => {
             try {
-                const workspaces = workspacesOf(deps);
-                const [snapshot, closed] = await Promise.all([getBoardSnapshot(workspaces), getClosedCounts(workspaces)]);
-                sendJson(res, 200, { ...snapshot, closed });
+                const home = await getHomeAggregate(workspacesOf(deps));
+                sendJson(res, 200, { ...home.snapshot, closed: home.closed, trend: home.trend });
             }
             catch (error) {
                 sendJson(res, 500, { error: error instanceof Error ? error.message : String(error) });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-task-ledger",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "Task ledger board for dsh (DeepSeek Harness): read-only board over task-ledger skill workspaces. The task-ledger skill is bundled — install the plugin, get the skill globally.",
   "keywords": [
     "deepseek",