@robotostudio/senku 0.1.0 → 0.2.0

package/README.md

@@ -104,6 +104,58 @@ interface RunOutput {
 
 `analyze()` is the one-shot path. To compose the pipeline yourself, the pieces are exported too: `cloneRepo`, `scrapeRepo`, `getRepoName`, `getAuthors`, `checkRepoHealth`, `assertGitAvailable`, `discoverRepos`, `runPipeline`, `aggregateByTicket`, `estimateTicketHours`, `createLinearClient`, `fetchTickets`, `extractFromPR` — plus all the types.
 
+## dailyDigest() — daily per-user GitHub API ingest
+
+For automated, cron-scheduled work attribution (Trigger.dev, Vercel Cron, scheduled lambdas), use `dailyDigest()` instead of `analyze()`. It reads the GitHub API directly — no local clone required — and is designed for serverless environments.
+
+```ts
+import { dailyDigest } from "@robotostudio/senku";
+
+const result = await dailyDigest({
+  users: [
+    {
+      login: "alice",
+      githubToken: process.env.GITHUB_TOKEN_ALICE,
+      linearApiKey: process.env.LINEAR_API_KEY_WORKSPACE_A,
+      repos: [{ slug: "org-a/repo-1" }, { slug: "org-a/repo-2" }],
+    },
+    {
+      login: "bob",
+      githubToken: process.env.GITHUB_TOKEN_BOB,
+      linearApiKey: process.env.LINEAR_API_KEY_WORKSPACE_B,
+      repos: [{ slug: "org-b/repo-1" }],
+    },
+  ],
+  openaiApiKey: process.env.OPENAI_API_KEY,
+  since: "2026-05-21T00:00:00Z",
+  until: "2026-05-28T23:59:59Z",
+  org: "daily-digest-example",
+});
+
+// result.users[0].output has the same shape as analyze() RunOutput
+for (const user of result.users) {
+  console.log(`${user.login}: ${user.output.totalHours}h`);
+}
+```
+
+**Key differences from `analyze()`:**
+
+| Aspect | `analyze()` | `dailyDigest()` |
+|--------|-----------|-----------------|
+| Data source | Local git clone (`git log --all`) | GitHub API (REST + GraphQL) |
+| Token model | One `githubToken` → all repos | Per-user `githubToken` (org-scoped) |
+| Attribution window | Commit window (from/to dates on commits) | Activity window — when work landed on GitHub (PR updated / commit pushed), not originally written |
+| Use case | Historical analysis, deep dives | Daily crons, per-user aggregation, serverless tasks |
+| Rate limit | None (local) | 5,000 API calls/hour per GitHub token |
+
+**When to use which:**
+
+- **Use `analyze()`** — One-off historical windows, all repos in one org, you control the GitHub token, want exact commit history.
+- **Use `dailyDigest()`** — Daily crons, different GitHub orgs need different tokens, running in serverless (Trigger.dev), working with open PRs that haven't been merged yet.
+- **Use both** — Combine in a morning digest: yesterday's `dailyDigest()` for quick per-user rollup, weekly `analyze()` for ticket-by-ticket detail.
+
+See [`docs/digest-context.md`](./docs/digest-context.md) for domain terminology (attribution, work unit, user definitions).
+
 ## CLI
 
 From a checkout:

package/dist/digest/github-fetch.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Fail-safe GitHub API fetch layer for the digest pipeline.
+ *
+ * Properties:
+ *   - **Preflight rate-limit check** refuses to start a user's run if the budget
+ *     is exhausted (default threshold: 100 calls remaining).
+ *   - **FetchResult<T> discriminated union**: every response maps to a typed
+ *     failure reason so callers can branch without null-checking.
+ *   - **5xx + network errors**: up to 3 retries with exponential backoff
+ *     (500ms / 1s / 2s).
+ *   - **Timeout**: 15s per request via `AbortSignal.timeout`.
+ *   - **GraphQL error detection**: 200 responses with a non-empty `errors[]`
+ *     array return `{ ok: false, reason: "graphql-error" }`.
+ *   - **Telemetry**: every HTTP request increments `ctx.httpRequests`; each
+ *     logical API call increments `ctx.apiCalls`. Retries appear in
+ *     `httpRequests` but not in `apiCalls`. Errors push to `ctx.errors`.
+ */
+import type pino from "pino";
+import { type GraphQLPullRequest, type RestCommit } from "./transform.js";
+import type { DigestPRData } from "./types.js";
+export type FetchFailReason = "unauthorized" | "forbidden" | "not-found" | "rate-limited" | "timeout" | "graphql-error" | "network" | "unknown";
+export type FetchResult<T> = {
+    ok: true;
+    data: T;
+} | {
+    ok: false;
+    reason: FetchFailReason;
+    status?: number;
+    message: string;
+};
+export interface CallContext {
+    /**
+     * Logical API calls — each distinct endpoint operation counts as one, even
+     * if it required multiple retries. Mirrors the pre-refactor `apiCalls`.
+     */
+    apiCalls: number;
+    /**
+     * Raw HTTP requests sent, including retry attempts. Always >= `apiCalls`.
+     * Useful for surfacing retry overhead in telemetry.
+     */
+    httpRequests: number;
+    errors: string[];
+}
+export declare const makeCallContext: () => CallContext;
+/**
+ * Single typed fetch with retry + timeout. Returns a {@link FetchResult} —
+ * never throws. Maps status codes to {@link FetchFailReason}.
+ *
+ * `ctx.apiCalls` is incremented once by the **caller** (logical level).
+ * `ctx.httpRequests` is incremented here on every actual HTTP attempt,
+ * including retries.
+ */
+export declare function safeFetch<T>(url: string, token: string, ctx: CallContext, init?: RequestInit, attempt?: number): Promise<FetchResult<T>>;
+/** Confirm token is valid and has enough rate-limit budget to run. */
+export declare function preflight(token: string, ctx: CallContext): Promise<number | null>;
+/**
+ * GraphQL search for PRs that were touched in the window by `login`. Returns
+ * full PR nodes including inner commits + stats. Paginates until
+ * `hasNextPage = false` or the {@link MAX_SEARCH_PAGES} hard cap is hit.
+ *
+ * The search query string is built outside the GraphQL document and injected
+ * as a `$searchQuery: String!` variable — eliminating the GraphQL injection
+ * vector while keeping the search term interpolation to the search API only.
+ */
+export declare function fetchPRsInWindow(token: string, login: string, repo: string, since: string, until: string, ctx: CallContext): Promise<GraphQLPullRequest[]>;
+/**
+ * REST list of commits authored by `login` on the default branch in window.
+ * Paginates via `page=N` until a partial page is returned or the
+ * {@link MAX_DIRECT_COMMIT_PAGES} cap is hit (1000-commit ceiling).
+ * Used for direct-to-main commits with no PR — caller filters out merge
+ * commits + squash-merge commits using PR mergeCommit SHAs.
+ */
+export declare function fetchDirectCommits(token: string, login: string, repo: string, since: string, until: string, ctx: CallContext): Promise<RestCommit[]>;
+/**
+ * Fetch per-commit addition/deletion/file-count from the REST single-commit
+ * endpoint. Returns `null` on any failure — callers treat null as "no stats".
+ *
+ * Counted as a logical `apiCalls` unit (each call is an independent cost unit).
+ */
+export declare function fetchCommitStats(token: string, repo: string, sha: string, ctx: CallContext): Promise<{
+    additions: number;
+    deletions: number;
+    filesChanged: number;
+} | null>;
+export interface FetchUserRepoOptions {
+    /**
+     * When true, issues one REST `GET /repos/:repo/commits/:sha` per direct
+     * commit to populate `additions`, `deletions`, and `filesChanged`.
+     * Default: false (cost reason — each commit is an extra API call).
+     */
+    populateDirectCommitStats?: boolean;
+}
+/**
+ * High-level fetch for one (user, repo). Returns digest-shaped
+ * {@link DigestPRData[]} after merging both API arms and applying the
+ * closed-unmerged filter + direct-commit dedup vs PR merge commits.
+ */
+export declare function fetchUserRepo(user: {
+    login: string;
+    githubToken: string;
+}, repo: string, since: string, until: string, ctx: CallContext, logger: pino.Logger, options?: FetchUserRepoOptions): Promise<DigestPRData[]>;

package/dist/digest/github-fetch.js

@@ -0,0 +1,305 @@
+import { batchConcurrent } from "../utils.js";
+import { collectMergeShas, directCommitToDigestPRData, isDirectCommit, prNodeToDigestPRData, } from "./transform.js";
+const GH_REST = "https://api.github.com";
+const GH_GRAPHQL = "https://api.github.com/graphql";
+const PREFLIGHT_MIN_BUDGET = 100;
+const MAX_RETRIES = 3;
+const TIMEOUT_MS = 15_000;
+/** GitHub search hard cap — prevents runaway pagination loops. */
+const MAX_SEARCH_PAGES = 20;
+const PAGE_SIZE = 50;
+export const makeCallContext = () => ({
+    apiCalls: 0,
+    httpRequests: 0,
+    errors: [],
+});
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const buildHeaders = (token, extra = {}) => ({
+    Authorization: `Bearer ${token}`,
+    Accept: "application/vnd.github+json",
+    "X-GitHub-Api-Version": "2022-11-28",
+    "User-Agent": "senku-daily-digest",
+    ...extra,
+});
+const STATUS_REASON = {
+    401: "unauthorized",
+    403: "forbidden",
+    404: "not-found",
+    429: "rate-limited",
+};
+function statusToReason(status) {
+    return STATUS_REASON[status] ?? "unknown";
+}
+// ---------------------------------------------------------------------------
+// Core fetch primitive
+// ---------------------------------------------------------------------------
+/** Extract a readable message from a GraphQL error array, if present. */
+function graphqlErrorMessage(body) {
+    if (!(body.errors && Array.isArray(body.errors)) || body.errors.length === 0) {
+        return null;
+    }
+    const first = body.errors[0];
+    return typeof first.message === "string" ? first.message : "GraphQL error";
+}
+/** Attempt one HTTP request. Returns a FetchResult or null when a retry is warranted. */
+async function attemptFetch(url, token, ctx, init, attempt) {
+    ctx.httpRequests++;
+    try {
+        const res = await fetch(url, {
+            ...init,
+            headers: buildHeaders(token, init.headers),
+            signal: AbortSignal.timeout(TIMEOUT_MS),
+        });
+        if (res.ok) {
+            const body = (await res.json());
+            const gqlErr = graphqlErrorMessage(body);
+            if (gqlErr) {
+                return { ok: false, reason: "graphql-error", status: 200, message: gqlErr };
+            }
+            return { ok: true, data: body };
+        }
+        if (res.status < 500) {
+            return {
+                ok: false,
+                reason: statusToReason(res.status),
+                status: res.status,
+                message: `${res.status} ${res.statusText} — ${url}`,
+            };
+        }
+        // 5xx — signal retry
+        return null;
+    }
+    catch (err) {
+        if (err instanceof DOMException && err.name === "TimeoutError") {
+            return { ok: false, reason: "timeout", message: `Timeout after ${TIMEOUT_MS}ms: ${url}` };
+        }
+        if (attempt + 1 >= MAX_RETRIES) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return { ok: false, reason: "network", message: `Network error: ${msg} — ${url}` };
+        }
+        // Network error — signal retry
+        return null;
+    }
+}
+/**
+ * Single typed fetch with retry + timeout. Returns a {@link FetchResult} —
+ * never throws. Maps status codes to {@link FetchFailReason}.
+ *
+ * `ctx.apiCalls` is incremented once by the **caller** (logical level).
+ * `ctx.httpRequests` is incremented here on every actual HTTP attempt,
+ * including retries.
+ */
+export async function safeFetch(url, token, ctx, init = {}, attempt = 0) {
+    if (attempt >= MAX_RETRIES) {
+        return {
+            ok: false,
+            reason: "unknown",
+            message: `Max retries (${MAX_RETRIES}) exceeded: ${url}`,
+        };
+    }
+    const result = await attemptFetch(url, token, ctx, init, attempt);
+    if (result !== null) {
+        return result;
+    }
+    await sleep(2 ** attempt * 500);
+    return safeFetch(url, token, ctx, init, attempt + 1);
+}
+// ---------------------------------------------------------------------------
+// Preflight
+// ---------------------------------------------------------------------------
+/** Confirm token is valid and has enough rate-limit budget to run. */
+export async function preflight(token, ctx) {
+    ctx.apiCalls++;
+    const result = await safeFetch(`${GH_REST}/rate_limit`, token, ctx);
+    if (!result.ok) {
+        ctx.errors.push(`preflight: ${result.message}`);
+        return null;
+    }
+    const remaining = result.data.resources.core.remaining;
+    return remaining >= PREFLIGHT_MIN_BUDGET ? remaining : null;
+}
+// ---------------------------------------------------------------------------
+// Input validation
+// ---------------------------------------------------------------------------
+const LOGIN_RE = /^[A-Za-z0-9_-]+$/;
+const REPO_RE = /^[\w.-]+\/[\w.-]+$/;
+function validateFetchInputs(login, repo) {
+    if (!LOGIN_RE.test(login)) {
+        throw new Error(`Invalid GitHub login: "${login}" — only [A-Za-z0-9_-] allowed`);
+    }
+    if (!REPO_RE.test(repo)) {
+        throw new Error(`Invalid repo slug: "${repo}" — expected owner/repo format`);
+    }
+}
+const GQL_PR_FIELDS = `
+  number title state createdAt mergedAt updatedAt headRefName url
+  author { login }
+  mergeCommit { oid }
+  commits(first: 100) {
+    nodes {
+      commit {
+        oid authoredDate committedDate message additions deletions changedFilesIfAvailable
+        author { user { login } email }
+      }
+    }
+  }
+`;
+const GQL_SEARCH_QUERY = `
+  query SearchPRs($searchQuery: String!, $after: String) {
+    search(query: $searchQuery, type: ISSUE, first: ${PAGE_SIZE}, after: $after) {
+      nodes {
+        ... on PullRequest {
+          ${GQL_PR_FIELDS}
+        }
+      }
+      pageInfo { endCursor hasNextPage }
+    }
+  }
+`;
+/**
+ * GraphQL search for PRs that were touched in the window by `login`. Returns
+ * full PR nodes including inner commits + stats. Paginates until
+ * `hasNextPage = false` or the {@link MAX_SEARCH_PAGES} hard cap is hit.
+ *
+ * The search query string is built outside the GraphQL document and injected
+ * as a `$searchQuery: String!` variable — eliminating the GraphQL injection
+ * vector while keeping the search term interpolation to the search API only.
+ */
+export function fetchPRsInWindow(token, login, repo, since, until, ctx) {
+    validateFetchInputs(login, repo);
+    // Build the GitHub search query string (NOT GraphQL syntax — interpolation here
+    // is safe because it targets the search API, not the GraphQL document itself).
+    const searchQuery = `repo:${repo} author:${login} updated:${since}..${until} type:pr`;
+    return fetchPRsPage(token, searchQuery, ctx, null, 0, []);
+}
+async function fetchPRsPage(token, searchQuery, ctx, cursor, page, accumulated) {
+    ctx.apiCalls++;
+    const variables = { searchQuery, after: cursor };
+    const result = await safeFetch(GH_GRAPHQL, token, ctx, {
+        method: "POST",
+        body: JSON.stringify({ query: GQL_SEARCH_QUERY, variables }),
+    });
+    if (!result.ok) {
+        ctx.errors.push(`fetchPRsInWindow page ${page + 1}: ${result.message}`);
+        return accumulated;
+    }
+    const { nodes, pageInfo } = result.data.data.search;
+    const prs = nodes.filter((n) => !!n?.number);
+    const next = [...accumulated, ...prs];
+    const nextPage = page + 1;
+    if (!pageInfo.hasNextPage) {
+        return next;
+    }
+    if (nextPage >= MAX_SEARCH_PAGES) {
+        ctx.errors.push(`search-truncated: ${next.length} PRs`);
+        return next;
+    }
+    return fetchPRsPage(token, searchQuery, ctx, pageInfo.endCursor, nextPage, next);
+}
+// ---------------------------------------------------------------------------
+// REST direct-commit fetch (#5)
+// ---------------------------------------------------------------------------
+/** Hard cap for REST commit pagination — 10 × 100 = 1000 commits per (user, repo). */
+const MAX_DIRECT_COMMIT_PAGES = 10;
+async function fetchDirectCommitsPage(token, baseUrl, ctx, page, accumulated) {
+    if (page > MAX_DIRECT_COMMIT_PAGES) {
+        ctx.errors.push(`fetchDirectCommits: truncated at ${MAX_DIRECT_COMMIT_PAGES * 100} commits`);
+        return accumulated;
+    }
+    const url = new URL(baseUrl);
+    url.searchParams.set("page", `${page}`);
+    const result = await safeFetch(url.toString(), token, ctx);
+    if (!result.ok) {
+        ctx.errors.push(`fetchDirectCommits: ${result.message}`);
+        return accumulated;
+    }
+    const next = [...accumulated, ...result.data];
+    if (result.data.length < 100) {
+        return next;
+    }
+    return fetchDirectCommitsPage(token, baseUrl, ctx, page + 1, next);
+}
+/**
+ * REST list of commits authored by `login` on the default branch in window.
+ * Paginates via `page=N` until a partial page is returned or the
+ * {@link MAX_DIRECT_COMMIT_PAGES} cap is hit (1000-commit ceiling).
+ * Used for direct-to-main commits with no PR — caller filters out merge
+ * commits + squash-merge commits using PR mergeCommit SHAs.
+ */
+export function fetchDirectCommits(token, login, repo, since, until, ctx) {
+    validateFetchInputs(login, repo);
+    const baseUrl = new URL(`${GH_REST}/repos/${repo}/commits`);
+    baseUrl.searchParams.set("author", login);
+    baseUrl.searchParams.set("since", since);
+    baseUrl.searchParams.set("until", until);
+    baseUrl.searchParams.set("per_page", "100");
+    ctx.apiCalls++;
+    return fetchDirectCommitsPage(token, baseUrl, ctx, 1, []);
+}
+/**
+ * Fetch per-commit addition/deletion/file-count from the REST single-commit
+ * endpoint. Returns `null` on any failure — callers treat null as "no stats".
+ *
+ * Counted as a logical `apiCalls` unit (each call is an independent cost unit).
+ */
+export async function fetchCommitStats(token, repo, sha, ctx) {
+    const url = new URL(`${GH_REST}/repos/${repo}/commits/${sha}`);
+    ctx.apiCalls++;
+    const result = await safeFetch(url.toString(), token, ctx);
+    if (!result.ok) {
+        ctx.errors.push(`fetchCommitStats ${sha}: ${result.message}`);
+        return null;
+    }
+    return {
+        additions: result.data.stats?.additions ?? 0,
+        deletions: result.data.stats?.deletions ?? 0,
+        filesChanged: result.data.files?.length ?? 0,
+    };
+}
+/**
+ * High-level fetch for one (user, repo). Returns digest-shaped
+ * {@link DigestPRData[]} after merging both API arms and applying the
+ * closed-unmerged filter + direct-commit dedup vs PR merge commits.
+ */
+export async function fetchUserRepo(user, repo, since, until, ctx, logger, options = {}) {
+    const [prs, restCommits] = await Promise.all([
+        fetchPRsInWindow(user.githubToken, user.login, repo, since, until, ctx),
+        fetchDirectCommits(user.githubToken, user.login, repo, since, until, ctx),
+    ]);
+    logger.debug({ repo, user: user.login, prs: prs.length, restCommits: restCommits.length }, "Fetched user/repo");
+    const prMergeShas = collectMergeShas(prs);
+    const prDataFromPrs = prs
+        .map((pr) => prNodeToDigestPRData(repo, pr, since, until))
+        .filter((p) => p !== null);
+    const directFiltered = restCommits.filter((c) => isDirectCommit(c, prMergeShas));
+    const prDataFromDirect = directFiltered.map((c) => directCommitToDigestPRData(repo, c));
+    if (!options.populateDirectCommitStats || prDataFromDirect.length === 0) {
+        return [...prDataFromPrs, ...prDataFromDirect];
+    }
+    // Enrich direct commits with per-commit stats (opt-in, concurrency=4).
+    const enriched = await batchConcurrent(prDataFromDirect.map((pd, i) => ({ pd, sha: directFiltered[i]?.sha ?? "" })), 4, async ({ pd, sha }) => {
+        if (!sha) {
+            return pd;
+        }
+        const stats = await fetchCommitStats(user.githubToken, repo, sha, ctx);
+        if (!stats) {
+            return pd;
+        }
+        return {
+            ...pd,
+            additions: stats.additions,
+            deletions: stats.deletions,
+            filesChanged: stats.filesChanged,
+            commits: pd.commits.map((c) => ({
+                ...c,
+                additions: stats.additions,
+                deletions: stats.deletions,
+                filesChanged: stats.filesChanged,
+            })),
+        };
+    });
+    return [...prDataFromPrs, ...enriched];
+}

