@gxp-dev/tools 2.0.63 → 2.0.64

package/bin/lib/commands/add-dependency.js

@@ -5,55 +5,55 @@
  * Loads OpenAPI and AsyncAPI specs to help users configure dependencies.
  */
 
-const fs = require("fs");
-const path = require("path");
-const https = require("https");
-const http = require("http");
-const { ENVIRONMENT_URLS } = require("../constants");
-const { findProjectRoot } = require("../utils");
+const fs = require("fs")
+const path = require("path")
+const https = require("https")
+const http = require("http")
+const { ENVIRONMENT_URLS } = require("../constants")
+const { findProjectRoot } = require("../utils")
 
 /**
  * Fetch JSON from a URL with timeout
  */
 function fetchJson(url, timeoutMs = 15000) {
 	return new Promise((resolve, reject) => {
-		const client = url.startsWith("https") ? https : http;
+		const client = url.startsWith("https") ? https : http
 		const options = {
 			rejectUnauthorized: false, // Allow self-signed certs for local dev
 			timeout: timeoutMs,
-		};
+		}
 
 		const req = client
 			.get(url, options, (res) => {
 				// Check for non-200 status
 				if (res.statusCode !== 200) {
-					reject(new Error(`HTTP ${res.statusCode} from ${url}`));
-					return;
+					reject(new Error(`HTTP ${res.statusCode} from ${url}`))
+					return
 				}
 
-				let data = "";
-				res.on("data", (chunk) => (data += chunk));
+				let data = ""
+				res.on("data", (chunk) => (data += chunk))
 				res.on("end", () => {
 					try {
-						resolve(JSON.parse(data));
+						resolve(JSON.parse(data))
 					} catch (e) {
-						reject(new Error(`Failed to parse JSON from ${url}: ${e.message}`));
+						reject(new Error(`Failed to parse JSON from ${url}: ${e.message}`))
 					}
-				});
+				})
 			})
 			.on("error", reject)
 			.on("timeout", () => {
-				req.destroy();
-				reject(new Error(`Request timeout after ${timeoutMs}ms for ${url}`));
-			});
-	});
+				req.destroy()
+				reject(new Error(`Request timeout after ${timeoutMs}ms for ${url}`))
+			})
+	})
 }
 
 /**
  * Group OpenAPI paths by their tags
  */
 function groupPathsByTag(openApiSpec) {
-	const tagGroups = {};
+	const tagGroups = {}
 
 	// Initialize tag groups with info from tags array
 	if (openApiSpec.tags) {
@@ -63,14 +63,16 @@ function groupPathsByTag(openApiSpec) {
 				description: tag.description || "",
 				paths: [],
 				asyncMessages: [],
-			};
+			}
 		}
 	}
 
 	// Group paths by their tags
-	for (const [pathUrl, pathMethods] of Object.entries(openApiSpec.paths || {})) {
+	for (const [pathUrl, pathMethods] of Object.entries(
+		openApiSpec.paths || {},
+	)) {
 		for (const [method, pathInfo] of Object.entries(pathMethods)) {
-			if (typeof pathInfo !== "object" || !pathInfo.tags) continue;
+			if (typeof pathInfo !== "object" || !pathInfo.tags) continue
 
 			for (const tag of pathInfo.tags) {
 				if (!tagGroups[tag]) {
@@ -79,12 +81,12 @@ function groupPathsByTag(openApiSpec) {
 						description: "",
 						paths: [],
 						asyncMessages: [],
-					};
+					}
 				}
 
 				// Extract permission and permission_key from x-permission
-				const permission = pathInfo["x-permission"]?.permission;
-				const permissionKey = pathInfo["x-permission"]?.permission_key;
+				const permission = pathInfo["x-permission"]?.permission
+				const permissionKey = pathInfo["x-permission"]?.permission_key
 
 				tagGroups[tag].paths.push({
 					path: pathUrl,
@@ -93,29 +95,29 @@ function groupPathsByTag(openApiSpec) {
 					summary: pathInfo.summary || "",
 					permission: permission || null,
 					permissionKey: permissionKey || null,
-				});
+				})
 			}
 		}
 	}
 
-	return tagGroups;
+	return tagGroups
 }
 
 /**
  * Extract messages from AsyncAPI and map to tags
  */
 function mapAsyncMessagesToTags(asyncApiSpec, tagGroups) {
-	const messages = asyncApiSpec?.components?.messages || {};
+	const messages = asyncApiSpec?.components?.messages || {}
 
 	for (const [messageName, messageInfo] of Object.entries(messages)) {
 		// Try to find matching tag based on message name
 		// Messages often have format like "GameUpdated", "LeaderboardCreated" etc.
 		const baseName = messageName
 			.replace(/Created$|Updated$|Deleted$|Changed$|Event$/, "")
-			.toLowerCase();
+			.toLowerCase()
 
 		for (const [tagName, tagGroup] of Object.entries(tagGroups)) {
-			const tagLower = tagName.toLowerCase();
+			const tagLower = tagName.toLowerCase()
 			// Match if tag contains the base name or vice versa
 			if (
 				tagLower.includes(baseName) ||
@@ -125,12 +127,12 @@ function mapAsyncMessagesToTags(asyncApiSpec, tagGroups) {
 				tagGroup.asyncMessages.push({
 					name: messageName,
 					description: messageInfo.description || messageInfo.summary || "",
-				});
+				})
 			}
 		}
 	}
 
