@nemus-cli/nemus 0.5.0 → 0.9.0

package/dist/utils/config-schema.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG_KEYS = exports.CONFIG_SCHEMA = void 0;
+exports.isConfigKey = isConfigKey;
+exports.parseConfigValue = parseConfigValue;
+exports.validateTypedValue = validateTypedValue;
+exports.applyConfigSet = applyConfigSet;
+exports.applyConfigUnset = applyConfigUnset;
+exports.formatConfigValue = formatConfigValue;
+exports.reviewConfigFileText = reviewConfigFileText;
+const config_1 = require("./config");
+const AGENT_VALUES = ['claude', 'pi', 'opencode', 'codex', 'gemini'];
+exports.CONFIG_SCHEMA = {
+    workspacesDir: { type: 'string', describe: 'Directory where workspaces are created' },
+    githubOrg: { type: 'string', allowEmpty: true, describe: 'Default GitHub org for repo lookups' },
+    cloneProtocol: { type: 'enum', values: ['ssh', 'https'], describe: 'Protocol used to clone repos' },
+    aiAgent: {
+        type: 'enum',
+        values: [...AGENT_VALUES, 'both', 'auto'],
+        describe: 'AI agent(s) to integrate with',
+    },
+    primaryAgent: {
+        type: 'enum',
+        values: [...AGENT_VALUES, 'auto'],
+        describe: 'Agent launched when opening a workspace',
+    },
+    autoLaunchClaude: { type: 'boolean', describe: 'Auto-launch the agent after creating a workspace' },
+    generateClaudeContext: { type: 'boolean', describe: 'Generate agent context files (AGENTS.md)' },
+    installMcp: { type: 'boolean', describe: 'Install the MCP server during configure' },
+    piWorkspaceInputStatus: { type: 'boolean', describe: "Show workspace status in Pi's input area" },
+    claudeWorkspaceStatusLine: { type: 'boolean', describe: "Show workspace table in Claude's status line" },
+    autoReportBugs: { type: 'boolean', describe: 'Auto-file a GitHub issue when a command crashes' },
+};
+exports.CONFIG_KEYS = Object.keys(exports.CONFIG_SCHEMA).sort();
+const TRUE_WORDS = new Set(['true', '1', 'yes', 'on', 'y']);
+const FALSE_WORDS = new Set(['false', '0', 'no', 'off', 'n']);
+/** True if `key` is a writable config key. */
+function isConfigKey(key) {
+    return Object.prototype.hasOwnProperty.call(exports.CONFIG_SCHEMA, key);
+}
+/** Validate + coerce a raw string for `key` into the field's typed value. */
+function parseConfigValue(key, raw) {
+    const spec = exports.CONFIG_SCHEMA[key];
+    if (spec.type === 'boolean') {
+        const v = raw.trim().toLowerCase();
+        if (TRUE_WORDS.has(v))
+            return { ok: true, value: true };
+        if (FALSE_WORDS.has(v))
+            return { ok: true, value: false };
+        return { ok: false, error: `${key} expects a boolean (true/false); got "${raw}"` };
+    }
+    if (spec.type === 'enum') {
+        // Enum values are all lowercase, so normalize input like booleans do —
+        // `HTTPS` / ` https ` should resolve to the canonical value, not fail.
+        const v = raw.trim().toLowerCase();
+        if (spec.values.includes(v)) {
+            return { ok: true, value: v };
+        }
+        return { ok: false, error: `${key} must be one of: ${spec.values.join(', ')}; got "${raw}"` };
+    }
+    // string: trim surrounding whitespace (a stray space in a path/org is almost
+    // always a mistake), but preserve case.
+    const trimmed = raw.trim();
+    if (!spec.allowEmpty && trimmed === '') {
+        return { ok: false, error: `${key} cannot be empty` };
+    }
+    return { ok: true, value: trimmed };
+}
+/**
+ * Validate an already-typed value (as it appears in the JSON config file) for
+ * `key` against its field spec. This is the parse-free sibling of
+ * parseConfigValue (which coerces a CLI string): it checks that a boolean field
+ * holds a boolean, an enum holds an allowed string, and a string field holds a
+ * (non-empty, unless allowEmpty) string. Used by `config edit` so a hand-edit
+ * is validated the same way `config set` validates. Pure + unit-tested.
+ */
+function validateTypedValue(key, value) {
+    const spec = exports.CONFIG_SCHEMA[key];
+    if (spec.type === 'boolean') {
+        return typeof value === 'boolean' ? { ok: true } : { ok: false, error: `${key} must be a boolean` };
+    }
+    if (spec.type === 'enum') {
+        return typeof value === 'string' && spec.values.includes(value)
+            ? { ok: true }
+            : { ok: false, error: `${key} must be one of: ${spec.values.join(', ')}` };
+    }
+    if (typeof value !== 'string')
+        return { ok: false, error: `${key} must be a string` };
+    if (!spec.allowEmpty && value.trim() === '')
+        return { ok: false, error: `${key} cannot be empty` };
+    return { ok: true };
+}
+/** Apply a `set` to a config object, returning a NEW config or an error. Pure. */
+function applyConfigSet(current, key, raw) {
+    if (!isConfigKey(key)) {
+        return { ok: false, error: `Unknown config key "${key}". Run "nemus config list" to see valid keys.` };
+    }
+    const parsed = parseConfigValue(key, raw);
+    if (!parsed.ok)
+        return parsed;
+    return { ok: true, next: { ...current, [key]: parsed.value }, value: parsed.value };
+}
+/** Reset a key to its default value, returning a NEW config or an error. Pure. */
+function applyConfigUnset(current, key) {
+    if (!isConfigKey(key)) {
+        return { ok: false, error: `Unknown config key "${key}". Run "nemus config list" to see valid keys.` };
+    }
+    const value = config_1.CONFIG_DEFAULTS[key];
+    return { ok: true, next: { ...current, [key]: value }, value };
+}
+/** Render a config value for plain (scriptable) stdout output. */
+function formatConfigValue(value) {
+    return typeof value === 'boolean' ? String(value) : String(value ?? '');
+}
+/**
+ * Review the raw text of a hand-edited config file the same way `config set`
+ * validates: it must parse, be a plain object, only use known keys, and every
+ * known key present must hold a schema-valid value. Pure so `config edit` can be
+ * fully unit-tested without spawning an editor.
+ */
+function reviewConfigFileText(text) {
+    const base = { parseError: false, notObject: false, unknownKeys: [], invalid: [] };
+    let raw;
+    try {
+        raw = JSON.parse(text);
+    }
+    catch {
+        return { ...base, parseError: true, ok: false };
+    }
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+        return { ...base, notObject: true, ok: false };
+    }
+    const obj = raw;
+    const known = new Set(exports.CONFIG_KEYS);
+    const unknownKeys = Object.keys(obj).filter((k) => !known.has(k));
+    const invalid = [];
+    for (const key of exports.CONFIG_KEYS) {
+        if (!(key in obj))
+            continue;
+        const res = validateTypedValue(key, obj[key]);
+        if (!res.ok)
+            invalid.push(res.error);
+    }
+    return { parseError: false, notObject: false, unknownKeys, invalid, ok: invalid.length === 0 };
+}