package/dist/digest/index.d.ts

@@ -0,0 +1,3 @@
+import type { DigestParams, DigestResult, DigestStats } from "./types.js";
+export declare function dailyDigest(params: DigestParams): Promise<DigestResult>;
+export type { DigestStats };

package/dist/digest/index.js

@@ -0,0 +1,199 @@
+/**
+ * `dailyDigest()` — per-user-token GitHub digest, sibling to {@link analyze}.
+ *
+ * Reads commits + PRs via the GitHub API (REST + GraphQL), groups by Linear
+ * ticket, and estimates hours via OpenAI. Output shape matches {@link analyze}
+ * so consumers can use the same downstream code paths.
+ *
+ * Why this exists alongside `analyze()`:
+ *   - No local git clone required (works in serverless / Trigger.dev tasks)
+ *   - Per-user token isolation (different orgs → different GitHub + Linear keys)
+ *   - Catches open PRs that local-git can't see
+ *
+ * Tradeoffs vs `analyze()`:
+ *   - Bound to default branch + PR'd branches (can't read every ref like `--all`)
+ *   - Rate-limited by GitHub (5,000/hr per token); use local `analyze()` for
+ *     long historical windows.
+ *   - Activity-date attribution — see [[CONTEXT.md#attribution]].
+ */
+import { createOpenAI } from "@ai-sdk/openai";
+import pino from "pino";
+import { z } from "zod/v4";
+import { aggregateByTicket } from "../aggregator.js";
+import { estimateTicketHours } from "../ai/summarizer.js";
+import { createLinearClient } from "../linear/client.js";
+import { fetchTickets } from "../linear/tickets.js";
+import { buildRepoResults, buildUserSummary } from "../output/summary.js";
+import { extractFromPR } from "../parser/ticket-extractor.js";
+import { UNLINKED_ID } from "../types.js";
+import { batchConcurrent, partition, tryCatch } from "../utils.js";
+import { fetchUserRepo, makeCallContext, preflight } from "./github-fetch.js";
+const DEFAULT_MODEL = "gpt-4o";
+const DEFAULT_ORG = "daily-digest";
+const DEFAULT_REPO_CONCURRENCY = 4;
+const DEFAULT_USER_CONCURRENCY = 5;
+const repoSchema = z.object({
+    slug: z.string().regex(/^[\w.-]+\/[\w.-]+$/, "must be owner/repo format"),
+});
+const userSchema = z.object({
+    login: z.string().min(1),
+    githubToken: z.string().min(1),
+    linearApiKey: z.string().min(1),
+    repos: z.array(repoSchema).min(1),
+});
+const paramsSchema = z.object({
+    users: z.array(userSchema).min(1),
+    openaiApiKey: z.string().min(1).optional(),
+    since: z.iso.datetime(),
+    until: z.iso.datetime(),
+    model: z.string().min(1).optional(),
+    org: z.string().min(1).optional(),
+    skipEstimation: z.boolean().optional(),
+    repoConcurrency: z.number().int().positive().optional(),
+    userConcurrency: z.number().int().positive().optional(),
+    populateDirectCommitStats: z.boolean().optional(),
+});
+export async function dailyDigest(params) {
+    const validated = paramsSchema.parse({
+        users: params.users,
+        openaiApiKey: params.openaiApiKey,
+        since: params.since,
+        until: params.until,
+        model: params.model,
+        org: params.org,
+        skipEstimation: params.skipEstimation,
+        repoConcurrency: params.repoConcurrency,
+        userConcurrency: params.userConcurrency,
+        populateDirectCommitStats: params.populateDirectCommitStats,
+    });
+    if (!(validated.skipEstimation || validated.openaiApiKey)) {
+        throw new Error("openaiApiKey is required when skipEstimation is not true");
+    }
+    const logger = params.logger ?? pino({ level: "silent" });
+    const model = validated.model ?? DEFAULT_MODEL;
+    const org = validated.org ?? DEFAULT_ORG;
+    const userConcurrency = validated.userConcurrency ?? DEFAULT_USER_CONCURRENCY;
+    // Dedup Linear clients by API key — avoids N viewer auth round-trips for
+    // multiple users sharing the same Linear workspace.
+    const linearClientCache = new Map();
+    for (const user of validated.users) {
+        if (!linearClientCache.has(user.linearApiKey)) {
+            linearClientCache.set(user.linearApiKey, createLinearClient(user.linearApiKey, logger));
+        }
+    }
+    const openaiKey = validated.openaiApiKey ?? "";
+    const languageModel = validated.skipEstimation
+        ? null
+        : createOpenAI({ apiKey: openaiKey })(model);
+    const generatedAt = new Date().toISOString();
+    const dateRange = {
+        from: validated.since.slice(0, 10),
+        to: validated.until.slice(0, 10),
+    };
+    const users = await batchConcurrent(validated.users, userConcurrency, (user) => digestOneUser({
+        user,
+        since: validated.since,
+        until: validated.until,
+        org,
+        languageModel,
+        logger: logger.child({ user: user.login }),
+        repoConcurrency: validated.repoConcurrency ?? DEFAULT_REPO_CONCURRENCY,
+        skipEstimation: validated.skipEstimation ?? false,
+        linearClientCache,
+    }));
+    return { org, generatedAt, dateRange, users };
+}
+async function digestOneUser(ctx) {
+    const t0 = Date.now();
+    const callCtx = makeCallContext();
+    const remaining = await preflight(ctx.user.githubToken, callCtx);
+    if (!remaining) {
+        callCtx.errors.push("preflight failed — token invalid or rate-limit exhausted");
+        return emptyResult(ctx, callCtx, t0, 0);
+    }
+    const repoPRs = await batchConcurrent(ctx.user.repos, ctx.repoConcurrency, async (repo) => ({
+        repo: repo.slug,
+        prs: await fetchUserRepo(ctx.user, repo.slug, ctx.since, ctx.until, callCtx, ctx.logger),
+    }));
+    const totalPRs = repoPRs.reduce((sum, r) => sum + r.prs.length, 0);
+    ctx.logger.info({ totalPRs, repos: repoPRs.length }, "Digest fetch complete");
+    if (!totalPRs) {
+        return emptyResult(ctx, callCtx, t0, remaining);
+    }
+    const tickets = await resolveTickets(ctx, [...collectTicketIds(repoPRs)], callCtx);
+    const aggregated = aggregateByTicket(repoPRs, tickets, ctx.logger);
+    const estimated = await estimateAll(aggregated, ctx, callCtx);
+    const repos = buildRepoResults(aggregated, estimated);
+    const userSummary = buildUserSummary(estimated);
+    const totalHours = repos.reduce((sum, r) => sum + r.totalHours, 0);
+    return {
+        login: ctx.user.login,
+        totalHours: Math.round(totalHours * 10) / 10,
+        repos,
+        userSummary,
+        stats: makeStats(callCtx, t0, remaining),
+    };
+}
+const makeStats = (callCtx, t0, remaining) => ({
+    apiCalls: callCtx.apiCalls,
+    durationMs: Date.now() - t0,
+    rateLimitAtStart: remaining,
+    errors: callCtx.errors,
+});
+const emptyResult = (ctx, callCtx, t0, remaining) => ({
+    login: ctx.user.login,
+    totalHours: 0,
+    repos: [],
+    userSummary: [],
+    stats: makeStats(callCtx, t0, remaining),
+});
+const collectTicketIds = (repoPRs) => new Set(repoPRs.flatMap(({ prs }) => prs.flatMap(extractFromPR)));
+async function resolveTickets(ctx, ids, callCtx) {
+    if (!ids.length) {
+        return new Map();
+    }
+    const cachedClient = ctx.linearClientCache.get(ctx.user.linearApiKey) ??
+        Promise.reject(new Error("linear client not cached"));
+    const clientResult = await tryCatch(cachedClient);
+    if (!clientResult.ok) {
+        callCtx.errors.push(`linear: ${clientResult.error}`);
+        return new Map();
+    }
+    const tickets = await tryCatch(fetchTickets(clientResult.data, ids, ctx.logger));
+    if (!tickets.ok) {
+        callCtx.errors.push(`linear-fetch: ${tickets.error}`);
+        return new Map();
+    }
+    return tickets.data;
+}
+const isResolved = (entry) => !!entry.ticket && entry.ticketId !== UNLINKED_ID;
+const markUnmapped = (entry) => ({
+    ...entry,
+    estimatedHours: 0,
+    confidence: "low",
+    reasoning: "Unmapped: Linear ticket not found — requires manual review",
+});
+const markSkipped = (entry) => ({
+    ...entry,
+    estimatedHours: 0,
+    confidence: "low",
+    reasoning: "AI estimation skipped",
+});
+async function estimateAll(aggregated, ctx, callCtx) {
+    const entries = [...aggregated.values()].flat();
+    const [resolved, unresolved] = partition(entries, isResolved);
+    const unmapped = unresolved.map(markUnmapped);
+    if (!resolved.length) {
+        return unmapped;
+    }
+    if (ctx.skipEstimation) {
+        return [...resolved.map(markSkipped), ...unmapped];
+    }
+    const dateRange = { from: ctx.since.slice(0, 10), to: ctx.until.slice(0, 10) };
+    const result = await tryCatch(estimateTicketHours(resolved, { model: ctx.languageModel, dateRange }, ctx.logger));
+    if (!result.ok) {
+        callCtx.errors.push(`ai-estimate: ${result.error}`);
+        return [...resolved, ...unmapped];
+    }
+    return [...result.data, ...unmapped];
+}

