@deftai/directive-core 0.55.0

package/dist/text/redos-safe.js

@@ -0,0 +1,338 @@
+/** Linear-time helpers replacing CodeQL-flagged polynomial regexes (#1810). */
+const WS = /\s/;
+function isRootPathChar(ch) {
+    return /[\w./-]/.test(ch);
+}
+function isSkillNameStart(ch) {
+    return ch >= "a" && ch <= "z";
+}
+function isSkillNameChar(ch) {
+    return (isSkillNameStart(ch) ||
+        ch === "_" ||
+        (ch >= "0" && ch <= "9") ||
+        (ch >= "A" && ch <= "Z") ||
+        ch === "-");
+}
+/** Equivalent of ``value.replace(/[\\/]+$/, "")`` without backtracking. */
+export function stripTrailingPathSeparators(value) {
+    let end = value.length;
+    while (end > 0) {
+        const ch = value[end - 1];
+        if (ch === "/" || ch === "\\") {
+            end -= 1;
+            continue;
+        }
+        break;
+    }
+    return value.slice(0, end);
+}
+/** Equivalent of ``value.replace(/^['"]|['"]$/g, "")`` without backtracking. */
+export function stripEdgeQuotes(value) {
+    let result = value;
+    if (result.length > 0 && (result[0] === '"' || result[0] === "'")) {
+        result = result.slice(1);
+    }
+    if (result.length > 0) {
+        const last = result[result.length - 1];
+        if (last === '"' || last === "'") {
+            result = result.slice(0, -1);
+        }
+    }
+    return result;
+}
+/**
+ * Expand compact JSON structural ``:`` / ``,`` to Python ``json.dumps`` spacing
+ * without touching separators inside string literals.
+ */
+export function expandPythonJsonSeparators(compactJson) {
+    let out = "";
+    let i = 0;
+    while (i < compactJson.length) {
+        const ch = compactJson[i];
+        if (ch === '"') {
+            out += '"';
+            i += 1;
+            let escaped = false;
+            while (i < compactJson.length) {
+                const current = compactJson[i];
+                out += current;
+                i += 1;
+                if (escaped) {
+                    escaped = false;
+                    continue;
+                }
+                if (current === "\\") {
+                    escaped = true;
+                    continue;
+                }
+                if (current === '"') {
+                    break;
+                }
+            }
+            continue;
+        }
+        if (ch === ":") {
+            out += ": ";
+            i += 1;
+            continue;
+        }
+        if (ch === ",") {
+            out += ", ";
+            i += 1;
+            continue;
+        }
+        out += ch;
+        i += 1;
+    }
+    return out;
+}
+/** Mirrors ``^(#{1,6})\s+(.*\S.*)$`` without polynomial backtracking. */
+export function parseMarkdownHeading(line) {
+    if (!line.startsWith("#")) {
+        return null;
+    }
+    let i = 0;
+    while (i < line.length && i < 6 && line[i] === "#") {
+        i += 1;
+    }
+    if (i === 0 || i > 6) {
+        return null;
+    }
+    const hashes = line.slice(0, i);
+    if (i === line.length) {
+        return null;
+    }
+    while (i < line.length && WS.test(line[i])) {
+        i += 1;
+    }
+    if (i === line.length) {
+        return null;
+    }
+    const text = line.slice(i);
+    let hasNonWs = false;
+    for (const ch of text) {
+        if (!WS.test(ch)) {
+            hasNonWs = true;
+            break;
+        }
+    }
+    if (!hasNonWs) {
+        return null;
+    }
+    return { hashes, text };
+}
+/** Mirrors doctor ``_SKILL_PATH_RE`` without non-greedy backtracking. */
+export function findSkillPathsInText(text) {
+    const found = new Set();
+    const marker = "/skills/";
+    let pos = 0;
+    while (pos < text.length) {
+        const idx = text.indexOf(marker, pos);
+        if (idx < 0) {
+            break;
+        }
+        let start = idx;
+        while (start > 0 && isRootPathChar(text[start - 1])) {
+            start -= 1;
+        }
+        const nameStart = idx + marker.length;
+        if (nameStart >= text.length || !isSkillNameStart(text[nameStart])) {
+            pos = idx + 1;
+            continue;
+        }
+        let nameEnd = nameStart + 1;
+        while (nameEnd < text.length && isSkillNameChar(text[nameEnd])) {
+            nameEnd += 1;
+        }
+        const suffix = "/SKILL.md";
+        if (text.slice(nameEnd, nameEnd + suffix.length) !== suffix) {
+            pos = idx + 1;
+            continue;
+        }
+        found.add(text.slice(start, nameEnd + suffix.length));
+        pos = idx + 1;
+    }
+    return [...found];
+}
+const LAST_REVIEWED_PREFIX = "Last reviewed commit:";
+function readHexSha(body, start) {
+    let sha = "";
+    let i = start;
+    while (i < body.length) {
+        const ch = body[i];
+        const lower = ch.toLowerCase();
+        const isHex = (lower >= "0" && lower <= "9") || (lower >= "a" && lower <= "f");
+        if (!isHex) {
+            break;
+        }
+        sha += lower;
+        i += 1;
+    }
+    if (sha.length < 7 || sha.length > 40) {
+        return null;
+    }
+    return { sha, end: i };
+}
+/** Return the last Greptile ``Last reviewed commit:`` SHA (linear scan). */
+export function findLastReviewedCommitSha(body) {
+    let lastSha = null;
+    let searchFrom = 0;
+    while (true) {
+        const idx = body.indexOf(LAST_REVIEWED_PREFIX, searchFrom);
+        if (idx < 0) {
+            break;
+        }
+        let i = idx + LAST_REVIEWED_PREFIX.length;
+        while (i < body.length && WS.test(body[i])) {
+            i += 1;
+        }
+        if (body[i] !== "[") {
+            searchFrom = idx + 1;
+            continue;
+        }
+        i += 1;
+        while (i < body.length && body[i] !== "]") {
+            i += 1;
+        }
+        if (i >= body.length || body[i] !== "]") {
+            searchFrom = idx + 1;
+            continue;
+        }
+        i += 1;
+        if (body[i] !== "(") {
+            searchFrom = idx + 1;
+            continue;
+        }
+        i += 1;
+        const http = "http://github.com/";
+        const https = "https://github.com/";
+        let matched = false;
+        if (body.startsWith(https, i)) {
+            i += https.length;
+            matched = true;
+        }
+        else if (body.startsWith(http, i)) {
+            i += http.length;
+            matched = true;
+        }
+        if (!matched) {
+            searchFrom = idx + 1;
+            continue;
+        }
+        let slashes = 0;
+        while (slashes < 3 && i < body.length) {
+            const slash = body.indexOf("/", i);
+            if (slash < 0) {
+                break;
+            }
+            i = slash + 1;
+            slashes += 1;
+        }
+        if (slashes < 3) {
+            searchFrom = idx + 1;
+            continue;
+        }
+        const shaRead = readHexSha(body, i);
+        if (shaRead !== null) {
+            lastSha = shaRead.sha;
+        }
+        searchFrom = idx + 1;
+    }
+    return lastSha;
+}
+/** Parse a single manifest ``key: value`` line (linear; mirrors MANIFEST_LINE_RE). */
+export function parseManifestKeyValueLine(line) {
+    const stripped = line.trim();
+    if (!stripped || stripped.startsWith("#")) {
+        return null;
+    }
+    const colon = stripped.indexOf(":");
+    if (colon < 0) {
+        return null;
+    }
+    const rawKey = stripped.slice(0, colon).trim();
+    if (!rawKey || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(rawKey)) {
+        return null;
+    }
+    const value = stripEdgeQuotes(stripped.slice(colon + 1).trim());
+    return { key: rawKey.toLowerCase(), value };
+}
+const GITHUB_HOSTS = new Set(["github.com", "www.github.com"]);
+function parseBareRepoSlug(trimmed) {
+    const slash = trimmed.indexOf("/");
+    if (slash <= 0 || slash >= trimmed.length - 1) {
+        return null;
+    }
+    const owner = trimmed.slice(0, slash);
+    const repo = trimmed.slice(slash + 1);
+    if (owner.includes(" ") || repo.includes(" ") || owner.includes("/") || repo.includes("/")) {
+        return null;
+    }
+    return `${owner}/${repo}`;
+}
+function parseGitAtSlug(trimmed) {
+    const prefix = "git@github.com:";
+    if (!trimmed.startsWith(prefix)) {
+        return null;
+    }
+    let rest = stripTrailingPathSeparators(trimmed.slice(prefix.length));
+    if (rest.endsWith(".git")) {
+        rest = rest.slice(0, -4);
+    }
+    const space = rest.search(/\s/);
+    if (space >= 0) {
+        rest = rest.slice(0, space);
+    }
+    return parseBareRepoSlug(rest);
+}
+function parseGitHubUrlSlug(trimmed) {
+    try {
+        const url = new URL(trimmed);
+        if (!GITHUB_HOSTS.has(url.hostname)) {
+            return null;
+        }
+        const parts = url.pathname.split("/").filter((part) => part.length > 0);
+        if (parts.length < 2 || !parts[0] || !parts[1]) {
+            return null;
+        }
+        let repo = parts[1];
+        if (repo.endsWith(".git")) {
+            repo = repo.slice(0, -4);
+        }
+        return `${parts[0]}/${repo}`;
+    }
+    catch {
+        return null;
+    }
+}
+/** Accept OWNER/NAME or a GitHub remote URL with strict host checks. */
+export function parseGitHubRepoSlug(value) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        return null;
+    }
+    const gitAt = parseGitAtSlug(trimmed);
+    if (gitAt !== null) {
+        return gitAt;
+    }
+    if (trimmed.includes("://") || trimmed.startsWith("git@")) {
+        return parseGitHubUrlSlug(trimmed);
+    }
+    if (/^[^/\s]+\/[^/\s]+$/.test(trimmed)) {
+        return trimmed;
+    }
+    return null;
+}
+/** Infer owner/name from a git remote URL (strict github.com host; no substring checks). */
+export function parseGitHubRemoteRepo(url) {
+    const trimmed = url.trim();
+    if (trimmed.length === 0) {
+        return null;
+    }
+    let cleaned = stripTrailingPathSeparators(trimmed);
+    if (cleaned.endsWith(".git")) {
+        cleaned = cleaned.slice(0, -4);
+    }
+    return parseGitHubRepoSlug(cleaned);
+}
+//# sourceMappingURL=redos-safe.js.map

