@code-yeongyu/senpi 2026.7.9-2 → 2026.7.9

package/dist/core/package-manager.js

@@ -583,20 +583,6 @@ 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 {
     constructor(options) {
         this.cwd = resolvePath(options.cwd);
@@ -973,67 +959,57 @@ 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 deltaBase = this.findAutoloadDeltaBase(pkg, scope, sources);
-            const resolvedSource = deltaBase?.source ?? sourceStr;
-            const resolvedScope = deltaBase?.scope ?? scope;
-            const parsed = this.parseSource(resolvedSource);
+            const parsed = this.parseSource(sourceStr);
             const metadata = { source: sourceStr, scope, origin: "package" };
             if (parsed.type === "local") {
-                const baseDir = this.getBaseDirForScope(resolvedScope);
+                const baseDir = this.getBaseDirForScope(scope);
                 this.resolveLocalExtensionSource(parsed, accumulator, filter, metadata, baseDir);
                 continue;
             }
             const installMissing = async () => {
-                if (isOfflineModeEnabled())
+                if (isOfflineModeEnabled()) {
                     return false;
+                }
                 if (!onMissing) {
-                    await this.installParsedSource(parsed, resolvedScope);
+                    await this.installParsedSource(parsed, scope);
                     return true;
                 }
-                const action = await onMissing(resolvedSource);
+                const action = await onMissing(sourceStr);
                 if (action === "skip")
                     return false;
                 if (action === "error")
-                    throw new Error(`Missing source: ${resolvedSource}`);
-                await this.installParsedSource(parsed, resolvedScope);
+                    throw new Error(`Missing source: ${sourceStr}`);
+                await this.installParsedSource(parsed, scope);
                 return true;
             };
             if (parsed.type === "npm") {
-                let installedPath = this.getNpmInstallPath(parsed, resolvedScope);
+                let installedPath = this.getNpmInstallPath(parsed, scope);
                 const needsInstall = !existsSync(installedPath) || !(await this.installedNpmMatchesConfiguredVersion(parsed, installedPath));
                 if (needsInstall) {
                     const installed = await installMissing();
                     if (!installed)
                         continue;
-                    installedPath = this.getNpmInstallPath(parsed, resolvedScope);
+                    installedPath = this.getNpmInstallPath(parsed, scope);
                 }
                 metadata.baseDir = installedPath;
                 this.collectPackageResources(installedPath, accumulator, filter, metadata);
                 continue;
             }
             if (parsed.type === "git") {
-                const installedPath = this.getGitInstallPath(parsed, resolvedScope);
+                const installedPath = this.getGitInstallPath(parsed, scope);
                 if (!existsSync(installedPath)) {
                     const installed = await installMissing();
                     if (!installed)
                         continue;
                 }
-                else if (resolvedScope === "temporary" && !parsed.pinned && !isOfflineModeEnabled()) {
-                    await this.refreshTemporaryGitSource(parsed, resolvedSource);
+                else if (scope === "temporary" && !parsed.pinned && !isOfflineModeEnabled()) {
+                    await this.refreshTemporaryGitSource(parsed, sourceStr);
                 }
                 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)) {
@@ -1375,30 +1351,25 @@ export class DefaultPackageManager {
     }
     /**
      * Dedupe packages: if same package identity appears in both global and project,
-     * 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).
+     * keep only the project one (project wins).
      */
     dedupePackages(packages) {
-        const result = [];
         const seen = new Map();
         for (const entry of packages) {
-            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);
+            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);
             }
-            else if (entry.scope === "project") {
-                result[index] = entry;
+            else if (entry.scope === "project" && existing.scope === "user") {
+                // Project wins over user
+                seen.set(identity, entry);
             }
+            // If existing is project and new is global, keep existing (project)
+            // If both are same scope, keep first one
         }
-        return result;
+        return Array.from(seen.values());
     }
     parseNpmSpec(spec) {
         const match = spec.match(/^(@?[^@]+(?:\/[^@]+)?)(?:@(.+))?$/);
@@ -1735,10 +1706,7 @@ export class DefaultPackageManager {
             for (const resourceType of RESOURCE_TYPES) {
                 const patterns = filter[resourceType];
                 const target = this.getTargetMap(accumulator, resourceType);
-                if (filter.autoload === false) {
-                    this.applyPackageDeltaFilter(packageRoot, patterns ?? [], resourceType, target, metadata);
-                }
-                else if (patterns !== undefined) {
+                if (patterns !== undefined) {
                     this.applyPackageFilter(packageRoot, patterns, resourceType, target, metadata);
                 }
                 else {
@@ -1801,16 +1769,6 @@ 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