@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-7NVJMH52.js

@@ -0,0 +1,306 @@
+import {
+  judgeCliOverlay,
+  resolveJudgeTierSettings
+} from "./chunk-ARARVIZK.js";
+import {
+  resolveCompeteConfig
+} from "./chunk-EN62WLFD.js";
+import {
+  resolveInheritanceMode
+} from "./chunk-6CAU7VBA.js";
+import {
+  tryResolveInstructionsImportOffer
+} from "./chunk-IYY3HQAD.js";
+import {
+  readNativeProviderDefaults
+} from "./chunk-7HYBSRPZ.js";
+import {
+  loadAskPresetsWithSources
+} from "./chunk-FUUVZZUB.js";
+import {
+  formatResolvedValue,
+  loadProviderRegistryForCwd,
+  resolveFastModel,
+  resolveJudgeConfig,
+  resolvePreferred,
+  resolveSplitterExecution,
+  resolveSynthesisProvider,
+  resolveSynthesisReasoningEffort
+} from "./chunk-C3DH3NCY.js";
+import {
+  isProviderCliResolvable
+} from "./chunk-KKQKWAMF.js";
+import {
+  ProviderRegistry
+} from "./chunk-QJ6OEH4K.js";
+import {
+  sanitizeValue
+} from "./chunk-CPSVQR2I.js";
+
+// src/cli/commands/config-resolved-extras.ts
+var RESOLVED_ENV_OVERRIDE_KEYS = [
+  "BUILD_DEFAULT_PROVIDER",
+  "BUILD_JUDGE_TYPE",
+  "BUILD_JUDGE",
+  "BUILD_JUDGE_RUN",
+  "BUILD_JUDGE_PRIMARY",
+  "BUILD_AI_JUDGE_RUN",
+  "BUILD_AI_JUDGE_PRIMARY",
+  "BUILD_COMPLETION_MODE",
+  "BUILD_TIMEOUT_MS",
+  "BUILD_CLAUDE_EXECUTION_TRANSPORT",
+  "BUILD_CODEX_EXECUTION_TRANSPORT",
+  "BUILD_PROVIDER_EXECUTION_TRANSPORT",
+  "BUILD_EXECUTION_TRANSPORT",
+  "BUILD_SYNTHESIS_STRATEGY",
+  "BUILD_SYNTHESIS_AI_FIRST"
+];
+function describeInheritance(cwd) {
+  const describe = (setting) => {
+    const resolved = resolveInheritanceMode(setting, cwd);
+    return resolved ? formatResolvedValue(resolved) : "unset (agent default)";
+  };
+  return { automated: describe("automated"), ask: describe("ask") };
+}
+function describeInstructionsImport() {
+  return tryResolveInstructionsImportOffer() ?? null;
+}
+
+// src/cli/commands/config-resolved-view.ts
+var AGENT_DEFAULT = "agent default";
+function fastFallbackLabel(defaultModel) {
+  return `falls back to default model (${defaultModel})`;
+}
+var ASK_DEFAULTS_SUMMARY = "agent default model and effort (override with --model, --effort, or a preset)";
+var JUDGE_TYPES = ["ai", "multi-lens"];
+function errorMessage(error) {
+  return sanitizeValue(error);
+}
+function shown(value) {
+  if (!value) return void 0;
+  return {
+    value: String(value.value),
+    source: value.source,
+    ...value.sourcePath ? { sourcePath: value.sourcePath } : {}
+  };
+}
+function formatShown(value) {
+  return value ? formatResolvedValue(value) : "unresolved";
+}
+function formatEffort(value) {
+  return value ? formatShown(value) : AGENT_DEFAULT;
+}
+function attribute(runs, looked, fallback) {
+  if (runs === void 0) return void 0;
+  return looked && String(looked.value) === runs ? shown(looked) : fallback();
+}
+async function buildJudgeRow(type, cwd, defaultType) {
+  const base = { type, isDefault: type === defaultType };
+  let lookup;
+  try {
+    lookup = resolveJudgeConfig(judgeCliOverlay(type, { cwd }), cwd, type);
+  } catch (error) {
+    return { ...base, reasoningEffort: null, error: errorMessage(error) };
+  }
+  let tier;
+  try {
+    tier = await resolveJudgeTierSettings(type, { cwd });
+  } catch (error) {
+    return {
+      ...base,
+      provider: shown(lookup.provider),
+      model: shown(lookup.model),
+      reasoningEffort: shown(lookup.reasoningEffort) ?? null,
+      error: errorMessage(error)
+    };
+  }
+  const role = tier.judgeModelResolvedRoles?.find((entry) => entry.judgeType === type);
+  const provider = attribute(tier.provider, lookup.provider, () => ({
+    value: tier.provider,
+    source: "fallback",
+    sourcePath: `judge:${type} tier`
+  }));
+  const model = attribute(tier.model, lookup.model, () => ({
+    value: tier.model,
+    source: "registry",
+    sourcePath: role?.promotionReason ? `judge:arbiter quality floor (requested ${role.requestedModel ?? lookup.model.value})` : `providers.yaml#providers.${tier.provider}.models (judge role)`
+  }));
+  const reasoningEffort = attribute(tier.reasoningEffort, lookup.reasoningEffort, () => ({
+    value: tier.reasoningEffort,
+    source: "fallback",
+    sourcePath: `judge:${type} tier`
+  })) ?? null;
+  return {
+    ...base,
+    provider,
+    model,
+    reasoningEffort
+  };
+}
+function summarizeJudgeRow(row, resolved) {
+  return {
+    type: row.type,
+    provider: row.provider?.value ?? resolved.judge.provider.value,
+    model: row.model?.value ?? resolved.judge.model.value,
+    reasoningEffort: row.reasoningEffort?.value ?? null,
+    ...row.error ? { error: row.error } : {}
+  };
+}
+function formatSummaryJudge(judge) {
+  const line = `${judge.type} (${judge.provider}, ${judge.model}, ${judge.reasoningEffort ?? AGENT_DEFAULT})`;
+  return judge.error ? `${line}, error: ${judge.error}` : line;
+}
+function buildSynthesisView(resolved, cwd) {
+  try {
+    const candidate = resolvePreferred("synthesis", { cwd });
+    return {
+      provider: {
+        value: candidate.provider,
+        source: candidate.providerSource,
+        sourcePath: candidate.providerSourcePath
+      },
+      model: {
+        value: candidate.model,
+        source: candidate.modelSource,
+        sourcePath: candidate.modelSourcePath
+      },
+      reasoningEffort: shown(resolveSynthesisReasoningEffort(void 0, cwd, candidate.provider)) ?? null
+    };
+  } catch (error) {
+    let provider;
+    try {
+      provider = shown(resolveSynthesisProvider(void 0, cwd));
+    } catch {
+      provider = void 0;
+    }
+    return {
+      ...provider ? { provider } : {},
+      model: shown(resolved.synthesisModel),
+      reasoningEffort: shown(resolved.synthesisReasoningEffort) ?? null,
+      error: errorMessage(error)
+    };
+  }
+}
+function buildSplitterView(resolved, cwd) {
+  try {
+    const splitter = resolveSplitterExecution(void 0, cwd);
+    return {
+      provider: shown(splitter.provider),
+      model: shown(splitter.model),
+      reasoningEffort: shown(splitter.reasoningEffort) ?? null
+    };
+  } catch (error) {
+    return {
+      model: shown(resolved.splitterModel),
+      reasoningEffort: shown(resolved.splitterReasoningEffort) ?? null,
+      error: errorMessage(error)
+    };
+  }
+}
+function buildProviderRows(resolved, cwd, projectRoot = cwd) {
+  const registry = loadProviderRegistryForCwd(cwd);
+  return Object.entries(resolved.providerModels).map(([id, model]) => {
+    const row = {
+      id,
+      installed: isProviderCliResolvable(id, registry),
+      model: shown(model),
+      reasoningEffort: shown(resolved.providerReasoningEfforts[id]) ?? null,
+      fastModel: null,
+      nativeDefaults: readNativeProviderDefaults(id, projectRoot)
+    };
+    try {
+      const fast = resolveFastModel(id, { cwd, registry });
+      row.fastModel = fast.slot === "default" ? null : shown(fast) ?? null;
+      const judgeModel = ProviderRegistry.getModelForRole(id, "judge_primary", registry);
+      if (judgeModel) {
+        const judgeEffort = ProviderRegistry.getJudgeReasoningEffort(id, registry);
+        row.judge = {
+          model: {
+            value: judgeModel,
+            source: "registry",
+            sourcePath: `providers.yaml#providers.${id}.models.roles.judge_primary`
+          },
+          reasoningEffort: judgeEffort ? {
+            value: judgeEffort,
+            source: "registry",
+            sourcePath: `providers.yaml#providers.${id}.models.judge_reasoning_effort`
+          } : null
+        };
+      }
+    } catch (error) {
+      row.error = errorMessage(error);
+    }
+    return row;
+  });
+}
+function buildAskView(cwd) {
+  const base = { summary: ASK_DEFAULTS_SUMMARY, model: null, reasoningEffort: null };
+  try {
+    const presets = loadAskPresetsWithSources(cwd).map(({ name, source, preset }) => ({
+      name,
+      source,
+      ...preset
+    }));
+    return { ...base, presets };
+  } catch (error) {
+    return { ...base, presets: [], error: errorMessage(error) };
+  }
+}
+function listRegistrySources(cwd) {
+  loadProviderRegistryForCwd(cwd);
+  return ProviderRegistry.getLoadedConfigSources();
+}
+async function buildExecutionPreview(resolved, projectRoot, cwd = process.cwd()) {
+  let compete;
+  try {
+    compete = await resolveCompeteConfig({}, { projectRoot });
+  } catch (error) {
+    compete = { error: errorMessage(error) };
+  }
+  const defaultType = resolved.judge.type.value;
+  const judges = [];
+  for (const type of JUDGE_TYPES) {
+    judges.push(await buildJudgeRow(type, projectRoot, defaultType));
+  }
+  const defaultJudge = judges.find((judge) => judge.isDefault);
+  const judgeRow = defaultJudge?.provider ? defaultJudge : void 0;
+  return {
+    run: {
+      provider: formatResolvedValue(resolved.defaultProvider),
+      model: formatResolvedValue(resolved.defaultModel),
+      reasoningEffort: formatEffort(
+        shown(resolved.providerReasoningEfforts[resolved.defaultProvider.value])
+      ),
+      transport: formatResolvedValue(resolved.providerExecutionTransport.current),
+      judge: {
+        type: formatResolvedValue(resolved.judge.type),
+        provider: judgeRow ? formatShown(judgeRow.provider) : formatResolvedValue(resolved.judge.provider),
+        model: judgeRow ? formatShown(judgeRow.model) : formatResolvedValue(resolved.judge.model),
+        reasoningEffort: judgeRow ? formatEffort(judgeRow.reasoningEffort) : formatEffort(shown(resolved.judge.reasoningEffort)),
+        ...defaultJudge?.error ? { error: defaultJudge.error } : {}
+      }
+    },
+    judges,
+    synthesis: buildSynthesisView(resolved, cwd),
+    splitter: buildSplitterView(resolved, cwd),
+    providers: buildProviderRows(resolved, cwd, projectRoot),
+    ask: buildAskView(cwd),
+    registrySources: listRegistrySources(cwd),
+    compete,
+    inheritance: describeInheritance(projectRoot),
+    envOverrides: RESOLVED_ENV_OVERRIDE_KEYS.filter((key) => process.env[key]?.trim())
+  };
+}
+
+export {
+  describeInstructionsImport,
+  AGENT_DEFAULT,
+  fastFallbackLabel,
+  formatShown,
+  formatEffort,
+  buildJudgeRow,
+  summarizeJudgeRow,
+  formatSummaryJudge,
+  buildExecutionPreview
+};
+//# sourceMappingURL=chunk-7NVJMH52.js.map

