@the-open-engine/zeroshot 6.31.3 → 6.32.1

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

@@ -0,0 +1,205 @@
+const { isDeepStrictEqual } = require('util');
+
+const { getNestedValue, resolveDecisionPath } = require('../../lib/setup-plan');
+
+function enabled(enabledGroups, id) {
+  return enabledGroups?.[id] !== false;
+}
+
+function buildWizardDecisions(plan, provider, isolation, enabledGroups = {}) {
+  const decisions = {
+    defaultProvider: provider,
+    [`providerLevel.${provider}`]: plan.recommended[`providerLevel.${provider}`],
+    defaultIsolation: isolation,
+    defaultDelivery: 'none',
+  };
+  if (enabled(enabledGroups, 'issue-source')) {
+    decisions.defaultIssueSource = plan.recommended.defaultIssueSource;
+  }
+  if (enabled(enabledGroups, 'updates')) decisions.updatePolicy = plan.recommended.updatePolicy;
+  if (isolation === 'docker' && enabled(enabledGroups, 'docker')) {
+    decisions.dockerMounts = plan.recommended.dockerMounts;
+    decisions.dockerEnvPassthrough = plan.recommended.dockerEnvPassthrough;
+  }
+  return decisions;
+}
+
+function previewValue(decisionId, value, settings) {
+  if (!decisionId.startsWith('providerLevel.')) return value;
+  const provider = decisionId.slice('providerLevel.'.length);
+  return { ...(settings.providerSettings?.[provider] || {}), ...value };
+}
+
+function decisionPreview(decisionId, value, settings, settingsFile) {
+  const target = resolveDecisionPath(decisionId);
+  if (!target) throw new Error(`Unknown setup decision: ${decisionId}`);
+  const source = target.scope === 'global' ? settings : {};
+  const from = getNestedValue(source, target.path) ?? null;
+  const to = previewValue(decisionId, value, settings);
+  if (isDeepStrictEqual(from, to)) return null;
+  return {
+    decisionId,
+    scope: target.scope,
+    path: target.path,
+    from,
+    to,
+    targetFile: target.scope === 'global' ? settingsFile : '.zeroshot/settings.json',
+  };
+}
+
+function groupDefinition(id, title, required, decisionIds) {
+  return { id, title, required, decisionIds };
+}
+
+function wizardDecisionGroups(provider, isolation) {
+  const groups = [
+    groupDefinition('execution', 'Execution defaults', true, [
+      'defaultProvider',
+      `providerLevel.${provider}`,
+      'defaultIsolation',
+      'defaultDelivery',
+    ]),
+    groupDefinition('issue-source', 'Repository integration', false, ['defaultIssueSource']),
+    groupDefinition('updates', 'Update notifications', false, ['updatePolicy']),
+  ];
+  if (isolation === 'docker') {
+    groups.splice(
+      1,
+      0,
+      groupDefinition('docker', 'Docker defaults', true, ['dockerMounts', 'dockerEnvPassthrough'])
+    );
+  }
+  return groups;
+}
+
+function buildWizardPlanModel({
+  plan,
+  settings,
+  settingsFile,
+  provider,
+  isolation,
+  enabledGroups,
+}) {
+  const decisions = buildWizardDecisions(plan, provider, isolation, enabledGroups);
+  const previewById = new Map();
+  for (const [decisionId, value] of Object.entries(decisions)) {
+    const preview = decisionPreview(decisionId, value, settings, settingsFile);
+    if (preview) previewById.set(decisionId, preview);
+  }
+  const groups = wizardDecisionGroups(provider, isolation).map((group) => ({
+    ...group,
+    enabled: group.required || enabled(enabledGroups, group.id),
+    writes: group.decisionIds.map((id) => previewById.get(id)).filter(Boolean),
+  }));
+  const writes = groups.flatMap((group) => (group.enabled ? group.writes : []));
+  return {
+    decisions,
+    groups,
+    writes,
+    files: [...new Set(writes.map((write) => write.targetFile))],
+  };
+}
+
+function isolationChoices(plan) {
+  return [
+    {
+      value: 'worktree',
+      label: 'Worktree',
+      detail: plan.facts.git.isRepo
+        ? 'isolated checkout · current checkout untouched'
+        : 'unavailable · not a git repository',
+      disabled: !plan.facts.git.isRepo,
+    },
+    {
+      value: 'docker',
+      label: 'Docker',
+      detail: plan.facts.docker.available
+        ? 'strongest isolation · slower startup'
+        : 'unavailable · Docker is not running',
+      disabled: !plan.facts.docker.available,
+    },
+    {
+      value: 'none',
+      label: 'Current checkout',
+      detail: 'no isolation · edits the active checkout directly',
+      disabled: false,
+    },
+  ];
+}
+
+function preferredIndex(choices, preferredValue) {
+  const preferred = choices.findIndex(
+    (choice) => choice.value === preferredValue && !choice.disabled
+  );
+  if (preferred >= 0) return preferred;
+  return choices.findIndex((choice) => !choice.disabled);
+}
+
+function syntheticScan(plan, onProgress) {
+  const providerSpecs = Object.keys(plan.facts.providers).map((id) => ({ kind: 'provider', id }));
+  const specs = [{ kind: 'git' }, { kind: 'docker' }, { kind: 'issue' }, ...providerSpecs];
+  const probes = {
+    git: { ...plan.facts.git, clean: true, defaultBranch: plan.facts.git.branch },
+    docker: { ...plan.facts.docker },
+    issue: {
+      installed: plan.facts.git.ghAvailable === true,
+      authenticated: plan.facts.git.ghAuthed === true,
+      error: null,
+    },
+  };
+  for (const [id, facts] of Object.entries(plan.facts.providers)) {
+    probes[`provider:${id}`] = {
+      id,
+      available: facts.available,
+      commandAvailable: facts.available,
+      displayName: facts.displayName,
+      path: facts.path,
+      authStatus: facts.available ? 'ready' : 'unknown',
+      authReason: null,
+    };
+  }
+  onProgress?.({ type: 'start', probes: specs, elapsedMs: 0 });
+  for (const spec of specs) {
+    const id = spec.id ? `provider:${spec.id}` : spec.kind;
+    onProgress?.({
+      type: 'complete',
+      id,
+      kind: spec.kind,
+      providerId: spec.id || null,
+      ok: true,
+      elapsedMs: 0,
+      result: probes[id],
+    });
+  }
+  onProgress?.({ type: 'finish', elapsedMs: 0, plan, probes });
+  return { plan, probes, elapsedMs: 0 };
+}
+
+function collectSetupScan({ cwd, settings, repoSettings, env, resolved, deps, onProgress }) {
+  if (deps.buildSetupPlan && !deps.scanSetupEnvironment) {
+    const plan = resolved.buildSetupPlan({
+      cwd,
+      settings,
+      repoSettings,
+      env: { ...env, __isTTY: true },
+      deps: resolved.setupPlanDeps,
+    });
+    return syntheticScan(plan, onProgress);
+  }
+  return resolved.scanSetupEnvironment({
+    cwd,
+    settings,
+    repoSettings,
+    env,
+    onProgress,
+    deps: resolved.setupScanDeps,
+  });
+}
+
+module.exports = {
+  buildWizardDecisions,
+  buildWizardPlanModel,
+  collectSetupScan,
+  isolationChoices,
+  preferredIndex,
+};

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

