@bakers-build/addon-track 0.0.0-stage → 0.1.0-next.42

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 keytec GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,5 @@
-# Temporary Holding Version
+# @bakers-build/addon-track
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Read personal daily evidence for time preparation.
+
+Part of the bakers.build CLI. Install the meta package `@bakers-build/bakers` to get the `bakers` CLI with all addons. Source: https://git.key-tec.de/bakers-build/bakers-build (bakers-cli/).

package/dist/src/dates.d.ts

@@ -0,0 +1,7 @@
+export declare function civilDate(value: string): number;
+export declare function shiftDate(date: string, days: number): string;
+export declare function selectedDates(from: string, to: string): string[];
+export declare function calendar(timezone: string): {
+    dateAt: (time: number) => string;
+    boundary: (date: string) => number;
+};

package/dist/src/dates.js

@@ -0,0 +1,55 @@
+const DAY = 86_400_000;
+export function civilDate(value) {
+    const time = Date.parse(`${value}T00:00:00Z`);
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(value) ||
+        !Number.isFinite(time) ||
+        new Date(time).toISOString().slice(0, 10) !== value) {
+        throw new Error(`Invalid civil date: ${value}`);
+    }
+    return time;
+}
+export function shiftDate(date, days) {
+    return new Date(civilDate(date) + days * DAY).toISOString().slice(0, 10);
+}
+export function selectedDates(from, to) {
+    const count = (civilDate(to) - civilDate(from)) / DAY + 1;
+    if (count < 1 || count > 366)
+        throw new Error('Select between 1 and 366 civil dates.');
+    return Array.from({ length: count }, (_, i) => shiftDate(from, i));
+}
+export function calendar(timezone) {
+    const formatter = new Intl.DateTimeFormat('en-CA', {
+        timeZone: timezone,
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+    });
+    const dateAt = (time) => {
+        const parts = formatter.formatToParts(time);
+        return ['year', 'month', 'day']
+            .map((type) => parts.find((part) => part.type === type)?.value)
+            .join('-');
+    };
+    const cache = new Map();
+    const boundary = (date) => {
+        const cached = cache.get(date);
+        if (cached !== undefined)
+            return cached;
+        // Find the first local instant, including zones whose clocks skip midnight.
+        const utc = civilDate(date);
+        let low = utc - 2 * DAY;
+        let high = utc + 2 * DAY;
+        while (high - low > 1) {
+            const middle = Math.floor((low + high) / 2);
+            if (dateAt(middle) < date)
+                low = middle;
+            else
+                high = middle;
+        }
+        if (dateAt(high) !== date)
+            throw new Error(`Civil date ${date} does not exist in ${timezone}.`);
+        cache.set(date, high);
+        return high;
+    };
+    return { dateAt, boundary };
+}

package/dist/src/evidence.d.ts

@@ -0,0 +1,104 @@
+import type { createBbConnectionClient } from '@bakers-build/core';
+type Client = Awaited<ReturnType<typeof createBbConnectionClient>>;
+type Selection = {
+    from: string;
+    to: string;
+    timezone?: string;
+};
+export declare function loadEvidence(client: Client, selection: Selection, worklogClient: Pick<Client, 'get'>): Promise<{
+    owner_id: string;
+    timezone: string;
+    from: string;
+    to: string;
+    complete: boolean;
+    evidence_gaps: string[];
+    unplaced_run_ids: string[];
+    days: {
+        recorded_seconds: number | null;
+        proposed_seconds: number | null;
+        baseline: {
+            date: string;
+            run_count: number | null;
+            known_duration_seconds: number;
+            first_start: string | null;
+            last_end: string | null;
+            span_complete: boolean;
+        }[];
+        baseline_median: number | null;
+        baseline_samples: number;
+        schedule_seconds: number | null;
+        cap_seconds: number | null;
+        activities: {
+            id: string;
+            date: string | null;
+            created: string | null;
+            kind: unknown;
+            actor_id: string | null;
+            run_id: string | null;
+            ticket_id: string | null;
+            previous_state: {} | null;
+            new_state: {} | null;
+            step: {} | null;
+            comment_id: string | null;
+            summary: string | null;
+            summary_truncated: boolean;
+        }[];
+        worklog_ids: string[];
+        date: string;
+        start: string;
+        end: string;
+        run_count: number | null;
+        observed_run_count: number;
+        span_complete: boolean;
+        states: Record<string, number>;
+        first_start: string | null;
+        last_end: string | null;
+        known_duration_seconds: number;
+        clusters: {
+            start: string;
+            end: string;
+        }[];
+        gaps: {
+            start: string;
+            end: string;
+            seconds: number;
+        }[];
+        runs: {
+            start: string;
+            end: string | null;
+            full_duration_seconds: number | null;
+            id: string;
+            state: {} | null;
+            step: {} | null;
+            ticket_id: string | null;
+            conductor_id: string | null;
+        }[];
+    }[];
+    weeks: {
+        recorded_seconds: number | null;
+        proposed_seconds: number | null;
+        from: string;
+        to: string;
+        schedule_seconds: number | null;
+    }[];
+    worklogs: {
+        id: string;
+        date: unknown;
+        state: unknown;
+        duration_seconds: number | null;
+        description: unknown;
+        ticket_id: string | null;
+        project_id: string | null;
+        submission_id: string | null;
+        source_keys: {} | null;
+    }[];
+    tickets: Record<string, {
+        identifier: unknown;
+        title: unknown;
+        project_id: string | null;
+    }>;
+    projects: Record<string, {
+        name: unknown;
+    }>;
+}>;
+export {};