-	return tagGroups;
+	return tagGroups
 }
 
 /**
@@ -138,188 +140,203 @@ function mapAsyncMessagesToTags(asyncApiSpec, tagGroups) {
  */
 async function selectWithTypeAhead(question, options) {
 	return new Promise((resolve) => {
-		const stdin = process.stdin;
-		const stdout = process.stdout;
+		const stdin = process.stdin
+		const stdout = process.stdout
 
-		let selectedIndex = 0;
-		let filter = "";
-		let filteredOptions = [...options];
+		let selectedIndex = 0
+		let filter = ""
+		let filteredOptions = [...options]
 
 		const applyFilter = () => {
 			if (!filter) {
-				filteredOptions = [...options];
+				filteredOptions = [...options]
 			} else {
-				const lowerFilter = filter.toLowerCase();
+				const lowerFilter = filter.toLowerCase()
 				filteredOptions = options.filter(
 					(opt) =>
 						opt.label.toLowerCase().includes(lowerFilter) ||
-						(opt.description && opt.description.toLowerCase().includes(lowerFilter))
-				);
+						(opt.description &&
+							opt.description.toLowerCase().includes(lowerFilter)),
+				)
 			}
-			selectedIndex = Math.min(selectedIndex, Math.max(0, filteredOptions.length - 1));
-		};
+			selectedIndex = Math.min(
+				selectedIndex,
+				Math.max(0, filteredOptions.length - 1),
+			)
+		}
 
-		const maxVisible = 10;
+		const maxVisible = 10
 		// Total lines rendered: question + filter + blank + scroll-up + maxVisible + scroll-down = maxVisible + 5
-		const totalLines = maxVisible + 5;
+		const totalLines = maxVisible + 5
 
 		const render = () => {
-			stdout.write("\x1B[?25l"); // Hide cursor
+			stdout.write("\x1B[?25l") // Hide cursor
 
 			// Calculate scroll window
-			let startIdx = 0;
+			let startIdx = 0
 			if (filteredOptions.length > maxVisible) {
-				startIdx = Math.max(0, selectedIndex - Math.floor(maxVisible / 2));
-				startIdx = Math.min(startIdx, filteredOptions.length - maxVisible);
+				startIdx = Math.max(0, selectedIndex - Math.floor(maxVisible / 2))
+				startIdx = Math.min(startIdx, filteredOptions.length - maxVisible)
 			}
-			const endIdx = Math.min(startIdx + maxVisible, filteredOptions.length);
-			const visibleOptions = filteredOptions.slice(startIdx, endIdx);
+			const endIdx = Math.min(startIdx + maxVisible, filteredOptions.length)
+			const visibleOptions = filteredOptions.slice(startIdx, endIdx)
 
 			// Clear screen area
-			stdout.write(`\x1B[${totalLines}A`);
+			stdout.write(`\x1B[${totalLines}A`)
 			for (let i = 0; i < totalLines; i++) {
-				stdout.write("\x1B[2K\n");
+				stdout.write("\x1B[2K\n")
 			}
-			stdout.write(`\x1B[${totalLines}A`);
+			stdout.write(`\x1B[${totalLines}A`)
 
 			// Print question and filter
-			stdout.write(`\x1B[36m?\x1B[0m ${question}\n`);
-			stdout.write(`  Filter: ${filter}\x1B[90m (type to filter, arrows to navigate)\x1B[0m\n`);
-			stdout.write(`\n`);
+			stdout.write(`\x1B[36m?\x1B[0m ${question}\n`)
+			stdout.write(
+				`  Filter: ${filter}\x1B[90m (type to filter, arrows to navigate)\x1B[0m\n`,
+			)
+			stdout.write(`\n`)
 
 			// Print scroll indicator if needed
 			if (startIdx > 0) {
-				stdout.write(`  \x1B[90m↑ ${startIdx} more above\x1B[0m\n`);
+				stdout.write(`  \x1B[90m↑ ${startIdx} more above\x1B[0m\n`)
 			} else {
-				stdout.write(`\n`);
+				stdout.write(`\n`)
 			}
 
 			// Print visible options
 			visibleOptions.forEach((opt, i) => {
-				const actualIndex = startIdx + i;
-				const isSelected = actualIndex === selectedIndex;
-				const prefix = isSelected ? "\x1B[36m❯\x1B[0m" : " ";
-				const label = isSelected ? `\x1B[36m${opt.label}\x1B[0m` : opt.label;
+				const actualIndex = startIdx + i
+				const isSelected = actualIndex === selectedIndex
+				const prefix = isSelected ? "\x1B[36m❯\x1B[0m" : " "
+				const label = isSelected ? `\x1B[36m${opt.label}\x1B[0m` : opt.label
 
 				if (opt.description) {
-					stdout.write(`${prefix} ${label} \x1B[90m- ${opt.description}\x1B[0m\n`);
+					stdout.write(
+						`${prefix} ${label} \x1B[90m- ${opt.description}\x1B[0m\n`,
+					)
 				} else {
-					stdout.write(`${prefix} ${label}\n`);
+					stdout.write(`${prefix} ${label}\n`)
 				}
-			});
+			})
 
 			// Pad remaining lines
 			for (let i = visibleOptions.length; i < maxVisible; i++) {
-				stdout.write(`\n`);
+				stdout.write(`\n`)
 			}
 
 			// Print scroll indicator if needed
 			if (endIdx < filteredOptions.length) {
-				stdout.write(`  \x1B[90m↓ ${filteredOptions.length - endIdx} more below\x1B[0m\n`);
+				stdout.write(
+					`  \x1B[90m↓ ${filteredOptions.length - endIdx} more below\x1B[0m\n`,
+				)
 			} else {
-				stdout.write(`\n`);
+				stdout.write(`\n`)
 			}
 