@@ -0,0 +1,157 @@
+const { CANCEL_KEYS, fit, gutter, stepHead, terminalWidth } = require('./setup-wizard-terminal');
+
+function formatValue(value) {
+  if (typeof value === 'string') return value;
+  const serialized = JSON.stringify(value);
+  return serialized.length > 44 ? `${serialized.slice(0, 41)}…` : serialized;
+}
+
+function writeMarker(write) {
+  return write.from === null || write.from === undefined ? '+' : '~';
+}
+
+function createPlanState(groups) {
+  return {
+    status: 'active',
+    focus: 0,
+    action: 0,
+    enabled: Object.fromEntries(groups.map((group) => [group.id, group.enabled !== false])),
+  };
+}
+
+function movePlanFocus(state, direction, groupCount) {
+  const count = groupCount + 1;
+  return { ...state, focus: (state.focus + direction + count) % count };
+}
+
+function togglePlanGroup(state, group) {
+  if (!group || group.required) return state;
+  return {
+    ...state,
+    enabled: { ...state.enabled, [group.id]: !state.enabled[group.id] },
+  };
+}
+
+function choosePlanAction(state, groups) {
+  if (state.focus < groups.length) return { ...state, focus: groups.length };
+  return { ...state, status: state.action === 0 ? 'apply' : 'cancelled' };
+}
+
+function navigatePlanActions(state, key, groupCount) {
+  if (state.focus !== groupCount) return null;
+  if (key !== 'left' && key !== 'right') return null;
+  return { ...state, action: state.action === 0 ? 1 : 0 };
+}
+
+function reducePlanState(state, key, groups) {
+  if (state.status !== 'active') return state;
+  if (CANCEL_KEYS.has(key)) return { ...state, status: 'cancelled' };
+  if (key === 'up') return movePlanFocus(state, -1, groups.length);
+  if (key === 'down') return movePlanFocus(state, 1, groups.length);
+  const actionNavigation = navigatePlanActions(state, key, groups.length);
+  if (actionNavigation) return actionNavigation;
+  if (key === 'space') return togglePlanGroup(state, groups[state.focus]);
+  return key === 'enter' ? choosePlanAction(state, groups) : state;
+}
+
+function planFrame({ stdout, theme, model, state, active = true }) {
+  const width = terminalWidth(stdout);
+  const targetCount = new Set(model.writes.map((write) => write.targetFile)).size;
+  const meta = `${targetCount} ${targetCount === 1 ? 'file' : 'files'} · ${model.writes.length} settings`;
+  const rows = [
+    stepHead(theme, active ? 'active' : 'done', 'Plan', { meta, width }),
+    gutter(theme),
+  ];
+  model.groups.forEach((group, index) => {
+    const selected = active && state.focus === index;
+    const enabled = group.required || state.enabled[group.id];
+    const cursor = selected ? theme.accent('▸') : ' ';
+    const box = enabled ? '[x]' : '[ ]';
+    const title = selected ? theme.bold(group.title) : group.title;
+    rows.push(
+      gutter(
+        theme,
+        fit(`${cursor} ${box} ${title}${group.required ? ' · required' : ''}`, width - 3)
+      )
+    );
+    if (enabled) {
+      for (const write of group.writes) {
+        rows.push(
+          gutter(
+            theme,
+            fit(`  ${writeMarker(write)} ${write.path} = ${formatValue(write.to)}`, width - 3)
+          )
+        );
+      }
+    }
+  });
+  if (model.files.length > 0) {
+    rows.push(gutter(theme));
+    rows.push(gutter(theme, fit(theme.dim(`files: ${model.files.join(', ')}`), width - 3)));
+  }
+  if (active) {
+    const actionFocus = state.focus === model.groups.length;
+    const apply = state.action === 0 && actionFocus ? theme.bold('▸ Apply') : theme.dim('  Apply');
+    const cancel =
+      state.action === 1 && actionFocus ? theme.bold('▸ Cancel') : theme.dim('  Cancel');
+    rows.push(gutter(theme));
+    rows.push(gutter(theme, fit(`${apply}   ${cancel}`, width - 3)));
+    rows.push(
+      gutter(theme, fit(theme.dim('↑↓ move · space toggle · ←→ choose · ↵ continue'), width - 3))
+    );
+  } else {
+    rows.push(gutter(theme, theme.dim('approved · writes begin below')));
+    rows.push(gutter(theme));
+  }
+  return rows;
+}
+
+async function selectPlan({ stdout, reader, live, theme, buildModel }) {
+  let model = buildModel();
+  let state = createPlanState(model.groups);
+  live.paint(planFrame({ stdout, theme, model, state }));
+  while (state.status === 'active') {
+    const key = await reader.read();
+    state = reducePlanState(state, key, model.groups);
+    model = buildModel(state.enabled);
+    if (state.status === 'active') live.paint(planFrame({ stdout, theme, model, state }));
+  }
+  if (state.status === 'apply') {
+    live.commit(planFrame({ stdout, theme, model, state, active: false }));
+    return { action: 'apply', model, enabled: state.enabled };
+  }
+  live.clear();
+  return { action: 'cancel', model, enabled: state.enabled };
+}
+
+function receiptLine(theme, result) {
+  if (result.applied) return `${theme.success('v')} ${result.decisionId}`;
+  return `${theme.dim('–')} ${result.decisionId} · ${result.skippedReason}`;
+}
+
+function applyState(verified, failed) {
+  if (failed) return { state: 'failed', meta: 'failed' };
+  if (verified) return { state: 'done', meta: 'verified' };
+  return { state: 'active', meta: 'writing' };
+}
+
+function renderApplyFrame({ stdout, theme, results, verified, failed }) {
+  const width = terminalWidth(stdout);
+  const { state, meta } = applyState(verified, failed);
+  const rows = [stepHead(theme, state, 'Apply', { meta, width }), gutter(theme)];
+  for (const result of results) {
+    rows.push(gutter(theme, fit(receiptLine(theme, result), width - 3)));
+  }
+  if (!verified && !failed) rows.push(gutter(theme, theme.dim('writing settings atomically')));
+  if (verified) rows.push(gutter(theme, `${theme.success('v')} persisted settings verified`));
+  rows.push(gutter(theme));
+  return rows;
+}
+
+module.exports = {
+  createPlanState,
+  planFrame,
+  reducePlanState,
+  renderApplyFrame,
+  selectPlan,
+};

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

