@backburner/cli 0.1.0

package/dist/src/git/types.js

@@ -0,0 +1,484 @@
+import { mkdir, rm, stat } from "node:fs/promises";
+import * as path from "node:path";
+import { CommandExecutionError } from "../utils/command-runner.js";
+export class GitCliGateway {
+    commandRunner;
+    constructor(commandRunner) {
+        this.commandRunner = commandRunner;
+    }
+    async cloneRepository(repo, destinationPath) {
+        const parentDir = path.dirname(destinationPath);
+        await mkdir(parentDir, { recursive: true });
+        await this.commandRunner.run("git", ["clone", `git@github.com:${repo.owner}/${repo.name}.git`, destinationPath], { cwd: parentDir });
+    }
+    async fetchRepository(localPath) {
+        await this.commandRunner.run("git", ["fetch", "--prune", "origin"], {
+            cwd: localPath
+        });
+    }
+    async getCurrentBranch(localPath) {
+        try {
+            const result = await this.commandRunner.run("git", ["symbolic-ref", "--quiet", "--short", "HEAD"], { cwd: localPath });
+            return result.stdout.trim() || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async getRemoteDefaultBranch(localPath) {
+        try {
+            const result = await this.commandRunner.run("git", ["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"], { cwd: localPath });
+            return stripOriginPrefix(result.stdout.trim());
+        }
+        catch {
+            const fallback = await this.commandRunner.run("git", ["remote", "show", "origin"], {
+                cwd: localPath
+            });
+            const match = fallback.stdout.match(/HEAD branch:\s+([^\s]+)/);
+            if (!match?.[1]) {
+                throw new Error(`Could not determine remote default branch for ${localPath}`);
+            }
+            return match[1];
+        }
+    }
+    async isWorkingTreeClean(localPath) {
+        const result = await this.commandRunner.run("git", ["status", "--porcelain", "."], {
+            cwd: localPath
+        });
+        return result.stdout.trim() === "";
+    }
+    async ensureDefaultBranchCheckedOut(localPath, branch) {
+        const hasLocalBranch = await this.hasLocalBranch(localPath, branch);
+        if (hasLocalBranch) {
+            await this.commandRunner.run("git", ["checkout", branch], { cwd: localPath });
+            return;
+        }
+        await this.commandRunner.run("git", ["checkout", "-b", branch, "--track", `origin/${branch}`], { cwd: localPath });
+    }
+    async fastForwardDefaultBranch(localPath, branch) {
+        await this.commandRunner.run("git", ["branch", "--set-upstream-to", `origin/${branch}`, branch], { cwd: localPath });
+        await this.commandRunner.run("git", ["merge", "--ff-only", `origin/${branch}`], {
+            cwd: localPath
+        });
+    }
+    validatePathWithinCodeRoot(codeRoot, candidatePath) {
+        return resolvePathWithinCodeRoot(codeRoot, candidatePath);
+    }
+    async compareBranchSyncStatus(localPath, parentBranch, defaultBranch) {
+        const defaultRef = this.remoteBranchRef(defaultBranch);
+        const parentRef = this.remoteBranchRef(parentBranch);
+        const baseComparison = {
+            parentBranch,
+            defaultBranch,
+            parentRef,
+            defaultRef
+        };
+        try {
+            if (!(await this.hasRef(localPath, defaultRef))) {
+                return {
+                    ...baseComparison,
+                    status: "missing_default_branch",
+                    message: "Default branch ref was not found locally."
+                };
+            }
+            if (!(await this.hasRef(localPath, parentRef))) {
+                return {
+                    ...baseComparison,
+                    status: "missing_parent_branch",
+                    message: "Parent branch ref was not found locally."
+                };
+            }
+            const result = await this.commandRunner.run("git", ["rev-list", "--left-right", "--count", `${defaultRef}...${parentRef}`], { cwd: localPath });
+            const tokens = result.stdout.trim().split(/\s+/);
+            if (tokens.length < 2) {
+                return {
+                    ...baseComparison,
+                    status: "unknown",
+                    message: "Could not compare branch sync status."
+                };
+            }
+            const behind = Number(tokens[0]);
+            const ahead = Number(tokens[1]);
+            if (isNaN(behind) || isNaN(ahead)) {
+                return {
+                    ...baseComparison,
+                    status: "unknown",
+                    message: "Could not compare branch sync status."
+                };
+            }
+            const comparison = {
+                ...baseComparison,
+                parentAheadCount: ahead,
+                parentBehindCount: behind,
+                status: "unknown",
+                message: ""
+            };
+            if (behind === 0) {
+                comparison.status = "up_to_date";
+                comparison.message = "Parent branch contains the default branch.";
+            }
+            else if (ahead === 0) {
+                comparison.status = "behind_default";
+                comparison.message = "Parent branch is behind the default branch.";
+            }
+            else {
+                comparison.status = "diverged";
+                comparison.message = "Parent branch and default branch have diverged.";
+            }
+            return comparison;
+        }
+        catch {
+            return {
+                ...baseComparison,
+                status: "unknown",
+                message: "Could not compare branch sync status."
+            };
+        }
+    }
+    async listWorktrees(repoPath) {
+        const result = await this.commandRunner.run("git", ["worktree", "list", "--porcelain"], {
+            cwd: repoPath
+        });
+        const worktrees = [];
+        let currentPath = "";
+        for (const line of result.stdout.split(/\r?\n/)) {
+            if (line.startsWith("worktree ")) {
+                currentPath = line.slice("worktree ".length).trim();
+            }
+            else if (line.startsWith("branch ") && currentPath) {
+                const branchRef = line.slice("branch ".length).trim();
+                const branchName = branchRef.startsWith("refs/heads/")
+                    ? branchRef.slice("refs/heads/".length)
+                    : branchRef;
+                worktrees.push({ path: currentPath, branch: branchName });
+                currentPath = "";
+            }
+        }
+        return worktrees;
+    }
+    async getWorktreeForBranch(repoPath, branch) {
+        const worktrees = await this.listWorktrees(repoPath);
+        const match = worktrees.find((wt) => wt.branch === branch);
+        return match ? match.path : null;
+    }
+    async createWorktree(repoPath, codeRoot, worktreePath, branch, startPoint) {
+        const safeWorktreePath = resolvePathWithinCodeRoot(codeRoot, worktreePath);
+        await this.commandRunner.run("git", ["worktree", "add", "-b", branch, safeWorktreePath, startPoint], { cwd: repoPath });
+        return safeWorktreePath;
+    }
+    async hasCommitsAhead(localPath, baseRef) {
+        const result = await this.commandRunner.run("git", ["rev-list", "--count", `${baseRef}..HEAD`], { cwd: localPath });
+        return Number(result.stdout.trim() || "0") > 0;
+    }
+    async commitAll(localPath, message) {
+        await this.commandRunner.run("git", ["add", "--all", "."], { cwd: localPath });
+        const status = await this.commandRunner.run("git", ["status", "--porcelain", "."], {
+            cwd: localPath
+        });
+        if (status.stdout.trim() === "") {
+            return false;
+        }
+        await this.commandRunner.run("git", ["commit", "-m", message, "."], { cwd: localPath });
+        return true;
+    }
+    async pushBranch(localPath, branch) {
+        await this.commandRunner.run("git", ["push", "-u", "origin", branch], { cwd: localPath });
+    }
+    async checkoutBranch(localPath, branch) {
+        await this.commandRunner.run("git", ["checkout", branch], { cwd: localPath });
+    }
+    async mergeRemoteBranch(localPath, remote, branch) {
+        await this.commandRunner.run("git", ["merge", "--no-edit", `${remote}/${branch}`], {
+            cwd: localPath
+        });
+    }
+    async abortMerge(localPath) {
+        await this.commandRunner.run("git", ["merge", "--abort"], { cwd: localPath });
+    }
+    async abortRebase(localPath) {
+        await this.commandRunner.run("git", ["rebase", "--abort"], { cwd: localPath });
+    }
+    async abortCherryPick(localPath) {
+        await this.commandRunner.run("git", ["cherry-pick", "--abort"], { cwd: localPath });
+    }
+    async abortRevert(localPath) {
+        await this.commandRunner.run("git", ["revert", "--abort"], { cwd: localPath });
+    }
+    async isInsideWorkingTree(localPath) {
+        try {
+            await stat(localPath);
+        }
+        catch (err) {
+            if (err instanceof Error && err.code === "ENOENT") {
+                return false;
+            }
+            throw err;
+        }
+        try {
+            const result = await this.commandRunner.run("git", ["rev-parse", "--is-inside-work-tree"], {
+                cwd: localPath
+            });
+            return result.stdout.trim() === "true";
+        }
+        catch (error) {
+            if (error instanceof CommandExecutionError &&
+                error.stderr.includes("not a git repository")) {
+                return false;
+            }
+            throw error;
+        }
+    }
+    async pullFastForwardOnly(localPath) {
+        await this.commandRunner.run("git", ["pull", "--ff-only"], { cwd: localPath });
+    }
+    async getHeadCommitSha(localPath) {
+        const result = await this.commandRunner.run("git", ["rev-parse", "HEAD"], {
+            cwd: localPath
+        });
+        return result.stdout.trim();
+    }
+    async cloneRepositoryFromUrl(sshUrl, destinationPath) {
+        const parentDir = path.dirname(destinationPath);
+        await mkdir(parentDir, { recursive: true });
+        await this.commandRunner.run("git", ["clone", sshUrl, destinationPath], { cwd: parentDir });
+    }
+    async checkoutBranchAtRemote(localPath, branch, options) {
+        if (!options?.skipFetch) {
+            await this.commandRunner.run("git", ["fetch", "origin"], { cwd: localPath });
+        }
+        await this.commandRunner.run("git", ["checkout", "-B", branch, `origin/${branch}`], { cwd: localPath });
+    }
+    async getAheadBehindVsRemote(localPath, branch) {
+        // Output format: "<behind>\t<ahead>" (left = behind, right = ahead)
+        const result = await this.commandRunner.run("git", ["rev-list", "--left-right", "--count", `origin/${branch}...HEAD`], { cwd: localPath });
+        const tokens = result.stdout.trim().split(/\s+/);
+        const behind = Number(tokens[0] ?? "0");
+        const ahead = Number(tokens[1] ?? "0");
+        return {
+            behind: isNaN(behind) ? 0 : behind,
+            ahead: isNaN(ahead) ? 0 : ahead
+        };
+    }
+    async isAncestorOf(localPath, ancestorSha, descendantSha) {
+        if (ancestorSha === descendantSha)
+            return true;
+        try {
+            await this.commandRunner.run("git", ["merge-base", "--is-ancestor", ancestorSha, descendantSha], { cwd: localPath });
+            return true;
+        }
+        catch {
+            // git merge-base --is-ancestor exits non-zero when ancestorSha is NOT an ancestor
+            return false;
+        }
+    }
+    async countCommitsAheadOf(localPath, baseSha) {
+        const result = await this.commandRunner.run("git", ["rev-list", "--count", `${baseSha}..HEAD`], { cwd: localPath });
+        return Number(result.stdout.trim()) || 0;
+    }
+    async getActiveMergeState(localPath) {
+        // Resolve .git directory path (works in both normal clones and linked worktrees)
+        const gitDirResult = await this.commandRunner.run("git", ["rev-parse", "--git-dir"], { cwd: localPath });
+        const rawGitDir = gitDirResult.stdout.trim();
+        const gitDir = path.isAbsolute(rawGitDir) ? rawGitDir : path.resolve(localPath, rawGitDir);
+        // Check file-based state indicators
+        const fileChecks = [
+            [path.join(gitDir, "MERGE_HEAD"), "merging"],
+            [path.join(gitDir, "REBASE_HEAD"), "rebasing"],
+            [path.join(gitDir, "CHERRY_PICK_HEAD"), "cherry-picking"],
+            [path.join(gitDir, "REVERT_HEAD"), "reverting"]
+        ];
+        for (const [filePath, state] of fileChecks) {
+            try {
+                await stat(filePath);
+                return state;
+            }
+            catch {
+                // file does not exist, continue
+            }
+        }
+        // Check directory-based rebase state indicators
+        const dirChecks = [
+            [path.join(gitDir, "rebase-merge"), "rebasing"],
+            [path.join(gitDir, "rebase-apply"), "rebasing"]
+        ];
+        for (const [dirPath, state] of dirChecks) {
+            try {
+                await stat(dirPath);
+                return state;
+            }
+            catch {
+                // directory does not exist, continue
+            }
+        }
+        return "none";
+    }
+    async pushWithLease(localPath, branch, expectedOldSha) {
+        await this.commandRunner.run("git", [
+            "push",
+            `--force-with-lease=refs/heads/${branch}:${expectedOldSha}`,
+            "origin",
+            `HEAD:refs/heads/${branch}`
+        ], { cwd: localPath });
+    }
+    async removeDirectory(dirPath) {
+        await rm(dirPath, { recursive: true, force: true });
+    }
+    async getCommitLogSince(localPath, baseSha) {
+        const result = await this.commandRunner.run("git", ["log", "--oneline", `${baseSha}..HEAD`], { cwd: localPath });
+        return result.stdout.trim();
+    }
+    async getDiffStatSince(localPath, baseSha) {
+        const result = await this.commandRunner.run("git", ["diff", "--stat", `${baseSha}..HEAD`], { cwd: localPath });
+        return result.stdout.trim();
+    }
+    async resetHard(localPath, ref) {
+        await this.commandRunner.run("git", ["reset", "--hard", ref], { cwd: localPath });
+    }
+    async cleanUntrackedFiles(localPath) {
+        await this.commandRunner.run("git", ["clean", "-fd"], { cwd: localPath });
+    }
+    remoteBranchRef(branch) {
+        return `refs/remotes/origin/${branch}`;
+    }
+    async hasRef(localPath, ref) {
+        try {
+            await this.commandRunner.run("git", ["show-ref", "--verify", "--quiet", ref], {
+                cwd: localPath
+            });
+            return true;
+        }
+        catch (error) {
+            if (error instanceof CommandExecutionError && error.exitCode === 1) {
+                return false;
+            }
+            throw error;
+        }
+    }
+    async hasLocalBranch(localPath, branch) {
+        try {
+            await this.commandRunner.run("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`], { cwd: localPath });
+            return true;
+        }
+        catch (error) {
+            if (error instanceof CommandExecutionError && error.exitCode === 1) {
+                return false;
+            }
+            throw error;
+        }
+    }
+}
+export class LocalRepoSyncService {
+    gitGateway;
+    gitHubGateway;
+    now;
+    constructor(gitGateway, gitHubGateway, now = () => new Date().toISOString()) {
+        this.gitGateway = gitGateway;
+        this.gitHubGateway = gitHubGateway;
+        this.now = now;
+    }
+    async syncRepository(repo, codeRoot) {
+        const localPath = resolvePathWithinCodeRoot(codeRoot, repo.localPath);
+        const repoSlug = `${repo.owner}/${repo.name}`;
+        const existedBeforeSync = await pathExists(localPath);
+        let currentBranchBefore = null;
+        let currentBranchAfter = null;
+        let defaultBranch = repo.defaultBranch ?? null;
+        let defaultBranchSource = repo.defaultBranch ? "config" : "unknown";
+        try {
+            if (!existedBeforeSync) {
+                await this.gitGateway.cloneRepository(repo, localPath);
+            }
+            await this.gitGateway.fetchRepository(localPath);
+            currentBranchBefore = await this.gitGateway.getCurrentBranch(localPath);
+            if (!defaultBranch) {
+                try {
+                    defaultBranch = await this.gitHubGateway.getRepositoryDefaultBranch(repo.owner, repo.name);
+                    defaultBranchSource = "github";
+                }
+                catch {
+                    defaultBranch = await this.gitGateway.getRemoteDefaultBranch(localPath);
+                    defaultBranchSource = "git";
+                }
+            }
+            const clean = await this.gitGateway.isWorkingTreeClean(localPath);
+            if (!clean) {
+                throw new Error("working tree is dirty; refusing to switch or fast-forward the default branch");
+            }
+            await this.gitGateway.ensureDefaultBranchCheckedOut(localPath, defaultBranch);
+            await this.gitGateway.fastForwardDefaultBranch(localPath, defaultBranch);
+            currentBranchAfter = await this.gitGateway.getCurrentBranch(localPath);
+            return {
+                repoId: repo.id,
+                repoName: repo.name,
+                repoSlug,
+                localPath,
+                codeRoot,
+                status: "synced",
+                existedBeforeSync,
+                cloned: !existedBeforeSync,
+                fetched: true,
+                defaultBranch,
+                defaultBranchSource,
+                currentBranchBefore,
+                currentBranchAfter,
+                syncedAt: this.now(),
+                message: !existedBeforeSync
+                    ? "Repository cloned, fetched, and synchronized to the latest default branch."
+                    : "Repository fetched and synchronized to the latest default branch."
+            };
+        }
+        catch (error) {
+            currentBranchAfter = await safeGetCurrentBranch(this.gitGateway, localPath);
+            return {
+                repoId: repo.id,
+                repoName: repo.name,
+                repoSlug,
+                localPath,
+                codeRoot,
+                status: "failed",
+                existedBeforeSync,
+                cloned: !existedBeforeSync && currentBranchAfter !== null,
+                fetched: existedBeforeSync,
+                defaultBranch,
+                defaultBranchSource,
+                currentBranchBefore,
+                currentBranchAfter,
+                syncedAt: this.now(),
+                message: "Repository synchronization failed.",
+                error: {
+                    step: "sync",
+                    message: error instanceof Error ? error.message : String(error)
+                }
+            };
+        }
+    }
+}
+async function safeGetCurrentBranch(gitGateway, localPath) {
+    try {
+        return await gitGateway.getCurrentBranch(localPath);
+    }
+    catch {
+        return null;
+    }
+}
+async function pathExists(filePath) {
+    try {
+        await stat(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function resolvePathWithinCodeRoot(codeRoot, localPath) {
+    const resolvedCodeRoot = path.resolve(codeRoot);
+    const resolvedRepoPath = path.resolve(resolvedCodeRoot, localPath);
+    const relativePath = path.relative(resolvedCodeRoot, resolvedRepoPath);
+    if (relativePath === ".." || relativePath.startsWith(`..${path.sep}`)) {
+        throw new Error(`Configured repo path "${localPath}" escapes the code root`);
+    }
+    return resolvedRepoPath;
+}
+function stripOriginPrefix(value) {
+    return value.startsWith("origin/") ? value.slice("origin/".length) : value;
+}

package/dist/src/github/broker-model-content.js

@@ -0,0 +1,215 @@
+const MODEL_VISIBLE_BODY_LENGTH = 1_500;
+const MODEL_VISIBLE_LIST_LENGTH = 10;
+const MODEL_VISIBLE_READ_TOOLS = new Set([
+    "get_issue",
+    "get_issue_comments",
+    "get_pr",
+    "get_pr_comments",
+    "get_pr_checks",
+    "search_code"
+]);
+export function createModelVisibleSuccessText(result) {
+    if (!MODEL_VISIBLE_READ_TOOLS.has(result.tool)) {
+        return result.summary;
+    }
+    return [
+        `${result.summary}. Model-visible result projection follows; full untruncated result is available in structuredContent.`,
+        JSON.stringify(createReadToolProjection(result.tool, result.result), null, 2)
+    ].join("\n");
+}
+function createReadToolProjection(tool, result) {
+    switch (tool) {
+        case "get_issue":
+            return { repo: result.repo, issue: projectIssue(result.issue) };
+        case "get_issue_comments":
+            return {
+                repo: result.repo,
+                issueNumber: result.issueNumber,
+                comments: projectList(result.comments, projectComment)
+            };
+        case "get_pr":
+            return {
+                repo: result.repo,
+                pullRequestNumber: getRecordProperty(result.pullRequest, "number"),
+                pullRequest: projectPullRequest(result.pullRequest)
+            };
+        case "get_pr_comments":
+            return {
+                repo: result.repo,
+                pullRequestNumber: result.pullRequestNumber,
+                comments: projectList(result.comments, projectComment),
+                reviews: projectList(result.reviews, projectReview),
+                reviewComments: projectList(result.reviewComments, projectReviewComment)
+            };
+        case "get_pr_checks":
+            return {
+                repo: result.repo,
+                pullRequestNumber: result.pullRequestNumber,
+                headSha: result.headSha,
+                checkRuns: projectList(result.checkRuns, projectCheckRun)
+            };
+        case "search_code":
+            return {
+                repo: result.repo,
+                query: result.query,
+                pathPrefix: result.pathPrefix,
+                totalCount: result.totalCount,
+                incompleteResults: result.incompleteResults,
+                items: projectList(result.items, projectSearchCodeItem)
+            };
+        default:
+            return { summary: "No model-visible projection is configured for this read tool." };
+    }
+}
+function projectIssue(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    return {
+        id: value.id,
+        number: value.number,
+        title: value.title,
+        state: value.state,
+        author: projectActor(value.author),
+        url: value.url,
+        labels: projectLabels(value.labels),
+        createdAt: value.createdAt,
+        updatedAt: value.updatedAt,
+        ...projectBody(value.body)
+    };
+}
+function projectPullRequest(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    return {
+        id: value.id,
+        number: value.number,
+        title: value.title,
+        state: value.state,
+        author: projectActor(value.author),
+        url: value.url,
+        labels: projectLabels(value.labels),
+        headRefName: value.headRefName,
+        headSha: value.headSha,
+        baseRefName: value.baseRefName,
+        isDraft: value.isDraft,
+        createdAt: value.createdAt,
+        updatedAt: value.updatedAt,
+        ...projectBody(value.body)
+    };
+}
+function projectComment(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    return {
+        id: value.id,
+        author: projectActor(value.author),
+        url: value.url,
+        createdAt: value.createdAt,
+        updatedAt: value.updatedAt,
+        ...projectBody(value.body)
+    };
+}
+function projectReview(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    return {
+        id: value.id,
+        author: projectActor(value.author),
+        state: value.state,
+        url: value.url,
+        submittedAt: value.submittedAt,
+        updatedAt: value.updatedAt,
+        ...projectBody(value.body)
+    };
+}
+function projectReviewComment(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    return {
+        id: value.id,
+        author: projectActor(value.user),
+        url: value.html_url,
+        path: value.path,
+        line: value.line,
+        originalLine: value.original_line,
+        side: value.side,
+        startLine: value.start_line,
+        startSide: value.start_side,
+        createdAt: value.created_at,
+        updatedAt: value.updated_at,
+        ...projectBody(value.body)
+    };
+}
+function projectCheckRun(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    return {
+        id: value.id,
+        name: value.name,
+        status: value.status,
+        conclusion: value.conclusion,
+        url: value.url,
+        startedAt: value.startedAt,
+        completedAt: value.completedAt
+    };
+}
+function projectSearchCodeItem(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    return {
+        name: value.name,
+        path: value.path,
+        sha: value.sha,
+        htmlUrl: value.htmlUrl
+    };
+}
+function projectList(value, projectItem) {
+    const items = Array.isArray(value) ? value : [];
+    const visibleItems = items.slice(-MODEL_VISIBLE_LIST_LENGTH);
+    return {
+        totalCount: items.length,
+        returnedCount: visibleItems.length,
+        truncated: visibleItems.length < items.length,
+        ...(visibleItems.length < items.length
+            ? { truncationNote: `Showing the latest ${visibleItems.length} of ${items.length} items.` }
+            : {}),
+        items: visibleItems.map(projectItem).filter((item) => item !== undefined)
+    };
+}
+function projectBody(value) {
+    if (typeof value !== "string") {
+        return { body: null };
+    }
+    if (value.length <= MODEL_VISIBLE_BODY_LENGTH) {
+        return { body: value };
+    }
+    return {
+        body: `${value.slice(0, MODEL_VISIBLE_BODY_LENGTH)}\n...[truncated]`,
+        bodyTruncated: true,
+        bodyOriginalLength: value.length
+    };
+}
+function projectActor(value) {
+    return isRecord(value) && typeof value.login === "string" ? value.login : null;
+}
+function projectLabels(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .map((label) => (isRecord(label) && typeof label.name === "string" ? label.name : undefined))
+        .filter((label) => label !== undefined);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getRecordProperty(value, property) {
+    return isRecord(value) ? value[property] : undefined;
+}