-			stdout.write(`\x1B[?25h`); // Show cursor
-		};
+			stdout.write(`\x1B[?25h`) // Show cursor
+		}
 
 		const cleanup = () => {
-			stdin.setRawMode(false);
-			stdin.removeAllListeners("data");
-			stdin.pause();
+			stdin.setRawMode(false)
+			stdin.removeAllListeners("data")
+			stdin.pause()
 			// Clear UI
-			stdout.write(`\x1B[${totalLines}A`);
+			stdout.write(`\x1B[${totalLines}A`)
 			for (let i = 0; i < totalLines; i++) {
-				stdout.write("\x1B[2K\n");
+				stdout.write("\x1B[2K\n")
 			}
-			stdout.write(`\x1B[${totalLines}A`);
-		};
+			stdout.write(`\x1B[${totalLines}A`)
+		}
 
 		// Initial render with spacing (must match totalLines)
 		for (let i = 0; i < totalLines; i++) {
-			console.log("");
+			console.log("")
 		}
 
-		stdin.setRawMode(true);
-		stdin.resume();
-		stdin.setEncoding("utf8");
+		stdin.setRawMode(true)
+		stdin.resume()
+		stdin.setEncoding("utf8")
 
-		let buffer = "";
+		let buffer = ""
 		stdin.on("data", (data) => {
-			buffer += data;
+			buffer += data
 
 			while (buffer.length > 0) {
 				// Ctrl+C
 				if (buffer[0] === "\x03") {
-					cleanup();
-					process.exit(0);
+					cleanup()
+					process.exit(0)
 				}
 
 				// Enter
 				if (buffer[0] === "\r" || buffer[0] === "\n") {
-					cleanup();
-					const selected = filteredOptions[selectedIndex];
+					cleanup()
+					const selected = filteredOptions[selectedIndex]
 					if (selected) {
-						stdout.write(`\x1B[36m?\x1B[0m ${question} \x1B[36m${selected.label}\x1B[0m\n`);
-						resolve(selected.value);
+						stdout.write(
+							`\x1B[36m?\x1B[0m ${question} \x1B[36m${selected.label}\x1B[0m\n`,
+						)
+						resolve(selected.value)
 					} else {
-						resolve(null);
+						resolve(null)
 					}
-					buffer = buffer.slice(1);
-					return;
+					buffer = buffer.slice(1)
+					return
 				}
 
 				// Escape sequences
 				if (buffer.startsWith("\x1b[A") || buffer.startsWith("\x1bOA")) {
 					// Up arrow
-					selectedIndex = Math.max(0, selectedIndex - 1);
-					render();
-					buffer = buffer.slice(3);
-					continue;
+					selectedIndex = Math.max(0, selectedIndex - 1)
+					render()
+					buffer = buffer.slice(3)
+					continue
 				}
 				if (buffer.startsWith("\x1b[B") || buffer.startsWith("\x1bOB")) {
 					// Down arrow
-					selectedIndex = Math.min(filteredOptions.length - 1, selectedIndex + 1);
-					render();
-					buffer = buffer.slice(3);
-					continue;
+					selectedIndex = Math.min(
+						filteredOptions.length - 1,
+						selectedIndex + 1,
+					)
+					render()
+					buffer = buffer.slice(3)
+					continue
 				}
 				if (buffer.startsWith("\x1b[") || buffer.startsWith("\x1bO")) {
 					if (buffer.length >= 3) {
-						buffer = buffer.slice(3);
-						continue;
+						buffer = buffer.slice(3)
+						continue
 					}
-					break;
+					break
 				}
 				if (buffer.startsWith("\x1b")) {
 					if (buffer.length >= 2) {
-						buffer = buffer.slice(1);
-						continue;
+						buffer = buffer.slice(1)
+						continue
 					}
-					break;
+					break
 				}
 
 				// Backspace
 				if (buffer[0] === "\x7f" || buffer[0] === "\b") {
-					filter = filter.slice(0, -1);
-					applyFilter();
-					render();
-					buffer = buffer.slice(1);
-					continue;
+					filter = filter.slice(0, -1)
+					applyFilter()
+					render()
+					buffer = buffer.slice(1)
+					continue
 				}
 
 				// Regular character
 				if (buffer[0].charCodeAt(0) >= 32 && buffer[0].charCodeAt(0) < 127) {
-					filter += buffer[0];
-					applyFilter();
-					render();
+					filter += buffer[0]
+					applyFilter()
+					render()
 				}
-				buffer = buffer.slice(1);
+				buffer = buffer.slice(1)
 			}
-		});
+		})
 
