Memos is an open-source, self-hosted note-taking app that brings your everyday thoughts together in a personal timeline. Your data stays yours, and you choose what to keep private or share.
Go dockerfossgomarkdownmemomicroblognote-takingnotesopen-sourceown-your-datareactself-hostedsqlitetimeline
feat(activity-calendar): aggregate by ViewContext.timeBasis
Steven8daef1dc8954
diff --git a/docs/superpowers/plans/2026-05-02-activity-calendar-time-basis.md b/docs/superpowers/plans/2026-05-02-activity-calendar-time-basis.mdnew file mode 100644index 000000000..2bd54a69c--- /dev/null+++ b/docs/superpowers/plans/2026-05-02-activity-calendar-time-basis.md@@ -0,0 +1,1018 @@+# ActivityCalendar Time Basis Implementation Plan++> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.++**Goal:** Make the heatmap aggregation follow `ViewContext.timeBasis` so the calendar and the memo list agree about "today" when sorting by `update_time`.++**Architecture:** Add a parallel `memo_updated_timestamps` field to `UserStats`, populate it in the backend stats path the same way `memo_created_timestamps` is populated. On the frontend, `useFilteredMemoStats` reads `timeBasis` from `ViewContext` and picks the matching array; the resulting `timeBasis` is propagated down through `StatisticsView` → `MonthCalendar`/`YearCalendar` so the tooltip text reflects the active basis. No DB migration; the only schema change is one additive proto field.++**Tech Stack:** Go 1.26 / Protobuf / Connect RPC (backend), React 18 + TypeScript 6 + React Query v5 + i18next (frontend), Vitest (frontend tests), Go testify with TestContainers (backend tests).++**Spec:** `docs/superpowers/specs/2026-05-02-activity-calendar-time-basis-design.md`++---++## File Map++**Backend**+- Modify: `proto/api/v1/user_service.proto` (add field)+- Generated: `proto/gen/api/v1/user_service.pb.go` (regenerated)+- Generated: `web/src/types/proto/api/v1/user_service_pb.ts` (regenerated)+- Modify: `server/router/api/v1/user_service_stats.go` (populate field in both functions)+- Modify: `server/router/api/v1/test/user_service_stats_test.go` (assert new field)++**Frontend types & util**+- Modify: `web/src/components/ActivityCalendar/types.ts` (add `MemoTimeBasis` import, prop)+- Modify: `web/src/components/ActivityCalendar/utils.ts` (basis-aware tooltip)+- Modify: `web/src/components/ActivityCalendar/MonthCalendar.tsx` (accept & forward `timeBasis`)+- Modify: `web/src/components/ActivityCalendar/YearCalendar.tsx` (accept & forward `timeBasis`)++**Frontend data**+- Modify: `web/src/hooks/useFilteredMemoStats.ts` (read `timeBasis`, switch source)+- Modify: `web/src/types/statistics.ts` (add `timeBasis` to `StatisticsData` and `MonthNavigatorProps`)+- Modify: `web/src/components/StatisticsView/StatisticsView.tsx` (forward `timeBasis`)+- Modify: `web/src/components/StatisticsView/MonthNavigator.tsx` (forward `timeBasis`)++**Frontend i18n**+- Modify: `web/src/locales/en.json` (add `count-memos-updated-in-date` key)++**Frontend tests**+- Create: `web/tests/activity-calendar-tooltip.test.ts`+- Create: `web/tests/filtered-memo-stats.test.ts`++---++## Task 1: Add `memo_updated_timestamps` field to `UserStats` proto++**Files:**+- Modify: `proto/api/v1/user_service.proto`+- Generated (do not hand-edit): `proto/gen/api/v1/user_service.pb.go`, `web/src/types/proto/api/v1/user_service_pb.ts`++- [ ] **Step 1: Add the field**++Open `proto/api/v1/user_service.proto`. Find the `UserStats` message (around line 345). After the existing `memo_created_timestamps` line (currently `repeated google.protobuf.Timestamp memo_created_timestamps = 7;`), add:++```proto+ // The latest update timestamps of the user's memos (one per memo,+ // mirrors memo_created_timestamps). Used by the activity heatmap when+ // the client's view is set to update_time basis.+ repeated google.protobuf.Timestamp memo_updated_timestamps = 8;+```++The `total_memo_count = 6` field stays at tag 6; this new field claims tag 8 (tag 2 is reserved per the existing `reserved 2;` line).++- [ ] **Step 2: Regenerate proto code**++Run from the repo root:++```bash+(cd proto && buf generate)+```++Expected: regenerates `proto/gen/api/v1/user_service.pb.go` and `web/src/types/proto/api/v1/user_service_pb.ts` (plus OpenAPI). Verify `memoUpdatedTimestamps` appears in the TS file:++```bash+grep -n "memoUpdatedTimestamps\|memo_updated_timestamps" web/src/types/proto/api/v1/user_service_pb.ts+```++Expected output: matches in both the doc comment and the field declaration around the existing `memoCreatedTimestamps` block.++- [ ] **Step 3: Verify Go compiles**++```bash+go build ./...+```++Expected: success with no errors.++- [ ] **Step 4: Commit**++```bash+git add proto/api/v1/user_service.proto proto/gen/api/v1/user_service.pb.go web/src/types/proto/api/v1/user_service_pb.ts proto/gen/apidocs.swagger.yaml+git commit -m "proto(user_service): add memo_updated_timestamps to UserStats"+```++(If `buf generate` touches additional files, include them in the same commit.)++---++## Task 2: Populate `MemoUpdatedTimestamps` in `GetUserStats` (backend)++**Files:**+- Modify: `server/router/api/v1/user_service_stats.go:177-277`++The existing `GetUserStats` function (line 177) collects `createdTimestamps` from each memo. We add a parallel `updatedTimestamps`.++- [ ] **Step 1: Add the parallel slice declaration**++In `server/router/api/v1/user_service_stats.go`, find line 207:++```go+ createdTimestamps := []*timestamppb.Timestamp{}+```++Replace with:++```go+ createdTimestamps := []*timestamppb.Timestamp{}+ updatedTimestamps := []*timestamppb.Timestamp{}+```++- [ ] **Step 2: Append `UpdatedTs` inside the memo loop**++Find line 233 (inside `for _, memo := range memos`):++```go+ createdTimestamps = append(createdTimestamps, timestamppb.New(time.Unix(memo.CreatedTs, 0)))+```++Replace with:++```go+ createdTimestamps = append(createdTimestamps, timestamppb.New(time.Unix(memo.CreatedTs, 0)))+ updatedTimestamps = append(updatedTimestamps, timestamppb.New(time.Unix(memo.UpdatedTs, 0)))+```++- [ ] **Step 3: Set the new field on the returned struct**++Find line 262-274 (the `userStats := &v1pb.UserStats{...}` literal). Add the new field next to `MemoCreatedTimestamps`:++Before:++```go+ userStats := &v1pb.UserStats{+ Name: fmt.Sprintf("%s/stats", BuildUserName(user.Username)),+ MemoCreatedTimestamps: createdTimestamps,+ TagCount: tagCount,+ ...+```++After:++```go+ userStats := &v1pb.UserStats{+ Name: fmt.Sprintf("%s/stats", BuildUserName(user.Username)),+ MemoCreatedTimestamps: createdTimestamps,+ MemoUpdatedTimestamps: updatedTimestamps,+ TagCount: tagCount,+ ...+```++- [ ] **Step 4: Build and verify**++```bash+go build ./server/router/api/v1/...+```++Expected: success.++---++## Task 3: Populate `MemoUpdatedTimestamps` in `ListAllUserStats` (backend)++**Files:**+- Modify: `server/router/api/v1/user_service_stats.go:56-175`++`ListAllUserStats` (line 56) builds a per-user stats map across all users. We mirror Task 2 inside this loop.++- [ ] **Step 1: Initialize the slice on first sight of a user**++Find lines 99-110 (the `userMemoStatMap[memo.CreatorID] = &v1pb.UserStats{...}` literal). Add `MemoUpdatedTimestamps: []*timestamppb.Timestamp{},` next to `MemoCreatedTimestamps`:++```go+ userMemoStatMap[memo.CreatorID] = &v1pb.UserStats{+ Name: "",+ TagCount: make(map[string]int32),+ MemoCreatedTimestamps: []*timestamppb.Timestamp{},+ MemoUpdatedTimestamps: []*timestamppb.Timestamp{},+ PinnedMemos: []string{},+ MemoTypeStats: &v1pb.UserStats_MemoTypeStats{+ LinkCount: 0,+ CodeCount: 0,+ TodoCount: 0,+ UndoCount: 0,+ },+ }+```++- [ ] **Step 2: Append in the per-memo loop**++Find line 115:++```go+ stats.MemoCreatedTimestamps = append(stats.MemoCreatedTimestamps, timestamppb.New(time.Unix(memo.CreatedTs, 0)))+```++Replace with:++```go+ stats.MemoCreatedTimestamps = append(stats.MemoCreatedTimestamps, timestamppb.New(time.Unix(memo.CreatedTs, 0)))+ stats.MemoUpdatedTimestamps = append(stats.MemoUpdatedTimestamps, timestamppb.New(time.Unix(memo.UpdatedTs, 0)))+```++- [ ] **Step 3: Build**++```bash+go build ./server/router/api/v1/...+```++Expected: success.++- [ ] **Step 4: Commit Tasks 2 + 3 together**++```bash+git add server/router/api/v1/user_service_stats.go+git commit -m "feat(user_service): populate memo_updated_timestamps in user stats"+```++---++## Task 4: Backend test — assert `MemoUpdatedTimestamps` is populated++**Files:**+- Modify: `server/router/api/v1/test/user_service_stats_test.go`++Add a TDD-style test that creates a memo, updates it, and verifies both timestamp arrays are populated correctly.++- [ ] **Step 1: Write the failing test**++Append this function to `server/router/api/v1/test/user_service_stats_test.go`:++```go+func TestGetUserStats_MemoUpdatedTimestamps(t *testing.T) {+ ctx := context.Background()++ ts := NewTestService(t)+ defer ts.Cleanup()++ user, err := ts.CreateHostUser(ctx, "ts-user")+ require.NoError(t, err)+ userCtx := ts.CreateUserContext(ctx, user.ID)++ // Create one memo. Its created_ts and updated_ts are equal at creation.+ memo, err := ts.Store.CreateMemo(ctx, &store.Memo{+ UID: "ts-memo-1",+ CreatorID: user.ID,+ Content: "first content",+ Visibility: store.Public,+ })+ require.NoError(t, err)+ require.NotNil(t, memo)++ // Bump updated_ts by updating content.+ newContent := "second content"+ updatedMemo, err := ts.Store.UpdateMemo(ctx, &store.UpdateMemo{+ ID: memo.ID,+ Content: &newContent,+ })+ require.NoError(t, err)+ require.NotNil(t, updatedMemo)++ userName := fmt.Sprintf("users/%s", user.Username)+ resp, err := ts.Service.GetUserStats(userCtx, &v1pb.GetUserStatsRequest{Name: userName})+ require.NoError(t, err)+ require.NotNil(t, resp)++ require.Len(t, resp.MemoCreatedTimestamps, 1, "should have one created timestamp")+ require.Len(t, resp.MemoUpdatedTimestamps, 1, "should have one updated timestamp")++ require.Equal(t, updatedMemo.CreatedTs, resp.MemoCreatedTimestamps[0].AsTime().Unix())+ require.Equal(t, updatedMemo.UpdatedTs, resp.MemoUpdatedTimestamps[0].AsTime().Unix())+ require.GreaterOrEqual(+ t,+ resp.MemoUpdatedTimestamps[0].AsTime().Unix(),+ resp.MemoCreatedTimestamps[0].AsTime().Unix(),+ "updated_ts should be at or after created_ts",+ )+}+```++- [ ] **Step 2: Verify it passes (Tasks 2/3 already implement the behavior)**++```bash+go test -v -race -run TestGetUserStats_MemoUpdatedTimestamps ./server/router/api/v1/test/...+```++Expected: PASS.++If it fails because `store.UpdateMemo` has a different signature, inspect the existing usage in this same test file or in `store/memo.go` and adjust. The intent is "create a memo, update it, then read stats."++- [ ] **Step 3: Commit**++```bash+git add server/router/api/v1/test/user_service_stats_test.go+git commit -m "test(user_service): cover memo_updated_timestamps in stats"+```++---++## Task 5: Add `MemoTimeBasis` to ActivityCalendar types++**Files:**+- Modify: `web/src/components/ActivityCalendar/types.ts`++The calendar components currently take `data: CalendarData`. We add an optional `timeBasis` prop so the tooltip can label correctly.++- [ ] **Step 1: Re-export the basis type and add to props**++Open `web/src/components/ActivityCalendar/types.ts`. At the top, add an import:++```ts+import type { MemoTimeBasis } from "@/contexts/ViewContext";+```++In `MonthCalendarProps` (around line 22), add an optional field:++```ts+export interface MonthCalendarProps {+ month: string;+ data: CalendarData;+ maxCount: number;+ size?: CalendarSize;+ onClick?: (date: string) => void;+ selectedDate?: string;+ className?: string;+ disableTooltips?: boolean;+ timeBasis?: MemoTimeBasis;+}+```++In `YearCalendarProps` (around line 33), add the same field:++```ts+export interface YearCalendarProps {+ selectedYear: number;+ data: CalendarData;+ onYearChange: (year: number) => void;+ onDateClick: (date: string) => void;+ className?: string;+ timeBasis?: MemoTimeBasis;+}+```++- [ ] **Step 2: Type-check**++```bash+cd web && pnpm lint+```++Expected: PASS (no implementations consume the new prop yet — that's fine, it's optional).++---++## Task 6: Add basis-aware tooltip text + i18n key++**Files:**+- Modify: `web/src/locales/en.json:233`+- Modify: `web/src/components/ActivityCalendar/utils.ts:63-73`++- [ ] **Step 1: Add the new English locale key**++Open `web/src/locales/en.json`. Find line 233:++```json+ "count-memos-in-date": "{{count}} {{memos}} in {{date}}",+```++Add a sibling key right after it:++```json+ "count-memos-in-date": "{{count}} {{memos}} in {{date}}",+ "count-memos-updated-in-date": "{{count}} {{memos}} updated on {{date}}",+```++(Other locale files keep using only `count-memos-in-date`; i18next will fall back to English for the new key, matching the project's existing fallback strategy.)++- [ ] **Step 2: Update `getTooltipText` to take a `timeBasis`**++In `web/src/components/ActivityCalendar/utils.ts`, replace lines 63-73:++```ts+export const getTooltipText = (count: number, date: string, t: TranslateFunction): string => {+ if (count === 0) {+ return date;+ }++ return t("memo.count-memos-in-date", {+ count,+ memos: count === 1 ? t("common.memo") : t("common.memos"),+ date,+ }).toLowerCase();+};+```++With:++```ts+import type { MemoTimeBasis } from "@/contexts/ViewContext";++export const getTooltipText = (count: number, date: string, t: TranslateFunction, timeBasis: MemoTimeBasis = "create_time"): string => {+ if (count === 0) {+ return date;+ }++ const key = timeBasis === "update_time" ? "memo.count-memos-updated-in-date" : "memo.count-memos-in-date";+ return t(key, {+ count,+ memos: count === 1 ? t("common.memo") : t("common.memos"),+ date,+ }).toLowerCase();+};+```++(Move the new `import` to the top of the file with the other imports — don't leave it mid-file.)++- [ ] **Step 3: Write the unit test**++Create `web/tests/activity-calendar-tooltip.test.ts`:++```ts+import { describe, expect, it } from "vitest";+import { getTooltipText } from "@/components/ActivityCalendar/utils";++// Minimal stub for the i18n translate fn — returns a deterministic string we can assert on.+const t = ((key: string, vars?: Record<string, unknown>) => {+ if (!vars) return key;+ const parts = Object.entries(vars).map(([k, v]) => `${k}=${String(v)}`);+ return `${key}|${parts.join(",")}`;+}) as Parameters<typeof getTooltipText>[2];++describe("getTooltipText", () => {+ it("returns just the date when count is 0", () => {+ expect(getTooltipText(0, "2026-05-02", t)).toBe("2026-05-02");+ });++ it("uses the created-tooltip key for create_time basis (default)", () => {+ const out = getTooltipText(3, "2026-05-02", t);+ expect(out.toLowerCase()).toContain("memo.count-memos-in-date");+ expect(out.toLowerCase()).not.toContain("updated");+ });++ it("uses the updated-tooltip key for update_time basis", () => {+ const out = getTooltipText(3, "2026-05-02", t, "update_time");+ expect(out.toLowerCase()).toContain("memo.count-memos-updated-in-date");+ });+});+```++- [ ] **Step 4: Run the test**++```bash+cd web && pnpm test activity-calendar-tooltip+```++Expected: 3/3 PASS.++- [ ] **Step 5: Commit**++```bash+git add web/src/locales/en.json web/src/components/ActivityCalendar/utils.ts web/src/components/ActivityCalendar/types.ts web/tests/activity-calendar-tooltip.test.ts+git commit -m "feat(activity-calendar): basis-aware tooltip text"+```++---++## Task 7: Forward `timeBasis` through `MonthCalendar` and `YearCalendar`++**Files:**+- Modify: `web/src/components/ActivityCalendar/MonthCalendar.tsx:37-77`+- Modify: `web/src/components/ActivityCalendar/YearCalendar.tsx:71-114`++- [ ] **Step 1: Pass `timeBasis` into `getTooltipText` from `MonthCalendar`**++In `web/src/components/ActivityCalendar/MonthCalendar.tsx`, the destructured props line (around 38) currently reads:++```tsx+const { month, data, maxCount, size = "default", onClick, selectedDate, className, disableTooltips = false } = props;+```++Replace with:++```tsx+const { month, data, maxCount, size = "default", onClick, selectedDate, className, disableTooltips = false, timeBasis = "create_time" } = props;+```++In the `flatDays.map` block (line 61-71), the `getTooltipText` call currently reads:++```tsx+tooltipText={getTooltipText(day.count, day.date, t)}+```++Replace with:++```tsx+tooltipText={getTooltipText(day.count, day.date, t, timeBasis)}+```++- [ ] **Step 2: Pass `timeBasis` from `YearCalendar` into the inner `MonthCalendar`**++In `web/src/components/ActivityCalendar/YearCalendar.tsx`, `YearCalendar` is currently:++```tsx+export const YearCalendar = memo(({ selectedYear, data, onYearChange, onDateClick, className }: YearCalendarProps) => {+```++Replace with:++```tsx+export const YearCalendar = memo(({ selectedYear, data, onYearChange, onDateClick, className, timeBasis }: YearCalendarProps) => {+```++`MonthCard` is the inner component that renders `MonthCalendar`. Update its props type (line 71-76) and component (line 78-83):++Before:++```tsx+interface MonthCardProps {+ month: string;+ data: CalendarData;+ maxCount: number;+ onDateClick: (date: string) => void;+}++const MonthCard = memo(({ month, data, maxCount, onDateClick }: MonthCardProps) => (+ <article className="flex flex-col gap-2 rounded-xl border border-border/20 bg-muted/5 p-3 transition-colors hover:bg-muted/10">+ <header className="text-[10px] font-medium text-muted-foreground/80 uppercase tracking-widest">{getMonthLabel(month)}</header>+ <MonthCalendar month={month} data={data} maxCount={maxCount} size="small" onClick={onDateClick} disableTooltips />+ </article>+));+```++After:++```tsx+interface MonthCardProps {+ month: string;+ data: CalendarData;+ maxCount: number;+ onDateClick: (date: string) => void;+ timeBasis?: import("@/contexts/ViewContext").MemoTimeBasis;+}++const MonthCard = memo(({ month, data, maxCount, onDateClick, timeBasis }: MonthCardProps) => (+ <article className="flex flex-col gap-2 rounded-xl border border-border/20 bg-muted/5 p-3 transition-colors hover:bg-muted/10">+ <header className="text-[10px] font-medium text-muted-foreground/80 uppercase tracking-widest">{getMonthLabel(month)}</header>+ <MonthCalendar month={month} data={data} maxCount={maxCount} size="small" onClick={onDateClick} disableTooltips timeBasis={timeBasis} />+ </article>+));+```++(Prefer importing `MemoTimeBasis` at the top of the file with other imports rather than the inline `import(...)` form. The inline form above is shown only to avoid forgetting it; relocate it.)++Then in the `months.map(...)` block (around line 108), pass `timeBasis` down:++Before:++```tsx+{months.map((month) => (+ <MonthCard key={month} month={month} data={yearData} maxCount={yearMaxCount} onDateClick={onDateClick} />+))}+```++After:++```tsx+{months.map((month) => (+ <MonthCard key={month} month={month} data={yearData} maxCount={yearMaxCount} onDateClick={onDateClick} timeBasis={timeBasis} />+))}+```++- [ ] **Step 3: Type-check**++```bash+cd web && pnpm lint+```++Expected: PASS.++- [ ] **Step 4: Commit**++```bash+git add web/src/components/ActivityCalendar/MonthCalendar.tsx web/src/components/ActivityCalendar/YearCalendar.tsx+git commit -m "feat(activity-calendar): forward timeBasis to tooltip"+```++---++## Task 8: Switch `useFilteredMemoStats` source by `timeBasis`++**Files:**+- Modify: `web/src/hooks/useFilteredMemoStats.ts`++- [ ] **Step 1: Read `timeBasis` from ViewContext and switch sources**++Replace the entire body of `web/src/hooks/useFilteredMemoStats.ts` with:++```ts+import { timestampDate } from "@bufbuild/protobuf/wkt";+import dayjs from "dayjs";+import { countBy } from "lodash-es";+import { useMemo } from "react";+import type { MemoExplorerContext } from "@/components/MemoExplorer";+import { type MemoTimeBasis, useView } from "@/contexts/ViewContext";+import useCurrentUser from "@/hooks/useCurrentUser";+import { useMemos } from "@/hooks/useMemoQueries";+import { useUserStats } from "@/hooks/useUserQueries";+import type { Memo } from "@/types/proto/api/v1/memo_service_pb";+import type { StatisticsData } from "@/types/statistics";++export interface FilteredMemoStats {+ statistics: StatisticsData;+ tags: Record<string, number>;+ loading: boolean;+}++export interface UseFilteredMemoStatsOptions {+ userName?: string;+ context?: MemoExplorerContext;+}++const toDateString = (date: Date) => dayjs(date).format("YYYY-MM-DD");++const memoTimestampForBasis = (memo: Memo, basis: MemoTimeBasis): Date | undefined => {+ const ts = basis === "update_time" ? memo.updateTime : memo.createTime;+ return ts ? timestampDate(ts) : undefined;+};++export const useFilteredMemoStats = (options: UseFilteredMemoStatsOptions = {}): FilteredMemoStats => {+ const { userName, context } = options;+ const currentUser = useCurrentUser();+ const { timeBasis } = useView();++ // home/profile: use backend per-user stats (full tag set, not page-limited)+ const { data: userStats, isLoading: isLoadingUserStats } = useUserStats(userName);++ // explore: fetch memos with visibility filter to exclude private content.+ // ListMemos AND's the request filter with the server's auth filter, so private+ // memos are always excluded regardless of backend version.+ // other contexts: fetch with default params for the fallback memo-based path.+ const exploreVisibilityFilter = currentUser != null ? 'visibility in ["PUBLIC", "PROTECTED"]' : 'visibility in ["PUBLIC"]';+ const memoQueryParams = context === "explore" ? { filter: exploreVisibilityFilter, pageSize: 1000 } : {};+ const { data: memosResponse, isLoading: isLoadingMemos } = useMemos(memoQueryParams);++ const data = useMemo(() => {+ const loading = isLoadingUserStats || isLoadingMemos;+ let activityStats: Record<string, number> = {};+ let tagCount: Record<string, number> = {};++ if (context === "explore") {+ // Tags and activity stats from visibility-filtered memos (no private content).+ for (const memo of memosResponse?.memos ?? []) {+ for (const tag of memo.tags ?? []) {+ tagCount[tag] = (tagCount[tag] ?? 0) + 1;+ }+ }+ const displayDates = (memosResponse?.memos ?? [])+ .map((memo) => memoTimestampForBasis(memo, timeBasis))+ .filter((date): date is Date => date !== undefined)+ .map(toDateString);+ activityStats = countBy(displayDates);+ } else if (userName && userStats) {+ // home/profile: use backend per-user stats.+ //+ // Generated protobuf-es types make repeated fields non-optional T[], so an+ // old server that doesn't know the new field will deserialize as []. Since+ // memo.updated_ts is set to created_ts at row creation, the two arrays are+ // expected to be the same length whenever there are memos. Length-based+ // detection is therefore reliable: created non-empty AND updated empty+ // means "old server".+ const createdArray = userStats.memoCreatedTimestamps ?? [];+ const updatedArray = userStats.memoUpdatedTimestamps ?? [];+ const wantUpdated = timeBasis === "update_time";+ const oldServerFallback = wantUpdated && updatedArray.length === 0 && createdArray.length > 0;+ if (oldServerFallback) {+ console.warn("UserStats.memo_updated_timestamps not present; falling back to memo_created_timestamps");+ }+ const sourceArray = wantUpdated && !oldServerFallback ? updatedArray : createdArray;+ if (sourceArray.length > 0) {+ activityStats = countBy(+ sourceArray+ .map((ts) => (ts ? timestampDate(ts) : undefined))+ .filter((date): date is Date => date !== undefined)+ .map(toDateString),+ );+ }+ if (userStats.tagCount) {+ tagCount = userStats.tagCount;+ }+ } else if (memosResponse?.memos) {+ // archived/fallback: compute from cached memos+ const displayDates = memosResponse.memos+ .map((memo) => memoTimestampForBasis(memo, timeBasis))+ .filter((date): date is Date => date !== undefined)+ .map(toDateString);+ activityStats = countBy(displayDates);+ for (const memo of memosResponse.memos) {+ for (const tag of memo.tags ?? []) {+ tagCount[tag] = (tagCount[tag] || 0) + 1;+ }+ }+ }++ return { statistics: { activityStats, timeBasis }, tags: tagCount, loading };+ }, [context, userName, userStats, memosResponse, isLoadingUserStats, isLoadingMemos, timeBasis]);++ return data;+};+```++- [ ] **Step 2: Type-check**++```bash+cd web && pnpm lint+```++Expected: ONE error pointing at `web/src/types/statistics.ts` because `StatisticsData` doesn't yet have `timeBasis`. That's the next task; do not fix it here, leave the failure visible to drive Task 9.++If you see other unrelated errors, stop and reconcile.++---++## Task 9: Add `timeBasis` to `StatisticsData` and forward through `StatisticsView`/`MonthNavigator`++**Files:**+- Modify: `web/src/types/statistics.ts`+- Modify: `web/src/components/StatisticsView/StatisticsView.tsx`+- Modify: `web/src/components/StatisticsView/MonthNavigator.tsx`++- [ ] **Step 1: Extend the data shape**++Replace the contents of `web/src/types/statistics.ts` with:++```ts+import type { MemoTimeBasis } from "@/contexts/ViewContext";++export interface StatisticsViewProps {+ className?: string;+}++export interface MonthNavigatorProps {+ visibleMonth: string;+ onMonthChange: (month: string) => void;+ activityStats: Record<string, number>;+ timeBasis: MemoTimeBasis;+}++export interface StatisticsData {+ activityStats: Record<string, number>;+ timeBasis: MemoTimeBasis;+}+```++- [ ] **Step 2: Forward `timeBasis` from `StatisticsView`**++Open `web/src/components/StatisticsView/StatisticsView.tsx`. The current body (line 12-32) destructures `activityStats` from `statisticsData`. Replace with:++```tsx+const StatisticsView = (props: Props) => {+ const { statisticsData } = props;+ const { activityStats, timeBasis } = statisticsData;+ const navigateToDateFilter = useDateFilterNavigation();+ const [visibleMonthString, setVisibleMonthString] = useState(dayjs().format("YYYY-MM"));++ return (+ <div className="group w-full mt-2 flex flex-col text-muted-foreground animate-fade-in">+ <MonthNavigator+ visibleMonth={visibleMonthString}+ onMonthChange={setVisibleMonthString}+ activityStats={activityStats}+ timeBasis={timeBasis}+ />++ <div className="w-full animate-scale-in">+ <MonthCalendar+ month={visibleMonthString}+ data={activityStats}+ maxCount={calculateMaxCount(activityStats)}+ onClick={navigateToDateFilter}+ timeBasis={timeBasis}+ />+ </div>+ </div>+ );+};+```++- [ ] **Step 3: Forward `timeBasis` from `MonthNavigator` into `YearCalendar`**++Open `web/src/components/StatisticsView/MonthNavigator.tsx`.++Replace the destructured prop list (line 11):++```tsx+export const MonthNavigator = memo(({ visibleMonth, onMonthChange, activityStats }: MonthNavigatorProps) => {+```++With:++```tsx+export const MonthNavigator = memo(({ visibleMonth, onMonthChange, activityStats, timeBasis }: MonthNavigatorProps) => {+```++Then update the `<YearCalendar ... />` call (line 62). Before:++```tsx+<YearCalendar selectedYear={currentYear} data={activityStats} onYearChange={handleYearChange} onDateClick={handleDateClick} />+```++After:++```tsx+<YearCalendar+ selectedYear={currentYear}+ data={activityStats}+ onYearChange={handleYearChange}+ onDateClick={handleDateClick}+ timeBasis={timeBasis}+/>+```++- [ ] **Step 4: Type-check**++```bash+cd web && pnpm lint+```++Expected: PASS.++- [ ] **Step 5: Commit Tasks 8 + 9 together**++```bash+git add web/src/hooks/useFilteredMemoStats.ts web/src/types/statistics.ts web/src/components/StatisticsView/StatisticsView.tsx web/src/components/StatisticsView/MonthNavigator.tsx+git commit -m "feat(activity-calendar): aggregate by ViewContext.timeBasis"+```++---++## Task 10: Frontend test — hook switches source by `timeBasis`++**Files:**+- Create: `web/tests/filtered-memo-stats.test.ts`++We test the hook indirectly by exercising the data-selection logic on a hand-built `userStats` object. Mocking the React Query hooks and ViewContext keeps the test fast and unit-scoped.++- [ ] **Step 1: Write the test**++Create `web/tests/filtered-memo-stats.test.ts`:++```ts+import { renderHook } from "@testing-library/react";+import type { ReactNode } from "react";+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";++// Mock dependencies BEFORE importing the hook under test.+vi.mock("@/hooks/useUserQueries", () => ({+ useUserStats: vi.fn(),+}));+vi.mock("@/hooks/useMemoQueries", () => ({+ useMemos: () => ({ data: undefined, isLoading: false }),+}));+vi.mock("@/hooks/useCurrentUser", () => ({+ default: () => ({ name: "users/test", id: 1 }),+}));++const mockUseView = vi.fn();+vi.mock("@/contexts/ViewContext", async () => {+ const actual = await vi.importActual<typeof import("@/contexts/ViewContext")>("@/contexts/ViewContext");+ return {+ ...actual,+ useView: () => mockUseView(),+ };+});++import { useUserStats } from "@/hooks/useUserQueries";+import { useFilteredMemoStats } from "@/hooks/useFilteredMemoStats";++const wrapper = ({ children }: { children: ReactNode }) => children as JSX.Element;++const ts = (year: number, month: number, day: number) => ({+ seconds: BigInt(Math.floor(Date.UTC(year, month - 1, day) / 1000)),+ nanos: 0,+});++describe("useFilteredMemoStats", () => {+ beforeEach(() => {+ vi.mocked(useUserStats).mockReturnValue({+ data: {+ memoCreatedTimestamps: [ts(2026, 5, 1), ts(2026, 5, 1), ts(2026, 5, 2)],+ memoUpdatedTimestamps: [ts(2026, 5, 3), ts(2026, 5, 3), ts(2026, 5, 3)],+ tagCount: {},+ },+ isLoading: false,+ } as ReturnType<typeof useUserStats>);+ });++ afterEach(() => {+ vi.clearAllMocks();+ });++ it("aggregates by created timestamps when timeBasis is create_time", () => {+ mockUseView.mockReturnValue({ timeBasis: "create_time", orderByTimeAsc: false, toggleSortOrder: vi.fn(), setTimeBasis: vi.fn() });++ const { result } = renderHook(() => useFilteredMemoStats({ userName: "users/test" }), { wrapper });++ expect(result.current.statistics.activityStats).toEqual({ "2026-05-01": 2, "2026-05-02": 1 });+ expect(result.current.statistics.timeBasis).toBe("create_time");+ });++ it("aggregates by updated timestamps when timeBasis is update_time", () => {+ mockUseView.mockReturnValue({ timeBasis: "update_time", orderByTimeAsc: false, toggleSortOrder: vi.fn(), setTimeBasis: vi.fn() });++ const { result } = renderHook(() => useFilteredMemoStats({ userName: "users/test" }), { wrapper });++ expect(result.current.statistics.activityStats).toEqual({ "2026-05-03": 3 });+ expect(result.current.statistics.timeBasis).toBe("update_time");+ });++ it("falls back to created timestamps when updated array is empty (old server)", () => {+ // Old servers that don't know about the new field deserialize it as [].+ // Length-divergence between created and updated is the reliable signal.+ vi.mocked(useUserStats).mockReturnValue({+ data: {+ memoCreatedTimestamps: [ts(2026, 5, 1)],+ memoUpdatedTimestamps: [],+ tagCount: {},+ },+ isLoading: false,+ } as ReturnType<typeof useUserStats>);+ mockUseView.mockReturnValue({ timeBasis: "update_time", orderByTimeAsc: false, toggleSortOrder: vi.fn(), setTimeBasis: vi.fn() });++ const warn = vi.spyOn(console, "warn").mockImplementation(() => {});+ const { result } = renderHook(() => useFilteredMemoStats({ userName: "users/test" }), { wrapper });++ expect(result.current.statistics.activityStats).toEqual({ "2026-05-01": 1 });+ expect(warn).toHaveBeenCalled();+ warn.mockRestore();+ });+});+```++- [ ] **Step 2: Run the test**++```bash+cd web && pnpm test filtered-memo-stats+```++Expected: 3/3 PASS.++If `JSX.Element` is unavailable in the test env (depends on `@testing-library/react` version), change `wrapper`'s return type to `any` or wrap children in a `<>` fragment via `React.createElement`. The intent is "render-only wrapper, no provider needed because we mocked useView".++- [ ] **Step 3: Commit**++```bash+git add web/tests/filtered-memo-stats.test.ts+git commit -m "test(activity-calendar): cover timeBasis source switching"+```++---++## Task 11: Manual verification & final lint++- [ ] **Step 1: Run all frontend checks**++```bash+cd web && pnpm lint && pnpm test+```++Expected: lint clean, all tests PASS.++- [ ] **Step 2: Run all backend checks**++```bash+go test -v -race ./server/router/api/v1/test/... -run "UserStats"+golangci-lint run+```++Expected: tests PASS, lint clean.++- [ ] **Step 3: Manual smoke test in dev**++In two terminals:++```bash+# terminal 1+go run ./cmd/memos --port 8081++# terminal 2+cd web && pnpm dev+```++Open `http://localhost:3001`, sign in, then:++1. Create a memo (today). Verify the heatmap shows +1 today.+2. Edit yesterday's memo (or any past memo, then immediately edit it).+3. Find the time-basis toggle (in the existing view settings; persists in `localStorage` under `memos-view-setting`). Switch to `update_time`.+4. **Expected**: the heatmap recomputes; the edited memo now shows on its `updated_ts` day, not its `created_ts` day. Tooltip text says "X memos updated on YYYY-MM-DD" (lowercase per `getTooltipText`).+5. Switch back to `create_time`. Heatmap reverts; tooltip says "X memos in YYYY-MM-DD".++If no UI control exists for the toggle, set it manually:++```js+// In browser console:+localStorage.setItem("memos-view-setting", JSON.stringify({ orderByTimeAsc: false, timeBasis: "update_time" }));+location.reload();+```++- [ ] **Step 4: No-op commit if nothing changed**++If steps 1-3 surfaced fixes, commit each fix. Otherwise nothing more to commit.diff --git a/docs/superpowers/specs/2026-05-02-activity-calendar-time-basis-design.md b/docs/superpowers/specs/2026-05-02-activity-calendar-time-basis-design.mdnew file mode 100644index 000000000..3212f348a--- /dev/null+++ b/docs/superpowers/specs/2026-05-02-activity-calendar-time-basis-design.md@@ -0,0 +1,124 @@+# ActivityCalendar: Honor `timeBasis` (Create vs Update)++## Problem++The ActivityCalendar in `web/src/components/ActivityCalendar/` always aggregates by memo creation time, regardless of how the surrounding memo list is sorted.++The application already supports a global "time basis" toggle (`web/src/contexts/ViewContext.tsx:3`):++```ts+export type MemoTimeBasis = "create_time" | "update_time";+```++The toggle is persisted in `localStorage` and drives memo list ordering across the app. When a user switches the list to `update_time`, the heatmap below it continues to show creation counts — the two views literally disagree about what "today" means.++This is the user-visible bug we are fixing.++## Non-goals++The following were considered and explicitly excluded:++- **Tracking every individual edit event.** This would require resurrecting the `activity` table that was deliberately dropped in migration `0.27/03__drop_activity.sql`. The cost (write-path instrumentation, storage growth, privacy review) is not justified by this UI bug.+- **Tracking archive / restore / delete events.** Housekeeping actions, not contributions; would also leak private behavior on public Profile/Explore pages.+- **Adding comments or reactions to the heatmap count.** A reasonable separate feature, but a different decision (event-type expansion). Out of scope for this spec — one ticket, one problem.+- **Renaming `ActivityCalendar` to `ContributionCalendar`.** Out of scope.++## Design++### Semantics++The heatmap aggregates one timestamp per memo:++- When `timeBasis === "create_time"`: use `memo.created_ts` (current behavior).+- When `timeBasis === "update_time"`: use `memo.updated_ts`.++Each memo contributes exactly one cell of color, on the day of its chosen timestamp. This matches the list view's semantics exactly: in `update_time` mode, a memo edited on 5/1 and again on 5/2 appears once at 5/2 in the list, and the heatmap will show +1 on 5/2 and nothing on 5/1. The "lossiness" is identical to the lossiness already accepted by the list view — so by definition, the two are consistent.++### Backend++`UserStats` (proto/api/v1/user_service.proto) gains one field:++```proto+// The latest update timestamps of the user's memos.+repeated google.protobuf.Timestamp memo_updated_timestamps = 8;+```++The implementation mirrors `memo_created_timestamps` in `server/router/api/v1/user_service_stats.go`: in the same loop that appends `memo.CreatedTs` (line 115), also append `memo.UpdatedTs` to a parallel slice. The same `FindMemo` filters apply automatically: `RowStatus: NORMAL` (archived excluded), `ExcludeComments: true`, and the viewer-based visibility filter. Both `GetUserStats` and `ListAllUserStats` paths must be updated symmetrically.++No DB migration. No new tables. No new write paths.++### Frontend++`web/src/hooks/useFilteredMemoStats.ts` reads `useView().timeBasis` and switches its data source:++- `create_time` → `userStats.memoCreatedTimestamps` (today's behavior, untouched)+- `update_time` → `userStats.memoUpdatedTimestamps`++The `explore` context branch (which derives stats from the in-memory memo list rather than `userStats`) applies the same switch using `memo.createTime` vs `memo.updateTime` from the cached memos.++The `MonthCalendar` / `YearCalendar` components themselves require no changes — they receive an opaque `Record<date, count>` and render it. The change is confined to the data-source layer.++### Tooltip / labeling++A small but necessary clarification for the user: the cell tooltip should reflect which basis is active, e.g.++- `create_time` mode: "3 memos on May 2"+- `update_time` mode: "3 memos updated on May 2"++This belongs in `ActivityCalendar/utils.ts:getTooltipText`, which already takes a `t` translator. Add a `timeBasis` argument and pick the right i18n key.++## Components++| Unit | Responsibility | Depends on |+|---|---|---|+| `UserStats` proto | Carry both timestamp arrays | — |+| `GetUserStats` server impl | Populate both arrays from `memo` table | store |+| `useFilteredMemoStats` | Pick the correct array based on `timeBasis`; aggregate by day | `useView`, `useUserStats`, `useMemos` |+| `getTooltipText` | Render basis-aware tooltip | i18n |+| `MonthCalendar` / `YearCalendar` | Unchanged — render `Record<date, count>` | — |++## Data flow++```+ViewContext.timeBasis ──┐+ ▼+ useFilteredMemoStats ── pick array ── countBy(day) ── Record<date,count> ── MonthCalendar+ ▲+ userStats ───────────┤ (memo_created_timestamps OR memo_updated_timestamps)+ │+ memos cache ─────────┘ (createTime OR updateTime — explore context only)+```++## Error handling++No new failure modes.++`protobuf-es` generates `repeated` fields as non-optional `T[]`, so an older server that doesn't populate the new field deserializes it as `[]` (never `undefined`). Naïvely treating empty as "no data" would be wrong, because a user with zero memos also gets `[]`. Detection uses **length divergence**: since `memo.updated_ts` is initialized to `created_ts` at row creation, the two arrays are the same length whenever there are any memos. So:++- `created.length === 0 && updated.length === 0` — user has no memos, render empty.+- `created.length > 0 && updated.length === created.length` — new server, normal path.+- `created.length > 0 && updated.length === 0` — old server, fall back to `memoCreatedTimestamps` regardless of `timeBasis`, with a one-line `console.warn`.++## Testing++- Unit test `useFilteredMemoStats`: given a fixed `userStats`, switching `timeBasis` returns aggregations matching the expected source array.+- Unit test the new `getTooltipText` branch.+- Manual verification: in dev, toggle the global time basis and confirm:+ - Heatmap recomputes+ - A memo edited yesterday but created last week shows up "yesterday" in update mode and "last week" in create mode+ - Tooltip text reflects the basis++## Migration / compatibility++- Proto field is additive (tag 8 is unused; tag 2 is `reserved`).+- Old clients ignore the new field.+- New clients tolerate old servers via the fallback above.+- No DB migration.+- No data backfill — `updated_ts` already exists on every memo row.++## Out-of-scope follow-ups (not part of this work)++These came up during brainstorming and are tracked here only so they aren't lost:++1. Adding comment / reaction event types to the heatmap count.+2. A "Memo History / Versions" feature (per-edit snapshots, diffs, optional commit messages). If pursued, the heatmap would become a downstream consumer of that history, and the field added here may be revisited.diff --git a/proto/api/v1/user_service.proto b/proto/api/v1/user_service.protoindex c6eeb86fc..1511deef5 100644--- a/proto/api/v1/user_service.proto+++ b/proto/api/v1/user_service.proto@@ -366,6 +366,11 @@ message UserStats {// The creation timestamps of the user's memos.repeated google.protobuf.Timestamp memo_created_timestamps = 7;+ // The latest update timestamps of the user's memos (one per memo,+ // mirrors memo_created_timestamps). Used by the activity heatmap when+ // the client's view is set to update_time basis.+ repeated google.protobuf.Timestamp memo_updated_timestamps = 8;+// The pinned memos of the user.repeated string pinned_memos = 5;diff --git a/proto/gen/api/v1/user_service.pb.go b/proto/gen/api/v1/user_service.pb.goindex 39d27ce24..fd48b03bc 100644--- a/proto/gen/api/v1/user_service.pb.go+++ b/proto/gen/api/v1/user_service.pb.go@@ -855,6 +855,10 @@ type UserStats struct {TagCount map[string]int32 `protobuf:"bytes,4,rep,name=tag_count,json=tagCount,proto3" json:"tag_count,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`// The creation timestamps of the user's memos.MemoCreatedTimestamps []*timestamppb.Timestamp `protobuf:"bytes,7,rep,name=memo_created_timestamps,json=memoCreatedTimestamps,proto3" json:"memo_created_timestamps,omitempty"`+ // The latest update timestamps of the user's memos (one per memo,+ // mirrors memo_created_timestamps). Used by the activity heatmap when+ // the client's view is set to update_time basis.+ MemoUpdatedTimestamps []*timestamppb.Timestamp `protobuf:"bytes,8,rep,name=memo_updated_timestamps,json=memoUpdatedTimestamps,proto3" json:"memo_updated_timestamps,omitempty"`// The pinned memos of the user.PinnedMemos []string `protobuf:"bytes,5,rep,name=pinned_memos,json=pinnedMemos,proto3" json:"pinned_memos,omitempty"`// Total memo count.@@ -921,6 +925,13 @@ func (x *UserStats) GetMemoCreatedTimestamps() []*timestamppb.Timestamp {return nil}+func (x *UserStats) GetMemoUpdatedTimestamps() []*timestamppb.Timestamp {+ if x != nil {+ return x.MemoUpdatedTimestamps+ }+ return nil+}+func (x *UserStats) GetPinnedMemos() []string {if x != nil {return x.PinnedMemos@@ -3172,12 +3183,13 @@ const file_api_v1_user_service_proto_rawDesc = "" +"\x11DeleteUserRequest\x12-\n" +"\x04name\x18\x01 \x01(\tB\x19\xe0A\x02\xfaA\x13\n" +"\x11memos.api.v1/UserR\x04name\x12\x19\n" +- "\x05force\x18\x02 \x01(\bB\x03\xe0A\x01R\x05force\"\x83\x05\n" ++ "\x05force\x18\x02 \x01(\bB\x03\xe0A\x01R\x05force\"\xd7\x05\n" +"\tUserStats\x12\x17\n" +"\x04name\x18\x01 \x01(\tB\x03\xe0A\bR\x04name\x12M\n" +"\x0fmemo_type_stats\x18\x03 \x01(\v2%.memos.api.v1.UserStats.MemoTypeStatsR\rmemoTypeStats\x12B\n" +"\ttag_count\x18\x04 \x03(\v2%.memos.api.v1.UserStats.TagCountEntryR\btagCount\x12R\n" +- "\x17memo_created_timestamps\x18\a \x03(\v2\x1a.google.protobuf.TimestampR\x15memoCreatedTimestamps\x12!\n" ++ "\x17memo_created_timestamps\x18\a \x03(\v2\x1a.google.protobuf.TimestampR\x15memoCreatedTimestamps\x12R\n" ++ "\x17memo_updated_timestamps\x18\b \x03(\v2\x1a.google.protobuf.TimestampR\x15memoUpdatedTimestamps\x12!\n" +"\fpinned_memos\x18\x05 \x03(\tR\vpinnedMemos\x12(\n" +"\x10total_memo_count\x18\x06 \x01(\x05R\x0etotalMemoCount\x1a;\n" +"\rTagCountEntry\x12\x10\n" +@@ -3478,89 +3490,90 @@ var file_api_v1_user_service_proto_depIdxs = []int32{46, // 10: memos.api.v1.UserStats.memo_type_stats:type_name -> memos.api.v1.UserStats.MemoTypeStats45, // 11: memos.api.v1.UserStats.tag_count:type_name -> memos.api.v1.UserStats.TagCountEntry52, // 12: memos.api.v1.UserStats.memo_created_timestamps:type_name -> google.protobuf.Timestamp- 13, // 13: memos.api.v1.ListAllUserStatsResponse.stats:type_name -> memos.api.v1.UserStats- 47, // 14: memos.api.v1.UserSetting.general_setting:type_name -> memos.api.v1.UserSetting.GeneralSetting- 48, // 15: memos.api.v1.UserSetting.webhooks_setting:type_name -> memos.api.v1.UserSetting.WebhooksSetting- 17, // 16: memos.api.v1.UpdateUserSettingRequest.setting:type_name -> memos.api.v1.UserSetting- 53, // 17: memos.api.v1.UpdateUserSettingRequest.update_mask:type_name -> google.protobuf.FieldMask- 17, // 18: memos.api.v1.ListUserSettingsResponse.settings:type_name -> memos.api.v1.UserSetting- 22, // 19: memos.api.v1.ListLinkedIdentitiesResponse.linked_identities:type_name -> memos.api.v1.LinkedIdentity- 52, // 20: memos.api.v1.PersonalAccessToken.created_at:type_name -> google.protobuf.Timestamp- 52, // 21: memos.api.v1.PersonalAccessToken.expires_at:type_name -> google.protobuf.Timestamp- 52, // 22: memos.api.v1.PersonalAccessToken.last_used_at:type_name -> google.protobuf.Timestamp- 28, // 23: memos.api.v1.ListPersonalAccessTokensResponse.personal_access_tokens:type_name -> memos.api.v1.PersonalAccessToken- 28, // 24: memos.api.v1.CreatePersonalAccessTokenResponse.personal_access_token:type_name -> memos.api.v1.PersonalAccessToken- 52, // 25: memos.api.v1.UserWebhook.create_time:type_name -> google.protobuf.Timestamp- 52, // 26: memos.api.v1.UserWebhook.update_time:type_name -> google.protobuf.Timestamp- 34, // 27: memos.api.v1.ListUserWebhooksResponse.webhooks:type_name -> memos.api.v1.UserWebhook- 34, // 28: memos.api.v1.CreateUserWebhookRequest.webhook:type_name -> memos.api.v1.UserWebhook- 34, // 29: memos.api.v1.UpdateUserWebhookRequest.webhook:type_name -> memos.api.v1.UserWebhook- 53, // 30: memos.api.v1.UpdateUserWebhookRequest.update_mask:type_name -> google.protobuf.FieldMask- 4, // 31: memos.api.v1.UserNotification.sender_user:type_name -> memos.api.v1.User- 2, // 32: memos.api.v1.UserNotification.status:type_name -> memos.api.v1.UserNotification.Status- 52, // 33: memos.api.v1.UserNotification.create_time:type_name -> google.protobuf.Timestamp- 3, // 34: memos.api.v1.UserNotification.type:type_name -> memos.api.v1.UserNotification.Type- 49, // 35: memos.api.v1.UserNotification.memo_comment:type_name -> memos.api.v1.UserNotification.MemoCommentPayload- 50, // 36: memos.api.v1.UserNotification.memo_mention:type_name -> memos.api.v1.UserNotification.MemoMentionPayload- 40, // 37: memos.api.v1.ListUserNotificationsResponse.notifications:type_name -> memos.api.v1.UserNotification- 40, // 38: memos.api.v1.UpdateUserNotificationRequest.notification:type_name -> memos.api.v1.UserNotification- 53, // 39: memos.api.v1.UpdateUserNotificationRequest.update_mask:type_name -> google.protobuf.FieldMask- 34, // 40: memos.api.v1.UserSetting.WebhooksSetting.webhooks:type_name -> memos.api.v1.UserWebhook- 5, // 41: memos.api.v1.UserService.ListUsers:input_type -> memos.api.v1.ListUsersRequest- 7, // 42: memos.api.v1.UserService.BatchGetUsers:input_type -> memos.api.v1.BatchGetUsersRequest- 9, // 43: memos.api.v1.UserService.GetUser:input_type -> memos.api.v1.GetUserRequest- 10, // 44: memos.api.v1.UserService.CreateUser:input_type -> memos.api.v1.CreateUserRequest- 11, // 45: memos.api.v1.UserService.UpdateUser:input_type -> memos.api.v1.UpdateUserRequest- 12, // 46: memos.api.v1.UserService.DeleteUser:input_type -> memos.api.v1.DeleteUserRequest- 15, // 47: memos.api.v1.UserService.ListAllUserStats:input_type -> memos.api.v1.ListAllUserStatsRequest- 14, // 48: memos.api.v1.UserService.GetUserStats:input_type -> memos.api.v1.GetUserStatsRequest- 18, // 49: memos.api.v1.UserService.GetUserSetting:input_type -> memos.api.v1.GetUserSettingRequest- 19, // 50: memos.api.v1.UserService.UpdateUserSetting:input_type -> memos.api.v1.UpdateUserSettingRequest- 20, // 51: memos.api.v1.UserService.ListUserSettings:input_type -> memos.api.v1.ListUserSettingsRequest- 23, // 52: memos.api.v1.UserService.ListLinkedIdentities:input_type -> memos.api.v1.ListLinkedIdentitiesRequest- 25, // 53: memos.api.v1.UserService.CreateLinkedIdentity:input_type -> memos.api.v1.CreateLinkedIdentityRequest- 26, // 54: memos.api.v1.UserService.GetLinkedIdentity:input_type -> memos.api.v1.GetLinkedIdentityRequest- 27, // 55: memos.api.v1.UserService.DeleteLinkedIdentity:input_type -> memos.api.v1.DeleteLinkedIdentityRequest- 29, // 56: memos.api.v1.UserService.ListPersonalAccessTokens:input_type -> memos.api.v1.ListPersonalAccessTokensRequest- 31, // 57: memos.api.v1.UserService.CreatePersonalAccessToken:input_type -> memos.api.v1.CreatePersonalAccessTokenRequest- 33, // 58: memos.api.v1.UserService.DeletePersonalAccessToken:input_type -> memos.api.v1.DeletePersonalAccessTokenRequest- 35, // 59: memos.api.v1.UserService.ListUserWebhooks:input_type -> memos.api.v1.ListUserWebhooksRequest- 37, // 60: memos.api.v1.UserService.CreateUserWebhook:input_type -> memos.api.v1.CreateUserWebhookRequest- 38, // 61: memos.api.v1.UserService.UpdateUserWebhook:input_type -> memos.api.v1.UpdateUserWebhookRequest- 39, // 62: memos.api.v1.UserService.DeleteUserWebhook:input_type -> memos.api.v1.DeleteUserWebhookRequest- 41, // 63: memos.api.v1.UserService.ListUserNotifications:input_type -> memos.api.v1.ListUserNotificationsRequest- 43, // 64: memos.api.v1.UserService.UpdateUserNotification:input_type -> memos.api.v1.UpdateUserNotificationRequest- 44, // 65: memos.api.v1.UserService.DeleteUserNotification:input_type -> memos.api.v1.DeleteUserNotificationRequest- 6, // 66: memos.api.v1.UserService.ListUsers:output_type -> memos.api.v1.ListUsersResponse- 8, // 67: memos.api.v1.UserService.BatchGetUsers:output_type -> memos.api.v1.BatchGetUsersResponse- 4, // 68: memos.api.v1.UserService.GetUser:output_type -> memos.api.v1.User- 4, // 69: memos.api.v1.UserService.CreateUser:output_type -> memos.api.v1.User- 4, // 70: memos.api.v1.UserService.UpdateUser:output_type -> memos.api.v1.User- 54, // 71: memos.api.v1.UserService.DeleteUser:output_type -> google.protobuf.Empty- 16, // 72: memos.api.v1.UserService.ListAllUserStats:output_type -> memos.api.v1.ListAllUserStatsResponse- 13, // 73: memos.api.v1.UserService.GetUserStats:output_type -> memos.api.v1.UserStats- 17, // 74: memos.api.v1.UserService.GetUserSetting:output_type -> memos.api.v1.UserSetting- 17, // 75: memos.api.v1.UserService.UpdateUserSetting:output_type -> memos.api.v1.UserSetting- 21, // 76: memos.api.v1.UserService.ListUserSettings:output_type -> memos.api.v1.ListUserSettingsResponse- 24, // 77: memos.api.v1.UserService.ListLinkedIdentities:output_type -> memos.api.v1.ListLinkedIdentitiesResponse- 22, // 78: memos.api.v1.UserService.CreateLinkedIdentity:output_type -> memos.api.v1.LinkedIdentity- 22, // 79: memos.api.v1.UserService.GetLinkedIdentity:output_type -> memos.api.v1.LinkedIdentity- 54, // 80: memos.api.v1.UserService.DeleteLinkedIdentity:output_type -> google.protobuf.Empty- 30, // 81: memos.api.v1.UserService.ListPersonalAccessTokens:output_type -> memos.api.v1.ListPersonalAccessTokensResponse- 32, // 82: memos.api.v1.UserService.CreatePersonalAccessToken:output_type -> memos.api.v1.CreatePersonalAccessTokenResponse- 54, // 83: memos.api.v1.UserService.DeletePersonalAccessToken:output_type -> google.protobuf.Empty- 36, // 84: memos.api.v1.UserService.ListUserWebhooks:output_type -> memos.api.v1.ListUserWebhooksResponse- 34, // 85: memos.api.v1.UserService.CreateUserWebhook:output_type -> memos.api.v1.UserWebhook- 34, // 86: memos.api.v1.UserService.UpdateUserWebhook:output_type -> memos.api.v1.UserWebhook- 54, // 87: memos.api.v1.UserService.DeleteUserWebhook:output_type -> google.protobuf.Empty- 42, // 88: memos.api.v1.UserService.ListUserNotifications:output_type -> memos.api.v1.ListUserNotificationsResponse- 40, // 89: memos.api.v1.UserService.UpdateUserNotification:output_type -> memos.api.v1.UserNotification- 54, // 90: memos.api.v1.UserService.DeleteUserNotification:output_type -> google.protobuf.Empty- 66, // [66:91] is the sub-list for method output_type- 41, // [41:66] is the sub-list for method input_type- 41, // [41:41] is the sub-list for extension type_name- 41, // [41:41] is the sub-list for extension extendee- 0, // [0:41] is the sub-list for field type_name+ 52, // 13: memos.api.v1.UserStats.memo_updated_timestamps:type_name -> google.protobuf.Timestamp+ 13, // 14: memos.api.v1.ListAllUserStatsResponse.stats:type_name -> memos.api.v1.UserStats+ 47, // 15: memos.api.v1.UserSetting.general_setting:type_name -> memos.api.v1.UserSetting.GeneralSetting+ 48, // 16: memos.api.v1.UserSetting.webhooks_setting:type_name -> memos.api.v1.UserSetting.WebhooksSetting+ 17, // 17: memos.api.v1.UpdateUserSettingRequest.setting:type_name -> memos.api.v1.UserSetting+ 53, // 18: memos.api.v1.UpdateUserSettingRequest.update_mask:type_name -> google.protobuf.FieldMask+ 17, // 19: memos.api.v1.ListUserSettingsResponse.settings:type_name -> memos.api.v1.UserSetting+ 22, // 20: memos.api.v1.ListLinkedIdentitiesResponse.linked_identities:type_name -> memos.api.v1.LinkedIdentity+ 52, // 21: memos.api.v1.PersonalAccessToken.created_at:type_name -> google.protobuf.Timestamp+ 52, // 22: memos.api.v1.PersonalAccessToken.expires_at:type_name -> google.protobuf.Timestamp+ 52, // 23: memos.api.v1.PersonalAccessToken.last_used_at:type_name -> google.protobuf.Timestamp+ 28, // 24: memos.api.v1.ListPersonalAccessTokensResponse.personal_access_tokens:type_name -> memos.api.v1.PersonalAccessToken+ 28, // 25: memos.api.v1.CreatePersonalAccessTokenResponse.personal_access_token:type_name -> memos.api.v1.PersonalAccessToken+ 52, // 26: memos.api.v1.UserWebhook.create_time:type_name -> google.protobuf.Timestamp+ 52, // 27: memos.api.v1.UserWebhook.update_time:type_name -> google.protobuf.Timestamp+ 34, // 28: memos.api.v1.ListUserWebhooksResponse.webhooks:type_name -> memos.api.v1.UserWebhook+ 34, // 29: memos.api.v1.CreateUserWebhookRequest.webhook:type_name -> memos.api.v1.UserWebhook+ 34, // 30: memos.api.v1.UpdateUserWebhookRequest.webhook:type_name -> memos.api.v1.UserWebhook+ 53, // 31: memos.api.v1.UpdateUserWebhookRequest.update_mask:type_name -> google.protobuf.FieldMask+ 4, // 32: memos.api.v1.UserNotification.sender_user:type_name -> memos.api.v1.User+ 2, // 33: memos.api.v1.UserNotification.status:type_name -> memos.api.v1.UserNotification.Status+ 52, // 34: memos.api.v1.UserNotification.create_time:type_name -> google.protobuf.Timestamp+ 3, // 35: memos.api.v1.UserNotification.type:type_name -> memos.api.v1.UserNotification.Type+ 49, // 36: memos.api.v1.UserNotification.memo_comment:type_name -> memos.api.v1.UserNotification.MemoCommentPayload+ 50, // 37: memos.api.v1.UserNotification.memo_mention:type_name -> memos.api.v1.UserNotification.MemoMentionPayload+ 40, // 38: memos.api.v1.ListUserNotificationsResponse.notifications:type_name -> memos.api.v1.UserNotification+ 40, // 39: memos.api.v1.UpdateUserNotificationRequest.notification:type_name -> memos.api.v1.UserNotification+ 53, // 40: memos.api.v1.UpdateUserNotificationRequest.update_mask:type_name -> google.protobuf.FieldMask+ 34, // 41: memos.api.v1.UserSetting.WebhooksSetting.webhooks:type_name -> memos.api.v1.UserWebhook+ 5, // 42: memos.api.v1.UserService.ListUsers:input_type -> memos.api.v1.ListUsersRequest+ 7, // 43: memos.api.v1.UserService.BatchGetUsers:input_type -> memos.api.v1.BatchGetUsersRequest+ 9, // 44: memos.api.v1.UserService.GetUser:input_type -> memos.api.v1.GetUserRequest+ 10, // 45: memos.api.v1.UserService.CreateUser:input_type -> memos.api.v1.CreateUserRequest+ 11, // 46: memos.api.v1.UserService.UpdateUser:input_type -> memos.api.v1.UpdateUserRequest+ 12, // 47: memos.api.v1.UserService.DeleteUser:input_type -> memos.api.v1.DeleteUserRequest+ 15, // 48: memos.api.v1.UserService.ListAllUserStats:input_type -> memos.api.v1.ListAllUserStatsRequest+ 14, // 49: memos.api.v1.UserService.GetUserStats:input_type -> memos.api.v1.GetUserStatsRequest+ 18, // 50: memos.api.v1.UserService.GetUserSetting:input_type -> memos.api.v1.GetUserSettingRequest+ 19, // 51: memos.api.v1.UserService.UpdateUserSetting:input_type -> memos.api.v1.UpdateUserSettingRequest+ 20, // 52: memos.api.v1.UserService.ListUserSettings:input_type -> memos.api.v1.ListUserSettingsRequest+ 23, // 53: memos.api.v1.UserService.ListLinkedIdentities:input_type -> memos.api.v1.ListLinkedIdentitiesRequest+ 25, // 54: memos.api.v1.UserService.CreateLinkedIdentity:input_type -> memos.api.v1.CreateLinkedIdentityRequest+ 26, // 55: memos.api.v1.UserService.GetLinkedIdentity:input_type -> memos.api.v1.GetLinkedIdentityRequest+ 27, // 56: memos.api.v1.UserService.DeleteLinkedIdentity:input_type -> memos.api.v1.DeleteLinkedIdentityRequest+ 29, // 57: memos.api.v1.UserService.ListPersonalAccessTokens:input_type -> memos.api.v1.ListPersonalAccessTokensRequest+ 31, // 58: memos.api.v1.UserService.CreatePersonalAccessToken:input_type -> memos.api.v1.CreatePersonalAccessTokenRequest+ 33, // 59: memos.api.v1.UserService.DeletePersonalAccessToken:input_type -> memos.api.v1.DeletePersonalAccessTokenRequest+ 35, // 60: memos.api.v1.UserService.ListUserWebhooks:input_type -> memos.api.v1.ListUserWebhooksRequest+ 37, // 61: memos.api.v1.UserService.CreateUserWebhook:input_type -> memos.api.v1.CreateUserWebhookRequest+ 38, // 62: memos.api.v1.UserService.UpdateUserWebhook:input_type -> memos.api.v1.UpdateUserWebhookRequest+ 39, // 63: memos.api.v1.UserService.DeleteUserWebhook:input_type -> memos.api.v1.DeleteUserWebhookRequest+ 41, // 64: memos.api.v1.UserService.ListUserNotifications:input_type -> memos.api.v1.ListUserNotificationsRequest+ 43, // 65: memos.api.v1.UserService.UpdateUserNotification:input_type -> memos.api.v1.UpdateUserNotificationRequest+ 44, // 66: memos.api.v1.UserService.DeleteUserNotification:input_type -> memos.api.v1.DeleteUserNotificationRequest+ 6, // 67: memos.api.v1.UserService.ListUsers:output_type -> memos.api.v1.ListUsersResponse+ 8, // 68: memos.api.v1.UserService.BatchGetUsers:output_type -> memos.api.v1.BatchGetUsersResponse+ 4, // 69: memos.api.v1.UserService.GetUser:output_type -> memos.api.v1.User+ 4, // 70: memos.api.v1.UserService.CreateUser:output_type -> memos.api.v1.User+ 4, // 71: memos.api.v1.UserService.UpdateUser:output_type -> memos.api.v1.User+ 54, // 72: memos.api.v1.UserService.DeleteUser:output_type -> google.protobuf.Empty+ 16, // 73: memos.api.v1.UserService.ListAllUserStats:output_type -> memos.api.v1.ListAllUserStatsResponse+ 13, // 74: memos.api.v1.UserService.GetUserStats:output_type -> memos.api.v1.UserStats+ 17, // 75: memos.api.v1.UserService.GetUserSetting:output_type -> memos.api.v1.UserSetting+ 17, // 76: memos.api.v1.UserService.UpdateUserSetting:output_type -> memos.api.v1.UserSetting+ 21, // 77: memos.api.v1.UserService.ListUserSettings:output_type -> memos.api.v1.ListUserSettingsResponse+ 24, // 78: memos.api.v1.UserService.ListLinkedIdentities:output_type -> memos.api.v1.ListLinkedIdentitiesResponse+ 22, // 79: memos.api.v1.UserService.CreateLinkedIdentity:output_type -> memos.api.v1.LinkedIdentity+ 22, // 80: memos.api.v1.UserService.GetLinkedIdentity:output_type -> memos.api.v1.LinkedIdentity+ 54, // 81: memos.api.v1.UserService.DeleteLinkedIdentity:output_type -> google.protobuf.Empty+ 30, // 82: memos.api.v1.UserService.ListPersonalAccessTokens:output_type -> memos.api.v1.ListPersonalAccessTokensResponse+ 32, // 83: memos.api.v1.UserService.CreatePersonalAccessToken:output_type -> memos.api.v1.CreatePersonalAccessTokenResponse+ 54, // 84: memos.api.v1.UserService.DeletePersonalAccessToken:output_type -> google.protobuf.Empty+ 36, // 85: memos.api.v1.UserService.ListUserWebhooks:output_type -> memos.api.v1.ListUserWebhooksResponse+ 34, // 86: memos.api.v1.UserService.CreateUserWebhook:output_type -> memos.api.v1.UserWebhook+ 34, // 87: memos.api.v1.UserService.UpdateUserWebhook:output_type -> memos.api.v1.UserWebhook+ 54, // 88: memos.api.v1.UserService.DeleteUserWebhook:output_type -> google.protobuf.Empty+ 42, // 89: memos.api.v1.UserService.ListUserNotifications:output_type -> memos.api.v1.ListUserNotificationsResponse+ 40, // 90: memos.api.v1.UserService.UpdateUserNotification:output_type -> memos.api.v1.UserNotification+ 54, // 91: memos.api.v1.UserService.DeleteUserNotification:output_type -> google.protobuf.Empty+ 67, // [67:92] is the sub-list for method output_type+ 42, // [42:67] is the sub-list for method input_type+ 42, // [42:42] is the sub-list for extension type_name+ 42, // [42:42] is the sub-list for extension extendee+ 0, // [0:42] is the sub-list for field type_name}func init() { file_api_v1_user_service_proto_init() }diff --git a/proto/gen/openapi.yaml b/proto/gen/openapi.yamlindex ec16f65a5..50668ccaf 100644--- a/proto/gen/openapi.yaml+++ b/proto/gen/openapi.yaml@@ -3809,6 +3809,15 @@ components:type: stringformat: date-timedescription: The creation timestamps of the user's memos.+ memoUpdatedTimestamps:+ type: array+ items:+ type: string+ format: date-time+ description: |-+ The latest update timestamps of the user's memos (one per memo,+ mirrors memo_created_timestamps). Used by the activity heatmap when+ the client's view is set to update_time basis.pinnedMemos:type: arrayitems:diff --git a/server/router/api/v1/test/user_service_stats_test.go b/server/router/api/v1/test/user_service_stats_test.goindex 901191fb6..bac17e137 100644--- a/server/router/api/v1/test/user_service_stats_test.go+++ b/server/router/api/v1/test/user_service_stats_test.go@@ -110,3 +110,51 @@ func TestGetUserStats_TagCount(t *testing.T) {require.Error(t, err)require.Contains(t, err.Error(), "user not found")}++func TestGetUserStats_MemoUpdatedTimestamps(t *testing.T) {+ ctx := context.Background()++ ts := NewTestService(t)+ defer ts.Cleanup()++ user, err := ts.CreateHostUser(ctx, "ts-user")+ require.NoError(t, err)+ userCtx := ts.CreateUserContext(ctx, user.ID)++ memo, err := ts.Store.CreateMemo(ctx, &store.Memo{+ UID: "ts-memo-1",+ CreatorID: user.ID,+ Content: "first content",+ Visibility: store.Public,+ })+ require.NoError(t, err)+ require.NotNil(t, memo)++ // SQLite UpdateMemo only sets fields explicitly passed (created_ts default+ // fires on INSERT only). So bump updated_ts explicitly to simulate an edit+ // happening after creation.+ newContent := "second content"+ newUpdatedTs := memo.UpdatedTs + 100+ require.NoError(t, ts.Store.UpdateMemo(ctx, &store.UpdateMemo{+ ID: memo.ID,+ Content: &newContent,+ UpdatedTs: &newUpdatedTs,+ }))++ userName := fmt.Sprintf("users/%s", user.Username)+ resp, err := ts.Service.GetUserStats(userCtx, &v1pb.GetUserStatsRequest{Name: userName})+ require.NoError(t, err)+ require.NotNil(t, resp)++ require.Len(t, resp.MemoCreatedTimestamps, 1, "should have one created timestamp")+ require.Len(t, resp.MemoUpdatedTimestamps, 1, "should have one updated timestamp")++ require.Equal(t, memo.CreatedTs, resp.MemoCreatedTimestamps[0].AsTime().Unix())+ require.Equal(t, newUpdatedTs, resp.MemoUpdatedTimestamps[0].AsTime().Unix())+ require.Greater(+ t,+ resp.MemoUpdatedTimestamps[0].AsTime().Unix(),+ resp.MemoCreatedTimestamps[0].AsTime().Unix(),+ "updated_ts should be after created_ts after an edit",+ )+}diff --git a/server/router/api/v1/user_service_stats.go b/server/router/api/v1/user_service_stats.goindex 73670c294..bc47797f4 100644--- a/server/router/api/v1/user_service_stats.go+++ b/server/router/api/v1/user_service_stats.go@@ -100,6 +100,7 @@ func (s *APIV1Service) ListAllUserStats(ctx context.Context, _ *v1pb.ListAllUserName: "",TagCount: make(map[string]int32),MemoCreatedTimestamps: []*timestamppb.Timestamp{},+ MemoUpdatedTimestamps: []*timestamppb.Timestamp{},PinnedMemos: []string{},MemoTypeStats: &v1pb.UserStats_MemoTypeStats{LinkCount: 0,@@ -113,6 +114,7 @@ func (s *APIV1Service) ListAllUserStats(ctx context.Context, _ *v1pb.ListAllUserstats := userMemoStatMap[memo.CreatorID]stats.MemoCreatedTimestamps = append(stats.MemoCreatedTimestamps, timestamppb.New(time.Unix(memo.CreatedTs, 0)))+ stats.MemoUpdatedTimestamps = append(stats.MemoUpdatedTimestamps, timestamppb.New(time.Unix(memo.UpdatedTs, 0)))// Count memo statsstats.TotalMemoCount++@@ -205,6 +207,7 @@ func (s *APIV1Service) GetUserStats(ctx context.Context, request *v1pb.GetUserSt}createdTimestamps := []*timestamppb.Timestamp{}+ updatedTimestamps := []*timestamppb.Timestamp{}tagCount := make(map[string]int32)linkCount := int32(0)codeCount := int32(0)@@ -231,6 +234,7 @@ func (s *APIV1Service) GetUserStats(ctx context.Context, request *v1pb.GetUserStfor _, memo := range memos {createdTimestamps = append(createdTimestamps, timestamppb.New(time.Unix(memo.CreatedTs, 0)))+ updatedTimestamps = append(updatedTimestamps, timestamppb.New(time.Unix(memo.UpdatedTs, 0)))// Count different memo types based on content.if memo.Payload != nil {for _, tag := range memo.Payload.Tags {@@ -262,6 +266,7 @@ func (s *APIV1Service) GetUserStats(ctx context.Context, request *v1pb.GetUserStuserStats := &v1pb.UserStats{Name: fmt.Sprintf("%s/stats", BuildUserName(user.Username)),MemoCreatedTimestamps: createdTimestamps,+ MemoUpdatedTimestamps: updatedTimestamps,TagCount: tagCount,PinnedMemos: pinnedMemos,TotalMemoCount: totalMemoCount,diff --git a/web/src/components/ActivityCalendar/MonthCalendar.tsx b/web/src/components/ActivityCalendar/MonthCalendar.tsxindex 3c3e9176c..7c114c316 100644--- a/web/src/components/ActivityCalendar/MonthCalendar.tsx+++ b/web/src/components/ActivityCalendar/MonthCalendar.tsx@@ -35,7 +35,17 @@ const WeekdayHeader = memo(({ weekDays, size }: WeekdayHeaderProps) => (WeekdayHeader.displayName = "WeekdayHeader";export const MonthCalendar = memo((props: MonthCalendarProps) => {- const { month, data, maxCount, size = "default", onClick, selectedDate, className, disableTooltips = false } = props;+ const {+ month,+ data,+ maxCount,+ size = "default",+ onClick,+ selectedDate,+ className,+ disableTooltips = false,+ timeBasis = "create_time",+ } = props;const t = useTranslate();const { generalSetting } = useInstance();const today = useTodayDate();@@ -63,7 +73,7 @@ export const MonthCalendar = memo((props: MonthCalendarProps) => {key={day.date}day={day}maxCount={maxCount}- tooltipText={getTooltipText(day.count, day.date, t)}+ tooltipText={getTooltipText(day.count, day.date, t, timeBasis)}onClick={onClick}size={size}disableTooltip={disableTooltips}diff --git a/web/src/components/ActivityCalendar/YearCalendar.tsx b/web/src/components/ActivityCalendar/YearCalendar.tsxindex 6c82faf9f..4e357f16e 100644--- a/web/src/components/ActivityCalendar/YearCalendar.tsx+++ b/web/src/components/ActivityCalendar/YearCalendar.tsx@@ -1,6 +1,7 @@import { ChevronLeftIcon, ChevronRightIcon } from "lucide-react";import { memo, useMemo } from "react";import { Button } from "@/components/ui/button";+import type { MemoTimeBasis } from "@/contexts/ViewContext";import { cn } from "@/lib/utils";import { useTranslate } from "@/utils/i18n";import { getMaxYear, MIN_YEAR } from "./constants";@@ -73,17 +74,18 @@ interface MonthCardProps {data: CalendarData;maxCount: number;onDateClick: (date: string) => void;+ timeBasis?: MemoTimeBasis;}-const MonthCard = memo(({ month, data, maxCount, onDateClick }: MonthCardProps) => (+const MonthCard = memo(({ month, data, maxCount, onDateClick, timeBasis }: MonthCardProps) => (<article className="flex flex-col gap-2 rounded-xl border border-border/20 bg-muted/5 p-3 transition-colors hover:bg-muted/10"><header className="text-[10px] font-medium text-muted-foreground/80 uppercase tracking-widest">{getMonthLabel(month)}</header>- <MonthCalendar month={month} data={data} maxCount={maxCount} size="small" onClick={onDateClick} disableTooltips />+ <MonthCalendar month={month} data={data} maxCount={maxCount} size="small" onClick={onDateClick} disableTooltips timeBasis={timeBasis} /></article>));MonthCard.displayName = "MonthCard";-export const YearCalendar = memo(({ selectedYear, data, onYearChange, onDateClick, className }: YearCalendarProps) => {+export const YearCalendar = memo(({ selectedYear, data, onYearChange, onDateClick, className, timeBasis }: YearCalendarProps) => {const currentYear = useMemo(() => new Date().getFullYear(), []);const yearData = useMemo(() => filterDataByYear(data, selectedYear), [data, selectedYear]);const months = useMemo(() => generateMonthsForYear(selectedYear), [selectedYear]);@@ -106,7 +108,7 @@ export const YearCalendar = memo(({ selectedYear, data, onYearChange, onDateClic<div className="grid gap-4 grid-cols-1 sm:grid-cols-2 md:grid-cols-3 lg:grid-cols-4 animate-fade-in">{months.map((month) => (- <MonthCard key={month} month={month} data={yearData} maxCount={yearMaxCount} onDateClick={onDateClick} />+ <MonthCard key={month} month={month} data={yearData} maxCount={yearMaxCount} onDateClick={onDateClick} timeBasis={timeBasis} />))}</div></section>diff --git a/web/src/components/ActivityCalendar/types.ts b/web/src/components/ActivityCalendar/types.tsindex 119b0d071..b5e4c0438 100644--- a/web/src/components/ActivityCalendar/types.ts+++ b/web/src/components/ActivityCalendar/types.ts@@ -1,3 +1,5 @@+import type { MemoTimeBasis } from "@/contexts/ViewContext";+export type CalendarSize = "default" | "small";export type CalendarData = Record<string, number>;@@ -28,6 +30,7 @@ export interface MonthCalendarProps {selectedDate?: string;className?: string;disableTooltips?: boolean;+ timeBasis?: MemoTimeBasis;}export interface YearCalendarProps {@@ -36,4 +39,5 @@ export interface YearCalendarProps {onYearChange: (year: number) => void;onDateClick: (date: string) => void;className?: string;+ timeBasis?: MemoTimeBasis;}diff --git a/web/src/components/ActivityCalendar/utils.ts b/web/src/components/ActivityCalendar/utils.tsindex 368c26abe..60f91b584 100644--- a/web/src/components/ActivityCalendar/utils.ts+++ b/web/src/components/ActivityCalendar/utils.ts@@ -1,6 +1,7 @@import dayjs from "dayjs";import isSameOrAfter from "dayjs/plugin/isSameOrAfter";import isSameOrBefore from "dayjs/plugin/isSameOrBefore";+import type { MemoTimeBasis } from "@/contexts/ViewContext";import { cn } from "@/lib/utils";import { useTranslate } from "@/utils/i18n";import { CELL_STYLES, INTENSITY_THRESHOLDS, MIN_COUNT, MONTHS_IN_YEAR } from "./constants";@@ -60,12 +61,13 @@ export const filterDataByYear = (data: Record<string, number>, year: number): Rereturn filtered;};-export const getTooltipText = (count: number, date: string, t: TranslateFunction): string => {+export const getTooltipText = (count: number, date: string, t: TranslateFunction, timeBasis: MemoTimeBasis = "create_time"): string => {if (count === 0) {return date;}- return t("memo.count-memos-in-date", {+ const key = timeBasis === "update_time" ? "memo.count-memos-updated-in-date" : "memo.count-memos-in-date";+ return t(key, {count,memos: count === 1 ? t("common.memo") : t("common.memos"),date,diff --git a/web/src/components/StatisticsView/MonthNavigator.tsx b/web/src/components/StatisticsView/MonthNavigator.tsxindex 14af7c8e1..60d8184a3 100644--- a/web/src/components/StatisticsView/MonthNavigator.tsx+++ b/web/src/components/StatisticsView/MonthNavigator.tsx@@ -8,7 +8,7 @@ import { Dialog, DialogContent, DialogTitle, DialogTrigger } from "@/components/import { addMonths, formatMonth, getMonthFromDate, getYearFromDate, setYearAndMonth } from "@/lib/calendar-utils";import type { MonthNavigatorProps } from "@/types/statistics";-export const MonthNavigator = memo(({ visibleMonth, onMonthChange, activityStats }: MonthNavigatorProps) => {+export const MonthNavigator = memo(({ visibleMonth, onMonthChange, activityStats, timeBasis }: MonthNavigatorProps) => {const { i18n } = useTranslation();const [isOpen, setIsOpen] = useState(false);@@ -59,7 +59,13 @@ export const MonthNavigator = memo(({ visibleMonth, onMonthChange, activityStatsshowCloseButton={false}><DialogTitle className="sr-only">Select Month</DialogTitle>- <YearCalendar selectedYear={currentYear} data={activityStats} onYearChange={handleYearChange} onDateClick={handleDateClick} />+ <YearCalendar+ selectedYear={currentYear}+ data={activityStats}+ onYearChange={handleYearChange}+ onDateClick={handleDateClick}+ timeBasis={timeBasis}+ /></DialogContent></Dialog>diff --git a/web/src/components/StatisticsView/StatisticsView.tsx b/web/src/components/StatisticsView/StatisticsView.tsxindex 02b0e6b93..7bea77c85 100644--- a/web/src/components/StatisticsView/StatisticsView.tsx+++ b/web/src/components/StatisticsView/StatisticsView.tsx@@ -11,13 +11,18 @@ interface Props {const StatisticsView = (props: Props) => {const { statisticsData } = props;- const { activityStats } = statisticsData;+ const { activityStats, timeBasis } = statisticsData;const navigateToDateFilter = useDateFilterNavigation();const [visibleMonthString, setVisibleMonthString] = useState(dayjs().format("YYYY-MM"));return (<div className="group w-full mt-2 flex flex-col text-muted-foreground animate-fade-in">- <MonthNavigator visibleMonth={visibleMonthString} onMonthChange={setVisibleMonthString} activityStats={activityStats} />+ <MonthNavigator+ visibleMonth={visibleMonthString}+ onMonthChange={setVisibleMonthString}+ activityStats={activityStats}+ timeBasis={timeBasis}+ /><div className="w-full animate-scale-in"><MonthCalendar@@ -25,6 +30,7 @@ const StatisticsView = (props: Props) => {data={activityStats}maxCount={calculateMaxCount(activityStats)}onClick={navigateToDateFilter}+ timeBasis={timeBasis}/></div></div>diff --git a/web/src/hooks/useFilteredMemoStats.ts b/web/src/hooks/useFilteredMemoStats.tsindex 8b8c90bf5..f9f0b4112 100644--- a/web/src/hooks/useFilteredMemoStats.ts+++ b/web/src/hooks/useFilteredMemoStats.ts@@ -3,9 +3,11 @@ import dayjs from "dayjs";import { countBy } from "lodash-es";import { useMemo } from "react";import type { MemoExplorerContext } from "@/components/MemoExplorer";+import { type MemoTimeBasis, useView } from "@/contexts/ViewContext";import useCurrentUser from "@/hooks/useCurrentUser";import { useMemos } from "@/hooks/useMemoQueries";import { useUserStats } from "@/hooks/useUserQueries";+import type { Memo } from "@/types/proto/api/v1/memo_service_pb";import type { StatisticsData } from "@/types/statistics";export interface FilteredMemoStats {@@ -21,9 +23,15 @@ export interface UseFilteredMemoStatsOptions {const toDateString = (date: Date) => dayjs(date).format("YYYY-MM-DD");+const memoTimestampForBasis = (memo: Memo, basis: MemoTimeBasis): Date | undefined => {+ const ts = basis === "update_time" ? memo.updateTime : memo.createTime;+ return ts ? timestampDate(ts) : undefined;+};+export const useFilteredMemoStats = (options: UseFilteredMemoStatsOptions = {}): FilteredMemoStats => {const { userName, context } = options;const currentUser = useCurrentUser();+ const { timeBasis } = useView();// home/profile: use backend per-user stats (full tag set, not page-limited)const { data: userStats, isLoading: isLoadingUserStats } = useUserStats(userName);@@ -49,15 +57,30 @@ export const useFilteredMemoStats = (options: UseFilteredMemoStatsOptions = {}):}}const displayDates = (memosResponse?.memos ?? [])- .map((memo) => (memo.createTime ? timestampDate(memo.createTime) : undefined))+ .map((memo) => memoTimestampForBasis(memo, timeBasis)).filter((date): date is Date => date !== undefined).map(toDateString);activityStats = countBy(displayDates);} else if (userName && userStats) {- // home/profile: use backend per-user stats- if (userStats.memoCreatedTimestamps && userStats.memoCreatedTimestamps.length > 0) {+ // home/profile: use backend per-user stats.+ //+ // protobuf-es generates repeated fields as non-optional T[], so an old+ // server that doesn't know the new field deserializes it as []. Since+ // memo.updated_ts is initialized to created_ts at row creation, the two+ // arrays are always the same length when there are memos. Length+ // divergence (created non-empty AND updated empty) therefore reliably+ // signals "old server" and is the only case where we fall back.+ const createdArray = userStats.memoCreatedTimestamps ?? [];+ const updatedArray = userStats.memoUpdatedTimestamps ?? [];+ const wantUpdated = timeBasis === "update_time";+ const oldServerFallback = wantUpdated && updatedArray.length === 0 && createdArray.length > 0;+ if (oldServerFallback) {+ console.warn("UserStats.memo_updated_timestamps not present; falling back to memo_created_timestamps");+ }+ const sourceArray = wantUpdated && !oldServerFallback ? updatedArray : createdArray;+ if (sourceArray.length > 0) {activityStats = countBy(- userStats.memoCreatedTimestamps+ sourceArray.map((ts) => (ts ? timestampDate(ts) : undefined)).filter((date): date is Date => date !== undefined).map(toDateString),@@ -69,7 +92,7 @@ export const useFilteredMemoStats = (options: UseFilteredMemoStatsOptions = {}):} else if (memosResponse?.memos) {// archived/fallback: compute from cached memosconst displayDates = memosResponse.memos- .map((memo) => (memo.createTime ? timestampDate(memo.createTime) : undefined))+ .map((memo) => memoTimestampForBasis(memo, timeBasis)).filter((date): date is Date => date !== undefined).map(toDateString);activityStats = countBy(displayDates);@@ -80,8 +103,8 @@ export const useFilteredMemoStats = (options: UseFilteredMemoStatsOptions = {}):}}- return { statistics: { activityStats }, tags: tagCount, loading };- }, [context, userName, userStats, memosResponse, isLoadingUserStats, isLoadingMemos]);+ return { statistics: { activityStats, timeBasis }, tags: tagCount, loading };+ }, [context, userName, userStats, memosResponse, isLoadingUserStats, isLoadingMemos, timeBasis]);return data;};diff --git a/web/src/locales/en.json b/web/src/locales/en.jsonindex 10156590d..7a3ec8a67 100644--- a/web/src/locales/en.json+++ b/web/src/locales/en.json@@ -231,6 +231,7 @@"copy-content": "Copy Content","copy-link": "Copy Link","count-memos-in-date": "{{count}} {{memos}} in {{date}}",+ "count-memos-updated-in-date": "{{count}} {{memos}} updated on {{date}}","delete-confirm": "Are you sure you want to delete this memo?","delete-confirm-description": "This action is irreversible. Attachments, links, and references will also be removed.","direction": "Direction",diff --git a/web/src/types/proto/api/v1/user_service_pb.ts b/web/src/types/proto/api/v1/user_service_pb.tsindex 6f9a52aa4..747ee0fb9 100644--- a/web/src/types/proto/api/v1/user_service_pb.ts+++ b/web/src/types/proto/api/v1/user_service_pb.ts@@ -18,7 +18,7 @@ import type { Message } from "@bufbuild/protobuf";* Describes the file api/v1/user_service.proto.*/export const file_api_v1_user_service: GenFile = /*@__PURE__*/- fileDesc("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", [file_api_v1_common, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_empty, file_google_protobuf_field_mask, file_google_protobuf_timestamp]);+ fileDesc("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", [file_api_v1_common, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_empty, file_google_protobuf_field_mask, file_google_protobuf_timestamp]);/*** @generated from message memos.api.v1.User@@ -423,6 +423,15 @@ export type UserStats = Message<"memos.api.v1.UserStats"> & {*/memoCreatedTimestamps: Timestamp[];+ /**+ * The latest update timestamps of the user's memos (one per memo,+ * mirrors memo_created_timestamps). Used by the activity heatmap when+ * the client's view is set to update_time basis.+ *+ * @generated from field: repeated google.protobuf.Timestamp memo_updated_timestamps = 8;+ */+ memoUpdatedTimestamps: Timestamp[];+/*** The pinned memos of the user.*diff --git a/web/src/types/statistics.ts b/web/src/types/statistics.tsindex acb2330e4..b8e92dc34 100644--- a/web/src/types/statistics.ts+++ b/web/src/types/statistics.ts@@ -1,3 +1,5 @@+import type { MemoTimeBasis } from "@/contexts/ViewContext";+export interface StatisticsViewProps {className?: string;}@@ -6,8 +8,10 @@ export interface MonthNavigatorProps {visibleMonth: string;onMonthChange: (month: string) => void;activityStats: Record<string, number>;+ timeBasis: MemoTimeBasis;}export interface StatisticsData {activityStats: Record<string, number>;+ timeBasis: MemoTimeBasis;}diff --git a/web/tests/activity-calendar-tooltip.test.ts b/web/tests/activity-calendar-tooltip.test.tsnew file mode 100644index 000000000..edeb768d8--- /dev/null+++ b/web/tests/activity-calendar-tooltip.test.ts@@ -0,0 +1,26 @@+import { describe, expect, it } from "vitest";+import { getTooltipText } from "@/components/ActivityCalendar/utils";++// Minimal stub for the i18n translate fn — returns a deterministic string we can assert on.+const t = ((key: string, vars?: Record<string, unknown>) => {+ if (!vars) return key;+ const parts = Object.entries(vars).map(([k, v]) => `${k}=${String(v)}`);+ return `${key}|${parts.join(",")}`;+}) as Parameters<typeof getTooltipText>[2];++describe("getTooltipText", () => {+ it("returns just the date when count is 0", () => {+ expect(getTooltipText(0, "2026-05-02", t)).toBe("2026-05-02");+ });++ it("uses the created-tooltip key for create_time basis (default)", () => {+ const out = getTooltipText(3, "2026-05-02", t);+ expect(out.toLowerCase()).toContain("memo.count-memos-in-date");+ expect(out.toLowerCase()).not.toContain("updated");+ });++ it("uses the updated-tooltip key for update_time basis", () => {+ const out = getTooltipText(3, "2026-05-02", t, "update_time");+ expect(out.toLowerCase()).toContain("memo.count-memos-updated-in-date");+ });+});diff --git a/web/tests/filtered-memo-stats.test.ts b/web/tests/filtered-memo-stats.test.tsnew file mode 100644index 000000000..0e3f3a0b5--- /dev/null+++ b/web/tests/filtered-memo-stats.test.ts@@ -0,0 +1,104 @@+import { renderHook } from "@testing-library/react";+import type { ReactNode } from "react";+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";++// Mock dependencies BEFORE importing the hook under test.+vi.mock("@/hooks/useUserQueries", () => ({+ useUserStats: vi.fn(),+}));+vi.mock("@/hooks/useMemoQueries", () => ({+ useMemos: () => ({ data: undefined, isLoading: false }),+}));+vi.mock("@/hooks/useCurrentUser", () => ({+ default: () => ({ name: "users/test", id: 1 }),+}));++const mockUseView = vi.fn();+vi.mock("@/contexts/ViewContext", async () => {+ const actual = await vi.importActual<typeof import("@/contexts/ViewContext")>("@/contexts/ViewContext");+ return {+ ...actual,+ useView: () => mockUseView(),+ };+});++import { useUserStats } from "@/hooks/useUserQueries";+import { useFilteredMemoStats } from "@/hooks/useFilteredMemoStats";++const wrapper = ({ children }: { children: ReactNode }) => children as never;++const ts = (year: number, month: number, day: number) => ({+ seconds: BigInt(Math.floor(Date.UTC(year, month - 1, day) / 1000)),+ nanos: 0,+});++describe("useFilteredMemoStats", () => {+ beforeEach(() => {+ vi.mocked(useUserStats).mockReturnValue({+ data: {+ memoCreatedTimestamps: [ts(2026, 5, 1), ts(2026, 5, 1), ts(2026, 5, 2)],+ memoUpdatedTimestamps: [ts(2026, 5, 3), ts(2026, 5, 3), ts(2026, 5, 3)],+ tagCount: {},+ },+ isLoading: false,+ } as ReturnType<typeof useUserStats>);+ });++ afterEach(() => {+ vi.clearAllMocks();+ });++ it("aggregates by created timestamps when timeBasis is create_time", () => {+ mockUseView.mockReturnValue({+ timeBasis: "create_time",+ orderByTimeAsc: false,+ toggleSortOrder: vi.fn(),+ setTimeBasis: vi.fn(),+ });++ const { result } = renderHook(() => useFilteredMemoStats({ userName: "users/test" }), { wrapper });++ expect(result.current.statistics.activityStats).toEqual({ "2026-05-01": 2, "2026-05-02": 1 });+ expect(result.current.statistics.timeBasis).toBe("create_time");+ });++ it("aggregates by updated timestamps when timeBasis is update_time", () => {+ mockUseView.mockReturnValue({+ timeBasis: "update_time",+ orderByTimeAsc: false,+ toggleSortOrder: vi.fn(),+ setTimeBasis: vi.fn(),+ });++ const { result } = renderHook(() => useFilteredMemoStats({ userName: "users/test" }), { wrapper });++ expect(result.current.statistics.activityStats).toEqual({ "2026-05-03": 3 });+ expect(result.current.statistics.timeBasis).toBe("update_time");+ });++ it("falls back to created timestamps when updated array is empty (old server)", () => {+ // Old servers that don't know about the new field deserialize it as [].+ // Length divergence (created non-empty, updated empty) is the signal.+ vi.mocked(useUserStats).mockReturnValue({+ data: {+ memoCreatedTimestamps: [ts(2026, 5, 1)],+ memoUpdatedTimestamps: [],+ tagCount: {},+ },+ isLoading: false,+ } as ReturnType<typeof useUserStats>);+ mockUseView.mockReturnValue({+ timeBasis: "update_time",+ orderByTimeAsc: false,+ toggleSortOrder: vi.fn(),+ setTimeBasis: vi.fn(),+ });++ const warn = vi.spyOn(console, "warn").mockImplementation(() => {});+ const { result } = renderHook(() => useFilteredMemoStats({ userName: "users/test" }), { wrapper });++ expect(result.current.statistics.activityStats).toEqual({ "2026-05-01": 1 });+ expect(warn).toHaveBeenCalled();+ warn.mockRestore();+ });+});