@deftai/directive-core 0.55.0

package/dist/packs/quarantine-ext.js

@@ -0,0 +1,164 @@
+/** Port of scripts/quarantine_ext.py — prompt-injection quarantine (#583). */
+import { readFileSync } from "node:fs";
+import { parseMarkdownHeading } from "../text/redos-safe.js";
+export const SUSPICIOUS_TOKENS = [
+    "STEP",
+    "TASK:",
+    "TASK ",
+    "IMPORTANT:",
+    "IMPORTANT ",
+    "MUST",
+    "SYSTEM:",
+    "SYSTEM ",
+    "AGENT:",
+    "AGENT ",
+    "ASSISTANT:",
+    "USER:",
+    "INSTRUCTION:",
+    "INSTRUCTIONS:",
+    "TOOL:",
+    "FUNCTION:",
+    "PROMPT:",
+    "OVERRIDE:",
+    "IGNORE PREVIOUS",
+    "DISREGARD PREVIOUS",
+    "FORGET PREVIOUS",
+    "ROLE:",
+    "DIRECTIVE:",
+];
+export const QUARANTINE_FENCE_OPEN = "```quarantined";
+export const QUARANTINE_FENCE_CLOSE = "```";
+function isWordChar(ch) {
+    return ((ch >= "A" && ch <= "Z") || (ch >= "a" && ch <= "z") || (ch >= "0" && ch <= "9") || ch === "_");
+}
+function hasWordBoundaryBefore(text, index) {
+    return index === 0 || !isWordChar(text[index - 1]);
+}
+function hasWordBoundaryAfter(text, index) {
+    return index >= text.length || !isWordChar(text[index]);
+}
+function isSuspicious(line) {
+    const lower = line.toLowerCase();
+    for (const token of SUSPICIOUS_TOKENS) {
+        const search = token.toLowerCase();
+        let start = 0;
+        while (start <= line.length - search.length) {
+            const idx = lower.indexOf(search, start);
+            if (idx < 0) {
+                break;
+            }
+            if (hasWordBoundaryBefore(line, idx)) {
+                if (token.endsWith(":") || token.endsWith(" ")) {
+                    return true;
+                }
+                if (hasWordBoundaryAfter(line, idx + search.length)) {
+                    return true;
+                }
+            }
+            start = idx + 1;
+        }
+    }
+    return false;
+}
+function isHeading(line) {
+    return parseMarkdownHeading(line) !== null;
+}
+function matchFence(line) {
+    if (line.startsWith("```")) {
+        return "```";
+    }
+    if (line.startsWith("~~~")) {
+        return "~~~";
+    }
+    return null;
+}
+function splitLines(text) {
+    if (text.length === 0) {
+        return [];
+    }
+    const lines = text.split(/\r\n|\r|\n/);
+    if (text.endsWith("\n") ||
+        text.endsWith("\r\n") ||
+        (text.endsWith("\r") && !text.endsWith("\r\n"))) {
+        if (lines.length > 0 && lines[lines.length - 1] === "") {
+            lines.pop();
+        }
+    }
+    return lines;
+}
+export function quarantineBody(rawMd) {
+    if (!rawMd) {
+        return rawMd;
+    }
+    const lines = splitLines(rawMd);
+    const out = [];
+    let i = 0;
+    let inFence = null;
+    while (i < lines.length) {
+        const line = lines[i];
+        const fenceMatch = matchFence(line);
+        if (fenceMatch !== null) {
+            if (inFence === null) {
+                inFence = fenceMatch;
+            }
+            else if (line.startsWith(inFence)) {
+                inFence = null;
+            }
+            out.push(line);
+            i += 1;
+            continue;
+        }
+        if (inFence !== null) {
+            out.push(line);
+            i += 1;
+            continue;
+        }
+        if (isHeading(line) && isSuspicious(line)) {
+            let sectionEnd = i + 1;
+            while (sectionEnd < lines.length) {
+                const nxt = lines[sectionEnd];
+                const nestedFence = matchFence(nxt);
+                if (nestedFence !== null) {
+                    sectionEnd += 1;
+                    const nested = nxt.slice(0, 3);
+                    while (sectionEnd < lines.length && !lines[sectionEnd]?.startsWith(nested)) {
+                        sectionEnd += 1;
+                    }
+                    sectionEnd += 1;
+                    continue;
+                }
+                if (isHeading(nxt)) {
+                    break;
+                }
+                sectionEnd += 1;
+            }
+            out.push(QUARANTINE_FENCE_OPEN);
+            out.push(...lines.slice(i, sectionEnd));
+            out.push(QUARANTINE_FENCE_CLOSE);
+            i = sectionEnd;
+            continue;
+        }
+        if (isSuspicious(line)) {
+            out.push(QUARANTINE_FENCE_OPEN);
+            out.push(line);
+            out.push(QUARANTINE_FENCE_CLOSE);
+            i += 1;
+            continue;
+        }
+        out.push(line);
+        i += 1;
+    }
+    const suffix = rawMd.endsWith("\n") ? "\n" : "";
+    return out.join("\n") + suffix;
+}
+export function main(argv) {
+    const args = argv ?? process.argv.slice(2);
+    if (args.length > 0 && (args[0] === "-h" || args[0] === "--help")) {
+        process.stdout.write("quarantine_ext.py -- prompt-injection quarantine for cached issue bodies (#583).\n");
+        return 0;
+    }
+    const text = args.length > 0 ? readFileSync(args[0], "utf8") : readFileSync(0, "utf8");
+    process.stdout.write(quarantineBody(text));
+    return 0;
+}
+//# sourceMappingURL=quarantine-ext.js.map

