@agentxm/extension-sources 0.28.4-bootstrap.0

package/dist/src/providers/bitbucket/url.js

@@ -0,0 +1,42 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import { SourceSyntaxInvalid } from "../../errors.js";
+import { BitbucketSourceParamsSchema, } from "@agentxm/extension-model/unstable/sources/types";
+import { refFromUrlHash } from "../../url-fragment.js";
+export const CANONICAL_HOSTNAME = "bitbucket.org";
+/** Matches: /owner/repo[/src/ref/path] */
+const BITBUCKET_PATH_PATTERN = /^\/([^/]+)\/([^/]+?)(?:\.git)?(?:\/src\/([^/]+)(?:\/(.+))?)?$/;
+const decodeBitbucketSourceParams = Schema.decodeUnknownResult(BitbucketSourceParamsSchema);
+export const parseUrl = (url, hostname = CANONICAL_HOSTNAME) => {
+    if (url.hostname !== hostname) {
+        return Effect.fail(new SourceSyntaxInvalid({
+            detail: "Invalid Bitbucket URL format",
+        }));
+    }
+    const match = url.pathname.match(BITBUCKET_PATH_PATTERN);
+    if (!match || !match[1] || !match[2]) {
+        return Effect.fail(new SourceSyntaxInvalid({
+            detail: "Invalid Bitbucket URL format",
+        }));
+    }
+    const fragmentRef = Option.getOrUndefined(refFromUrlHash(url));
+    const decoded = decodeBitbucketSourceParams({
+        type: "bitbucket",
+        owner: match[1],
+        repo: match[2],
+        ...(match[3] === undefined
+            ? fragmentRef === undefined
+                ? {}
+                : { ref: fragmentRef }
+            : { ref: match[3] }),
+        ...(match[4] === undefined ? {} : { subPath: match[4] }),
+    });
+    return Result.isSuccess(decoded)
+        ? Effect.succeed(decoded.success)
+        : Effect.fail(new SourceSyntaxInvalid({
+            detail: "Invalid Bitbucket URL format",
+        }));
+};
+//# sourceMappingURL=url.js.map

package/dist/src/providers/convention-discovery.d.ts

@@ -0,0 +1,11 @@
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import { type SourceError } from "../errors.js";
+import { type ExtensionRef } from "@agentxm/extension-model/unstable/extensions/refs/extension-ref";
+import type { FindOptions } from "@agentxm/extension-model/unstable/sources/source-host-provider";
+import type { GitBasedSource, LocalSource } from "@agentxm/extension-model/unstable/sources/types";
+type ExternalSource = GitBasedSource | LocalSource;
+export declare const discoverConventionRefs: (source: ExternalSource, basePath: string, options: FindOptions) => Effect.Effect<ReadonlyArray<ExtensionRef>, SourceError, FileSystem.FileSystem | Path.Path>;
+export {};
+//# sourceMappingURL=convention-discovery.d.ts.map

package/dist/src/providers/convention-discovery.js

