libero-mcp 0.1.0

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

@@ -0,0 +1,57 @@
+export function nowUTC() {
+    return new Date().toISOString();
+}
+export function nowLocal(offsetMinutes) {
+    const d = new Date();
+    const offset = offsetMinutes ?? -d.getTimezoneOffset();
+    if (offset < -720 || offset > 720) {
+        throw new Error(`Timezone offset ${offset} out of range (must be ±720 minutes)`);
+    }
+    const sign = offset >= 0 ? "+" : "-";
+    const abs = Math.abs(offset);
+    const h = String(Math.floor(abs / 60)).padStart(2, "0");
+    const m = String(abs % 60).padStart(2, "0");
+    const utc = new Date(d.getTime() + d.getTimezoneOffset() * 60000);
+    const local = new Date(utc.getTime() + offset * 60000);
+    const iso = local.toISOString().replace("Z", "");
+    return `${iso}${sign}${h}:${m}`;
+}
+export function formatTime(isoString, format) {
+    const p = parseTime(isoString);
+    const pad = (n) => String(n).padStart(2, "0");
+    return format
+        .replace("YYYY", String(p.year))
+        .replace("MM", pad(p.month))
+        .replace("DD", pad(p.day))
+        .replace("HH", pad(p.hour))
+        .replace("mm", pad(p.minute))
+        .replace("ss", pad(p.second));
+}
+export function parseTime(isoString) {
+    // Match ISO 8601 with timezone offset
+    const m = isoString.match(/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d+)?([+-]\d{2}:\d{2}|Z)$/);
+    if (!m) {
+        throw new Error(`Invalid ISO time string: ${isoString}`);
+    }
+    let offsetMinutes = 0;
+    if (m[7] === "Z") {
+        offsetMinutes = 0;
+    }
+    else {
+        const sign = m[7][0] === "+" ? 1 : -1;
+        const [h, min] = m[7].slice(1).split(":").map(Number);
+        offsetMinutes = sign * (h * 60 + min);
+    }
+    return {
+        year: parseInt(m[1]),
+        month: parseInt(m[2]),
+        day: parseInt(m[3]),
+        hour: parseInt(m[4]),
+        minute: parseInt(m[5]),
+        second: parseInt(m[6]),
+        offsetMinutes,
+    };
+}
+export function getLocalOffset() {
+    return -new Date().getTimezoneOffset();
+}

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

@@ -0,0 +1,15 @@
+export function createMatrixTools(repo) {
+    return {
+        async renderMatrix(filters) {
+            if (!filters.user_id) {
+                throw new Error("user_id 为必填参数");
+            }
+            if (filters.from !== undefined &&
+                filters.to !== undefined &&
+                filters.from > filters.to) {
+                throw new Error("开始时间不能晚于结束时间");
+            }
+            return repo.renderMatrix(filters);
+        },
+    };
+}

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

@@ -0,0 +1,18 @@
+/** Validate and delegate profile operations to the repository.
+ *  ADR-0001: Dependency-injected — the caller provides the repo. */
+export function createProfileTools(repo) {
+    return {
+        async get(userId) {
+            if (!userId) {
+                throw new Error("user_id 为必填参数");
+            }
+            return repo.getById(userId);
+        },
+        async upsert(input) {
+            if (!input.user_id) {
+                throw new Error("user_id 为必填参数");
+            }
+            return repo.upsert(input);
+        },
+    };
+}

package/dist/mcp/src/repo/in-memory.js

@@ -0,0 +1,15 @@
+/** In-memory CategoryRepo for testing / contract verification.
+ *  Receives seed data via constructor — no global state, no getDb(). */
+export class InMemoryCategoryRepo {
+    categories;
+    constructor(seed) {
+        this.categories = [...seed];
+    }
+    async getAll() {
+        // Return defensive copy so callers can't mutate internal state
+        return [...this.categories];
+    }
+    async getById(id) {
+        return this.categories.find((c) => c.id === id) ?? null;
+    }
+}

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

