forgedock 1.0.9 → 1.0.11

package/bin/init-detect.mjs

@@ -186,7 +186,7 @@ function detectDefaultBranch(cwd) {
       );
     }
   } catch {
-    // git not available or detached HEAD
+    // git unavailable or not a git repo
   }
 
   // Strategy 3: fall back

package/bin/init-enrich-api.mjs

@@ -107,8 +107,26 @@ export function parseEnrichedDraft(output, draft) {
         // Found the closing brace of the top-level object — parse the candidate.
         try {
           const enriched = JSON.parse(output.slice(start, i + 1));
-          // Basic sanity check: must have the required top-level sections.
-          if (!enriched.project || !enriched.paths || !enriched.branches) {
+          // Basic sanity check: must have the required top-level sections and
+          // each section must be a plain non-null object. The typeof+null guard
+          // rejects null and primitives; Array.isArray() additionally rejects
+          // arrays since typeof [] === 'object' would otherwise pass them.
+          const isPlainObject = (v) =>
+            typeof v === "object" && v !== null && !Array.isArray(v);
+          if (
+            !isPlainObject(enriched.project) ||
+            !isPlainObject(enriched.paths) ||
+            !isPlainObject(enriched.branches) ||
+            !isPlainObject(enriched.meta)
+          ) {
+            if (process.env.FORGEDOCK_DEBUG) {
+              const failing = ["project", "paths", "branches", "meta"]
+                .filter((k) => !isPlainObject(enriched[k]))
+                .join(", ");
+              console.error(
+                `  ${dim("[debug]")} api enrichment: parseEnrichedDraft rejected LLM output — missing/invalid sections: ${failing}. Falling back to baseline draft.`,
+              );
+            }
             return draft;
           }
           return enriched;

package/bin/tui.mjs

@@ -106,9 +106,6 @@ export function box(content, { title = "", padding = 1, width } = {}) {
   const lines = Array.isArray(content) ? content : String(content).split("\n");
   const pad = " ".repeat(padding);
 
-  // Strip ANSI codes to compute visual width
-  const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*[A-Za-z]/g, "");
-
   const contentWidth = lines.reduce(
     (max, l) => Math.max(max, stripAnsi(l).length),
     0,
@@ -659,8 +656,6 @@ export function table(
 ) {
   if (!rows || rows.length === 0) return "";
 
-  const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*[A-Za-z]/g, "");
-
   // Compute column widths
   const colCount = Math.max(...rows.map((r) => r.length));
   const widths = Array.from({ length: colCount }, (_, c) =>
@@ -701,6 +696,66 @@ export function table(
   return lines.join("\n") + "\n";
 }
 
+// ---------------------------------------------------------------------------
+// ANSI string utilities (exported for testing)
+// ---------------------------------------------------------------------------
+
+/** Strip all ANSI CSI sequences from a string, returning only visible text. */
+export function stripAnsi(s) {
+  return s.replace(/\x1b\[[0-9;]*[A-Za-z]/g, "");
+}
+
+/**
+ * Truncate an ANSI-decorated string to at most `maxWidth` visible characters,
+ * never bisecting an escape sequence.
+ *
+ * Tokens from the cut region are suppressed — only ANSI tokens encountered
+ * while the visible budget is still live are forwarded to the output.
+ * A trailing reset (\x1b[0m) is appended when truncation occurs and the
+ * result already contains ANSI sequences, preventing color bleed into
+ * adjacent columns.
+ */
+export function truncateVisible(str, maxWidth) {
+  const ansiRe = /\x1b\[[0-9;]*[A-Za-z]/g;
+  let visible = 0;
+  let result = "";
+  let lastIndex = 0;
+  let m;
+  ansiRe.lastIndex = 0;
+  while ((m = ansiRe.exec(str)) !== null) {
+    // Consume plain-text chars before this ANSI token
+    const plain = str.slice(lastIndex, m.index);
+    const remaining = maxWidth - visible;
+    if (remaining > 0) {
+      result += plain.slice(0, remaining);
+      visible += Math.min(plain.length, remaining);
+    }
+    // Only include the ANSI token while the visible budget is not yet exhausted.
+    // Once the cut point is reached, tokens from the removed region are suppressed;
+    // the post-loop reset guard below handles color-state cleanup.
+    if (visible < maxWidth) {
+      result += m[0];
+    }
+    lastIndex = ansiRe.lastIndex;
+  }
+  // Remaining plain text after last ANSI token
+  const remaining = maxWidth - visible;
+  if (remaining > 0) {
+    result += str.slice(lastIndex, lastIndex + remaining);
+  }
+  // If truncation occurred (or visible length exactly equals maxWidth) and the
+  // result contains any ANSI sequences, append a full reset to prevent color from
+  // bleeding into adjacent columns.  The guard uses >= rather than > to cover the
+  // exact-boundary case: when visible === maxWidth the loop guard (visible < maxWidth)
+  // suppresses the original trailing RESET token, so the post-loop guard must fire
+  // to close any open sequences.  Inputs shorter than maxWidth are unaffected because
+  // stripAnsi(str).length < maxWidth makes the condition false.
+  if (stripAnsi(str).length >= maxWidth && result.includes("\x1b[")) {
+    result += "\x1b[0m";
+  }
+  return result;
+}
+
 // ---------------------------------------------------------------------------
 // Annotated Review Screen
 // ---------------------------------------------------------------------------
@@ -821,50 +876,12 @@ export async function annotatedReviewScreen(
     };
   }
 
-  const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*[A-Za-z]/g, "");
-
   // Pad an ANSI-decorated string to `width` visible characters.
   function padVisible(str, width) {
     const visual = stripAnsi(str).length;
     return str + " ".repeat(Math.max(0, width - visual));
   }
 
-  // Truncate an ANSI-decorated string to at most `maxWidth` visible characters,
-  // never bisecting an escape sequence.
-  function truncateVisible(str, maxWidth) {
-    const ansiRe = /\x1b\[[0-9;]*[A-Za-z]/g;
-    let visible = 0;
-    let result = "";
-    let lastIndex = 0;
-    let m;
-    ansiRe.lastIndex = 0;
-    while ((m = ansiRe.exec(str)) !== null) {
-      // Consume plain-text chars before this ANSI token
-      const plain = str.slice(lastIndex, m.index);
-      const remaining = maxWidth - visible;
-      if (remaining > 0) {
-        result += plain.slice(0, remaining);
-        visible += Math.min(plain.length, remaining);
-      }
-      // Always include the ANSI token (zero visible width)
-      result += m[0];
-      lastIndex = ansiRe.lastIndex;
-    }
-    // Remaining plain text after last ANSI token
-    const remaining = maxWidth - visible;
-    if (remaining > 0) {
-      result += str.slice(lastIndex, lastIndex + remaining);
-    }
-    // If truncation occurred and the result contains any ANSI sequences,
-    // append a full reset to prevent color from bleeding into adjacent columns.
-    // Truncation is detected by checking whether the original string has more
-    // visible characters than maxWidth (i.e. stripAnsi(str).length > maxWidth).
-    if (stripAnsi(str).length > maxWidth && result.includes("\x1b[")) {
-      result += "\x1b[0m";
-    }
-    return result;
-  }
-
   // ── Render the annotated table ────────────────────────────────────────────
   function renderScreen() {
     process.stdout.write("\n");