@go-to-k/cdkd 0.3.6 → 0.4.0

package/dist/index.js

@@ -432,6 +432,141 @@ var init_aws_clients = __esm({
   }
 });
 
+// src/utils/live-renderer.ts
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var FRAME_INTERVAL_MS = 80;
+var ESC = "\x1B[";
+var LiveRenderer = class {
+  constructor(stream = process.stdout) {
+    this.stream = stream;
+  }
+  tasks = /* @__PURE__ */ new Map();
+  active = false;
+  spinnerIndex = 0;
+  interval = null;
+  linesDrawn = 0;
+  cursorHidden = false;
+  exitListener = null;
+  isActive() {
+    return this.active;
+  }
+  /**
+   * Enable the live renderer. No-op if stdout is not a TTY or if
+   * `CDKD_NO_LIVE=1`. Returns true if successfully enabled.
+   */
+  start() {
+    if (this.active)
+      return true;
+    if (!this.stream.isTTY)
+      return false;
+    if (process.env["CDKD_NO_LIVE"] === "1")
+      return false;
+    this.active = true;
+    this.hideCursor();
+    if (!this.exitListener) {
+      this.exitListener = () => this.showCursor();
+      process.on("exit", this.exitListener);
+    }
+    this.interval = setInterval(() => this.draw(), FRAME_INTERVAL_MS);
+    if (typeof this.interval.unref === "function")
+      this.interval.unref();
+    return true;
+  }
+  stop() {
+    if (!this.active)
+      return;
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+    this.clear();
+    this.showCursor();
+    if (this.exitListener) {
+      process.removeListener("exit", this.exitListener);
+      this.exitListener = null;
+    }
+    this.tasks.clear();
+    this.active = false;
+  }
+  addTask(id, label) {
+    this.tasks.set(id, { label, startedAt: Date.now() });
+    if (this.active)
+      this.draw();
+  }
+  removeTask(id) {
+    if (!this.tasks.delete(id))
+      return;
+    if (this.active)
+      this.draw();
+  }
+  /**
+   * Print content above the live area. Clears the live area, runs the writer,
+   * then redraws the live area. When the renderer is inactive, the writer
+   * runs directly so callers can use this unconditionally.
+   */
+  printAbove(write) {
+    if (!this.active) {
+      write();
+      return;
+    }
+    this.clear();
+    write();
+    this.draw();
+  }
+  clear() {
+    if (this.linesDrawn === 0)
+      return;
+    this.stream.write("\r");
+    for (let i = 0; i < this.linesDrawn; i++) {
+      this.stream.write(`${ESC}1A${ESC}2K`);
+    }
+    this.linesDrawn = 0;
+  }
+  draw() {
+    if (!this.active)
+      return;
+    this.clear();
+    if (this.tasks.size === 0)
+      return;
+    const frame = SPINNER_FRAMES[this.spinnerIndex % SPINNER_FRAMES.length];
+    this.spinnerIndex++;
+    const cols = this.stream.columns ?? 80;
+    const lines = [];
+    for (const task of this.tasks.values()) {
+      const elapsed = ((Date.now() - task.startedAt) / 1e3).toFixed(1);
+      const raw = `  ${frame} ${task.label} (${elapsed}s)`;
+      lines.push(this.truncate(raw, cols));
+    }
+    this.stream.write(lines.join("\n") + "\n");
+    this.linesDrawn = lines.length;
+  }
+  truncate(s, maxLen) {
+    if (s.length <= maxLen)
+      return s;
+    if (maxLen <= 1)
+      return "\u2026";
+    return s.substring(0, maxLen - 1) + "\u2026";
+  }
+  hideCursor() {
+    if (this.cursorHidden)
+      return;
+    this.stream.write(`${ESC}?25l`);
+    this.cursorHidden = true;
+  }
+  showCursor() {
+    if (!this.cursorHidden)
+      return;
+    this.stream.write(`${ESC}?25h`);
+    this.cursorHidden = false;
+  }
+};
+var globalRenderer = null;
+function getLiveRenderer() {
+  if (!globalRenderer)
+    globalRenderer = new LiveRenderer();
+  return globalRenderer;
+}
+
 // src/utils/logger.ts
 var colors = {
   reset: "\x1B[0m",
@@ -488,22 +623,26 @@ var ConsoleLogger = class {
   }
   debug(message, ...args) {
     if (this.shouldLog("debug")) {
-      console.debug(this.formatMessage("debug", message, ...args));
+      const formatted = this.formatMessage("debug", message, ...args);
+      getLiveRenderer().printAbove(() => console.debug(formatted));
     }
   }
   info(message, ...args) {
     if (this.shouldLog("info")) {
-      console.info(this.formatMessage("info", message, ...args));
+      const formatted = this.formatMessage("info", message, ...args);
+      getLiveRenderer().printAbove(() => console.info(formatted));
     }
   }
   warn(message, ...args) {
     if (this.shouldLog("warn")) {
-      console.warn(this.formatMessage("warn", message, ...args));
+      const formatted = this.formatMessage("warn", message, ...args);
+      getLiveRenderer().printAbove(() => console.warn(formatted));
     }
   }
   error(message, ...args) {
     if (this.shouldLog("error")) {
-      console.error(this.formatMessage("error", message, ...args));
+      const formatted = this.formatMessage("error", message, ...args);
+      getLiveRenderer().printAbove(() => console.error(formatted));
     }
   }
   /**
@@ -934,6 +1073,7 @@ var AssemblyReader = class {
     }
     return {
       stackName,
+      displayName: artifact.displayName ?? stackName,
       artifactId,
       template,
       assetManifestPath,
@@ -7247,11 +7387,15 @@ var DeployEngine = class {
     this.logger.debug(`Starting deployment for stack: ${stackName}`);
     setCurrentStackName(stackName);
     await this.lockManager.acquireLockWithRetry(stackName, void 0, "deploy");
+    const renderer = getLiveRenderer();
+    renderer.start();
     this.interrupted = false;
     const sigintHandler = () => {
-      process.stderr.write(
-        "\nInterrupted \u2014 saving partial state after current operations complete...\n"
-      );
+      renderer.printAbove(() => {
+        process.stderr.write(
+          "\nInterrupted \u2014 saving partial state after current operations complete...\n"
+        );
+      });
       this.interrupted = true;
     };
     process.on("SIGINT", sigintHandler);
@@ -7366,6 +7510,7 @@ var DeployEngine = class {
         durationMs
       };
     } finally {
+      renderer.stop();
       process.removeListener("SIGINT", sigintHandler);
       try {
         await this.lockManager.releaseLock(stackName);
@@ -7794,6 +7939,10 @@ var DeployEngine = class {
   async provisionResource(logicalId, change, stateResources, stackName, template, parameterValues, conditions, counts, progress) {
     const resourceType = change.resourceType;
     const provider = this.providerRegistry.getProvider(resourceType);
+    const renderer = getLiveRenderer();
+    const needsReplacement = change.changeType === "UPDATE" && (change.propertyChanges?.some((pc) => pc.requiresReplacement) ?? false);
+    const verb = change.changeType === "CREATE" ? "Creating" : change.changeType === "DELETE" ? "Deleting" : needsReplacement ? "Replacing" : "Updating";
+    renderer.addTask(logicalId, `${verb} ${logicalId} (${resourceType})`);
     try {
       switch (change.changeType) {
         case "CREATE": {
@@ -7825,6 +7974,7 @@ var DeployEngine = class {
           if (progress)
             progress.current++;
           const createPrefix = progress ? `[${progress.current}/${progress.total}] ` : "  ";
+          renderer.removeTask(logicalId);
           this.logger.info(`${createPrefix}\u2705 ${logicalId} (${resourceType}) created`);
           break;
         }
@@ -7852,9 +8002,9 @@ var DeployEngine = class {
               counts.skipped++;
             break;
           }
-          const needsReplacement = change.propertyChanges?.some((pc) => pc.requiresReplacement);
+          const needsReplacement2 = change.propertyChanges?.some((pc) => pc.requiresReplacement);
           const dependencies = this.extractAllDependencies(template, logicalId);
-          if (needsReplacement) {
+          if (needsReplacement2) {
             const replacedProps = change.propertyChanges?.filter((pc) => pc.requiresReplacement).map((pc) => pc.path).join(", ");
             this.logger.info(
               `Replacing ${logicalId} (${resourceType}) - immutable properties changed: ${replacedProps}`
@@ -7898,6 +8048,7 @@ var DeployEngine = class {
             if (progress)
               progress.current++;
             const replacePrefix = progress ? `[${progress.current}/${progress.total}] ` : "  ";
+            renderer.removeTask(logicalId);
             this.logger.info(`${replacePrefix}\u2705 ${logicalId} (${resourceType}) replaced`);
           } else {
             this.logger.debug(`Updating ${logicalId} (${resourceType})`);
@@ -7973,6 +8124,7 @@ var DeployEngine = class {
             if (progress)
               progress.current++;
             const updatePrefix = progress ? `[${progress.current}/${progress.total}] ` : "  ";
+            renderer.removeTask(logicalId);
             this.logger.info(`${updatePrefix}\u2705 ${logicalId} (${resourceType}) updated`);
           }
           break;
@@ -8018,11 +8170,13 @@ var DeployEngine = class {
           if (progress)
             progress.current++;
           const deletePrefix = progress ? `[${progress.current}/${progress.total}] ` : "  ";
+          renderer.removeTask(logicalId);
           this.logger.info(`${deletePrefix}\u2705 ${logicalId} (${resourceType}) deleted`);
           break;
         }
       }
     } catch (error) {
+      renderer.removeTask(logicalId);
       const message = error instanceof Error ? error.message : String(error);
       this.logger.error(`Failed to ${change.changeType.toLowerCase()} ${logicalId}: ${message}`);
       throw new ProvisioningError(
@@ -8032,6 +8186,8 @@ var DeployEngine = class {
         stateResources[logicalId]?.physicalId,
         error instanceof Error ? error : void 0
       );
+    } finally {
+      renderer.removeTask(logicalId);
     }
   }
   /**