@go-to-k/cdkd 0.147.2 → 0.148.0

package/README.md

@@ -306,6 +306,8 @@ cdkd state info --state-bucket my-bucket  # explicit bucket; reports Source: --s
 cdkd state list
 cdkd state ls --long          # include resource count, last-modified, lock status
 cdkd state list --json        # JSON output (alone, or combined with --long)
+cdkd state list --tree        # parent → child stack tree (nested stacks; #555 A3)
+cdkd state list --tree --json # tree as nested JSON
 
 # List resources of a single stack from state
 cdkd state resources MyStack          # aligned columns: LogicalID, Type, PhysicalID

package/dist/cli.js

@@ -34897,6 +34897,95 @@ function createStateMigrateCommand() {
 	return cmd;
 }
 
+//#endregion
+//#region src/cli/commands/state-list-tree.ts
+/**
+* Build a parent → child tree from the flat list of state records.
+*
+* Children are linked to their parent by `(parentStack, parentRegion)`
+* matching another entry's `(stackName, region)`. Children whose parent
+* isn't present in the input (orphans — parent state was hand-deleted,
+* or destroyed out-of-band) are reported at the root level so they stay
+* visible to `cdkd state list` rather than vanishing silently.
+*
+* A self-link (parent equals self) is treated as a missing parent — the
+* node lands at the root rather than building an infinite tree.
+*
+* The roots and every child list are sorted alphabetically by `stackName`,
+* then by `region` (legacy `undefined` last), so output is stable across
+* runs.
+*/
+function buildStackTree(entries) {
+	const refKey = (stackName, region) => `${stackName}\0${region ?? ""}`;
+	const byKey = /* @__PURE__ */ new Map();
+	for (const entry of entries) byKey.set(refKey(entry.stackName, entry.region), {
+		...entry,
+		children: []
+	});
+	const roots = [];
+	for (const node of byKey.values()) {
+		if (node.parentStack !== void 0) {
+			const parent = byKey.get(refKey(node.parentStack, node.parentRegion));
+			if (parent && parent !== node) {
+				parent.children.push(node);
+				continue;
+			}
+		}
+		roots.push(node);
+	}
+	const cmp = (a, b) => {
+		if (a.stackName < b.stackName) return -1;
+		if (a.stackName > b.stackName) return 1;
+		const ar = a.region ?? "￿";
+		const br = b.region ?? "￿";
+		if (ar < br) return -1;
+		if (ar > br) return 1;
+		return 0;
+	};
+	const sortRecursive = (list) => {
+		list.sort(cmp);
+		for (const node of list) sortRecursive(node.children);
+	};
+	sortRecursive(roots);
+	return roots;
+}
+/**
+* Render the tree using `tree(1)`-style box-drawing prefixes.
+*
+* Each line is built by `formatLine(node)`. The caller picks the
+* human-readable shape (e.g. `Stack (region)`); this helper only owns the
+* indentation.
+*/
+function renderStackTreeAscii(roots, formatLine) {
+	const lines = [];
+	for (const root of roots) {
+		lines.push(formatLine(root));
+		renderChildren(root.children, "", lines, formatLine);
+	}
+	return lines.join("\n");
+}
+function renderChildren(children, prefix, out, formatLine) {
+	const lastIdx = children.length - 1;
+	for (let i = 0; i < children.length; i++) {
+		const child = children[i];
+		const isLast = i === lastIdx;
+		const branch = isLast ? "└── " : "├── ";
+		const childPrefix = isLast ? "    " : "│   ";
+		out.push(`${prefix}${branch}${formatLine(child)}`);
+		renderChildren(child.children, prefix + childPrefix, out, formatLine);
+	}
+}
+function stackTreeToJson(roots) {
+	return roots.map((node) => ({
+		stackName: node.stackName,
+		region: node.region ?? null,
+		parentStack: node.parentStack ?? null,
+		parentLogicalId: node.parentLogicalId ?? null,
+		parentRegion: node.parentRegion ?? null,
+		children: stackTreeToJson(node.children)
+	}));
+}
+
 //#endregion
 //#region src/cli/commands/state.ts
 /**
@@ -35001,6 +35090,10 @@ function sortRefs(refs) {
 *   `version: 1` records (no region) appear as plain `Stack` rows.
 * - `--long`/`-l`: include resource count, last-modified time, and lock status.
 * - `--json`: emit a JSON array (alongside or instead of the long form).
+* - `--tree`: render parent → child stack tree (issue #555 A3). Loads each
+*   state record to read the v6 `parentStack` / `parentRegion` fields, then
+*   reconstructs the hierarchy. Flat default is preserved so tooling that
+*   greps the existing one-per-line shape keeps working.
 */
 async function stateListCommand(options) {
 	const logger = getLogger();
@@ -35008,6 +35101,10 @@ async function stateListCommand(options) {
 	const setup = await setupStateBackend(options);
 	try {
 		const refs = sortRefs(await setup.stateBackend.listStacks());
+		if (options.tree) {
+			await renderTreeMode(refs, setup.stateBackend, options.json);
+			return;
+		}
 		if (!options.long && !options.json) {
 			for (const ref of refs) process.stdout.write(`${formatStackRef(ref)}\n`);
 			return;
@@ -35057,10 +35154,56 @@ async function stateListCommand(options) {
 	}
 }
 /**
+* Render the parent → child stack tree for `cdkd state list --tree`.
+*
+* Loads each state record in parallel to read the v6 `parentStack` /
+* `parentLogicalId` / `parentRegion` fields, then hands the enriched flat
+* list to {@link buildStackTree}. A missing state record (NoSuchKey returns
+* `null` from getState) OR an unreadable one (transient S3 503 / throttle /
+* per-stack IAM hiccup throws) degrades to a top-level entry (no parent
+* link) — the row still appears in the tree at the root level rather than
+* vanishing, and one bad record never kills the whole view.
+*
+* `tree --json` emits the nested {@link import('./state-list-tree.js').StackTreeJson}
+* shape; plain `tree` renders `tree(1)`-style box-drawing.
+*/
+async function renderTreeMode(refs, stateBackend, asJson) {
+	const roots = buildStackTree(await Promise.all(refs.map(async (ref) => {
+		if (!ref.region) return { stackName: ref.stackName };
+		let state;
+		try {
+			state = (await stateBackend.getState(ref.stackName, ref.region))?.state;
+		} catch {
+			return {
+				stackName: ref.stackName,
+				region: ref.region
+			};
+		}
+		return {
+			stackName: ref.stackName,
+			region: ref.region,
+			...state?.parentStack !== void 0 && { parentStack: state.parentStack },
+			...state?.parentLogicalId !== void 0 && { parentLogicalId: state.parentLogicalId },
+			...state?.parentRegion !== void 0 && { parentRegion: state.parentRegion }
+		};
+	})));
+	if (asJson) {
+		process.stdout.write(`${JSON.stringify(stackTreeToJson(roots), null, 2)}\n`);
+		return;
+	}
+	if (roots.length === 0) return;
+	const rendered = renderStackTreeAscii(roots, (node) => formatStackRef({
+		stackName: node.stackName,
+		...node.region ? { region: node.region } : {}
+	}));
+	process.stdout.write(`${rendered}\n`);
+}
+/**
 * Create the `state list` subcommand.
 */
 function createStateListCommand() {
-	const cmd = new Command("list").alias("ls").description("List stacks registered in the cdkd state bucket").option("-l, --long", "Show resource count, last-modified time, and lock status", false).option("--json", "Output as JSON", false).action(withErrorHandling(stateListCommand));
+	const treeOption = new Option("--tree", "Render parent → child stack tree (loads each state record to read the v6 parent link)").default(false).conflicts("long");
+	const cmd = new Command("list").alias("ls").description("List stacks registered in the cdkd state bucket").option("-l, --long", "Show resource count, last-modified time, and lock status", false).option("--json", "Output as JSON", false).addOption(treeOption).action(withErrorHandling(stateListCommand));
 	[...commonOptions, ...stateOptions].forEach((opt) => cmd.addOption(opt));
 	cmd.addOption(deprecatedRegionOption);
 	return cmd;
@@ -56684,7 +56827,7 @@ function reorderArgs(argv) {
 */
 async function main() {
 	const program = new Command();
-	program.name("cdkd").description("CDK Direct - Deploy AWS CDK apps directly via SDK/Cloud Control API").version("0.147.2");
+	program.name("cdkd").description("CDK Direct - Deploy AWS CDK apps directly via SDK/Cloud Control API").version("0.148.0");
 	program.addCommand(createBootstrapCommand());
 	program.addCommand(createSynthCommand());
 	program.addCommand(createListCommand());