package/dist/digest/transform.d.ts

@@ -0,0 +1,89 @@
+import type { DigestPRData } from "./types.js";
+/**
+ * GitHub GraphQL PullRequest node, narrowed to fields we read. Authoritative
+ * for "commits inside a PR" — preserves original `authoredDate` and
+ * `committedDate` even after a rebase.
+ */
+export interface GraphQLPullRequest {
+    number: number;
+    title: string;
+    state: "OPEN" | "MERGED" | "CLOSED";
+    createdAt: string;
+    mergedAt: string | null;
+    updatedAt: string;
+    headRefName: string;
+    url: string;
+    author: {
+        login: string;
+    } | null;
+    mergeCommit: {
+        oid: string;
+    } | null;
+    commits: {
+        nodes: Array<{
+            commit: {
+                oid: string;
+                authoredDate: string;
+                committedDate: string;
+                message: string;
+                additions: number;
+                deletions: number;
+                changedFilesIfAvailable: number | null;
+                author: {
+                    user: {
+                        login: string;
+                    } | null;
+                    email: string | null;
+                } | null;
+            };
+        }>;
+    };
+}
+/** GitHub REST commit, narrowed. Used for direct-to-main commits with no PR. */
+export interface RestCommit {
+    sha: string;
+    commit: {
+        author: {
+            name: string;
+            email: string;
+            date: string;
+        } | null;
+        committer: {
+            name: string;
+            email: string;
+            date: string;
+        } | null;
+        message: string;
+    };
+    author: {
+        login: string;
+    } | null;
+    parents: Array<{
+        sha: string;
+    }>;
+}
+/** Stable identifier for cross-run dedup. PR-grouped when a PR exists. */
+export declare function buildWorkUnit(repo: string, prNumber: number, directSha?: string): string;
+/** Inclusive on both ends — matches GitHub `since`/`until` semantics. */
+export declare function isWithinWindow(date: string, since: string, until: string): boolean;
+/** Q8: drop closed-without-merge PRs. OPEN and MERGED stay. */
+export declare function shouldIncludePr(state: GraphQLPullRequest["state"]): boolean;
+/**
+ * Convert a GraphQL PR into a {@link DigestPRData}, filtering inner commits to
+ * the activity window. Returns null if the PR has no commits in window (e.g.
+ * stale PR with `updatedAt` in window due to a label change but no new code).
+ */
+export declare function prNodeToDigestPRData(repo: string, pr: GraphQLPullRequest, since: string, until: string): DigestPRData | null;
+/**
+ * Convert a single REST direct-to-main commit into a synthetic PRData. Each
+ * direct commit is its own work unit (Q4) — no grouping by author or day.
+ */
+export declare function directCommitToDigestPRData(repo: string, commit: RestCommit): DigestPRData;
+/** A REST commit is "direct" iff it's not a merge AND not the squash-output of a PR. */
+export declare function isDirectCommit(commit: RestCommit, prMergeShas: Set<string>): boolean;
+/**
+ * Collect all PR mergeCommit SHAs from a list of PR nodes. Used to filter out
+ * squash-merge commits from the REST direct-commits arm — those commits
+ * represent work already counted via the GraphQL PR arm.
+ */
+export declare function collectMergeShas(prs: GraphQLPullRequest[]): Set<string>;

