npm - @commandgarden/cli - Versions diffs - 1.4.1 → 2.0.0 - Mend

@commandgarden/cli 1.4.1 → 2.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (81) hide show

package/node_modules/@commandgarden/app/dist/client/index.html CHANGED Viewed

@@ -10,8 +10,8 @@
   <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
   <link href="https://fonts.googleapis.com/css2?family=Space+Grotesk:wght@400;500;600;700&family=JetBrains+Mono:wght@400;500;600&display=swap" rel="stylesheet" />
   <title>commandGarden</title>
-  <script type="module" crossorigin src="/assets/index-Bb1BOK1E.js"></script>
-  <link rel="stylesheet" crossorigin href="/assets/index-B-_w54e9.css">
+  <script type="module" crossorigin src="/assets/index-WANip_um.js"></script>
+  <link rel="stylesheet" crossorigin href="/assets/index-CThI0UCl.css">
 </head>
 <body>
   <div id="root"></div>

package/node_modules/@commandgarden/app/dist/server/journal/journal.config.d.ts ADDED Viewed

@@ -0,0 +1,25 @@
+/**
+ * Journal configuration — reads from commandGarden preferences (SQLite).
+ * Users configure their settings through the GUI Config page.
+ *
+ * Preference keys:
+ *   journal.author     — email/name as it appears in git commits and ADO
+ *   journal.ado_org    — Azure DevOps organization (e.g. "daimler-mic")
+ *   journal.ado_repos  — comma-separated "project/repo" pairs
+ *   journal.target_hours — weekly target hours (default 40)
+ */
+import type { AppStore } from '../store.js';
+/** Build journal config from the user's stored preferences. */
+export declare function getJournalConfig(store: AppStore): {
+    author: string;
+    azureDevOps: {
+        org: string;
+        repos: {
+            project: string;
+            repo: string;
+        }[];
+    };
+    targetHours: number;
+};
+/** Type of the config object returned by getJournalConfig. */
+export type JournalConfig = ReturnType<typeof getJournalConfig>;

package/node_modules/@commandgarden/app/dist/server/journal/journal.config.js ADDED Viewed

@@ -0,0 +1,31 @@
+/**
+ * Journal configuration — reads from commandGarden preferences (SQLite).
+ * Users configure their settings through the GUI Config page.
+ *
+ * Preference keys:
+ *   journal.author     — email/name as it appears in git commits and ADO
+ *   journal.ado_org    — Azure DevOps organization (e.g. "daimler-mic")
+ *   journal.ado_repos  — comma-separated "project/repo" pairs
+ *   journal.target_hours — weekly target hours (default 40)
+ */
+/** Parse comma-separated "project/repo" pairs.
+ *  Example: "mic-dns/mic-dns-api,mic-dns/mic-dns-ui" */
+function parseRepos(raw) {
+    if (!raw)
+        return [];
+    return raw.split(',').map((entry) => {
+        const [project, repo] = entry.trim().split('/');
+        return { project, repo };
+    });
+}
+/** Build journal config from the user's stored preferences. */
+export function getJournalConfig(store) {
+    return {
+        author: store.getPreference('journal.author') ?? '',
+        azureDevOps: {
+            org: store.getPreference('journal.ado_org') ?? '',
+            repos: parseRepos(store.getPreference('journal.ado_repos') ?? ''),
+        },
+        targetHours: Number(store.getPreference('journal.target_hours')) || 40,
+    };
+}

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

