@massu/core 0.9.2 → 1.1.0

package/src/detect/migrate.ts

@@ -0,0 +1,278 @@
+// Copyright (c) 2026 Massu. All rights reserved.
+// Licensed under BSL 1.1 - see LICENSE file for details.
+
+/**
+ * Config migration logic (P7-003).
+ *
+ * Pure functions that upgrade legacy v1-shaped `massu.config.yaml` objects to
+ * schema_version=2. Driven by the Phase 1 `DetectionResult` so the v2 output
+ * reflects the actual runtime stack.
+ *
+ * User overrides ALWAYS win — this migrator never overwrites fields that the
+ * user set explicitly in v1. The only thing that gets replaced is content
+ * whose v1 value is a schema default ('typescript', 'none', 'src', etc.) AND
+ * detection discovered a different value.
+ *
+ * Idempotence: passing a v2 config back in should be a no-op (beyond `schema_version`
+ * normalization). The test suite asserts this.
+ *
+ * No filesystem I/O, no network, no child processes. Pure data in, pure data
+ * out. Consumers (future `massu config upgrade` CLI, drift-repair flow) are
+ * responsible for reading/writing the YAML.
+ */
+
+import type { DetectionResult, SupportedLanguage, VRCommandSet } from './index.ts';
+
+/**
+ * Shape accepted for input. We intentionally use `Record<string, unknown>`
+ * rather than the full `Config` Zod type — legacy configs may contain fields
+ * that don't parse through the current schema (e.g., invalid enum values for
+ * `framework.router` from eko-ultra-automations), and a strict shape would
+ * reject the very configs we're trying to fix.
+ */
+export type AnyConfig = Record<string, unknown>;
+
+/** Fields the migrator preserves verbatim when present on the v1 input. */
+const PRESERVED_FIELDS: readonly string[] = [
+  'rules',
+  'domains',
+  'canonical_paths',
+  'verification_types',
+  'detection',
+  'accessScopes',
+  'knownMismatches',
+  'dbAccessPattern',
+  'analytics',
+  'governance',
+  'security',
+  'team',
+  'regression',
+  'cloud',
+  'conventions',
+  'autoLearning',
+];
+
+function getRecord(obj: unknown): Record<string, unknown> {
+  if (obj !== null && typeof obj === 'object' && !Array.isArray(obj)) {
+    return obj as Record<string, unknown>;
+  }
+  return {};
+}
+
+function isNoneOrDefault(v: unknown): boolean {
+  if (v === undefined || v === null) return true;
+  if (typeof v !== 'string') return false;
+  return v === 'none' || v === '';
+}
+
+function chooseString(user: unknown, detected: string | null | undefined): string {
+  // User wins unless it's falsey / 'none' and the detector has something concrete.
+  if (typeof user === 'string' && !isNoneOrDefault(user)) return user;
+  if (typeof detected === 'string' && detected !== '') return detected;
+  if (typeof user === 'string') return user;
+  return 'none';
+}
+
+function buildLanguageEntries(
+  detection: DetectionResult
+): Record<string, Record<string, unknown>> {
+  const languages = Array.from(
+    new Set(detection.manifests.map((m) => m.language))
+  ) as SupportedLanguage[];
+  const entries: Record<string, Record<string, unknown>> = {};
+  for (const lang of languages) {
+    const fw = detection.frameworks[lang];
+    const dirInfo = detection.sourceDirs[lang];
+    const sourceDirs = dirInfo?.source_dirs ?? [];
+    const entry: Record<string, unknown> = {};
+    if (fw?.framework) entry.framework = fw.framework;
+    if (fw?.test_framework) entry.test_framework = fw.test_framework;
+    if (fw?.orm) entry.orm = fw.orm;
+    if (fw?.router) entry.router = fw.router;
+    if (fw?.ui_library) entry.ui = fw.ui_library;
+    if (sourceDirs.length > 0) entry.source_dirs = sourceDirs;
+    if (Object.keys(entry).length > 0) {
+      entries[lang] = entry;
+    }
+  }
+  return entries;
+}
+
+function pickPrimary(detection: DetectionResult): SupportedLanguage | null {
+  const counts = new Map<SupportedLanguage, number>();
+  for (const m of detection.manifests) {
+    counts.set(m.language, (counts.get(m.language) ?? 0) + 1);
+  }
+  const sorted = [...counts.entries()].sort((a, b) => {
+    if (b[1] !== a[1]) return b[1] - a[1];
+    return a[0].localeCompare(b[0]);
+  });
+  return sorted.length > 0 ? sorted[0][0] : null;
+}
+
+function buildVerificationBlock(
+  detection: DetectionResult,
+  userVerification: Record<string, Record<string, string>> | undefined
+): Record<string, Record<string, string>> {
+  const ver: Record<string, Record<string, string>> = {};
+  const languages = Array.from(
+    new Set(detection.manifests.map((m) => m.language))
+  ) as SupportedLanguage[];
+  for (const lang of languages) {
+    const cmds: VRCommandSet | undefined = detection.verificationCommands[lang];
+    if (!cmds) continue;
+    const entry: Record<string, string> = {};
+    if (cmds.test) entry.test = cmds.test;
+    if (cmds.type) entry.type = cmds.type;
+    if (cmds.build) entry.build = cmds.build;
+    if (cmds.syntax) entry.syntax = cmds.syntax;
+    if (cmds.lint) entry.lint = cmds.lint;
+    if (Object.keys(entry).length > 0) ver[lang] = entry;
+  }
+  // Overlay user overrides — any user verification entry wins over detected.
+  if (userVerification) {
+    for (const [lang, userEntry] of Object.entries(userVerification)) {
+      if (typeof userEntry !== 'object' || userEntry === null) continue;
+      ver[lang] = { ...(ver[lang] ?? {}), ...userEntry };
+    }
+  }
+  return ver;
+}
+
+/**
+ * Migrate a v1-shaped (or malformed) config to v2, using `detection` as the
+ * source of truth for the stack layout. User-authored overrides (rules,
+ * domains, canonical_paths, etc.) are preserved unchanged.
+ *
+ * Idempotent: passing a valid v2 config back in returns an equivalent v2 config.
+ */
+export function migrateV1ToV2(
+  v1Config: AnyConfig,
+  detection: DetectionResult
+): AnyConfig {
+  const v1 = getRecord(v1Config);
+  const v1Framework = getRecord(v1.framework);
+  const v1Paths = getRecord(v1.paths);
+  const v1Project = getRecord(v1.project);
+  const v1Verification = v1.verification as
+    | Record<string, Record<string, string>>
+    | undefined;
+
+  const languages = Array.from(
+    new Set(detection.manifests.map((m) => m.language))
+  ) as SupportedLanguage[];
+  const languageEntries = buildLanguageEntries(detection);
+  const primary = pickPrimary(detection);
+
+  const frameworkType = languages.length > 1
+    ? 'multi'
+    : (languages[0] ?? (typeof v1Framework.type === 'string' ? v1Framework.type : 'typescript'));
+
+  // Legacy top-level router/orm/ui: prefer user value; fall back to primary lang.
+  const primaryEntry = primary ? languageEntries[primary] : undefined;
+  const primaryRouter = primaryEntry?.router as string | undefined;
+  const primaryOrm = primaryEntry?.orm as string | undefined;
+  const primaryUi = primaryEntry?.ui as string | undefined;
+
+  const legacyRouter = chooseString(v1Framework.router, primaryRouter);
+  const legacyOrm = chooseString(v1Framework.orm, primaryOrm);
+  const legacyUi = chooseString(v1Framework.ui, primaryUi);
+
+  const framework: Record<string, unknown> = {
+    type: frameworkType,
+    router: legacyRouter,
+    orm: legacyOrm,
+    ui: legacyUi,
+  };
+  if (languages.length > 1 && primary) {
+    framework.primary = primary;
+  }
+  if (Object.keys(languageEntries).length > 0) {
+    framework.languages = languageEntries;
+  }
+
+  // Paths: preserve user-set fields; fill `source` from detection if user had 'src' default.
+  let pathsSource: string = typeof v1Paths.source === 'string' ? v1Paths.source : 'src';
+  if (pathsSource === 'src' && primary) {
+    const primaryDirs = detection.sourceDirs[primary]?.source_dirs ?? [];
+    if (primaryDirs.length > 0) pathsSource = primaryDirs[0];
+  }
+  const aliases = v1Paths.aliases && typeof v1Paths.aliases === 'object'
+    ? (v1Paths.aliases as Record<string, string>)
+    : { '@': pathsSource };
+  const paths: Record<string, unknown> = {
+    source: pathsSource,
+    aliases,
+  };
+  for (const k of ['routers', 'routerRoot', 'pages', 'middleware', 'schema', 'components', 'hooks']) {
+    if (typeof v1Paths[k] === 'string') paths[k] = v1Paths[k];
+  }
+
+  const verification = buildVerificationBlock(detection, v1Verification);
+
+  // Construct v2 output.
+  const v2: AnyConfig = {
+    schema_version: 2,
+    project: {
+      name: typeof v1Project.name === 'string' ? v1Project.name : 'my-project',
+      root: typeof v1Project.root === 'string' ? v1Project.root : 'auto',
+    },
+    framework,
+    paths,
+    toolPrefix: typeof v1.toolPrefix === 'string' ? v1.toolPrefix : 'massu',
+  };
+
+  // Preserve user-authored collections verbatim.
+  for (const field of PRESERVED_FIELDS) {
+    if (field in v1 && v1[field] !== undefined) {
+      v2[field] = v1[field];
+    }
+  }
+
+  // Ensure domains / rules exist as arrays (v2 requires them).
+  if (!Array.isArray(v2.domains)) {
+    v2.domains = [];
+  }
+  if (!Array.isArray(v2.rules)) {
+    v2.rules = [];
+  }
+
+  if (Object.keys(verification).length > 0) {
+    v2.verification = verification;
+  }
+
+  // Preserve/update the v1 `python` sub-block when python is detected.
+  if (languages.includes('python')) {
+    const existing = getRecord(v1.python);
+    const pyFw = detection.frameworks.python;
+    const pySourceDirs = detection.sourceDirs.python?.source_dirs ?? [];
+    const pyRoot =
+      typeof existing.root === 'string' && existing.root !== ''
+        ? existing.root
+        : (pySourceDirs.length > 0 ? pySourceDirs[0] : '.');
+    const pythonBlock: Record<string, unknown> = {
+      root: pyRoot,
+      exclude_dirs: Array.isArray(existing.exclude_dirs)
+        ? existing.exclude_dirs
+        : ['__pycache__', '.venv', 'venv', '.mypy_cache', '.pytest_cache'],
+    };
+    if (existing.domains !== undefined) pythonBlock.domains = existing.domains;
+    if (existing.alembic_dir !== undefined) pythonBlock.alembic_dir = existing.alembic_dir;
+    if (pyFw?.framework && existing.framework === undefined) {
+      pythonBlock.framework = pyFw.framework;
+    } else if (existing.framework !== undefined) {
+      pythonBlock.framework = existing.framework;
+    }
+    if (pyFw?.orm && existing.orm === undefined) {
+      pythonBlock.orm = pyFw.orm;
+    } else if (existing.orm !== undefined) {
+      pythonBlock.orm = existing.orm;
+    }
+    v2.python = pythonBlock;
+  } else if (v1.python !== undefined) {
+    // Preserve even if detection didn't find python (e.g. non-monorepo-with-python).
+    v2.python = v1.python;
+  }
+
+  return v2;
+}

