moluoxixi-ai-rules 0.2.0 → 0.2.2

package/dist/scripts/lib/tool.js

@@ -4,7 +4,7 @@ import { fileURLToPath } from 'node:url';
 import { HOST_IDS, resolveHostId } from '../../constants/hosts.js';
 import { ensureGlobalSkillLink, ensureInstallRoot, getDefaultInstallPaths, projectHostById, runSkillSetupCommands, } from './install.js';
 import { resolveRoleManifestPath } from './roles.js';
-import { rebuildVendorAssets } from './vendor-staging.js';
+import { cleanupEmptyVendorSkillDirectories, rebuildVendorAssets } from './vendor-staging.js';
 import { ensureVendorRepo, verifyVendorRepoRevision } from './vendor-sync.js';
 import { loadVendorManifest } from './vendors.js';
 import { verifyGlobalAgentSkills, verifyHost } from './verify.js';
@@ -105,6 +105,7 @@ export async function syncToHosts(options) {
             }
         }
     }
+    cleanupEmptyVendorSkillDirectories(paths.moluoHome);
     if (failedHosts.length > 0) {
         throw new Error(`Host verification failed: ${failedHosts.join(', ')}`);
     }

package/dist/scripts/lib/vendor-staging.d.ts

@@ -8,4 +8,5 @@ export interface RebuildVendorAssetsOptions {
     role: string;
     manifestPath: string;
 }
+export declare function cleanupEmptyVendorSkillDirectories(homeDir: string): void;
 export declare function rebuildVendorAssets(options: RebuildVendorAssetsOptions): Promise<VendorAssetInventory>;

package/dist/scripts/lib/vendor-staging.js

@@ -412,6 +412,71 @@ function rollbackManagedEntries(entries) {
     }
     return rollbackErrors;
 }
