aiblueprint-cli 1.4.66 → 1.4.68

package/README.md

@@ -77,7 +77,7 @@ npx aiblueprint-cli@latest agents symlink
 # Centralize global skills and agents in ~/.agents
 npx aiblueprint-cli@latest agents unify
 
-# Unify project-local .claude/.codex/.cursor config into .agents
+# Unify project-local .claude/.cursor config into .agents
 npx aiblueprint-cli@latest agents unify projects
 
 # Recover sessions from saved configs and backups

package/dist/cli.js

@@ -34892,10 +34892,132 @@ async function symlinkCommand(params = {}) {
 }
 
 // src/lib/agents-unifier.ts
-var import_fs_extra12 = __toESM(require_lib4(), 1);
+var import_fs_extra13 = __toESM(require_lib4(), 1);
 import crypto from "crypto";
-import os13 from "os";
+import os14 from "os";
+import path17 from "path";
+
+// src/lib/backup-utils.ts
+var import_fs_extra12 = __toESM(require_lib4(), 1);
 import path16 from "path";
+import os13 from "os";
+var BACKUP_BASE_DIR = path16.join(os13.homedir(), ".config", "aiblueprint", "backup");
+function getBackupDir() {
+  return process.env.AIBLUEPRINT_BACKUP_DIR || BACKUP_BASE_DIR;
+}
+function formatDate(date) {
+  const pad = (n) => n.toString().padStart(2, "0");
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}-${pad(date.getHours())}-${pad(date.getMinutes())}-${pad(date.getSeconds())}`;
+}
+function createBackupNameSuffix(value) {
+  return value.trim().replace(/^[a-zA-Z]:/, (drive) => drive.replace(":", "")).replace(/[\\/]+/g, "--").replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "root";
+}
+function createTimestampedBackupName(suffix, date = new Date) {
+  const base = formatDate(date);
+  if (!suffix)
+    return base;
+  return `${base}--${createBackupNameSuffix(suffix)}`;
+}
+async function listBackups() {
+  const backupBaseDir = getBackupDir();
+  const exists = await import_fs_extra12.default.pathExists(backupBaseDir);
+  if (!exists) {
+    return [];
+  }
+  const entries = await import_fs_extra12.default.readdir(backupBaseDir, { withFileTypes: true });
+  const backups = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory())
+      continue;
+    const match = entry.name.match(/^(\d{4})-(\d{2})-(\d{2})-(\d{2})-(\d{2})-(\d{2})(?:--.+)?$/);
+    if (!match)
+      continue;
+    const [, year, month, day, hour, minute, second] = match;
+    const date = new Date(parseInt(year), parseInt(month) - 1, parseInt(day), parseInt(hour), parseInt(minute), parseInt(second));
+    backups.push({
+      name: entry.name,
+      path: path16.join(backupBaseDir, entry.name),
+      date
+    });
+  }
+  return backups.sort((a, b) => b.date.getTime() - a.date.getTime());
+}
+var AGENTS_BACKUP_SUBDIR = ".agents";
+var CLAUDE_ITEMS = ["commands", "agents", "skills", "scripts", "settings.json"];
+var MANAGED_FOLDERS = [".claude", ".codex", ".agents"];
+async function copyForBackup(sourcePath, destPath) {
+  await import_fs_extra12.default.copy(sourcePath, destPath, {
+    overwrite: true,
+    dereference: false
+  });
+}
+async function hasMeaningfulContent(dir) {
+  if (!await import_fs_extra12.default.pathExists(dir))
+    return false;
+  const files = await import_fs_extra12.default.readdir(dir);
+  return files.some((f) => f !== ".DS_Store");
+}
+async function loadBackup(backupPath, claudeDir, codexDir, agentsDir) {
+  const exists = await import_fs_extra12.default.pathExists(backupPath);
+  if (!exists) {
+    throw new Error(`Backup not found: ${backupPath}`);
+  }
+  const managedDestinations = {
+    ".claude": claudeDir,
+    ".codex": codexDir,
+    ".agents": agentsDir
+  };
+  let restoredManagedFolder = false;
+  for (const folderName of MANAGED_FOLDERS) {
+    const sourcePath = path16.join(backupPath, folderName);
+    const destPath = managedDestinations[folderName];
+    if (!destPath || !await import_fs_extra12.default.pathExists(sourcePath))
+      continue;
+    await import_fs_extra12.default.ensureDir(destPath);
+    await copyForBackup(sourcePath, destPath);
+    restoredManagedFolder = true;
+  }
+  if (!restoredManagedFolder) {
+    await import_fs_extra12.default.ensureDir(claudeDir);
+    for (const item of CLAUDE_ITEMS) {
+      const sourcePath = path16.join(backupPath, item);
+      const destPath = path16.join(claudeDir, item);
+      if (await import_fs_extra12.default.pathExists(sourcePath)) {
+        await copyForBackup(sourcePath, destPath);
+      }
+    }
+    if (agentsDir) {
+      const agentsBackupPath = path16.join(backupPath, AGENTS_BACKUP_SUBDIR);
+      if (await import_fs_extra12.default.pathExists(agentsBackupPath)) {
+        await import_fs_extra12.default.ensureDir(agentsDir);
+        await copyForBackup(agentsBackupPath, agentsDir);
+      }
+    }
+  }
+}
+async function createBackup(claudeDir, codexDir, agentsDir) {
+  const claudeHasContent = await hasMeaningfulContent(claudeDir);
+  const codexHasContent = codexDir ? await hasMeaningfulContent(codexDir) : false;
+  const agentsHasContent = agentsDir ? await hasMeaningfulContent(agentsDir) : false;
+  if (!claudeHasContent && !codexHasContent && !agentsHasContent) {
+    return null;
+  }
+  const backupPath = path16.join(getBackupDir(), createTimestampedBackupName());
+  await import_fs_extra12.default.ensureDir(backupPath);
+  if (claudeHasContent) {
+    await copyForBackup(claudeDir, path16.join(backupPath, ".claude"));
+  }
+  if (codexHasContent && codexDir) {
+    await copyForBackup(codexDir, path16.join(backupPath, ".codex"));
+  }
+  if (agentsHasContent && agentsDir) {
+    const destPath = path16.join(backupPath, AGENTS_BACKUP_SUBDIR);
+    await copyForBackup(agentsDir, destPath);
+  }
+  return backupPath;
+}
+
+// src/lib/agents-unifier.ts
 var IGNORED_ENTRY_NAMES2 = new Set([
   ".DS_Store",
   ".git",
@@ -34905,7 +35027,7 @@ function uniqueByPath(candidates) {
   const seen = new Set;
   const unique = [];
   for (const candidate of candidates) {
-    const resolved = path16.resolve(candidate.path);
+    const resolved = path17.resolve(candidate.path);
     if (seen.has(resolved))
       continue;
     seen.add(resolved);
@@ -34913,245 +35035,221 @@ function uniqueByPath(candidates) {
   }
   return unique;
 }
-function getContainerCandidates(options) {
+function getContainerCandidates(options, includeCodex = true) {
   const folders = resolveFolders(options);
-  const cursorDir = path16.join(folders.rootDir, ".cursor");
-  const factoryDir = path16.join(folders.rootDir, ".factory");
-  const opencodeDir = path16.join(folders.rootDir, ".config", "opencode");
+  const cursorDir = path17.join(folders.rootDir, ".cursor");
+  const factoryDir = path17.join(folders.rootDir, ".factory");
+  const opencodeDir = path17.join(folders.rootDir, ".config", "opencode");
   return uniqueByPath([
     {
       category: "skills",
       label: "agents-skills",
-      path: path16.join(folders.agentsDir, "skills"),
+      path: path17.join(folders.agentsDir, "skills"),
       isDestination: true
     },
     {
       category: "skills",
       label: "claude-skills",
-      path: path16.join(folders.claudeDir, "skills"),
+      path: path17.join(folders.claudeDir, "skills"),
       linkWhenMissing: true
     },
-    {
+    ...includeCodex ? [{
       category: "skills",
       label: "codex-skills",
-      path: path16.join(folders.codexDir, "skills"),
+      path: path17.join(folders.codexDir, "skills"),
       linkWhenMissing: true
-    },
+    }] : [],
     {
       category: "skills",
       label: "cursor-skills",
-      path: path16.join(cursorDir, "skills"),
+      path: path17.join(cursorDir, "skills"),
       linkWhenParentExists: true
     },
     {
       category: "skills",
       label: "cursor-skills-cursor",
-      path: path16.join(cursorDir, "skills-cursor"),
+      path: path17.join(cursorDir, "skills-cursor"),
       linkWhenParentExists: true
     },
     {
       category: "skills",
       label: "factory-skills",
-      path: path16.join(factoryDir, "skills"),
+      path: path17.join(factoryDir, "skills"),
       linkWhenParentExists: true
     },
     {
       category: "skills",
       label: "opencode-skill",
-      path: path16.join(opencodeDir, "skill"),
+      path: path17.join(opencodeDir, "skill"),
       linkWhenParentExists: true
     },
     {
       category: "skills",
       label: "opencode-skills",
-      path: path16.join(opencodeDir, "skills"),
+      path: path17.join(opencodeDir, "skills"),
       linkWhenParentExists: true
     },
     {
       category: "agents",
       label: "agents-agents",
-      path: path16.join(folders.agentsDir, "agents"),
+      path: path17.join(folders.agentsDir, "agents"),
       isDestination: true
     },
     {
       category: "agents",
       label: "claude-agents",
-      path: path16.join(folders.claudeDir, "agents"),
+      path: path17.join(folders.claudeDir, "agents"),
       linkWhenMissing: true
     },
     {
       category: "agents",
       label: "claude-agnets",
-      path: path16.join(folders.claudeDir, "agnets")
+      path: path17.join(folders.claudeDir, "agnets")
     },
     {
       category: "agents",
       label: "cursor-agents",
-      path: path16.join(cursorDir, "agents"),
+      path: path17.join(cursorDir, "agents"),
       linkWhenParentExists: true
     },
     {
       category: "agents",
       label: "factory-droids",
-      path: path16.join(factoryDir, "droids"),
+      path: path17.join(factoryDir, "droids"),
       linkWhenParentExists: true
     },
     {
       category: "agents",
       label: "opencode-agent",
-      path: path16.join(opencodeDir, "agent"),
+      path: path17.join(opencodeDir, "agent"),
       linkWhenParentExists: true
     },
     {
       category: "agents",
       label: "opencode-agents",
-      path: path16.join(opencodeDir, "agents"),
+      path: path17.join(opencodeDir, "agents"),
       linkWhenParentExists: true
     }
   ]);
 }
-function getInstructionFileCandidates(options) {
+function getInstructionFileCandidates(options, includeCodex = true) {
   const folders = resolveFolders(options);
   return uniqueByPath([
     {
       label: "agents-instructions",
-      path: path16.join(folders.agentsDir, "AGENTS.md"),
+      path: path17.join(folders.agentsDir, "AGENTS.md"),
       isDestination: true
     },
     {
       label: "claude-instructions",
-      path: path16.join(folders.claudeDir, "CLAUDE.md"),
+      path: path17.join(folders.claudeDir, "CLAUDE.md"),
       linkWhenMissing: true
     },
-    {
+    ...includeCodex ? [{
       label: "codex-instructions",
-      path: path16.join(folders.codexDir, "AGENTS.md"),
+      path: path17.join(folders.codexDir, "AGENTS.md"),
       linkWhenMissing: true
-    }
+    }] : []
   ]);
 }
 function getRepositoryContainerCandidates(options) {
   const folders = resolveFolders(options);
-  const cursorDir = path16.join(folders.rootDir, ".cursor");
+  const cursorDir = path17.join(folders.rootDir, ".cursor");
   return uniqueByPath([
-    ...getContainerCandidates(options),
+    ...getContainerCandidates(options, false),
     {
       category: "rules",
       label: "agents-rules",
-      path: path16.join(folders.agentsDir, "rules"),
+      path: path17.join(folders.agentsDir, "rules"),
       isDestination: true
     },
     {
       category: "rules",
       label: "claude-rules",
-      path: path16.join(folders.claudeDir, "rules"),
+      path: path17.join(folders.claudeDir, "rules"),
       linkWhenMissing: true
     },
-    {
-      category: "rules",
-      label: "codex-rules",
-      path: path16.join(folders.codexDir, "rules"),
-      linkWhenParentExists: true
-    },
     {
       category: "rules",
       label: "cursor-rules",
-      path: path16.join(cursorDir, "rules"),
+      path: path17.join(cursorDir, "rules"),
       linkWhenParentExists: true
     },
     {
       category: "rules",
       label: "claude-memories",
-      path: path16.join(folders.claudeDir, "memories"),
-      linkSource: false
-    },
-    {
-      category: "rules",
-      label: "codex-memories",
-      path: path16.join(folders.codexDir, "memories"),
+      path: path17.join(folders.claudeDir, "memories"),
       linkSource: false
     },
     {
       category: "rules",
       label: "cursor-memories",
-      path: path16.join(cursorDir, "memories"),
+      path: path17.join(cursorDir, "memories"),
       linkSource: false
     },
     {
       category: "rules",
       label: "claude-memory",
-      path: path16.join(folders.claudeDir, "memory.md"),
-      linkSource: false
-    },
-    {
-      category: "rules",
-      label: "codex-memory",
-      path: path16.join(folders.codexDir, "memory.md"),
+      path: path17.join(folders.claudeDir, "memory.md"),
       linkSource: false
     },
     {
       category: "rules",
       label: "cursor-memory",
-      path: path16.join(cursorDir, "memory.md"),
+      path: path17.join(cursorDir, "memory.md"),
       linkSource: false
     },
     {
       category: "rules",
       label: "claude-memory-uppercase",
-      path: path16.join(folders.claudeDir, "MEMORY.md"),
-      linkSource: false
-    },
-    {
-      category: "rules",
-      label: "codex-memory-uppercase",
-      path: path16.join(folders.codexDir, "MEMORY.md"),
+      path: path17.join(folders.claudeDir, "MEMORY.md"),
       linkSource: false
     },
     {
       category: "rules",
       label: "cursor-memory-uppercase",
-      path: path16.join(cursorDir, "MEMORY.md"),
+      path: path17.join(cursorDir, "MEMORY.md"),
       linkSource: false
     }
   ]);
 }
 async function pathExistsOrSymlink(targetPath) {
-  const stat = await import_fs_extra12.default.lstat(targetPath).catch(() => null);
+  const stat = await import_fs_extra13.default.lstat(targetPath).catch(() => null);
   return Boolean(stat);
 }
 async function realPathIfPossible(targetPath) {
   try {
-    return await import_fs_extra12.default.realpath(targetPath);
+    return await import_fs_extra13.default.realpath(targetPath);
   } catch {
     return null;
   }
 }
 function samePath(a, b) {
-  return path16.resolve(a) === path16.resolve(b);
+  return path17.resolve(a) === path17.resolve(b);
 }
 function hashString(value) {
   return crypto.createHash("sha256").update(value).digest("hex");
 }
 async function hashPath(targetPath) {
-  const stat = await import_fs_extra12.default.lstat(targetPath);
+  const stat = await import_fs_extra13.default.lstat(targetPath);
   if (stat.isSymbolicLink()) {
-    const linkTarget = await import_fs_extra12.default.readlink(targetPath);
+    const linkTarget = await import_fs_extra13.default.readlink(targetPath);
     return hashString(`symlink:${linkTarget}`);
   }
   if (stat.isFile()) {
     const fileHash = crypto.createHash("sha256");
     fileHash.update("file:");
-    fileHash.update(await import_fs_extra12.default.readFile(targetPath));
+    fileHash.update(await import_fs_extra13.default.readFile(targetPath));
     return fileHash.digest("hex");
   }
   if (stat.isDirectory()) {
-    const entries = (await import_fs_extra12.default.readdir(targetPath, { withFileTypes: true })).filter((entry) => !IGNORED_ENTRY_NAMES2.has(entry.name)).sort((a, b) => a.name.localeCompare(b.name));
+    const entries = (await import_fs_extra13.default.readdir(targetPath, { withFileTypes: true })).filter((entry) => !IGNORED_ENTRY_NAMES2.has(entry.name)).sort((a, b) => a.name.localeCompare(b.name));
     const dirHash = crypto.createHash("sha256");
     dirHash.update("dir:");
     for (const entry of entries) {
       dirHash.update(entry.name);
       dirHash.update("\x00");
-      dirHash.update(await hashPath(path16.join(targetPath, entry.name)));
+      dirHash.update(await hashPath(path17.join(targetPath, entry.name)));
       dirHash.update("\x00");
     }
     return dirHash.digest("hex");
@@ -35197,39 +35295,39 @@ function normalizePortableText(content) {
   return normalized;
 }
 function isLikelyTextFile(filePath) {
-  const ext = path16.extname(filePath).toLowerCase();
+  const ext = path17.extname(filePath).toLowerCase();
   if (TEXT_EXTENSIONS.has(ext))
     return true;
-  return path16.basename(filePath) === "SKILL.md";
+  return path17.basename(filePath) === "SKILL.md";
 }
 async function normalizePortableContent(targetPath) {
-  const stat = await import_fs_extra12.default.lstat(targetPath).catch(() => null);
+  const stat = await import_fs_extra13.default.lstat(targetPath).catch(() => null);
   if (!stat || stat.isSymbolicLink())
     return;
   if (stat.isDirectory()) {
-    const entries = await import_fs_extra12.default.readdir(targetPath);
+    const entries = await import_fs_extra13.default.readdir(targetPath);
     for (const entry of entries) {
       if (IGNORED_ENTRY_NAMES2.has(entry))
         continue;
-      await normalizePortableContent(path16.join(targetPath, entry));
+      await normalizePortableContent(path17.join(targetPath, entry));
     }
     return;
   }
   if (!stat.isFile() || !isLikelyTextFile(targetPath))
     return;
-  const content = await import_fs_extra12.default.readFile(targetPath, "utf-8").catch(() => null);
+  const content = await import_fs_extra13.default.readFile(targetPath, "utf-8").catch(() => null);
   if (content === null || content.includes("\x00"))
     return;
   const normalized = normalizePortableText(content);
   if (normalized !== content) {
-    await import_fs_extra12.default.writeFile(targetPath, normalized, "utf-8");
+    await import_fs_extra13.default.writeFile(targetPath, normalized, "utf-8");
   }
 }
 function suffixFromLabel(label) {
   return label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "source";
 }
 function nameWithSuffix(name, suffix, index) {
-  const parsed = path16.parse(name);
+  const parsed = path17.parse(name);
   const numberedSuffix = index === 1 ? suffix : `${suffix}-${index}`;
   if (parsed.ext && parsed.name) {
     return `${parsed.name}--${numberedSuffix}${parsed.ext}`;
@@ -35241,32 +35339,31 @@ async function findTargetName(destinationDir, originalName, label) {
   let index = 1;
   while (true) {
     const candidate = nameWithSuffix(originalName, suffix, index);
-    if (!await pathExistsOrSymlink(path16.join(destinationDir, candidate))) {
+    if (!await pathExistsOrSymlink(path17.join(destinationDir, candidate))) {
       return candidate;
     }
     index++;
   }
 }
 async function addExistingDestinationHashes(destinationDir, knownHashes) {
-  if (!await import_fs_extra12.default.pathExists(destinationDir))
+  if (!await import_fs_extra13.default.pathExists(destinationDir))
     return;
-  const entries = await import_fs_extra12.default.readdir(destinationDir, { withFileTypes: true });
+  const entries = await import_fs_extra13.default.readdir(destinationDir, { withFileTypes: true });
   for (const entry of entries) {
     if (IGNORED_ENTRY_NAMES2.has(entry.name))
       continue;
-    const entryPath = path16.join(destinationDir, entry.name);
+    const entryPath = path17.join(destinationDir, entry.name);
     knownHashes.set(await hashPath(entryPath), entry.name);
   }
 }
 async function importCategoryEntries(category, candidates, destinationDir, result) {
-  await import_fs_extra12.default.ensureDir(destinationDir);
-  const destinationRealPath = await realPathIfPossible(destinationDir);
-  const knownHashes = new Map;
-  await addExistingDestinationHashes(destinationDir, knownHashes);
+  const sourceEntries = [];
+  const destinationExists = await pathExistsOrSymlink(destinationDir);
+  const destinationRealPath = destinationExists ? await realPathIfPossible(destinationDir) : null;
   for (const candidate of candidates) {
     if (candidate.category !== category || candidate.isDestination)
       continue;
-    const candidateStat = await import_fs_extra12.default.lstat(candidate.path).catch(() => null);
+    const candidateStat = await import_fs_extra13.default.lstat(candidate.path).catch(() => null);
     if (!candidateStat)
       continue;
     const candidateRealPath = await realPathIfPossible(candidate.path);
@@ -35282,9 +35379,24 @@ async function importCategoryEntries(category, candidates, destinationDir, resul
       });
       continue;
     }
+    const collectableEntries = [];
     for (const entry of entries) {
-      if (!shouldCollectPath(category, entry.name, entry.path))
+      if (!await shouldCollectPath(category, entry.name, entry.path))
         continue;
+      collectableEntries.push(entry);
+    }
+    if (collectableEntries.length > 0) {
+      sourceEntries.push({ candidate, entries: collectableEntries });
+    }
+  }
+  if (!destinationExists && sourceEntries.length === 0) {
+    return false;
+  }
+  await import_fs_extra13.default.ensureDir(destinationDir);
+  const knownHashes = new Map;
+  await addExistingDestinationHashes(destinationDir, knownHashes);
+  for (const { candidate, entries } of sourceEntries) {
+    for (const entry of entries) {
       const sourcePath = entry.path;
       const sourceHash = await hashPath(sourcePath);
       const existingName = knownHashes.get(sourceHash);
@@ -35293,15 +35405,15 @@ async function importCategoryEntries(category, candidates, destinationDir, resul
           category,
           name: entry.name,
           from: sourcePath,
-          keptAs: path16.join(destinationDir, existingName)
+          keptAs: path17.join(destinationDir, existingName)
         });
         continue;
       }
       let targetName = entry.name;
-      let targetPath = path16.join(destinationDir, targetName);
+      let targetPath = path17.join(destinationDir, targetName);
       if (await pathExistsOrSymlink(targetPath)) {
         targetName = await findTargetName(destinationDir, entry.name, candidate.label);
-        targetPath = path16.join(destinationDir, targetName);
+        targetPath = path17.join(destinationDir, targetName);
         result.renamed.push({
           category,
           name: entry.name,
@@ -35310,12 +35422,12 @@ async function importCategoryEntries(category, candidates, destinationDir, resul
           reason: "Same name with different content"
         });
       }
-      await import_fs_extra12.default.copy(sourcePath, targetPath, {
+      await import_fs_extra13.default.copy(sourcePath, targetPath, {
         dereference: false,
         overwrite: false
       });
       await normalizePortableContent(targetPath);
-      knownHashes.set(sourceHash, targetName);
+      knownHashes.set(await hashPath(targetPath), targetName);
       result.imported.push({
         category,
         name: entry.name,
@@ -35324,28 +35436,29 @@ async function importCategoryEntries(category, candidates, destinationDir, resul
       });
     }
   }
+  return true;
 }
 async function collectCandidateEntries(candidate) {
-  const stat = await import_fs_extra12.default.lstat(candidate.path);
+  const stat = await import_fs_extra13.default.lstat(candidate.path);
   if (stat.isDirectory()) {
-    const entries = await import_fs_extra12.default.readdir(candidate.path, { withFileTypes: true });
+    const entries = await import_fs_extra13.default.readdir(candidate.path, { withFileTypes: true });
     return entries.map((entry) => ({
       name: entry.name,
-      path: path16.join(candidate.path, entry.name)
+      path: path17.join(candidate.path, entry.name)
     }));
   }
   if (stat.isSymbolicLink()) {
-    const targetStat = await import_fs_extra12.default.stat(candidate.path).catch(() => null);
+    const targetStat = await import_fs_extra13.default.stat(candidate.path).catch(() => null);
     if (targetStat?.isDirectory()) {
-      const entries = await import_fs_extra12.default.readdir(candidate.path, { withFileTypes: true });
+      const entries = await import_fs_extra13.default.readdir(candidate.path, { withFileTypes: true });
       return entries.map((entry) => ({
         name: entry.name,
-        path: path16.join(candidate.path, entry.name)
+        path: path17.join(candidate.path, entry.name)
       }));
     }
   }
   return [{
-    name: path16.basename(candidate.path),
+    name: path17.basename(candidate.path),
     path: candidate.path
   }];
 }
@@ -35355,53 +35468,51 @@ async function shouldCollectPath(category, name, sourcePath) {
   if (category === "skills" && name === ".cursor-managed-skills-manifest.json") {
     return true;
   }
-  const stat = await import_fs_extra12.default.lstat(sourcePath).catch(() => null);
+  const stat = await import_fs_extra13.default.lstat(sourcePath).catch(() => null);
   if (!stat)
     return false;
   return stat.isFile() || stat.isDirectory() || stat.isSymbolicLink();
 }
-function timestamp2(date = new Date) {
-  return date.toISOString().replace(/\.\d{3}Z$/, "").replace(/[:T]/g, "-");
-}
 function safeRelativePath(rootDir, targetPath) {
-  const relativePath = path16.relative(rootDir, targetPath);
-  if (!relativePath || relativePath.startsWith("..") || path16.isAbsolute(relativePath)) {
-    return path16.join("external", targetPath.replace(/[^a-zA-Z0-9._-]+/g, "-"));
+  const relativePath = path17.relative(rootDir, targetPath);
+  if (!relativePath || relativePath.startsWith("..") || path17.isAbsolute(relativePath)) {
+    return path17.join("external", targetPath.replace(/[^a-zA-Z0-9._-]+/g, "-"));
   }
   return relativePath;
 }
 function createBackupPath(rootDir) {
-  return path16.join(rootDir, ".aiblueprint", "backups", "agents-unify-sources", timestamp2());
+  const projectKey = createBackupNameSuffix(path17.resolve(rootDir));
+  return path17.join(getBackupDir(), createTimestampedBackupName(`project-${projectKey}-agents-unify-sources`));
 }
 async function ensureBackupPath(result) {
   if (!result.backupPath) {
     result.backupPath = createBackupPath(result.rootDir);
-    await import_fs_extra12.default.ensureDir(result.backupPath);
+    await import_fs_extra13.default.ensureDir(result.backupPath);
   }
   return result.backupPath;
 }
 async function createDirectorySymlink(source, target) {
-  await import_fs_extra12.default.ensureDir(path16.dirname(target));
-  if (os13.platform() === "win32") {
-    await import_fs_extra12.default.symlink(source, target, "junction");
+  await import_fs_extra13.default.ensureDir(path17.dirname(target));
+  if (os14.platform() === "win32") {
+    await import_fs_extra13.default.symlink(source, target, "junction");
     return;
   }
-  await import_fs_extra12.default.symlink(source, target, "dir");
+  await import_fs_extra13.default.symlink(source, target, "dir");
 }
 async function createFileSymlink(source, target) {
-  await import_fs_extra12.default.ensureDir(path16.dirname(target));
-  if (os13.platform() === "win32") {
-    await import_fs_extra12.default.symlink(source, target, "file");
+  await import_fs_extra13.default.ensureDir(path17.dirname(target));
+  if (os14.platform() === "win32") {
+    await import_fs_extra13.default.symlink(source, target, "file");
     return;
   }
-  await import_fs_extra12.default.symlink(source, target);
+  await import_fs_extra13.default.symlink(source, target);
 }
 async function shouldLinkMissingContainer(candidate) {
   if (candidate.linkWhenMissing)
     return true;
   if (!candidate.linkWhenParentExists)
     return false;
-  return import_fs_extra12.default.pathExists(path16.dirname(candidate.path));
+  return import_fs_extra13.default.pathExists(path17.dirname(candidate.path));
 }
 async function linkContainer(candidate, destinationDir, result) {
   if (candidate.linkSource === false) {
@@ -35411,7 +35522,7 @@ async function linkContainer(candidate, destinationDir, result) {
     return;
   }
   const destinationRealPath = await realPathIfPossible(destinationDir);
-  const stat = await import_fs_extra12.default.lstat(candidate.path).catch(() => null);
+  const stat = await import_fs_extra13.default.lstat(candidate.path).catch(() => null);
   if (!stat) {
     if (!await shouldLinkMissingContainer(candidate))
       return;
@@ -35433,7 +35544,7 @@ async function linkContainer(candidate, destinationDir, result) {
       });
       return;
     }
-    await import_fs_extra12.default.remove(candidate.path);
+    await import_fs_extra13.default.remove(candidate.path);
     await createDirectorySymlink(destinationDir, candidate.path);
     result.linked.push({
       category: candidate.category,
@@ -35443,9 +35554,9 @@ async function linkContainer(candidate, destinationDir, result) {
     return;
   }
   const backupRoot = await ensureBackupPath(result);
-  const backupTarget = path16.join(backupRoot, safeRelativePath(result.rootDir, candidate.path));
-  await import_fs_extra12.default.ensureDir(path16.dirname(backupTarget));
-  await import_fs_extra12.default.move(candidate.path, backupTarget, { overwrite: false });
+  const backupTarget = path17.join(backupRoot, safeRelativePath(result.rootDir, candidate.path));
+  await import_fs_extra13.default.ensureDir(path17.dirname(backupTarget));
+  await import_fs_extra13.default.move(candidate.path, backupTarget, { overwrite: false });
   await createDirectorySymlink(destinationDir, candidate.path);
   result.linked.push({
     category: candidate.category,
@@ -35455,29 +35566,37 @@ async function linkContainer(candidate, destinationDir, result) {
   });
 }
 async function importInstructionFiles(candidates, destinationPath, result) {
-  await import_fs_extra12.default.ensureDir(path16.dirname(destinationPath));
-  const destinationRealPath = await realPathIfPossible(destinationPath);
-  let destinationHash = await pathExistsOrSymlink(destinationPath) ? await hashPath(destinationPath) : null;
+  const destinationExists = await pathExistsOrSymlink(destinationPath);
+  const destinationRealPath = destinationExists ? await realPathIfPossible(destinationPath) : null;
+  const sourceCandidates = [];
   for (const candidate of candidates) {
     if (candidate.isDestination)
       continue;
-    const sourceStat = await import_fs_extra12.default.lstat(candidate.path).catch(() => null);
+    const sourceStat = await import_fs_extra13.default.lstat(candidate.path).catch(() => null);
     if (!sourceStat)
       continue;
     const sourceRealPath = await realPathIfPossible(candidate.path);
     if (destinationRealPath && sourceRealPath && samePath(destinationRealPath, sourceRealPath)) {
       continue;
     }
+    sourceCandidates.push(candidate);
+  }
+  if (!destinationExists && sourceCandidates.length === 0) {
+    return false;
+  }
+  await import_fs_extra13.default.ensureDir(path17.dirname(destinationPath));
+  let destinationHash = destinationExists ? await hashPath(destinationPath) : null;
+  for (const candidate of sourceCandidates) {
     const sourceHash = await hashPath(candidate.path);
     if (!destinationHash) {
-      await import_fs_extra12.default.copy(candidate.path, destinationPath, {
+      await import_fs_extra13.default.copy(candidate.path, destinationPath, {
         dereference: false,
         overwrite: false
       });
       destinationHash = sourceHash;
       result.imported.push({
         category: "instructions",
-        name: path16.basename(candidate.path),
+        name: path17.basename(candidate.path),
         from: candidate.path,
         to: destinationPath
       });
@@ -35486,26 +35605,27 @@ async function importInstructionFiles(candidates, destinationPath, result) {
     if (sourceHash === destinationHash) {
       result.duplicates.push({
         category: "instructions",
-        name: path16.basename(candidate.path),
+        name: path17.basename(candidate.path),
         from: candidate.path,
         keptAs: destinationPath
       });
       continue;
     }
-    const targetName = await findTargetName(path16.dirname(destinationPath), path16.basename(destinationPath), candidate.label);
-    const targetPath = path16.join(path16.dirname(destinationPath), targetName);
-    await import_fs_extra12.default.copy(candidate.path, targetPath, {
+    const targetName = await findTargetName(path17.dirname(destinationPath), path17.basename(destinationPath), candidate.label);
+    const targetPath = path17.join(path17.dirname(destinationPath), targetName);
+    await import_fs_extra13.default.copy(candidate.path, targetPath, {
       dereference: false,
       overwrite: false
     });
     result.renamed.push({
       category: "instructions",
-      name: path16.basename(candidate.path),
+      name: path17.basename(candidate.path),
       from: candidate.path,
       to: targetPath,
       reason: "Shared instruction file already exists with different content"
     });
   }
+  return true;
 }
 async function shouldLinkMissingInstruction(candidate) {
   if (candidate.linkWhenMissing)
@@ -35520,7 +35640,7 @@ async function linkInstructionFile(candidate, destinationPath, result) {
     return;
   }
   const destinationRealPath = await realPathIfPossible(destinationPath);
-  const stat = await import_fs_extra12.default.lstat(candidate.path).catch(() => null);
+  const stat = await import_fs_extra13.default.lstat(candidate.path).catch(() => null);
   if (!stat) {
     if (!await shouldLinkMissingInstruction(candidate))
       return;
@@ -35542,7 +35662,7 @@ async function linkInstructionFile(candidate, destinationPath, result) {
       });
       return;
     }
-    await import_fs_extra12.default.remove(candidate.path);
+    await import_fs_extra13.default.remove(candidate.path);
     await createFileSymlink(destinationPath, candidate.path);
     result.linked.push({
       category: "instructions",
@@ -35552,9 +35672,9 @@ async function linkInstructionFile(candidate, destinationPath, result) {
     return;
   }
   const backupRoot = await ensureBackupPath(result);
-  const backupTarget = path16.join(backupRoot, safeRelativePath(result.rootDir, candidate.path));
-  await import_fs_extra12.default.ensureDir(path16.dirname(backupTarget));
-  await import_fs_extra12.default.move(candidate.path, backupTarget, { overwrite: false });
+  const backupTarget = path17.join(backupRoot, safeRelativePath(result.rootDir, candidate.path));
+  await import_fs_extra13.default.ensureDir(path17.dirname(backupTarget));
+  await import_fs_extra13.default.move(candidate.path, backupTarget, { overwrite: false });
   await createFileSymlink(destinationPath, candidate.path);
   result.linked.push({
     category: "instructions",
@@ -35566,31 +35686,31 @@ async function linkInstructionFile(candidate, destinationPath, result) {
 var RULES_INDEX_START = "<!-- AIBLUEPRINT:RULES:START -->";
 var RULES_INDEX_END = "<!-- AIBLUEPRINT:RULES:END -->";
 function titleFromRulePath(rulePath) {
-  return path16.basename(rulePath, path16.extname(rulePath)).replace(/[-_]+/g, " ").replace(/\b\w/g, (letter) => letter.toUpperCase());
+  return path17.basename(rulePath, path17.extname(rulePath)).replace(/[-_]+/g, " ").replace(/\b\w/g, (letter) => letter.toUpperCase());
 }
 async function readRuleTitle(rulePath) {
-  const content = await import_fs_extra12.default.readFile(rulePath, "utf-8").catch(() => "");
+  const content = await import_fs_extra13.default.readFile(rulePath, "utf-8").catch(() => "");
   const heading = content.match(/^#\s+(.+)$/m)?.[1]?.trim();
   return heading || titleFromRulePath(rulePath);
 }
 async function collectRuleIndexEntries(rulesDir, rootDir, currentDir = rulesDir) {
-  const entries = await import_fs_extra12.default.readdir(currentDir, { withFileTypes: true }).catch(() => []);
+  const entries = await import_fs_extra13.default.readdir(currentDir, { withFileTypes: true }).catch(() => []);
   const rules = [];
   for (const entry of entries) {
     if (IGNORED_ENTRY_NAMES2.has(entry.name))
       continue;
-    const entryPath = path16.join(currentDir, entry.name);
+    const entryPath = path17.join(currentDir, entry.name);
     if (entry.isDirectory()) {
       rules.push(...await collectRuleIndexEntries(rulesDir, rootDir, entryPath));
       continue;
     }
     if (!entry.isFile() && !entry.isSymbolicLink())
       continue;
-    if (![".md", ".mdc"].includes(path16.extname(entry.name).toLowerCase()))
+    if (![".md", ".mdc"].includes(path17.extname(entry.name).toLowerCase()))
       continue;
     rules.push({
       title: await readRuleTitle(entryPath),
-      relativePath: path16.relative(rootDir, entryPath)
+      relativePath: path17.relative(rootDir, entryPath)
     });
   }
   return rules.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
@@ -35628,10 +35748,10 @@ function renderRulesIndexBlock(rules) {
 `);
 }
 async function readExistingInstructions(rootDir) {
-  const agentsPath = path16.join(rootDir, "AGENTS.md");
-  const claudePath = path16.join(rootDir, "CLAUDE.md");
-  const agentsContent = await import_fs_extra12.default.readFile(agentsPath, "utf-8").catch(() => null);
-  const claudeContent = await import_fs_extra12.default.readFile(claudePath, "utf-8").catch(() => null);
+  const agentsPath = path17.join(rootDir, "AGENTS.md");
+  const claudePath = path17.join(rootDir, "CLAUDE.md");
+  const agentsContent = await import_fs_extra13.default.readFile(agentsPath, "utf-8").catch(() => null);
+  const claudeContent = await import_fs_extra13.default.readFile(claudePath, "utf-8").catch(() => null);
   if (agentsContent !== null && claudeContent !== null && agentsContent.trim() !== claudeContent.trim()) {
     return `${agentsContent.trimEnd()}
 
@@ -35647,26 +35767,26 @@ ${claudeContent.trimStart()}`;
 `;
 }
 async function copyPathToBackup(result, targetPath) {
-  const stat = await import_fs_extra12.default.lstat(targetPath).catch(() => null);
+  const stat = await import_fs_extra13.default.lstat(targetPath).catch(() => null);
   if (!stat)
     return null;
   const backupRoot = await ensureBackupPath(result);
-  const backupTarget = path16.join(backupRoot, safeRelativePath(result.rootDir, targetPath));
-  await import_fs_extra12.default.ensureDir(path16.dirname(backupTarget));
-  await import_fs_extra12.default.copy(targetPath, backupTarget, {
+  const backupTarget = path17.join(backupRoot, safeRelativePath(result.rootDir, targetPath));
+  await import_fs_extra13.default.ensureDir(path17.dirname(backupTarget));
+  await import_fs_extra13.default.copy(targetPath, backupTarget, {
     dereference: false,
     overwrite: false
   });
   return backupTarget;
 }
 async function replaceWithFileSymlink(sourcePath, targetPath) {
-  await import_fs_extra12.default.ensureDir(path16.dirname(targetPath));
-  const relativeSource = path16.relative(path16.dirname(targetPath), sourcePath) || path16.basename(sourcePath);
-  await import_fs_extra12.default.symlink(relativeSource, targetPath, "file");
+  await import_fs_extra13.default.ensureDir(path17.dirname(targetPath));
+  const relativeSource = path17.relative(path17.dirname(targetPath), sourcePath) || path17.basename(sourcePath);
+  await import_fs_extra13.default.symlink(relativeSource, targetPath, "file");
 }
 async function ensureClaudeInstructionSymlink(result, agentsPath, claudePath) {
   const agentsRealPath = await realPathIfPossible(agentsPath);
-  const claudeStat = await import_fs_extra12.default.lstat(claudePath).catch(() => null);
+  const claudeStat = await import_fs_extra13.default.lstat(claudePath).catch(() => null);
   if (claudeStat?.isSymbolicLink()) {
     const claudeRealPath = await realPathIfPossible(claudePath);
     if (agentsRealPath && claudeRealPath && samePath(agentsRealPath, claudeRealPath)) {
@@ -35675,29 +35795,34 @@ async function ensureClaudeInstructionSymlink(result, agentsPath, claudePath) {
   }
   if (claudeStat) {
     await copyPathToBackup(result, claudePath);
-    await import_fs_extra12.default.remove(claudePath);
+    await import_fs_extra13.default.remove(claudePath);
   }
   await replaceWithFileSymlink(agentsPath, claudePath);
 }
 async function writeRepositoryInstructionIndex(result, folders) {
-  const rulesDir = path16.join(folders.agentsDir, "rules");
-  await import_fs_extra12.default.ensureDir(rulesDir);
+  const rulesDir = path17.join(folders.agentsDir, "rules");
+  if (!await pathExistsOrSymlink(rulesDir)) {
+    return;
+  }
   const rules = await collectRuleIndexEntries(rulesDir, folders.rootDir);
+  if (rules.length === 0) {
+    return;
+  }
   const existing = stripGeneratedRulesIndex(await readExistingInstructions(folders.rootDir));
   const content = `${existing}
 
 ${renderRulesIndexBlock(rules)}
 `;
-  const agentsPath = path16.join(folders.rootDir, "AGENTS.md");
-  const claudePath = path16.join(folders.rootDir, "CLAUDE.md");
-  const agentsStat = await import_fs_extra12.default.lstat(agentsPath).catch(() => null);
+  const agentsPath = path17.join(folders.rootDir, "AGENTS.md");
+  const claudePath = path17.join(folders.rootDir, "CLAUDE.md");
+  const agentsStat = await import_fs_extra13.default.lstat(agentsPath).catch(() => null);
   if (agentsStat) {
     await copyPathToBackup(result, agentsPath);
     if (agentsStat.isSymbolicLink()) {
-      await import_fs_extra12.default.remove(agentsPath);
+      await import_fs_extra13.default.remove(agentsPath);
     }
   }
-  await import_fs_extra12.default.writeFile(agentsPath, content, "utf-8");
+  await import_fs_extra13.default.writeFile(agentsPath, content, "utf-8");
   await ensureClaudeInstructionSymlink(result, agentsPath, claudePath);
   result.instructionIndex = {
     agentsPath,
@@ -35708,7 +35833,8 @@ ${renderRulesIndexBlock(rules)}
 async function unifyAgentsConfiguration(options = {}) {
   const scope = options.scope ?? "global";
   const folders = resolveFolders(options);
-  const instructionCandidates = getInstructionFileCandidates(options);
+  const includeCodex = scope !== "repository";
+  const instructionCandidates = getInstructionFileCandidates(options, includeCodex);
   const candidates = scope === "repository" ? getRepositoryContainerCandidates(options) : getContainerCandidates(options);
   const result = {
     rootDir: folders.rootDir,
@@ -35724,18 +35850,23 @@ async function unifyAgentsConfiguration(options = {}) {
     instructionIndex: null
   };
   const destinationByCategory = {
-    skills: path16.join(folders.agentsDir, "skills"),
-    agents: path16.join(folders.agentsDir, "agents"),
-    instructions: path16.join(folders.agentsDir, "AGENTS.md"),
-    rules: path16.join(folders.agentsDir, "rules")
+    skills: path17.join(folders.agentsDir, "skills"),
+    agents: path17.join(folders.agentsDir, "agents"),
+    instructions: path17.join(folders.agentsDir, "AGENTS.md"),
+    rules: path17.join(folders.agentsDir, "rules")
   };
-  await import_fs_extra12.default.ensureDir(folders.agentsDir);
   await importInstructionFiles(instructionCandidates, destinationByCategory.instructions, result);
   const categories = scope === "repository" ? ["skills", "agents", "rules"] : ["skills", "agents"];
+  const activeCategories = new Set;
   for (const category of categories) {
-    await importCategoryEntries(category, candidates, destinationByCategory[category], result);
+    const isActive = await importCategoryEntries(category, candidates, destinationByCategory[category], result);
+    if (isActive) {
+      activeCategories.add(category);
+    }
   }
   for (const candidate of candidates) {
+    if (!activeCategories.has(candidate.category))
+      continue;
     await linkContainer(candidate, destinationByCategory[candidate.category], result);
   }
   for (const candidate of instructionCandidates) {
@@ -35765,9 +35896,9 @@ async function agentsUnifyCommand(params = {}) {
 AIBlueprint agents unify ${source_default.gray(`v${getVersion()}`)}
 `));
     console.log(source_default.gray(`Scope: ${params.scope ?? "global"}`));
