@hyperspaceng/neural-coding-agent 0.62.1 → 0.63.2

package/dist/core/package-manager.js

@@ -7,6 +7,7 @@ import ignore from "ignore";
 import { minimatch } from "minimatch";
 import { CONFIG_DIR_NAME } from "../config.js";
 import { parseGitUrl } from "../utils/git.js";
+import { isStdoutTakenOver } from "./output-guard.js";
 const NETWORK_TIMEOUT_MS = 10000;
 const UPDATE_CHECK_CONCURRENCY = 4;
 function isOfflineModeEnabled() {
@@ -130,7 +131,7 @@ function collectFiles(dir, filePattern, skipNodeModules = true, ignoreMatcher, r
     }
     return files;
 }
-function collectSkillEntries(dir, includeRootFiles = true, ignoreMatcher, rootDir) {
+function collectSkillEntries(dir, mode, ignoreMatcher, rootDir) {
     const entries = [];
     if (!existsSync(dir))
         return entries;
@@ -139,6 +140,26 @@ function collectSkillEntries(dir, includeRootFiles = true, ignoreMatcher, rootDi
     addIgnoreRules(ig, dir, root);
     try {
         const dirEntries = readdirSync(dir, { withFileTypes: true });
+        for (const entry of dirEntries) {
+            if (entry.name !== "SKILL.md") {
+                continue;
+            }
+            const fullPath = join(dir, entry.name);
+            let isFile = entry.isFile();
+            if (entry.isSymbolicLink()) {
+                try {
+                    isFile = statSync(fullPath).isFile();
+                }
+                catch {
+                    continue;
+                }
+            }
+            const relPath = toPosixPath(relative(root, fullPath));
+            if (isFile && !ig.ignores(relPath)) {
+                entries.push(fullPath);
+                return entries;
+            }
+        }
         for (const entry of dirEntries) {
             if (entry.name.startsWith("."))
                 continue;
@@ -158,19 +179,15 @@ function collectSkillEntries(dir, includeRootFiles = true, ignoreMatcher, rootDi
                 }
             }
             const relPath = toPosixPath(relative(root, fullPath));
-            const ignorePath = isDir ? `${relPath}/` : relPath;
-            if (ig.ignores(ignorePath))
+            if (mode === "pi" && dir === root && isFile && entry.name.endsWith(".md") && !ig.ignores(relPath)) {
+                entries.push(fullPath);
                 continue;
-            if (isDir) {
-                entries.push(...collectSkillEntries(fullPath, false, ig, root));
-            }
-            else if (isFile) {
-                const isRootMd = includeRootFiles && entry.name.endsWith(".md");
-                const isSkillMd = !includeRootFiles && entry.name === "SKILL.md";
-                if (isRootMd || isSkillMd) {
-                    entries.push(fullPath);
-                }
             }
+            if (!isDir)
+                continue;
+            if (ig.ignores(`${relPath}/`))
+                continue;
+            entries.push(...collectSkillEntries(fullPath, mode, ig, root));
         }
     }
     catch {
@@ -178,8 +195,8 @@ function collectSkillEntries(dir, includeRootFiles = true, ignoreMatcher, rootDi
     }
     return entries;
 }
-function collectAutoSkillEntries(dir, includeRootFiles = true) {
-    return collectSkillEntries(dir, includeRootFiles);
+function collectAutoSkillEntries(dir, mode) {
+    return collectSkillEntries(dir, mode);
 }
 function findGitRepoRoot(startDir) {
     let dir = resolve(startDir);
@@ -379,7 +396,7 @@ function collectAutoExtensionEntries(dir) {
  */
 function collectResourceFiles(dir, resourceType) {
     if (resourceType === "skills") {
-        return collectSkillEntries(dir);
+        return collectSkillEntries(dir, "pi");
     }
     if (resourceType === "extensions") {
         return collectAutoExtensionEntries(dir);
@@ -674,18 +691,27 @@ export class DefaultPackageManager {
         const globalSettings = this.settingsManager.getGlobalSettings();
         const projectSettings = this.settingsManager.getProjectSettings();
         const identity = source ? this.getPackageIdentity(source) : undefined;
+        let matched = false;
         for (const pkg of globalSettings.packages ?? []) {
             const sourceStr = typeof pkg === "string" ? pkg : pkg.source;
             if (identity && this.getPackageIdentity(sourceStr, "user") !== identity)
                 continue;
+            matched = true;
             await this.updateSourceForScope(sourceStr, "user");
         }
         for (const pkg of projectSettings.packages ?? []) {
             const sourceStr = typeof pkg === "string" ? pkg : pkg.source;
             if (identity && this.getPackageIdentity(sourceStr, "project") !== identity)
                 continue;
+            matched = true;
             await this.updateSourceForScope(sourceStr, "project");
         }
+        if (source && !matched) {
+            throw new Error(this.buildNoMatchingPackageMessage(source, [
+                ...(globalSettings.packages ?? []),
+                ...(projectSettings.packages ?? []),
+            ]));
+        }
     }
     async updateSourceForScope(source, scope) {
         if (isOfflineModeEnabled()) {
@@ -696,7 +722,10 @@ export class DefaultPackageManager {
             if (parsed.pinned)
                 return;
             await this.withProgress("update", source, `Updating ${source}...`, async () => {
-                await this.installNpm(parsed, scope, false);
+                await this.installNpm({
+                    ...parsed,
+                    spec: `${parsed.name}@latest`,
+                }, scope, false);
             });
             return;
         }
@@ -878,6 +907,35 @@ export class DefaultPackageManager {
         const baseDir = this.getBaseDirForScope(scope);
         return `local:${this.resolvePathFromBase(parsed.path, baseDir)}`;
     }
+    buildNoMatchingPackageMessage(source, configuredPackages) {
+        const suggestion = this.findSuggestedConfiguredSource(source, configuredPackages);
+        if (!suggestion) {
+            return `No matching package found for ${source}`;
+        }
+        return `No matching package found for ${source}. Did you mean ${suggestion}?`;
+    }
+    findSuggestedConfiguredSource(source, configuredPackages) {
+        const trimmedSource = source.trim();
+        const suggestions = new Set();
+        for (const pkg of configuredPackages) {
+            const sourceStr = this.getPackageSourceString(pkg);
+            const parsed = this.parseSource(sourceStr);
+            if (parsed.type === "npm") {
+                if (trimmedSource === parsed.name || trimmedSource === parsed.spec) {
+                    suggestions.add(sourceStr);
+                }
+                continue;
+            }
+            if (parsed.type === "git") {
+                const shorthand = `${parsed.host}/${parsed.path}`;
+                const shorthandWithRef = parsed.ref ? `${shorthand}@${parsed.ref}` : undefined;
+                if (trimmedSource === shorthand || (shorthandWithRef && trimmedSource === shorthandWithRef)) {
+                    suggestions.add(sourceStr);
+                }
+            }
+        }
+        return suggestions.values().next().value;
+    }
     packageSourcesMatch(existing, inputSource, scope) {
         const left = this.getSourceMatchKeyForSettings(this.getPackageSourceString(existing), scope);
         const right = this.getSourceMatchKeyForInput(inputSource);
@@ -1002,6 +1060,67 @@ export class DefaultPackageManager {
         }
         return match[1];
     }
+    async getLocalGitUpdateTarget(installedPath) {
+        try {
+            const upstream = await this.runCommandCapture("git", ["rev-parse", "--abbrev-ref", "@{upstream}"], {
+                cwd: installedPath,
+                timeoutMs: NETWORK_TIMEOUT_MS,
+            });
+            const trimmedUpstream = upstream.trim();
+            if (!trimmedUpstream.startsWith("origin/")) {
+                throw new Error(`Unsupported upstream remote: ${trimmedUpstream}`);
+            }
+            const branch = trimmedUpstream.slice("origin/".length);
+            if (!branch) {
+                throw new Error("Missing upstream branch name");
+            }
+            const head = await this.runCommandCapture("git", ["rev-parse", "@{upstream}"], {
+                cwd: installedPath,
+                timeoutMs: NETWORK_TIMEOUT_MS,
+            });
+            return {
+                ref: "@{upstream}",
+                head,
+                fetchArgs: [
+                    "fetch",
+                    "--prune",
+                    "--no-tags",
+                    "origin",
+                    `+refs/heads/${branch}:refs/remotes/origin/${branch}`,
+                ],
+            };
+        }
+        catch {
+            await this.runCommand("git", ["remote", "set-head", "origin", "-a"], { cwd: installedPath }).catch(() => { });
+            const head = await this.runCommandCapture("git", ["rev-parse", "origin/HEAD"], {
+                cwd: installedPath,
+                timeoutMs: NETWORK_TIMEOUT_MS,
+            });
+            const originHeadRef = await this.runCommandCapture("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
+                cwd: installedPath,
+                timeoutMs: NETWORK_TIMEOUT_MS,
+            }).catch(() => "");
+            const branch = originHeadRef.trim().replace(/^refs\/remotes\/origin\//, "");
+            if (branch) {
+                return {
+                    ref: "origin/HEAD",
+                    head,
+                    fetchArgs: [
+                        "fetch",
+                        "--prune",
+                        "--no-tags",
+                        "origin",
+                        `+refs/heads/${branch}:refs/remotes/origin/${branch}`,
+                    ],
+                };
+            }
+            return {
+                ref: "origin/HEAD",
+                head,
+                fetchArgs: ["fetch", "--prune", "--no-tags", "origin", "+HEAD:refs/remotes/origin/HEAD"],
+            };
+        }
+    }
     async getGitUpstreamRef(installedPath) {
         try {
             const upstream = await this.runCommandCapture("git", ["rev-parse", "--abbrev-ref", "@{upstream}"], {
@@ -1164,16 +1283,21 @@ export class DefaultPackageManager {
             await this.installGit(source, scope);
             return;
         }
-        // Fetch latest from remote (handles force-push by getting new history)
-        await this.runCommand("git", ["fetch", "--prune", "origin"], { 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 });
+        const target = await this.getLocalGitUpdateTarget(targetDir);
+        // Fetch only the ref we will reset to, avoiding unrelated branch/tag noise.
+        await this.runCommand("git", target.fetchArgs, { cwd: targetDir });
+        const localHead = await this.runCommandCapture("git", ["rev-parse", "HEAD"], {
+            cwd: targetDir,
+            timeoutMs: NETWORK_TIMEOUT_MS,
+        });
+        const refreshedTargetHead = await this.runCommandCapture("git", ["rev-parse", target.ref], {
+            cwd: targetDir,
+            timeoutMs: NETWORK_TIMEOUT_MS,
+        });
+        if (localHead.trim() === refreshedTargetHead.trim()) {
+            return;
         }
+        await this.runCommand("git", ["reset", "--hard", target.ref], { cwd: targetDir });
         // Clean untracked files (extensions should be pristine)
         await this.runCommand("git", ["clean", "-fdx"], { cwd: targetDir });
         const packageJsonPath = join(targetDir, "package.json");
@@ -1509,13 +1633,13 @@ export class DefaultPackageManager {
         };
         addResources("extensions", collectAutoExtensionEntries(projectDirs.extensions), projectMetadata, projectOverrides.extensions, projectBaseDir);
         addResources("skills", [
-            ...collectAutoSkillEntries(projectDirs.skills),
-            ...projectAgentsSkillDirs.flatMap((dir) => collectAutoSkillEntries(dir)),
+            ...collectAutoSkillEntries(projectDirs.skills, "pi"),
+            ...projectAgentsSkillDirs.flatMap((dir) => collectAutoSkillEntries(dir, "agents")),
         ], projectMetadata, projectOverrides.skills, projectBaseDir);
         addResources("prompts", collectAutoPromptEntries(projectDirs.prompts), projectMetadata, projectOverrides.prompts, projectBaseDir);
         addResources("themes", collectAutoThemeEntries(projectDirs.themes), projectMetadata, projectOverrides.themes, projectBaseDir);
         addResources("extensions", collectAutoExtensionEntries(userDirs.extensions), userMetadata, userOverrides.extensions, globalBaseDir);
-        addResources("skills", [...collectAutoSkillEntries(userDirs.skills), ...collectAutoSkillEntries(userAgentsSkillsDir)], userMetadata, userOverrides.skills, globalBaseDir);
+        addResources("skills", [...collectAutoSkillEntries(userDirs.skills, "pi"), ...collectAutoSkillEntries(userAgentsSkillsDir, "agents")], userMetadata, userOverrides.skills, globalBaseDir);
         addResources("prompts", collectAutoPromptEntries(userDirs.prompts), userMetadata, userOverrides.prompts, globalBaseDir);
         addResources("themes", collectAutoThemeEntries(userDirs.themes), userMetadata, userOverrides.themes, globalBaseDir);
     }
@@ -1630,7 +1754,7 @@ export class DefaultPackageManager {
         return new Promise((resolvePromise, reject) => {
             const child = spawn(command, args, {
                 cwd: options?.cwd,
-                stdio: "inherit",
+                stdio: isStdoutTakenOver() ? ["ignore", 2, 2] : "inherit",
                 shell: process.platform === "win32",
             });
             child.on("error", reject);