@@ -0,0 +1,37 @@
+/**
+ * Journal orchestrator — fetches all sources in parallel, cross-references,
+ * and generates basic insights.
+ * Ported from dashboard/api/src/journal/journal.service.ts.
+ *
+ * Removed NestJS DI: takes source instances via constructor params.
+ * Removed AuditService dependency: audit logging deferred to route level / Phase 3.
+ */
+import { GitSource } from './sources/git.source.js';
+import { TimetrackingSource } from './sources/timetracking.source.js';
+import { MeetingsSource } from './sources/meetings.source.js';
+import { JiraSource } from './sources/jira.source.js';
+import type { JournalInput, JournalResponse } from './journal.types.js';
+export declare class JournalService {
+    private readonly git;
+    private readonly timetracking;
+    private readonly meetings;
+    private readonly jira;
+    constructor(git: GitSource, timetracking: TimetrackingSource, meetings: MeetingsSource, jira: JiraSource);
+    generate(input: JournalInput): Promise<JournalResponse>;
+    /**
+     * Cross-reference data across sources to identify patterns:
+     * - forgottenDays: days with activity but 0 hours logged
+     * - heavyMeetingDays: days with 4+ hours in meetings
+     * - zeroCodingDays: weekdays with 0 commits
+     * - meetingRatio: fraction of work hours spent in meetings
+     * - codingHours: estimated non-meeting hours
+     */
+    private crossReference;
+    /**
+     * Generate basic insights without LLM.
+     * Phase 4 replaces this with an LLM call for richer, more contextual insights.
+     */
+    private generateBasicInsights;
+    private addDays;
+    private weekdaysInRange;
+}

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

