orbital-command 0.2.0 → 0.3.0

package/server/wizard/config-editor.ts

@@ -0,0 +1,248 @@
+/**
+ * Interactive config editor — `orbital config`
+ */
+
+import fs from 'fs';
+import path from 'path';
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { WORKFLOW_PRESETS } from './types.js';
+
+export async function runConfigEditor(projectRoot: string, packageVersion: string, args: string[]): Promise<void> {
+  const subcommand = args[0];
+
+  // Non-interactive: orbital config show
+  if (subcommand === 'show') {
+    const config = loadProjectConfig(projectRoot);
+    if (!config) {
+      console.error('No config found. Run `orbital init` first.');
+      process.exit(1);
+    }
+    console.log(JSON.stringify(config, null, 2));
+    return;
+  }
+
+  // Non-interactive: orbital config set <key> <value>
+  if (subcommand === 'set') {
+    const key = args[1];
+    const value = args[2];
+    if (!key || value === undefined) {
+      console.error('Usage: orbital config set <key> <value>');
+      process.exit(1);
+    }
+    setConfigValue(projectRoot, key, value);
+    return;
+  }
+
+  // Interactive mode
+  const config = loadProjectConfig(projectRoot);
+  if (!config) {
+    p.log.error('No config found. Run `orbital init` first.');
+    process.exit(1);
+  }
+
+  p.intro(`${pc.bgCyan(pc.black(' Orbital Config '))} ${pc.dim(`v${packageVersion}`)}`);
+
+  // If a section was specified, jump directly to it
+  if (subcommand === 'project') {
+    await editProjectSection(projectRoot, config);
+  } else if (subcommand === 'workflow') {
+    await editWorkflowSection(projectRoot);
+  } else if (subcommand === 'global') {
+    await editGlobalSection();
+  } else {
+    // Show interactive menu
+    const section = await p.select({
+      message: 'What would you like to configure?',
+      options: [
+        { value: 'project', label: 'Project', hint: 'name, ports, build commands' },
+        { value: 'workflow', label: 'Workflow', hint: 'switch preset, view lists' },
+        { value: 'global', label: 'Global', hint: 'registered projects' },
+      ],
+    });
+
+    if (p.isCancel(section)) {
+      p.cancel('Config cancelled.');
+      return;
+    }
+
+    if (section === 'project') await editProjectSection(projectRoot, config);
+    else if (section === 'workflow') await editWorkflowSection(projectRoot);
+    else if (section === 'global') await editGlobalSection();
+  }
+
+  p.outro('Configuration updated.');
+}
+
+// ─── Section Editors ────────────────────────────────────────────
+
+async function editProjectSection(projectRoot: string, config: Record<string, unknown>): Promise<void> {
+  const name = await p.text({
+    message: 'Project name',
+    defaultValue: (config.projectName as string) || '',
+    placeholder: (config.projectName as string) || '',
+  });
+  if (p.isCancel(name)) return;
+
+  const serverPort = await p.text({
+    message: 'Server port',
+    defaultValue: String(config.serverPort || 4444),
+    placeholder: String(config.serverPort || 4444),
+    validate: (val) => {
+      const n = Number(val);
+      if (isNaN(n) || n < 1 || n > 65535) return 'Must be a valid port (1-65535)';
+      return undefined;
+    },
+  });
+  if (p.isCancel(serverPort)) return;
+
+  const clientPort = await p.text({
+    message: 'Client port',
+    defaultValue: String(config.clientPort || 4445),
+    placeholder: String(config.clientPort || 4445),
+    validate: (val) => {
+      const n = Number(val);
+      if (isNaN(n) || n < 1 || n > 65535) return 'Must be a valid port (1-65535)';
+      return undefined;
+    },
+  });
+  if (p.isCancel(clientPort)) return;
+
+  config.projectName = name;
+  config.serverPort = Number(serverPort);
+  config.clientPort = Number(clientPort);
+  saveProjectConfig(projectRoot, config);
+  p.log.success('Project config saved.');
+}
+
+async function editWorkflowSection(projectRoot: string): Promise<void> {
+  const workflowPath = path.join(projectRoot, '.claude', 'config', 'workflow.json');
+  let currentPreset = 'unknown';
+
+  if (fs.existsSync(workflowPath)) {
+    try {
+      const wf = JSON.parse(fs.readFileSync(workflowPath, 'utf8'));
+      currentPreset = wf.name || 'Custom';
+      const lists = (wf.lists || []).map((l: Record<string, string>) => l.label).join(' → ');
+      p.note(`Current: ${pc.cyan(currentPreset)}\nLists:   ${lists}`, 'Active Workflow');
+    } catch { /* show selector anyway */ }
+  }
+
+  const switchPreset = await p.confirm({
+    message: 'Switch to a different preset?',
+    initialValue: false,
+  });
+  if (p.isCancel(switchPreset) || !switchPreset) return;
+
+  const preset = await p.select({
+    message: 'Choose a workflow preset',
+    options: WORKFLOW_PRESETS.map(wp => ({
+      value: wp.value,
+      label: wp.label,
+      hint: wp.hint,
+    })),
+  });
+  if (p.isCancel(preset)) return;
+
+  // Find and copy the preset
+  // Walk up to find templates dir
+  const templatesDir = findTemplatesDir();
+  if (!templatesDir) {
+    p.log.error('Could not locate templates directory.');
+    return;
+  }
+
+  const presetPath = path.join(templatesDir, 'presets', `${preset}.json`);
+  if (fs.existsSync(presetPath)) {
+    fs.copyFileSync(presetPath, workflowPath);
+    p.log.success(`Switched to ${preset} workflow.`);
+  } else {
+    p.log.error(`Preset file not found: ${preset}.json`);
+  }
+}
+
+async function editGlobalSection(): Promise<void> {
+  const homedir = process.env.HOME || process.env.USERPROFILE || '~';
+  const registryPath = path.join(homedir, '.orbital', 'config.json');
+
+  if (!fs.existsSync(registryPath)) {
+    p.log.info('No global registry found. Run `orbital init` in a project first.');
+    return;
+  }
+
+  try {
+    const registry = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
+    const projects = registry.projects || [];
+
+    if (projects.length === 0) {
+      p.log.info('No projects registered.');
+      return;
+    }
+
+    const rows = projects.map((proj: Record<string, unknown>) => {
+      const exists = fs.existsSync(proj.path as string);
+      const status = proj.enabled ? (exists ? pc.green('active') : pc.yellow('offline')) : pc.dim('disabled');
+      return `  ${pc.cyan(String(proj.id).padEnd(20))} ${status.padEnd(20)} ${proj.path}`;
+    });
+    p.note(rows.join('\n'), `Registered Projects (${projects.length})`);
+  } catch {
+    p.log.error('Could not read global registry.');
+  }
+}
+
+// ─── Helpers ────────────────────────────────────────────────────
+
+function loadProjectConfig(projectRoot: string): Record<string, unknown> | null {
+  const configPath = path.join(projectRoot, '.claude', 'orbital.config.json');
+  if (!fs.existsSync(configPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function saveProjectConfig(projectRoot: string, config: Record<string, unknown>): void {
+  const configPath = path.join(projectRoot, '.claude', 'orbital.config.json');
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
+}
+
+function setConfigValue(projectRoot: string, key: string, value: string): void {
+  const config = loadProjectConfig(projectRoot);
+  if (!config) {
+    console.error('No config found. Run `orbital init` first.');
+    process.exit(1);
+  }
+
+  // Parse value: try number, then boolean, then string
+  let parsed: unknown = value;
+  if (value === 'true') parsed = true;
+  else if (value === 'false') parsed = false;
+  else if (value === 'null') parsed = null;
+  else if (!isNaN(Number(value)) && value !== '') parsed = Number(value);
+
+  // Support dot notation for nested keys
+  const keys = key.split('.');
+  let target: Record<string, unknown> = config;
+  for (let i = 0; i < keys.length - 1; i++) {
+    if (typeof target[keys[i]] !== 'object' || target[keys[i]] === null) {
+      target[keys[i]] = {};
+    }
+    target = target[keys[i]] as Record<string, unknown>;
+  }
+  target[keys[keys.length - 1]] = parsed;
+
+  saveProjectConfig(projectRoot, config);
+  console.log(`Set ${key} = ${JSON.stringify(parsed)}`);
+}
+
+function findTemplatesDir(): string | null {
+  // Walk up from this file to find templates/
+  let dir = path.dirname(new URL(import.meta.url).pathname);
+  for (let i = 0; i < 5; i++) {
+    const candidate = path.join(dir, 'templates');
+    if (fs.existsSync(candidate)) return candidate;
+    dir = path.resolve(dir, '..');
+  }
+  return null;
+}

package/server/wizard/detect.ts

@@ -0,0 +1,104 @@
+/**
+ * Environment and state detection for the wizard.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import type { SetupState, ProjectSetupState } from './types.js';
+
+const ORBITAL_HOME = path.join(process.env.HOME || process.env.USERPROFILE || '~', '.orbital');
+
+export { ORBITAL_HOME };
+
+export function isInteractiveTerminal(): boolean {
+  return !!(process.stdout.isTTY && !process.env.CI);
+}
+
+export function isOrbitalSetupDone(): boolean {
+  return fs.existsSync(path.join(ORBITAL_HOME, 'config.json'));
+}
+
+export function buildSetupState(packageVersion: string): SetupState {
+  return {
+    packageVersion,
+    isFirstTime: !isOrbitalSetupDone(),
+    linkedProjects: [],
+  };
+}
+
+export function buildProjectState(projectRoot: string, packageVersion: string): ProjectSetupState {
+  const projectConfigExists = fs.existsSync(path.join(projectRoot, '.claude', 'orbital.config.json'));
+
+  return {
+    projectRoot,
+    isProjectInitialized: projectConfigExists,
+    packageVersion,
+  };
+}
+
+export function detectProjectName(projectRoot: string): string {
+  return path.basename(projectRoot)
+    .replace(/[-_]+/g, ' ')
+    .replace(/\b\w/g, c => c.toUpperCase());
+}
+
+export function detectCommands(projectRoot: string): Record<string, string | null> {
+  const commands: Record<string, string | null> = {
+    typeCheck: null,
+    lint: null,
+    build: null,
+    test: null,
+  };
+
+  const pkgJsonPath = path.join(projectRoot, 'package.json');
+  if (!fs.existsSync(pkgJsonPath)) return commands;
+
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
+    const scripts = pkg.scripts || {};
+
+    if (scripts.typecheck || scripts['type-check']) {
+      commands.typeCheck = `npm run ${scripts.typecheck ? 'typecheck' : 'type-check'}`;
+    }
+    if (scripts.lint) commands.lint = 'npm run lint';
+    if (scripts.build) commands.build = 'npm run build';
+    if (scripts.test) commands.test = 'npm run test';
+  } catch { /* ignore malformed package.json */ }
+
+  return commands;
+}
+
+export function detectPortConflict(serverPort: number): string | null {
+  const registryPath = path.join(ORBITAL_HOME, 'config.json');
+  if (!fs.existsSync(registryPath)) return null;
+
+  try {
+    const registry = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
+    for (const project of registry.projects || []) {
+      const configPath = path.join(project.path, '.claude', 'orbital.config.json');
+      if (!fs.existsSync(configPath)) continue;
+      try {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        if (config.serverPort === serverPort) return project.name;
+      } catch { /* skip unreadable configs */ }
+    }
+  } catch { /* skip unreadable registry */ }
+
+  return null;
+}
+
+export function isValidProjectPath(p: string): string | undefined {
+  const resolved = p.startsWith('~')
+    ? path.join(process.env.HOME || process.env.USERPROFILE || '~', p.slice(1))
+    : path.resolve(p);
+  if (!fs.existsSync(resolved)) return 'Directory does not exist';
+  if (!fs.statSync(resolved).isDirectory()) return 'Not a directory';
+  return undefined;
+}
+
+export function resolveProjectPath(p: string): string {
+  if (p.startsWith('~')) {
+    return path.join(process.env.HOME || process.env.USERPROFILE || '~', p.slice(1));
+  }
+  return path.resolve(p);
+}

package/server/wizard/doctor.ts

@@ -0,0 +1,114 @@
+/**
+ * Health diagnostics — `orbital doctor`
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { execFileSync } from 'child_process';
+import pc from 'picocolors';
+
+export async function runDoctor(projectRoot: string, packageVersion: string): Promise<void> {
+  console.log(`\n  ${pc.bold('Orbital Command')} ${pc.cyan(`v${packageVersion}`)}\n`);
+
+  const checks: { label: string; status: string }[] = [];
+
+  // 1. Check for latest version on npm
+  try {
+    const latest = execFileSync('npm', ['view', 'orbital-command', 'version'], {
+      encoding: 'utf8',
+      timeout: 5000,
+    }).trim();
+
+    if (latest && latest !== packageVersion) {
+      checks.push({ label: 'Latest', status: pc.yellow(`v${latest} available (run \`npm update -g orbital-command\`)`) });
+    } else {
+      checks.push({ label: 'Latest', status: pc.green(`v${packageVersion} (up to date)`) });
+    }
+  } catch {
+    checks.push({ label: 'Latest', status: pc.dim('could not check (npm unreachable)') });
+  }
+
+  // 2. Node version
+  const nodeVersion = process.version;
+  const major = parseInt(nodeVersion.slice(1), 10);
+  if (major >= 18) {
+    checks.push({ label: 'Node', status: pc.green(`${nodeVersion} (supported)`) });
+  } else {
+    checks.push({ label: 'Node', status: pc.red(`${nodeVersion} (requires Node 18+)`) });
+  }
+
+  // 3. Global registry
+  const homedir = process.env.HOME || process.env.USERPROFILE || '~';
+  const registryPath = path.join(homedir, '.orbital', 'config.json');
+  if (fs.existsSync(registryPath)) {
+    try {
+      const registry = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
+      const count = (registry.projects || []).length;
+      checks.push({ label: 'Global', status: pc.green(`~/.orbital/ exists (${count} project${count !== 1 ? 's' : ''} registered)`) });
+    } catch {
+      checks.push({ label: 'Global', status: pc.yellow('~/.orbital/ exists (registry unreadable)') });
+    }
+  } else {
+    checks.push({ label: 'Global', status: pc.dim('~/.orbital/ not found (run `orbital init` to create)') });
+  }
+
+  // 4. Project initialization
+  const configPath = path.join(projectRoot, '.claude', 'orbital.config.json');
+  if (fs.existsSync(configPath)) {
+    try {
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      const name = config.projectName || path.basename(projectRoot);
+      checks.push({ label: 'Project', status: pc.green(`initialized (${name})`) });
+    } catch {
+      checks.push({ label: 'Project', status: pc.yellow('config exists but unreadable') });
+    }
+  } else {
+    checks.push({ label: 'Project', status: pc.dim('not initialized (run `orbital init`)') });
+  }
+
+  // 5. Workflow
+  const workflowPath = path.join(projectRoot, '.claude', 'config', 'workflow.json');
+  if (fs.existsSync(workflowPath)) {
+    try {
+      const wf = JSON.parse(fs.readFileSync(workflowPath, 'utf8'));
+      const listCount = (wf.lists || []).length;
+      const mode = wf.branchingMode || 'unknown';
+      checks.push({ label: 'Workflow', status: pc.green(`${wf.name || 'Custom'} (${listCount} lists, ${mode})`) });
+    } catch {
+      checks.push({ label: 'Workflow', status: pc.yellow('workflow.json exists but unreadable') });
+    }
+  } else {
+    checks.push({ label: 'Workflow', status: pc.dim('no workflow configured') });
+  }
+
+  // 6. Database
+  const dbPath = path.join(projectRoot, '.claude', 'orbital', 'orbital.db');
+  if (fs.existsSync(dbPath)) {
+    const stats = fs.statSync(dbPath);
+    const sizeMb = (stats.size / (1024 * 1024)).toFixed(1);
+    checks.push({ label: 'Database', status: pc.green(`${sizeMb} MB`) });
+  } else {
+    checks.push({ label: 'Database', status: pc.dim('not yet created (starts on first launch)') });
+  }
+
+  // 7. Template staleness
+  if (fs.existsSync(configPath)) {
+    try {
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      if (config.templateVersion && config.templateVersion !== packageVersion) {
+        checks.push({ label: 'Templates', status: pc.yellow(`outdated (v${config.templateVersion} → v${packageVersion}, run \`orbital update\`)`) });
+      } else if (config.templateVersion) {
+        checks.push({ label: 'Templates', status: pc.green('synced') });
+      } else {
+        checks.push({ label: 'Templates', status: pc.yellow('no version stamp (run `orbital update`)') });
+      }
+    } catch { /* skip */ }
+  }
+
+  // Print all checks
+  const maxLabel = Math.max(...checks.map(c => c.label.length));
+  for (const check of checks) {
+    console.log(`  ${pc.dim(check.label.padEnd(maxLabel + 2))} ${check.status}`);
+  }
+  console.log();
+}

