aiwcli 0.13.8 → 0.15.1

package/dist/templates/_shared/skills/prompt-codex/scripts/launch-codex.ts

@@ -0,0 +1,387 @@
+#!/usr/bin/env bun
+/**
+ * Launch Codex in a tmux pane and inject a prompt into its REPL.
+ *
+ * Usage:
+ *   bun launch-codex.ts [--model fast|standard|smart|<model-id>] [--sandbox read-only|workspace-write|danger-full-access] [--no-yolo] [--capture] [--context <id>] plan
+ *   bun launch-codex.ts [--model fast|standard|smart|<model-id>] [--sandbox read-only|workspace-write|danger-full-access] [--no-yolo] [--capture] [--context <id>] --file <path>
+ *   bun launch-codex.ts [--model fast|standard|smart|<model-id>] [--sandbox read-only|workspace-write|danger-full-access] [--no-yolo] [--capture] [--context <id>] <inline text...>
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import {
+  getTmuxAvailability,
+  launchDriverInTmuxOrFallback,
+} from "../../../lib-ts/base/tmux-driver.js";
+import { getProjectRoot } from "../../../lib-ts/base/constants.js";
+import { resolveCodexModel, codexReplSpec, buildCliInvocation, isCodexSandbox, type CodexSandbox } from "../../../lib-ts/base/cli-args.js";
+import { CODEX_MODELS } from "../../../lib-ts/base/models.js";
+import { logDebug, logWarn } from "../../../lib-ts/base/logger.js";
+import { displayPath } from "../../../lib-ts/base/utils.js";
+import { getContextBySessionId, getContext } from "../../../lib-ts/context/context-store.js";
+import { buildExternalAgentContext } from "../../../lib-ts/context/context-formatter.js";
+import { findLatestPlan } from "../../../lib-ts/context/plan-manager.js";
+import type { ContextState } from "../../../lib-ts/types.js";
+
+/** Codex-specific model abbreviations. Checked before tier resolution. */
+const CODEX_ALIASES: Record<string, string> = {
+  spark: CODEX_MODELS.spark,
+  codex: CODEX_MODELS.codex,
+  gpt: CODEX_MODELS.gpt,
+};
+
+const SESSION_DISCOVERY_TIMEOUT_MS = 12000;
+const SESSION_DISCOVERY_POLL_MS = 250;
+const SESSION_MTIME_WINDOW_MS = 120000;
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function eprint(...args: unknown[]): void {
+  process.stderr.write(args.map(String).join(" ") + "\n");
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function collectSessionJsonlFiles(rootDir: string): string[] {
+  if (!fs.existsSync(rootDir)) return [];
+  const stack: string[] = [rootDir];
+  const files: string[] = [];
+
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    if (!dir) continue;
+    let entries: fs.Dirent[] = [];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+        files.push(fullPath);
+      }
+    }
+  }
+
+  return files;
+}
+
+function samePath(a: string, b: string): boolean {
+  const left = path.resolve(a);
+  const right = path.resolve(b);
+  if (process.platform === "win32") {
+    return left.toLowerCase() === right.toLowerCase();
+  }
+  return left === right;
+}
+
+function readSessionMeta(sessionFile: string): { sessionId: string; cwd: string } | null {
+  try {
+    const raw = fs.readFileSync(sessionFile, "utf-8");
+    const firstLine = raw.split(/\r?\n/).find((line) => line.trim().length > 0);
+    if (!firstLine) return null;
+    const parsed = JSON.parse(firstLine);
+    if (parsed?.type !== "session_meta") return null;
+    const sessionId = parsed?.payload?.id;
+    const cwd = parsed?.payload?.cwd;
+    if (typeof sessionId !== "string" || typeof cwd !== "string") return null;
+    return { sessionId, cwd };
+  } catch {
+    return null;
+  }
+}
+
+function findLatestSessionCandidate(
+  projectRoot: string,
+  launchStartedAtMs: number,
+): { sessionId: string; sessionFile: string } | null {
+  const sessionsRoot = path.join(os.homedir(), ".codex", "sessions");
+  const files = collectSessionJsonlFiles(sessionsRoot);
+  if (files.length === 0) return null;
+
+  const candidates: Array<{ sessionId: string; sessionFile: string; mtimeMs: number }> = [];
+  for (const sessionFile of files) {
+    let mtimeMs = 0;
+    try {
+      mtimeMs = fs.statSync(sessionFile).mtimeMs;
+    } catch {
+      continue;
+    }
+    if (mtimeMs < launchStartedAtMs - SESSION_MTIME_WINDOW_MS) continue;
+
+    const meta = readSessionMeta(sessionFile);
+    if (!meta) continue;
+    if (!samePath(meta.cwd, projectRoot)) continue;
+
+    candidates.push({ sessionId: meta.sessionId, sessionFile, mtimeMs });
+  }
+
+  if (candidates.length === 0) return null;
+  candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  const best = candidates[0];
+  return best ? { sessionId: best.sessionId, sessionFile: best.sessionFile } : null;
+}
+
+async function waitForCaptureSession(
+  projectRoot: string,
+  launchStartedAtMs: number,
+): Promise<{ sessionId: string; sessionFile: string } | null> {
+  const deadline = Date.now() + SESSION_DISCOVERY_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    const candidate = findLatestSessionCandidate(projectRoot, launchStartedAtMs);
+    if (candidate) return candidate;
+    await sleep(SESSION_DISCOVERY_POLL_MS);
+  }
+  return findLatestSessionCandidate(projectRoot, launchStartedAtMs);
+}
+
+/** Fallback plan discovery: scan all context plan dirs by mtime. */
+function findLatestPlanByMtime(projectRoot: string): string | null {
+  const contextsDir = path.join(projectRoot, "_output", "contexts");
+  if (!fs.existsSync(contextsDir)) return null;
+
+  let best: { path: string; mtime: number } | null = null;
+
+  for (const ctxEntry of fs.readdirSync(contextsDir)) {
+    if (ctxEntry.startsWith("_")) continue;
+    const plansDir = path.join(contextsDir, ctxEntry, "plans");
+    if (!fs.existsSync(plansDir)) continue;
+
+    for (const file of fs.readdirSync(plansDir)) {
+      if (!file.endsWith(".md")) continue;
+      const fullPath = path.join(plansDir, file);
+      try {
+        const mtime = fs.statSync(fullPath).mtimeMs;
+        if (!best || mtime > best.mtime) {
+          best = { path: fullPath, mtime };
+        }
+      } catch { /* skip unreadable */ }
+    }
+  }
+
+  return best?.path ?? null;
+}
+
+// ---------------------------------------------------------------------------
+// Arg parsing
+// ---------------------------------------------------------------------------
+
+const rawArgs = process.argv.slice(2);
+
+if (rawArgs.length === 0) {
+  eprint("Usage: launch-codex.ts [--model <model>] [--sandbox <mode>] [--no-yolo] [--capture] [--context <id>] plan | --file <path> | <text...>");
+  process.exit(1);
+}
+
+// Extract --model, --sandbox, and --context flags before mode dispatch
+let modelFlag: string | undefined;
+let sandboxFlag: CodexSandbox | undefined;
+let contextFlag: string | undefined;
+let yolo = true;
+let capture = false;
+const args: string[] = [];
+
+for (let i = 0; i < rawArgs.length; i++) {
+  if (rawArgs[i] === "--model" && i + 1 < rawArgs.length) {
+    modelFlag = rawArgs[++i];
+  } else if (rawArgs[i] === "--sandbox" && i + 1 < rawArgs.length) {
+    const val = rawArgs[++i];
+    if (!isCodexSandbox(val)) {
+      eprint(`Error: Invalid sandbox mode "${val}". Valid: read-only, workspace-write, danger-full-access`);
+      process.exit(1);
+    }
+    sandboxFlag = val;
+  } else if (rawArgs[i] === "--context" && i + 1 < rawArgs.length) {
+    contextFlag = rawArgs[++i];
+  } else if (rawArgs[i] === "--yolo") {
+    yolo = true;
+  } else if (rawArgs[i] === "--no-yolo") {
+    yolo = false;
+  } else if (rawArgs[i] === "--capture") {
+    capture = true;
+  } else {
+    args.push(rawArgs[i]);
+  }
+}
+
+if (args.length === 0) {
+  eprint("Usage: launch-codex.ts [--model <model>] [--sandbox <mode>] [--no-yolo] [--capture] [--context <id>] plan | --file <path> | <text...>");
+  process.exit(1);
+}
+
+// Resolve model: alias first, then tier/pass-through via shared resolver
+let resolvedModel: string | undefined;
+if (modelFlag) {
+  const lower = modelFlag.toLowerCase();
+  resolvedModel = lower in CODEX_ALIASES
+    ? CODEX_ALIASES[lower]
+    : resolveCodexModel(modelFlag);
+}
+
+let promptPath: string | null = null;
+let tempFile: string | null = null;
+
+const projectRoot = getProjectRoot(process.cwd());
+
+// Context lookup — available for all modes (orientation header + plan discovery)
+// --context flag preferred (passed by skill caller); CLAUDE_SESSION_ID as fallback (hooks only)
+let ctx: ContextState | null = null;
+if (contextFlag) {
+  ctx = getContext(contextFlag, projectRoot) ?? null;
+} else {
+  const sessionId = process.env.CLAUDE_SESSION_ID;
+  if (sessionId) {
+    ctx = getContextBySessionId(sessionId, projectRoot) ?? null;
+  }
+}
+
+if (args[0] === "plan") {
+  // Plan discovery: context system first, mtime fallback second
+  let planPath: string | null = null;
+
+  if (ctx) {
+    planPath = findLatestPlan(ctx.id, projectRoot);
+  }
+
+  if (!planPath) {
+    planPath = findLatestPlanByMtime(projectRoot);
+  }
+
+  if (!planPath) {
+    eprint("Error: No plan found. Create a plan first (use plan mode), then run this command.");
+    process.exit(1);
+  }
+
+  promptPath = planPath;
+  console.log(`Found plan: ${displayPath(planPath)}`);
+
+} else if (args[0] === "--file") {
+  if (!args[1]) {
+    eprint("Error: --file requires a path argument.");
+    process.exit(1);
+  }
+  const filePath = path.resolve(args[1]);
+  if (!fs.existsSync(filePath)) {
+    eprint(`Error: File not found: ${filePath}`);
+    process.exit(1);
+  }
+  promptPath = filePath;
+
+} else {
+  // Inline text: join args, write to temp file
+  const text = args.join(" ");
+  tempFile = path.join(os.tmpdir(), `codex-prompt-${Date.now()}.md`);
+  fs.writeFileSync(tempFile, text, "utf-8");
+  promptPath = tempFile;
+}
+
+// Prepend context orientation if available — graceful degradation on failure
+if (ctx && promptPath) {
+  try {
+    const orientation = buildExternalAgentContext(ctx, projectRoot);
+    const original = fs.readFileSync(promptPath, "utf-8");
+    const combined = `${orientation}\n\n---\n\n${original}`;
+    const contextPromptPath = path.join(os.tmpdir(), `codex-ctx-prompt-${Date.now()}.md`);
+    fs.writeFileSync(contextPromptPath, combined, "utf-8");
+    if (tempFile) {
+      try { fs.unlinkSync(tempFile); } catch { /* ignore */ }
+    }
+    promptPath = contextPromptPath;
+    tempFile = contextPromptPath;
+  } catch {
+    logWarn("codex-skill", `Context orientation prepend failed for ${ctx.id}, continuing without header`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Pre-flight: tmux required
+// ---------------------------------------------------------------------------
+
+const tmux = getTmuxAvailability();
+if (!tmux.available) {
+  eprint(`Error: tmux is required for Codex REPL mode. ${tmux.reason ?? ""}`);
+  if (tempFile) try { fs.unlinkSync(tempFile); } catch { /* ignore */ }
+  process.exit(1);
+}
+
+// ---------------------------------------------------------------------------
+// Launch Codex REPL in tmux pane
+// ---------------------------------------------------------------------------
+
+// Build args via centralized CLI builder
+const codexArgs = buildCliInvocation(codexReplSpec(resolvedModel, sandboxFlag, yolo)).args;
+if (yolo) console.log("Mode: YOLO (bypass approvals and sandbox)");
+if (sandboxFlag) console.log(`Sandbox: ${sandboxFlag}`);
+if (resolvedModel) console.log(`Model: ${resolvedModel}${modelFlag !== resolvedModel ? ` (from "${modelFlag}")` : ""}`);
+
+logDebug("codex-skill", `Launching: model=${resolvedModel ?? "default"}, sandbox=${sandboxFlag ?? "default"}, yolo=${yolo}, source=${args[0]}, bytes=${promptPath ? fs.statSync(promptPath).size : 0}`);
+const launchStartedAtMs = Date.now();
+
+const result = await launchDriverInTmuxOrFallback({
+  toolName: "codex",
+  mode: "repl",
+  args: codexArgs,
+  promptPath,
+  sendPromptInRepl: true,
+  allowExecFallback: false,
+});
+
+// Cleanup temp file after injection
+if (tempFile) {
+  try { fs.unlinkSync(tempFile); } catch { /* ignore */ }
+}
+
+if (!result.launched) {
+  logWarn("codex-skill", `Launch failed: ${result.reason}`);
+  eprint(`Error: Failed to launch Codex. ${result.reason ?? ""}`);
+  process.exit(1);
+}
+
+// Log injection diagnostics
+const diag = result.sendDiagnostics;
+if (diag) {
+  if (diag.success) {
+    logDebug("codex-skill", `Injection OK: promptWait=${diag.promptWaitMs}ms, retrySent=${diag.retrySent}`);
+  } else {
+    logWarn("codex-skill", `Injection failed at ${diag.failedAt}: wait=${diag.promptWaitMs}ms, stderr=${diag.tmuxStderr ?? "none"}, paneTail=${diag.paneTailOnTimeout ?? "none"}`);
+  }
+}
+
+if (result.paneId) {
+  console.log(`Codex launched in tmux pane: ${result.paneId}`);
+} else {
+  console.log("Codex launched in tmux pane.");
+}
+
+if (capture && result.paneId) {
+  try {
+    const sessionInfo = await waitForCaptureSession(projectRoot, launchStartedAtMs);
+    if (sessionInfo) {
+      console.log(`CODEX_CAPTURE_PANE=${result.paneId}`);
+      console.log(`CODEX_CAPTURE_SESSION_ID=${sessionInfo.sessionId}`);
+      console.log(`CODEX_CAPTURE_SESSION_FILE=${sessionInfo.sessionFile}`);
+    } else {
+      logWarn(
+        "codex-skill",
+        `Capture session discovery failed for pane ${result.paneId} in ${SESSION_DISCOVERY_TIMEOUT_MS}ms`,
+      );
+    }
+  } catch (error) {
+    logWarn("codex-skill", `Capture session discovery threw for ${result.paneId}: ${String(error)}`);
+  }
+}
+
+if (result.reason) {
+  // Partial success (e.g., launched but prompt injection failed)
+  eprint(`Warning: ${result.reason}`);
+}

package/dist/templates/_shared/skills/prompt-codex/scripts/watch-codex.ts

@@ -0,0 +1,257 @@
+#!/usr/bin/env bun
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import { inference } from "../../../lib-ts/base/inference.js";
+import { logDebug, logWarn } from "../../../lib-ts/base/logger.js";
+import { CODEX_MODELS } from "../../../lib-ts/base/models.js";
+import { execFileAsync } from "../../../lib-ts/base/subprocess-utils.js";
+import { getTmuxAvailability } from "../../../lib-ts/base/tmux-driver.js";
+
+const POLL_INTERVAL_MS = 2000;
+const POLL_TIMEOUT_MS = 3000;
+const SUMMARY_TIMEOUT_SEC = 8;
+const RESUME_TIMEOUT_MS = 45000;
+const MAX_TRANSCRIPT_LINES = 220;
+const MAX_LINE_LENGTH = 500;
+const SUMMARY_UNAVAILABLE_MESSAGE = "Codex session completed. Summary unavailable.";
+
+const TRANSCRIPT_SUMMARY_PROMPT = `Summarize this Codex session transcript excerpt.
+Return 3-5 concise bullet points.
+Focus on:
+- what was accomplished
+- files changed
+- errors or blockers
+Do not ask follow-up questions.
+Do not request additional input.
+If information is partial, provide best-effort summary from available text.`;
+
+const RESUME_SUMMARY_PROMPT = `Summarize the previous Codex session in 3-5 concise bullet points.
+Focus on:
+- what was accomplished
+- files changed
+- errors or blockers
+Do not ask follow-up questions.
+Do not request additional input.
+If the prior session was brief, still provide a best-effort summary.`;
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function safeCleanup(filePath: string): void {
+  try {
+    if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
+  } catch {
+    // Best-effort cleanup only.
+  }
+}
+
+function readTextIfExists(filePath: string): string {
+  try {
+    if (!filePath || !fs.existsSync(filePath)) return "";
+    return fs.readFileSync(filePath, "utf-8").trim();
+  } catch {
+    return "";
+  }
+}
+
+function normalizeText(text: string): string {
+  return text
+    .replace(/\r/g, "")
+    .replace(/[\x00-\x08\x0B-\x1F\x7F]/g, "")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function getMessageContentText(content: unknown): string {
+  if (!Array.isArray(content)) return "";
+  return content
+    .map((entry: any) => {
+      if (!entry || typeof entry !== "object") return "";
+      if (typeof entry.text !== "string") return "";
+      return entry.text;
+    })
+    .join("\n");
+}
+
+function collectTranscriptLines(sessionFile: string): string[] {
+  if (!sessionFile || !fs.existsSync(sessionFile)) return [];
+
+  const out: string[] = [];
+  const seen = new Set<string>();
+
+  try {
+    const raw = fs.readFileSync(sessionFile, "utf-8");
+    const lines = raw.split(/\r?\n/).filter((line) => line.trim().length > 0);
+
+    for (const line of lines) {
+      let parsed: any;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        continue;
+      }
+
+      let role = "";
+      let text = "";
+
+      if (parsed?.type === "response_item" && parsed?.payload?.type === "message") {
+        role = parsed?.payload?.role === "assistant" ? "assistant" : (parsed?.payload?.role === "user" ? "user" : "");
+        text = getMessageContentText(parsed?.payload?.content);
+      } else if (parsed?.type === "item.completed" && parsed?.item?.type === "agent_message" && typeof parsed?.item?.text === "string") {
+        role = "assistant";
+        text = parsed.item.text;
+      } else if (parsed?.type === "event_msg" && parsed?.payload?.type === "agent_message" && typeof parsed?.payload?.message === "string") {
+        role = "assistant";
+        text = parsed.payload.message;
+      }
+
+      const normalized = normalizeText(text);
+      if (!role || !normalized) continue;
+
+      const truncated = normalized.length > MAX_LINE_LENGTH ? `${normalized.slice(0, MAX_LINE_LENGTH)}...` : normalized;
+      const tagged = `${role}: ${truncated}`;
+      if (seen.has(tagged)) continue;
+
+      seen.add(tagged);
+      out.push(tagged);
+    }
+  } catch (error) {
+    logWarn("codex-capture", `Session transcript parse failed: ${String(error)}`);
+  }
+
+  return out.slice(-MAX_TRANSCRIPT_LINES);
+}
+
+function looksLikeBadSummary(output: string): boolean {
+  const normalized = output.toLowerCase();
+  return (
+    normalized.includes("don't see") ||
+    normalized.includes("no output") ||
+    normalized.includes("could you provide") ||
+    normalized.includes("paste")
+  );
+}
+
+async function waitForPaneClose(paneId: string): Promise<void> {
+  const tmux = getTmuxAvailability();
+  if (!tmux.available || !tmux.tmuxPath) {
+    logWarn("codex-capture", `tmux unavailable while watching pane ${paneId}: ${tmux.reason ?? "unknown reason"}`);
+    return;
+  }
+
+  while (true) {
+    const result = await execFileAsync(tmux.tmuxPath, ["list-panes", "-a", "-F", "#{pane_id}"], {
+      timeout: POLL_TIMEOUT_MS,
+    });
+
+    if (result.exitCode !== 0) {
+      logDebug("codex-capture", `list-panes failed; assuming pane closed (${result.stderr.trim() || "no stderr"})`);
+      return;
+    }
+
+    const activePaneIds = result.stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    if (!activePaneIds.includes(paneId)) return;
+
+    await sleep(POLL_INTERVAL_MS);
+  }
+}
+
+function summarizeViaSessionFileSpark(sessionFile: string): string | null {
+  const transcriptLines = collectTranscriptLines(sessionFile);
+  if (transcriptLines.length === 0) return null;
+
+  const transcript = transcriptLines.join("\n");
+  const result = inference(
+    TRANSCRIPT_SUMMARY_PROMPT,
+    `Session transcript excerpt:\n\n${transcript}`,
+    "fast",
+    SUMMARY_TIMEOUT_SEC,
+    { model: CODEX_MODELS.spark },
+  );
+
+  if (result.success && result.output && result.output.trim() && !looksLikeBadSummary(result.output)) {
+    return result.output.trim();
+  }
+
+  logWarn(
+    "codex-capture",
+    `Session-file Spark summary failed: ${result.error ?? "empty or low-signal output"}`,
+  );
+  return null;
+}
+
+async function summarizeViaResume(sessionId: string): Promise<string | null> {
+  const outputFile = path.join(os.tmpdir(), `codex-resume-summary-${Date.now()}-${process.pid}.txt`);
+
+  const result = await execFileAsync(
+    "codex",
+    [
+      "exec",
+      "resume",
+      sessionId,
+      RESUME_SUMMARY_PROMPT,
+      "--json",
+      "--model",
+      CODEX_MODELS.spark,
+      "--output-last-message",
+      outputFile,
+    ],
+    { timeout: RESUME_TIMEOUT_MS },
+  );
+
+  const summary = readTextIfExists(outputFile);
+  safeCleanup(outputFile);
+
+  if (summary && !looksLikeBadSummary(summary)) return summary;
+  logWarn("codex-capture", `codex exec resume failed for ${sessionId}: exit=${result.exitCode}, stderr=${result.stderr.trim() || "none"}`);
+  return null;
+}
+
+function summarizeFromSessionFileFallback(sessionFile: string): string | null {
+  const lines = collectTranscriptLines(sessionFile).slice(-12);
+  if (lines.length === 0) return null;
+  return `Codex session completed. Transcript fallback:\n- ${lines.join("\n- ")}`;
+}
+
+async function main(): Promise<void> {
+  const [paneId, sessionId, sessionFile] = process.argv.slice(2);
+
+  if (!paneId) {
+    console.log(SUMMARY_UNAVAILABLE_MESSAGE);
+    return;
+  }
+
+  await waitForPaneClose(paneId);
+
+  const transcriptSummary = summarizeViaSessionFileSpark(sessionFile ?? "");
+  if (transcriptSummary) {
+    console.log(transcriptSummary);
+    return;
+  }
+
+  if (sessionId) {
+    const resumeSummary = await summarizeViaResume(sessionId);
+    if (resumeSummary) {
+      console.log(resumeSummary);
+      return;
+    }
+  }
+
+  const fallback = summarizeFromSessionFileFallback(sessionFile ?? "");
+  if (fallback) {
+    console.log(fallback);
+    return;
+  }
+
+  console.log(SUMMARY_UNAVAILABLE_MESSAGE);
+}
+
+main().catch((error) => {
+  logWarn("codex-capture", `watch-codex failed: ${String(error)}`);
+  console.log(SUMMARY_UNAVAILABLE_MESSAGE);
+  process.exit(0);
+});