@deftai/directive-core 0.55.0

package/dist/triage/scope/normalize.js

@@ -0,0 +1,45 @@
+import { createHash } from "node:crypto";
+import { SUBSCRIPTION_HASH_LEN } from "./constants.js";
+function sortRuleObject(rule) {
+    const nRule = {};
+    for (const key of Object.keys(rule).sort()) {
+        let value = rule[key];
+        if (rule.rule === "labels" && (key === "any-of" || key === "all-of") && Array.isArray(value)) {
+            value = [...value].sort();
+        }
+        else if (rule.rule === "explicit-watch" && key === "issues" && Array.isArray(value)) {
+            value = value
+                .filter((v) => typeof v === "object" && v !== null && !Array.isArray(v))
+                .map((v) => {
+                const sorted = {};
+                for (const k of Object.keys(v).sort())
+                    sorted[k] = v[k];
+                return sorted;
+            })
+                .sort((a, b) => Number(a.n ?? 0) - Number(b.n ?? 0));
+        }
+        nRule[key] = value;
+    }
+    return nRule;
+}
+/** Stable canonical-ordered copy of scope rules for hashing. */
+export function normalizeScopeRules(rules) {
+    const normalised = [];
+    for (const rule of rules) {
+        if (typeof rule !== "object" || rule === null || Array.isArray(rule))
+            continue;
+        normalised.push(sortRuleObject(rule));
+    }
+    return normalised.sort((a, b) => {
+        const sa = JSON.stringify(a);
+        const sb = JSON.stringify(b);
+        return sa < sb ? -1 : sa > sb ? 1 : 0;
+    });
+}
+/** Stable canonical-JSON SHA-256 digest truncated to SUBSCRIPTION_HASH_LEN. */
+export function subscriptionHash(rules) {
+    const canonical = JSON.stringify(normalizeScopeRules(rules));
+    const digest = createHash("sha256").update(canonical, "utf8").digest("hex");
+    return digest.slice(0, SUBSCRIPTION_HASH_LEN);
+}
+//# sourceMappingURL=normalize.js.map

package/dist/triage/scope/python-repr.d.ts

@@ -0,0 +1,7 @@
+/** Python-style type name for validation error messages. */
+export declare function pythonTypeName(value: unknown): string;
+/** Python repr for a string (single-quoted). */
+export declare function pyStrRepr(value: string): string;
+/** Python repr for a list of strings (single-quoted elements). */
+export declare function pyListRepr(items: readonly string[]): string;
+//# sourceMappingURL=python-repr.d.ts.map

package/dist/triage/scope/python-repr.js

@@ -0,0 +1,25 @@
+/** Python-style type name for validation error messages. */
+export function pythonTypeName(value) {
+    if (value === null)
+        return "None";
+    if (Array.isArray(value))
+        return "list";
+    if (typeof value === "boolean")
+        return "bool";
+    if (typeof value === "number")
+        return Number.isInteger(value) ? "int" : "float";
+    if (typeof value === "string")
+        return "str";
+    if (typeof value === "object")
+        return "dict";
+    return typeof value;
+}
+/** Python repr for a string (single-quoted). */
+export function pyStrRepr(value) {
+    return `'${value}'`;
+}
+/** Python repr for a list of strings (single-quoted elements). */
+export function pyListRepr(items) {
+    return `[${items.map((s) => `'${s}'`).join(", ")}]`;
+}
+//# sourceMappingURL=python-repr.js.map

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

@@ -0,0 +1,9 @@
+export declare function extractReferencedIssues(projectRoot: string, lifecycleFolders?: readonly string[]): {
+    any: Set<number>;
+    active: Set<number>;
+};
+export declare function renderList(rules: Iterable<Record<string, unknown>>, options?: {
+    isDefault?: boolean;
+}): string;
+export declare function renderIgnores(ignores: Iterable<Record<string, unknown>> | null | undefined): string;
+//# sourceMappingURL=renderers.d.ts.map

package/dist/triage/scope/renderers.js

