@agentxm/extension-sources 0.28.4-bootstrap.0

package/dist/src/providers/git.js

@@ -0,0 +1,46 @@
+/**
+ * Source provider for generic git repositories.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+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 } from "../errors.js";
+import { shallowClone } from "../git/operations.js";
+import { fileUrlToPath } from "../file-url.js";
+import { discoverConventionRefs } from "./convention-discovery.js";
+/**
+ * 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 const createGitSourceHostProvider = () => ({
+    type: "git",
+    match: (url) => Effect.succeed(url.protocol === "git:" || url.protocol === "ssh:" || url.href.startsWith("git@")),
+    find: (source, options) => Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        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(source.url.href, 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 git source, but none was provided",
+            }));
+        }
+        return Effect.succeed({
+            directory: fileUrlToPath(ref.location),
+        });
+    },
+});
+//# sourceMappingURL=git.js.map

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

@@ -0,0 +1,11 @@
+/**
+ * GitHub source parsing and API operations.
+ *
+ * @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/github/index.js

@@ -0,0 +1,11 @@
+/**
+ * GitHub source parsing and API operations.
+ *
+ * @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/github/resolve-repo.d.ts

@@ -0,0 +1,11 @@
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { SourceNotResolvable } from "../../errors.js";
+import type { GitHubSourceParams } 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<GitHubSourceParams>, SourceNotResolvable, HttpClient.HttpClient>;
+//# sourceMappingURL=resolve-repo.d.ts.map

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

@@ -0,0 +1,34 @@
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { SourceNotResolvable } from "../../errors.js";
+const headRequest = (url, _input) => Effect.gen(function* () {
+    const client = yield* HttpClient.HttpClient;
+    const request = HttpClientRequest.head(url);
+    return yield* client.execute(request).pipe(Effect.mapError((error) => new SourceNotResolvable({
+        category: "validation",
+        detail: `Failed to check GitHub: ${error.reason._tag === "TransportError" ? String(error.reason.cause) : `HTTP error`}`,
+        cause: error,
+    })));
+});
+export const resolveRepo = (args) => Effect.gen(function* () {
+    const repoUrl = `https://github.com/${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}/tree/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: "github",
+        owner: args.owner,
+        repo: args.repo,
+        ref: Option.none(),
+        subPath: args.subPath,
+    });
+});
+//# sourceMappingURL=resolve-repo.js.map

package/dist/src/providers/github/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: "github";
+    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/github/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 { GitHubSourceParamsSchema, } 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 decodeGitHubSourceParams = Schema.decodeUnknownResult(GitHubSourceParamsSchema);
+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 GitHub SSH URL format",
+        }));
+    }
+    const decoded = decodeGitHubSourceParams({
+        type: "github",
+        owner: match[2],
+        repo: match[3],
+    });
+    return Result.isSuccess(decoded)
+        ? Effect.succeed(decoded.success)
+        : Effect.fail(new SourceSyntaxInvalid({
+            detail: "Invalid GitHub SSH URL format",
+        }));
+};
+//# sourceMappingURL=scp.js.map

package/dist/src/providers/github/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: "github";
+}, import("../../errors.ts").SourceSyntaxInvalid, never>;
+//# sourceMappingURL=shorthand.d.ts.map

package/dist/src/providers/github/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("github:".length);
+    const parts = yield* parseProviderShorthand(body, input);
+    return {
+        type: "github",
+        ...parts,
+    };
+});
+//# sourceMappingURL=shorthand.js.map

package/dist/src/providers/github/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 = "github.com";
+export declare const parseUrl: (url: URL, hostname?: string) => Effect.Effect<never, SourceSyntaxInvalid, never> | Effect.Effect<{
+    readonly owner: string;
+    readonly type: "github";
+    readonly repo: string;
+    readonly ref: Option.Option<string>;
+    readonly subPath: Option.Option<string>;
+    readonly sourceName?: string | undefined;
+}, never, never>;
+//# sourceMappingURL=url.d.ts.map

package/dist/src/providers/github/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 { GitHubSourceParamsSchema, } from "@agentxm/extension-model/unstable/sources/types";
+import { refFromUrlHash } from "../../url-fragment.js";
+export const CANONICAL_HOSTNAME = "github.com";
+/** Matches: /owner/repo[/tree/ref/path] */
+const GITHUB_PATH_PATTERN = /^\/([^/]+)\/([^/]+?)(?:\.git)?(?:\/tree\/([^/]+)(?:\/(.+))?)?$/;
+const decodeGitHubSourceParams = Schema.decodeUnknownResult(GitHubSourceParamsSchema);
+export const parseUrl = (url, hostname = CANONICAL_HOSTNAME) => {
+    if (url.hostname !== hostname) {
+        return Effect.fail(new SourceSyntaxInvalid({
+            detail: "Invalid GitHub URL format",
+        }));
+    }
+    const match = url.pathname.match(GITHUB_PATH_PATTERN);
+    if (!match || !match[1] || !match[2]) {
+        return Effect.fail(new SourceSyntaxInvalid({
+            detail: "Invalid GitHub URL format",
+        }));
+    }
+    const fragmentRef = Option.getOrUndefined(refFromUrlHash(url));
+    const decoded = decodeGitHubSourceParams({
+        type: "github",
+        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 GitHub URL format",
+        }));
+};
+//# sourceMappingURL=url.js.map

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

