@vandeepunk/pi-coding-agent 0.0.2 → 0.0.4

package/dist/core/package-manager.js

@@ -6,12 +6,12 @@ import { basename, dirname, join, relative, resolve, sep } from "node:path";
 import ignore from "ignore";
 import { minimatch } from "minimatch";
 import { CONFIG_DIR_NAME } from "../config.js";
-import { looksLikeGitUrl } from "../utils/git.js";
-const RESOURCE_TYPES = ["extensions", "skills", "prompts", "themes"];
+import { parseGitUrl } from "../utils/git.js";
+const RESOURCE_TYPES = ["extensions", "skills", "commands", "themes"];
 const FILE_PATTERNS = {
     extensions: /\.(ts|js)$/,
     skills: /\.md$/,
-    prompts: /\.md$/,
+    commands: /\.md$/,
     themes: /\.json$/,
 };
 const IGNORE_FILE_NAMES = [".gitignore", ".ignore", ".fdignore"];
@@ -283,6 +283,12 @@ function collectAutoExtensionEntries(dir) {
     const entries = [];
     if (!existsSync(dir))
         return entries;
+    // First check if this directory itself has explicit extension entries (package.json or index)
+    const rootEntries = resolveExtensionEntries(dir);
+    if (rootEntries) {
+        return rootEntries;
+    }
+    // Otherwise, discover extensions from directory contents
     const ig = ignore();
     addIgnoreRules(ig, dir, dir);
     try {
@@ -465,6 +471,41 @@ export class DefaultPackageManager {
     setProgressCallback(callback) {
         this.progressCallback = callback;
     }
+    addSourceToSettings(source, options) {
+        const scope = options?.local ? "project" : "user";
+        const currentSettings = scope === "project" ? this.settingsManager.getProjectSettings() : this.settingsManager.getGlobalSettings();
+        const currentPackages = currentSettings.packages ?? [];
+        const normalizedSource = this.normalizePackageSourceForSettings(source, scope);
+        const exists = currentPackages.some((existing) => this.packageSourcesMatch(existing, source, scope));
+        if (exists) {
+            return false;
+        }
+        const nextPackages = [...currentPackages, normalizedSource];
+        if (scope === "project") {
+            this.settingsManager.setProjectPackages(nextPackages);
+        }
+        else {
+            this.settingsManager.setPackages(nextPackages);
+        }
+        return true;
+    }
+    removeSourceFromSettings(source, options) {
+        const scope = options?.local ? "project" : "user";
+        const currentSettings = scope === "project" ? this.settingsManager.getProjectSettings() : this.settingsManager.getGlobalSettings();
+        const currentPackages = currentSettings.packages ?? [];
+        const nextPackages = currentPackages.filter((existing) => !this.packageSourcesMatch(existing, source, scope));
+        const changed = nextPackages.length !== currentPackages.length;
+        if (!changed) {
+            return false;
+        }
+        if (scope === "project") {
+            this.settingsManager.setProjectPackages(nextPackages);
+        }
+        else {
+            this.settingsManager.setPackages(nextPackages);
+        }
+        return true;
+    }
     getInstalledPath(source, scope) {
         const parsed = this.parseSource(source);
         if (parsed.type === "npm") {
@@ -658,6 +699,9 @@ export class DefaultPackageManager {
                     if (!installed)
                         continue;
                 }
+                else if (scope === "temporary" && !parsed.pinned) {
+                    await this.refreshTemporaryGitSource(parsed, sourceStr);
+                }
                 metadata.baseDir = installedPath;
                 this.collectPackageResources(installedPath, accumulator, filter, metadata);
             }
@@ -697,6 +741,45 @@ export class DefaultPackageManager {
             return;
         }
     }
+    getPackageSourceString(pkg) {
+        return typeof pkg === "string" ? pkg : pkg.source;
+    }
+    getSourceMatchKeyForInput(source) {
+        const parsed = this.parseSource(source);
+        if (parsed.type === "npm") {
+            return `npm:${parsed.name}`;
+        }
+        if (parsed.type === "git") {
+            return `git:${parsed.host}/${parsed.path}`;
+        }
+        return `local:${this.resolvePath(parsed.path)}`;
+    }
+    getSourceMatchKeyForSettings(source, scope) {
+        const parsed = this.parseSource(source);
+        if (parsed.type === "npm") {
+            return `npm:${parsed.name}`;
+        }
+        if (parsed.type === "git") {
+            return `git:${parsed.host}/${parsed.path}`;
+        }
+        const baseDir = this.getBaseDirForScope(scope);
+        return `local:${this.resolvePathFromBase(parsed.path, baseDir)}`;
+    }
+    packageSourcesMatch(existing, inputSource, scope) {
+        const left = this.getSourceMatchKeyForSettings(this.getPackageSourceString(existing), scope);
+        const right = this.getSourceMatchKeyForInput(inputSource);
+        return left === right;
+    }
+    normalizePackageSourceForSettings(source, scope) {
+        const parsed = this.parseSource(source);
+        if (parsed.type !== "local") {
+            return source;
+        }
+        const baseDir = this.getBaseDirForScope(scope);
+        const resolved = this.resolvePath(parsed.path);
+        const rel = relative(baseDir, resolved);
+        return rel || ".";
+    }
     parseSource(source) {
         if (source.startsWith("npm:")) {
             const spec = source.slice("npm:".length).trim();
@@ -708,21 +791,21 @@ export class DefaultPackageManager {
                 pinned: Boolean(version),
             };
         }
-        if (source.startsWith("git:") || looksLikeGitUrl(source)) {
-            const repoSpec = source.startsWith("git:") ? source.slice("git:".length).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),
-            };
+        const trimmed = source.trim();
+        const isWindowsAbsolutePath = /^[A-Za-z]:[\\/]|^\\\\/.test(trimmed);
+        const isLocalPathLike = trimmed.startsWith("./") ||
+            trimmed.startsWith("../") ||
+            trimmed.startsWith("/") ||
+            trimmed === "~" ||
+            trimmed.startsWith("~/") ||
+            isWindowsAbsolutePath;
+        if (isLocalPathLike) {
+            return { type: "local", path: source };
+        }
+        // Try parsing as git URL
+        const gitParsed = parseGitUrl(source);
+        if (gitParsed) {
+            return gitParsed;
         }
         return { type: "local", path: source };
     }
@@ -773,6 +856,8 @@ export class DefaultPackageManager {
     /**
      * Get a unique identity for a package, ignoring version/ref.
      * Used to detect when the same package is in both global and project settings.
+     * For git packages, uses normalized host/path to ensure SSH and HTTPS URLs
+     * for the same repository are treated as identical.
      */
     getPackageIdentity(source, scope) {
         const parsed = this.parseSource(source);
@@ -780,7 +865,8 @@ export class DefaultPackageManager {
             return `npm:${parsed.name}`;
         }
         if (parsed.type === "git") {
-            return `git:${parsed.repo}`;
+            // Use host/path for identity to normalize SSH and HTTPS
+            return `git:${parsed.host}/${parsed.path}`;
         }
         if (scope) {
             const baseDir = this.getBaseDirForScope(scope);
@@ -849,8 +935,7 @@ export class DefaultPackageManager {
             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]);
+        await this.runCommand("git", ["clone", source.repo, targetDir]);
         if (source.ref) {
             await this.runCommand("git", ["checkout", source.ref], { cwd: targetDir });
         }
@@ -867,8 +952,14 @@ export class DefaultPackageManager {
         }
         // Fetch latest from remote (handles force-push by getting new history)
         await this.runCommand("git", ["fetch", "--prune", "origin"], { cwd: targetDir });
-        // Reset to upstream tracking branch (handles force-push gracefully)
-        await this.runCommand("git", ["reset", "--hard", "@{upstream}"], { cwd: targetDir });
+        // Reset to tracking branch. Fall back to origin/HEAD when no upstream is configured.
+        try {
+            await this.runCommand("git", ["reset", "--hard", "@{upstream}"], { cwd: targetDir });
+        }
+        catch {
+            await this.runCommand("git", ["remote", "set-head", "origin", "-a"], { cwd: targetDir }).catch(() => { });
+            await this.runCommand("git", ["reset", "--hard", "origin/HEAD"], { cwd: targetDir });
+        }
         // Clean untracked files (extensions should be pristine)
         await this.runCommand("git", ["clean", "-fdx"], { cwd: targetDir });
         const packageJsonPath = join(targetDir, "package.json");
@@ -876,6 +967,16 @@ export class DefaultPackageManager {
             await this.runCommand("npm", ["install"], { cwd: targetDir });
         }
     }
+    async refreshTemporaryGitSource(source, sourceStr) {
+        try {
+            await this.withProgress("pull", sourceStr, `Refreshing ${sourceStr}...`, async () => {
+                await this.updateGit(source, "temporary");
+            });
+        }
+        catch {
+            // Keep cached temporary checkout if refresh fails.
+        }
+    }
     async removeGit(source, scope) {
         const targetDir = this.getGitInstallPath(source, scope);
         if (!existsSync(targetDir))
@@ -1156,25 +1257,25 @@ export class DefaultPackageManager {
         const userOverrides = {
             extensions: (globalSettings.extensions ?? []),
             skills: (globalSettings.skills ?? []),
-            prompts: (globalSettings.prompts ?? []),
+            commands: (globalSettings.commands ?? []),
             themes: (globalSettings.themes ?? []),
         };
         const projectOverrides = {
             extensions: (projectSettings.extensions ?? []),
             skills: (projectSettings.skills ?? []),
-            prompts: (projectSettings.prompts ?? []),
+            commands: (projectSettings.commands ?? []),
             themes: (projectSettings.themes ?? []),
         };
         const userDirs = {
             extensions: join(globalBaseDir, "extensions"),
             skills: join(globalBaseDir, "skills"),
-            prompts: join(globalBaseDir, "prompts"),
+            commands: join(globalBaseDir, "commands"),
             themes: join(globalBaseDir, "themes"),
         };
         const projectDirs = {
             extensions: join(projectBaseDir, "extensions"),
             skills: join(projectBaseDir, "skills"),
-            prompts: join(projectBaseDir, "prompts"),
+            commands: join(projectBaseDir, "commands"),
             themes: join(projectBaseDir, "themes"),
         };
         const addResources = (resourceType, paths, metadata, overrides, baseDir) => {
@@ -1186,11 +1287,11 @@ export class DefaultPackageManager {
         };
         addResources("extensions", collectAutoExtensionEntries(userDirs.extensions), userMetadata, userOverrides.extensions, globalBaseDir);
         addResources("skills", collectAutoSkillEntries(userDirs.skills), userMetadata, userOverrides.skills, globalBaseDir);
-        addResources("prompts", collectAutoPromptEntries(userDirs.prompts), userMetadata, userOverrides.prompts, globalBaseDir);
+        addResources("commands", collectAutoPromptEntries(userDirs.commands), userMetadata, userOverrides.commands, globalBaseDir);
         addResources("themes", collectAutoThemeEntries(userDirs.themes), userMetadata, userOverrides.themes, globalBaseDir);
         addResources("extensions", collectAutoExtensionEntries(projectDirs.extensions), projectMetadata, projectOverrides.extensions, projectBaseDir);
         addResources("skills", collectAutoSkillEntries(projectDirs.skills), projectMetadata, projectOverrides.skills, projectBaseDir);
-        addResources("prompts", collectAutoPromptEntries(projectDirs.prompts), projectMetadata, projectOverrides.prompts, projectBaseDir);
+        addResources("commands", collectAutoPromptEntries(projectDirs.commands), projectMetadata, projectOverrides.commands, projectBaseDir);
         addResources("themes", collectAutoThemeEntries(projectDirs.themes), projectMetadata, projectOverrides.themes, projectBaseDir);
     }
     collectFilesFromPaths(paths, resourceType) {
@@ -1219,8 +1320,8 @@ export class DefaultPackageManager {
                 return accumulator.extensions;
             case "skills":
                 return accumulator.skills;
-            case "prompts":
-                return accumulator.prompts;
+            case "commands":
+                return accumulator.commands;
             case "themes":
                 return accumulator.themes;
             default:
@@ -1238,7 +1339,7 @@ export class DefaultPackageManager {
         return {
             extensions: new Map(),
             skills: new Map(),
-            prompts: new Map(),
+            commands: new Map(),
             themes: new Map(),
         };
     }
@@ -1253,7 +1354,7 @@ export class DefaultPackageManager {
         return {
             extensions: toResolved(accumulator.extensions),
             skills: toResolved(accumulator.skills),
-            prompts: toResolved(accumulator.prompts),
+            commands: toResolved(accumulator.commands),
             themes: toResolved(accumulator.themes),
         };
     }