@deftai/directive-core 0.55.0

package/dist/triage/scope/validate.js

@@ -0,0 +1,272 @@
+import { REFERENCED_BY_VBRIEF_SCOPES, SLICED_FROM_SCOPES, VALID_IGNORE_KEYS, VALID_IGNORE_RULES, VALID_RULE_TYPES, } from "./constants.js";
+import { parseDurationMs } from "./duration.js";
+import { validateMilestoneRule } from "./milestone.js";
+import { pyListRepr, pyStrRepr, pythonTypeName } from "./python-repr.js";
+const INDEXED_ERROR_RE = /^plan\.policy\.triageScopeIgnores\[(\d+)\]/;
+function validateRuleBody(rule, prefix, errors, warnings) {
+    const kind = rule.rule;
+    if (kind === "all-open") {
+        const extra = Object.keys(rule)
+            .filter((k) => k !== "rule")
+            .sort();
+        if (extra.length > 0) {
+            warnings.push(`${prefix}: all-open takes no parameters; ignoring extra keys ${JSON.stringify(extra)}`);
+        }
+        return;
+    }
+    if (kind === "labels") {
+        const anyOf = rule["any-of"];
+        const allOf = rule["all-of"];
+        if (anyOf === undefined && allOf === undefined) {
+            errors.push(`${prefix}.labels requires 'any-of' or 'all-of'`);
+            return;
+        }
+        if (anyOf !== undefined && allOf !== undefined) {
+            errors.push(`${prefix}.labels: 'any-of' and 'all-of' are mutually exclusive`);
+            return;
+        }
+        const target = anyOf !== undefined ? anyOf : allOf;
+        const which = anyOf !== undefined ? "any-of" : "all-of";
+        if (!Array.isArray(target) || target.length === 0) {
+            errors.push(`${prefix}.labels.${which} must be a non-empty list of strings`);
+            return;
+        }
+        for (let j = 0; j < target.length; j += 1) {
+            const label = target[j];
+            if (typeof label !== "string" || !label) {
+                errors.push(`${prefix}.labels.${which}[${j}] must be a non-empty string`);
+            }
+        }
+        return;
+    }
+    if (kind === "milestone") {
+        validateMilestoneRule(rule, prefix, errors, warnings);
+        return;
+    }
+    if (kind === "opened-since" || kind === "updated-since") {
+        const duration = rule.duration;
+        if (typeof duration !== "string" || !duration) {
+            errors.push(`${prefix}.${kind} requires a non-empty 'duration' string`);
+            return;
+        }
+        try {
+            parseDurationMs(duration);
+        }
+        catch (err) {
+            errors.push(`${prefix}.${kind}.duration: ${String(err)}`);
+        }
+        return;
+    }
+    if (kind === "referenced-by-vbrief") {
+        const scope = rule.scope;
+        if (!REFERENCED_BY_VBRIEF_SCOPES.has(String(scope))) {
+            errors.push(`${prefix}.referenced-by-vbrief.scope must be one of ` +
+                `${pyListRepr([...REFERENCED_BY_VBRIEF_SCOPES].sort())}; got ${pyStrRepr(String(scope))}`);
+        }
+        return;
+    }
+    if (kind === "sliced-from") {
+        const scope = rule.scope;
+        if (!SLICED_FROM_SCOPES.has(String(scope))) {
+            errors.push(`${prefix}.sliced-from.scope must be one of ` +
+                `${pyListRepr([...SLICED_FROM_SCOPES].sort())}; got ${pyStrRepr(String(scope))}`);
+        }
+        return;
+    }
+    if (kind === "explicit-watch") {
+        const issues = rule.issues;
+        if (!Array.isArray(issues) || issues.length === 0) {
+            errors.push(`${prefix}.explicit-watch.issues must be a non-empty list of ` +
+                "{n: <int>, note: <str>} objects");
+            return;
+        }
+        for (let j = 0; j < issues.length; j += 1) {
+            const entry = issues[j];
+            if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+                errors.push(`${prefix}.explicit-watch.issues[${j}] must be an object, ` +
+                    `got ${pythonTypeName(entry)}`);
+                continue;
+            }
+            const rec = entry;
+            const n = rec.n;
+            const note = rec.note;
+            if (typeof n !== "number" || !Number.isInteger(n) || n <= 0) {
+                errors.push(`${prefix}.explicit-watch.issues[${j}].n must be a positive integer`);
+            }
+            if (typeof note !== "string" || !note.trim()) {
+                errors.push(`${prefix}.explicit-watch.issues[${j}].note must be a non-empty string ` +
+                    "(Decision 4: per-issue note required for future-operator legibility)");
+            }
+        }
+    }
+}
+/** Validate plan.policy.triageScope payload (#1131). */
+export function validateScopeRules(rules) {
+    const errors = [];
+    const warnings = [];
+    if (rules === null || rules === undefined) {
+        return { errors, warnings };
+    }
+    if (!Array.isArray(rules)) {
+        errors.push(`plan.policy.triageScope must be a list of rule objects; got ${pythonTypeName(rules)}`);
+        return { errors, warnings };
+    }
+    for (let i = 0; i < rules.length; i += 1) {
+        const prefix = `plan.policy.triageScope[${i}]`;
+        const rule = rules[i];
+        if (typeof rule !== "object" || rule === null || Array.isArray(rule)) {
+            errors.push(`${prefix} must be an object, got ${pythonTypeName(rule)}`);
+            continue;
+        }
+        const rec = rule;
+        const kind = rec.rule;
+        if (typeof kind !== "string" || !kind) {
+            errors.push(`${prefix}.rule must be a non-empty string`);
+            continue;
+        }
+        if (!VALID_RULE_TYPES.has(kind)) {
+            errors.push(`${prefix}.rule ${pyStrRepr(kind)} is not a valid rule type; ` +
+                `expected one of ${pyListRepr([...VALID_RULE_TYPES].sort())}`);
+            continue;
+        }
+        validateRuleBody(rec, prefix, errors, warnings);
+    }
+    return { errors, warnings };
+}
+function validateSingleKeyIgnore(entry, prefix, errors, warnings) {
+    const known = Object.keys(entry)
+        .filter((k) => VALID_IGNORE_KEYS.has(k))
+        .sort();
+    const unknown = Object.keys(entry)
+        .filter((k) => !VALID_IGNORE_KEYS.has(k))
+        .sort();
+    if (known.length === 0) {
+        errors.push(`${prefix} must have a 'label' / 'milestone' key OR a ` +
+            `'rule' discriminator (v1 single-key keys: ${JSON.stringify([...VALID_IGNORE_KEYS].sort())}; ` +
+            `v1 rule kinds: ${JSON.stringify([...VALID_IGNORE_RULES].sort())})`);
+        return;
+    }
+    if (known.length > 1) {
+        errors.push(`${prefix}: 'label' and 'milestone' are mutually exclusive`);
+        return;
+    }
+    if (unknown.length > 0) {
+        warnings.push(`${prefix}: ignoring unrecognised keys ${JSON.stringify(unknown)} ` +
+            "(forward-compat: future ignore-entry variants will surface here)");
+    }
+    const key = known[0] ?? "label";
+    const value = entry[key];
+    if (typeof value !== "string" || !value.trim()) {
+        errors.push(`${prefix}.${key} must be a non-empty string`);
+    }
+}
+function validateRuleIgnore(entry, prefix, errors, warnings) {
+    const kind = entry.rule;
+    if (typeof kind !== "string" || !kind.trim()) {
+        errors.push(`${prefix}.rule must be a non-empty string`);
+        return;
+    }
+    if (!VALID_IGNORE_RULES.has(kind)) {
+        errors.push(`${prefix}.rule ${JSON.stringify(kind)} is not a recognised ignore-rule ` +
+            `kind; expected one of ${JSON.stringify([...VALID_IGNORE_RULES].sort())}`);
+        return;
+    }
+    if (kind === "author") {
+        const anyOf = entry["any-of"];
+        if (!Array.isArray(anyOf) || anyOf.length === 0) {
+            errors.push(`${prefix}.author requires 'any-of' as a non-empty list ` +
+                "of GitHub login strings (e.g. ['dependabot[bot]'])");
+            return;
+        }
+        for (let j = 0; j < anyOf.length; j += 1) {
+            const name = anyOf[j];
+            if (typeof name !== "string" || !name.trim()) {
+                errors.push(`${prefix}.author.any-of[${j}] must be a non-empty string`);
+            }
+        }
+        const extra = Object.keys(entry)
+            .filter((k) => k !== "rule" && k !== "any-of")
+            .sort();
+        if (extra.length > 0) {
+            warnings.push(`${prefix}.author: ignoring unrecognised keys ${JSON.stringify(extra)} ` +
+                "(forward-compat: future author-rule variants will surface here)");
+        }
+    }
+}
+/** Validate plan.policy.triageScopeIgnores payload (#1133 / #1182). */
+export function validateScopeIgnores(ignores) {
+    const errors = [];
+    const warnings = [];
+    if (ignores === null || ignores === undefined) {
+        return { errors, warnings };
+    }
+    if (!Array.isArray(ignores)) {
+        errors.push("plan.policy.triageScopeIgnores must be a list of " +
+            "{label|milestone: <name>} or {rule: <kind>, any-of: [...]} " +
+            `objects; got ${pythonTypeName(ignores)}`);
+        return { errors, warnings };
+    }
+    for (let i = 0; i < ignores.length; i += 1) {
+        const prefix = `plan.policy.triageScopeIgnores[${i}]`;
+        const entry = ignores[i];
+        if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+            errors.push(`${prefix} must be an object, got ${pythonTypeName(entry)}`);
+            continue;
+        }
+        const rec = entry;
+        if ("rule" in rec) {
+            validateRuleIgnore(rec, prefix, errors, warnings);
+        }
+        else {
+            validateSingleKeyIgnore(rec, prefix, errors, warnings);
+        }
+    }
+    return { errors, warnings };
+}
+function pointerForError(err, rawList) {
+    const match = INDEXED_ERROR_RE.exec(err);
+    if (match) {
+        const idx = Number(match[1]);
+        if (idx >= 0 && idx < rawList.length) {
+            const entry = rawList[idx];
+            if (typeof entry === "object" && entry !== null && !Array.isArray(entry) && "rule" in entry) {
+                return "#1182";
+            }
+        }
+    }
+    return "#1133";
+}
+export function validateTriageScopeOnPlan(plan, filepath) {
+    const out = [];
+    const policy = typeof plan === "object" && plan !== null && !Array.isArray(plan)
+        ? plan.policy
+        : undefined;
+    const rawScope = typeof policy === "object" && policy !== null && !Array.isArray(policy)
+        ? policy.triageScope
+        : undefined;
+    if (rawScope === undefined)
+        return out;
+    const { errors } = validateScopeRules(rawScope);
+    for (const err of errors) {
+        out.push(`${filepath}: ${err} (#1131)`);
+    }
+    return out;
+}
+export function validateTriageScopeIgnoresOnPlan(plan, filepath) {
+    const out = [];
+    const policy = typeof plan === "object" && plan !== null && !Array.isArray(plan)
+        ? plan.policy
+        : undefined;
+    const raw = typeof policy === "object" && policy !== null && !Array.isArray(policy)
+        ? policy.triageScopeIgnores
+        : undefined;
+    if (raw === undefined)
+        return out;
+    const { errors } = validateScopeIgnores(raw);
+    const rawList = Array.isArray(raw) ? raw : [];
+    for (const err of errors) {
+        out.push(`${filepath}: ${err} (${pointerForError(err, rawList)})`);
+    }
+    return out;
+}
+//# sourceMappingURL=validate.js.map

