@go-to-k/cdkd 0.228.0 → 0.229.0

package/README.md

@@ -589,14 +589,17 @@ cdkd events MyStack                 # list runs, newest first
 cdkd events MyStack --run <runId>   # one run's full event stream
 cdkd events MyStack --format json   # machine-readable (AI-agent hand-off)
 cdkd events prune MyStack --all     # purge event history (reclaim S3 space)
+cdkd destroy MyStack --purge-events # destroy + purge events in one command
 ```
 
 Events are persisted as JSONL under a `deployments/` key family separate
 from `state.json` (no state schema bump), so a destroyed stack's failure
 history stays readable. Recording is best-effort and never blocks the
 run; events carry error + metadata only (never resource properties). The
-store self-bounds to the last 20 runs, and `cdkd events prune` purges old
-history on demand (`--keep N` / `--older-than <dur>` / `--all`). See
+store self-bounds to the last 20 runs, `cdkd events prune` purges old
+history on demand (`--keep N` / `--older-than <dur>` / `--all`), and
+`cdkd destroy --purge-events` deletes a stack's history right after a clean
+destroy so the bucket returns fully empty. See
 **[docs/deployment-events.md](docs/deployment-events.md)** for the full
 reference.
 

package/dist/cli.js

@@ -1556,7 +1556,7 @@ const FLUSH_INTERVAL_MS = 2e3;
 const FLUSH_EVENT_THRESHOLD = 50;
 /** Build-time cdkd version, with a dev fallback for non-built contexts. */
 function getCdkdVersion() {
-	return "0.228.0";
+	return "0.229.0";
 }
 /**
 * Generate a time-sortable unique run id, e.g.
@@ -39418,6 +39418,37 @@ function orderConsumersBeforeProducers(stackNames, consumerToProducers) {
 	return ordered;
 }
 /**
+* Issue [#885] — apply `cdkd destroy --purge-events` for one stack.
+*
+* Purges the stack's deployment-event history (the post-mortem `deployments/`
+* store cdkd keeps by default) ONLY after a clean, non-interrupted destroy, so
+* the state bucket returns fully empty. Deliberately skipped on a failed /
+* interrupted destroy — those events ARE the post-mortem the user wants on the
+* retry — and a no-op when `--purge-events` was not passed.
+*
+* MUST be called AFTER the run's `eventRecorder.finalize()` (which writes this
+* run's own events + index): purging first would just be re-created by the
+* finalize. Best-effort — a purge failure warns but never fails the
+* already-successful destroy (the resources are gone regardless). The
+* equivalent for an already-destroyed stack is `cdkd events prune <stack> --all`.
+*
+* Returns the prune result when a purge ran, or `null` when it was skipped
+* (flag off / failed / interrupted) or the purge itself errored. Extracted
+* from the destroy loop so the gating is unit-testable without the full
+* synth / AWS-client harness.
+*/
+async function purgeEventsAfterDestroy(reader, stackName, region, opts, logger) {
+	if (opts.purgeEvents !== true || opts.runResult !== "SUCCEEDED" || opts.interrupted) return null;
+	try {
+		const purge = await reader.pruneRuns(stackName, region, { all: true });
+		if (purge.deletedRunIds.length > 0 || purge.indexDeleted) logger.info(`  Purged deployment-event history for ${stackName} (${region}).`);
+		return purge;
+	} catch (purgeError) {
+		logger.warn(`  Failed to purge deployment-event history for ${stackName}: ${purgeError instanceof Error ? purgeError.message : String(purgeError)}`);
+		return null;
+	}
+}
+/**
 * Destroy command implementation
 */
 async function destroyCommand(stackArgs, options) {
@@ -39645,6 +39676,11 @@ async function destroyCommand(stackArgs, options) {
 			} finally {
 				await eventRecorder.finalize(destroyRunResult);
 			}
+			await purgeEventsAfterDestroy(new DeploymentEventsReader(stateBackend), stackName, stackTargetRegion, {
+				purgeEvents: options.purgeEvents,
+				runResult: destroyRunResult,
+				interrupted
+			}, logger);
 			if (interrupted) break;
 		}
 		if (totalErrors > 0) throw new PartialFailureError(`Destroy completed with ${totalErrors} resource error(s). State preserved — inspect 'cdkd state show <stack>' and re-run 'cdkd destroy' to retry.`);
@@ -39657,7 +39693,7 @@ async function destroyCommand(stackArgs, options) {
 * Create destroy command
 */
 function createDestroyCommand() {
-	const cmd = new Command("destroy").description("Destroy all resources in the stack").argument("[stacks...]", "Stack name(s) to destroy. Accepts physical CloudFormation names (e.g. 'MyStage-Api') or CDK display paths (e.g. 'MyStage/Api'). Supports wildcards (e.g. 'MyStage/*').").option("--all", "Destroy all stacks", false).action(withErrorHandling(destroyCommand));
+	const cmd = new Command("destroy").description("Destroy all resources in the stack").argument("[stacks...]", "Stack name(s) to destroy. Accepts physical CloudFormation names (e.g. 'MyStage-Api') or CDK display paths (e.g. 'MyStage/Api'). Supports wildcards (e.g. 'MyStage/*').").option("--all", "Destroy all stacks", false).option("--purge-events", "After a clean destroy, also delete the stack's deployment-event history (issue #808 store) so the state bucket returns fully empty. By default events survive destroy as post-mortem context. Skipped when the destroy fails or is interrupted (those events aid the retry). Equivalent for an already-destroyed stack: 'cdkd events prune <stack> --all'.", false).action(withErrorHandling(destroyCommand));
 	[
 		...commonOptions,
 		...appOptions,
@@ -54952,7 +54988,7 @@ function reorderArgs(argv) {
 async function main() {
 	installPipeCloseHandler();
 	const program = new Command();
-	program.name("cdkd").description("CDK Direct - Deploy AWS CDK apps directly via SDK/Cloud Control API").version("0.228.0");
+	program.name("cdkd").description("CDK Direct - Deploy AWS CDK apps directly via SDK/Cloud Control API").version("0.229.0");
 	program.addCommand(createBootstrapCommand());
 	program.addCommand(createSynthCommand());
 	program.addCommand(createListCommand());