package/dist/digest/transform.js

@@ -0,0 +1,108 @@
+/** Stable identifier for cross-run dedup. PR-grouped when a PR exists. */
+export function buildWorkUnit(repo, prNumber, directSha) {
+    return prNumber > 0 ? `${repo}:pr-${prNumber}` : `${repo}:direct:${directSha}`;
+}
+/** Inclusive on both ends — matches GitHub `since`/`until` semantics. */
+export function isWithinWindow(date, since, until) {
+    return date >= since && date <= until;
+}
+/** Q8: drop closed-without-merge PRs. OPEN and MERGED stay. */
+export function shouldIncludePr(state) {
+    return state === "OPEN" || state === "MERGED";
+}
+function commitNodeToCommitData(node) {
+    const { commit } = node;
+    return {
+        sha: commit.oid,
+        message: commit.message,
+        author: commit.author?.user?.login ?? commit.author?.email ?? "unknown",
+        // Q10/B: bucket by activity date — use committedDate, not authoredDate.
+        date: commit.committedDate,
+        additions: commit.additions,
+        deletions: commit.deletions,
+        filesChanged: commit.changedFilesIfAvailable ?? 0,
+    };
+}
+/**
+ * Convert a GraphQL PR into a {@link DigestPRData}, filtering inner commits to
+ * the activity window. Returns null if the PR has no commits in window (e.g.
+ * stale PR with `updatedAt` in window due to a label change but no new code).
+ */
+export function prNodeToDigestPRData(repo, pr, since, until) {
+    if (!shouldIncludePr(pr.state)) {
+        return null;
+    }
+    const commitsInWindow = pr.commits.nodes
+        .filter((n) => isWithinWindow(n.commit.committedDate, since, until))
+        .map(commitNodeToCommitData);
+    if (commitsInWindow.length === 0) {
+        return null;
+    }
+    const additions = commitsInWindow.reduce((sum, c) => sum + c.additions, 0);
+    const deletions = commitsInWindow.reduce((sum, c) => sum + c.deletions, 0);
+    const filesChanged = commitsInWindow.reduce((sum, c) => sum + c.filesChanged, 0);
+    return {
+        number: pr.number,
+        title: pr.title,
+        author: pr.author?.login ?? "unknown",
+        branchName: pr.headRefName,
+        additions,
+        deletions,
+        filesChanged,
+        commits: commitsInWindow,
+        mergedAt: pr.mergedAt,
+        createdAt: pr.createdAt,
+        url: pr.url,
+        workUnit: buildWorkUnit(repo, pr.number),
+    };
+}
+/**
+ * Convert a single REST direct-to-main commit into a synthetic PRData. Each
+ * direct commit is its own work unit (Q4) — no grouping by author or day.
+ */
+export function directCommitToDigestPRData(repo, commit) {
+    const message = commit.commit.message;
+    const titleLine = message.split("\n")[0];
+    // Q10/B: bucket on committer.date, not author.date.
+    const committedDate = commit.commit.committer?.date ?? commit.commit.author?.date ?? "";
+    const authorLogin = commit.author?.login ?? commit.commit.author?.email ?? "unknown";
+    const commitData = {
+        sha: commit.sha,
+        message,
+        author: authorLogin,
+        date: committedDate,
+        // REST list endpoint omits stats; populated separately if a per-commit call
+        // is made. Zero is safe — heuristic estimator handles it.
+        additions: 0,
+        deletions: 0,
+        filesChanged: 0,
+    };
+    return {
+        number: 0,
+        title: titleLine,
+        author: authorLogin,
+        branchName: "",
+        additions: 0,
+        deletions: 0,
+        filesChanged: 0,
+        commits: [commitData],
+        mergedAt: null,
+        createdAt: committedDate,
+        url: `https://github.com/${repo}/commit/${commit.sha}`,
+        workUnit: buildWorkUnit(repo, 0, commit.sha),
+    };
+}
+/** A REST commit is "direct" iff it's not a merge AND not the squash-output of a PR. */
+export function isDirectCommit(commit, prMergeShas) {
+    const isMerge = commit.parents.length > 1;
+    const isPrMerge = prMergeShas.has(commit.sha);
+    return !(isMerge || isPrMerge);
+}
+/**
+ * Collect all PR mergeCommit SHAs from a list of PR nodes. Used to filter out
+ * squash-merge commits from the REST direct-commits arm — those commits
+ * represent work already counted via the GraphQL PR arm.
+ */
+export function collectMergeShas(prs) {
+    return new Set(prs.map((pr) => pr.mergeCommit?.oid).filter((oid) => !!oid));
+}

