@agentxm/extension-sources 0.28.4-bootstrap.0

package/dist/src/resolve-source.js

@@ -0,0 +1,503 @@
+/**
+ * Source resolution: classifies input via parseInputPattern, then routes
+ * each pattern type to the appropriate resolution logic.
+ *
+ * For URL and SCP patterns, resolution iterates configured sources and
+ * matches by hostname + provider parse. For other patterns, resolution
+ * handles them directly.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Array from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as Match from "effect/Match";
+import * as Option from "effect/Option";
+import * as azurerepos from "./providers/azurerepos/index.js";
+import * as bitbucket from "./providers/bitbucket/index.js";
+import * as github from "./providers/github/index.js";
+import * as gitlab from "./providers/gitlab/index.js";
+import { parseInputPattern } from "@agentxm/extension-model/unstable/sources/parser";
+import { createRegistryClient } from "@agentxm/registry-client";
+import { decodeHandleSync } from "@agentxm/extension-model/unstable/extensions/handle";
+import { decodeExtensionNameSync, extensionTypeSentenceLabels, isExtensionTypePlural, parseRegistrySourcePatternParts, toExtensionType, toExtensionTypePlural, } from "@agentxm/extension-model/unstable/extensions";
+import { SourceHostNotConfigured, SourceNotResolvable, SourceSyntaxInvalid, } from "./errors.js";
+import { WorkspaceCatalog } from "./workspace-catalog.js";
+import { refFromFragment, refFromUrlHash, stripUrlHash } from "./url-fragment.js";
+// -----------------------------------------------------------------------------
+// Constants
+// -----------------------------------------------------------------------------
+const isGenericGitUrl = (url) => url.protocol === "git:" || url.protocol === "ssh:" || url.pathname.endsWith(".git");
+const genericGitSourceFromUrl = (url) => ({
+    type: "git",
+    url: stripUrlHash(url),
+    ref: refFromUrlHash(url),
+});
+const withRefFallback = (params, ref) => {
+    if (Option.isNone(ref))
+        return params;
+    switch (params.type) {
+        case "github":
+        case "gitlab":
+        case "bitbucket":
+        case "azurerepos":
+        case "git":
+            return Option.isSome(params.ref) ? params : { ...params, ref };
+        case "registry":
+        case "local":
+        case "inline":
+        case "workspace":
+            return params;
+    }
+};
+const withCloneUrl = (source, cloneUrl) => {
+    if (Option.isNone(cloneUrl))
+        return source;
+    switch (source.type) {
+        case "github":
+        case "gitlab":
+        case "bitbucket":
+        case "azurerepos":
+            return { ...source, cloneUrl };
+        case "git":
+        case "registry":
+        case "local":
+        case "workspace":
+            return source;
+    }
+};
+const splitScpPathRef = (scp) => {
+    const refIndex = scp.path.lastIndexOf("#");
+    if (refIndex < 0) {
+        return {
+            scp,
+            ref: Option.none(),
+            cloneUrl: new URL(`ssh://${scp.user}@${scp.host}/${scp.path}`),
+        };
+    }
+    const path = scp.path.slice(0, refIndex);
+    const rawRef = scp.path.slice(refIndex + 1);
+    const ref = refFromFragment(rawRef);
+    return {
+        scp: { ...scp, path },
+        ref,
+        cloneUrl: new URL(`ssh://${scp.user}@${scp.host}/${path}`),
+    };
+};
+const firstSuccess = (attempts, onFailure) => Effect.gen(function* () {
+    for (const attempt of attempts) {
+        const result = yield* Effect.result(attempt);
+        if (result._tag === "Success") {
+            return result.success;
+        }
+    }
+    return yield* Effect.fail(onFailure());
+});
+// -----------------------------------------------------------------------------
+// Helpers
+// -----------------------------------------------------------------------------
+/** Get configured sources from the workspace catalog, wrapping catalog failures. */
+const getConfiguredSources = (_input) => Effect.gen(function* () {
+    const catalog = yield* WorkspaceCatalog;
+    return yield* catalog.configuredSources.pipe(Effect.mapError((e) => new SourceNotResolvable({
+        category: "validation",
+        detail: `Failed to get configured sources: ${e._tag}`,
+    })));
+});
+/** Parse shorthand input using the provider for the given source type. */
+const parseShorthandForSource = (shorthand) => {
+    const input = `${shorthand.prefix}:${shorthand.remainingInput}`;
+    switch (shorthand.prefix) {
+        case "github":
+            return github.parseShorthand(input);
+        case "gitlab":
+            return gitlab.parseShorthand(input);
+        case "bitbucket":
+            return bitbucket.parseShorthand(input);
+        case "azurerepos":
+            return azurerepos.parseShorthand(input);
+        case "registry": {
+            const parsed = parseRegistrySourcePatternParts(shorthand.remainingInput);
+            return parsed === undefined
+                ? Effect.fail(new SourceSyntaxInvalid({
+                    detail: `Invalid Registry source reference "${input}"`,
+                }))
+                : Effect.succeed({ type: "registry", owner: Option.some(parsed.owner) });
+        }
+        default:
+            return Effect.fail(new SourceSyntaxInvalid({
+                detail: `Source type "${shorthand.prefix}" does not support shorthand syntax`,
+            }));
+    }
+};
+/**
+ * Merge a configured source host with SourceParams to produce a Source.
+ * Uses exhaustive type checks on both discriminators and fails on mismatch.
+ */
+const configToSource = (config, params, _input) => {
+    const mismatch = () => Effect.fail(new SourceHostNotConfigured({
+        detail: `Source params type "${params.type}" does not match config type "${config.type}"`,
+    }));
+    switch (config.type) {
+        case "github":
+            return params.type === "github"
+                ? Effect.succeed({ ...params, name: config.name, url: config.url })
+                : mismatch();
+        case "gitlab":
+            return params.type === "gitlab"
+                ? Effect.succeed({ ...params, name: config.name, url: config.url })
+                : mismatch();
+        case "bitbucket":
+            return params.type === "bitbucket"
+                ? Effect.succeed({ ...params, name: config.name, url: config.url })
+                : mismatch();
+        case "azurerepos":
+            return params.type === "azurerepos"
+                ? Effect.succeed({ ...params, name: config.name, url: config.url })
+                : mismatch();
+        case "registry":
+            return params.type === "registry"
+                ? Effect.succeed({ ...params, name: config.name, location: config.location })
+                : mismatch();
+    }
+};
+// -----------------------------------------------------------------------------
+// URL routing
+// -----------------------------------------------------------------------------
+/**
+ * Route a URL input by iterating configured sources and matching by
+ * hostname + provider parse. First successful match wins.
+ */
+export const routeUrlInput = (url, input) => Effect.gen(function* () {
+    // Opaque URLs (empty hostname, e.g. "ghe:owner/repo") may be config-name shorthands
+    if (!url.hostname) {
+        return yield* routeOpaqueUrl(url, input);
+    }
+    const sources = yield* getConfiguredSources(input);
+    const noMatch = new SourceHostNotConfigured({
+        detail: `No configured source matches URL "${url.href}"`,
+    });
+    const tryParseUrl = (configUrl, config, parse) => configUrl.hostname !== url.hostname
+        ? Effect.fail(noMatch)
+        : Effect.flatMap(parse(url, configUrl.hostname), (params) => configToSource(config, params, input));
+    const tryMatch = Match.type().pipe(Match.when({ type: "github" }, (c) => tryParseUrl(c.url, c, github.parseUrl)), Match.when({ type: "gitlab" }, (c) => tryParseUrl(c.url, c, gitlab.parseUrl)), Match.when({ type: "bitbucket" }, (c) => tryParseUrl(c.url, c, bitbucket.parseUrl)), Match.when({ type: "azurerepos" }, (c) => tryParseUrl(c.url, c, azurerepos.parseUrl)), Match.when({ type: "registry" }, () => Effect.fail(noMatch)), Match.exhaustive);
+    const attempts = Array.map(sources, tryMatch);
+    if (Array.isReadonlyArrayEmpty(attempts)) {
+        if (isGenericGitUrl(url)) {
+            return genericGitSourceFromUrl(url);
+        }
+        return yield* noMatch;
+    }
+    const matches = [];
+    for (const attempt of attempts) {
+        const result = yield* Effect.result(attempt);
+        if (result._tag === "Success") {
+            matches.push(result.success);
+        }
+    }
+    const [match, ...remainingMatches] = matches;
+    if (match !== undefined && remainingMatches.length === 0)
+        return match;
+    if (match !== undefined) {
+        return yield* new SourceHostNotConfigured({
+            detail: `URL "${url.href}" matches multiple configured sources: ${matches
+                .flatMap((source) => ("name" in source ? [source.name] : []))
+                .join(", ")}. Select one by source name.`,
+        });
+    }
+    if (isGenericGitUrl(url)) {
+        return genericGitSourceFromUrl(url);
+    }
+    return yield* new SourceHostNotConfigured({
+        detail: `No configured source matches URL "${url.href}"`,
+    });
+});
+/**
+ * Handle opaque URLs (no hostname, e.g. "ghe:owner/repo") by checking if
+ * the scheme matches a config name for a git hosting source type.
+ */
+const routeOpaqueUrl = (url, input) => Effect.gen(function* () {
+    const colonIndex = input.indexOf(":");
+    if (colonIndex <= 0) {
+        return yield* new SourceSyntaxInvalid({
+            detail: "Unable to parse source",
+        });
+    }
+    const prefix = input.slice(0, colonIndex);
+    const sources = yield* getConfiguredSources(input);
+    // Check if the scheme matches a config name
+    const matchedConfig = sources.find((s) => s.name === prefix);
+    if (matchedConfig !== undefined) {
+        const remainder = input.slice(colonIndex + 1);
+        const params = yield* parseShorthandForSource({
+            pattern: "shorthand-input",
+            prefix: matchedConfig.type,
+            remainingInput: remainder,
+        });
+        return yield* configToSource(matchedConfig, params, input);
+    }
+    // Not a config name — fail
+    return yield* new SourceHostNotConfigured({
+        detail: `No configured source matches URL "${url.href}"`,
+    });
+});
+// -----------------------------------------------------------------------------
+// SCP routing
+// -----------------------------------------------------------------------------
+/**
+ * Route an SCP address by iterating configured sources and matching by
+ * hostname + provider parse. First successful match wins.
+ */
+export const routeScpInput = (scp, input) => Effect.gen(function* () {
+    const sources = yield* getConfiguredSources(input);
+    const scpParts = splitScpPathRef(scp);
+    const scpInput = `${scpParts.scp.user}@${scpParts.scp.host}:${scpParts.scp.path}`;
+    const noMatch = new SourceHostNotConfigured({
+        detail: `No configured source matches SCP address "${scpInput}"`,
+    });
+    const tryParseScp = (scpHostname, config, parse) => scpParts.scp.host !== scpHostname
+        ? Effect.fail(noMatch)
+        : Effect.flatMap(parse(scpInput, scpParts.scp.host), (params) => Effect.map(configToSource(config, withRefFallback(params, scpParts.ref), input), (source) => withCloneUrl(source, Option.some(scpParts.cloneUrl.href))));
+    const tryMatch = Match.type().pipe(Match.when({ type: "github" }, (c) => tryParseScp(c.url.hostname, c, github.parseScp)), Match.when({ type: "gitlab" }, (c) => tryParseScp(c.url.hostname, c, gitlab.parseScp)), Match.when({ type: "bitbucket" }, (c) => tryParseScp(c.url.hostname, c, bitbucket.parseScp)), Match.when({ type: "azurerepos" }, (c) => tryParseScp(`ssh.${c.url.hostname}`, c, azurerepos.parseScp)), Match.when({ type: "registry" }, () => Effect.fail(noMatch)), Match.exhaustive);
+    const attempts = Array.map(sources, tryMatch);
+    const genericGitSource = genericGitSourceFromUrl(scpParts.cloneUrl);
+    const genericGitSourceWithRef = { ...genericGitSource, ref: scpParts.ref };
+    if (Array.isReadonlyArrayEmpty(attempts)) {
+        return genericGitSourceWithRef;
+    }
+    const matches = [];
+    for (const attempt of attempts) {
+        const result = yield* Effect.result(attempt);
+        if (result._tag === "Success") {
+            matches.push(result.success);
+        }
+    }
+    const [match, ...remainingMatches] = matches;
+    if (match !== undefined && remainingMatches.length === 0)
+        return match;
+    if (match !== undefined) {
+        return yield* new SourceHostNotConfigured({
+            detail: `SCP address "${scpInput}" matches multiple configured sources: ${matches
+                .flatMap((source) => ("name" in source ? [source.name] : []))
+                .join(", ")}. Select one by source name.`,
+        });
+    }
+    return genericGitSourceWithRef;
+});
+// -----------------------------------------------------------------------------
+// Shorthand routing
+// -----------------------------------------------------------------------------
+/**
+ * Route shorthand input (github:owner/repo, ghe:owner/repo, etc.).
+ *
+ * Known source-type prefixes dispatch directly to the provider's shorthand
+ * parser. Config-name prefixes look up the config and parse using its source
+ * type's shorthand parser.
+ */
+export const resolveShorthandInputSource = (parseResult) => Effect.gen(function* () {
+    const prefix = parseResult.pattern.prefix;
+    const input = parseResult.originalInput;
+    const sources = yield* getConfiguredSources(input);
+    // Prefixes always select an exact configured source name.
+    const matchedConfig = sources.find((s) => s.name === prefix);
+    if (matchedConfig === undefined) {
+        return yield* new SourceHostNotConfigured({
+            detail: `No configured source named "${prefix}"`,
+        });
+    }
+    const params = yield* parseShorthandForSource({
+        pattern: "shorthand-input",
+        prefix: matchedConfig.type,
+        remainingInput: parseResult.pattern.remainingInput,
+    });
+    return yield* configToSource(matchedConfig, params, input);
+});
+// -----------------------------------------------------------------------------
+// Simple pattern routing
+// -----------------------------------------------------------------------------
+/** Route NameInput through the complete desired extension graph. */
+export const routeNameInput = (name, _input, expectedType = "skill") => Effect.gen(function* () {
+    const catalog = yield* WorkspaceCatalog;
+    const graph = yield* catalog.desiredExtensionGraph;
+    if (!graph.complete) {
+        return yield* new SourceNotResolvable({
+            category: "conflict",
+            detail: `Cannot resolve the ${extensionTypeSentenceLabels[expectedType]} while the desired extension graph is incomplete.`,
+            recover: "Repair or reinstall the configured packs, then retry.",
+        });
+    }
+    const desired = graph.nodes.find((node) => node.type === expectedType && node.name === name);
+    if (desired?.source !== undefined) {
+        return yield* resolveSource(desired.source);
+    }
+    return yield* new SourceNotResolvable({
+        category: "validation",
+        detail: `Unknown ${extensionTypeSentenceLabels[expectedType]} "${name}".`,
+        suggestions: [
+            {
+                description: `Inspect configured ${extensionTypeSentenceLabels[expectedType]} entries.`,
+                cmd: `axm ${toExtensionTypePlural(expectedType)} list`,
+            },
+        ],
+    });
+});
+/** Route RegistryPatternInput: find matching registry config and intersect with params. */
+export const routeRegistryInput = (pattern, _input) => Effect.gen(function* () {
+    const catalog = yield* WorkspaceCatalog;
+    // Name filtering is handled in the find phase; this routing step only resolves registry host.
+    const sources = yield* catalog.configuredSources.pipe(Effect.mapError((e) => new SourceNotResolvable({
+        category: "validation",
+        detail: `Failed to get source ${pattern.sourceName}: ${e._tag}`,
+    })));
+    const configured = Option.fromUndefinedOr(sources.find((source) => source.name === pattern.sourceName));
+    if (Option.isNone(configured) || configured.value.type !== "registry") {
+        return yield* new SourceHostNotConfigured({
+            detail: `No Registry source named "${pattern.sourceName}" is configured`,
+        });
+    }
+    return {
+        type: "registry",
+        name: configured.value.name,
+        location: configured.value.location,
+        owner: Option.some(pattern.owner),
+    };
+});
+/**
+ * Route SlashPattern (owner/repo): iterate git-hosting configs that support
+ * shorthand, try each provider in config order. First success wins.
+ */
+const registryExtensionTypeFromSegment = (segment) => {
+    if (!isExtensionTypePlural(segment)) {
+        return Option.none();
+    }
+    return Option.some(toExtensionType(segment));
+};
+export const resolveSlashInputSource = (pattern, input) => Effect.gen(function* () {
+    const sources = yield* getConfiguredSources(input);
+    const shorthandTypes = ["github", "gitlab", "bitbucket"];
+    const shorthandBody = Option.match(pattern.third, {
+        onNone: () => `${pattern.first}/${pattern.second}`,
+        onSome: (subPath) => `${pattern.first}/${pattern.second}//${subPath}`,
+    });
+    if (Option.isSome(pattern.third)) {
+        const type = registryExtensionTypeFromSegment(pattern.second);
+        if (Option.isSome(type)) {
+            const catalog = yield* WorkspaceCatalog;
+            const owner = pattern.first.startsWith("@") ? decodeHandleSync(pattern.first) : undefined;
+            const extensionName = (() => {
+                try {
+                    return decodeExtensionNameSync(pattern.third.value);
+                }
+                catch {
+                    return undefined;
+                }
+            })();
+            const registrySources = (yield* catalog.registrySourceHosts.pipe(Effect.mapError((e) => new SourceNotResolvable({
+                category: "validation",
+                detail: `Failed to get registry sources: ${e._tag}`,
+            })))).filter((source) => source.name === "agentxm");
+            if (owner !== undefined && extensionName !== undefined) {
+                for (const regSource of registrySources) {
+                    const client = yield* createRegistryClient(regSource.location.href);
+                    const exists = yield* client
+                        .extensionExists({ owner, type: type.value, name: extensionName })
+                        .pipe(Effect.orElseSucceed(() => false));
+                    if (exists) {
+                        return {
+                            type: "registry",
+                            name: regSource.name,
+                            location: regSource.location,
+                            owner: Option.some(owner),
+                        };
+                    }
+                }
+            }
+        }
+    }
+    const attempts = sources.flatMap((config) => {
+        const sourceType = shorthandTypes.find((t) => t === config.type);
+        if (!sourceType) {
+            return [];
+        }
+        return [
+            Effect.flatMap(parseShorthandForSource({
+                pattern: "shorthand-input",
+                prefix: sourceType,
+                remainingInput: shorthandBody,
+            }), (params) => configToSource(config, params, input)),
+        ];
+    });
+    if (Array.isReadonlyArrayEmpty(attempts)) {
+        return yield* new SourceHostNotConfigured({
+            detail: `Ambiguous pattern '${pattern.first}/${pattern.second}' — no git hosting sources configured`,
+        });
+    }
+    return yield* firstSuccess(attempts, () => new SourceHostNotConfigured({
+        detail: `Ambiguous pattern '${pattern.first}/${pattern.second}' — use github:${pattern.first}/${pattern.second}, gitlab:${pattern.first}/${pattern.second}, or bitbucket:${pattern.first}/${pattern.second}`,
+    }));
+});
+// -----------------------------------------------------------------------------
+// Main resolver
+// -----------------------------------------------------------------------------
+/**
+ * Resolve a source string into a fully resolved `Source`.
+ *
+ * Classifies the input via `parseInputPattern`, then routes each pattern
+ * type to the appropriate resolution logic. For URL and SCP patterns,
+ * resolution iterates configured sources and matches by hostname + provider
+ * parse. For other patterns, resolution handles them directly.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @param input - The source string to resolve
+ * @returns Effect containing a resolved `Source` or a typed resolution failure
+ */
+export const resolveSource = (input, options) => Effect.gen(function* () {
+    const trimmed = input.trim();
+    if (!trimmed) {
+        return yield* new SourceSyntaxInvalid({
+            detail: "Source string cannot be empty",
+        });
+    }
+    const parseResultOpt = parseInputPattern(trimmed);
+    if (Option.isNone(parseResultOpt)) {
+        return yield* new SourceSyntaxInvalid({
+            detail: "Unable to parse source",
+        });
+    }
+    const parsed = parseResultOpt.value;
+    const pattern = parsed.pattern;
+    switch (pattern.pattern) {
+        case "url-input":
+            return yield* routeUrlInput(pattern.url, parsed.originalInput);
+        case "git-scp-address":
+            return yield* routeScpInput(pattern, parsed.originalInput);
+        case "shorthand-input":
+            return yield* resolveShorthandInputSource({
+                pattern,
+                originalInput: parsed.originalInput,
+            });
+        case "name-input":
+            return yield* routeNameInput(pattern.name, parsed.originalInput, options?.expectedType ?? "skill");
+        case "file-path-pattern":
+            return { type: "local", path: pattern.path };
+        case "registry-pattern-input":
+            return yield* routeRegistryInput(pattern, parsed.originalInput);
+        case "slash-pattern":
+            return yield* resolveSlashInputSource(pattern, parsed.originalInput);
+        case "glob-input":
+            return yield* new SourceSyntaxInvalid({
+                detail: `Glob patterns are not supported by resolveSource — use resolveSourcePattern instead`,
+            });
+        case "workspace-pattern-input":
+            return {
+                type: "workspace",
+                owner: pattern.owner,
+                extensionType: pattern.type,
+                name: pattern.name,
+            };
+    }
+    return yield* new SourceSyntaxInvalid({
+        detail: "Unable to resolve source pattern",
+    });
+});
+//# sourceMappingURL=resolve-source.js.map

