@evref-bl/dev-nexus 0.1.0-alpha.0

package/dist/workTrackingGitHubProvider.js

@@ -0,0 +1,663 @@
+import { spawnSync } from "node:child_process";
+export const defaultGitHubApiBaseUrl = "https://api.github.com";
+export const defaultGitHubApiVersion = "2026-03-10";
+export const githubStatusLabelPrefix = "status:";
+const openStatuses = new Set([
+    "todo",
+    "ready",
+    "in_progress",
+    "blocked",
+]);
+const closedStatuses = new Set(["done", "wont_do"]);
+const workStatuses = new Set([
+    ...openStatuses,
+    ...closedStatuses,
+]);
+export class GitHubWorkTrackerProviderError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "GitHubWorkTrackerProviderError";
+    }
+}
+export const githubWorkTrackerCapabilities = {
+    createItem: true,
+    listItems: true,
+    getItem: true,
+    updateItem: true,
+    comment: true,
+    labels: true,
+    assignees: true,
+    milestones: true,
+    board: false,
+    boardStatus: false,
+    draftItems: false,
+    webhooks: false,
+};
+export function githubWorkTrackerCapabilitiesForConfig(config) {
+    const board = githubProjectV2BoardConfig(config);
+    const statusOptions = board?.statusOptions ?? {};
+    return {
+        ...githubWorkTrackerCapabilities,
+        board: Boolean(board),
+        boardStatus: Boolean(board?.statusFieldId && Object.keys(statusOptions).length > 0),
+    };
+}
+export function createGitHubWorkTrackerProvider(options) {
+    return new GitHubWorkTrackerProvider(options);
+}
+export class GitHubWorkTrackerProvider {
+    provider = "github";
+    capabilities;
+    config;
+    fetchFn;
+    apiBaseUrl;
+    graphqlApiUrl;
+    apiVersion;
+    staticAuthorizationHeader;
+    credentialRunner;
+    credentialInteractive;
+    credentialAuthorizationHeader;
+    constructor(options) {
+        this.config = options.config;
+        this.fetchFn = options.fetch ?? fetch;
+        this.apiBaseUrl = normalizeGitHubApiBaseUrl(options.apiBaseUrl ?? options.config.host);
+        this.graphqlApiUrl = normalizeGitHubGraphQLApiUrl(options.graphqlApiUrl ?? options.config.host);
+        this.apiVersion = requiredNonEmptyString(options.apiVersion ?? defaultGitHubApiVersion, "apiVersion");
+        this.capabilities = githubWorkTrackerCapabilitiesForConfig(options.config);
+        const token = optionalNonEmptyString(options.token, "token") ??
+            optionalNonEmptyString((options.env ?? process.env).GITHUB_TOKEN, "GITHUB_TOKEN") ??
+            optionalNonEmptyString((options.env ?? process.env).GH_TOKEN, "GH_TOKEN");
+        this.staticAuthorizationHeader = token ? `Bearer ${token}` : undefined;
+        this.credentialRunner =
+            options.credentialRunner === false
+                ? undefined
+                : options.credentialRunner ?? defaultGitCredentialRunner;
+        this.credentialInteractive = options.credentialInteractive ?? false;
+    }
+    async createWorkItem(input) {
+        const status = input.status ?? "todo";
+        assertWorkStatus(status);
+        const created = await this.requestJson("POST", this.issuePath(), {
+            title: requiredNonEmptyString(input.title, "title"),
+            ...(input.description !== undefined ? { body: input.description } : {}),
+            ...requestArray("labels", labelsWithStatus(input.labels, status)),
+            ...requestArray("assignees", normalizeStringArray(input.assignees, "assignees")),
+            ...requestMilestone(input.milestone),
+        });
+        if (closedStatuses.has(status)) {
+            return this.updateWorkItem({ id: String(created.number) }, { status });
+        }
+        await this.addIssueToConfiguredProject(created, status);
+        return this.issueToWorkItem(created);
+    }
+    async listWorkItems(query = {}) {
+        const statuses = normalizeStatusFilter(query.status);
+        const state = githubStateForQuery(statuses);
+        const limit = normalizeLimit(query.limit);
+        const params = new URLSearchParams({
+            state,
+            per_page: String(limit ? Math.min(Math.max(limit, 1), 100) : 100),
+            page: "1",
+        });
+        const labels = normalizeStringArray(query.labels, "labels");
+        if (labels.length > 0) {
+            params.set("labels", labels.join(","));
+        }
+        const assignees = normalizeStringArray(query.assignees, "assignees");
+        if (assignees.length === 1) {
+            params.set("assignee", assignees[0]);
+        }
+        const issues = await this.requestJson("GET", `${this.issuePath()}?${params.toString()}`);
+        const search = query.search?.trim().toLowerCase();
+        const items = issues
+            .filter((issue) => !issue.pull_request)
+            .map((issue) => this.issueToWorkItem(issue))
+            .filter((item) => matchesStatusFilter(item, statuses))
+            .filter((item) => matchesStringFilter(item.assignees, assignees))
+            .filter((item) => !search || matchesSearch(item, search));
+        return limit === undefined ? items : items.slice(0, limit);
+    }
+    async getWorkItem(ref) {
+        return this.issueToWorkItem(await this.getIssue(ref));
+    }
+    async updateWorkItem(ref, patch) {
+        const issueNumber = issueNumberFromRef(ref);
+        const body = {};
+        if (patch.title !== undefined) {
+            body.title = requiredNonEmptyString(patch.title, "title");
+        }
+        if (patch.description !== undefined) {
+            body.body = patch.description;
+        }
+        if (patch.assignees !== undefined) {
+            body.assignees = normalizeStringArray(patch.assignees, "assignees");
+        }
+        if (patch.milestone !== undefined) {
+            Object.assign(body, requestMilestone(patch.milestone));
+        }
+        if (patch.status !== undefined) {
+            assertWorkStatus(patch.status);
+            body.state = githubStateForStatus(patch.status);
+            if (closedStatuses.has(patch.status)) {
+                body.state_reason =
+                    patch.status === "wont_do" ? "not_planned" : "completed";
+            }
+        }
+        if (patch.labels !== undefined || patch.status !== undefined) {
+            const baseLabels = patch.labels !== undefined
+                ? normalizeStringArray(patch.labels, "labels")
+                : labelNames(await this.getIssue(ref));
+            body.labels = labelsWithStatus(baseLabels, patch.status);
+        }
+        const updated = await this.requestJson("PATCH", `${this.issuePath()}/${issueNumber}`, body);
+        if (patch.status !== undefined) {
+            await this.addIssueToConfiguredProject(updated, patch.status);
+        }
+        return this.issueToWorkItem(updated);
+    }
+    async addComment(ref, body) {
+        const issueNumber = issueNumberFromRef(ref);
+        const comment = await this.requestJson("POST", `${this.issuePath()}/${issueNumber}/comments`, {
+            body: requiredNonEmptyString(body, "body"),
+        });
+        return this.commentToWorkComment(comment, issueNumber);
+    }
+    async setStatus(ref, status) {
+        return this.updateWorkItem(ref, { status });
+    }
+    async getIssue(ref) {
+        const issueNumber = issueNumberFromRef(ref);
+        return this.requestJson("GET", `${this.issuePath()}/${issueNumber}`);
+    }
+    async addIssueToConfiguredProject(issue, status) {
+        const board = githubProjectV2BoardConfig(this.config);
+        if (!board) {
+            return undefined;
+        }
+        const contentId = requiredNonEmptyString(issue.node_id, "issue.node_id");
+        const addResult = await this.graphql(`mutation AddIssueToProject($projectId: ID!, $contentId: ID!) {
+        addProjectV2ItemById(input: {projectId: $projectId, contentId: $contentId}) {
+          item {
+            id
+          }
+        }
+      }`, {
+            projectId: board.projectId,
+            contentId,
+        });
+        const itemId = requiredNonEmptyString(addResult.addProjectV2ItemById.item.id, "addProjectV2ItemById.item.id");
+        const statusOptionId = status ? board.statusOptions?.[status] : undefined;
+        if (board.statusFieldId && statusOptionId) {
+            await this.graphql(`mutation UpdateProjectItemStatus(
+          $projectId: ID!
+          $itemId: ID!
+          $fieldId: ID!
+          $optionId: String!
+        ) {
+          updateProjectV2ItemFieldValue(
+            input: {
+              projectId: $projectId
+              itemId: $itemId
+              fieldId: $fieldId
+              value: { singleSelectOptionId: $optionId }
+            }
+          ) {
+            projectV2Item {
+              id
+            }
+          }
+        }`, {
+                projectId: board.projectId,
+                itemId,
+                fieldId: board.statusFieldId,
+                optionId: statusOptionId,
+            });
+        }
+        return itemId;
+    }
+    issuePath() {
+        return `/repos/${encodePathSegment(this.config.repository.owner)}/${encodePathSegment(this.config.repository.name)}/issues`;
+    }
+    async requestJson(method, pathAndQuery, body) {
+        const url = new URL(pathAndQuery.replace(/^\/+/, ""), `${this.apiBaseUrl}/`);
+        const headers = {
+            Accept: "application/vnd.github+json",
+            "User-Agent": "dev-nexus",
+            "X-GitHub-Api-Version": this.apiVersion,
+        };
+        if (body !== undefined) {
+            headers["Content-Type"] = "application/json";
+        }
+        const authorizationHeader = this.authorizationHeader();
+        if (authorizationHeader) {
+            headers.Authorization = authorizationHeader;
+        }
+        const response = await this.fetchFn(url, {
+            method,
+            headers,
+            ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
+        });
+        if (!response.ok) {
+            const message = await githubErrorMessage(response, method, url);
+            throw new GitHubWorkTrackerProviderError(gitHubErrorMessageWithCredentialHint(message, response, authorizationHeader, this.config));
+        }
+        return (await response.json());
+    }
+    async graphql(query, variables) {
+        const headers = {
+            Accept: "application/vnd.github+json",
+            "Content-Type": "application/json",
+            "User-Agent": "dev-nexus",
+            "X-GitHub-Api-Version": this.apiVersion,
+        };
+        const authorizationHeader = this.authorizationHeader();
+        if (authorizationHeader) {
+            headers.Authorization = authorizationHeader;
+        }
+        const response = await this.fetchFn(this.graphqlApiUrl, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({ query, variables }),
+        });
+        if (!response.ok) {
+            const message = await githubErrorMessage(response, "POST", new URL(this.graphqlApiUrl));
+            throw new GitHubWorkTrackerProviderError(gitHubErrorMessageWithCredentialHint(message, response, authorizationHeader, this.config));
+        }
+        const payload = (await response.json());
+        if (payload.errors?.length) {
+            throw new GitHubWorkTrackerProviderError(`GitHub GraphQL request failed: ${payload.errors
+                .map((error) => error.message ?? "unknown error")
+                .join("; ")}`);
+        }
+        if (!payload.data) {
+            throw new GitHubWorkTrackerProviderError("GitHub GraphQL response did not include data");
+        }
+        return payload.data;
+    }
+    issueToWorkItem(issue) {
+        return {
+            id: `github-${issue.number}`,
+            title: requiredNonEmptyString(issue.title, "issue.title"),
+            description: issue.body ?? null,
+            status: workStatusFromIssue(issue),
+            provider: "github",
+            labels: userLabelNames(issue),
+            assignees: assigneeLogins(issue),
+            milestone: issue.milestone?.title ?? null,
+            createdAt: issue.created_at ?? null,
+            updatedAt: issue.updated_at ?? null,
+            closedAt: issue.closed_at ?? null,
+            webUrl: issue.html_url ?? null,
+            externalRef: this.issueExternalRef(issue),
+        };
+    }
+    commentToWorkComment(comment, issueNumber) {
+        return {
+            id: `github-comment-${comment.id}`,
+            body: comment.body ?? "",
+            author: comment.user?.login ?? null,
+            createdAt: comment.created_at ?? null,
+            updatedAt: comment.updated_at ?? null,
+            externalRef: {
+                provider: "github",
+                host: this.config.host ?? null,
+                repositoryOwner: this.config.repository.owner,
+                repositoryName: this.config.repository.name,
+                itemId: String(comment.id),
+                itemNumber: issueNumber,
+                nodeId: comment.node_id ?? null,
+                webUrl: comment.html_url ?? null,
+            },
+        };
+    }
+    issueExternalRef(issue) {
+        return {
+            provider: "github",
+            host: this.config.host ?? null,
+            repositoryOwner: this.config.repository.owner,
+            repositoryName: this.config.repository.name,
+            itemId: String(issue.number),
+            itemNumber: issue.number,
+            nodeId: issue.node_id ?? null,
+            webUrl: issue.html_url ?? null,
+        };
+    }
+    authorizationHeader() {
+        if (this.staticAuthorizationHeader) {
+            return this.staticAuthorizationHeader;
+        }
+        if (this.credentialAuthorizationHeader !== undefined) {
+            return this.credentialAuthorizationHeader ?? undefined;
+        }
+        if (!this.credentialRunner) {
+            this.credentialAuthorizationHeader = null;
+            return undefined;
+        }
+        const credential = fillGitCredential(this.credentialRunner, githubCredentialRequest(this.config), { interactive: this.credentialInteractive });
+        this.credentialAuthorizationHeader = credential
+            ? authorizationHeaderFromCredential(credential)
+            : null;
+        return this.credentialAuthorizationHeader ?? undefined;
+    }
+}
+export function normalizeGitHubApiBaseUrl(hostOrApiBaseUrl) {
+    const value = hostOrApiBaseUrl?.trim();
+    if (!value || value === "github.com" || value === "https://github.com") {
+        return defaultGitHubApiBaseUrl;
+    }
+    if (value === "api.github.com" || value === "https://api.github.com") {
+        return defaultGitHubApiBaseUrl;
+    }
+    if (value.startsWith("http://") || value.startsWith("https://")) {
+        return value.replace(/\/+$/, "");
+    }
+    return `https://${value.replace(/\/+$/, "")}/api/v3`;
+}
+export function normalizeGitHubGraphQLApiUrl(hostOrApiBaseUrl) {
+    const value = hostOrApiBaseUrl?.trim();
+    if (!value ||
+        value === "github.com" ||
+        value === "https://github.com" ||
+        value === "api.github.com" ||
+        value === "https://api.github.com") {
+        return "https://api.github.com/graphql";
+    }
+    const url = value.startsWith("http://") || value.startsWith("https://")
+        ? new URL(value)
+        : new URL(`https://${value}`);
+    if (url.hostname === "api.github.com") {
+        return "https://api.github.com/graphql";
+    }
+    if (url.pathname.endsWith("/api/graphql") || url.pathname.endsWith("/graphql")) {
+        return url.toString().replace(/\/+$/, "");
+    }
+    return `${url.protocol}//${url.host}/api/graphql`;
+}
+export function githubCredentialRequest(config) {
+    const host = normalizeGitHubCredentialHost(config.host);
+    return {
+        protocol: "https",
+        host,
+        path: `${config.repository.owner}/${config.repository.name}.git`,
+    };
+}
+export function normalizeGitHubCredentialHost(hostOrApiBaseUrl) {
+    const value = hostOrApiBaseUrl?.trim();
+    if (!value || value === "github.com" || value === "https://github.com") {
+        return "github.com";
+    }
+    if (value === "api.github.com" || value === "https://api.github.com") {
+        return "github.com";
+    }
+    const url = value.startsWith("http://") || value.startsWith("https://")
+        ? new URL(value)
+        : new URL(`https://${value}`);
+    return url.host;
+}
+function githubProjectV2BoardConfig(config) {
+    const board = config.board;
+    if (!board || board.kind !== "github-project-v2") {
+        return undefined;
+    }
+    const projectId = optionalNonEmptyString(board.projectId ?? board.id, "board.projectId");
+    if (!projectId) {
+        return undefined;
+    }
+    const statusFieldId = optionalNonEmptyString(board.statusFieldId, "board.statusFieldId") ??
+        undefined;
+    return {
+        projectId,
+        ...(statusFieldId ? { statusFieldId } : {}),
+        ...(board.statusOptions ? { statusOptions: board.statusOptions } : {}),
+    };
+}
+export function defaultGitCredentialRunner(request, options) {
+    const result = spawnSync("git", ["credential", "fill"], {
+        input: gitCredentialInput(request),
+        encoding: "utf8",
+        env: {
+            ...process.env,
+            ...(options.interactive
+                ? {}
+                : {
+                    GCM_INTERACTIVE: "0",
+                    GIT_TERMINAL_PROMPT: "0",
+                }),
+        },
+    });
+    return {
+        status: result.status,
+        stdout: result.stdout ?? "",
+        stderr: result.stderr ?? "",
+        ...(result.error ? { error: result.error } : {}),
+    };
+}
+function fillGitCredential(runner, request, options) {
+    const result = runner(request, options);
+    if (result.status !== 0 || result.error) {
+        return undefined;
+    }
+    const credential = parseGitCredentialOutput(result.stdout);
+    return credential.password || (credential.authtype && credential.credential)
+        ? credential
+        : undefined;
+}
+function authorizationHeaderFromCredential(credential) {
+    const authtype = optionalNonEmptyString(credential.authtype, "authtype");
+    const encodedCredential = optionalNonEmptyString(credential.credential, "credential");
+    if (authtype && encodedCredential) {
+        return `${authtype} ${encodedCredential}`;
+    }
+    const password = optionalNonEmptyString(credential.password, "password");
+    return password ? `Bearer ${password}` : undefined;
+}
+function gitCredentialInput(request) {
+    return [
+        `protocol=${request.protocol}`,
+        `host=${request.host}`,
+        ...(request.path ? [`path=${request.path}`] : []),
+        "",
+    ].join("\n");
+}
+function parseGitCredentialOutput(output) {
+    const credential = {};
+    for (const line of output.split(/\r?\n/)) {
+        if (line.length === 0) {
+            continue;
+        }
+        const separator = line.indexOf("=");
+        if (separator <= 0) {
+            continue;
+        }
+        credential[line.slice(0, separator)] = line.slice(separator + 1);
+    }
+    return credential;
+}
+function workStatusFromIssue(issue) {
+    if (issue.state === "closed") {
+        return issue.state_reason === "not_planned" ? "wont_do" : "done";
+    }
+    const statusLabel = labelNames(issue).find((label) => label.startsWith(githubStatusLabelPrefix));
+    if (!statusLabel) {
+        return "todo";
+    }
+    const candidate = statusLabel.slice(githubStatusLabelPrefix.length);
+    return workStatuses.has(candidate)
+        ? candidate
+        : "todo";
+}
+function githubStateForStatus(status) {
+    assertWorkStatus(status);
+    return closedStatuses.has(status) ? "closed" : "open";
+}
+function githubStateForQuery(statuses) {
+    if (!statuses || statuses.size === 0) {
+        return "all";
+    }
+    let hasOpen = false;
+    let hasClosed = false;
+    for (const status of statuses) {
+        hasOpen ||= openStatuses.has(status);
+        hasClosed ||= closedStatuses.has(status);
+    }
+    return hasOpen && hasClosed ? "all" : hasClosed ? "closed" : "open";
+}
+function labelsWithStatus(labels, status) {
+    const normalized = normalizeStringArray(labels, "labels").filter((label) => !label.startsWith(githubStatusLabelPrefix));
+    if (status && openStatuses.has(status) && status !== "todo") {
+        normalized.push(`${githubStatusLabelPrefix}${status}`);
+    }
+    return dedupeStrings(normalized);
+}
+function userLabelNames(issue) {
+    return labelNames(issue).filter((label) => !label.startsWith(githubStatusLabelPrefix));
+}
+function labelNames(issue) {
+    return (issue.labels ?? [])
+        .map((label) => (typeof label === "string" ? label : label.name))
+        .filter((label) => Boolean(label && label.trim()))
+        .map((label) => label.trim());
+}
+function assigneeLogins(issue) {
+    return (issue.assignees ?? [])
+        .map((assignee) => assignee.login)
+        .filter((login) => Boolean(login && login.trim()))
+        .map((login) => login.trim());
+}
+function issueNumberFromRef(ref) {
+    if (ref.provider && ref.provider !== "github") {
+        throw new GitHubWorkTrackerProviderError(`github provider cannot resolve ${ref.provider} work item refs`);
+    }
+    if (ref.externalRef?.provider && ref.externalRef.provider !== "github") {
+        throw new GitHubWorkTrackerProviderError(`github provider cannot resolve ${ref.externalRef.provider} external refs`);
+    }
+    const candidate = ref.externalRef?.itemNumber ??
+        ref.id ??
+        ref.externalRef?.itemId;
+    if (candidate === undefined || candidate === null) {
+        throw new GitHubWorkTrackerProviderError("GitHub issue number is required");
+    }
+    if (typeof candidate === "number") {
+        return positiveInteger(candidate, "issue number");
+    }
+    const normalized = candidate.trim().replace(/^github-/, "");
+    return positiveInteger(Number(normalized), "issue number");
+}
+function normalizeStatusFilter(status) {
+    if (status === undefined) {
+        return undefined;
+    }
+    const values = Array.isArray(status) ? status : [status];
+    const normalized = new Set();
+    for (const value of values) {
+        assertWorkStatus(value);
+        normalized.add(value);
+    }
+    return normalized;
+}
+function matchesStatusFilter(item, statuses) {
+    return !statuses || statuses.size === 0 || statuses.has(item.status);
+}
+function matchesStringFilter(itemValues, requiredValues) {
+    return requiredValues.every((value) => itemValues?.includes(value));
+}
+function matchesSearch(item, search) {
+    return [item.id, item.title, item.description ?? ""].some((value) => value.toLowerCase().includes(search));
+}
+function requestArray(key, values) {
+    return values.length > 0 ? { [key]: values } : {};
+}
+function requestMilestone(value) {
+    if (value === undefined) {
+        return {};
+    }
+    if (value === null) {
+        return { milestone: null };
+    }
+    const normalized = requiredNonEmptyString(value, "milestone");
+    const numeric = Number(normalized);
+    return Number.isInteger(numeric) && numeric > 0
+        ? { milestone: numeric }
+        : { milestone: normalized };
+}
+function normalizeLimit(limit) {
+    if (limit === undefined) {
+        return undefined;
+    }
+    if (!Number.isInteger(limit) || limit < 0) {
+        throw new GitHubWorkTrackerProviderError("limit must be a non-negative integer");
+    }
+    return limit;
+}
+function normalizeStringArray(values, pathName) {
+    if (values === undefined) {
+        return [];
+    }
+    if (!Array.isArray(values)) {
+        throw new GitHubWorkTrackerProviderError(`${pathName} must be an array`);
+    }
+    return dedupeStrings(values.map((value, index) => requiredNonEmptyString(value, `${pathName}[${index}]`)));
+}
+function dedupeStrings(values) {
+    const seen = new Set();
+    const result = [];
+    for (const value of values) {
+        if (!seen.has(value)) {
+            seen.add(value);
+            result.push(value);
+        }
+    }
+    return result;
+}
+function assertWorkStatus(status) {
+    if (!workStatuses.has(status)) {
+        throw new GitHubWorkTrackerProviderError(`Invalid work status: ${status}`);
+    }
+}
+function positiveInteger(value, pathName) {
+    if (!Number.isInteger(value) || value < 1) {
+        throw new GitHubWorkTrackerProviderError(`${pathName} must be a positive integer`);
+    }
+    return value;
+}
+function requiredNonEmptyString(value, pathName) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new GitHubWorkTrackerProviderError(`${pathName} must be a non-empty string`);
+    }
+    return value.trim();
+}
+function optionalNonEmptyString(value, pathName) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (value.trim().length === 0) {
+        return undefined;
+    }
+    return requiredNonEmptyString(value, pathName);
+}
+function encodePathSegment(value) {
+    return encodeURIComponent(requiredNonEmptyString(value, "path segment"));
+}
+async function githubErrorMessage(response, method, url) {
+    let detail;
+    try {
+        const body = (await response.json());
+        detail = body.message;
+    }
+    catch {
+        detail = await response.text().catch(() => undefined);
+    }
+    return [
+        `GitHub request failed: ${method} ${url.pathname} returned ${response.status}`,
+        detail ? `: ${detail}` : "",
+    ].join("");
+}
+function gitHubErrorMessageWithCredentialHint(message, response, authorizationHeader, config) {
+    if (authorizationHeader ||
+        (response.status !== 401 && response.status !== 403)) {
+        return message;
+    }
+    return (`${message}. No GitHub token or git credential was available for ` +
+        `${normalizeGitHubCredentialHost(config.host)}. Configure GITHUB_TOKEN, ` +
+        "GH_TOKEN, or a git credential helper.");
+}