@agentxm/extension-sources 0.28.4-bootstrap.0

package/dist/src/package-discovery.js

@@ -0,0 +1,137 @@
+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 { DISCOVERY_MAX_DEPTH, DISCOVERY_SKIPPED_DIRECTORIES, } from "@agentxm/extension-model/unstable/discovery-walk";
+import { ManifestIdentitySchema, manifestFilenameForType, manifestSchemaForType, validateManifestHasNoAgentsField, } from "@agentxm/registry-protocol/unstable/publish/manifest-policy";
+const typeForManifestFilename = (fileName) => {
+    switch (fileName) {
+        case "skill.json":
+            return "skill";
+        case "mcp.json":
+            return "mcp-server";
+        case "subagent.json":
+            return "subagent";
+        case "rule.json":
+            return "rule";
+        case "hook.json":
+            return "hook";
+        case "knowledge.json":
+            return "knowledge";
+        case "pack.json":
+            return "pack";
+        default:
+            return undefined;
+    }
+};
+const matchesFilter = (identity, filter) => (filter.type === "*" || filter.type === identity.type) &&
+    (filter.names.length === 0 || filter.names.includes(identity.name)) &&
+    (Option.isNone(filter.owner) || filter.owner.value === identity.owner);
+export const inspectExtensionPackage = (directory) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const entries = yield* fs.readDirectory(directory).pipe(Effect.mapError((cause) => new SourceNotResolvable({
+        category: "validation",
+        detail: `AXM package directory could not be read: ${directory}`,
+        cause,
+    })));
+    const manifestEntries = entries
+        .filter((entry) => typeForManifestFilename(entry) !== undefined)
+        .sort();
+    const manifestFile = manifestEntries[0];
+    if (manifestFile === undefined) {
+        return yield* new SourceNotResolvable({
+            category: "validation",
+            detail: `No AXM extension manifest was found at ${directory}; use skills import or subagents import for supported unmanaged/native content`,
+        });
+    }
+    if (manifestEntries.length > 1) {
+        return yield* new SourceNotResolvable({
+            category: "validation",
+            detail: `Multiple AXM extension manifests were found at ${directory}: ${manifestEntries.join(", ")}`,
+        });
+    }
+    const type = typeForManifestFilename(manifestFile);
+    if (type === undefined) {
+        return yield* new SourceNotResolvable({
+            category: "internal",
+            detail: `Manifest type could not be determined for ${manifestFile}`,
+        });
+    }
+    const manifestPath = path.join(directory, manifestFile);
+    const text = yield* fs.readFileString(manifestPath).pipe(Effect.mapError((cause) => new SourceNotResolvable({
+        category: "validation",
+        detail: `AXM manifest could not be read: ${manifestPath}`,
+        cause,
+    })));
+    const raw = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown))(text).pipe(Effect.mapError((cause) => new SourceNotResolvable({
+        category: "validation",
+        detail: `AXM manifest contains invalid JSON: ${manifestPath}`,
+        cause,
+    })));
+    yield* Effect.fromResult(validateManifestHasNoAgentsField(manifestFile, raw)).pipe(Effect.mapError((cause) => new SourceNotResolvable({ category: "validation", detail: cause.detail, cause })));
+    yield* Schema.decodeUnknownEffect(manifestSchemaForType(type))(raw).pipe(Effect.mapError((cause) => new SourceNotResolvable({
+        category: "validation",
+        detail: `AXM manifest does not conform to ${manifestFile}: ${manifestPath}`,
+        cause,
+    })));
+    const identity = yield* Schema.decodeUnknownEffect(ManifestIdentitySchema)(raw).pipe(Effect.mapError((cause) => new SourceNotResolvable({
+        category: "validation",
+        detail: `AXM manifest identity is invalid: ${manifestPath}`,
+        cause,
+    })));
+    if (identity.type !== type || manifestFilenameForType(identity.type) !== manifestFile) {
+        return yield* new SourceNotResolvable({
+            category: "validation",
+            detail: `AXM manifest filename and declared type disagree: ${manifestPath}`,
+        });
+    }
+    return { directory, identity };
+});
+export const discoverExtensionPackages = (root, filter) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const scan = (directory, depth) => Effect.gen(function* () {
+        if (depth > DISCOVERY_MAX_DEPTH)
+            return [];
+        const entries = yield* fs.readDirectory(directory).pipe(Effect.mapError((cause) => new SourceNotResolvable({
+            category: "validation",
+            detail: `Extension source directory could not be read: ${directory}`,
+            cause,
+        })));
+        const manifests = entries.filter((entry) => typeForManifestFilename(entry) !== undefined);
+        if (manifests.length > 0) {
+            const candidate = yield* inspectExtensionPackage(directory).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path));
+            return matchesFilter(candidate.identity, filter) ? [candidate] : [];
+        }
+        if (depth === DISCOVERY_MAX_DEPTH)
+            return [];
+        const children = yield* Effect.forEach(entries.filter((entry) => !DISCOVERY_SKIPPED_DIRECTORIES.has(entry)).sort(), (entry) => Effect.gen(function* () {
+            const child = path.join(directory, entry);
+            const link = yield* fs.readLink(child).pipe(Effect.option);
+            if (Option.isSome(link))
+                return [];
+            const info = yield* fs.stat(child).pipe(Effect.option);
+            if (Option.isNone(info) || info.value.type !== "Directory")
+                return [];
+            return yield* scan(child, depth + 1);
+        }), { concurrency: 16 });
+        return children.flat();
+    });
+    const exists = yield* fs.exists(root).pipe(Effect.mapError((cause) => new SourceNotResolvable({
+        category: "validation",
+        detail: `Source does not exist: ${root}`,
+        cause,
+    })));
+    if (!exists) {
+        return yield* new SourceNotResolvable({
+            category: "not_found",
+            detail: `Source does not exist: ${root}`,
+        });
+    }
+    const packages = yield* scan(path.resolve(root), 0);
+    return [...packages].sort((left, right) => left.directory.localeCompare(right.directory));
+});
+//# sourceMappingURL=package-discovery.js.map

