@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-3P5IN5E7.js

@@ -0,0 +1,9 @@
+// src/core/providers/shared/unknown-error-policy.ts
+function isUnknownErrorRetryable(policy) {
+  return policy === "retry";
+}
+
+export {
+  isUnknownErrorRetryable
+};
+//# sourceMappingURL=chunk-3P5IN5E7.js.map

package/dist/chunk-3PL22IYZ.js

@@ -0,0 +1,20 @@
+// src/core/classification/validation-artifact-compete.ts
+var VALIDATION_ARTIFACT_TARGET = /(?:^|[\s`"'(])(?:\.\/)?(?:\.build-project\/validation\/|dogfood-validation-artifacts\/)/i;
+function hasValidationArtifactTarget(text) {
+  return VALIDATION_ARTIFACT_TARGET.test(text);
+}
+function isExactValidationArtifactCompeteTask(task) {
+  return /\bvalidation(?:\s+run)?\s+only\b/i.test(task) && hasValidationArtifactTarget(task) && /\b(?:(?:containing|with)\s+exactly|so it contains exactly)\b/i.test(task);
+}
+function isValidationTargetedScopedEditTask(task) {
+  return /\bvalidation(?:\s+run)?\s+only\b/i.test(task) && hasValidationArtifactTarget(task) && /\b(?:edit|update|modify|change)\s+only\b/i.test(task);
+}
+function isValidationTargetedCodeOverrideExpected(task) {
+  return isExactValidationArtifactCompeteTask(task) || isValidationTargetedScopedEditTask(task);
+}
+
+export {
+  hasValidationArtifactTarget,
+  isValidationTargetedCodeOverrideExpected
+};
+//# sourceMappingURL=chunk-3PL22IYZ.js.map

package/dist/chunk-3REDAJUJ.js

@@ -0,0 +1,14 @@
+import {
+  loadConfigLayers
+} from "./chunk-C3DH3NCY.js";
+
+// src/core/config/git-message-style.ts
+function resolveGitMessageStyle(cwd) {
+  const { project, user } = loadConfigLayers(cwd);
+  return project?.git?.messageStyle ?? user?.git?.messageStyle ?? "plain";
+}
+
+export {
+  resolveGitMessageStyle
+};
+//# sourceMappingURL=chunk-3REDAJUJ.js.map

package/dist/chunk-3S2R4XJI.js

@@ -0,0 +1,203 @@
+import {
+  atomicWriteJsonSync
+} from "./chunk-RFDVSI4N.js";
+import {
+  LabPathResolver,
+  isLabModeFromEnv
+} from "./chunk-C3KCMAJP.js";
+import {
+  resolveProjectRuntimeDir
+} from "./chunk-AJN5Y5YZ.js";
+import {
+  getBuildProjectRoot
+} from "./chunk-CHA2HDE5.js";
+import {
+  emitWarning
+} from "./chunk-7VRJHTGZ.js";
+
+// src/orchestrator/execution-history.ts
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync } from "fs";
+import path from "path";
+import lockfile from "proper-lockfile";
+function resolveHistoryCommand(input) {
+  if (input.commandSurface === "fusion") return "fusion";
+  if (typeof input.commandSurface === "string" && input.commandSurface.trim().length > 0) {
+    return input.commandSurface.trim();
+  }
+  return input.fallbackCommand ?? "compete";
+}
+function deriveFusionHistoryOutcome(input) {
+  if (input.competitionOutcome === "timed_out") return "timeout";
+  const status = (input.analysisSynthesisStatus ?? "not_produced").trim() || "not_produced";
+  const contributorCount = Math.max(0, Math.floor(input.synthesisContributorCount));
+  if (contributorCount <= 0) return "failed";
+  if (contributorCount < 2) return "degraded";
+  if (status === "partial" || status === "degraded") return "degraded";
+  if (status === "succeeded") return "success";
+  return "failed";
+}
+function resolveHistoryProviderAttribution(input) {
+  const providers = uniqueSortedProviders(input.variantProviders ?? []);
+  const winnerProvider = input.winnerProvider?.trim();
+  if (winnerProvider) {
+    const withWinner = providers.includes(winnerProvider) ? providers : uniqueSortedProviders([...providers, winnerProvider]);
+    return { provider: winnerProvider, providers: withWinner };
+  }
+  if (providers.length === 1) {
+    return { provider: providers[0], providers };
+  }
+  if (providers.length > 1) {
+    return { provider: providers.join("+"), providers };
+  }
+  return { provider: "none", providers: [] };
+}
+function uniqueSortedProviders(values) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    const trimmed = typeof value === "string" ? value.trim() : "";
+    if (trimmed.length > 0) seen.add(trimmed);
+  }
+  return Array.from(seen).sort((a, b) => a.localeCompare(b, "en"));
+}
+var MAX_RECORDS = 100;
+var HISTORY_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
+var storeCache = null;
+var storeCachePath = null;
+function getHistoryPath() {
+  const envPath = process.env.BUILD_EXECUTION_HISTORY_PATH?.trim();
+  if (envPath) return path.resolve(envPath);
+  const projectRoot = getBuildProjectRoot();
+  if (isLabModeFromEnv()) {
+    const resolver = LabPathResolver.getInstance();
+    if (resolver.isLabMode()) {
+      return path.join(
+        resolver.getStateDir(path.join(projectRoot, ".build-project")),
+        "execution-history.json"
+      );
+    }
+  }
+  return path.join(
+    resolveProjectRuntimeDir(path.join(projectRoot, ".build-project"), "cache"),
+    "execution-history.json"
+  );
+}
+function ensureHistoryFile() {
+  const historyPath = getHistoryPath();
+  mkdirSync(path.dirname(historyPath), { recursive: true });
+  if (!existsSync(historyPath)) {
+    const fd = openSync(historyPath, "a");
+    closeSync(fd);
+  }
+  return historyPath;
+}
+function readHistoryFromDisk(historyPath) {
+  try {
+    const raw = readFileSync(historyPath, "utf-8");
+    if (raw.trim().length === 0) {
+      return { records: [] };
+    }
+    const parsed = JSON.parse(raw);
+    if (parsed?.records && Array.isArray(parsed.records)) {
+      return parsed;
+    }
+  } catch {
+  }
+  return { records: [] };
+}
+function loadHistory() {
+  const historyPath = getHistoryPath();
+  if (storeCache && storeCachePath === historyPath) return storeCache;
+  const store = readHistoryFromDisk(historyPath);
+  storeCache = store;
+  storeCachePath = historyPath;
+  return storeCache;
+}
+function saveHistory(store) {
+  try {
+    const historyPath = getHistoryPath();
+    atomicWriteJsonSync(historyPath, store);
+    storeCache = store;
+    storeCachePath = historyPath;
+  } catch (error) {
+    emitWarning(
+      "WS-002A",
+      { subsystem: "orchestrator", executionPhase: "execution" },
+      {
+        severity: "WARN" /* WARN */,
+        metadata: {
+          operation: "saveExecutionHistory",
+          error: error instanceof Error ? error.message : String(error)
+        }
+      }
+    );
+  }
+}
+function recordExecution(record) {
+  try {
+    const historyPath = ensureHistoryFile();
+    const release = lockfile.lockSync(historyPath);
+    try {
+      const store = readHistoryFromDisk(historyPath);
+      store.records.push(record);
+      const cutoff = Date.now() - HISTORY_TTL_MS;
+      store.records = store.records.filter((r) => r.completedAt > cutoff).slice(-MAX_RECORDS);
+      saveHistory(store);
+    } finally {
+      release();
+    }
+  } catch (error) {
+    emitWarning(
+      "WS-002A",
+      { subsystem: "orchestrator", executionPhase: "execution" },
+      {
+        severity: "WARN" /* WARN */,
+        metadata: {
+          operation: "recordExecutionHistory",
+          error: error instanceof Error ? error.message : String(error)
+        }
+      }
+    );
+  }
+}
+function queryHistory(criteria) {
+  const store = loadHistory();
+  const cutoff = Date.now() - HISTORY_TTL_MS;
+  return store.records.filter((r) => {
+    if (r.completedAt <= cutoff) return false;
+    if (criteria.provider && r.provider !== criteria.provider) return false;
+    if (criteria.model && r.model !== criteria.model) return false;
+    if (criteria.strategy && r.strategy !== criteria.strategy) return false;
+    if (criteria.executionMode && r.executionMode !== criteria.executionMode) return false;
+    if (criteria.intent && r.intent !== criteria.intent) return false;
+    if (criteria.runSemantics && r.runSemantics !== criteria.runSemantics) return false;
+    if (criteria.command && r.command !== criteria.command) return false;
+    if (criteria.stageCountRange) {
+      const [min, max] = criteria.stageCountRange;
+      if (r.stageCount < min || r.stageCount > max) return false;
+    }
+    if (criteria.isCompetitive !== void 0 && r.isCompetitive !== criteria.isCompetitive) {
+      return false;
+    }
+    return true;
+  });
+}
+function calculateHistoricalMultiplier(criteria) {
+  const records = queryHistory(criteria);
+  if (records.length < 3) return 1;
+  const ratios = records.filter((r) => r.estimatedDurationMs > 0).map((r) => r.actualDurationMs / r.estimatedDurationMs);
+  if (ratios.length < 3) return 1;
+  ratios.sort((a, b) => a - b);
+  const mid = Math.floor(ratios.length / 2);
+  const median = ratios.length % 2 === 0 ? (ratios[mid - 1] + ratios[mid]) / 2 : ratios[mid];
+  return Math.max(0.5, Math.min(20, median));
+}
+
+export {
+  resolveHistoryCommand,
+  deriveFusionHistoryOutcome,
+  resolveHistoryProviderAttribution,
+  recordExecution,
+  queryHistory,
+  calculateHistoricalMultiplier
+};
+//# sourceMappingURL=chunk-3S2R4XJI.js.map

package/dist/chunk-3UBZI5DW.js

@@ -0,0 +1,61 @@
+import {
+  getOutputLevel,
+  isQuietOutputRequested
+} from "./chunk-XWIZ6B5S.js";
+
+// src/cli/utils/output-renderer.ts
+import chalk from "chalk";
+function colorForLevel(level) {
+  switch (level) {
+    case "success":
+      return chalk.green;
+    case "warning":
+      return chalk.yellow;
+    case "error":
+      return chalk.red;
+    case "debug":
+      return chalk.gray;
+    default:
+      return (value) => value;
+  }
+}
+function createCliOutputRenderer() {
+  return {
+    event(event) {
+      if (isQuietOutputRequested() && event.level !== "error") {
+        return;
+      }
+      if (event.level === "debug" && getOutputLevel() !== "debug") {
+        return;
+      }
+      const color = colorForLevel(event.level);
+      const message = event.detail ? `${event.message}: ${event.detail}` : event.message;
+      const writer = event.level === "error" ? console.error : console.log;
+      writer(color(message));
+    },
+    line(message) {
+      if (!isQuietOutputRequested()) {
+        console.log(message);
+      }
+    },
+    error(message) {
+      console.error(chalk.red(message));
+    },
+    verbose(message) {
+      const level = getOutputLevel();
+      if (level === "verbose" || level === "debug") {
+        console.log(chalk.gray(message));
+      }
+    },
+    debug(message) {
+      if (getOutputLevel() === "debug") {
+        console.log(chalk.gray(message));
+      }
+    }
+  };
+}
+
+export {
+  createCliOutputRenderer
+};
+//# sourceMappingURL=chunk-3UBZI5DW.js.map

package/dist/chunk-3VV5OBGG.js

@@ -0,0 +1,308 @@
+import {
+  registry,
+  validateModel
+} from "./chunk-7HYBSRPZ.js";
+import {
+  ExitCodeError
+} from "./chunk-Y4ZDDHB6.js";
+import {
+  resolveConfig
+} from "./chunk-C3DH3NCY.js";
+import {
+  clearActiveProfile,
+  createProfile,
+  deleteProfile,
+  listProfiles,
+  readActiveProfileName,
+  readProfile,
+  setActiveProfile
+} from "./chunk-M4BUEXXF.js";
+import {
+  getUserConfigFile
+} from "./chunk-56WPYDJH.js";
+
+// src/cli/commands/profile.ts
+import { Command, Option } from "commander";
+function printJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+var MODEL_VALIDATABLE_PROVIDERS = /* @__PURE__ */ new Set([
+  "codex",
+  "cursor",
+  "copilot",
+  "claude",
+  "gemini",
+  "openai"
+]);
+function validateProfileProvider(provider) {
+  if (registry.has(provider)) {
+    return;
+  }
+  const available = registry.getAllIds().join(", ");
+  console.error(`Error: Unknown provider "${provider}".`);
+  console.error(`Valid providers: ${available}`);
+  throw new ExitCodeError(1);
+}
+function resolveProviderContextForModelValidation(provider, fromProfile) {
+  if (provider) {
+    return provider;
+  }
+  if (!fromProfile) {
+    return void 0;
+  }
+  try {
+    return readProfile(fromProfile).defaults?.provider;
+  } catch {
+    return void 0;
+  }
+}
+function validateProfileModel(provider, model) {
+  if (!model) {
+    return;
+  }
+  if (!provider) {
+    console.error("Error: --model requires --provider (or --from a profile with a provider).");
+    throw new ExitCodeError(1);
+  }
+  validateProfileProvider(provider);
+  if (!MODEL_VALIDATABLE_PROVIDERS.has(provider)) {
+    return;
+  }
+  const result = validateModel({ provider, model });
+  if (result.valid) {
+    return;
+  }
+  const detail = result.warnings.join(" ");
+  console.error(`Error: Invalid model "${model}" for provider "${provider}".`);
+  if (detail) {
+    console.error(detail);
+  }
+  if (result.suggestion) {
+    console.error(`Did you mean "${result.suggestion}"?`);
+  }
+  console.error(
+    "Run `build provider show <id> --json` or `build provider refresh <id> --models` to inspect available model data."
+  );
+  throw new ExitCodeError(1);
+}
+function formatProfile(data, active) {
+  const lines = [];
+  lines.push(`name: ${data.name}${active ? " (active)" : ""}`);
+  if (data.description) lines.push(`description: ${data.description}`);
+  lines.push(`created: ${data.createdAt}`);
+  lines.push(`updated: ${data.updatedAt}`);
+  if (data.defaults && Object.keys(data.defaults).length > 0) {
+    lines.push("defaults:");
+    const d = data.defaults;
+    if (d.provider) lines.push(`  provider: ${d.provider}`);
+    if (d.model) lines.push(`  model: ${d.model}`);
+    if (d.judge?.type) lines.push(`  judge.type: ${d.judge.type}`);
+    if (d.judge?.provider) lines.push(`  judge.provider: ${d.judge.provider}`);
+    if (d.judge?.model) lines.push(`  judge.model: ${d.judge.model}`);
+    if (d.synthesis?.provider) lines.push(`  synthesis.provider: ${d.synthesis.provider}`);
+    if (d.synthesis?.model) lines.push(`  synthesis.model: ${d.synthesis.model}`);
+    if (d.providers && Object.keys(d.providers).length > 0) {
+      lines.push("  providers:");
+      for (const [prov, cfg] of Object.entries(d.providers)) {
+        if (cfg?.model) lines.push(`    ${prov}.model: ${cfg.model}`);
+      }
+    }
+  }
+  if (data.telemetry && Object.keys(data.telemetry).length > 0) {
+    lines.push("telemetry:");
+    if (data.telemetry.enabled !== void 0) lines.push(`  enabled: ${data.telemetry.enabled}`);
+    if (data.telemetry.silent !== void 0) lines.push(`  silent: ${data.telemetry.silent}`);
+  }
+  return lines.join("\n");
+}
+function createListSubcommand() {
+  return new Command("list").description("List all profiles").option("--json", "Output as JSON").action((opts) => {
+    const profiles = listProfiles();
+    if (opts.json) {
+      printJson(profiles);
+      return;
+    }
+    if (profiles.length === 0) {
+      console.log("No profiles found.");
+      return;
+    }
+    for (const p of profiles) {
+      const activeMarker = p.active ? " *" : "  ";
+      const desc = p.description ? `  ${p.description}` : "";
+      console.log(`${activeMarker} ${p.name}${desc}`);
+    }
+  });
+}
+function createUseSubcommand() {
+  return new Command("use").description("Set the active profile").argument("<name>", "Profile name to activate").action((name) => {
+    setActiveProfile(name);
+    console.log(`Active profile: ${name}`);
+  });
+}
+function createShowSubcommand() {
+  return new Command("show").description("Show profile contents (defaults to active profile)").argument("[name]", "Profile name (defaults to active)").option("--json", "Output as JSON").action((name, opts) => {
+    const activeName = readActiveProfileName();
+    const profileName = name ?? activeName;
+    if (!profileName) {
+      console.error(
+        "Error: No active profile. Specify a profile name or set one with: build profile use <name>"
+      );
+      throw new ExitCodeError(1);
+    }
+    const data = readProfile(profileName);
+    const isActive = profileName === activeName;
+    if (opts.json) {
+      printJson({ ...data, active: isActive });
+      return;
+    }
+    console.log(formatProfile(data, isActive));
+  });
+}
+function createCreateSubcommand() {
+  return new Command("create").description("Create a new profile").argument("<name>", "Profile name").option("--from <other>", "Clone settings from another profile").option("--description <text>", "Profile description").option("--provider <id>", "Default provider for this profile").option("--model <id>", "Default model for this profile").addOption(new Option("--strategy <name>").hideHelp()).option("--json", "Output as JSON").action(
+    (name, opts) => {
+      if (opts.provider) {
+        validateProfileProvider(opts.provider);
+      }
+      const providerForModel = resolveProviderContextForModelValidation(
+        opts.provider,
+        opts.from
+      );
+      validateProfileModel(providerForModel, opts.model);
+      if (opts.strategy) {
+        console.warn(
+          "Warning: --strategy is ignored. The variant strategy axis was removed (ADR-025); use --provider or --model."
+        );
+      }
+      const defaults = opts.provider || opts.model ? {
+        provider: opts.provider,
+        model: opts.model
+      } : void 0;
+      const profile = createProfile(name, {
+        fromProfile: opts.from,
+        description: opts.description,
+        defaults
+      });
+      if (opts.json) {
+        printJson(profile);
+        return;
+      }
+      const fromNote = opts.from ? ` (cloned from ${opts.from})` : "";
+      console.log(`Created profile: ${name}${fromNote}`);
+      if (opts.description) console.log(`  description: ${opts.description}`);
+      if (profile.defaults?.provider) console.log(`  provider: ${profile.defaults.provider}`);
+      if (profile.defaults?.model) console.log(`  model: ${profile.defaults.model}`);
+    }
+  );
+}
+function createDeleteSubcommand() {
+  return new Command("delete").description("Delete a profile").argument("<name>", "Profile name").option("--force", "Force delete even if this is the active profile").option("--json", "Output as JSON").action((name, opts) => {
+    deleteProfile(name, opts.force);
+    if (opts.json) {
+      printJson({ deleted: name });
+      return;
+    }
+    console.log(`Deleted profile: ${name}`);
+  });
+}
+function createExplainSubcommand() {
+  return new Command("explain").description("Show the active profile and how it interacts with configuration resolution").option("--json", "Output as JSON").action((opts) => {
+    const activeName = readActiveProfileName();
+    const profiles = listProfiles();
+    let activeProfileData = null;
+    if (activeName) {
+      try {
+        activeProfileData = readProfile(activeName);
+      } catch {
+      }
+    }
+    const resolved = resolveConfig(void 0, process.cwd(), { strictSynthesisModel: false });
+    if (opts.json) {
+      printJson({
+        activeProfile: activeName ?? null,
+        profileData: activeProfileData,
+        availableProfiles: profiles.map((p) => p.name),
+        resolution: {
+          provider: {
+            value: resolved.defaultProvider.value,
+            source: resolved.defaultProvider.source
+          },
+          model: {
+            value: resolved.defaultModel.value,
+            source: resolved.defaultModel.source
+          },
+          judgeType: {
+            value: resolved.judge.type.value,
+            source: resolved.judge.type.source
+          }
+        }
+      });
+      return;
+    }
+    console.log("Profile resolution:");
+    console.log("");
+    if (activeName && activeProfileData) {
+      console.log(`Active profile: ${activeName}`);
+      if (activeProfileData.description) {
+        console.log(`  ${activeProfileData.description}`);
+      }
+    } else if (activeName) {
+      console.log(`Active profile: ${activeName} (missing \u2014 file not found)`);
+    } else {
+      console.log("Active profile: none");
+    }
+    console.log("");
+    console.log("Precedence order (highest to lowest):");
+    console.log("  1. CLI flags");
+    console.log("  2. Env vars (BUILD_DEFAULT_PROVIDER, BUILD_ACTIVE_PROFILE, ...)");
+    console.log(`  3. Active profile  ${activeName ? `[${activeName}]` : "[none set]"}`);
+    console.log("  4. Project config  (.build-project/config/build.config.jsonc)");
+    console.log(`  5. User config     (${getUserConfigFile()})`);
+    console.log("  6. Registry defaults");
+    console.log("  7. Hardcoded fallback");
+    console.log("");
+    console.log("Effective values:");
+    console.log(
+      `  provider: ${resolved.defaultProvider.value}  [from: ${resolved.defaultProvider.source}]`
+    );
+    console.log(
+      `  model:    ${resolved.defaultModel.value}  [from: ${resolved.defaultModel.source}]`
+    );
+    console.log(
+      `  judge:    ${resolved.judge.type.value}  [from: ${resolved.judge.type.source}]`
+    );
+    if (profiles.length > 1) {
+      console.log("");
+      console.log("Available profiles:");
+      for (const p of profiles) {
+        console.log(`  ${p.active ? "*" : " "} ${p.name}`);
+      }
+    }
+  });
+}
+function createClearSubcommand() {
+  return new Command("clear").description("Clear the active profile (use system defaults)").option("--json", "Output as JSON").action((opts) => {
+    clearActiveProfile();
+    if (opts.json) {
+      printJson({ activeProfile: null });
+      return;
+    }
+    console.log("Active profile cleared.");
+  });
+}
+function createProfileCommand() {
+  const cmd = new Command("profile").description("Manage named user-level configuration profiles");
+  cmd.addCommand(createListSubcommand());
+  cmd.addCommand(createUseSubcommand());
+  cmd.addCommand(createShowSubcommand());
+  cmd.addCommand(createCreateSubcommand());
+  cmd.addCommand(createDeleteSubcommand());
+  cmd.addCommand(createExplainSubcommand());
+  cmd.addCommand(createClearSubcommand());
+  return cmd;
+}
+
+export {
+  createProfileCommand
+};
+//# sourceMappingURL=chunk-3VV5OBGG.js.map