@@ -0,0 +1,177 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { subscriptionHash } from "./normalize.js";
+import { pyListRepr } from "./python-repr.js";
+const LIFECYCLE_FOLDERS = ["proposed", "pending", "active", "completed", "cancelled"];
+export function extractReferencedIssues(projectRoot, lifecycleFolders = LIFECYCLE_FOLDERS) {
+    const root = join(projectRoot, "vbrief");
+    const anySet = new Set();
+    const activeSet = new Set();
+    if (!existsSync(root))
+        return { any: anySet, active: activeSet };
+    for (const folder of lifecycleFolders) {
+        const folderPath = join(root, folder);
+        if (!existsSync(folderPath))
+            continue;
+        for (const name of readdirSync(folderPath)) {
+            if (!name.endsWith(".vbrief.json"))
+                continue;
+            const vbriefPath = join(folderPath, name);
+            let data;
+            try {
+                data = JSON.parse(readFileSync(vbriefPath, "utf8"));
+            }
+            catch {
+                continue;
+            }
+            if (typeof data !== "object" || data === null || Array.isArray(data))
+                continue;
+            const plan = data.plan;
+            if (typeof plan !== "object" || plan === null || Array.isArray(plan))
+                continue;
+            const refs = plan.references ?? [];
+            if (!Array.isArray(refs))
+                continue;
+            for (const ref of refs) {
+                if (typeof ref !== "object" || ref === null || Array.isArray(ref))
+                    continue;
+                const rec = ref;
+                if (rec.type !== "x-vbrief/github-issue")
+                    continue;
+                const uri = rec.uri;
+                if (typeof uri !== "string")
+                    continue;
+                const tail = uri.replace(/\/$/, "").split("/").pop() ?? "";
+                if (/^\d+$/.test(tail)) {
+                    const n = Number.parseInt(tail, 10);
+                    anySet.add(n);
+                    if (folder === "active")
+                        activeSet.add(n);
+                }
+            }
+        }
+    }
+    return { any: anySet, active: activeSet };
+}
+function renderRule(idx, rule) {
+    const kind = rule.rule ?? "<unknown>";
+    if (kind === "all-open")
+        return [`  ${idx}. all-open`];
+    if (kind === "labels") {
+        if ("any-of" in rule && Array.isArray(rule["any-of"])) {
+            const sorted = [...rule["any-of"]].filter((x) => typeof x === "string").sort();
+            return [`  ${idx}. labels any-of=${pyListRepr(sorted)}`];
+        }
+        if ("all-of" in rule && Array.isArray(rule["all-of"])) {
+            const sorted = [...rule["all-of"]].filter((x) => typeof x === "string").sort();
+            return [`  ${idx}. labels all-of=${pyListRepr(sorted)}`];
+        }
+        return [`  ${idx}. labels (malformed)`];
+    }
+    if (kind === "milestone") {
+        if ("name" in rule)
+            return [`  ${idx}. milestone name=${JSON.stringify(rule.name ?? "?")}`];
+        if ("any-of" in rule) {
+            const raw = rule["any-of"];
+            const sorted = Array.isArray(raw)
+                ? [...raw].filter((x) => typeof x === "string").sort()
+                : raw;
+            return [
+                `  ${idx}. milestone any-of=${Array.isArray(sorted) ? pyListRepr(sorted) : String(sorted)}`,
+            ];
+        }
+        if (rule["is-open"] === true) {
+            return [`  ${idx}. milestone is-open=true (currently-open upstream)`];
+        }
+        return [`  ${idx}. milestone (malformed)`];
+    }
+    if (kind === "opened-since" || kind === "updated-since") {
+        return [`  ${idx}. ${kind} duration=${rule.duration ?? "?"}`];
+    }
+    if (kind === "referenced-by-vbrief") {
+        return [`  ${idx}. referenced-by-vbrief scope=${rule.scope ?? "?"}`];
+    }
+    if (kind === "sliced-from") {
+        return [`  ${idx}. sliced-from scope=${rule.scope ?? "?"}`];
+    }
+    if (kind === "explicit-watch") {
+        const out = [`  ${idx}. explicit-watch:`];
+        const issues = rule.issues;
+        if (Array.isArray(issues)) {
+            for (const entry of issues) {
+                if (typeof entry !== "object" || entry === null || Array.isArray(entry))
+                    continue;
+                const rec = entry;
+                out.push(`       - #${rec.n}  (${rec.note ?? ""})`);
+            }
+        }
+        return out;
+    }
+    return [`  ${idx}. ${kind} (unknown rule type)`];
+}
+export function renderList(rules, options = {}) {
+    const ruleList = [...rules];
+    const lines = [];
+    let header = `triage:scope effective rules (${ruleList.length}):`;
+    if (options.isDefault) {
+        header += " (default applied -- plan.policy.triageScope unset)";
+    }
+    lines.push(header);
+    for (let i = 0; i < ruleList.length; i += 1) {
+        const rule = ruleList[i];
+        if (typeof rule === "object" && rule !== null && !Array.isArray(rule)) {
+            lines.push(...renderRule(i + 1, rule));
+        }
+    }
+    lines.push(`subscription-hash: ${subscriptionHash(ruleList)}`);
+    return lines.join("\n");
+}
+export function renderIgnores(ignores) {
+    const entries = [...(ignores ?? [])];
+    const lines = [`triage:scope ignores (${entries.length} entries):`];
+    if (entries.length === 0) {
+        lines.push("  (none) -- task triage:scope -- --ignore-label=<L> to add");
+        return lines.join("\n");
+    }
+    const labels = [];
+    const milestones = [];
+    const authors = [];
+    const other = [];
+    for (const entry of entries) {
+        if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+            other.push(JSON.stringify(entry));
+            continue;
+        }
+        if (entry.rule === "author") {
+            const anyOf = entry["any-of"];
+            if (Array.isArray(anyOf)) {
+                for (const name of anyOf) {
+                    if (typeof name === "string" && name)
+                        authors.push(name);
+                }
+            }
+            continue;
+        }
+        const label = entry.label;
+        if (typeof label === "string" && label) {
+            labels.push(label);
+            continue;
+        }
+        const milestone = entry.milestone;
+        if (typeof milestone === "string" && milestone) {
+            milestones.push(milestone);
+            continue;
+        }
+        other.push(JSON.stringify(entry));
+    }
+    if (labels.length > 0)
+        lines.push(`  labels:     ${pyListRepr([...labels].sort())}`);
+    if (milestones.length > 0)
+        lines.push(`  milestones: ${pyListRepr([...milestones].sort())}`);
+    if (authors.length > 0)
+        lines.push(`  authors:    ${pyListRepr([...authors].sort())}`);
+    if (other.length > 0)
+        lines.push(`  unrecognised: ${JSON.stringify(other)}`);
+    return lines.join("\n");
+}
+//# sourceMappingURL=renderers.js.map

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