@@ -0,0 +1,11 @@
+/**
+ * GitLab 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/gitlab/index.js

@@ -0,0 +1,11 @@
+/**
+ * GitLab 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/gitlab/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 { GitLabSourceParams } 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<GitLabSourceParams>, SourceNotResolvable, HttpClient.HttpClient>;
+//# sourceMappingURL=resolve-repo.d.ts.map

package/dist/src/providers/gitlab/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 GitLab: ${error instanceof Error ? error.message : String(error)}`,
+        cause: error,
+    })));
+});
+export const resolveRepo = (args) => Effect.gen(function* () {
+    const repoUrl = `https://gitlab.com/${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}/-/tree/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: "gitlab",
+        owner: args.owner,
+        repo: args.repo,
+        ref: Option.none(),
+        subPath: args.subPath,
+    });
+});
+//# sourceMappingURL=resolve-repo.js.map

package/dist/src/providers/gitlab/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: "gitlab";
+    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/gitlab/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 { GitLabSourceParamsSchema, } 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 decodeGitLabSourceParams = Schema.decodeUnknownResult(GitLabSourceParamsSchema);
+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 GitLab SSH URL format",
+        }));
+    }
+    const decoded = decodeGitLabSourceParams({
+        type: "gitlab",
+        owner: match[2],
+        repo: match[3],
+    });
+    return Result.isSuccess(decoded)
+        ? Effect.succeed(decoded.success)
+        : Effect.fail(new SourceSyntaxInvalid({
+            detail: "Invalid GitLab SSH URL format",
+        }));
+};
+//# sourceMappingURL=scp.js.map

package/dist/src/providers/gitlab/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: "gitlab";
+}, import("../../errors.ts").SourceSyntaxInvalid, never>;
+//# sourceMappingURL=shorthand.d.ts.map

package/dist/src/providers/gitlab/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("gitlab:".length);
+    const parts = yield* parseProviderShorthand(body, input);
+    return {
+        type: "gitlab",
+        ...parts,
+    };
+});
+//# sourceMappingURL=shorthand.js.map

package/dist/src/providers/gitlab/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 = "gitlab.com";
+export declare const parseUrl: (url: URL, hostname?: string) => Effect.Effect<never, SourceSyntaxInvalid, never> | Effect.Effect<{
+    readonly owner: string;
+    readonly type: "gitlab";
+    readonly repo: string;
+    readonly ref: Option.Option<string>;
+    readonly subPath: Option.Option<string>;
+    readonly sourceName?: string | undefined;
+}, never, never>;
+//# sourceMappingURL=url.d.ts.map

package/dist/src/providers/gitlab/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 { GitLabSourceParamsSchema, } from "@agentxm/extension-model/unstable/sources/types";
+import { refFromUrlHash } from "../../url-fragment.js";
+export const CANONICAL_HOSTNAME = "gitlab.com";
+/** Matches: /owner/repo[/-/tree/ref/path] */
+const GITLAB_PATH_PATTERN = /^\/([^/]+)\/([^/]+?)(?:\.git)?(?:\/-\/tree\/([^/]+)(?:\/(.+))?)?$/;
+const decodeGitLabSourceParams = Schema.decodeUnknownResult(GitLabSourceParamsSchema);
+export const parseUrl = (url, hostname = CANONICAL_HOSTNAME) => {
+    if (url.hostname !== hostname) {
+        return Effect.fail(new SourceSyntaxInvalid({
+            detail: "Invalid GitLab URL format",
+        }));
+    }
+    const match = url.pathname.match(GITLAB_PATH_PATTERN);
+    if (!match || !match[1] || !match[2]) {
+        return Effect.fail(new SourceSyntaxInvalid({
+            detail: "Invalid GitLab URL format",
+        }));
+    }
+    const fragmentRef = Option.getOrUndefined(refFromUrlHash(url));
+    const decoded = decodeGitLabSourceParams({
+        type: "gitlab",
+        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 GitLab URL format",
+        }));
+};
+//# sourceMappingURL=url.js.map