package/dist/src/package-sources.d.ts

@@ -0,0 +1,25 @@
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import type * as Scope from "effect/Scope";
+import { type SourceResolutionFailure } from "./errors.js";
+import type { Source } from "@agentxm/extension-model/unstable/sources/types";
+import { SourceHostProviders } from "./service.js";
+import { type DiscoveredExtensionPackage, type ExtensionPackageFilter } from "./package-discovery.js";
+export interface ResolvedExtensionPackage extends DiscoveredExtensionPackage {
+    readonly origin: string;
+}
+export interface AcquiredExternalSource {
+    readonly directory: string;
+    readonly origin: string;
+}
+/** Acquire a stable local view of a local or Git source for the current scope. */
+export declare const acquireExternalSource: (source: Source) => Effect.Effect<AcquiredExternalSource, SourceResolutionFailure, FileSystem.FileSystem | Path.Path | SourceHostProviders | Scope.Scope>;
+/**
+ * Discover only manifest-backed AXM packages from a resolved source.
+ *
+ * Native convention discovery intentionally remains separate so callers can
+ * never mistake unmanaged content for a forkable AXM package.
+ */
+export declare const findExtensionPackagesFromSource: (source: Source, filter: ExtensionPackageFilter) => Effect.Effect<ReadonlyArray<ResolvedExtensionPackage>, SourceResolutionFailure, FileSystem.FileSystem | Path.Path | SourceHostProviders | Scope.Scope>;
+//# sourceMappingURL=package-sources.d.ts.map

package/dist/src/package-sources.js

