@deftai/directive-core 0.61.2 → 0.63.0

package/dist/check-updates/index.d.ts

@@ -0,0 +1,49 @@
+/** Default subprocess timeout for `git ls-remote` (seconds). */
+export declare const REMOTE_PROBE_DEFAULT_TIMEOUT = 5;
+/** Baked-in canonical upstream (#1320). Never probe consumer origin. */
+export declare const DEFT_UPSTREAM_URL = "https://github.com/deftai/directive.git";
+/** Reject git ls-remote targets that could be parsed as options (#CodeQL). */
+export declare function isSafeGitLsRemoteTarget(url: string): boolean;
+/** Return a trimmed upstream URL safe for `git ls-remote`, or null when rejected. */
+export declare function sanitizeGitLsRemoteTarget(url: string): string | null;
+export type RemoteProbeStatus = "ok" | "behind" | "skipped" | "no-upstream" | "no-tags" | "error";
+export interface RemoteProbeResult {
+    readonly status: RemoteProbeStatus;
+    readonly current: string;
+    readonly remote?: string;
+    readonly upstream_url?: string;
+    readonly reason?: string;
+    readonly error?: string;
+}
+export type SemverKey = readonly [number, number, number, number, string];
+export interface GitRunner {
+    lsRemoteTags(upstreamUrl: string, timeoutMs: number): string[] | "timeout" | "os-error";
+}
+export declare function parseSemverTag(tag: string): SemverKey | null;
+export declare function maxSemverTag(tags: readonly string[]): string | null;
+export declare function resolveProbeCurrentVersion(projectRoot: string, frameworkRoot?: string): string;
+export declare function resolveUpstreamUrl(projectRoot: string): string;
+export declare function resolveProbeTimeout(env?: NodeJS.ProcessEnv): number;
+export declare function noNetworkActive(env?: NodeJS.ProcessEnv): boolean;
+export declare function parseLsRemoteTags(stdout: string): string[];
+export declare function defaultGitRunner(): GitRunner;
+export interface RunRemoteProbeOptions {
+    readonly projectRoot: string;
+    readonly frameworkRoot?: string;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly git?: GitRunner;
+}
+export declare function runRemoteProbe(options: RunRemoteProbeOptions): RemoteProbeResult;
+export interface EmitCheckUpdatesOptions {
+    readonly jsonMode: boolean;
+    readonly writeOut: (text: string) => void;
+}
+export declare function emitCheckUpdates(result: RemoteProbeResult, options: EmitCheckUpdatesOptions): number;
+export declare function runCheckUpdates(argv: readonly string[], options?: {
+    projectRoot?: string;
+    frameworkRoot?: string;
+    env?: NodeJS.ProcessEnv;
+    git?: GitRunner;
+    writeOut?: (text: string) => void;
+}): number;
+//# sourceMappingURL=index.d.ts.map

package/dist/check-updates/index.js

