@deftai/directive-core 0.55.0

package/dist/pr-closing-keywords/detect.js

@@ -0,0 +1,113 @@
+import { WINDOW_RADIUS } from "./constants.js";
+export const CLOSING_KEYWORD_RE = /\b(close|closes|closed|fix|fixes|fixed|resolve|resolves|resolved)\s+#(\d+)\b/gi;
+const NEGATION_MARKERS = [
+    /\bnot\s+/i,
+    /n't\s+/i,
+    /\bnever\s+/i,
+    /\bintentionally\s+not\s+/i,
+    /\bdoes\s+not\b/i,
+    /\bdo\s+not\b/i,
+    /\bwon't\b/i,
+    /\bcannot\b/i,
+    /\bWITHOUT\b/,
+    /\bEXCEPT\b/,
+];
+const QUOTE_MARKERS = ["`", "'", '"', "\u2018", "\u2019", "\u201c", "\u201d"];
+const EXAMPLE_MARKERS = [
+    /\be\.g\./i,
+    /\bi\.e\./i,
+    /\bfor\s+example\b/i,
+    /\bsuch\s+as\b/i,
+    /\blike\b/i,
+];
+const BLOCKQUOTE_RE = /^\s*>\s/m;
+const CODE_FENCE_RE = /^```/m;
+function findAllMatches(text, re) {
+    const flags = re.flags.includes("g") ? re.flags : `${re.flags}g`;
+    const pattern = new RegExp(re.source, flags);
+    const matches = [];
+    let m = pattern.exec(text);
+    while (m !== null) {
+        matches.push(m);
+        m = pattern.exec(text);
+    }
+    return matches;
+}
+function lineStartingAt(text, offset) {
+    const lineStart = text.lastIndexOf("\n", offset - 1) + 1;
+    let lineEnd = text.indexOf("\n", offset);
+    if (lineEnd === -1) {
+        lineEnd = text.length;
+    }
+    return text.slice(lineStart, lineEnd);
+}
+function isInsideCodeFence(text, offset) {
+    const prefix = text.slice(0, offset);
+    const matches = prefix.match(CODE_FENCE_RE);
+    return matches !== null && matches.length % 2 === 1;
+}
+function classifyHit(text, match) {
+    const start = match.index ?? 0;
+    const end = start + match[0].length;
+    if (isInsideCodeFence(text, start)) {
+        return "code-block";
+    }
+    const line = lineStartingAt(text, start);
+    if (BLOCKQUOTE_RE.test(line)) {
+        return "blockquote";
+    }
+    const winStart = Math.max(0, start - WINDOW_RADIUS);
+    const winEnd = Math.min(text.length, end + WINDOW_RADIUS);
+    const window = text.slice(winStart, winEnd);
+    const kwOffset = start - winStart;
+    for (const negation of NEGATION_MARKERS) {
+        for (const m of findAllMatches(window, negation)) {
+            if (m.index !== undefined && m.index + m[0].length <= kwOffset) {
+                return "negation";
+            }
+        }
+    }
+    const pre = text.slice(Math.max(0, start - 3), start);
+    const post = text.slice(end, Math.min(text.length, end + 3));
+    if (QUOTE_MARKERS.some((q) => pre.includes(q)) && QUOTE_MARKERS.some((q) => post.includes(q))) {
+        return "quotation";
+    }
+    if (pre.includes("`") && post.includes("`")) {
+        return "quotation";
+    }
+    for (const example of EXAMPLE_MARKERS) {
+        for (const m of findAllMatches(window, example)) {
+            if (m.index !== undefined && m.index + m[0].length <= kwOffset) {
+                return "example";
+            }
+        }
+    }
+    return null;
+}
+export function renderHit(hit) {
+    return (`  [${hit.source}] ${hit.reason}: ` +
+        `"...${hit.context}..." -> ${hit.keyword} #${hit.issueNumber}`);
+}
+export function findHits(text, source) {
+    const hits = [];
+    const re = new RegExp(CLOSING_KEYWORD_RE.source, CLOSING_KEYWORD_RE.flags);
+    let match = re.exec(text);
+    while (match !== null) {
+        const category = classifyHit(text, match);
+        if (category !== null) {
+            const snippetStart = Math.max(0, (match.index ?? 0) - 30);
+            const snippetEnd = Math.min(text.length, (match.index ?? 0) + match[0].length + 30);
+            const context = text.slice(snippetStart, snippetEnd).replace(/\n/g, " ");
+            hits.push({
+                source,
+                keyword: match[1] ?? "",
+                issueNumber: Number(match[2]),
+                context,
+                reason: category,
+            });
+        }
+        match = re.exec(text);
+    }
+    return hits;
+}
+//# sourceMappingURL=detect.js.map