package/server/wizard/index.ts

@@ -0,0 +1,187 @@
+/**
+ * Interactive CLI wizard — main orchestrator.
+ *
+ * Entry points:
+ *   runSetupWizard()   — Phase 1: first-time Orbital setup (~/.orbital/)
+ *   runProjectSetup()  — Phase 2: per-project scaffolding (.claude/)
+ *   runConfigEditor()  — interactive config editor (orbital config)
+ *   runDoctor()        — health diagnostics (orbital doctor)
+ */
+
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { buildSetupState, buildProjectState, ORBITAL_HOME } from './detect.js';
+import { phaseSetupWizard } from './phases/setup-wizard.js';
+import { phaseWelcome } from './phases/welcome.js';
+import { phaseProjectSetup } from './phases/project-setup.js';
+import { phaseWorkflowSetup } from './phases/workflow-setup.js';
+import { phaseConfirm, showPostInstall } from './phases/confirm.js';
+import { NOTES } from './ui.js';
+import { runConfigEditor } from './config-editor.js';
+import { runDoctor } from './doctor.js';
+
+export { runConfigEditor, runDoctor };
+
+// ─── Phase 1: Setup Wizard ─────────────────────────────────────
+
+/**
+ * First-time setup. Creates ~/.orbital/, seeds primitives,
+ * optionally links projects (running Phase 2 for each).
+ */
+export async function runSetupWizard(packageVersion: string): Promise<void> {
+  const state = buildSetupState(packageVersion);
+
+  p.intro(`${pc.bgCyan(pc.black(' Orbital Command '))} ${pc.dim(`v${packageVersion}`)}`);
+
+  await phaseSetupWizard(state);
+
+  // If user linked projects, run Phase 2 for each
+  for (const projectRoot of state.linkedProjects) {
+    p.log.step(`Setting up ${pc.cyan(path.basename(projectRoot))}...`);
+    await runProjectSetupInline(projectRoot, packageVersion);
+  }
+
+  if (state.linkedProjects.length === 0) {
+    p.note(NOTES.setupComplete, 'Done');
+  }
+
+  p.outro(
+    state.linkedProjects.length > 0
+      ? `Run ${pc.cyan('orbital launch --open')} to open the dashboard.`
+      : `Run ${pc.cyan('orbital init')} in a project directory to get started.`
+  );
+}
+
+// ─── Phase 2: Project Setup ────────────────────────────────────
+
+/**
+ * Per-project setup. Walks through name, commands, workflow, then
+ * calls runInit() to scaffold files into .claude/.
+ */
+export async function runProjectSetup(projectRoot: string, packageVersion: string, args: string[]): Promise<void> {
+  const state = buildProjectState(projectRoot, packageVersion);
+  const force = args.includes('--force');
+
+  p.intro(`${pc.bgCyan(pc.black(' Orbital Command '))} ${pc.dim(`v${packageVersion}`)}`);
+
+  // Welcome gate: detect re-init / reconfigure
+  const forceFromWelcome = await phaseWelcome(state);
+  const useForce = force || forceFromWelcome;
+
+  await runProjectPhases(state, useForce);
+
+  p.outro(`Run ${pc.cyan('orbital launch --open')} to open the dashboard.`);
+}
+
+// ─── Shared project phases (used by both flows) ────────────────
+
+/**
+ * Run the project setup phases and install. Used by both
+ * standalone runProjectSetup() and inline from runSetupWizard().
+ */
+async function runProjectPhases(state: ReturnType<typeof buildProjectState>, useForce: boolean): Promise<void> {
+  await phaseProjectSetup(state);
+  await phaseWorkflowSetup(state);
+  await phaseConfirm(state);
+
+  // Install
+  const s = p.spinner();
+  s.start('Installing into project...');
+
+  try {
+    const { runInit } = await import('../init.js');
+
+    runInit(state.projectRoot, {
+      force: useForce,
+      quiet: true,
+      preset: state.workflowPreset,
+      projectName: state.projectName,
+      serverPort: state.serverPort,
+      clientPort: state.clientPort,
+      commands: state.selectedCommands,
+    });
+
+    registerProject(state.projectRoot, state.projectName);
+    stampTemplateVersion(state.projectRoot, state.packageVersion);
+
+    s.stop('Project ready.');
+  } catch (err) {
+    s.stop('Installation failed.');
+    p.log.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+
+  showPostInstall(state);
+}
+
+/**
+ * Inline project setup — called from Phase 1 when user links a project.
+ * Skips intro/outro since the setup wizard already has those.
+ */
+async function runProjectSetupInline(projectRoot: string, packageVersion: string): Promise<void> {
+  const state = buildProjectState(projectRoot, packageVersion);
+
+  // Skip welcome gate for inline — this is a fresh project being linked
+  await runProjectPhases(state, false);
+}
+
+// ─── Registration ──────────────────────────────────────────────
+
+function registerProject(projectRoot: string, projectName?: string): void {
+  const registryPath = path.join(ORBITAL_HOME, 'config.json');
+  let registry: { version: number; projects: Array<Record<string, unknown>> };
+
+  try {
+    registry = fs.existsSync(registryPath)
+      ? JSON.parse(fs.readFileSync(registryPath, 'utf8'))
+      : { version: 1, projects: [] };
+  } catch {
+    registry = { version: 1, projects: [] };
+  }
+
+  if (!registry.projects) registry.projects = [];
+  if (registry.projects.some((proj: Record<string, unknown>) => proj.path === projectRoot)) return;
+
+  const COLORS = [
+    '210 80% 55%', '340 75% 55%', '160 60% 45%', '30 90% 55%',
+    '270 65% 55%', '50 85% 50%', '180 55% 45%', '0 70% 55%',
+  ];
+  const usedColors = registry.projects.map((proj: Record<string, unknown>) => proj.color);
+  const color = COLORS.find(c => !usedColors.includes(c)) || COLORS[0];
+
+  const name = projectName || path.basename(projectRoot);
+  const baseSlug = path.basename(projectRoot).toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '') || 'project';
+  const existingIds = registry.projects.map((proj: Record<string, unknown>) => proj.id);
+  const slug = existingIds.includes(baseSlug)
+    ? `${baseSlug}-${crypto.createHash('sha256').update(projectRoot).digest('hex').slice(0, 4)}`
+    : baseSlug;
+
+  registry.projects.push({
+    id: slug,
+    path: projectRoot,
+    name,
+    color,
+    registeredAt: new Date().toISOString(),
+    enabled: true,
+  });
+
+  fs.writeFileSync(registryPath, JSON.stringify(registry, null, 2), 'utf8');
+}
+
+// ─── Template Version Stamping ─────────────────────────────────
+
+function stampTemplateVersion(projectRoot: string, packageVersion: string): void {
+  const configPath = path.join(projectRoot, '.claude', 'orbital.config.json');
+  if (!fs.existsSync(configPath)) return;
+
+  try {
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    if (config.templateVersion !== packageVersion) {
+      config.templateVersion = packageVersion;
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
+    }
+  } catch { /* ignore malformed config */ }
+}

