supipowers 1.5.2 → 2.0.0

package/src/config/loader.ts

@@ -2,12 +2,19 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type {
+  CommandGateId,
   ConfigScope,
   SupipowersConfig,
   ReleaseChannel,
   QualityGatesConfig,
 } from "../types.js";
 import type { PlatformPaths } from "../platform/types.js";
+import { resolvePackageManager } from "../workspace/package-manager.js";
+import {
+  discoverWorkspaceTargets,
+  normalizeWorkspaceRelativePath,
+} from "../workspace/targets.js";
+import { getRootConfigPath } from "../workspace/state-paths.js";
 import { DEFAULT_CONFIG } from "./defaults.js";
 import {
   collectConfigValidationErrors,
@@ -32,16 +39,49 @@ export interface QualityGateRecoveryInspection {
   scopes: ScopedConfigInspection[];
 }
 
-function getProjectConfigPath(paths: PlatformPaths, cwd: string): string {
-  return paths.project(cwd, "config.json");
+export interface ConfigResolutionOptions {
+  repoRoot?: string;
+}
+
+export interface ConfigMutationOptions extends ConfigResolutionOptions {
+  scope?: ConfigScope;
+}
+
+interface ResolvedConfigContext {
+  repoRoot: string;
+}
+
+interface ResolvedConfigLayer {
+  scope: ConfigScope;
+  path: string;
+}
+
+function resolveConfigContext(cwd: string, options?: ConfigResolutionOptions): ResolvedConfigContext {
+  return { repoRoot: options?.repoRoot ?? cwd };
 }
 
 function getGlobalConfigPath(paths: PlatformPaths): string {
   return paths.global("config.json");
 }
 
-function getConfigPath(paths: PlatformPaths, cwd: string, scope: ConfigScope): string {
-  return scope === "global" ? getGlobalConfigPath(paths) : getProjectConfigPath(paths, cwd);
+function getConfigPath(
+  paths: PlatformPaths,
+  cwd: string,
+  scope: ConfigScope,
+  options?: ConfigResolutionOptions,
+): string {
+  const { repoRoot } = resolveConfigContext(cwd, options);
+
+  switch (scope) {
+    case "global":
+      return getGlobalConfigPath(paths);
+    case "root":
+      return getRootConfigPath(paths, repoRoot);
+  }
+}
+
+function getInspectionScopes(): ConfigScope[] {
+  return ["global", "root"];
 }
 
 function readJsonFile(
@@ -136,6 +176,49 @@ function asRecord(value: unknown): Record<string, unknown> | null {
     : null;
 }
 
+function hasMeaningfulUltraPlanPolicy(config: Record<string, unknown> | null): boolean {
+  const ultraplan = asRecord(config?.ultraplan);
+  if (!ultraplan) {
+    return false;
+  }
+
+  const slots = asRecord(ultraplan.slots);
+  if (slots && Object.values(slots).some((override) => {
+    const slotOverride = asRecord(override);
+    return !!slotOverride && (
+      typeof slotOverride.agentName === "string"
+      || typeof slotOverride.model === "string"
+      || typeof slotOverride.thinkingLevel === "string"
+    );
+  })) {
+    return true;
+  }
+
+  const reviewGates = asRecord(ultraplan.reviewGates);
+  return !!reviewGates && Object.values(reviewGates).some((policy) => {
+    const reviewGate = asRecord(policy);
+    return !!reviewGate && typeof reviewGate.enabled === "boolean";
+  });
+}
+
+function omitMeaninglessUltraPlanFromGlobalRead(
+  config: Record<string, unknown> | null,
+  scope: ConfigScope,
+ ): Record<string, unknown> | null {
+  if (
+    scope !== "global"
+    || !config
+    || !Object.prototype.hasOwnProperty.call(config, "ultraplan")
+    || hasMeaningfulUltraPlanPolicy(config)
+  ) {
+    return config;
+  }
+
+  const { ultraplan: _ultraplan, ...scoped } = config;
+  return scoped;
+}
+
+
 function normalizeReleaseChannels(
   existingChannels: unknown,
   pipeline: string | null,
@@ -153,6 +236,93 @@ function normalizeReleaseChannels(
   return [];
 }
 
+const COMMAND_GATE_IDS: CommandGateId[] = ["lint", "typecheck", "format", "test-suite", "build"];
+
+function createAllTargetsRun(command: string): { command: string; target: { scope: "all-targets" } } {
+  return {
+    command,
+    target: { scope: "all-targets" },
+  };
+}
+
+function normalizeCommandGateRunTarget(target: unknown): unknown {
+  const record = asRecord(target);
+  if (!record || typeof record.scope !== "string") {
+    return target;
+  }
+
+  switch (record.scope) {
+    case "all-targets":
+    case "root":
+    case "all-workspaces":
+      return { scope: record.scope };
+    case "workspace":
+      return {
+        scope: "workspace",
+        relativeDir:
+          typeof record.relativeDir === "string"
+            ? normalizeWorkspaceRelativePath(record.relativeDir.trim())
+            : record.relativeDir,
+      };
+    default:
+      return target;
+  }
+}
+
+function normalizeCommandGateRuns(runs: unknown): unknown {
+  if (!Array.isArray(runs)) {
+    return runs;
+  }
+
+  return runs.map((run) => {
+    const record = asRecord(run);
+    if (!record) {
+      return run;
+    }
+
+    return {
+      ...record,
+      command: typeof record.command === "string" ? record.command.trim() : record.command,
+      target: normalizeCommandGateRunTarget(record.target),
+    };
+  });
+}
+
+function migrateCommandGateConfig(config: unknown): unknown {
+  const record = asRecord(config);
+  if (!record) {
+    return config;
+  }
+
+  if (record.enabled === false) {
+    return { enabled: false };
+  }
+
+  if (record.enabled !== true) {
+    return config;
+  }
+
+  if (Array.isArray(record.runs)) {
+    return {
+      enabled: true,
+      runs: normalizeCommandGateRuns(record.runs),
+    };
+  }
+
+  const legacyCommand =
+    typeof record.command === "string" && record.command.trim().length > 0
+      ? record.command.trim()
+      : null;
+  if (legacyCommand) {
+    return {
+      enabled: true,
+      runs: [createAllTargetsRun(legacyCommand)],
+    };
+  }
+
+  return { enabled: true };
+}
+
 function legacyGatesFromProfile(
   profileName: string | null,
   legacyTestCommand: string | null,
@@ -164,7 +334,10 @@ function legacyGatesFromProfile(
   }
 
   if (legacyTestCommand) {
-    gates["test-suite"] = { enabled: true, command: legacyTestCommand };
+    gates["test-suite"] = {
+      enabled: true,
+      runs: [createAllTargetsRun(legacyTestCommand)],
+    };
   }
 
   return Object.keys(gates).length > 0 ? gates : null;
@@ -207,6 +380,12 @@ function migrateConfig(config: Record<string, unknown>): Record<string, unknown>
     if (gates) {
       // Strip legacy ai-review gate — removed from the schema in the checks/review split.
       delete gates["ai-review"];
+
+      for (const gateId of COMMAND_GATE_IDS) {
+        if (gateId in gates) {
+          gates[gateId] = migrateCommandGateConfig(gates[gateId]);
+        }
+      }
     }
     if (!gates || Object.keys(gates).length === 0) {
       const legacyGates = legacyGatesFromProfile(legacyProfile, legacyTestCommand);
@@ -214,7 +393,10 @@ function migrateConfig(config: Record<string, unknown>): Record<string, unknown>
         quality.gates = legacyGates as unknown as Record<string, unknown>;
       }
     } else if (legacyTestCommand && !("test-suite" in gates)) {
-      gates["test-suite"] = { enabled: true, command: legacyTestCommand };
+      gates["test-suite"] = {
+        enabled: true,
+        runs: [createAllTargetsRun(legacyTestCommand)],
+      };
       quality.gates = gates;
     }
     migrated.quality = quality;
@@ -226,17 +408,14 @@ function migrateConfig(config: Record<string, unknown>): Record<string, unknown>
 
 function mergeConfigLayers(
   defaults: SupipowersConfig,
-  globalData: Record<string, unknown> | null,
-  projectData: Record<string, unknown> | null,
-): Record<string, unknown> {
+  ...layers: Array<Record<string, unknown> | null>
+ ): Record<string, unknown> {
   let merged = structuredClone(defaults) as unknown as Record<string, unknown>;
 
-  if (globalData) {
-    merged = applyConfigOverride(merged, globalData);
-  }
-
-  if (projectData) {
-    merged = applyConfigOverride(merged, projectData);
+  for (const layer of layers) {
+    if (layer) {
+      merged = applyConfigOverride(merged, layer);
+    }
   }
 
   // The config schema changed without a version bump, so normalize known
@@ -246,14 +425,112 @@ function mergeConfigLayers(
   return merged;
 }
 
+interface ResolvedConfigLayerRead extends ResolvedConfigLayer {
+  readResult: { data: Record<string, unknown> | null; error: ConfigParseError | null };
+}
+
+function readConfigLayers(
+  paths: PlatformPaths,
+  cwd: string,
+  options?: ConfigResolutionOptions,
+ ): ResolvedConfigLayerRead[] {
+  return getInspectionScopes().map((scope) => {
+    const filePath = getConfigPath(paths, cwd, scope, options);
+    const readResult = readJsonFile(scope, filePath);
+    return {
+      scope,
+      path: filePath,
+      readResult: {
+        ...readResult,
+        data: omitMeaninglessUltraPlanFromGlobalRead(readResult.data, scope),
+      },
+    };
+  });
+}
+
+function collectCommandGateSelectorValidationErrors(
+  config: Record<string, unknown>,
+  repoRoot: string,
+): ConfigValidationError[] {
+  const quality = asRecord(config.quality);
+  const gates = asRecord(quality?.gates);
+  if (!gates) {
+    return [];
+  }
+
+  const workspaceRelativeDirs = new Set(
+    discoverWorkspaceTargets(repoRoot, resolvePackageManager(repoRoot).id)
+      .filter((target) => target.kind === "workspace")
+      .map((target) => target.relativeDir),
+  );
+
+  const errors: ConfigValidationError[] = [];
+  for (const gateId of COMMAND_GATE_IDS) {
+    const gateConfig = asRecord(gates[gateId]);
+    if (!gateConfig || gateConfig.enabled !== true || !Array.isArray(gateConfig.runs)) {
+      continue;
+    }
+
+    gateConfig.runs.forEach((run, index) => {
+      const target = asRecord(asRecord(run)?.target);
+      if (target?.scope !== "workspace") {
+        return;
+      }
+
+      const relativeDir =
+        typeof target.relativeDir === "string"
+          ? normalizeWorkspaceRelativePath(target.relativeDir)
+          : null;
+      if (relativeDir && workspaceRelativeDirs.has(relativeDir)) {
+        return;
+      }
+
+      errors.push({
+        path: `quality.gates.${gateId}.runs.${index}.target.relativeDir`,
+        message: `Unknown workspace target "${String(target.relativeDir)}"`,
+      });
+    });
+  }
+
+  return errors;
+}
+
+function collectScopeValidationErrors(
+  config: Record<string, unknown> | null,
+  scope: ConfigScope,
+): ConfigValidationError[] {
+  if (scope !== "global" || !hasMeaningfulUltraPlanPolicy(config)) {
+    return [];
+  }
+
+  return [
+    {
+      path: "ultraplan",
+      message: "Only repository config may define ultraplan",
+    },
+  ];
+}
+
+
+function collectAllValidationErrors(
+  config: Record<string, unknown>,
+  repoRoot: string,
+): ConfigValidationError[] {
+  return [
+    ...collectConfigValidationErrors(config),
+    ...collectCommandGateSelectorValidationErrors(config, repoRoot),
+  ];
+}
+
 function inspectScopeConfig(
   paths: PlatformPaths,
   cwd: string,
   scope: ConfigScope,
+  options?: ConfigResolutionOptions,
 ): ScopedConfigInspection {
-  const filePath = getConfigPath(paths, cwd, scope);
+  const { repoRoot } = resolveConfigContext(cwd, options);
+  const filePath = getConfigPath(paths, cwd, scope, options);
   const readResult = readJsonFile(scope, filePath);
-
   if (readResult.error) {
     return {
       scope,
@@ -269,11 +546,12 @@ function inspectScopeConfig(
   }
 
   const hasOwnQualityGates = !!readResult.data && hasOwnNestedProperty(readResult.data, "quality", "gates");
-  const mergedConfig =
-    scope === "global"
-      ? mergeConfigLayers(DEFAULT_CONFIG, readResult.data, null)
-      : mergeConfigLayers(DEFAULT_CONFIG, null, readResult.data);
-  const validationErrors = collectConfigValidationErrors(mergedConfig);
+  const scopeData = omitMeaninglessUltraPlanFromGlobalRead(readResult.data, scope);
+  const mergedConfig = mergeConfigLayers(DEFAULT_CONFIG, scopeData);
+  const validationErrors = [
+    ...collectAllValidationErrors(mergedConfig, repoRoot),
+    ...collectScopeValidationErrors(readResult.data, scope),
+  ];
   const qualityGateValidationErrors = hasOwnQualityGates
     ? validationErrors.filter((error) => error.path === "quality.gates" || error.path.startsWith("quality.gates."))
     : [];
@@ -295,6 +573,7 @@ function inspectScopeConfig(
   };
 }
 
+
 function removeQualityGatesFromRecord(config: Record<string, unknown>): Record<string, unknown> {
   const next = structuredClone(config) as Record<string, unknown>;
   const quality = asRecord(next.quality);
@@ -317,14 +596,21 @@ function writeRawConfigFile(filePath: string, config: Record<string, unknown>):
   fs.writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n");
 }
 
+export function inspectConfigScopes(
+  paths: PlatformPaths,
+  cwd: string,
+  options?: ConfigResolutionOptions,
+ ): ScopedConfigInspection[] {
+  return getInspectionScopes().map((scope) => inspectScopeConfig(paths, cwd, scope, options));
+}
+
 export function inspectQualityGateRecovery(
   paths: PlatformPaths,
   cwd: string,
-): QualityGateRecoveryInspection {
+  options?: ConfigResolutionOptions,
+ ): QualityGateRecoveryInspection {
   return {
-    scopes: (["global", "project"] as ConfigScope[]).map((scope) =>
-      inspectScopeConfig(paths, cwd, scope),
-    ),
+    scopes: inspectConfigScopes(paths, cwd, options),
   };
 }
 
@@ -333,8 +619,9 @@ export function writeQualityGatesConfig(
   cwd: string,
   scope: ConfigScope,
   gates: QualityGatesConfig,
-): void {
-  const configPath = getConfigPath(paths, cwd, scope);
+  options?: ConfigResolutionOptions,
+ ): void {
+  const configPath = getConfigPath(paths, cwd, scope, options);
   const current = readJsonFile(scope, configPath);
   if (current.error) {
     throw new Error(`${scope} config ${configPath}: ${current.error.message}`);
@@ -355,8 +642,9 @@ export function removeQualityGatesConfig(
   paths: PlatformPaths,
   cwd: string,
   scope: ConfigScope,
-): boolean {
-  const configPath = getConfigPath(paths, cwd, scope);
+  options?: ConfigResolutionOptions,
+ ): boolean {
+  const configPath = getConfigPath(paths, cwd, scope, options);
   const current = readJsonFile(scope, configPath);
   if (current.error) {
     throw new Error(`${scope} config ${configPath}: ${current.error.message}`);
@@ -369,10 +657,14 @@ export function removeQualityGatesConfig(
   return true;
 }
 
+function describeConfigSource(source: ConfigParseError["source"]): string {
+  return source === "root" ? "repository" : source;
+}
+
 export function formatConfigErrors(result: InspectionLoadResult): string {
   const messages = [
     ...result.parseErrors.map(
-      (error) => `${error.source} config ${error.path}: ${error.message}`,
+      (error) => `${describeConfigSource(error.source)} config ${error.path}: ${error.message}`,
     ),
     ...result.validationErrors.map(
       (error) => `${error.path}: ${error.message}`,
@@ -382,14 +674,21 @@ export function formatConfigErrors(result: InspectionLoadResult): string {
   return messages.join("\n") || "Unknown config error";
 }
 
-export function inspectConfig(paths: PlatformPaths, cwd: string): InspectionLoadResult {
-  const globalRead = readJsonFile("global", getGlobalConfigPath(paths));
-  const projectRead = readJsonFile("project", getProjectConfigPath(paths, cwd));
-  const mergedConfig = mergeConfigLayers(DEFAULT_CONFIG, globalRead.data, projectRead.data);
-  const parseErrors = [globalRead.error, projectRead.error].filter(
-    (error): error is ConfigParseError => error !== null,
+function buildInspectionLoadResult(
+  layers: ResolvedConfigLayerRead[],
+  repoRoot: string,
+): InspectionLoadResult {
+  const mergedConfig = mergeConfigLayers(
+    DEFAULT_CONFIG,
+    ...layers.map((layer) => layer.readResult.data),
   );
-  const validationErrors = collectConfigValidationErrors(mergedConfig);
+  const parseErrors = layers
+    .map((layer) => layer.readResult.error)
+    .filter((error): error is ConfigParseError => error !== null);
+  const validationErrors = [
+    ...collectAllValidationErrors(mergedConfig, repoRoot),
+    ...layers.flatMap((layer) => collectScopeValidationErrors(layer.readResult.data, layer.scope)),
+  ];
 
   return {
     mergedConfig,
@@ -402,9 +701,38 @@ export function inspectConfig(paths: PlatformPaths, cwd: string): InspectionLoad
   };
 }
 
-/** Load config with global -> project layering over defaults. */
-export function loadConfig(paths: PlatformPaths, cwd: string): SupipowersConfig {
-  const result = inspectConfig(paths, cwd);
+export function inspectConfigAtScope(
+  paths: PlatformPaths,
+  cwd: string,
+  scope: ConfigScope,
+  options?: ConfigResolutionOptions,
+): InspectionLoadResult {
+  const { repoRoot } = resolveConfigContext(cwd, options);
+  const layers = readConfigLayers(paths, cwd, options).filter((layer) =>
+    scope === "global"
+      ? layer.scope === "global"
+      : layer.scope === "global" || layer.scope === "root",
+  );
+
+  return buildInspectionLoadResult(layers, repoRoot);
+}
+
+export function inspectConfig(
+  paths: PlatformPaths,
+  cwd: string,
+  options?: ConfigResolutionOptions,
+): InspectionLoadResult {
+  const { repoRoot } = resolveConfigContext(cwd, options);
+  return buildInspectionLoadResult(readConfigLayers(paths, cwd, options), repoRoot);
+}
+
+/** Load config with global -> repository layering over defaults. */
+export function loadConfig(
+  paths: PlatformPaths,
+  cwd: string,
+  options?: ConfigResolutionOptions,
+ ): SupipowersConfig {
+  const result = inspectConfig(paths, cwd, options);
 
   if (!result.effectiveConfig) {
     throw new Error(formatConfigErrors(result));
@@ -413,43 +741,103 @@ export function loadConfig(paths: PlatformPaths, cwd: string): SupipowersConfig
   return result.effectiveConfig;
 }
 
-function assertValidConfig(data: unknown): void {
-  const validationErrors = collectConfigValidationErrors(data);
+// Global scope never persists UltraPlan policy; writes only keep the shared config surface it may own.
+function omitUnsupportedUltraPlanFromGlobalWrite(
+  config: Record<string, unknown>,
+  scope: ConfigScope,
+ ): Record<string, unknown> {
+  if (scope !== "global") {
+    return config;
+  }
 
-  if (validationErrors.length === 0) {
+  const { ultraplan: _ultraplan, ...scoped } = config;
+  return scoped;
+}
+
+function prepareScopedConfigWrite(
+  fullConfig: unknown,
+  scopeData: Record<string, unknown>,
+  repoRoot: string,
+  scope: ConfigScope,
+ ): Record<string, unknown> {
+  const persistedScopeData = omitUnsupportedUltraPlanFromGlobalWrite(scopeData, scope);
+  const validatedScopeData = scope === "global" && !hasMeaningfulUltraPlanPolicy(scopeData)
+    ? persistedScopeData
+    : scopeData;
+
+  assertValidConfig(fullConfig, repoRoot, scope, validatedScopeData);
+  return persistedScopeData;
+}
+
+function assertValidConfig(
+  data: unknown,
+  repoRoot: string,
+  scope?: ConfigScope,
+  scopeData?: Record<string, unknown> | null,
+): void {
+  const record = asRecord(data);
+  const validationErrors = record ? collectAllValidationErrors(record, repoRoot) : collectConfigValidationErrors(data);
+  const scopeValidationErrors = scope ? collectScopeValidationErrors(scopeData ?? null, scope) : [];
+
+  if (validationErrors.length === 0 && scopeValidationErrors.length === 0) {
     return;
   }
 
   throw new Error(
-    validationErrors
+    [...validationErrors, ...scopeValidationErrors]
       .map((error) => `${error.path}: ${error.message}`)
       .join("\n"),
   );
 }
 
-
-/** Save project-level config. */
-export function saveConfig(paths: PlatformPaths, cwd: string, config: SupipowersConfig): void {
-  assertValidConfig(config);
-
-  const configPath = getProjectConfigPath(paths, cwd);
+/** Save a full config document to the selected scope. */
+export function saveConfig(
+  paths: PlatformPaths,
+  cwd: string,
+  config: SupipowersConfig,
+  options?: ConfigMutationOptions,
+ ): void {
+  const { repoRoot } = resolveConfigContext(cwd, options);
+  const scope = options?.scope ?? "root";
+  const rawConfig = prepareScopedConfigWrite(
+    config,
+    config as unknown as Record<string, unknown>,
+    repoRoot,
+    scope,
+  );
+  const configPath = getConfigPath(paths, cwd, scope, options);
   fs.mkdirSync(path.dirname(configPath), { recursive: true });
-  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  fs.writeFileSync(configPath, JSON.stringify(rawConfig, null, 2) + "\n");
 }
 
-/** Update specific config fields (deep merge into current). */
+/** Update specific config fields in the selected raw scope. */
 export function updateConfig(
   paths: PlatformPaths,
   cwd: string,
   updates: Record<string, unknown>,
-): SupipowersConfig {
-  const current = loadConfig(paths, cwd);
-  const updated = applyConfigOverride(
-    structuredClone(current) as unknown as Record<string, unknown>,
+  options?: ConfigMutationOptions,
+ ): SupipowersConfig {
+  const { repoRoot } = resolveConfigContext(cwd, options);
+  const scope = options?.scope ?? "root";
+  const configPath = getConfigPath(paths, cwd, scope, options);
+  const current = readJsonFile(scope, configPath);
+  if (current.error) {
+    throw new Error(`${scope} config ${configPath}: ${current.error.message}`);
+  }
+
+  const nextScopeData = applyConfigOverride(
+    current.data ? structuredClone(current.data) as Record<string, unknown> : {},
     updates,
   );
-  assertValidConfig(updated);
 
-  saveConfig(paths, cwd, updated as unknown as SupipowersConfig);
-  return updated as unknown as SupipowersConfig;
+  const scopedLayerData = omitUnsupportedUltraPlanFromGlobalWrite(nextScopeData, scope);
+  const layers = readConfigLayers(paths, cwd, options);
+  const mergedConfig = mergeConfigLayers(
+    DEFAULT_CONFIG,
+    ...layers.map((layer) => layer.scope === scope ? scopedLayerData : layer.readResult.data),
+  );
+  const rawConfig = prepareScopedConfigWrite(mergedConfig, nextScopeData, repoRoot, scope);
+
+  writeRawConfigFile(configPath, rawConfig);
+  return mergedConfig as unknown as SupipowersConfig;
 }