@@ -0,0 +1,102 @@
+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 { SourceNetworkFailure, SourceNotResolvable, } from "./errors.js";
+import { shallowClone } from "./git/operations.js";
+import { buildCloneUrlForSource } from "./providers/git-hosting.js";
+import { SourceHostProviders } from "./service.js";
+import { discoverExtensionPackages, inspectExtensionPackage, } from "./package-discovery.js";
+const acquireClone = (cloneUrl, ref) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const tempDir = yield* Effect.acquireRelease(fs.makeTempDirectory({ prefix: "axm-source-clone-" }).pipe(Effect.mapError((cause) => new SourceNetworkFailure({
+        detail: "Temporary package source directory could not be created",
+        cause,
+    }))), (directory) => fs.remove(directory, { recursive: true }).pipe(Effect.ignore));
+    yield* shallowClone(cloneUrl, tempDir, Option.getOrUndefined(ref));
+    return tempDir;
+});
+/** Acquire a stable local view of a local or Git source for the current scope. */
+export const acquireExternalSource = (source) => Effect.gen(function* () {
+    const path = yield* Path.Path;
+    const providers = yield* SourceHostProviders;
+    const origin = providers.origin(source);
+    switch (source.type) {
+        case "local":
+            return { directory: source.path, origin };
+        case "git":
+            return { directory: yield* acquireClone(source.url.href, source.ref), origin };
+        case "github":
+        case "gitlab":
+        case "bitbucket":
+        case "azurerepos": {
+            const cloneRoot = yield* acquireClone(buildCloneUrlForSource(source), source.ref);
+            return {
+                directory: Option.match(source.subPath, {
+                    onNone: () => cloneRoot,
+                    onSome: (subPath) => path.join(cloneRoot, subPath),
+                }),
+                origin,
+            };
+        }
+        case "registry":
+        case "workspace":
+            return yield* new SourceNotResolvable({
+                category: "validation",
+                detail: "Native import accepts local or Git sources; use fork for managed AXM sources",
+            });
+    }
+});
+/**
+ * Discover only manifest-backed AXM packages from a resolved source.
+ *
+ * Native convention discovery intentionally remains separate so callers can
+ * never mistake unmanaged content for a forkable AXM package.
+ */
+export const findExtensionPackagesFromSource = (source, filter) => Effect.gen(function* () {
+    const path = yield* Path.Path;
+    const providers = yield* SourceHostProviders;
+    const origin = providers.origin(source);
+    switch (source.type) {
+        case "local": {
+            const packages = yield* discoverExtensionPackages(source.path, filter);
+            return packages.map((candidate) => ({ ...candidate, origin }));
+        }
+        case "git": {
+            const cloneRoot = yield* acquireClone(source.url.href, source.ref);
+            const packages = yield* discoverExtensionPackages(cloneRoot, filter);
+            return packages.map((candidate) => ({ ...candidate, origin }));
+        }
+        case "github":
+        case "gitlab":
+        case "bitbucket":
+        case "azurerepos": {
+            const cloneRoot = yield* acquireClone(buildCloneUrlForSource(source), source.ref);
+            const discoveryRoot = Option.match(source.subPath, {
+                onNone: () => cloneRoot,
+                onSome: (subPath) => path.join(cloneRoot, subPath),
+            });
+            const packages = yield* discoverExtensionPackages(discoveryRoot, filter);
+            return packages.map((candidate) => ({ ...candidate, origin }));
+        }
+        case "registry": {
+            const refs = yield* providers.find(source, {
+                names: filter.names,
+                owner: filter.owner,
+                type: filter.type,
+                versionRange: Option.none(),
+            });
+            return yield* Effect.forEach(refs, (ref) => Effect.gen(function* () {
+                const files = yield* providers.fetch(ref);
+                const candidate = yield* inspectExtensionPackage(files.directory);
+                return { ...candidate, origin };
+            }), { concurrency: 8 });
+        }
+        case "workspace":
+            return yield* new SourceNotResolvable({
+                category: "validation",
+                detail: "Workspace packages resolve from their canonical managed path",
+            });
+    }
+});
+//# sourceMappingURL=package-sources.js.map