package/dist/platform/agents-md.d.ts

@@ -0,0 +1,31 @@
+export interface ManagedSectionAttrs {
+    readonly version: number;
+    readonly sha: string | null;
+    readonly refreshed: string | null;
+    readonly session: string | null;
+    readonly extras: Record<string, string>;
+}
+export interface AgentsMdSeams {
+    readonly frameworkRoot?: string;
+    readonly readTemplate?: () => string | null;
+    readonly resolveSha?: () => string;
+    readonly nowIso?: () => string;
+    readonly newSession?: () => string;
+    readonly readAgents?: (path: string) => string | null;
+}
+/** Return the framework root (directory owning `templates/`). */
+export declare function frameworkRoot(seams?: AgentsMdSeams): string;
+export declare function parseManagedSectionAttrs(extracted: string): ManagedSectionAttrs | null;
+export declare function stripManagedSectionAttrs(section: string): string;
+export declare function renderManagedSection(templateText: string): string | null;
+export declare function extractManagedSection(text: string): string | null;
+export declare function iterManagedSections(text: string): Array<[number, number, string]>;
+export declare function attributeRenderManagedSection(rendered: string, attrs: {
+    frameworkSha: string;
+    refreshed: string;
+    sessionId: string;
+}): string;
+/** Compute AGENTS.md managed-section freshness plan (mirrors scripts/_agents_md.py). */
+export declare function agentsRefreshPlan(projectRoot: string, seams?: AgentsMdSeams): Record<string, unknown>;
+export declare function hasV3ManagedMarker(projectRoot: string, readText?: (path: string) => string | null): boolean;
+//# sourceMappingURL=agents-md.d.ts.map

package/dist/platform/agents-md.js

