@backburner/cli 0.1.0

package/dist/src/github/pr-classification.js

@@ -0,0 +1,73 @@
+export function classifyPullRequestBase(input) {
+    const baseBranch = input.baseBranch.trim();
+    const defaultBranch = input.defaultBranch.trim();
+    if (baseBranch === defaultBranch) {
+        return {
+            kind: "top_level",
+            pullRequestNumber: input.pullRequestNumber,
+            repoSlug: input.repoSlug,
+            baseBranch,
+            defaultBranch,
+        };
+    }
+    return {
+        kind: "non_default_parent",
+        pullRequestNumber: input.pullRequestNumber,
+        repoSlug: input.repoSlug,
+        baseBranch,
+        defaultBranch,
+    };
+}
+export const MANAGEMENT_LEARNING_BRANCH_PREFIXES = [
+    "agent/management-learning/",
+    "management-learning/",
+];
+export function classifyManagementPullRequest(input) {
+    const { repoId, repoSlug, pullRequestNumber, headBranch, managementRepo, managementPrs = [], managementBranchPrefixes = MANAGEMENT_LEARNING_BRANCH_PREFIXES, } = input;
+    // 1. Check if it matches a known management PR record
+    const matchingRecord = managementPrs.find((record) => record.mode === "pull_request" &&
+        record.prNumber === pullRequestNumber &&
+        (record.repoSlug === repoSlug || record.repoId === repoId));
+    if (matchingRecord) {
+        return {
+            kind: "management",
+            reason: "Matched known management PR record",
+            managementPrRecordId: matchingRecord.id,
+        };
+    }
+    // 2. Check if it's in the management repo
+    const isManagementRepo = managementRepo &&
+        (managementRepo.repoId === repoId || managementRepo.repoSlug === repoSlug);
+    if (isManagementRepo) {
+        // 3. Check head branch prefix
+        if (headBranch) {
+            if (managementBranchPrefixes.some((prefix) => headBranch.startsWith(prefix))) {
+                return {
+                    kind: "management",
+                    reason: "Management repo PR with management branch prefix",
+                };
+            }
+        }
+        // 4. Check if it matches a management record by branch
+        const matchingBranchRecord = managementPrs.find((record) => record.branchName === headBranch &&
+            (record.repoSlug === repoSlug || record.repoId === repoId));
+        if (matchingBranchRecord) {
+            return {
+                kind: "management",
+                reason: "Matched known management PR record by branch",
+                managementPrRecordId: matchingBranchRecord.id,
+            };
+        }
+    }
+    // 5. If we don't have enough info about management repo, we might return unknown
+    if (!managementRepo) {
+        return {
+            kind: "unknown",
+            reason: "Management repository identity is unknown",
+        };
+    }
+    return {
+        kind: "operational",
+        reason: "Did not match management PR criteria",
+    };
+}

package/dist/src/github/scoped-broker.js

@@ -0,0 +1,35 @@
+export class ScopedBrokerToolService {
+    delegate;
+    activeAllowedToolNames;
+    constructor(delegate) {
+        this.delegate = delegate;
+    }
+    listTools() {
+        return this.delegate.listTools().filter((tool) => this.isAllowed(tool.name));
+    }
+    async callTool(name, rawArguments) {
+        if (!this.isAllowed(name)) {
+            return {
+                ok: false,
+                tool: name,
+                error: {
+                    code: "tool_not_found",
+                    message: `Tool "${name}" is not enabled for this agent run`
+                }
+            };
+        }
+        return await this.delegate.callTool(name, rawArguments);
+    }
+    bindAllowedTools(allowedToolNames) {
+        this.activeAllowedToolNames = new Set(allowedToolNames);
+    }
+    clearAllowedTools() {
+        this.activeAllowedToolNames = undefined;
+    }
+    isAllowed(publicToolName) {
+        return (this.activeAllowedToolNames === undefined ||
+            this.activeAllowedToolNames.has(publicToolName) ||
+            this.activeAllowedToolNames.has("*") ||
+            Array.from(this.activeAllowedToolNames).some((allowedToolName) => allowedToolName.endsWith(".*") && publicToolName.startsWith(allowedToolName.slice(0, -1))));
+    }
+}

