@commandgarden/cli 2.10.0 → 2.11.0

package/node_modules/@commandgarden/app/dist/server/daemon-client.test.js

@@ -0,0 +1,47 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { DaemonClient } from './daemon-client.js';
+describe('DaemonClient', () => {
+    let client;
+    const mockFetch = vi.fn();
+    beforeEach(() => {
+        vi.stubGlobal('fetch', mockFetch);
+        client = new DaemonClient('http://127.0.0.1:19825', 'test-token');
+        mockFetch.mockReset();
+    });
+    it('sends auth headers on GET', async () => {
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({ ok: true, data: 'test' }),
+        });
+        await client.get('/api/status');
+        expect(mockFetch).toHaveBeenCalledWith('http://127.0.0.1:19825/api/status', expect.objectContaining({
+            method: 'GET',
+            headers: expect.objectContaining({
+                Authorization: 'Bearer test-token',
+                'X-CommandGarden': '1',
+            }),
+        }));
+    });
+    it('sends body on POST', async () => {
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({ ok: true }),
+        });
+        await client.post('/api/run', { connector: 'test/cmd', args: {} });
+        const call = mockFetch.mock.calls[0];
+        expect(call[1].method).toBe('POST');
+        expect(JSON.parse(call[1].body)).toEqual({ connector: 'test/cmd', args: {} });
+    });
+    it('throws on non-ok response', async () => {
+        mockFetch.mockResolvedValueOnce({
+            ok: false,
+            status: 401,
+            json: () => Promise.resolve({ error: 'Unauthorized' }),
+        });
+        await expect(client.get('/api/status')).rejects.toThrow('Unauthorized');
+    });
+    it('throws on network error', async () => {
+        mockFetch.mockRejectedValueOnce(new Error('fetch failed'));
+        await expect(client.get('/api/status')).rejects.toThrow('Cannot connect to daemon');
+    });
+});

package/node_modules/@commandgarden/app/dist/server/journal/journal.service.d.ts

