@bastani/atomic 0.8.28 → 0.8.29-alpha.3

package/dist/core/package-manager.js

@@ -60,10 +60,13 @@ function getCommandEnv(command, overrides) {
  *   2  user + settings entry (source: "local", scope: "user")
  *   3  user + auto-discovered (source: "auto", scope: "user")
  *   4  package resource (origin: "package")
+ *   5  project-local resources borrowed from explicit temporary extension sources
  */
 function resourcePrecedenceRank(m) {
     if (m.origin === "package")
         return 4;
+    if (m.borrowedProjectLocal)
+        return 5;
     const scopeBase = m.scope === "project" ? 0 : 2;
     return scopeBase + (m.source === "local" ? 0 : 1);
 }
@@ -772,7 +775,9 @@ export class DefaultPackageManager {
         const accumulator = this.createAccumulator();
         const scope = options?.temporary ? "temporary" : options?.local ? "project" : "user";
         const packageSources = sources.map((source) => ({ pkg: source, scope }));
-        await this.resolvePackageSources(packageSources, accumulator);
+        await this.resolvePackageSources(packageSources, accumulator, undefined, {
+            includeProjectLocalResources: options?.includeProjectLocalResources === true,
+        });
         return this.toResolvedPaths(accumulator);
     }
     listConfiguredPackages() {
@@ -1016,7 +1021,7 @@ export class DefaultPackageManager {
         const results = await this.runWithConcurrency(checks, UPDATE_CHECK_CONCURRENCY);
         return results.filter((result) => result !== undefined);
     }
-    async resolvePackageSources(sources, accumulator, onMissing) {
+    async resolvePackageSources(sources, accumulator, onMissing, options) {
         for (const { pkg, scope } of sources) {
             const sourceStr = typeof pkg === "string" ? pkg : pkg.source;
             const filter = typeof pkg === "object" ? pkg : undefined;
@@ -1024,7 +1029,9 @@ export class DefaultPackageManager {
             const metadata = { source: sourceStr, scope, origin: "package" };
             if (parsed.type === "local") {
                 for (const baseDir of this.getBaseDirsForScope(scope)) {
-                    this.resolveLocalExtensionSource(parsed, accumulator, filter, { ...metadata, baseDir }, baseDir);
+                    this.resolveLocalExtensionSource(parsed, accumulator, filter, { ...metadata, baseDir }, baseDir, {
+                        includeProjectLocalResources: options?.includeProjectLocalResources === true,
+                    });
                 }
                 continue;
             }
@@ -1076,7 +1083,7 @@ export class DefaultPackageManager {
             }
         }
     }
-    resolveLocalExtensionSource(source, accumulator, filter, metadata, baseDir) {
+    resolveLocalExtensionSource(source, accumulator, filter, metadata, baseDir, options) {
         const resolved = this.resolvePathFromBase(source.path, baseDir);
         if (!existsSync(resolved)) {
             return;
@@ -1084,15 +1091,19 @@ export class DefaultPackageManager {
         try {
             const stats = statSync(resolved);
             if (stats.isFile()) {
-                metadata.baseDir = dirname(resolved);
-                this.addResource(accumulator.extensions, resolved, metadata, true);
+                this.addResource(accumulator.extensions, resolved, { ...metadata, baseDir: dirname(resolved) }, true);
                 return;
             }
             if (stats.isDirectory()) {
-                metadata.baseDir = resolved;
-                const resources = this.collectPackageResources(resolved, accumulator, filter, metadata);
-                if (!resources) {
-                    this.addResource(accumulator.extensions, resolved, metadata, true);
+                const packageMetadata = { ...metadata, baseDir: resolved };
+                const packageResources = this.collectPackageResources(resolved, accumulator, filter, packageMetadata);
+                const projectLocalResources = options?.includeProjectLocalResources
+                    ? this.collectProjectLocalResources(resolved, accumulator, filter, packageMetadata)
+                    : false;
+                const extensionEntries = resolveExtensionEntries(resolved);
+                const shouldAddDirectoryFallback = extensionEntries !== null || (options?.includeProjectLocalResources === true && !projectLocalResources);
+                if (!packageResources && shouldAddDirectoryFallback) {
+                    this.addResource(accumulator.extensions, resolved, packageMetadata, true);
                 }
             }
         }
@@ -1811,6 +1822,40 @@ export class DefaultPackageManager {
         }
         return hasAnyDir;
     }
+    collectProjectLocalResources(sourceRoot, accumulator, filter, metadata) {
+        let found = false;
+        const projectMetadata = { ...metadata, origin: "top-level", borrowedProjectLocal: true };
+        const addResources = (resourceType, paths, resourceMetadata, patterns) => {
+            if (paths.length === 0)
+                return;
+            found = true;
+            const target = this.getTargetMap(accumulator, resourceType);
+            let enabledPaths;
+            if (patterns === undefined) {
+                enabledPaths = new Set(paths);
+            }
+            else if (patterns.length === 0) {
+                enabledPaths = new Set();
+            }
+            else {
+                enabledPaths = applyPatterns(paths, patterns, sourceRoot);
+            }
+            for (const path of paths) {
+                this.addResource(target, path, resourceMetadata, enabledPaths.has(path));
+            }
+        };
+        for (const configDir of getProjectConfigDirs(sourceRoot)) {
+            const configMetadata = { ...projectMetadata, baseDir: configDir };
+            addResources("extensions", collectAutoExtensionEntries(join(configDir, "extensions")), configMetadata, filter?.extensions);
+            addResources("skills", collectAutoSkillEntries(join(configDir, "skills"), "pi"), configMetadata, filter?.skills);
+            addResources("prompts", collectAutoPromptEntries(join(configDir, "prompts")), configMetadata, filter?.prompts);
+            addResources("themes", collectAutoThemeEntries(join(configDir, "themes")), configMetadata, filter?.themes);
+            addResources("workflows", collectResourceFiles(join(configDir, "workflows"), "workflows"), configMetadata, filter?.workflows);
+        }
+        const agentsSkillsDir = join(sourceRoot, ".agents", "skills");
+        addResources("skills", collectAutoSkillEntries(agentsSkillsDir, "agents"), { ...projectMetadata, baseDir: dirname(agentsSkillsDir) }, filter?.skills);
+        return found;
+    }
     collectDefaultResources(packageRoot, resourceType, target, metadata) {
         const manifest = this.readPiManifest(packageRoot);
         const entries = manifestEntriesForResource(manifest, resourceType);