@@ -0,0 +1,473 @@
+import * as Array from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Option from "effect/Option";
+import * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
+import { SourceNotResolvable } from "../errors.js";
+import { decodeExtensionNameSync, } from "@agentxm/extension-model/unstable/extensions";
+import {} from "@agentxm/extension-model/unstable/extensions/refs/extension-ref";
+import { discoverManifestPackagesInDir } from "../manifest-package-discovery.js";
+import { DISCOVERY_MAX_DEPTH, DISCOVERY_SKIPPED_DIRECTORIES, } from "@agentxm/extension-model/unstable/discovery-walk";
+import { getCommitSha, getTreeSha } from "../git/operations.js";
+import { hookPackagesInDir } from "../hook-package-discovery.js";
+import {} from "@agentxm/extension-model/unstable/extensions/refs/hook";
+import { KNOWLEDGE_MANIFEST_FILENAME, KnowledgeManifestSchema, } from "@agentxm/extension-model/unstable/knowledge";
+import {} from "@agentxm/extension-model/unstable/extensions/refs/knowledge";
+import { rulePackagesInDir } from "../rule-package-discovery.js";
+import {} from "@agentxm/extension-model/unstable/extensions/refs/rule";
+import { MANIFEST_FILENAME, SubagentManifestSchema, } from "@agentxm/extension-model/unstable/subagents/manifest-schema";
+import { MANIFEST_FILENAME as SKILL_MANIFEST_FILENAME, SkillManifestSchema, } from "@agentxm/extension-model/unstable/skills/manifest-schema";
+import { parseSkillMd } from "@agentxm/registry-protocol/unstable/content";
+import {} from "@agentxm/extension-model/unstable/extensions/refs/skill";
+import { fileUrlToPath } from "../file-url.js";
+// Directory reads reuse the repository's existing sixteen-read archive cap.
+// Git metadata probes stay serial because they spawn subprocesses and no
+// higher subprocess capacity has been established.
+const FILESYSTEM_DISCOVERY_CONCURRENCY = 16;
+const GIT_METADATA_CONCURRENCY = 1;
+const matchesIdentity = (candidate, options) => {
+    const nameMatch = options.names.length === 0 || options.names.includes(candidate.name);
+    const ownerMatch = Option.isNone(options.owner) ||
+        (candidate.owner !== undefined && candidate.owner === options.owner.value);
+    return nameMatch && ownerMatch;
+};
+const relativeDir = (basePath, location) => Effect.gen(function* () {
+    const path = yield* Path.Path;
+    return path.relative(basePath, fileUrlToPath(location));
+});
+const gitTreeShaFor = (source, basePath, location) => relativeDir(basePath, location).pipe(Effect.flatMap((dir) => getTreeSha(basePath, dir)));
+const gitCommitShaFor = (basePath) => getCommitSha(basePath);
+const subPathForSource = (source) => {
+    switch (source.type) {
+        case "github":
+        case "gitlab":
+        case "bitbucket":
+        case "azurerepos":
+            return source.subPath;
+        case "git":
+        case "local":
+            return Option.none();
+    }
+};
+const discoverSkillPackagesInDir = discoverManifestPackagesInDir({
+    type: "skill",
+    manifestFilename: SKILL_MANIFEST_FILENAME,
+    manifestSchema: SkillManifestSchema,
+});
+const readPortableSkillDiscovery = (dir) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const hasPackageManifest = yield* fs
+        .exists(path.join(dir, SKILL_MANIFEST_FILENAME))
+        .pipe(Effect.catch(() => Effect.succeed(false)));
+    const isAxmPackageContent = path.basename(dir) === "src" &&
+        (yield* fs
+            .exists(path.join(path.dirname(dir), SKILL_MANIFEST_FILENAME))
+            .pipe(Effect.catch(() => Effect.succeed(false))));
+    if (hasPackageManifest || isAxmPackageContent) {
+        return Option.none();
+    }
+    const content = yield* fs.readFileString(path.join(dir, "SKILL.md")).pipe(Effect.option);
+    if (Option.isNone(content))
+        return Option.none();
+    const skill = parseSkillMd(content.value, path.basename(dir));
+    if (Option.isNone(skill))
+        return Option.none();
+    const name = decodeExtensionNameSync(skill.value.name);
+    return Option.some({
+        type: "skill",
+        name,
+        skill: {
+            name,
+            description: Option.some(skill.value.description),
+            metadata: skill.value.metadata,
+        },
+        location: `file://${dir}`,
+    });
+});
+const portableSkillDiscoveries = (root) => Effect.gen(function* () {
+    const dirs = yield* manifestDirs(root, "SKILL.md");
+    const discoveries = yield* Effect.forEach(dirs, readPortableSkillDiscovery, {
+        concurrency: FILESYSTEM_DISCOVERY_CONCURRENCY,
+    });
+    return discoveries.flatMap((discovery) => (Option.isSome(discovery) ? [discovery.value] : []));
+});
+const portableSkillRefsInDir = (source, basePath, options) => Effect.gen(function* () {
+    const root = yield* searchRootFor(source, basePath);
+    const discoveries = yield* portableSkillDiscoveries(root);
+    const matching = discoveries.filter((discovery) => matchesIdentity(discovery, options));
+    return yield* Effect.forEach(matching, (discovery) => Effect.gen(function* () {
+        const sourcePath = yield* relativeDir(basePath, discovery.location);
+        switch (source.type) {
+            case "local":
+                return {
+                    type: "skill",
+                    refType: "local",
+                    name: discovery.name,
+                    skill: discovery.skill,
+                    source,
+                    sourcePath,
+                    portable: true,
+                    location: discovery.location,
+                };
+            case "github":
+            case "gitlab":
+            case "bitbucket":
+            case "azurerepos":
+            case "git":
+                return {
+                    type: "skill",
+                    refType: "git-hosted",
+                    name: discovery.name,
+                    skill: discovery.skill,
+                    source,
+                    sourcePath,
+                    portable: true,
+                    location: discovery.location,
+                    gitTreeSha: yield* gitTreeShaFor(source, basePath, discovery.location),
+                    gitCommitSha: yield* gitCommitShaFor(basePath),
+                };
+        }
+    }), { concurrency: GIT_METADATA_CONCURRENCY });
+});
+const skillRefsInDir = (source, basePath, options) => searchRootFor(source, basePath).pipe(Effect.flatMap((root) => discoverSkillPackagesInDir(root, { fullDepth: true })), Effect.flatMap((skills) => Effect.forEach(skills.filter(({ manifest }) => matchesIdentity(manifest, options)), (discovered) => Effect.gen(function* () {
+    const skill = {
+        name: discovered.manifest.name,
+        description: Option.fromUndefinedOr(discovered.manifest.description),
+        metadata: Option.none(),
+    };
+    const identity = {
+        owner: discovered.manifest.owner,
+        name: discovered.manifest.name,
+    };
+    switch (source.type) {
+        case "local":
+            return {
+                type: "skill",
+                refType: "local",
+                skill,
+                ...identity,
+                source,
+                location: discovered.location,
+                sourcePath: yield* relativeDir(basePath, discovered.location),
+            };
+        case "github":
+        case "gitlab":
+        case "bitbucket":
+        case "azurerepos":
+        case "git":
+            return {
+                type: "skill",
+                refType: "git-hosted",
+                skill,
+                ...identity,
+                source,
+                location: discovered.location,
+                sourcePath: yield* relativeDir(basePath, discovered.location),
+                gitTreeSha: yield* gitTreeShaFor(source, basePath, discovered.location),
+                gitCommitSha: yield* gitCommitShaFor(basePath),
+            };
+    }
+}), { concurrency: GIT_METADATA_CONCURRENCY })));
+const searchRootFor = (source, basePath) => Effect.gen(function* () {
+    const path = yield* Path.Path;
+    if (source.type === "local")
+        return source.path;
+    return Option.match(subPathForSource(source), {
+        onNone: () => basePath,
+        onSome: (subPath) => path.join(basePath, subPath),
+    });
+});
+const manifestDirs = (root, manifestFilename) => {
+    const scan = (dir, depth) => Effect.gen(function* () {
+        if (depth > DISCOVERY_MAX_DEPTH)
+            return [];
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+        const entries = yield* fs.readDirectory(dir).pipe(Effect.option);
+        if (Option.isNone(entries))
+            return [];
+        const hasManifest = entries.value.includes(manifestFilename);
+        const childDirs = yield* Effect.forEach(entries.value, (entry) => Effect.gen(function* () {
+            if (DISCOVERY_SKIPPED_DIRECTORIES.has(entry))
+                return [];
+            const fullPath = path.join(dir, entry);
+            const stat = yield* fs.stat(fullPath).pipe(Effect.option);
+            if (Option.isNone(stat) || stat.value.type !== "Directory")
+                return [];
+            return yield* scan(fullPath, depth + 1);
+        }), { concurrency: FILESYSTEM_DISCOVERY_CONCURRENCY }).pipe(Effect.map((results) => Array.flatten(results)));
+        return hasManifest ? [dir, ...childDirs] : childDirs;
+    });
+    return scan(root, 0);
+};
+const readSubagentDiscovery = (dir) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const manifestPath = path.join(dir, MANIFEST_FILENAME);
+    const raw = yield* fs.readFileString(manifestPath).pipe(Effect.option);
+    if (Option.isNone(raw))
+        return Option.none();
+    const json = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown))(raw.value).pipe(Effect.option);
+    if (Option.isNone(json))
+        return Option.none();
+    const manifest = yield* Schema.decodeUnknownEffect(SubagentManifestSchema)(json.value).pipe(Effect.option);
+    if (Option.isNone(manifest))
+        return Option.none();
+    return Option.some({
+        type: "subagent",
+        owner: manifest.value.owner,
+        name: manifest.value.name,
+        description: Option.fromUndefinedOr(manifest.value.description),
+        location: `file://${dir}`,
+    });
+});
+const readKnowledgeDiscovery = (dir) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const manifestPath = path.join(dir, KNOWLEDGE_MANIFEST_FILENAME);
+    const raw = yield* fs.readFileString(manifestPath).pipe(Effect.option);
+    if (Option.isNone(raw))
+        return Option.none();
+    const json = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown))(raw.value).pipe(Effect.option);
+    if (Option.isNone(json))
+        return Option.none();
+    const manifest = yield* Schema.decodeUnknownEffect(KnowledgeManifestSchema)(json.value).pipe(Effect.option);
+    if (Option.isNone(manifest))
+        return Option.none();
+    return Option.some({
+        type: "knowledge",
+        owner: manifest.value.owner,
+        name: manifest.value.name,
+        location: `file://${dir}`,
+    });
+});
+const subagentDiscoveries = (root) => Effect.gen(function* () {
+    const dirs = yield* manifestDirs(root, MANIFEST_FILENAME);
+    const discoveries = yield* Effect.forEach(dirs, (dir) => readSubagentDiscovery(dir), {
+        concurrency: FILESYSTEM_DISCOVERY_CONCURRENCY,
+    });
+    return discoveries.flatMap((discovery) => (Option.isSome(discovery) ? [discovery.value] : []));
+});
+const knowledgeDiscoveries = (root) => Effect.gen(function* () {
+    const dirs = yield* manifestDirs(root, KNOWLEDGE_MANIFEST_FILENAME);
+    const discoveries = yield* Effect.forEach(dirs, (dir) => readKnowledgeDiscovery(dir), {
+        concurrency: FILESYSTEM_DISCOVERY_CONCURRENCY,
+    });
+    return discoveries.flatMap((discovery) => (Option.isSome(discovery) ? [discovery.value] : []));
+});
+const subagentRef = (source, basePath, discovery) => Effect.gen(function* () {
+    const subagent = { name: discovery.name, description: discovery.description };
+    const identity = { owner: discovery.owner, name: discovery.name };
+    switch (source.type) {
+        case "local":
+            return {
+                type: "subagent",
+                refType: "local",
+                subagent,
+                ...identity,
+                source,
+                location: discovery.location,
+                sourcePath: yield* relativeDir(basePath, discovery.location),
+            };
+        case "github":
+        case "gitlab":
+        case "bitbucket":
+        case "azurerepos":
+        case "git":
+            return {
+                type: "subagent",
+                refType: "git-hosted",
+                subagent,
+                ...identity,
+                source,
+                location: discovery.location,
+                sourcePath: yield* relativeDir(basePath, discovery.location),
+                gitTreeSha: yield* gitTreeShaFor(source, basePath, discovery.location),
+                gitCommitSha: yield* gitCommitShaFor(basePath),
+            };
+    }
+});
+const knowledgeRef = (source, basePath, discovery) => Effect.gen(function* () {
+    const knowledge = { name: discovery.name };
+    const identity = { owner: discovery.owner, name: discovery.name };
+    switch (source.type) {
+        case "local":
+            return {
+                type: "knowledge",
+                refType: "local",
+                knowledge,
+                ...identity,
+                source,
+                location: discovery.location,
+                sourcePath: yield* relativeDir(basePath, discovery.location),
+            };
+        case "github":
+        case "gitlab":
+        case "bitbucket":
+        case "azurerepos":
+        case "git":
+            return {
+                type: "knowledge",
+                refType: "git-hosted",
+                knowledge,
+                ...identity,
+                source,
+                location: discovery.location,
+                sourcePath: yield* relativeDir(basePath, discovery.location),
+                gitTreeSha: yield* gitTreeShaFor(source, basePath, discovery.location),
+                gitCommitSha: yield* gitCommitShaFor(basePath),
+            };
+    }
+});
+const subagentRefsInDir = (source, basePath, options) => Effect.gen(function* () {
+    const root = yield* searchRootFor(source, basePath);
+    const discoveries = yield* subagentDiscoveries(root);
+    const matching = discoveries.filter((discovery) => matchesIdentity(discovery, options));
+    return yield* Effect.forEach(matching, (discovery) => subagentRef(source, basePath, discovery), { concurrency: GIT_METADATA_CONCURRENCY });
+});
+const knowledgeRefsInDir = (source, basePath, options) => Effect.gen(function* () {
+    const root = yield* searchRootFor(source, basePath);
+    const discoveries = yield* knowledgeDiscoveries(root);
+    const matching = discoveries.filter((discovery) => matchesIdentity(discovery, options));
+    return yield* Effect.forEach(matching, (discovery) => knowledgeRef(source, basePath, discovery), { concurrency: GIT_METADATA_CONCURRENCY });
+});
+const ruleRefsInDir = (source, basePath, options) => Effect.gen(function* () {
+    const root = yield* searchRootFor(source, basePath);
+    const discovered = yield* rulePackagesInDir(root, { fullDepth: true });
+    const matching = discovered.filter(({ manifest }) => matchesIdentity(manifest, options));
+    return yield* Effect.forEach(matching, (discovery) => Effect.gen(function* () {
+        const rule = { name: discovery.manifest.name };
+        const identity = {
+            owner: discovery.manifest.owner,
+            name: discovery.manifest.name,
+        };
+        switch (source.type) {
+            case "local":
+                return {
+                    type: "rule",
+                    refType: "local",
+                    rule,
+                    ...identity,
+                    source,
+                    location: discovery.location,
+                    sourcePath: yield* relativeDir(basePath, discovery.location),
+                };
+            case "github":
+            case "gitlab":
+            case "bitbucket":
+            case "azurerepos":
+            case "git":
+                return {
+                    type: "rule",
+                    refType: "git-hosted",
+                    rule,
+                    ...identity,
+                    source,
+                    location: discovery.location,
+                    sourcePath: yield* relativeDir(basePath, discovery.location),
+                    gitTreeSha: yield* gitTreeShaFor(source, basePath, discovery.location),
+                    gitCommitSha: yield* gitCommitShaFor(basePath),
+                };
+        }
+    }), { concurrency: GIT_METADATA_CONCURRENCY });
+});
+const hookRefsInDir = (source, basePath, options) => Effect.gen(function* () {
+    const root = yield* searchRootFor(source, basePath);
+    const discovered = yield* hookPackagesInDir(root, { fullDepth: true });
+    const matching = discovered.filter(({ manifest }) => matchesIdentity(manifest, options));
+    return yield* Effect.forEach(matching, (discovery) => Effect.gen(function* () {
+        const hook = { name: discovery.manifest.name };
+        const identity = {
+            owner: discovery.manifest.owner,
+            name: discovery.manifest.name,
+        };
+        switch (source.type) {
+            case "local":
+                return {
+                    type: "hook",
+                    refType: "local",
+                    hook,
+                    ...identity,
+                    source,
+                    location: discovery.location,
+                    sourcePath: yield* relativeDir(basePath, discovery.location),
+                };
+            case "github":
+            case "gitlab":
+            case "bitbucket":
+            case "azurerepos":
+            case "git":
+                return {
+                    type: "hook",
+                    refType: "git-hosted",
+                    hook,
+                    ...identity,
+                    source,
+                    location: discovery.location,
+                    sourcePath: yield* relativeDir(basePath, discovery.location),
+                    gitTreeSha: yield* gitTreeShaFor(source, basePath, discovery.location),
+                    gitCommitSha: yield* gitCommitShaFor(basePath),
+                };
+        }
+    }), { concurrency: GIT_METADATA_CONCURRENCY });
+});
+const identityKey = (ref) => {
+    switch (ref.type) {
+        case "subagent":
+            return `${ref.type}:${ref.subagent.name}`;
+        case "rule":
+            return `${ref.type}:${ref.rule.name}`;
+        case "hook":
+            return `${ref.type}:${ref.hook.name}`;
+        case "knowledge":
+            return `${ref.type}:${ref.knowledge.name}`;
+        case "skill":
+            return `${ref.type}:${ref.skill.name}`;
+        case "mcp-server":
+            return `${ref.type}:${ref.server.name}`;
+        case "pack":
+            return `${ref.type}:${ref.owner}:${ref.pack.name}`;
+    }
+};
+const rejectAmbiguousDuplicates = (refs) => Effect.gen(function* () {
+    const seen = new Set();
+    for (const ref of refs) {
+        const key = identityKey(ref);
+        if (key === undefined)
+            continue;
+        if (seen.has(key)) {
+            return yield* new SourceNotResolvable({
+                category: "validation",
+                detail: `Multiple discovered extensions declare the same identity: ${key}`,
+            });
+        }
+        seen.add(key);
+    }
+    return refs;
+});
+export const discoverConventionRefs = (source, basePath, options) => Effect.gen(function* () {
+    const refs = [
+        ...(options.type === "skill" || options.type === "*"
+            ? [
+                ...(yield* skillRefsInDir(source, basePath, options)),
+                ...(yield* portableSkillRefsInDir(source, basePath, options)),
+            ]
+            : []),
+        ...(options.type === "subagent" || options.type === "*"
+            ? yield* subagentRefsInDir(source, basePath, options)
+            : []),
+        ...(options.type === "rule" || options.type === "*"
+            ? yield* ruleRefsInDir(source, basePath, options)
+            : []),
+        ...(options.type === "hook" || options.type === "*"
+            ? yield* hookRefsInDir(source, basePath, options)
+            : []),
+        ...(options.type === "knowledge" || options.type === "*"
+            ? yield* knowledgeRefsInDir(source, basePath, options)
+            : []),
+    ];
+    return yield* rejectAmbiguousDuplicates(refs);
+});
+//# sourceMappingURL=convention-discovery.js.map