package/src/detect/monorepo-detector.ts

@@ -0,0 +1,347 @@
+// Copyright (c) 2026 Massu. All rights reserved.
+// Licensed under BSL 1.1 - see LICENSE file for details.
+
+/**
+ * Monorepo Detector (P1-004)
+ * ==========================
+ *
+ * Detects the presence and kind of monorepo layout at `projectRoot`:
+ *   - turbo       (turbo.json)
+ *   - nx          (nx.json)
+ *   - lerna       (lerna.json)
+ *   - pnpm        (pnpm-workspace.yaml)
+ *   - yarn        (package.json `workspaces`)
+ *   - bazel       (WORKSPACE / WORKSPACE.bazel / MODULE.bazel)
+ *   - generic     (any of apps/*, packages/*, services/*, libs/*, modules/*
+ *                  subdirs with their own manifests)
+ *   - single      (no monorepo signals)
+ *
+ * Nested schemes: when the outer has a primary manager AND an inner scheme is
+ * present (e.g., turbo-outer + pnpm-inner), `nested[]` lists the inner scheme.
+ *
+ * Usage:
+ * ```ts
+ * import { detectMonorepo } from './detect/monorepo-detector.ts';
+ * const info = detectMonorepo('/repo');
+ * ```
+ */
+
+import { readFileSync, existsSync, statSync, lstatSync, readdirSync } from 'fs';
+import { join, relative } from 'path';
+import { parse as parseYaml } from 'yaml';
+import { parse as parseToml } from 'smol-toml';
+
+export type MonorepoKind =
+  | 'turbo'
+  | 'nx'
+  | 'lerna'
+  | 'pnpm'
+  | 'yarn'
+  | 'bazel'
+  | 'generic'
+  | 'single';
+
+export interface WorkspacePackage {
+  /** Path relative to projectRoot, forward-slash normalized. */
+  path: string;
+  /** Name from the manifest (null if not present). */
+  name: string | null;
+  /** The manifest file that declares the workspace. */
+  manifest:
+    | 'package.json'
+    | 'pyproject.toml'
+    | 'Cargo.toml'
+    | 'go.mod'
+    | 'build.gradle'
+    | 'pom.xml'
+    | 'Gemfile'
+    | 'Package.swift'
+    | 'unknown';
+}
+
+export interface MonorepoInfo {
+  type: MonorepoKind;
+  /** Workspace packages discovered. Empty for 'single'. */
+  packages: WorkspacePackage[];
+  /** Secondary monorepo schemes nested inside the primary. */
+  nested: MonorepoInfo[];
+}
+
+const MANIFEST_PRIORITY: WorkspacePackage['manifest'][] = [
+  'package.json',
+  'pyproject.toml',
+  'Cargo.toml',
+  'go.mod',
+  'build.gradle',
+  'pom.xml',
+  'Gemfile',
+  'Package.swift',
+];
+
+const IGNORED_DIRS = new Set([
+  'node_modules',
+  '.venv',
+  'venv',
+  '__pycache__',
+  'dist',
+  'build',
+  '.build',
+  'target',
+  '.next',
+  '.nuxt',
+  'coverage',
+  '.git',
+  '.massu',
+  '.turbo',
+  '.cache',
+]);
+
+const CONVENTIONAL_WORKSPACE_PARENTS = [
+  'apps',
+  'packages',
+  'services',
+  'libs',
+  'modules',
+];
+
+function safeReadText(path: string): string | null {
+  try {
+    if (!existsSync(path)) return null;
+    // Reject symlinks — defence in depth against manifest-forged escape paths
+    // or credential exposure via symlinked files (parity with package-detector.ts).
+    // lstatSync does NOT follow symlinks; statSync would return the target's stat.
+    const ls = lstatSync(path);
+    if (ls.isSymbolicLink()) return null;
+    const st = statSync(path);
+    if (!st.isFile()) return null;
+    return readFileSync(path, 'utf-8');
+  } catch {
+    return null;
+  }
+}
+
+function firstManifestIn(dir: string): WorkspacePackage['manifest'] | null {
+  for (const m of MANIFEST_PRIORITY) {
+    if (existsSync(join(dir, m))) return m;
+  }
+  return null;
+}
+
+function manifestName(dir: string, manifest: WorkspacePackage['manifest']): string | null {
+  try {
+    if (manifest === 'package.json') {
+      const raw = safeReadText(join(dir, 'package.json'));
+      if (!raw) return null;
+      const pkg = JSON.parse(raw) as { name?: unknown };
+      return typeof pkg.name === 'string' ? pkg.name : null;
+    }
+    if (manifest === 'pyproject.toml') {
+      const raw = safeReadText(join(dir, 'pyproject.toml'));
+      if (!raw) return null;
+      const toml = parseToml(raw) as Record<string, unknown>;
+      const project = toml.project as Record<string, unknown> | undefined;
+      if (project && typeof project.name === 'string') return project.name;
+      const tool = toml.tool as Record<string, unknown> | undefined;
+      const poetry = tool?.poetry as Record<string, unknown> | undefined;
+      if (poetry && typeof poetry.name === 'string') return poetry.name;
+      return null;
+    }
+    if (manifest === 'Cargo.toml') {
+      const raw = safeReadText(join(dir, 'Cargo.toml'));
+      if (!raw) return null;
+      const toml = parseToml(raw) as Record<string, unknown>;
+      const pkg = toml.package as Record<string, unknown> | undefined;
+      if (pkg && typeof pkg.name === 'string') return pkg.name;
+      return null;
+    }
+    if (manifest === 'go.mod') {
+      const raw = safeReadText(join(dir, 'go.mod'));
+      if (!raw) return null;
+      for (const line of raw.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('module ')) return trimmed.slice(7).trim();
+      }
+      return null;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+function pkgFromDir(root: string, dir: string): WorkspacePackage | null {
+  const m = firstManifestIn(dir);
+  if (!m) return null;
+  return {
+    path: relative(root, dir).split(/[/\\]/).join('/'),
+    name: manifestName(dir, m),
+    manifest: m,
+  };
+}
+
+function listSubdirs(dir: string): string[] {
+  try {
+    return readdirSync(dir, { withFileTypes: true })
+      .filter((e) => e.isDirectory() && !IGNORED_DIRS.has(e.name))
+      .map((e) => join(dir, e.name));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Collect generic conventional workspaces (any manifested package under
+ * apps/*, packages/*, services/*, libs/*, modules/*).
+ */
+function genericWorkspaces(root: string): WorkspacePackage[] {
+  const out: WorkspacePackage[] = [];
+  for (const parent of CONVENTIONAL_WORKSPACE_PARENTS) {
+    const p = join(root, parent);
+    if (!existsSync(p)) continue;
+    for (const sub of listSubdirs(p)) {
+      const pkg = pkgFromDir(root, sub);
+      if (pkg) out.push(pkg);
+    }
+  }
+  return out;
+}
+
+function detectYarnWorkspaces(root: string): WorkspacePackage[] | null {
+  const raw = safeReadText(join(root, 'package.json'));
+  if (!raw) return null;
+  let pkg: { workspaces?: unknown };
+  try {
+    pkg = JSON.parse(raw) as { workspaces?: unknown };
+  } catch {
+    return null;
+  }
+  const ws = pkg.workspaces;
+  if (!ws) return null;
+  // Can be array of strings OR { packages: [...] }
+  const globs: string[] = Array.isArray(ws)
+    ? (ws.filter((x) => typeof x === 'string') as string[])
+    : typeof ws === 'object' && ws !== null &&
+        Array.isArray((ws as { packages?: unknown }).packages)
+      ? (((ws as { packages: unknown[] }).packages).filter((x) => typeof x === 'string') as string[])
+      : [];
+  if (globs.length === 0) return null;
+  return expandWorkspaceGlobs(root, globs);
+}
+
+function detectPnpmWorkspaces(root: string): WorkspacePackage[] | null {
+  const raw = safeReadText(join(root, 'pnpm-workspace.yaml'));
+  if (!raw) return null;
+  try {
+    const parsed = parseYaml(raw) as { packages?: unknown } | null;
+    const list = Array.isArray(parsed?.packages)
+      ? (parsed!.packages as unknown[]).filter((x) => typeof x === 'string') as string[]
+      : [];
+    return expandWorkspaceGlobs(root, list);
+  } catch {
+    return null;
+  }
+}
+
+function expandWorkspaceGlobs(root: string, globs: string[]): WorkspacePackage[] {
+  // Minimal brace/star expansion: support `foo/*` and `foo/**` by one level only.
+  // For simplicity and no-dep, expand each pattern manually.
+  const out: WorkspacePackage[] = [];
+  const seen = new Set<string>();
+  for (const pattern of globs) {
+    // Handle `apps/*`, `packages/*`, `services/*`, `apps/**`
+    const parts = pattern.split('/');
+    if (parts.length === 2 && (parts[1] === '*' || parts[1] === '**')) {
+      const parent = join(root, parts[0]);
+      if (!existsSync(parent)) continue;
+      for (const sub of listSubdirs(parent)) {
+        const pkg = pkgFromDir(root, sub);
+        if (pkg && !seen.has(pkg.path)) {
+          seen.add(pkg.path);
+          out.push(pkg);
+        }
+      }
+      continue;
+    }
+    // Direct path (no glob)
+    const direct = join(root, pattern);
+    if (existsSync(direct)) {
+      const pkg = pkgFromDir(root, direct);
+      if (pkg && !seen.has(pkg.path)) {
+        seen.add(pkg.path);
+        out.push(pkg);
+      }
+    }
+  }
+  return out;
+}
+
+function hasTurbo(root: string): boolean {
+  return existsSync(join(root, 'turbo.json'));
+}
+function hasNx(root: string): boolean {
+  return existsSync(join(root, 'nx.json'));
+}
+function hasLerna(root: string): boolean {
+  return existsSync(join(root, 'lerna.json'));
+}
+function hasBazel(root: string): boolean {
+  return (
+    existsSync(join(root, 'WORKSPACE')) ||
+    existsSync(join(root, 'WORKSPACE.bazel')) ||
+    existsSync(join(root, 'MODULE.bazel'))
+  );
+}
+
+/**
+ * Detect the monorepo layout (or lack thereof) at `projectRoot`.
+ */
+export function detectMonorepo(projectRoot: string): MonorepoInfo {
+  const nested: MonorepoInfo[] = [];
+
+  const pnpm = detectPnpmWorkspaces(projectRoot);
+  const yarn = detectYarnWorkspaces(projectRoot);
+
+  // Determine primary by priority: turbo > nx > lerna > pnpm > yarn > bazel > generic > single
+  let primary: MonorepoKind = 'single';
+  let primaryPackages: WorkspacePackage[] = [];
+
+  if (hasTurbo(projectRoot)) {
+    primary = 'turbo';
+    // Turbo reuses an underlying manager's workspaces list.
+    primaryPackages = pnpm ?? yarn ?? genericWorkspaces(projectRoot);
+    // Record nested inner scheme (the actual workspace manager)
+    if (pnpm && pnpm.length) {
+      nested.push({ type: 'pnpm', packages: pnpm, nested: [] });
+    } else if (yarn && yarn.length) {
+      nested.push({ type: 'yarn', packages: yarn, nested: [] });
+    }
+  } else if (hasNx(projectRoot)) {
+    primary = 'nx';
+    primaryPackages = yarn ?? pnpm ?? genericWorkspaces(projectRoot);
+    if (pnpm && pnpm.length) nested.push({ type: 'pnpm', packages: pnpm, nested: [] });
+    else if (yarn && yarn.length) nested.push({ type: 'yarn', packages: yarn, nested: [] });
+  } else if (hasLerna(projectRoot)) {
+    primary = 'lerna';
+    primaryPackages = yarn ?? pnpm ?? genericWorkspaces(projectRoot);
+  } else if (pnpm && pnpm.length) {
+    primary = 'pnpm';
+    primaryPackages = pnpm;
+  } else if (yarn && yarn.length) {
+    primary = 'yarn';
+    primaryPackages = yarn;
+  } else if (hasBazel(projectRoot)) {
+    primary = 'bazel';
+    primaryPackages = genericWorkspaces(projectRoot);
+  } else {
+    const gen = genericWorkspaces(projectRoot);
+    if (gen.length > 0) {
+      primary = 'generic';
+      primaryPackages = gen;
+    } else {
+      primary = 'single';
+      primaryPackages = [];
+    }
+  }
+
+  return { type: primary, packages: primaryPackages, nested };
+}