-    console.log(source_default.gray("Centralizing reusable agent configuration into .agents, then rendering Codex agents"));
+    console.log(source_default.gray(params.scope === "repository" ? "Centralizing project agent configuration into .agents" : "Centralizing reusable agent configuration into .agents, then rendering Codex agents"));
     const result = await unifyAgentsConfiguration(params);
-    const codexResult = await renderCodexAgentsFromMarkdown(params);
+    const codexResult = params.scope === "repository" ? null : await renderCodexAgentsFromMarkdown(params);
     console.log(source_default.green(`
 Unify complete`));
     console.log(source_default.gray(`  Shared folder: ${result.agentsDir}`));
@@ -35777,7 +35908,9 @@ Unify complete`));
     if (result.scope === "repository") {
       printCategorySummary(result, "rules");
     }
-    console.log(source_default.gray(`  codex agents: ${codexResult.rendered.length} rendered, ${codexResult.skipped.length} skipped`));
+    if (codexResult) {
+      console.log(source_default.gray(`  codex agents: ${codexResult.rendered.length} rendered, ${codexResult.skipped.length} skipped`));
+    }
     if (result.instructionIndex) {
       console.log(source_default.gray(`  rules index: ${result.instructionIndex.indexedRules.length} rules indexed in ${result.instructionIndex.agentsPath}`));
       console.log(source_default.gray(`  Claude instructions: ${result.instructionIndex.claudePath}`));
@@ -35832,120 +35965,6 @@ var import_fs_extra14 = __toESM(require_lib4(), 1);
 import crypto2 from "crypto";
 import os15 from "os";
 import path18 from "path";
-
-// src/lib/backup-utils.ts
-var import_fs_extra13 = __toESM(require_lib4(), 1);
-import path17 from "path";
-import os14 from "os";
-var BACKUP_BASE_DIR = path17.join(os14.homedir(), ".config", "aiblueprint", "backup");
-function getBackupDir() {
-  return process.env.AIBLUEPRINT_BACKUP_DIR || BACKUP_BASE_DIR;
-}
-function formatDate(date) {
-  const pad = (n) => n.toString().padStart(2, "0");
-  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}-${pad(date.getHours())}-${pad(date.getMinutes())}-${pad(date.getSeconds())}`;
-}
-async function listBackups() {
-  const backupBaseDir = getBackupDir();
-  const exists = await import_fs_extra13.default.pathExists(backupBaseDir);
-  if (!exists) {
-    return [];
-  }
-  const entries = await import_fs_extra13.default.readdir(backupBaseDir, { withFileTypes: true });
-  const backups = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory())
-      continue;
-    const match = entry.name.match(/^(\d{4})-(\d{2})-(\d{2})-(\d{2})-(\d{2})-(\d{2})$/);
-    if (!match)
-      continue;
-    const [, year, month, day, hour, minute, second] = match;
-    const date = new Date(parseInt(year), parseInt(month) - 1, parseInt(day), parseInt(hour), parseInt(minute), parseInt(second));
-    backups.push({
-      name: entry.name,
-      path: path17.join(backupBaseDir, entry.name),
-      date
-    });
-  }
-  return backups.sort((a, b) => b.date.getTime() - a.date.getTime());
-}
-var AGENTS_BACKUP_SUBDIR = ".agents";
-var CLAUDE_ITEMS = ["commands", "agents", "skills", "scripts", "settings.json"];
-var MANAGED_FOLDERS = [".claude", ".codex", ".agents"];
-async function copyForBackup(sourcePath, destPath) {
-  await import_fs_extra13.default.copy(sourcePath, destPath, {
-    overwrite: true,
-    dereference: false
-  });
-}
-async function hasMeaningfulContent(dir) {
-  if (!await import_fs_extra13.default.pathExists(dir))
-    return false;
-  const files = await import_fs_extra13.default.readdir(dir);
-  return files.some((f) => f !== ".DS_Store");
-}
-async function loadBackup(backupPath, claudeDir, codexDir, agentsDir) {
-  const exists = await import_fs_extra13.default.pathExists(backupPath);
-  if (!exists) {
-    throw new Error(`Backup not found: ${backupPath}`);
-  }
-  const managedDestinations = {
-    ".claude": claudeDir,
-    ".codex": codexDir,
-    ".agents": agentsDir
-  };
-  let restoredManagedFolder = false;
-  for (const folderName of MANAGED_FOLDERS) {
-    const sourcePath = path17.join(backupPath, folderName);
-    const destPath = managedDestinations[folderName];
-    if (!destPath || !await import_fs_extra13.default.pathExists(sourcePath))
-      continue;
-    await import_fs_extra13.default.ensureDir(destPath);
-    await copyForBackup(sourcePath, destPath);
-    restoredManagedFolder = true;
-  }
-  if (!restoredManagedFolder) {
-    await import_fs_extra13.default.ensureDir(claudeDir);
-    for (const item of CLAUDE_ITEMS) {
-      const sourcePath = path17.join(backupPath, item);
-      const destPath = path17.join(claudeDir, item);
-      if (await import_fs_extra13.default.pathExists(sourcePath)) {
-        await copyForBackup(sourcePath, destPath);
-      }
-    }
-    if (agentsDir) {
-      const agentsBackupPath = path17.join(backupPath, AGENTS_BACKUP_SUBDIR);
-      if (await import_fs_extra13.default.pathExists(agentsBackupPath)) {
-        await import_fs_extra13.default.ensureDir(agentsDir);
-        await copyForBackup(agentsBackupPath, agentsDir);
-      }
-    }
-  }
-}
-async function createBackup(claudeDir, codexDir, agentsDir) {
-  const claudeHasContent = await hasMeaningfulContent(claudeDir);
-  const codexHasContent = codexDir ? await hasMeaningfulContent(codexDir) : false;
-  const agentsHasContent = agentsDir ? await hasMeaningfulContent(agentsDir) : false;
-  if (!claudeHasContent && !codexHasContent && !agentsHasContent) {
-    return null;
-  }
-  const timestamp3 = formatDate(new Date);
-  const backupPath = path17.join(getBackupDir(), timestamp3);
-  await import_fs_extra13.default.ensureDir(backupPath);
-  if (claudeHasContent) {
-    await copyForBackup(claudeDir, path17.join(backupPath, ".claude"));
-  }
-  if (codexHasContent && codexDir) {
-    await copyForBackup(codexDir, path17.join(backupPath, ".codex"));
-  }
-  if (agentsHasContent && agentsDir) {
-    const destPath = path17.join(backupPath, AGENTS_BACKUP_SUBDIR);
-    await copyForBackup(agentsDir, destPath);
-  }
-  return backupPath;
-}
-
-// src/lib/session-unifier.ts
 var MANAGED_FOLDERS2 = [".claude", ".codex", ".agents"];
 var SESSION_PATHS = {
   ".claude": ["projects", "sessions"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiblueprint-cli",
-  "version": "1.4.66",
+  "version": "1.4.68",
   "description": "AIBlueprint CLI for setting up AI coding configurations",
   "author": "AIBlueprint",
   "license": "MIT",