package/dist/triage/scope-drift/add-ignore.d.ts

@@ -0,0 +1,10 @@
+export interface AddIgnoreResult {
+    readonly changed: boolean;
+    readonly message: string;
+}
+/** Append a label/milestone ignore entry — mirrors Python `add_ignore`. */
+export declare function addIgnore(projectRoot: string, options: {
+    readonly label?: string;
+    readonly milestone?: string;
+}): AddIgnoreResult;
+//# sourceMappingURL=add-ignore.d.ts.map

package/dist/triage/scope-drift/add-ignore.js

@@ -0,0 +1,78 @@
+import { existsSync, mkdtempSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+const PROJECT_DEFINITION_REL_PATH = "vbrief/PROJECT-DEFINITION.vbrief.json";
+function projectDefinitionPath(projectRoot) {
+    return join(resolve(projectRoot), PROJECT_DEFINITION_REL_PATH);
+}
+function loadForMutation(projectRoot) {
+    const path = projectDefinitionPath(projectRoot);
+    if (!existsSync(path)) {
+        throw new Error(`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 Error(`Could not read PROJECT-DEFINITION at ${path}: ${String(err)}`);
+    }
+    let data;
+    try {
+        data = JSON.parse(raw);
+    }
+    catch (err) {
+        throw new Error(`PROJECT-DEFINITION at ${path} is not valid JSON: ${String(err)}`);
+    }
+    if (typeof data !== "object" || data === null || Array.isArray(data)) {
+        throw new Error(`PROJECT-DEFINITION at ${path} top-level value is not a JSON object`);
+    }
+    return [data, path];
+}
+function atomicWrite(path, data) {
+    const dir = dirname(path);
+    const payload = `${JSON.stringify(data, null, 2)}\n`;
+    const tmp = join(dir, `.${Date.now()}.tmp`);
+    writeFileSync(tmp, payload, "utf8");
+    renameSync(tmp, path);
+}
+/** Append a label/milestone ignore entry — mirrors Python `add_ignore`. */
+export function addIgnore(projectRoot, options) {
+    const hasLabel = options.label !== undefined;
+    const hasMilestone = options.milestone !== undefined;
+    if (hasLabel === hasMilestone) {
+        throw new Error("add_ignore() requires exactly one of label= / milestone=");
+    }
+    const key = hasLabel ? "label" : "milestone";
+    const value = (hasLabel ? options.label : options.milestone) ?? "";
+    if (typeof value !== "string" || !value.trim()) {
+        throw new Error(`${key} must be a non-empty string; got ${JSON.stringify(value)}`);
+    }
+    const [data, path] = loadForMutation(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;
+    let policy = planRec.policy;
+    if (typeof policy !== "object" || policy === null || Array.isArray(policy)) {
+        policy = {};
+        planRec.policy = policy;
+    }
+    const policyRec = policy;
+    const raw = Array.isArray(policyRec.triageScopeIgnores)
+        ? policyRec.triageScopeIgnores
+        : [];
+    policyRec.triageScopeIgnores = raw;
+    for (const entry of raw) {
+        if (typeof entry === "object" && entry !== null && !Array.isArray(entry)) {
+            if (entry[key] === value) {
+                return { changed: false, message: `already-ignored (${key}=${value})` };
+            }
+        }
+    }
+    raw.push({ [key]: value });
+    atomicWrite(path, data);
+    return { changed: true, message: `added ignore (${key}=${value})` };
+}
+//# sourceMappingURL=add-ignore.js.map

package/dist/triage/scope-drift/cache-walker.d.ts

@@ -0,0 +1,8 @@
+/** Walk `<cacheRoot>/github-issue/<owner>/<repo>/<N>/raw.json`. */
+export declare function iterCacheIssues(cacheRoot: string): Array<Record<string, unknown>>;
+export declare function extractLabels(issue: Record<string, unknown>): Set<string>;
+export declare function extractMilestone(issue: Record<string, unknown>): string;
+export declare function extractAuthor(issue: Record<string, unknown>): string;
+export declare function isOpen(issue: Record<string, unknown>): boolean;
+export declare function issueRepoKey(issue: Record<string, unknown>): string;
+//# sourceMappingURL=cache-walker.d.ts.map

package/dist/triage/scope-drift/cache-walker.js

@@ -0,0 +1,103 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { CACHE_SOURCE } from "./types.js";
+/** Walk `<cacheRoot>/github-issue/<owner>/<repo>/<N>/raw.json`. */
+export function iterCacheIssues(cacheRoot) {
+    const base = join(cacheRoot, CACHE_SOURCE);
+    if (!existsSync(base))
+        return [];
+    const out = [];
+    const owners = readdirSync(base, { withFileTypes: true })
+        .filter((d) => d.isDirectory())
+        .map((d) => d.name)
+        .sort();
+    for (const owner of owners) {
+        const ownerDir = join(base, owner);
+        const repos = readdirSync(ownerDir, { withFileTypes: true })
+            .filter((d) => d.isDirectory())
+            .map((d) => d.name)
+            .sort();
+        for (const repo of repos) {
+            const repoDir = join(ownerDir, repo);
+            const issues = readdirSync(repoDir, { withFileTypes: true })
+                .filter((d) => d.isDirectory() && /^\d+$/.test(d.name))
+                .map((d) => d.name)
+                .sort((a, b) => Number(a) - Number(b));
+            for (const issueNum of issues) {
+                const rawPath = join(repoDir, issueNum, "raw.json");
+                if (!existsSync(rawPath))
+                    continue;
+                try {
+                    const data = JSON.parse(readFileSync(rawPath, "utf8"));
+                    if (typeof data === "object" && data !== null && !Array.isArray(data)) {
+                        out.push(data);
+                    }
+                }
+                catch { }
+            }
+        }
+    }
+    return out;
+}
+export function extractLabels(issue) {
+    const raw = issue.labels;
+    const names = new Set();
+    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" && name)
+                names.add(name);
+        }
+        else if (typeof item === "string" && item) {
+            names.add(item);
+        }
+    }
+    return names;
+}
+export function extractMilestone(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" && title)
+            return title;
+        const alt = rec.name;
+        if (typeof alt === "string" && alt)
+            return alt;
+    }
+    else if (typeof raw === "string" && raw) {
+        return raw;
+    }
+    return "";
+}
+export function extractAuthor(issue) {
+    const user = issue.user;
+    if (typeof user === "object" && user !== null && !Array.isArray(user)) {
+        const login = user.login;
+        if (typeof login === "string" && login)
+            return login;
+    }
+    const author = issue.author;
+    if (typeof author === "object" && author !== null && !Array.isArray(author)) {
+        const login = author.login;
+        if (typeof login === "string" && login)
+            return login;
+    }
+    if (typeof author === "string" && author)
+        return author;
+    return "";
+}
+export function isOpen(issue) {
+    return issue.state === undefined || issue.state === "open";
+}
+export function issueRepoKey(issue) {
+    for (const key of ["repository_url", "html_url"]) {
+        const value = issue[key];
+        if (typeof value === "string" && value)
+            return value;
+    }
+    return "";
+}
+//# sourceMappingURL=cache-walker.js.map

package/dist/triage/scope-drift/compute.d.ts

@@ -0,0 +1,9 @@
+import { type DriftReport } from "./types.js";
+export interface ComputeDriftOptions {
+    readonly cacheRoot?: string;
+    readonly threshold?: number;
+    readonly openMilestonesFetcher?: () => Set<string> | Iterable<string>;
+}
+/** Read-only subscription drift computation — mirrors Python `compute_drift`. */
+export declare function computeDrift(projectRoot: string, options?: ComputeDriftOptions): DriftReport;
+//# sourceMappingURL=compute.d.ts.map

package/dist/triage/scope-drift/compute.js

@@ -0,0 +1,92 @@
+import { join, resolve } from "node:path";
+import { extractAuthor, extractLabels, extractMilestone, isOpen, issueRepoKey, iterCacheIssues, } from "./cache-walker.js";
+import { inferRepoFromIssues, resolveScopeIgnores, resolveScopeRules, rulesRequestIsOpen, subscribedLabels, subscribedMilestones, } from "./scope-rules.js";
+import { CACHE_DIR_NAME, DRIFT_MIN_ISSUES } from "./types.js";
+/** Read-only subscription drift computation — mirrors Python `compute_drift`. */
+export function computeDrift(projectRoot, options = {}) {
+    const root = resolve(projectRoot);
+    const resolvedCacheRoot = options.cacheRoot ?? join(root, CACHE_DIR_NAME);
+    const effectiveThreshold = options.threshold !== undefined && options.threshold > 0 ? options.threshold : DRIFT_MIN_ISSUES;
+    const issues = iterCacheIssues(resolvedCacheRoot);
+    const rules = resolveScopeRules(root);
+    const ignores = resolveScopeIgnores(root);
+    let openMsSnapshot = new Set();
+    if (rulesRequestIsOpen(rules)) {
+        if (options.openMilestonesFetcher) {
+            try {
+                const raw = options.openMilestonesFetcher();
+                openMsSnapshot = raw instanceof Set ? new Set(raw) : new Set(raw);
+            }
+            catch {
+                openMsSnapshot = new Set();
+            }
+        }
+        else {
+            openMsSnapshot = new Set();
+        }
+    }
+    if (rules.some((r) => r.rule === "all-open")) {
+        return { labels: {}, milestones: {}, total: 0, threshold: effectiveThreshold };
+    }
+    const subLabels = subscribedLabels(rules);
+    const subMilestones = subscribedMilestones(rules, openMsSnapshot);
+    const labelCounts = {};
+    const milestoneCounts = {};
+    const ignoredAuthors = ignores.authors;
+    for (const issue of issues) {
+        if (!isOpen(issue))
+            continue;
+        const number = issue.number;
+        if (typeof number !== "number" || !Number.isInteger(number))
+            continue;
+        if (ignoredAuthors.size > 0 && ignoredAuthors.has(extractAuthor(issue)))
+            continue;
+        const labels = extractLabels(issue);
+        for (const label of labels) {
+            if (subLabels.has(label) || ignores.labels.has(label))
+                continue;
+            labelCounts[label] = (labelCounts[label] ?? 0) + 1;
+        }
+        const milestone = extractMilestone(issue);
+        if (milestone && !subMilestones.has(milestone) && !ignores.milestones.has(milestone)) {
+            milestoneCounts[milestone] = (milestoneCounts[milestone] ?? 0) + 1;
+        }
+    }
+    const surfacedLabels = {};
+    for (const [label, count] of Object.entries(labelCounts)) {
+        if (count >= effectiveThreshold)
+            surfacedLabels[label] = count;
+    }
+    const surfacedMilestones = {};
+    for (const [name, count] of Object.entries(milestoneCounts)) {
+        if (count >= effectiveThreshold)
+            surfacedMilestones[name] = count;
+    }
+    const sortedLabels = Object.fromEntries(Object.entries(surfacedLabels).sort(([a], [b]) => a.localeCompare(b)));
+    const sortedMilestones = Object.fromEntries(Object.entries(surfacedMilestones).sort(([a], [b]) => a.localeCompare(b)));
+    const surfacedIssues = new Set();
+    for (const issue of issues) {
+        if (!isOpen(issue))
+            continue;
+        const number = issue.number;
+        if (typeof number !== "number" || !Number.isInteger(number))
+            continue;
+        if (ignoredAuthors.size > 0 && ignoredAuthors.has(extractAuthor(issue)))
+            continue;
+        const labels = extractLabels(issue);
+        const milestone = extractMilestone(issue);
+        const hasLabelDrift = [...labels].some((l) => l in sortedLabels);
+        const hasMilestoneDrift = milestone.length > 0 && milestone in sortedMilestones;
+        if (hasLabelDrift || hasMilestoneDrift) {
+            surfacedIssues.add(`${issueRepoKey(issue)}:${number}`);
+        }
+    }
+    void inferRepoFromIssues(issues);
+    return {
+        labels: sortedLabels,
+        milestones: sortedMilestones,
+        total: surfacedIssues.size,
+        threshold: effectiveThreshold,
+    };
+}
+//# sourceMappingURL=compute.js.map

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

@@ -0,0 +1,6 @@
+export { type AddIgnoreResult, addIgnore } from "./add-ignore.js";
+export { type ComputeDriftOptions, computeDrift } from "./compute.js";
+export { renderDriftReport } from "./render.js";
+export { collectMilestoneSubscribedNames, inferRepoFromIssues, resolveScopeIgnores, resolveScopeRules, rulesRequestIsOpen, type ScopeIgnores, subscribedLabels, subscribedMilestones, } from "./scope-rules.js";
+export { CACHE_DIR_NAME, CACHE_SOURCE, DRIFT_MIN_ISSUES, type DriftReport, isEmptyReport, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/triage/scope-drift/index.js

@@ -0,0 +1,6 @@
+export { addIgnore } from "./add-ignore.js";
+export { computeDrift } from "./compute.js";
+export { renderDriftReport } from "./render.js";
+export { collectMilestoneSubscribedNames, inferRepoFromIssues, resolveScopeIgnores, resolveScopeRules, rulesRequestIsOpen, subscribedLabels, subscribedMilestones, } from "./scope-rules.js";
+export { CACHE_DIR_NAME, CACHE_SOURCE, DRIFT_MIN_ISSUES, isEmptyReport, } from "./types.js";
+//# sourceMappingURL=index.js.map

package/dist/triage/scope-drift/render.d.ts

@@ -0,0 +1,4 @@
+import { type DriftReport } from "./types.js";
+/** Human-readable drift report — mirrors Python `render_drift_report`. */
+export declare function renderDriftReport(report: DriftReport): string;
+//# sourceMappingURL=render.d.ts.map

package/dist/triage/scope-drift/render.js

@@ -0,0 +1,45 @@
+import { isEmptyReport } from "./types.js";
+/** Human-readable drift report — mirrors Python `render_drift_report`. */
+export function renderDriftReport(report) {
+    if (isEmptyReport(report)) {
+        return ("[scope-drift] no unsubscribed labels / milestones found " +
+            `(threshold: >= ${report.threshold} cached open issues).`);
+    }
+    const lines = [];
+    const labelNames = Object.keys(report.labels);
+    if (labelNames.length > 0) {
+        lines.push("[scope-drift] labels not in subscription:");
+        const width = Math.max(...labelNames.map((n) => n.length));
+        for (const [name, count] of Object.entries(report.labels)) {
+            lines.push(`  ${name.padEnd(width)}  (${count} open issues)`);
+        }
+    }
+    const milestoneNames = Object.keys(report.milestones);
+    if (milestoneNames.length > 0) {
+        if (lines.length > 0)
+            lines.push("");
+        lines.push("[scope-drift] milestones not in subscription:");
+        const width = Math.max(...milestoneNames.map((n) => n.length));
+        for (const [name, count] of Object.entries(report.milestones)) {
+            lines.push(`  ${name.padEnd(width)}  (${count} open issues)`);
+        }
+    }
+    lines.push("");
+    lines.push("To subscribe:");
+    for (const name of labelNames) {
+        lines.push(`  task triage:subscribe -- --label=${name}`);
+    }
+    for (const name of milestoneNames) {
+        lines.push(`  task triage:subscribe -- --milestone=${name}`);
+    }
+    lines.push("");
+    lines.push("To suppress (record explicit ignore):");
+    for (const name of labelNames) {
+        lines.push(`  task triage:scope-drift -- --ignore-label=${name}`);
+    }
+    for (const name of milestoneNames) {
+        lines.push(`  task triage:scope-drift -- --ignore-milestone=${name}`);
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=render.js.map

package/dist/triage/scope-drift/scope-rules.d.ts

@@ -0,0 +1,16 @@
+/** Resolve effective `plan.policy.triageScope` rules. */
+export declare function resolveScopeRules(projectRoot: string, projectDefinition?: Record<string, unknown> | null): Array<Record<string, unknown>>;
+export interface ScopeIgnores {
+    readonly labels: Set<string>;
+    readonly milestones: Set<string>;
+    readonly authors: Set<string>;
+}
+/** Return label/milestone/author ignore sets from PROJECT-DEFINITION. */
+export declare function resolveScopeIgnores(projectRoot: string, projectDefinition?: Record<string, unknown> | null): ScopeIgnores;
+export declare function subscribedLabels(rules: Array<Record<string, unknown>>): Set<string>;
+export declare function collectMilestoneSubscribedNames(rules: Array<Record<string, unknown>>): Set<string>;
+export declare function rulesRequestIsOpen(rules: Array<Record<string, unknown>>): boolean;
+export declare function subscribedMilestones(rules: Array<Record<string, unknown>>, openMilestonesSnapshot?: Set<string>): Set<string>;
+/** Best-effort owner/name inference from cached issue payloads. */
+export declare function inferRepoFromIssues(issues: Array<Record<string, unknown>>): string | null;
+//# sourceMappingURL=scope-rules.d.ts.map