package/dist/pr-closing-keywords/gh.d.ts

@@ -0,0 +1,6 @@
+import type { RunGhFn, RunGhResult } from "./types.js";
+/** UTF-8-safe gh capture via execFile (no shell) — mirrors _safe_subprocess.run_text (#1366). */
+export declare function defaultRunGh(cmd: readonly string[]): RunGhResult;
+export declare function fetchPrBody(prNumber: number, repo: string | null, runGh: RunGhFn): string | null;
+export declare function fetchPrCommitMessages(prNumber: number, repo: string | null, runGh: RunGhFn): string[] | null;
+//# sourceMappingURL=gh.d.ts.map

package/dist/pr-closing-keywords/gh.js

@@ -0,0 +1,129 @@
+import { execFileSync } from "node:child_process";
+import { resolveBinary } from "../scm/binary.js";
+import { SUBPROCESS_MAX_BUFFER } from "../subprocess/max-buffer.js";
+import { GH_TIMEOUT_S } from "./constants.js";
+/** UTF-8-safe gh capture via execFile (no shell) — mirrors _safe_subprocess.run_text (#1366). */
+export function defaultRunGh(cmd) {
+    if (cmd.length === 0 || cmd[0] !== "gh") {
+        return { returncode: -1, stdout: "", stderr: "expected gh as first argv element" };
+    }
+    const binary = resolveBinary();
+    const args = cmd.slice(1);
+    try {
+        const stdout = execFileSync(binary, args, {
+            encoding: "utf8",
+            timeout: GH_TIMEOUT_S * 1000,
+            stdio: ["ignore", "pipe", "pipe"],
+            maxBuffer: SUBPROCESS_MAX_BUFFER,
+        });
+        return { returncode: 0, stdout: typeof stdout === "string" ? stdout : "", stderr: "" };
+    }
+    catch (err) {
+        const e = err;
+        if (e.code === "ENOENT") {
+            return { returncode: -1, stdout: "", stderr: "gh CLI not found. Install GitHub CLI." };
+        }
+        if (e.code === "ETIMEDOUT") {
+            return {
+                returncode: -1,
+                stdout: "",
+                stderr: `gh CLI timed out fetching PR #${args.includes("view") ? (args[2] ?? "?") : "?"}.`,
+            };
+        }
+        return {
+            returncode: typeof e.status === "number" ? e.status : -1,
+            stdout: typeof e.stdout === "string" ? e.stdout : "",
+            stderr: typeof e.stderr === "string" ? e.stderr : String(e.message ?? ""),
+        };
+    }
+}
+export function fetchPrBody(prNumber, repo, runGh) {
+    const cmd = ["gh", "pr", "view", String(prNumber), "--json", "body"];
+    if (repo) {
+        cmd.push("--repo", repo);
+    }
+    const { returncode, stdout, stderr } = runGh(cmd);
+    if (returncode === -1 && stderr.includes("not found")) {
+        process.stderr.write("Error: gh CLI not found. Install GitHub CLI.\n");
+        return null;
+    }
+    if (returncode === -1 && stderr.includes("timed out")) {
+        process.stderr.write(`Error: gh CLI timed out fetching PR #${prNumber}.\n`);
+        return null;
+    }
+    if (returncode !== 0) {
+        process.stderr.write(`Error: gh CLI failed fetching PR #${prNumber}: ${stderr.trim()}\n`);
+        return null;
+    }
+    let payload;
+    try {
+        payload = JSON.parse(stdout);
+    }
+    catch (exc) {
+        const message = exc instanceof Error ? exc.message : String(exc);
+        process.stderr.write(`Error: failed to parse gh CLI output: ${message}\n`);
+        return null;
+    }
+    if (payload === null || typeof payload !== "object" || Array.isArray(payload)) {
+        process.stderr.write("Error: failed to parse gh CLI output: unexpected shape\n");
+        return null;
+    }
+    const body = payload.body ?? "";
+    if (typeof body !== "string") {
+        process.stderr.write(`Error: unexpected body shape: ${typeof body}\n`);
+        return null;
+    }
+    return body;
+}
+export function fetchPrCommitMessages(prNumber, repo, runGh) {
+    const cmd = ["gh", "pr", "view", String(prNumber), "--json", "commits"];
+    if (repo) {
+        cmd.push("--repo", repo);
+    }
+    const { returncode, stdout, stderr } = runGh(cmd);
+    if (returncode === -1 && stderr.includes("not found")) {
+        process.stderr.write("Error: gh CLI not found. Install GitHub CLI.\n");
+        return null;
+    }
+    if (returncode === -1 && stderr.includes("timed out")) {
+        process.stderr.write(`Error: gh CLI timed out fetching commits for PR #${prNumber}.\n`);
+        return null;
+    }
+    if (returncode !== 0) {
+        process.stderr.write(`Error: gh CLI failed fetching commits: ${stderr.trim()}\n`);
+        return null;
+    }
+    let payload;
+    try {
+        payload = JSON.parse(stdout);
+    }
+    catch (exc) {
+        const message = exc instanceof Error ? exc.message : String(exc);
+        process.stderr.write(`Error: failed to parse gh CLI output: ${message}\n`);
+        return null;
+    }
+    if (payload === null || typeof payload !== "object" || Array.isArray(payload)) {
+        process.stderr.write("Error: failed to parse gh CLI output: unexpected shape\n");
+        return null;
+    }
+    const commits = payload.commits;
+    if (!Array.isArray(commits)) {
+        process.stderr.write(`Error: unexpected commits shape: ${typeof commits}\n`);
+        return null;
+    }
+    const messages = [];
+    for (const entry of commits) {
+        if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
+            continue;
+        }
+        const e = entry;
+        const headline = typeof e.messageHeadline === "string" ? e.messageHeadline : "";
+        const body = typeof e.messageBody === "string" ? e.messageBody : "";
+        const combined = `${headline}\n${body}`.trim();
+        if (combined.length > 0) {
+            messages.push(combined);
+        }
+    }
+    return messages;
+}
+//# sourceMappingURL=gh.js.map