package/dist/src/github/security.js

@@ -0,0 +1,126 @@
+export class SecurityFilteredGitHubGateway {
+    inner;
+    allowedUsers;
+    constructor(inner, allowedUsers) {
+        this.inner = inner;
+        this.allowedUsers = allowedUsers;
+    }
+    isAllowed(login) {
+        return this.allowedUsers.includes(login || "");
+    }
+    async getRepositoryMetadata(owner, name) {
+        return this.inner.getRepositoryMetadata(owner, name);
+    }
+    async getRepositoryDefaultBranch(owner, name) {
+        return this.inner.getRepositoryDefaultBranch(owner, name);
+    }
+    async getIssue(owner, name, issueNumber) {
+        const issue = await this.inner.getIssue(owner, name, issueNumber);
+        if (!this.isAllowed(issue.author?.login)) {
+            throw new Error(`Unauthorized: Issue #${issueNumber} author is not in allowedUsers`);
+        }
+        return this.filterLabels(owner, name, issue);
+    }
+    async getPullRequest(owner, name, prNumber) {
+        const pr = await this.inner.getPullRequest(owner, name, prNumber);
+        if (!this.isAllowed(pr.author?.login)) {
+            throw new Error(`Unauthorized: PR #${prNumber} author is not in allowedUsers`);
+        }
+        return this.filterLabels(owner, name, pr);
+    }
+    async findOpenPullRequestByHeadBranch(owner, name, headBranch) {
+        const pr = await this.inner.findOpenPullRequestByHeadBranch(owner, name, headBranch);
+        if (pr && !this.isAllowed(pr.author?.login)) {
+            return null;
+        }
+        if (!pr) {
+            return null;
+        }
+        return this.filterLabels(owner, name, pr);
+    }
+    async createPullRequest(input) {
+        const pr = await this.inner.createPullRequest(input);
+        if (!this.isAllowed(pr.author?.login)) {
+            throw new Error(`Unauthorized: Created PR author is not in allowedUsers`);
+        }
+        return this.filterLabels(input.owner, input.name, pr);
+    }
+    async listOpenIssues(owner, name) {
+        const issues = await this.inner.listOpenIssues(owner, name);
+        const filteredIssues = issues.filter((issue) => this.isAllowed(issue.author?.login));
+        return Promise.all(filteredIssues.map((issue) => this.filterLabels(owner, name, issue)));
+    }
+    async listOpenPullRequests(owner, name) {
+        const prs = await this.inner.listOpenPullRequests(owner, name);
+        const filteredPrs = prs.filter((pr) => this.isAllowed(pr.author?.login));
+        return Promise.all(filteredPrs.map((pr) => this.filterLabels(owner, name, pr)));
+    }
+    async listIssueComments(owner, name, issueNumber) {
+        const comments = await this.inner.listIssueComments(owner, name, issueNumber);
+        return comments.filter((comment) => this.isAllowed(comment.author?.login));
+    }
+    async listPullRequestComments(owner, name, prNumber) {
+        const comments = await this.inner.listPullRequestComments(owner, name, prNumber);
+        return comments.filter((comment) => this.isAllowed(comment.author?.login));
+    }
+    async listPullRequestReviews(owner, name, prNumber) {
+        const reviews = await this.inner.listPullRequestReviews(owner, name, prNumber);
+        return reviews.filter((review) => this.isAllowed(review.author?.login));
+    }
+    async listPullRequestReviewComments(owner, name, prNumber) {
+        const comments = await this.inner.listPullRequestReviewComments(owner, name, prNumber);
+        return comments.filter((comment) => this.isAllowed(comment.user?.login));
+    }
+    async listPullRequestChangedFiles(owner, name, prNumber) {
+        return this.inner.listPullRequestChangedFiles(owner, name, prNumber);
+    }
+    async searchCode(input) {
+        return this.inner.searchCode(input);
+    }
+    async postIssueComment(input) {
+        return this.inner.postIssueComment(input);
+    }
+    async updateIssueComment(input) {
+        return this.inner.updateIssueComment(input);
+    }
+    async addReaction(input) {
+        return this.inner.addReaction(input);
+    }
+    async postPullRequestReviewCommentReply(input) {
+        return this.inner.postPullRequestReviewCommentReply(input);
+    }
+    async submitPullRequestReview(input) {
+        return this.inner.submitPullRequestReview(input);
+    }
+    async listIssueEvents(owner, name, issueNumber) {
+        return this.inner.listIssueEvents(owner, name, issueNumber);
+    }
+    async listPullRequestCheckRuns(owner, name, headSha) {
+        return this.inner.listPullRequestCheckRuns(owner, name, headSha);
+    }
+    async filterLabels(owner, name, entity) {
+        const labels = entity.labels || [];
+        if (labels.length === 0) {
+            return {
+                ...entity,
+                labels: []
+            };
+        }
+        const events = await this.inner.listIssueEvents(owner, name, entity.number);
+        const allowedLabels = new Set();
+        for (const label of labels) {
+            const labelEvents = events.filter((e) => e.label?.name === label.name && (e.event === "labeled" || e.event === "unlabeled"));
+            const sortedEvents = [...labelEvents].sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+            const lastEvent = sortedEvents[sortedEvents.length - 1];
+            if (lastEvent && lastEvent.event === "labeled") {
+                if (this.isAllowed(lastEvent.actor?.login)) {
+                    allowedLabels.add(label.name);
+                }
+            }
+        }
+        return {
+            ...entity,
+            labels: labels.filter((l) => allowedLabels.has(l.name))
+        };
+    }
+}

