@agentxm/extension-sources 0.28.4-bootstrap.0

package/dist/src/glob.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Glob expansion for extension names.
+ *
+ * Expands `*` wildcards against a list of names. Only `*` is supported
+ * as a wildcard — all other characters are treated as literals.
+ *
+ * Deliberately duplicated from the CLI-destined glob module: the
+ * integration may not depend on application utilities, and this helper is
+ * within the sanctioned duplication budget for small pure functions.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+/**
+ * Expand a glob pattern against a list of names.
+ *
+ * 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
+ */
+export declare const expandGlob: (pattern: string, names: ReadonlyArray<string>) => ReadonlyArray<string>;
+/**
+ * Expand multiple glob patterns against a list of skill names.
+ *
+ * Returns the union of all matches, deduplicated, preserving the original
+ * order of `names`.
+ *
+ * @param patterns - Patterns to match (may contain `*`)
+ * @param names - Available names to match against
+ * @returns Matching names in their original order, deduplicated
+ */
+export declare const expandGlobs: (patterns: ReadonlyArray<string>, names: ReadonlyArray<string>) => ReadonlyArray<string>;
+/**
+ * Returns true when an input should be treated as a glob pattern.
+ */
+export declare const isGlobPattern: (input: string) => boolean;
+//# sourceMappingURL=glob.d.ts.map

package/dist/src/glob.js

@@ -0,0 +1,79 @@
+/**
+ * Glob expansion for extension names.
+ *
+ * Expands `*` wildcards against a list of names. Only `*` is supported
+ * as a wildcard — all other characters are treated as literals.
+ *
+ * Deliberately duplicated from the CLI-destined glob module: the
+ * integration may not depend on application utilities, and this helper is
+ * within the sanctioned duplication budget for small pure functions.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+/**
+ * Expand a glob pattern against a list of names.
+ *
+ * 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
+ */
+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;
+            }
+        }
+        while (pattern[patternIndex] === "*") {
+            patternIndex += 1;
+        }
+        return patternIndex === pattern.length;
+    };
+    return names.filter(matches);
+};
+/**
+ * Expand multiple glob patterns against a list of skill names.
+ *
+ * Returns the union of all matches, deduplicated, preserving the original
+ * order of `names`.
+ *
+ * @param patterns - Patterns to match (may contain `*`)
+ * @param names - Available names to match against
+ * @returns Matching names in their original order, deduplicated
+ */
+export const expandGlobs = (patterns, names) => {
+    const matched = new Set();
+    for (const pattern of patterns) {
+        for (const name of expandGlob(pattern, names)) {
+            matched.add(name);
+        }
+    }
+    return names.filter((n) => matched.has(n));
+};
+/**
+ * Returns true when an input should be treated as a glob pattern.
+ */
+export const isGlobPattern = (input) => input.includes("*");
+//# sourceMappingURL=glob.js.map

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

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

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

