@penvhq/cli 0.3.2 → 0.4.0

package/dist/index.js

@@ -376,29 +376,61 @@ function permitsAbsence(node) {
   }
   return void 0;
 }
-function leaves(node, path, inherited, out) {
+function leaves(node, path, inherited, out2) {
   const own = permitsAbsence(node);
   const absencePermitted = inherited === true || own === true ? true : combine(inherited, own);
   const shape = shapeOf(unwrap(node));
   if (shape === void 0) {
     if (path.length > 0) {
-      out.push({ path, absencePermitted });
+      out2.push({ path, absencePermitted, node });
     }
     return;
   }
   for (const key of Object.keys(shape)) {
-    leaves(shape[key], [...path, key], absencePermitted, out);
+    leaves(shape[key], [...path, key], absencePermitted, out2);
   }
 }
 function combine(left, right) {
   return left === void 0 || right === void 0 ? void 0 : false;
 }
 function declaredLeaves(schema) {
-  const out = [];
-  leaves(schema, [], false, out);
-  return out;
+  const out2 = [];
+  leaves(schema, [], false, out2);
+  return out2;
 }
-var EMPTY_DRIFT = { declared: [], undeclared: [] };
+function defaultValueOf(node) {
+  let current = node;
+  for (let depth = 0; depth < 8; depth += 1) {
+    const def = defOf(current);
+    if (def === void 0) {
+      return void 0;
+    }
+    if (typeOf(current) === "default" || typeOf(current) === "prefault") {
+      let value = def.defaultValue;
+      if (typeof value === "function") {
+        try {
+          value = value();
+        } catch {
+          return void 0;
+        }
+      }
+      if (typeof value === "string") {
+        return JSON.stringify(value);
+      }
+      if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+        return String(value);
+      }
+      return void 0;
+    }
+    const inner = def.innerType;
+    if (inner === void 0) {
+      return void 0;
+    }
+    current = inner;
+  }
+  return void 0;
+}
+var EMPTY_DRIFT = { declared: [], undeclared: [], optional: [] };
 function hasValue(resolution) {
   return resolution.winner !== void 0;
 }