package/dist/digest/types.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Public types for {@link dailyDigest} — a stateless, fail-safe per-user worker
+ * that reads work-attribution data from the GitHub API for a date window and
+ * produces senku-shaped output per user.
+ *
+ * Design tradeoffs locked in this module:
+ *   - **Stateless + fingerprint**: every call is pure; consumers dedup across
+ *     runs via the per-PR `workUnit` field on the emitted {@link PRData}.
+ *   - **PR-grouped workUnit**: all commits within one GitHub PR share a
+ *     workUnit, so squash-merges across runs collapse to one logical unit.
+ *   - **Per-user output**: errors isolate to one user; other users' results are
+ *     unaffected. Consumers map multiple Users to one person if needed.
+ *   - **OPEN + MERGED only**: closed-without-merge PRs are excluded upstream.
+ *   - **Window applies to activity** (committerDate / PR updatedAt). Cherry-
+ *     picks and rebased commits bucket on the day they landed, not the day
+ *     they were originally written.
+ */
+import type pino from "pino";
+import type { PRData, RepoResult, UserSummary } from "../types.js";
+/** A repository to scan, identified by `"owner/repo"`. */
+export interface DigestRepo {
+    slug: string;
+}
+/**
+ * Sentinel for commit/PR author when the GitHub API returns no login and no
+ * email. Typed as a const so narrowing works on equality checks.
+ */
+export declare const UNKNOWN_AUTHOR: "unknown";
+/**
+ * One identity-in-one-org. GitHub and Linear are both org-scoped, so they
+ * travel together inside a User entry. One human appears as N Users if they
+ * work across N orgs.
+ */
+export interface DigestUser {
+    /** GitHub login (e.g. `"hrithikbluelabel"`). */
+    login: string;
+    /**
+     * GitHub PAT with `repo` (classic) or `Contents: read` + `Pull requests: read`
+     * (fine-grained). Used as the bearer for REST + GraphQL.
+     */
+    githubToken: string;
+    /** Linear workspace key (`lin_api_...`). Resolves ticket IDs to titles/states. */
+    linearApiKey: string;
+    /** Repos to scan for this user. */
+    repos: DigestRepo[];
+}
+/**
+ * Parameters for {@link dailyDigest}.
+ */
+export interface DigestParams {
+    users: DigestUser[];
+    /**
+     * OpenAI API key. Optional when `skipEstimation` is `true`.
+     * Cost note: the default model (`gpt-4o`) is called once per resolved ticket;
+     * large orgs can accumulate meaningful spend — use `gpt-4o-mini` or
+     * `skipEstimation: true` for zero-cost dry runs.
+     */
+    openaiApiKey?: string;
+    /** ISO-8601 window start (inclusive). */
+    since: string;
+    /** ISO-8601 window end (inclusive). */
+    until: string;
+    /**
+     * Override the OpenAI model. Default: `"gpt-4o"`.
+     * `gpt-4o-mini` is cheaper with similar accuracy for hour estimation.
+     */
+    model?: string;
+    /** Label that flows into DigestResult.org. Default: `"daily-digest"`. */
+    org?: string;
+    /** Optional pino logger for diagnostics. Default: a silent logger. */
+    logger?: pino.Logger;
+    /**
+     * When `true`, skip OpenAI estimation entirely. All resolved entries receive
+     * `estimatedHours: 0, confidence: "low"`. Makes `openaiApiKey` optional.
+     * Useful for CI dry-runs or rate-limit-sensitive contexts.
+     */
+    skipEstimation?: boolean;
+    /**
+     * Max repos fetched in parallel per user. Default: 4.
+     * Raise cautiously — GitHub secondary rate limits penalise burst parallelism.
+     */
+    repoConcurrency?: number;
+    /**
+     * Max users processed in parallel. Default: 5.
+     * Each user makes N*repo API calls; keep conservative in large orgs.
+     */
+    userConcurrency?: number;
+    /**
+     * When `true`, pass through to fetchUserRepo to populate direct-commit stats.
+     * Default: false.
+     */
+    populateDirectCommitStats?: boolean;
+}
+/** Per-user telemetry — useful for cost tracking + debugging in consumers. */
+export interface DigestStats {
+    apiCalls: number;
+    durationMs: number;
+    /**
+     * GitHub API rate-limit remaining calls at the time of preflight.
+     * Reflects the budget at the start of the run, not after it completes.
+     */
+    rateLimitAtStart: number;
+    /** Non-fatal errors collected during the run (bad repo, Linear failure, etc.). */
+    errors: string[];
+}
+/** Per-user result. Shared fields (`org`, `generatedAt`, `dateRange`) live on {@link DigestResult}. */
+export interface DigestUserResult {
+    login: string;
+    totalHours: number;
+    repos: RepoResult[];
+    userSummary: UserSummary[];
+    stats: DigestStats;
+}
+/** Top-level return value from {@link dailyDigest}. */
+export interface DigestResult {
+    org: string;
+    generatedAt: string;
+    dateRange: {
+        from: string;
+        to: string;
+    };
+    users: DigestUserResult[];
+}
+/**
+ * PRData extended with the dedup fingerprint. The base {@link PRData} flows
+ * unmodified through senku's existing pipeline; `workUnit` is populated only
+ * on digest-emitted PRs.
+ *
+ * Format:
+ *   - PR-derived: `"<owner>/<repo>:pr-<number>"`
+ *   - Direct commit: `"<owner>/<repo>:direct:<sha>"`
+ */
+export interface DigestPRData extends PRData {
+    workUnit: string;
+}

