@agentxm/extension-model 0.35.0 → 0.37.0

package/dist/src/unstable/agents/types.js

@@ -10,8 +10,6 @@ import { CONFIGURABLE_AGENT_IDS, } from "../agent-capabilities/identity.js";
 // -----------------------------------------------------------------------------
 /** @experimental This API is unstable and may change without notice. */
 export { CONFIGURABLE_AGENT_IDS };
-/** @experimental This API is unstable and may change without notice. */
-export const AGENT_IDS = [...CONFIGURABLE_AGENT_IDS, "universal"];
-/** @experimental This API is unstable and may change without notice. */
-export const isConfigurableAgentId = (id) => id !== "universal";
+/** Real agents that can participate in native materialization. @experimental */
+export const MATERIALIZATION_TARGET_IDS = [...CONFIGURABLE_AGENT_IDS];
 //# sourceMappingURL=types.js.map

package/dist/src/unstable/extensions/common.d.ts

@@ -677,8 +677,7 @@ export { AgentIdSchema };
 /**
  * Agent identifiers users may persist in `axm.json`.
  *
- * Synthetic materialization targets such as `universal` are known agents, but
- * they are injected by repository code rather than configured by users.
+ * Shared native locations are policy, not additional agent identities.
  *
  * @experimental This API is unstable and may change without notice.
  */

package/dist/src/unstable/extensions/common.js

@@ -643,8 +643,7 @@ export { AgentIdSchema };
 /**
  * Agent identifiers users may persist in `axm.json`.
  *
- * Synthetic materialization targets such as `universal` are known agents, but
- * they are injected by repository code rather than configured by users.
+ * Shared native locations are policy, not additional agent identities.
  *
  * @experimental This API is unstable and may change without notice.
  */

package/dist/src/unstable/extensions/name-patterns.d.ts

@@ -7,15 +7,17 @@
  * @experimental This API is unstable and may change without notice.
  */
 /**
- * Expand a glob pattern against a list of names.
+ * Match one extension name against a pattern.
  *
  * Only `*` wildcards are supported. All other characters (including `?`, `[`, `]`)
  * are treated as literals. Matching is case-sensitive.
  *
  * @param pattern - The pattern to match (may contain `*`)
- * @param names - Available names to match against
- * @returns Matching names in their original order
+ * @param name - The name to check
+ * @returns Whether the complete name matches
  */
+export declare const matchesPattern: (pattern: string, name: string) => boolean;
+/** Expand a glob pattern against names, preserving their original order. */
 export declare const expandGlob: (pattern: string, names: ReadonlyArray<string>) => ReadonlyArray<string>;
 /**
  * Expand multiple glob patterns against a list of extension names.

package/dist/src/unstable/extensions/name-patterns.js

@@ -7,48 +7,47 @@
  * @experimental This API is unstable and may change without notice.
  */
 /**
- * Expand a glob pattern against a list of names.
+ * Match one extension name against a pattern.
  *
  * Only `*` wildcards are supported. All other characters (including `?`, `[`, `]`)
  * are treated as literals. Matching is case-sensitive.
  *
  * @param pattern - The pattern to match (may contain `*`)
- * @param names - Available names to match against
- * @returns Matching names in their original order
+ * @param name - The name to check
+ * @returns Whether the complete name matches
  */
