@massu/core 0.9.2 → 1.1.0

package/src/commands/config-refresh.ts

@@ -0,0 +1,224 @@
+// Copyright (c) 2026 Massu. All rights reserved.
+// Licensed under BSL 1.1 - see LICENSE file for details.
+
+/**
+ * `massu config refresh` — re-run detection, diff against current config, apply
+ * or print-only (--dry-run).
+ *
+ * Merge semantics:
+ *   - Detector-owned keys (framework, paths.source, verification, detection) are REFRESHED.
+ *   - User-authored keys (rules, domains, canonical_paths, accessScopes,
+ *     knownMismatches, dbAccessPattern, analytics, governance, security, team,
+ *     regression, cloud, conventions, autoLearning, verification_types,
+ *     python) are PRESERVED verbatim from the existing config.
+ *
+ * Flags:
+ *   --dry-run    Emit the diff to stdout, exit 0, never write.
+ *   (none)       Interactive: show diff, prompt for confirmation via @clack/prompts.
+ *                When stdin is not a TTY, behaves as --dry-run with a note.
+ *
+ * Exit codes:
+ *   0  success (applied, or dry-run completed)
+ *   1  missing massu.config.yaml (run `massu init`)
+ *   2  unparseable massu.config.yaml
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { resolve } from 'path';
+import { parse as parseYaml } from 'yaml';
+import { runDetection } from '../detect/index.ts';
+import { computeFingerprint } from '../detect/drift.ts';
+import type { AnyConfig } from '../detect/migrate.ts';
+import { buildConfigFromDetection, renderConfigYaml, writeConfigAtomic } from './init.ts';
+
+const PRESERVED_FIELDS = [
+  'rules',
+  'domains',
+  'canonical_paths',
+  'verification_types',
+  'accessScopes',
+  'knownMismatches',
+  'dbAccessPattern',
+  'analytics',
+  'governance',
+  'security',
+  'team',
+  'regression',
+  'cloud',
+  'conventions',
+  'autoLearning',
+  'python',
+] as const;
+
+export interface ConfigRefreshOptions {
+  dryRun?: boolean;
+  cwd?: string;
+  silent?: boolean;
+}
+
+export interface ConfigRefreshResult {
+  exitCode: 0 | 1 | 2;
+  applied: boolean;
+  dryRun: boolean;
+  diff: DiffLine[];
+  message?: string;
+}
+
+export interface DiffLine {
+  kind: 'add' | 'remove' | 'change' | 'same';
+  path: string;
+  before?: unknown;
+  after?: unknown;
+}
+
+function flatten(obj: unknown, prefix = ''): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  if (obj === null || obj === undefined) {
+    out[prefix || '<root>'] = obj;
+    return out;
+  }
+  if (typeof obj !== 'object' || Array.isArray(obj)) {
+    out[prefix || '<root>'] = obj;
+    return out;
+  }
+  const rec = obj as Record<string, unknown>;
+  for (const [k, v] of Object.entries(rec)) {
+    const p = prefix ? `${prefix}.${k}` : k;
+    if (v !== null && typeof v === 'object' && !Array.isArray(v)) {
+      Object.assign(out, flatten(v, p));
+    } else {
+      out[p] = v;
+    }
+  }
+  return out;
+}
+
+export function computeDiff(before: AnyConfig, after: AnyConfig): DiffLine[] {
+  const b = flatten(before);
+  const a = flatten(after);
+  const keys = new Set<string>([...Object.keys(b), ...Object.keys(a)]);
+  const sorted = [...keys].sort();
+  const lines: DiffLine[] = [];
+  for (const k of sorted) {
+    const bVal = b[k];
+    const aVal = a[k];
+    const bHas = k in b;
+    const aHas = k in a;
+    if (bHas && !aHas) {
+      lines.push({ kind: 'remove', path: k, before: bVal });
+    } else if (!bHas && aHas) {
+      lines.push({ kind: 'add', path: k, after: aVal });
+    } else if (JSON.stringify(bVal) !== JSON.stringify(aVal)) {
+      lines.push({ kind: 'change', path: k, before: bVal, after: aVal });
+    }
+  }
+  return lines;
+}
+
+export function mergeRefresh(existing: AnyConfig, refreshed: AnyConfig): AnyConfig {
+  const out: AnyConfig = { ...refreshed };
+  for (const field of PRESERVED_FIELDS) {
+    if (existing[field] !== undefined) {
+      out[field] = existing[field];
+    }
+  }
+  return out;
+}
+
+function renderDiff(diff: DiffLine[]): string {
+  if (diff.length === 0) return '(no changes)\n';
+  const lines: string[] = [];
+  for (const d of diff) {
+    if (d.kind === 'add') lines.push(`+ ${d.path}: ${JSON.stringify(d.after)}`);
+    else if (d.kind === 'remove') lines.push(`- ${d.path}: ${JSON.stringify(d.before)}`);
+    else if (d.kind === 'change') {
+      lines.push(`~ ${d.path}: ${JSON.stringify(d.before)} -> ${JSON.stringify(d.after)}`);
+    }
+  }
+  return lines.join('\n') + '\n';
+}
+
+export async function runConfigRefresh(opts: ConfigRefreshOptions = {}): Promise<ConfigRefreshResult> {
+  const cwd = opts.cwd ?? process.cwd();
+  const configPath = resolve(cwd, 'massu.config.yaml');
+  const log = opts.silent ? () => {} : (s: string) => process.stdout.write(s);
+
+  if (!existsSync(configPath)) {
+    const message = 'massu.config.yaml not found. Run: npx massu init';
+    if (!opts.silent) process.stderr.write(message + '\n');
+    return { exitCode: 1, applied: false, dryRun: !!opts.dryRun, diff: [], message };
+  }
+
+  let existing: AnyConfig;
+  try {
+    const content = readFileSync(configPath, 'utf-8');
+    const parsed = parseYaml(content);
+    if (!parsed || typeof parsed !== 'object') {
+      throw new Error('config is not a YAML object');
+    }
+    existing = parsed as AnyConfig;
+  } catch (err) {
+    const message = `Failed to parse massu.config.yaml: ${err instanceof Error ? err.message : String(err)}`;
+    if (!opts.silent) process.stderr.write(message + '\n');
+    return { exitCode: 2, applied: false, dryRun: !!opts.dryRun, diff: [], message };
+  }
+
+  const detection = await runDetection(cwd);
+  const refreshed = buildConfigFromDetection({
+    projectRoot: cwd,
+    detection,
+    projectName: typeof (existing.project as Record<string, unknown> | undefined)?.name === 'string'
+      ? (existing.project as Record<string, unknown>).name as string
+      : undefined,
+  });
+  // buildConfigFromDetection already stamps detection.fingerprint. Double-check.
+  if (!(refreshed.detection as Record<string, unknown> | undefined)?.fingerprint) {
+    refreshed.detection = { fingerprint: computeFingerprint(detection) };
+  }
+
+  const merged = mergeRefresh(existing, refreshed);
+  const diff = computeDiff(existing, merged);
+
+  if (opts.dryRun) {
+    log('Config diff (dry-run; no changes written):\n');
+    log(renderDiff(diff));
+    return { exitCode: 0, applied: false, dryRun: true, diff };
+  }
+
+  if (diff.length === 0) {
+    log('No changes needed — config is already up to date.\n');
+    return { exitCode: 0, applied: false, dryRun: false, diff };
+  }
+
+  // Interactive prompt; fall back to dry-run semantics when not a TTY.
+  if (!process.stdin.isTTY) {
+    log('Config diff (non-interactive; pass --dry-run to suppress this note or run interactively to apply):\n');
+    log(renderDiff(diff));
+    return {
+      exitCode: 0,
+      applied: false,
+      dryRun: false,
+      diff,
+      message: 'non-interactive shell; no changes written',
+    };
+  }
+
+  log('Config diff:\n');
+  log(renderDiff(diff));
+  const { confirm } = await import('@clack/prompts');
+  const apply = await confirm({ message: 'Apply these changes to massu.config.yaml?' });
+  if (apply !== true) {
+    log('Aborted; no changes written.\n');
+    return { exitCode: 0, applied: false, dryRun: false, diff, message: 'aborted by user' };
+  }
+
+  const yamlContent = renderConfigYaml(merged);
+  const writeRes = writeConfigAtomic(configPath, yamlContent);
+  if (!writeRes.validated) {
+    const message = `Failed to write config: ${writeRes.error}`;
+    if (!opts.silent) process.stderr.write(message + '\n');
+    return { exitCode: 2, applied: false, dryRun: false, diff, message };
+  }
+  log('Config refreshed.\n');
+  return { exitCode: 0, applied: true, dryRun: false, diff };
+}

package/src/commands/config-upgrade.ts

@@ -0,0 +1,126 @@
+// Copyright (c) 2026 Massu. All rights reserved.
+// Licensed under BSL 1.1 - see LICENSE file for details.
+
+/**
+ * `massu config upgrade` — migrate a v1 `massu.config.yaml` to schema_version=2.
+ *
+ * Flags:
+ *   --rollback    Restore massu.config.yaml from massu.config.yaml.bak.
+ *   --ci / --yes  Non-interactive; no prompts; detector wins on conflicts.
+ *
+ * Safety:
+ *   - Writes .bak of the original before overwriting.
+ *   - Atomic write via writeConfigAtomic (tmp + rename).
+ *   - Idempotent: running on a schema_version=2 config is a no-op.
+ *
+ * Exit codes:
+ *   0  success (migrated, rolled back, or already current)
+ *   1  config missing / rollback source missing
+ *   2  parse or write failure
+ */
+
+import { existsSync, readFileSync, writeFileSync, copyFileSync, unlinkSync } from 'fs';
+import { resolve } from 'path';
+import { parse as parseYaml } from 'yaml';
+import { runDetection } from '../detect/index.ts';
+import { computeFingerprint } from '../detect/drift.ts';
+import { migrateV1ToV2, type AnyConfig } from '../detect/migrate.ts';
+import { renderConfigYaml, writeConfigAtomic } from './init.ts';
+
+export interface ConfigUpgradeOptions {
+  rollback?: boolean;
+  ci?: boolean;
+  cwd?: string;
+  silent?: boolean;
+}
+
+export interface ConfigUpgradeResult {
+  exitCode: 0 | 1 | 2;
+  action: 'migrated' | 'already-current' | 'rolled-back' | 'none';
+  message?: string;
+}
+
+export async function runConfigUpgrade(opts: ConfigUpgradeOptions = {}): Promise<ConfigUpgradeResult> {
+  const cwd = opts.cwd ?? process.cwd();
+  const configPath = resolve(cwd, 'massu.config.yaml');
+  const bakPath = `${configPath}.bak`;
+  const log = opts.silent ? () => {} : (s: string) => process.stdout.write(s);
+  const err = opts.silent ? () => {} : (s: string) => process.stderr.write(s);
+
+  if (opts.rollback) {
+    if (!existsSync(bakPath)) {
+      const message = `No backup found at ${bakPath}`;
+      err(message + '\n');
+      return { exitCode: 1, action: 'none', message };
+    }
+    try {
+      copyFileSync(bakPath, configPath);
+      unlinkSync(bakPath);
+      log('Config restored from backup.\n');
+      return { exitCode: 0, action: 'rolled-back' };
+    } catch (e) {
+      const message = `Rollback failed: ${e instanceof Error ? e.message : String(e)}`;
+      err(message + '\n');
+      return { exitCode: 2, action: 'none', message };
+    }
+  }
+
+  if (!existsSync(configPath)) {
+    const message = 'massu.config.yaml not found. Run: npx massu init';
+    err(message + '\n');
+    return { exitCode: 1, action: 'none', message };
+  }
+
+  let existing: AnyConfig;
+  try {
+    const content = readFileSync(configPath, 'utf-8');
+    const parsed = parseYaml(content);
+    if (!parsed || typeof parsed !== 'object') {
+      throw new Error('config is not a YAML object');
+    }
+    existing = parsed as AnyConfig;
+  } catch (e) {
+    const message = `Failed to parse massu.config.yaml: ${e instanceof Error ? e.message : String(e)}`;
+    err(message + '\n');
+    return { exitCode: 2, action: 'none', message };
+  }
+
+  const schemaVersion = existing.schema_version;
+  if (schemaVersion === 2) {
+    log('Config is already at schema_version=2; nothing to do.\n');
+    return { exitCode: 0, action: 'already-current' };
+  }
+
+  const detection = await runDetection(cwd);
+  const v2 = migrateV1ToV2(existing, detection);
+  v2.detection = {
+    ...(v2.detection as Record<string, unknown> | undefined ?? {}),
+    fingerprint: computeFingerprint(detection),
+  };
+
+  // Back up original before any write.
+  try {
+    const original = readFileSync(configPath, 'utf-8');
+    writeFileSync(bakPath, original, 'utf-8');
+  } catch (e) {
+    const message = `Failed to write backup: ${e instanceof Error ? e.message : String(e)}`;
+    err(message + '\n');
+    return { exitCode: 2, action: 'none', message };
+  }
+
+  const yamlContent = renderConfigYaml(v2);
+  const writeRes = writeConfigAtomic(configPath, yamlContent);
+  if (!writeRes.validated) {
+    const message = `Failed to write upgraded config: ${writeRes.error}`;
+    err(message + '\n');
+    return { exitCode: 2, action: 'none', message };
+  }
+
+  // Non-interactive mode just proceeds; interactive mode currently has no
+  // prompt on migrate (the migrator is deterministic and always user-preserving).
+  // --ci / --yes remain accepted for script-pipeline safety.
+  void opts.ci;
+
+  log(`Config upgraded to schema_version=2. Backup saved at ${bakPath}\n`);
+  return { exitCode: 0, action: 'migrated' };
+}