-		render();
-	});
+		render()
+	})
 }
 
 /**
@@ -327,169 +344,175 @@ async function selectWithTypeAhead(question, options) {
  */
 async function multiSelectPrompt(question, options) {
 	return new Promise((resolve) => {
-		const stdin = process.stdin;
-		const stdout = process.stdout;
+		const stdin = process.stdin
+		const stdout = process.stdout
 
-		let selectedIndex = 0;
-		const selected = new Set();
-		const maxVisible = 10;
+		let selectedIndex = 0
+		const selected = new Set()
+		const maxVisible = 10
 		// Total lines: question + hint + selected-count + scroll-up + maxVisible + scroll-down = maxVisible + 5
-		const totalLines = maxVisible + 5;
+		const totalLines = maxVisible + 5
 
 		const render = () => {
-			stdout.write("\x1B[?25l");
+			stdout.write("\x1B[?25l")
 
 			// Calculate scroll window
-			let startIdx = 0;
+			let startIdx = 0
 			if (options.length > maxVisible) {
-				startIdx = Math.max(0, selectedIndex - Math.floor(maxVisible / 2));
-				startIdx = Math.min(startIdx, options.length - maxVisible);
+				startIdx = Math.max(0, selectedIndex - Math.floor(maxVisible / 2))
+				startIdx = Math.min(startIdx, options.length - maxVisible)
 			}
-			const endIdx = Math.min(startIdx + maxVisible, options.length);
-			const visibleOptions = options.slice(startIdx, endIdx);
+			const endIdx = Math.min(startIdx + maxVisible, options.length)
+			const visibleOptions = options.slice(startIdx, endIdx)
 
-			stdout.write(`\x1B[${totalLines}A`);
+			stdout.write(`\x1B[${totalLines}A`)
 			for (let i = 0; i < totalLines; i++) {
-				stdout.write("\x1B[2K\n");
+				stdout.write("\x1B[2K\n")
 			}
-			stdout.write(`\x1B[${totalLines}A`);
+			stdout.write(`\x1B[${totalLines}A`)
 
-			stdout.write(`\x1B[36m?\x1B[0m ${question}\n`);
-			stdout.write(`  \x1B[90m(Space to toggle, Enter to confirm, A to toggle all)\x1B[0m\n`);
-			stdout.write(`  Selected: ${selected.size} of ${options.length}\n`);
+			stdout.write(`\x1B[36m?\x1B[0m ${question}\n`)
+			stdout.write(
+				`  \x1B[90m(Space to toggle, Enter to confirm, A to toggle all)\x1B[0m\n`,
+			)
+			stdout.write(`  Selected: ${selected.size} of ${options.length}\n`)
 
 			if (startIdx > 0) {
-				stdout.write(`  \x1B[90m↑ ${startIdx} more above\x1B[0m\n`);
+				stdout.write(`  \x1B[90m↑ ${startIdx} more above\x1B[0m\n`)
 			} else {
-				stdout.write(`\n`);
+				stdout.write(`\n`)
 			}
 
 			visibleOptions.forEach((opt, i) => {
-				const actualIndex = startIdx + i;
-				const isHighlighted = actualIndex === selectedIndex;
-				const isSelected = selected.has(actualIndex);
+				const actualIndex = startIdx + i
+				const isHighlighted = actualIndex === selectedIndex
+				const isSelected = selected.has(actualIndex)
 
-				const checkbox = isSelected ? "\x1B[32m◉\x1B[0m" : "○";
-				const prefix = isHighlighted ? "\x1B[36m❯\x1B[0m" : " ";
-				const label = isHighlighted ? `\x1B[36m${opt.label}\x1B[0m` : opt.label;
+				const checkbox = isSelected ? "\x1B[32m◉\x1B[0m" : "○"
+				const prefix = isHighlighted ? "\x1B[36m❯\x1B[0m" : " "
+				const label = isHighlighted ? `\x1B[36m${opt.label}\x1B[0m` : opt.label
 
 				if (opt.description) {
-					stdout.write(`${prefix} ${checkbox} ${label} \x1B[90m- ${opt.description}\x1B[0m\n`);
+					stdout.write(
+						`${prefix} ${checkbox} ${label} \x1B[90m- ${opt.description}\x1B[0m\n`,
+					)
 				} else {
-					stdout.write(`${prefix} ${checkbox} ${label}\n`);
+					stdout.write(`${prefix} ${checkbox} ${label}\n`)
 				}
-			});
+			})
 
 			for (let i = visibleOptions.length; i < maxVisible; i++) {
-				stdout.write(`\n`);
+				stdout.write(`\n`)
 			}
 
 			if (endIdx < options.length) {
-				stdout.write(`  \x1B[90m↓ ${options.length - endIdx} more below\x1B[0m\n`);
+				stdout.write(
+					`  \x1B[90m↓ ${options.length - endIdx} more below\x1B[0m\n`,
+				)
 			} else {
-				stdout.write(`\n`);
+				stdout.write(`\n`)
 			}
 
-			stdout.write(`\x1B[?25h`);
-		};
+			stdout.write(`\x1B[?25h`)
+		}
 
 		const cleanup = () => {
-			stdin.setRawMode(false);
-			stdin.removeAllListeners("data");
-			stdin.pause();
-			stdout.write(`\x1B[${totalLines}A`);
+			stdin.setRawMode(false)
+			stdin.removeAllListeners("data")
+			stdin.pause()
+			stdout.write(`\x1B[${totalLines}A`)
 			for (let i = 0; i < totalLines; i++) {
-				stdout.write("\x1B[2K\n");
+				stdout.write("\x1B[2K\n")
 			}
-			stdout.write(`\x1B[${totalLines}A`);
-		};
+			stdout.write(`\x1B[${totalLines}A`)
+		}
 
 		for (let i = 0; i < totalLines; i++) {
-			console.log("");
+			console.log("")
 		}
 