@@ -0,0 +1,323 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { manifestTagToVersion, parseInstallManifest } from "../doctor/manifest.js";
+import { resolveVersion } from "../doctor/paths.js";
+/** Default subprocess timeout for `git ls-remote` (seconds). */
+export const REMOTE_PROBE_DEFAULT_TIMEOUT = 5.0;
+/** Baked-in canonical upstream (#1320). Never probe consumer origin. */
+export const DEFT_UPSTREAM_URL = "https://github.com/deftai/directive.git";
+const MANIFEST_UPSTREAM_URL_KEYS = [
+    "source_url",
+    "url",
+    "upstream_url",
+    "upstream",
+    "origin",
+];
+/** Reject git ls-remote targets that could be parsed as options (#CodeQL). */
+export function isSafeGitLsRemoteTarget(url) {
+    return sanitizeGitLsRemoteTarget(url) !== null;
+}
+/** Return a trimmed upstream URL safe for `git ls-remote`, or null when rejected. */
+export function sanitizeGitLsRemoteTarget(url) {
+    const trimmed = url.trim();
+    if (!trimmed || trimmed.startsWith("-")) {
+        return null;
+    }
+    if (/^https?:\/\/\S+$/i.test(trimmed)) {
+        return trimmed;
+    }
+    if (/^git@[\w.-]+:[\w./-]+\.git$/i.test(trimmed)) {
+        return trimmed;
+    }
+    return null;
+}
+function normalizePrereleaseForSort(pre) {
+    const dot = pre.indexOf(".");
+    if (dot <= 0) {
+        return pre;
+    }
+    const kind = pre.slice(0, dot).toLowerCase();
+    if (kind !== "alpha" && kind !== "beta" && kind !== "rc") {
+        return pre;
+    }
+    const afterKind = pre.slice(dot + 1);
+    let numEnd = 0;
+    while (numEnd < afterKind.length) {
+        const ch = afterKind[numEnd];
+        if (ch === undefined || ch < "0" || ch > "9") {
+            break;
+        }
+        numEnd += 1;
+    }
+    if (numEnd === 0) {
+        return pre;
+    }
+    const padded = afterKind.slice(0, numEnd).padStart(8, "0");
+    return `${kind}.${padded}${afterKind.slice(numEnd)}`;
+}
+const SEMVER_TAG_RE = /^v?(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)(?<pre>-[\w][\w.-]*)?$/;
+export function parseSemverTag(tag) {
+    if (!tag) {
+        return null;
+    }
+    const match = SEMVER_TAG_RE.exec(tag.trim());
+    if (!match?.groups) {
+        return null;
+    }
+    const pre = match.groups.pre ?? "";
+    const preStripped = pre.replace(/^-/, "");
+    return [
+        Number(match.groups.major),
+        Number(match.groups.minor),
+        Number(match.groups.patch),
+        pre ? 0 : 1,
+        normalizePrereleaseForSort(preStripped),
+    ];
+}
+export function maxSemverTag(tags) {
+    const parsed = [];
+    for (const tag of tags) {
+        const key = parseSemverTag(tag);
+        if (key !== null) {
+            parsed.push({ key, tag });
+        }
+    }
+    if (parsed.length === 0) {
+        return null;
+    }
+    parsed.sort((a, b) => {
+        for (let i = 0; i < a.key.length; i += 1) {
+            const av = a.key[i];
+            const bv = b.key[i];
+            if (typeof av === "number" && typeof bv === "number" && av !== bv) {
+                return av - bv;
+            }
+            if (typeof av === "string" && typeof bv === "string" && av !== bv) {
+                return av < bv ? -1 : 1;
+            }
+        }
+        return 0;
+    });
+    return parsed[parsed.length - 1]?.tag ?? null;
+}
+function readVendoredManifest(projectRoot) {
+    for (const candidate of [
+        join(projectRoot, ".deft", "core", "VERSION"),
+        join(projectRoot, ".deft", "VERSION"),
+        join(projectRoot, "deft", "VERSION"),
+    ]) {
+        if (!existsSync(candidate)) {
+            continue;
+        }
+        try {
+            return parseInstallManifest(readFileSync(candidate, "utf8"));
+        }
+        catch { }
+    }
+    return null;
+}
+export function resolveProbeCurrentVersion(projectRoot, frameworkRoot) {
+    const manifest = readVendoredManifest(projectRoot);
+    if (manifest) {
+        const derived = manifestTagToVersion(manifest);
+        if (derived) {
+            return derived;
+        }
+    }
+    return resolveVersion(frameworkRoot).replace(/^v/, "");
+}
+export function resolveUpstreamUrl(projectRoot) {
+    const manifest = readVendoredManifest(projectRoot);
+    if (manifest) {
+        for (const key of MANIFEST_UPSTREAM_URL_KEYS) {
+            const value = manifest[key];
+            if (typeof value === "string" && value.trim()) {
+                const safe = sanitizeGitLsRemoteTarget(value);
+                if (safe) {
+                    return safe;
+                }
+            }
+        }
+    }
+    return DEFT_UPSTREAM_URL;
+}
+export function resolveProbeTimeout(env = process.env) {
+    const raw = (env.DEFT_REMOTE_PROBE_TIMEOUT ?? "").trim();
+    if (!raw) {
+        return REMOTE_PROBE_DEFAULT_TIMEOUT;
+    }
+    const value = Number(raw);
+    if (!Number.isFinite(value) || value <= 0) {
+        return REMOTE_PROBE_DEFAULT_TIMEOUT;
+    }
+    return value;
+}
+export function noNetworkActive(env = process.env) {
+    return (env.DEFT_NO_NETWORK ?? "").trim() === "1";
+}
+export function parseLsRemoteTags(stdout) {
+    const tags = [];
+    for (const line of stdout.split("\n")) {
+        const marker = "\trefs/tags/";
+        const idx = line.indexOf(marker);
+        if (idx < 0) {
+            continue;
+        }
+        const tag = line.slice(idx + marker.length).trim();
+        if (tag) {
+            tags.push(tag);
+        }
+    }
+    return tags;
+}
+export function defaultGitRunner() {
+    return {
+        lsRemoteTags(upstreamUrl, timeoutMs) {
+            const safeUrl = sanitizeGitLsRemoteTarget(upstreamUrl);
+            if (!safeUrl) {
+                return "os-error";
+            }
+            try {
+                const stdout = execFileSync("git", ["ls-remote", "--tags", "--refs", "--", safeUrl], {
+                    encoding: "utf8",
+                    timeout: timeoutMs,
+                });
+                return parseLsRemoteTags(stdout);
+            }
+            catch (exc) {
+                if (exc instanceof Error &&
+                    (exc.message.includes("ETIMEDOUT") || exc.message.includes("timed out"))) {
+                    return "timeout";
+                }
+                return "os-error";
+            }
+        },
+    };
+}
+export function runRemoteProbe(options) {
+    const env = options.env ?? process.env;
+    const current = resolveProbeCurrentVersion(options.projectRoot, options.frameworkRoot);
+    if (noNetworkActive(env)) {
+        return {
+            status: "skipped",
+            reason: "DEFT_NO_NETWORK=1",
+            current,
+        };
+    }
+    const timeoutSec = resolveProbeTimeout(env);
+    const upstreamUrl = resolveUpstreamUrl(options.projectRoot);
+    const git = options.git ?? defaultGitRunner();
+    const tagsResult = git.lsRemoteTags(upstreamUrl, Math.ceil(timeoutSec * 1000));
+    if (tagsResult === "timeout") {
+        return {
+            status: "error",
+            current,
+            upstream_url: upstreamUrl,
+            error: "timeout",
+        };
+    }
+    if (tagsResult === "os-error") {
+        return {
+            status: "error",
+            current,
+            upstream_url: upstreamUrl,
+            error: "Error: git unavailable",
+        };
+    }
+    const remoteTag = maxSemverTag(tagsResult);
+    if (remoteTag === null) {
+        return {
+            status: "no-tags",
+            current,
+            upstream_url: upstreamUrl,
+        };
+    }
+    const remoteKey = parseSemverTag(remoteTag);
+    const currentKey = parseSemverTag(current.startsWith("v") ? current : `v${current}`);
+    if (currentKey !== null && remoteKey !== null && compareSemverKeys(remoteKey, currentKey) > 0) {
+        return {
+            status: "behind",
+            current,
+            remote: remoteTag,
+            upstream_url: upstreamUrl,
+        };
+    }
+    return {
+        status: "ok",
+        current,
+        remote: remoteTag,
+        upstream_url: upstreamUrl,
+    };
+}
+function compareSemverKeys(a, b) {
+    for (let i = 0; i < a.length; i += 1) {
+        const av = a[i];
+        const bv = b[i];
+        if (av === bv) {
+            continue;
+        }
+        if (typeof av === "number" && typeof bv === "number") {
+            return av - bv;
+        }
+        return String(av) < String(bv) ? -1 : 1;
+    }
+    return 0;
+}
+export function emitCheckUpdates(result, options) {
+    if (options.jsonMode) {
+        const payload = {
+            status: result.status,
+            current: result.current,
+        };
+        if (result.remote !== undefined) {
+            payload.remote = result.remote;
+        }
+        if (result.upstream_url !== undefined) {
+            payload.upstream_url = result.upstream_url;
+        }
+        if (result.reason !== undefined) {
+            payload.reason = result.reason;
+        }
+        if (result.error !== undefined) {
+            payload.error = result.error;
+        }
+        options.writeOut(`${JSON.stringify(payload, Object.keys(payload).sort())}\n`);
+    }
+    else {
+        const current = result.current;
+        switch (result.status) {
+            case "ok":
+                options.writeOut(`OK upstream=${result.remote}\n`);
+                break;
+            case "behind":
+                options.writeOut(`BEHIND upstream=${result.remote} current=v${current} commits-behind=unknown\n`);
+                break;
+            case "skipped":
+                options.writeOut(`SKIPPED reason=DEFT_NO_NETWORK current=v${current}\n`);
+                break;
+            case "no-upstream":
+                options.writeOut(`NO-UPSTREAM current=v${current}\n`);
+                break;
+            case "no-tags":
+                options.writeOut(`NO-TAGS current=v${current} upstream=${result.upstream_url ?? ""}\n`);
+                break;
+            default:
+                options.writeOut(`ERROR current=v${current} upstream=${result.upstream_url ?? ""} error=${result.error ?? "unknown"}\n`);
+                break;
+        }
+    }
+    return result.status === "behind" ? 1 : 0;
+}
+export function runCheckUpdates(argv, options = {}) {
+    const jsonMode = argv.includes("--json");
+    const result = runRemoteProbe({
+        projectRoot: options.projectRoot ?? process.cwd(),
+        frameworkRoot: options.frameworkRoot,
+        env: options.env,
+        git: options.git,
+    });
+    const writeOut = options.writeOut ?? ((text) => process.stdout.write(text));
+    return emitCheckUpdates(result, { jsonMode, writeOut });
+}
+//# sourceMappingURL=index.js.map