package/dist/src/providers/git-hosting.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Shared source provider factory for git hosting platforms (GitHub, GitLab, Bitbucket).
+ *
+ * Wraps existing clone + discover logic into the `SourceHostProvider` interface.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import type * as Scope from "effect/Scope";
+import { type SourceError } from "../errors.js";
+import type { SourceHostProvider } from "@agentxm/extension-model/unstable/sources/source-host-provider";
+import type { GitHubSource, GitLabSource, BitbucketSource, AzureReposSource, GitHostingSourceHost } from "@agentxm/extension-model/unstable/sources/types";
+/**
+ * Creates a `SourceHostProvider` for a git hosting platform.
+ *
+ * Constructed with a `SourceHost` that provides the host URL.
+ * The `match` method checks if a URL's hostname matches the configured host.
+ * The `find` implementation clones the repository into a scoped temp directory,
+ * discovers skills via the 3-phase algorithm, and enriches each with its git
+ * tree SHA.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const createGitHostingSourceHostProvider: <S extends GitHubSource | GitLabSource | BitbucketSource | AzureReposSource>(host: Extract<GitHostingSourceHost, {
+    type: S["type"];
+}>) => SourceHostProvider<S, FileSystem.FileSystem | Path.Path | Scope.Scope, SourceError>;
+/** Build a clone URL from a git hosting source (internal helper). */
+export declare const buildCloneUrlForSource: (source: GitHubSource | GitLabSource | BitbucketSource | AzureReposSource) => string;
+//# sourceMappingURL=git-hosting.d.ts.map

