@deftai/directive-core 0.55.0

package/dist/triage/scope/index.js

@@ -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.js.map

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

@@ -0,0 +1,13 @@
+export declare function validateMilestoneRule(rule: Record<string, unknown>, prefix: string, errors: string[], warnings: string[]): void;
+export declare function collectMilestoneSubscribedNames(rules: Iterable<Record<string, unknown>>): Set<string>;
+export declare function rulesRequestIsOpen(rules: Iterable<Record<string, unknown>>): boolean;
+export declare function inferRepoFromIssues(issues: Iterable<Record<string, unknown>>): string | null;
+export type OpenMilestonesFetcher = () => Set<string> | readonly string[];
+export declare function makeOpenMilestonesResolver(fetcher: OpenMilestonesFetcher | null | undefined, issues: readonly Record<string, unknown>[], repo: string | null | undefined, defaultFetcher: (repo: string | null) => Set<string>): () => Set<string>;
+export declare function evaluateMilestoneRuleInto(rule: Record<string, unknown>, issues: readonly Record<string, unknown>[], matched: Map<number, Record<string, unknown>>, helpers: {
+    getOpenMilestones: () => Set<string>;
+    isOpenIssue: (issue: Record<string, unknown>) => boolean;
+    issueNumber: (issue: Record<string, unknown>) => number;
+    milestoneName: (issue: Record<string, unknown>) => string;
+}): void;
+//# sourceMappingURL=milestone.d.ts.map

package/dist/triage/scope/milestone.js