package/server/wizard/phases/confirm.ts

@@ -0,0 +1,45 @@
+/**
+ * Phase 3: Confirm choices, run installation, show next steps.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import * as p from '@clack/prompts';
+import type { ProjectSetupState } from '../types.js';
+import { NOTES, formatSummary } from '../ui.js';
+
+export async function phaseConfirm(state: ProjectSetupState): Promise<void> {
+  p.note(formatSummary(state), 'Ready to Initialize');
+
+  const proceed = await p.confirm({
+    message: 'Proceed with installation?',
+    initialValue: true,
+  });
+
+  if (p.isCancel(proceed) || !proceed) {
+    p.cancel('Setup cancelled.');
+    process.exit(0);
+  }
+}
+
+export function showPostInstall(state: ProjectSetupState): void {
+  // Count installed artifacts
+  const claudeDir = path.join(state.projectRoot, '.claude');
+  const counts = {
+    hooks: countDir(path.join(claudeDir, 'hooks')),
+    skills: countDir(path.join(claudeDir, 'skills')),
+    agents: countDir(path.join(claudeDir, 'agents')),
+  };
+
+  p.note(NOTES.postInstall(counts), 'Installation Complete');
+  p.note(NOTES.nextSteps, 'Getting Started');
+}
+
+function countDir(dir: string): number {
+  if (!fs.existsSync(dir)) return 0;
+  try {
+    return fs.readdirSync(dir).filter(f => !f.startsWith('.')).length;
+  } catch {
+    return 0;
+  }
+}