@@ -0,0 +1,39 @@
+/**
+ * SQLite-specific WHERE-clause builder for time-range filtering.
+ *
+ * Eliminates duplicated time-filter logic previously inlined in:
+ *   timeblock.list / stats.summarize / stats.dailyBreakdown / matrix.renderMatrix
+ *
+ * ADR-0001: SQLite dialect helpers belong in this file, not in the generic repo interface.
+ */
+/**
+ * Build WHERE sub-clauses for time-range filtering.
+ *
+ * Date mode (date is set):
+ *   `column >= :dateT00:00:00 AND column < :dateT23:59:59`
+ * Range mode (date absent, from/to optional):
+ *   `column >= :from` / `column <= :to`
+ * Neither:
+ *   returns empty clauses.
+ */
+export function buildTimeRangeWhere(input) {
+    const clauses = [];
+    const params = [];
+    if (input.date) {
+        // Single-day mode — timeblock.list legacy contract:
+        // start_time >= dateT00:00:00 AND start_time < dateT23:59:59
+        clauses.push(`${input.column} >= ?`, `${input.column} < ?`);
+        params.push(`${input.date}T00:00:00`, `${input.date}T23:59:59`);
+    }
+    else {
+        if (input.from) {
+            clauses.push(`${input.column} >= ?`);
+            params.push(input.from);
+        }
+        if (input.to) {
+            clauses.push(`${input.column} <= ?`);
+            params.push(input.to);
+        }
+    }
+    return { clauses, params };
+}

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