package/dist/src/providers/azurerepos/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Azure Repos source parsing.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+export { checkAzureReposRepoExists } from "./repo-exists.js";
+export { parseUrl } from "./url.js";
+export { parseScp } from "./scp.js";
+export { parseShorthand } from "./shorthand.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/providers/azurerepos/index.js

@@ -0,0 +1,11 @@
+/**
+ * Azure Repos source parsing.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+export { checkAzureReposRepoExists } from "./repo-exists.js";
+export { parseUrl } from "./url.js";
+export { parseScp } from "./scp.js";
+export { parseShorthand } from "./shorthand.js";
+//# sourceMappingURL=index.js.map

package/dist/src/providers/azurerepos/repo-exists.d.ts

@@ -0,0 +1,5 @@
+import * as Effect from "effect/Effect";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import { SourceNotResolvable } from "../../errors.js";
+export declare const checkAzureReposRepoExists: (organization: string, project: string, repo: string) => Effect.Effect<void, SourceNotResolvable, HttpClient.HttpClient>;
+//# sourceMappingURL=repo-exists.d.ts.map

package/dist/src/providers/azurerepos/repo-exists.js

@@ -0,0 +1,21 @@
+import * as Effect from "effect/Effect";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
+import { SourceNotResolvable } from "../../errors.js";
+export const checkAzureReposRepoExists = (organization, project, repo) => Effect.gen(function* () {
+    const client = yield* HttpClient.HttpClient;
+    const url = `https://dev.azure.com/${organization}/${project}/_git/${repo}`;
+    const request = HttpClientRequest.head(url);
+    const response = yield* client.execute(request).pipe(Effect.mapError((error) => new SourceNotResolvable({
+        category: "validation",
+        detail: `Failed to check Azure Repos: ${error instanceof Error ? error.message : String(error)}`,
+        cause: error,
+    })));
+    if (response.status < 200 || response.status >= 300) {
+        return yield* new SourceNotResolvable({
+            category: "validation",
+            detail: `Not found on Azure Repos`,
+        });
+    }
+});
+//# sourceMappingURL=repo-exists.js.map

package/dist/src/providers/azurerepos/scp.d.ts

@@ -0,0 +1,12 @@
+import * as Effect from "effect/Effect";
+import { SourceSyntaxInvalid } from "../../errors.js";
+export declare const parseScp: (input: string, hostname?: string) => Effect.Effect<never, SourceSyntaxInvalid, never> | Effect.Effect<{
+    readonly type: "azurerepos";
+    readonly repo: string;
+    readonly ref: import("effect/Option").Option<string>;
+    readonly subPath: import("effect/Option").Option<string>;
+    readonly organization: string;
+    readonly project: string;
+    readonly sourceName?: string | undefined;
+}, never, never>;
+//# sourceMappingURL=scp.d.ts.map

package/dist/src/providers/azurerepos/scp.js

@@ -0,0 +1,29 @@
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import { SourceSyntaxInvalid } from "../../errors.js";
+import { AzureReposSourceParamsSchema, } from "@agentxm/extension-model/unstable/sources/types";
+const CANONICAL_SSH_HOSTNAME = "ssh.dev.azure.com";
+/** Matches: git@{hostname}:v3/{org}/{project}/{repo} */
+const SCP_PATTERN = /^git@([^:]+):v3\/([^/]+)\/([^/]+)\/([^/]+?)(?:\.git)?$/;
+const decodeAzureReposSourceParams = Schema.decodeUnknownResult(AzureReposSourceParamsSchema);
+export const parseScp = (input, hostname = CANONICAL_SSH_HOSTNAME) => {
+    const match = input.match(SCP_PATTERN);
+    if (!match || !match[1] || !match[2] || !match[3] || !match[4] || match[1] !== hostname) {
+        return Effect.fail(new SourceSyntaxInvalid({
+            detail: "Invalid Azure Repos SSH URL format",
+        }));
+    }
+    const decoded = decodeAzureReposSourceParams({
+        type: "azurerepos",
+        organization: match[2],
+        project: match[3],
+        repo: match[4],
+    });
+    return Result.isSuccess(decoded)
+        ? Effect.succeed(decoded.success)
+        : Effect.fail(new SourceSyntaxInvalid({
+            detail: "Invalid Azure Repos SSH URL format",
+        }));
+};
+//# sourceMappingURL=scp.js.map

