ccmv 1.0.0

package/lib/index.js

@@ -0,0 +1,352 @@
+import { existsSync, renameSync, rmSync } from 'node:fs';
+import { homedir } from 'node:os';
+import {
+  logInfo,
+  logOk,
+  logCheck,
+  logError,
+  logDone,
+  logDryrun,
+  logRollback,
+  setVerbose,
+} from './logger.js';
+import {
+  encodePath,
+  pathToFileUri,
+  resolvePath,
+  resolveNewPath,
+} from './utils.js';
+import {
+  checkClaudeExists,
+  createBackup,
+  renameClaudeDir,
+  updateProjectFiles,
+  updateHistory,
+  verifyClaude,
+  rollbackClaude,
+  removeBackup,
+} from './claude.js';
+import {
+  detectCursor,
+  checkCursorNotRunning,
+  findCursorWorkspaces,
+  backupCursorData,
+  renameCursorWorkspace,
+  updateCursorStorageJson,
+  updateCursorStateVscdb,
+  updateCursorWorkspaceStorage,
+  verifyCursorMigration,
+  rollbackCursor,
+} from './cursor.js';
+
+const USAGE = `Usage: ccmv [OPTIONS] <old-path> <new-path>
+
+Moves a project directory and updates all Claude Code references.
+If Cursor is installed, also updates Cursor's workspace data automatically.
+
+Options:
+  --refs-only    Only update Claude's references (don't move the actual directory)
+  --dry-run      Show what would be done without making changes
+  --keep-backup  Don't remove backups after successful migration
+  --no-cursor    Skip Cursor data updates even if Cursor is installed
+  --verbose      Show detailed logs (default: on)
+  --quiet        Suppress detailed logs
+  --help         Show this help message
+
+Examples:
+  ccmv /Users/jane/old-project /Users/jane/new-project
+  ccmv --dry-run ~/projects/myapp ~/work/myapp
+  ccmv --refs-only /old/path /new/path
+  ccmv --no-cursor ~/proj-a ~/proj-b
+`;
+
+/**
+ * Parse command line arguments
+ */
+function parseArgs(args) {
+  const options = {
+    dryRun: false,
+    refsOnly: false,
+    keepBackup: false,
+    verbose: true,
+    noCursor: false,
+    help: false,
+    paths: [],
+  };
+
+  for (const arg of args) {
+    switch (arg) {
+      case '--dry-run':
+        options.dryRun = true;
+        break;
+      case '--refs-only':
+        options.refsOnly = true;
+        break;
+      case '--keep-backup':
+        options.keepBackup = true;
+        break;
+      case '--verbose':
+        options.verbose = true;
+        break;
+      case '--quiet':
+        options.verbose = false;
+        break;
+      case '--no-cursor':
+        options.noCursor = true;
+        break;
+      case '--help':
+      case '-h':
+        options.help = true;
+        break;
+      default:
+        if (arg.startsWith('-')) {
+          logError(`Unknown option: ${arg}`);
+          console.log('Use --help for usage information');
+          process.exit(1);
+        }
+        options.paths.push(arg);
+    }
+  }
+
+  return options;
+}
+
+/**
+ * Validate paths and environment
+ */
+function validate(oldPath, newPath, refsOnly) {
+  logCheck('Validating paths...');
+
+  // Check old path exists
+  if (!existsSync(oldPath)) {
+    if (refsOnly) {
+      logInfo("Old path doesn't exist (OK for --refs-only mode)");
+    } else {
+      logError(`Old path does not exist: ${oldPath}`);
+      return false;
+    }
+  } else {
+    logOk('Old path exists');
+  }
+
+  // Check new path doesn't exist (unless refs-only)
+  if (!refsOnly) {
+    if (existsSync(newPath)) {
+      logError(`New path already exists: ${newPath}`);
+      return false;
+    }
+    logOk('New path does not exist');
+  }
+
+  console.log('');
+  return true;
+}
+
+/**
+ * Move the actual project directory
+ */
+function moveProject(oldPath, newPath, refsOnly, dryRun) {
+  if (refsOnly) {
+    return;
+  }
+
+  if (dryRun) {
+    logDryrun(`Would move: ${oldPath} -> ${newPath}`);
+    console.log('');
+    return;
+  }
+
+  logInfo('Moving project directory...');
+  renameSync(oldPath, newPath);
+  logOk(`Moved: ${oldPath} -> ${newPath}`);
+  console.log('');
+}
+
+/**
+ * Rollback on error
+ */
+function rollback(backupDir, oldPath, newPath, encodedOld, encodedNew, refsOnly, cursorDetected) {
+  if (!backupDir || !existsSync(backupDir)) {
+    logError('No backup available for rollback');
+    return;
+  }
+
+  logError('Migration failed! Rolling back...');
+
+  // Rollback Claude data
+  rollbackClaude(backupDir, encodedOld, encodedNew);
+
+  // Restore original project location if moved
+  if (!refsOnly) {
+    if (existsSync(newPath) && !existsSync(oldPath)) {
+      renameSync(newPath, oldPath);
+      logRollback('Moved project back to original location');
+    }
+  }
+
+  // Rollback Cursor data
+  if (cursorDetected) {
+    rollbackCursor(backupDir);
+  }
+
+  logRollback('Complete. Your project is unchanged.');
+  console.log('');
+  console.log(`Backup kept at: ${backupDir}`);
+}
+
+/**
+ * Main entry point
+ */
+export async function main(args) {
+  const options = parseArgs(args);
+
+  if (options.help) {
+    console.log(USAGE);
+    process.exit(0);
+  }
+
+  if (options.paths.length !== 2) {
+    logError('Expected 2 arguments: old-path and new-path');
+    console.log('Use --help for usage information');
+    process.exit(1);
+  }
+
+  setVerbose(options.verbose);
+
+  // Resolve paths
+  const oldPath = resolvePath(options.paths[0]);
+  const newPath = resolveNewPath(options.paths[1]);
+
+  // Encode paths for Claude
+  const encodedOld = encodePath(oldPath);
+  const encodedNew = encodePath(newPath);
+
+  // Generate file:// URIs for Cursor
+  const oldFileUri = pathToFileUri(oldPath);
+  const newFileUri = pathToFileUri(newPath);
+
+  // Display info
+  console.log('');
+  logInfo(`Old path: ${oldPath}`);
+  logInfo(`New path: ${newPath}`);
+  logInfo(`Encoded old: ${encodedOld}`);
+  logInfo(`Encoded new: ${encodedNew}`);
+
+  if (options.dryRun) {
+    console.log('');
+    logDryrun('Running in dry-run mode - no changes will be made');
+  }
+
+  if (options.refsOnly) {
+    console.log('');
+    logInfo('Running in refs-only mode - project directory will not be moved');
+  }
+
+  console.log('');
+
+  // State for rollback
+  let backupDir = null;
+  let cursorDetected = false;
+  let claudeExists = false;
+  let cursorWorkspaceInfo = { oldWorkspaceHash: null, workspaceDirs: [] };
+
+  try {
+    // Validate paths
+    if (!validate(oldPath, newPath, options.refsOnly)) {
+      process.exit(1);
+    }
+
+    // Check Claude data exists
+    claudeExists = checkClaudeExists(encodedOld);
+
+    // Detect and check Cursor
+    cursorDetected = detectCursor(options.noCursor);
+    if (!checkCursorNotRunning(cursorDetected, options.dryRun)) {
+      process.exit(1);
+    }
+
+    // Find Cursor workspaces
+    cursorWorkspaceInfo = findCursorWorkspaces(cursorDetected, oldPath);
+
+    // Fail if neither Claude nor Cursor data exists
+    const hasCursorData = cursorWorkspaceInfo.workspaceDirs.length > 0;
+    if (!claudeExists && !hasCursorData) {
+      logError('No Claude Code or Cursor data found for this project.');
+      logError('Use regular mv command to move the directory.');
+      process.exit(1);
+    }
+
+    // Create backups
+    backupDir = createBackup(encodedOld, options.dryRun, claudeExists);
+    backupCursorData(cursorDetected, cursorWorkspaceInfo.workspaceDirs, backupDir, options.dryRun);
+
+    // Move project
+    moveProject(oldPath, newPath, options.refsOnly, options.dryRun);
+
+    // Rename Cursor workspace (after move, uses new birthtime)
+    const renamedWorkspace = renameCursorWorkspace(
+      cursorDetected,
+      cursorWorkspaceInfo.oldWorkspaceHash,
+      newPath,
+      oldFileUri,
+      newFileUri,
+      options.dryRun
+    );
+    if (renamedWorkspace.workspaceDirs.length > 0) {
+      cursorWorkspaceInfo.workspaceDirs = renamedWorkspace.workspaceDirs;
+    }
+
+    // Rename Claude dir
+    renameClaudeDir(encodedOld, encodedNew, options.dryRun, claudeExists);
+
+    // Update files
+    updateProjectFiles(oldPath, newPath, encodedOld, encodedNew, options.dryRun, claudeExists);
+    updateHistory(oldPath, newPath, options.dryRun);
+
+    // Update Cursor data
+    updateCursorStorageJson(cursorDetected, oldPath, newPath, oldFileUri, newFileUri, options.dryRun);
+    await updateCursorStateVscdb(cursorDetected, oldPath, newPath, oldFileUri, newFileUri, options.dryRun);
+    await updateCursorWorkspaceStorage(
+      cursorDetected,
+      cursorWorkspaceInfo.workspaceDirs,
+      oldPath,
+      newPath,
+      oldFileUri,
+      newFileUri,
+      options.dryRun
+    );
+
+    // Verify
+    if (!verifyClaude(oldPath, encodedNew, options.dryRun, claudeExists)) {
+      throw new Error('Claude verification failed');
+    }
+    if (!verifyCursorMigration(cursorDetected, cursorWorkspaceInfo.workspaceDirs, oldPath, newPath, options.dryRun)) {
+      throw new Error('Cursor verification failed');
+    }
+
+    // Cleanup
+    if (!options.dryRun) {
+      if (options.keepBackup) {
+        logInfo(`Backup kept at: ${backupDir.replace(homedir(), '~')}/`);
+      } else {
+        removeBackup(backupDir);
+      }
+    }
+
+    // Success
+    if (options.dryRun) {
+      logDone('Dry-run complete! No changes were made.');
+    } else {
+      logDone('Migration complete!');
+      if (!options.refsOnly) {
+        logInfo(`Your project is now at: ${newPath}`);
+      }
+    }
+  } catch (err) {
+    if (!options.dryRun && backupDir) {
+      rollback(backupDir, oldPath, newPath, encodedOld, encodedNew, options.refsOnly, cursorDetected);
+    }
+    logError(err.message);
+    process.exit(1);
+  }
+}