package/dist/install-upgrade/index.js

@@ -6,7 +6,7 @@ import { buildInstallManifestText, CANONICAL_INSTALL_ROOT, } from "../init-depos
 import { agentsRefreshPlan } from "../platform/agents-md.js";
 import { DEV_FALLBACK } from "../platform/constants.js";
 import { resolveVersion } from "../platform/resolve-version.js";
-import { detectPreCutoverLegacy } from "../vbrief-validate/precutover.js";
+import { detectPreCutoverLegacy, frozenPreCutoverMigrationGuidance, } from "../vbrief-validate/precutover.js";
 const ENGINE_PACKAGE_FALLBACK = "0.0.0";
 /**
  * Resolve the framework version for an upgrade (#2053).
@@ -193,7 +193,7 @@ export function runInstallUpgrade(args, io) {
     }
     const legacy = detectPreCutoverLegacy(projectRoot);
     if (legacy.length > 0) {
-        io.writeOut(`Pre-v0.20 document model detected (${legacy.join(", ")}). Run \`task migrate:vbrief\` first -- it migrates legacy artifacts and creates the lifecycle folder structure. This command only records the framework version.\n`);
+        io.writeOut(`Pre-v0.20 document model detected (${legacy.join(", ")}). ${frozenPreCutoverMigrationGuidance()}\n`);
     }
     const vbriefDir = join(projectRoot, "vbrief");
     const targetDir = existsSync(vbriefDir) && statSync(vbriefDir).isDirectory() ? vbriefDir : projectRoot;
@@ -216,7 +216,7 @@ export function runInstallUpgrade(args, io) {
     else {
         io.writeOut(`Updated .deft-version from ${recorded} to ${normalizedVersion}.\n`);
     }
-    io.writeOut("If legacy SPECIFICATION.md or PROJECT.md content remains, run `task migrate:vbrief` to complete the upgrade.\n");
+    io.writeOut(`If legacy SPECIFICATION.md or PROJECT.md content remains, see UPGRADING.md § Frozen pre-v0.20 document-model migration (#2068).\n`);
     return runAgentsRefresh(projectRoot, agentsRoot, io);
 }
 //# sourceMappingURL=index.js.map

package/dist/migrate-preflight/index.d.ts

@@ -18,11 +18,10 @@ export type MigratePreflightOutcome = {
     readonly exitCode: 0 | 1;
     readonly results: readonly CheckResult[];
 } | MigratePreflightConfigError;
-export declare function checkUv(which?: (cmd: string) => string | null): CheckResult;
 export declare function checkLayout(deftRoot: string, projectRoot: string): CheckResult;
 export declare function checkGitClean(projectRoot: string): CheckResult;
 export declare function checkDocumentModel(projectRoot: string): CheckResult;
-export declare function evaluate(deftRoot: string, projectRoot: string, which?: (cmd: string) => string | null): {
+export declare function evaluate(deftRoot: string, projectRoot: string): {
     exitCode: 0 | 1;
     results: CheckResult[];
 };

package/dist/migrate-preflight/index.js

@@ -1,8 +1,7 @@
 import { execFileSync } from "node:child_process";
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { join, resolve } from "node:path";
-import { defaultWhich } from "../scm/binary.js";
-import { detectPreCutoverLegacy, isCurrentGeneratedSpecification, isGeneratedSpecificationExport, missingLifecycleFolders, } from "../vbrief-validate/precutover.js";
+import { detectPreCutoverLegacy, frozenPreCutoverMigrationGuidance, isCurrentGeneratedSpecification, isGeneratedSpecificationExport, missingLifecycleFolders, } from "../vbrief-validate/precutover.js";
 function resolveContentRoot(frameworkRoot) {
     const nested = join(frameworkRoot, "content");
     try {
@@ -14,25 +13,7 @@ function resolveContentRoot(frameworkRoot) {
     }
     return frameworkRoot;
 }
-export function checkUv(which = defaultWhich) {
-    if (which("uv") !== null) {
-        return { name: "uv", status: "PASS", message: "uv is on PATH." };
-    }
-    return {
-        name: "uv",
-        status: "FAIL",
-        message: "uv is not on PATH. Install from https://docs.astral.sh/uv/ and re-run.",
-    };
-}
 export function checkLayout(deftRoot, projectRoot) {
-    const migrator = join(deftRoot, "scripts", "migrate_vbrief.py");
-    if (!existsSync(migrator) || !statSync(migrator).isFile()) {
-        return {
-            name: "layout",
-            status: "FAIL",
-            message: `Migrator script missing at ${migrator}. The framework checkout appears incomplete or pre-v0.20; refresh per deft/QUICK-START.md.`,
-        };
-    }
     const schemasDir = join(resolveContentRoot(deftRoot), "vbrief", "schemas");
     if (!existsSync(schemasDir) || !statSync(schemasDir).isDirectory()) {
         return {
@@ -46,13 +27,13 @@ export function checkLayout(deftRoot, projectRoot) {
         return {
             name: "layout",
             status: "WARN",
-            message: `Project vbrief/ not present at ${projectVbrief} -- migrator will create it on first run; this is expected for greenfield projects.`,
+            message: `Project vbrief/ not present at ${projectVbrief} -- expected for greenfield projects.`,
         };
     }
     return {
         name: "layout",
         status: "PASS",
-        message: `Framework migrator + schemas present; project vbrief/ at ${projectVbrief}.`,
+        message: `Framework schemas present; project vbrief/ at ${projectVbrief}.`,
     };
 }
 export function checkGitClean(projectRoot) {
@@ -65,7 +46,7 @@ export function checkGitClean(projectRoot) {
             return {
                 name: "git-clean",
                 status: "WARN",
-                message: "Working tree is dirty. The migrator will refuse to run without --force; preview with `task migrate:vbrief -- --dry-run` first.",
+                message: "Working tree is dirty. Commit or stash before running a frozen-release migration.",
             };
         }
         return { name: "git-clean", status: "PASS", message: "Working tree is clean." };
@@ -76,7 +57,7 @@ export function checkGitClean(projectRoot) {
             return {
                 name: "git-clean",
                 status: "WARN",
-                message: "git executable not on PATH; skipping working-tree check. Migrator's dirty-tree guard will still fire if applicable.",
+                message: "git executable not on PATH; skipping working-tree check.",
             };
         }
         return {
@@ -91,8 +72,8 @@ export function checkDocumentModel(projectRoot) {
     if (legacy.length > 0) {
         return {
             name: "document-model",
-            status: "PASS",
-            message: `Legacy root artifact(s) detected: ${legacy.join(", ")}.`,
+            status: "FAIL",
+            message: `Pre-v0.20 document model detected (${legacy.join(", ")}). ${frozenPreCutoverMigrationGuidance()}`,
         };
     }
     const specPath = join(projectRoot, "SPECIFICATION.md");
@@ -117,8 +98,8 @@ export function checkDocumentModel(projectRoot) {
         if (isCurrentGeneratedSpecification(projectRoot, content)) {
             return {
                 name: "document-model",
-                status: "FAIL",
-                message: "Current generated SPECIFICATION.md detected (source: vbrief/specification.vbrief.json); `task migrate:vbrief` is not needed.",
+                status: "PASS",
+                message: "Current generated SPECIFICATION.md detected (source: vbrief/specification.vbrief.json); pre-v0.20 migration is not needed.",
             };
         }
     }
@@ -128,20 +109,19 @@ export function checkDocumentModel(projectRoot) {
         if (missing.length > 0) {
             return {
                 name: "document-model",
-                status: "PASS",
-                message: `Partial vBRIEF layout detected; missing lifecycle folder(s): ${missing.join(", ")}.`,
+                status: "FAIL",
+                message: `Partial vBRIEF layout detected; missing lifecycle folder(s): ${missing.join(", ")}. Create the folders or follow ${frozenPreCutoverMigrationGuidance()}`,
             };
         }
     }
     return {
         name: "document-model",
-        status: "WARN",
-        message: "No legacy root SPECIFICATION.md/PROJECT.md artifacts detected. Migration may have nothing to do.",
+        status: "PASS",
+        message: "No pre-v0.20 document-model artifacts detected.",
     };
 }
-export function evaluate(deftRoot, projectRoot, which = defaultWhich) {
+export function evaluate(deftRoot, projectRoot) {
     const results = [
-        checkUv(which),
         checkLayout(deftRoot, projectRoot),
         checkDocumentModel(projectRoot),
         checkGitClean(projectRoot),
@@ -183,10 +163,10 @@ export function emitMigratePreflight(outcome, io, quiet) {
             io.writeOut(line);
     }
     if (outcome.exitCode === 1) {
-        io.writeErr("migrate:preflight FAILED -- resolve the FAIL line(s) above before running `task migrate:vbrief`.\n");
+        io.writeErr("migrate:preflight FAILED -- pre-v0.20 document model or incomplete vBRIEF layout. Resolve using UPGRADING.md § Frozen pre-v0.20 document-model migration (#2068).\n");
     }
     else {
-        io.writeOut("migrate:preflight OK -- environment ready for `task migrate:vbrief`.\n");
+        io.writeOut("migrate:preflight OK -- no pre-v0.20 document-model migration required.\n");
     }
     return outcome.exitCode;
 }

package/dist/release/build-dist-runner.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=build-dist-runner.d.ts.map

package/dist/release/build-dist-runner.js

@@ -0,0 +1,21 @@
+/**
+ * Subprocess entry for sync callers (release pipeline, task build).
+ * Top-level await keeps the process alive until the archive is written.
+ */
+import { buildArchive, selectFormat } from "./build-dist.js";
+const version = process.argv[2];
+const root = process.argv[3];
+if (!version || !root) {
+    process.stderr.write("usage: build-dist-runner <version> <root>\n");
+    process.exit(2);
+}
+const fmt = selectFormat(process.env.DEFT_BUILD_FORMAT);
+try {
+    const out = await buildArchive(root, version, fmt);
+    process.stdout.write(`${out}\n`);
+}
+catch (err) {
+    process.stderr.write(`${String(err)}\n`);
+    process.exit(1);
+}
+//# sourceMappingURL=build-dist-runner.js.map

package/dist/release/build-dist.d.ts

@@ -0,0 +1,14 @@
+export declare const DEFAULT_EXCLUDES: Set<string>;
+export declare const DEFAULT_EXCLUDED_PATH_PREFIXES: readonly ["history/archive", "vbrief/completed", "vbrief/cancelled"];
+export declare const ARCHIVE_ROOT = "deft";
+export declare const CONTENT_PREFIX = "content/";
+export declare function iterSourceFiles(root: string, excludes?: ReadonlySet<string>, excludedPrefixes?: readonly string[]): Array<{
+    absPath: string;
+    archiveRel: string;
+}>;
+export declare function selectFormat(arg: string | null | undefined): "tar" | "zip";
+export declare function outputPath(root: string, version: string, fmt: "tar" | "zip"): string;
+export declare function buildArchive(root: string, version: string, fmt: "tar" | "zip", extraExcludes?: readonly string[]): Promise<string>;
+export declare function parseExtraExcludes(raw: string): string[];
+export declare function main(argv: readonly string[]): Promise<number>;
+//# sourceMappingURL=build-dist.d.ts.map