package/dist/triage/actions/candidates-log.d.ts

@@ -0,0 +1,8 @@
+import type { CandidatesLog } from "./types.js";
+export declare const AUDIT_LOG_REL_PATH = "vbrief/.eval/candidates.jsonl";
+/** Filesystem-backed candidates audit log (mirrors ``scripts/candidates_log.py``). */
+export declare function createCandidatesLog(defaultProjectRoot: string): CandidatesLog;
+/** Remove the audit-log line whose ``decision_id`` matches (rollback path). */
+export declare function rollbackAuditEntry(decisionId: string, projectRoot: string, logPathOverride?: string): boolean;
+export declare function resolveAuditLogPath(projectRoot: string): string;
+//# sourceMappingURL=candidates-log.d.ts.map

package/dist/triage/actions/candidates-log.js

@@ -0,0 +1,195 @@
+import { randomUUID } from "node:crypto";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { CandidatesLogError } from "./errors.js";
+export const AUDIT_LOG_REL_PATH = "vbrief/.eval/candidates.jsonl";
+const VALID_DECISIONS = new Set([
+    "accept",
+    "reject",
+    "defer",
+    "needs-ac",
+    "mark-duplicate",
+    "reset",
+    "resume-eligible",
+]);
+const PRIOR_REQUIRED_DECISIONS = new Set(["reset", "resume-eligible"]);
+const REQUIRED_FIELDS = [
+    "decision_id",
+    "timestamp",
+    "repo",
+    "issue_number",
+    "decision",
+    "actor",
+];
+const OPTIONAL_FIELDS = ["reason", "resume_on", "linked_to", "prior_decision_id"];
+const ALLOWED_FIELDS = new Set([...REQUIRED_FIELDS, ...OPTIONAL_FIELDS]);
+const UUID_RE = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+const REPO_RE = /^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/;
+const ISO8601_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/;
+function validateEntry(entry) {
+    if (typeof entry !== "object" || entry === null) {
+        throw new CandidatesLogError(`entry must be a dict, got ${typeof entry}`);
+    }
+    const row = entry;
+    const missing = REQUIRED_FIELDS.filter((field) => !(field in row));
+    if (missing.length > 0) {
+        throw new CandidatesLogError(`entry missing required field(s): ${JSON.stringify(missing)}`);
+    }
+    const extras = Object.keys(row)
+        .filter((key) => !ALLOWED_FIELDS.has(key))
+        .sort();
+    if (extras.length > 0) {
+        throw new CandidatesLogError(`entry has unknown field(s): ${JSON.stringify(extras)}`);
+    }
+    const decisionId = row.decision_id;
+    if (typeof decisionId !== "string" || !UUID_RE.test(decisionId)) {
+        throw new CandidatesLogError(`decision_id must be a UUID string, got ${String(decisionId)}`);
+    }
+    const timestamp = row.timestamp;
+    if (typeof timestamp !== "string" || !ISO8601_RE.test(timestamp)) {
+        throw new CandidatesLogError(`timestamp must be ISO-8601 UTC with Z suffix (e.g. 2026-05-03T16:32:54Z), got ${String(timestamp)}`);
+    }
+    const repo = row.repo;
+    if (typeof repo !== "string" || !REPO_RE.test(repo)) {
+        throw new CandidatesLogError(`repo must match 'owner/name', got ${String(repo)}`);
+    }
+    const issueNumber = row.issue_number;
+    if (typeof issueNumber !== "number" || !Number.isInteger(issueNumber) || issueNumber < 1) {
+        throw new CandidatesLogError(`issue_number must be a positive int, got ${String(issueNumber)}`);
+    }
+    const decision = row.decision;
+    if (typeof decision !== "string" || !VALID_DECISIONS.has(decision)) {
+        throw new CandidatesLogError(`decision must be one of ${JSON.stringify([...VALID_DECISIONS].sort())}, got ${String(decision)}`);
+    }
+    const actor = row.actor;
+    if (typeof actor !== "string" || actor.length === 0) {
+        throw new CandidatesLogError(`actor must be a non-empty string, got ${String(actor)}`);
+    }
+    if ("reason" in row && typeof row.reason !== "string") {
+        throw new CandidatesLogError(`reason must be a string, got ${typeof row.reason}`);
+    }
+    if ("resume_on" in row) {
+        const resumeOn = row.resume_on;
+        if (typeof resumeOn !== "string" || resumeOn.length === 0) {
+            throw new CandidatesLogError(`resume_on must be a non-empty string, got ${String(resumeOn)}`);
+        }
+    }
+    if (decision === "mark-duplicate") {
+        if (!("linked_to" in row)) {
+            throw new CandidatesLogError("decision 'mark-duplicate' requires 'linked_to'");
+        }
+        const linkedTo = row.linked_to;
+        if (typeof linkedTo !== "number" || !Number.isInteger(linkedTo) || linkedTo < 1) {
+            throw new CandidatesLogError(`linked_to must be a positive int, got ${String(linkedTo)}`);
+        }
+    }
+    else if ("linked_to" in row) {
+        throw new CandidatesLogError("'linked_to' is only valid for decision='mark-duplicate'");
+    }
+    if (PRIOR_REQUIRED_DECISIONS.has(decision)) {
+        if (!("prior_decision_id" in row)) {
+            throw new CandidatesLogError(`decision '${decision}' requires 'prior_decision_id'`);
+        }
+        const priorId = row.prior_decision_id;
+        if (typeof priorId !== "string" || !UUID_RE.test(priorId)) {
+            throw new CandidatesLogError(`prior_decision_id must be a UUID string, got ${String(priorId)}`);
+        }
+    }
+    else if ("prior_decision_id" in row) {
+        throw new CandidatesLogError(`'prior_decision_id' is only valid for decision in ${JSON.stringify([...PRIOR_REQUIRED_DECISIONS].sort())}`);
+    }
+}
+function resolveLogPath(projectRoot, override) {
+    if (override !== undefined) {
+        return override;
+    }
+    return join(projectRoot, AUDIT_LOG_REL_PATH);
+}
+function stableStringify(entry) {
+    const sortedKeys = Object.keys(entry).sort();
+    const sorted = {};
+    for (const key of sortedKeys) {
+        sorted[key] = entry[key];
+    }
+    return JSON.stringify(sorted);
+}
+function readAll(repo, logPath) {
+    if (!existsSync(logPath)) {
+        return [];
+    }
+    const out = [];
+    const raw = readFileSync(logPath, "utf8");
+    for (const line of raw.split("\n")) {
+        const stripped = line.trim();
+        if (!stripped)
+            continue;
+        try {
+            const obj = JSON.parse(stripped);
+            if (typeof obj !== "object" || obj === null)
+                continue;
+            const row = obj;
+            if (repo !== null && row.repo !== repo)
+                continue;
+            out.push(row);
+        }
+        catch { }
+    }
+    return out;
+}
+/** Filesystem-backed candidates audit log (mirrors ``scripts/candidates_log.py``). */
+export function createCandidatesLog(defaultProjectRoot) {
+    return {
+        append(entry, options) {
+            validateEntry(entry);
+            const logPath = resolveLogPath(defaultProjectRoot, options?.path);
+            mkdirSync(join(logPath, ".."), { recursive: true });
+            appendFileSync(logPath, `${stableStringify(entry)}\n`, { encoding: "utf8" });
+            return entry.decision_id;
+        },
+        latestDecision(issueNumber, repo, options) {
+            const logPath = resolveLogPath(defaultProjectRoot, options?.path);
+            const rows = readAll(repo, logPath).filter((row) => row.issue_number === issueNumber);
+            if (rows.length === 0)
+                return null;
+            rows.sort((a, b) => String(a.timestamp).localeCompare(String(b.timestamp)));
+            return rows.at(-1) ?? null;
+        },
+        newDecisionId() {
+            return randomUUID();
+        },
+    };
+}
+/** Remove the audit-log line whose ``decision_id`` matches (rollback path). */
+export function rollbackAuditEntry(decisionId, projectRoot, logPathOverride) {
+    const path = resolveLogPath(projectRoot, logPathOverride);
+    if (!existsSync(path)) {
+        return false;
+    }
+    const kept = [];
+    let removed = false;
+    const raw = readFileSync(path, "utf8");
+    for (const line of raw.split("\n")) {
+        const stripped = line.trim();
+        if (!stripped)
+            continue;
+        try {
+            const entry = JSON.parse(stripped);
+            if (!removed && entry.decision_id === decisionId) {
+                removed = true;
+                continue;
+            }
+            kept.push(line.endsWith("\n") ? line : `${line}\n`);
+        }
+        catch {
+            kept.push(line.endsWith("\n") ? line : `${line}\n`);
+        }
+    }
+    if (removed) {
+        writeFileSync(path, kept.join(""), { encoding: "utf8" });
+    }
+    return removed;
+}
+export function resolveAuditLogPath(projectRoot) {
+    return join(projectRoot, AUDIT_LOG_REL_PATH);
+}
+//# sourceMappingURL=candidates-log.js.map

