@polderlabs/bizar 10.1.0 → 10.3.0

package/cli/migrate.mjs

@@ -0,0 +1,157 @@
+/**
+ * cli/migrate.mjs — `bizar migrate` subcommand.
+ *
+ * v10.3.0 — One-time migration path for users with v6.x-era installs.
+ *
+ * Detects:
+ *   - ~/.config/cline/         (Cline-era Claude Code config)
+ *   - ~/.config/bizar/        (Bizar runtime state, pre-v10)
+ *
+ * Moves both to ~/.claude/ (canonical Claude Code path).
+ *
+ * Idempotent — leaves a .migration-stamp file so it never re-runs.
+ * `--check` reports state without modifying anything.
+ */
+
+import chalk from 'chalk';
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, cpSync, rmSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+/** @typedef {{ hasLegacyClaude: boolean, hasLegacyBizar: boolean, paths: string[] }} LegacyInfo */
+
+/**
+ * Detect legacy install state.
+ * @param {string} home - home directory path
+ * @returns {LegacyInfo}
+ */
+export function detectLegacyInstall(home) {
+  const legacyClaude = join(home, '.config', 'cline');
+  const legacyBizar = join(home, '.config', 'bizar');
+  const paths = [];
+  const hasLegacyClaude = existsSync(legacyClaude);
+  const hasLegacyBizar = existsSync(legacyBizar);
+  if (hasLegacyClaude) paths.push(legacyClaude);
+  if (hasLegacyBizar) paths.push(legacyBizar);
+  return { hasLegacyClaude, hasLegacyBizar, paths };
+}
+
+/**
+ * Check if migration has already run.
+ * @param {string} home - home directory path
+ * @returns {boolean}
+ */
+export function isAlreadyMigrated(home) {
+  const stamp = join(home, '.claude', 'bizar', '.migration-stamp');
+  return existsSync(stamp);
+}
+
+/**
+ * Write the migration stamp file.
+ * @param {string} home - home directory path
+ * @param {string} version - version string
+ */
+export function markMigrated(home, version) {
+  const dir = join(home, '.claude', 'bizar');
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  const stamp = join(dir, '.migration-stamp');
+  writeFileSync(stamp, `migrated=${version}\n`);
+}
+
+/**
+ * Run the migration.
+ * @param {{ dryRun?: boolean, force?: boolean, home?: string }} opts
+ * @returns {Promise<{ ok: boolean, message: string }>}
+ */
+export async function migrateLegacy({ dryRun = false, force = false, home = homedir() } = {}) {
+  const legacy = detectLegacyInstall(home);
+
+  if (!legacy.hasLegacyClaude && !legacy.hasLegacyBizar) {
+    return { ok: true, message: 'No legacy install found — nothing to do.' };
+  }
+
+  if (isAlreadyMigrated(home) && !force) {
+    return { ok: true, message: 'Already migrated — stamp found. Use --force to re-run.' };
+  }
+
+  if (dryRun) {
+    const what = [];
+    if (legacy.hasLegacyClaude) what.push(`  ~/.config/cline/ → ~/.claude/`);
+    if (legacy.hasLegacyBizar) what.push(`  ~/.config/bizar/ → ~/.claude/`);
+    return {
+      ok: true,
+      message: `Dry run — would move:\n${what.join('\n')}`,
+    };
+  }
+
+  // Ensure ~/.claude/ exists
+  const claudeDir = join(home, '.claude');
+  if (!existsSync(claudeDir)) mkdirSync(claudeDir, { recursive: true });
+
+  // Move ~/.config/cline/ → ~/.claude/
+  if (legacy.hasLegacyClaude) {
+    const src = join(home, '.config', 'cline');
+    const dst = join(claudeDir);
+    await moveAtomic(src, dst);
+  }
+
+  // Move ~/.config/bizar/ → ~/.claude/bizar/
+  if (legacy.hasLegacyBizar) {
+    const src = join(home, '.config', 'bizar');
+    const dst = join(claudeDir, 'bizar');
+    await moveAtomic(src, dst);
+  }
+
+  markMigrated(home, '10.3.0');
+  return { ok: true, message: 'Migration complete.' };
+}
+
+/**
+ * Move src to dst atomically (rename), falling back to copy+delete on cross-device.
+ * @param {string} src
+ * @param {string} dst
+ */
+async function moveAtomic(src, dst) {
+  try {
+    renameSync(src, dst);
+  } catch (err) {
+    if (err.code !== 'EXDEV') throw err;
+    // Cross-device: copy then delete
+    cpSync(src, dst, { recursive: true });
+    rmSync(src, { recursive: true, force: true });
+  }
+}
+
+// ── CLI runner ─────────────────────────────────────────────────────────────────
+
+/**
+ * @param {string[]} args
+ */
+export async function runMigrate(args) {
+  const dryRun = args.includes('--dry-run');
+  const force = args.includes('--force');
+  const check = args.includes('--check');
+  const home = homedir();
+
+  if (check) {
+    const legacy = detectLegacyInstall(home);
+    const migrated = isAlreadyMigrated(home);
+    if (!legacy.hasLegacyClaude && !legacy.hasLegacyBizar) {
+      console.log(chalk.green('No legacy install found.'));
+    } else {
+      console.log(chalk.yellow('Legacy install detected:'));
+      if (legacy.hasLegacyClaude) console.log(`  ~/.config/cline/ (Cline-era config)`);
+      if (legacy.hasLegacyBizar) console.log(`  ~/.config/bizar/ (Bizar pre-v10 state)`);
+    }
+    console.log(`Already migrated: ${migrated ? chalk.green('yes') : chalk.red('no')}`);
+    return;
+  }
+
+  const result = await migrateLegacy({ dryRun, force });
+  if (result.ok) {
+    console.log(chalk.green(result.message));
+  } else {
+    console.error(chalk.red(result.message));
+    process.exit(1);
+  }
+}

