aiblueprint-cli 1.4.72 → 1.4.74

package/dist/cli.js

@@ -33628,6 +33628,8 @@ async function mergeCodexConfigFile(sourceConfigPath, codexDir) {
 // src/lib/configs-store.ts
 var import_fs_extra7 = __toESM(require_lib4(), 1);
 import path11 from "path";
+var RETENTION_MANAGED_BACKUP_TRIGGERS = new Set(["setup", "sync", "load", "backup-load"]);
+var DEFAULT_BACKUP_RETENTION_DAYS = 30;
 function getConfigStorePaths(rootDir) {
   const baseDir = path11.join(rootDir, ".aiblueprint");
   return {
@@ -33866,6 +33868,117 @@ async function listConfigBackups(options = {}) {
   const paths = getConfigStorePaths(folders.rootDir);
   return listSnapshots(paths.backupsDir, "backup");
 }
+function normalizeBackupRetentionDays(value = DEFAULT_BACKUP_RETENTION_DAYS) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error("Backup retention days must be a positive integer.");
+  }
+  return value;
+}
+function isRetentionManagedBackup(metadata, includeManual = false) {
+  return RETENTION_MANAGED_BACKUP_TRIGGERS.has(metadata.trigger) || includeManual && metadata.trigger === "manual-backup";
+}
+function isPathInside(childPath, parentPath) {
+  const relativePath = path11.relative(parentPath, childPath);
+  return relativePath !== "" && !relativePath.startsWith("..") && !path11.isAbsolute(relativePath);
+}
+async function realBackupStorePath(backupsDir) {
+  if (!await import_fs_extra7.default.pathExists(backupsDir))
+    return null;
+  const stats = await import_fs_extra7.default.lstat(backupsDir);
+  if (stats.isSymbolicLink()) {
+    throw new Error("Backup directory cannot be a symlink.");
+  }
+  if (!stats.isDirectory()) {
+    throw new Error("Backup path is not a directory.");
+  }
+  return import_fs_extra7.default.realpath(backupsDir);
+}
+function cleanupDateForSnapshot(snapshot) {
+  if (snapshot.metadata.type !== "backup")
+    return null;
+  const createdAt = new Date(snapshot.metadata.createdAt);
+  if (Number.isNaN(createdAt.getTime()))
+    return null;
+  return createdAt;
+}
+async function removeBackupSnapshot(snapshot, backupsRealPath) {
+  const snapshotRealPath = await import_fs_extra7.default.realpath(snapshot.path);
+  if (!isPathInside(snapshotRealPath, backupsRealPath)) {
+    throw new Error(`Refusing to delete backup outside store: ${snapshot.name}`);
+  }
+  await import_fs_extra7.default.remove(snapshot.path);
+}
+async function cleanConfigBackups(options = {}) {
+  const days = normalizeBackupRetentionDays(options.days);
+  const folders = resolveConfigStoreFolders(options);
+  const paths = getConfigStorePaths(folders.rootDir);
+  const backupsRealPath = await realBackupStorePath(paths.backupsDir);
+  const now = options.now ?? new Date;
+  const cutoffDate = new Date(now.getTime() - days * 24 * 60 * 60 * 1000);
+  if (!backupsRealPath) {
+    return {
+      cutoff: cutoffDate.toISOString(),
+      deleted: [],
+      failed: [],
+      kept: [],
+      skipped: []
+    };
+  }
+  const backups = await listSnapshots(paths.backupsDir, "backup");
+  const deleted = [];
+  const failed = [];
+  const kept = [];
+  const skipped = [];
+  const deletionCandidates = [];
+  for (const backup of backups) {
+    if (!isRetentionManagedBackup(backup.metadata, options.includeManual)) {
+      skipped.push({ snapshot: backup, reason: "not retention-managed" });
+      continue;
+    }
+    const cleanupDate = cleanupDateForSnapshot(backup);
+    if (!cleanupDate) {
+      skipped.push({ snapshot: backup, reason: "missing valid backup metadata date" });
+      continue;
+    }
+    if (cleanupDate < cutoffDate) {
+      deletionCandidates.push(backup);
+    } else {
+      kept.push(backup);
+    }
+  }
+  if (options.dryRun) {
+    deleted.push(...deletionCandidates);
+  } else {
+    for (const backup of deletionCandidates) {
+      try {
+        await removeBackupSnapshot(backup, backupsRealPath);
+        deleted.push(backup);
+      } catch (error) {
+        failed.push({
+          snapshot: backup,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    if (deleted.length > 0 || failed.length > 0) {
+      await appendHistory(paths, {
+        action: "backup-clean",
+        days,
+        cutoff: cutoffDate.toISOString(),
+        deleted: deleted.map((backup) => backup.name),
+        failed: failed.map((entry) => ({ name: entry.snapshot.name, error: entry.error })),
+        skipped: skipped.map((entry) => ({ name: entry.snapshot.name, reason: entry.reason }))
+      });
+    }
+  }
+  return {
+    cutoff: cutoffDate.toISOString(),
+    deleted,
+    failed,
+    kept,
+    skipped
+  };
+}
 
 // src/lib/codex-agents-renderer.ts
 var import_fs_extra8 = __toESM(require_lib4(), 1);
@@ -34083,6 +34196,17 @@ async function resolveClaudeAssetPath(sourceDir, name) {
   }
   return null;
 }
+async function resolveDirectoryCopyDestination(destination) {
+  const stat = await import_fs_extra9.default.lstat(destination).catch(() => null);
+  if (!stat?.isSymbolicLink())
+    return destination;
+  const targetStat = await import_fs_extra9.default.stat(destination).catch(() => null);
+  if (targetStat?.isDirectory()) {
+    return import_fs_extra9.default.realpath(destination);
+  }
+  await import_fs_extra9.default.remove(destination);
+  return destination;
+}
 async function setupCommand(params = {}) {
   const {
     folder,
@@ -34195,11 +34319,10 @@ async function setupCommand(params = {}) {
       s.start("Setting up scripts");
       const scriptsSource = await resolveClaudeAssetPath(sourceDir, "scripts");
       if (scriptsSource) {
-        await import_fs_extra9.default.copy(scriptsSource, path13.join(claudeDir, "scripts"), {
-          overwrite: true
-        });
-        await replacePathPlaceholdersInDir(path13.join(claudeDir, "scripts"), claudeDir);
-        await import_fs_extra9.default.ensureDir(path13.join(claudeDir, "scripts/statusline/data"));
+        const scriptsDestination = path13.join(claudeDir, "scripts");
+        await import_fs_extra9.default.copy(scriptsSource, await resolveDirectoryCopyDestination(scriptsDestination), { overwrite: true });
+        await replacePathPlaceholdersInDir(scriptsDestination, claudeDir);
+        await import_fs_extra9.default.ensureDir(path13.join(scriptsDestination, "statusline/data"));
         s.stop("Scripts installed");
       } else {
         s.stop("Scripts not available in repository");
@@ -35738,6 +35861,7 @@ var IGNORED_ENTRY_NAMES2 = new Set([
   ".git",
   "node_modules"
 ]);
+var RULE_EXTENSION_RENAME_REASON = "Rule file extension normalized from .mdc to .md";
 function uniqueByPath(candidates) {
   const seen = new Set;
   const unique = [];
@@ -35971,6 +36095,60 @@ async function hashPath(targetPath) {
   }
   return hashString(`other:${stat.mode}:${stat.size}`);
 }
+async function hashRulePath(targetPath) {
+  const stat = await import_fs_extra13.default.lstat(targetPath);
+  if (stat.isSymbolicLink()) {
+    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_extra13.default.readFile(targetPath));
+    return fileHash.digest("hex");
+  }
+  if (stat.isDirectory()) {
+    const entries = (await import_fs_extra13.default.readdir(targetPath, { withFileTypes: true })).filter((entry) => !IGNORED_ENTRY_NAMES2.has(entry.name)).sort(compareRuleEntryNames);
+    const canonicalEntries = [];
+    const usedNames = new Set;
+    const hashesByName = new Map;
+    const dirHash = crypto.createHash("sha256");
+    dirHash.update("dir:");
+    for (const entry of entries) {
+      const entryHash = await hashRulePath(path17.join(targetPath, entry.name));
+      let entryName = entry.isDirectory() ? entry.name : normalizeRuleFileName(entry.name);
+      const existingHash = hashesByName.get(entryName);
+      if (existingHash) {
+        if (existingHash === entryHash)
+          continue;
+        entryName = findAvailableRuleName(entryName, usedNames);
+      }
+      usedNames.add(entryName);
+      hashesByName.set(entryName, entryHash);
+      canonicalEntries.push({ name: entryName, hash: entryHash });
+    }
+    for (const entry of canonicalEntries.sort((a, b3) => a.name.localeCompare(b3.name))) {
+      dirHash.update(entry.name);
+      dirHash.update("\x00");
+      dirHash.update(entry.hash);
+      dirHash.update("\x00");
+    }
+    return dirHash.digest("hex");
+  }
+  return hashString(`other:${stat.mode}:${stat.size}`);
+}
+async function hashPathForCategory(category, targetPath) {
+  return category === "rules" ? hashRulePath(targetPath) : hashPath(targetPath);
+}
+function findAvailableRuleName(originalName, usedNames) {
+  let index = 1;
+  while (true) {
+    const candidate = nameWithSuffix(originalName, "agents-rules", index);
+    if (!usedNames.has(candidate))
+      return candidate;
+    index++;
+  }
+}
 var TEXT_EXTENSIONS = new Set([
   ".cjs",
   ".js",
@@ -36049,15 +36227,40 @@ function nameWithSuffix(name, suffix, index) {
   }
   return `${name}--${numberedSuffix}`;
 }
-async function addExistingDestinationHashes(destinationDir, knownHashes) {
+function normalizeRuleFileName(name) {
+  return path17.extname(name).toLowerCase() === ".mdc" ? `${path17.basename(name, path17.extname(name))}.md` : name;
+}
+function ruleExtensionPriority(name) {
+  const ext = path17.extname(name).toLowerCase();
+  if (ext === ".md")
+    return 0;
+  if (ext === ".mdc")
+    return 1;
+  return 2;
+}
+function compareRuleEntryNames(a, b3) {
+  const normalizedCompare = normalizeRuleFileName(a.name).localeCompare(normalizeRuleFileName(b3.name));
+  if (normalizedCompare !== 0)
+    return normalizedCompare;
+  const priorityCompare = ruleExtensionPriority(a.name) - ruleExtensionPriority(b3.name);
+  if (priorityCompare !== 0)
+    return priorityCompare;
+  return a.name.localeCompare(b3.name);
+}
+async function addExistingDestinationHashes(category, destinationDir, knownHashes, result) {
   if (!await import_fs_extra13.default.pathExists(destinationDir))
     return;
+  const plannedRuleNames = new Map(result.renamed.filter((entry) => entry.category === "rules").map((entry) => [path17.resolve(entry.from), path17.basename(entry.to)]));
+  const removedRulePaths = new Set(result.duplicates.filter((entry) => entry.category === "rules").map((entry) => path17.resolve(entry.from)));
   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 = path17.join(destinationDir, entry.name);
-    knownHashes.set(await hashPath(entryPath), entry.name);
+    if (category === "rules" && removedRulePaths.has(path17.resolve(entryPath)))
+      continue;
+    const entryName = category === "rules" ? plannedRuleNames.get(path17.resolve(entryPath)) ?? normalizeRuleFileName(entry.name) : entry.name;
+    knownHashes.set(await hashPathForCategory(category, entryPath), entryName);
   }
 }
 async function importCategoryEntries(category, candidates, destinationDir, result, dryRun = false) {
@@ -36074,7 +36277,7 @@ async function importCategoryEntries(category, candidates, destinationDir, resul
     if (destinationRealPath && candidateRealPath && samePath(destinationRealPath, candidateRealPath)) {
       continue;
     }
-    const entries = await collectCandidateEntries(candidate).catch(() => null);
+    const entries = await collectCandidateEntries(candidate, category).catch(() => null);
     if (!entries) {
       result.skipped.push({
         category,
@@ -36100,12 +36303,12 @@ async function importCategoryEntries(category, candidates, destinationDir, resul
     await import_fs_extra13.default.ensureDir(destinationDir);
   }
   const knownHashes = new Map;
-  await addExistingDestinationHashes(destinationDir, knownHashes);
+  await addExistingDestinationHashes(category, destinationDir, knownHashes, result);
   const knownNames = new Set(knownHashes.values());
   for (const { candidate, entries } of sourceEntries) {
     for (const entry of entries) {
       const sourcePath = entry.path;
-      const sourceHash = await hashPath(sourcePath);
+      const sourceHash = await hashPathForCategory(category, sourcePath);
       const existingName = knownHashes.get(sourceHash);
       if (existingName) {
         result.duplicates.push({
@@ -36116,10 +36319,10 @@ async function importCategoryEntries(category, candidates, destinationDir, resul
         });
         continue;
       }
-      let targetName = entry.name;
+      let targetName = category === "rules" ? normalizeRuleFileName(entry.name) : entry.name;
       let targetPath = path17.join(destinationDir, targetName);
       if (await pathExistsOrSymlink(targetPath) || knownNames.has(targetName)) {
-        targetName = await findAvailableTargetName(destinationDir, entry.name, candidate.label, knownNames);
+        targetName = await findAvailableTargetName(destinationDir, targetName, candidate.label, knownNames);
         targetPath = path17.join(destinationDir, targetName);
         result.renamed.push({
           category,
@@ -36137,7 +36340,7 @@ async function importCategoryEntries(category, candidates, destinationDir, resul
         await normalizePortableContent(targetPath);
       }
       knownNames.add(targetName);
-      knownHashes.set(dryRun ? sourceHash : await hashPath(targetPath), targetName);
+      knownHashes.set(dryRun ? sourceHash : await hashPathForCategory(category, targetPath), targetName);
       result.imported.push({
         category,
         name: entry.name,
@@ -36148,6 +36351,84 @@ async function importCategoryEntries(category, candidates, destinationDir, resul
   }
   return true;
 }
+function recordRuleExtensionRename(result, from3, to) {
+  result.renamed.push({
+    category: "rules",
+    name: path17.basename(from3),
+    from: from3,
+    to,
+    reason: RULE_EXTENSION_RENAME_REASON
+  });
+}
+async function migrateExistingRuleExtensions(rulesDir, result, dryRun = false) {
+  const usedNamesByDir = new Map;
+  async function usedNamesForDir(currentDir) {
+    const existing = usedNamesByDir.get(currentDir);
+    if (existing)
+      return existing;
+    const names = new Set(await import_fs_extra13.default.readdir(currentDir).catch(() => []));
+    usedNamesByDir.set(currentDir, names);
+    return names;
+  }
+  async function walk(currentDir) {
+    const entries = sortSourceEntries(await import_fs_extra13.default.readdir(currentDir, { withFileTypes: true }).catch(() => []), "rules");
+    for (const entry of entries) {
+      if (IGNORED_ENTRY_NAMES2.has(entry.name))
+        continue;
+      const sourcePath = path17.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(sourcePath);
+        continue;
+      }
+      if (!entry.isFile() && !entry.isSymbolicLink())
+        continue;
+      if (path17.extname(entry.name).toLowerCase() !== ".mdc")
+        continue;
+      const targetPath = path17.join(currentDir, normalizeRuleFileName(entry.name));
+      if (samePath(sourcePath, targetPath))
+        continue;
+      if (await pathExistsOrSymlink(targetPath)) {
+        const sourceHash = await hashPath(sourcePath);
+        const targetHash = await hashPath(targetPath);
+        if (sourceHash === targetHash) {
+          const backupRoot = await ensureBackupPath(result, dryRun);
+          const backupTarget = path17.join(backupRoot, safeRelativePath(result.rootDir, sourcePath));
+          if (!dryRun) {
+            await import_fs_extra13.default.ensureDir(path17.dirname(backupTarget));
+            await import_fs_extra13.default.move(sourcePath, backupTarget, { overwrite: false });
+          }
+          result.duplicates.push({
+            category: "rules",
+            name: entry.name,
+            from: sourcePath,
+            keptAs: targetPath
+          });
+          const usedNames3 = await usedNamesForDir(currentDir);
+          usedNames3.delete(entry.name);
+          continue;
+        }
+        const usedNames2 = await usedNamesForDir(currentDir);
+        const targetName = await findAvailableTargetName(currentDir, path17.basename(targetPath), "agents-rules", usedNames2);
+        const renamedTargetPath = path17.join(currentDir, targetName);
+        if (!dryRun) {
+          await import_fs_extra13.default.move(sourcePath, renamedTargetPath, { overwrite: false });
+        }
+        usedNames2.delete(entry.name);
+        usedNames2.add(targetName);
+        recordRuleExtensionRename(result, sourcePath, renamedTargetPath);
+        continue;
+      }
+      const usedNames = await usedNamesForDir(currentDir);
+      if (!dryRun) {
+        await import_fs_extra13.default.move(sourcePath, targetPath, { overwrite: false });
+      }
+      usedNames.delete(entry.name);
+      usedNames.add(path17.basename(targetPath));
+      recordRuleExtensionRename(result, sourcePath, targetPath);
+    }
+  }
+  await walk(rulesDir);
+}
 async function findAvailableTargetName(destinationDir, originalName, label, knownNames) {
   const suffix = suffixFromLabel(label);
   let index = 1;
@@ -36159,11 +36440,18 @@ async function findAvailableTargetName(destinationDir, originalName, label, know
     index++;
   }
 }
-async function collectCandidateEntries(candidate) {
+function sortSourceEntries(entries, category) {
+  return [...entries].sort((a, b3) => {
+    if (category === "rules")
+      return compareRuleEntryNames(a, b3);
+    return a.name.localeCompare(b3.name);
+  });
+}
+async function collectCandidateEntries(candidate, category) {
   const stat = await import_fs_extra13.default.lstat(candidate.path);
   if (stat.isDirectory()) {
     const entries = await import_fs_extra13.default.readdir(candidate.path, { withFileTypes: true });
-    return entries.map((entry) => ({
+    return sortSourceEntries(entries, category).map((entry) => ({
       name: entry.name,
       path: path17.join(candidate.path, entry.name)
     }));
@@ -36172,7 +36460,7 @@ async function collectCandidateEntries(candidate) {
     const targetStat = await import_fs_extra13.default.stat(candidate.path).catch(() => null);
     if (targetStat?.isDirectory()) {
       const entries = await import_fs_extra13.default.readdir(candidate.path, { withFileTypes: true });
-      return entries.map((entry) => ({
+      return sortSourceEntries(entries, category).map((entry) => ({
         name: entry.name,
         path: path17.join(candidate.path, entry.name)
       }));
@@ -36450,7 +36738,7 @@ async function collectRuleIndexEntries(rulesDir, rootDir, currentDir = rulesDir)
     }
     if (!entry.isFile() && !entry.isSymbolicLink())
       continue;
-    if (![".md", ".mdc"].includes(path17.extname(entry.name).toLowerCase()))
+    if (path17.extname(entry.name).toLowerCase() !== ".md")
       continue;
     rules.push({
       title: await readRuleTitle(entryPath),
@@ -36601,21 +36889,20 @@ ${renderRulesIndexBlock(rules)}
 }
 async function collectPlannedRuleIndexEntries(result, rootDir) {
   const rules = [];
+  const removedRulePaths = new Set([
+    ...result.renamed.filter((entry) => entry.category === "rules").map((entry) => path17.relative(rootDir, entry.from)),
+    ...result.duplicates.filter((entry) => entry.category === "rules").map((entry) => path17.relative(rootDir, entry.from))
+  ]);
   const plannedRuleEntries = [
     ...result.imported.filter((entry) => entry.category === "rules"),
     ...result.renamed.filter((entry) => entry.category === "rules")
   ];
   for (const entry of plannedRuleEntries) {
-    const ext = path17.extname(entry.to).toLowerCase();
-    if (![".md", ".mdc"].includes(ext))
-      continue;
-    rules.push({
-      title: await readRuleTitle(entry.from),
-      relativePath: path17.relative(rootDir, entry.to)
-    });
+    rules.push(...await collectPlannedRuleEntryFiles(entry, rootDir));
   }
   if (await pathExistsOrSymlink(path17.join(rootDir, ".agents", "rules"))) {
-    rules.push(...await collectRuleIndexEntries(path17.join(rootDir, ".agents", "rules"), rootDir));
+    const existingRules = await collectRuleIndexEntries(path17.join(rootDir, ".agents", "rules"), rootDir);
+    rules.push(...existingRules.filter((rule) => !removedRulePaths.has(rule.relativePath)));
   }
   const byPath = new Map;
   for (const rule of rules) {
@@ -36623,6 +36910,58 @@ async function collectPlannedRuleIndexEntries(result, rootDir) {
   }
   return [...byPath.values()].sort((a, b3) => a.relativePath.localeCompare(b3.relativePath));
 }
+async function collectPlannedRuleEntryFiles(entry, rootDir) {
+  const sourceStat = await import_fs_extra13.default.lstat(entry.from).catch(() => null);
+  if (!sourceStat?.isDirectory()) {
+    const ext = path17.extname(entry.to).toLowerCase();
+    if (ext !== ".md")
+      return [];
+    return [{
+      title: await readRuleTitle(entry.from),
+      relativePath: path17.relative(rootDir, entry.to)
+    }];
+  }
+  return collectPlannedRuleDirectoryFiles(entry.from, entry.to, rootDir);
+}
+async function collectPlannedRuleDirectoryFiles(sourceDir, targetDir, rootDir) {
+  const entries = sortSourceEntries(await import_fs_extra13.default.readdir(sourceDir, { withFileTypes: true }).catch(() => []), "rules");
+  const rules = [];
+  const usedNames = new Set;
+  const plannedSourcesByName = new Map;
+  for (const entry of entries) {
+    if (IGNORED_ENTRY_NAMES2.has(entry.name))
+      continue;
+    const sourcePath = path17.join(sourceDir, entry.name);
+    if (entry.isDirectory()) {
+      const targetPath2 = path17.join(targetDir, entry.name);
+      usedNames.add(entry.name);
+      rules.push(...await collectPlannedRuleDirectoryFiles(sourcePath, targetPath2, rootDir));
+      continue;
+    }
+    if (!entry.isFile() && !entry.isSymbolicLink())
+      continue;
+    const ext = path17.extname(entry.name).toLowerCase();
+    if (![".md", ".mdc"].includes(ext))
+      continue;
+    let targetName = normalizeRuleFileName(entry.name);
+    const existingSourcePath = plannedSourcesByName.get(targetName);
+    if (existingSourcePath) {
+      const sourceHash = await hashRulePath(sourcePath);
+      const existingHash = await hashRulePath(existingSourcePath);
+      if (sourceHash === existingHash)
+        continue;
+      targetName = await findAvailableTargetName(targetDir, targetName, "agents-rules", usedNames);
+    }
+    usedNames.add(targetName);
+    plannedSourcesByName.set(targetName, sourcePath);
+    const targetPath = path17.join(targetDir, targetName);
+    rules.push({
+      title: await readRuleTitle(sourcePath),
+      relativePath: path17.relative(rootDir, targetPath)
+    });
+  }
+  return rules;
+}
 async function unifyAgentsConfiguration(options = {}) {
   const scope = options.scope ?? "global";
   const dryRun = Boolean(options.dryRun);
@@ -36651,6 +36990,9 @@ async function unifyAgentsConfiguration(options = {}) {
   };
   await importInstructionFiles(instructionCandidates, destinationByCategory.instructions, result, dryRun);
   const categories = scope === "repository" ? ["skills", "agents", "rules"] : ["skills", "agents"];
+  if (scope === "repository" && await pathExistsOrSymlink(destinationByCategory.rules)) {
+    await migrateExistingRuleExtensions(destinationByCategory.rules, result, dryRun);
+  }
   const activeCategories = new Set;
   for (const category of categories) {
     const isActive = await importCategoryEntries(category, candidates, destinationByCategory[category], result, dryRun);
@@ -36667,6 +37009,9 @@ async function unifyAgentsConfiguration(options = {}) {
     await linkInstructionFile(candidate, destinationByCategory.instructions, result, dryRun);
   }
   if (scope === "repository") {
+    if (!dryRun && await pathExistsOrSymlink(destinationByCategory.rules)) {
+      await migrateExistingRuleExtensions(destinationByCategory.rules, result, dryRun);
+    }
     await writeRepositoryInstructionIndex(result, folders, dryRun);
   }
   return result;
@@ -38454,6 +38799,35 @@ async function configsBackupsCreateCommand(reason, options = {}) {
     process.exit(1);
   }
 }
+async function configsBackupsCleanCommand(options = {}) {
+  try {
+    const days = options.days ?? DEFAULT_BACKUP_RETENTION_DAYS;
+    console.log(source_default.gray(`Cleaning config backups older than ${days} day${days !== 1 ? "s" : ""}...`));
+    const result = await cleanConfigBackups(options);
+    if (options.dryRun) {
+      console.log(source_default.yellow(`Dry run: ${result.deleted.length} backup${result.deleted.length !== 1 ? "s" : ""} would be deleted.`));
+    } else {
+      console.log(source_default.green(`Deleted ${result.deleted.length} old backup${result.deleted.length !== 1 ? "s" : ""}.`));
+    }
+    console.log(source_default.gray(`Cutoff: ${formatDate2(result.cutoff)}`));
+    for (const backup of result.deleted) {
+      console.log(source_default.gray(`  ${backup.name}`));
+    }
+    if (result.skipped.length > 0) {
+      console.log(source_default.gray(`Skipped ${result.skipped.length} backup${result.skipped.length !== 1 ? "s" : ""}.`));
+    }
+    if (result.failed.length > 0) {
+      console.error(source_default.red(`Failed to delete ${result.failed.length} backup${result.failed.length !== 1 ? "s" : ""}.`));
+      for (const failure of result.failed) {
+        console.error(source_default.red(`  ${failure.snapshot.name}: ${failure.error}`));
+      }
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(source_default.red(error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+  }
+}
 
 // src/commands/openclaw-pro.ts
 import os20 from "os";
@@ -39068,6 +39442,13 @@ function readConfigOptions(command, options = {}) {
     agentsFolder: findOption("agentsFolder")
   };
 }
+function parseRetentionDays(value) {
+  try {
+    return normalizeBackupRetentionDays(Number(value));
+  } catch (error) {
+    throw new InvalidArgumentError(error instanceof Error ? error.message : String(error));
+  }
+}
 var agentsCmd = program2.command("agents").description("AI coding configuration commands");
 registerAgentsCommands(agentsCmd);
 var aiCodingCmd = program2.command("ai-coding").description("Legacy alias for agents configuration commands");
@@ -39119,6 +39500,15 @@ addConfigFolderOptions(configsBackupsCmd.command("create [reason]").description(
     ...folderOptions
   });
 });
+addConfigFolderOptions(configsBackupsCmd.command("clean").description("Delete old config backups managed by retention").option("-d, --days <days>", "Delete backups older than this many days", parseRetentionDays, DEFAULT_BACKUP_RETENTION_DAYS).option("--dry-run", "Show backups that would be deleted without removing them").option("--include-manual", "Also delete manual backups created with configs backups create")).action((options, command) => {
+  const folderOptions = readConfigOptions(command, options);
+  configsBackupsCleanCommand({
+    ...folderOptions,
+    days: options.days,
+    dryRun: options.dryRun,
+    includeManual: options.includeManual
+  });
+});
 var openclawCmd = program2.command("openclaw").description("OpenClaw configuration commands").option("-f, --folder <path>", "Specify custom OpenClaw folder path (default: ~/.openclaw)");
 var openclawProCmd = openclawCmd.command("pro").description("Manage OpenClaw Pro features");
 openclawProCmd.command("activate [token]").description("Activate OpenClaw Pro with your access token").action((token) => {

package/package.json

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