package/dist/digest/types.js

@@ -0,0 +1,5 @@
+/**
+ * Sentinel for commit/PR author when the GitHub API returns no login and no
+ * email. Typed as a const so narrowing works on equality checks.
+ */
+export const UNKNOWN_AUTHOR = "unknown";

package/dist/lib.d.ts

@@ -16,6 +16,8 @@ export type { AnalyzeDeps } from "./analyze.js";
 export { analyze } from "./analyze.js";
 export { discoverRepos } from "./cli/discover.js";
 export { cloneRepo } from "./clone.js";
+export { dailyDigest, dailyDigest as digest } from "./digest/index.js";
+export type { DigestParams, DigestPRData, DigestRepo, DigestResult, DigestStats, DigestUser, DigestUserResult, } from "./digest/types.js";
 export { assertGitAvailable, runGit } from "./exec.js";
 export type { GitHubUser } from "./github-user.js";
 export { fetchGitHubUser } from "./github-user.js";

package/dist/lib.js

@@ -15,6 +15,7 @@ export { estimateTicketHours } from "./ai/summarizer.js";
 export { analyze } from "./analyze.js";
 export { discoverRepos } from "./cli/discover.js";
 export { cloneRepo } from "./clone.js";
+export { dailyDigest, dailyDigest as digest } from "./digest/index.js";
 export { assertGitAvailable, runGit } from "./exec.js";
 export { fetchGitHubUser } from "./github-user.js";
 export { createLinearClient } from "./linear/client.js";