@@ -0,0 +1,142 @@
+/**
+ * Journal orchestrator — fetches all sources in parallel, cross-references,
+ * and generates basic insights.
+ * Ported from dashboard/api/src/journal/journal.service.ts.
+ *
+ * Removed NestJS DI: takes source instances via constructor params.
+ * Removed AuditService dependency: audit logging deferred to route level / Phase 3.
+ */
+export class JournalService {
+    git;
+    timetracking;
+    meetings;
+    jira;
+    constructor(git, timetracking, meetings, jira) {
+        this.git = git;
+        this.timetracking = timetracking;
+        this.meetings = meetings;
+        this.jira = jira;
+    }
+    async generate(input) {
+        const weekStart = input.weekStart;
+        const weekEnd = this.addDays(weekStart, 6); // Mon–Sun (full 7-day week)
+        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 tt = ttResult.status === 'fulfilled' ? ttResult.value : null;
+        if (ttResult.status === 'rejected')
+            errors.push(`TimeTracking: ${ttResult.reason}`);
+        const mtg = meetingsResult.status === 'fulfilled' ? meetingsResult.value : null;
+        if (meetingsResult.status === 'rejected')
+            errors.push(`Meetings: ${meetingsResult.reason}`);
+        const jira = jiraResult.status === 'fulfilled' ? jiraResult.value : null;
+        if (jiraResult.status === 'rejected')
+            errors.push(`Jira: ${jiraResult.reason}`);
+        const git = gitResult.status === 'fulfilled' ? gitResult.value : null;
+        if (gitResult.status === 'rejected')
+            errors.push(`Git: ${gitResult.reason}`);
+        // Cross-reference available data
+        const crossRef = this.crossReference(tt, mtg, jira, git, weekStart, weekEnd);
+        // Determine overall status
+        const hasAnyData = tt || mtg || jira || git;
+        const status = hasAnyData ? (errors.length > 0 ? 'partial' : 'success') : 'error';
+        // Rule-based insights (LLM replacement in Phase 4)
+        const insights = this.generateBasicInsights(tt, mtg, jira, git, crossRef);
+        return {
+            status,
+            week: `${weekStart} – ${weekEnd}`,
+            timetracking: tt,
+            meetings: mtg,
+            jira,
+            git,
+            crossRef,
+            insights,
+            errors,
+        };
+    }
+    /**
+     * Cross-reference data across sources to identify patterns:
+     * - forgottenDays: days with activity but 0 hours logged
+     * - heavyMeetingDays: days with 4+ hours in meetings
+     * - zeroCodingDays: weekdays with 0 commits
+     * - meetingRatio: fraction of work hours spent in meetings
+     * - codingHours: estimated non-meeting hours
+     */
+    crossReference(tt, mtg, _jira, git, weekStart, weekEnd) {
+        if (!tt && !mtg && !git)
+            return null;
+        // Days with activity but 0 hours logged in TimeTracking
+        const forgottenDays = [];
+        if (tt) {
+            for (const gap of tt.gaps) {
+                const hasMeetings = mtg?.daily.some((d) => d.date === gap && d.count > 0);
+                const hasCommits = git?.daily.some((d) => d.date === gap && d.commits > 0);
+                if (hasMeetings || hasCommits)
+                    forgottenDays.push(gap);
+            }
+        }
+        // Heavy meeting days (4+ hours)
+        const heavyMeetingDays = (mtg?.daily ?? [])
+            .filter((d) => d.hours >= 4)
+            .map((d) => ({ date: d.date, hours: d.hours }));
+        // Days with 0 commits
+        const allWeekdays = this.weekdaysInRange(weekStart, weekEnd);
+        const zeroCodingDays = git
+            ? allWeekdays.filter((date) => !git.daily.some((d) => d.date === date && d.commits > 0))
+            : [];
+        // Meeting ratio
+        const totalWorkHours = tt?.totalHours ?? 40;
+        const meetingHours = mtg?.totalHours ?? 0;
+        const meetingRatio = totalWorkHours > 0 ? Math.round((meetingHours / totalWorkHours) * 100) / 100 : 0;
+        const codingHours = Math.max(0, totalWorkHours - meetingHours);
+        return { forgottenDays, heavyMeetingDays, zeroCodingDays, meetingRatio, codingHours };
+    }
+    /**
+     * Generate basic insights without LLM.
+     * Phase 4 replaces this with an LLM call for richer, more contextual insights.
+     */
+    generateBasicInsights(tt, mtg, jira, git, crossRef) {
+        const insights = [];
+        if (crossRef?.forgottenDays.length) {
+            insights.push(`You have activity on ${crossRef.forgottenDays.join(', ')} but 0 hours logged in TimeTracking — you may have forgotten to fill it.`);
+        }
+        if (crossRef?.heavyMeetingDays.length) {
+            const days = crossRef.heavyMeetingDays.map((d) => `${d.date} (${d.hours}h)`).join(', ');
+            insights.push(`Heavy meeting days: ${days}. Consider blocking focus time.`);
+        }
+        if (tt && tt.totalHours < tt.targetHours * 0.8) {
+            const gap = tt.targetHours - tt.totalHours;
+            insights.push(`You're ${gap}h below your ${tt.targetHours}h weekly target.`);
+        }
+        if (jira?.blockers.length) {
+            const items = jira.blockers.map((b) => `${b.key} (${b.staleDays}d)`).join(', ');
+            insights.push(`Stale tickets: ${items}. Consider unblocking or reassigning.`);
+        }
+        if (crossRef && crossRef.meetingRatio > 0.5 && mtg) {
+            insights.push(`Meetings consumed ${Math.round(crossRef.meetingRatio * 100)}% of your logged hours this week.`);
+        }
+        return insights;
+    }
+    addDays(dateStr, days) {
+        const d = new Date(dateStr);
+        d.setDate(d.getDate() + days);
+        return d.toISOString().slice(0, 10);
+    }
+    weekdaysInRange(start, end) {
+        const days = [];
+        const cursor = new Date(start);
+        const endDate = new Date(end);
+        while (cursor <= endDate) {
+            if (cursor.getDay() >= 1 && cursor.getDay() <= 5) {
+                days.push(cursor.toISOString().slice(0, 10));
+            }
+            cursor.setDate(cursor.getDate() + 1);
+        }
+        return days;
+    }
+}

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