package/dist/src/providers/local-parser/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Local source parsing.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+export { parseLocalPath } from "./parser.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/providers/local-parser/index.js

@@ -0,0 +1,8 @@
+/**
+ * Local source parsing.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+export { parseLocalPath } from "./parser.js";
+//# sourceMappingURL=index.js.map

package/dist/src/providers/local-parser/parser.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Local source parsers.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Effect from "effect/Effect";
+import type { LocalSourceParams } from "@agentxm/extension-model/unstable/sources/types";
+/**
+ * Parse a local filesystem path.
+ */
+export declare const parseLocalPath: (input: string) => Effect.Effect<LocalSourceParams>;
+//# sourceMappingURL=parser.d.ts.map

package/dist/src/providers/local-parser/parser.js

@@ -0,0 +1,14 @@
+/**
+ * Local source parsers.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Effect from "effect/Effect";
+/**
+ * Parse a local filesystem path.
+ */
+export const parseLocalPath = (input) => {
+    return Effect.succeed({ type: "local", path: input });
+};
+//# sourceMappingURL=parser.js.map

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

@@ -0,0 +1,23 @@
+/**
+ * Source provider for local filesystem paths.
+ *
+ * Wraps the existing `skillsInDir` logic into the `SourceHostProvider` interface.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type * as FileSystem from "effect/FileSystem";
+import type * as Path from "effect/Path";
+import { type SourceError } from "../errors.js";
+import type { SourceHostProvider } from "@agentxm/extension-model/unstable/sources/source-host-provider";
+import type { LocalSource } from "@agentxm/extension-model/unstable/sources/types";
+/**
+ * Source host provider for local filesystem paths.
+ *
+ * Self-describing — no host config needed.
+ * `match` returns true for file:// URLs and absolute/relative paths.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const createLocalSourceHostProvider: () => SourceHostProvider<LocalSource, FileSystem.FileSystem | Path.Path, SourceError>;
+//# sourceMappingURL=local.d.ts.map

package/dist/src/providers/local.js

@@ -0,0 +1,39 @@
+/**
+ * Source provider for local filesystem paths.
+ *
+ * Wraps the existing `skillsInDir` logic into the `SourceHostProvider` interface.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Effect from "effect/Effect";
+import { SourceNetworkFailure } from "../errors.js";
+import { fileUrlToPath } from "../file-url.js";
+import { discoverConventionRefs } from "./convention-discovery.js";
+/**
+ * Source host provider for local filesystem paths.
+ *
+ * Self-describing — no host config needed.
+ * `match` returns true for file:// URLs and absolute/relative paths.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const createLocalSourceHostProvider = () => ({
+    type: "local",
+    match: (url) => Effect.succeed(url.protocol === "file:"),
+    find: (source, options) => discoverConventionRefs(source, source.path, options).pipe(Effect.mapError((error) => new SourceNetworkFailure({
+        detail: "Failed to discover extensions",
+        cause: error,
+    }))),
+    fetch: (_source, ref) => {
+        if (ref.refType !== "local") {
+            return Effect.fail(new SourceNetworkFailure({
+                detail: "Expected ref with location for local source, but none was provided",
+            }));
+        }
+        return Effect.succeed({
+            directory: fileUrlToPath(ref.location),
+        });
+    },
+});
+//# sourceMappingURL=local.js.map

package/dist/src/providers/parse-provider-shorthand.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Shared helper for parsing provider shorthand patterns.
+ *
+ * Parses the `owner/repo[//subpath][@ref]` portion (after stripping the prefix)
+ * into constituent parts.
+ *
+ * @packageDocumentation
+ */
+import * as Effect from "effect/Effect";
+import { SourceSyntaxInvalid } from "../errors.js";
+import { type GitHostedSourceParamParts } from "@agentxm/extension-model/unstable/sources/types";
+/**
+ * Parse the body of a provider shorthand (the part after the `prefix:` prefix).
+ *
+ * Returns `{ owner, repo, subPath?, ref? }` or fails with `SourceSyntaxInvalid`.
+ */
+export declare const parseProviderShorthand: (input: string, original: string) => Effect.Effect<GitHostedSourceParamParts, SourceSyntaxInvalid>;
+//# sourceMappingURL=parse-provider-shorthand.d.ts.map

