agentplane 0.3.6 → 0.3.8

package/dist/commands/upgrade/apply.js

@@ -5,6 +5,7 @@ import { backupPath, fileExists } from "../../cli/fs-utils.js";
 import { exitCodeForError } from "../../cli/exit-codes.js";
 import { withDiagnosticContext } from "../../shared/diagnostics.js";
 import { CliError } from "../../shared/errors.js";
+import { protectedPathKindForFile } from "../../shared/protected-paths.js";
 import { execFileAsync, gitEnv } from "../shared/git.js";
 async function safeRemovePath(targetPath) {
     try {
@@ -74,10 +75,41 @@ export async function createUpgradeCommit(opts) {
         `Source: ${opts.source}\n` +
         `Managed-Changes: add=${opts.additions}, update=${opts.updates}, unchanged=${opts.unchanged}\n` +
         `Incidents-Appended: ${opts.incidentsAppendedCount}\n`;
+    const allow = {
+        allowTasks: false,
+        allowPolicy: false,
+        allowConfig: false,
+        allowHooks: false,
+        allowCI: false,
+    };
+    for (const filePath of uniquePaths) {
+        const kind = protectedPathKindForFile({
+            filePath,
+            tasksPath: opts.tasksPath,
+            workflowDir: opts.workflowDir,
+        });
+        if (kind === "tasks")
+            allow.allowTasks = true;
+        if (kind === "policy")
+            allow.allowPolicy = true;
+        if (kind === "config")
+            allow.allowConfig = true;
+        if (kind === "hooks")
+            allow.allowHooks = true;
+        if (kind === "ci")
+            allow.allowCI = true;
+    }
     try {
         await execFileAsync("git", ["commit", "-m", subject, "-m", body], {
             cwd: opts.gitRoot,
-            env: gitEnv(),
+            env: {
+                ...gitEnv(),
+                AGENTPLANE_ALLOW_TASKS: allow.allowTasks ? "1" : "0",
+                AGENTPLANE_ALLOW_POLICY: allow.allowPolicy ? "1" : "0",
+                AGENTPLANE_ALLOW_CONFIG: allow.allowConfig ? "1" : "0",
+                AGENTPLANE_ALLOW_HOOKS: allow.allowHooks ? "1" : "0",
+                AGENTPLANE_ALLOW_CI: allow.allowCI ? "1" : "0",
+            },
             maxBuffer: 10 * 1024 * 1024,
         });
     }

package/dist/commands/upgrade/materialize.d.ts

@@ -0,0 +1,28 @@
+import type { FrameworkManifest } from "./types.js";
+type MaterializeFlags = {
+    source?: string;
+    tag?: string;
+    bundle?: string;
+    checksum?: string;
+    asset?: string;
+    checksumAsset?: string;
+    remote: boolean;
+    allowTarball: boolean;
+};
+export type MaterializedUpgrade = {
+    tempRoot: string;
+    extractRoot: string | null;
+    bundleLayout: "local_assets" | "upgrade_bundle" | "repo_tarball";
+    bundleRoot: string;
+    manifest: FrameworkManifest;
+    normalizedSourceToPersist: string | null;
+    upgradeVersionLabel: string;
+};
+export declare function materializeUpgradeSource(opts: {
+    flags: MaterializeFlags;
+    frameworkSource: string;
+    assetsDirUrl: URL;
+    ensureApproved: (reason: string) => Promise<void>;
+}): Promise<MaterializedUpgrade>;
+export {};
+//# sourceMappingURL=materialize.d.ts.map

package/dist/commands/upgrade/materialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"materialize.d.ts","sourceRoot":"","sources":["../../../src/commands/upgrade/materialize.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,YAAY,CAAC;AAOnE,KAAK,gBAAgB,GAAG;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,OAAO,CAAC;IAChB,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,YAAY,EAAE,cAAc,GAAG,gBAAgB,GAAG,cAAc,CAAC;IACjE,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,yBAAyB,EAAE,MAAM,GAAG,IAAI,CAAC;IACzC,mBAAmB,EAAE,MAAM,CAAC;CAC7B,CAAC;AAEF,wBAAsB,wBAAwB,CAAC,IAAI,EAAE;IACnD,KAAK,EAAE,gBAAgB,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,GAAG,CAAC;IAClB,cAAc,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACnD,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAkK/B"}

package/dist/commands/upgrade/materialize.js

@@ -0,0 +1,154 @@
+import { mkdtemp, readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { downloadToFile, fetchJson } from "../../cli/http.js";
+import { parseSha256Text, sha256File } from "../../cli/checksum.js";
+import { extractArchive } from "../../cli/archive.js";
+import { exitCodeForError } from "../../cli/exit-codes.js";
+import { warnMessage } from "../../cli/output.js";
+import { getVersion } from "../../meta/version.js";
+import { CliError } from "../../shared/errors.js";
+import { normalizeUpgradeVersionLabel } from "./policy.js";
+import { loadFrameworkManifestFromPath, normalizeFrameworkSourceForUpgrade, resolveRepoTarballUrl, resolveUpgradeDownloadFromRelease, resolveUpgradeRoot, } from "./source.js";
+const DEFAULT_UPGRADE_ASSET = "agentplane-upgrade.tar.gz";
+const DEFAULT_UPGRADE_CHECKSUM_ASSET = "agentplane-upgrade.tar.gz.sha256";
+const UPGRADE_DOWNLOAD_TIMEOUT_MS = 60_000;
+const UPGRADE_RELEASE_METADATA_TIMEOUT_MS = 15_000;
+export async function materializeUpgradeSource(opts) {
+    const { flags } = opts;
+    const hasBundle = Boolean(flags.bundle);
+    const hasRemoteHints = Boolean(flags.source) ||
+        Boolean(flags.tag) ||
+        Boolean(flags.asset) ||
+        Boolean(flags.checksumAsset);
+    const useRemote = flags.remote === true || hasRemoteHints;
+    const tempRoot = await mkdtemp(path.join(os.tmpdir(), "agentplane-upgrade-"));
+    let extractRoot = null;
+    let bundleLayout = "upgrade_bundle";
+    let bundleRoot = "";
+    let normalizedSourceToPersist = null;
+    let upgradeVersionLabel = normalizeUpgradeVersionLabel(getVersion());
+    let manifestPath = "";
+    if (!hasBundle && !useRemote) {
+        bundleLayout = "local_assets";
+        bundleRoot = fileURLToPath(opts.assetsDirUrl);
+        manifestPath = fileURLToPath(new URL("../../../assets/framework.manifest.json", import.meta.url));
+    }
+    else {
+        let bundlePath = "";
+        let checksumPath = "";
+        if (flags.bundle) {
+            const bundleIsUrl = flags.bundle.startsWith("http://") || flags.bundle.startsWith("https://");
+            bundlePath = bundleIsUrl ? path.join(tempRoot, "bundle.tar.gz") : path.resolve(flags.bundle);
+            if (bundleIsUrl) {
+                await opts.ensureApproved("upgrade downloads the bundle/checksum from the network");
+                await downloadToFile(flags.bundle, bundlePath, UPGRADE_DOWNLOAD_TIMEOUT_MS);
+            }
+            const checksumValue = flags.checksum ?? "";
+            const checksumIsUrl = checksumValue.startsWith("http://") || checksumValue.startsWith("https://");
+            checksumPath = checksumIsUrl
+                ? path.join(tempRoot, "bundle.tar.gz.sha256")
+                : path.resolve(checksumValue);
+            if (checksumIsUrl) {
+                await opts.ensureApproved("upgrade downloads the bundle/checksum from the network");
+                await downloadToFile(checksumValue, checksumPath, UPGRADE_DOWNLOAD_TIMEOUT_MS);
+            }
+        }
+        else {
+            const sourceFromFlags = typeof flags.source === "string" && flags.source.trim().length > 0;
+            const originalSource = flags.source ?? opts.frameworkSource;
+            const normalized = normalizeFrameworkSourceForUpgrade(originalSource);
+            if (!sourceFromFlags && normalized.migrated) {
+                normalizedSourceToPersist = normalized.source;
+            }
+            if (normalized.migrated) {
+                process.stderr.write(`${warnMessage(`config.framework.source uses deprecated repo basilisk-labs/agent-plane; using ${normalized.source}`)}\n`);
+            }
+            const releaseUrl = flags.tag
+                ? `https://api.github.com/repos/${normalized.owner}/${normalized.repo}/releases/tags/${flags.tag}`
+                : `https://api.github.com/repos/${normalized.owner}/${normalized.repo}/releases/latest`;
+            await opts.ensureApproved("upgrade fetches release metadata and downloads assets from the network");
+            const release = (await fetchJson(releaseUrl, UPGRADE_RELEASE_METADATA_TIMEOUT_MS));
+            const releaseTag = (typeof release.tag_name === "string" && release.tag_name.trim()) ||
+                (typeof flags.tag === "string" && flags.tag.trim()) ||
+                "";
+            if (releaseTag) {
+                upgradeVersionLabel = normalizeUpgradeVersionLabel(releaseTag);
+            }
+            const download = resolveUpgradeDownloadFromRelease({
+                release,
+                owner: normalized.owner,
+                repo: normalized.repo,
+                assetName: flags.asset ?? DEFAULT_UPGRADE_ASSET,
+                checksumName: flags.checksumAsset ?? DEFAULT_UPGRADE_CHECKSUM_ASSET,
+            });
+            if (download.kind === "assets") {
+                bundlePath = path.join(tempRoot, flags.asset ?? DEFAULT_UPGRADE_ASSET);
+                checksumPath = path.join(tempRoot, flags.checksumAsset ?? DEFAULT_UPGRADE_CHECKSUM_ASSET);
+                await downloadToFile(download.bundleUrl, bundlePath, UPGRADE_DOWNLOAD_TIMEOUT_MS);
+                await downloadToFile(download.checksumUrl, checksumPath, UPGRADE_DOWNLOAD_TIMEOUT_MS);
+            }
+            else {
+                if (!flags.allowTarball) {
+                    throw new CliError({
+                        exitCode: exitCodeForError("E_NETWORK"),
+                        code: "E_NETWORK",
+                        message: `Upgrade assets ${flags.asset ?? DEFAULT_UPGRADE_ASSET}/${flags.checksumAsset ?? DEFAULT_UPGRADE_CHECKSUM_ASSET} not found in ${normalized.owner}/${normalized.repo} release. ` +
+                            "Publish the upgrade bundle assets, or re-run with --allow-tarball to download a repo tarball (no checksum verification).",
+                    });
+                }
+                process.stderr.write(`${warnMessage(`upgrade release does not include ${flags.asset ?? DEFAULT_UPGRADE_ASSET}/${flags.checksumAsset ?? DEFAULT_UPGRADE_CHECKSUM_ASSET}; falling back to repo tarball without checksum verification`)}\n`);
+                bundleLayout = "repo_tarball";
+                bundlePath = path.join(tempRoot, "source.tar.gz");
+                const tarballUrl = resolveRepoTarballUrl({
+                    release,
+                    owner: normalized.owner,
+                    repo: normalized.repo,
+                    explicitTag: flags.tag,
+                });
+                await downloadToFile(tarballUrl, bundlePath, UPGRADE_DOWNLOAD_TIMEOUT_MS);
+                checksumPath = "";
+            }
+        }
+        if (checksumPath) {
+            const expected = parseSha256Text(await readFile(checksumPath, "utf8"));
+            if (!expected) {
+                throw new CliError({
+                    exitCode: 3,
+                    code: "E_VALIDATION",
+                    message: "Upgrade checksum file is empty or invalid",
+                });
+            }
+            const actual = await sha256File(bundlePath);
+            if (actual !== expected) {
+                throw new CliError({
+                    exitCode: 3,
+                    code: "E_VALIDATION",
+                    message: `Upgrade checksum mismatch (expected ${expected}, got ${actual})`,
+                });
+            }
+        }
+        extractRoot = await mkdtemp(path.join(os.tmpdir(), "agentplane-upgrade-extract-"));
+        await extractArchive({
+            archivePath: bundlePath,
+            destDir: extractRoot,
+        });
+        const extractedRoot = await resolveUpgradeRoot(extractRoot);
+        bundleRoot =
+            bundleLayout === "repo_tarball"
+                ? path.join(extractedRoot, "packages", "agentplane", "assets")
+                : extractedRoot;
+        manifestPath = path.join(bundleRoot, "framework.manifest.json");
+    }
+    const manifest = await loadFrameworkManifestFromPath(manifestPath);
+    return {
+        tempRoot,
+        extractRoot,
+        bundleLayout,
+        bundleRoot,
+        manifest,
+        normalizedSourceToPersist,
+        upgradeVersionLabel,
+    };
+}

package/dist/commands/upgrade/plan.d.ts

@@ -0,0 +1,18 @@
+import type { FrameworkManifest, UpgradeReviewRecord } from "./types.js";
+export type ManagedUpgradePlan = {
+    additions: string[];
+    updates: string[];
+    skipped: string[];
+    merged: string[];
+    fileContents: Map<string, Buffer>;
+    reviewRecords: UpgradeReviewRecord[];
+    incidentsAppendedCount: number;
+};
+export declare function planManagedUpgrade(opts: {
+    gitRoot: string;
+    manifest: FrameworkManifest;
+    bundleRoot: string;
+    baselineDirNew: string;
+    baselineDirLegacy: string;
+}): Promise<ManagedUpgradePlan>;
+//# sourceMappingURL=plan.d.ts.map

package/dist/commands/upgrade/plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../../src/commands/upgrade/plan.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEzE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,aAAa,EAAE,mBAAmB,EAAE,CAAC;IACrC,sBAAsB,EAAE,MAAM,CAAC;CAChC,CAAC;AAwBF,wBAAsB,kBAAkB,CAAC,IAAI,EAAE;IAC7C,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,iBAAiB,EAAE,MAAM,CAAC;CAC3B,GAAG,OAAO,CAAC,kBAAkB,CAAC,CA6M9B"}

package/dist/commands/upgrade/plan.js

@@ -0,0 +1,219 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileExists, getPathKind } from "../../cli/fs-utils.js";
+import { exitCodeForError } from "../../cli/exit-codes.js";
+import { CliError } from "../../shared/errors.js";
+import { INCIDENTS_POLICY_PATH, isAllowedUpgradePath, isDeniedUpgradePath, mergeIncidentsPolicy, textChangedForType, toUpgradeBaselineKey, } from "./policy.js";
+async function readUpgradeBaseline(opts) {
+    try {
+        return await readFile(path.join(opts.baselineDirNew, opts.baselineKey), "utf8");
+    }
+    catch {
+        try {
+            return await readFile(path.join(opts.baselineDirLegacy, opts.baselineKey), "utf8");
+        }
+        catch {
+            return null;
+        }
+    }
+}
+async function resolvePolicyGatewayRel(gitRoot) {
+    if (await fileExists(path.join(gitRoot, "AGENTS.md")))
+        return "AGENTS.md";
+    if (await fileExists(path.join(gitRoot, "CLAUDE.md")))
+        return "CLAUDE.md";
+    return "AGENTS.md";
+}
+export async function planManagedUpgrade(opts) {
+    const additions = [];
+    const updates = [];
+    const skipped = [];
+    const merged = [];
+    const fileContents = new Map();
+    const missingRequired = [];
+    const reviewRecords = [];
+    let incidentsAppendedCount = 0;
+    const policyGatewayRel = await resolvePolicyGatewayRel(opts.gitRoot);
+    const remapManagedGatewayRel = (rel) => {
+        if (rel === "AGENTS.md" && policyGatewayRel === "CLAUDE.md")
+            return "CLAUDE.md";
+        return rel;
+    };
+    for (const entry of opts.manifest.files) {
+        const relRaw = entry.path.replaceAll("\\", "/").trim();
+        if (!relRaw || relRaw.startsWith("..") || path.isAbsolute(relRaw)) {
+            throw new CliError({
+                exitCode: 3,
+                code: "E_VALIDATION",
+                message: `Invalid manifest path: ${entry.path}`,
+            });
+        }
+        if (isDeniedUpgradePath(relRaw)) {
+            throw new CliError({
+                exitCode: 3,
+                code: "E_VALIDATION",
+                message: `Manifest includes a denied path: ${relRaw}`,
+            });
+        }
+        if (!isAllowedUpgradePath(relRaw)) {
+            throw new CliError({
+                exitCode: 3,
+                code: "E_VALIDATION",
+                message: `Manifest path not allowed: ${relRaw}`,
+            });
+        }
+        const rel = remapManagedGatewayRel(relRaw);
+        const destPath = path.join(opts.gitRoot, rel);
+        const kind = await getPathKind(destPath);
+        if (kind === "dir") {
+            throw new CliError({
+                exitCode: exitCodeForError("E_IO"),
+                code: "E_IO",
+                message: `Upgrade target is a directory: ${rel}`,
+            });
+        }
+        const sourceRelRaw = (entry.source_path ?? entry.path).replaceAll("\\", "/").trim();
+        const mappedSourceRel = rel === "CLAUDE.md" && sourceRelRaw === "AGENTS.md" ? "CLAUDE.md" : sourceRelRaw;
+        const sourceCandidates = [...new Set([mappedSourceRel, sourceRelRaw])];
+        let incomingData = null;
+        for (const candidate of sourceCandidates) {
+            try {
+                incomingData = await readFile(path.join(opts.bundleRoot, candidate));
+                break;
+            }
+            catch {
+                // try next candidate
+            }
+        }
+        if (!incomingData) {
+            if (entry.required)
+                missingRequired.push(rel);
+            continue;
+        }
+        let existingBuf = null;
+        if (kind !== null) {
+            existingBuf = await readFile(destPath);
+        }
+        const incomingTextOriginal = incomingData.toString("utf8");
+        const currentTextForReview = existingBuf ? existingBuf.toString("utf8") : null;
+        const baselineKey = toUpgradeBaselineKey(rel);
+        const baselineText = baselineKey
+            ? await readUpgradeBaseline({
+                baselineDirNew: opts.baselineDirNew,
+                baselineDirLegacy: opts.baselineDirLegacy,
+                baselineKey,
+            })
+            : null;
+        const hasBaseline = baselineText !== null;
+        const changedCurrentVsBaseline = hasBaseline && currentTextForReview !== null
+            ? textChangedForType({
+                type: entry.type,
+                aText: currentTextForReview,
+                bText: baselineText,
+            })
+            : null;
+        const changedIncomingVsBaseline = hasBaseline
+            ? textChangedForType({
+                type: entry.type,
+                aText: incomingTextOriginal,
+                bText: baselineText,
+            })
+            : null;
+        const currentAndIncomingEqual = currentTextForReview === null
+            ? false
+            : textChangedForType({
+                type: entry.type,
+                aText: currentTextForReview,
+                bText: incomingTextOriginal,
+            }) === false;
+        if (currentTextForReview !== null && currentAndIncomingEqual) {
+            skipped.push(rel);
+            reviewRecords.push({
+                relPath: rel,
+                mergeStrategy: entry.merge_strategy,
+                hasBaseline,
+                changedCurrentVsBaseline,
+                changedIncomingVsBaseline,
+                currentDiffersFromIncoming: false,
+                needsSemanticReview: false,
+                mergeApplied: false,
+                mergePath: "none",
+            });
+            continue;
+        }
+        if (currentTextForReview !== null && changedCurrentVsBaseline === false) {
+            updates.push(rel);
+            fileContents.set(rel, incomingData);
+            reviewRecords.push({
+                relPath: rel,
+                mergeStrategy: entry.merge_strategy,
+                hasBaseline,
+                changedCurrentVsBaseline,
+                changedIncomingVsBaseline,
+                currentDiffersFromIncoming: true,
+                needsSemanticReview: false,
+                mergeApplied: false,
+                mergePath: "none",
+            });
+            continue;
+        }
+        let mergeApplied = false;
+        let mergePath = "none";
+        let nextData = incomingData;
+        if (existingBuf && rel === INCIDENTS_POLICY_PATH) {
+            const mergedIncidents = mergeIncidentsPolicy({
+                incomingText: incomingData.toString("utf8"),
+                currentText: existingBuf.toString("utf8"),
+                baselineText,
+            });
+            nextData = Buffer.from(mergedIncidents.nextText, "utf8");
+            if (mergedIncidents.appended) {
+                merged.push(rel);
+                mergeApplied = true;
+                mergePath = "incidentsAppend";
+                incidentsAppendedCount += mergedIncidents.appendedCount;
+            }
+        }
+        const currentDiffersFromIncoming = currentTextForReview === null
+            ? false
+            : textChangedForType({
+                type: entry.type,
+                aText: currentTextForReview,
+                bText: incomingTextOriginal,
+            });
+        reviewRecords.push({
+            relPath: rel,
+            mergeStrategy: entry.merge_strategy,
+            hasBaseline,
+            changedCurrentVsBaseline,
+            changedIncomingVsBaseline,
+            currentDiffersFromIncoming,
+            needsSemanticReview: false,
+            mergeApplied,
+            mergePath,
+        });
+        fileContents.set(rel, nextData);
+        if (kind === null)
+            additions.push(rel);
+        else if (existingBuf && Buffer.compare(existingBuf, nextData) === 0)
+            skipped.push(rel);
+        else
+            updates.push(rel);
+    }
+    if (missingRequired.length > 0) {
+        throw new CliError({
+            exitCode: 3,
+            code: "E_VALIDATION",
+            message: `Upgrade bundle is missing required managed files: ${missingRequired.join(", ")}`,
+        });
+    }
+    return {
+        additions,
+        updates,
+        skipped,
+        merged,
+        fileContents,
+        reviewRecords,
+        incidentsAppendedCount,
+    };
+}

package/dist/commands/upgrade/policy.d.ts

@@ -0,0 +1,24 @@
+import type { FrameworkManifestEntry } from "./types.js";
+export declare const INCIDENTS_POLICY_PATH = ".agentplane/policy/incidents.md";
+export declare const INCIDENTS_APPEND_MARKER = "<!-- AGENTPLANE:UPGRADE-APPEND incidents.md -->";
+export declare const CONFIG_REL_PATH = ".agentplane/config.json";
+export declare function isDeniedUpgradePath(relPath: string): boolean;
+export declare function isAllowedUpgradePath(relPath: string): boolean;
+export declare function textChangedForType(opts: {
+    type: FrameworkManifestEntry["type"];
+    aText: string | null;
+    bText: string | null;
+}): boolean;
+export declare function mergeIncidentsPolicy(opts: {
+    incomingText: string;
+    currentText: string;
+    baselineText: string | null;
+}): {
+    nextText: string;
+    appended: boolean;
+    appendedCount: number;
+};
+export declare function normalizeUpgradeVersionLabel(input: string): string;
+export declare function normalizeVersionForConfig(input: string): string | null;
+export declare function toUpgradeBaselineKey(rel: string): string | null;
+//# sourceMappingURL=policy.d.ts.map

package/dist/commands/upgrade/policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.d.ts","sourceRoot":"","sources":["../../../src/commands/upgrade/policy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAEzD,eAAO,MAAM,qBAAqB,oCAAoC,CAAC;AACvE,eAAO,MAAM,uBAAuB,oDAAoD,CAAC;AACzF,eAAO,MAAM,eAAe,4BAA4B,CAAC;AAEzD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAU5D;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAc7D;AAwBD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACvC,IAAI,EAAE,sBAAsB,CAAC,MAAM,CAAC,CAAC;IACrC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB,GAAG,OAAO,CAaV;AAqDD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE;IACzC,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B,GAAG;IACF,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;CACvB,CAiDA;AAED,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAKlE;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGtE;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAK/D"}