@@ -0,0 +1,91 @@
+/** Shared types for the Dev Work Journal module.
+ *  Ported from dashboard/api/src/journal/journal.types.ts — identical interfaces,
+ *  no NestJS dependencies. */
+export interface JournalInput {
+    weekStart: string;
+}
+export interface TtDailyEntry {
+    date: string;
+    hours: number;
+    projects: {
+        projectId: string;
+        hours: number;
+    }[];
+}
+export interface TimetrackingData {
+    totalHours: number;
+    targetHours: number;
+    daily: TtDailyEntry[];
+    gaps: string[];
+}
+export interface MeetingEntry {
+    date: string;
+    subject: string;
+    start: string;
+    end: string;
+    durationMin: number;
+}
+export interface MeetingsDaily {
+    date: string;
+    count: number;
+    hours: number;
+}
+export interface MeetingsData {
+    totalCount: number;
+    totalHours: number;
+    avgDurationMin: number;
+    daily: MeetingsDaily[];
+    entries: MeetingEntry[];
+}
+export interface JiraTicket {
+    key: string;
+    summary: string;
+}
+export interface JiraData {
+    resolved: (JiraTicket & {
+        resolvedDate: string;
+    })[];
+    inProgress: JiraTicket[];
+    blockers: (JiraTicket & {
+        staleDays: number;
+    })[];
+}
+export interface GitDaily {
+    date: string;
+    commits: number;
+    filesChanged: number;
+}
+export interface GitRepoActivity {
+    project: string;
+    repo: string;
+    commits: number;
+}
+export interface GitData {
+    totalCommits: number;
+    totalPRsMerged: number;
+    totalPRsReviewed: number;
+    daily: GitDaily[];
+    repos: GitRepoActivity[];
+}
+export interface CrossRefData {
+    forgottenDays: string[];
+    heavyMeetingDays: {
+        date: string;
+        hours: number;
+    }[];
+    zeroCodingDays: string[];
+    meetingRatio: number;
+    codingHours: number;
+}
+export type JournalStatus = 'success' | 'partial' | 'error';
+export interface JournalResponse {
+    status: JournalStatus;
+    week: string;
+    timetracking: TimetrackingData | null;
+    meetings: MeetingsData | null;
+    jira: JiraData | null;
+    git: GitData | null;
+    crossRef: CrossRefData | null;
+    insights: string[];
+    errors: string[];
+}

package/node_modules/@commandgarden/app/dist/server/journal/journal.types.js ADDED Viewed

@@ -0,0 +1,4 @@
+/** Shared types for the Dev Work Journal module.
+ *  Ported from dashboard/api/src/journal/journal.types.ts — identical interfaces,
+ *  no NestJS dependencies. */
+export {};

package/node_modules/@commandgarden/app/dist/server/journal/sources/git.source.d.ts ADDED Viewed

@@ -0,0 +1,21 @@
+/**
+ * Git data source — fetches commits and PRs via the ado/git-commits
+ * commandGarden connector through the daemon API.
+ *
+ * Phase 3 rewrite: replaced direct REST API calls + PAT auth with a single
+ * daemon.post('/api/run') call per repo. The connector uses the browser's
+ * MSAL session token — no PAT required.
+ */
+import type { DaemonClient } from '@commandgarden/shared';
+import type { JournalConfig } from '../journal.config.js';
+import type { GitData } from '../journal.types.js';
+export declare class GitSource {
+    private readonly daemon;
+    private readonly org;
+    private readonly repos;
+    private readonly author;
+    constructor(daemon: DaemonClient, config: JournalConfig);
+    fetch(weekStart: string, weekEnd: string): Promise<GitData>;
+    /** Fetch a single repo's commits+PRs via the daemon connector. */
+    private fetchRepo;
+}

package/node_modules/@commandgarden/app/dist/server/journal/sources/git.source.js ADDED Viewed