package/dist/src/evidence.js

@@ -0,0 +1,418 @@
+import { DrupalJsonApiParams } from 'drupal-jsonapi-params';
+import { calendar, civilDate, selectedDates, shiftDate } from './dates.js';
+const attr = (row, key) => row.attributes?.[key];
+const relation = (row, key) => {
+    const value = row.relationships?.[key]?.data;
+    return value && !Array.isArray(value) && typeof value.id === 'string'
+        ? value.id
+        : null;
+};
+const stamp = (value) => typeof value === 'string' && Number.isFinite(Date.parse(value))
+    ? Date.parse(value)
+    : null;
+const iso = (time) => new Date(time).toISOString();
+function rows(value) {
+    return (Array.isArray(value) &&
+        value.every((row) => row &&
+            typeof row === 'object' &&
+            typeof row.id === 'string' &&
+            typeof row.type === 'string'));
+}
+async function collect(client, type, params, path = `${type}/${type}`) {
+    const data = new Map();
+    const included = new Map();
+    let complete = true;
+    let offset = 0;
+    while (true) {
+        params.addPageLimit(50).addPageOffset(offset);
+        const raw = await client.get(path, params);
+        if (!raw || typeof raw !== 'object' || !('data' in raw) || !rows(raw.data))
+            throw new Error(`Invalid ${type} collection response.`);
+        const page = raw;
+        if (page.included !== undefined && !rows(page.included))
+            throw new Error(`Invalid ${type} included resources.`);
+        if (page.meta?.omitted)
+            complete = false;
+        for (const row of page.data) {
+            if (row.type !== `${type}--${type}`)
+                throw new Error(`Unexpected resource in ${type}.`);
+            data.set(row.id, row);
+        }
+        for (const row of page.included ?? [])
+            included.set(`${row.type}/${row.id}`, row);
+        if (!page.links?.next)
+            break;
+        const href = typeof page.links.next === 'string'
+            ? page.links.next
+            : page.links.next.href;
+        if (!href)
+            throw new Error(`Invalid ${type} pagination link.`);
+        // Consume only the next offset; keep our authenticated endpoint and filters.
+        const next = new URL(href, 'https://pagination.invalid').searchParams.get('page[offset]');
+        if (next === null ||
+            !/^\d+$/.test(next) ||
+            !Number.isSafeInteger(Number(next)) ||
+            Number(next) <= offset)
+            throw new Error(`Non-advancing ${type} pagination.`);
+        offset = Number(next);
+    }
+    return {
+        data: [...data.values()],
+        included: [...included.values()],
+        complete,
+    };
+}
+function context(params) {
+    return params
+        .addInclude(['ticket_id.project_id'])
+        .addFields('bb_ticket--bb_ticket', ['identifier', 'title', 'project_id'])
+        .addFields('bb_project--bb_project', ['name']);
+}
+export async function loadEvidence(client, selection, worklogClient) {
+    const dates = selectedDates(selection.from, selection.to);
+    if (selection.timezone)
+        calendar(selection.timezone);
+    const owner = await client.me();
+    const user = await client.resource('user', owner);
+    const timezone = selection.timezone ?? user.attr('timezone');
+    if (!timezone)
+        throw new Error('Employee timezone is unavailable; supply --timezone.');
+    const { boundary, dateAt } = calendar(timezone);
+    const start = boundary(selection.from);
+    const end = boundary(shiftDate(selection.to, 1));
+    const historyStart = boundary(shiftDate(selection.from, -28));
+    const weekday = (date) => (new Date(civilDate(date)).getUTCDay() + 6) % 7;
+    const weekStart = shiftDate(selection.from, -weekday(selection.from));
+    const weekEnd = shiftDate(selection.to, 6 - weekday(selection.to));
+    const rawSchedule = user.attr('work_schedule');
+    const schedule = (Array.isArray(rawSchedule) ? rawSchedule[0] : rawSchedule);
+    const seconds = (value) => typeof value === 'number' && Number.isSafeInteger(value) && value >= 0
+        ? value
+        : null;
+    const evidenceGaps = [];
+    const runParams = context(new DrupalJsonApiParams())
+        .addFilter('owner_user_id.id', owner)
+        .addGroup('start', 'OR')
+        .addFilter('started_at', String(end / 1000), '<', 'start')
+        .addGroup('not_started', 'AND', 'start')
+        .addFilter('started_at', null, 'IS NULL', 'not_started')
+        .addFilter('created', String(end / 1000), '<', 'not_started')
+        .addGroup('end', 'OR')
+        .addFilter('closed_date', String(historyStart / 1000), '>=', 'end')
+        .addFilter('closed_date', null, 'IS NULL', 'end')
+        .addFields('bb_run--bb_run', [
+        'owner_user_id',
+        'started_at',
+        'closed_date',
+        'state',
+        'state_at_start',
+        'ticket_id',
+        'conductor_id',
+    ])
+        .addSort('drupal_internal__id');
+    const activityParams = context(new DrupalJsonApiParams())
+        .addFilter('created', String(start / 1000), '>=')
+        .addFilter('created', String(end / 1000), '<')
+        .addGroup('personal', 'OR')
+        .addFilter('actor.id', owner, '=', 'personal')
+        .addFilter('run_id.owner_user_id.id', owner, '=', 'personal')
+        .addInclude(['ticket_id.project_id', 'comment_id', 'run_id'])
+        .addFields('bb_run--bb_run', ['owner_user_id'])
+        .addFields('bb_activity--bb_activity', [
+        'created',
+        'kind',
+        'actor',
+        'run_id',
+        'ticket_id',
+        'comment_id',
+        'previous_state',
+        'new_state',
+        'step',
+    ])
+        .addFields('bb_comment--bb_comment', ['body'])
+        .addSort('drupal_internal__id');
+    const worklogParams = new DrupalJsonApiParams().addCustomParam({
+        from: weekStart,
+        to: weekEnd,
+    });
+    const [runPage, activityPage, worklogPage] = await Promise.all([
+        collect(client, 'bb_run', runParams),
+        collect(client, 'bb_activity', activityParams),
+        collect(worklogClient, 'bb_track_worklog', worklogParams, 'worklogs'),
+    ]);
+    for (const [name, page] of [
+        ['runs', runPage],
+        ['activities', activityPage],
+        ['worklogs', worklogPage],
+    ]) {
+        if (!page.complete)
+            evidenceGaps.push(`Some ${name} or included resources were omitted by the server.`);
+    }
+    const tickets = {};
+    const projects = {};
+    const summaries = new Map();
+    for (const row of [
+        ...runPage.included,
+        ...activityPage.included,
+        ...worklogPage.included,
+    ]) {
+        if (row.type === 'bb_ticket--bb_ticket')
+            tickets[row.id] = {
+                identifier: attr(row, 'identifier') ?? null,
+                title: attr(row, 'title') ?? null,
+                project_id: relation(row, 'project_id'),
+            };
+        if (row.type === 'bb_project--bb_project')
+            projects[row.id] = { name: attr(row, 'name') ?? null };
+        if (row.type === 'bb_comment--bb_comment') {
+            const body = attr(row, 'body');
+            if (typeof body?.value === 'string')
+                summaries.set(row.id, body.value);
+        }
+    }
+    const unplaced = [];
+    for (const [id, ticket] of Object.entries(tickets))
+        if (ticket.project_id && !projects[ticket.project_id])
+            evidenceGaps.push(`Ticket ${id} has unavailable project context.`);
+    const runs = runPage.data
+        .filter((row) => relation(row, 'owner_user_id') === owner)
+        .map((row) => {
+        const start = stamp(attr(row, 'started_at'));
+        const rawEnd = attr(row, 'closed_date');
+        let end = stamp(rawEnd);
+        if (start === null)
+            unplaced.push(row.id);
+        if ((rawEnd !== null && rawEnd !== undefined && end === null) ||
+            (start !== null && end !== null && end < start)) {
+            evidenceGaps.push(`Run ${row.id} has an invalid end.`);
+            end = null;
+        }
+        if (end === null)
+            evidenceGaps.push(`Run ${row.id} has an unknown end; later-day overlap cannot be confirmed.`);
+        const ticketId = relation(row, 'ticket_id');
+        if (!ticketId || !tickets[ticketId])
+            evidenceGaps.push(`Run ${row.id} has unavailable ticket context.`);
+        return {
+            id: row.id,
+            start,
+            end,
+            state: attr(row, 'state') ?? null,
+            step: attr(row, 'state_at_start') ?? null,
+            ticket_id: ticketId,
+            conductor_id: relation(row, 'conductor_id'),
+        };
+    });
+    if (unplaced.length)
+        evidenceGaps.push(`Runs with unknown start: ${unplaced.join(', ')}.`);
+    for (const row of runPage.data)
+        if (!relation(row, 'owner_user_id'))
+            evidenceGaps.push(`Run ${row.id} has unknown ownership.`);
+    const runsComplete = runPage.complete &&
+        unplaced.length === 0 &&
+        runPage.data.every((row) => relation(row, 'owner_user_id'));
+    const knownRuns = new Set([
+        ...runs.map((run) => run.id),
+        ...activityPage.included
+            .filter((row) => row.type === 'bb_run--bb_run' &&
+            relation(row, 'owner_user_id') === owner)
+            .map((row) => row.id),
+    ]);
+    for (const row of activityPage.data) {
+        if (relation(row, 'actor') !== owner &&
+            !knownRuns.has(relation(row, 'run_id') ?? ''))
+            evidenceGaps.push(`Activity ${row.id} could not be attributed to this employee.`);
+    }
+    const activities = activityPage.data
+        .filter((row) => relation(row, 'actor') === owner ||
+        knownRuns.has(relation(row, 'run_id') ?? ''))
+        .map((row) => {
+        const time = stamp(attr(row, 'created'));
+        const commentId = relation(row, 'comment_id');
+        const summary = commentId ? summaries.get(commentId) : undefined;
+        if (time === null)
+            evidenceGaps.push(`Activity ${row.id} has an unknown timestamp.`);
+        if (commentId && summary === undefined)
+            evidenceGaps.push(`Activity ${row.id} has an unavailable summary.`);
+        return {
+            id: row.id,
+            date: time === null ? null : dateAt(time),
+            created: time === null ? null : iso(time),
+            kind: attr(row, 'kind'),
+            actor_id: relation(row, 'actor'),
+            run_id: relation(row, 'run_id'),
+            ticket_id: relation(row, 'ticket_id'),
+            previous_state: attr(row, 'previous_state') ?? null,
+            new_state: attr(row, 'new_state') ?? null,
+            step: attr(row, 'step') ?? null,
+            comment_id: commentId,
+            summary: summary?.slice(0, 2000) ?? null,
+            summary_truncated: (summary?.length ?? 0) > 2000,
+        };
+    });
+    const worklogs = worklogPage.data
+        .filter((row) => relation(row, 'owner_user_id') === owner)
+        .map((row) => ({
+        id: row.id,
+        date: attr(row, 'work_date'),
+        state: attr(row, 'state'),
+        duration_seconds: seconds(attr(row, 'duration_seconds')),
+        description: attr(row, 'description'),
+        ticket_id: relation(row, 'ticket_id'),
+        project_id: relation(row, 'project_id'),
+        submission_id: relation(row, 'submission_id'),
+        source_keys: attr(row, 'source_keys') ?? null,
+    }));
+    const worklogsValid = worklogPage.data.every((row) => relation(row, 'owner_user_id')) &&
+        worklogs.every((row) => typeof row.date === 'string' &&
+            Number.isFinite(civilDate(row.date)) &&
+            row.duration_seconds !== null &&
+            ['recorded', 'approved', 'proposed'].includes(String(row.state)));
+    if (!worklogsValid)
+        evidenceGaps.push('Some worklogs have invalid dates, states or durations.');
+    for (const row of [...activities, ...worklogs]) {
+        if (row.ticket_id && !tickets[row.ticket_id])
+            evidenceGaps.push(`Resource ${row.id} has unavailable ticket context.`);
+    }
+    for (const row of worklogs)
+        if (row.project_id && !projects[row.project_id])
+            evidenceGaps.push(`Worklog ${row.id} has unavailable project context.`);
+    const totals = (items) => ({
+        recorded_seconds: worklogPage.complete && worklogsValid
+            ? items
+                .filter((w) => w.state === 'recorded' || w.state === 'approved')
+                .reduce((sum, w) => sum + (w.duration_seconds ?? 0), 0)
+            : null,
+        proposed_seconds: worklogPage.complete && worklogsValid
+            ? items
+                .filter((w) => w.state === 'proposed')
+                .reduce((sum, w) => sum + (w.duration_seconds ?? 0), 0)
+            : null,
+    });
+    function daily(date) {
+        const low = boundary(date), high = boundary(shiftDate(date, 1));
+        const selected = runs.filter((run) => run.start !== null &&
+            run.start < high &&
+            (run.end === null ||
+                run.end > low ||
+                (run.end === run.start && run.start >= low)));
+        const uncertainOverlap = selected.some((run) => run.end === null && run.start < low);
+        const intervals = selected
+            .filter((r) => r.end !== null)
+            .map((r) => ({
+            start: Math.max(r.start, low),
+            end: Math.min(r.end, high),
+        }))
+            .sort((a, b) => a.start - b.start);
+        const merged = [];
+        for (const interval of intervals) {
+            const last = merged.at(-1);
+            if (last && interval.start <= last.end)
+                last.end = Math.max(last.end, interval.end);
+            else
+                merged.push({ ...interval });
+        }
+        const spanComplete = runsComplete && selected.every((run) => run.end !== null);
+        const clusters = merged.map((r) => ({
+            start: iso(r.start),
+            end: iso(r.end),
+        }));
+        const gaps = [];
+        if (spanComplete) {
+            for (let i = 1; i < merged.length; i++) {
+                const previous = merged[i - 1], current = merged[i];
+                if (previous && current)
+                    gaps.push({
+                        start: iso(previous.end),
+                        end: iso(current.start),
+                        seconds: (current.start - previous.end) / 1000,
+                    });
+            }
+        }
+        const last = merged.at(-1);
+        const states = {};
+        for (const run of selected)
+            states[String(run.state)] = (states[String(run.state)] ?? 0) + 1;
+        return {
+            date,
+            start: iso(low),
+            end: iso(high),
+            run_count: runsComplete && !uncertainOverlap ? selected.length : null,
+            observed_run_count: selected.filter((r) => r.end !== null || r.start >= low).length,
+            span_complete: spanComplete,
+            states,
+            first_start: selected.length
+                ? iso(Math.max(low, Math.min(...selected.map((r) => r.start))))
+                : null,
+            last_end: last ? iso(last.end) : null,
+            known_duration_seconds: merged.reduce((sum, r) => sum + (r.end - r.start) / 1000, 0),
+            clusters,
+            gaps,
+            runs: selected.map((r) => ({
+                ...r,
+                start: iso(r.start),
+                end: r.end === null ? null : iso(r.end),
+                full_duration_seconds: r.end === null ? null : (r.end - r.start) / 1000,
+            })),
+        };
+    }
+    const days = dates.map((date) => {
+        const day = daily(date);
+        const baseline = [7, 14, 21, 28].map((delta) => {
+            const previous = daily(shiftDate(date, -delta));
+            return {
+                date: previous.date,
+                run_count: previous.run_count,
+                known_duration_seconds: previous.known_duration_seconds,
+                first_start: previous.first_start,
+                last_end: previous.last_end,
+                span_complete: previous.span_complete,
+            };
+        });
+        const counts = baseline
+            .map((b) => b.run_count)
+            .filter((n) => n !== null)
+            .sort((a, b) => a - b);
+        const middle = counts.slice(Math.floor((counts.length - 1) / 2), Math.floor(counts.length / 2) + 1);
+        const median = middle.length
+            ? middle.reduce((sum, value) => sum + value, 0) / middle.length
+            : null;
+        return {
+            ...day,
+            baseline,
+            baseline_median: median,
+            baseline_samples: counts.length,
+            schedule_seconds: seconds(schedule?.[`day_${weekday(date)}`]),
+            cap_seconds: seconds(schedule?.cap),
+            activities: activities.filter((a) => a.date === date),
+            worklog_ids: worklogs.filter((w) => w.date === date).map((w) => w.id),
+            ...totals(worklogs.filter((w) => w.date === date)),
+        };
+    });
+    const weeks = [];
+    for (let date = weekStart; date <= weekEnd; date = shiftDate(date, 7)) {
+        const last = shiftDate(date, 6);
+        const values = Array.from({ length: 7 }, (_, i) => seconds(schedule?.[`day_${i}`]));
+        weeks.push({
+            from: date,
+            to: last,
+            schedule_seconds: values.every((v) => v !== null)
+                ? values.reduce((sum, v) => sum + (v ?? 0), 0)
+                : null,
+            ...totals(worklogs.filter((w) => typeof w.date === 'string' && w.date >= date && w.date <= last)),
+        });
+    }
+    return {
+        owner_id: owner,
+        timezone,
+        from: selection.from,
+        to: selection.to,
+        complete: evidenceGaps.length === 0,
+        evidence_gaps: [...new Set(evidenceGaps)],
+        unplaced_run_ids: unplaced,
+        days,
+        weeks,
+        worklogs,
+        tickets,
+        projects,
+    };
+}

