@opengoat/core 2026.2.20 → 2026.2.23

package/dist/core/skills/application/skill.service.js

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import os from "node:os";
 import path from "node:path";
 import { BOARD_MANAGER_SKILL_ID } from "../../agents/domain/agent-manifest.js";
@@ -6,9 +7,11 @@ import { resolveSkillsConfig, } from "../domain/skill.js";
 export class SkillService {
     fileSystem;
     pathPort;
+    commandRunner;
     constructor(deps) {
         this.fileSystem = deps.fileSystem;
         this.pathPort = deps.pathPort;
+        this.commandRunner = deps.commandRunner;
     }
     async listSkills(paths, agentId = DEFAULT_AGENT_ID, runtimeConfig) {
         const normalizedAgentId = normalizeAgentId(agentId) || DEFAULT_AGENT_ID;
@@ -17,7 +20,7 @@ export class SkillService {
         if (!resolvedConfig.enabled) {
             return [];
         }
-        const discovered = await this.loadSkillsWithPrecedence(paths, resolvedConfig);
+        const discovered = await this.loadSkillsWithPrecedence(paths, normalizedAgentId, resolvedConfig);
         const assigned = new Set(resolvedConfig.assigned);
         const filtered = assigned.size > 0
             ? discovered.filter((skill) => assigned.has(skill.id))
@@ -64,7 +67,7 @@ export class SkillService {
             "- If exactly one skill clearly applies, follow that skill.",
             "- If multiple skills could apply, choose the most specific.",
             "- If none apply, continue without using a skill.",
-            "Skill definitions are centralized under the global skills store.",
+            "Skill definitions may come from global and agent-specific stores.",
             "",
         ];
         if (selected.length === 0) {
@@ -95,75 +98,353 @@ export class SkillService {
             skills: selected,
         };
     }
-    async installSkill(paths, request) {
+    async installSkill(paths, request, options = {}) {
+        const hasSourcePath = Boolean(request.sourcePath?.trim());
+        const hasSourceUrl = Boolean(request.sourceUrl?.trim());
+        if (hasSourcePath && hasSourceUrl) {
+            throw new Error("Use either sourcePath or sourceUrl, not both.");
+        }
         const scope = request.scope === "global" ? "global" : "agent";
         const normalizedAgentId = normalizeAgentId(request.agentId ?? DEFAULT_AGENT_ID) || DEFAULT_AGENT_ID;
-        const skillId = normalizeAgentId(request.skillName);
+        const requestedSkillName = request.skillName?.trim() || request.sourceSkillName?.trim();
+        const skillId = normalizeAgentId(requestedSkillName ?? "");
         if (!skillId) {
             throw new Error("Skill name must contain at least one alphanumeric character.");
         }
-        const baseDir = paths.skillsDir;
-        const targetDir = this.pathPort.join(baseDir, skillId);
+        const globalSkillDir = this.pathPort.join(paths.skillsDir, skillId);
+        const globalSkillFile = this.pathPort.join(globalSkillDir, "SKILL.md");
+        const agentScopedSkillsBaseDir = this.pathPort.join(paths.skillsDir, AGENT_SCOPED_STORE_DIR, normalizedAgentId);
+        const agentScopedSkillDir = this.pathPort.join(agentScopedSkillsBaseDir, skillId);
+        const targetDir = scope === "global" ? globalSkillDir : agentScopedSkillDir;
         const targetSkillFile = this.pathPort.join(targetDir, "SKILL.md");
-        const replaced = await this.fileSystem.exists(targetDir);
-        await this.fileSystem.ensureDir(baseDir);
-        if (request.sourcePath?.trim()) {
-            const sourcePath = resolveUserPath(request.sourcePath.trim());
-            const sourceSkillFile = sourcePath.toLowerCase().endsWith("/skill.md") ||
-                sourcePath.toLowerCase().endsWith("\\skill.md")
-                ? sourcePath
-                : this.pathPort.join(sourcePath, "SKILL.md");
-            const sourceFileExists = await this.fileSystem.exists(sourceSkillFile);
-            if (!sourceFileExists) {
-                throw new Error(`Source skill not found: ${sourceSkillFile}`);
+        let replaced = await this.fileSystem.exists(targetDir);
+        let workspaceInstallPaths = [];
+        if (hasSourcePath || hasSourceUrl) {
+            await this.fileSystem.ensureDir(scope === "global" ? paths.skillsDir : agentScopedSkillsBaseDir);
+            let resolvedSource;
+            try {
+                resolvedSource = hasSourcePath
+                    ? await this.resolveInstallSourceFromPath(request.sourcePath?.trim() ?? "")
+                    : await this.resolveInstallSourceFromUrl(paths, request.sourceUrl?.trim() ?? "", request.sourceSkillName, skillId);
+                await this.fileSystem.removeDir(targetDir);
+                await this.fileSystem.copyDir(resolvedSource.sourceDir, targetDir);
+            }
+            finally {
+                if (resolvedSource?.cleanup) {
+                    await resolvedSource.cleanup();
+                }
             }
-            const sourceDir = sourceSkillFile === sourcePath ? path.dirname(sourcePath) : sourcePath;
-            await this.fileSystem.removeDir(targetDir);
-            await this.fileSystem.copyDir(sourceDir, targetDir);
             if (scope === "agent") {
-                await this.assignSkillToAgent(paths, normalizedAgentId, skillId);
-                await this.reconcileRoleSkillsIfNeeded(paths, normalizedAgentId, skillId);
+                workspaceInstallPaths = await this.installSkillForAgent(paths, normalizedAgentId, skillId, options, targetDir);
             }
             return {
                 scope,
                 agentId: scope === "agent" ? normalizedAgentId : undefined,
+                assignedAgentIds: scope === "agent" ? [normalizedAgentId] : undefined,
                 skillId,
-                skillName: request.skillName.trim(),
-                source: "source-path",
+                skillName: requestedSkillName ?? skillId,
+                source: hasSourcePath ? "source-path" : "source-url",
                 installedPath: targetSkillFile,
+                workspaceInstallPaths,
                 replaced,
             };
         }
         let source = "generated";
-        const existingGlobalSkill = this.pathPort.join(paths.skillsDir, skillId, "SKILL.md");
-        if (scope === "agent" &&
-            (await this.fileSystem.exists(existingGlobalSkill))) {
+        let installedPath = targetSkillFile;
+        let workspaceSourceDir = targetDir;
+        if (scope === "agent" && (await this.fileSystem.exists(globalSkillFile))) {
+            const hadAgentOverride = await this.fileSystem.exists(agentScopedSkillDir);
+            if (hadAgentOverride) {
+                await this.fileSystem.removeDir(agentScopedSkillDir);
+            }
+            replaced = hadAgentOverride;
             source = "managed";
+            installedPath = globalSkillFile;
+            workspaceSourceDir = globalSkillDir;
         }
         else {
             const description = request.description?.trim() ||
-                `Skill instructions for ${request.skillName.trim()}.`;
+                `Skill instructions for ${requestedSkillName ?? skillId}.`;
             const content = request.content?.trim() ||
                 renderSkillMarkdown({ skillId, description });
+            await this.fileSystem.ensureDir(scope === "global" ? paths.skillsDir : agentScopedSkillsBaseDir);
             await this.fileSystem.ensureDir(targetDir);
             await this.fileSystem.writeFile(targetSkillFile, ensureTrailingNewline(content));
             source = "generated";
         }
         if (scope === "agent") {
-            await this.assignSkillToAgent(paths, normalizedAgentId, skillId);
-            await this.reconcileRoleSkillsIfNeeded(paths, normalizedAgentId, skillId);
+            workspaceInstallPaths = await this.installSkillForAgent(paths, normalizedAgentId, skillId, options, workspaceSourceDir);
         }
         return {
             scope,
             agentId: scope === "agent" ? normalizedAgentId : undefined,
+            assignedAgentIds: scope === "agent" ? [normalizedAgentId] : undefined,
             skillId,
-            skillName: request.skillName.trim(),
+            skillName: requestedSkillName ?? skillId,
             source,
-            installedPath: targetSkillFile,
+            installedPath,
+            workspaceInstallPaths,
             replaced,
         };
     }
-    async loadSkillsWithPrecedence(paths, config) {
+    async assignInstalledSkillToAgent(paths, agentId, skillId, options = {}) {
+        const normalizedAgentId = normalizeAgentId(agentId) || DEFAULT_AGENT_ID;
+        const normalizedSkillId = normalizeAgentId(skillId);
+        if (!normalizedSkillId) {
+            throw new Error("Skill id must contain at least one alphanumeric character.");
+        }
+        const sourceSkillFile = this.pathPort.join(paths.skillsDir, normalizedSkillId, "SKILL.md");
+        if (!(await this.fileSystem.exists(sourceSkillFile))) {
+            throw new Error(`Skill "${normalizedSkillId}" is not installed in global storage.`);
+        }
+        return this.installSkillForAgent(paths, normalizedAgentId, normalizedSkillId, options, this.pathPort.join(paths.skillsDir, normalizedSkillId));
+    }
+    async removeSkill(paths, request, options = {}) {
+        const scope = request.scope === "global" ? "global" : "agent";
+        const normalizedSkillId = normalizeAgentId(request.skillId ?? "");
+        if (!normalizedSkillId) {
+            throw new Error("Skill id must contain at least one alphanumeric character.");
+        }
+        if (scope === "global") {
+            const globalSkillDir = this.pathPort.join(paths.skillsDir, normalizedSkillId);
+            const removedFromGlobal = await this.fileSystem.exists(globalSkillDir);
+            await this.fileSystem.removeDir(globalSkillDir);
+            return {
+                scope: "global",
+                skillId: normalizedSkillId,
+                removedFromGlobal,
+                removedFromAgentIds: [],
+                removedWorkspacePaths: [],
+            };
+        }
+        const normalizedAgentId = normalizeAgentId(request.agentId ?? DEFAULT_AGENT_ID) || DEFAULT_AGENT_ID;
+        const removed = await this.removeSkillForAgent(paths, normalizedAgentId, normalizedSkillId, options);
+        return {
+            scope: "agent",
+            agentId: normalizedAgentId,
+            skillId: normalizedSkillId,
+            removedFromGlobal: false,
+            removedFromAgentIds: removed.removedFromConfig ||
+                removed.removedFromWorkspace ||
+                removed.removedFromAgentStore
+                ? [normalizedAgentId]
+                : [],
+            removedWorkspacePaths: removed.removedWorkspacePaths,
+        };
+    }
+    async removeAssignedSkillFromAgent(paths, agentId, skillId, options = {}) {
+        const normalizedAgentId = normalizeAgentId(agentId) || DEFAULT_AGENT_ID;
+        const normalizedSkillId = normalizeAgentId(skillId ?? "");
+        if (!normalizedSkillId) {
+            throw new Error("Skill id must contain at least one alphanumeric character.");
+        }
+        return this.removeSkillForAgent(paths, normalizedAgentId, normalizedSkillId, options);
+    }
+    async installSkillForAgent(paths, agentId, skillId, options, sourceSkillDir) {
+        await this.assignSkillToAgent(paths, agentId, skillId);
+        await this.reconcileRoleSkillsIfNeeded(paths, agentId, skillId);
+        return this.syncSkillToWorkspace(paths, agentId, skillId, options, sourceSkillDir);
+    }
+    async removeSkillForAgent(paths, agentId, skillId, options) {
+        const removedFromAgentStore = await this.removeAgentScopedSkill(paths, agentId, skillId);
+        const removedFromConfig = await this.unassignSkillFromAgent(paths, agentId, skillId);
+        const removedWorkspacePaths = await this.removeSkillFromWorkspace(paths, agentId, skillId, options);
+        return {
+            removedFromConfig,
+            removedFromAgentStore,
+            removedFromWorkspace: removedWorkspacePaths.length > 0,
+            removedWorkspacePaths,
+        };
+    }
+    async syncSkillToWorkspace(paths, agentId, skillId, options, sourceSkillDir) {
+        const workspaceDir = options.workspaceDir?.trim() ||
+            this.pathPort.join(paths.workspacesDir, agentId);
+        const normalizedDirectories = normalizeWorkspaceSkillDirectories(options.workspaceSkillDirectories);
+        if (normalizedDirectories.length === 0) {
+            return [];
+        }
+        const resolvedSourceDir = sourceSkillDir ??
+            (await this.resolveInstalledSkillSourceDir(paths, agentId, skillId));
+        if (!resolvedSourceDir ||
+            !(await this.fileSystem.exists(resolvedSourceDir))) {
+            return [];
+        }
+        const installedPaths = [];
+        for (const relativeSkillsDir of normalizedDirectories) {
+            const skillsDir = this.pathPort.join(workspaceDir, relativeSkillsDir);
+            const targetSkillDir = this.pathPort.join(skillsDir, skillId);
+            await this.fileSystem.ensureDir(skillsDir);
+            await this.fileSystem.removeDir(targetSkillDir);
+            await this.fileSystem.copyDir(resolvedSourceDir, targetSkillDir);
+            installedPaths.push(this.pathPort.join(targetSkillDir, "SKILL.md"));
+        }
+        return installedPaths;
+    }
+    async removeSkillFromWorkspace(paths, agentId, skillId, options) {
+        const workspaceDir = options.workspaceDir?.trim() ||
+            this.pathPort.join(paths.workspacesDir, agentId);
+        const normalizedDirectories = normalizeWorkspaceSkillDirectories(options.workspaceSkillDirectories);
+        if (normalizedDirectories.length === 0) {
+            return [];
+        }
+        const removedPaths = [];
+        for (const relativeSkillsDir of normalizedDirectories) {
+            const skillsDir = this.pathPort.join(workspaceDir, relativeSkillsDir);
+            const targetSkillDir = this.pathPort.join(skillsDir, skillId);
+            if (!(await this.fileSystem.exists(targetSkillDir))) {
+                continue;
+            }
+            await this.fileSystem.removeDir(targetSkillDir);
+            removedPaths.push(this.pathPort.join(targetSkillDir, "SKILL.md"));
+        }
+        return removedPaths;
+    }
+    async resolveInstalledSkillSourceDir(paths, agentId, skillId) {
+        const agentScopedDir = this.pathPort.join(paths.skillsDir, AGENT_SCOPED_STORE_DIR, agentId, skillId);
+        if (await this.fileSystem.exists(agentScopedDir)) {
+            return agentScopedDir;
+        }
+        const globalDir = this.pathPort.join(paths.skillsDir, skillId);
+        if (await this.fileSystem.exists(globalDir)) {
+            return globalDir;
+        }
+        return undefined;
+    }
+    async removeAgentScopedSkill(paths, agentId, skillId) {
+        const agentScopedDir = this.pathPort.join(paths.skillsDir, AGENT_SCOPED_STORE_DIR, agentId, skillId);
+        const exists = await this.fileSystem.exists(agentScopedDir);
+        if (!exists) {
+            return false;
+        }
+        await this.fileSystem.removeDir(agentScopedDir);
+        return true;
+    }
+    async resolveInstallSourceFromPath(sourcePathInput) {
+        const sourcePath = resolveUserPath(sourcePathInput);
+        const sourceSkillFile = sourcePath.toLowerCase().endsWith("/skill.md") ||
+            sourcePath.toLowerCase().endsWith("\\skill.md")
+            ? sourcePath
+            : this.pathPort.join(sourcePath, "SKILL.md");
+        const sourceFileExists = await this.fileSystem.exists(sourceSkillFile);
+        if (!sourceFileExists) {
+            throw new Error(`Source skill not found: ${sourceSkillFile}`);
+        }
+        const sourceDir = sourceSkillFile === sourcePath ? path.dirname(sourcePath) : sourcePath;
+        return {
+            sourceDir,
+            source: "source-path",
+        };
+    }
+    async resolveInstallSourceFromUrl(paths, sourceUrl, sourceSkillName, fallbackSkillId) {
+        if (!this.commandRunner) {
+            throw new Error("Installing skills from URL requires a configured command runner.");
+        }
+        const resolvedUrl = sourceUrl.trim();
+        if (!resolvedUrl) {
+            throw new Error("sourceUrl cannot be empty.");
+        }
+        const tempRoot = this.pathPort.join(paths.homeDir, ".tmp", "skill-installs", randomUUID());
+        const cloneDir = this.pathPort.join(tempRoot, "repo");
+        await this.fileSystem.ensureDir(tempRoot);
+        const cloneSource = stripGitHubTreePath(resolvedUrl);
+        const cloneResult = await this.commandRunner.run({
+            command: "git",
+            args: ["clone", "--depth", "1", cloneSource, cloneDir],
+            cwd: paths.homeDir,
+        });
+        if (cloneResult.code !== 0) {
+            throw new Error(`Unable to clone skill source URL "${resolvedUrl}". ${cloneResult.stderr.trim() || cloneResult.stdout.trim() || ""}`.trim());
+        }
+        const pathHint = resolveGitHubTreePathHint(resolvedUrl);
+        const skillHint = sourceSkillName?.trim() || fallbackSkillId;
+        const resolvedSkillDir = await this.resolveRepositorySkillDirectory(cloneDir, skillHint, pathHint);
+        return {
+            sourceDir: resolvedSkillDir,
+            source: "source-url",
+            cleanup: async () => {
+                await this.fileSystem.removeDir(tempRoot);
+            },
+        };
+    }
+    async resolveRepositorySkillDirectory(repositoryDir, skillHint, pathHint) {
+        const normalizedSkillHint = normalizeAgentId(skillHint);
+        const normalizedPathHint = normalizeRelativeDirectory(pathHint);
+        if (normalizedPathHint) {
+            const hinted = this.pathPort.join(repositoryDir, normalizedPathHint);
+            const hintedSkillFile = this.pathPort.join(hinted, "SKILL.md");
+            if (await this.fileSystem.exists(hintedSkillFile)) {
+                return hinted;
+            }
+        }
+        if (normalizedSkillHint) {
+            const candidateRelativePaths = [
+                normalizedSkillHint,
+                `skills/${normalizedSkillHint}`,
+                `.claude/skills/${normalizedSkillHint}`,
+                ".claude-plugin/skills/" + normalizedSkillHint,
+                ".agents/skills/" + normalizedSkillHint,
+                ".agent/skills/" + normalizedSkillHint,
+                ".cursor/skills/" + normalizedSkillHint,
+                ".copilot/skills/" + normalizedSkillHint,
+                ".opencode/skills/" + normalizedSkillHint,
+                ".gemini/skills/" + normalizedSkillHint,
+            ];
+            for (const relativeCandidate of candidateRelativePaths) {
+                const candidate = this.pathPort.join(repositoryDir, relativeCandidate);
+                const candidateSkillFile = this.pathPort.join(candidate, "SKILL.md");
+                if (await this.fileSystem.exists(candidateSkillFile)) {
+                    return candidate;
+                }
+            }
+        }
+        const discovered = await this.discoverSkillDirectories(repositoryDir, 0, 7);
+        if (normalizedSkillHint) {
+            const matched = discovered.find((directoryPath) => {
+                const relativePath = path
+                    .relative(repositoryDir, directoryPath)
+                    .replace(/\\/g, "/");
+                const directoryName = path.basename(directoryPath).trim();
+                return (normalizeAgentId(directoryName) === normalizedSkillHint ||
+                    normalizeAgentId(relativePath) === normalizedSkillHint);
+            });
+            if (matched) {
+                return matched;
+            }
+        }
+        if (discovered.length === 1) {
+            return discovered[0];
+        }
+        if (discovered.length === 0) {
+            throw new Error("No valid SKILL.md definitions were found in the source URL.");
+        }
+        const available = discovered
+            .slice(0, 10)
+            .map((directoryPath) => path.relative(repositoryDir, directoryPath))
+            .join(", ");
+        throw new Error(`Multiple skills were found in the source URL. Specify sourceSkillName. Available candidates: ${available}`);
+    }
+    async discoverSkillDirectories(rootDir, depth, maxDepth) {
+        if (depth > maxDepth) {
+            return [];
+        }
+        const skillFile = this.pathPort.join(rootDir, "SKILL.md");
+        const found = [];
+        if (await this.fileSystem.exists(skillFile)) {
+            found.push(rootDir);
+        }
+        const childDirectories = await this.fileSystem.listDirectories(rootDir);
+        for (const childDirectory of childDirectories) {
+            if (!childDirectory || childDirectory.startsWith(".git")) {
+                continue;
+            }
+            const childPath = this.pathPort.join(rootDir, childDirectory);
+            const nested = await this.discoverSkillDirectories(childPath, depth + 1, maxDepth);
+            found.push(...nested);
+        }
+        return dedupe(found).sort((left, right) => left.localeCompare(right));
+    }
+    async loadSkillsWithPrecedence(paths, agentId, config) {
+        const agentScopedDir = this.pathPort.join(paths.skillsDir, AGENT_SCOPED_STORE_DIR, agentId);
         const extraDirs = config.load.extraDirs.map(resolveUserPath);
         const sources = [
             {
@@ -171,6 +452,11 @@ export class SkillService {
                 dir: paths.skillsDir,
                 enabled: config.includeManaged,
             },
+            {
+                source: "managed",
+                dir: agentScopedDir,
+                enabled: config.includeManaged,
+            },
             ...extraDirs.map((dir) => ({
                 source: "extra",
                 dir,
@@ -275,6 +561,41 @@ export class SkillService {
         parsed.runtime = runtimeRecord;
         await this.fileSystem.writeFile(configPath, `${JSON.stringify(parsed, null, 2)}\n`);
     }
+    async unassignSkillFromAgent(paths, agentId, skillId) {
+        const configPath = this.pathPort.join(paths.agentsDir, agentId, "config.json");
+        if (!(await this.fileSystem.exists(configPath))) {
+            return false;
+        }
+        const raw = await this.fileSystem.readFile(configPath);
+        const parsed = JSON.parse(raw);
+        const runtimeRecord = parsed.runtime &&
+            typeof parsed.runtime === "object" &&
+            !Array.isArray(parsed.runtime)
+            ? parsed.runtime
+            : {};
+        const skillsRecord = runtimeRecord.skills &&
+            typeof runtimeRecord.skills === "object" &&
+            !Array.isArray(runtimeRecord.skills)
+            ? runtimeRecord.skills
+            : {};
+        const assignedRaw = Array.isArray(skillsRecord.assigned)
+            ? skillsRecord.assigned
+            : [];
+        const assigned = [
+            ...new Set(assignedRaw
+                .map((value) => String(value).trim().toLowerCase())
+                .filter(Boolean)),
+        ];
+        const nextAssigned = assigned.filter((entry) => entry !== skillId);
+        if (nextAssigned.length === assigned.length) {
+            return false;
+        }
+        skillsRecord.assigned = nextAssigned;
+        runtimeRecord.skills = skillsRecord;
+        parsed.runtime = runtimeRecord;
+        await this.fileSystem.writeFile(configPath, `${JSON.stringify(parsed, null, 2)}\n`);
+        return true;
+    }
     async reconcileRoleSkillsIfNeeded(paths, agentId, skillId) {
         const normalizedSkill = skillId.trim().toLowerCase();
         if (!ROLE_SKILL_IDS.has(normalizedSkill)) {
@@ -330,6 +651,7 @@ const BOARD_INDIVIDUAL_SKILL_ID = "og-board-individual";
 const BOARDS_SKILL_ID = "og-boards";
 const LEGACY_BOARD_MANAGER_SKILL_ID = "board-manager";
 const LEGACY_BOARD_INDIVIDUAL_SKILL_ID = "board-individual";
+const AGENT_SCOPED_STORE_DIR = ".agent-scoped";
 const ROLE_SKILL_IDS = new Set([
     BOARDS_SKILL_ID,
     BOARD_MANAGER_SKILL_ID,
@@ -459,6 +781,84 @@ function resolveUserPath(value) {
     }
     return path.resolve(value);
 }
+function normalizeWorkspaceSkillDirectories(input) {
+    if (!Array.isArray(input) || input.length === 0) {
+        return [];
+    }
+    const directories = [];
+    for (const candidate of input) {
+        const normalized = normalizeRelativeDirectory(candidate);
+        if (!normalized || directories.includes(normalized)) {
+            continue;
+        }
+        directories.push(normalized);
+    }
+    return directories;
+}
+function normalizeRelativeDirectory(value) {
+    if (!value) {
+        return null;
+    }
+    const normalized = value
+        .trim()
+        .replace(/\\/g, "/")
+        .replace(/^\/+/, "")
+        .replace(/\/+$/, "");
+    if (!normalized || normalized.startsWith("..")) {
+        return null;
+    }
+    const parts = normalized
+        .split("/")
+        .map((part) => part.trim())
+        .filter(Boolean);
+    if (parts.length === 0 || parts.includes("..")) {
+        return null;
+    }
+    return parts.join("/");
+}
+function stripGitHubTreePath(sourceUrl) {
+    try {
+        const parsed = new URL(sourceUrl);
+        if (parsed.hostname !== "github.com") {
+            return sourceUrl;
+        }
+        const segments = parsed.pathname.split("/").filter(Boolean);
+        if (segments.length >= 4 && segments[2] === "tree") {
+            const owner = segments[0];
+            const repo = segments[1]?.replace(/\.git$/i, "");
+            if (owner && repo) {
+                return `https://github.com/${owner}/${repo}.git`;
+            }
+        }
+        return sourceUrl;
+    }
+    catch {
+        return sourceUrl;
+    }
+}
+function resolveGitHubTreePathHint(sourceUrl) {
+    try {
+        const parsed = new URL(sourceUrl);
+        if (parsed.hostname !== "github.com") {
+            return undefined;
+        }
+        const segments = parsed.pathname.split("/").filter(Boolean);
+        if (segments.length <= 4 || segments[2] !== "tree") {
+            return undefined;
+        }
+        const relativeSegments = segments.slice(4);
+        if (relativeSegments.length === 0) {
+            return undefined;
+        }
+        return relativeSegments.join("/");
+    }
+    catch {
+        return undefined;
+    }
+}
+function dedupe(values) {
+    return [...new Set(values)];
+}
 function escapeXml(value) {
     return value
         .replace(/&/g, "&amp;")