@@ -0,0 +1,461 @@
+import { buildTimeRangeWhere } from "./sqlite-helpers.js";
+// ============================================================
+// SqliteCategoryRepo (R1-R3)
+// ============================================================
+export class SqliteCategoryRepo {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async getAll() {
+        return this.db
+            .prepare("SELECT id, name, emoji, color FROM categories WHERE deleted_at IS NULL ORDER BY id")
+            .all();
+    }
+    async getById(id) {
+        const row = this.db
+            .prepare("SELECT id, name, emoji, color FROM categories WHERE id = ? AND deleted_at IS NULL")
+            .get(id);
+        return row ?? null;
+    }
+}
+// ============================================================
+// SqliteTimeBlockRepo (R2)
+// ============================================================
+export class SqliteTimeBlockRepo {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async create(input) {
+        const id = crypto.randomUUID();
+        const now = new Date().toISOString().replace("T", " ").replace("Z", "");
+        const durationMinutes = input.duration_minutes ??
+            Math.round((new Date(input.end_time).getTime() -
+                new Date(input.start_time).getTime()) /
+                60000);
+        this.db
+            .prepare(`INSERT INTO time_blocks (id, user_id, title, category_id, start_time, end_time, duration_minutes, rating, rating_reason, notes, status, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(id, input.user_id, input.title.trim(), input.category_id ?? null, input.start_time, input.end_time, durationMinutes, input.rating ?? null, input.rating_reason ?? null, input.notes ?? null, input.status ?? "completed", now, now);
+        return (await this.getById(id));
+    }
+    async getById(id) {
+        const row = this.db
+            .prepare("SELECT * FROM time_blocks WHERE id = ? AND deleted_at IS NULL")
+            .get(id);
+        return row ?? null;
+    }
+    async list(filters) {
+        const conditions = ["user_id = ?"];
+        const params = [filters.user_id];
+        if (!filters.include_deleted) {
+            conditions.push("deleted_at IS NULL");
+        }
+        const range = buildTimeRangeWhere({
+            column: "start_time",
+            date: filters.date,
+            from: filters.from,
+            to: filters.to,
+        });
+        conditions.push(...range.clauses);
+        params.push(...range.params);
+        if (filters.category_id) {
+            conditions.push("category_id = ?");
+            params.push(filters.category_id);
+        }
+        let limit = filters.limit ?? 50;
+        if (limit > 100)
+            limit = 100;
+        const offset = filters.offset ?? 0;
+        const sql = `SELECT * FROM time_blocks WHERE ${conditions.join(" AND ")} ORDER BY start_time DESC LIMIT ? OFFSET ?`;
+        params.push(limit, offset);
+        return this.db.prepare(sql).all(...params);
+    }
+    async update(id, input) {
+        const existing = this.db
+            .prepare("SELECT * FROM time_blocks WHERE id = ? AND deleted_at IS NULL")
+            .get(id);
+        if (!existing) {
+            throw new Error("时间块不存在");
+        }
+        const newStart = input.start_time ?? existing.start_time;
+        const newEnd = input.end_time ?? existing.end_time;
+        let newDuration;
+        if (input.duration_minutes !== undefined) {
+            newDuration = input.duration_minutes;
+        }
+        else if (input.start_time !== undefined ||
+            input.end_time !== undefined) {
+            newDuration = Math.round((new Date(newEnd).getTime() - new Date(newStart).getTime()) / 60000);
+        }
+        else {
+            newDuration = existing.duration_minutes;
+        }
+        const now = new Date().toISOString().replace("T", " ").replace("Z", "") +
+            String(Math.floor(performance.now() * 100000) % 100000).padStart(5, "0");
+        this.db
+            .prepare(`UPDATE time_blocks SET
+           title = ?,
+           category_id = ?,
+           start_time = ?,
+           end_time = ?,
+           duration_minutes = ?,
+           rating = ?,
+           rating_reason = ?,
+           notes = ?,
+           status = ?,
+           updated_at = ?
+         WHERE id = ?`)
+            .run((input.title ?? existing.title).trim() || existing.title, input.category_id !== undefined
+            ? input.category_id
+            : existing.category_id, newStart, newEnd, newDuration, input.rating !== undefined ? input.rating : existing.rating, input.rating_reason !== undefined
+            ? input.rating_reason
+            : existing.rating_reason, input.notes !== undefined ? input.notes : existing.notes, input.status !== undefined ? input.status : existing.status, now, id);
+        return (await this.getById(id));
+    }
+    async remove(id) {
+        const exists = this.db
+            .prepare("SELECT id, deleted_at FROM time_blocks WHERE id = ?")
+            .get(id);
+        if (!exists) {
+            throw new Error("时间块不存在");
+        }
+        if (exists.deleted_at !== null) {
+            return; // already soft-deleted, idempotent
+        }
+        const now = new Date().toISOString().replace("T", " ").replace("Z", "");
+        this.db
+            .prepare("UPDATE time_blocks SET deleted_at = ?, updated_at = ? WHERE id = ?")
+            .run(now, now, id);
+    }
+    async exists(id) {
+        const row = this.db
+            .prepare("SELECT id FROM time_blocks WHERE id = ?")
+            .get(id);
+        return !!row;
+    }
+    async userExists(userId) {
+        const row = this.db
+            .prepare("SELECT id FROM user_profile WHERE id = ? AND deleted_at IS NULL")
+            .get(userId);
+        return !!row;
+    }
+    async restore(id) {
+        const row = this.db
+            .prepare("SELECT id, deleted_at FROM time_blocks WHERE id = ?")
+            .get(id);
+        if (!row || row.deleted_at === null) {
+            throw new Error("时间块不存在或未被删除");
+        }
+        const now = new Date().toISOString().replace("T", " ").replace("Z", "");
+        this.db
+            .prepare("UPDATE time_blocks SET deleted_at = NULL, status = 'completed', updated_at = ? WHERE id = ?")
+            .run(now, id);
+        return (await this.getById(id));
+    }
+}
+// ============================================================
+// SqliteStatsRepo (R2 — stats + matrix)
+// ============================================================
+// -- pure helpers for renderMatrix (copied verbatim from matrix/index.ts) --
+function median(values) {
+    if (values.length === 0)
+        return 0;
+    const sorted = [...values].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    if (sorted.length % 2 === 1) {
+        return sorted[mid];
+    }
+    return (sorted[mid - 1] + sorted[mid]) / 2;
+}
+const QUADRANT_ORDER = {
+    "能耗黑洞": 0,
+    "可放弃": 1,
+    "保持区": 2,
+    "亮点区": 3,
+};
+function assignQuadrant(highTime, highRating) {
+    if (highTime && highRating)
+        return "保持区";
+    if (highTime && !highRating)
+        return "能耗黑洞";
+    if (!highTime && highRating)
+        return "亮点区";
+    return "可放弃";
+}
+export class SqliteStatsRepo {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async summarize(filters) {
+        const conditions = [
+            "tb.user_id = ?",
+            "tb.deleted_at IS NULL",
+        ];
+        const params = [filters.user_id];
+        const range = buildTimeRangeWhere({
+            column: "tb.start_time",
+            from: filters.from,
+            to: filters.to,
+        });
+        conditions.push(...range.clauses);
+        params.push(...range.params);
+        if (filters.category_id) {
+            conditions.push("tb.category_id = ?");
+            params.push(filters.category_id);
+        }
+        const rows = this.db
+            .prepare(`SELECT
+           COALESCE(tb.category_id, 'cat-other') as category_id,
+           COALESCE(c.name, '其他') as category_name,
+           COALESCE(c.emoji, '❓') as category_emoji,
+           SUM(tb.duration_minutes) as total_minutes,
+           COUNT(*) as record_count
+         FROM time_blocks tb
+         LEFT JOIN categories c ON tb.category_id = c.id
+         WHERE ${conditions.join(" AND ")}
+         GROUP BY COALESCE(tb.category_id, 'cat-other')
+         ORDER BY total_minutes DESC`)
+            .all(...params);
+        const grandTotal = rows.reduce((sum, r) => sum + r.total_minutes, 0);
+        return rows.map((r) => ({
+            category_id: r.category_id,
+            category_name: r.category_name,
+            category_emoji: r.category_emoji,
+            total_minutes: r.total_minutes,
+            percentage: grandTotal > 0
+                ? Math.round((r.total_minutes / grandTotal) * 1000) / 10
+                : 0,
+            record_count: r.record_count,
+        }));
+    }
+    async dailyBreakdown(filters) {
+        const conditions = [
+            "tb.user_id = ?",
+            "tb.deleted_at IS NULL",
+        ];
+        const params = [filters.user_id];
+        const range = buildTimeRangeWhere({
+            column: "tb.start_time",
+            from: filters.from,
+            to: filters.to,
+        });
+        conditions.push(...range.clauses);
+        params.push(...range.params);
+        if (filters.category_id) {
+            conditions.push("tb.category_id = ?");
+            params.push(filters.category_id);
+        }
+        const rows = this.db
+            .prepare(`SELECT
+           DATE(tb.start_time) as date,
+           COALESCE(tb.category_id, 'cat-other') as category_id,
+           COALESCE(c.name, '其他') as category_name,
+           COALESCE(c.emoji, '❓') as category_emoji,
+           SUM(tb.duration_minutes) as minutes
+         FROM time_blocks tb
+         LEFT JOIN categories c ON tb.category_id = c.id
+         WHERE ${conditions.join(" AND ")}
+         GROUP BY DATE(tb.start_time), COALESCE(tb.category_id, 'cat-other')
+         ORDER BY DATE(tb.start_time) ASC, minutes DESC`)
+            .all(...params);
+        // Aggregate into date-keyed map
+        const dayMap = new Map();
+        for (const row of rows) {
+            let day = dayMap.get(row.date);
+            if (!day) {
+                day = { date: row.date, total_minutes: 0, categories: [] };
+                dayMap.set(row.date, day);
+            }
+            day.categories.push({
+                category_id: row.category_id,
+                category_name: row.category_name,
+                category_emoji: row.category_emoji,
+                minutes: row.minutes,
+            });
+            day.total_minutes += row.minutes;
+        }
+        return [...dayMap.values()];
+    }
+    async renderMatrix(filters) {
+        const conditions = [
+            "tb.user_id = ?",
+            "tb.deleted_at IS NULL",
+        ];
+        const params = [filters.user_id];
+        const range = buildTimeRangeWhere({
+            column: "tb.start_time",
+            from: filters.from,
+            to: filters.to,
+        });
+        conditions.push(...range.clauses);
+        params.push(...range.params);
+        const rows = this.db
+            .prepare(`SELECT
+           COALESCE(tb.category_id, 'cat-other') as category_id,
+           COALESCE(c.name, '其他') as category_name,
+           COALESCE(c.emoji, '❓') as category_emoji,
+           SUM(tb.duration_minutes) as total_minutes,
+           AVG(tb.rating) as avg_rating,
+           COUNT(*) as record_count
+         FROM time_blocks tb
+         LEFT JOIN categories c ON tb.category_id = c.id
+         WHERE ${conditions.join(" AND ")}
+         GROUP BY COALESCE(tb.category_id, 'cat-other')
+         HAVING avg_rating IS NOT NULL`)
+            .all(...params);
+        if (rows.length === 0) {
+            return { median_minutes: 0, median_rating: 0, bubbles: [] };
+        }
+        const minutesValues = rows.map((r) => r.total_minutes);
+        const ratingValues = rows.map((r) => r.avg_rating);
+        const medianMinutes = median(minutesValues);
+        const medianRating = median(ratingValues);
+        const bubbles = rows
+            .map((r) => {
+            const highTime = r.total_minutes >= medianMinutes;
+            const highRating = r.avg_rating >= medianRating;
+            return {
+                category_id: r.category_id,
+                category_name: r.category_name,
+                category_emoji: r.category_emoji,
+                total_minutes: r.total_minutes,
+                avg_rating: Math.round(r.avg_rating * 10) / 10,
+                record_count: r.record_count,
+                quadrant: assignQuadrant(highTime, highRating),
+            };
+        })
+            .sort((a, b) => {
+            const orderDiff = QUADRANT_ORDER[a.quadrant] - QUADRANT_ORDER[b.quadrant];
+            if (orderDiff !== 0)
+                return orderDiff;
+            return b.total_minutes - a.total_minutes;
+        });
+        return {
+            median_minutes: medianMinutes,
+            median_rating: Math.round(medianRating * 10) / 10,
+            bubbles,
+        };
+    }
+}
+// ============================================================
+// SqliteTimerRepo (R4 — timer persistence)
+// ============================================================
+export class SqliteTimerRepo {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async getActive(userId) {
+        const row = this.db
+            .prepare("SELECT * FROM timer_sessions WHERE user_id = ? AND status IN ('running', 'paused') LIMIT 1")
+            .get(userId);
+        return row ?? null;
+    }
+    async create(input) {
+        const id = crypto.randomUUID();
+        const now = new Date().toISOString();
+        this.db
+            .prepare(`INSERT INTO timer_sessions (id, user_id, event, category_id, status, started_at, accumulated_ms, created_at, updated_at)
+         VALUES (?, ?, ?, ?, 'running', ?, 0, ?, ?)`)
+            .run(id, input.user_id, input.event.trim(), input.category_id ?? null, input.started_at, now, now);
+        return this.db
+            .prepare("SELECT * FROM timer_sessions WHERE id = ?")
+            .get(id);
+    }
+    async update(id, patch) {
+        const now = new Date().toISOString();
+        const sets = ["updated_at = ?"];
+        const params = [now];
+        if (patch.status !== undefined) {
+            sets.push("status = ?");
+            params.push(patch.status);
+        }
+        if (patch.started_at !== undefined) {
+            sets.push("started_at = ?");
+            params.push(patch.started_at);
+        }
+        if (patch.accumulated_ms !== undefined) {
+            sets.push("accumulated_ms = ?");
+            params.push(patch.accumulated_ms);
+        }
+        if (patch.ended_at !== undefined) {
+            sets.push("ended_at = ?");
+            params.push(patch.ended_at);
+        }
+        params.push(id);
+        this.db
+            .prepare(`UPDATE timer_sessions SET ${sets.join(", ")} WHERE id = ?`)
+            .run(...params);
+        return this.db
+            .prepare("SELECT * FROM timer_sessions WHERE id = ?")
+            .get(id);
+    }
+    async userExists(userId) {
+        const row = this.db
+            .prepare("SELECT id FROM user_profile WHERE id = ? AND deleted_at IS NULL")
+            .get(userId);
+        return !!row;
+    }
+}
+// ============================================================
+// SqliteProfileRepo (S13 — profile with structured settings)
+// ============================================================
+export class SqliteProfileRepo {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async getById(userId) {
+        const row = this.db
+            .prepare("SELECT id, display_name, expectations, settings, created_at, updated_at FROM user_profile WHERE id = ? AND deleted_at IS NULL")
+            .get(userId);
+        if (!row)
+            return null;
+        return {
+            id: row.id,
+            display_name: row.display_name,
+            expectations: row.expectations,
+            settings: row.settings != null ? JSON.parse(row.settings) : null,
+            created_at: row.created_at,
+            updated_at: row.updated_at,
+        };
+    }
+    async upsert(input) {
+        const existing = await this.getById(input.user_id);
+        const now = new Date().toISOString().replace("T", " ").replace("Z", "");
+        if (existing) {
+            // Update: merge top-level fields, retain existing values for unset fields
+            const display_name = input.display_name !== undefined
+                ? input.display_name
+                : existing.display_name;
+            const expectations = input.expectations !== undefined
+                ? input.expectations
+                : existing.expectations;
+            // settings: whole-object replace (not deep merge), per S13 §4
+            const settings = input.settings !== undefined
+                ? JSON.stringify(input.settings)
+                : existing.settings != null
+                    ? JSON.stringify(existing.settings)
+                    : null;
+            this.db
+                .prepare(`UPDATE user_profile SET display_name = ?, expectations = ?, settings = ?, updated_at = ? WHERE id = ?`)
+                .run(display_name, expectations, settings, now, input.user_id);
+        }
+        else {
+            // Insert
+            const display_name = input.display_name ?? "";
+            const expectations = input.expectations ?? null;
+            const settings = input.settings !== undefined
+                ? JSON.stringify(input.settings)
+                : null;
+            this.db
+                .prepare(`INSERT INTO user_profile (id, display_name, expectations, settings, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?)`)
+                .run(input.user_id, display_name, expectations, settings, now, now);
+        }
+        return (await this.getById(input.user_id));
+    }
+}

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

@@ -0,0 +1,4 @@
+// ============================================================
+// Domain types — shared by tools and repos
+// ============================================================
+export {};

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

@@ -0,0 +1,26 @@
+export function createStatsTools(repo) {
+    return {
+        async summarize(filters) {
+            if (!filters.user_id) {
+                throw new Error("user_id 为必填参数");
+            }
+            if (filters.from !== undefined &&
+                filters.to !== undefined &&
+                filters.from > filters.to) {
+                throw new Error("开始时间不能晚于结束时间");
+            }
+            return repo.summarize(filters);
+        },
+        async dailyBreakdown(filters) {
+            if (!filters.user_id) {
+                throw new Error("user_id 为必填参数");
+            }
+            if (filters.from !== undefined &&
+                filters.to !== undefined &&
+                filters.from > filters.to) {
+                throw new Error("开始时间不能晚于结束时间");
+            }
+            return repo.dailyBreakdown(filters);
+        },
+    };
+}