package/dist/triage/actions/errors.d.ts

@@ -0,0 +1,17 @@
+/** Validation errors for audit-log entries. */
+export declare class CandidatesLogError extends Error {
+    constructor(message: string);
+}
+/** Raised when a triage action cannot complete. */
+export declare class TriageError extends Error {
+    constructor(message: string);
+}
+/** ``gh issue close`` failed; companion audit entry has been rolled back. */
+export declare class UpstreamCloseError extends TriageError {
+    constructor(message: string);
+}
+/** Resume-condition grammar parse failure. */
+export declare class ResumeGrammarError extends Error {
+    constructor(message: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/triage/actions/errors.js

@@ -0,0 +1,29 @@
+/** Validation errors for audit-log entries. */
+export class CandidatesLogError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "CandidatesLogError";
+    }
+}
+/** Raised when a triage action cannot complete. */
+export class TriageError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TriageError";
+    }
+}
+/** ``gh issue close`` failed; companion audit entry has been rolled back. */
+export class UpstreamCloseError extends TriageError {
+    constructor(message) {
+        super(message);
+        this.name = "UpstreamCloseError";
+    }
+}
+/** Resume-condition grammar parse failure. */
+export class ResumeGrammarError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ResumeGrammarError";
+    }
+}
+//# sourceMappingURL=errors.js.map

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