@@ -0,0 +1,178 @@
+import { pythonTypeName } from "./python-repr.js";
+const MILESTONE_VARIANT_KEYS = ["name", "any-of", "is-open"];
+const MILESTONE_ALL_KEYS = new Set(["rule", ...MILESTONE_VARIANT_KEYS]);
+export function validateMilestoneRule(rule, prefix, errors, warnings) {
+    const hasName = "name" in rule;
+    const hasAny = "any-of" in rule;
+    const hasOpen = "is-open" in rule;
+    const setCount = [hasName, hasAny, hasOpen].filter(Boolean).length;
+    if (setCount === 0) {
+        errors.push(`${prefix}.milestone requires one of 'name' / 'any-of' / ` +
+            "'is-open: true' (D14b / #1181); see " +
+            "scripts/triage_scope.py for the variant matrix");
+        return;
+    }
+    if (setCount > 1) {
+        const present = MILESTONE_VARIANT_KEYS.filter((k) => k in rule);
+        errors.push(`${prefix}.milestone: ${JSON.stringify(present)} are mutually exclusive; ` +
+            "choose exactly one of name / any-of / is-open (#1181)");
+        return;
+    }
+    if (hasName) {
+        const name = rule.name;
+        if (typeof name !== "string" || !name.trim()) {
+            errors.push(`${prefix}.milestone.name must be a non-empty string`);
+        }
+        return;
+    }
+    if (hasAny) {
+        const anyOf = rule["any-of"];
+        if (!Array.isArray(anyOf) || anyOf.length === 0) {
+            errors.push(`${prefix}.milestone.any-of must be a non-empty list of strings (#1181)`);
+            return;
+        }
+        for (let j = 0; j < anyOf.length; j += 1) {
+            const item = anyOf[j];
+            if (typeof item !== "string" || !item) {
+                errors.push(`${prefix}.milestone.any-of[${j}] must be a non-empty string`);
+            }
+        }
+        return;
+    }
+    const isOpen = rule["is-open"];
+    if (typeof isOpen !== "boolean") {
+        errors.push(`${prefix}.milestone.is-open must be a boolean literal \`true\`; ` +
+            `got ${pythonTypeName(isOpen)} (#1181)`);
+        return;
+    }
+    if (isOpen === false) {
+        errors.push(`${prefix}.milestone.is-open: false is meaningless -- ` +
+            "to subscribe to specific milestones use `name` or " +
+            "`any-of` (#1181)");
+        return;
+    }
+    const extra = Object.keys(rule)
+        .filter((k) => !MILESTONE_ALL_KEYS.has(k))
+        .sort();
+    if (extra.length > 0) {
+        warnings.push(`${prefix}.milestone: ignoring unrecognised keys ${JSON.stringify(extra)}`);
+    }
+}
+export function collectMilestoneSubscribedNames(rules) {
+    const out = new Set();
+    for (const rule of rules) {
+        if (rule.rule !== "milestone")
+            continue;
+        const name = rule.name;
+        if (typeof name === "string" && name)
+            out.add(name);
+        const anyOf = rule["any-of"];
+        if (Array.isArray(anyOf)) {
+            for (const item of anyOf) {
+                if (typeof item === "string" && item)
+                    out.add(item);
+            }
+        }
+    }
+    return out;
+}
+export function rulesRequestIsOpen(rules) {
+    for (const r of rules) {
+        if (r.rule === "milestone" && r["is-open"] === true)
+            return true;
+    }
+    return false;
+}
+const GITHUB_HOSTNAMES = new Set(["github.com", "api.github.com"]);
+export function inferRepoFromIssues(issues) {
+    for (const issue of issues) {
+        for (const key of ["repository_url", "html_url"]) {
+            const value = issue[key];
+            if (typeof value !== "string" || !value)
+                continue;
+            let parsed;
+            try {
+                parsed = new URL(value);
+            }
+            catch {
+                continue;
+            }
+            const host = (parsed.hostname ?? "").toLowerCase();
+            if (!GITHUB_HOSTNAMES.has(host))
+                continue;
+            const segments = parsed.pathname.split("/").filter((s) => s.length > 0);
+            let owner;
+            let name;
+            if (segments[0] === "repos" && segments.length >= 3) {
+                owner = segments[1];
+                name = segments[2];
+            }
+            else if (segments.length >= 2) {
+                owner = segments[0];
+                name = segments[1];
+            }
+            if (owner && name)
+                return `${owner}/${name}`;
+        }
+    }
+    return null;
+}
+export function makeOpenMilestonesResolver(fetcher, issues, repo, defaultFetcher) {
+    let cached = null;
+    return () => {
+        if (cached !== null)
+            return cached;
+        if (fetcher !== null && fetcher !== undefined) {
+            try {
+                const raw = fetcher();
+                cached = new Set(Array.isArray(raw) ? raw : [...raw]);
+            }
+            catch {
+                cached = new Set();
+            }
+        }
+        else {
+            const resolvedRepo = repo ?? inferRepoFromIssues(issues);
+            cached = defaultFetcher(resolvedRepo);
+        }
+        return cached;
+    };
+}
+export function evaluateMilestoneRuleInto(rule, issues, matched, helpers) {
+    if ("name" in rule) {
+        const wanted = rule.name;
+        if (typeof wanted !== "string" || !wanted)
+            return;
+        for (const issue of issues) {
+            if (helpers.isOpenIssue(issue) && helpers.milestoneName(issue) === wanted) {
+                matched.set(helpers.issueNumber(issue), issue);
+            }
+        }
+        return;
+    }
+    if ("any-of" in rule) {
+        const raw = rule["any-of"];
+        if (!Array.isArray(raw) || raw.length === 0)
+            return;
+        const wantedSet = new Set(raw.filter((w) => typeof w === "string" && Boolean(w)));
+        if (wantedSet.size === 0)
+            return;
+        for (const issue of issues) {
+            if (helpers.isOpenIssue(issue) && wantedSet.has(helpers.milestoneName(issue))) {
+                matched.set(helpers.issueNumber(issue), issue);
+            }
+        }
+        return;
+    }
+    if (rule["is-open"] === true) {
+        const openSet = helpers.getOpenMilestones();
+        if (openSet.size === 0)
+            return;
+        for (const issue of issues) {
+            if (helpers.isOpenIssue(issue) && openSet.has(helpers.milestoneName(issue))) {
+                matched.set(helpers.issueNumber(issue), issue);
+            }
+        }
+    }
+}
+//# sourceMappingURL=milestone.js.map