package/dist/src/rule-package-discovery.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Rule package discovery for local and git sources.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import type * as Effect from "effect/Effect";
+import type * as FileSystem from "effect/FileSystem";
+import type * as Path from "effect/Path";
+import { type RuleManifest } from "@agentxm/extension-model/unstable/rules/manifest-schema";
+export interface DiscoveredRulePackage {
+    readonly type: "rule";
+    readonly manifest: RuleManifest;
+    readonly location: string;
+}
+export interface RulePackageDiscoveryOptions {
+    readonly fullDepth: boolean;
+}
+export declare const rulePackagesInDir: (searchPath: string, options: RulePackageDiscoveryOptions) => Effect.Effect<ReadonlyArray<DiscoveredRulePackage>, never, FileSystem.FileSystem | Path.Path>;
+//# sourceMappingURL=rule-package-discovery.d.ts.map

package/dist/src/rule-package-discovery.js

@@ -0,0 +1,14 @@
+/**
+ * Rule package discovery for local and git sources.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import { discoverManifestPackagesInDir } from "./manifest-package-discovery.js";
+import { RULE_MANIFEST_FILENAME, RuleManifestSchema, } from "@agentxm/extension-model/unstable/rules/manifest-schema";
+const discoverRulePackagesInDir = discoverManifestPackagesInDir({
+    type: "rule",
+    manifestFilename: RULE_MANIFEST_FILENAME,
+    manifestSchema: RuleManifestSchema,
+});
+export const rulePackagesInDir = (searchPath, options) => discoverRulePackagesInDir(searchPath, options);
+//# sourceMappingURL=rule-package-discovery.js.map

package/dist/src/service.d.ts

@@ -0,0 +1,72 @@
+/**
+ * SourceHostProviders Effect service.
+ *
+ * Provides a unified interface for discovering and fetching extensions
+ * across all source types, plus clone URL and source display building.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as ServiceMap from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import type * as Scope from "effect/Scope";
+import type { SourceResolutionFailure } from "./errors.js";
+import type { ExtensionRef } from "@agentxm/extension-model/unstable/extensions/refs/extension-ref";
+import type { ExtensionFiles, FindOptions, NamedRegistryFindOptions, NamedRegistryResolution } from "@agentxm/extension-model/unstable/sources/source-host-provider";
+import type { RegistrySource, Source } from "@agentxm/extension-model/unstable/sources/types";
+/**
+ * Service interface for source host providers.
+ *
+ * Dependencies (FileSystem, Path, WorkspaceCatalog) are resolved at layer creation —
+ * callers only see the service, not its implementation details.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export interface SourceHostProvidersService {
+    /** Find extensions matching the given source and search criteria. */
+    readonly find: (source: Source, options: FindOptions) => Effect.Effect<ReadonlyArray<ExtensionRef>, SourceResolutionFailure, Scope.Scope>;
+    /** Resolve one explicit Registry target with a typed selection outcome. */
+    readonly resolveNamedRegistry: (source: RegistrySource, options: NamedRegistryFindOptions) => Effect.Effect<NamedRegistryResolution, SourceResolutionFailure, Scope.Scope>;
+    /** Fetch and materialize extension files for a discovered ref. */
+    readonly fetch: (ref: ExtensionRef) => Effect.Effect<ExtensionFiles, SourceResolutionFailure, Scope.Scope>;
+    /** Build a git clone URL for this source. Returns None for non-git sources. */
+    readonly cloneUrl: (source: Source) => Option.Option<string>;
+    /** Canonical origin string for display/comparison. */
+    readonly origin: (source: Source) => string;
+}
+declare const SourceHostProviders_base: ServiceMap.ServiceClass<SourceHostProviders, "@agentxm/extension-sources/service/SourceHostProviders", SourceHostProvidersService>;
+/**
+ * Effect service tag for source host providers.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare class SourceHostProviders extends SourceHostProviders_base {
+}
+/**
+ * Build a git clone URL from a source.
+ * Returns Some for git-based hosting sources, None for others.
+ *
+ * @internal
+ */
+export declare const buildCloneUrlFromSource: (source: Source) => Option.Option<string>;
+/**
+ * Get the canonical source string for display/comparison.
+ *
+ * @internal
+ */
+export declare const getOriginFromSource: (source: Source) => string;
+/**
+ * Creates a registry meta-provider that delegates find/fetch to the
+ * resolved registry host encoded in the provided `RegistrySource`.
+ *
+ * @internal
+ */
+export declare const createRegistryMetaProvider: () => {
+    type: "registry";
+    find: (source: RegistrySource, options: FindOptions) => Effect.Effect<readonly ExtensionRef[], SourceResolutionFailure, import("effect/FileSystem").FileSystem | import("effect/Path").Path | import("./axm-skill-gate.ts").AxmSkillCandidateGate | Scope.Scope | import("effect/unstable/http/HttpClient").HttpClient>;
+    resolveNamed: (source: RegistrySource, options: NamedRegistryFindOptions) => Effect.Effect<NamedRegistryResolution, SourceResolutionFailure, import("effect/FileSystem").FileSystem | import("effect/Path").Path | import("./axm-skill-gate.ts").AxmSkillCandidateGate | Scope.Scope | import("effect/unstable/http/HttpClient").HttpClient>;
+    fetch: (source: RegistrySource, ref: ExtensionRef) => Effect.Effect<ExtensionFiles, SourceResolutionFailure, import("effect/FileSystem").FileSystem | import("effect/Path").Path | import("./axm-skill-gate.ts").AxmSkillCandidateGate | Scope.Scope | import("effect/unstable/http/HttpClient").HttpClient>;
+};
+export {};
+//# sourceMappingURL=service.d.ts.map