package/cli/migrate.test.mjs

@@ -0,0 +1,85 @@
+/**
+ * cli/migrate.test.mjs — tests for `bizar migrate`.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import test from 'node:test';
+import { detectLegacyInstall, isAlreadyMigrated, markMigrated, migrateLegacy } from './migrate.mjs';
+
+test('detect — finds both legacy dirs', () => {
+  const tmp = mkdtempSync(join(tmpdir(), 'bizar-migrate-test-'));
+  try {
+    const fakeHome = join(tmp, 'home');
+    mkdirSync(join(fakeHome, '.config', 'cline'), { recursive: true });
+    mkdirSync(join(fakeHome, '.config', 'bizar'), { recursive: true });
+
+    const result = detectLegacyInstall(fakeHome);
+    if (!result.hasLegacyClaude) throw new Error('expected hasLegacyClaude=true');
+    if (!result.hasLegacyBizar) throw new Error('expected hasLegacyBizar=true');
+    if (result.paths.length !== 2) throw new Error(`expected 2 paths, got ${result.paths.length}`);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test('migrate — moves files to ~/.claude/ and writes stamp', async () => {
+  const tmp = mkdtempSync(join(tmpdir(), 'bizar-migrate-test-'));
+  try {
+    const fakeHome = join(tmp, 'home');
+
+    // Set up legacy dirs with content
+    mkdirSync(join(fakeHome, '.config', 'cline'), { recursive: true });
+    writeFileSync(join(fakeHome, '.config', 'cline', 'settings.json'), '{"tabSize":2}');
+    mkdirSync(join(fakeHome, '.config', 'bizar'), { recursive: true });
+    writeFileSync(join(fakeHome, '.config', 'bizar', 'state.json'), '{"v":"6.2.0"}');
+
+    const result = await migrateLegacy({ dryRun: false, force: true, home: fakeHome });
+
+    if (!result.ok) throw new Error(`migrateLegacy failed: ${result.message}`);
+    if (!result.message.includes('Migration complete')) throw new Error(`unexpected message: ${result.message}`);
+
+    // Verify cline content landed in ~/.claude/
+    const migratedSettings = join(fakeHome, '.claude', 'settings.json');
+    if (!existsSync(migratedSettings)) throw new Error('settings.json not migrated');
+    const data = JSON.parse(readFileSync(migratedSettings, 'utf8'));
+    if (data.tabSize !== 2) throw new Error('settings.json content wrong');
+
+    // Verify bizar content landed in ~/.claude/bizar/
+    const migratedState = join(fakeHome, '.claude', 'bizar', 'state.json');
+    if (!existsSync(migratedState)) throw new Error('state.json not migrated');
+
+    // Verify stamp written
+    const stamp = join(fakeHome, '.claude', 'bizar', '.migration-stamp');
+    if (!existsSync(stamp)) throw new Error('migration stamp not written');
+
+    // Verify originals gone
+    if (existsSync(join(fakeHome, '.config', 'cline'))) throw new Error('cline not removed');
+    if (existsSync(join(fakeHome, '.config', 'bizar'))) throw new Error('bizar not removed');
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test('idempotent — second run returns "already migrated" without touching anything', async () => {
+  const tmp = mkdtempSync(join(tmpdir(), 'bizar-migrate-test-'));
+  try {
+    const fakeHome = join(tmp, 'home');
+    mkdirSync(join(fakeHome, '.config', 'cline'), { recursive: true });
+    mkdirSync(join(fakeHome, '.claude', 'bizar'), { recursive: true });
+    writeFileSync(join(fakeHome, '.claude', 'bizar', '.migration-stamp'), 'migrated=10.3.0\n');
+
+    const result = await migrateLegacy({ dryRun: false, force: false, home: fakeHome });
+    if (!result.message.includes('Already migrated')) {
+      throw new Error(`Expected "Already migrated" message, got: ${result.message}`);
+    }
+
+    // Verify original still exists (not touched)
+    if (!existsSync(join(fakeHome, '.config', 'cline'))) {
+      throw new Error('Original cline dir was removed despite already-migrated state');
+    }
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});