+function managedChildNames(currentRoot, nextRoot, label) {
+    const names = new Map();
+    for (const root of [currentRoot, nextRoot]) {
+        if (!fs.existsSync(root))
+            continue;
+        requirePlainDirectoryOrMissing(root, label);
+        for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+            if (!entry.isDirectory() && !entry.isFile())
+                throw new Error(`${label} has unsupported filesystem type: ${path.join(root, entry.name)}`);
+            const key = entry.name.toLowerCase();
+            const previous = names.get(key);
+            if (previous !== undefined && previous !== entry.name)
+                throw new Error(`${label} names differ only by case: ${previous}, ${entry.name}`);
+            names.set(key, entry.name);
+        }
+    }
+    return [...names.values()].sort(compareStable);
+}
+function isPlainDirectory(target) {
+    const stats = fs.lstatSync(target, { throwIfNoEntry: false });
+    return stats !== undefined && stats.isDirectory() && !stats.isSymbolicLink();
+}
+function commitDirectoryContents(currentRoot, nextRoot, backupRoot, committedEntries, emptiedRoots) {
+    const childNames = managedChildNames(currentRoot, nextRoot, 'Managed vendor skill directory');
+    for (const name of childNames) {
+        const currentChild = path.join(currentRoot, name);
+        const nextChild = path.join(nextRoot, name);
+        const hasNextChild = fs.existsSync(nextChild);
+        if (isPlainDirectory(currentChild) && (!hasNextChild || isPlainDirectory(nextChild))) {
+            commitDirectoryContents(currentChild, nextChild, path.join(backupRoot, name), committedEntries, emptiedRoots);
+            if (!hasNextChild)
+                emptiedRoots.push(currentChild);
+            continue;
+        }
+        const entry = {
+            current: currentChild,
+            backup: path.join(backupRoot, name),
+            movedCurrent: false,
+            installedNext: false,
+        };
+        committedEntries.push(entry);
+        if (fs.existsSync(entry.current)) {
+            fs.mkdirSync(path.dirname(entry.backup), { recursive: true });
+            fs.renameSync(entry.current, entry.backup);
+            entry.movedCurrent = true;
+        }
+        if (fs.existsSync(nextChild)) {
+            fs.renameSync(nextChild, entry.current);
+            entry.installedNext = true;
+        }
+    }
+}
+function commitManagedChildren(spec, committedEntries, createdRoots, emptiedRoots) {
+    requirePlainDirectoryOrMissing(spec.current, 'Managed vendor skills root');
+    requirePlainDirectoryOrMissing(spec.next, 'Staged vendor skills root');
+    const childNames = managedChildNames(spec.current, spec.next, 'Managed vendor skill');
+    if (!fs.existsSync(spec.current)) {
+        if (!fs.existsSync(spec.next))
+            return;
+        fs.mkdirSync(spec.current, { recursive: true });
+        createdRoots.push(spec.current);
+    }
+    if (childNames.length > 0)
+        commitDirectoryContents(spec.current, spec.next, spec.backup, committedEntries, emptiedRoots);
+}
 async function commitManagedEntries(stagingRoot, roleStagingRoot, homeDir, role) {
     const resolvedHome = path.resolve(homeDir);
     const vendorRoot = path.join(resolvedHome, 'vendor');
@@ -429,6 +494,8 @@ async function commitManagedEntries(stagingRoot, roleStagingRoot, homeDir, role)
     const nextRoot = path.join(nextWorkspace, 'vendor');
     const backupRoot = fs.mkdtempSync(path.join(resolvedHome, '.airules-vendor-backup-'));
     const committedEntries = [];
+    const createdRoots = [];
+    const emptiedRoots = [];
     try {
         fs.mkdirSync(nextRoot);
         fs.cpSync(stagingRoot, nextRoot, { recursive: true, dereference: true });
@@ -436,6 +503,7 @@ async function commitManagedEntries(stagingRoot, roleStagingRoot, homeDir, role)
             current: path.join(vendorRoot, name),
             next: path.join(nextRoot, name),
             backup: path.join(backupRoot, 'vendor', name),
+            preserveRoot: name === 'skills',
         }));
         if (roleStagingRoot !== undefined) {
             const nextRole = path.join(nextWorkspace, 'roles', role);
@@ -448,6 +516,10 @@ async function commitManagedEntries(stagingRoot, roleStagingRoot, homeDir, role)
             });
         }
         for (const spec of specs) {
+            if (spec.preserveRoot) {
+                commitManagedChildren(spec, committedEntries, createdRoots, emptiedRoots);
+                continue;
+            }
             const entry = {
                 current: spec.current,
                 backup: spec.backup,
@@ -469,6 +541,14 @@ async function commitManagedEntries(stagingRoot, roleStagingRoot, homeDir, role)
     }
     catch (error) {
         const rollbackErrors = rollbackManagedEntries(committedEntries);
+        for (const root of [...createdRoots].reverse()) {
+            try {
+                fs.rmdirSync(root);
+            }
+            catch (rollbackError) {
+                rollbackErrors.push(rollbackError instanceof Error ? rollbackError : new Error(String(rollbackError)));
+            }
+        }
         removeBestEffort(nextWorkspace);
         if (rollbackErrors.length > 0) {
             throw new AggregateError([error, ...rollbackErrors], `Role and vendor staging commit failed and rollback did not restore every managed asset: ${String(error)}`);
@@ -476,9 +556,36 @@ async function commitManagedEntries(stagingRoot, roleStagingRoot, homeDir, role)
         removeBestEffort(backupRoot);
         throw new Error(`Role and vendor staging commit failed; previous managed assets restored: ${String(error)}`, { cause: error });
     }
+    for (const root of emptiedRoots)
+        removeEmptyDirectoryBestEffort(root);
     removeBestEffort(nextWorkspace);
     removeBestEffort(backupRoot);
 }
+function removeEmptyDirectoryBestEffort(target) {
+    try {
+        fs.rmdirSync(target);
+    }
+    catch {
+        // Host junctions can keep an empty skill directory locked until projection finishes.
+    }
+}
+function cleanupEmptyDirectoryTree(root) {
+    for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+        if (entry.isDirectory())
+            cleanupEmptyDirectoryTree(path.join(root, entry.name));
+    }
+    removeEmptyDirectoryBestEffort(root);
+}
+export function cleanupEmptyVendorSkillDirectories(homeDir) {
+    const skillsRoot = path.resolve(homeDir, 'vendor', 'skills');
+    if (!fs.existsSync(skillsRoot))
+        return;
+    requirePlainDirectoryOrMissing(skillsRoot, 'Managed vendor skills root');
+    for (const entry of fs.readdirSync(skillsRoot, { withFileTypes: true })) {
+        if (entry.isDirectory())
+            cleanupEmptyDirectoryTree(path.join(skillsRoot, entry.name));
+    }
+}
 export async function rebuildVendorAssets(options) {
     const role = requireRoleName(options.role);
     const manifest = await loadVendorManifest(options.manifestPath);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "moluoxixi-ai-rules",
   "type": "module",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Remote AI role asset distribution for supported hosts.",
   "license": "MIT",
   "repository": "https://github.com/moluoxixi/AIRules",