-		stdin.setRawMode(true);
-		stdin.resume();
-		stdin.setEncoding("utf8");
+		stdin.setRawMode(true)
+		stdin.resume()
+		stdin.setEncoding("utf8")
 
-		let buffer = "";
+		let buffer = ""
 		stdin.on("data", (data) => {
-			buffer += data;
+			buffer += data
 
 			while (buffer.length > 0) {
 				if (buffer[0] === "\x03") {
-					cleanup();
-					process.exit(0);
+					cleanup()
+					process.exit(0)
 				}
 
 				if (buffer[0] === "\r" || buffer[0] === "\n") {
-					cleanup();
-					const selectedOptions = options.filter((_, i) => selected.has(i));
+					cleanup()
+					const selectedOptions = options.filter((_, i) => selected.has(i))
 					stdout.write(
-						`\x1B[36m?\x1B[0m ${question} \x1B[36m${selectedOptions.length} selected\x1B[0m\n`
-					);
-					resolve(selectedOptions.map((opt) => opt.value));
-					buffer = buffer.slice(1);
-					return;
+						`\x1B[36m?\x1B[0m ${question} \x1B[36m${selectedOptions.length} selected\x1B[0m\n`,
+					)
+					resolve(selectedOptions.map((opt) => opt.value))
+					buffer = buffer.slice(1)
+					return
 				}
 
 				if (buffer.startsWith("\x1b[A") || buffer.startsWith("\x1bOA")) {
-					selectedIndex = Math.max(0, selectedIndex - 1);
-					render();
-					buffer = buffer.slice(3);
-					continue;
+					selectedIndex = Math.max(0, selectedIndex - 1)
+					render()
+					buffer = buffer.slice(3)
+					continue
 				}
 				if (buffer.startsWith("\x1b[B") || buffer.startsWith("\x1bOB")) {
-					selectedIndex = Math.min(options.length - 1, selectedIndex + 1);
-					render();
-					buffer = buffer.slice(3);
-					continue;
+					selectedIndex = Math.min(options.length - 1, selectedIndex + 1)
+					render()
+					buffer = buffer.slice(3)
+					continue
 				}
 				if (buffer.startsWith("\x1b[") || buffer.startsWith("\x1bO")) {
 					if (buffer.length >= 3) {
-						buffer = buffer.slice(3);
-						continue;
+						buffer = buffer.slice(3)
+						continue
 					}
-					break;
+					break
 				}
 				if (buffer.startsWith("\x1b")) {
 					if (buffer.length >= 2) {
-						buffer = buffer.slice(1);
-						continue;
+						buffer = buffer.slice(1)
+						continue
 					}
-					break;
+					break
 				}
 
 				// Spacebar toggle
 				if (buffer[0] === " ") {
 					if (selected.has(selectedIndex)) {
-						selected.delete(selectedIndex);
+						selected.delete(selectedIndex)
 					} else {
-						selected.add(selectedIndex);
+						selected.add(selectedIndex)
 					}
-					render();
-					buffer = buffer.slice(1);
-					continue;
+					render()
+					buffer = buffer.slice(1)
+					continue
 				}
 
 				// 'a' or 'A' toggle all
 				if (buffer[0] === "a" || buffer[0] === "A") {
 					if (selected.size === options.length) {
-						selected.clear();
+						selected.clear()
 					} else {
-						options.forEach((_, i) => selected.add(i));
+						options.forEach((_, i) => selected.add(i))
 					}
-					render();
-					buffer = buffer.slice(1);
-					continue;
+					render()
+					buffer = buffer.slice(1)
+					continue
 				}
 
-				buffer = buffer.slice(1);
+				buffer = buffer.slice(1)
 			}
-		});
+		})
 