package/dist/src/index.d.ts

@@ -0,0 +1,12 @@
+import { type BbCommandPlugin } from '@bakers-build/core';
+import type { Command } from 'commander';
+type Options = {
+    from: string;
+    to: string;
+    timezone?: string;
+    config?: string;
+    connection?: string;
+};
+export declare function registerTrack(program: Command, read: (options: Options) => Promise<unknown>): void;
+declare const trackCommand: BbCommandPlugin;
+export default trackCommand;

package/dist/src/index.js

@@ -0,0 +1,38 @@
+import { createBbConnectionClient, loadReadyBbConnection, } from '@bakers-build/core';
+import { loadEvidence } from './evidence.js';
+export function registerTrack(program, read) {
+    program
+        .command('track')
+        .description('Personal time evidence')
+        .command('evidence')
+        .description('Read daily runs, activities and existing time as JSON')
+        .requiredOption('--from <date>', 'first civil date (YYYY-MM-DD)')
+        .requiredOption('--to <date>', 'last civil date (YYYY-MM-DD), inclusive')
+        .option('--timezone <zone>', 'IANA timezone; defaults to the employee profile')
+        .option('--config <path>', 'connection config path')
+        .option('--connection <id>', 'named connection')
+        .action(async (options) => {
+        const report = await read(options);
+        process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+    });
+}
+const trackCommand = {
+    kind: 'command',
+    name: 'track',
+    describe: 'read personal daily evidence for time preparation',
+    register(program, host) {
+        registerTrack(program, async (options) => {
+            const connection = await loadReadyBbConnection(host, {
+                ...(options.config ? { explicit: options.config } : {}),
+                ...(options.connection ? { connection: options.connection } : {}),
+            });
+            const client = await createBbConnectionClient(connection);
+            const worklogs = await createBbConnectionClient({
+                ...connection,
+                site: { ...connection.site, jsonapi_prefix: '/api/time' },
+            });
+            return loadEvidence(client, options, worklogs);
+        });
+    },
+};
+export default trackCommand;

package/dist/src/preset.d.ts

@@ -0,0 +1,2 @@
+import type { BbPreset } from '@bakers-build/core';
+export declare const commands: BbPreset['commands'];

package/dist/src/preset.js

@@ -0,0 +1,8 @@
+export const commands = (acc) => [
+    ...acc,
+    {
+        name: 'track',
+        plugin: '@bakers-build/addon-track',
+        describe: 'read personal daily evidence for time preparation',
+    },
+];

package/package.json

@@ -1,6 +1,29 @@
 {
   "name": "@bakers-build/addon-track",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-next.42",
+  "description": "Read personal daily evidence for time preparation.",
+  "type": "module",
+  "license": "MIT",
+  "exports": {
+    ".": "./dist/src/index.js",
+    "./preset": "./dist/src/preset.js"
+  },
+  "files": [
+    "dist/src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://git.key-tec.de/bakers-build/bakers-build.git",
+    "directory": "bakers-cli/addons/track"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "drupal-jsonapi-params": "^3.0.1"
+  },
+  "peerDependencies": {
+    "@bakers-build/core": "^0.1.0-next.42"
+  }
+}