package/lib/logger.js

@@ -0,0 +1,60 @@
+// ANSI color codes
+const colors = {
+  red: '\x1b[0;31m',
+  green: '\x1b[0;32m',
+  yellow: '\x1b[0;33m',
+  blue: '\x1b[0;34m',
+  reset: '\x1b[0m',
+};
+
+let verbose = true;
+
+export function setVerbose(value) {
+  verbose = value;
+}
+
+export function logInfo(message) {
+  console.log(`${colors.blue}[INFO]${colors.reset} ${message}`);
+}
+
+export function logOk(message) {
+  console.log(`${colors.green}[OK]${colors.reset} ${message}`);
+}
+
+export function logCheck(message) {
+  console.log(`${colors.yellow}[CHECK]${colors.reset} ${message}`);
+}
+
+export function logBackup(message) {
+  console.log(`${colors.yellow}[BACKUP]${colors.reset} ${message}`);
+}
+
+export function logFile(message) {
+  console.log(`${colors.blue}[FILE]${colors.reset} ${message}`);
+}
+
+export function logReplace(message) {
+  if (verbose) {
+    console.log(`  ${colors.green}[REPLACE]${colors.reset} ${message}`);
+  }
+}
+
+export function logRename(message) {
+  console.log(`${colors.blue}[RENAME]${colors.reset} ${message}`);
+}
+
+export function logDone(message) {
+  console.log(`${colors.green}[DONE]${colors.reset} ${message}`);
+}
+
+export function logError(message) {
+  console.error(`${colors.red}[ERROR]${colors.reset} ${message}`);
+}
+
+export function logRollback(message) {
+  console.log(`${colors.yellow}[ROLLBACK]${colors.reset} ${message}`);
+}
+
+export function logDryrun(message) {
+  console.log(`${colors.yellow}[DRY-RUN]${colors.reset} ${message}`);
+}