-		render();
-	});
+		render()
+	})
 }
 
 /**
@@ -497,129 +520,135 @@ async function multiSelectPrompt(question, options) {
  */
 async function textInput(question, defaultValue = "") {
 	return new Promise((resolve) => {
-		const stdin = process.stdin;
-		const stdout = process.stdout;
+		const stdin = process.stdin
+		const stdout = process.stdout
 
-		let value = defaultValue;
-		let cursorPos = value.length;
+		let value = defaultValue
+		let cursorPos = value.length
 
 		const render = () => {
-			stdout.write("\x1B[?25l");
-			stdout.write("\r\x1B[2K");
-			stdout.write(`\x1B[36m?\x1B[0m ${question}: ${value}`);
-			const totalLength = question.length + 4 + cursorPos;
-			stdout.write(`\r\x1B[${totalLength}C`);
-			stdout.write("\x1B[?25h");
-		};
+			stdout.write("\x1B[?25l")
+			stdout.write("\r\x1B[2K")
+			stdout.write(`\x1B[36m?\x1B[0m ${question}: ${value}`)
+			const totalLength = question.length + 4 + cursorPos
+			stdout.write(`\r\x1B[${totalLength}C`)
+			stdout.write("\x1B[?25h")
+		}
 
 		const cleanup = () => {
-			stdin.setRawMode(false);
-			stdin.removeAllListeners("data");
-			stdin.pause();
-		};
+			stdin.setRawMode(false)
+			stdin.removeAllListeners("data")
+			stdin.pause()
+		}
 
-		console.log("");
-		render();
+		console.log("")
+		render()
 
-		stdin.setRawMode(true);
-		stdin.resume();
-		stdin.setEncoding("utf8");
+		stdin.setRawMode(true)
+		stdin.resume()
+		stdin.setEncoding("utf8")
 
 		stdin.on("data", (key) => {
 			if (key === "\x03") {
-				cleanup();
-				process.exit(0);
+				cleanup()
+				process.exit(0)
 			}
 
 			if (key === "\r" || key === "\n") {
-				cleanup();
-				stdout.write("\r\x1B[2K");
-				stdout.write(`\x1B[36m?\x1B[0m ${question}: \x1B[36m${value}\x1B[0m\n`);
-				resolve(value);
-				return;
+				cleanup()
+				stdout.write("\r\x1B[2K")
+				stdout.write(`\x1B[36m?\x1B[0m ${question}: \x1B[36m${value}\x1B[0m\n`)
+				resolve(value)
+				return
 			}
 
 			if (key === "\x7f" || key === "\b") {
 				if (cursorPos > 0) {
-					value = value.slice(0, cursorPos - 1) + value.slice(cursorPos);
-					cursorPos--;
+					value = value.slice(0, cursorPos - 1) + value.slice(cursorPos)
+					cursorPos--
 				}
-				render();
-				return;
+				render()
+				return
 			}
 
 			if (key === "\x1b[D") {
-				cursorPos = Math.max(0, cursorPos - 1);
-				render();
-				return;
+				cursorPos = Math.max(0, cursorPos - 1)
+				render()
+				return
 			}
 
 			if (key === "\x1b[C") {
-				cursorPos = Math.min(value.length, cursorPos + 1);
-				render();
-				return;
+				cursorPos = Math.min(value.length, cursorPos + 1)
+				render()
+				return
 			}
 
-			if (key.length === 1 && key.charCodeAt(0) >= 32 && key.charCodeAt(0) < 127) {
-				value = value.slice(0, cursorPos) + key + value.slice(cursorPos);
-				cursorPos++;
-				render();
+			if (
+				key.length === 1 &&
+				key.charCodeAt(0) >= 32 &&
+				key.charCodeAt(0) < 127
+			) {
+				value = value.slice(0, cursorPos) + key + value.slice(cursorPos)
+				cursorPos++
+				render()
 			}
-		});
-	});
+		})
+	})
 }
 
 /**
  * Main command handler
  */
 async function addDependencyCommand(argv) {
-	const environment = argv.env || "staging";
+	const environment = argv.env || "staging"
 
-	console.log("");
-	console.log("\x1B[36m╔════════════════════════════════════════════╗\x1B[0m");
-	console.log("\x1B[36m║       Add API Dependency Wizard            ║\x1B[0m");
-	console.log("\x1B[36m╚════════════════════════════════════════════╝\x1B[0m");
-	console.log("");
+	console.log("")
+	console.log("\x1B[36m╔════════════════════════════════════════════╗\x1B[0m")
+	console.log("\x1B[36m║       Add API Dependency Wizard            ║\x1B[0m")
+	console.log("\x1B[36m╚════════════════════════════════════════════╝\x1B[0m")
+	console.log("")
 
 	// Get environment URLs
-	const envUrls = ENVIRONMENT_URLS[environment];
+	const envUrls = ENVIRONMENT_URLS[environment]
 	if (!envUrls) {
-		console.error(`\x1B[31m✗ Unknown environment: ${environment}\x1B[0m`);
-		console.log(`  Available: ${Object.keys(ENVIRONMENT_URLS).join(", ")}`);
-		process.exit(1);
+		console.error(`\x1B[31m✗ Unknown environment: ${environment}\x1B[0m`)
+		console.log(`  Available: ${Object.keys(ENVIRONMENT_URLS).join(", ")}`)
+		process.exit(1)
 	}
 
-	console.log(`\x1B[90mEnvironment: ${environment}\x1B[0m`);
-	console.log(`\x1B[90mLoading API specifications...\x1B[0m`);
+	console.log(`\x1B[90mEnvironment: ${environment}\x1B[0m`)
+	console.log(`\x1B[90mLoading API specifications...\x1B[0m`)
 
 	// Fetch specs
-	let openApiSpec, asyncApiSpec;
+	let openApiSpec, asyncApiSpec
 	try {
-		[openApiSpec, asyncApiSpec] = await Promise.all([
+		;[openApiSpec, asyncApiSpec] = await Promise.all([
 			fetchJson(envUrls.openApiSpec),
-			fetchJson(envUrls.asyncApiSpec).catch(() => ({ components: { messages: {} } })),
-		]);
+			fetchJson(envUrls.asyncApiSpec).catch(() => ({
+				components: { messages: {} },
+			})),
+		])
 	} catch (error) {
-		console.error(`\x1B[31m✗ Failed to load API specs: ${error.message}\x1B[0m`);
-		process.exit(1);
+		console.error(`\x1B[31m✗ Failed to load API specs: ${error.message}\x1B[0m`)
+		process.exit(1)
 	}
 
-	console.log(`\x1B[32m✓ Loaded OpenAPI spec\x1B[0m`);
-	console.log(`\x1B[32m✓ Loaded AsyncAPI spec\x1B[0m`);
-	console.log("");
+	console.log(`\x1B[32m✓ Loaded OpenAPI spec\x1B[0m`)
+	console.log(`\x1B[32m✓ Loaded AsyncAPI spec\x1B[0m`)
+	console.log("")
 
 	// Group paths by tags and map async messages
-	let tagGroups = groupPathsByTag(openApiSpec);
-	tagGroups = mapAsyncMessagesToTags(asyncApiSpec, tagGroups);
+	let tagGroups = groupPathsByTag(openApiSpec)
+	tagGroups = mapAsyncMessagesToTags(asyncApiSpec, tagGroups)
 
 	// Filter out empty tags
 	const tags = Object.values(tagGroups)
 		.filter((t) => t.paths.length > 0)
-		.sort((a, b) => a.name.localeCompare(b.name));
+		.sort((a, b) => a.name.localeCompare(b.name))
 
 	if (tags.length === 0) {
-		console.error("\x1B[31m✗ No API tags found in spec\x1B[0m");
-		process.exit(1);
+		console.error("\x1B[31m✗ No API tags found in spec\x1B[0m")
+		process.exit(1)
 	}
 
 	// Step 1: Select a tag
@@ -627,88 +656,98 @@ async function addDependencyCommand(argv) {
 		label: t.name,
 		description: `${t.paths.length} endpoints${t.asyncMessages.length > 0 ? `, ${t.asyncMessages.length} events` : ""}`,
 		value: t,
-	}));
+	}))
 
