libero-mcp 0.2.13 → 0.2.14

package/dist/mcp/src/repo/sqlite.js

@@ -164,10 +164,14 @@ export class SqliteTimeBlockRepo {
         return (await this.getById(id));
     }
     async findOverlapping(input) {
+        // ⚠️ 时区安全：用 SQLite datetime() 规范化所有时间字段后再比较。
+        // datetime() 能解析多种 ISO 格式（含 +08:00 / Z），输出统一 'YYYY-MM-DD HH:MM:SS' UTC。
+        // 不能用裸字符串比较（'2026-08-07T09:00:00+08:00' vs '2026-08-07T01:00:00Z' 字符串比较会误判）。
         return this.db
             .prepare(`SELECT * FROM time_blocks
          WHERE user_id = ? AND status = 'planned' AND deleted_at IS NULL
-           AND start_time < ? AND end_time > ?
+           AND datetime(start_time) < datetime(?)
+           AND datetime(end_time) > datetime(?)
          ORDER BY start_time`)
             .all(input.user_id, input.end, input.start);
     }

package/dist/mcp/src/timeline/index.js

@@ -287,69 +287,45 @@ export function renderTimelineCells(input) {
             i = j;
         }
     }
-    // Build text lines: 表格在前（用户先看到具体内容），矩阵在后（时间分布概览）
-    // pressure 反馈 2026-07-27：纯色块矩阵对单调数据认不出，表格更直观，应优先展示
+    // Build text lines: 明细在前（用户先看具体内容），矩阵在后（时间分布概览）
+    // S9 v0.5（2026-08-07）：表头移到矩阵上方，不再夹在明细前面
     const textLines = [];