package/dist/src/github/service.js

@@ -0,0 +1,332 @@
+import { normalizeIssue, normalizeIssueComments, normalizePullRequest, normalizePullRequestReviewComments, normalizePullRequestReviews } from "./normalize.js";
+export class GitHubScanService {
+    gitHubGateway;
+    now;
+    constructor(gitHubGateway, now = () => new Date().toISOString()) {
+        this.gitHubGateway = gitHubGateway;
+        this.now = now;
+    }
+    async scanRepositories(repos, repoResults, previousState) {
+        const seenAt = this.now();
+        const previousIssues = new Map(previousState.issues.map((issue) => [issue.id, issue]));
+        const previousPullRequests = new Map(previousState.prs.map((pr) => [pr.id, pr]));
+        const previousComments = new Map(previousState.comments.map((comment) => [comment.id, comment]));
+        const resultsByRepoId = new Map(repoResults.map((record) => [record.repoId, record]));
+        const issues = [];
+        const prs = [];
+        const comments = [];
+        const failures = [];
+        for (const repo of repos) {
+            const repoResult = resultsByRepoId.get(repo.id);
+            if (!repoResult) {
+                continue;
+            }
+            const repoFailures = [];
+            let repoIssueCount = 0;
+            let repoPrCount = 0;
+            let repoCommentCount = 0;
+            const repoMetadata = await this.fetchRepositoryMetadata(repo, repoResult, repoFailures);
+            if (!repoMetadata) {
+                const carriedIssues = entitiesForRepo(previousState.issues, repo.id);
+                const carriedPrs = entitiesForRepo(previousState.prs, repo.id);
+                const carriedComments = entitiesForRepo(previousState.comments, repo.id);
+                issues.push(...carriedIssues);
+                prs.push(...carriedPrs);
+                comments.push(...carriedComments);
+                failures.push(...repoFailures);
+                repoResult.githubScan = {
+                    status: "failed",
+                    scannedAt: seenAt,
+                    issueCount: carriedIssues.length,
+                    pullRequestCount: carriedPrs.length,
+                    commentCount: carriedComments.length,
+                    failures: repoFailures
+                };
+                continue;
+            }
+            const [issueListFetch, pullRequestListFetch] = await Promise.all([
+                this.fetchWithFailure(() => this.gitHubGateway.listOpenIssues(repo.owner, repo.name), repo.id, repoMetadata.nameWithOwner, "list_issues", "repo", repoFailures),
+                this.fetchWithFailure(() => this.gitHubGateway.listOpenPullRequests(repo.owner, repo.name), repo.id, repoMetadata.nameWithOwner, "list_pull_requests", "repo", repoFailures)
+            ]);
+            const rawIssues = issueListFetch.value ?? [];
+            const rawPullRequests = pullRequestListFetch.value ?? [];
+            const rawPullRequestsByNumber = new Map(rawPullRequests.map((pr) => [pr.number, pr]));
+            if (issueListFetch.failed) {
+                const carriedIssues = entitiesForRepo(previousState.issues, repo.id);
+                const carriedIssueComments = commentsForParentType(previousState.comments, repo.id, "issue");
+                issues.push(...carriedIssues);
+                comments.push(...carriedIssueComments);
+                repoIssueCount += carriedIssues.length;
+                repoCommentCount += carriedIssueComments.length;
+            }
+            if (!issueListFetch.failed) {
+                for (const rawIssue of rawIssues) {
+                    const issueCommentFetch = await this.fetchWithFailure(() => this.gitHubGateway.listIssueComments(repo.owner, repo.name, rawIssue.number), repo.id, repoMetadata.nameWithOwner, "issue_comments", `issue#${rawIssue.number}`, repoFailures);
+                    const issueComments = issueCommentFetch.value ?? [];
+                    const normalizedComments = normalizeIssueComments(issueComments, rawIssue.number, "issue", "issue_comment", {
+                        repo,
+                        repoMetadata,
+                        seenAt,
+                        previousIssues,
+                        previousPullRequests,
+                        previousComments
+                    });
+                    const carriedComments = issueCommentFetch.failed
+                        ? commentsForParent(previousState.comments, repo.id, "issue", rawIssue.number)
+                        : [];
+                    const mergedComments = mergeById(normalizedComments, carriedComments).sort(compareComments);
+                    const normalizedIssue = normalizeIssue(rawIssue, mergedComments, {
+                        repo,
+                        repoMetadata,
+                        seenAt,
+                        previousIssues,
+                        previousPullRequests,
+                        previousComments
+                    });
+                    issues.push(normalizedIssue);
+                    comments.push(...mergedComments);
+                    repoIssueCount += 1;
+                    repoCommentCount += mergedComments.length;
+                }
+            }
+            if (pullRequestListFetch.failed) {
+                const carriedPrs = entitiesForRepo(previousState.prs, repo.id);
+                const carriedPrComments = commentsForParentType(previousState.comments, repo.id, "pull_request");
+                prs.push(...carriedPrs);
+                comments.push(...carriedPrComments);
+                repoPrCount += carriedPrs.length;
+                repoCommentCount += carriedPrComments.length;
+            }
+            if (!pullRequestListFetch.failed) {
+                for (const rawPr of rawPullRequests) {
+                    const [prCommentsFetch, prReviewsFetch, prReviewCommentsFetch] = await Promise.all([
+                        this.fetchWithFailure(() => this.gitHubGateway.listPullRequestComments(repo.owner, repo.name, rawPr.number), repo.id, repoMetadata.nameWithOwner, "pull_request_comments", `pull_request#${rawPr.number}`, repoFailures),
+                        this.fetchWithFailure(() => this.gitHubGateway.listPullRequestReviews(repo.owner, repo.name, rawPr.number), repo.id, repoMetadata.nameWithOwner, "pull_request_reviews", `pull_request#${rawPr.number}`, repoFailures),
+                        this.fetchWithFailure(() => this.gitHubGateway.listPullRequestReviewComments(repo.owner, repo.name, rawPr.number), repo.id, repoMetadata.nameWithOwner, "pull_request_review_comments", `pull_request#${rawPr.number}`, repoFailures)
+                    ]);
+                    const normalizedComments = [
+                        ...normalizeIssueComments(prCommentsFetch.value ?? [], rawPr.number, "pull_request", "pull_request_comment", {
+                            repo,
+                            repoMetadata,
+                            seenAt,
+                            previousIssues,
+                            previousPullRequests,
+                            previousComments
+                        }),
+                        ...normalizePullRequestReviews(prReviewsFetch.value ?? [], rawPr.number, {
+                            repo,
+                            repoMetadata,
+                            seenAt,
+                            previousIssues,
+                            previousPullRequests,
+                            previousComments
+                        }),
+                        ...normalizePullRequestReviewComments(prReviewCommentsFetch.value ?? [], rawPr.number, {
+                            repo,
+                            repoMetadata,
+                            seenAt,
+                            previousIssues,
+                            previousPullRequests,
+                            previousComments
+                        })
+                    ].sort((left, right) => left.id.localeCompare(right.id));
+                    const carriedComments = prCommentsFetch.failed || prReviewsFetch.failed || prReviewCommentsFetch.failed
+                        ? commentsForParent(previousState.comments, repo.id, "pull_request", rawPr.number)
+                        : [];
+                    const mergedComments = mergeById(normalizedComments, carriedComments).sort(compareComments);
+                    const normalizedPr = normalizePullRequest(rawPr, mergedComments, {
+                        repo,
+                        repoMetadata,
+                        seenAt,
+                        previousIssues,
+                        previousPullRequests,
+                        previousComments
+                    });
+                    prs.push(normalizedPr);
+                    comments.push(...mergedComments);
+                    repoPrCount += 1;
+                    repoCommentCount += mergedComments.length;
+                }
+                const trackedMissingPullRequests = await this.fetchTrackedMissingPullRequests({
+                    repo,
+                    repoMetadata,
+                    seenAt,
+                    previousState,
+                    previousIssues,
+                    previousPullRequests,
+                    previousComments,
+                    rawPullRequestsByNumber,
+                    failures: repoFailures
+                });
+                for (const normalizedPr of trackedMissingPullRequests) {
+                    prs.push(normalizedPr);
+                    repoPrCount += 1;
+                }
+            }
+            failures.push(...repoFailures);
+            repoResult.githubScan = {
+                status: repoFailures.length === 0
+                    ? "scanned"
+                    : repoIssueCount === 0 && repoPrCount === 0
+                        ? "failed"
+                        : "partial",
+                scannedAt: seenAt,
+                issueCount: repoIssueCount,
+                pullRequestCount: repoPrCount,
+                commentCount: repoCommentCount,
+                failures: repoFailures
+            };
+        }
+        return {
+            issues: issues.sort(compareEntities),
+            prs: prs.sort(compareEntities),
+            comments: comments.sort(compareComments),
+            repoResults,
+            failures
+        };
+    }
+    async fetchRepositoryMetadata(repo, repoResult, failures) {
+        try {
+            return await this.gitHubGateway.getRepositoryMetadata(repo.owner, repo.name);
+        }
+        catch (error) {
+            failures.push({
+                repoId: repo.id,
+                repoSlug: repoResult.repoSlug,
+                step: "repo_metadata",
+                scope: "repo",
+                message: error instanceof Error ? error.message : String(error)
+            });
+            return undefined;
+        }
+    }
+    async fetchWithFailure(fetcher, repoId, repoSlug, step, scope, failures) {
+        try {
+            return { value: await fetcher(), failed: false };
+        }
+        catch (error) {
+            failures.push({
+                repoId,
+                repoSlug,
+                step,
+                scope,
+                message: error instanceof Error ? error.message : String(error)
+            });
+            return { failed: true };
+        }
+    }
+    async fetchTrackedMissingPullRequests(input) {
+        const trackedNumbers = collectTrackedPullRequestNumbers(input.repo.id, input.repoMetadata.nameWithOwner, input.previousState);
+        const missingNumbers = [...trackedNumbers]
+            .filter((number) => !input.rawPullRequestsByNumber.has(number))
+            .sort((left, right) => left - right);
+        const fetched = [];
+        for (const prNumber of missingNumbers) {
+            const fetch = await this.fetchWithFailure(() => this.gitHubGateway.getPullRequest(input.repo.owner, input.repo.name, prNumber), input.repo.id, input.repoMetadata.nameWithOwner, "get_pull_request", `pull_request#${prNumber}`, input.failures);
+            if (fetch.value) {
+                fetched.push(normalizePullRequest(fetch.value, commentsForParent(input.previousState.comments, input.repo.id, "pull_request", prNumber), {
+                    repo: input.repo,
+                    repoMetadata: input.repoMetadata,
+                    seenAt: input.seenAt,
+                    previousIssues: input.previousIssues,
+                    previousPullRequests: input.previousPullRequests,
+                    previousComments: input.previousComments
+                }));
+                continue;
+            }
+            const previousTrackedPr = input.previousPullRequests.get(`pull_request:${input.repoMetadata.nameWithOwner}:${prNumber}`);
+            if (previousTrackedPr) {
+                fetched.push(previousTrackedPr);
+            }
+        }
+        return fetched;
+    }
+}
+function collectTrackedPullRequestNumbers(repoId, repoSlug, previousState) {
+    const numbers = new Set();
+    const mergedPacketPrNumbers = new Set();
+    for (const workstream of previousState.workstreams) {
+        if (workstream.repoKey !== repoSlug) {
+            continue;
+        }
+        for (const packet of Object.values(workstream.packetPlan?.packets ?? {})) {
+            if (packet.prNumber === undefined) {
+                continue;
+            }
+            if (packet.status === "merged_to_parent") {
+                mergedPacketPrNumbers.add(packet.prNumber);
+            }
+            else {
+                numbers.add(packet.prNumber);
+            }
+        }
+    }
+    // Collect PR numbers already belonging to terminal workstreams so we don't
+    // re-fetch them — once a workstream is closed/merged its PR state is final.
+    const terminalPrNumbers = new Set();
+    for (const workstream of previousState.workstreams) {
+        if (workstream.repoKey !== repoSlug) {
+            continue;
+        }
+        if (workstream.status === "closed" || workstream.status === "merged" || workstream.resolution === "merged") {
+            for (const linkedPr of workstream.linkedPrs) {
+                terminalPrNumbers.add(linkedPr.number);
+            }
+            if (workstream.activePrNumber !== undefined) {
+                terminalPrNumbers.add(workstream.activePrNumber);
+            }
+        }
+    }
+    for (const worktree of previousState.worktrees) {
+        if (worktree.repoId !== repoId || worktree.prNumber === undefined) {
+            continue;
+        }
+        if (worktree.packet) {
+            if (!mergedPacketPrNumbers.has(worktree.prNumber)) {
+                numbers.add(worktree.prNumber);
+            }
+        }
+        else if (!terminalPrNumbers.has(worktree.prNumber)) {
+            // Non-packet (integration) worktree PRs are not covered by the packet plan
+            // loop above, so track them until their merged state is observed.
+            numbers.add(worktree.prNumber);
+        }
+    }
+    return numbers;
+}
+function entitiesForRepo(items, repoId) {
+    return items.filter((item) => item.repoId === repoId);
+}
+function commentsForParentType(comments, repoId, parentType) {
+    return comments.filter((comment) => comment.repoId === repoId && comment.parentType === parentType);
+}
+function commentsForParent(comments, repoId, parentType, parentNumber) {
+    return comments.filter((comment) => comment.repoId === repoId &&
+        comment.parentType === parentType &&
+        comment.parentNumber === parentNumber);
+}
+function mergeById(fresh, carried) {
+    const byId = new Map();
+    for (const item of carried) {
+        byId.set(item.id, item);
+    }
+    for (const item of fresh) {
+        byId.set(item.id, item);
+    }
+    return [...byId.values()];
+}
+function compareEntities(left, right) {
+    if (left.repoSlug !== right.repoSlug) {
+        return left.repoSlug.localeCompare(right.repoSlug);
+    }
+    return left.number - right.number;
+}
+function compareComments(left, right) {
+    if (left.repoSlug !== right.repoSlug) {
+        return left.repoSlug.localeCompare(right.repoSlug);
+    }
+    if (left.parentNumber !== right.parentNumber) {
+        return left.parentNumber - right.parentNumber;
+    }
+    return left.id.localeCompare(right.id);
+}