package/dist/triage/scope/mutations-core.d.ts

@@ -0,0 +1,24 @@
+export declare class ProjectDefinitionIOError extends Error {
+    readonly name = "ProjectDefinitionIOError";
+}
+export declare function projectDefinitionPath(projectRoot: string): string;
+export declare function loadProjectDefinitionForMutation(projectRoot: string): [Record<string, unknown>, string];
+export declare function atomicWriteProjectDefinition(path: string, data: Record<string, unknown>): void;
+export declare function recordSubscriptionChange(projectRoot: string, options: {
+    op: string;
+    label?: string | null;
+    milestone?: string | null;
+    issue?: number | null;
+    author?: string | null;
+    before?: unknown[];
+    after?: unknown[];
+    actor?: string | null;
+    extra?: Record<string, unknown>;
+}): void;
+export declare function subscribe(projectRoot: string, options: {
+    label?: string;
+    milestone?: string;
+    actor?: string | null;
+}): [boolean, string];
+export declare function addIgnore(projectRoot: string, label: string): [boolean, string];
+//# sourceMappingURL=mutations-core.d.ts.map

package/dist/triage/scope/mutations-core.js

@@ -0,0 +1,216 @@
+import { randomUUID } from "node:crypto";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { PROJECT_DEFINITION_REL_PATH, SUBSCRIPTION_HISTORY_REL_PATH, SUBSCRIPTION_HISTORY_SCHEMA, } from "./constants.js";
+import { pyStrRepr } from "./python-repr.js";
+import { utcIso } from "./time.js";
+export class ProjectDefinitionIOError extends Error {
+    name = "ProjectDefinitionIOError";
+}
+export function projectDefinitionPath(projectRoot) {
+    return join(projectRoot, PROJECT_DEFINITION_REL_PATH);
+}
+export function loadProjectDefinitionForMutation(projectRoot) {
+    const path = projectDefinitionPath(projectRoot);
+    if (!existsSync(path)) {
+        throw new ProjectDefinitionIOError(`PROJECT-DEFINITION not found at ${path}; run task triage:welcome / ` +
+            "task triage:bootstrap to scaffold one first.");
+    }
+    let raw;
+    try {
+        raw = readFileSync(path, "utf8");
+    }
+    catch (err) {
+        throw new ProjectDefinitionIOError(`Could not read PROJECT-DEFINITION at ${path}: ${String(err)}`);
+    }
+    let data;
+    try {
+        data = JSON.parse(raw);
+    }
+    catch (err) {
+        throw new ProjectDefinitionIOError(`PROJECT-DEFINITION at ${path} is not valid JSON: ${String(err)}`);
+    }
+    if (typeof data !== "object" || data === null || Array.isArray(data)) {
+        throw new ProjectDefinitionIOError(`PROJECT-DEFINITION at ${path} top-level value is not a JSON object`);
+    }
+    return [data, path];
+}
+export function atomicWriteProjectDefinition(path, data) {
+    mkdirSync(dirname(path), { recursive: true });
+    const payload = `${JSON.stringify(data, null, 2)}\n`;
+    const tmp = join(tmpdir(), `${randomUUID()}.tmp`);
+    writeFileSync(tmp, payload, "utf8");
+    renameSync(tmp, path);
+}
+function resolveActor(actor) {
+    if (typeof actor === "string" && actor.trim())
+        return actor;
+    const envActor = process.env.DEFT_TRIAGE_ACTOR;
+    if (typeof envActor === "string" && envActor.trim())
+        return envActor;
+    try {
+        const user = process.env.USER ?? process.env.USERNAME ?? "unknown";
+        return `user:${user}`;
+    }
+    catch {
+        return "user:unknown";
+    }
+}
+export function recordSubscriptionChange(projectRoot, options) {
+    const historyPath = join(projectRoot, SUBSCRIPTION_HISTORY_REL_PATH);
+    const record = {
+        schema: SUBSCRIPTION_HISTORY_SCHEMA,
+        change_id: randomUUID(),
+        timestamp: utcIso(),
+        actor: resolveActor(options.actor),
+        op: options.op,
+        label: options.label ?? null,
+        milestone: options.milestone ?? null,
+        issue: options.issue ?? null,
+        author: options.author ?? null,
+        before: options.before ?? [],
+        after: options.after ?? [],
+    };
+    if (options.extra)
+        record.extra = options.extra;
+    const line = JSON.stringify(record, Object.keys(record).sort());
+    try {
+        mkdirSync(dirname(historyPath), { recursive: true });
+        appendFileSync(historyPath, `${line}\n`, "utf8");
+    }
+    catch {
+        // observability only
+    }
+}
+function snapshotRules(rules) {
+    return JSON.parse(JSON.stringify(rules));
+}
+function applySubscribeLabel(rules, label) {
+    for (const rule of rules) {
+        if (typeof rule === "object" &&
+            rule !== null &&
+            !Array.isArray(rule) &&
+            rule.rule === "labels" &&
+            Array.isArray(rule["any-of"])) {
+            const rec = rule;
+            const anyOf = rec["any-of"];
+            if (anyOf.includes(label)) {
+                return [false, `already-subscribed (labels.any-of contains ${pyStrRepr(label)})`];
+            }
+            anyOf.push(label);
+            return [true, `added ${pyStrRepr(label)} to existing labels.any-of`];
+        }
+    }
+    rules.push({ rule: "labels", "any-of": [label] });
+    return [true, `created new labels.any-of rule for ${pyStrRepr(label)}`];
+}
+function applySubscribeMilestone(rules, milestone) {
+    for (const rule of rules) {
+        if (typeof rule === "object" &&
+            rule !== null &&
+            !Array.isArray(rule) &&
+            rule.rule === "milestone" &&
+            rule.name === milestone) {
+            return [false, `already-subscribed (milestone ${pyStrRepr(milestone)})`];
+        }
+    }
+    rules.push({ rule: "milestone", name: milestone });
+    return [true, `added milestone rule for ${pyStrRepr(milestone)}`];
+}
+export function subscribe(projectRoot, options) {
+    const chosen = [
+        options.label !== undefined ? "label" : null,
+        options.milestone !== undefined ? "milestone" : null,
+    ].filter(Boolean);
+    if (chosen.length !== 1) {
+        throw new Error(`subscribe() requires exactly one of --label / --milestone / --issue; got ${JSON.stringify(chosen)}`);
+    }
+    const [data, path] = loadProjectDefinitionForMutation(projectRoot);
+    const plan = data.plan;
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+        throw new Error(`PROJECT-DEFINITION at ${path} has a non-object 'plan' key`);
+    }
+    const planRec = plan;
+    if (planRec.policy === undefined)
+        planRec.policy = {};
+    const policy = planRec.policy;
+    if (typeof policy !== "object" || policy === null || Array.isArray(policy)) {
+        throw new Error(`PROJECT-DEFINITION at ${path} has a non-object 'plan.policy' key`);
+    }
+    const policyRec = policy;
+    if (policyRec.triageScope === undefined)
+        policyRec.triageScope = [];
+    const rules = policyRec.triageScope;
+    if (!Array.isArray(rules)) {
+        throw new Error(`PROJECT-DEFINITION at ${path} has a non-list 'plan.policy.triageScope'`);
+    }
+    const before = snapshotRules(rules);
+    let changed;
+    let message;
+    if (options.label !== undefined) {
+        [changed, message] = applySubscribeLabel(rules, options.label);
+    }
+    else if (options.milestone !== undefined) {
+        [changed, message] = applySubscribeMilestone(rules, options.milestone);
+    }
+    else {
+        throw new Error("subscribe() requires exactly one of label or milestone");
+    }
+    if (!changed)
+        return [false, message];
+    atomicWriteProjectDefinition(path, data);
+    recordSubscriptionChange(projectRoot, {
+        op: "subscribe",
+        label: options.label ?? null,
+        milestone: options.milestone ?? null,
+        before,
+        after: snapshotRules(rules),
+        actor: options.actor,
+    });
+    return [true, message];
+}
+export function addIgnore(projectRoot, label) {
+    if (!label.trim())
+        throw new Error(`label must be a non-empty string; got ${JSON.stringify(label)}`);
+    const [data, path] = loadProjectDefinitionForMutation(projectRoot);
+    const plan = data.plan;
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+        throw new Error(`PROJECT-DEFINITION at ${path} has a non-object 'plan' key`);
+    }
+    const planRec = plan;
+    if (planRec.policy === undefined)
+        planRec.policy = {};
+    const policy = planRec.policy;
+    if (typeof policy !== "object" || policy === null || Array.isArray(policy)) {
+        throw new Error(`PROJECT-DEFINITION at ${path} has a non-object 'plan.policy' key`);
+    }
+    const policyRec = policy;
+    if (policyRec.triageScopeIgnores === undefined)
+        policyRec.triageScopeIgnores = [];
+    const raw = policyRec.triageScopeIgnores;
+    if (!Array.isArray(raw)) {
+        throw new Error(`PROJECT-DEFINITION at ${path} has a non-list 'plan.policy.triageScopeIgnores'`);
+    }
+    const before = snapshotRules(raw);
+    for (const entry of raw) {
+        if (typeof entry === "object" &&
+            entry !== null &&
+            !Array.isArray(entry) &&
+            entry.label === label) {
+            return [false, `already-ignored (label=${label})`];
+        }
+    }
+    raw.push({ label });
+    atomicWriteProjectDefinition(path, data);
+    const after = snapshotRules(raw);
+    recordSubscriptionChange(projectRoot, {
+        op: "ignore-label",
+        label,
+        before,
+        after,
+        actor: null,
+    });
+    return [true, `added ignore (label=${label})`];
+}
+//# sourceMappingURL=mutations-core.js.map

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