-	const selectedTag = await selectWithTypeAhead("Select an API model (tag):", tagOptions);
+	const selectedTag = await selectWithTypeAhead(
+		"Select an API model (tag):",
+		tagOptions,
+	)
 
 	if (!selectedTag) {
-		console.log("Cancelled.");
-		process.exit(0);
+		console.log("Cancelled.")
+		process.exit(0)
 	}
 
-	console.log("");
+	console.log("")
 
 	// Step 2: Select paths
 	const pathOptions = selectedTag.paths.map((p) => ({
 		label: `${p.method} ${p.path}`,
 		description: p.summary,
 		value: p,
-	}));
+	}))
 
 	const selectedPaths = await multiSelectPrompt(
 		`Select API endpoints for ${selectedTag.name}:`,
-		pathOptions
-	);
+		pathOptions,
+	)
 
 	if (selectedPaths.length === 0) {
-		console.log("\x1B[33m⚠ No endpoints selected. Using all endpoints.\x1B[0m");
-		selectedPaths.push(...selectedTag.paths);
+		console.log("\x1B[33m⚠ No endpoints selected. Using all endpoints.\x1B[0m")
+		selectedPaths.push(...selectedTag.paths)
 	}
 
-	console.log("");
+	console.log("")
 
 	// Step 3: Select async messages (if any)
-	let selectedMessages = [];
+	let selectedMessages = []
 	if (selectedTag.asyncMessages.length > 0) {
 		const messageOptions = selectedTag.asyncMessages.map((m) => ({
 			label: m.name,
 			description: m.description,
 			value: m,
-		}));
+		}))
 
 		selectedMessages = await multiSelectPrompt(
 			`Select socket events for ${selectedTag.name}:`,
-			messageOptions
-		);
-		console.log("");
+			messageOptions,
+		)
+		console.log("")
 	}
 
 	// Step 4: Enter identifier
 	const defaultIdentifier = selectedTag.name
 		.toLowerCase()
 		.replace(/[^a-z0-9]+/g, "_")
