@indigoai-us/hq-cli 5.267.0 → 5.269.0

package/dist/lib/lanes/merge-command.js

@@ -0,0 +1,363 @@
+import { LanesError } from "./errors.js";
+function fail(error, message, details = {}) {
+    throw new LanesError(error, message, details);
+}
+export function canonicalRepo(raw) {
+    const value = raw.trim();
+    const parts = value.split("/");
+    if (parts.length !== 2) {
+        return fail("repo_hold_repo_invalid", "Repository must be a safe owner/repo pair", { field: "repo" });
+    }
+    const [owner, repository] = parts;
+    if (!owner || !repository ||
+        !/^[A-Za-z0-9][A-Za-z0-9-]{0,38}$/.test(owner) ||
+        !/^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/.test(repository) ||
+        owner === "." || owner === ".." || repository === "." || repository === "..") {
+        return fail("repo_hold_repo_invalid", "Repository must be a safe owner/repo pair", { field: "repo" });
+    }
+    return `${owner.toLowerCase()}/${repository.toLowerCase()}`;
+}
+function splitCommandChain(command) {
+    const segments = [];
+    let current = "";
+    let quote = null;
+    let escaped = false;
+    for (let index = 0; index < command.length; index += 1) {
+        const character = command[index] ?? "";
+        if (escaped) {
+            current += character;
+            escaped = false;
+            continue;
+        }
+        if (character === "\\" && quote !== "'") {
+            current += character;
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            current += character;
+            if (character === quote)
+                quote = null;
+            continue;
+        }
+        if (character === "'" || character === "\"") {
+            quote = character;
+            current += character;
+            continue;
+        }
+        if (character === ";" || character === "|") {
+            segments.push(current.trim());
+            current = "";
+            if (character === "|" && command[index + 1] === "|")
+                index += 1;
+            continue;
+        }
+        if (character === "&" && command[index + 1] === "&") {
+            segments.push(current.trim());
+            current = "";
+            index += 1;
+            continue;
+        }
+        current += character;
+    }
+    if (quote !== null || escaped) {
+        return fail("repo_hold_command_invalid", "Command has an unclosed quote or escape");
+    }
+    segments.push(current.trim());
+    return segments.filter(Boolean);
+}
+function shellWords(segment) {
+    const words = [];
+    let current = "";
+    let quote = null;
+    let escaped = false;
+    for (const character of segment) {
+        if (escaped) {
+            current += character;
+            escaped = false;
+            continue;
+        }
+        if (character === "\\" && quote !== "'") {
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            if (character === quote)
+                quote = null;
+            else
+                current += character;
+            continue;
+        }
+        if (character === "'" || character === "\"") {
+            quote = character;
+            continue;
+        }
+        if (/\s/.test(character)) {
+            if (current)
+                words.push(current);
+            current = "";
+            continue;
+        }
+        current += character;
+    }
+    if (escaped)
+        current += "\\";
+    if (current)
+        words.push(current);
+    return words;
+}
+function optionRepo(words) {
+    for (let index = 0; index < words.length; index += 1) {
+        const word = words[index] ?? "";
+        if ((word === "-R" || word === "--repo") && words[index + 1])
+            return words[index + 1] ?? null;
+        if (word.startsWith("--repo="))
+            return word.slice("--repo=".length);
+        if (word.startsWith("-R") && word.length > 2)
+            return word.slice(2);
+    }
+    return null;
+}
+function ghPrSubcommand(words) {
+    const groupIndex = words.indexOf("pr", 1);
+    if (groupIndex < 0)
+        return null;
+    for (let index = groupIndex + 1; index < words.length; index += 1) {
+        const word = words[index] ?? "";
+        if (word === "-R" || word === "--repo" || word === "--hostname") {
+            index += 1;
+            continue;
+        }
+        if (word.startsWith("--repo=") || (word.startsWith("-R") && word.length > 2))
+            continue;
+        if (word.startsWith("-"))
+            continue;
+        return { subcommandIndex: index, subcommand: word };
+    }
+    return { subcommandIndex: words.length, subcommand: null };
+}
+const SHELL_ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=/;
+const PR_MERGE_VALUE_OPTIONS = new Set([
+    "-A", "--author-email", "-b", "--body", "-F", "--body-file",
+    "--match-head-commit", "-t", "--subject",
+]);
+function skipEnvOptions(words, start) {
+    let index = start + 1;
+    while (index < words.length) {
+        const word = words[index] ?? "";
+        if (SHELL_ASSIGNMENT.test(word)) {
+            index += 1;
+            continue;
+        }
+        if (word === "-i" || word === "--ignore-environment") {
+            index += 1;
+            continue;
+        }
+        if (word === "-u" || word === "--unset" || word === "-C" || word === "--chdir") {
+            index += 2;
+            continue;
+        }
+        if (word.startsWith("--unset=") || word.startsWith("--chdir=")) {
+            index += 1;
+            continue;
+        }
+        if (word === "--")
+            return index + 1;
+        if (word.startsWith("-")) {
+            index += 1;
+            continue;
+        }
+        break;
+    }
+    return index;
+}
+function skipTimeoutOptions(words, start) {
+    let index = start + 1;
+    while (index < words.length) {
+        const word = words[index] ?? "";
+        if (word === "--") {
+            index += 1;
+            break;
+        }
+        if (word === "-k" || word === "--kill-after" || word === "-s" || word === "--signal") {
+            index += 2;
+            continue;
+        }
+        if (word.startsWith("--kill-after=") || word.startsWith("--signal=")) {
+            index += 1;
+            continue;
+        }
+        if (word === "--preserve-status" || word === "--foreground" || word === "--verbose" || word === "-v") {
+            index += 1;
+            continue;
+        }
+        if (word.startsWith("-")) {
+            index += 1;
+            continue;
+        }
+        break;
+    }
+    return Math.min(index + 1, words.length);
+}
+function unwrapCommand(words) {
+    let index = 0;
+    while (index < words.length) {
+        if (SHELL_ASSIGNMENT.test(words[index] ?? "")) {
+            index += 1;
+            continue;
+        }
+        if (words[index] === "env") {
+            index = skipEnvOptions(words, index);
+            continue;
+        }
+        if (words[index] === "timeout") {
+            index = skipTimeoutOptions(words, index);
+            continue;
+        }
+        break;
+    }
+    return words.slice(index);
+}
+function parsePullUrl(raw) {
+    if (!/^https?:\/\//i.test(raw))
+        return null;
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        return null;
+    }
+    const match = /^\/([^/]+)\/([^/]+)\/pull\/(\d+)\/?$/.exec(url.pathname);
+    if (!match)
+        return null;
+    try {
+        const pr = Number(match[3]);
+        if (!Number.isSafeInteger(pr) || pr <= 0)
+            return null;
+        return { repo: canonicalRepo(`${decodeURIComponent(match[1] ?? "")}/${decodeURIComponent(match[2] ?? "")}`), pr };
+    }
+    catch (error) {
+        if (error instanceof LanesError && error.error === "repo_hold_repo_invalid") {
+            return fail("repo_hold_repo_invalid", "Pull request URL has an invalid repository", { field: "repo" });
+        }
+        throw error;
+    }
+}
+function pinnedHead(words, start = 0) {
+    for (let index = start; index < words.length; index += 1) {
+        const word = words[index] ?? "";
+        if (word === "--match-head-commit")
+            return words[index + 1]?.trim().toLowerCase() || null;
+        if (word.startsWith("--match-head-commit="))
+            return word.slice("--match-head-commit=".length).trim().toLowerCase() || null;
+        if (word === "-f" || word === "-F" || word === "--field" || word === "--raw-field") {
+            const value = words[index + 1] ?? "";
+            if (value.startsWith("sha="))
+                return value.slice(4).trim().toLowerCase() || null;
+            index += 1;
+            continue;
+        }
+        for (const prefix of ["-fsha=", "-Fsha=", "--field=sha=", "--raw-field=sha="]) {
+            if (word.startsWith(prefix))
+                return word.slice(prefix.length).trim().toLowerCase() || null;
+        }
+    }
+    return null;
+}
+function prMergeTarget(words, subcommandIndex) {
+    const rawRepo = optionRepo(words);
+    let rawNumber = null;
+    let urlTarget = null;
+    const start = subcommandIndex + 1;
+    for (let index = start; index < words.length; index += 1) {
+        const word = words[index] ?? "";
+        if (PR_MERGE_VALUE_OPTIONS.has(word)) {
+            index += 1;
+            continue;
+        }
+        if (["-R", "--repo", "--hostname"].includes(word)) {
+            index += 1;
+            continue;
+        }
+        if (word.startsWith("--repo=") || (word.startsWith("-R") && word.length > 2) || word.startsWith("--match-head-commit="))
+            continue;
+        if (word.startsWith("-"))
+            continue;
+        urlTarget = parsePullUrl(word);
+        if (urlTarget)
+            break;
+        rawNumber = word;
+        break;
+    }
+    const repo = rawRepo ? canonicalRepo(rawRepo) : urlTarget?.repo ?? null;
+    const pr = urlTarget?.pr ?? (rawNumber && /^\d+$/.test(rawNumber) && Number.isSafeInteger(Number(rawNumber)) && Number(rawNumber) > 0
+        ? Number(rawNumber)
+        : null);
+    const reason = repo === null
+        ? "repository could not be resolved without a pull request URL or --repo"
+        : pr === null
+            ? "pull request number could not be resolved"
+            : null;
+    return { kind: "pr", repo, pr, pinnedHead: pinnedHead(words, start), unresolvedReason: reason };
+}
+function apiMergeTarget(words, apiIndex) {
+    const rest = words.slice(apiIndex + 1);
+    const graphql = rest.includes("graphql");
+    if (graphql && rest.some((word) => word.includes("mergePullRequest"))) {
+        return {
+            kind: "graphql",
+            repo: null,
+            pr: null,
+            pinnedHead: pinnedHead(rest),
+            unresolvedReason: "GraphQL mergePullRequest identifies a node id, not a pull request number",
+        };
+    }
+    for (const word of rest) {
+        const match = /^(?:https?:\/\/api\.github\.com)?\/?repos\/([^/]+)\/([^/]+)\/pulls\/(\d+)\/merge\/?$/.exec(word);
+        if (!match)
+            continue;
+        const pr = Number(match[3]);
+        if (!Number.isSafeInteger(pr) || pr <= 0)
+            break;
+        return {
+            kind: "api",
+            repo: canonicalRepo(`${match[1]}/${match[2]}`),
+            pr,
+            pinnedHead: pinnedHead(rest),
+            unresolvedReason: null,
+        };
+    }
+    return null;
+}
+function parseSegment(segment) {
+    const words = unwrapCommand(shellWords(segment));
+    if (words[0] === "git" && words.slice(1).includes("merge")) {
+        return {
+            kind: "git",
+            repo: null,
+            pr: null,
+            pinnedHead: null,
+            unresolvedReason: "git merge does not identify a pull request",
+        };
+    }
+    if (words[0] !== "gh")
+        return null;
+    const pr = ghPrSubcommand(words);
+    if (pr?.subcommand === "merge")
+        return prMergeTarget(words, pr.subcommandIndex);
+    const apiIndex = words.indexOf("api", 1);
+    if (apiIndex < 0)
+        return null;
+    return apiMergeTarget(words, apiIndex);
+}
+export function parseMergeCommands(command) {
+    const targets = splitCommandChain(command)
+        .map(parseSegment)
+        .filter((target) => target !== null);
+    return {
+        targets,
+        unresolved: targets.some((target) => target.unresolvedReason !== null),
+    };
+}
+//# sourceMappingURL=merge-command.js.map