@@ -0,0 +1,21 @@
+export interface DiffReport {
+    readonly subscribedLabels: ReadonlySet<string>;
+    readonly ignoredLabels: ReadonlySet<string>;
+    readonly neitherLabels: ReadonlySet<string>;
+    readonly subscribedMilestones: ReadonlySet<string>;
+    readonly ignoredMilestones: ReadonlySet<string>;
+    readonly neitherMilestones: ReadonlySet<string>;
+    readonly repo: string;
+}
+export declare function computeDiffFromUpstream(projectRoot: string, options: {
+    upstreamLabels: Set<string>;
+    upstreamMilestones: Set<string>;
+    repo?: string;
+    openMilestonesSnapshot?: Set<string>;
+}): DiffReport;
+export declare function renderDiffReport(report: DiffReport): string;
+export declare function fetchUpstreamLabelsAndMilestones(repo: string, binary?: string): [Set<string>, Set<string>];
+export declare function addLabelToScope(projectRoot: string, label: string, actor?: string | null): [boolean, string];
+export declare function addMilestoneToScope(projectRoot: string, milestone: string, actor?: string | null): [boolean, string];
+export declare function addLabelToIgnores(projectRoot: string, label: string): [boolean, string];
+//# sourceMappingURL=mutations.d.ts.map

