@nemus-cli/nemus 0.4.0 → 0.8.0

package/CHANGELOG.md

@@ -7,6 +7,50 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.8.0] - 2026-09-01
+
+### Added
+
+- **`nemus reflect history`** and **`nemus reflect show [id]`** to review saved
+  reports (under `~/.nemus/reflect/`) without re-running the judge. `show`
+  defaults to the latest, accepts an id or id-prefix, and supports
+  `--json` / `--markdown` / `--group-by`.
+- **`nemus reflect --group-by kind|priority`** (default `priority`) to control
+  how recommendations are grouped in both the human and Markdown output.
+
+## [0.7.0] - 2026-09-01
+
+### Added
+
+- **`nemus reflect --markdown`** — render the reflection report as clean,
+  severity-grouped Markdown to stdout (pipe into a file or an issue:
+  `nemus reflect --markdown > reflection.md`). Fenced example snippets are
+  escaped so they can't break out of their own code block.
+- The human `reflect` report now prints a **severity summary line**
+  (e.g. `2 high · 1 medium`).
+
+## [0.6.0] - 2026-09-01
+
+### Added
+
+- **`nemus config` command** for non-interactive configuration:
+  `config get [key]`, `set <key> <value>`, `unset <key>`, `list` (alias `ls`),
+  and `path`. Values are validated and coerced per field (booleans accept
+  `true/false/yes/no/on/off/1/0`; enums like `cloneProtocol` are checked), an
+  unknown key or invalid value exits non-zero with a clear message, and
+  `get`/`list` support `--json`. Complements the interactive `configure` wizard
+  and pairs well with `--quiet` for scripting.
+
+## [0.5.0] - 2026-09-01
+
+### Added
+
+- **`--no-color` and `-q, --quiet` global flags.** `--no-color` disables ANSI
+  color; Nemus also honors the standard [`NO_COLOR`](https://no-color.org) env
+  var, auto-disables color when stdout isn't a TTY, and respects `FORCE_COLOR=1`.
+  `--quiet` suppresses routine progress logs (info/success/step) while still
+  showing warnings and errors; data output (including `--json`) is unaffected.
+
 ## [0.4.0] - 2026-09-01
 
 ### Changed

package/README.md

@@ -243,6 +243,31 @@ The workspace-scoped ones (`status`/`doctor`/`analyze-deps`) need an explicit
 workspace name with `--json` (they never prompt). On failure, `--json` prints a
 parseable `{ "ok": false, "error": … }` to stdout and exits non-zero.
 
+### Configuration
+
+Run `nemus configure` for the interactive wizard, or manage settings
+non-interactively (handy for scripts and dotfiles):
+
+```bash
+nemus config list                     # all keys, values, and descriptions
+nemus config get cloneProtocol        # print one value (raw, for scripts)
+nemus config set cloneProtocol https  # validated + coerced per key
+nemus config set autoReportBugs yes   # booleans accept true/false/yes/no/on/off/1/0
+nemus config unset githubOrg          # reset a key to its default
+nemus config path                     # print the config file location
+```
+
+`get`/`list` also accept `--json`. An unknown key or an invalid value exits
+non-zero with a clear message (e.g. `cloneProtocol must be one of: ssh, https`).
+
+### Global flags
+
+- `--no-color` — disable ANSI color. Nemus also honors the standard
+  [`NO_COLOR`](https://no-color.org) env var and auto-disables color when stdout
+  isn't a TTY (piped/redirected); `FORCE_COLOR=1` forces it on.
+- `-q, --quiet` — suppress routine progress logs (info/success/step) while still
+  showing warnings and errors. Data (including `--json`) is unaffected.
+
 ### Shell completions
 
 Tab-complete subcommands and workspace names. `nemus completion <shell>` prints
@@ -286,9 +311,25 @@ nemus snapshot restore <id>   # (sr)
 nemus reflect                 # (retro) analyze your last 10 workspaces' sessions
 nemus reflect --limit 5       # narrow the window
 nemus reflect --json          # structured report for tooling
+nemus reflect --markdown      # Markdown report (grouped by severity) to paste/save
+nemus reflect --group-by kind # group recommendations by kind instead of priority
 nemus reflect --dry-run       # show what the judge sees, without calling the agent
 ```
 
+`--markdown` writes a clean, severity-grouped report to stdout — pipe it into a
+file or an issue: `nemus reflect --markdown > reflection.md`. `--group-by
+kind|priority` (default `priority`) controls how recommendations are grouped in
+both the human and Markdown output.
+
+Every run is saved under `~/.nemus/reflect/`. Review past reports without
+re-running the judge:
+
+```bash
+nemus reflect history            # list saved reports, newest first (--json)
+nemus reflect show               # print the latest saved report
+nemus reflect show <id>          # a specific one (--markdown / --json / --group-by)
+```
+
 `reflect` reads your recent agent **session transcripts** (Claude + pi), distills
 the prompts you sent, the failures the agent hit, and the tools it used, then asks
 **your own configured agent** (LLM-as-a-judge — no extra API key) to recommend
@@ -319,6 +360,20 @@ repos, create/update workspaces, check status, and more directly from a prompt.
 
 Run `nemus --help` for the full command reference.
 
+## Cloud (optional, self-hosted)
+
+Nemus is **local-first** — everything above runs entirely on your machine. If you
+want to hand a task to an agent that runs **headlessly on infrastructure you own**
+(local Docker, AWS Fargate, or any Kubernetes cluster) and opens a PR for you,
+there's an **optional, opt-in** package: [`@nemus-cli/cloud`](./packages/cloud).
+
+It's a separate, vendor-neutral package built from swappable seams — runners
+(`docker`, `aws-fargate`, `kubernetes`), IaC provisioners (OpenTofu/Terraform
+modules), git forges (GitHub/GitLab), a bounded CI-fix loop, and notifiers — with
+no cloud SDK in the core CLI. It is **not published to npm**; it lives in this
+repo for you to build and run yourself. See
+[`packages/cloud/README.md`](./packages/cloud/README.md) to get started.
+
 ## Configuration
 
 `nemus configure` writes `~/.nemus/config.json`. Environment

package/dist/commands/config.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerConfigCommand = registerConfigCommand;
+const config_1 = require("../utils/config");
+const config_schema_1 = require("../utils/config-schema");
+const output_1 = require("../utils/output");
+const logger_1 = require("../utils/logger");
+const colors_1 = require("../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.
+ */
+function registerConfigCommand(parent) {
+    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, opts) => {
+        const cfg = (0, config_1.getUserConfig)();
+        if (key === undefined) {
+            printAll(cfg, opts.json);
+            return;
+        }
+        if (!(0, config_schema_1.isConfigKey)(key)) {
+            if (opts.json)
+                (0, output_1.outputJsonError)(`Unknown config key "${key}"`);
+            else
+                (0, logger_1.logError)(`Unknown config key "${key}". Run "nemus config list" to see valid keys.`);
+            process.exitCode = 1;
+            return;
+        }
+        const value = cfg[key];
+        if (opts.json)
+            (0, output_1.outputJson)({ key, value });
+        else
+            process.stdout.write((0, config_schema_1.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, value, opts) => {
+        const result = (0, config_schema_1.applyConfigSet)((0, config_1.getUserConfig)(), key, value);
+        if (!result.ok) {
+            if (opts.json)
+                (0, output_1.outputJsonError)(result.error);
+            else
+                (0, logger_1.logError)(result.error);
+            process.exitCode = 1;
+            return;
+        }
+        (0, config_1.saveUserConfig)(result.next);
+        if (opts.json)
+            (0, output_1.outputJson)({ ok: true, key, value: result.value });
+        else
+            (0, logger_1.logSuccess)(`Set ${(0, colors_1.colorize)(key, 'cyan')} = ${(0, config_schema_1.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, opts) => {
+        const result = (0, config_schema_1.applyConfigUnset)((0, config_1.getUserConfig)(), key);
+        if (!result.ok) {
+            if (opts.json)
+                (0, output_1.outputJsonError)(result.error);
+            else
+                (0, logger_1.logError)(result.error);
+            process.exitCode = 1;
+            return;
+        }
+        (0, config_1.saveUserConfig)(result.next);
+        if (opts.json)
+            (0, output_1.outputJson)({ ok: true, key, value: result.value });
+        else
+            (0, logger_1.logSuccess)(`Reset ${(0, colors_1.colorize)(key, 'cyan')} to default (${(0, config_schema_1.formatConfigValue)(result.value)})`);
+    });
+    config
+        .command('list')
+        .alias('ls')
+        .description('List all config keys and current values')
+        .option('--json', 'Output as JSON')
+        .action((opts) => printAll((0, config_1.getUserConfig)(), opts.json));
+    config
+        .command('path')
+        .description('Print the path to the config file')
+        .action(() => {
+        process.stdout.write(config_1.CONFIG_PATH + '\n');
+    });
+}
+function printAll(cfg, json) {
+    if (json) {
+        const values = {};
+        for (const key of config_schema_1.CONFIG_KEYS)
+            values[key] = cfg[key];
+        (0, output_1.outputJson)({ path: config_1.CONFIG_PATH, values });
+        return;
+    }
+    const width = Math.max(...config_schema_1.CONFIG_KEYS.map((k) => k.length));
+    console.log((0, colors_1.colorize)('Nemus configuration', 'bright') + (0, colors_1.colorize)(`  (${config_1.CONFIG_PATH})`, 'dim'));
+    for (const key of config_schema_1.CONFIG_KEYS) {
+        const val = (0, config_schema_1.formatConfigValue)(cfg[key]);
+        const shown = val === '' ? (0, colors_1.colorize)('(empty)', 'dim') : val;
+        console.log(`  ${key.padEnd(width)}  ${shown}  ${(0, colors_1.colorize)(config_schema_1.CONFIG_SCHEMA[key].describe, 'dim')}`);
+    }
+}

package/dist/commands/reflect.js

@@ -11,22 +11,55 @@ function registerReflectCommand(parent) {
     parent
         .command('reflect')
         .alias('retro')
-        .description('Analyze your recent workspace sessions and suggest skill/prompt/context improvements (LLM-as-a-judge)')
+        .description('Analyze recent sessions for improvements, or review saved reports ("history"/"show")')
+        .argument('[subcommand]', '"history" or "show" — omit to run a new analysis')
+        .argument('[id]', 'report id when using "show" (default: latest)')
         .option('-n, --limit <n>', 'How many recent workspaces to analyze', '10')
         .option('-w, --workspace <name>', 'Analyze a single workspace by name (ignores --limit)')
         .option('--model <model>', 'Judge model override (agent-native pattern/id)')
         .option('--thinking <level>', 'Judge thinking level for pi: off|minimal|low|medium|high|xhigh|max')
         .option('--json', 'Output the report as JSON')
+        .option('--markdown', 'Output the report as Markdown (paste into an issue/PR)')
+        .option('--group-by <how>', 'Group recommendations by: priority | kind', 'priority')
         .option('--no-save', 'Do not save the report to ~/.nemus/reflect/')
         .option('--dry-run', 'Print the assembled corpus + judge prompt without calling the agent')
-        .action(async (opts) => {
-        await handleReflect(opts);
+        .addHelpText('after', '\nSaved reports:\n  nemus reflect history            List saved reports (newest first)\n  nemus reflect show [id]          Print a saved report (default: latest)\n')
+        // history/show are positional (not commander subcommands) on purpose: as
+        // subcommands they would share --json/--markdown/--group-by with this parent
+        // command, and the only commander fix (enablePositionalOptions on the root)
+        // breaks global flags placed after a subcommand (e.g. `nemus list --quiet`).
+        .action(async (subcommand, id, opts) => {
+        if (subcommand === 'history')
+            return handleHistory(opts);
+        if (subcommand === 'show')
+            return handleShow(id, opts);
+        if (subcommand !== undefined) {
+            const msg = `Unknown reflect subcommand "${subcommand}" (expected "history" or "show").`;
+            if (opts.json)
+                (0, output_1.outputJsonError)(msg);
+            else
+                (0, logger_1.logError)(msg);
+            process.exit(1);
+        }
+        return handleReflect(opts);
     });
 }
+/** Validate --group-by; returns the value or exits non-zero with a clear error. */
+function resolveGroupBy(raw, json) {
+    if (raw === undefined || raw === 'priority' || raw === 'kind')
+        return (raw ?? 'priority');
+    const msg = `--group-by must be "priority" or "kind"; got "${raw}"`;
+    if (json)
+        (0, output_1.outputJsonError)(msg);
+    else
+        (0, logger_1.logError)(msg);
+    process.exit(1);
+}
 async function handleReflect(opts) {
     const limit = Math.max(1, Number.parseInt(opts.limit ?? '10', 10) || 10);
+    const groupBy = resolveGroupBy(opts.groupBy, opts.json);
     try {
-        const showProgress = !opts.json && !opts.dryRun;
+        const showProgress = !opts.json && !opts.markdown && !opts.dryRun;
         if (showProgress) {
             (0, logger_1.logStep)(opts.workspace
                 ? `Analyzing workspace ${(0, colors_1.colorize)(opts.workspace, 'cyan')}…`
@@ -66,7 +99,7 @@ async function handleReflect(opts) {
         const timeoutMs = Number.parseInt(process.env.NEMUS_JUDGE_TIMEOUT_MS ?? '', 10) || undefined;
         const model = opts.model ?? process.env.NEMUS_JUDGE_MODEL ?? undefined;
         const thinking = opts.thinking ?? process.env.NEMUS_JUDGE_THINKING ?? undefined;
-        const stopSpinner = opts.json
+        const stopSpinner = opts.json || opts.markdown
             ? () => { }
             : startSpinner(`Judging ${withSessions} session(s) with your configured agent (this can take a minute)…`);
         let parsed;
@@ -95,7 +128,20 @@ async function handleReflect(opts) {
             (0, output_1.outputJson)({ analyzed: withSessions, workspaces: corpus.workspaces.length, ...report, savedTo });
             return;
         }
-        printReport(report, corpus.workspaces.length, withSessions);
+        if (opts.markdown) {
+            // DATA channel: markdown to stdout, nothing else (a 'Saved report' note
+            // would corrupt a redirected .md file), so surface the path on stderr.
+            process.stdout.write((0, reflect_1.renderReportMarkdown)(report, {
+                analyzed: withSessions,
+                workspaces: corpus.workspaces.length,
+                workspace: opts.workspace,
+                generatedAt: new Date().toISOString(),
+            }, groupBy));
+            if (savedTo)
+                (0, logger_1.logInfo)(`Saved report to ${(0, colors_1.colorize)(savedTo, 'dim')}`);
+            return;
+        }
+        printReport(report, corpus.workspaces.length, withSessions, groupBy);
         if (savedTo)
             (0, logger_1.logInfo)(`Saved report to ${(0, colors_1.colorize)(savedTo, 'dim')}`);
     }
@@ -164,7 +210,7 @@ function priorityBadge(p) {
         return (0, colors_1.colorize)('● med', 'yellow');
     return (0, colors_1.colorize)('● low', 'gray');
 }
-function printReport(report, workspaces, analyzed) {
+function printReport(report, workspaces, analyzed, groupBy = 'priority') {
     console.log('');
     console.log((0, colors_1.colorize)('  Reflection', 'bright') + (0, colors_1.colorize)(`  (${analyzed} sessions across ${workspaces} workspaces)`, 'dim'));
     console.log((0, colors_1.colorize)('  ' + '─'.repeat(56), 'dim'));
@@ -175,19 +221,94 @@ function printReport(report, workspaces, analyzed) {
         console.log('\n  ' + (0, colors_1.colorize)('No specific recommendations — looks solid.', 'green') + '\n');
         return;
     }
-    // High priority first.
-    const order = { high: 0, medium: 1, low: 2 };
-    const recs = [...report.recommendations].sort((a, b) => order[a.priority] - order[b.priority]);
-    console.log('');
-    for (const r of recs) {
-        const target = r.target ? (0, colors_1.colorize)(`  [${r.target}]`, 'cyan') : '';
-        console.log(`  ${priorityBadge(r.priority)}  ${(0, colors_1.colorize)(KIND_LABEL[r.kind], 'bright')}  ${r.title}${target}`);
-        if (r.detail)
-            console.log(`      ${r.detail.replace(/\n/g, '\n      ')}`);
-        if (r.example) {
-            console.log((0, colors_1.colorize)('      example:', 'dim'));
-            console.log((0, colors_1.colorize)(r.example.replace(/^/gm, '        '), 'dim'));
+    console.log('\n  ' + (0, colors_1.colorize)((0, reflect_1.severitySummary)(report.recommendations), 'dim'));
+    for (const group of (0, reflect_1.groupRecommendations)(report.recommendations, groupBy)) {
+        console.log('\n  ' + (0, colors_1.colorize)(group.heading, 'bright'));
+        for (const r of group.recs) {
+            const target = r.target ? (0, colors_1.colorize)(`  [${r.target}]`, 'cyan') : '';
+            // Under a kind heading show the priority badge; under a priority heading
+            // show the kind label (the heading conveys the other axis).
+            const lead = groupBy === 'kind' ? priorityBadge(r.priority) : (0, colors_1.colorize)(KIND_LABEL[r.kind], 'bright');
+            console.log(`    ${lead}  ${r.title}${target}`);
+            if (r.detail)
+                console.log(`      ${r.detail.replace(/\n/g, '\n      ')}`);
+            if (r.example) {
+                console.log((0, colors_1.colorize)('      example:', 'dim'));
+                console.log((0, colors_1.colorize)(r.example.replace(/^/gm, '        '), 'dim'));
+            }
         }
-        console.log('');
     }
+    console.log('');
+}
+async function handleHistory(opts) {
+    const reports = await (0, reflect_1.listSavedReports)();
+    if (opts.json) {
+        (0, output_1.outputJson)({
+            count: reports.length,
+            reports: reports.map((r) => ({
+                id: r.id,
+                generatedAt: r.generatedAt,
+                analyzed: r.analyzed,
+                workspaces: r.workspaces,
+                workspace: r.workspace,
+                recommendations: r.report.recommendations.length,
+                severity: (0, reflect_1.severitySummary)(r.report.recommendations),
+            })),
+        });
+        return;
+    }
+    if (reports.length === 0) {
+        (0, logger_1.logInfo)('No saved reflection reports yet. Run `nemus reflect` to create one.');
+        return;
+    }
+    console.log('');
+    console.log((0, colors_1.colorize)('  Saved reflections', 'bright') + (0, colors_1.colorize)(`  (${reports.length})`, 'dim'));
+    console.log((0, colors_1.colorize)('  ' + '─'.repeat(56), 'dim'));
+    for (const r of reports) {
+        const when = r.generatedAt ? new Date(r.generatedAt).toLocaleString() : r.id;
+        const scope = r.workspace ? (0, colors_1.colorize)(` ${r.workspace}`, 'cyan') : (0, colors_1.colorize)(` ${r.analyzed} sessions`, 'dim');
+        const sev = r.report.recommendations.length
+            ? (0, colors_1.colorize)(`  ${(0, reflect_1.severitySummary)(r.report.recommendations)}`, 'dim')
+            : (0, colors_1.colorize)('  no recs', 'green');
+        console.log(`  ${(0, colors_1.colorize)(r.id, 'bright')}${scope}${sev}`);
+        console.log((0, colors_1.colorize)(`     ${when}`, 'dim'));
+    }
+    console.log('');
+    console.log((0, colors_1.colorize)('  nemus reflect show <id>   (or `latest`)', 'dim'));
+}
+async function handleShow(id, opts) {
+    const groupBy = resolveGroupBy(opts.groupBy, opts.json);
+    const matches = (0, reflect_1.findSavedMatches)(await (0, reflect_1.listSavedReports)(), id);
+    const saved = matches[0];
+    if (!saved) {
+        const msg = id && id !== 'latest'
+            ? `No saved report matching "${id}". Run "nemus reflect history" to list them.`
+            : 'No saved reflection reports yet. Run "nemus reflect" to create one.';
+        if (opts.json)
+            (0, output_1.outputJsonError)(msg);
+        else
+            (0, logger_1.logError)(msg);
+        process.exit(1);
+    }
+    // An id-prefix that matches several reports resolves to the newest — say so
+    // (stderr only, so --json/--markdown stdout stays clean) rather than quietly
+    // showing a possibly-unintended report. An exact id / "latest" never multi-matches.
+    if (matches.length > 1 && !opts.json) {
+        (0, logger_1.logWarning)(`"${id}" matched ${matches.length} reports; showing the newest (${saved.id}). Use a longer id to disambiguate.`);
+    }
+    const meta = {
+        analyzed: saved.analyzed,
+        workspaces: saved.workspaces,
+        workspace: saved.workspace,
+        generatedAt: saved.generatedAt,
+    };
+    if (opts.json) {
+        (0, output_1.outputJson)({ id: saved.id, ...meta, ...saved.report });
+        return;
+    }
+    if (opts.markdown) {
+        process.stdout.write((0, reflect_1.renderReportMarkdown)(saved.report, meta, groupBy));
+        return;
+    }
+    printReport(saved.report, saved.workspaces, saved.analyzed, groupBy);
 }

package/dist/program.js

@@ -38,24 +38,18 @@ const commander_1 = require("commander");
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
 const colors_1 = require("./utils/colors");
+const banner_1 = require("./utils/banner");
+const global_flags_1 = require("./utils/global-flags");
 // Read version from package.json
 const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf-8'));
-const g = colors_1.colors.green;
-const d = colors_1.colors.dim;
-const b = colors_1.colors.bright;
-const r = colors_1.colors.reset;
-const INNER = 38;
-const titleLine = `>_  Nemus`;
-const titlePad = ' '.repeat(Math.max(0, INNER - 2 - titleLine.length));
-const versionLine = `v${pkg.version} · multi-repo workspaces`;
-const versionPad = ' '.repeat(Math.max(0, INNER - 7 - versionLine.length));
-const bar = '─'.repeat(INNER);
-const bannerText = `
-${d}    ╭${bar}╮${r}
-${d}    │${r}  ${g}>_${r}  ${b}Nemus${r}${titlePad}${d}│${r}
-${d}    │${r}       ${d}${versionLine}${r}${versionPad}${d}│${r}
-${d}    ╰${bar}╯${r}
-`;
+// --no-color must be applied BEFORE commander parses so it reaches the help
+// banner (a preAction hook is too late for help output, and ES imports run
+// before hooks). It's a long flag, so it can't be bundled — an argv scan is
+// sufficient here. colors.ts already applied NO_COLOR / non-TTY at import.
+// --quiet is handled in the preAction hook below (it only affects command
+// logs, never help), which also catches bundled short forms like `-yq`.
+if (process.argv.includes('--no-color'))
+    (0, colors_1.setColorEnabled)(false);
 exports.program = new commander_1.Command();
 exports.program
     .name('workspace')
@@ -63,7 +57,14 @@ exports.program
     .version(pkg.version, '-V, --version')
     .option('-f, --force-refresh', 'Force refresh GitHub repos (skip cache)')
     .option('-y, --yes', 'Skip confirmations')
-    .addHelpText('before', bannerText);
+    .option('--no-color', 'Disable colored output (also honors NO_COLOR)')
+    .option('-q, --quiet', 'Suppress progress logs (keep warnings + errors)')
+    .addHelpText('before', () => (0, banner_1.renderHelpBanner)(pkg.version));
+// Apply global --quiet / --color from commander's PARSED options (robust to
+// bundled short flags like `-yq` that a raw argv scan misses). Runs before every
+// command action; help output doesn't reach here, which is why --no-color is
+// also pre-scanned above.
+exports.program.hook('preAction', () => (0, global_flags_1.applyGlobalFlags)(exports.program.opts()));
 // Register top-level commands
 const create_1 = require("./commands/create");
 const list_1 = require("./commands/list");
@@ -83,6 +84,7 @@ const archive_1 = require("./commands/archive");
 const sessions_1 = require("./commands/sessions");
 const generate_docs_1 = require("./commands/generate-docs");
 const configure_1 = require("./commands/configure");
+const config_1 = require("./commands/config");
 const configure_claude_1 = require("./commands/configure-claude");
 const ghq_status_1 = require("./commands/ghq-status");
 const save_context_1 = require("./commands/save-context");
@@ -108,6 +110,7 @@ const reflect_1 = require("./commands/reflect");
 (0, sessions_1.registerSessionsCommand)(exports.program);
 (0, generate_docs_1.registerGenerateDocsCommand)(exports.program);
 (0, configure_1.registerConfigureCommand)(exports.program);
+(0, config_1.registerConfigCommand)(exports.program);
 (0, configure_claude_1.registerConfigureClaudeCommand)(exports.program);
 (0, ghq_status_1.registerGhqStatusCommand)(exports.program);
 (0, save_context_1.registerSaveContextCommand)(exports.program);

package/dist/utils/banner.js

@@ -1,24 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.printBanner = exports.BANNER_PLAIN = exports.BANNER = void 0;
+exports.renderHelpBanner = exports.printBanner = exports.renderBanner = exports.BANNER_PLAIN = void 0;
 const colors_1 = require("./colors");
-const g = colors_1.colors.green;
-const d = colors_1.colors.dim;
-const b = colors_1.colors.bright;
-const r = colors_1.colors.reset;
-exports.BANNER = `
-${d}    ╭──────────────────────────────────────╮${r}
-${d}    │${r}  ${g}>_${r}  ${b}Nemus${r}                           ${d}│${r}
-${d}    │${r}       ${d}multi-repo workspaces${r}          ${d}│${r}
-${d}    ╰──────────────────────────────────────╯${r}
-`;
 exports.BANNER_PLAIN = `
     ╭──────────────────────────────────────╮
     │  >_  Nemus                           │
     │       multi-repo workspaces          │
     ╰──────────────────────────────────────╯
 `;
+// Rendered live (not captured at import) so --no-color / NO_COLOR applied before
+// this is called produce a plain banner. With color off, every colors.* is ''.
+const renderBanner = () => {
+    const { green: g, dim: d, bright: b, reset: r } = colors_1.colors;
+    return `
+${d}    ╭──────────────────────────────────────╮${r}
+${d}    │${r}  ${g}>_${r}  ${b}Nemus${r}                           ${d}│${r}
+${d}    │${r}       ${d}multi-repo workspaces${r}          ${d}│${r}
+${d}    ╰──────────────────────────────────────╯${r}
+`;
+};
+exports.renderBanner = renderBanner;
 const printBanner = () => {
-    console.log(exports.BANNER);
+    console.log((0, exports.renderBanner)());
 };
 exports.printBanner = printBanner;
+// The `--help` banner: a boxed splash with the version + tagline, width-fitted.
+// Lives here alongside renderBanner() so the two renderers don't drift; also
+// rendered live so --no-color / NO_COLOR yields a plain box.
+const renderHelpBanner = (version) => {
+    const { green: g, dim: d, bright: b, reset: r } = colors_1.colors;
+    const INNER = 38;
+    const titleLine = `>_  Nemus`;
+    const titlePad = ' '.repeat(Math.max(0, INNER - 2 - titleLine.length));
+    const versionLine = `v${version} · multi-repo workspaces`;
+    const versionPad = ' '.repeat(Math.max(0, INNER - 7 - versionLine.length));
+    const bar = '─'.repeat(INNER);
+    return `
+${d}    ╭${bar}╮${r}
+${d}    │${r}  ${g}>_${r}  ${b}Nemus${r}${titlePad}${d}│${r}
+${d}    │${r}       ${d}${versionLine}${r}${versionPad}${d}│${r}
+${d}    ╰${bar}╯${r}
+`;
+};
+exports.renderHelpBanner = renderHelpBanner;

package/dist/utils/colors.js

@@ -1,7 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.colorize = exports.colors = void 0;
-exports.colors = {
+exports.colorize = exports.isColorEnabled = exports.colors = void 0;
+exports.setColorEnabled = setColorEnabled;
+exports.detectColorEnabled = detectColorEnabled;
+// ANSI escape codes. `colors` starts as a copy of these but is emptied in place
+// when color is disabled (--no-color / NO_COLOR / non-TTY), so BOTH `colorize()`
+// and inline `colors.x` template usage go plain without touching call sites.
+const ANSI = {
     reset: '\x1b[0m',
     bright: '\x1b[1m',
     dim: '\x1b[2m',
@@ -20,7 +25,43 @@ exports.colors = {
     bgYellow: '\x1b[43m',
     bgBlue: '\x1b[44m',
 };
+// Live map read at every use. Mutated in place by setColorEnabled so previously
+// imported references (e.g. `colors.gray` inside a template) see the change.
+exports.colors = { ...ANSI };
+let enabled = true;
+/** Whether colored output is currently on. */
+const isColorEnabled = () => enabled;
+exports.isColorEnabled = isColorEnabled;
+/** Turn color on/off. When off, every `colors.*` code becomes '' so output is
+ *  plain; when on, the ANSI codes are restored. */
+function setColorEnabled(on) {
+    enabled = on;
+    for (const key of Object.keys(ANSI)) {
+        exports.colors[key] = on ? ANSI[key] : '';
+    }
+}
+/**
+ * Decide whether to use color by default, following the common conventions:
+ * - `NO_COLOR` (any value, even empty) disables — see https://no-color.org
+ * - `FORCE_COLOR` (and not "0"/"false") forces it on, even when not a TTY
+ * - otherwise on only when the stdout stream is a TTY and `TERM` isn't `dumb`
+ */
+function detectColorEnabled(env = process.env, isTTY = !!process.stdout.isTTY) {
+    if ('NO_COLOR' in env)
+        return false;
+    const force = env.FORCE_COLOR;
+    if (force !== undefined && force !== '' && force !== '0' && force.toLowerCase() !== 'false') {
+        return true;
+    }
+    if (env.TERM === 'dumb')
+        return false;
+    return isTTY;
+}
 const colorize = (text, color) => {
     return `${exports.colors[color]}${text}${exports.colors.reset}`;
 };
 exports.colorize = colorize;
+// Apply the environment default at import time so NO_COLOR / a non-TTY pipe is
+// respected even before any CLI flag is parsed (an explicit --no-color / --color
+// flag overrides this later).
+setColorEnabled(detectColorEnabled());