aiblueprint-cli 1.4.61 → 1.4.62

package/dist/cli.js

@@ -35077,6 +35077,26 @@ function getContainerCandidates(options) {
     }
   ]);
 }
+function getInstructionFileCandidates(options) {
+  const folders = resolveFolders(options);
+  return uniqueByPath([
+    {
+      label: "agents-instructions",
+      path: path16.join(folders.agentsDir, "AGENTS.md"),
+      isDestination: true
+    },
+    {
+      label: "claude-instructions",
+      path: path16.join(folders.claudeDir, "CLAUDE.md"),
+      linkWhenMissing: true
+    },
+    {
+      label: "codex-instructions",
+      path: path16.join(folders.codexDir, "AGENTS.md"),
+      linkWhenMissing: true
+    }
+  ]);
+}
 function shouldCollectEntry(category, entry) {
   if (IGNORED_ENTRY_NAMES2.has(entry.name))
     return false;
@@ -35255,6 +35275,14 @@ async function createDirectorySymlink(source, target) {
   }
   await import_fs_extra12.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");
+    return;
+  }
+  await import_fs_extra12.default.symlink(source, target);
+}
 async function shouldLinkMissingContainer(candidate) {
   if (candidate.linkWhenMissing)
     return true;
@@ -35310,9 +35338,119 @@ async function linkContainer(candidate, destinationDir, result) {
     movedToBackup: backupTarget
   });
 }
+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;
+  for (const candidate of candidates) {
+    if (candidate.isDestination)
+      continue;
+    const sourceStat = await import_fs_extra12.default.lstat(candidate.path).catch(() => null);
+    if (!sourceStat)
+      continue;
+    const sourceRealPath = await realPathIfPossible(candidate.path);
+    if (destinationRealPath && sourceRealPath && samePath(destinationRealPath, sourceRealPath)) {
+      continue;
+    }
+    const sourceHash = await hashPath(candidate.path);
+    if (!destinationHash) {
+      await import_fs_extra12.default.copy(candidate.path, destinationPath, {
+        dereference: false,
+        overwrite: false
+      });
+      destinationHash = sourceHash;
+      result.imported.push({
+        category: "instructions",
+        name: path16.basename(candidate.path),
+        from: candidate.path,
+        to: destinationPath
+      });
+      continue;
+    }
+    if (sourceHash === destinationHash) {
+      result.duplicates.push({
+        category: "instructions",
+        name: path16.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, {
+      dereference: false,
+      overwrite: false
+    });
+    result.renamed.push({
+      category: "instructions",
+      name: path16.basename(candidate.path),
+      from: candidate.path,
+      to: targetPath,
+      reason: "Shared instruction file already exists with different content"
+    });
+  }
+}
+async function shouldLinkMissingInstruction(candidate) {
+  if (candidate.linkWhenMissing)
+    return true;
+  return false;
+}
+async function linkInstructionFile(candidate, destinationPath, result) {
+  if (candidate.isDestination || samePath(candidate.path, destinationPath)) {
+    return;
+  }
+  if (!await pathExistsOrSymlink(destinationPath)) {
+    return;
+  }
+  const destinationRealPath = await realPathIfPossible(destinationPath);
+  const stat = await import_fs_extra12.default.lstat(candidate.path).catch(() => null);
+  if (!stat) {
+    if (!await shouldLinkMissingInstruction(candidate))
+      return;
+    await createFileSymlink(destinationPath, candidate.path);
+    result.linked.push({
+      category: "instructions",
+      from: candidate.path,
+      to: destinationPath
+    });
+    return;
+  }
+  if (stat.isSymbolicLink()) {
+    const existingRealPath = await realPathIfPossible(candidate.path);
+    if (destinationRealPath && existingRealPath && samePath(destinationRealPath, existingRealPath)) {
+      result.alreadyLinked.push({
+        category: "instructions",
+        from: candidate.path,
+        to: destinationPath
+      });
+      return;
+    }
+    await import_fs_extra12.default.remove(candidate.path);
+    await createFileSymlink(destinationPath, candidate.path);
+    result.linked.push({
+      category: "instructions",
+      from: candidate.path,
+      to: destinationPath
+    });
+    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 });
+  await createFileSymlink(destinationPath, candidate.path);
+  result.linked.push({
+    category: "instructions",
+    from: candidate.path,
+    to: destinationPath,
+    movedToBackup: backupTarget
+  });
+}
 async function unifyAgentsConfiguration(options = {}) {
   const folders = resolveFolders(options);
   const candidates = getContainerCandidates(options);
+  const instructionCandidates = getInstructionFileCandidates(options);
   const result = {
     rootDir: folders.rootDir,
     agentsDir: folders.agentsDir,
@@ -35326,15 +35464,20 @@ async function unifyAgentsConfiguration(options = {}) {
   };
   const destinationByCategory = {
     skills: path16.join(folders.agentsDir, "skills"),
-    agents: path16.join(folders.agentsDir, "agents")
+    agents: path16.join(folders.agentsDir, "agents"),
+    instructions: path16.join(folders.agentsDir, "AGENTS.md")
   };
   await import_fs_extra12.default.ensureDir(folders.agentsDir);
+  await importInstructionFiles(instructionCandidates, destinationByCategory.instructions, result);
   for (const category of ["skills", "agents"]) {
     await importCategoryEntries(category, candidates, destinationByCategory[category], result);
   }
   for (const candidate of candidates) {
     await linkContainer(candidate, destinationByCategory[candidate.category], result);
   }
+  for (const candidate of instructionCandidates) {
+    await linkInstructionFile(candidate, destinationByCategory.instructions, result);
+  }
   return result;
 }
 
@@ -35361,6 +35504,7 @@ AIBlueprint agents unify ${source_default.gray(`v${getVersion()}`)}
     console.log(source_default.green(`
 Unify complete`));
     console.log(source_default.gray(`  Shared folder: ${result.agentsDir}`));
+    printCategorySummary(result, "instructions");
     printCategorySummary(result, "skills");
     printCategorySummary(result, "agents");
     console.log(source_default.gray(`  codex agents: ${codexResult.rendered.length} rendered, ${codexResult.skipped.length} skipped`));

package/package.json

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