@@ -0,0 +1,14 @@
+/**
+ * Hook package discovery for local and git sources.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import { discoverManifestPackagesInDir } from "./manifest-package-discovery.js";
+import { HOOK_MANIFEST_FILENAME, HookManifestSchema, } from "@agentxm/extension-model/unstable/hooks/manifest-schema";
+const discoverHookPackagesInDir = discoverManifestPackagesInDir({
+    type: "hook",
+    manifestFilename: HOOK_MANIFEST_FILENAME,
+    manifestSchema: HookManifestSchema,
+});
+export const hookPackagesInDir = (searchPath, options) => discoverHookPackagesInDir(searchPath, options);
+//# sourceMappingURL=hook-package-discovery.js.map

package/dist/src/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * AXM extension-source integration.
+ *
+ * Provides source host providers, source resolution, identifier resolution,
+ * package discovery, multi-source pattern resolution, and git acquisition.
+ * The environment-backed `SourceHostProvidersLive` layer ships separately
+ * through the `./live` export.
+ *
+ * @experimental All exports from this module are unstable and may change without notice.
+ * @packageDocumentation
+ */
+export { GitOperationFailed, SOURCE_ERROR_CATEGORIES, SourceHostNotConfigured, SourceNetworkFailure, SourceNotResolvable, SourceSyntaxInvalid, isSourceError, isSourceResolutionFailure, sourceResolutionFailureCategory, type GitOperation, type SourceError, type SourceErrorCategory, type SourceResolutionFailure, } from "./errors.js";
+export type { CarriedFailureCategory } from "./failure-category.js";
+export { createGitSourceHostProvider } from "./providers/git.js";
+export { createGitHostingSourceHostProvider } from "./providers/git-hosting.js";
+export { createLocalSourceHostProvider } from "./providers/local.js";
+export { createLocalRegistrySourceHostProvider, createRegistrySourceHostProviderFromHost, createRemoteRegistrySourceHostProvider, } from "./providers/registry/host-provider.js";
+export type { SourceHostProvidersService } from "./service.js";
+export { SourceHostProviders, createRegistryMetaProvider } from "./service.js";
+export { WorkspaceCatalog, WorkspaceCatalogUnavailable, type ConfiguredSourceHost, type DesiredExtensionGraphView, type DesiredExtensionNodeView, type SkillCandidates, type WorkspaceCatalogService, } from "./workspace-catalog.js";
+export { AxmSkillCandidateGate, AxmSkillGateUnavailable, type AxmSkillCandidate, type AxmSkillCandidateGateService, type AxmSkillCandidateVerdict, } from "./axm-skill-gate.js";
+export { resolveSource, resolveShorthandInputSource, resolveSlashInputSource, routeUrlInput, routeScpInput, routeNameInput, routeRegistryInput, } from "./resolve-source.js";
+export { resolveIdentifier, resolveInstalledIdentifier, resolveInstalledIdentifierNameOrInput, type IdentifierResolutionScope, type IdentifierResourceType, type ResolveIdentifierArgs, type ResolvedIdentifier, } from "./resolve-identifier.js";
+export { resolveSourcePattern } from "./resolve-source-pattern.js";
+export { discoverExtensionPackages, inspectExtensionPackage, type DiscoveredExtensionPackage, type ExtensionPackageFilter, } from "./package-discovery.js";
+export { acquireExternalSource, findExtensionPackagesFromSource, type AcquiredExternalSource, type ResolvedExtensionPackage, } from "./package-sources.js";
+export { fileUrlToPath } from "./file-url.js";
+export { findGitRoot, isGitManaged } from "./git/detect.js";
+export { getCommitSha, getTreeSha, shallowClone } from "./git/operations.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.js

@@ -0,0 +1,35 @@
+/**
+ * AXM extension-source integration.
+ *
+ * Provides source host providers, source resolution, identifier resolution,
+ * package discovery, multi-source pattern resolution, and git acquisition.
+ * The environment-backed `SourceHostProvidersLive` layer ships separately
+ * through the `./live` export.
+ *
+ * @experimental All exports from this module are unstable and may change without notice.
+ * @packageDocumentation
+ */
+// Failure vocabulary
+export { GitOperationFailed, SOURCE_ERROR_CATEGORIES, SourceHostNotConfigured, SourceNetworkFailure, SourceNotResolvable, SourceSyntaxInvalid, isSourceError, isSourceResolutionFailure, sourceResolutionFailureCategory, } from "./errors.js";
+// Provider implementations
+export { createGitSourceHostProvider } from "./providers/git.js";
+export { createGitHostingSourceHostProvider } from "./providers/git-hosting.js";
+export { createLocalSourceHostProvider } from "./providers/local.js";
+export { createLocalRegistrySourceHostProvider, createRegistrySourceHostProviderFromHost, createRemoteRegistrySourceHostProvider, } from "./providers/registry/host-provider.js";
+export { SourceHostProviders, createRegistryMetaProvider } from "./service.js";
+// Workspace catalog port (implemented by the composition root)
+export { WorkspaceCatalog, WorkspaceCatalogUnavailable, } from "./workspace-catalog.js";
+// Official AXM skill candidate gate port (implemented by the composition root)
+export { AxmSkillCandidateGate, AxmSkillGateUnavailable, } from "./axm-skill-gate.js";
+// Source resolver
+export { resolveSource, resolveShorthandInputSource, resolveSlashInputSource, routeUrlInput, routeScpInput, routeNameInput, routeRegistryInput, } from "./resolve-source.js";
+export { resolveIdentifier, resolveInstalledIdentifier, resolveInstalledIdentifierNameOrInput, } from "./resolve-identifier.js";
+export { resolveSourcePattern } from "./resolve-source-pattern.js";
+export { discoverExtensionPackages, inspectExtensionPackage, } from "./package-discovery.js";
+export { acquireExternalSource, findExtensionPackagesFromSource, } from "./package-sources.js";
+// Locator utilities
+export { fileUrlToPath } from "./file-url.js";
+// Git acquisition
+export { findGitRoot, isGitManaged } from "./git/detect.js";
+export { getCommitSha, getTreeSha, shallowClone } from "./git/operations.js";
+//# sourceMappingURL=index.js.map