package/dist/src/github/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/github/utils.js

@@ -0,0 +1,16 @@
+export function parseGitHubRemoteUrl(url) {
+    // git@github.com:owner/name.git
+    // https://github.com/owner/name.git
+    // https://github.com/owner/name
+    const sshRegex = /^git@github\.com:([^/]+)\/([^/]+)\.git$/;
+    const httpsRegex = /^https:\/\/github\.com\/([^/]+)\/([^/]+?)(\.git)?$/;
+    const sshMatch = url.match(sshRegex);
+    if (sshMatch) {
+        return { owner: sshMatch[1], name: sshMatch[2] };
+    }
+    const httpsMatch = url.match(httpsRegex);
+    if (httpsMatch) {
+        return { owner: httpsMatch[1], name: httpsMatch[2] };
+    }
+    return undefined;
+}

package/dist/src/journal/index.js

@@ -0,0 +1,4 @@
+export { JournalWriter } from "./writer.js";
+export { JournalReader } from "./reader.js";
+export { JournalService } from "./service.js";
+export { renderJournalEntries } from "./renderer.js";

package/dist/src/journal/reader.js

@@ -0,0 +1,62 @@
+import { readFile } from "node:fs/promises";
+import * as path from "node:path";
+export class JournalReader {
+    journalPath;
+    constructor(journalDir) {
+        this.journalPath = path.join(journalDir, "journal.jsonl");
+    }
+    async read() {
+        let raw;
+        try {
+            raw = await readFile(this.journalPath, "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return [];
+            }
+            throw error;
+        }
+        return raw
+            .split(/\r?\n/)
+            .filter(Boolean)
+            .map((line) => JSON.parse(line));
+    }
+    async query(q = {}) {
+        let entries = await this.read();
+        if (q.repoId !== undefined) {
+            entries = entries.filter((e) => e.repoId === q.repoId);
+        }
+        if (q.workstreamId !== undefined) {
+            entries = entries.filter((e) => e.workstreamId === q.workstreamId);
+        }
+        if (q.issueNumber !== undefined) {
+            entries = entries.filter((e) => e.issueNumber === q.issueNumber);
+        }
+        if (q.prNumber !== undefined) {
+            entries = entries.filter((e) => e.prNumber === q.prNumber);
+        }
+        if (q.cycleId !== undefined) {
+            entries = entries.filter((e) => e.cycleId === q.cycleId);
+        }
+        if (q.executionId !== undefined) {
+            entries = entries.filter((e) => e.executionId === q.executionId);
+        }
+        if (q.scope !== undefined) {
+            entries = entries.filter((e) => e.scope === q.scope);
+        }
+        if (q.category !== undefined) {
+            entries = entries.filter((e) => e.category === q.category);
+        }
+        if (q.severity !== undefined) {
+            entries = entries.filter((e) => e.severity === q.severity);
+        }
+        if (q.since !== undefined) {
+            const sinceMs = new Date(q.since).getTime();
+            entries = entries.filter((e) => new Date(e.timestamp).getTime() >= sinceMs);
+        }
+        if (q.limit !== undefined) {
+            entries = entries.slice(-q.limit);
+        }
+        return entries;
+    }
+}