-		.replace(/^_|_$/g, "");
+		.replace(/^_|_$/g, "")
 
-	const identifier = await textInput("Enter dependency identifier:", defaultIdentifier);
+	const identifier = await textInput(
+		"Enter dependency identifier:",
+		defaultIdentifier,
+	)
 
 	// Collect all permissions from selected paths
-	const allPermissions = new Set();
-	let permissionKey = null;
+	const allPermissions = new Set()
+	let permissionKey = null
 	for (const pathInfo of selectedPaths) {
 		if (pathInfo.permission) {
-			allPermissions.add(pathInfo.permission);
+			allPermissions.add(pathInfo.permission)
 		}
 		// Get permission_key from first path that has it (should be same for all)
 		if (!permissionKey && pathInfo.permissionKey) {
-			permissionKey = pathInfo.permissionKey;
+			permissionKey = pathInfo.permissionKey
 		}
 	}
 
 	// Build operations object from selected paths
-	const operations = {};
+	const operations = {}
 	for (const pathInfo of selectedPaths) {
 		if (pathInfo.operationId) {
 			// Remove "portal.v1.project." prefix from operationId
-			const cleanOperationId = pathInfo.operationId.replace(/^portal\.v1\.project\./, "");
+			const cleanOperationId = pathInfo.operationId.replace(
+				/^portal\.v1\.project\./,
+				"",
+			)
 			// Prepend method to path (e.g., "get:/v1/projects/...")
-			operations[cleanOperationId] = `${pathInfo.method.toLowerCase()}:${pathInfo.path}`;
+			operations[cleanOperationId] =
+				`${pathInfo.method.toLowerCase()}:${pathInfo.path}`
 		}
 	}
 
 	// Build events object
-	const events = {};
+	const events = {}
 	for (const msg of selectedMessages) {
-		events[msg.name] = msg.name;
+		events[msg.name] = msg.name
 	}
 
 	// Build the dependency object
@@ -719,48 +758,50 @@ async function addDependencyCommand(argv) {
 		permissions: Array.from(allPermissions).sort(),
 		operations,
 		events,
-	};
+	}
 
-	console.log("");
-	console.log("\x1B[36m─────────────────────────────────────────────\x1B[0m");
-	console.log("\x1B[36mGenerated Dependency Configuration:\x1B[0m");
-	console.log("\x1B[36m─────────────────────────────────────────────\x1B[0m");
-	console.log(JSON.stringify(dependency, null, 2));
-	console.log("");
+	console.log("")
+	console.log("\x1B[36m─────────────────────────────────────────────\x1B[0m")
+	console.log("\x1B[36mGenerated Dependency Configuration:\x1B[0m")
+	console.log("\x1B[36m─────────────────────────────────────────────\x1B[0m")
+	console.log(JSON.stringify(dependency, null, 2))
+	console.log("")
 
 	// Find and update app-manifest.json
-	const projectPath = findProjectRoot();
-	const manifestPath = path.join(projectPath, "app-manifest.json");
+	const projectPath = findProjectRoot()
+	const manifestPath = path.join(projectPath, "app-manifest.json")
 
 	if (!fs.existsSync(manifestPath)) {
-		console.log("\x1B[33m⚠ app-manifest.json not found. Creating new file.\x1B[0m");
-		const manifest = { dependencies: [dependency] };
-		fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
-		console.log(`\x1B[32m✓ Created app-manifest.json with dependency\x1B[0m`);
+		console.log(
+			"\x1B[33m⚠ app-manifest.json not found. Creating new file.\x1B[0m",
+		)
+		const manifest = { dependencies: [dependency] }
+		fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2))
+		console.log(`\x1B[32m✓ Created app-manifest.json with dependency\x1B[0m`)
 	} else {
-		const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
-		manifest.dependencies = manifest.dependencies || [];
+		const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"))
+		manifest.dependencies = manifest.dependencies || []
 
 		// Check for existing dependency with same identifier
 		const existingIndex = manifest.dependencies.findIndex(
-			(d) => d.identifier === identifier
-		);
+			(d) => d.identifier === identifier,
+		)
 
 		if (existingIndex >= 0) {
-			manifest.dependencies[existingIndex] = dependency;
-			console.log(`\x1B[32m✓ Updated existing dependency: ${identifier}\x1B[0m`);
+			manifest.dependencies[existingIndex] = dependency
+			console.log(`\x1B[32m✓ Updated existing dependency: ${identifier}\x1B[0m`)
 		} else {
-			manifest.dependencies.push(dependency);
-			console.log(`\x1B[32m✓ Added new dependency: ${identifier}\x1B[0m`);
+			manifest.dependencies.push(dependency)
+			console.log(`\x1B[32m✓ Added new dependency: ${identifier}\x1B[0m`)
 		}
 
-		fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+		fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2))
 	}
 
-	console.log(`\x1B[32m✓ Saved to ${manifestPath}\x1B[0m`);
-	console.log("");
+	console.log(`\x1B[32m✓ Saved to ${manifestPath}\x1B[0m`)
+	console.log("")
 }
 
 module.exports = {
 	addDependencyCommand,
-};
+}