package/dist/pr-closing-keywords/index.d.ts

@@ -0,0 +1,7 @@
+export { EXIT_CONFIG_ERROR, EXIT_HITS_FOUND, EXIT_OK, GH_TIMEOUT_S, WINDOW_RADIUS, } from "./constants.js";
+export { findHits, renderHit } from "./detect.js";
+export { defaultRunGh, fetchPrBody, fetchPrCommitMessages } from "./gh.js";
+export { readCommitsFile, readTextFile } from "./io.js";
+export { cmdPrCheckClosingKeywords, parseAllowList, parseArgs, run } from "./main.js";
+export type { Hit, ParsedArgs, RunGhFn, RunGhResult } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/pr-closing-keywords/index.js

@@ -0,0 +1,6 @@
+export { EXIT_CONFIG_ERROR, EXIT_HITS_FOUND, EXIT_OK, GH_TIMEOUT_S, WINDOW_RADIUS, } from "./constants.js";
+export { findHits, renderHit } from "./detect.js";
+export { defaultRunGh, fetchPrBody, fetchPrCommitMessages } from "./gh.js";
+export { readCommitsFile, readTextFile } from "./io.js";
+export { cmdPrCheckClosingKeywords, parseAllowList, parseArgs, run } from "./main.js";
+//# sourceMappingURL=index.js.map

package/dist/pr-closing-keywords/io.d.ts

@@ -0,0 +1,3 @@
+export declare function readTextFile(path: string): string | null;
+export declare function readCommitsFile(path: string): string[] | null;
+//# sourceMappingURL=io.d.ts.map

package/dist/pr-closing-keywords/io.js

@@ -0,0 +1,22 @@
+import { readFileSync } from "node:fs";
+export function readTextFile(path) {
+    try {
+        return readFileSync(path, { encoding: "utf8" });
+    }
+    catch (exc) {
+        const message = exc instanceof Error ? exc.message : String(exc);
+        process.stderr.write(`Error: failed to read ${path}: ${message}\n`);
+        return null;
+    }
+}
+export function readCommitsFile(path) {
+    const text = readTextFile(path);
+    if (text === null) {
+        return null;
+    }
+    return text
+        .split("\n--END--\n")
+        .map((p) => p.trim())
+        .filter((p) => p.length > 0);
+}
+//# sourceMappingURL=io.js.map

package/dist/pr-closing-keywords/main.d.ts

@@ -0,0 +1,9 @@
+import type { ParsedArgs, RunGhFn } from "./types.js";
+export declare function parseAllowList(values: readonly string[]): Set<number>;
+export declare function parseArgs(argv: readonly string[]): ParsedArgs;
+export interface RunOptions {
+    readonly runGh?: RunGhFn;
+}
+export declare function run(argv: readonly string[], options?: RunOptions): number;
+export declare function cmdPrCheckClosingKeywords(argv: readonly string[], options?: RunOptions): number;
+//# sourceMappingURL=main.d.ts.map