package/dist/src/integrity.d.ts

@@ -0,0 +1,13 @@
+/**
+ * SHA-512 integrity utility.
+ *
+ * Deliberately duplicated from the CLI-destined integrity module: the
+ * integration may not depend on application utilities, and this helper is
+ * within the sanctioned duplication budget for small pure functions.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+/** Compute SHA-512 integrity in `sha512-<base64>` SRI format. */
+export declare const computeIntegrity: (data: Uint8Array) => Effect.Effect<string>;
+//# sourceMappingURL=integrity.d.ts.map

package/dist/src/integrity.js

@@ -0,0 +1,17 @@
+/**
+ * SHA-512 integrity utility.
+ *
+ * Deliberately duplicated from the CLI-destined integrity module: the
+ * integration may not depend on application utilities, and this helper is
+ * within the sanctioned duplication budget for small pure functions.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import { createHash } from "node:crypto";
+/** Compute SHA-512 integrity in `sha512-<base64>` SRI format. */
+export const computeIntegrity = (data) => Effect.sync(() => {
+    const base64 = createHash("sha512").update(data).digest("base64");
+    return `sha512-${base64}`;
+});
+//# sourceMappingURL=integrity.js.map

package/dist/src/live.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Environment-backed Live layer for `SourceHostProviders`.
+ *
+ * Composed only at the application composition root: the layer captures the
+ * platform services and the two composition-root ports (workspace catalog,
+ * official AXM skill gate) once and hides them behind the service interface.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as FileSystem from "effect/FileSystem";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as Path from "effect/Path";
+import * as Layer from "effect/Layer";
+import { AxmSkillCandidateGate } from "./axm-skill-gate.js";
+import { SourceHostProviders } from "./service.js";
+import { WorkspaceCatalog } from "./workspace-catalog.js";
+/**
+ * Live layer for SourceHostProviders.
+ *
+ * Constructs the provider registry with all source type providers.
+ * Captures FileSystem, Path, HttpClient, the WorkspaceCatalog port, and the
+ * AxmSkillCandidateGate port at creation time so the service interface
+ * doesn't leak these dependencies.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const SourceHostProvidersLive: Layer.Layer<SourceHostProviders, never, FileSystem.FileSystem | HttpClient.HttpClient | Path.Path | WorkspaceCatalog | AxmSkillCandidateGate>;
+//# sourceMappingURL=live.d.ts.map

package/dist/src/live.js

@@ -0,0 +1,131 @@
+/**
+ * Environment-backed Live layer for `SourceHostProviders`.
+ *
+ * Composed only at the application composition root: the layer captures the
+ * platform services and the two composition-root ports (workspace catalog,
+ * official AXM skill gate) once and hides them behind the service interface.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as FileSystem from "effect/FileSystem";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as Path from "effect/Path";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import { makeWorkspaceRelativeSourcePath } from "@agentxm/extension-model/unstable/path-types";
+import { AxmSkillCandidateGate } from "./axm-skill-gate.js";
+import { SourceNotResolvable } from "./errors.js";
+import { fileUrlToPath } from "./file-url.js";
+import { createGitSourceHostProvider } from "./providers/git.js";
+import { createGitHostingSourceHostProvider } from "./providers/git-hosting.js";
+import { createLocalSourceHostProvider } from "./providers/local.js";
+import { buildCloneUrlFromSource, createRegistryMetaProvider, getOriginFromSource, SourceHostProviders, } from "./service.js";
+import { WorkspaceCatalog } from "./workspace-catalog.js";
+// -----------------------------------------------------------------------------
+// Layer
+// -----------------------------------------------------------------------------
+/**
+ * Live layer for SourceHostProviders.
+ *
+ * Constructs the provider registry with all source type providers.
+ * Captures FileSystem, Path, HttpClient, the WorkspaceCatalog port, and the
+ * AxmSkillCandidateGate port at creation time so the service interface
+ * doesn't leak these dependencies.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const SourceHostProvidersLive = Layer.effect(SourceHostProviders, Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const httpClient = yield* HttpClient.HttpClient;
+    const path = yield* Path.Path;
+    const catalog = yield* WorkspaceCatalog;
+    const axmSkillGate = yield* AxmSkillCandidateGate;
+    const localProvider = createLocalSourceHostProvider();
+    const gitProvider = createGitSourceHostProvider();
+    const registryMetaProvider = createRegistryMetaProvider();
+    // Captured layer for providing to provider operations
+    const depLayer = Layer.mergeAll(Layer.succeed(FileSystem.FileSystem, fs), Layer.succeed(HttpClient.HttpClient, httpClient), Layer.succeed(Path.Path, path), Layer.succeed(AxmSkillCandidateGate, axmSkillGate));
+    const findGitHosting = (source, options) => {
+        const provider = createGitHostingSourceHostProvider(source);
+        return provider.find(source, options).pipe(Effect.provide(depLayer));
+    };
+    const fetchGitHosting = (source, ref) => {
+        const provider = createGitHostingSourceHostProvider(source);
+        return provider.fetch(source, ref).pipe(Effect.provide(depLayer));
+    };
+    const localSourceForWorkspace = (source) => ({
+        ...source,
+        path: path.isAbsolute(source.path)
+            ? source.path
+            : path.resolve(catalog.workspaceRoot, source.path),
+    });
+    const normalizeLocalRefSourcePath = (ref) => {
+        if (ref.refType !== "local")
+            return Effect.succeed(ref);
+        const selectedPath = fileUrlToPath(ref.location);
+        const relative = makeWorkspaceRelativeSourcePath(path, catalog.workspaceRoot, selectedPath);
+        if (Option.isNone(relative)) {
+            return Effect.fail(new SourceNotResolvable({
+                category: "validation",
+                detail: `Local extension source path cannot be represented relative to the workspace: ${selectedPath}`,
+            }));
+        }
+        return Effect.succeed({ ...ref, sourcePath: relative.value });
+    };
+    const findImpl = (source, options) => {
+        switch (source.type) {
+            case "github":
+            case "gitlab":
+            case "bitbucket":
+            case "azurerepos":
+                return findGitHosting(source, options);
+            case "local":
+                return localProvider.find(localSourceForWorkspace(source), options).pipe(Effect.provide(depLayer), Effect.flatMap((refs) => Effect.forEach(refs, normalizeLocalRefSourcePath)));
+            case "git":
+                return gitProvider.find(source, options).pipe(Effect.provide(depLayer));
+            case "registry":
+                return registryMetaProvider.find(source, options).pipe(Effect.provide(depLayer));
+            case "workspace":
+                return Effect.fail(new SourceNotResolvable({
+                    category: "validation",
+                    detail: "Workspace sources resolve from their canonical package through the workspace configured-entry resolver",
+                }));
+        }
+    };
+    const fetchImpl = (source, ref) => {
+        switch (source.type) {
+            case "github":
+            case "gitlab":
+            case "bitbucket":
+            case "azurerepos":
+                return fetchGitHosting(source, ref);
+            case "local":
+                return localProvider.fetch(source, ref).pipe(Effect.provide(depLayer));
+            case "git":
+                return gitProvider.fetch(source, ref).pipe(Effect.provide(depLayer));
+            case "registry":
+                return registryMetaProvider.fetch(source, ref).pipe(Effect.provide(depLayer));
+            case "workspace":
+                return Effect.fail(new SourceNotResolvable({
+                    category: "validation",
+                    detail: "Workspace source files are read directly from their canonical package and are not fetched through a source host provider",
+                }));
+        }
+    };
+    const service = {
+        find: (source, options) => findImpl(source, options).pipe(Effect.withSpan("SourceHostProviders.find")),
+        resolveNamedRegistry: (source, options) => registryMetaProvider
+            .resolveNamed(source, options)
+            .pipe(Effect.provide(depLayer), Effect.withSpan("SourceHostProviders.resolveNamedRegistry")),
+        fetch: (ref) => {
+            const source = ref.source;
+            return fetchImpl(source, ref).pipe(Effect.withSpan("SourceHostProviders.fetch"));
+        },
+        cloneUrl: buildCloneUrlFromSource,
+        origin: getOriginFromSource,
+    };
+    return service;
+}));
+//# sourceMappingURL=live.js.map

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

@@ -0,0 +1,28 @@
+/**
+ * Shared manifest package discovery for local and git sources.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
+interface ManifestWithName {
+    readonly name: string;
+}
+export interface DiscoveredManifestPackage<Type extends string, Manifest extends ManifestWithName> {
+    readonly type: Type;
+    readonly manifest: Manifest;
+    readonly location: string;
+}
+export interface ManifestPackageDiscoveryOptions {
+    readonly fullDepth: boolean;
+}
+export interface ManifestPackageDiscoveryConfig<Type extends string, Manifest extends ManifestWithName> {
+    readonly type: Type;
+    readonly manifestFilename: string;
+    readonly manifestSchema: Schema.Decoder<Manifest>;
+}
+export declare const discoverManifestPackagesInDir: <Type extends string, Manifest extends ManifestWithName>(config: ManifestPackageDiscoveryConfig<Type, Manifest>) => (searchPath: string, options: ManifestPackageDiscoveryOptions) => Effect.Effect<ReadonlyArray<DiscoveredManifestPackage<Type, Manifest>>, never, FileSystem.FileSystem | Path.Path>;
+export {};
+//# sourceMappingURL=manifest-package-discovery.d.ts.map

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

@@ -0,0 +1,96 @@
+/**
+ * Shared manifest package discovery for local and git sources.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+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 { DISCOVERY_MAX_DEPTH, DISCOVERY_SKIPPED_DIRECTORIES, } from "@agentxm/extension-model/unstable/discovery-walk";
+export const discoverManifestPackagesInDir = (config) => (searchPath, options) => {
+    const tryParsePackageInDir = (dir) => Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+        const manifestPath = path.join(dir, config.manifestFilename);
+        const exists = yield* fs
+            .exists(manifestPath)
+            .pipe(Effect.catch(() => Effect.succeed(false)));
+        if (!exists)
+            return Option.none();
+        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(config.manifestSchema)(json.value).pipe(Effect.option);
+        if (Option.isNone(manifest))
+            return Option.none();
+        return Option.some({
+            type: config.type,
+            manifest: manifest.value,
+            location: `file://${dir}`,
+        });
+    });
+    const scanChildren = (dir) => Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+        const entries = yield* fs.readDirectory(dir).pipe(Effect.option);
+        if (Option.isNone(entries))
+            return [];
+        return yield* Effect.forEach(entries.value, (entry) => Effect.gen(function* () {
+            const fullPath = path.join(dir, entry);
+            const stat = yield* fs.stat(fullPath).pipe(Effect.option);
+            if (Option.isNone(stat) || stat.value.type !== "Directory") {
+                return [];
+            }
+            const discovered = yield* tryParsePackageInDir(fullPath);
+            return Option.isSome(discovered) ? [discovered.value] : [];
+        }), { concurrency: "unbounded" }).pipe(Effect.map((results) => Array.flatten(results)));
+    });
+    const recursiveScan = (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 [];
+        return 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 [];
+            }
+            const discovered = yield* tryParsePackageInDir(fullPath);
+            const current = Option.isSome(discovered) ? [discovered.value] : [];
+            const nested = yield* recursiveScan(fullPath, depth + 1);
+            return [...current, ...nested];
+        }), { concurrency: "unbounded" }).pipe(Effect.map((results) => Array.flatten(results)));
+    });
+    return Effect.gen(function* () {
+        const direct = yield* tryParsePackageInDir(searchPath);
+        const directPackages = Option.isSome(direct) ? [direct.value] : [];
+        if (directPackages.length > 0 && !options.fullDepth)
+            return directPackages;
+        const childPackages = yield* scanChildren(searchPath);
+        if ((directPackages.length > 0 || childPackages.length > 0) && !options.fullDepth) {
+            return [...directPackages, ...childPackages];
+        }
+        const recursivePackages = yield* recursiveScan(searchPath, 0);
+        const all = [...directPackages, ...childPackages, ...recursivePackages];
+        const seen = new Set();
+        return all.filter((pkg) => {
+            if (seen.has(pkg.manifest.name))
+                return false;
+            seen.add(pkg.manifest.name);
+            return true;
+        });
+    });
+};
+//# sourceMappingURL=manifest-package-discovery.js.map

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

@@ -0,0 +1,19 @@
+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 { SourceNotResolvable } from "./errors.js";
+import type { ExtensionType, Handle } from "@agentxm/extension-model/unstable/extensions";
+import { type ManifestIdentity } from "@agentxm/registry-protocol/unstable/publish/manifest-policy";
+export interface ExtensionPackageFilter {
+    readonly names: ReadonlyArray<string>;
+    readonly owner: Option.Option<Handle>;
+    readonly type: ExtensionType | "*";
+}
+export interface DiscoveredExtensionPackage {
+    readonly directory: string;
+    readonly identity: ManifestIdentity;
+}
+export declare const inspectExtensionPackage: (directory: string) => Effect.Effect<DiscoveredExtensionPackage, SourceNotResolvable, FileSystem.FileSystem | Path.Path>;
+export declare const discoverExtensionPackages: (root: string, filter: ExtensionPackageFilter) => Effect.Effect<ReadonlyArray<DiscoveredExtensionPackage>, SourceNotResolvable, FileSystem.FileSystem | Path.Path>;
+//# sourceMappingURL=package-discovery.d.ts.map