package/dist/src/providers/azurerepos/shorthand.d.ts

@@ -0,0 +1,12 @@
+import * as Effect from "effect/Effect";
+import { SourceSyntaxInvalid } from "../../errors.js";
+export declare const parseShorthand: (input: string) => Effect.Effect<never, SourceSyntaxInvalid, never> | Effect.Effect<{
+    readonly type: "azurerepos";
+    readonly repo: string;
+    readonly ref: import("effect/Option").Option<string>;
+    readonly subPath: import("effect/Option").Option<string>;
+    readonly organization: string;
+    readonly project: string;
+    readonly sourceName?: string | undefined;
+}, never, never>;
+//# sourceMappingURL=shorthand.d.ts.map

package/dist/src/providers/azurerepos/shorthand.js

@@ -0,0 +1,45 @@
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import { SourceSyntaxInvalid } from "../../errors.js";
+import { AzureReposSourceParamsSchema, } from "@agentxm/extension-model/unstable/sources/types";
+const decode = Schema.decodeUnknownResult(AzureReposSourceParamsSchema);
+export const parseShorthand = (input) => {
+    const colon = input.indexOf(":");
+    const body = colon < 0 ? input : input.slice(colon + 1);
+    const refIndex = body.lastIndexOf("@");
+    const coordinate = refIndex > 0 ? body.slice(0, refIndex) : body;
+    const ref = refIndex > 0 ? body.slice(refIndex + 1) : undefined;
+    const subPathIndex = coordinate.indexOf("//");
+    const repositoryCoordinate = subPathIndex < 0 ? coordinate : coordinate.slice(0, subPathIndex);
+    const subPath = subPathIndex < 0 ? undefined : coordinate.slice(subPathIndex + 2);
+    const [organization, project, repo, ...extra] = repositoryCoordinate.split("/");
+    if (organization === undefined ||
+        project === undefined ||
+        repo === undefined ||
+        extra.length > 0 ||
+        organization.length === 0 ||
+        project.length === 0 ||
+        repo.length === 0 ||
+        subPath === "" ||
+        ref === "") {
+        return Effect.fail(new SourceSyntaxInvalid({
+            detail: `Invalid Azure Repos shorthand "${input}": expected organization/project/repo[//subpath][@ref]`,
+        }));
+    }
+    const decoded = decode({
+        type: "azurerepos",
+        organization,
+        project,
+        repo,
+        ...(subPath === undefined ? {} : { subPath }),
+        ...(ref === undefined ? {} : { ref }),
+    });
+    return Result.isSuccess(decoded)
+        ? Effect.succeed(decoded.success)
+        : Effect.fail(new SourceSyntaxInvalid({
+            detail: `Invalid Azure Repos shorthand "${input}"`,
+            cause: decoded.failure,
+        }));
+};
+//# sourceMappingURL=shorthand.js.map

package/dist/src/providers/azurerepos/url.d.ts

@@ -0,0 +1,14 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { SourceSyntaxInvalid } from "../../errors.js";
+export declare const CANONICAL_HOSTNAME = "dev.azure.com";
+export declare const parseUrl: (url: URL, hostname?: string) => Effect.Effect<never, SourceSyntaxInvalid, never> | Effect.Effect<{
+    readonly type: "azurerepos";
+    readonly repo: string;
+    readonly ref: Option.Option<string>;
+    readonly subPath: Option.Option<string>;
+    readonly organization: string;
+    readonly project: string;
+    readonly sourceName?: string | undefined;
+}, never, never>;
+//# sourceMappingURL=url.d.ts.map

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