package/dist/src/providers/parse-provider-shorthand.js

@@ -0,0 +1,74 @@
+/**
+ * Shared helper for parsing provider shorthand patterns.
+ *
+ * Parses the `owner/repo[//subpath][@ref]` portion (after stripping the prefix)
+ * into constituent parts.
+ *
+ * @packageDocumentation
+ */
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import { SourceSyntaxInvalid } from "../errors.js";
+import { GitHostedSourceParamPartsSchema, } from "@agentxm/extension-model/unstable/sources/types";
+const decodeGitHostedSourceParamParts = Schema.decodeUnknownResult(GitHostedSourceParamPartsSchema);
+const parseRef = (input) => {
+    const refIndex = input.lastIndexOf("@");
+    if (refIndex <= 0) {
+        return { coordinate: input };
+    }
+    const ref = input.slice(refIndex + 1);
+    if (ref.length === 0) {
+        return { coordinate: input };
+    }
+    const subPathMarker = input.indexOf("//");
+    const isAtPathSegment = subPathMarker !== -1 &&
+        refIndex > subPathMarker + 1 &&
+        input[refIndex - 1] === "/" &&
+        ref.includes("/");
+    if (isAtPathSegment) {
+        return { coordinate: input };
+    }
+    return { coordinate: input.slice(0, refIndex), ref };
+};
+const parseCoordinate = (input) => {
+    const { coordinate, ref } = parseRef(input);
+    const subPathMarker = coordinate.indexOf("//");
+    const repoCoordinate = subPathMarker === -1 ? coordinate : coordinate.slice(0, subPathMarker);
+    const subPath = subPathMarker === -1 ? undefined : coordinate.slice(subPathMarker + 2);
+    const segments = repoCoordinate.split("/");
+    const repo = segments.at(-1);
+    const ownerSegments = segments.slice(0, -1);
+    if (repo === undefined || repo.length === 0 || ownerSegments.length === 0) {
+        return undefined;
+    }
+    const owner = ownerSegments.join("/");
+    return {
+        owner,
+        repo,
+        ...(subPath === undefined ? {} : { subPath }),
+        ...(ref === undefined ? {} : { ref }),
+    };
+};
+/**
+ * Parse the body of a provider shorthand (the part after the `prefix:` prefix).
+ *
+ * Returns `{ owner, repo, subPath?, ref? }` or fails with `SourceSyntaxInvalid`.
+ */
+export const parseProviderShorthand = (input, original) => Effect.gen(function* () {
+    const parsed = parseCoordinate(input);
+    if (parsed === undefined) {
+        return yield* new SourceSyntaxInvalid({
+            detail: `Invalid provider shorthand "${original}": expected owner/repo[//subpath][@ref]`,
+        });
+    }
+    const decoded = decodeGitHostedSourceParamParts(parsed);
+    if (Result.isFailure(decoded)) {
+        return yield* new SourceSyntaxInvalid({
+            detail: `Invalid provider shorthand "${original}": subpaths cannot traverse outside the repository, and shorthand refs cannot contain "/"`,
+            cause: decoded.failure,
+        });
+    }
+    return decoded.success;
+});
+//# sourceMappingURL=parse-provider-shorthand.js.map