package/dist/chunk-7RMARDVH.js

@@ -0,0 +1,33 @@
+// src/core/config/review-policy.ts
+var DEFAULT_REVIEW_POLICY = "repair:high";
+function parseReviewPolicy(value) {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "off" || normalized === "advisory") {
+    return { value: normalized, action: normalized };
+  }
+  const match = /^(block|repair):(critical|high|medium|low)$/.exec(normalized);
+  if (!match) return null;
+  const action = match[1];
+  const level = match[2];
+  return { value: `${action}:${level}`, action, level };
+}
+function reviewPolicyFromLegacy(gate, threshold = "high") {
+  if (gate === "off" || gate === "advisory") return gate;
+  return `repair:${threshold}`;
+}
+function reviewPolicyBlocks(policy) {
+  return policy.action === "block" || policy.action === "repair";
+}
+function reviewPolicyRepairs(policy) {
+  return policy.action === "repair";
+}
+
+export {
+  DEFAULT_REVIEW_POLICY,
+  parseReviewPolicy,
+  reviewPolicyFromLegacy,
+  reviewPolicyBlocks,
+  reviewPolicyRepairs
+};
+//# sourceMappingURL=chunk-7RMARDVH.js.map

package/dist/chunk-7SEWU4QG.js

@@ -0,0 +1,36 @@
+// src/core/providers/shared/native-subagent-guidance.ts
+var NATIVE_SUBAGENT_GUIDANCE_HEADING = "Provider-native subagents:";
+function appendNativeSubagentGuidance(prompt, request, options = {}) {
+  if (prompt.includes(NATIVE_SUBAGENT_GUIDANCE_HEADING)) {
+    return { prompt, applied: false };
+  }
+  const requestLine = typeof request === "number" ? `Use up to ${request} native subagents if useful for this task.` : "Use native subagents when useful for this task.";
+  const guidance = [
+    "",
+    NATIVE_SUBAGENT_GUIDANCE_HEADING,
+    requestLine,
+    "Use fewer or none for narrow work.",
+    "Give subagents disjoint responsibilities, ask them for concise findings or changes, then synthesize the final answer yourself.",
+    ...options.concurrencyHint ? [options.concurrencyHint] : [],
+    "Do not run Build commands recursively."
+  ].join("\n");
+  return { prompt: `${prompt.trimEnd()}
+${guidance}`, applied: true };
+}
+var GUIDANCE_END = "Do not run Build commands recursively.";
+function removeNativeSubagentGuidance(prompt) {
+  const start = prompt.indexOf(`
+
+${NATIVE_SUBAGENT_GUIDANCE_HEADING}
+`);
+  if (start < 0) return prompt;
+  const end = prompt.indexOf(GUIDANCE_END, start);
+  if (end < 0) return prompt;
+  return prompt.slice(0, start) + prompt.slice(end + GUIDANCE_END.length);
+}
+
+export {
+  appendNativeSubagentGuidance,
+  removeNativeSubagentGuidance
+};
+//# sourceMappingURL=chunk-7SEWU4QG.js.map