@@ -0,0 +1,38 @@
+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 { AzureReposSourceParamsSchema, } from "@agentxm/extension-model/unstable/sources/types";
+import { refFromUrlHash } from "../../url-fragment.js";
+export const CANONICAL_HOSTNAME = "dev.azure.com";
+/** Matches: /{org}/{project}/_git/{repo} */
+const AZUREREPOS_PATH_PATTERN = /^\/([^/]+)\/([^/]+)\/_git\/([^/]+?)(?:\.git)?$/;
+const decodeAzureReposSourceParams = Schema.decodeUnknownResult(AzureReposSourceParamsSchema);
+export const parseUrl = (url, hostname = CANONICAL_HOSTNAME) => {
+    if (url.hostname !== hostname) {
+        return Effect.fail(new SourceSyntaxInvalid({
+            detail: "Invalid Azure Repos URL format",
+        }));
+    }
+    const match = url.pathname.match(AZUREREPOS_PATH_PATTERN);
+    if (!match || !match[1] || !match[2] || !match[3]) {
+        return Effect.fail(new SourceSyntaxInvalid({
+            detail: "Invalid Azure Repos URL format",
+        }));
+    }
+    const fragmentRef = Option.getOrUndefined(refFromUrlHash(url));
+    const decoded = decodeAzureReposSourceParams({
+        type: "azurerepos",
+        organization: match[1],
+        project: match[2],
+        repo: match[3],
+        ...(fragmentRef === undefined ? {} : { ref: fragmentRef }),
+    });
+    return Result.isSuccess(decoded)
+        ? Effect.succeed(decoded.success)
+        : Effect.fail(new SourceSyntaxInvalid({
+            detail: "Invalid Azure Repos URL format",
+        }));
+};
+//# sourceMappingURL=url.js.map

package/dist/src/providers/bitbucket/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Bitbucket source parsing.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+export { resolveRepo } from "./resolve-repo.js";
+export { parseShorthand } from "./shorthand.js";
+export { parseUrl } from "./url.js";
+export { parseScp } from "./scp.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,11 @@
+/**
+ * Bitbucket source parsing.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+export { resolveRepo } from "./resolve-repo.js";
+export { parseShorthand } from "./shorthand.js";
+export { parseUrl } from "./url.js";
+export { parseScp } from "./scp.js";
+//# sourceMappingURL=index.js.map

package/dist/src/providers/bitbucket/resolve-repo.d.ts

@@ -0,0 +1,11 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import { SourceNotResolvable } from "../../errors.js";
+import type { BitbucketSourceParams } from "@agentxm/extension-model/unstable/sources/types";
+export declare const resolveRepo: (args: {
+    readonly owner: string;
+    readonly repo: string;
+    readonly subPath: Option.Option<string>;
+}) => Effect.Effect<Option.Option<BitbucketSourceParams>, SourceNotResolvable, HttpClient.HttpClient>;
+//# sourceMappingURL=resolve-repo.d.ts.map

package/dist/src/providers/bitbucket/resolve-repo.js

@@ -0,0 +1,33 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
+import { SourceNotResolvable } from "../../errors.js";
+const headRequest = (url, _input) => Effect.gen(function* () {
+    const client = yield* HttpClient.HttpClient;
+    return yield* client.execute(HttpClientRequest.head(url)).pipe(Effect.mapError((error) => new SourceNotResolvable({
+        category: "validation",
+        detail: `Failed to check Bitbucket: ${error instanceof Error ? error.message : String(error)}`,
+        cause: error,
+    })));
+});
+export const resolveRepo = (args) => Effect.gen(function* () {
+    const repoUrl = `https://bitbucket.org/${args.owner}/${args.repo}`;
+    const repoResponse = yield* headRequest(repoUrl, `${args.owner}/${args.repo}`);
+    if (repoResponse.status !== 200)
+        return Option.none();
+    if (Option.isSome(args.subPath)) {
+        const subPathUrl = `${repoUrl}/src/HEAD/${args.subPath.value}`;
+        const subPathResponse = yield* headRequest(subPathUrl, `${args.owner}/${args.repo}/${args.subPath.value}`);
+        if (subPathResponse.status !== 200)
+            return Option.none();
+    }
+    return Option.some({
+        type: "bitbucket",
+        owner: args.owner,
+        repo: args.repo,
+        ref: Option.none(),
+        subPath: args.subPath,
+    });
+});
+//# sourceMappingURL=resolve-repo.js.map

package/dist/src/providers/bitbucket/scp.d.ts

@@ -0,0 +1,11 @@
+import * as Effect from "effect/Effect";
+import { SourceSyntaxInvalid } from "../../errors.js";
+export declare const parseScp: (input: string, hostname?: string) => Effect.Effect<never, SourceSyntaxInvalid, never> | Effect.Effect<{
+    readonly owner: string;
+    readonly type: "bitbucket";
+    readonly repo: string;
+    readonly ref: import("effect/Option").Option<string>;
+    readonly subPath: import("effect/Option").Option<string>;
+    readonly sourceName?: string | undefined;
+}, never, never>;
+//# sourceMappingURL=scp.d.ts.map

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

@@ -0,0 +1,28 @@
+import * as Effect from "effect/Effect";
+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 { CANONICAL_HOSTNAME } from "./url.js";
+/** Matches: git@{hostname}:owner/repo.git */
+const SCP_PATTERN = /^git@([^:]+):([^/]+)\/([^/]+?)(?:\.git)?$/;
+const decodeBitbucketSourceParams = Schema.decodeUnknownResult(BitbucketSourceParamsSchema);
+export const parseScp = (input, hostname = CANONICAL_HOSTNAME) => {
+    const match = input.match(SCP_PATTERN);
+    if (!match || !match[1] || !match[2] || !match[3] || match[1] !== hostname) {
+        return Effect.fail(new SourceSyntaxInvalid({
+            detail: "Invalid Bitbucket SSH URL format",
+        }));
+    }
+    const decoded = decodeBitbucketSourceParams({
+        type: "bitbucket",
+        owner: match[2],
+        repo: match[3],
+    });
+    return Result.isSuccess(decoded)
+        ? Effect.succeed(decoded.success)
+        : Effect.fail(new SourceSyntaxInvalid({
+            detail: "Invalid Bitbucket SSH URL format",
+        }));
+};
+//# sourceMappingURL=scp.js.map