@@ -0,0 +1,72 @@
+/**
+ * Git data source — fetches commits and PRs via the ado/git-commits
+ * commandGarden connector through the daemon API.
+ *
+ * Phase 3 rewrite: replaced direct REST API calls + PAT auth with a single
+ * daemon.post('/api/run') call per repo. The connector uses the browser's
+ * MSAL session token — no PAT required.
+ */
+export class GitSource {
+    daemon;
+    org;
+    repos;
+    author;
+    constructor(daemon, config) {
+        this.daemon = daemon;
+        this.org = config.azureDevOps.org;
+        this.repos = config.azureDevOps.repos;
+        this.author = config.author;
+    }
+    async fetch(weekStart, weekEnd) {
+        try {
+            // Call the ado/git-commits connector once per configured repo via daemon
+            const results = await Promise.all(this.repos.map((r) => this.fetchRepo(r.project, r.repo, weekStart, weekEnd)));
+            // Aggregate daily commits across all repos
+            const dailyMap = new Map();
+            const repoActivity = [];
+            let totalPRsMerged = 0;
+            for (let i = 0; i < this.repos.length; i++) {
+                const { project, repo } = this.repos[i];
+                const rows = results[i];
+                const commitRows = rows.filter((r) => r.isPR !== 'true');
+                const prRows = rows.filter((r) => r.isPR === 'true');
+                repoActivity.push({ project, repo, commits: commitRows.length });
+                totalPRsMerged += prRows.length;
+                for (const r of commitRows) {
+                    const date = r.date;
+                    const entry = dailyMap.get(date) ?? { date, commits: 0, filesChanged: 0 };
+                    entry.commits += 1;
+                    entry.filesChanged += (r.filesAdded ?? 0) + (r.filesEdited ?? 0) + (r.filesDeleted ?? 0);
+                    dailyMap.set(date, entry);
+                }
+            }
+            const daily = [...dailyMap.values()].sort((a, b) => a.date.localeCompare(b.date));
+            const totalCommits = daily.reduce((sum, d) => sum + d.commits, 0);
+            return {
+                totalCommits,
+                totalPRsMerged,
+                totalPRsReviewed: 0,
+                daily,
+                repos: repoActivity.filter((r) => r.commits > 0),
+            };
+        }
+        catch (e) {
+            console.error('[git] fetch error:', e);
+            // Graceful degradation: return empty data instead of failing
+            return { totalCommits: 0, totalPRsMerged: 0, totalPRsReviewed: 0, daily: [], repos: [] };
+        }
+    }
+    /** Fetch a single repo's commits+PRs via the daemon connector. */
+    async fetchRepo(project, repo, fromDate, toDate) {
+        try {
+            const result = await this.daemon.post('/api/run', {
+                connector: 'ado/git-commits',
+                args: { org: this.org, project, repo, fromDate, toDate, author: this.author },
+            });
+            return result.ok && result.data ? result.data : [];
+        }
+        catch {
+            return [];
+        }
+    }
+}

package/node_modules/@commandgarden/app/dist/server/journal/sources/jira.source.d.ts ADDED Viewed

@@ -0,0 +1,15 @@
+/**
+ * Jira Cloud data source — fetches tickets via the jira/my-tickets
+ * commandGarden connector through the daemon API.
+ *
+ * Uses Jira Cloud REST API (mercedes-benz.atlassian.net) with the browser's
+ * Atlassian session — no API token required. Connector returns rows with a
+ * `category` field (resolved/inProgress/blocker) and Jira issue keys (e.g. PROJ-123).
+ */
+import type { DaemonClient } from '@commandgarden/shared';
+import type { JiraData } from '../journal.types.js';
+export declare class JiraSource {
+    private readonly daemon;
+    constructor(daemon: DaemonClient);
+    fetch(weekStart: string, weekEnd: string): Promise<JiraData | null>;
+}

package/node_modules/@commandgarden/app/dist/server/journal/sources/jira.source.js ADDED Viewed

