@the-open-engine/zeroshot 6.31.2 → 6.32.0

package/cli/lib/setup-wizard-terminal.js

@@ -0,0 +1,237 @@
+const chalk = require('chalk');
+const {
+  CANCEL_KEYS,
+  beginTerminal,
+  createKeyReader,
+  createSelectionState,
+  parseKeys,
+  reduceSelection,
+} = require('./setup-wizard-input');
+
+const WIZARD_WIDTH = 74;
+const WIZARD_SPINNER = Object.freeze(['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']);
+const ANSI_PATTERN = /\x1b\[[0-?]*[ -/]*[@-~]/g;
+
+function forcedColorLevel(env) {
+  if (!Object.prototype.hasOwnProperty.call(env, 'FORCE_COLOR')) return null;
+  const forced = String(env.FORCE_COLOR).trim();
+  if (forced === '' || forced === 'true') return 1;
+  const parsed = Number(forced);
+  return Number.isInteger(parsed) ? Math.max(0, Math.min(3, parsed)) : 1;
+}
+
+function colorLevel(stdout, env) {
+  if (Object.prototype.hasOwnProperty.call(env, 'NO_COLOR') || env.TERM === 'dumb') return 0;
+  const forced = forcedColorLevel(env);
+  if (forced !== null) return forced;
+  if (!stdout.isTTY) return 0;
+  const depth = typeof stdout.getColorDepth === 'function' ? stdout.getColorDepth(env) : 8;
+  if (depth >= 24) return 3;
+  if (depth >= 8) return 2;
+  return 1;
+}
+
+function accentStyle(colors, level) {
+  if (level >= 3) return colors.hex('#c2240c');
+  if (level >= 2) return colors.ansi256(130);
+  return colors.red;
+}
+
+function createWizardTheme(stdout, env = process.env) {
+  const level = colorLevel(stdout, env);
+  const colors = new chalk.Instance({ level });
+  const accent = accentStyle(colors, level);
+  return {
+    color: level > 0,
+    accent,
+    bold: colors.bold,
+    dim: colors.dim,
+    success: colors.green,
+    warning: colors.yellow,
+    danger: colors.red,
+    plain: (text) => String(text),
+  };
+}
+
+function stripAnsi(text) {
+  return String(text).replace(ANSI_PATTERN, '');
+}
+
+function displayWidth(text) {
+  return [...stripAnsi(text)].length;
+}
+
+function fit(text, maxWidth) {
+  if (maxWidth <= 0) return '';
+  if (displayWidth(text) <= maxWidth) return text;
+  if (maxWidth === 1) return '…';
+  const plain = stripAnsi(text);
+  return `${[...plain].slice(0, maxWidth - 1).join('')}…`;
+}
+
+function terminalWidth(stdout) {
+  const columns = Number.isInteger(stdout.columns) ? stdout.columns : WIZARD_WIDTH;
+  return Math.max(12, Math.min(WIZARD_WIDTH, columns - 2));
+}
+
+function padEndPlain(text, width) {
+  return `${text}${' '.repeat(Math.max(0, width - displayWidth(text)))}`;
+}
+
+function stepGlyph(state) {
+  if (state === 'done') return '◆';
+  if (state === 'active') return '*';
+  if (state === 'failed') return '!';
+  return '◇';
+}
+
+function stepGlyphStyle(theme, state) {
+  if (state === 'failed') return theme.danger;
+  if (state === 'active') return theme.accent;
+  return theme.plain;
+}
+
+function stepHead(theme, state, title, { meta = '', width = WIZARD_WIDTH } = {}) {
+  const glyph = stepGlyph(state);
+  const glyphStyle = stepGlyphStyle(theme, state);
+  const titleStyle = state === 'active' ? theme.bold : theme.plain;
+  const left = `${glyph} ${title}`;
+  const right = fit(meta, Math.max(0, width - displayWidth(left) - 3));
+  const dots = Math.max(2, width - displayWidth(left) - displayWidth(right) - (right ? 2 : 1));
+  return ` ${glyphStyle(glyph)} ${titleStyle(title)} ${theme.dim('·'.repeat(dots))}${right ? ` ${right}` : ''}`;
+}
+
+function gutter(theme, text = '') {
+  return ` ${theme.dim('|')}${text ? ` ${text}` : ''}`;
+}
+
+function line(stdout, text = '') {
+  stdout.write(`${text}\n`);
+}
+
+class LiveRegion {
+  constructor(stdout) {
+    this.stdout = stdout;
+    this.lineCount = 0;
+  }
+
+  _erase() {
+    if (this.lineCount === 0) return;
+    this.stdout.write('\r');
+    if (this.lineCount > 1) this.stdout.write(`\x1b[${this.lineCount - 1}A`);
+    for (let index = 0; index < this.lineCount; index += 1) {
+      this.stdout.write('\x1b[2K');
+      if (index < this.lineCount - 1) this.stdout.write('\n');
+    }
+    if (this.lineCount > 1) this.stdout.write(`\x1b[${this.lineCount - 1}A`);
+    this.stdout.write('\r');
+    this.lineCount = 0;
+  }
+
+  paint(lines) {
+    this._erase();
+    const normalized = lines.map((item) => String(item));
+    if (normalized.length === 0) return;
+    this.stdout.write(normalized.join('\n'));
+    this.lineCount = normalized.length;
+  }
+
+  clear() {
+    this._erase();
+  }
+
+  commit(lines) {
+    this.paint(lines);
+    if (this.lineCount > 0) this.stdout.write('\n');
+    this.lineCount = 0;
+  }
+}
+
+function choiceRadio(theme, choice, selected) {
+  if (choice.disabled) return theme.dim('○');
+  return selected ? theme.accent('◉') : '○';
+}
+
+function choiceLabel(theme, choice, selected) {
+  if (choice.disabled) return theme.dim(choice.label);
+  return selected ? theme.bold(choice.label) : choice.label;
+}
+
+function defaultChoiceFrame({ theme, title, meta, choices, state, stdout, orientation }) {
+  const width = terminalWidth(stdout);
+  const rows = [stepHead(theme, 'active', title, { meta, width }), gutter(theme)];
+  if (orientation === 'horizontal') {
+    const actions = choices
+      .map((choice, index) => {
+        const selected = index === state.selected;
+        const label = selected ? theme.bold(choice.label) : theme.dim(choice.label);
+        return `${selected ? '▸' : ' '} ${label}`;
+      })
+      .join('   ');
+    rows.push(gutter(theme, fit(actions, width - 3)));
+    rows.push(gutter(theme));
+    rows.push(gutter(theme, theme.dim('←→ choose · ↵ confirm · esc cancel')));
+    return rows;
+  }
+  choices.forEach((choice, index) => {
+    const selected = index === state.selected;
+    const marker = selected ? theme.accent('▸') : ' ';
+    const radio = choiceRadio(theme, choice, selected);
+    const label = choiceLabel(theme, choice, selected);
+    rows.push(gutter(theme, fit(`${marker} ${radio} ${label}`, width - 3)));
+  });
+  rows.push(gutter(theme));
+  rows.push(gutter(theme, theme.dim('↑↓ move · ↵ confirm · esc cancel')));
+  return rows;
+}
+
+async function selectChoice({
+  stdout,
+  reader,
+  live = new LiveRegion(stdout),
+  theme = createWizardTheme(stdout),
+  title,
+  meta = '',
+  choices,
+  initial = 0,
+  orientation = 'vertical',
+  renderFrame = defaultChoiceFrame,
+}) {
+  let state = createSelectionState(choices, initial);
+  if (state.selected < 0) return null;
+  live.paint(renderFrame({ theme, title, meta, choices, state, stdout, orientation }));
+  while (state.status === 'active') {
+    const key = await reader.read();
+    const next = reduceSelection(state, key, choices, orientation);
+    if (key === 'resize' || next !== state) {
+      state = next;
+      if (state.status === 'active') {
+        live.paint(renderFrame({ theme, title, meta, choices, state, stdout, orientation }));
+      }
+    }
+  }
+  live.clear();
+  return state.status === 'confirmed' ? state.value : null;
+}
+
+module.exports = {
+  CANCEL_KEYS,
+  LiveRegion,
+  WIZARD_SPINNER,
+  WIZARD_WIDTH,
+  beginTerminal,
+  createKeyReader,
+  createSelectionState,
+  createWizardTheme,
+  displayWidth,
+  fit,
+  gutter,
+  line,
+  padEndPlain,
+  parseKeys,
+  reduceSelection,
+  selectChoice,
+  stepHead,
+  stripAnsi,
+  terminalWidth,
+};

package/cli/lib/setup-wizard-view.js

@@ -0,0 +1,180 @@
+const {
+  LiveRegion,
+  createWizardTheme,
+  fit,
+  gutter,
+  line,
+  selectChoice,
+  stepHead,
+  terminalWidth,
+} = require('./setup-wizard-terminal');
+const {
+  createPlanState,
+  planFrame,
+  reducePlanState,
+  renderApplyFrame,
+  selectPlan,
+} = require('./setup-wizard-plan-view');
+const { ScanPresenter, formatSeconds, probeDetail } = require('./setup-wizard-scan-view');
+
+function readinessStyle(theme, status) {
+  if (status === 'ready') return theme.success;
+  if (status === 'login-required') return theme.warning;
+  if (status === 'incompatible') return theme.danger;
+  return theme.dim;
+}
+
+function providerRadio(theme, choice, selected) {
+  if (choice.disabled) return theme.dim('○');
+  return selected ? theme.accent('◉') : '○';
+}
+
+function providerChoiceFrame({ theme, title, meta, choices, state, stdout }) {
+  const width = terminalWidth(stdout);
+  const rows = [stepHead(theme, 'active', title, { meta, width }), gutter(theme)];
+  choices.forEach((choice, index) => {
+    const selected = index === state.selected;
+    const cursor = selected ? theme.accent('▸') : ' ';
+    const radio = providerRadio(theme, choice, selected);
+    const style = readinessStyle(theme, choice.status);
+    const name = selected && !choice.disabled ? theme.bold(choice.label) : style(choice.label);
+    rows.push(gutter(theme, fit(`${cursor} ${radio} ${name} ${style(choice.status)}`, width - 3)));
+    if (selected && choice.detail) {
+      rows.push(gutter(theme, fit(theme.dim(`  ${choice.detail}`), width - 3)));
+    }
+  });
+  rows.push(gutter(theme));
+  rows.push(gutter(theme, theme.dim('↑↓ move · ↵ confirm · esc cancel')));
+  return rows;
+}
+
+class WizardRenderer {
+  constructor({ stdout, env = process.env, clock = globalThis, motion } = {}) {
+    this.stdout = stdout;
+    this.theme = createWizardTheme(stdout, env);
+    this.live = new LiveRegion(stdout);
+    this.clock = clock;
+    this.motion = motion ?? (env.CI !== 'true' && env.TERM !== 'dumb');
+  }
+
+  intro() {
+    line(this.stdout, this.theme.bold(this.theme.accent('zeroshot')));
+    line(
+      this.stdout,
+      this.theme.dim('Independent execution. Verified changes. · read-only until Apply')
+    );
+    line(this.stdout);
+  }
+
+  scanPresenter() {
+    return new ScanPresenter({
+      stdout: this.stdout,
+      theme: this.theme,
+      live: this.live,
+      motion: this.motion,
+      clock: this.clock,
+    });
+  }
+
+  async choose({ title, meta, choices, initial, reader, provider = false }) {
+    const value = await selectChoice({
+      stdout: this.stdout,
+      reader,
+      live: this.live,
+      theme: this.theme,
+      title,
+      meta,
+      choices,
+      initial,
+      renderFrame: provider ? providerChoiceFrame : undefined,
+    });
+    if (value === null) return null;
+    const choice = choices.find((item) => item.value === value);
+    this.live.commit([
+      stepHead(this.theme, 'done', title, {
+        meta: choice.label,
+        width: terminalWidth(this.stdout),
+      }),
+      gutter(this.theme, choice.detail || choice.label),
+      gutter(this.theme),
+    ]);
+    return value;
+  }
+
+  plan(reader, buildModel) {
+    return selectPlan({
+      stdout: this.stdout,
+      reader,
+      live: this.live,
+      theme: this.theme,
+      buildModel,
+    });
+  }
+
+  applyStarted() {
+    this.live.paint(
+      renderApplyFrame({ stdout: this.stdout, theme: this.theme, results: [], verified: false })
+    );
+  }
+
+  applyReceipts(results) {
+    for (let count = 1; count <= results.length; count += 1) {
+      this.live.paint(
+        renderApplyFrame({
+          stdout: this.stdout,
+          theme: this.theme,
+          results: results.slice(0, count),
+          verified: false,
+        })
+      );
+    }
+  }
+
+  applyVerified(results) {
+    this.live.commit(
+      renderApplyFrame({ stdout: this.stdout, theme: this.theme, results, verified: true })
+    );
+  }
+
+  failed(title, error, results = []) {
+    this.live.commit(
+      renderApplyFrame({ stdout: this.stdout, theme: this.theme, results, failed: true })
+    );
+    line(this.stdout, `${this.theme.danger('!')} ${title}`);
+    line(this.stdout, `  ${error.message}`);
+  }
+
+  fatal(title, error) {
+    this.live.clear();
+    line(this.stdout, `${this.theme.danger('!')} ${title}`);
+    line(this.stdout, `  ${error.message}`);
+  }
+
+  ready(provider, isolation) {
+    const width = terminalWidth(this.stdout);
+    this.live.commit([
+      stepHead(this.theme, 'done', 'Ready', { meta: `${provider} · ${isolation}`, width }),
+      gutter(this.theme, this.theme.bold('zeroshot run "Describe the change"')),
+      gutter(this.theme, 'undo: zeroshot setup undo'),
+      gutter(this.theme),
+    ]);
+  }
+
+  cancelled() {
+    this.live.clear();
+    line(this.stdout, this.theme.dim('Setup cancelled. Nothing was written.'));
+  }
+}
+
+module.exports = {
+  ScanPresenter,
+  WizardRenderer,
+  createPlanState,
+  formatSeconds,
+  planFrame,
+  probeDetail,
+  providerChoiceFrame,
+  reducePlanState,
+  renderApplyFrame,
+  selectPlan,
+};

package/cli/lib/setup-wizard.js

@@ -0,0 +1,281 @@
+const { isDeepStrictEqual } = require('util');
+
+const { applyDecisionValues } = require('../../lib/setup-apply');
+const { buildSetupPlan, getNestedValue, resolveDecisionPath } = require('../../lib/setup-plan');
+const {
+  getSettingsFile,
+  loadSettings,
+  mutateSettings,
+  settingsFileExists,
+} = require('../../lib/settings');
+const { readRepoSettings } = require('../../lib/repo-settings');
+const { runPreflight } = require('../../src/preflight');
+const { providerChoices } = require('./setup-provider-readiness');
+const { scanSetupEnvironment } = require('./setup-scanner');
+const {
+  buildWizardDecisions,
+  buildWizardPlanModel,
+  collectSetupScan,
+  isolationChoices,
+  preferredIndex,
+} = require('./setup-wizard-model');
+const {
+  beginTerminal,
+  createKeyReader,
+  line,
+  parseKeys,
+  selectChoice,
+  stripAnsi,
+} = require('./setup-wizard-terminal');
+const { WizardRenderer } = require('./setup-wizard-view');
+
+function defaultDeps() {
+  return {
+    applyDecisionValues,
+    buildSetupPlan,
+    getSettingsFile,
+    loadSettings,
+    mutateSettings,
+    readRepoSettings,
+    runPreflight,
+    scanSetupEnvironment,
+    settingsFileExists,
+  };
+}
+
+function verifyPersistedDecisions(decisions, persisted) {
+  for (const [decisionId, expected] of Object.entries(decisions)) {
+    const target = resolveDecisionPath(decisionId);
+    if (!target || target.scope !== 'global') continue;
+    const actual = getNestedValue(persisted, target.path);
+    if (decisionId.startsWith('providerLevel.')) {
+      for (const [key, value] of Object.entries(expected)) {
+        if (actual?.[key] !== value) {
+          throw new Error(`Persisted ${target.path}.${key} did not match the approved plan`);
+        }
+      }
+    } else if (!isDeepStrictEqual(actual, expected)) {
+      throw new Error(`Persisted ${target.path} did not match the approved plan`);
+    }
+  }
+}
+
+function preflightFailure(result) {
+  const message = result.errors
+    .map((error) => stripAnsi(error).trim())
+    .filter(Boolean)
+    .join('\n');
+  return new Error(message || 'Setup preflight failed');
+}
+
+async function verifyAppliedSetup({ resolved, decisions, provider, isolation, cwd }) {
+  const persisted = resolved.loadSettings();
+  verifyPersistedDecisions(decisions, persisted);
+  const preflight = await resolved.runPreflight({
+    cwd,
+    settings: persisted,
+    provider,
+    requireDocker: isolation === 'docker',
+    requireGit: isolation === 'worktree',
+    quiet: true,
+  });
+  if (!preflight.valid) throw preflightFailure(preflight);
+  return { persisted, preflight };
+}
+
+function renderBlockedProviders(renderer, choices) {
+  const theme = renderer.theme;
+  line(renderer.stdout, theme.danger('No provider is ready for the selected isolation.'));
+  for (const choice of choices) {
+    line(
+      renderer.stdout,
+      `  ${choice.label}: ${choice.status}${choice.detail ? ` · ${choice.detail}` : ''}`
+    );
+    const action =
+      choice.status === 'unavailable' ? choice.installInstructions : choice.authInstructions;
+    if (action) line(renderer.stdout, `    ${action.split('\n')[0]}`);
+  }
+  line(renderer.stdout, 'Run `zeroshot setup` again after resolving one provider.');
+}
+
+function cancelledResult(renderer, plan) {
+  renderer.cancelled();
+  return { status: 'cancelled', applied: false, exitCode: 130, plan };
+}
+
+function hasAvailableProvider(probes) {
+  return Object.entries(probes).some(
+    ([id, probe]) => id.startsWith('provider:') && probe.available
+  );
+}
+
+function blockedProviderResult(renderer, request) {
+  renderBlockedProviders(renderer, providerChoices(request));
+  return { status: 'no-provider', applied: false, exitCode: 1, plan: request.plan };
+}
+
+async function chooseWizardConfiguration({ renderer, reader, plan, probes, settings }) {
+  const isolations = isolationChoices(plan);
+  if (!hasAvailableProvider(probes)) {
+    const preview = isolations.find((choice) => !choice.disabled)?.value || 'none';
+    return {
+      result: blockedProviderResult(renderer, { plan, probes, isolation: preview, settings }),
+    };
+  }
+  const isolation = await renderer.choose({
+    title: 'Isolation',
+    meta: 'execution context',
+    choices: isolations,
+    initial: preferredIndex(isolations, plan.recommended.defaultIsolation),
+    reader,
+  });
+  if (!isolation) return { result: cancelledResult(renderer, plan) };
+  const providers = providerChoices({ plan, probes, isolation, settings });
+  if (!providers.some((choice) => !choice.disabled)) {
+    return {
+      result: blockedProviderResult(renderer, { plan, probes, isolation, settings }),
+    };
+  }
+  const provider = await renderer.choose({
+    title: 'Provider',
+    meta: `${isolation}-compatible`,
+    choices: providers,
+    initial: preferredIndex(providers, plan.recommended.defaultProvider),
+    reader,
+    provider: true,
+  });
+  return provider ? { provider, isolation } : { result: cancelledResult(renderer, plan) };
+}
+
+async function applyApprovedPlan({
+  renderer,
+  resolved,
+  plan,
+  provider,
+  isolation,
+  enabledGroups,
+  cwd,
+}) {
+  renderer.applyStarted();
+  const decisions = buildWizardDecisions(plan, provider, isolation, enabledGroups);
+  let receipts = [];
+  try {
+    receipts = resolved.applyDecisionValues({ decisions, cwd });
+    renderer.applyReceipts(receipts);
+    const verification = await verifyAppliedSetup({
+      resolved,
+      decisions,
+      provider,
+      isolation,
+      cwd,
+    });
+    resolved.mutateSettings((current) => {
+      current.setupVersion = 1;
+    });
+    renderer.applyVerified(receipts);
+    renderer.ready(provider, isolation);
+    return {
+      status: 'applied',
+      applied: true,
+      exitCode: 0,
+      decisions,
+      results: receipts,
+      verification,
+      plan,
+    };
+  } catch (error) {
+    renderer.failed('Setup was not completed.', error, receipts);
+    return {
+      status: 'failed',
+      applied: receipts.some((receipt) => receipt.applied),
+      exitCode: 1,
+      error,
+    };
+  }
+}
+
+async function runSetupWizard({
+  cwd = process.cwd(),
+  stdin = process.stdin,
+  stdout = process.stdout,
+  env = process.env,
+  deps = {},
+} = {}) {
+  if (!stdin.isTTY || !stdout.isTTY) {
+    line(stdout, 'Interactive setup requires a TTY.');
+    line(stdout, 'Use `zeroshot setup plan` and `zeroshot setup apply --decisions <file>`.');
+    return { status: 'non-interactive', applied: false, exitCode: 1 };
+  }
+  const resolved = { ...defaultDeps(), ...deps };
+  const settings = resolved.loadSettings();
+  settings.__meta = { fileExists: resolved.settingsFileExists() };
+  const { settings: repoSettings } = resolved.readRepoSettings(cwd);
+  const restoreTerminal = beginTerminal(stdin, stdout);
+  const reader = createKeyReader(stdin, stdout);
+  const renderer = new WizardRenderer({
+    stdout,
+    env,
+    clock: resolved.clock,
+    motion: resolved.motion,
+  });
+  try {
+    renderer.intro();
+    const scanPresenter = renderer.scanPresenter();
+    const scan = await collectSetupScan({
+      cwd,
+      settings,
+      repoSettings,
+      env,
+      resolved,
+      deps,
+      onProgress: (event) => scanPresenter.handle(event),
+    });
+    scanPresenter.commit(scan);
+    const selection = await chooseWizardConfiguration({
+      renderer,
+      reader,
+      plan: scan.plan,
+      probes: scan.probes,
+      settings,
+    });
+    if (selection.result) return selection.result;
+    const settingsFile = resolved.getSettingsFile();
+    const buildModel = (enabledGroups) =>
+      buildWizardPlanModel({
+        plan: scan.plan,
+        settings,
+        settingsFile,
+        provider: selection.provider,
+        isolation: selection.isolation,
+        enabledGroups,
+      });
+    const approval = await renderer.plan(reader, buildModel);
+    if (approval.action !== 'apply') return cancelledResult(renderer, scan.plan);
+    return applyApprovedPlan({
+      renderer,
+      resolved,
+      plan: scan.plan,
+      provider: selection.provider,
+      isolation: selection.isolation,
+      enabledGroups: approval.enabled,
+      cwd,
+    });
+  } catch (error) {
+    renderer.fatal('Setup scan failed.', error);
+    return { status: 'failed', applied: false, exitCode: 1, error };
+  } finally {
+    reader.close();
+    restoreTerminal();
+  }
+}
+
+module.exports = {
+  runSetupWizard,
+  buildWizardDecisions,
+  buildWizardPlanModel,
+  isolationChoices,
+  parseKeys,
+  preferredIndex,
+  selectChoice,
+  verifyPersistedDecisions,
+};