package/dist/pr-closing-keywords/main.js

@@ -0,0 +1,246 @@
+import { EXIT_CONFIG_ERROR, EXIT_HITS_FOUND, EXIT_OK } from "./constants.js";
+import { findHits, renderHit } from "./detect.js";
+import { defaultRunGh, fetchPrBody, fetchPrCommitMessages } from "./gh.js";
+import { readCommitsFile, readTextFile } from "./io.js";
+export function parseAllowList(values) {
+    const out = new Set();
+    for (const chunk of values) {
+        for (const raw of chunk.split(",")) {
+            const tok = raw.trim().replace(/^#/, "");
+            if (tok.length === 0) {
+                continue;
+            }
+            if (!/^\d+$/.test(tok)) {
+                throw new Error(`Invalid issue number in --allow-known-false-positives: ${JSON.stringify(tok)}`);
+            }
+            out.add(Number(tok));
+        }
+    }
+    return out;
+}
+export function parseArgs(argv) {
+    let pr = null;
+    let bodyFile = null;
+    let commitsFile = null;
+    let repo = null;
+    const allowKnownFalsePositives = [];
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--pr") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return {
+                    pr,
+                    bodyFile,
+                    commitsFile,
+                    repo,
+                    allowKnownFalsePositives,
+                    error: "argument --pr: expected one argument",
+                };
+            }
+            const n = Number(value);
+            if (!Number.isInteger(n)) {
+                return {
+                    pr,
+                    bodyFile,
+                    commitsFile,
+                    repo,
+                    allowKnownFalsePositives,
+                    error: `invalid int value: ${JSON.stringify(value)}`,
+                };
+            }
+            pr = n;
+            i += 1;
+        }
+        else if (arg?.startsWith("--pr=")) {
+            const value = arg.slice("--pr=".length);
+            const n = Number(value);
+            if (!Number.isInteger(n)) {
+                return {
+                    pr,
+                    bodyFile,
+                    commitsFile,
+                    repo,
+                    allowKnownFalsePositives,
+                    error: `invalid int value: ${JSON.stringify(value)}`,
+                };
+            }
+            pr = n;
+        }
+        else if (arg === "--body-file") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return {
+                    pr,
+                    bodyFile,
+                    commitsFile,
+                    repo,
+                    allowKnownFalsePositives,
+                    error: "argument --body-file: expected one argument",
+                };
+            }
+            bodyFile = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--body-file=")) {
+            bodyFile = arg.slice("--body-file=".length);
+        }
+        else if (arg === "--commits-file") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return {
+                    pr,
+                    bodyFile,
+                    commitsFile,
+                    repo,
+                    allowKnownFalsePositives,
+                    error: "argument --commits-file: expected one argument",
+                };
+            }
+            commitsFile = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--commits-file=")) {
+            commitsFile = arg.slice("--commits-file=".length);
+        }
+        else if (arg === "--repo") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return {
+                    pr,
+                    bodyFile,
+                    commitsFile,
+                    repo,
+                    allowKnownFalsePositives,
+                    error: "argument --repo: expected one argument",
+                };
+            }
+            repo = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--repo=")) {
+            repo = arg.slice("--repo=".length);
+        }
+        else if (arg === "--allow-known-false-positives") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return {
+                    pr,
+                    bodyFile,
+                    commitsFile,
+                    repo,
+                    allowKnownFalsePositives,
+                    error: "argument --allow-known-false-positives: expected one argument",
+                };
+            }
+            allowKnownFalsePositives.push(value);
+            i += 1;
+        }
+        else if (arg?.startsWith("--allow-known-false-positives=")) {
+            allowKnownFalsePositives.push(arg.slice("--allow-known-false-positives=".length));
+        }
+        else if (arg?.startsWith("-")) {
+            return {
+                pr,
+                bodyFile,
+                commitsFile,
+                repo,
+                allowKnownFalsePositives,
+                error: `unrecognized arguments: ${arg}`,
+            };
+        }
+        else {
+            return {
+                pr,
+                bodyFile,
+                commitsFile,
+                repo,
+                allowKnownFalsePositives,
+                error: `unrecognized arguments: ${arg}`,
+            };
+        }
+    }
+    return { pr, bodyFile, commitsFile, repo, allowKnownFalsePositives };
+}
+function filterHits(hits, allowList) {
+    return hits.filter((h) => !allowList.has(h.issueNumber));
+}
+function emitResult(hits, filtered) {
+    if (filtered.length === 0) {
+        if (hits.length > 0) {
+            process.stderr.write(`OK: ${hits.length} hit(s) suppressed by --allow-known-false-positives.\n`);
+        }
+        else {
+            process.stderr.write("OK: no closing-keyword negation/quotation/example/code-block hits found.\n");
+        }
+        return EXIT_OK;
+    }
+    process.stderr.write(`FAIL: ${filtered.length} closing-keyword negation-context hit(s) found (see #737). Rewrite the PR body / commit messages to avoid the trigger token, or pass --allow-known-false-positives to suppress.\n`);
+    for (const h of filtered) {
+        process.stderr.write(`${renderHit(h)}\n`);
+    }
+    return EXIT_HITS_FOUND;
+}
+export function run(argv, options = {}) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`Error: ${args.error}\n`);
+        return EXIT_CONFIG_ERROR;
+    }
+    let allowList;
+    try {
+        allowList = parseAllowList(args.allowKnownFalsePositives);
+    }
+    catch (exc) {
+        const message = exc instanceof Error ? exc.message : String(exc);
+        process.stderr.write(`Error: ${message}\n`);
+        return EXIT_CONFIG_ERROR;
+    }
+    const runGh = options.runGh ?? defaultRunGh;
+    let bodyText = null;
+    let commitMessages = [];
+    if (args.pr !== null) {
+        bodyText = fetchPrBody(args.pr, args.repo, runGh);
+        if (bodyText === null) {
+            return EXIT_CONFIG_ERROR;
+        }
+        const msgs = fetchPrCommitMessages(args.pr, args.repo, runGh);
+        if (msgs === null) {
+            return EXIT_CONFIG_ERROR;
+        }
+        commitMessages = msgs;
+    }
+    else {
+        if (args.bodyFile === null && args.commitsFile === null) {
+            process.stderr.write("Error: must specify --pr OR --body-file / --commits-file.\n");
+            return EXIT_CONFIG_ERROR;
+        }
+        if (args.bodyFile !== null) {
+            const text = readTextFile(args.bodyFile);
+            if (text === null) {
+                return EXIT_CONFIG_ERROR;
+            }
+            bodyText = text;
+        }
+        if (args.commitsFile !== null) {
+            const msgs = readCommitsFile(args.commitsFile);
+            if (msgs === null) {
+                return EXIT_CONFIG_ERROR;
+            }
+            commitMessages = msgs;
+        }
+    }
+    const hits = [];
+    if (bodyText !== null) {
+        hits.push(...findHits(bodyText, "pr-body"));
+    }
+    for (let idx = 0; idx < commitMessages.length; idx += 1) {
+        hits.push(...findHits(commitMessages[idx] ?? "", `commit:${idx}`));
+    }
+    const filtered = filterHits(hits, allowList);
+    return emitResult(hits, filtered);
+}
+export function cmdPrCheckClosingKeywords(argv, options = {}) {
+    return run(argv, options);
+}
+//# sourceMappingURL=main.js.map