package/lib/utils.js

@@ -0,0 +1,93 @@
+import { createHash } from 'node:crypto';
+import { statSync, existsSync } from 'node:fs';
+import { resolve, dirname, basename } from 'node:path';
+
+/**
+ * Encode path for Claude projects directory
+ * Rule: / -> -, : -> -, space -> -
+ */
+export function encodePath(path) {
+  return path.replace(/[\/: ]/g, '-');
+}
+
+/**
+ * Convert filesystem path to file:// URI with URL encoding
+ */
+export function pathToFileUri(path) {
+  // URL encode the path, keeping / as safe character
+  const encoded = path
+    .split('/')
+    .map((segment) => encodeURIComponent(segment))
+    .join('/');
+  return `file://${encoded}`;
+}
+
+/**
+ * Calculate VSCode/Cursor workspace hash from path
+ * Hash = MD5(path + birthtime_ms)
+ */
+export function getWorkspaceHash(path) {
+  if (!existsSync(path)) {
+    return null;
+  }
+
+  try {
+    const stat = statSync(path);
+    const birthtimeMs = stat.birthtime.getTime();
+    const hash = createHash('md5')
+      .update(path)
+      .update(String(birthtimeMs))
+      .digest('hex');
+    return hash;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Resolve path to absolute, handling relative paths
+ */
+export function resolvePath(inputPath) {
+  // Expand ~ to home directory
+  if (inputPath.startsWith('~')) {
+    inputPath = inputPath.replace(/^~/, process.env.HOME || '');
+  }
+  return resolve(inputPath).replace(/\/$/, ''); // Remove trailing slash
+}
+
+/**
+ * Resolve new path (which may not exist yet)
+ */
+export function resolveNewPath(inputPath) {
+  // Expand ~ to home directory
+  if (inputPath.startsWith('~')) {
+    inputPath = inputPath.replace(/^~/, process.env.HOME || '');
+  }
+
+  const parent = dirname(inputPath);
+  const name = basename(inputPath);
+
+  // Resolve parent (which should exist)
+  const resolvedParent = resolve(parent);
+  return `${resolvedParent}/${name}`.replace(/\/$/, '');
+}
+
+/**
+ * Convert path to tilde form if under home directory
+ */
+export function pathToTilde(path) {
+  const home = process.env.HOME || '';
+  if (path.startsWith(home)) {
+    return path.replace(home, '~');
+  }
+  return path;
+}
+
+/**
+ * Format timestamp for backup directory
+ */
+export function formatTimestamp() {
+  const now = new Date();
+  const pad = (n) => String(n).padStart(2, '0');
+  return `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "ccmv",
+  "version": "1.0.0",
+  "description": "Claude Code project directory migration tool",
+  "type": "module",
+  "main": "lib/index.js",
+  "bin": {
+    "ccmv": "./bin/ccmv.js"
+  },
+  "scripts": {
+    "test": "node --test"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "migration",
+    "cursor",
+    "vscode"
+  ],
+  "author": "Saqoosha",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/saqoosha/ccmv.git"
+  },
+  "bugs": {
+    "url": "https://github.com/saqoosha/ccmv/issues"
+  },
+  "homepage": "https://github.com/saqoosha/ccmv#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "better-sqlite3": "^11.0.0"
+  }
+}