package/dist/output/summary.d.ts

@@ -0,0 +1,5 @@
+import type { RepoResult, TicketEntry, UserSummary } from "../types.js";
+/** Build per-repo {@link RepoResult} list from aggregation keys + estimated entries. */
+export declare function buildRepoResults(aggregated: Map<string, TicketEntry[]>, estimated: TicketEntry[]): RepoResult[];
+/** Build per-user hour summary by splitting each ticket's hours equally across contributors. */
+export declare function buildUserSummary(estimated: TicketEntry[]): UserSummary[];

package/dist/output/summary.js

@@ -0,0 +1,26 @@
+/** Build per-repo {@link RepoResult} list from aggregation keys + estimated entries. */
+export function buildRepoResults(aggregated, estimated) {
+    return [...aggregated.keys()].map((repoName) => {
+        const repoTickets = estimated.filter((e) => e.repo === repoName);
+        const totalHours = repoTickets.reduce((sum, t) => sum + t.estimatedHours, 0);
+        return { repo: repoName, totalHours: Math.round(totalHours * 10) / 10, tickets: repoTickets };
+    });
+}
+/** Build per-user hour summary by splitting each ticket's hours equally across contributors. */
+export function buildUserSummary(estimated) {
+    const userMap = estimated.reduce((map, entry) => {
+        const perUserHours = entry.users.length ? entry.estimatedHours / entry.users.length : 0;
+        for (const user of entry.users) {
+            const existing = map.get(user) ?? { hours: 0, tickets: new Set() };
+            existing.hours += perUserHours;
+            existing.tickets.add(entry.ticketId);
+            map.set(user, existing);
+        }
+        return map;
+    }, new Map());
+    return [...userMap.entries()].map(([user, data]) => ({
+        user,
+        totalHours: Math.round(data.hours * 10) / 10,
+        ticketCount: data.tickets.size,
+    }));
+}