package/dist/src/providers/bitbucket/shorthand.d.ts

@@ -0,0 +1,10 @@
+import * as Effect from "effect/Effect";
+export declare const parseShorthand: (input: string) => Effect.Effect<{
+    owner: string;
+    repo: string;
+    ref: import("effect/Option").Option<string>;
+    subPath: import("effect/Option").Option<string>;
+    sourceName?: string | undefined;
+    type: "bitbucket";
+}, import("../../errors.ts").SourceSyntaxInvalid, never>;
+//# sourceMappingURL=shorthand.d.ts.map

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

@@ -0,0 +1,11 @@
+import * as Effect from "effect/Effect";
+import { parseProviderShorthand } from "../parse-provider-shorthand.js";
+export const parseShorthand = (input) => Effect.gen(function* () {
+    const body = input.slice("bitbucket:".length);
+    const parts = yield* parseProviderShorthand(body, input);
+    return {
+        type: "bitbucket",
+        ...parts,
+    };
+});
+//# sourceMappingURL=shorthand.js.map

package/dist/src/providers/bitbucket/url.d.ts

@@ -0,0 +1,13 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { SourceSyntaxInvalid } from "../../errors.js";
+export declare const CANONICAL_HOSTNAME = "bitbucket.org";
+export declare const parseUrl: (url: URL, hostname?: string) => Effect.Effect<never, SourceSyntaxInvalid, never> | Effect.Effect<{
+    readonly owner: string;
+    readonly type: "bitbucket";
+    readonly repo: string;
+    readonly ref: Option.Option<string>;
+    readonly subPath: Option.Option<string>;
+    readonly sourceName?: string | undefined;
+}, never, never>;
+//# sourceMappingURL=url.d.ts.map