@@ -0,0 +1,15 @@
+export declare function projectDefinitionPath(projectRoot: string): string;
+export declare function loadProjectDefinition(projectRoot: string): Record<string, unknown> | null;
+export declare function isDefaultApplied(data: Record<string, unknown> | null): boolean;
+export declare function getRawScope(data: Record<string, unknown> | null): unknown;
+export declare function getRawIgnores(data: Record<string, unknown> | null): Record<string, unknown>[];
+/** Resolve effective plan.policy.triageScope rule list (#1131). */
+export declare function resolveScopeRules(projectRoot: string, projectDefinition?: Record<string, unknown> | null): Record<string, unknown>[];
+export interface ResolvedIgnores {
+    readonly labels: Set<string>;
+    readonly milestones: Set<string>;
+    readonly authors: Set<string>;
+}
+/** Resolve plan.policy.triageScopeIgnores into typed sets (#1133 / #1182). */
+export declare function resolveScopeIgnores(projectRoot: string, projectDefinition?: Record<string, unknown> | null): ResolvedIgnores;
+//# sourceMappingURL=resolve.d.ts.map

package/dist/triage/scope/resolve.js

@@ -0,0 +1,122 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { DEFAULT_TRIAGE_SCOPE, PROJECT_DEFINITION_REL_PATH } from "./constants.js";
+export function projectDefinitionPath(projectRoot) {
+    return join(resolve(projectRoot), PROJECT_DEFINITION_REL_PATH);
+}
+export function loadProjectDefinition(projectRoot) {
+    const path = projectDefinitionPath(projectRoot);
+    if (!existsSync(path))
+        return null;
+    try {
+        const data = JSON.parse(readFileSync(path, "utf8"));
+        return typeof data === "object" && data !== null && !Array.isArray(data)
+            ? data
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function isDefaultApplied(data) {
+    if (data === null)
+        return true;
+    const plan = data.plan;
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan))
+        return true;
+    const policy = plan.policy;
+    if (typeof policy !== "object" || policy === null || Array.isArray(policy))
+        return true;
+    const scope = policy.triageScope;
+    return !Array.isArray(scope) || scope.length === 0;
+}
+export function getRawScope(data) {
+    if (data === null)
+        return undefined;
+    const plan = data.plan;
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan))
+        return undefined;
+    const policy = plan.policy;
+    if (typeof policy !== "object" || policy === null || Array.isArray(policy))
+        return undefined;
+    return policy.triageScope;
+}
+export function getRawIgnores(data) {
+    if (data === null)
+        return [];
+    const plan = data.plan;
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan))
+        return [];
+    const policy = plan.policy;
+    if (typeof policy !== "object" || policy === null || Array.isArray(policy))
+        return [];
+    const raw = policy.triageScopeIgnores;
+    return Array.isArray(raw)
+        ? raw.filter((e) => typeof e === "object" && e !== null && !Array.isArray(e))
+        : [];
+}
+/** Resolve effective plan.policy.triageScope rule list (#1131). */
+export function resolveScopeRules(projectRoot, projectDefinition) {
+    const data = projectDefinition !== undefined ? projectDefinition : loadProjectDefinition(projectRoot);
+    if (data === null) {
+        return DEFAULT_TRIAGE_SCOPE.map((r) => ({ ...r }));
+    }
+    const plan = data.plan;
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+        return DEFAULT_TRIAGE_SCOPE.map((r) => ({ ...r }));
+    }
+    const policy = plan.policy;
+    if (typeof policy !== "object" || policy === null || Array.isArray(policy)) {
+        return DEFAULT_TRIAGE_SCOPE.map((r) => ({ ...r }));
+    }
+    const scope = policy.triageScope;
+    if (!Array.isArray(scope) || scope.length === 0) {
+        return DEFAULT_TRIAGE_SCOPE.map((r) => ({ ...r }));
+    }
+    const rules = scope.filter((r) => typeof r === "object" && r !== null && !Array.isArray(r));
+    return rules.length > 0
+        ? rules.map((r) => ({ ...r }))
+        : DEFAULT_TRIAGE_SCOPE.map((x) => ({ ...x }));
+}
+/** Resolve plan.policy.triageScopeIgnores into typed sets (#1133 / #1182). */
+export function resolveScopeIgnores(projectRoot, projectDefinition) {
+    const data = projectDefinition !== undefined ? projectDefinition : loadProjectDefinition(projectRoot);
+    const out = {
+        labels: new Set(),
+        milestones: new Set(),
+        authors: new Set(),
+    };
+    if (data === null)
+        return out;
+    const plan = data.plan;
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan))
+        return out;
+    const policy = plan.policy;
+    if (typeof policy !== "object" || policy === null || Array.isArray(policy))
+        return out;
+    const raw = policy.triageScopeIgnores;
+    if (!Array.isArray(raw))
+        return out;
+    for (const entry of raw) {
+        if (typeof entry !== "object" || entry === null || Array.isArray(entry))
+            continue;
+        const rec = entry;
+        const label = rec.label;
+        if (typeof label === "string" && label.trim())
+            out.labels.add(label);
+        const milestone = rec.milestone;
+        if (typeof milestone === "string" && milestone.trim())
+            out.milestones.add(milestone);
+        if (rec.rule === "author") {
+            const anyOf = rec["any-of"];
+            if (Array.isArray(anyOf)) {
+                for (const name of anyOf) {
+                    if (typeof name === "string" && name.trim())
+                        out.authors.add(name);
+                }
+            }
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=resolve.js.map

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

@@ -0,0 +1,6 @@
+/** UTC ISO-8601 stamp with trailing Z, mirroring Python `_utc_iso`. */
+export declare function utcIso(dt?: Date | null): string;
+/** Parse ISO-8601 stamp (with Z suffix) into Date. */
+export declare function parseIso(stamp: string): Date;
+export declare function utcNow(): Date;
+//# sourceMappingURL=time.d.ts.map

package/dist/triage/scope/time.js

@@ -0,0 +1,18 @@
+/** UTC ISO-8601 stamp with trailing Z, mirroring Python `_utc_iso`. */
+export function utcIso(dt = null) {
+    const value = dt ?? new Date();
+    const iso = value.toISOString();
+    return iso.replace(/\.\d{3}Z$/, "Z");
+}
+/** Parse ISO-8601 stamp (with Z suffix) into Date. */
+export function parseIso(stamp) {
+    let text = stamp.trim();
+    if (text.endsWith("Z")) {
+        text = `${text.slice(0, -1)}+00:00`;
+    }
+    return new Date(text);
+}
+export function utcNow() {
+    return new Date();
+}
+//# sourceMappingURL=time.js.map

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

@@ -0,0 +1,11 @@
+export interface ValidationResult {
+    readonly errors: string[];
+    readonly warnings: string[];
+}
+/** Validate plan.policy.triageScope payload (#1131). */
+export declare function validateScopeRules(rules: unknown): ValidationResult;
+/** Validate plan.policy.triageScopeIgnores payload (#1133 / #1182). */
+export declare function validateScopeIgnores(ignores: unknown): ValidationResult;
+export declare function validateTriageScopeOnPlan(plan: unknown, filepath: string): string[];
+export declare function validateTriageScopeIgnoresOnPlan(plan: unknown, filepath: string): string[];
+//# sourceMappingURL=validate.d.ts.map