@selesai/code 0.3.9 → 0.4.0

package/dist/core/package-manager.js

@@ -599,6 +599,20 @@ function applyPatterns(allPaths, patterns, baseDir) {
     }
     return new Set(result);
 }
+function applyAutoloadDisabledPatterns(allPaths, patterns, baseDir) {
+    const result = new Map();
+    for (const pattern of patterns) {
+        const target = pattern.slice(pattern.startsWith("+") || pattern.startsWith("-") || pattern.startsWith("!") ? 1 : 0);
+        const enabled = !pattern.startsWith("-") && !pattern.startsWith("!");
+        const exact = pattern.startsWith("+") || pattern.startsWith("-");
+        for (const filePath of allPaths) {
+            if (exact ? matchesAnyExactPattern(filePath, [target], baseDir) : matchesAnyPattern(filePath, [target], baseDir)) {
+                result.set(filePath, enabled);
+            }
+        }
+    }
+    return result;
+}
 export class DefaultPackageManager {
     cwd;
     agentDir;
@@ -981,57 +995,67 @@ export class DefaultPackageManager {
         for (const { pkg, scope } of sources) {
             const sourceStr = typeof pkg === "string" ? pkg : pkg.source;
             const filter = typeof pkg === "object" ? pkg : undefined;
-            const parsed = this.parseSource(sourceStr);
+            const deltaBase = this.findAutoloadDeltaBase(pkg, scope, sources);
+            const resolvedSource = deltaBase?.source ?? sourceStr;
+            const resolvedScope = deltaBase?.scope ?? scope;
+            const parsed = this.parseSource(resolvedSource);
             const metadata = { source: sourceStr, scope, origin: "package" };
             if (parsed.type === "local") {
-                const baseDir = this.getBaseDirForScope(scope);
+                const baseDir = this.getBaseDirForScope(resolvedScope);
                 this.resolveLocalExtensionSource(parsed, accumulator, filter, metadata, baseDir);
                 continue;
             }
             const installMissing = async () => {
-                if (isOfflineModeEnabled()) {
+                if (isOfflineModeEnabled())
                     return false;
-                }
                 if (!onMissing) {
-                    await this.installParsedSource(parsed, scope);
+                    await this.installParsedSource(parsed, resolvedScope);
                     return true;
                 }
-                const action = await onMissing(sourceStr);
+                const action = await onMissing(resolvedSource);
                 if (action === "skip")
                     return false;
                 if (action === "error")
-                    throw new Error(`Missing source: ${sourceStr}`);
-                await this.installParsedSource(parsed, scope);
+                    throw new Error(`Missing source: ${resolvedSource}`);
+                await this.installParsedSource(parsed, resolvedScope);
                 return true;
             };
             if (parsed.type === "npm") {
-                let installedPath = this.getNpmInstallPath(parsed, scope);
+                let installedPath = this.getNpmInstallPath(parsed, resolvedScope);
                 const needsInstall = !existsSync(installedPath) || !(await this.installedNpmMatchesConfiguredVersion(parsed, installedPath));
                 if (needsInstall) {
                     const installed = await installMissing();
                     if (!installed)
                         continue;
-                    installedPath = this.getNpmInstallPath(parsed, scope);
+                    installedPath = this.getNpmInstallPath(parsed, resolvedScope);
                 }
                 metadata.baseDir = installedPath;
                 this.collectPackageResources(installedPath, accumulator, filter, metadata);
                 continue;
             }
             if (parsed.type === "git") {
-                const installedPath = this.getGitInstallPath(parsed, scope);
+                const installedPath = this.getGitInstallPath(parsed, resolvedScope);
                 if (!existsSync(installedPath)) {
                     const installed = await installMissing();
                     if (!installed)
                         continue;
                 }
-                else if (scope === "temporary" && !parsed.pinned && !isOfflineModeEnabled()) {
-                    await this.refreshTemporaryGitSource(parsed, sourceStr);
+                else if (resolvedScope === "temporary" && !parsed.pinned && !isOfflineModeEnabled()) {
+                    await this.refreshTemporaryGitSource(parsed, resolvedSource);
                 }
                 metadata.baseDir = installedPath;
                 this.collectPackageResources(installedPath, accumulator, filter, metadata);
             }
         }
     }
+    findAutoloadDeltaBase(pkg, scope, sources) {
+        if (scope !== "project" || typeof pkg !== "object" || pkg.autoload !== false)
+            return undefined;
+        const identity = this.getPackageIdentity(pkg.source, scope);
+        const userEntry = sources.find((entry) => entry.scope === "user" &&
+            this.getPackageIdentity(this.getPackageSourceString(entry.pkg), "user") === identity);
+        return userEntry ? { source: this.getPackageSourceString(userEntry.pkg), scope: "user" } : undefined;
+    }
     resolveLocalExtensionSource(source, accumulator, filter, metadata, baseDir) {
         const resolved = this.resolvePathFromBase(source.path, baseDir);
         if (!existsSync(resolved)) {
@@ -1373,25 +1397,30 @@ export class DefaultPackageManager {
     }
     /**
      * Dedupe packages: if same package identity appears in both global and project,
-     * keep only the project one (project wins).
+     * keep only the project one (project wins). A project entry with autoload=false
+     * is a delta over the global entry, so both are kept (delta first).
      */
     dedupePackages(packages) {
+        const result = [];
         const seen = new Map();
         for (const entry of packages) {
-            const sourceStr = typeof entry.pkg === "string" ? entry.pkg : entry.pkg.source;
-            const identity = this.getPackageIdentity(sourceStr, entry.scope);
-            const existing = seen.get(identity);
-            if (!existing) {
-                seen.set(identity, entry);
+            const identity = this.getPackageIdentity(this.getPackageSourceString(entry.pkg), entry.scope);
+            const index = seen.get(identity);
+            if (index === undefined) {
+                seen.set(identity, result.length);
+                result.push(entry);
+                continue;
+            }
+            const existing = result[index];
+            if (existing?.scope === "project" && entry.scope === "user") {
+                if (typeof existing.pkg === "object" && existing.pkg.autoload === false)
+                    result.push(entry);
             }
-            else if (entry.scope === "project" && existing.scope === "user") {
-                // Project wins over user
-                seen.set(identity, entry);
+            else if (entry.scope === "project") {
+                result[index] = entry;
             }
-            // If existing is project and new is global, keep existing (project)
-            // If both are same scope, keep first one
         }
-        return Array.from(seen.values());
+        return result;
     }
     parseNpmSpec(spec) {
         const match = spec.match(/^(@?[^@]+(?:\/[^@]+)?)(?:@(.+))?$/);
@@ -1726,7 +1755,10 @@ export class DefaultPackageManager {
             for (const resourceType of RESOURCE_TYPES) {
                 const patterns = filter[resourceType];
                 const target = this.getTargetMap(accumulator, resourceType);
-                if (patterns !== undefined) {
+                if (filter.autoload === false) {
+                    this.applyPackageDeltaFilter(packageRoot, patterns ?? [], resourceType, target, metadata);
+                }
+                else if (patterns !== undefined) {
                     this.applyPackageFilter(packageRoot, patterns, resourceType, target, metadata);
                 }
                 else {
@@ -1789,6 +1821,16 @@ export class DefaultPackageManager {
             this.addResource(target, f, metadata, enabled);
         }
     }
+    applyPackageDeltaFilter(packageRoot, userPatterns, resourceType, target, metadata) {
+        if (userPatterns.length === 0) {
+            return;
+        }
+        const { allFiles } = this.collectManifestFiles(packageRoot, resourceType);
+        const enabledByUser = applyAutoloadDisabledPatterns(allFiles, userPatterns, packageRoot);
+        for (const [filePath, enabled] of enabledByUser) {
+            this.addResource(target, filePath, metadata, enabled);
+        }
+    }
     /**
      * Collect all files from a package for a resource type, applying manifest patterns.
      * Returns { allFiles, enabledByManifest } where enabledByManifest is the set of files