@massu/core 0.9.1 → 1.0.0

package/src/config.ts

@@ -1,6 +1,15 @@
 // Copyright (c) 2026 Massu. All rights reserved.
 // Licensed under BSL 1.1 - see LICENSE file for details.
 
+// ============================================================
+// P2-000 (2026-04-19): Strategy A chosen — extend config.ts in-place.
+// Per Phase 0 artifact (.massu/agent-results/phase0-discovery.md)
+// the CR-10 blast radius is 52 non-test consumers, with only 1 CHANGE callsite
+// (tools.ts) and zero INVESTIGATE items. No file split. All schema v2 extensions
+// live below and preserve the v1 `framework.{type,router,orm,ui}` access paths
+// so existing consumers (tools.ts:89,192,246) keep working unchanged.
+// ============================================================
+
 import { resolve, dirname } from 'path';
 import { existsSync, readFileSync } from 'fs';
 import { homedir } from 'os';
@@ -22,9 +31,13 @@ const DomainConfigSchema = z.object({
 export type DomainConfig = z.infer<typeof DomainConfigSchema>;
 
 // --- Pattern Rule Config ---
+// P2-003: optional `language` discriminator so rules can be scoped to a specific
+// runtime (e.g., only apply to Python files). Rules without `language` continue
+// to apply to all files for v1 backcompat.
 const PatternRuleConfigSchema = z.object({
   pattern: z.string().default('**'),
   rules: z.array(z.string()).default([]),
+  language: z.string().optional(),
 });
 export type PatternRuleConfig = z.infer<typeof PatternRuleConfigSchema>;
 
@@ -253,19 +266,94 @@ const PathsConfigSchema = z.object({
   hooks: z.string().optional(),
 });
 
+// --- P2-002: Multi-runtime per-language entry ---
+// Each entry declares the framework + test framework + optional router/orm/ui
+// used for that language slot. Used when `framework.type === 'multi'` via
+// `framework.languages`.
+const LanguageFrameworkEntrySchema = z.object({
+  framework: z.string().optional(),
+  test_framework: z.string().optional(),
+  test: z.string().optional(),
+  runtime: z.string().optional(),
+  orm: z.string().optional(),
+  router: z.string().optional(),
+  ui: z.string().optional(),
+}).passthrough();
+export type LanguageFrameworkEntry = z.infer<typeof LanguageFrameworkEntrySchema>;
+
+// --- P2-002: Framework schema (supports v1 single-language AND v2 multi-runtime) ---
+// v1: { type: 'typescript', router: 'none', orm: 'none', ui: 'none' }
+// v2: { type: 'multi', primary: 'python', languages: { python: {...}, typescript: {...} } }
+// Legacy top-level router/orm/ui keys are PRESERVED in both modes so that
+// existing consumers (tools.ts:89,192,246) keep working without refactor.
+const FrameworkConfigSchema = z.object({
+  type: z.string().default('typescript'),
+  primary: z.string().optional(),
+  router: z.string().default('none'),
+  orm: z.string().default('none'),
+  ui: z.string().default('none'),
+  languages: z.record(z.string(), LanguageFrameworkEntrySchema).optional(),
+}).passthrough();
+export type FrameworkConfig = z.infer<typeof FrameworkConfigSchema>;
+
+// --- P2-004: Verification command map ---
+// Map of language name -> command strings for each verification type.
+// User entries take precedence over any Phase 1 auto-defaults.
+const VerificationEntrySchema = z.object({
+  type: z.string().optional(),
+  test: z.string().optional(),
+  syntax: z.string().optional(),
+  lint: z.string().optional(),
+  build: z.string().optional(),
+}).passthrough();
+export type VerificationEntry = z.infer<typeof VerificationEntrySchema>;
+
+const VerificationConfigSchema = z.record(z.string(), VerificationEntrySchema).optional();
+export type VerificationConfig = z.infer<typeof VerificationConfigSchema>;
+
+// --- P2-005: Canonical paths extension (free-form string map) ---
+const CanonicalPathsSchema = z.record(z.string(), z.string()).optional();
+export type CanonicalPaths = z.infer<typeof CanonicalPathsSchema>;
+
+// --- P2-006: VR-* types extension (user-declared verification types) ---
+const VerificationTypesSchema = z.record(z.string(), z.string()).optional();
+export type VerificationTypes = z.infer<typeof VerificationTypesSchema>;
+
+// --- P2-008: Detection rules extension ---
+// Users may add or override built-in detection patterns. Phase 1 detectors
+// merge this with the inline DETECTION_RULES table.
+const DetectionRuleEntrySchema = z.object({
+  signals: z.array(z.string()).default([]),
+  priority: z.number().optional(),
+}).passthrough();
+
+const DetectionConfigSchema = z.object({
+  rules: z.record(
+    z.string(), // language
+    z.record(z.string(), DetectionRuleEntrySchema) // framework -> rule entry
+  ).optional(),
+  signal_weights: z.record(z.string(), z.number()).optional(),
+  disable_builtin: z.boolean().optional(),
+}).passthrough().optional();
+export type DetectionConfig = z.infer<typeof DetectionConfigSchema>;
+
 // --- Top-level Raw Config Schema ---
 // This validates the raw YAML output, coercing types and providing defaults.
+// P2-001: schema_version tracks the config shape version. Defaults to 1 so
+// existing v1 configs (without the field) keep loading unchanged. New v2
+// configs set `schema_version: 2` explicitly.
 const RawConfigSchema = z.object({
+  schema_version: z.union([z.literal(1), z.literal(2)]).default(1),
   project: z.object({
     name: z.string().default('my-project'),
     root: z.string().default('auto'),
   }).default({ name: 'my-project', root: 'auto' }),
-  framework: z.object({
-    type: z.string().default('typescript'),
-    router: z.string().default('none'),
-    orm: z.string().default('none'),
-    ui: z.string().default('none'),
-  }).default({ type: 'typescript', router: 'none', orm: 'none', ui: 'none' }),
+  framework: FrameworkConfigSchema.default({
+    type: 'typescript',
+    router: 'none',
+    orm: 'none',
+    ui: 'none',
+  }),
   paths: PathsConfigSchema.default({ source: 'src', aliases: { '@': 'src' } }),
   toolPrefix: z.string().default('massu'),
   dbAccessPattern: z.string().optional(),
@@ -280,14 +368,30 @@ const RawConfigSchema = z.object({
   regression: RegressionConfigSchema,
   cloud: CloudConfigSchema,
   conventions: ConventionsConfigSchema,
-  python: PythonConfigSchema,
   autoLearning: AutoLearningConfigSchema,
+  python: PythonConfigSchema,
+  // P2-004 / P2-005 / P2-006 / P2-008: v2 extensions (all optional)
+  verification: VerificationConfigSchema,
+  canonical_paths: CanonicalPathsSchema,
+  verification_types: VerificationTypesSchema,
+  detection: DetectionConfigSchema,
 }).passthrough();
 
 // --- Final Config interface (derived from Zod) ---
+// Legacy v1 access paths (framework.type/router/orm/ui) are preserved here so
+// that existing consumers (tools.ts:89,192,246 etc.) keep working regardless
+// of whether the config is v1 or v2 multi-runtime shape.
 export interface Config {
+  schema_version: 1 | 2;
   project: { name: string; root: string };
-  framework: { type: string; router: string; orm: string; ui: string };
+  framework: {
+    type: string;
+    router: string;
+    orm: string;
+    ui: string;
+    primary?: string;
+    languages?: Record<string, LanguageFrameworkEntry>;
+  };
   paths: z.infer<typeof PathsConfigSchema>;
   toolPrefix: string;
   dbAccessPattern?: string;
@@ -302,8 +406,13 @@ export interface Config {
   regression?: RegressionConfig;
   cloud?: CloudConfig;
   conventions?: ConventionsConfig;
-  python?: PythonConfig;
   autoLearning?: AutoLearningConfig;
+  python?: PythonConfig;
+  // P2-004/005/006/008: optional v2 extensions
+  verification?: VerificationConfig;
+  canonical_paths?: CanonicalPaths;
+  verification_types?: VerificationTypes;
+  detection?: DetectionConfig;
 }
 
 let _config: Config | null = null;
@@ -372,20 +481,62 @@ export function getConfig(): Config {
     rawYaml = parseYaml(content) ?? {};
   }
 
-  // Validate with Zod — provides defaults and type coercion
-  const parsed = RawConfigSchema.parse(rawYaml);
+  // P2-007: Validate with Zod and surface actionable errors on failure.
+  // Every Zod issue is translated into "<field path>: <message> (received <type>)"
+  // lines, grouped under a single Error message that names massu.config.yaml.
+  const result = RawConfigSchema.safeParse(rawYaml);
+  if (!result.success) {
+    const issues = result.error.issues.map(i => {
+      const path = i.path.length > 0 ? i.path.join('.') : '(root)';
+      const received = 'received' in i && i.received !== undefined
+        ? ` (received ${JSON.stringify(i.received)})`
+        : '';
+      return `  - ${path}: ${i.message}${received}`;
+    }).join('\n');
+    throw new Error(
+      `Invalid massu.config.yaml at ${configPath}:\n${issues}\n` +
+      `Hint: run \`massu config refresh\` to regenerate a valid config or fix the listed fields manually.`
+    );
+  }
+  const parsed = result.data;
 
   // Resolve project root path
   const projectRoot = parsed.project.root === 'auto' || !parsed.project.root
     ? root
     : resolve(root, parsed.project.root);
 
+  // P2-002 backcompat: when `framework.type === 'multi'`, mirror router/orm/ui
+  // from the primary language entry so that tools.ts:89,192,246 keep resolving.
+  // User-provided top-level keys always win — only fall back to the primary
+  // language when the top-level value is missing OR still the schema default
+  // 'none' (meaning the user didn't set it explicitly).
+  const fw = parsed.framework;
+  let router = fw.router;
+  let orm = fw.orm;
+  let ui = fw.ui;
+  if (fw.type === 'multi' && fw.primary && fw.languages) {
+    const primaryEntry = fw.languages[fw.primary];
+    if (primaryEntry) {
+      if (router === 'none' && primaryEntry.router) router = primaryEntry.router;
+      if (orm === 'none' && primaryEntry.orm) orm = primaryEntry.orm;
+      if (ui === 'none' && primaryEntry.ui) ui = primaryEntry.ui;
+    }
+  }
+
   _config = {
+    schema_version: parsed.schema_version,
     project: {
       name: parsed.project.name,
       root: projectRoot,
     },
-    framework: parsed.framework,
+    framework: {
+      type: fw.type,
+      router,
+      orm,
+      ui,
+      primary: fw.primary,
+      languages: fw.languages,
+    },
     paths: parsed.paths,
     toolPrefix: parsed.toolPrefix,
     dbAccessPattern: parsed.dbAccessPattern,
@@ -400,7 +551,12 @@ export function getConfig(): Config {
     regression: parsed.regression,
     cloud: parsed.cloud,
     conventions: parsed.conventions,
+    autoLearning: parsed.autoLearning,
     python: parsed.python,
+    verification: parsed.verification,
+    canonical_paths: parsed.canonical_paths,
+    verification_types: parsed.verification_types,
+    detection: parsed.detection,
   };
 
   // Allow environment variable override for API key (security best practice)

package/src/detect/domain-inferrer.ts

@@ -0,0 +1,142 @@
+// Copyright (c) 2026 Massu. All rights reserved.
+// Licensed under BSL 1.1 - see LICENSE file for details.
+
+/**
+ * Domain Inferrer (P1-006)
+ * ========================
+ *
+ * Suggests `DomainConfig[]` entries based on monorepo + source-dir discovery.
+ * Each workspace package (apps/*, packages/*, services/*, libs/*, modules/*)
+ * becomes one suggested domain. In single-package repos, top-level
+ * `src/<subdir>/` candidates are suggested as domains.
+ *
+ * Output matches the existing `DomainConfig` type from `config.ts` so init
+ * and refresh can write it directly into `massu.config.yaml`. Suggested
+ * `allowedImportsFrom` is always empty — the user fills relationships.
+ *
+ * Deterministic ordering: alphabetical by domain name.
+ *
+ * Usage:
+ * ```ts
+ * import { inferDomains } from './detect/domain-inferrer.ts';
+ * const domains = inferDomains('/repo', monorepo, sourceDirs);
+ * ```
+ */
+
+import { existsSync, readdirSync } from 'fs';
+import { join } from 'path';
+import type { DomainConfig } from '../config.ts';
+import type { MonorepoInfo, WorkspacePackage } from './monorepo-detector.ts';
+import type { SourceDirMap } from './source-dir-detector.ts';
+
+const IGNORED_SUBDIRS = new Set([
+  'node_modules',
+  '__pycache__',
+  'dist',
+  'build',
+  '.build',
+  'target',
+  '.next',
+  '.git',
+  '.massu',
+  'coverage',
+  'tests',
+  'test',
+  '__tests__',
+]);
+
+function titleCase(s: string): string {
+  if (!s) return s;
+  return s
+    .split(/[-_\s]+/)
+    .filter(Boolean)
+    .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
+    .join(' ');
+}
+
+function domainFromWorkspace(pkg: WorkspacePackage): DomainConfig {
+  // Prefer the explicit package name; fall back to the final path segment.
+  const pathTail = pkg.path.split('/').pop() ?? pkg.path;
+  const name = pkg.name ?? titleCase(pathTail);
+  return {
+    name,
+    routers: [],
+    pages: [],
+    tables: [],
+    allowedImportsFrom: [],
+  };
+}
+
+function topLevelSrcSubdirs(root: string): string[] {
+  const srcDir = join(root, 'src');
+  if (!existsSync(srcDir)) return [];
+  try {
+    return readdirSync(srcDir, { withFileTypes: true })
+      .filter((e) => e.isDirectory() && !IGNORED_SUBDIRS.has(e.name))
+      .map((e) => e.name)
+      .sort();
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Produce a suggested `DomainConfig[]`.
+ *
+ * @param projectRoot absolute path
+ * @param monorepo    output of P1-004 detectMonorepo
+ * @param sourceDirs  output of P1-003 detectSourceDirs
+ */
+export function inferDomains(
+  projectRoot: string,
+  monorepo: MonorepoInfo,
+  sourceDirs: SourceDirMap
+): DomainConfig[] {
+  const domains: DomainConfig[] = [];
+
+  if (monorepo.type !== 'single' && monorepo.packages.length > 0) {
+    // Monorepo: one domain per workspace package.
+    for (const pkg of monorepo.packages) {
+      domains.push(domainFromWorkspace(pkg));
+    }
+  } else {
+    // Single repo: suggest one domain per top-level src/<subdir>/ if src/ exists.
+    const subdirs = topLevelSrcSubdirs(projectRoot);
+    for (const s of subdirs) {
+      domains.push({
+        name: titleCase(s),
+        routers: [],
+        pages: [],
+        tables: [],
+        allowedImportsFrom: [],
+      });
+    }
+    // If no src/ subdirs, emit a single-language-based domain when sourceDirs has entries.
+    if (domains.length === 0) {
+      const langs = Object.keys(sourceDirs);
+      for (const lang of langs.sort()) {
+        domains.push({
+          name: titleCase(lang),
+          routers: [],
+          pages: [],
+          tables: [],
+          allowedImportsFrom: [],
+        });
+      }
+    }
+  }
+
+  // Deterministic alphabetical order by name.
+  domains.sort((a, b) => a.name.localeCompare(b.name));
+
+  // Dedup by name (monorepo workspaces may coincidentally share a name).
+  const seen = new Set<string>();
+  const dedup: DomainConfig[] = [];
+  for (const d of domains) {
+    if (seen.has(d.name)) continue;
+    seen.add(d.name);
+    dedup.push(d);
+  }
+
+  return dedup;
+}

package/src/detect/drift.ts

@@ -0,0 +1,199 @@
+// Copyright (c) 2026 Massu. All rights reserved.
+// Licensed under BSL 1.1 - see LICENSE file for details.
+
+/**
+ * Drift detection logic (P7-004).
+ *
+ * Phase 5 runtime (drift runner / auto-rerun) is NOT in the MVP cut, but the
+ * pure detection LOGIC is tested here so the runtime layer lands without bugs.
+ *
+ * Two primary entry points:
+ *
+ *   1. `computeFingerprint(detectionResult)` — deterministic SHA-256 of the
+ *      normalized JSON form of (languages, frameworks, source_dirs, manifest
+ *      paths sorted). Any meaningful change in the detected stack changes the
+ *      fingerprint.
+ *
+ *   2. `detectDrift(currentConfig, actualDetection)` — returns
+ *      `{ drifted: boolean, changes: Array<{field, before, after}> }`.
+ *
+ * No filesystem / network / child_process.
+ */
+
+import { createHash } from 'crypto';
+import type { AnyConfig } from './migrate.ts';
+import type { DetectionResult, SupportedLanguage } from './index.ts';
+
+export interface DriftChange {
+  field: string;
+  before: unknown;
+  after: unknown;
+}
+
+export interface DriftReport {
+  drifted: boolean;
+  changes: DriftChange[];
+}
+
+/** Stable-sorted, normalized summary of a DetectionResult used for hashing. */
+interface DetectionFingerprintData {
+  languages: string[];
+  frameworks: Record<string, { framework: string | null; test_framework: string | null; orm: string | null }>;
+  source_dirs: Record<string, string[]>;
+  manifests: string[];
+  monorepo: string;
+  workspaces: string[];
+}
+
+function summarizeDetection(det: DetectionResult): DetectionFingerprintData {
+  const languages = Array.from(new Set(det.manifests.map((m) => m.language))).sort();
+  const frameworks: DetectionFingerprintData['frameworks'] = {};
+  for (const lang of languages) {
+    const fw = det.frameworks[lang as SupportedLanguage];
+    frameworks[lang] = {
+      framework: fw?.framework ?? null,
+      test_framework: fw?.test_framework ?? null,
+      orm: fw?.orm ?? null,
+    };
+  }
+  const sourceDirs: Record<string, string[]> = {};
+  for (const lang of languages) {
+    const info = det.sourceDirs[lang as SupportedLanguage];
+    sourceDirs[lang] = [...(info?.source_dirs ?? [])].sort();
+  }
+  const manifests = [...det.manifests.map((m) => m.relativePath)].sort();
+  const workspaces = [...det.monorepo.packages.map((p) => p.path)].sort();
+  return {
+    languages,
+    frameworks,
+    source_dirs: sourceDirs,
+    manifests,
+    monorepo: det.monorepo.type,
+    workspaces,
+  };
+}
+
+/** Deterministic SHA-256 of a detection result. Stable across runs for the
+ * same inputs. */
+export function computeFingerprint(det: DetectionResult): string {
+  const data = summarizeDetection(det);
+  const stable = JSON.stringify(data, Object.keys(data).sort());
+  return createHash('sha256').update(stable).digest('hex');
+}
+
+function stringOf(v: unknown): string | null {
+  if (typeof v === 'string') return v;
+  if (v === null || v === undefined) return null;
+  return String(v);
+}
+
+/**
+ * Compute drift between a currently-loaded config and a freshly-run detection.
+ *
+ * A non-empty `changes[]` means fields in the config no longer agree with
+ * what the repository actually contains. Callers decide whether to auto-repair
+ * (via `migrateV1ToV2`) or surface to the user.
+ */
+export function detectDrift(
+  currentConfig: AnyConfig,
+  actualDetection: DetectionResult
+): DriftReport {
+  const changes: DriftChange[] = [];
+
+  const configFw = (currentConfig.framework && typeof currentConfig.framework === 'object')
+    ? (currentConfig.framework as Record<string, unknown>)
+    : {};
+  const configLanguages = (configFw.languages && typeof configFw.languages === 'object')
+    ? (configFw.languages as Record<string, Record<string, unknown>>)
+    : {};
+
+  const detectedLanguages = Array.from(
+    new Set(actualDetection.manifests.map((m) => m.language))
+  ) as SupportedLanguage[];
+
+  const configLangKeys = Object.keys(configLanguages).sort();
+  const detectedLangKeys = [...detectedLanguages].sort();
+
+  // 1. Language set drift.
+  if (JSON.stringify(configLangKeys) !== JSON.stringify(detectedLangKeys)) {
+    changes.push({
+      field: 'framework.languages',
+      before: configLangKeys,
+      after: detectedLangKeys,
+    });
+  }
+
+  // 2. Per-language framework/test_framework drift.
+  for (const lang of detectedLanguages) {
+    const detFw = actualDetection.frameworks[lang];
+    const cfgEntry = configLanguages[lang];
+    if (!cfgEntry) continue;
+    const cfgFramework = stringOf(cfgEntry.framework);
+    const detFramework = detFw?.framework ?? null;
+    if (cfgFramework !== detFramework && detFramework !== null) {
+      changes.push({
+        field: `framework.languages.${lang}.framework`,
+        before: cfgFramework,
+        after: detFramework,
+      });
+    }
+    const cfgTest = stringOf(cfgEntry.test_framework);
+    const detTest = detFw?.test_framework ?? null;
+    if (cfgTest !== detTest && detTest !== null) {
+      changes.push({
+        field: `framework.languages.${lang}.test_framework`,
+        before: cfgTest,
+        after: detTest,
+      });
+    }
+  }
+
+  // 3. Manifest set drift: new/removed manifest files.
+  const detectedManifestPaths = new Set(actualDetection.manifests.map((m) => m.relativePath));
+  const declaredManifestPaths = new Set<string>();
+  // v2 configs don't record manifest paths directly; we look at
+  // `canonical_paths.manifest_paths` (string comma-separated) OR a `manifests`
+  // top-level array. When neither is present we skip this check.
+  const canonical = currentConfig.canonical_paths as Record<string, unknown> | undefined;
+  if (canonical && typeof canonical.manifest_paths === 'string') {
+    for (const p of (canonical.manifest_paths as string).split(',').map((s) => s.trim())) {
+      if (p) declaredManifestPaths.add(p);
+    }
+  }
+  if (Array.isArray(currentConfig.manifests)) {
+    for (const p of currentConfig.manifests as unknown[]) {
+      if (typeof p === 'string') declaredManifestPaths.add(p);
+    }
+  }
+  if (declaredManifestPaths.size > 0) {
+    const added = [...detectedManifestPaths].filter((p) => !declaredManifestPaths.has(p)).sort();
+    const removed = [...declaredManifestPaths].filter((p) => !detectedManifestPaths.has(p)).sort();
+    if (added.length > 0) {
+      changes.push({ field: 'manifests.added', before: [], after: added });
+    }
+    if (removed.length > 0) {
+      changes.push({ field: 'manifests.removed', before: removed, after: [] });
+    }
+  }
+
+  // 4. Monorepo workspace set drift.
+  const configWorkspaces: string[] = [];
+  if (Array.isArray((currentConfig.monorepo as Record<string, unknown> | undefined)?.workspaces)) {
+    for (const w of ((currentConfig.monorepo as Record<string, unknown>).workspaces as unknown[])) {
+      if (typeof w === 'string') configWorkspaces.push(w);
+    }
+  }
+  const detectedWorkspaces = actualDetection.monorepo.packages.map((p) => p.path).sort();
+  if (configWorkspaces.length > 0) {
+    const cfgSorted = [...configWorkspaces].sort();
+    if (JSON.stringify(cfgSorted) !== JSON.stringify(detectedWorkspaces)) {
+      changes.push({
+        field: 'monorepo.workspaces',
+        before: cfgSorted,
+        after: detectedWorkspaces,
+      });
+    }
+  }
+
+  return { drifted: changes.length > 0, changes };
+}