@@ -406,23 +438,39 @@ function computeDrift(input) {
   const { schema, resolutions, config, environment } = input;
   const valued = new Set(resolutions.filter(hasValue).map((resolution) => resolution.parameter));
   const declared = [];
+  const optional = [];
   for (const leaf of declaredLeaves(schema)) {
-    if (leaf.absencePermitted !== false) {
+    if (leaf.absencePermitted === void 0) {
       continue;
     }
     const path = leaf.path.join(".");
     const ref = refFromAccessPath2(leaf.path);
+    const renameRemedy = `Rename the \`${path}\` key in .penv/env.ts \u2014 a parameter name is lower-case, hyphenated, and never a reserved token, so no value file reaches this key.`;
     if (ref === void 0 || isReservedToken2(ref.name, config)) {
-      declared.push({
-        subject: path,
-        remedy: `Rename the \`${path}\` key in .penv/env.ts \u2014 a parameter name is lower-case, hyphenated, and never a reserved token, so no value file reaches this key.`,
-        detail: "declared, no filename reaches it"
-      });
+      if (leaf.absencePermitted) {
+        optional.push({ subject: path, remedy: renameRemedy });
+      } else {
+        declared.push({
+          subject: path,
+          remedy: renameRemedy,
+          detail: "declared, no filename reaches it"
+        });
+      }
       continue;
     }
     if (valued.has(parameterId2(ref))) {
       continue;
     }
+    if (leaf.absencePermitted) {
+      const defaultValue = defaultValueOf(leaf.node);
+      optional.push({
+        subject: parameterId2(ref),
+        ref,
+        ...defaultValue === void 0 ? {} : { defaultValue },
+        remedy: `penv set ${[...ref.namespace, ref.name].join("/")} --env ${environment}`
+      });
+      continue;
+    }
     declared.push({
       subject: parameterId2(ref),
       ref,
@@ -440,28 +488,91 @@ function computeDrift(input) {
       variable: variableName(resolution.ref, config)
     });
   }
-  return { declared, undeclared };
+  return { declared, undeclared, optional };
+}
+
+// src/style.ts
+function supportsColor(stream) {
+  const env = process.env;
+  if (env.NO_COLOR !== void 0 && env.NO_COLOR !== "") {
+    return false;
+  }
+  if (env.FORCE_COLOR !== void 0 && env.FORCE_COLOR !== "" && env.FORCE_COLOR !== "0") {
+    return true;
+  }
+  if (env.TERM === "dumb") {
+    return false;
+  }
+  return stream.isTTY === true;
+}
+var ESC = `${String.fromCharCode(27)}[`;
+var identity = (text) => text;
+function sgr(open, close, on) {
+  if (!on) {
+    return identity;
+  }
+  const opener = `${ESC}${open}m`;
+  const closer = `${ESC}${close}m`;
+  return (text) => `${opener}${text}${closer}`;
+}
+function paletteFor(stream) {
+  const on = supportsColor(stream);
+  return {
+    enabled: on,
+    bold: sgr(1, 22, on),
+    dim: sgr(2, 22, on),
+    red: sgr(31, 39, on),
+    green: sgr(32, 39, on),
+    yellow: sgr(33, 39, on),
+    cyan: sgr(36, 39, on),
+    magenta: sgr(35, 39, on)
+  };
+}
+var out = paletteFor(process.stdout);
+var err = paletteFor(process.stderr);
+var STYLE_PATTERN = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+function visibleWidth(text) {
+  return text.replace(STYLE_PATTERN, "").length;
+}
+function padVisible(text, width) {
+  const missing = width - visibleWidth(text);
+  return missing > 0 ? text + " ".repeat(missing) : text;
 }
 
 // src/ui.ts
 import { PenvError as PenvError3 } from "@penvhq/core";
 var CHECK = "\u2713";
 var WARN = "\u26A0";
+var CROSS = "\u2717";
 var UNKNOWN = "?";
+function paintGlyph(glyph) {
+  switch (glyph) {
+    case CHECK:
+      return out.green(glyph);
+    case WARN:
+      return out.yellow(glyph);
+    case CROSS:
+      return out.red(glyph);
+    case UNKNOWN:
+      return out.dim(glyph);
+    default:
+      return glyph;
+  }
+}
 var NOTE_COLUMN = 29;
 function widest(values) {
-  return values.reduce((max, value) => Math.max(max, value.length), 0);
+  return values.reduce((max, value) => Math.max(max, visibleWidth(value)), 0);
 }
 function formatRows(rows) {
   const labelWidth = widest(rows.map((row) => row.label)) + 2;
   const detailed = rows.filter((row) => row.detail !== void 0);
   const subjectWidth = widest(detailed.map((row) => row.subject ?? "")) + 1;
   return rows.map((row) => {
-    const head = `${row.glyph} ${row.label.padEnd(labelWidth)}`;
+    const head = `${paintGlyph(row.glyph)} ${padVisible(row.label, labelWidth)}`;
     if (row.detail === void 0) {
       return `${head}${row.subject ?? ""}`.trimEnd();
     }
-    return `${head}${(row.subject ?? "").padEnd(subjectWidth)}${row.detail}`.trimEnd();
+    return `${head}${padVisible(row.subject ?? "", subjectWidth)}${out.dim(row.detail)}`.trimEnd();
   });
 }
 function columns(rows, gap = 2) {
@@ -471,18 +582,31 @@ function columns(rows, gap = 2) {
     widths.push(widest(rows.map((row) => row[column] ?? "")) + gap);
   }
   return rows.map(
-    (row) => row.map((cell, index) => index === row.length - 1 ? cell : cell.padEnd(widths[index] ?? 0)).join("").trimEnd()
+    (row) => row.map(
+      (cell, index) => index === row.length - 1 ? cell : padVisible(cell, widths[index] ?? 0)
+    ).join("").trimEnd()
   );
 }
 function formatSteps(steps) {
   return steps.map((step) => {
     if (step.note === void 0) {
-      return `${step.glyph} ${step.text}`;
+      return `${paintGlyph(step.glyph)} ${step.text}`;
     }
-    const text = step.text.length >= NOTE_COLUMN ? `${step.text} ` : step.text.padEnd(NOTE_COLUMN);
-    return `${step.glyph} ${text}${step.note}`;
+    const text = visibleWidth(step.text) >= NOTE_COLUMN ? `${step.text} ` : padVisible(step.text, NOTE_COLUMN);
+    return `${paintGlyph(step.glyph)} ${text}${out.dim(step.note)}`;
   });
 }
+function heading(command, context) {
+  return context === void 0 ? out.bold(command) : `${out.bold(command)} ${out.dim(`\xB7 ${context}`)}`;
+}
+function tip(text) {
+  return `  ${out.cyan("\u2192")} ${text}`;
+}
+function prompt(subject, context) {
+  const head = `${out.cyan("?")} ${out.bold(subject)}`;
+  const tail = out.dim("\u203A ");
+  return context === void 0 ? `${head} ${tail}` : `${head} ${out.dim(`\xB7 ${context}`)} ${tail}`;
+}
 function write(lines) {
   for (const line of lines) {
     process.stdout.write(`${line}
@@ -491,13 +615,26 @@ function write(lines) {
 }
 function reportError(error) {
   if (error instanceof PenvError3) {
-    process.stderr.write(`${error.message}
+    const suffix = error.remedy === void 0 ? void 0 : `
+  ${error.remedy}`;
+    const message = suffix !== void 0 && error.message.endsWith(suffix) ? error.message.slice(0, -suffix.length) : error.message;
+    process.stderr.write(`${err.red(CROSS)} ${message}
+`);
+    if (error.remedy !== void 0) {
+      process.stderr.write(`  ${err.cyan("\u2192")} ${error.remedy}
 `);
+    }
   } else if (error instanceof Error) {
-    process.stderr.write(`${error.stack ?? error.message}
+    process.stderr.write(`${err.red(CROSS)} ${error.message}
+`);
+    const stack = error.stack;
+    const frames = stack?.startsWith(`${error.name}: ${error.message}`) ? stack.slice(`${error.name}: ${error.message}`.length).replace(/^\n/, "") : stack;
+    if (frames !== void 0 && frames !== "") {
+      process.stderr.write(`${err.dim(frames)}
 `);
+    }
   } else {
-    process.stderr.write(`${String(error)}
+    process.stderr.write(`${err.red(CROSS)} ${String(error)}
 `);
   }
   process.exitCode = 1;
@@ -905,18 +1042,26 @@ function renderValidate(result2) {
     ]);
   }
   const rows = result2.issues.map((issue) => ({
-    glyph: WARN,
+    glyph: CROSS,
     label: LABELS[issue.kind],
     subject: issue.subject,
     detail: issue.message
   }));
   const lines = formatRows(rows);
-  const remedies = [...new Set(result2.issues.map((issue) => issue.remedy))];
-  for (const remedy of remedies) {
-    if (remedy !== void 0) {
-      lines.push(`  ${remedy}`);
+  const remedies = [...new Set(result2.issues.map((issue) => issue.remedy))].filter(
+    (remedy) => remedy !== void 0
+  );
+  if (remedies.length > 0) {
+    lines.push("");
+    for (const remedy of remedies) {
+      lines.push(tip(remedy));
     }
   }
+  const count = result2.issues.length;
+  lines.push(
+    "",
+    `${out.red(CROSS)} ${count} ${count === 1 ? "issue" : "issues"} for environment ${result2.environment}`
+  );
   return lines;
 }
 var validateCommand = defineCommand2({
@@ -1671,22 +1816,51 @@ async function providerDriftFindings(project, environment, override) {
     }
   ];
 }
+var GLYPHS = {
+  pass: CHECK,
+  warning: WARN,
+  failure: CROSS,
+  unknown: UNKNOWN
+};
+function summarize(report) {
+  const counts = { pass: 0, warning: 0, failure: 0, unknown: 0 };
+  for (const finding of report.findings) {
+    counts[finding.severity] += 1;
+  }
+  const parts = [out.green(`${counts.pass} passed`)];
+  if (counts.warning > 0) {
+    parts.push(out.yellow(`${counts.warning} ${counts.warning === 1 ? "warning" : "warnings"}`));
+  }
+  if (counts.failure > 0) {
+    parts.push(out.red(`${counts.failure} ${counts.failure === 1 ? "failure" : "failures"}`));
+  }
+  if (counts.unknown > 0) {
+    parts.push(out.dim(`${counts.unknown} could not be checked`));
+  }
+  const verdict = report.ok ? out.green(CHECK) : out.red(CROSS);
+  return `${verdict} ${report.findings.length} checks: ${parts.join(out.dim(" \xB7 "))}`;
+}
 function renderDoctor(report) {
   const rows = report.findings.map((finding) => ({
-    glyph: finding.severity === "pass" ? CHECK : finding.severity === "unknown" ? UNKNOWN : WARN,
+    glyph: GLYPHS[finding.severity],
     label: finding.label,
     ...finding.subject === void 0 ? {} : { subject: finding.subject },
     ...finding.detail === void 0 ? {} : { detail: finding.detail }
   }));
-  const lines = formatRows(rows);
+  const lines = [heading("penv doctor", `environment ${report.environment}`), ""];
+  lines.push(...formatRows(rows));
   const remedies = [
     ...new Set(
       report.findings.filter((finding) => finding.severity !== "pass").map((finding) => finding.remedy).filter((remedy) => remedy !== void 0)
     )
   ];
-  for (const remedy of remedies) {
-    lines.push(`  ${remedy}`);
+  if (remedies.length > 0) {
+    lines.push("");
+    for (const remedy of remedies) {
+      lines.push(tip(remedy));
+    }
   }
+  lines.push("", summarize(report));
   return lines;
 }
 var doctorCommand = defineCommand3({
@@ -1984,9 +2158,52 @@ var decryptCommand = defineCommand5({
 });
 
 // src/commands/fill.ts
-import { createInterface } from "readline/promises";
 import { PenvError as PenvError8 } from "@penvhq/core";
 import { defineCommand as defineCommand6 } from "citty";
+
+// src/input.ts
+import { createInterface } from "readline";
+function lineReader(input = process.stdin, output = process.stdout) {
+  const rl = createInterface({ input, output });
+  const buffered = [];
+  const waiting = [];
+  let closed = false;
+  rl.on("line", (line) => {
+    const next = waiting.shift();
+    if (next === void 0) {
+      buffered.push(line);
+    } else {
+      next(line);
+    }
+  });
+  rl.on("close", () => {
+    closed = true;
+    for (const next of waiting.splice(0)) {
+      next(void 0);
+    }
+  });
+  return {
+    ask(question) {
+      const early = buffered.shift();
+      if (early !== void 0) {
+        return Promise.resolve(early);
+      }
+      if (closed) {
+        return Promise.resolve(void 0);
+      }
+      rl.setPrompt(question);
+      rl.prompt();
+      return new Promise((resolve7) => {
+        waiting.push(resolve7);
+      });
+    },
+    close() {
+      rl.close();
+    }
+  };
+}
+
+// src/commands/fill.ts
 var BLOCKING = /* @__PURE__ */ new Set(["config", "collision", "reserved"]);
 async function runFill(options) {
   const validation = await runValidate({
@@ -2008,6 +2225,7 @@ ${detail}`,
   }
   const written = [];
   const skipped2 = [];
+  const kept = [];
   const unreachable = [];
   for (const drift of validation.drift.declared) {
     if (drift.ref === void 0) {
@@ -2016,7 +2234,12 @@ ${detail}`,
     }
     const ref = drift.ref;
     const key = [...ref.namespace, ref.name].join("/");
-    const value = await options.ask({ parameter: key, environment, secret: false });
+    const value = await options.ask({
+      parameter: key,
+      environment,
+      secret: false,
+      optional: false
+    });
     if (value === void 0 || value === "") {
       skipped2.push(drift.subject);
       continue;
@@ -2028,17 +2251,45 @@ ${detail}`,
       encrypted: result2.encrypted
     });
   }
-  return { environment, written, skipped: skipped2, unreachable };
+  for (const item of validation.drift.optional) {
+    if (item.ref === void 0) {
+      unreachable.push({ subject: item.subject, remedy: item.remedy });
+      continue;
+    }
+    const ref = item.ref;
+    const key = [...ref.namespace, ref.name].join("/");
+    const value = await options.ask({
+      parameter: key,
+      environment,
+      secret: false,
+      optional: true,
+      ...item.defaultValue === void 0 ? {} : { defaultValue: item.defaultValue }
+    });
+    if (value === void 0 || value === "") {
+      kept.push(item.subject);
+      continue;
+    }
+    const result2 = await runSet({ cwd: options.cwd, key, value, environment });
+    written.push({
+      parameter: item.subject,
+      location: result2.location,
+      encrypted: result2.encrypted
+    });
+  }
+  return { environment, written, skipped: skipped2, kept, unreachable };
 }
 function summaryLine(result2) {
   const filled = result2.written.length;
-  if (filled === 0 && result2.skipped.length === 0 && result2.unreachable.length === 0) {
-    return `Nothing to fill for environment ${result2.environment}: every declared parameter has a value`;
+  if (filled === 0 && result2.skipped.length === 0 && result2.kept.length === 0 && result2.unreachable.length === 0) {
+    return `${out.green(CHECK)} Nothing to fill for environment ${result2.environment}: every declared parameter has a value`;
   }
   const parts = [`${filled} written`];
   if (result2.skipped.length > 0) {
     parts.push(`${result2.skipped.length} skipped`);
   }
+  if (result2.kept.length > 0) {
+    parts.push(`${result2.kept.length} left to the schema's defaults`);
+  }
   if (result2.unreachable.length > 0) {
     parts.push(`${result2.unreachable.length} unreachable`);
   }
@@ -2059,6 +2310,16 @@ function renderFill(result2) {
   lines.push(summaryLine(result2));
   return lines;
 }
+function contextFor(prompt2) {
+  if (!prompt2.optional) {
+    return `${prompt2.environment}, Enter to skip`;
+  }
+  if (prompt2.defaultValue === void 0) {
+    return `${prompt2.environment} \xB7 optional, Enter leaves it unset`;
+  }
+  const shown = prompt2.defaultValue.length > 24 ? `${prompt2.defaultValue.slice(0, 23)}\u2026` : prompt2.defaultValue;
+  return `${prompt2.environment} \xB7 optional, Enter keeps ${shown}`;
+}
 var fillCommand = defineCommand6({
   meta: {
     name: "fill",
@@ -2069,8 +2330,8 @@ var fillCommand = defineCommand6({
   },
   run({ args }) {
     return guard(async () => {
-      const rl = createInterface({ input: process.stdin, output: process.stdout });
-      const ask = (prompt) => rl.question(`${prompt.parameter} (${prompt.environment}): `);
+      const reader = lineReader();
+      const ask = (prompt2) => reader.ask(prompt(prompt2.parameter, contextFor(prompt2)));
       try {
         write(
           renderFill(
@@ -2082,7 +2343,7 @@ var fillCommand = defineCommand6({
           )
         );
       } finally {
-        rl.close();
+        reader.close();
       }
     });
   }
@@ -2251,12 +2512,14 @@ async function runExplain(options) {
 function renderExplain(explanation) {
   const target = explanation.location === void 0 ? "nothing" : `${PENV_DIR}/${explanation.location}`;
   const rows = explanation.candidates.map((candidate) => [
-    candidate.location,
-    candidate.wins ? "present, wins" : candidate.present ? candidate.skipped ?? "present" : candidate.skipped ?? "absent"
+    candidate.wins ? candidate.location : out.dim(candidate.location),
+    candidate.wins ? out.green("present, wins") : out.dim(
+      candidate.present ? candidate.skipped ?? "present" : candidate.skipped ?? "absent"
+    )
   ]);
   return [
-    `${explanation.parameter} resolves to ${target} for environment ${explanation.environment}`,
-    ...explanation.undecryptable === void 0 ? [] : [`  penv cannot decrypt it: ${explanation.undecryptable}`],
+    `${out.bold(explanation.parameter)} resolves to ${target} for environment ${explanation.environment}`,
+    ...explanation.undecryptable === void 0 ? [] : [`  ${out.red(CROSS)} penv cannot decrypt it: ${explanation.undecryptable}`],
     "",
     ...columns(rows).map((line) => `  ${line}`)
   ];
@@ -2561,23 +2824,27 @@ function planInit(root, flags = {}) {
 function renderPlan(plan2) {
   const rows = [];
   rows.push([
-    "  environments",
-    plan2.suggestedEnvironments.length === 0 ? "" : `[${plan2.suggestedEnvironments.join(", ")}]`,
-    plan2.suggestedEnvironments.length === 0 ? "<- name them, or Enter to leave the whitelist empty" : "<- from your .env files; edit, or Enter to accept"
+    `  ${out.dim("environments")}`,
+    plan2.suggestedEnvironments.length === 0 ? "" : out.cyan(`[${plan2.suggestedEnvironments.join(", ")}]`),
+    out.dim(
+      plan2.suggestedEnvironments.length === 0 ? "\u2190 name them, or Enter to leave the whitelist empty" : "\u2190 from your .env files; edit, or Enter to accept"
+    )
   ]);
   rows.push([
-    "  schemaFile",
+    `  ${out.dim("schemaFile")}`,
     plan2.decisions.schemaFile,
-    plan2.decisions.schemaFile === DEFAULT_SCHEMA_FILE2 ? "" : `(default: ${DEFAULT_SCHEMA_FILE2})`
+    plan2.decisions.schemaFile === DEFAULT_SCHEMA_FILE2 ? "" : out.dim(`(default: ${DEFAULT_SCHEMA_FILE2})`)
   ]);
   for (const prefix of plan2.decisions.publicPrefixes) {
-    rows.push(["  publicPrefix", prefix, ""]);
+    rows.push([`  ${out.dim("publicPrefix")}`, prefix, ""]);
   }
-  const headline = plan2.detected === void 0 ? "No framework detected in package.json." : `Detected ${plan2.detected.name}.`;
+  const headline = out.bold(
+    plan2.detected === void 0 ? "No framework detected in package.json." : `Detected ${plan2.detected.name}.`
+  );
   return [headline, "", ...columns(rows), ""];
 }
 function environmentsHint(plan2) {
-  return plan2.suggestedEnvironments.length === 0 ? "environments (comma-separated, Enter for none) > " : 'environments (Enter to accept, "none" for an empty whitelist) > ';
+  return plan2.suggestedEnvironments.length === 0 ? prompt("environments", "comma-separated, Enter for none") : prompt("environments", 'Enter to accept, "none" for an empty whitelist');
 }
 async function promptForDecisions(plan2, io) {
   for (const line of renderPlan(plan2)) {
@@ -2592,7 +2859,7 @@ async function promptForDecisions(plan2, io) {
     );
     io.write("");
   }
-  const proceed = (await io.ask("Proceed? [Y/n] ")).trim().toLowerCase();
+  const proceed = (await io.ask(prompt("Proceed?", "Y/n"))).trim().toLowerCase();
   if (proceed.length > 0 && proceed !== "y" && proceed !== "yes") {
     return void 0;
   }
@@ -2997,7 +3264,8 @@ function renderInit(result2) {
   return [
     ...formatSteps(steps),
     "",
-    `Done. Declare your parameters in ${result2.decisions.schemaFile}, then \`penv set <key>\`.`,
+    `${out.green(CHECK)} ${out.bold("Done.")} Declare your parameters in ${result2.decisions.schemaFile}, then:`,
+    tip(out.cyan("penv set <key>")),
     ...result2.decisions.environments.length === 0 ? [
       `Then declare your environments in ${CONFIG_FILE}: penv leaves the whitelist empty rather than inventing one, and every command needs it.`
     ] : []
@@ -3466,20 +3734,28 @@ function runKeyCreate(options) {
 function renderKeyCreate(result2) {
   if (result2.source === "keychain") {
     return [
-      `A new key for environment ${result2.environment}, stored in your OS keychain as \`${result2.id}\`.`,
+      `${out.green(CHECK)} A new key for environment ${result2.environment}, stored in your OS keychain as \`${result2.id}\`.`,
       "",
-      "penv kept no copy. Anything sealed under it is unreadable without your keychain, and running",
-      "`penv key create` again would replace it \u2014 so it lives in exactly one place, on this machine."
+      out.dim(
+        "penv kept no copy. Anything sealed under it is unreadable without your keychain, and running"
+      ),
+      out.dim(
+        "`penv key create` again would replace it \u2014 so it lives in exactly one place, on this machine."
+      )
     ];
   }
   return [
-    `A new key for environment ${result2.environment}. penv did not store it.`,
+    `${out.green(CHECK)} A new key for environment ${result2.environment}. penv did not store it.`,
     "",
-    `  ${result2.variable}=${result2.key}`,
+    `  ${out.cyan(`${result2.variable}=${result2.key}`)}`,
     "",
-    "Export it where penv runs, and put it wherever this environment's secrets already live \u2014",
-    "a KMS, your CI's secret store, a password manager. Anything sealed under it is unreadable",
-    "without it, and penv keeps no copy to fall back on."
+    out.dim(
+      "Export it where penv runs, and put it wherever this environment's secrets already live \u2014"
+    ),
+    out.dim(
+      "a KMS, your CI's secret store, a password manager. Anything sealed under it is unreadable"
+    ),
+    out.dim("without it, and penv keeps no copy to fall back on.")
   ];
 }
 var keyCommand = defineCommand11({
@@ -3547,11 +3823,31 @@ async function runList(options) {
   }
   return { environment, parameters };
 }
+function paintScope(entry) {
+  if (entry.scope === "absent" || entry.viaUnscopedFallback) {
+    return out.yellow(entry.scope);
+  }
+  return out.green(entry.scope);
+}
 function renderList(result2) {
   if (result2.parameters.length === 0) {
-    return [`No parameters in ${PENV_DIR}/ for environment ${result2.environment}.`];
+    return [
+      `No parameters in ${PENV_DIR}/ for environment ${result2.environment}.`,
+      tip(`penv set <key> --env ${result2.environment}`)
+    ];
   }
-  return columns(result2.parameters.map((entry) => [entry.parameter, entry.scope, entry.variable]));
+  const header = ["parameter", "scope", "variable", ""].map((cell) => out.dim(cell));
+  const rows = result2.parameters.map((entry) => [
+    entry.parameter,
+    paintScope(entry),
+    entry.variable,
+    entry.encrypted ? out.dim("encrypted") : ""
+  ]);
+  return [
+    heading("penv list", `environment ${result2.environment}`),
+    "",
+    ...columns([header, ...rows])
+  ];
 }
 var listCommand = defineCommand12({
   meta: { name: "list", description: "List parameters" },
@@ -3699,8 +3995,9 @@ function renderMove(result2) {
   const lines = formatRows(rows);
   lines.push(
     "",
-    `  .penv/env.ts still declares \`${result2.schema.was}\`. Rename it to \`${result2.schema.now}\`,`,
-    "  or `penv validate` will report the value as unused and the declaration as unset."
+    tip(
+      `.penv/env.ts still declares \`${result2.schema.was}\` \u2014 rename it to \`${result2.schema.now}\`, or \`penv validate\` will report the value as unused and the declaration as unset.`
+    )
   );
   return lines;
 }
@@ -4235,9 +4532,9 @@ function renderDrift(drift, environment) {
   if (rows.length === 0) {
     return [];
   }
-  const lines = ["", `Schema and tree differ for ${environment}:`, ...formatRows(rows)];
+  const lines = ["", out.bold(`Schema and tree differ for ${environment}:`), ...formatRows(rows)];
   for (const remedy of new Set(drift.declared.map((item) => item.remedy))) {
-    lines.push(`  ${remedy}`);
+    lines.push(tip(remedy));
   }
   return lines;
 }
@@ -4268,7 +4565,7 @@ var watchCommand = defineCommand17({
           process.exitCode = previous;
         }
       });
-      write(["Watching .penv/ and penv.config.ts. Ctrl-C to stop."]);
+      write([`Watching .penv/ and penv.config.ts. ${out.dim("Ctrl-C to stop.")}`]);
       await new Promise((resolve7) => {
         process.once("SIGINT", () => {
           handle.close();