-    textLines.push("       00  10  20  30  40  50");
-    // ── 表格段（在前）──
-    // S9 v0.3: details 段按 symbol 分组紧凑展示
-    // 用户痛点：移动端窄屏，原格式 "{time}  {symbol}  {title}  [planned]" 长标题折行后 [planned] 跑到第三行，诡异
-    // 新格式：同 symbol 合并到一行，用 · 分隔；移除 [status] 后缀（状态在矩阵方块色已表达）
-    // S9 v0.4: completed → ✓ 前缀 + ~~划线~~ title；unverified → ❓ 后缀；插入「📍 现在」分隔线
+    // ── 明细段（在前）──
+    // S9 v0.3: 按 symbol 分组紧凑展示（合并同 symbol 到一行）
+    // S9 v0.4: completed → ✓ + ~~划线~~；unverified → ❓ 后缀；插入「📍 现在」分隔线
+    // S9 v0.5（2026-08-07）: 改为每条独占一行（用户反馈"挤在一起乱"）
+    //   格式：`{status} {symbol} {time} {title}`
+    //   status: completed → "✓ "；unverified → "? "；planned/timer_* → "  "（空格占位对齐）
     const details = input.details ?? [];
     if (details.length > 0) {
         textLines.push("📋 明细");
         const inWin = details.filter((d) => d.in_window);
         const outWin = details.filter((d) => !d.in_window);
-        // S9 v0.4: 构造单条 entry，根据 status 加完成态视觉
-        // - completed: "✓ {time} ~~{title}~~"
-        // - unverified: "{time} {title} ❓"
-        // - planned / timer_running / timer_paused: "{time} {title}"
+        // S9 v0.5: 每条独占一行的 entry 构造
         const buildEntry = (d) => {
+            let statusMark = "  "; // 默认 2 空格占位（对齐 ✓ 和 ?）
+            let titlePart = d.title;
             if (d.status === "completed") {
-                return `✓ ${d.time} ~~${d.title}~~`;
-            }
-            if (d.status === "unverified") {
-                return `${d.time} ${d.title} ❓`;
+                statusMark = "✓ ";
+                titlePart = `~~${d.title}~~`;
             }
-            return `${d.time} ${d.title}`;
-        };
-        // 按 symbol 分组（保留 inWin 内的原始顺序）
-        const groupBySymbol = (list) => {
-            const groups = [];
-            const symbolToGroup = new Map();
-            for (const d of list) {
-                mark(d.symbol);
-                const entry = buildEntry(d);
-                const idx = symbolToGroup.get(d.symbol);
-                if (idx === undefined) {
-                    symbolToGroup.set(d.symbol, groups.length);
-                    groups.push({ symbol: d.symbol, entries: [entry] });
-                }
-                else {
-                    groups[idx].entries.push(entry);
-                }
+            else if (d.status === "unverified") {
+                statusMark = "? ";
             }
-            return groups;
+            return `${statusMark}${d.symbol} ${d.time} ${titlePart}`;
         };
-        // S9 v0.4: 计算「📍 现在」插入点
-        // 在 inWin 列表中，找到第一条 start_time > now 的明细位置
-        // 时间从 detail.time "HH:MM-HH:MM" 取 start
+        // S9 v0.4: 「📍 现在」分隔线判断（v0.5 保留同规则）
         const parseDetailStart = (time) => {
             const startStr = time.split("-")[0].trim();
             const [h, m] = startStr.split(":").map(Number);
             return h * 60 + m;
         };
-        const nowMs = new Date(input.nowIso).getTime();
         const nowDate = new Date(input.nowIso);
         const nowHM = nowDate.getHours() * 60 + nowDate.getMinutes();
         const nowLabel = `${String(nowDate.getHours()).padStart(2, "0")}:${String(nowDate.getMinutes()).padStart(2, "0")}`;
-        // 判断是否需要插「📍 现在」
-        // 仅当 inWin 中存在 start > now 且存在 start <= now 时才插（即跨 now）
         const inWinAllPast = inWin.every((d) => parseDetailStart(d.time) <= nowHM);
         const inWinAllFuture = inWin.every((d) => parseDetailStart(d.time) > nowHM);
         const needNowMarker = inWin.length > 0 && !inWinAllPast && !inWinAllFuture;
-        // 找到第一个 start > now 的 index（在该位置前插入分隔线）
         let firstFutureIdx = inWin.length;
         if (needNowMarker) {
             for (let i = 0; i < inWin.length; i++) {
@@ -359,30 +335,17 @@ export function renderTimelineCells(input) {
                 }
             }
         }
-        // S9 v0.4: 改写分组渲染——需要保留 inWin 原始顺序，在 firstFutureIdx 处插分隔线
-        // 旧逻辑 groupBySymbol 一次处理整个 inWin，无法在中间插分隔线
-        // 新逻辑：先按 firstFutureIdx 切成 past / future 两段，各自 groupBySymbol，中间插「📍 现在」
-        if (needNowMarker) {
-            const past = inWin.slice(0, firstFutureIdx);
-            const future = inWin.slice(firstFutureIdx);
-            for (const g of groupBySymbol(past)) {
-                textLines.push(`${g.symbol} ${g.entries.join(" · ")}`);
-            }
-            textLines.push(`─── 📍 现在 ${nowLabel} ──`);
-            for (const g of groupBySymbol(future)) {
-                textLines.push(`${g.symbol} ${g.entries.join(" · ")}`);
-            }
-        }
-        else {
-            // 无需分隔线（全过 / 全未到），原逻辑
-            for (const g of groupBySymbol(inWin)) {
-                textLines.push(`${g.symbol} ${g.entries.join(" · ")}`);
+        // S9 v0.5: 每条独占一行，在 firstFutureIdx 处插分隔线
+        for (let i = 0; i < inWin.length; i++) {
+            if (needNowMarker && i === firstFutureIdx) {
+                textLines.push(`─── 📍 现在 ${nowLabel} ──`);
             }
+            textLines.push(buildEntry(inWin[i]));
         }
         if (outWin.length > 0) {
             textLines.push("（窗口外）");
-            for (const g of groupBySymbol(outWin)) {
-                textLines.push(`${g.symbol} ${g.entries.join(" · ")}`);
+            for (const d of outWin) {
+                textLines.push(buildEntry(d));
             }
         }
     }
@@ -397,6 +360,8 @@ export function renderTimelineCells(input) {
     };
     if (boundary)
         pushEllipsis();
+    // S9 v0.5: 时间表头紧贴矩阵上方（之前在明细前，造成"表头夹中间"错觉）
+    textLines.push("       00  10  20  30  40  50");
     // 2026-07-27 UX 反馈：矩阵上下行距太挤，每行后加一个空行透气
     for (let k = 0; k < matrixLines.length; k++) {
         const line = matrixLines[k];

package/dist/mcp/src/timer/index.js

@@ -116,8 +116,41 @@ export function createTimerTools(repo, timeBlockRepo, db) {
             ended_at: endedAt,
         });
         let timeblockId;
-        // Auto-persist to timeblock when rating is provided
-        if (options?.rating !== undefined && timeBlockRepo) {
+        // S42 (2026-08-07): 回查匹配的 planned timeblock → 改 completed
+        // 用户场景：先排了 planned timeblock（如「羽毛球 9:00-11:00」），后开计时；
+        // 停计时期望自动标完成（带 ✓ + 划线），而不是 create 新的。
+        // 匹配规则：同 user_id + 同 title + 时间重叠 + status=planned
+        //
+        // ⚠️ 时区陷阱：planned timeblock 的 start_time/end_time 可能是 +08:00 格式（用户传入），
+        // 而 timer.session 的 started_at 是 Z 格式（nowISO()）。findOverlapping 用字符串比较，
+        // 混合时区会误判（"2026-08-07T09:00:00+08:00" vs "2026-08-07T05:00:00Z" 字符串比较 09 > 05）。
+        // 解法：调用前把 started_at/endedAt 都转 ISO UTC（Z 格式），与 line 578-581 其它 list 查询姿势一致。
+        if (timeBlockRepo) {
+            const startUtc = new Date(active.started_at).toISOString();
+            const endUtc = new Date(endedAt).toISOString();
+            const candidates = await timeBlockRepo.findOverlapping({
+                user_id: active.user_id,
+                start: startUtc,
+                end: endUtc,
+            });
+            const match = candidates.find((tb) => tb.status === "planned" &&
+                (tb.title === active.event ||
+                    tb.title.includes(active.event) ||
+                    active.event.includes(tb.title)));
+            if (match) {
+                const updated = await timeBlockRepo.update(match.id, {
+                    end_time: endedAt,
+                    status: "completed",
+                    ...(options?.rating !== undefined ? { rating: options.rating } : {}),
+                    ...(options?.rating_reason !== undefined
+                        ? { rating_reason: options.rating_reason }
+                        : {}),
+                });
+                timeblockId = updated.id;
+            }
+        }
+        // 没匹配到 planned → 走原 create 路径（仅 rating 时）
+        if (!timeblockId && options?.rating !== undefined && timeBlockRepo) {
             const tb = await timeBlockRepo.create({
                 user_id: active.user_id,
                 title: active.event,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libero-mcp",
-  "version": "0.2.13",
+  "version": "0.2.14",
   "description": "AI 时间管理教练 MCP 工具集——时间块记录、统计、矩阵诊断、计时、分类、profile",
   "license": "MIT",
   "author": "amosyuan",