package/dist/src/providers/git-hosting.js

@@ -0,0 +1,73 @@
+/**
+ * Shared source provider factory for git hosting platforms (GitHub, GitLab, Bitbucket).
+ *
+ * Wraps existing clone + discover logic into the `SourceHostProvider` interface.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { SourceNetworkFailure } from "../errors.js";
+import { shallowClone } from "../git/operations.js";
+import { fileUrlToPath } from "../file-url.js";
+import { discoverConventionRefs } from "./convention-discovery.js";
+// -----------------------------------------------------------------------------
+// New Factory (SourceHostProvider)
+// -----------------------------------------------------------------------------
+/**
+ * Creates a `SourceHostProvider` for a git hosting platform.
+ *
+ * Constructed with a `SourceHost` that provides the host URL.
+ * The `match` method checks if a URL's hostname matches the configured host.
+ * The `find` implementation clones the repository into a scoped temp directory,
+ * discovers skills via the 3-phase algorithm, and enriches each with its git
+ * tree SHA.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const createGitHostingSourceHostProvider = (host) => ({
+    type: host.type,
+    match: (url) => Effect.succeed(url.hostname === host.url.hostname),
+    find: (source, options) => Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const cloneUrl = buildCloneUrlForSource(source);
+        // Acquire scoped temp directory (cleaned up when the scope closes)
+        const tempDir = yield* Effect.acquireRelease(fs.makeTempDirectory({ prefix: "axm-source-discovery-" }).pipe(Effect.mapError((error) => new SourceNetworkFailure({
+            detail: "Temporary source directory could not be created",
+            cause: error,
+        }))), (dir) => fs.remove(dir, { recursive: true }).pipe(Effect.ignore));
+        yield* shallowClone(cloneUrl, tempDir, Option.getOrUndefined(source.ref));
+        return yield* discoverConventionRefs(source, tempDir, options);
+    }),
+    fetch: (_source, _ref) => {
+        if (_ref.refType !== "git-hosted") {
+            return Effect.fail(new SourceNetworkFailure({
+                detail: `Expected ref with location for ${host.type} source, but none was provided`,
+            }));
+        }
+        return Effect.succeed({
+            directory: fileUrlToPath(_ref.location),
+        });
+    },
+});
+/** Build a clone URL from a git hosting source (internal helper). */
+export const buildCloneUrlForSource = (source) => {
+    const explicitCloneUrl = Option.getOrUndefined(source.cloneUrl ?? Option.none());
+    if (explicitCloneUrl !== undefined) {
+        return explicitCloneUrl;
+    }
+    switch (source.type) {
+        case "github":
+            return `${source.url.origin}/${source.owner}/${source.repo}.git`;
+        case "gitlab":
+            return `${source.url.origin}/${source.owner}/${source.repo}.git`;
+        case "bitbucket":
+            return `${source.url.origin}/${source.owner}/${source.repo}.git`;
+        case "azurerepos":
+            return `${source.url.origin}/${source.organization}/${source.project}/_git/${source.repo}`;
+    }
+};
+//# sourceMappingURL=git-hosting.js.map

package/dist/src/providers/git.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Source provider for generic git repositories.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import type * as Scope from "effect/Scope";
+import { type SourceError } from "../errors.js";
+import type { SourceHostProvider } from "@agentxm/extension-model/unstable/sources/source-host-provider";
+import type { GitSource } from "@agentxm/extension-model/unstable/sources/types";
+/**
+ * Source host provider for generic git URLs.
+ *
+ * Self-describing — no host config needed.
+ * `match` returns true for git://, ssh://, and git@... URL schemes.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const createGitSourceHostProvider: () => SourceHostProvider<GitSource, FileSystem.FileSystem | Path.Path | Scope.Scope, SourceError>;
+//# sourceMappingURL=git.d.ts.map