@@ -0,0 +1,42 @@
+/**
+ * Jira Cloud data source — fetches tickets via the jira/my-tickets
+ * commandGarden connector through the daemon API.
+ *
+ * Uses Jira Cloud REST API (mercedes-benz.atlassian.net) with the browser's
+ * Atlassian session — no API token required. Connector returns rows with a
+ * `category` field (resolved/inProgress/blocker) and Jira issue keys (e.g. PROJ-123).
+ */
+export class JiraSource {
+    daemon;
+    constructor(daemon) {
+        this.daemon = daemon;
+    }
+    async fetch(weekStart, weekEnd) {
+        try {
+            // assignee left empty → connector uses Jira's currentUser() function
+            const result = await this.daemon.post('/api/run', {
+                connector: 'jira/my-tickets',
+                args: { fromDate: weekStart, toDate: weekEnd },
+            });
+            if (!result.ok || !result.data || result.data.length === 0)
+                return null;
+            // Map connector rows by category to the JiraData sub-arrays.
+            // Connector returns Jira issue keys directly (e.g. "PROJ-123").
+            const rows = result.data;
+            return {
+                resolved: rows
+                    .filter((r) => r.category === 'resolved')
+                    .map((r) => ({ key: r.key, summary: r.summary, resolvedDate: r.resolvedDate })),
+                inProgress: rows
+                    .filter((r) => r.category === 'inProgress')
+                    .map((r) => ({ key: r.key, summary: r.summary })),
+                blockers: rows
+                    .filter((r) => r.category === 'blocker')
+                    .map((r) => ({ key: r.key, summary: r.summary, staleDays: r.staleDays })),
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+}

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

@@ -0,0 +1,21 @@
+/**
+ * Meetings data source — DISABLED for v1.
+ *
+ * The Outlook connector is blocked by the corporate MCAS proxy
+ * (outlook.cloud.microsoft.mcas.ms) which prevents all standard auth patterns:
+ * - OWA REST API: X-OWA-CANARY cookie is HttpOnly (JS can't read it)
+ * - Graph API: no Graph-scoped MSAL token available in MCAS session storage
+ * - Response interception: eval script installs after OWA's initial data fetch
+ *
+ * Returns null immediately — the journal renders without meeting data
+ * (graceful degradation). Git + Jira provide a strong 2-source story.
+ *
+ * TODO: Revisit post-demo with MCAS-specific auth investigation.
+ */
+import type { DaemonClient } from '@commandgarden/shared';
+import type { MeetingsData } from '../journal.types.js';
+export declare class MeetingsSource {
+    private readonly _daemon;
+    constructor(_daemon: DaemonClient);
+    fetch(_weekStart: string, _weekEnd: string): Promise<MeetingsData | null>;
+}

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

@@ -0,0 +1,25 @@
+/**
+ * Meetings data source — DISABLED for v1.
+ *
+ * The Outlook connector is blocked by the corporate MCAS proxy
+ * (outlook.cloud.microsoft.mcas.ms) which prevents all standard auth patterns:
+ * - OWA REST API: X-OWA-CANARY cookie is HttpOnly (JS can't read it)
+ * - Graph API: no Graph-scoped MSAL token available in MCAS session storage
+ * - Response interception: eval script installs after OWA's initial data fetch
+ *
+ * Returns null immediately — the journal renders without meeting data
+ * (graceful degradation). Git + Jira provide a strong 2-source story.
+ *
+ * TODO: Revisit post-demo with MCAS-specific auth investigation.
+ */
+export class MeetingsSource {
+    _daemon;
+    constructor(_daemon) {
+        this._daemon = _daemon;
+    }
+    async fetch(_weekStart, _weekEnd) {
+        // Disabled for v1 — MCAS proxy blocks all standard auth patterns.
+        // Returns null so the journal renders without meeting data.
+        return null;
+    }
+}

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

@@ -0,0 +1,17 @@
+/**
+ * TimeTracking data source — fetches hours via commandGarden daemon.
+ * Ported from dashboard/api/src/journal/sources/timetracking.source.ts.
+ *
+ * Replaces OpencliService (CLI spawn) with DaemonClient (HTTP to daemon).
+ * The daemon runs the timetracking/report connector via browser automation.
+ * 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 { JournalConfig } from '../journal.config.js';
+export declare class TimetrackingSource {
+    private readonly daemon;
+    private readonly config;
+    constructor(daemon: DaemonClient, config: JournalConfig);
+    fetch(weekStart: string, weekEnd: string): Promise<TimetrackingData | null>;
+}

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

@@ -0,0 +1,83 @@
+/**
+ * TimeTracking data source — fetches hours via commandGarden daemon.
+ * Ported from dashboard/api/src/journal/sources/timetracking.source.ts.
+ *
+ * Replaces OpencliService (CLI spawn) with DaemonClient (HTTP to daemon).
+ * The daemon runs the timetracking/report connector via browser automation.
+ * Returns null gracefully when the connector isn't available (Phase 2 dependency).
+ */
+export class TimetrackingSource {
+    daemon;
+    config;
+    constructor(daemon, config) {
+        this.daemon = daemon;
+        this.config = config;
+    }
+    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
+            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);
+                }
+            }
+            // Filter to rows within the week range
+            const weekRows = allRows.filter((r) => {
+                if (!r.date)
+                    return false;
+                return r.date >= weekStart && r.date <= weekEnd;
+            });
+            // Group by date
+            const dailyMap = new Map();
+            for (const row of weekRows) {
+                const date = row.date;
+                const entry = dailyMap.get(date) ?? { date, hours: 0, projects: [] };
+                const hrs = typeof row.hours === 'number' ? row.hours : 0;
+                entry.hours += hrs;
+                if (row.projectId) {
+                    const proj = entry.projects.find((p) => p.projectId === row.projectId);
+                    if (proj)
+                        proj.hours += hrs;
+                    else
+                        entry.projects.push({ projectId: row.projectId, hours: hrs });
+                }
+                dailyMap.set(date, entry);
+            }
+            const daily = [...dailyMap.values()].sort((a, b) => a.date.localeCompare(b.date));
+            const totalHours = Math.round(daily.reduce((sum, d) => sum + d.hours, 0) * 100) / 100;
+            // Find gaps: weekdays in range with 0 hours
+            const gaps = [];
+            const cursor = new Date(weekStart);
+            const end = new Date(weekEnd);
+            while (cursor <= end) {
+                const day = cursor.getDay();
+                if (day >= 1 && day <= 5) {
+                    const iso = cursor.toISOString().slice(0, 10);
+                    const entry = dailyMap.get(iso);
+                    if (!entry || entry.hours === 0)
+                        gaps.push(iso);
+                }
+                cursor.setDate(cursor.getDate() + 1);
+            }
+            return {
+                totalHours,
+                targetHours: this.config.targetHours,
+                daily,
+                gaps,
+            };
+        }
+        catch {
+            // Graceful degradation: connector not available yet (Phase 2 dependency)
+            return null;
+        }
+    }
+}

package/node_modules/@commandgarden/app/dist/server/routes/index.js CHANGED Viewed

@@ -6,6 +6,7 @@ import { configRoutes } from './config.js';
 import { preferencesRoutes } from './preferences.js';
 import { goalsRoutes } from './goals.js';
 import { timetrackingCacheRoutes } from './timetracking-cache.js';
+import { journalRoutes } from './journal.js';
 export function registerRoutes(app, daemon, store) {
     statusRoutes(app, daemon);
     connectorRoutes(app, daemon);
@@ -15,4 +16,5 @@ export function registerRoutes(app, daemon, store) {
     preferencesRoutes(app, store);
     goalsRoutes(app, store);
     timetrackingCacheRoutes(app, store);
+    journalRoutes(app, daemon, store);
 }