@@ -18,6 +18,7 @@ export declare class JournalService {
     private readonly jira;
     constructor(git: GitSource, timetracking: TimetrackingSource, meetings: MeetingsSource, jira: JiraSource);
     generate(input: JournalInput): Promise<JournalResponse>;
+    private currentMonth;
     /**
      * Cross-reference data across sources to identify patterns:
      * - forgottenDays: days with activity but 0 hours logged

package/node_modules/@commandgarden/app/dist/server/journal/journal.service.js

@@ -20,13 +20,24 @@ export class JournalService {
     async generate(input) {
         const weekStart = input.weekStart;
         const weekEnd = this.addDays(weekStart, 6); // Mon–Sun (full 7-day week)
+        const sources = {
+            timetracking: input.sources?.timetracking ?? true,
+            meetings: input.sources?.meetings ?? true,
+            jira: input.sources?.jira ?? true,
+            git: input.sources?.git ?? true,
+        };
         const errors = [];
-        // Fetch all sources in parallel; each source handles its own errors gracefully
-        const [ttResult, meetingsResult, jiraResult, gitResult] = await Promise.allSettled([
-            this.timetracking.fetch(weekStart, weekEnd),
-            this.meetings.fetch(weekStart, weekEnd),
-            this.jira.fetch(weekStart, weekEnd),
-            this.git.fetch(weekStart, weekEnd),
+        const currentMonth = this.currentMonth();
+        // Fetch only the enabled sources in parallel; each source handles its own errors gracefully.
+        // Disabled sources resolve to null immediately without calling the connector.
+        // The monthly timetracking status reuses TimetrackingSource's per-request cache, so if
+        // the selected week falls in the current month, it never drives the browser connector twice.
+        const [ttResult, meetingsResult, jiraResult, gitResult, monthlyTtResult] = await Promise.allSettled([
+            sources.timetracking ? this.timetracking.fetch(weekStart, weekEnd) : Promise.resolve(null),
+            sources.meetings ? this.meetings.fetch(weekStart, weekEnd) : Promise.resolve(null),
+            sources.jira ? this.jira.fetch(weekStart, weekEnd) : Promise.resolve(null),
+            sources.git ? this.git.fetch(weekStart, weekEnd) : Promise.resolve(null),
+            sources.timetracking ? this.timetracking.fetchMonthlyStatus(currentMonth) : Promise.resolve(null),
         ]);
         const tt = ttResult.status === 'fulfilled' ? ttResult.value : null;
         if (ttResult.status === 'rejected')
@@ -40,6 +51,9 @@ export class JournalService {
         const git = gitResult.status === 'fulfilled' ? gitResult.value : null;
         if (gitResult.status === 'rejected')
             errors.push(`Git: ${gitResult.reason}`);
+        const monthlyTimetracking = monthlyTtResult.status === 'fulfilled' ? monthlyTtResult.value : null;
+        if (monthlyTtResult.status === 'rejected')
+            errors.push(`Monthly TimeTracking: ${monthlyTtResult.reason}`);
         // Cross-reference available data
         const crossRef = this.crossReference(tt, mtg, jira, git, weekStart, weekEnd);
         // Determine overall status
@@ -57,8 +71,13 @@ export class JournalService {
             crossRef,
             insights,
             errors,
+            monthlyTimetracking,
         };
     }
+    currentMonth() {
+        const d = new Date();
+        return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}`;
+    }
     /**
      * Cross-reference data across sources to identify patterns:
      * - forgottenDays: days with activity but 0 hours logged

package/node_modules/@commandgarden/app/dist/server/journal/journal.types.d.ts

@@ -1,8 +1,15 @@
 /** Shared types for the Dev Work Journal module.
  *  Ported from dashboard/api/src/journal/journal.types.ts — identical interfaces,
  *  no NestJS dependencies. */
+export interface JournalSources {
+    timetracking: boolean;
+    meetings: boolean;
+    jira: boolean;
+    git: boolean;
+}
 export interface JournalInput {
     weekStart: string;
+    sources?: Partial<JournalSources>;
 }
 export interface TtDailyEntry {
     date: string;
@@ -18,6 +25,17 @@ export interface TimetrackingData {
     daily: TtDailyEntry[];
     gaps: string[];
 }
+export interface MonthlyTimetrackingData {
+    month: string;
+    workingDaysTotal: number;
+    workingDaysElapsed: number;
+    releasedDates: string[];
+    unreleasedDates: string[];
+    hoursByProject: {
+        projectId: string;
+        hours: number;
+    }[];
+}
 export interface MeetingEntry {
     date: string;
     subject: string;
@@ -78,6 +96,12 @@ export interface CrossRefData {
     codingHours: number;
 }
 export type JournalStatus = 'success' | 'partial' | 'error';
+/** Cache provenance — added at the route level (not by JournalService),
+ *  so the UI can show whether a result came from app.db and when it was fetched. */
+export interface JournalCacheInfo {
+    hit: boolean;
+    fetchedAt: string;
+}
 export interface JournalResponse {
     status: JournalStatus;
     week: string;
@@ -88,4 +112,6 @@ export interface JournalResponse {
     crossRef: CrossRefData | null;
     insights: string[];
     errors: string[];
+    monthlyTimetracking: MonthlyTimetrackingData | null;
+    cache?: JournalCacheInfo;
 }

package/node_modules/@commandgarden/app/dist/server/journal/sources/meetings.source.d.ts

@@ -6,8 +6,12 @@
  * to bypass the MCAS proxy (see docs/ado-git-commits-fix.md for the
  * Runtime.evaluate CSP bypass that also applies here).
  *
- * Calls the connector once per weekday in the date range, then
- * aggregates into MeetingsData (totalCount, totalHours, daily, entries).
+ * The Scheduling Assistant grid renders the whole work week around
+ * whichever date it's pointed at, so a single connector call (using any
+ * weekday in the target range as an anchor) already returns every day's
+ * meetings for that week — no need to call once per weekday. Rows outside
+ * [weekStart, weekEnd] (if the connector's week grid doesn't align exactly
+ * with our range) are filtered out before aggregating into MeetingsData.
  */
 import type { DaemonClient } from '@commandgarden/shared';
 import type { MeetingsData } from '../journal.types.js';
@@ -15,6 +19,8 @@ export declare class MeetingsSource {
     private readonly daemon;
     constructor(daemon: DaemonClient);
     fetch(weekStart: string, weekEnd: string): Promise<MeetingsData | null>;
-    /** Fetch a single day's meetings via the daemon connector. */
-    private fetchDay;
+    /** Fetch the whole work week's meetings via the daemon connector, anchored on one date. */
+    private fetchWeek;
+    /** First weekday (Mon–Fri) in [start, end], or null if the range has none. */
+    private firstWeekday;
 }

package/node_modules/@commandgarden/app/dist/server/journal/sources/meetings.source.js

@@ -6,8 +6,12 @@
  * to bypass the MCAS proxy (see docs/ado-git-commits-fix.md for the
  * Runtime.evaluate CSP bypass that also applies here).
  *
- * Calls the connector once per weekday in the date range, then
- * aggregates into MeetingsData (totalCount, totalHours, daily, entries).
+ * The Scheduling Assistant grid renders the whole work week around
+ * whichever date it's pointed at, so a single connector call (using any
+ * weekday in the target range as an anchor) already returns every day's
+ * meetings for that week — no need to call once per weekday. Rows outside
+ * [weekStart, weekEnd] (if the connector's week grid doesn't align exactly
+ * with our range) are filtered out before aggregating into MeetingsData.
  */
 export class MeetingsSource {
     daemon;
@@ -16,30 +20,21 @@ export class MeetingsSource {
     }
     async fetch(weekStart, weekEnd) {
         try {
-            // Fetch meetings for each weekday in the range.
-            // The connector opens the Scheduling Assistant per call, so we
-            // batch weekdays sequentially to avoid multiple browser tabs.
-            const allEntries = [];
-            const cursor = new Date(weekStart);
-            const end = new Date(weekEnd);
-            while (cursor <= end) {
-                const day = cursor.getDay();
-                // Only fetch weekdays (Mon–Fri) to avoid unnecessary calls
-                if (day >= 1 && day <= 5) {
-                    const dateStr = cursor.toISOString().slice(0, 10);
-                    const rows = await this.fetchDay(dateStr);
-                    for (const r of rows) {
-                        allEntries.push({
-                            date: r.date,
-                            subject: r.subject,
-                            start: r.start,
-                            end: r.end,
-                            durationMin: r.durationMin,
-                        });
-                    }
-                }
-                cursor.setDate(cursor.getDate() + 1);
-            }
+            // Anchor on the first weekday in range — the connector's single call
+            // returns the whole work week's meetings for whichever date it's given.
+            const anchorDate = this.firstWeekday(weekStart, weekEnd);
+            if (!anchorDate)
+                return null;
+            const rows = await this.fetchWeek(anchorDate);
+            const allEntries = rows
+                .filter((r) => r.date >= weekStart && r.date <= weekEnd)
+                .map((r) => ({
+                date: r.date,
+                subject: r.subject,
+                start: r.start,
+                end: r.end,
+                durationMin: r.durationMin,
+            }));
             if (allEntries.length === 0)
                 return null;
             // Aggregate daily stats
@@ -62,12 +57,12 @@ export class MeetingsSource {
             return null;
         }
     }
-    /** Fetch a single day's meetings via the daemon connector. */
-    async fetchDay(date) {
+    /** Fetch the whole work week's meetings via the daemon connector, anchored on one date. */
+    async fetchWeek(anchorDate) {
         try {
             const result = await this.daemon.post('/api/run', {
                 connector: 'outlook/my-meetings',
-                args: { date },
+                args: { date: anchorDate },
             });
             return result.ok && result.data ? result.data : [];
         }
@@ -75,4 +70,16 @@ export class MeetingsSource {
             return [];
         }
     }
+    /** First weekday (Mon–Fri) in [start, end], or null if the range has none. */
+    firstWeekday(start, end) {
+        const cursor = new Date(start);
+        const endDate = new Date(end);
+        while (cursor <= endDate) {
+            const day = cursor.getDay();
+            if (day >= 1 && day <= 5)
+                return cursor.toISOString().slice(0, 10);
+            cursor.setDate(cursor.getDate() + 1);
+        }
+        return null;
+    }
 }

package/node_modules/@commandgarden/app/dist/server/journal/sources/timetracking.source.d.ts

@@ -7,11 +7,20 @@
  * Returns null gracefully when the connector isn't available (Phase 2 dependency).
  */
 import type { DaemonClient } from '@commandgarden/shared';
-import type { TimetrackingData } from '../journal.types.js';
+import type { TimetrackingData, MonthlyTimetrackingData } from '../journal.types.js';
 import type { JournalConfig } from '../journal.config.js';
 export declare class TimetrackingSource {
     private readonly daemon;
     private readonly config;
+    private readonly rawCache;
     constructor(daemon: DaemonClient, config: JournalConfig);
+    private fetchMonthRaw;
     fetch(weekStart: string, weekEnd: string): Promise<TimetrackingData | null>;
+    /**
+     * Compute month-to-date release status (working days released/unreleased)
+     * and per-project logged hours. Reuses the cached raw month fetch so this
+     * never triggers a second browser-driven connector run for a month that
+     * was already fetched by `fetch()` in the same request.
+     */
+    fetchMonthlyStatus(month: string): Promise<MonthlyTimetrackingData>;
 }

package/node_modules/@commandgarden/app/dist/server/journal/sources/timetracking.source.js

@@ -9,26 +9,33 @@
 export class TimetrackingSource {
     daemon;
     config;
+    // Per-instance cache so a single journal-generate request only ever drives
+    // the browser-based timetracking connector once per calendar month, even
+    // if both the weekly report and the monthly status need the same month.
+    rawCache = new Map();
     constructor(daemon, config) {
         this.daemon = daemon;
         this.config = config;
     }
+    fetchMonthRaw(month) {
+        if (!this.rawCache.has(month)) {
+            this.rawCache.set(month, this.daemon
+                .post('/api/run', { connector: 'timetracking/report', args: { month } })
+                .then((result) => (result.ok && result.data ? result.data : []))
+                .catch(() => []));
+        }
+        return this.rawCache.get(month);
+    }
     async fetch(weekStart, weekEnd) {
         try {
             // Determine which month(s) the week spans
             const startMonth = weekStart.slice(0, 7);
             const endMonth = weekEnd.slice(0, 7);
             const months = startMonth === endMonth ? [startMonth] : [startMonth, endMonth];
-            // Fetch each month's report via daemon
+            // Fetch each month's report via daemon (cached per month within this request)
             const allRows = [];
             for (const month of months) {
-                const result = await this.daemon.post('/api/run', {
-                    connector: 'timetracking/report',
-                    args: { month },
-                });
-                if (result.ok && result.data) {
-                    allRows.push(...result.data);
-                }
+                allRows.push(...(await this.fetchMonthRaw(month)));
             }
             // Filter to rows within the week range
             const weekRows = allRows.filter((r) => {
@@ -80,4 +87,51 @@ export class TimetrackingSource {
             return null;
         }
     }
+    /**
+     * Compute month-to-date release status (working days released/unreleased)
+     * and per-project logged hours. Reuses the cached raw month fetch so this
+     * never triggers a second browser-driven connector run for a month that
+     * was already fetched by `fetch()` in the same request.
+     */
+    async fetchMonthlyStatus(month) {
+        const raw = await this.fetchMonthRaw(month);
+        const [y, m] = month.split('-').map(Number);
+        const today = new Date();
+        const todayIso = `${today.getFullYear()}-${String(today.getMonth() + 1).padStart(2, '0')}-${String(today.getDate()).padStart(2, '0')}`;
+        const daysInMonth = new Date(y, m, 0).getDate();
+        let workingDaysTotal = 0;
+        const workingDatesElapsed = [];
+        for (let d = 1; d <= daysInMonth; d++) {
+            const date = new Date(y, m - 1, d);
+            const day = date.getDay();
+            if (day === 0 || day === 6)
+                continue;
+            workingDaysTotal += 1;
+            const iso = `${y}-${String(m).padStart(2, '0')}-${String(d).padStart(2, '0')}`;
+            if (iso <= todayIso)
+                workingDatesElapsed.push(iso);
+        }
+        const releasedDateSet = new Set(raw.filter((r) => r.date && r.status && /released/i.test(String(r.status))).map((r) => r.date));
+        const releasedDates = workingDatesElapsed.filter((d) => releasedDateSet.has(d));
+        const unreleasedDates = workingDatesElapsed.filter((d) => !releasedDateSet.has(d));
+        const hoursMap = new Map();
+        for (const row of raw) {
+            if (!row.projectId)
+                continue;
+            const hrs = typeof row.hours === 'number' ? row.hours : 0;
+            hoursMap.set(row.projectId, (hoursMap.get(row.projectId) ?? 0) + hrs);
+        }
+        const hoursByProject = [...hoursMap.entries()].map(([projectId, hours]) => ({
+            projectId,
+            hours: Math.round(hours * 100) / 100,
+        }));
+        return {
+            month,
+            workingDaysTotal,
+            workingDaysElapsed: workingDatesElapsed.length,
+            releasedDates,
+            unreleasedDates,
+            hoursByProject,
+        };
+    }
 }

package/node_modules/@commandgarden/app/dist/server/routes/journal.d.ts

@@ -2,6 +2,18 @@
  * Journal Fastify route — POST /api/journal/generate.
  * Reads journal config from user preferences (SQLite), instantiates
  * sources with that config, and generates the weekly report.
+ *
+ * Results are cached in app.db (journal_cache table), keyed by weekStart
+ * only — the latest generated result for a week is cached regardless of
+ * which sources were selected. A cache hit skips every browser-driven
+ * connector call entirely; the response carries `cache: { hit, fetchedAt }`
+ * so the UI can always show the user whether they're looking at a cached
+ * result and from when. Pass `forceRefresh: true` to bypass the cache and
+ * drive a fresh fetch (e.g. via a "Refresh" action in the UI).
+ *
+ * The user's last-selected source toggles (Timetracking/Meetings/Jira/Git/
+ * Saba) are stored separately in journal_source_prefs, so the UI can
+ * restore the user's picks on next load.
  */
 import type { FastifyInstance } from 'fastify';
 import type { DaemonClient } from '@commandgarden/shared';

package/node_modules/@commandgarden/app/dist/server/routes/journal.js

@@ -2,6 +2,18 @@
  * Journal Fastify route — POST /api/journal/generate.
  * Reads journal config from user preferences (SQLite), instantiates
  * sources with that config, and generates the weekly report.
+ *
+ * Results are cached in app.db (journal_cache table), keyed by weekStart
+ * only — the latest generated result for a week is cached regardless of
+ * which sources were selected. A cache hit skips every browser-driven
+ * connector call entirely; the response carries `cache: { hit, fetchedAt }`
+ * so the UI can always show the user whether they're looking at a cached
+ * result and from when. Pass `forceRefresh: true` to bypass the cache and
+ * drive a fresh fetch (e.g. via a "Refresh" action in the UI).
+ *
+ * The user's last-selected source toggles (Timetracking/Meetings/Jira/Git/
+ * Saba) are stored separately in journal_source_prefs, so the UI can
+ * restore the user's picks on next load.
  */
 import { getJournalConfig } from '../journal/journal.config.js';
 import { GitSource } from '../journal/sources/git.source.js';
@@ -10,6 +22,60 @@ import { TimetrackingSource } from '../journal/sources/timetracking.source.js';
 import { MeetingsSource } from '../journal/sources/meetings.source.js';
 import { JournalService } from '../journal/journal.service.js';
 export function journalRoutes(app, daemon, store) {
+    // Read-only cache lookup — no connector calls, no config validation. Used by the
+    // UI to silently restore a previously generated result (e.g. after navigating
+    // away and back, which remounts the page and loses its local React state).
+    app.get('/api/journal/cache', async (req, reply) => {
+        const query = req.query;
+        if (!query.weekStart || !/^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/.test(query.weekStart)) {
+            return reply.code(400).send({
+                ok: false,
+                error: 'weekStart is required and must be YYYY-MM-DD format',
+            });
+        }
+        const cached = store.getCachedJournal(query.weekStart);
+        if (!cached)
+            return { ok: true, data: null, saba: null };
+        return {
+            ok: true,
+            data: { ...cached.data, cache: { hit: true, fetchedAt: cached.fetchedAt } },
+            saba: cached.sabaData,
+        };
+    });
+    // Persists the Saba "pending training" result for a week — saved separately
+    // from the main journal generate() flow since it's fetched client-side and
+    // can complete at a different time.
+    app.post('/api/journal/cache/saba', async (req, reply) => {
+        const body = req.body;
+        if (!body?.weekStart || !/^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/.test(body.weekStart)) {
+            return reply.code(400).send({
+                ok: false,
+                error: 'weekStart is required and must be YYYY-MM-DD format',
+            });
+        }
+        store.cacheJournalSaba(body.weekStart, body.saba ?? null);
+        return { ok: true };
+    });
+    // Last-selected source toggles — persisted so the UI can restore the
+    // user's picks on next load instead of always resetting to "all enabled".
+    app.get('/api/journal/source-prefs', async () => {
+        const prefs = store.getJournalSourcePrefs();
+        return { ok: true, prefs };
+    });
+    app.post('/api/journal/source-prefs', async (req, reply) => {
+        const body = req.body;
+        if (!body) {
+            return reply.code(400).send({ ok: false, error: 'Request body is required' });
+        }
+        store.saveJournalSourcePrefs({
+            timetracking: body.timetracking ?? true,
+            meetings: body.meetings ?? true,
+            jira: body.jira ?? true,
+            git: body.git ?? true,
+            saba: body.saba ?? true,
+        });
+        return { ok: true };
+    });
     app.post('/api/journal/generate', async (req, reply) => {
         const body = req.body;
         // Validate weekStart is present and matches YYYY-MM-DD format
@@ -19,10 +85,25 @@ export function journalRoutes(app, daemon, store) {
                 error: 'weekStart is required and must be YYYY-MM-DD format',
             });
         }
+        const sources = {
+            timetracking: body.sources?.timetracking ?? true,
+            meetings: body.sources?.meetings ?? true,
+            jira: body.sources?.jira ?? true,
+            git: body.sources?.git ?? true,
+        };
+        if (!body.forceRefresh) {
+            const cached = store.getCachedJournal(body.weekStart);
+            if (cached) {
+                return {
+                    ...cached.data,
+                    cache: { hit: true, fetchedAt: cached.fetchedAt },
+                };
+            }
+        }
         // Build config from user preferences (configured via GUI Config page)
         const config = getJournalConfig(store);
-        // Check that required settings are configured
-        if (!config.azureDevOps.org || config.azureDevOps.repos.length === 0) {
+        // Check that required settings are configured, only if git (ADO) is enabled
+        if (sources.git && (!config.azureDevOps.org || config.azureDevOps.repos.length === 0)) {
             return reply.code(400).send({
                 ok: false,
                 error: 'Journal not configured. Go to Configuration → Journal Settings and set your ADO org and repos.',
@@ -36,16 +117,17 @@ export function journalRoutes(app, daemon, store) {
             const timetracking = new TimetrackingSource(daemon, config);
             const meetings = new MeetingsSource(daemon);
             const service = new JournalService(git, timetracking, meetings, jira);
-            const result = await service.generate({ weekStart: body.weekStart });
+            const result = await service.generate({ weekStart: body.weekStart, sources });
+            const fetchedAt = store.cacheJournal(body.weekStart, result);
             // Audit log (non-blocking — failure should not break the response)
             const durationMs = Date.now() - start;
             daemon.post('/api/audit/log', {
                 command: 'journal generate',
-                args: { weekStart: body.weekStart },
+                args: { weekStart: body.weekStart, sources },
                 status: result.status,
                 durationMs,
             }).catch(() => { });
-            return result;
+            return { ...result, cache: { hit: false, fetchedAt } };
         }
         catch (err) {
             const message = err instanceof Error ? err.message : 'Unknown error';