package/dist/lib/lanes/reviews.d.ts

@@ -0,0 +1,38 @@
+export declare const LANE_REVIEWS_REL: string;
+export declare const LANE_REVIEW_SCHEMA_VERSION = "hq-lanes-review.v1";
+export declare const LANE_REVIEW_HISTORY_CAP = 50;
+export interface LaneReviewHistoryEntry {
+    repo: string;
+    pr: number;
+    head_sha: string;
+    reviewer_lane: string | null;
+    reviewer_session: string | null;
+    worker_lane: string | null;
+    note: string | null;
+    recorded_at: string;
+}
+export interface LaneReview extends LaneReviewHistoryEntry {
+    schema_version: typeof LANE_REVIEW_SCHEMA_VERSION;
+    history: LaneReviewHistoryEntry[];
+}
+export interface LaneReviewListing {
+    reviews: LaneReview[];
+    skipped: number;
+}
+export interface RecordLaneReviewInput {
+    repo: string;
+    pr: string | number;
+    headSha: string;
+    reviewerLane: string | null;
+    reviewerSession: string | null;
+    workerLane?: string;
+    note?: string;
+    recordedAt: Date;
+}
+export declare function canonicalLaneReviewRepo(raw: string): string;
+export declare function parseLaneReviewPr(raw: string | number): number;
+export declare function laneReviewPath(hqRoot: string, repo: string, pr: number): string;
+export declare function readLaneReview(hqRoot: string, repo: string, pr: number): LaneReview | null;
+export declare function listLaneReviews(hqRoot: string, reviewerLane?: string): LaneReviewListing;
+export declare function recordLaneReview(hqRoot: string, input: RecordLaneReviewInput): Promise<LaneReview>;
+//# sourceMappingURL=reviews.d.ts.map