package/src/commands/doctor.ts

@@ -8,14 +8,13 @@
  * 1. massu.config.yaml exists and parses correctly
  * 2. .mcp.json has massu entry
  * 3. .claude/settings.local.json has hooks config
- * 4. All 15 compiled hook files exist
+ * 4. All 11 compiled hook files exist
  * 5. Knowledge DB exists (.massu/memory.db)
  * 6. Memory directory exists (~/.claude/projects/.../memory/)
  * 7. Shell hooks wired in settings.local.json
  * 8. better-sqlite3 native module loads
  * 9. Node.js version >= 18
  * 10. Git repository detected
- * 11. CLAUDE.md exists with content
  */
 
 import { existsSync, readFileSync, readdirSync } from 'fs';
@@ -374,32 +373,6 @@ function checkPythonHealth(projectRoot: string): CheckResult | null {
   };
 }
 
-function checkClaudeMd(projectRoot: string): CheckResult {
-  const claudeMdPath = resolve(projectRoot, 'CLAUDE.md');
-  if (!existsSync(claudeMdPath)) {
-    return {
-      name: 'CLAUDE.md',
-      status: 'warn',
-      detail: 'CLAUDE.md not found. Run: npx massu init (or create manually)',
-    };
-  }
-
-  const content = readFileSync(claudeMdPath, 'utf-8');
-  if (content.trim().length < 50) {
-    return {
-      name: 'CLAUDE.md',
-      status: 'warn',
-      detail: 'CLAUDE.md exists but appears empty or minimal',
-    };
-  }
-
-  return {
-    name: 'CLAUDE.md',
-    status: 'pass',
-    detail: 'CLAUDE.md found and has content',
-  };
-}
-
 // ============================================================
 // Main Doctor Flow
 // ============================================================
@@ -424,7 +397,6 @@ export async function runDoctor(): Promise<void> {
     checkNodeVersion(),
     await checkGitRepo(projectRoot),
     await checkLicenseStatus(),
-    checkClaudeMd(projectRoot),
   ];
 
   // Add Python health check if configured