wehub-resource-sync
571 lines
18 KiB
JavaScript
571 lines
18 KiB
JavaScript
#!/usr/bin/env node
|
|
import fs from "node:fs";
|
|
|
|
const LABEL_PREFIX = "db/";
|
|
const USER_PRIORITY_PREFIX = "user-priority/";
|
|
const API_VERSION = "2022-11-28";
|
|
const dryRun = process.env.DRY_RUN === "1" || process.env.DRY_RUN === "true";
|
|
|
|
const USER_PRIORITY_LABELS = {
|
|
P0: { color: "b60205", description: "User-reported priority: urgent" },
|
|
P1: { color: "d93f0b", description: "User-reported priority: important" },
|
|
P2: { color: "fbca04", description: "User-reported priority: normal" },
|
|
P3: { color: "bfd4f2", description: "User-reported priority: low" },
|
|
};
|
|
|
|
const LABEL_PALETTE = [
|
|
"0e8a16",
|
|
"1d76db",
|
|
"5319e7",
|
|
"c2e0c6",
|
|
"bfd4f2",
|
|
"d4c5f9",
|
|
"fef2c0",
|
|
"fbca04",
|
|
"f9d0c4",
|
|
"e99695",
|
|
"f29513",
|
|
"c5def5",
|
|
];
|
|
|
|
const extraAliases = {
|
|
mysql: ["mariadb", "percona", "tidb"],
|
|
postgres: ["postgresql", "postgres", "pgsql", "pg", "hologres"],
|
|
sqlite: ["sqlite3", "sql lite"],
|
|
clickhouse: ["click house", "ch"],
|
|
sqlserver: ["sql server", "mssql", "microsoft sql server", "sqlservice"],
|
|
mongodb: ["mongo", "mongodb"],
|
|
oracle: ["oracle database"],
|
|
elasticsearch: ["elastic search"],
|
|
chromadb: ["chroma"],
|
|
manticoresearch: ["manticore"],
|
|
dameng: ["dm8", "dameng", "达梦"],
|
|
kingbase: ["kingbasees", "kingbase", "人大金仓", "金仓"],
|
|
highgo: ["瀚高"],
|
|
yashandb: ["yashan", "崖山"],
|
|
saphana: ["hana", "sap hana"],
|
|
opengauss: ["open gauss"],
|
|
"oceanbase-oracle": ["oceanbase", "oceanbase oracle"],
|
|
gbase: ["gbase 8a", "gbase8a", "gbase 8s", "gbase8s"],
|
|
access: ["microsoft access", "ms access"],
|
|
vastbase: ["vastbase g", "vastbaseg"],
|
|
prestosql: ["presto", "presto sql"],
|
|
hive: ["apache hive"],
|
|
db2: ["ibm db2"],
|
|
informix: ["ibm informix"],
|
|
bigquery: ["google bigquery"],
|
|
kylin: ["apache kylin"],
|
|
oscar: ["shentong", "oscar", "神通"],
|
|
xugu: ["xugudb", "xugu", "虚谷"],
|
|
zookeeper: ["zoo keeper", "apache zookeeper"],
|
|
mq: ["message queue", "kafka", "rabbitmq", "rocketmq"],
|
|
iotdb: ["apache iotdb"],
|
|
iris: ["intersystems iris", "intersystems cache", "intersystems caché", "cache", "caché", "ensemble"],
|
|
spark: ["apache spark"],
|
|
};
|
|
|
|
const globallyAmbiguousAliases = new Set([
|
|
"access",
|
|
"ch",
|
|
"h2",
|
|
"iris",
|
|
"jdbc",
|
|
"mq",
|
|
"pg",
|
|
"spark",
|
|
]);
|
|
|
|
const genericDatabaseValues = [
|
|
"general",
|
|
"generic",
|
|
"global",
|
|
"all",
|
|
"any",
|
|
"none",
|
|
"n/a",
|
|
"na",
|
|
"通用",
|
|
"全部",
|
|
"所有",
|
|
"无",
|
|
"不适用",
|
|
];
|
|
|
|
const manifestUrl = new URL("../../crates/dbx-core/assets/database-drivers.manifest.json", import.meta.url);
|
|
const manifest = JSON.parse(fs.readFileSync(manifestUrl, "utf8"));
|
|
const drivers = manifest.drivers.map((driver) => ({
|
|
dbType: driver.dbType,
|
|
label: driver.label,
|
|
aliases: [...new Set([driver.dbType, driver.label, ...(extraAliases[driver.dbType] || [])])],
|
|
}));
|
|
const exactAsciiAliases = new Set(
|
|
drivers.flatMap((driver) => driver.aliases.map((alias) => compactAscii(alias)).filter((alias) => alias.length >= 5)),
|
|
);
|
|
|
|
function loadIssue() {
|
|
if (process.env.GITHUB_EVENT_PATH && fs.existsSync(process.env.GITHUB_EVENT_PATH)) {
|
|
const event = JSON.parse(fs.readFileSync(process.env.GITHUB_EVENT_PATH, "utf8"));
|
|
return event.issue || {};
|
|
}
|
|
|
|
return {
|
|
number: process.env.ISSUE_NUMBER,
|
|
title: process.env.ISSUE_TITLE || "",
|
|
body: process.env.ISSUE_BODY || "",
|
|
labels: process.env.ISSUE_LABELS ? JSON.parse(process.env.ISSUE_LABELS) : [],
|
|
};
|
|
}
|
|
|
|
function labelNames(labels) {
|
|
return (labels || []).map((label) => (typeof label === "string" ? label : label.name)).filter(Boolean);
|
|
}
|
|
|
|
function stablePaletteColor(value) {
|
|
let hash = 0;
|
|
for (const char of value) {
|
|
hash = (hash * 31 + char.codePointAt(0)) >>> 0;
|
|
}
|
|
return LABEL_PALETTE[hash % LABEL_PALETTE.length];
|
|
}
|
|
|
|
function extractIssueFormSection(body, predicate) {
|
|
const matches = [...String(body || "").matchAll(/^###\s+(.+?)\s*$/gm)];
|
|
for (const [index, match] of matches.entries()) {
|
|
const heading = match[1].trim();
|
|
if (!predicate(heading)) continue;
|
|
|
|
const start = match.index + match[0].length;
|
|
const end = matches[index + 1]?.index ?? body.length;
|
|
return body.slice(start, end).trim();
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
function extractDatabaseField(body) {
|
|
return extractIssueFormSection(body, (heading) => (
|
|
heading.includes("数据库类型") ||
|
|
heading.toLowerCase().includes("database type") ||
|
|
/^database$/i.test(heading)
|
|
));
|
|
}
|
|
|
|
function extractPriorityField(body) {
|
|
return extractIssueFormSection(body, (heading) => (
|
|
heading.includes("优先级") ||
|
|
heading.toLowerCase().includes("priority")
|
|
));
|
|
}
|
|
|
|
function extractTitleSummaryField(body) {
|
|
const headingPredicates = [
|
|
(heading) => heading.includes("问题描述") || heading.toLowerCase().includes("description"),
|
|
(heading) => heading.includes("当前痛点") || heading.toLowerCase().includes("problem"),
|
|
(heading) => heading.includes("期望方案") || heading.toLowerCase().includes("proposal"),
|
|
(heading) => heading === "描述" || heading.toLowerCase() === "description",
|
|
];
|
|
|
|
for (const predicate of headingPredicates) {
|
|
const section = extractIssueFormSection(body, predicate);
|
|
if (section) return section;
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
function matchPriorityLabel(value) {
|
|
const match = String(value || "").normalize("NFKC").match(/\bP([0-3])\b/i);
|
|
return match ? `P${match[1]}` : null;
|
|
}
|
|
|
|
function genericIssueTitlePrefix(title) {
|
|
const normalized = String(title || "").normalize("NFKC").trim().replace(/\s+/g, " ");
|
|
const bracketMatch = normalized.match(/^([\[【][^\]】]*(?:bug|feature|feat|compatibility|question)[^\]】]*[\]】])$/i);
|
|
if (bracketMatch) return bracketMatch[1];
|
|
|
|
const bareMatch = normalized.match(/^(bug|feature|feat|compatibility|question):?$/i);
|
|
if (!bareMatch) return null;
|
|
|
|
const normalizedPrefix = bareMatch[1].toLowerCase() === "feat" ? "Feat" : (
|
|
bareMatch[1].charAt(0).toUpperCase() + bareMatch[1].slice(1).toLowerCase()
|
|
);
|
|
return `[${normalizedPrefix}]`;
|
|
}
|
|
|
|
function cleanTitleSummaryLine(line) {
|
|
return String(line || "")
|
|
.replace(/<img\b[^>]*>/gi, "")
|
|
.replace(/<[^>]+>/g, "")
|
|
.replace(/^>\s*/, "")
|
|
.replace(/^[-*]\s+/, "")
|
|
.replace(/^\d+[.)、]\s*/, "")
|
|
.replace(/!\[[^\]]*?\]\([^)]*?\)/g, "")
|
|
.replace(/\[[^\]]*?\]\([^)]*?\)/g, "")
|
|
.replace(/[`*_~]/g, "")
|
|
.replace(/\s+/g, " ")
|
|
.trim();
|
|
}
|
|
|
|
function isSkippableTitleSummaryLine(line) {
|
|
return (
|
|
/^DBX debug log$/i.test(line) ||
|
|
/^(Exported|User agent|Platform|Timezone):/i.test(line) ||
|
|
/^(Native|Tauri) log dir:/i.test(line) ||
|
|
/^=+.*logs?.*=+$/i.test(line) ||
|
|
/^\[\d{4}-\d{2}-\d{2}(?:T|\])/.test(line) ||
|
|
/^\[(DEBUG|INFO|WARN|ERROR|LOG|STARTUP)\]/i.test(line)
|
|
);
|
|
}
|
|
|
|
function firstSentence(value) {
|
|
const withoutCodeBlocks = String(value || "").replace(/```[\s\S]*?```/g, "\n");
|
|
const lines = withoutCodeBlocks
|
|
.split(/\r?\n/)
|
|
.map(cleanTitleSummaryLine)
|
|
.filter((line) => !isSkippableTitleSummaryLine(line))
|
|
.filter((line) => /[\p{L}\p{N}\u3400-\u9fff]/u.test(line));
|
|
|
|
for (const line of lines) {
|
|
const sentenceMatch = line.match(/^(.{4,120}?[。！？!?]|.{12,120}?\.(?=\s|$))/u);
|
|
const sentence = (sentenceMatch ? sentenceMatch[1] : line)
|
|
.replace(/[。！？!?.]+$/u, "")
|
|
.trim();
|
|
if (sentence.length >= 4) {
|
|
return sentence.length > 90 ? `${sentence.slice(0, 89)}…` : sentence;
|
|
}
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
function inferIssueTitle(title, body) {
|
|
const prefix = genericIssueTitlePrefix(title);
|
|
if (!prefix) return null;
|
|
|
|
const summary = firstSentence(extractTitleSummaryField(body));
|
|
if (!summary) return null;
|
|
|
|
return `${prefix} ${summary}`;
|
|
}
|
|
|
|
function normalizeText(value) {
|
|
return String(value || "")
|
|
.normalize("NFKC")
|
|
.toLowerCase()
|
|
.replace(/[·，。；：、]/g, " ")
|
|
.replace(/\s+/g, " ")
|
|
.trim();
|
|
}
|
|
|
|
function containsCjk(value) {
|
|
return /[\u3400-\u9fff]/u.test(value);
|
|
}
|
|
|
|
function escapeRegExp(value) {
|
|
return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
|
|
}
|
|
|
|
function compactAscii(value) {
|
|
return normalizeText(value).replace(/[^a-z0-9]/g, "");
|
|
}
|
|
|
|
function levenshteinDistance(left, right) {
|
|
if (left === right) return 0;
|
|
if (!left) return right.length;
|
|
if (!right) return left.length;
|
|
|
|
let previous = Array.from({ length: right.length + 1 }, (_, index) => index);
|
|
for (let leftIndex = 0; leftIndex < left.length; leftIndex += 1) {
|
|
const current = [leftIndex + 1];
|
|
for (let rightIndex = 0; rightIndex < right.length; rightIndex += 1) {
|
|
const substitutionCost = left[leftIndex] === right[rightIndex] ? 0 : 1;
|
|
current[rightIndex + 1] = Math.min(
|
|
current[rightIndex] + 1,
|
|
previous[rightIndex + 1] + 1,
|
|
previous[rightIndex] + substitutionCost,
|
|
);
|
|
}
|
|
previous = current;
|
|
}
|
|
|
|
return previous[right.length];
|
|
}
|
|
|
|
function fuzzyThreshold(length) {
|
|
if (length < 6) return 0;
|
|
if (length <= 8) return 1;
|
|
return 2;
|
|
}
|
|
|
|
function candidateTokens(text) {
|
|
const normalized = normalizeText(text);
|
|
const tokens = new Set();
|
|
|
|
for (const match of normalized.matchAll(/[a-z][a-z0-9._-]*/g)) {
|
|
const compact = compactAscii(match[0]);
|
|
if (!compact) continue;
|
|
|
|
tokens.add(compact);
|
|
|
|
// User reports often write database names directly followed by versions,
|
|
// for example mysql5.7, Oracle19c, or postgresql18.
|
|
const withoutVersion = compact.replace(/(?:v?\d[\da-z.]*)$/i, "");
|
|
if (withoutVersion && withoutVersion !== compact) tokens.add(withoutVersion);
|
|
}
|
|
|
|
return [...tokens].filter((token) => token.length >= 5);
|
|
}
|
|
|
|
function fuzzyAliasMatches(text, alias) {
|
|
const normalizedAlias = normalizeText(alias);
|
|
if (containsCjk(normalizedAlias)) return false;
|
|
if (globallyAmbiguousAliases.has(normalizedAlias)) return false;
|
|
|
|
const compactAlias = compactAscii(normalizedAlias);
|
|
const threshold = fuzzyThreshold(compactAlias.length);
|
|
if (!threshold) return false;
|
|
|
|
return candidateTokens(text).some((token) => {
|
|
if (token !== compactAlias && exactAsciiAliases.has(token)) return false;
|
|
if (Math.abs(token.length - compactAlias.length) > threshold) return false;
|
|
return levenshteinDistance(token, compactAlias) <= threshold;
|
|
});
|
|
}
|
|
|
|
function aliasMatches(text, alias) {
|
|
const normalizedText = normalizeText(text);
|
|
const normalizedAlias = normalizeText(alias);
|
|
if (!normalizedAlias) return false;
|
|
|
|
if (containsCjk(normalizedAlias)) {
|
|
return normalizedText.includes(normalizedAlias);
|
|
}
|
|
|
|
const flexibleAlias = normalizedAlias
|
|
.split(/[\s._/-]+/)
|
|
.filter(Boolean)
|
|
.map(escapeRegExp)
|
|
.join("[\\s._/-]*");
|
|
const trailingBoundary = /[0-9]$/.test(normalizedAlias)
|
|
? "(?:[^a-z0-9]|$)"
|
|
: "(?:[^a-z0-9]|$|(?=v?\\d))";
|
|
const pattern = new RegExp(`(^|[^a-z0-9])${flexibleAlias}${trailingBoundary}`, "i");
|
|
return pattern.test(normalizedText);
|
|
}
|
|
|
|
function isGenericDatabaseValue(value) {
|
|
const normalized = normalizeText(value);
|
|
const parts = normalized
|
|
.split(/[,\n/|;，、]+/)
|
|
.map((part) => part.trim())
|
|
.filter(Boolean);
|
|
|
|
return (
|
|
parts.length > 0 &&
|
|
parts.every((part) => genericDatabaseValues.some((generic) => aliasMatches(part, generic)))
|
|
);
|
|
}
|
|
|
|
function matchDrivers(text, { allowAmbiguous }) {
|
|
const matches = [];
|
|
|
|
for (const driver of drivers) {
|
|
const matchedAlias = driver.aliases.find((alias) => {
|
|
const normalizedAlias = normalizeText(alias);
|
|
if (!allowAmbiguous && globallyAmbiguousAliases.has(normalizedAlias)) return false;
|
|
return aliasMatches(text, alias) || fuzzyAliasMatches(text, alias);
|
|
});
|
|
|
|
if (matchedAlias) {
|
|
matches.push({ ...driver, matchedAlias });
|
|
}
|
|
}
|
|
|
|
return matches;
|
|
}
|
|
|
|
function uniqueByDbType(matches) {
|
|
const seen = new Set();
|
|
return matches.filter((match) => {
|
|
if (seen.has(match.dbType)) return false;
|
|
seen.add(match.dbType);
|
|
return true;
|
|
});
|
|
}
|
|
|
|
async function githubRequest(method, path, body) {
|
|
const token = process.env.GITHUB_TOKEN;
|
|
const repository = process.env.GITHUB_REPOSITORY;
|
|
if (!token) throw new Error("GITHUB_TOKEN is required");
|
|
if (!repository) throw new Error("GITHUB_REPOSITORY is required");
|
|
|
|
const response = await fetch(`https://api.github.com/repos/${repository}${path}`, {
|
|
method,
|
|
headers: {
|
|
Accept: "application/vnd.github+json",
|
|
Authorization: `Bearer ${token}`,
|
|
"Content-Type": "application/json",
|
|
"X-GitHub-Api-Version": API_VERSION,
|
|
},
|
|
body: body ? JSON.stringify(body) : undefined,
|
|
});
|
|
|
|
const text = await response.text();
|
|
const payload = text ? JSON.parse(text) : null;
|
|
if (!response.ok) {
|
|
const message = payload?.message || response.statusText;
|
|
const error = new Error(`${method} ${path} failed: ${response.status} ${message}`);
|
|
error.status = response.status;
|
|
error.payload = payload;
|
|
throw error;
|
|
}
|
|
return payload;
|
|
}
|
|
|
|
async function ensureLabel(name, description, color) {
|
|
try {
|
|
const dbType = name.startsWith(LABEL_PREFIX) ? name.slice(LABEL_PREFIX.length) : name;
|
|
await githubRequest("POST", "/labels", { name, color: color || stablePaletteColor(dbType), description });
|
|
console.log(`Created label ${name}`);
|
|
} catch (error) {
|
|
// GitHub returns 422 when the label already exists; that is the common path
|
|
// after the first issue for a database type has been triaged.
|
|
if (error.status === 422) {
|
|
console.log(`Label ${name} already exists`);
|
|
return;
|
|
}
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
async function addLabels(issueNumber, names) {
|
|
await githubRequest("POST", `/issues/${issueNumber}/labels`, { labels: names });
|
|
}
|
|
|
|
async function removeLabel(issueNumber, name) {
|
|
try {
|
|
await githubRequest("DELETE", `/issues/${issueNumber}/labels/${encodeURIComponent(name)}`);
|
|
console.log(`Removed stale label ${name}`);
|
|
} catch (error) {
|
|
if (error.status === 404) return;
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
async function updateIssueTitle(issueNumber, title) {
|
|
await githubRequest("PATCH", `/issues/${issueNumber}`, { title });
|
|
}
|
|
|
|
const issue = loadIssue();
|
|
if (issue.pull_request) {
|
|
console.log("Skipping pull request event");
|
|
process.exit(0);
|
|
}
|
|
|
|
if (!issue.number) {
|
|
throw new Error("Issue number is required");
|
|
}
|
|
|
|
const databaseField = extractDatabaseField(issue.body || "");
|
|
const hasDatabaseField = databaseField.length > 0;
|
|
const fieldIsGeneric = hasDatabaseField && isGenericDatabaseValue(databaseField);
|
|
// Free-form bodies often mention comparison databases or examples; the title
|
|
// and issue-form database field are the reliable labeling sources.
|
|
const sourceText = hasDatabaseField ? databaseField : issue.title || "";
|
|
const matchedDrivers = isGenericDatabaseValue(sourceText)
|
|
? []
|
|
: uniqueByDbType(matchDrivers(sourceText, { allowAmbiguous: hasDatabaseField }));
|
|
const titleMatchedDrivers = uniqueByDbType(matchDrivers(issue.title || "", { allowAmbiguous: false }));
|
|
if (hasDatabaseField && titleMatchedDrivers.length > 0) {
|
|
matchedDrivers.push(...titleMatchedDrivers);
|
|
}
|
|
if (hasDatabaseField && matchedDrivers.length === 0 && !fieldIsGeneric) {
|
|
// Some issue forms contain only a version in the database field and put the
|
|
// actual database name in the title; keep that fallback conservative.
|
|
matchedDrivers.push(
|
|
...uniqueByDbType(matchDrivers(`${issue.title || ""}\n${databaseField}`, { allowAmbiguous: false })),
|
|
);
|
|
}
|
|
const uniqueMatchedDrivers = uniqueByDbType(matchedDrivers);
|
|
const targetLabels = uniqueMatchedDrivers.map((driver) => `${LABEL_PREFIX}${driver.dbType}`);
|
|
const targetLabelColors = Object.fromEntries(
|
|
uniqueMatchedDrivers.map((driver) => [`${LABEL_PREFIX}${driver.dbType}`, stablePaletteColor(driver.dbType)]),
|
|
);
|
|
const priorityField = extractPriorityField(issue.body || "");
|
|
const targetPriorityValue = matchPriorityLabel(priorityField);
|
|
const targetPriorityLabel = targetPriorityValue ? `${USER_PRIORITY_PREFIX}${targetPriorityValue}` : null;
|
|
if (targetPriorityValue) {
|
|
targetLabelColors[targetPriorityLabel] = USER_PRIORITY_LABELS[targetPriorityValue].color;
|
|
}
|
|
const existingLabels = labelNames(issue.labels);
|
|
const titleToUpdate = inferIssueTitle(issue.title || "", issue.body || "");
|
|
const existingDatabaseLabels = existingLabels.filter((name) => name.startsWith(LABEL_PREFIX));
|
|
const staleDatabaseLabels = hasDatabaseField
|
|
? existingDatabaseLabels.filter((name) => !targetLabels.includes(name))
|
|
: [];
|
|
const existingPriorityLabels = existingLabels.filter((name) => name.startsWith(USER_PRIORITY_PREFIX));
|
|
const stalePriorityLabels = targetPriorityLabel
|
|
? existingPriorityLabels.filter((name) => name !== targetPriorityLabel)
|
|
: [];
|
|
const labelsToAdd = [...targetLabels, targetPriorityLabel].filter(Boolean).filter((name) => !existingLabels.includes(name));
|
|
const labelSpecs = [
|
|
...uniqueMatchedDrivers.map((driver) => ({
|
|
name: `${LABEL_PREFIX}${driver.dbType}`,
|
|
description: `Database: ${driver.label}`,
|
|
color: stablePaletteColor(driver.dbType),
|
|
})),
|
|
...(targetPriorityValue
|
|
? [{ name: targetPriorityLabel, ...USER_PRIORITY_LABELS[targetPriorityValue] }]
|
|
: []),
|
|
];
|
|
|
|
console.log(
|
|
JSON.stringify(
|
|
{
|
|
issue: issue.number,
|
|
databaseField: hasDatabaseField ? databaseField : null,
|
|
titleMatched: titleMatchedDrivers.map(({ dbType, label, matchedAlias }) => ({ dbType, label, matchedAlias })),
|
|
matched: uniqueMatchedDrivers.map(({ dbType, label, matchedAlias }) => ({ dbType, label, matchedAlias })),
|
|
priorityField: priorityField || null,
|
|
priorityLabel: targetPriorityLabel,
|
|
priorityValue: targetPriorityValue,
|
|
titleToUpdate,
|
|
labelsToAdd,
|
|
targetLabelColors,
|
|
staleDatabaseLabels,
|
|
stalePriorityLabels,
|
|
},
|
|
null,
|
|
2,
|
|
),
|
|
);
|
|
|
|
if (dryRun) {
|
|
console.log("Dry run enabled; no GitHub API calls were made");
|
|
process.exit(0);
|
|
}
|
|
|
|
for (const labelSpec of labelSpecs) {
|
|
await ensureLabel(labelSpec.name, labelSpec.description, labelSpec.color);
|
|
}
|
|
|
|
if (labelsToAdd.length > 0) {
|
|
await addLabels(issue.number, labelsToAdd);
|
|
console.log(`Added labels: ${labelsToAdd.join(", ")}`);
|
|
} else {
|
|
console.log("No database labels to add");
|
|
}
|
|
|
|
for (const label of staleDatabaseLabels) {
|
|
await removeLabel(issue.number, label);
|
|
}
|
|
|
|
for (const label of stalePriorityLabels) {
|
|
await removeLabel(issue.number, label);
|
|
}
|
|
|
|
if (titleToUpdate) {
|
|
await updateIssueTitle(issue.number, titleToUpdate);
|
|
console.log(`Updated title: ${titleToUpdate}`);
|
|
}
|