indusagi-coding-agent 0.1.38 → 0.1.40

package/dist/core/package-manager.js

@@ -1,253 +1,50 @@
 import { spawn, spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { homedir, tmpdir } from "node:os";
+import { tmpdir } from "node:os";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import { minimatch } from "minimatch";
 import { CONFIG_DIR_NAME } from "../config.js";
-import { looksLikeGitUrl } from "../utils/git.js";
 const RESOURCE_TYPES = ["extensions", "hooks", "skills", "prompts", "themes"];
 const FILE_PATTERNS = {
-    extensions: /\.(ts|js)$/,
-    hooks: /\.(ts|js)$/,
+    extensions: /\.(ts|js|mjs|cjs)$/,
+    hooks: /\.(ts|js|mjs|cjs)$/,
     skills: /\.md$/,
     prompts: /\.md$/,
     themes: /\.json$/,
 };
-function isPattern(s) {
-    return s.startsWith("!") || s.startsWith("+") || s.startsWith("-") || s.includes("*") || s.includes("?");
+function looksLikeGitUrl(source) {
+    const normalized = source.replace(/^https?:\/\//, "");
+    return ["github.com", "gitlab.com", "bitbucket.org", "codeberg.org"].some((host) => normalized.startsWith(`${host}/`));
 }
-function splitPatterns(entries) {
-    const plain = [];
-    const patterns = [];
-    for (const entry of entries) {
-        if (isPattern(entry)) {
-            patterns.push(entry);
-        }
-        else {
-            plain.push(entry);
-        }
-    }
-    return { plain, patterns };
-}
-function collectFiles(dir, filePattern, skipNodeModules = true) {
-    const files = [];
-    if (!existsSync(dir))
-        return files;
+function readManifest(packageJsonPath) {
     try {
-        const entries = readdirSync(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (entry.name.startsWith("."))
-                continue;
-            if (skipNodeModules && entry.name === "node_modules")
-                continue;
-            const fullPath = join(dir, entry.name);
-            let isDir = entry.isDirectory();
-            let isFile = entry.isFile();
-            if (entry.isSymbolicLink()) {
-                try {
-                    const stats = statSync(fullPath);
-                    isDir = stats.isDirectory();
-                    isFile = stats.isFile();
-                }
-                catch {
-                    continue;
-                }
-            }
-            if (isDir) {
-                files.push(...collectFiles(fullPath, filePattern, skipNodeModules));
-            }
-            else if (isFile && filePattern.test(entry.name)) {
-                files.push(fullPath);
-            }
-        }
+        const parsed = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+        return parsed.indusagi ?? null;
     }
     catch {
-        // Ignore errors
+        return null;
     }
-    return files;
 }
-function collectSkillEntries(dir, includeRootFiles = true) {
-    const entries = [];
-    if (!existsSync(dir))
-        return entries;
+function safeReaddir(dir) {
     try {
-        const dirEntries = readdirSync(dir, { withFileTypes: true });
-        for (const entry of dirEntries) {
-            if (entry.name.startsWith("."))
-                continue;
-            if (entry.name === "node_modules")
-                continue;
-            const fullPath = join(dir, entry.name);
-            let isDir = entry.isDirectory();
-            let isFile = entry.isFile();
-            if (entry.isSymbolicLink()) {
-                try {
-                    const stats = statSync(fullPath);
-                    isDir = stats.isDirectory();
-                    isFile = stats.isFile();
-                }
-                catch {
-                    continue;
-                }
-            }
-            if (isDir) {
-                entries.push(...collectSkillEntries(fullPath, false));
-            }
-            else if (isFile) {
-                const isRootMd = includeRootFiles && entry.name.endsWith(".md");
-                const isSkillMd = !includeRootFiles && entry.name === "SKILL.md";
-                if (isRootMd || isSkillMd) {
-                    entries.push(fullPath);
-                }
-            }
-        }
+        return readdirSync(dir);
     }
     catch {
-        // Ignore errors
+        return [];
     }
-    return entries;
-}
-function collectAutoSkillEntries(dir, includeRootFiles = true) {
-    return collectSkillEntries(dir, includeRootFiles);
 }
-function collectAutoPromptEntries(dir) {
-    const entries = [];
-    if (!existsSync(dir))
-        return entries;
-    try {
-        const dirEntries = readdirSync(dir, { withFileTypes: true });
-        for (const entry of dirEntries) {
-            if (entry.name.startsWith("."))
-                continue;
-            if (entry.name === "node_modules")
-                continue;
-            const fullPath = join(dir, entry.name);
-            let isFile = entry.isFile();
-            if (entry.isSymbolicLink()) {
-                try {
-                    isFile = statSync(fullPath).isFile();
-                }
-                catch {
-                    continue;
-                }
-            }
-            if (isFile && entry.name.endsWith(".md")) {
-                entries.push(fullPath);
-            }
-        }
+function collectFiles(dir, filePattern) {
+    if (!existsSync(dir)) {
+        return [];
     }
-    catch {
-        // Ignore errors
-    }
-    return entries;
-}
-function collectAutoThemeEntries(dir) {
-    const entries = [];
-    if (!existsSync(dir))
-        return entries;
+    const results = [];
     try {
-        const dirEntries = readdirSync(dir, { withFileTypes: true });
-        for (const entry of dirEntries) {
-            if (entry.name.startsWith("."))
-                continue;
-            if (entry.name === "node_modules")
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.name.startsWith(".") || entry.name === "node_modules") {
                 continue;
-            const fullPath = join(dir, entry.name);
-            let isFile = entry.isFile();
-            if (entry.isSymbolicLink()) {
-                try {
-                    isFile = statSync(fullPath).isFile();
-                }
-                catch {
-                    continue;
-                }
-            }
-            if (isFile && entry.name.endsWith(".json")) {
-                entries.push(fullPath);
-            }
-        }
-    }
-    catch {
-        // Ignore errors
-    }
-    return entries;
-}
-function readIndusagiManifestFile(packageJsonPath) {
-    try {
-        const content = readFileSync(packageJsonPath, "utf-8");
-        const pkg = JSON.parse(content);
-        return pkg.indusagi ?? null;
-    }
-    catch {
-        return null;
-    }
-}
-function resolveExtensionEntries(dir) {
-    const packageJsonPath = join(dir, "package.json");
-    if (existsSync(packageJsonPath)) {
-        const manifest = readIndusagiManifestFile(packageJsonPath);
-        if (manifest?.extensions?.length) {
-            const entries = [];
-            for (const extPath of manifest.extensions) {
-                const resolvedExtPath = resolve(dir, extPath);
-                if (existsSync(resolvedExtPath)) {
-                    entries.push(resolvedExtPath);
-                }
             }
-            if (entries.length > 0) {
-                return entries;
-            }
-        }
-    }
-    const indexTs = join(dir, "index.ts");
-    const indexJs = join(dir, "index.js");
-    if (existsSync(indexTs)) {
-        return [indexTs];
-    }
-    if (existsSync(indexJs)) {
-        return [indexJs];
-    }
-    return null;
-}
-function resolveHookEntries(dir) {
-    const packageJsonPath = join(dir, "package.json");
-    if (existsSync(packageJsonPath)) {
-        const manifest = readIndusagiManifestFile(packageJsonPath);
-        if (manifest?.hooks?.length) {
-            const entries = [];
-            for (const hookPath of manifest.hooks) {
-                const resolvedHookPath = resolve(dir, hookPath);
-                if (existsSync(resolvedHookPath)) {
-                    entries.push(resolvedHookPath);
-                }
-            }
-            if (entries.length > 0) {
-                return entries;
-            }
-        }
-    }
-    const indexTs = join(dir, "index.ts");
-    const indexJs = join(dir, "index.js");
-    if (existsSync(indexTs)) {
-        return [indexTs];
-    }
-    if (existsSync(indexJs)) {
-        return [indexJs];
-    }
-    return null;
-}
-function collectAutoExtensionEntries(dir) {
-    const entries = [];
-    if (!existsSync(dir))
-        return entries;
-    try {
-        const dirEntries = readdirSync(dir, { withFileTypes: true });
-        for (const entry of dirEntries) {
-            if (entry.name.startsWith("."))
-                continue;
-            if (entry.name === "node_modules")
-                continue;
             const fullPath = join(dir, entry.name);
             let isDir = entry.isDirectory();
             let isFile = entry.isFile();
@@ -261,33 +58,30 @@ function collectAutoExtensionEntries(dir) {
                     continue;
                 }
             }
-            if (isFile && (entry.name.endsWith(".ts") || entry.name.endsWith(".js"))) {
-                entries.push(fullPath);
+            if (isDir) {
+                results.push(...collectFiles(fullPath, filePattern));
             }
-            else if (isDir) {
-                const resolvedEntries = resolveExtensionEntries(fullPath);
-                if (resolvedEntries) {
-                    entries.push(...resolvedEntries);
-                }
+            else if (isFile && filePattern.test(entry.name)) {
+                results.push(fullPath);
             }
         }
     }
     catch {
-        // Ignore errors
+        return results;
     }
-    return entries;
+    return results;
 }
-function collectAutoHookEntries(dir) {
-    const entries = [];
-    if (!existsSync(dir))
-        return entries;
+function collectSkillEntries(dir, includeRootFiles = true) {
+    if (!existsSync(dir)) {
+        return [];
+    }
+    const results = [];
     try {
-        const dirEntries = readdirSync(dir, { withFileTypes: true });
-        for (const entry of dirEntries) {
-            if (entry.name.startsWith("."))
-                continue;
-            if (entry.name === "node_modules")
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.name.startsWith(".") || entry.name === "node_modules") {
                 continue;
+            }
             const fullPath = join(dir, entry.name);
             let isDir = entry.isDirectory();
             let isFile = entry.isFile();
@@ -301,134 +95,40 @@ function collectAutoHookEntries(dir) {
                     continue;
                 }
             }
-            if (isFile && (entry.name.endsWith(".ts") || entry.name.endsWith(".js"))) {
-                entries.push(fullPath);
+            if (isDir) {
+                results.push(...collectSkillEntries(fullPath, false));
             }
-            else if (isDir) {
-                const resolvedEntries = resolveHookEntries(fullPath);
-                if (resolvedEntries) {
-                    entries.push(...resolvedEntries);
+            else if (isFile) {
+                const isRootMd = includeRootFiles && entry.name.endsWith(".md");
+                const isSkillMd = !includeRootFiles && entry.name === "SKILL.md";
+                if (isRootMd || isSkillMd) {
+                    results.push(fullPath);
                 }
             }
         }
     }
     catch {
-        // Ignore errors
+        return results;
     }
-    return entries;
+    return results;
 }
-function matchesAnyPattern(filePath, patterns, baseDir) {
-    const rel = relative(baseDir, filePath);
-    const name = basename(filePath);
-    const isSkillFile = name === "SKILL.md";
-    const parentDir = isSkillFile ? dirname(filePath) : undefined;
-    const parentRel = isSkillFile ? relative(baseDir, parentDir) : undefined;
-    const parentName = isSkillFile ? basename(parentDir) : undefined;
-    return patterns.some((pattern) => {
-        if (minimatch(rel, pattern) || minimatch(name, pattern) || minimatch(filePath, pattern)) {
-            return true;
-        }
-        if (!isSkillFile)
-            return false;
-        return minimatch(parentRel, pattern) || minimatch(parentName, pattern) || minimatch(parentDir, pattern);
-    });
-}
-function normalizeExactPattern(pattern) {
-    if (pattern.startsWith("./") || pattern.startsWith(".\\")) {
-        return pattern.slice(2);
+function matchesFilter(filePath, baseDir, patterns) {
+    if (!patterns || patterns.length === 0) {
+        return true;
     }
-    return pattern;
-}
-function matchesAnyExactPattern(filePath, patterns, baseDir) {
-    if (patterns.length === 0)
-        return false;
     const rel = relative(baseDir, filePath);
     const name = basename(filePath);
-    const isSkillFile = name === "SKILL.md";
-    const parentDir = isSkillFile ? dirname(filePath) : undefined;
-    const parentRel = isSkillFile ? relative(baseDir, parentDir) : undefined;
     return patterns.some((pattern) => {
-        const normalized = normalizeExactPattern(pattern);
-        if (normalized === rel || normalized === filePath) {
-            return true;
-        }
-        if (!isSkillFile)
-            return false;
-        return normalized === parentRel || normalized === parentDir;
+        const normalized = pattern.replace(/^\.\//, "");
+        return (minimatch(rel, normalized, { nocase: true }) ||
+            minimatch(name, normalized, { nocase: true }) ||
+            minimatch(filePath, normalized, { nocase: true }) ||
+            rel === normalized ||
+            name === normalized);
     });
 }
-function getOverridePatterns(entries) {
-    return entries.filter((pattern) => pattern.startsWith("!") || pattern.startsWith("+") || pattern.startsWith("-"));
-}
-function isEnabledByOverrides(filePath, patterns, baseDir) {
-    const overrides = getOverridePatterns(patterns);
-    const excludes = overrides.filter((pattern) => pattern.startsWith("!")).map((pattern) => pattern.slice(1));
-    const forceIncludes = overrides.filter((pattern) => pattern.startsWith("+")).map((pattern) => pattern.slice(1));
-    const forceExcludes = overrides.filter((pattern) => pattern.startsWith("-")).map((pattern) => pattern.slice(1));
-    let enabled = true;
-    if (excludes.length > 0 && matchesAnyPattern(filePath, excludes, baseDir)) {
-        enabled = false;
-    }
-    if (forceIncludes.length > 0 && matchesAnyExactPattern(filePath, forceIncludes, baseDir)) {
-        enabled = true;
-    }
-    if (forceExcludes.length > 0 && matchesAnyExactPattern(filePath, forceExcludes, baseDir)) {
-        enabled = false;
-    }
-    return enabled;
-}
-/**
- * Apply patterns to paths and return a Set of enabled paths.
- * Pattern types:
- * - Plain patterns: include matching paths
- * - `!pattern`: exclude matching paths
- * - `+path`: force-include exact path (overrides exclusions)
- * - `-path`: force-exclude exact path (overrides force-includes)
- */
-function applyPatterns(allPaths, patterns, baseDir) {
-    const includes = [];
-    const excludes = [];
-    const forceIncludes = [];
-    const forceExcludes = [];
-    for (const p of patterns) {
-        if (p.startsWith("+")) {
-            forceIncludes.push(p.slice(1));
-        }
-        else if (p.startsWith("-")) {
-            forceExcludes.push(p.slice(1));
-        }
-        else if (p.startsWith("!")) {
-            excludes.push(p.slice(1));
-        }
-        else {
-            includes.push(p);
-        }
-    }
-    // Step 1: Apply includes (or all if no includes)
-    let result;
-    if (includes.length === 0) {
-        result = [...allPaths];
-    }
-    else {
-        result = allPaths.filter((filePath) => matchesAnyPattern(filePath, includes, baseDir));
-    }
-    // Step 2: Apply excludes
-    if (excludes.length > 0) {
-        result = result.filter((filePath) => !matchesAnyPattern(filePath, excludes, baseDir));
-    }
-    // Step 3: Force-include (add back from allPaths, overriding exclusions)
-    if (forceIncludes.length > 0) {
-        for (const filePath of allPaths) {
-            if (!result.includes(filePath) && matchesAnyExactPattern(filePath, forceIncludes, baseDir)) {
-                result.push(filePath);
-            }
-        }
-    }
-    // Step 4: Force-exclude (remove even if included or force-included)
-    if (forceExcludes.length > 0) {
-        result = result.filter((filePath) => !matchesAnyExactPattern(filePath, forceExcludes, baseDir));
-    }
-    return new Set(result);
+function pickPatterns(filter, resourceType) {
+    return filter?.[resourceType];
 }
 export class DefaultPackageManager {
     constructor(options) {
@@ -441,40 +141,21 @@ export class DefaultPackageManager {
     }
     getInstalledPath(source, scope) {
         const parsed = this.parseSource(source);
-        if (parsed.type === "npm") {
-            const path = this.getNpmInstallPath(parsed, scope);
-            return existsSync(path) ? path : undefined;
-        }
-        if (parsed.type === "git") {
-            const path = this.getGitInstallPath(parsed, scope);
-            return existsSync(path) ? path : undefined;
-        }
         if (parsed.type === "local") {
-            const path = this.resolvePath(parsed.path);
-            return existsSync(path) ? path : undefined;
-        }
-        return undefined;
-    }
-    emitProgress(event) {
-        this.progressCallback?.(event);
-    }
-    async withProgress(action, source, message, operation) {
-        this.emitProgress({ type: "start", action, source, message });
-        try {
-            await operation();
-            this.emitProgress({ type: "complete", action, source });
+            const resolved = this.resolveLocalPath(parsed.path);
+            return existsSync(resolved) ? resolved : undefined;
         }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            this.emitProgress({ type: "error", action, source, message: errorMessage });
-            throw error;
+        if (parsed.type === "npm") {
+            const installedPath = this.getNpmInstallPath(parsed, scope);
+            return existsSync(installedPath) ? installedPath : undefined;
         }
+        const installedPath = this.getGitInstallPath(parsed, scope);
+        return existsSync(installedPath) ? installedPath : undefined;
     }
     async resolve(onMissing) {
         const accumulator = this.createAccumulator();
         const globalSettings = this.settingsManager.getGlobalSettings();
         const projectSettings = this.settingsManager.getProjectSettings();
-        // Collect all packages with scope
         const allPackages = [];
         for (const pkg of globalSettings.packages ?? []) {
             allPackages.push({ pkg, scope: "user" });
@@ -482,42 +163,38 @@ export class DefaultPackageManager {
         for (const pkg of projectSettings.packages ?? []) {
             allPackages.push({ pkg, scope: "project" });
         }
-        // Dedupe: project scope wins over global for same package identity
-        const packageSources = this.dedupePackages(allPackages);
-        await this.resolvePackageSources(packageSources, accumulator, onMissing);
-        const globalBaseDir = this.agentDir;
-        const projectBaseDir = join(this.cwd, CONFIG_DIR_NAME);
+        for (const entry of this.dedupePackages(allPackages)) {
+            await this.resolvePackageSource(entry.pkg, entry.scope, accumulator, onMissing);
+        }
+        const globalBase = this.agentDir;
+        const projectBase = join(this.cwd, CONFIG_DIR_NAME);
         for (const resourceType of RESOURCE_TYPES) {
-            const target = this.getTargetMap(accumulator, resourceType);
-            const globalEntries = (globalSettings[resourceType] ?? []);
-            const projectEntries = (projectSettings[resourceType] ?? []);
-            this.resolveLocalEntries(globalEntries, resourceType, target, {
-                source: "local",
-                scope: "user",
-                origin: "top-level",
-            }, globalBaseDir);
-            this.resolveLocalEntries(projectEntries, resourceType, target, {
-                source: "local",
-                scope: "project",
-                origin: "top-level",
-            }, projectBaseDir);
+            this.resolveTopLevelEntries((globalSettings[resourceType] ?? []), resourceType, accumulator, { source: "local", scope: "user", origin: "top-level", baseDir: globalBase }, globalBase);
+            this.resolveTopLevelEntries((projectSettings[resourceType] ?? []), resourceType, accumulator, { source: "local", scope: "project", origin: "top-level", baseDir: projectBase }, projectBase);
         }
-        this.addAutoDiscoveredResources(accumulator, globalSettings, projectSettings, globalBaseDir, projectBaseDir);
+        this.addConventionalResources(accumulator, this.agentDir, { source: "local", scope: "user", origin: "top-level", baseDir: this.agentDir });
+        this.addConventionalResources(accumulator, join(this.cwd, CONFIG_DIR_NAME), {
+            source: "local",
+            scope: "project",
+            origin: "top-level",
+            baseDir: join(this.cwd, CONFIG_DIR_NAME),
+        });
         return this.toResolvedPaths(accumulator);
     }
     async resolveExtensionSources(sources, options) {
         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);
+        for (const source of sources) {
+            await this.resolvePackageSource(source, scope, accumulator);
+        }
         return this.toResolvedPaths(accumulator);
     }
     async install(source, options) {
         const parsed = this.parseSource(source);
         const scope = options?.local ? "project" : "user";
-        await this.withProgress("install", source, `Installing ${source}...`, async () => {
+        await this.withProgress("install", source, async () => {
             if (parsed.type === "npm") {
-                await this.installNpm(parsed, scope, false);
+                await this.installNpm(parsed, scope);
                 return;
             }
             if (parsed.type === "git") {
@@ -530,13 +207,13 @@ export class DefaultPackageManager {
     async remove(source, options) {
         const parsed = this.parseSource(source);
         const scope = options?.local ? "project" : "user";
-        await this.withProgress("remove", source, `Removing ${source}...`, async () => {
+        await this.withProgress("remove", source, async () => {
             if (parsed.type === "npm") {
                 await this.uninstallNpm(parsed, scope);
                 return;
             }
             if (parsed.type === "git") {
-                await this.removeGit(parsed, scope);
+                this.removeGit(parsed, scope);
                 return;
             }
             throw new Error(`Unsupported remove source: ${source}`);
@@ -550,239 +227,250 @@ export class DefaultPackageManager {
         }
         const globalSettings = this.settingsManager.getGlobalSettings();
         const projectSettings = this.settingsManager.getProjectSettings();
-        for (const extension of globalSettings.extensions ?? []) {
-            await this.updateSourceForScope(extension, "user");
+        for (const pkg of globalSettings.packages ?? []) {
+            await this.updateSourceForScope(typeof pkg === "string" ? pkg : pkg.source, "user");
         }
-        for (const extension of projectSettings.extensions ?? []) {
-            await this.updateSourceForScope(extension, "project");
+        for (const pkg of projectSettings.packages ?? []) {
+            await this.updateSourceForScope(typeof pkg === "string" ? pkg : pkg.source, "project");
         }
     }
-    async updateSourceForScope(source, scope) {
+    async resolvePackageSource(pkg, scope, accumulator, onMissing) {
+        const source = typeof pkg === "string" ? pkg : pkg.source;
+        const filter = typeof pkg === "string" ? undefined : pkg;
         const parsed = this.parseSource(source);
-        if (parsed.type === "npm") {
-            if (parsed.pinned)
+        const metadata = { source, scope, origin: "package" };
+        if (parsed.type === "local") {
+            const localPath = this.resolveLocalPath(parsed.path);
+            if (!existsSync(localPath)) {
                 return;
-            await this.withProgress("update", source, `Updating ${source}...`, async () => {
-                await this.installNpm(parsed, scope, false);
-            });
+            }
+            metadata.baseDir = statSync(localPath).isDirectory() ? localPath : dirname(localPath);
+            this.collectSourceResources(localPath, accumulator, filter, metadata);
             return;
         }
-        if (parsed.type === "git") {
-            if (parsed.pinned)
+        const installedPath = this.getInstalledPath(source, scope === "temporary" ? "project" : scope);
+        if (!installedPath) {
+            const action = onMissing ? await onMissing(source) : "install";
+            if (action === "skip") {
                 return;
-            await this.withProgress("update", source, `Updating ${source}...`, async () => {
-                await this.updateGit(parsed, scope);
-            });
+            }
+            if (action === "error") {
+                throw new Error(`Missing source: ${source}`);
+            }
+            await this.installParsedSource(parsed, scope);
+        }
+        const resolvedPath = this.getInstalledPath(source, scope === "temporary" ? "project" : scope);
+        if (!resolvedPath) {
             return;
         }
+        metadata.baseDir = resolvedPath;
+        this.collectSourceResources(resolvedPath, accumulator, filter, metadata);
     }
-    async resolvePackageSources(sources, accumulator, onMissing) {
-        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 metadata = { source: sourceStr, scope, origin: "package" };
-            if (parsed.type === "local") {
-                this.resolveLocalExtensionSource(parsed, accumulator, filter, metadata);
-                continue;
-            }
-            const installMissing = async () => {
-                if (!onMissing) {
-                    await this.installParsedSource(parsed, scope);
-                    return true;
-                }
-                const action = await onMissing(sourceStr);
-                if (action === "skip")
-                    return false;
-                if (action === "error")
-                    throw new Error(`Missing source: ${sourceStr}`);
-                await this.installParsedSource(parsed, scope);
-                return true;
-            };
-            if (parsed.type === "npm") {
-                const installedPath = this.getNpmInstallPath(parsed, scope);
-                const needsInstall = !existsSync(installedPath) || (await this.npmNeedsUpdate(parsed, installedPath));
-                if (needsInstall) {
-                    const installed = await installMissing();
-                    if (!installed)
-                        continue;
+    collectSourceResources(sourcePath, accumulator, filter, metadata) {
+        const stats = statSync(sourcePath);
+        if (stats.isFile()) {
+            this.addResource(accumulator.extensions, sourcePath, metadata, true);
+            return;
+        }
+        const manifest = readManifest(join(sourcePath, "package.json"));
+        const indusagiRoot = existsSync(join(sourcePath, ".indusagi")) ? join(sourcePath, ".indusagi") : sourcePath;
+        for (const resourceType of RESOURCE_TYPES) {
+            const configuredEntries = manifest?.[resourceType] ?? [];
+            const patterns = pickPatterns(filter, resourceType);
+            if (configuredEntries.length > 0) {
+                for (const entry of configuredEntries) {
+                    this.addResolvedEntry(resolve(sourcePath, entry), resourceType, accumulator, { ...metadata, baseDir: sourcePath }, patterns);
                 }
-                metadata.baseDir = installedPath;
-                this.collectPackageResources(installedPath, accumulator, filter, metadata);
                 continue;
             }
-            if (parsed.type === "git") {
-                const installedPath = this.getGitInstallPath(parsed, scope);
-                if (!existsSync(installedPath)) {
-                    const installed = await installMissing();
-                    if (!installed)
-                        continue;
-                }
-                metadata.baseDir = installedPath;
-                this.collectPackageResources(installedPath, accumulator, filter, metadata);
-            }
+            const conventionalDir = join(indusagiRoot, resourceType);
+            this.addResolvedEntry(conventionalDir, resourceType, accumulator, { ...metadata, baseDir: indusagiRoot }, patterns);
         }
     }
-    resolveLocalExtensionSource(source, accumulator, filter, metadata) {
-        const resolved = this.resolvePath(source.path);
-        if (!existsSync(resolved)) {
+    addResolvedEntry(entryPath, resourceType, accumulator, metadata, patterns) {
+        if (!existsSync(entryPath)) {
             return;
         }
-        try {
-            const stats = statSync(resolved);
-            if (stats.isFile()) {
-                metadata.baseDir = dirname(resolved);
-                this.addResource(accumulator.extensions, resolved, metadata, true);
-                return;
+        const stats = statSync(entryPath);
+        if (stats.isFile()) {
+            if (FILE_PATTERNS[resourceType].test(basename(entryPath)) && matchesFilter(entryPath, metadata.baseDir ?? dirname(entryPath), patterns)) {
+                this.addResource(this.getTargetMap(accumulator, resourceType), entryPath, metadata, true);
             }
-            if (stats.isDirectory()) {
-                metadata.baseDir = resolved;
-                const resources = this.collectPackageResources(resolved, accumulator, filter, metadata);
-                if (!resources) {
-                    this.addResource(accumulator.extensions, resolved, metadata, true);
-                }
+            return;
+        }
+        const files = this.collectResourceFiles(entryPath, resourceType);
+        for (const filePath of files) {
+            if (matchesFilter(filePath, metadata.baseDir ?? entryPath, patterns)) {
+                this.addResource(this.getTargetMap(accumulator, resourceType), filePath, metadata, true);
             }
         }
-        catch {
+    }
+    resolveTopLevelEntries(entries, resourceType, accumulator, metadata, baseDir) {
+        for (const entry of entries) {
+            if (!entry || entry.startsWith("!") || entry.startsWith("+") || entry.startsWith("-")) {
+                continue;
+            }
+            this.addResolvedEntry(resolve(baseDir, entry), resourceType, accumulator, metadata);
+        }
+    }
+    addConventionalResources(accumulator, baseDir, metadata) {
+        if (!existsSync(baseDir)) {
             return;
         }
+        for (const resourceType of RESOURCE_TYPES) {
+            this.addResolvedEntry(join(baseDir, resourceType), resourceType, accumulator, metadata);
+        }
+    }
+    collectResourceFiles(baseDir, resourceType) {
+        if (resourceType === "skills") {
+            return collectSkillEntries(baseDir);
+        }
+        return collectFiles(baseDir, FILE_PATTERNS[resourceType]);
+    }
+    addResource(target, resourcePath, metadata, enabled) {
+        if (!target.has(resourcePath)) {
+            target.set(resourcePath, { metadata: { ...metadata }, enabled });
+            return;
+        }
+        const existing = target.get(resourcePath);
+        if (metadata.scope === "project" && existing.metadata.scope === "user") {
+            target.set(resourcePath, { metadata: { ...metadata }, enabled });
+        }
+    }
+    getTargetMap(accumulator, resourceType) {
+        return accumulator[resourceType];
+    }
+    createAccumulator() {
+        return {
+            extensions: new Map(),
+            hooks: new Map(),
+            skills: new Map(),
+            prompts: new Map(),
+            themes: new Map(),
+        };
+    }
+    toResolvedPaths(accumulator) {
+        const toList = (map) => Array.from(map.entries()).map(([path, value]) => ({ path, enabled: value.enabled, metadata: value.metadata }));
+        return {
+            extensions: toList(accumulator.extensions),
+            hooks: toList(accumulator.hooks),
+            skills: toList(accumulator.skills),
+            prompts: toList(accumulator.prompts),
+            themes: toList(accumulator.themes),
+        };
+    }
+    async updateSourceForScope(source, scope) {
+        const parsed = this.parseSource(source);
+        if (parsed.type === "npm") {
+            if (parsed.pinned) {
+                return;
+            }
+            await this.withProgress("update", source, async () => {
+                await this.installNpm(parsed, scope);
+            });
+            return;
+        }
+        if (parsed.type === "git") {
+            if (parsed.pinned) {
+                return;
+            }
+            await this.withProgress("update", source, async () => {
+                await this.updateGit(parsed, scope);
+            });
+        }
     }
     async installParsedSource(parsed, scope) {
         if (parsed.type === "npm") {
-            await this.installNpm(parsed, scope, scope === "temporary");
+            await this.installNpm(parsed, scope);
             return;
         }
         if (parsed.type === "git") {
             await this.installGit(parsed, scope);
-            return;
         }
     }
     parseSource(source) {
         if (source.startsWith("npm:")) {
-            const spec = source.slice("npm:".length).trim();
+            const spec = source.slice(4).trim();
             const { name, version } = this.parseNpmSpec(spec);
-            return {
-                type: "npm",
-                spec,
-                name,
-                pinned: Boolean(version),
-            };
+            return { type: "npm", spec, name, pinned: Boolean(version) };
         }
         if (source.startsWith("git:") || looksLikeGitUrl(source)) {
-            const repoSpec = source.startsWith("git:") ? source.slice("git:".length).trim() : source;
+            const repoSpec = source.startsWith("git:") ? source.slice(4).trim() : source;
             const [repo, ref] = repoSpec.split("@");
             const normalized = repo.replace(/^https?:\/\//, "").replace(/\.git$/, "");
-            const parts = normalized.split("/");
-            const host = parts.shift() ?? "";
-            const repoPath = parts.join("/");
-            return {
-                type: "git",
-                repo: normalized,
-                host,
-                path: repoPath,
-                ref,
-                pinned: Boolean(ref),
-            };
+            return { type: "git", repo: normalized, ref, pinned: Boolean(ref) };
         }
         return { type: "local", path: source };
     }
-    /**
-     * Check if an npm package needs to be updated.
-     * - For unpinned packages: check if registry has a newer version
-     * - For pinned packages: check if installed version matches the pinned version
-     */
-    async npmNeedsUpdate(source, installedPath) {
-        const installedVersion = this.getInstalledNpmVersion(installedPath);
-        if (!installedVersion)
-            return true;
-        const { version: pinnedVersion } = this.parseNpmSpec(source.spec);
-        if (pinnedVersion) {
-            // Pinned: check if installed matches pinned (exact match for now)
-            return installedVersion !== pinnedVersion;
+    parseNpmSpec(spec) {
+        const match = spec.match(/^(@?[^@]+(?:\/[^@]+)?)(?:@(.+))?$/);
+        if (!match) {
+            return { name: spec };
         }
-        // Unpinned: check registry for latest version
+        return { name: match[1] ?? spec, version: match[2] };
+    }
+    resolveLocalPath(inputPath) {
+        return resolve(this.cwd, inputPath);
+    }
+    async withProgress(action, source, operation) {
+        this.progressCallback?.({ type: "start", action, source });
         try {
-            const latestVersion = await this.getLatestNpmVersion(source.name);
-            return latestVersion !== installedVersion;
+            await operation();
+            this.progressCallback?.({ type: "complete", action, source });
         }
-        catch {
-            // If we can't check registry, assume it's fine
-            return false;
+        catch (error) {
+            this.progressCallback?.({
+                type: "error",
+                action,
+                source,
+                message: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
         }
     }
-    getInstalledNpmVersion(installedPath) {
-        const packageJsonPath = join(installedPath, "package.json");
-        if (!existsSync(packageJsonPath))
-            return undefined;
-        try {
-            const content = readFileSync(packageJsonPath, "utf-8");
-            const pkg = JSON.parse(content);
-            return pkg.version;
+    getNpmInstallRoot(scope) {
+        if (scope === "project") {
+            return join(this.cwd, CONFIG_DIR_NAME, "packages", "node");
         }
-        catch {
-            return undefined;
+        if (scope === "temporary") {
+            const hash = createHash("sha1").update(this.cwd).digest("hex").slice(0, 12);
+            return join(tmpdir(), `indusagi-screth-packages-${hash}`);
         }
+        return this.agentDir;
     }
-    async getLatestNpmVersion(packageName) {
-        const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`);
-        if (!response.ok)
-            throw new Error(`Failed to fetch npm registry: ${response.status}`);
-        const data = (await response.json());
-        return data.version;
+    getProjectNpmNodeModules(scope) {
+        return join(this.getNpmInstallRoot(scope), "node_modules");
     }
-    /**
-     * Get a unique identity for a package, ignoring version/ref.
-     * Used to detect when the same package is in both global and project settings.
-     */
-    getPackageIdentity(source) {
-        const parsed = this.parseSource(source);
-        if (parsed.type === "npm") {
-            return `npm:${parsed.name}`;
-        }
-        if (parsed.type === "git") {
-            return `git:${parsed.repo}`;
+    getNpmInstallPath(source, scope) {
+        if (scope === "user") {
+            return join(this.getGlobalNpmRoot(), source.name);
         }
-        // For local paths, use the absolute resolved path
-        return `local:${this.resolvePath(parsed.path)}`;
+        return join(this.getProjectNpmNodeModules("project"), source.name);
     }
-    /**
-     * Dedupe packages: if same package identity appears in both global and project,
-     * keep only the project one (project wins).
-     */
-    dedupePackages(packages) {
-        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);
-            const existing = seen.get(identity);
-            if (!existing) {
-                seen.set(identity, entry);
-            }
-            else if (entry.scope === "project" && existing.scope === "user") {
-                // Project wins over user
-                seen.set(identity, entry);
+    getGlobalNpmRoot() {
+        if (this.globalNpmRoot) {
+            return this.globalNpmRoot;
+        }
+        let output = "";
+        try {
+            const result = spawnSync("npm", ["root", "-g"], { encoding: "utf-8" });
+            if (result.status === 0 && result.stdout.trim()) {
+                output = result.stdout.trim();
             }
-            // If existing is project and new is global, keep existing (project)
-            // If both are same scope, keep first one
         }
-        return Array.from(seen.values());
-    }
-    parseNpmSpec(spec) {
-        const match = spec.match(/^(@?[^@]+(?:\/[^@]+)?)(?:@(.+))?$/);
-        if (!match) {
-            return { name: spec };
+        catch {
+            // Ignore and fall back.
         }
-        const name = match[1] ?? spec;
-        const version = match[2];
-        return { name, version };
+        this.globalNpmRoot = output || join(this.agentDir, "node_modules");
+        return this.globalNpmRoot;
     }
-    async installNpm(source, scope, temporary) {
-        if (scope === "user" && !temporary) {
+    async installNpm(source, scope) {
+        if (scope === "user") {
             await this.runCommand("npm", ["install", "-g", source.spec]);
             return;
         }
-        const installRoot = this.getNpmInstallRoot(scope, temporary);
-        this.ensureNpmProject(installRoot);
+        const installRoot = this.getNpmInstallRoot(scope);
+        this.ensureNodeProject(installRoot);
         await this.runCommand("npm", ["install", source.spec, "--prefix", installRoot]);
     }
     async uninstallNpm(source, scope) {
@@ -790,432 +478,106 @@ export class DefaultPackageManager {
             await this.runCommand("npm", ["uninstall", "-g", source.name]);
             return;
         }
-        const installRoot = this.getNpmInstallRoot(scope, false);
+        const installRoot = this.getNpmInstallRoot(scope);
         if (!existsSync(installRoot)) {
             return;
         }
         await this.runCommand("npm", ["uninstall", source.name, "--prefix", installRoot]);
     }
+    getGitInstallPath(source, scope) {
+        const base = scope === "project" ? join(this.cwd, CONFIG_DIR_NAME, "packages", "git") : join(this.agentDir, "packages", "git");
+        const hash = createHash("sha1").update(source.repo).digest("hex").slice(0, 12);
+        const safeName = source.repo.split("/").pop() || "repo";
+        return join(base, `${safeName}-${hash}`);
+    }
     async installGit(source, scope) {
-        const targetDir = this.getGitInstallPath(source, scope);
+        const targetDir = this.getGitInstallPath(source, scope === "temporary" ? "project" : scope);
         if (existsSync(targetDir)) {
             return;
         }
-        const gitRoot = this.getGitInstallRoot(scope);
-        if (gitRoot) {
-            this.ensureGitIgnore(gitRoot);
-        }
         mkdirSync(dirname(targetDir), { recursive: true });
         const cloneUrl = source.repo.startsWith("http") ? source.repo : `https://${source.repo}`;
         await this.runCommand("git", ["clone", cloneUrl, targetDir]);
         if (source.ref) {
             await this.runCommand("git", ["checkout", source.ref], { cwd: targetDir });
         }
-        const packageJsonPath = join(targetDir, "package.json");
-        if (existsSync(packageJsonPath)) {
+        if (existsSync(join(targetDir, "package.json"))) {
             await this.runCommand("npm", ["install"], { cwd: targetDir });
         }
     }
     async updateGit(source, scope) {
-        const targetDir = this.getGitInstallPath(source, scope);
+        const targetDir = this.getGitInstallPath(source, scope === "temporary" ? "project" : scope);
         if (!existsSync(targetDir)) {
             await this.installGit(source, scope);
             return;
         }
         await this.runCommand("git", ["pull"], { cwd: targetDir });
-        const packageJsonPath = join(targetDir, "package.json");
-        if (existsSync(packageJsonPath)) {
+        if (existsSync(join(targetDir, "package.json"))) {
             await this.runCommand("npm", ["install"], { cwd: targetDir });
         }
     }
-    async removeGit(source, scope) {
-        const targetDir = this.getGitInstallPath(source, scope);
-        if (!existsSync(targetDir))
-            return;
-        rmSync(targetDir, { recursive: true, force: true });
-    }
-    ensureNpmProject(installRoot) {
-        if (!existsSync(installRoot)) {
-            mkdirSync(installRoot, { recursive: true });
-        }
-        this.ensureGitIgnore(installRoot);
-        const packageJsonPath = join(installRoot, "package.json");
-        if (!existsSync(packageJsonPath)) {
-            const pkgJson = { name: "indusagi-extensions", private: true };
-            writeFileSync(packageJsonPath, JSON.stringify(pkgJson, null, 2), "utf-8");
-        }
-    }
-    ensureGitIgnore(dir) {
-        if (!existsSync(dir)) {
-            mkdirSync(dir, { recursive: true });
-        }
-        const ignorePath = join(dir, ".gitignore");
-        if (!existsSync(ignorePath)) {
-            writeFileSync(ignorePath, "*\n!.gitignore\n", "utf-8");
-        }
-    }
-    getNpmInstallRoot(scope, temporary) {
-        if (temporary) {
-            return this.getTemporaryDir("npm");
-        }
-        if (scope === "project") {
-            return join(this.cwd, CONFIG_DIR_NAME, "npm");
-        }
-        return join(this.getGlobalNpmRoot(), "..");
-    }
-    getGlobalNpmRoot() {
-        if (this.globalNpmRoot) {
-            return this.globalNpmRoot;
-        }
-        const result = this.runCommandSync("npm", ["root", "-g"]);
-        this.globalNpmRoot = result.trim();
-        return this.globalNpmRoot;
-    }
-    getNpmInstallPath(source, scope) {
-        if (scope === "temporary") {
-            return join(this.getTemporaryDir("npm"), "node_modules", source.name);
-        }
-        if (scope === "project") {
-            return join(this.cwd, CONFIG_DIR_NAME, "npm", "node_modules", source.name);
-        }
-        return join(this.getGlobalNpmRoot(), source.name);
-    }
-    getGitInstallPath(source, scope) {
-        if (scope === "temporary") {
-            return this.getTemporaryDir(`git-${source.host}`, source.path);
-        }
-        if (scope === "project") {
-            return join(this.cwd, CONFIG_DIR_NAME, "git", source.host, source.path);
-        }
-        return join(this.agentDir, "git", source.host, source.path);
-    }
-    getGitInstallRoot(scope) {
-        if (scope === "temporary") {
-            return undefined;
-        }
-        if (scope === "project") {
-            return join(this.cwd, CONFIG_DIR_NAME, "git");
-        }
-        return join(this.agentDir, "git");
-    }
-    getTemporaryDir(prefix, suffix) {
-        const hash = createHash("sha256")
-            .update(`${prefix}-${suffix ?? ""}`)
-            .digest("hex")
-            .slice(0, 8);
-        return join(tmpdir(), "indusagi-extensions", prefix, hash, suffix ?? "");
-    }
-    resolvePath(input) {
-        const trimmed = input.trim();
-        if (trimmed === "~")
-            return homedir();
-        if (trimmed.startsWith("~/"))
-            return join(homedir(), trimmed.slice(2));
-        if (trimmed.startsWith("~"))
-            return join(homedir(), trimmed.slice(1));
-        return resolve(this.cwd, trimmed);
-    }
-    resolvePathFromBase(input, baseDir) {
-        const trimmed = input.trim();
-        if (trimmed === "~")
-            return homedir();
-        if (trimmed.startsWith("~/"))
-            return join(homedir(), trimmed.slice(2));
-        if (trimmed.startsWith("~"))
-            return join(homedir(), trimmed.slice(1));
-        return resolve(baseDir, trimmed);
-    }
-    collectPackageResources(packageRoot, accumulator, filter, metadata) {
-        if (filter) {
-            for (const resourceType of RESOURCE_TYPES) {
-                const patterns = filter[resourceType];
-                const target = this.getTargetMap(accumulator, resourceType);
-                if (patterns !== undefined) {
-                    this.applyPackageFilter(packageRoot, patterns, resourceType, target, metadata);
-                }
-                else {
-                    this.collectDefaultResources(packageRoot, resourceType, target, metadata);
-                }
-            }
-            return true;
-        }
-        const manifest = this.readIndusagiManifest(packageRoot);
-        if (manifest) {
-            for (const resourceType of RESOURCE_TYPES) {
-                const entries = manifest[resourceType];
-                this.addManifestEntries(entries, packageRoot, resourceType, this.getTargetMap(accumulator, resourceType), metadata);
-            }
-            return true;
-        }
-        let hasAnyDir = false;
-        for (const resourceType of RESOURCE_TYPES) {
-            const dir = join(packageRoot, resourceType);
-            if (existsSync(dir)) {
-                // Collect all files from the directory (all enabled by default)
-                const files = resourceType === "skills" ? collectSkillEntries(dir) : collectFiles(dir, FILE_PATTERNS[resourceType]);
-                for (const f of files) {
-                    this.addResource(this.getTargetMap(accumulator, resourceType), f, metadata, true);
-                }
-                hasAnyDir = true;
-            }
-        }
-        return hasAnyDir;
-    }
-    collectDefaultResources(packageRoot, resourceType, target, metadata) {
-        const manifest = this.readIndusagiManifest(packageRoot);
-        const entries = manifest?.[resourceType];
-        if (entries) {
-            this.addManifestEntries(entries, packageRoot, resourceType, target, metadata);
-            return;
-        }
-        const dir = join(packageRoot, resourceType);
-        if (existsSync(dir)) {
-            // Collect all files from the directory (all enabled by default)
-            const files = resourceType === "skills" ? collectSkillEntries(dir) : collectFiles(dir, FILE_PATTERNS[resourceType]);
-            for (const f of files) {
-                this.addResource(target, f, metadata, true);
-            }
-        }
-    }
-    applyPackageFilter(packageRoot, userPatterns, resourceType, target, metadata) {
-        const { allFiles, enabledByManifest } = this.collectManifestFiles(packageRoot, resourceType);
-        if (userPatterns.length === 0) {
-            // No user patterns, just use manifest filtering
-            for (const f of allFiles) {
-                this.addResource(target, f, metadata, enabledByManifest.has(f));
-            }
-            return;
-        }
-        // Apply user patterns on top of manifest-enabled files
-        const enabledByUser = applyPatterns(allFiles, userPatterns, packageRoot);
-        for (const f of allFiles) {
-            const enabled = enabledByUser.has(f);
-            this.addResource(target, f, 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
-     * that pass the manifest's own patterns.
-     */
-    collectManifestFiles(packageRoot, resourceType) {
-        const manifest = this.readIndusagiManifest(packageRoot);
-        const entries = manifest?.[resourceType];
-        if (entries && entries.length > 0) {
-            const allFiles = this.collectFilesFromManifestEntries(entries, packageRoot, resourceType);
-            const manifestPatterns = entries.filter(isPattern);
-            const enabledByManifest = manifestPatterns.length > 0 ? applyPatterns(allFiles, manifestPatterns, packageRoot) : new Set(allFiles);
-            return { allFiles: Array.from(enabledByManifest), enabledByManifest };
-        }
-        const conventionDir = join(packageRoot, resourceType);
-        if (!existsSync(conventionDir)) {
-            return { allFiles: [], enabledByManifest: new Set() };
+    removeGit(source, scope) {
+        const targetDir = this.getGitInstallPath(source, scope === "temporary" ? "project" : scope);
+        if (existsSync(targetDir)) {
+            rmSync(targetDir, { recursive: true, force: true });
         }
-        const allFiles = resourceType === "skills"
-            ? collectSkillEntries(conventionDir)
-            : collectFiles(conventionDir, FILE_PATTERNS[resourceType]);
-        return { allFiles, enabledByManifest: new Set(allFiles) };
     }
-    readIndusagiManifest(packageRoot) {
-        const packageJsonPath = join(packageRoot, "package.json");
+    ensureNodeProject(dir) {
+        mkdirSync(dir, { recursive: true });
+        const packageJsonPath = join(dir, "package.json");
         if (!existsSync(packageJsonPath)) {
-            return null;
-        }
-        try {
-            const content = readFileSync(packageJsonPath, "utf-8");
-            const pkg = JSON.parse(content);
-            return pkg.indusagi ?? null;
-        }
-        catch {
-            return null;
-        }
-    }
-    addManifestEntries(entries, root, resourceType, target, metadata) {
-        if (!entries)
-            return;
-        const allFiles = this.collectFilesFromManifestEntries(entries, root, resourceType);
-        const patterns = entries.filter(isPattern);
-        const enabledPaths = applyPatterns(allFiles, patterns, root);
-        for (const f of allFiles) {
-            if (enabledPaths.has(f)) {
-                this.addResource(target, f, metadata, true);
-            }
-        }
-    }
-    collectFilesFromManifestEntries(entries, root, resourceType) {
-        const plain = entries.filter((entry) => !isPattern(entry));
-        const resolved = plain.map((entry) => resolve(root, entry));
-        return this.collectFilesFromPaths(resolved, resourceType);
-    }
-    resolveLocalEntries(entries, resourceType, target, metadata, baseDir) {
-        if (entries.length === 0)
-            return;
-        // Collect all files from plain entries (non-pattern entries)
-        const { plain, patterns } = splitPatterns(entries);
-        const resolvedPlain = plain.map((p) => this.resolvePathFromBase(p, baseDir));
-        const allFiles = this.collectFilesFromPaths(resolvedPlain, resourceType);
-        // Determine which files are enabled based on patterns
-        const enabledPaths = applyPatterns(allFiles, patterns, baseDir);
-        // Add all files with their enabled state
-        for (const f of allFiles) {
-            this.addResource(target, f, metadata, enabledPaths.has(f));
+            writeFileSync(packageJsonPath, JSON.stringify({ name: "indusagi-screth-packages", private: true }, null, 2), "utf-8");
         }
     }
-    addAutoDiscoveredResources(accumulator, globalSettings, projectSettings, globalBaseDir, projectBaseDir) {
-        const userMetadata = {
-            source: "auto",
-            scope: "user",
-            origin: "top-level",
-            baseDir: globalBaseDir,
-        };
-        const projectMetadata = {
-            source: "auto",
-            scope: "project",
-            origin: "top-level",
-            baseDir: projectBaseDir,
-        };
-        const userOverrides = {
-            extensions: (globalSettings.extensions ?? []),
-            hooks: (globalSettings.hooks ?? []),
-            skills: (globalSettings.skills ?? []),
-            prompts: (globalSettings.prompts ?? []),
-            themes: (globalSettings.themes ?? []),
-        };
-        const projectOverrides = {
-            extensions: (projectSettings.extensions ?? []),
-            hooks: (projectSettings.hooks ?? []),
-            skills: (projectSettings.skills ?? []),
-            prompts: (projectSettings.prompts ?? []),
-            themes: (projectSettings.themes ?? []),
-        };
-        const userDirs = {
-            extensions: join(globalBaseDir, "extensions"),
-            hooks: join(globalBaseDir, "hooks"),
-            skills: join(globalBaseDir, "skills"),
-            prompts: join(globalBaseDir, "prompts"),
-            themes: join(globalBaseDir, "themes"),
-        };
-        const projectDirs = {
-            extensions: join(projectBaseDir, "extensions"),
-            hooks: join(projectBaseDir, "hooks"),
-            skills: join(projectBaseDir, "skills"),
-            prompts: join(projectBaseDir, "prompts"),
-            themes: join(projectBaseDir, "themes"),
-        };
-        const addResources = (resourceType, paths, metadata, overrides, baseDir) => {
-            const target = this.getTargetMap(accumulator, resourceType);
-            for (const path of paths) {
-                const enabled = isEnabledByOverrides(path, overrides, baseDir);
-                this.addResource(target, path, metadata, enabled);
-            }
-        };
-        addResources("extensions", collectAutoExtensionEntries(userDirs.extensions), userMetadata, userOverrides.extensions, globalBaseDir);
-        addResources("hooks", collectAutoHookEntries(userDirs.hooks), userMetadata, userOverrides.hooks, globalBaseDir);
-        addResources("skills", collectAutoSkillEntries(userDirs.skills), userMetadata, userOverrides.skills, globalBaseDir);
-        addResources("prompts", collectAutoPromptEntries(userDirs.prompts), userMetadata, userOverrides.prompts, globalBaseDir);
-        addResources("themes", collectAutoThemeEntries(userDirs.themes), userMetadata, userOverrides.themes, globalBaseDir);
-        addResources("extensions", collectAutoExtensionEntries(projectDirs.extensions), projectMetadata, projectOverrides.extensions, projectBaseDir);
-        addResources("hooks", collectAutoHookEntries(projectDirs.hooks), projectMetadata, projectOverrides.hooks, projectBaseDir);
-        addResources("skills", collectAutoSkillEntries(projectDirs.skills), projectMetadata, projectOverrides.skills, projectBaseDir);
-        addResources("prompts", collectAutoPromptEntries(projectDirs.prompts), projectMetadata, projectOverrides.prompts, projectBaseDir);
-        addResources("themes", collectAutoThemeEntries(projectDirs.themes), projectMetadata, projectOverrides.themes, projectBaseDir);
-    }
-    collectFilesFromPaths(paths, resourceType) {
-        const files = [];
-        for (const p of paths) {
-            if (!existsSync(p))
-                continue;
-            try {
-                const stats = statSync(p);
-                if (stats.isFile()) {
-                    files.push(p);
-                }
-                else if (stats.isDirectory()) {
-                    if (resourceType === "skills") {
-                        files.push(...collectSkillEntries(p));
-                    }
-                    else {
-                        files.push(...collectFiles(p, FILE_PATTERNS[resourceType]));
-                    }
-                }
-            }
-            catch {
-                // Ignore errors
-            }
-        }
-        return files;
-    }
-    getTargetMap(accumulator, resourceType) {
-        switch (resourceType) {
-            case "extensions":
-                return accumulator.extensions;
-            case "hooks":
-                return accumulator.hooks;
-            case "skills":
-                return accumulator.skills;
-            case "prompts":
-                return accumulator.prompts;
-            case "themes":
-                return accumulator.themes;
-            default:
-                throw new Error(`Unknown resource type: ${resourceType}`);
-        }
-    }
-    addResource(map, path, metadata, enabled) {
-        if (!path)
-            return;
-        if (!map.has(path)) {
-            map.set(path, { metadata, enabled });
-        }
-    }
-    createAccumulator() {
-        return {
-            extensions: new Map(),
-            hooks: new Map(),
-            skills: new Map(),
-            prompts: new Map(),
-            themes: new Map(),
-        };
-    }
-    toResolvedPaths(accumulator) {
-        const toResolved = (entries) => {
-            return Array.from(entries.entries()).map(([path, { metadata, enabled }]) => ({
-                path,
-                enabled,
-                metadata,
-            }));
-        };
-        return {
-            extensions: toResolved(accumulator.extensions),
-            hooks: toResolved(accumulator.hooks),
-            skills: toResolved(accumulator.skills),
-            prompts: toResolved(accumulator.prompts),
-            themes: toResolved(accumulator.themes),
-        };
-    }
-    runCommand(command, args, options) {
-        return new Promise((resolvePromise, reject) => {
+    async runCommand(command, args, options) {
+        await new Promise((resolvePromise, rejectPromise) => {
             const child = spawn(command, args, {
-                cwd: options?.cwd,
-                stdio: "inherit",
+                cwd: options?.cwd ?? this.cwd,
+                stdio: ["ignore", "pipe", "pipe"],
             });
-            child.on("error", reject);
-            child.on("exit", (code) => {
+            let stderr = "";
+            child.stderr?.on("data", (data) => {
+                stderr += data.toString();
+                this.progressCallback?.({
+                    type: "progress",
+                    action: command === "git" && args[0] === "clone" ? "clone" : command === "git" ? "pull" : "install",
+                    source: args.join(" "),
+                    message: data.toString().trim(),
+                });
+            });
+            child.on("close", (code) => {
                 if (code === 0) {
                     resolvePromise();
+                    return;
                 }
-                else {
-                    reject(new Error(`${command} ${args.join(" ")} failed with code ${code}`));
-                }
+                rejectPromise(new Error(stderr.trim() || `${command} ${args.join(" ")} failed with code ${code}`));
+            });
+            child.on("error", (error) => {
+                rejectPromise(error);
             });
         });
     }
-    runCommandSync(command, args) {
-        const result = spawnSync(command, args, { stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" });
-        if (result.status !== 0) {
-            throw new Error(`Failed to run ${command} ${args.join(" ")}: ${result.stderr || result.stdout}`);
+    getPackageIdentity(source) {
+        const parsed = this.parseSource(source);
+        if (parsed.type === "npm") {
+            return `npm:${parsed.name}`;
+        }
+        if (parsed.type === "git") {
+            return `git:${parsed.repo}`;
+        }
+        return `local:${this.resolveLocalPath(parsed.path)}`;
+    }
+    dedupePackages(packages) {
+        const seen = new Map();
+        for (const entry of packages) {
+            const source = typeof entry.pkg === "string" ? entry.pkg : entry.pkg.source;
+            const identity = this.getPackageIdentity(source);
+            const existing = seen.get(identity);
+            if (!existing || (entry.scope === "project" && existing.scope === "user")) {
+                seen.set(identity, entry);
+            }
         }
-        return (result.stdout || result.stderr || "").trim();
+        return Array.from(seen.values());
     }
 }
 //# sourceMappingURL=package-manager.js.map