@@ -0,0 +1,19 @@
+import type { AcceptOptions, AuditEntry, DeferOptions, RejectOptions, TriageActionsDeps } from "./types.js";
+export { AUDIT_LOG_REL_PATH, createCandidatesLog, resolveAuditLogPath, rollbackAuditEntry, } from "./candidates-log.js";
+export { CandidatesLogError, ResumeGrammarError, TriageError, UpstreamCloseError, } from "./errors.js";
+export { parseResumeOn } from "./resume-on.js";
+export type { AcceptOptions, AuditEntry, CandidatesLog, DeferOptions, IssueIngest, RejectOptions, ScmRunner, TriageActionsDeps, } from "./types.js";
+export declare const REJECTED_LABEL = "triage-rejected";
+export declare const REJECTED_LABEL_COLOR = "B60205";
+export declare const REJECTED_LABEL_DESCRIPTION = "Issue rejected during deft triage";
+/** Default dependency bundle for production CLI use. */
+export declare function createDefaultDeps(projectRoot: string): TriageActionsDeps;
+/** Record an accept audit entry and delegate vBRIEF authoring to issue_ingest. */
+export declare function accept(issueNumber: number, repo: string, deps: TriageActionsDeps, options?: AcceptOptions): string;
+/** Close upstream, best-effort label, record reject audit entry. */
+export declare function reject(issueNumber: number, repo: string, reason: string, deps: TriageActionsDeps, options?: RejectOptions): string;
+/** Record a defer audit entry (#1123 -- structured reason + resume_on). */
+export declare function deferAction(issueNumber: number, repo: string, reason: string | null | undefined, deps: TriageActionsDeps, options?: DeferOptions): string;
+/** Format a decision entry for CLI ``status`` / ``history`` output. */
+export declare function formatDecision(entry: AuditEntry | null): string;
+//# sourceMappingURL=index.d.ts.map