package/dist/utils/config.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.config = exports.CLONE_MAX_BUFFER = exports.CLONE_TIMEOUT_MS = exports.CONFIG_PATH = exports.META_FILENAME = exports.SUITES_FILE = exports.HISTORY_FILE = exports.CACHE_DIR = exports.WORKSPACES_DIR = void 0;
+exports.config = exports.CLONE_MAX_BUFFER = exports.CLONE_TIMEOUT_MS = exports.CONFIG_PATH = exports.META_FILENAME = exports.SUITES_FILE = exports.HISTORY_FILE = exports.CACHE_DIR = exports.WORKSPACES_DIR = exports.CONFIG_DEFAULTS = void 0;
 exports.getUserConfig = getUserConfig;
 exports.getPackageVersion = getPackageVersion;
 exports.getCloneUrl = getCloneUrl;
@@ -77,7 +77,7 @@ const CACHE_DIR_RESOLVED = process.env.NEMUS_CACHE_DIR || process.env.WORKSPACE_
 migrateLegacyCacheDir(CACHE_DIR_RESOLVED);
 // Config file lives inside the cache dir.
 const CONFIG_FILE = path.join(CACHE_DIR_RESOLVED, 'config.json');
-const DEFAULTS = {
+exports.CONFIG_DEFAULTS = {
     workspacesDir: path.join(HOME_DIR, 'workspaces'),
     githubOrg: '',
     autoLaunchClaude: true,
@@ -90,6 +90,8 @@ const DEFAULTS = {
     claudeWorkspaceStatusLine: true,
     autoReportBugs: false,
 };
+// Internal alias retained for the many references below.
+const DEFAULTS = exports.CONFIG_DEFAULTS;
 function loadConfigFileSync() {
     try {
         const content = fs.readFileSync(CONFIG_FILE, 'utf-8');

package/dist/utils/editor.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveEditor = resolveEditor;
+exports.openInEditor = openInEditor;
+const child_process_1 = require("child_process");
+/**
+ * Resolve the user's preferred editor as an argv array. Honors `$VISUAL` then
+ * `$EDITOR` (the long-standing Unix convention — `VISUAL` wins for full-screen
+ * editors), falling back to `notepad` on Windows and `vi` elsewhere. The env
+ * value may include flags (e.g. `code --wait`, `emacs -nw`), so it's split on
+ * whitespace into a command + args. Pure + unit-tested.
+ */
+function resolveEditor(env = process.env, platform = process.platform) {
+    const raw = (env.VISUAL || env.EDITOR || '').trim();
+    if (raw)
+        return raw.split(/\s+/);
+    return platform === 'win32' ? ['notepad'] : ['vi'];
+}
+/**
+ * Open `file` in the resolved editor, inheriting the terminal so the editor is
+ * interactive. Returns a structured result rather than throwing so the caller
+ * controls messaging/exit. `spawn` is injected for tests.
+ */
+function openInEditor(file, deps = {}) {
+    const spawn = deps.spawn ?? child_process_1.spawnSync;
+    const [cmd, ...args] = resolveEditor(deps.env, deps.platform);
+    const res = spawn(cmd, [...args, file], { stdio: 'inherit' });
+    if (res.error) {
+        const err = res.error;
+        const reason = err.code === 'ENOENT' ? `editor "${cmd}" not found` : err.message;
+        return { ok: false, editor: cmd, error: reason };
+    }
+    const code = typeof res.status === 'number' ? res.status : 1;
+    return { ok: code === 0, editor: cmd, code };
+}

package/dist/utils/reflect.js

@@ -33,7 +33,11 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.REFLECT_REPORTS_DIR = exports.REFLECT_SCHEMA = void 0;
+exports.REFLECT_REPORTS_DIR = exports.REFLECT_SCHEMA = exports.PRIORITY_HEADING = exports.KIND_LABEL = void 0;
+exports.severityCounts = severityCounts;
+exports.severitySummary = severitySummary;
+exports.groupRecommendations = groupRecommendations;
+exports.renderReportMarkdown = renderReportMarkdown;
 exports.isCorrectionPrompt = isCorrectionPrompt;
 exports.distillTranscript = distillTranscript;
 exports.classifyAgentsMd = classifyAgentsMd;
@@ -41,12 +45,117 @@ exports.findLatestTranscriptFile = findLatestTranscriptFile;
 exports.gatherReflectionCorpus = gatherReflectionCorpus;
 exports.parseReflectionReport = parseReflectionReport;
 exports.saveReflectionReport = saveReflectionReport;
+exports.listSavedReports = listSavedReports;
+exports.findSavedMatches = findSavedMatches;
+exports.loadSavedReport = loadSavedReport;
 const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
 const config_1 = require("./config");
 const workspace_meta_1 = require("./workspace-meta");
 const agent_config_1 = require("./agent-config");
 const claude_sessions_1 = require("./claude-sessions");
+/** Count recommendations by priority. */
+function severityCounts(recs) {
+    const counts = { high: 0, medium: 0, low: 0 };
+    for (const r of recs)
+        counts[r.priority]++;
+    return counts;
+}
+/** "3 high · 2 medium · 1 low", omitting zero buckets; '' when there are none. */
+function severitySummary(recs) {
+    const c = severityCounts(recs);
+    return ['high', 'medium', 'low']
+        .filter((p) => c[p] > 0)
+        .map((p) => `${c[p]} ${p}`)
+        .join(' · ');
+}
+exports.KIND_LABEL = {
+    skill: 'Skill',
+    context: 'Context/AGENTS.md',
+    test: 'Test',
+    prompt: 'Prompt',
+    connectivity: 'Connectivity',
+    workflow: 'Workflow',
+    other: 'Other',
+};
+// Back-compat alias for existing references.
+const MD_KIND_LABEL = exports.KIND_LABEL;
+exports.PRIORITY_HEADING = {
+    high: 'High priority',
+    medium: 'Medium priority',
+    low: 'Low priority',
+};
+const KIND_ORDER = ['skill', 'context', 'test', 'prompt', 'connectivity', 'workflow', 'other'];
+const PRIORITY_ORDER = ['high', 'medium', 'low'];
+const PRIORITY_RANK = { high: 0, medium: 1, low: 2 };
+/**
+ * Split recommendations into ordered, non-empty groups by either priority
+ * (high→low) or kind (a fixed, stable order). When grouping by kind, each
+ * group's recs are sorted high-priority first. Pure + unit-tested; shared by the
+ * Markdown renderer and the human printer so the two never diverge.
+ */
+function groupRecommendations(recs, groupBy) {
+    if (groupBy === 'kind') {
+        return KIND_ORDER.map((k) => ({
+            key: k,
+            heading: exports.KIND_LABEL[k],
+            recs: recs
+                .filter((r) => r.kind === k)
+                .sort((a, b) => PRIORITY_RANK[a.priority] - PRIORITY_RANK[b.priority]),
+        })).filter((g) => g.recs.length > 0);
+    }
+    return PRIORITY_ORDER.map((p) => ({
+        key: p,
+        heading: exports.PRIORITY_HEADING[p],
+        recs: recs.filter((r) => r.priority === p),
+    })).filter((g) => g.recs.length > 0);
+}
+/** A fenced code block whose fence is guaranteed longer than any backtick run
+ *  inside `body`, so the snippet can't break out of its own fence. */
+function fencedBlock(body) {
+    const longest = Math.max(0, ...(body.match(/`+/g) ?? []).map((m) => m.length));
+    const fence = '`'.repeat(Math.max(3, longest + 1));
+    return `${fence}\n${body}\n${fence}`;
+}
+/**
+ * Render a reflection report as clean Markdown — for pasting into an issue/PR or
+ * saving alongside the JSON. Pure (no color, no I/O) so it's unit-tested.
+ * Recommendations are grouped by severity (high→low); each carries its kind,
+ * optional target, detail, and a fenced example.
+ */
+function renderReportMarkdown(report, meta, groupBy = 'priority') {
+    const lines = ['# Reflection', ''];
+    const scope = meta.workspace
+        ? `workspace **${meta.workspace}**`
+        : `${meta.analyzed} session${meta.analyzed === 1 ? '' : 's'} across ${meta.workspaces} workspace${meta.workspaces === 1 ? '' : 's'}`;
+    const stamp = meta.generatedAt ? ` · ${meta.generatedAt}` : '';
+    lines.push(`_${scope}${stamp}_`, '');
+    if (report.summary.trim())
+        lines.push(report.summary.trim(), '');
+    if (report.recommendations.length === 0) {
+        lines.push('## Recommendations', '', '_No specific recommendations — looks solid._', '');
+        return lines.join('\n');
+    }
+    lines.push('## Recommendations', '', `**${severitySummary(report.recommendations)}**`, '');
+    for (const group of groupRecommendations(report.recommendations, groupBy)) {
+        lines.push(`### ${group.heading}`, '');
+        for (const r of group.recs) {
+            const target = r.target ? ` (\`${r.target}\`)` : '';
+            // Under a kind heading the [Kind] prefix is redundant; show a priority tag
+            // instead. Under a priority heading, show the kind.
+            const label = groupBy === 'kind' ? `_${r.priority}_ — ` : `[${exports.KIND_LABEL[r.kind]}] `;
+            lines.push(`- **${label}${r.title}**${target}`);
+            if (r.detail.trim()) {
+                lines.push(...r.detail.trim().split('\n').map((l) => `  ${l}`));
+            }
+            if (r.example?.trim()) {
+                lines.push('', ...fencedBlock(r.example.trim()).split('\n').map((l) => `  ${l}`));
+            }
+            lines.push('');
+        }
+    }
+    return lines.join('\n').replace(/\n{3,}/g, '\n\n').trimEnd() + '\n';
+}
 // --------------------------------------------------------- transcript distill
 // Kept deliberately lean: the judge runs on the user's own (often local, slow)
 // agent, and a 10-workspace corpus at full verbosity produced a ~200KB prompt
@@ -408,3 +517,63 @@ async function saveReflectionReport(report, meta) {
     await fs.writeFile(file, JSON.stringify({ generatedAt: new Date().toISOString(), ...meta, ...report }, null, 2));
     return file;
 }
+/**
+ * List saved reports under `~/.nemus/reflect/`, newest first (filenames start
+ * with an ISO timestamp, so a reverse name sort is chronological). Unreadable /
+ * unparseable files are skipped, not fatal. Returns [] if the dir is absent.
+ */
+async function listSavedReports(dir = exports.REFLECT_REPORTS_DIR) {
+    let names;
+    try {
+        names = await fs.readdir(dir);
+    }
+    catch {
+        return [];
+    }
+    const jsons = names.filter((n) => n.endsWith('.json')).sort().reverse();
+    const out = [];
+    for (const name of jsons) {
+        const file = path.join(dir, name);
+        try {
+            const raw = JSON.parse(await fs.readFile(file, 'utf-8'));
+            out.push({
+                id: name.replace(/\.json$/, ''),
+                file,
+                generatedAt: typeof raw.generatedAt === 'string' ? raw.generatedAt : undefined,
+                analyzed: typeof raw.analyzed === 'number' ? raw.analyzed : 0,
+                workspaces: typeof raw.workspaces === 'number' ? raw.workspaces : 0,
+                workspace: typeof raw.workspace === 'string' ? raw.workspace : undefined,
+                report: parseReflectionReport(raw),
+            });
+        }
+        catch {
+            /* skip a corrupt/partial file */
+        }
+    }
+    return out;
+}
+/**
+ * Resolve a report reference against an (already newest-first) list. Returns ALL
+ * matches so a caller can detect ambiguity: `undefined`/`'latest'` -> the newest;
+ * an exact id -> that one; otherwise every id with the prefix (newest-first). An
+ * exact id always wins over prefixes, so an id can't be ambiguous with itself.
+ * Pure + unit-tested.
+ */
+function findSavedMatches(all, ref) {
+    if (all.length === 0)
+        return [];
+    if (!ref || ref === 'latest')
+        return [all[0]];
+    const exact = all.find((r) => r.id === ref);
+    if (exact)
+        return [exact];
+    return all.filter((r) => r.id.startsWith(ref));
+}
+/**
+ * Load one saved report by id. `undefined`/`'latest'` returns the newest; an id
+ * is matched exactly, then as a prefix (newest match wins). Returns null when
+ * nothing matches. For ambiguity-aware callers, use findSavedMatches directly.
+ */
+async function loadSavedReport(ref, dir = exports.REFLECT_REPORTS_DIR) {
+    return findSavedMatches(await listSavedReports(dir), ref)[0] ?? null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nemus-cli/nemus",
-  "version": "0.5.0",
+  "version": "0.9.0",
   "workspaces": [
     "packages/*"
   ],

package/src/commands/config.ts

@@ -0,0 +1,163 @@
+import { Command } from 'commander';
+import * as fs from 'fs';
+import { getUserConfig, saveUserConfig, CONFIG_PATH } from '../utils/config';
+import { openInEditor } from '../utils/editor';
+import {
+  CONFIG_KEYS,
+  CONFIG_SCHEMA,
+  isConfigKey,
+  applyConfigSet,
+  applyConfigUnset,
+  reviewConfigFileText,
+  formatConfigValue,
+} from '../utils/config-schema';
+import { outputJson, outputJsonError } from '../utils/output';
+import { logSuccess, logError, logWarning } from '../utils/logger';
+import { colorize } from '../utils/colors';
+
+/**
+ * Non-interactive config management: `nemus config get/set/unset/list/path`.
+ * Complements the interactive `configure` wizard and is script-friendly —
+ * `get`/`list` write DATA to stdout (raw value, or JSON with --json), logs go to
+ * stderr. Values are validated/coerced against config-schema.ts.
+ */
+export function registerConfigCommand(parent: Command): void {
+  const config = parent.command('config').description('Get or set Nemus configuration');
+
+  config
+    .command('get')
+    .description('Print a config value (or all values with no key)')
+    .argument('[key]', 'Config key')
+    .option('--json', 'Output as JSON')
+    .action((key: string | undefined, opts: { json?: boolean }) => {
+      const cfg = getUserConfig();
+      if (key === undefined) {
+        printAll(cfg, opts.json);
+        return;
+      }
+      if (!isConfigKey(key)) {
+        if (opts.json) outputJsonError(`Unknown config key "${key}"`);
+        else logError(`Unknown config key "${key}". Run "nemus config list" to see valid keys.`);
+        process.exitCode = 1;
+        return;
+      }
+      const value = cfg[key];
+      if (opts.json) outputJson({ key, value });
+      else process.stdout.write(formatConfigValue(value) + '\n');
+    });
+
+  config
+    .command('set')
+    .description('Set a config value')
+    .argument('<key>', 'Config key')
+    .argument('<value>', 'New value')
+    .option('--json', 'Output as JSON')
+    .action((key: string, value: string, opts: { json?: boolean }) => {
+      const result = applyConfigSet(getUserConfig(), key, value);
+      if (!result.ok) {
+        if (opts.json) outputJsonError(result.error);
+        else logError(result.error);
+        process.exitCode = 1;
+        return;
+      }
+      saveUserConfig(result.next);
+      if (opts.json) outputJson({ ok: true, key, value: result.value });
+      else logSuccess(`Set ${colorize(key, 'cyan')} = ${formatConfigValue(result.value)}`);
+    });
+
+  config
+    .command('unset')
+    .description('Reset a config value to its default')
+    .argument('<key>', 'Config key')
+    .option('--json', 'Output as JSON')
+    .action((key: string, opts: { json?: boolean }) => {
+      const result = applyConfigUnset(getUserConfig(), key);
+      if (!result.ok) {
+        if (opts.json) outputJsonError(result.error);
+        else logError(result.error);
+        process.exitCode = 1;
+        return;
+      }
+      saveUserConfig(result.next);
+      if (opts.json) outputJson({ ok: true, key, value: result.value });
+      else logSuccess(`Reset ${colorize(key, 'cyan')} to default (${formatConfigValue(result.value)})`);
+    });
+
+  config
+    .command('list')
+    .alias('ls')
+    .description('List all config keys and current values')
+    .option('--json', 'Output as JSON')
+    .action((opts: { json?: boolean }) => printAll(getUserConfig(), opts.json));
+
+  config
+    .command('path')
+    .description('Print the path to the config file')
+    .action(() => {
+      process.stdout.write(CONFIG_PATH + '\n');
+    });
+
+  config
+    .command('edit')
+    .description('Open the config file in $EDITOR (or $VISUAL)')
+    .action(() => {
+      handleEdit();
+    });
+}
+
+function handleEdit(): void {
+  if (!process.stdout.isTTY) {
+    logError('`config edit` needs an interactive terminal. Use `config set <key> <value>` in scripts.');
+    process.exitCode = 1;
+    return;
+  }
+  // Seed the file with the fully-resolved config so there's something complete
+  // to edit on a first run (getUserConfig merges defaults + any overrides).
+  if (!fs.existsSync(CONFIG_PATH)) saveUserConfig(getUserConfig());
+
+  const result = openInEditor(CONFIG_PATH);
+  if (!result.ok) {
+    logError(result.error ?? `editor exited with code ${result.code}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  // Re-validate: a hand-edit can produce invalid JSON or invalid values, which
+  // getUserConfig would silently ignore (falling back to defaults). Surface that
+  // instead, using the SAME schema `config set` uses so both write paths agree.
+  const review = reviewConfigFileText(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+  if (review.parseError) {
+    logError(`${CONFIG_PATH} is not valid JSON after editing — changes are kept, but Nemus will use defaults until it parses.`);
+    process.exitCode = 1;
+    return;
+  }
+  if (review.notObject) {
+    logError(`${CONFIG_PATH} must contain a JSON object — changes are kept, but Nemus will use defaults until it does.`);
+    process.exitCode = 1;
+    return;
+  }
+  if (review.unknownKeys.length > 0) logWarning(`Ignoring unrecognized key(s): ${review.unknownKeys.join(', ')}`);
+  if (!review.ok) {
+    for (const e of review.invalid) logWarning(e);
+    logError('Some values are invalid and will fall back to their defaults until fixed.');
+    process.exitCode = 1;
+    return;
+  }
+  logSuccess('Config saved.');
+}
+
+function printAll(cfg: ReturnType<typeof getUserConfig>, json?: boolean): void {
+  if (json) {
+    const values: Record<string, unknown> = {};
+    for (const key of CONFIG_KEYS) values[key] = cfg[key];
+    outputJson({ path: CONFIG_PATH, values });
+    return;
+  }
+  const width = Math.max(...CONFIG_KEYS.map((k) => k.length));
+  console.log(colorize('Nemus configuration', 'bright') + colorize(`  (${CONFIG_PATH})`, 'dim'));
+  for (const key of CONFIG_KEYS) {
+    const val = formatConfigValue(cfg[key]);
+    const shown = val === '' ? colorize('(empty)', 'dim') : val;
+    console.log(`  ${key.padEnd(width)}  ${shown}  ${colorize(CONFIG_SCHEMA[key].describe, 'dim')}`);
+  }
+}