@@ -0,0 +1,320 @@
+import { execFileSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { contentRoot } from "../content-root.js";
+import { AGENTS_MANAGED_CLOSE, AGENTS_MANAGED_OPEN_V3_LITERAL } from "./constants.js";
+import { findManagedOpenMarker } from "./linear-scan.js";
+/** Return the framework root (directory owning `templates/`). */
+export function frameworkRoot(seams = {}) {
+    if (seams.frameworkRoot)
+        return resolve(seams.frameworkRoot);
+    const envRoot = process.env.DEFT_ROOT?.trim();
+    if (envRoot)
+        return resolve(envRoot);
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 8; i += 1) {
+        // #1875: templates/ moved under content/ in the source repo; the C1 flatten
+        // deposits it at templates/ in a consumer install. Accept either layout.
+        if (existsSync(join(dir, "content", "templates", "agents-entry.md")) ||
+            existsSync(join(dir, "templates", "agents-entry.md")))
+            return dir;
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "..");
+}
+function agentsTemplatePath(seams = {}) {
+    // #1875: resolve through contentRoot so the template is found in both the
+    // source checkout (content/templates/agents-entry.md) and the flattened
+    // consumer deposit (templates/agents-entry.md). Mirrors scripts/_agents_md.py.
+    return join(contentRoot(frameworkRoot(seams)), "templates", "agents-entry.md");
+}
+function readAgentsTemplate(seams = {}) {
+    if (seams.readTemplate)
+        return seams.readTemplate();
+    const candidate = agentsTemplatePath(seams);
+    try {
+        if (!existsSync(candidate))
+            return null;
+        return readFileSync(candidate, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+function resolveFrameworkSha(seams = {}) {
+    if (seams.resolveSha)
+        return seams.resolveSha();
+    const root = frameworkRoot(seams);
+    try {
+        const stdout = execFileSync("git", ["rev-parse", "--short=12", "HEAD"], {
+            cwd: root,
+            encoding: "utf8",
+            timeout: 5000,
+        });
+        const sha = stdout.trim();
+        return sha || "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+function nowUtcIso() {
+    return new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+function newSessionId() {
+    return randomUUID().replace(/-/g, "").slice(0, 12);
+}
+export function parseManagedSectionAttrs(extracted) {
+    const open = findManagedOpenMarker(extracted, 0);
+    if (open === null)
+        return null;
+    let result = {
+        version: open.version,
+        sha: null,
+        refreshed: null,
+        session: null,
+        extras: {},
+    };
+    for (const rawPair of open.attrsRaw.split(/\s+/)) {
+        const eq = rawPair.indexOf("=");
+        if (eq < 0)
+            continue;
+        const key = rawPair.slice(0, eq).trim().toLowerCase();
+        let value = rawPair.slice(eq + 1).trim();
+        if ((value.startsWith("'") && value.endsWith("'")) ||
+            (value.startsWith('"') && value.endsWith('"'))) {
+            value = value.slice(1, -1);
+        }
+        if (!key)
+            continue;
+        if (key === "sha")
+            result = { ...result, sha: value };
+        else if (key === "refreshed")
+            result = { ...result, refreshed: value };
+        else if (key === "session")
+            result = { ...result, session: value };
+        else
+            result.extras[key] = value;
+    }
+    return result;
+}
+export function stripManagedSectionAttrs(section) {
+    const open = findManagedOpenMarker(section, 0);
+    if (open === null)
+        return section;
+    return section.slice(0, open.start) + AGENTS_MANAGED_OPEN_V3_LITERAL + section.slice(open.end);
+}
+export function renderManagedSection(templateText) {
+    const normalised = templateText.replace(/\r\n/g, "\n");
+    const open = findManagedOpenMarker(normalised, 0);
+    if (open === null)
+        return null;
+    const closeIdx = normalised.indexOf(AGENTS_MANAGED_CLOSE, open.end);
+    if (closeIdx < 0)
+        return null;
+    const end = closeIdx + AGENTS_MANAGED_CLOSE.length;
+    return stripManagedSectionAttrs(normalised.slice(open.start, end));
+}
+export function extractManagedSection(text) {
+    const normalised = text.replace(/\r\n/g, "\n");
+    const open = findManagedOpenMarker(normalised, 0);
+    if (open === null)
+        return null;
+    const closeIdx = normalised.indexOf(AGENTS_MANAGED_CLOSE, open.end);
+    if (closeIdx < 0)
+        return null;
+    const end = closeIdx + AGENTS_MANAGED_CLOSE.length;
+    return normalised.slice(open.start, end);
+}
+export function iterManagedSections(text) {
+    const results = [];
+    let pos = 0;
+    while (pos <= text.length) {
+        const open = findManagedOpenMarker(text, pos);
+        if (open === null)
+            break;
+        const closeIdx = text.indexOf(AGENTS_MANAGED_CLOSE, open.end);
+        if (closeIdx < 0)
+            break;
+        const end = closeIdx + AGENTS_MANAGED_CLOSE.length;
+        results.push([open.start, end, text.slice(open.start, end)]);
+        pos = end;
+    }
+    return results;
+}
+export function attributeRenderManagedSection(rendered, attrs) {
+    const attrString = `v3 sha=${attrs.frameworkSha} refreshed=${attrs.refreshed} session=${attrs.sessionId}`;
+    const attributedOpen = `<!-- deft:managed-section ${attrString} -->`;
+    return rendered.replace(AGENTS_MANAGED_OPEN_V3_LITERAL, attributedOpen);
+}
+function wrapLegacyInMarkers(existing, rendered) {
+    const body = existing.replace(/\r\n/g, "\n").replace(/\n$/, "");
+    if (body)
+        return `${body}\n\n${rendered}\n`;
+    return `${rendered}\n`;
+}
+/** Compute AGENTS.md managed-section freshness plan (mirrors scripts/_agents_md.py). */
+export function agentsRefreshPlan(projectRoot, seams = {}) {
+    const readTemplate = seams.readTemplate ?? (() => readAgentsTemplate(seams));
+    const resolveSha = seams.resolveSha ?? (() => resolveFrameworkSha(seams));
+    const nowIso = seams.nowIso ?? nowUtcIso;
+    const newSession = seams.newSession ?? newSessionId;
+    const readAgents = seams.readAgents ??
+        ((path) => {
+            try {
+                if (!existsSync(path))
+                    return null;
+                return readFileSync(path, "utf8");
+            }
+            catch {
+                return null;
+            }
+        });
+    const templateText = readTemplate();
+    if (templateText === null) {
+        return {
+            state: "template-missing",
+            path: join(projectRoot, "AGENTS.md"),
+            rendered: null,
+            existing: null,
+            new_content: null,
+        };
+    }
+    const rendered = renderManagedSection(templateText);
+    if (rendered === null) {
+        return {
+            state: "template-malformed",
+            path: join(projectRoot, "AGENTS.md"),
+            rendered: null,
+            existing: null,
+            new_content: null,
+        };
+    }
+    const frameworkSha = resolveSha();
+    const refreshed = nowIso();
+    const sessionId = newSession();
+    const attributedRendered = attributeRenderManagedSection(rendered, {
+        frameworkSha,
+        refreshed,
+        sessionId,
+    });
+    const agentsMd = join(projectRoot, "AGENTS.md");
+    let existing;
+    try {
+        existing = readAgents(agentsMd);
+    }
+    catch (exc) {
+        return {
+            state: "unreadable",
+            path: agentsMd,
+            rendered,
+            existing: null,
+            new_content: null,
+            error: String(exc),
+        };
+    }
+    if (existing === null) {
+        return {
+            state: "absent",
+            path: agentsMd,
+            rendered,
+            attributed_rendered: attributedRendered,
+            sha: frameworkSha,
+            refreshed,
+            session: sessionId,
+            existing: null,
+            new_content: `${attributedRendered}\n`,
+        };
+    }
+    const normalised = existing.replace(/\r\n/g, "\n");
+    const blocks = iterManagedSections(normalised);
+    if (blocks.length === 0) {
+        return {
+            state: "missing",
+            path: agentsMd,
+            rendered,
+            attributed_rendered: attributedRendered,
+            sha: frameworkSha,
+            refreshed,
+            session: sessionId,
+            existing,
+            new_content: wrapLegacyInMarkers(normalised, attributedRendered),
+        };
+    }
+    if (blocks.length > 1) {
+        const firstStart = blocks[0]?.[0] ?? 0;
+        let newContent = normalised;
+        for (const [start, end] of [...blocks].reverse()) {
+            newContent = newContent.slice(0, start) + newContent.slice(end);
+        }
+        newContent =
+            newContent.slice(0, firstStart) + attributedRendered + newContent.slice(firstStart);
+        return {
+            state: "stale",
+            path: agentsMd,
+            rendered,
+            attributed_rendered: attributedRendered,
+            sha: frameworkSha,
+            refreshed,
+            session: sessionId,
+            existing,
+            new_content: newContent,
+        };
+    }
+    const extracted = blocks[0]?.[2] ?? "";
+    const extractedAttrs = parseManagedSectionAttrs(extracted);
+    const isLegacyMarker = extractedAttrs !== null && [1, 2].includes(extractedAttrs.version);
+    if (!isLegacyMarker && stripManagedSectionAttrs(extracted) === rendered) {
+        return {
+            state: "current",
+            path: agentsMd,
+            rendered,
+            existing,
+            new_content: existing,
+        };
+    }
+    const newContent = normalised.replace(extracted, attributedRendered);
+    return {
+        state: "stale",
+        path: agentsMd,
+        rendered,
+        attributed_rendered: attributedRendered,
+        sha: frameworkSha,
+        refreshed,
+        session: sessionId,
+        existing,
+        new_content: newContent,
+    };
+}
+export function hasV3ManagedMarker(projectRoot, readText = defaultReadAgents) {
+    const agentsMd = join(projectRoot, "AGENTS.md");
+    const text = readText(agentsMd);
+    if (text === null)
+        return false;
+    let pos = 0;
+    while (pos < text.length) {
+        const open = findManagedOpenMarker(text, pos);
+        if (open === null)
+            return false;
+        if (open.version === 3)
+            return true;
+        pos = open.end;
+    }
+    return false;
+}
+function defaultReadAgents(path) {
+    try {
+        if (!existsSync(path))
+            return null;
+        return readFileSync(path, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=agents-md.js.map

package/dist/platform/changelog-cli.d.ts

@@ -0,0 +1,3 @@
+/** CLI entry for changelog:resolve-unreleased (mirrors resolve_changelog_unreleased.py). */
+export declare function changelogResolveUnreleasedMain(argv: string[]): number;
+//# sourceMappingURL=changelog-cli.d.ts.map

package/dist/platform/changelog-cli.js

@@ -0,0 +1,64 @@
+import { existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { evaluateChangelogPath } from "./resolve-changelog-unreleased.js";
+function parseChangelogCliArgs(argv) {
+    let changelogPath = "CHANGELOG.md";
+    let dryRun = false;
+    let quiet = false;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--changelog-path") {
+            const v = argv[i + 1];
+            if (v === undefined) {
+                return { changelogPath, dryRun, quiet, error: "missing --changelog-path value" };
+            }
+            changelogPath = v;
+            i += 1;
+        }
+        else if (arg?.startsWith("--changelog-path=")) {
+            changelogPath = arg.slice("--changelog-path=".length);
+        }
+        else if (arg === "--dry-run") {
+            dryRun = true;
+        }
+        else if (arg === "--quiet") {
+            quiet = true;
+        }
+        else {
+            return { changelogPath, dryRun, quiet, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return { changelogPath, dryRun, quiet };
+}
+/** CLI entry for changelog:resolve-unreleased (mirrors resolve_changelog_unreleased.py). */
+export function changelogResolveUnreleasedMain(argv) {
+    const parsed = parseChangelogCliArgs(argv);
+    if (parsed.error !== undefined) {
+        process.stderr.write(`resolve_changelog_unreleased: ${parsed.error}\n` +
+            `Usage: changelog-resolve-unreleased [--changelog-path PATH] [--dry-run] [--quiet]\n`);
+        return 2;
+    }
+    const absPath = resolve(parsed.changelogPath);
+    const exists = existsSync(absPath);
+    const isFile = exists && statSync(absPath).isFile();
+    const [code, message, warnings] = evaluateChangelogPath(absPath, {
+        exists,
+        isFile,
+        readText: () => readFileSync(absPath, "utf8"),
+        dryRun: parsed.dryRun,
+        writeText: (content) => writeFileSync(absPath, content, "utf8"),
+    });
+    for (const w of warnings) {
+        process.stderr.write(`warning: ${w}\n`);
+    }
+    if (code === 0) {
+        if (!parsed.quiet) {
+            process.stdout.write(`${message}\n`);
+        }
+    }
+    else {
+        process.stderr.write(`${message}\n`);
+    }
+    return code;
+}
+//# sourceMappingURL=changelog-cli.js.map

package/dist/platform/constants.d.ts

@@ -0,0 +1,20 @@
+/** Shared platform constants mirroring Python module defaults. */
+export declare const AGENTS_MANAGED_CLOSE = "<!-- /deft:managed-section -->";
+export declare const AGENTS_MANAGED_OPEN_V3_LITERAL = "<!-- deft:managed-section v3 -->";
+export declare const DEV_FALLBACK = "0.0.0-dev";
+export declare const ENV_VAR = "DEFT_RELEASE_VERSION";
+export declare const WINDOWS_RESERVED: Set<string>;
+export declare const DEFAULT_MAX_LEN = 60;
+export declare const CONTENT_PREFIX_LEN = 60;
+export declare const CONFLICT_HEAD_PREFIX = "<<<<<<< ";
+export declare const CONFLICT_SEP = "=======";
+export declare const CONFLICT_TAIL_PREFIX = ">>>>>>> ";
+export declare const AMBIENT_NONE = "";
+export declare const RUNTIME_MODE_LOCAL_UNSANDBOXED = "local-unsandboxed";
+export declare const RUNTIME_MODE_CURSOR_NATIVE_SANDBOX = "cursor-native-sandbox";
+export declare const RUNTIME_MODE_CLOUD_HEADLESS = "cloud-headless";
+export declare const IDENTITY_REAL_ROOT = "real-root";
+export declare const IDENTITY_SANDBOX_REMAPPED_LOCAL_USER = "sandbox-remapped-local-user";
+export declare const IDENTITY_LOCAL_USER = "local-user";
+export declare const IDENTITY_UNKNOWN = "unknown";
+//# sourceMappingURL=constants.d.ts.map

package/dist/platform/constants.js

@@ -0,0 +1,27 @@
+/** Shared platform constants mirroring Python module defaults. */
+export const AGENTS_MANAGED_CLOSE = "<!-- /deft:managed-section -->";
+export const AGENTS_MANAGED_OPEN_V3_LITERAL = "<!-- deft:managed-section v3 -->";
+export const DEV_FALLBACK = "0.0.0-dev";
+export const ENV_VAR = "DEFT_RELEASE_VERSION";
+export const WINDOWS_RESERVED = new Set([
+    "con",
+    "prn",
+    "aux",
+    "nul",
+    ...Array.from({ length: 9 }, (_, i) => `com${i + 1}`),
+    ...Array.from({ length: 9 }, (_, i) => `lpt${i + 1}`),
+]);
+export const DEFAULT_MAX_LEN = 60;
+export const CONTENT_PREFIX_LEN = 60;
+export const CONFLICT_HEAD_PREFIX = "<<<<<<< ";
+export const CONFLICT_SEP = "=======";
+export const CONFLICT_TAIL_PREFIX = ">>>>>>> ";
+export const AMBIENT_NONE = "";
+export const RUNTIME_MODE_LOCAL_UNSANDBOXED = "local-unsandboxed";
+export const RUNTIME_MODE_CURSOR_NATIVE_SANDBOX = "cursor-native-sandbox";
+export const RUNTIME_MODE_CLOUD_HEADLESS = "cloud-headless";
+export const IDENTITY_REAL_ROOT = "real-root";
+export const IDENTITY_SANDBOX_REMAPPED_LOCAL_USER = "sandbox-remapped-local-user";
+export const IDENTITY_LOCAL_USER = "local-user";
+export const IDENTITY_UNKNOWN = "unknown";
+//# sourceMappingURL=constants.js.map

package/dist/platform/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./agents-md.js";
+export * from "./constants.js";
+export * from "./ip-risk.js";
+export * from "./linear-scan.js";
+export * from "./platform-capabilities.js";
+export * from "./resolve-changelog-unreleased.js";
+export * from "./resolve-version.js";
+export * from "./slug-normalize.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/platform/index.js

@@ -0,0 +1,9 @@
+export * from "./agents-md.js";
+export * from "./constants.js";
+export * from "./ip-risk.js";
+export * from "./linear-scan.js";
+export * from "./platform-capabilities.js";
+export * from "./resolve-changelog-unreleased.js";
+export * from "./resolve-version.js";
+export * from "./slug-normalize.js";
+//# sourceMappingURL=index.js.map

package/dist/platform/ip-risk.d.ts

@@ -0,0 +1,10 @@
+export interface IPHit {
+    readonly term: string;
+    readonly category: string;
+}
+/** Scan text for known IP terms (mirrors scripts/ip_risk.py). */
+export declare function detectIpTerms(text: string): IPHit[];
+export declare function isIpAdjacent(text: string): boolean;
+export declare function ipRiskScopeItems(monetizationIntent: string): Array<Record<string, unknown>>;
+export declare function plainRiskSummary(hits: IPHit[], monetizationIntent: string): string;
+//# sourceMappingURL=ip-risk.d.ts.map