package/dist/triage/scope/mutations.js

@@ -0,0 +1,203 @@
+import { spawnSync } from "node:child_process";
+import { SUBPROCESS_MAX_BUFFER } from "../../subprocess/max-buffer.js";
+import { collectMilestoneSubscribedNames, rulesRequestIsOpen } from "./milestone.js";
+import { addIgnore, subscribe } from "./mutations-core.js";
+import { resolveScopeIgnores, resolveScopeRules } from "./resolve.js";
+function subscribedLabels(rules) {
+    const out = new Set();
+    for (const rule of rules) {
+        if (rule.rule !== "labels")
+            continue;
+        for (const key of ["any-of", "all-of"]) {
+            const value = rule[key];
+            if (Array.isArray(value)) {
+                for (const label of value) {
+                    if (typeof label === "string" && label)
+                        out.add(label);
+                }
+            }
+        }
+    }
+    return out;
+}
+function subscribedMilestones(rules, openSnapshot) {
+    const out = collectMilestoneSubscribedNames(rules);
+    if (rulesRequestIsOpen(rules) && openSnapshot) {
+        for (const name of openSnapshot)
+            out.add(name);
+    }
+    return out;
+}
+export function computeDiffFromUpstream(projectRoot, options) {
+    const rules = resolveScopeRules(projectRoot);
+    const ignores = resolveScopeIgnores(projectRoot);
+    const subLabels = subscribedLabels(rules);
+    const subMs = subscribedMilestones(rules, options.openMilestonesSnapshot);
+    const ignLabels = ignores.labels;
+    const ignMs = ignores.milestones;
+    const subscribedLabelSet = new Set();
+    const ignoredLabelSet = new Set();
+    const neitherLabelSet = new Set();
+    for (const name of options.upstreamLabels) {
+        if (!name)
+            continue;
+        if (subLabels.has(name))
+            subscribedLabelSet.add(name);
+        else if (ignLabels.has(name))
+            ignoredLabelSet.add(name);
+        else
+            neitherLabelSet.add(name);
+    }
+    const subscribedMsSet = new Set();
+    const ignoredMsSet = new Set();
+    const neitherMsSet = new Set();
+    for (const name of options.upstreamMilestones) {
+        if (!name)
+            continue;
+        if (subMs.has(name))
+            subscribedMsSet.add(name);
+        else if (ignMs.has(name))
+            ignoredMsSet.add(name);
+        else
+            neitherMsSet.add(name);
+    }
+    return {
+        subscribedLabels: subscribedLabelSet,
+        ignoredLabels: ignoredLabelSet,
+        neitherLabels: neitherLabelSet,
+        subscribedMilestones: subscribedMsSet,
+        ignoredMilestones: ignoredMsSet,
+        neitherMilestones: neitherMsSet,
+        repo: options.repo ?? "",
+    };
+}
+function fmtBucket(bucket) {
+    if (bucket.size === 0)
+        return "-";
+    return [...bucket].sort().join(", ");
+}
+export function renderDiffReport(report) {
+    const lines = [];
+    const repoSuffix = report.repo ? ` (repo: ${report.repo})` : "";
+    lines.push(`triage:scope --diff-from-upstream${repoSuffix}`);
+    lines.push("Labels:");
+    lines.push(`  subscribed (${report.subscribedLabels.size}): ${fmtBucket(report.subscribedLabels)}`);
+    lines.push(`  ignored    (${report.ignoredLabels.size}): ${fmtBucket(report.ignoredLabels)}`);
+    lines.push(`  neither    (${report.neitherLabels.size}): ${fmtBucket(report.neitherLabels)}`);
+    lines.push("Milestones:");
+    lines.push(`  subscribed (${report.subscribedMilestones.size}): ${fmtBucket(report.subscribedMilestones)}`);
+    lines.push(`  ignored    (${report.ignoredMilestones.size}): ${fmtBucket(report.ignoredMilestones)}`);
+    lines.push(`  neither    (${report.neitherMilestones.size}): ${fmtBucket(report.neitherMilestones)}`);
+    if (report.neitherLabels.size > 0 || report.neitherMilestones.size > 0) {
+        lines.push("");
+        lines.push("To act on 'neither' items: task triage:scope -- --add-label=<L> / " +
+            "--add-milestone=<M> / --ignore-label=<L>");
+    }
+    return lines.join("\n");
+}
+function rawDecodeJson(text, offset) {
+    for (let end = offset + 1; end <= text.length; end += 1) {
+        try {
+            const obj = JSON.parse(text.slice(offset, end));
+            return [obj, end - offset];
+        }
+        catch {
+            // keep extending
+        }
+    }
+    throw new SyntaxError("invalid JSON");
+}
+function addNamesFromList(data, nameField, names) {
+    if (!Array.isArray(data)) {
+        throw new Error("non-list payload");
+    }
+    for (const item of data) {
+        if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+            const value = item[nameField];
+            if (typeof value === "string" && value)
+                names.add(value);
+        }
+    }
+}
+function parseGhPaginatedNames(stdout, nameField) {
+    const names = new Set();
+    const text = stdout.trim();
+    if (!text)
+        return names;
+    try {
+        addNamesFromList(JSON.parse(text), nameField, names);
+        return names;
+    }
+    catch {
+        // Paginate may concatenate arrays; decode one document at a time.
+    }
+    let idx = 0;
+    while (idx < text.length) {
+        while (idx < text.length && /\s/.test(text[idx] ?? ""))
+            idx += 1;
+        if (idx >= text.length)
+            break;
+        try {
+            const [obj, consumed] = rawDecodeJson(text, idx);
+            addNamesFromList(obj, nameField, names);
+            idx += consumed;
+        }
+        catch (err) {
+            throw new Error(`\`gh api\` returned non-JSON output: ${String(err)}`);
+        }
+    }
+    return names;
+}
+function fetchNamesViaGh(binary, path, nameField) {
+    let proc;
+    try {
+        proc = spawnSync(binary, ["api", "--paginate", path], {
+            encoding: "utf8",
+            timeout: 30_000,
+            maxBuffer: SUBPROCESS_MAX_BUFFER,
+        });
+    }
+    catch {
+        throw new Error(`\`${binary} api ${path}\` timed out after 30s -- check your network.`);
+    }
+    if (proc.error) {
+        const errCode = proc.error.code;
+        if (errCode === "ENOENT") {
+            throw new Error(`\`${binary}\` not found on PATH -- install GitHub CLI to use ` +
+                "`task triage:scope -- --diff-from-upstream`.");
+        }
+        if (proc.error.message?.includes("ETIMEDOUT")) {
+            throw new Error(`\`${binary} api ${path}\` timed out after 30s -- check your network.`);
+        }
+    }
+    if (proc.status !== 0) {
+        const errText = String(proc.stderr ?? proc.stdout ?? "").trim() || (proc.error ? proc.error.message : "");
+        throw new Error(`\`${binary} api ${path}\` failed (exit ${proc.status ?? 1}): ${errText}`);
+    }
+    return parseGhPaginatedNames(String(proc.stdout ?? ""), nameField);
+}
+export function fetchUpstreamLabelsAndMilestones(repo, binary = "gh") {
+    if (!repo.includes("/")) {
+        throw new Error(`--repo must be 'owner/name'; got ${JSON.stringify(repo)}. Pass --repo OR set $DEFT_TRIAGE_REPO.`);
+    }
+    const labels = fetchNamesViaGh(binary, `repos/${repo}/labels?per_page=100`, "name");
+    const milestones = fetchNamesViaGh(binary, `repos/${repo}/milestones?per_page=100&state=open`, "title");
+    return [labels, milestones];
+}
+export function addLabelToScope(projectRoot, label, actor) {
+    if (!label.trim())
+        throw new Error(`label must be a non-empty string; got ${JSON.stringify(label)}`);
+    return subscribe(projectRoot, { label, actor });
+}
+export function addMilestoneToScope(projectRoot, milestone, actor) {
+    if (!milestone.trim()) {
+        throw new Error(`milestone must be a non-empty string; got ${JSON.stringify(milestone)}`);
+    }
+    return subscribe(projectRoot, { milestone, actor });
+}
+export function addLabelToIgnores(projectRoot, label) {
+    if (!label.trim())
+        throw new Error(`label must be a non-empty string; got ${JSON.stringify(label)}`);
+    return addIgnore(projectRoot, label);
+}
+//# sourceMappingURL=mutations.js.map

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

@@ -0,0 +1,5 @@
+/** Stable canonical-ordered copy of scope rules for hashing. */
+export declare function normalizeScopeRules(rules: Iterable<Record<string, unknown>>): Record<string, unknown>[];
+/** Stable canonical-JSON SHA-256 digest truncated to SUBSCRIPTION_HASH_LEN. */
+export declare function subscriptionHash(rules: Iterable<Record<string, unknown>>): string;
+//# sourceMappingURL=normalize.d.ts.map