@deftai/directive-core 0.55.0

package/dist/triage/scope/cli.js

@@ -0,0 +1,257 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { coveragePath, writeCoverageDenominator } from "./coverage.js";
+import { addLabelToIgnores, addLabelToScope, addMilestoneToScope, computeDiffFromUpstream, fetchUpstreamLabelsAndMilestones, renderDiffReport, } from "./mutations.js";
+import { subscriptionHash } from "./normalize.js";
+import { pyListRepr } from "./python-repr.js";
+import { renderIgnores, renderList } from "./renderers.js";
+import { getRawIgnores, getRawScope, isDefaultApplied, loadProjectDefinition, resolveScopeRules, } from "./resolve.js";
+import { validateScopeRules } from "./validate.js";
+export function parseCliArgs(argv) {
+    const parsed = {
+        projectRoot: process.env.DEFT_PROJECT_ROOT ?? ".",
+        doList: false,
+        refreshDenominator: false,
+        repo: process.env.DEFT_TRIAGE_REPO,
+        addLabel: undefined,
+        addMilestone: undefined,
+        ignoreLabel: undefined,
+        diffFromUpstream: false,
+        source: "github-issue",
+        cacheRoot: undefined,
+        count: undefined,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--list")
+            parsed.doList = true;
+        else if (arg === "--refresh-denominator")
+            parsed.refreshDenominator = true;
+        else if (arg === "--diff-from-upstream")
+            parsed.diffFromUpstream = true;
+        else if (arg === "--project-root") {
+            parsed.projectRoot = argv[i + 1] ?? ".";
+            i += 1;
+        }
+        else if (arg?.startsWith("--project-root="))
+            parsed.projectRoot = arg.slice("--project-root=".length);
+        else if (arg === "--repo") {
+            parsed.repo = argv[i + 1];
+            i += 1;
+        }
+        else if (arg?.startsWith("--repo="))
+            parsed.repo = arg.slice("--repo=".length);
+        else if (arg === "--add-label") {
+            parsed.addLabel = argv[i + 1];
+            i += 1;
+        }
+        else if (arg?.startsWith("--add-label="))
+            parsed.addLabel = arg.slice("--add-label=".length);
+        else if (arg === "--add-milestone") {
+            parsed.addMilestone = argv[i + 1];
+            i += 1;
+        }
+        else if (arg?.startsWith("--add-milestone="))
+            parsed.addMilestone = arg.slice("--add-milestone=".length);
+        else if (arg === "--ignore-label") {
+            parsed.ignoreLabel = argv[i + 1];
+            i += 1;
+        }
+        else if (arg?.startsWith("--ignore-label="))
+            parsed.ignoreLabel = arg.slice("--ignore-label=".length);
+        else if (arg === "--source") {
+            parsed.source = argv[i + 1] ?? "github-issue";
+            i += 1;
+        }
+        else if (arg?.startsWith("--source="))
+            parsed.source = arg.slice("--source=".length);
+        else if (arg === "--cache-root") {
+            parsed.cacheRoot = argv[i + 1];
+            i += 1;
+        }
+        else if (arg?.startsWith("--cache-root="))
+            parsed.cacheRoot = arg.slice("--cache-root=".length);
+        else if (arg === "--count") {
+            const raw = argv[i + 1];
+            parsed.count = raw !== undefined ? Number.parseInt(raw, 10) : undefined;
+            i += 1;
+        }
+        else if (arg?.startsWith("--count=")) {
+            parsed.count = Number.parseInt(arg.slice("--count=".length), 10);
+        }
+    }
+    return parsed;
+}
+export const CLI_HELP = `usage: triage_scope.py [-h] [--project-root PROJECT_ROOT] [--list]
+                       [--refresh-denominator] [--repo REPO]
+                       [--add-label ADD_LABEL] [--add-milestone ADD_MILESTONE]
+                       [--ignore-label IGNORE_LABEL] [--diff-from-upstream]
+                       [--source SOURCE] [--cache-root CACHE_ROOT]
+                       [--count COUNT]
+
+Inspect, mutate, and diff the typed plan.policy.triageScope[] subscription +
+plan.policy.triageScopeIgnores[] (#1131 / D12, #1133 / D14, #1182 / D14c).
+Read paths never trigger a recompute; use --refresh-denominator to update the
+coverage cache. Mutation flags --add-label / --add-milestone / --ignore-label
+are idempotent and atomic; every mutation appends a subscription-change audit
+entry to vbrief/.eval/subscription-history.jsonl.
+`;
+function handleMutation(projectRoot, args) {
+    const out = { stdout: [], stderr: [] };
+    try {
+        let changed;
+        let message;
+        let verb;
+        if (args.addLabel !== undefined) {
+            [changed, message] = addLabelToScope(projectRoot, args.addLabel);
+            verb = "add-label";
+        }
+        else if (args.addMilestone !== undefined) {
+            [changed, message] = addMilestoneToScope(projectRoot, args.addMilestone);
+            verb = "add-milestone";
+        }
+        else if (args.ignoreLabel !== undefined) {
+            [changed, message] = addLabelToIgnores(projectRoot, args.ignoreLabel);
+            verb = "ignore-label";
+        }
+        else {
+            throw new Error("internal: mutation flag set but no handler matched");
+        }
+        const suffix = changed ? "." : " (no-op).";
+        const line = `triage:scope ${verb}: ${message}${suffix}\n`;
+        if (changed)
+            out.stdout.push(line);
+        else
+            out.stderr.push(line);
+        return { code: 0, out };
+    }
+    catch (err) {
+        out.stderr.push(`triage:scope: ${String(err)}`);
+        return { code: 1, out };
+    }
+}
+/** Run triage:scope CLI; returns exit code and captured output for parity. */
+export function runCliCapture(argv) {
+    const args = parseCliArgs(argv);
+    const stdout = [];
+    const stderr = [];
+    const projectRoot = resolve(args.projectRoot);
+    if (!existsSync(projectRoot)) {
+        return {
+            code: 2,
+            stdout: "",
+            stderr: `triage:scope: --project-root ${projectRoot} does not exist or is not a directory.\n`,
+        };
+    }
+    const mutationFlags = [
+        args.addLabel !== undefined ? "--add-label" : null,
+        args.addMilestone !== undefined ? "--add-milestone" : null,
+        args.ignoreLabel !== undefined ? "--ignore-label" : null,
+    ].filter((f) => f !== null);
+    if (mutationFlags.length > 1) {
+        return {
+            code: 2,
+            stdout: "",
+            stderr: "triage:scope: --add-label / --add-milestone / --ignore-label " +
+                `are mutually exclusive (got ${pyListRepr(mutationFlags)}).\n`,
+        };
+    }
+    const noAction = !args.doList &&
+        !args.refreshDenominator &&
+        mutationFlags.length === 0 &&
+        !args.diffFromUpstream;
+    if (noAction) {
+        return { code: 0, stdout: CLI_HELP, stderr: "" };
+    }
+    if (mutationFlags.length > 0) {
+        const mutation = handleMutation(projectRoot, args);
+        stderr.push(...mutation.out.stderr);
+        stdout.push(...mutation.out.stdout);
+        if (mutation.code !== 0) {
+            return { code: mutation.code, stdout: stdout.join(""), stderr: stderr.join("") };
+        }
+    }
+    const data = loadProjectDefinition(projectRoot);
+    const rules = resolveScopeRules(projectRoot, data);
+    const isDefault = isDefaultApplied(data);
+    const { errors: schemaErrors } = validateScopeRules(getRawScope(data));
+    if (schemaErrors.length > 0) {
+        stderr.push(`triage:scope: PROJECT-DEFINITION plan.policy.triageScope has ${schemaErrors.length} validation error(s):\n`);
+        for (const err of schemaErrors)
+            stderr.push(`  - ${err}\n`);
+        return { code: 1, stdout: stdout.join(""), stderr: stderr.join("") };
+    }
+    if (args.doList) {
+        stdout.push(`${renderList(rules, { isDefault })}\n`);
+        stdout.push(`${renderIgnores(getRawIgnores(data))}\n`);
+    }
+    if (args.refreshDenominator) {
+        if (!args.repo?.includes("/")) {
+            return {
+                code: 2,
+                stdout: stdout.join(""),
+                stderr: `${stderr.join("")}` +
+                    "triage:scope --refresh-denominator requires --repo OWNER/NAME (or $DEFT_TRIAGE_REPO).\n",
+            };
+        }
+        if (args.count === undefined || Number.isNaN(args.count)) {
+            return {
+                code: 2,
+                stdout: stdout.join(""),
+                stderr: `${stderr.join("")}` +
+                    "triage:scope --refresh-denominator requires --count <int> (D5 will provide the live-probe wiring; until then a synthetic / cached count is the caller's contract).\n",
+            };
+        }
+        const path = coveragePath(args.source, args.repo, {
+            projectRoot,
+            cacheRoot: args.cacheRoot !== undefined ? resolve(args.cacheRoot) : undefined,
+        });
+        const subHash = subscriptionHash(rules);
+        const record = writeCoverageDenominator(path, {
+            count: args.count,
+            subscriptionHashValue: subHash,
+        });
+        stdout.push(`triage:scope: wrote coverage denominator count=${record.count} ` +
+            `subscription-hash=${record.subscriptionHash} path=${path}\n`);
+    }
+    if (args.diffFromUpstream) {
+        if (!args.repo?.includes("/")) {
+            return {
+                code: 2,
+                stdout: stdout.join(""),
+                stderr: `${stderr.join("")}` +
+                    "triage:scope --diff-from-upstream requires --repo OWNER/NAME (or $DEFT_TRIAGE_REPO).\n",
+            };
+        }
+        try {
+            const [labels, milestones] = fetchUpstreamLabelsAndMilestones(args.repo);
+            const report = computeDiffFromUpstream(projectRoot, {
+                upstreamLabels: labels,
+                upstreamMilestones: milestones,
+                repo: args.repo,
+            });
+            stdout.push(`${renderDiffReport(report)}\n`);
+        }
+        catch (err) {
+            return {
+                code: 1,
+                stdout: stdout.join(""),
+                stderr: `${stderr.join("")}triage:scope --diff-from-upstream: ${String(err)}\n`,
+            };
+        }
+    }
+    return { code: 0, stdout: stdout.join(""), stderr: stderr.join("") };
+}
+export function run(argv) {
+    const result = runCliCapture(argv);
+    if (result.stdout)
+        process.stdout.write(result.stdout);
+    if (result.stderr)
+        process.stderr.write(result.stderr);
+    return result.code;
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=cli.js.map

package/dist/triage/scope/constants.d.ts

@@ -0,0 +1,16 @@
+/** Framework default when plan.policy.triageScope is unset (#1131). */
+export declare const DEFAULT_TRIAGE_SCOPE: ReadonlyArray<Record<string, unknown>>;
+export declare const PROJECT_DEFINITION_REL_PATH = "vbrief/PROJECT-DEFINITION.vbrief.json";
+export declare const CACHE_DIR_NAME = ".deft-cache";
+export declare const COVERAGE_FILENAME = "coverage.json";
+export declare const ENV_COVERAGE_TTL_HOURS = "DEFT_COVERAGE_MAX_AGE_HOURS";
+export declare const DEFAULT_COVERAGE_TTL_HOURS = 24;
+export declare const SUBSCRIPTION_HASH_LEN = 16;
+export declare const VALID_RULE_TYPES: Set<string>;
+export declare const VALID_IGNORE_KEYS: Set<string>;
+export declare const VALID_IGNORE_RULES: Set<string>;
+export declare const REFERENCED_BY_VBRIEF_SCOPES: Set<string>;
+export declare const SLICED_FROM_SCOPES: Set<string>;
+export declare const SUBSCRIPTION_HISTORY_REL_PATH = "vbrief/.eval/subscription-history.jsonl";
+export declare const SUBSCRIPTION_HISTORY_SCHEMA = "deft.triage.subscription-change.v1";
+//# sourceMappingURL=constants.d.ts.map

package/dist/triage/scope/constants.js

@@ -0,0 +1,25 @@
+/** Framework default when plan.policy.triageScope is unset (#1131). */
+export const DEFAULT_TRIAGE_SCOPE = [{ rule: "all-open" }];
+export const PROJECT_DEFINITION_REL_PATH = "vbrief/PROJECT-DEFINITION.vbrief.json";
+export const CACHE_DIR_NAME = ".deft-cache";
+export const COVERAGE_FILENAME = "coverage.json";
+export const ENV_COVERAGE_TTL_HOURS = "DEFT_COVERAGE_MAX_AGE_HOURS";
+export const DEFAULT_COVERAGE_TTL_HOURS = 24;
+export const SUBSCRIPTION_HASH_LEN = 16;
+export const VALID_RULE_TYPES = new Set([
+    "all-open",
+    "labels",
+    "milestone",
+    "opened-since",
+    "updated-since",
+    "referenced-by-vbrief",
+    "sliced-from",
+    "explicit-watch",
+]);
+export const VALID_IGNORE_KEYS = new Set(["label", "milestone"]);
+export const VALID_IGNORE_RULES = new Set(["author"]);
+export const REFERENCED_BY_VBRIEF_SCOPES = new Set(["any", "active"]);
+export const SLICED_FROM_SCOPES = new Set(["any-umbrella-in-cache"]);
+export const SUBSCRIPTION_HISTORY_REL_PATH = "vbrief/.eval/subscription-history.jsonl";
+export const SUBSCRIPTION_HISTORY_SCHEMA = "deft.triage.subscription-change.v1";
+//# sourceMappingURL=constants.js.map

package/dist/triage/scope/coverage.d.ts

@@ -0,0 +1,24 @@
+export interface CoverageRecord {
+    readonly count: number;
+    readonly fetchedAt: string;
+    readonly subscriptionHash: string;
+    readonly stale: boolean;
+    readonly ageHours: number | null;
+}
+export declare function coveragePath(source: string, repo: string, options?: {
+    projectRoot?: string;
+    cacheRoot?: string;
+}): string;
+export declare function coverageTtlHours(): number;
+export declare function writeCoverageDenominator(path: string, options: {
+    count: number;
+    subscriptionHashValue: string;
+    fetchedAt?: Date;
+}): CoverageRecord;
+export declare function readCoverageDenominator(path: string, options: {
+    currentHash: string;
+    ttlHours?: number;
+    now?: Date;
+}): CoverageRecord | null;
+export declare function formatCoverageDisplay(numerator: number, record: CoverageRecord | null): string;
+//# sourceMappingURL=coverage.d.ts.map

package/dist/triage/scope/coverage.js

@@ -0,0 +1,96 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { CACHE_DIR_NAME, COVERAGE_FILENAME, DEFAULT_COVERAGE_TTL_HOURS, ENV_COVERAGE_TTL_HOURS, } from "./constants.js";
+import { parseIso, utcIso, utcNow } from "./time.js";
+export function coveragePath(source, repo, options = {}) {
+    if (!repo.includes("/")) {
+        throw new Error(`repo must be 'owner/name'; got ${JSON.stringify(repo)}`);
+    }
+    const root = options.cacheRoot !== undefined
+        ? resolve(options.cacheRoot)
+        : join(resolve(options.projectRoot ?? "."), CACHE_DIR_NAME);
+    const owner = repo.split("/", 2)[0] ?? "";
+    const name = repo.split("/", 2)[1] ?? "";
+    return join(root, source, owner, name, COVERAGE_FILENAME);
+}
+export function coverageTtlHours() {
+    const raw = process.env[ENV_COVERAGE_TTL_HOURS] ?? "";
+    if (!raw)
+        return DEFAULT_COVERAGE_TTL_HOURS;
+    const value = Number.parseInt(raw, 10);
+    if (Number.isNaN(value) || value < 0)
+        return DEFAULT_COVERAGE_TTL_HOURS;
+    return value;
+}
+export function writeCoverageDenominator(path, options) {
+    if (options.count < 0) {
+        throw new Error(`count must be >= 0; got ${options.count}`);
+    }
+    if (!options.subscriptionHashValue) {
+        throw new Error("subscription_hash_value must be a non-empty string");
+    }
+    const stamp = utcIso(options.fetchedAt ?? null);
+    mkdirSync(join(path, ".."), { recursive: true });
+    const payload = {
+        count: options.count,
+        fetched_at: stamp,
+        subscription_hash: options.subscriptionHashValue,
+    };
+    writeFileSync(path, `${JSON.stringify(payload, Object.keys(payload).sort())}\n`, "utf8");
+    return {
+        count: options.count,
+        fetchedAt: stamp,
+        subscriptionHash: options.subscriptionHashValue,
+        stale: false,
+        ageHours: 0,
+    };
+}
+export function readCoverageDenominator(path, options) {
+    if (!existsSync(path))
+        return null;
+    let data;
+    try {
+        data = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return null;
+    }
+    if (typeof data !== "object" || data === null || Array.isArray(data))
+        return null;
+    const rec = data;
+    const count = rec.count;
+    const fetchedAt = rec.fetched_at;
+    const storedHash = rec.subscription_hash;
+    if (typeof count !== "number" || !Number.isInteger(count) || count < 0)
+        return null;
+    if (typeof fetchedAt !== "string" || !fetchedAt)
+        return null;
+    if (typeof storedHash !== "string" || !storedHash)
+        return null;
+    const effectiveTtl = options.ttlHours !== undefined ? Math.max(0, options.ttlHours) : coverageTtlHours();
+    const nowDt = options.now ?? utcNow();
+    let fetchedDt;
+    try {
+        fetchedDt = parseIso(fetchedAt);
+    }
+    catch {
+        return null;
+    }
+    const ageSeconds = Math.max(0, (nowDt.getTime() - fetchedDt.getTime()) / 1000);
+    const ageHours = ageSeconds / 3600;
+    const ttlStale = effectiveTtl > 0 && ageHours > effectiveTtl;
+    const hashStale = storedHash !== options.currentHash;
+    return {
+        count,
+        fetchedAt,
+        subscriptionHash: storedHash,
+        stale: Boolean(ttlStale || hashStale),
+        ageHours,
+    };
+}
+export function formatCoverageDisplay(numerator, record) {
+    if (record === null || record.stale)
+        return `${numerator}/?`;
+    return `${numerator}/${record.count}`;
+}
+//# sourceMappingURL=coverage.js.map

package/dist/triage/scope/duration.d.ts

@@ -0,0 +1,6 @@
+/** Parse duration string into milliseconds (Python timedelta equivalent). */
+export declare function parseDurationMs(raw: unknown): number;
+export declare function parseDuration(raw: unknown): {
+    ms: number;
+};
+//# sourceMappingURL=duration.d.ts.map

package/dist/triage/scope/duration.js

@@ -0,0 +1,44 @@
+const DURATION_RE_SIMPLE = /^\s*(\d+)\s*([smhdw])\s*$/i;
+const DURATION_RE_ISO = /^P(?:(?:(\d+)D))?(?:T(?:(?:(\d+)H))?(?:(?:(\d+)M))?(?:(?:(\d+)S))?)?$/i;
+function scaleDuration(n, unit) {
+    const u = unit.toLowerCase();
+    if (u === "s")
+        return n * 1000;
+    if (u === "m")
+        return n * 60 * 1000;
+    if (u === "h")
+        return n * 60 * 60 * 1000;
+    if (u === "d")
+        return n * 24 * 60 * 60 * 1000;
+    if (u === "w")
+        return n * 7 * 24 * 60 * 60 * 1000;
+    throw new Error(`unknown duration unit ${unit}`);
+}
+/** Parse duration string into milliseconds (Python timedelta equivalent). */
+export function parseDurationMs(raw) {
+    if (typeof raw !== "string") {
+        throw new Error(`duration must be a string, got ${typeof raw}`);
+    }
+    const text = raw.trim();
+    if (!text) {
+        throw new Error("duration must be a non-empty string");
+    }
+    const simple = DURATION_RE_SIMPLE.exec(text);
+    if (simple) {
+        return scaleDuration(Number(simple[1]), simple[2] ?? "s");
+    }
+    const iso = DURATION_RE_ISO.exec(text);
+    if (iso && (iso[1] ?? iso[2] ?? iso[3] ?? iso[4])) {
+        const days = Number(iso[1] ?? 0);
+        const hours = Number(iso[2] ?? 0);
+        const minutes = Number(iso[3] ?? 0);
+        const seconds = Number(iso[4] ?? 0);
+        return (days * 24 * 60 * 60 * 1000 + hours * 60 * 60 * 1000 + minutes * 60 * 1000 + seconds * 1000);
+    }
+    throw new Error(`invalid duration ${JSON.stringify(raw)}: expected '<N>(s|m|h|d|w)' ` +
+        "(e.g. '7d', '24h') or ISO-8601 'PnDTnHnMnS' (e.g. 'P7D', 'PT24H')");
+}
+export function parseDuration(raw) {
+    return { ms: parseDurationMs(raw) };
+}
+//# sourceMappingURL=duration.js.map

package/dist/triage/scope/evaluate.d.ts

@@ -0,0 +1,18 @@
+import { type OpenMilestonesFetcher } from "./milestone.js";
+export interface EvaluateRulesOptions {
+    readonly now?: Date;
+    readonly vbriefReferenced?: ReadonlySet<number>;
+    readonly vbriefActiveReferenced?: ReadonlySet<number>;
+    readonly umbrellaSlices?: ReadonlySet<number>;
+    readonly openMilestonesFetcher?: OpenMilestonesFetcher;
+    readonly repo?: string | null;
+    readonly defaultOpenMilestonesFetcher?: (repo: string | null) => Set<string>;
+}
+declare function isOpen(issue: Record<string, unknown>): boolean;
+declare function issueNumber(issue: Record<string, unknown>): number;
+declare function labelNames(issue: Record<string, unknown>): Set<string>;
+declare function milestoneName(issue: Record<string, unknown>): string;
+/** Apply scope rules to issues; returns union of matches sorted by number. */
+export declare function evaluateRules(rules: Iterable<Record<string, unknown>>, issues: Iterable<Record<string, unknown>>, options?: EvaluateRulesOptions): Record<string, unknown>[];
+export { isOpen, issueNumber, labelNames, milestoneName };
+//# sourceMappingURL=evaluate.d.ts.map

package/dist/triage/scope/evaluate.js

@@ -0,0 +1,161 @@
+import { DEFAULT_TRIAGE_SCOPE } from "./constants.js";
+import { parseDurationMs } from "./duration.js";
+import { evaluateMilestoneRuleInto, makeOpenMilestonesResolver, } from "./milestone.js";
+import { parseIso } from "./time.js";
+function isOpen(issue) {
+    return issue.state === undefined ? true : issue.state === "open";
+}
+function issueNumber(issue) {
+    const n = issue.number;
+    return typeof n === "number" && Number.isInteger(n) ? n : 0;
+}
+function labelNames(issue) {
+    const names = new Set();
+    const raw = issue.labels;
+    if (!Array.isArray(raw))
+        return names;
+    for (const item of raw) {
+        if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+            const name = item.name;
+            if (typeof name === "string")
+                names.add(name);
+        }
+        else if (typeof item === "string") {
+            names.add(item);
+        }
+    }
+    return names;
+}
+function milestoneName(issue) {
+    const raw = issue.milestone;
+    if (typeof raw === "object" && raw !== null && !Array.isArray(raw)) {
+        const rec = raw;
+        const title = rec.title;
+        if (typeof title === "string")
+            return title;
+        const alt = rec.name;
+        if (typeof alt === "string")
+            return alt;
+        return "";
+    }
+    if (typeof raw === "string")
+        return raw;
+    return "";
+}
+function tsAfter(stamp, cutoff) {
+    if (typeof stamp !== "string" || !stamp)
+        return false;
+    try {
+        const dt = parseIso(stamp);
+        return dt >= cutoff;
+    }
+    catch {
+        return false;
+    }
+}
+const noopFetcher = () => new Set();
+/** Apply scope rules to issues; returns union of matches sorted by number. */
+export function evaluateRules(rules, issues, options = {}) {
+    const ruleList = [...rules];
+    const effectiveRules = ruleList.length > 0 ? ruleList : DEFAULT_TRIAGE_SCOPE.map((r) => ({ ...r }));
+    const issueList = [...issues];
+    const nowDt = options.now ?? new Date();
+    const matched = new Map();
+    const resolveOpen = makeOpenMilestonesResolver(options.openMilestonesFetcher, issueList, options.repo ?? null, options.defaultOpenMilestonesFetcher ?? noopFetcher);
+    const helpers = {
+        getOpenMilestones: resolveOpen,
+        isOpenIssue: isOpen,
+        issueNumber,
+        milestoneName,
+    };
+    for (const rule of effectiveRules) {
+        if (typeof rule !== "object" || rule === null || Array.isArray(rule))
+            continue;
+        const kind = rule.rule;
+        if (kind === "all-open") {
+            for (const issue of issueList) {
+                if (isOpen(issue))
+                    matched.set(issueNumber(issue), issue);
+            }
+        }
+        else if (kind === "labels") {
+            const wantedAny = rule["any-of"];
+            const wantedAll = rule["all-of"];
+            for (const issue of issueList) {
+                if (!isOpen(issue))
+                    continue;
+                const names = labelNames(issue);
+                const hitAny = Array.isArray(wantedAny) &&
+                    wantedAny.some((label) => typeof label === "string" && names.has(label));
+                const hitAll = Array.isArray(wantedAll) &&
+                    wantedAll.every((label) => typeof label === "string" && names.has(label));
+                if (hitAny || hitAll)
+                    matched.set(issueNumber(issue), issue);
+            }
+        }
+        else if (kind === "opened-since") {
+            const cutoff = new Date(nowDt.getTime() - parseDurationMs(String(rule.duration)));
+            for (const issue of issueList) {
+                if (isOpen(issue) && tsAfter(issue.created_at, cutoff)) {
+                    matched.set(issueNumber(issue), issue);
+                }
+            }
+        }
+        else if (kind === "updated-since") {
+            const cutoff = new Date(nowDt.getTime() - parseDurationMs(String(rule.duration)));
+            for (const issue of issueList) {
+                if (isOpen(issue) && tsAfter(issue.updated_at, cutoff)) {
+                    matched.set(issueNumber(issue), issue);
+                }
+            }
+        }
+        else if (kind === "referenced-by-vbrief") {
+            const scope = rule.scope ?? "any";
+            const refSet = scope === "active"
+                ? (options.vbriefActiveReferenced ?? new Set())
+                : (options.vbriefReferenced ?? new Set());
+            for (const issue of issueList) {
+                const n = issueNumber(issue);
+                if (isOpen(issue) && refSet.has(n))
+                    matched.set(n, issue);
+            }
+        }
+        else if (kind === "sliced-from") {
+            const slices = options.umbrellaSlices ?? new Set();
+            for (const issue of issueList) {
+                const n = issueNumber(issue);
+                if (isOpen(issue) && slices.has(n))
+                    matched.set(n, issue);
+            }
+        }
+        else if (kind === "explicit-watch") {
+            const issuesList = rule.issues;
+            const pinned = new Set();
+            if (Array.isArray(issuesList)) {
+                for (const e of issuesList) {
+                    if (typeof e === "object" && e !== null && !Array.isArray(e)) {
+                        const n = e.n;
+                        if (typeof n === "number" && Number.isInteger(n))
+                            pinned.add(n);
+                    }
+                }
+            }
+            for (const issue of issueList) {
+                const n = issueNumber(issue);
+                if (pinned.has(n))
+                    matched.set(n, issue);
+            }
+        }
+        else if (kind === "milestone") {
+            evaluateMilestoneRuleInto(rule, issueList, matched, helpers);
+        }
+    }
+    return [...matched.keys()]
+        .sort((a, b) => a - b)
+        .map((k) => {
+        const issue = matched.get(k);
+        return issue ?? {};
+    });
+}
+export { isOpen, issueNumber, labelNames, milestoneName };
+//# sourceMappingURL=evaluate.js.map

package/dist/triage/scope/index.d.ts

@@ -0,0 +1,14 @@
+export { CLI_HELP, parseCliArgs, run, runCliCapture } from "./cli.js";
+export * from "./constants.js";
+export * from "./coverage.js";
+export * from "./duration.js";
+export * from "./evaluate.js";
+export * from "./milestone.js";
+export * from "./mutations.js";
+export { addIgnore, ProjectDefinitionIOError, recordSubscriptionChange, subscribe, } from "./mutations-core.js";
+export * from "./normalize.js";
+export * from "./renderers.js";
+export * from "./resolve.js";
+export * from "./time.js";
+export * from "./validate.js";
+//# sourceMappingURL=index.d.ts.map