@@ -0,0 +1,144 @@
+const { getProviderMetadata } = require('../../lib/provider-names');
+const { WIZARD_SPINNER, fit, gutter, stepHead, terminalWidth } = require('./setup-wizard-terminal');
+
+function formatSeconds(ms) {
+  return `${(Math.max(0, ms) / 1000).toFixed(1)}s`;
+}
+
+function probeLabel(spec) {
+  if (spec.kind === 'git') return 'Repository';
+  if (spec.kind === 'docker') return 'Docker';
+  if (spec.kind === 'issue') return 'Issue host';
+  return getProviderMetadata(spec.id).displayName;
+}
+
+function gitProbeDetail(result) {
+  if (!result.isRepo) return 'not a git repository';
+  return `${result.branch || 'detached'}${result.clean === true ? ' · clean' : ''}`;
+}
+
+function issueProbeDetail(result) {
+  if (!result.installed) return 'gh unavailable';
+  return result.authenticated ? 'GitHub authenticated' : 'GitHub login required';
+}
+
+function providerProbeDetail(result) {
+  if (!result.available) return result.commandAvailable ? 'probe failed' : 'not installed';
+  if (result.authStatus === 'login-required') return 'login required';
+  return result.path || 'available';
+}
+
+function probeDetail(event) {
+  const result = event.result;
+  if (event.kind === 'git') return gitProbeDetail(result);
+  if (event.kind === 'docker')
+    return result.available ? 'available' : result.error || 'unavailable';
+  if (event.kind === 'issue') return issueProbeDetail(result);
+  return providerProbeDetail(result);
+}
+
+class ScanPresenter {
+  constructor({ stdout, theme, live, motion, clock }) {
+    this.stdout = stdout;
+    this.theme = theme;
+    this.live = live;
+    this.motion = motion;
+    this.clock = clock;
+    this.specs = [];
+    this.completed = new Map();
+    this.frameIndex = 0;
+    this.elapsedMs = 0;
+    this.timer = null;
+  }
+
+  handle(event) {
+    this.elapsedMs = event.elapsedMs || 0;
+    if (event.type === 'start') {
+      this.specs = event.probes;
+      this.startTimer();
+    } else if (event.type === 'complete') {
+      this.completed.set(event.id, event);
+    }
+    this.paint();
+  }
+
+  startTimer() {
+    if (!this.motion || this.timer) return;
+    this.timer = this.clock.setInterval(() => {
+      this.frameIndex = (this.frameIndex + 1) % WIZARD_SPINNER.length;
+      this.elapsedMs += 80;
+      this.paint();
+    }, 80);
+    this.timer.unref?.();
+  }
+
+  stopTimer() {
+    if (!this.timer) return;
+    this.clock.clearInterval(this.timer);
+    this.timer = null;
+  }
+
+  paint() {
+    if (this.specs.length === 0) return;
+    const width = terminalWidth(this.stdout);
+    const done = this.completed.size;
+    const spinner = this.motion ? WIZARD_SPINNER[this.frameIndex] : '*';
+    const rows = [
+      stepHead(this.theme, 'active', 'Scan', {
+        meta: `${formatSeconds(this.elapsedMs)} · ${done}/${this.specs.length}`,
+        width,
+      }),
+      gutter(this.theme),
+    ];
+    for (const spec of this.specs) {
+      const id = spec.id ? `provider:${spec.id}` : spec.kind;
+      const event = this.completed.get(id);
+      const glyph = event ? this.theme.success('v') : this.theme.accent(spinner);
+      const detail = event ? this.theme.dim(probeDetail(event)) : this.theme.dim('checking');
+      rows.push(gutter(this.theme, fit(`${glyph} ${probeLabel(spec)} · ${detail}`, width - 3)));
+    }
+    this.live.paint(rows);
+  }
+
+  summaryRows({ probes, elapsedMs, width }) {
+    const providerResults = Object.entries(probes)
+      .filter(([id]) => id.startsWith('provider:'))
+      .map(([, result]) => result);
+    const ready = providerResults.filter((result) => result.available).length;
+    const unavailable = providerResults.length - ready;
+    const cleanliness = probes.git.clean ? 'clean repository' : 'local changes';
+    const gitSummary = probes.git.isRepo
+      ? `git ${probes.git.branch || 'detached'} · ${cleanliness}`
+      : 'not a git repository';
+    const dockerSummary = probes.docker.available ? 'available' : 'unavailable';
+    const issueSummary = probes.issue.authenticated ? 'authenticated' : 'not authenticated';
+    return [
+      stepHead(this.theme, 'done', 'Scan', {
+        meta: `${formatSeconds(elapsedMs)} · ${ready} providers found`,
+        width,
+      }),
+      gutter(this.theme, fit(gitSummary, width - 3)),
+      gutter(this.theme, fit(`docker ${dockerSummary}`, width - 3)),
+      gutter(
+        this.theme,
+        fit(
+          `providers ${ready} found · ${unavailable} unavailable · GitHub ${issueSummary}`,
+          width - 3
+        )
+      ),
+      gutter(this.theme),
+    ];
+  }
+
+  commit({ probes, elapsedMs }) {
+    this.stopTimer();
+    this.live.commit(this.summaryRows({ probes, elapsedMs, width: terminalWidth(this.stdout) }));
+  }
+
+  clear() {
+    this.stopTimer();
+    this.live.clear();
+  }
+}
+
+module.exports = { ScanPresenter, formatSeconds, probeDetail };