package/dist/pipeline.js

@@ -3,6 +3,7 @@ import { aggregateByTicket } from "./aggregator.js";
 import { estimateTicketHours } from "./ai/summarizer.js";
 import { createLinearClient } from "./linear/client.js";
 import { fetchTickets } from "./linear/tickets.js";
+import { buildRepoResults, buildUserSummary } from "./output/summary.js";
 import { extractFromPR } from "./parser/ticket-extractor.js";
 import { getRepoName, scrapeRepo } from "./scrape.js";
 import { UNLINKED_ID } from "./types.js";
@@ -60,34 +61,6 @@ async function runAiEstimation(resolvedEntries, unmappedWithFlag, input, dateRan
     progress(`AI estimation complete for ${aiEstimated.length} tickets`);
     return [...aiEstimated, ...unmappedWithFlag];
 }
-function buildRepoResults(aggregated, estimated) {
-    return [...aggregated.keys()].map((repoName) => {
-        const repoTickets = estimated.filter((e) => e.repo === repoName);
-        const totalHours = repoTickets.reduce((sum, t) => sum + t.estimatedHours, 0);
-        return { repo: repoName, totalHours: Math.round(totalHours * 10) / 10, tickets: repoTickets };
-    });
-}
-function buildUserSummary(estimated) {
-    const userHoursMap = new Map();
-    for (const entry of estimated) {
-        const perUserHours = entry.estimatedHours / entry.users.length;
-        for (const user of entry.users) {
-            const existing = userHoursMap.get(user);
-            if (existing) {
-                existing.hours += perUserHours;
-                existing.tickets.add(entry.ticketId);
-            }
-            else {
-                userHoursMap.set(user, { hours: perUserHours, tickets: new Set([entry.ticketId]) });
-            }
-        }
-    }
-    return [...userHoursMap.entries()].map(([user, data]) => ({
-        user,
-        totalHours: Math.round(data.hours * 10) / 10,
-        ticketCount: data.tickets.size,
-    }));
-}
 export function defaultLanguageModel(apiKey, modelName) {
     return createOpenAI({ apiKey })(modelName);
 }

package/dist/utils.d.ts

@@ -13,4 +13,9 @@ export declare function formatDate(date: Date): string;
 export declare function expandHome(path: string): string;
 export declare function batchConcurrent<T, R>(items: T[], concurrency: number, fn: (item: T) => Promise<R>): Promise<R[]>;
 export declare function sanitizeFilename(name: string): string;
+/**
+ * Split `items` into two arrays in a single pass.
+ * Returns `[matching, nonMatching]`.
+ */
+export declare function partition<T>(items: T[], predicate: (item: T) => boolean): [T[], T[]];
 export {};

package/dist/utils.js

@@ -42,3 +42,19 @@ export function sanitizeFilename(name) {
         .slice(0, 100);
     return sanitized.length > 0 ? sanitized : "unnamed";
 }
+/**
+ * Split `items` into two arrays in a single pass.
+ * Returns `[matching, nonMatching]`.
+ */
+export function partition(items, predicate) {
+    return items.reduce((acc, item) => {
+        const [yes, no] = acc;
+        if (predicate(item)) {
+            yes.push(item);
+        }
+        else {
+            no.push(item);
+        }
+        return acc;
+    }, [[], []]);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robotostudio/senku",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Estimate dev hours per Linear ticket from git history + AI. A stateless library plus an interactive CLI; runs on Node and on Trigger.dev.",
   "license": "MIT",
   "type": "module",
@@ -14,7 +14,7 @@
     "./package.json": "./package.json"
   },
   "bin": {
-    "senku": "./dist/index.js"
+    "senku": "dist/index.js"
   },
   "files": [
     "dist",