-export const expandGlob = (pattern, names) => {
-    const matches = (name) => {
-        let patternIndex = 0;
-        let nameIndex = 0;
-        let wildcardIndex = -1;
-        let wildcardNameIndex = 0;
-        while (nameIndex < name.length) {
-            const token = pattern[patternIndex];
-            if (token !== undefined && token !== "*" && token === name[nameIndex]) {
-                patternIndex += 1;
-                nameIndex += 1;
-            }
-            else if (token === "*") {
-                wildcardIndex = patternIndex;
-                wildcardNameIndex = nameIndex;
-                patternIndex += 1;
-            }
-            else if (wildcardIndex >= 0) {
-                patternIndex = wildcardIndex + 1;
-                wildcardNameIndex += 1;
-                nameIndex = wildcardNameIndex;
-            }
-            else {
-                return false;
-            }
+export const matchesPattern = (pattern, name) => {
+    let patternIndex = 0;
+    let nameIndex = 0;
+    let wildcardIndex = -1;
+    let wildcardNameIndex = 0;
+    while (nameIndex < name.length) {
+        const token = pattern[patternIndex];
+        if (token !== undefined && token !== "*" && token === name[nameIndex]) {
+            patternIndex += 1;
+            nameIndex += 1;
         }
-        while (pattern[patternIndex] === "*") {
+        else if (token === "*") {
+            wildcardIndex = patternIndex;
+            wildcardNameIndex = nameIndex;
             patternIndex += 1;
         }
-        return patternIndex === pattern.length;
-    };
-    return names.filter(matches);
+        else if (wildcardIndex >= 0) {
+            patternIndex = wildcardIndex + 1;
+            wildcardNameIndex += 1;
+            nameIndex = wildcardNameIndex;
+        }
+        else {
+            return false;
+        }
+    }
+    while (pattern[patternIndex] === "*") {
+        patternIndex += 1;
+    }
+    return patternIndex === pattern.length;
 };
+/** Expand a glob pattern against names, preserving their original order. */
+export const expandGlob = (pattern, names) => names.filter((name) => matchesPattern(pattern, name));
 /**
  * Expand multiple glob patterns against a list of extension names.
  *

package/dist/src/unstable/path-types.d.ts

@@ -26,4 +26,10 @@ export declare const makeWorkspaceRelativeSourcePath: (path: Path.Path, workspac
  * prefix is not mistaken for a child.
  */
 export declare const isPathSafe: (path: Path.Path, base: string, target: string) => boolean;
+/** Resolve a child against its base and reject paths that escape it. */
+export declare const safeChildPath: (path: Path.Path, base: string, target: string) => Option.Option<AbsolutePath>;
+/** Relative-path containment, including the parent itself. */
+export declare const isWithinOrEqual: (path: Path.Path, parent: string, child: string) => boolean;
+/** Relative-path containment that excludes the parent itself. */
+export declare const isStrictlyWithin: (path: Path.Path, parent: string, child: string) => boolean;
 //# sourceMappingURL=path-types.d.ts.map

package/dist/src/unstable/path-types.js

@@ -56,4 +56,24 @@ export const isPathSafe = (path, base, target) => {
     const resolvedTarget = path.resolve(target);
     return resolvedTarget === resolvedBase || resolvedTarget.startsWith(resolvedBase + path.sep);
 };
+/** Resolve a child against its base and reject paths that escape it. */
+export const safeChildPath = (path, base, target) => {
+    const resolvedBase = path.resolve(base);
+    const resolvedTarget = path.isAbsolute(target)
+        ? path.resolve(target)
+        : path.resolve(resolvedBase, target);
+    return isPathSafe(path, resolvedBase, resolvedTarget)
+        ? Option.some(makeAbsolutePath(path, resolvedTarget))
+        : Option.none();
+};
+/** Relative-path containment, including the parent itself. */
+export const isWithinOrEqual = (path, parent, child) => {
+    const relative = path.relative(path.resolve(parent), path.resolve(child));
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+};
+/** Relative-path containment that excludes the parent itself. */
+export const isStrictlyWithin = (path, parent, child) => {
+    const relative = path.relative(path.resolve(parent), path.resolve(child));
+    return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative);
+};
 //# sourceMappingURL=path-types.js.map

package/dist/src/unstable/sources/forge-grammar.d.ts

@@ -1,22 +1,58 @@
 /**
- * Pure per-forge source shorthand printing grammar.
+ * Forge coordinate, clone URL, and browser URL grammar.
  *
- * Each printer formats source params as the forge's canonical shorthand
- * string. Probing and acquisition stay with the source-resolution providers;
- * only the string grammar lives here.
+ * Probing and acquisition stay with source resolution; the model owns the
+ * strings and URLs that identify each forge repository.
  *
  * @experimental This API is unstable and may change without notice.
  * @packageDocumentation
  */
-import type { AzureReposSourceParams, BitbucketSourceParams, GitHubSourceParams, GitLabSourceParams, LocalSourceParams } from "./types.js";
+import * as Option from "effect/Option";
+import * as Result from "effect/Result";
 /** @experimental */
-export declare const printGitHubSource: (source: GitHubSourceParams, sourceName?: string) => string;
+export declare const FORGE_PREFIXES: readonly ["github", "gitlab", "bitbucket", "azurerepos"];
 /** @experimental */
-export declare const printGitLabSource: (source: GitLabSourceParams, sourceName?: string) => string;
+export type ForgePrefix = (typeof FORGE_PREFIXES)[number];
 /** @experimental */
-export declare const printBitbucketSource: (source: BitbucketSourceParams, sourceName?: string) => string;
+export declare const isForgePrefix: (value: string) => value is ForgePrefix;
 /** @experimental */
-export declare const printAzureReposSource: (source: AzureReposSourceParams, sourceName?: string) => string;
+export interface ForgeCoordinate {
+    readonly forge: ForgePrefix;
+    readonly repository: string;
+    readonly ref: Option.Option<string>;
+    readonly subPath: Option.Option<string>;
+}
+interface BrowserPath {
+    readonly repository: string;
+    readonly ref?: string;
+    readonly subPath?: string;
+}
 /** @experimental */
-export declare const printLocalSource: (source: LocalSourceParams) => string;
+export interface Forge {
+    readonly prefix: ForgePrefix;
+    readonly hostname: string;
+    readonly repositorySegments: (count: number) => boolean;
+    readonly cloneUrl: (repository: string) => URL;
+    readonly repositoryFromCloneUrl: (pathname: string) => string | undefined;
+    readonly parseBrowserPath: (pathname: string) => BrowserPath | undefined;
+}
+/** @experimental */
+export declare const FORGES: Record<ForgePrefix, Forge>;
+/** @experimental */
+export declare const forgeForHostname: (hostname: string) => Forge | undefined;
+/** @experimental */
+export declare const parseForgeCoordinate: (forge: ForgePrefix, body: string) => Result.Result<ForgeCoordinate, {
+    readonly reason: string;
+}>;
+/** @experimental */
+export declare const printForgeCoordinateBody: (coordinate: ForgeCoordinate) => string;
+/** @experimental */
+export declare const printForgeCoordinate: (coordinate: ForgeCoordinate) => string;
+/** @experimental */
+export declare const forgeCloneUrl: (coordinate: ForgeCoordinate) => URL;
+/** @experimental */
+export declare const forgeCoordinateFromGitUrl: (url: URL, ref: Option.Option<string>, subPath: Option.Option<string>) => Option.Option<ForgeCoordinate>;
+/** @experimental */
+export declare const parseForgeBrowserUrl: (url: URL) => Option.Option<ForgeCoordinate>;
+export {};
 //# sourceMappingURL=forge-grammar.d.ts.map

package/dist/src/unstable/sources/forge-grammar.js

@@ -1,50 +1,170 @@
 /**
- * Pure per-forge source shorthand printing grammar.
+ * Forge coordinate, clone URL, and browser URL grammar.
  *
- * Each printer formats source params as the forge's canonical shorthand
- * string. Probing and acquisition stay with the source-resolution providers;
- * only the string grammar lives here.
+ * Probing and acquisition stay with source resolution; the model owns the
+ * strings and URLs that identify each forge repository.
  *
  * @experimental This API is unstable and may change without notice.
  * @packageDocumentation
  */
 import * as Option from "effect/Option";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import { SourceNamespaceSchema, SourceRefSchema, SourceSubPathSchema } from "./types.js";
 /** @experimental */
-export const printGitHubSource = (source, sourceName = source.sourceName ?? "github") => {
-    let s = `${sourceName}:${source.owner}/${source.repo}`;
-    if (Option.isSome(source.subPath))
-        s += `//${source.subPath.value}`;
-    if (Option.isSome(source.ref))
-        s += `@${source.ref.value}`;
-    return s;
+export const FORGE_PREFIXES = ["github", "gitlab", "bitbucket", "azurerepos"];
+/** @experimental */
+export const isForgePrefix = (value) => FORGE_PREFIXES.some((prefix) => prefix === value);
+const segments = (pathname) => pathname.split("/").filter((segment) => segment.length > 0);
+const withoutGit = (name) => (name.endsWith(".git") ? name.slice(0, -4) : name);
+const hostedRepositoryFromCloneUrl = (pathname) => {
+    const parts = segments(pathname);
+    const last = parts.at(-1);
+    return last === undefined || parts.length < 2
+        ? undefined
+        : [...parts.slice(0, -1), withoutGit(last)].join("/");
+};
+const hostedBrowserPath = (pathname, marker) => {
+    const pattern = marker === "tree"
+        ? /^\/([^/]+)\/([^/]+?)(?:\.git)?(?:\/tree\/([^/]+)(?:\/(.+))?)?$/u
+        : /^\/([^/]+)\/([^/]+?)(?:\.git)?(?:\/src\/([^/]+)(?:\/(.+))?)?$/u;
+    const match = pattern.exec(pathname);
+    if (match?.[1] === undefined || match[2] === undefined)
+        return undefined;
+    return {
+        repository: `${match[1]}/${match[2]}`,
+        ...(match[3] === undefined ? {} : { ref: match[3] }),
+        ...(match[4] === undefined ? {} : { subPath: match[4] }),
+    };
+};
+const gitlabBrowserPath = (pathname) => {
+    const marker = "/-/tree/";
+    const markerIndex = pathname.indexOf(marker);
+    const repositoryParts = segments(markerIndex < 0 ? pathname : pathname.slice(0, markerIndex));
+    const last = repositoryParts.at(-1);
+    if (last === undefined || repositoryParts.length < 2)
+        return undefined;
+    const treePath = markerIndex < 0 ? [] : pathname.slice(markerIndex + marker.length).split("/");
+    const subPath = treePath.slice(1).join("/");
+    return {
+        repository: [...repositoryParts.slice(0, -1), withoutGit(last)].join("/"),
+        ...(treePath[0] === undefined ? {} : { ref: treePath[0] }),
+        ...(subPath.length === 0 ? {} : { subPath }),
+    };
+};
+const azureRepositoryFromCloneUrl = (pathname) => {
+    const parts = segments(pathname);
+    return parts.length === 4 && parts[2] === "_git"
+        ? `${parts[0]}/${parts[1]}/${withoutGit(parts[3] ?? "")}`
+        : undefined;
+};
+const azureBrowserPath = (pathname) => {
+    const match = /^\/([^/]+)\/([^/]+)\/_git\/([^/]+?)(?:\.git)?$/u.exec(pathname);
+    return match?.[1] === undefined || match[2] === undefined || match[3] === undefined
+        ? undefined
+        : { repository: `${match[1]}/${match[2]}/${match[3]}` };
+};
+const hostedForge = (prefix, hostname, parseBrowserPath) => ({
+    prefix,
+    hostname,
+    repositorySegments: (count) => count >= 2,
+    cloneUrl: (repository) => new URL(`https://${hostname}/${repository}.git`),
+    repositoryFromCloneUrl: hostedRepositoryFromCloneUrl,
+    parseBrowserPath,
+});
+/** @experimental */
+export const FORGES = {
+    github: hostedForge("github", "github.com", (pathname) => hostedBrowserPath(pathname, "tree")),
+    gitlab: hostedForge("gitlab", "gitlab.com", gitlabBrowserPath),
+    bitbucket: hostedForge("bitbucket", "bitbucket.org", (pathname) => hostedBrowserPath(pathname, "src")),
+    azurerepos: {
+        prefix: "azurerepos",
+        hostname: "dev.azure.com",
+        repositorySegments: (count) => count === 3,
+        cloneUrl: (repository) => {
+            const [organization, project, repo] = repository.split("/");
+            return new URL(`https://dev.azure.com/${organization}/${project}/_git/${repo}`);
+        },
+        repositoryFromCloneUrl: azureRepositoryFromCloneUrl,
+        parseBrowserPath: azureBrowserPath,
+    },
+};
+/** @experimental */
+export const forgeForHostname = (hostname) => Object.values(FORGES).find((forge) => forge.hostname === hostname);
+const decodeNamespace = Schema.decodeUnknownResult(SourceNamespaceSchema);
+const decodeSubPath = Schema.decodeUnknownResult(SourceSubPathSchema);
+const decodeRef = Schema.decodeUnknownResult(SourceRefSchema);
+const validCoordinate = (coordinate) => FORGES[coordinate.forge].repositorySegments(coordinate.repository.split("/").length) &&
+    Result.isSuccess(decodeNamespace(coordinate.repository)) &&
+    (Option.isNone(coordinate.subPath) ||
+        Result.isSuccess(decodeSubPath(coordinate.subPath.value))) &&
+    (Option.isNone(coordinate.ref) || Result.isSuccess(decodeRef(coordinate.ref.value)));
+const splitRef = (input) => {
+    const refIndex = input.lastIndexOf("@");
+    if (refIndex <= 0)
+        return { coordinate: input };
+    const ref = input.slice(refIndex + 1);
+    const subPathMarker = input.indexOf("//");
+    const isAtPathSegment = subPathMarker !== -1 &&
+        refIndex > subPathMarker + 1 &&
+        input[refIndex - 1] === "/" &&
+        ref.includes("/");
+    return isAtPathSegment ? { coordinate: input } : { coordinate: input.slice(0, refIndex), ref };
 };
 /** @experimental */
-export const printGitLabSource = (source, sourceName = source.sourceName ?? "gitlab") => {
-    let s = `${sourceName}:${source.owner}/${source.repo}`;
-    if (Option.isSome(source.subPath))
-        s += `//${source.subPath.value}`;
-    if (Option.isSome(source.ref))
-        s += `@${source.ref.value}`;
-    return s;
+export const parseForgeCoordinate = (forge, body) => {
+    const { coordinate, ref } = splitRef(body);
+    const marker = coordinate.indexOf("//");
+    const repository = marker < 0 ? coordinate : coordinate.slice(0, marker);
+    const subPath = marker < 0 ? undefined : coordinate.slice(marker + 2);
+    const parsed = {
+        forge,
+        repository,
+        ref: Option.fromUndefinedOr(ref),
+        subPath: Option.fromUndefinedOr(subPath),
+    };
+    return validCoordinate(parsed)
+        ? Result.succeed(parsed)
+        : Result.fail({ reason: `Expected valid ${forge} repository[//subpath][@ref]` });
 };
 /** @experimental */
-export const printBitbucketSource = (source, sourceName = source.sourceName ?? "bitbucket") => {
-    let s = `${sourceName}:${source.owner}/${source.repo}`;
-    if (Option.isSome(source.subPath))
-        s += `//${source.subPath.value}`;
-    if (Option.isSome(source.ref))
-        s += `@${source.ref.value}`;
-    return s;
+export const printForgeCoordinateBody = (coordinate) => {
+    let body = coordinate.repository;
+    if (Option.isSome(coordinate.subPath))
+        body += `//${coordinate.subPath.value}`;
+    if (Option.isSome(coordinate.ref))
+        body += `@${coordinate.ref.value}`;
+    return body;
 };
 /** @experimental */
-export const printAzureReposSource = (source, sourceName = source.sourceName ?? "azurerepos") => {
-    let s = `${sourceName}:${source.organization}/${source.project}/${source.repo}`;
-    if (Option.isSome(source.subPath))
-        s += `//${source.subPath.value}`;
-    if (Option.isSome(source.ref))
-        s += `@${source.ref.value}`;
-    return s;
+export const printForgeCoordinate = (coordinate) => `${coordinate.forge}:${printForgeCoordinateBody(coordinate)}`;
+/** @experimental */
+export const forgeCloneUrl = (coordinate) => FORGES[coordinate.forge].cloneUrl(coordinate.repository);
+/** @experimental */
+export const forgeCoordinateFromGitUrl = (url, ref, subPath) => {
+    const forge = forgeForHostname(url.hostname);
+    if (forge === undefined)
+        return Option.none();
+    const repository = forge.repositoryFromCloneUrl(url.pathname);
+    if (repository === undefined)
+        return Option.none();
+    const coordinate = { forge: forge.prefix, repository, ref, subPath };
+    return validCoordinate(coordinate) ? Option.some(coordinate) : Option.none();
 };
 /** @experimental */
-export const printLocalSource = (source) => source.path.startsWith("/") || source.path.startsWith(".") ? source.path : `./${source.path}`;
+export const parseForgeBrowserUrl = (url) => {
+    const forge = forgeForHostname(url.hostname);
+    if (forge === undefined)
+        return Option.none();
+    const parsed = forge.parseBrowserPath(url.pathname);
+    if (parsed === undefined)
+        return Option.none();
+    const coordinate = {
+        forge: forge.prefix,
+        repository: parsed.repository,
+        ref: Option.fromUndefinedOr(parsed.ref),
+        subPath: Option.fromUndefinedOr(parsed.subPath),
+    };
+    return validCoordinate(coordinate) ? Option.some(coordinate) : Option.none();
+};
 //# sourceMappingURL=forge-grammar.js.map

package/dist/src/unstable/sources/parser.d.ts

@@ -9,6 +9,7 @@
  * @packageDocumentation
  */
 import * as Option from "effect/Option";
+import { type ForgeCoordinate, type ForgePrefix } from "./forge-grammar.js";
 import type { VersionRange } from "../version-constraints/version-constraints.js";
 import type { ExtensionName, ExtensionType, ExtensionTypePlural } from "../extensions/common.js";
 import type { Handle } from "../extensions/handle.js";
@@ -45,10 +46,7 @@ type GitScpAddress = {
 /** An `owner/repo[//path][@ref]` style pattern containing `/` (not a URL or file path). */
 type SlashPattern = {
     readonly pattern: "slash-pattern";
-    readonly first: string;
-    readonly second: string;
-    readonly third: Option.Option<string>;
-    readonly ref: Option.Option<string>;
+    readonly coordinate: ForgeCoordinate;
 };
 /** A local filesystem path matching `LOCAL_PATH_PATTERN`. */
 type FilePathPattern = {
@@ -58,7 +56,7 @@ type FilePathPattern = {
 /** A shorthand prefixed input: `<prefix>:...` where prefix is a known source provider. */
 export type ShorthandInput = {
     readonly pattern: "shorthand-input";
-    readonly prefix: string;
+    readonly prefix: ForgePrefix;
     readonly remainingInput: string;
 };
 /** A glob pattern containing `*` wildcards (e.g. `effect-*`). */

package/dist/src/unstable/sources/parser.js

@@ -10,14 +10,13 @@
  */
 import * as Option from "effect/Option";
 import * as Result from "effect/Result";
+import { isForgePrefix, parseForgeCoordinate, } from "./forge-grammar.js";
 import { parseFqn } from "../extensions/fqn.js";
 import { parseSourceQualifiedRegistrySourcePatternParts } from "../extensions/registry-source.js";
 /** Matches: ./path, ../path, /path, ~/path, ~\path, or Windows paths like C:\path */
 const LOCAL_PATH_PATTERN = /^(?:\.\.?\/|\/|~\/|~\\|[A-Za-z]:[\\/])/;
 /** SCP-style: `user@host:path` — no `://` scheme. */
 const SCP_PATTERN = /^([^@]+)@([^:]+):(.+)$/;
-/** Known shorthand prefixes. */
-const SHORTHAND_PREFIXES = new Set(["github", "gitlab", "bitbucket", "azurerepos"]);
 /** Simple name: alphanumeric with hyphens, no leading/trailing hyphen. */
 const NAME_PATTERN = /^[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?$/;
 /**
@@ -66,10 +65,11 @@ export const parseInputPattern = (input) => {
     }
     // 4. Shorthand prefix (github:..., gitlab:..., etc.) — must check before URL
     const colonIndex = input.indexOf(":");
-    if (colonIndex > 0 && SHORTHAND_PREFIXES.has(input.slice(0, colonIndex))) {
+    const prefix = input.slice(0, colonIndex);
+    if (colonIndex > 0 && isForgePrefix(prefix)) {
         return Option.some(wrap({
             pattern: "shorthand-input",
-            prefix: input.slice(0, colonIndex),
+            prefix,
             remainingInput: input.slice(colonIndex + 1),
         }));
     }
@@ -90,34 +90,17 @@ export const parseInputPattern = (input) => {
     }
     // 7. Slash pattern (`owner/repo[//path][@ref]`)
     if (input.includes("/")) {
-        const refIndex = input.lastIndexOf("@");
-        const hasRef = refIndex > 0 && refIndex < input.length - 1;
-        const coordinate = hasRef ? input.slice(0, refIndex) : input;
-        const ref = hasRef ? input.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 segments = repositoryCoordinate.split("/");
-        const first = segments.at(0);
-        const second = segments.at(1);
-        if (first !== undefined &&
-            second !== undefined &&
-            segments.length === 2 &&
-            NAME_PATTERN.test(first) &&
-            NAME_PATTERN.test(second) &&
-            (ref === undefined || (ref.length > 0 && !ref.includes("/"))) &&
-            (subPath === undefined ||
-                (subPath.length > 0 &&
-                    subPath.split("/").every((segment) => segment.length > 0 && segment !== "..")))) {
-            return Option.some(wrap({
-                pattern: "slash-pattern",
-                first,
-                second,
-                third: Option.fromUndefinedOr(subPath),
-                ref: Option.fromUndefinedOr(ref),
-            }));
+        const parsed = parseForgeCoordinate("github", input);
+        if (Result.isFailure(parsed))
+            return Option.none();
+        const coordinate = parsed.success;
+        const segments = coordinate.repository.split("/");
+        if (segments.length !== 2 ||
+            !segments.every((segment) => NAME_PATTERN.test(segment)) ||
+            Option.exists(coordinate.ref, (ref) => ref.includes("/"))) {
+            return Option.none();
         }
-        return Option.none();
+        return Option.some(wrap({ pattern: "slash-pattern", coordinate }));
     }
     // 8. Glob pattern (contains `*` wildcard)
     if (input.includes("*")) {

package/dist/src/unstable/sources/printer.js

@@ -6,7 +6,14 @@
  */
 import * as Option from "effect/Option";
 import { formatFqn } from "../extensions/fqn.js";
-import { printLocalSource } from "./forge-grammar.js";
+import { forgeCoordinateFromGitUrl, printForgeCoordinate } from "./forge-grammar.js";
+const printLocalSource = (source) => {
+    if (source.path === "." || source.path === "..")
+        return `${source.path}/`;
+    return /^(?:\.\.?\/|\/|~[\\/]|[A-Za-z]:[\\/])/.test(source.path)
+        ? source.path
+        : `./${source.path}`;
+};
 /**
  * Print source params as their canonical shorthand string.
  *
@@ -17,40 +24,14 @@ export const printSourceParams = (source) => {
         case "local":
             return printLocalSource(source);
         case "git": {
-            const repositorySegments = source.url.pathname
-                .split("/")
-                .filter((segment) => segment.length > 0);
-            if (source.url.hostname === "dev.azure.com" &&
-                repositorySegments.length === 4 &&
-                repositorySegments[2] === "_git") {
-                let shorthand = `azurerepos:${repositorySegments[0]}/${repositorySegments[1]}/${repositorySegments[3]}`;
-                if (Option.isSome(source.subPath))
-                    shorthand += `//${source.subPath.value}`;
-                if (Option.isSome(source.ref))
-                    shorthand += `@${source.ref.value}`;
-                return shorthand;
-            }
-            const lastSegment = repositorySegments.at(-1);
-            const repo = lastSegment?.endsWith(".git") ? lastSegment.slice(0, -4) : lastSegment;
-            const sourcePrefix = source.url.hostname === "github.com"
-                ? "github"
-                : source.url.hostname === "gitlab.com"
-                    ? "gitlab"
-                    : source.url.hostname === "bitbucket.org"
-                        ? "bitbucket"
-                        : undefined;
-            if (sourcePrefix !== undefined && repo !== undefined && repositorySegments.length >= 2) {
-                const owner = repositorySegments.slice(0, -1).join("/");
-                let shorthand = `${sourcePrefix}:${owner}/${repo}`;
-                if (Option.isSome(source.subPath))
-                    shorthand += `//${source.subPath.value}`;
-                if (Option.isSome(source.ref))
-                    shorthand += `@${source.ref.value}`;
-                return shorthand;
-            }
-            const url = new URL(source.url.href);
-            url.hash = Option.getOrElse(source.ref, () => "");
-            return url.href;
+            return Option.match(forgeCoordinateFromGitUrl(source.url, source.ref, source.subPath), {
+                onSome: printForgeCoordinate,
+                onNone: () => {
+                    const url = new URL(source.url.href);
+                    url.hash = Option.getOrElse(source.ref, () => "");
+                    return url.href;
+                },
+            });
         }
         case "registry": {
             return source.sourceName ?? ("name" in source ? String(source.name) : "agentxm");