package/dist/pr-closing-keywords/types.d.ts

@@ -0,0 +1,23 @@
+export interface Hit {
+    readonly source: string;
+    readonly keyword: string;
+    readonly issueNumber: number;
+    readonly context: string;
+    readonly reason: string;
+}
+export interface RunGhResult {
+    readonly returncode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+/** Injectable gh subprocess seam (#1366 / parity harness). */
+export type RunGhFn = (cmd: readonly string[]) => RunGhResult;
+export interface ParsedArgs {
+    readonly pr: number | null;
+    readonly bodyFile: string | null;
+    readonly commitsFile: string | null;
+    readonly repo: string | null;
+    readonly allowKnownFalsePositives: readonly string[];
+    readonly error?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/pr-closing-keywords/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/pr-merge-readiness/compute.d.ts

@@ -0,0 +1,7 @@
+import { isMergeReady } from "./evaluate.js";
+import type { GateResult, RunGhFn } from "./types.js";
+declare function buildGateResult(prNumber: number, repo: string | null, headSha: string | null, body: string, via: string, partialData?: Record<string, unknown>, error?: string | null): GateResult;
+/** Run the primary->fallback1->fallback2 cascade and return a result. */
+export declare function computeGateResult(prNumber: number, repo: string | null, runGh: RunGhFn): GateResult;
+export { buildGateResult, isMergeReady };
+//# sourceMappingURL=compute.d.ts.map