@unbrained/pm-cli 2026.7.14 → 2026.7.15

package/dist/cli/commands/history-redact.js

@@ -1,587 +1,12 @@
 /**
  * @module cli/commands/history-redact
  *
- * Implements the pm history redact command surface and its agent-facing runtime behavior.
+ * Presentation compatibility shim for the public SDK history-redaction
+ * primitive. CLI registration imports this module so extensions and existing
+ * integrations keep a stable command path while all domain logic is SDK-owned.
  */
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="c10a0e85-a013-5cdc-8120-effe2c6b25f9")}catch(e){}}();
-import fs from "node:fs/promises";
-import { pathExists, readFileIfExists, writeFileAtomic, } from "../../core/fs/fs-utils.js";
-import { createHistoryEntry } from "../../core/history/history.js";
-import { executeHistoryRewrite } from "../../core/history/history-rewrite.js";
-import { EMPTY_REPLAY_DOCUMENT, historyEntriesToRaw, replayHash, replayToItemDocument, tryApplyReplayPatch, verifyHistoryChain, } from "../../core/history/replay.js";
-import { normalizeItemId, normalizeRawItemId } from "../../core/item/id.js";
-import { canonicalDocument, serializeItemDocument, } from "../../core/item/item-format.js";
-import { resolveItemTypeRegistry } from "../../core/item/type-registry.js";
-import { EXIT_CODE } from "../../core/shared/constants.js";
-import { PmCliError } from "../../core/shared/errors.js";
-import { nowIso } from "../../core/shared/time.js";
-import { getActiveExtensionRegistrations, runActiveOnWriteHooks, } from "../../core/extensions/index.js";
-import { locateItem, readLocatedItem } from "../../core/store/item-store.js";
-import { getHistoryPath, getItemPath, getSettingsPath, resolvePmRoot, } from "../../core/store/paths.js";
-import { readSettings } from "../../core/store/settings.js";
-import { resolveAuthor } from "../../core/shared/author.js";
-import { readHistoryEntries } from "./history.js";
-function normalizeStringArrayInput(value) {
-    if (Array.isArray(value)) {
-        return value;
-    }
-    if (typeof value === "string") {
-        return [value];
-    }
-    return [];
-}
-function normalizeRegexFlags(flags) {
-    const unique = [];
-    for (const token of flags) {
-        if (!unique.includes(token)) {
-            unique.push(token);
-        }
-    }
-    if (!unique.includes("g")) {
-        unique.push("g");
-    }
-    return unique.join("");
-}
-function parseRegexRule(spec) {
-    const trimmed = spec.trim();
-    if (trimmed.length === 0) {
-        throw new PmCliError("history-redact --regex requires a non-empty pattern.", EXIT_CODE.USAGE);
-    }
-    let source = trimmed;
-    let flags = "g";
-    if (trimmed.startsWith("/") && trimmed.length > 1) {
-        /* c8 ignore start -- bare-slash regex literals are rejected earlier in argument validation. */
-        const slashIndex = trimmed.lastIndexOf("/");
-        if (slashIndex > 0) {
-            source = trimmed.slice(1, slashIndex);
-            flags = normalizeRegexFlags(trimmed.slice(slashIndex + 1));
-        }
-        /* c8 ignore stop */
-    }
-    if (source.length === 0) {
-        throw new PmCliError("history-redact --regex cannot use an empty pattern.", EXIT_CODE.USAGE);
-    }
-    try {
-        new RegExp(source, flags);
-    }
-    catch (error) {
-        /* c8 ignore start -- RegExp constructor failures are normalized in higher-level parser tests. */
-        throw new PmCliError(`Invalid --regex value "${spec}": ${error instanceof Error ? error.message : String(error)}`, EXIT_CODE.USAGE);
-        /* c8 ignore stop */
-    }
-    return {
-        kind: "regex",
-        source,
-        flags,
-        label: `/${source}/${flags}`,
-    };
-}
-function buildRedactionRules(literalInput, regexInput) {
-    const literalRules = [
-        ...new Set(normalizeStringArrayInput(literalInput).map((entry) => entry.trim())),
-    ]
-        .filter((entry) => entry.length > 0)
-        .map((entry) => ({
-        kind: "literal",
-        value: entry,
-        label: entry,
-    }));
-    const regexRules = [
-        ...new Set(normalizeStringArrayInput(regexInput).map((entry) => entry.trim())),
-    ]
-        .filter((entry) => entry.length > 0)
-        .map(parseRegexRule);
-    const rules = [...literalRules, ...regexRules];
-    if (rules.length === 0) {
-        throw new PmCliError("history-redact requires at least one matcher via --literal or --regex.", EXIT_CODE.USAGE, {
-            code: "missing_required_argument",
-            required: "Provide --literal <value> and/or --regex <pattern>.",
-            examples: [
-                'pm history-redact pm-a1b2 --literal "[redacted_path_prefix]/private"',
-                'pm history-redact pm-a1b2 --regex "/192\\\\.168\\\\.[0-9.]+/g" --replacement "[scrubbed_ip]"',
-            ],
-        });
-    }
-    return rules;
-}
-function applyLiteralRule(value, literal, replacement) {
-    if (literal.length === 0) {
-        return { value, replacements: 0 };
-    }
-    let cursor = 0;
-    let replacements = 0;
-    while (cursor <= value.length) {
-        const index = value.indexOf(literal, cursor);
-        if (index === -1) {
-            break;
-        }
-        replacements += 1;
-        cursor = index + Math.max(1, literal.length);
-    }
-    if (replacements === 0) {
-        return { value, replacements: 0 };
-    }
-    return {
-        value: value.split(literal).join(replacement),
-        replacements,
-    };
-}
-function applyRegexRule(value, rule, replacement) {
-    const regex = new RegExp(rule.source, rule.flags);
-    const matches = [...value.matchAll(regex)];
-    if (matches.length === 0) {
-        return { value, replacements: 0 };
-    }
-    return {
-        value: value.replace(regex, replacement),
-        replacements: matches.length,
-    };
-}
-function redactStringValue(value, rules, replacement) {
-    let next = value;
-    let replacements = 0;
-    for (const rule of rules) {
-        const result = rule.kind === "literal"
-            ? applyLiteralRule(next, rule.value, replacement)
-            : applyRegexRule(next, rule, replacement);
-        next = result.value;
-        replacements += result.replacements;
-    }
-    return {
-        value: next,
-        replacements,
-    };
-}
-function redactUnknownValue(value, rules, replacement) {
-    if (typeof value === "string") {
-        return redactStringValue(value, rules, replacement);
-    }
-    if (Array.isArray(value)) {
-        let replacements = 0;
-        const nextValues = value.map((entry) => {
-            const redacted = redactUnknownValue(entry, rules, replacement);
-            replacements += redacted.replacements;
-            return redacted.value;
-        });
-        return {
-            value: nextValues,
-            replacements,
-        };
-    }
-    if (typeof value === "object" && value !== null) {
-        let replacements = 0;
-        const nextRecord = {};
-        for (const [key, entry] of Object.entries(value)) {
-            const redacted = redactUnknownValue(entry, rules, replacement);
-            replacements += redacted.replacements;
-            nextRecord[key] = redacted.value;
-        }
-        return {
-            value: nextRecord,
-            replacements,
-        };
-    }
-    return {
-        value,
-        replacements: 0,
-    };
-}
-function applyHistoryPatch(current, patch, entryNumber, op) {
-    const result = tryApplyReplayPatch(current, patch);
-    /* c8 ignore start -- invalid patch replay paths are covered by replay helper tests. */
-    if (!result.ok) {
-        throw new PmCliError(`history-redact failed to apply patch at entry ${entryNumber} (op=${op}): ${result.error instanceof Error
-            ? result.error.message
-            : String(result.error)}`, EXIT_CODE.GENERIC_FAILURE);
-    }
-    /* c8 ignore stop */
-    return result.document;
-}
-function inspectHistoryIntegrity(entries) {
-    let replay = structuredClone(EMPTY_REPLAY_DOCUMENT);
-    let hashMismatchesBefore = 0;
-    let hashMismatchesAfter = 0;
-    for (let index = 0; index < entries.length; index += 1) {
-        const entry = entries[index];
-        if (replayHash(replay) !== entry.before_hash) {
-            hashMismatchesBefore += 1;
-        }
-        replay = applyHistoryPatch(replay, entry.patch, index + 1, entry.op);
-        /* c8 ignore start -- after-hash mismatch branch is exercised in dedicated history integrity tests. */
-        if (replayHash(replay) !== entry.after_hash) {
-            hashMismatchesAfter += 1;
-        }
-        /* c8 ignore stop */
-    }
-    return {
-        hashMismatchesBefore,
-        hashMismatchesAfter,
-        finalDocument: replay,
-    };
-}
-function redactHistoryEntry(entry, rules, replacement) {
-    let replacements = 0;
-    let changed = false;
-    let nextMessage = entry.message;
-    if (typeof entry.message === "string") {
-        const redactedMessage = redactStringValue(entry.message, rules, replacement);
-        nextMessage = redactedMessage.value;
-        replacements += redactedMessage.replacements;
-        if (redactedMessage.replacements > 0) {
-            changed = true;
-        }
-    }
-    const nextPatch = entry.patch.map((operation) => {
-        /* c8 ignore start -- patch operations without `value` are covered in lower-level patch adapters. */
-        if (!Object.prototype.hasOwnProperty.call(operation, "value")) {
-            return operation;
-        }
-        /* c8 ignore stop */
-        const redactedValue = redactUnknownValue(operation.value, rules, replacement);
-        replacements += redactedValue.replacements;
-        if (redactedValue.replacements > 0) {
-            changed = true;
-            return {
-                ...operation,
-                value: redactedValue.value,
-            };
-        }
-        return operation;
-    });
-    return {
-        entry: {
-            ...entry,
-            message: nextMessage,
-            patch: nextPatch,
-        },
-        replacements,
-        changed,
-    };
-}
-function rewriteHistoryEntries(entries, rules, replacement) {
-    let replay = structuredClone(EMPTY_REPLAY_DOCUMENT);
-    let entriesChanged = 0;
-    let replacements = 0;
-    const rewrittenEntries = [];
-    for (let index = 0; index < entries.length; index += 1) {
-        const redacted = redactHistoryEntry(entries[index], rules, replacement);
-        replacements += redacted.replacements;
-        if (redacted.changed) {
-            entriesChanged += 1;
-        }
-        const beforeHash = replayHash(replay);
-        replay = applyHistoryPatch(replay, redacted.entry.patch, index + 1, redacted.entry.op);
-        const afterHash = replayHash(replay);
-        rewrittenEntries.push({
-            ...redacted.entry,
-            before_hash: beforeHash,
-            after_hash: afterHash,
-        });
-    }
-    return {
-        entries: rewrittenEntries,
-        finalDocument: replay,
-        entriesChanged,
-        replacements,
-    };
-}
-function hasItemMetadata(replay) {
-    return Object.keys(replay.metadata).length > 0;
-}
-async function loadHistoryRedactCurrentItem(subject, settings) {
-    const currentItemPath = subject.located?.itemPath ?? null;
-    if (!subject.located) {
-        return { raw: null, path: currentItemPath, document: null };
-    }
-    const loaded = await readLocatedItem(subject.located, {
-        schema: settings.schema,
-    });
-    return { raw: loaded.raw, path: currentItemPath, document: loaded.document };
-}
-function resolveHistoryRedactNextItem(params) {
-    if (!hasItemMetadata(params.finalDocument)) {
-        return { raw: null, path: null, document: null };
-    }
-    const canonical = canonicalDocument(replayToItemDocument(params.finalDocument), { schema: params.settings.schema });
-    if (canonical.metadata.id !== params.subject.id) {
-        throw new PmCliError(`history-redact would change item id from ${params.subject.id} to ${canonical.metadata.id}; narrow your patterns.`, EXIT_CODE.USAGE);
-    }
-    return {
-        document: canonical,
-        path: getItemPath(params.pmRoot, canonical.metadata.type, params.subject.id, "toon", params.typeToFolder),
-        raw: serializeItemDocument(canonical, {
-            format: "toon",
-            schema: params.settings.schema,
-        }),
-    };
-}
-/* v8 ignore start -- message passthrough/plural formatting is deterministic around covered redaction outcomes */
-function buildHistoryRedactMessage(options, rewritten) {
-    if (typeof options.message === "string" &&
-        options.message.trim().length > 0) {
-        return options.message;
-    }
-    return `history-redact replaced ${rewritten.replacements} match(es) across ${rewritten.entriesChanged} entr${rewritten.entriesChanged === 1 ? "y" : "ies"}.`;
-}
-/* v8 ignore stop */
-function buildHistoryRedactEntries(params) {
-    const rewrittenEntries = [...params.rewritten.entries];
-    if (params.dryRun || !params.changed) {
-        return { rewrittenEntries, auditEntryAdded: false };
-    }
-    /* c8 ignore next -- fallback replay-to-item conversion runs only when rewritten final metadata is absent. */
-    const finalDocument = params.nextItemDocument ??
-        replayToItemDocument(params.rewritten.finalDocument);
-    rewrittenEntries.push(createHistoryEntry({
-        nowIso: nowIso(),
-        author: params.author,
-        op: "history_redact",
-        before: finalDocument,
-        after: finalDocument,
-        message: params.message,
-    }));
-    return { rewrittenEntries, auditEntryAdded: true };
-}
-async function applyHistoryRedactRewrite(params) {
-    return executeHistoryRewrite({
-        pmRoot: params.pmRoot,
-        subject: params.subject,
-        settings: params.settings,
-        typeRegistry: params.typeRegistry,
-        historyRawBeforeLock: params.historyRawBeforeLock,
-        currentItemRawBeforeLock: params.currentItem.raw,
-        operation: "history-redact",
-        author: params.author,
-        force: params.force,
-        itemDocument: params.currentItem.document,
-        applyRewrite: async ({ historyRawUnderLock }) => {
-            const affectedItemPaths = new Set();
-            if (params.currentItem.path) {
-                affectedItemPaths.add(params.currentItem.path);
-            }
-            if (params.nextItem.path) {
-                affectedItemPaths.add(params.nextItem.path);
-            }
-            const itemSnapshots = new Map();
-            if (params.currentItem.path && params.currentItem.raw !== null) {
-                itemSnapshots.set(params.currentItem.path, params.currentItem.raw);
-            }
-            try {
-                /* c8 ignore next -- item-write diff branch requires path and content divergence under lock races. */
-                if (params.nextItem.path &&
-                    params.nextItem.raw !== null &&
-                    params.nextItem.raw !== params.currentItem.raw) {
-                    await writeFileAtomic(params.nextItem.path, params.nextItem.raw);
-                }
-                if (params.currentItem.path &&
-                    (!params.nextItem.path ||
-                        params.nextItem.path !== params.currentItem.path)) {
-                    await fs.rm(params.currentItem.path, { force: true });
-                }
-                await writeFileAtomic(params.subject.historyPath, historyEntriesToRaw(params.rewrittenEntries));
-            }
-            catch (error) {
-                await rollbackHistoryRedactRewrite(params.subject.historyPath, historyRawUnderLock, affectedItemPaths, itemSnapshots);
-                throw error;
-            }
-        },
-        applyPostRewrite: async () => runHistoryRedactWriteHooks(params.subject.historyPath, [
-            params.nextItem.path,
-            params.currentItem.path,
-        ]),
-    });
-}
-async function rollbackHistoryRedactRewrite(historyPath, historyRawUnderLock, affectedItemPaths, itemSnapshots) {
-    /* c8 ignore start -- no-history-under-lock rollback path is exercised in lock-race integration tests. */
-    if (historyRawUnderLock === null) {
-        await fs.rm(historyPath, { force: true });
-    }
-    else {
-        await writeFileAtomic(historyPath, historyRawUnderLock);
-    }
-    /* c8 ignore stop */
-    for (const itemPath of affectedItemPaths) {
-        const snapshot = itemSnapshots.get(itemPath);
-        /* c8 ignore start -- missing snapshot rollback occurs only for create/delete race permutations. */
-        if (snapshot === undefined) {
-            await fs.rm(itemPath, { force: true });
-        }
-        else {
-            await writeFileAtomic(itemPath, snapshot);
-        }
-        /* c8 ignore stop */
-    }
-}
-async function runHistoryRedactWriteHooks(historyPath, itemHookPaths) {
-    const hookWarnings = [];
-    const uniqueItemHookPaths = new Set(itemHookPaths.filter((itemPath) => itemPath !== null));
-    for (const itemHookPath of uniqueItemHookPaths) {
-        hookWarnings.push(...(await runActiveOnWriteHooks({
-            path: itemHookPath,
-            scope: "project",
-            op: "history_redact",
-        })));
-    }
-    hookWarnings.push(...(await runActiveOnWriteHooks({
-        path: historyPath,
-        scope: "project",
-        op: "history_redact:history",
-    })));
-    return hookWarnings;
-}
-/** Implements resolve history subject for the public runtime surface of this module. */
-export async function resolveHistorySubject(pmRoot, id, settings, typeToFolder) {
-    const located = await locateItem(pmRoot, id, settings.id_prefix, settings.item_format, typeToFolder);
-    if (located) {
-        return {
-            id: located.id,
-            historyPath: getHistoryPath(pmRoot, located.id),
-            located,
-        };
-    }
-    const normalizedId = normalizeItemId(id, settings.id_prefix);
-    const rawNormalizedId = normalizeRawItemId(id);
-    const candidateIds = normalizedId === rawNormalizedId
-        ? [normalizedId]
-        : [normalizedId, rawNormalizedId];
-    for (const candidateId of candidateIds) {
-        const historyPath = getHistoryPath(pmRoot, candidateId);
-        if (await pathExists(historyPath)) {
-            return {
-                id: candidateId,
-                historyPath,
-                located: null,
-            };
-        }
-    }
-    throw new PmCliError(`Item ${id} not found`, EXIT_CODE.NOT_FOUND);
-}
-/** Implements run history redact for the public runtime surface of this module. */
-export async function runHistoryRedact(id, options, global) {
-    const pmRoot = resolvePmRoot(process.cwd(), global.path);
-    if (!(await pathExists(getSettingsPath(pmRoot)))) {
-        throw new PmCliError(`Tracker is not initialized at ${pmRoot}. Run pm init first.`, EXIT_CODE.NOT_FOUND);
-    }
-    const settings = await readSettings(pmRoot);
-    const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
-    const replacement = typeof options.replacement === "string" && options.replacement.length > 0
-        ? options.replacement
-        : "[redacted]";
-    const rules = buildRedactionRules(options.literal, options.regex);
-    const subject = await resolveHistorySubject(pmRoot, id, settings, typeRegistry.type_to_folder);
-    if (!(await pathExists(subject.historyPath))) {
-        throw new PmCliError(`No history stream exists for ${subject.id}.`, EXIT_CODE.NOT_FOUND);
-    }
-    const historyRawBeforeLock = await readFileIfExists(subject.historyPath);
-    const historyEntries = await readHistoryEntries(subject.historyPath, subject.id);
-    if (historyEntries.length === 0) {
-        throw new PmCliError(`No history entries exist for ${subject.id}; nothing to redact.`, EXIT_CODE.USAGE);
-    }
-    const integritySnapshot = inspectHistoryIntegrity(historyEntries);
-    const rewritten = rewriteHistoryEntries(historyEntries, rules, replacement);
-    const preexistingHashMismatches = integritySnapshot.hashMismatchesBefore +
-        integritySnapshot.hashMismatchesAfter;
-    const dryRun = Boolean(options.dryRun);
-    const changed = rewritten.replacements > 0;
-    const warnings = [];
-    if (preexistingHashMismatches > 0) {
-        warnings.push(`history_redact_preexisting_hash_mismatches:${preexistingHashMismatches}`);
-    }
-    if (!changed) {
-        warnings.push("history_redact_no_matches");
-    }
-    const currentItem = await loadHistoryRedactCurrentItem(subject, settings);
-    const nextItem = resolveHistoryRedactNextItem({
-        pmRoot,
-        subject,
-        settings,
-        typeToFolder: typeRegistry.type_to_folder,
-        finalDocument: rewritten.finalDocument,
-    });
-    const itemChanged = 
-    /* c8 ignore next -- null-coalescing item-path comparison branch is exercised in broader command integration coverage. */
-    (currentItem.path ?? null) !== (nextItem.path ?? null) ||
-        /* c8 ignore next -- null-coalescing item-content comparison branch is exercised in broader command integration coverage. */
-        (currentItem.raw ?? null) !== (nextItem.raw ?? null);
-    const author = resolveAuthor(options.author, settings.author_default);
-    const redactionMessage = buildHistoryRedactMessage(options, rewritten);
-    const { rewrittenEntries, auditEntryAdded } = buildHistoryRedactEntries({
-        rewritten,
-        dryRun,
-        changed,
-        nextItemDocument: nextItem.document,
-        author,
-        message: redactionMessage,
-    });
-    const historyVerify = verifyHistoryChain(rewrittenEntries);
-    /* c8 ignore start -- invalid rewritten chains are covered by history verification unit tests. */
-    if (!historyVerify.ok) {
-        throw new PmCliError(`history-redact produced an invalid rewritten chain (${historyVerify.errors.join(", ")}).`, EXIT_CODE.GENERIC_FAILURE);
-    }
-    /* c8 ignore stop */
-    if (!dryRun && changed) {
-        warnings.push(...(await applyHistoryRedactRewrite({
-            pmRoot,
-            subject,
-            settings,
-            typeRegistry,
-            historyRawBeforeLock,
-            currentItem,
-            nextItem,
-            author,
-            force: options.force,
-            rewrittenEntries,
-        })));
-    }
-    return {
-        id: subject.id,
-        dry_run: dryRun,
-        changed,
-        patterns: {
-            literals: rules
-                .filter((rule) => rule.kind === "literal")
-                .map((rule) => rule.value),
-            regex: rules
-                .filter((rule) => rule.kind === "regex")
-                .map((rule) => `/${rule.source}/${rule.flags}`),
-            replacement,
-        },
-        history: {
-            path: subject.historyPath,
-            entries_scanned: historyEntries.length,
-            entries_changed: rewritten.entriesChanged,
-            replacements: rewritten.replacements,
-            hash_mismatches_before: integritySnapshot.hashMismatchesBefore,
-            hash_mismatches_after: integritySnapshot.hashMismatchesAfter,
-            preexisting_hash_mismatches: preexistingHashMismatches,
-            audit_entry_added: auditEntryAdded,
-            verify_ok: historyVerify.ok,
-            verify_errors: historyVerify.errors,
-        },
-        item: {
-            existed_before: currentItem.path !== null,
-            exists_after: nextItem.path !== null,
-            path_before: currentItem.path,
-            path_after: nextItem.path,
-            changed: itemChanged,
-        },
-        /* c8 ignore next -- warning dedupe ordering is covered indirectly by command-level smoke tests. */
-        warnings: [...new Set(warnings)].sort((left, right) => left.localeCompare(right)),
-        generated_at: nowIso(),
-    };
-}
-/** Public contract for test only, shared by SDK and presentation-layer consumers. */
-export const _testOnly = {
-    applyLiteralRule,
-    applyRegexRule,
-    buildRedactionRules,
-    hasItemMetadata,
-    normalizeRegexFlags,
-    normalizeStringArrayInput,
-    parseRegexRule,
-    redactStringValue,
-    redactUnknownValue,
-};
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="9c8bd422-4982-5eb8-97c4-34a48b2c5b78")}catch(e){}}();
+export { _testOnly, resolveHistorySubject, runHistoryRedact, } from "../../sdk/history-redact.js";
 //# sourceMappingURL=history-redact.js.map
-//# debugId=c10a0e85-a013-5cdc-8120-effe2c6b25f9
+//# debugId=9c8bd422-4982-5eb8-97c4-34a48b2c5b78