@nemus-cli/nemus 0.4.0 → 0.8.0

package/dist/utils/config-schema.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG_KEYS = exports.CONFIG_SCHEMA = void 0;
+exports.isConfigKey = isConfigKey;
+exports.parseConfigValue = parseConfigValue;
+exports.applyConfigSet = applyConfigSet;
+exports.applyConfigUnset = applyConfigUnset;
+exports.formatConfigValue = formatConfigValue;
+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 };
+}
+/** 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 ?? '');
+}

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/global-flags.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyGlobalFlags = applyGlobalFlags;
+const colors_1 = require("./colors");
+const logger_1 = require("./logger");
+/**
+ * Apply parsed global flags to process-wide state. Kept pure over injected
+ * setters so it's testable without commander — the `preAction` hook in
+ * program.ts is a one-line call into this. Only ever turns features OFF here:
+ * color defaults on (and env/TTY detection already ran at import), so we act
+ * solely on an explicit `--no-color` (`color === false`).
+ */
+function applyGlobalFlags(opts, deps = {
+    setColorEnabled: colors_1.setColorEnabled,
+    setQuiet: logger_1.setQuiet,
+}) {
+    if (opts.color === false)
+        deps.setColorEnabled(false);
+    if (opts.quiet)
+        deps.setQuiet(true);
+}

package/dist/utils/logger.js

@@ -1,11 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.logStep = exports.logWarning = exports.logError = exports.logSuccess = exports.logInfo = void 0;
+exports.logStep = exports.logWarning = exports.logError = exports.logSuccess = exports.logInfo = exports.isQuiet = exports.setQuiet = void 0;
 const colors_1 = require("./colors");
 // Diagnostics (info/success/error/warn/step) go to STDERR so stdout carries only
 // a command's actual data — required for clean `--json` piping (nemus list
 // --json | jq …) and for non-TTY consumers. Use `outputJson`/stdout for data.
 const logStream = (line) => console.error(line);
+// `--quiet` silences routine progress (info/success/step) while KEEPING warnings
+// and errors, which a script or human still needs to see.
+let quiet = false;
+const setQuiet = (on) => {
+    quiet = on;
+};
+exports.setQuiet = setQuiet;
+const isQuiet = () => quiet;
+exports.isQuiet = isQuiet;
 const getTimestamp = () => {
     const now = new Date();
     return now.toLocaleTimeString('en-US', {
@@ -16,10 +25,14 @@ const getTimestamp = () => {
     });
 };
 const logInfo = (message) => {
+    if (quiet)
+        return;
     logStream(`${colors_1.colors.gray}[${getTimestamp()}]${colors_1.colors.reset} ${message}`);
 };
 exports.logInfo = logInfo;
 const logSuccess = (message) => {
+    if (quiet)
+        return;
     logStream(`${colors_1.colors.gray}[${getTimestamp()}]${colors_1.colors.reset} ${(0, colors_1.colorize)('✓', 'green')} ${message}`);
 };
 exports.logSuccess = logSuccess;
@@ -32,6 +45,8 @@ const logWarning = (message) => {
 };
 exports.logWarning = logWarning;
 const logStep = (stepOrMessage, total, message) => {
+    if (quiet)
+        return;
     if (typeof stepOrMessage === 'string') {
         // Single parameter version: just a message
         logStream(`${colors_1.colors.gray}[${getTimestamp()}]${colors_1.colors.reset} ${(0, colors_1.colorize)('▸', 'cyan')} ${stepOrMessage}`);

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.4.0",
+  "version": "0.8.0",
   "workspaces": [
     "packages/*"
   ],

package/src/commands/config.ts

@@ -0,0 +1,112 @@
+import { Command } from 'commander';
+import { getUserConfig, saveUserConfig, CONFIG_PATH } from '../utils/config';
+import {
+  CONFIG_KEYS,
+  CONFIG_SCHEMA,
+  isConfigKey,
+  applyConfigSet,
+  applyConfigUnset,
+  formatConfigValue,
+} from '../utils/config-schema';
+import { outputJson, outputJsonError } from '../utils/output';
+import { logSuccess, logError } 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');
+    });
+}
+
+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')}`);
+  }
+}