@agentxm/extension-discovery 0.28.4-bootstrap.0

package/dist/src/packaging/jsr.js

@@ -0,0 +1,227 @@
+/**
+ * JSR package detector and Deno reader for package-compatibility discovery.
+ *
+ * Parses `deno.json`/`deno.jsonc` for `jsr:@scope/name` imports and reads
+ * axm metadata from Deno's module cache.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+// Intentional escape hatch: node:os homedir() has no @effect/platform equivalent.
+import * as os from "node:os";
+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 Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import { PackageURL } from "packageurl-js";
+import { readEnv } from "../internal/environment.js";
+import { PackageTypeSchema } from "@agentxm/extension-model/unstable/packaging/package-type";
+import { decodeAxmMeta, decodePurl, parseJsonOptional, readFileOptional } from "./reader-io.js";
+const jsrType = Schema.decodeUnknownSync(PackageTypeSchema)("jsr");
+/**
+ * Strip single-line (//) and multi-line comments from JSONC content.
+ * Simple approach that handles most common cases.
+ */
+const stripJsoncComments = (content) => {
+    let result = "";
+    let i = 0;
+    let inString = false;
+    while (i < content.length) {
+        // Track string boundaries
+        if (content[i] === '"' && (i === 0 || content[i - 1] !== "\\")) {
+            inString = !inString;
+            result += content[i];
+            i++;
+            continue;
+        }
+        if (inString) {
+            result += content[i];
+            i++;
+            continue;
+        }
+        // Single-line comment
+        if (content[i] === "/" && content[i + 1] === "/") {
+            while (i < content.length && content[i] !== "\n")
+                i++;
+            continue;
+        }
+        // Multi-line comment
+        if (content[i] === "/" && content[i + 1] === "*") {
+            i += 2;
+            while (i < content.length - 1 && !(content[i] === "*" && content[i + 1] === "/"))
+                i++;
+            i += 2; // skip */
+            continue;
+        }
+        result += content[i];
+        i++;
+    }
+    return result;
+};
+/**
+ * Returns true if the specifier is an exact semver version (no range operators).
+ */
+const isExactVersion = (version) => /^\d+\.\d+\.\d+(?:[-+][a-zA-Z0-9._+-]*)?$/.test(version);
+/**
+ * Parse a JSR import specifier like `jsr:@scope/name@version`.
+ * Returns parsed parts or undefined if not a JSR import.
+ */
+const parseJsrSpecifier = (specifier) => {
+    if (!specifier.startsWith("jsr:"))
+        return undefined;
+    const rest = specifier.slice(4); // Remove "jsr:" prefix
+    // Match @scope/name or @scope/name@version
+    const match = /^(@[^/]+)\/([^@]+)(?:@(.+))?$/.exec(rest);
+    if (match === null || match[1] === undefined || match[2] === undefined)
+        return undefined;
+    return {
+        scope: match[1],
+        name: match[2],
+        ...(match[3] !== undefined ? { version: match[3] } : {}),
+    };
+};
+/**
+ * Extract JSR imports from a parsed deno.json imports map.
+ */
+const extractJsrImports = (imports, source) => {
+    const results = [];
+    for (const specifier of Object.values(imports)) {
+        const parsed = parseJsrSpecifier(specifier);
+        if (parsed === undefined)
+            continue; // Skip non-JSR imports (npm:, etc.)
+        const version = parsed.version !== undefined && isExactVersion(parsed.version) ? parsed.version : undefined;
+        const purl = new PackageURL("jsr", parsed.scope, parsed.name, version ?? null, null, null);
+        const purlParts = decodePurl(purl.toString());
+        results.push({ purl: purlParts, type: jsrType, source });
+    }
+    return results;
+};
+/** Schema to extract the optional "imports" field from deno.json. */
+const DenoImportsSchema = Schema.Struct({
+    imports: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+});
+const decodeDenoImports = Schema.decodeUnknownResult(DenoImportsSchema);
+/**
+ * JSR package detector.
+ *
+ * Scans `deno.json` and `deno.jsonc` in the project directory and extracts
+ * `jsr:@scope/name` imports, producing `pkg:jsr/<scope>/<name>` purls.
+ * npm-prefixed imports are skipped.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const jsrDetector = {
+    type: jsrType,
+    detect: Effect.fn("detect.jsr")(function* (projectDir) {
+        const path = yield* Path.Path;
+        // Try deno.json first, then deno.jsonc
+        const denoJsonPath = path.join(projectDir, "deno.json");
+        const denoJsoncPath = path.join(projectDir, "deno.jsonc");
+        let content = yield* readFileOptional(denoJsonPath);
+        let source = denoJsonPath;
+        let isJsonc = false;
+        if (Option.isNone(content)) {
+            content = yield* readFileOptional(denoJsoncPath);
+            source = denoJsoncPath;
+            isJsonc = true;
+        }
+        if (Option.isNone(content))
+            return [];
+        // Strip comments for .jsonc files
+        const jsonContent = isJsonc ? stripJsoncComments(content.value) : content.value;
+        const parsed = yield* parseJsonOptional(jsonContent, source);
+        if (Option.isNone(parsed))
+            return [];
+        const importsResult = decodeDenoImports(parsed.value);
+        if (Result.isFailure(importsResult))
+            return [];
+        const imports = importsResult.success.imports;
+        if (imports === undefined)
+            return [];
+        return extractJsrImports(imports, source);
+    }, Effect.annotateLogs({ detector: "jsr" }), Effect.withSpan("detect.jsr")),
+};
+/** Schema to extract the optional "axm" field from deno.json. */
+const AxmContainerSchema = Schema.Struct({
+    axm: Schema.optional(Schema.Unknown),
+});
+const decodeAxmContainer = Schema.decodeUnknownResult(AxmContainerSchema);
+/**
+ * Resolve the Deno cache directory.
+ * Uses $DENO_DIR if set, otherwise platform-specific defaults.
+ */
+const resolveDenoDir = () => Effect.sync(() => {
+    const denoDir = readEnv("DENO_DIR");
+    if (denoDir !== undefined && denoDir !== "")
+        return denoDir;
+    // Platform-specific defaults
+    if (process.platform === "darwin") {
+        return `${os.homedir()}/Library/Caches/deno`;
+    }
+    return `${os.homedir()}/.cache/deno`;
+});
+/**
+ * Deno package reader.
+ *
+ * Reads axm metadata from cached module metadata in Deno's module cache.
+ * Checks for an `"axm"` field in cached `deno.json` files.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const denoReader = {
+    type: jsrType,
+    read: Effect.fn("read.deno")(function* (pkg) {
+        const path = yield* Path.Path;
+        const fs = yield* FileSystem.FileSystem;
+        const denoDir = yield* resolveDenoDir();
+        // Check if deno cache directory exists
+        const denoDirExists = yield* fs.exists(denoDir).pipe(Effect.option);
+        if (Option.isNone(denoDirExists) || !denoDirExists.value)
+            return Option.none();
+        const pkgNamespace = pkg.purl.namespace;
+        if (pkgNamespace === undefined)
+            return Option.none();
+        const scope = pkgNamespace;
+        // Look for cached module metadata
+        // Deno caches JSR packages in registry cache
+        const registryCacheDir = path.join(denoDir, "registries", "jsr.io");
+        const cacheDirExists = yield* fs.exists(registryCacheDir).pipe(Effect.option);
+        if (Option.isNone(cacheDirExists) || !cacheDirExists.value)
+            return Option.none();
+        // Check the cached package directory for deno.json with axm field
+        const pkgCacheDir = path.join(registryCacheDir, scope, pkg.purl.name);
+        const pkgDirExists = yield* fs.exists(pkgCacheDir).pipe(Effect.option);
+        if (Option.isNone(pkgDirExists) || !pkgDirExists.value)
+            return Option.none();
+        // Scan version directories for deno.json with axm field
+        const versionDirs = yield* fs.readDirectory(pkgCacheDir).pipe(Effect.option);
+        if (Option.isNone(versionDirs))
+            return Option.none();
+        for (const versionDir of versionDirs.value) {
+            const denoJsonPath = path.join(pkgCacheDir, versionDir, "deno.json");
+            const content = yield* readFileOptional(denoJsonPath);
+            if (Option.isNone(content))
+                continue;
+            const parsed = yield* parseJsonOptional(content.value, `${scope}/${pkg.purl.name}/deno.json`);
+            if (Option.isNone(parsed))
+                continue;
+            // Extract and validate the "axm" field
+            const axmContainerResult = decodeAxmContainer(parsed.value);
+            if (Result.isFailure(axmContainerResult))
+                continue;
+            const axmRaw = axmContainerResult.success.axm;
+            if (axmRaw === undefined)
+                continue;
+            const metaResult = decodeAxmMeta(axmRaw);
+            if (Result.isFailure(metaResult)) {
+                yield* Effect.logWarning(`Invalid axm metadata in deno cache for ${scope}/${pkg.purl.name}: schema validation failed`);
+                continue;
+            }
+            return Option.some(metaResult.success.extensions);
+        }
+        return Option.none();
+    }, Effect.annotateLogs({ reader: "deno" }), Effect.withSpan("read.deno")),
+};
+//# sourceMappingURL=jsr.js.map

package/dist/src/packaging/julia.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Julia package detector and reader for package-compatibility discovery.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { PackageDetector, PackageReader } from "./types.js";
+/**
+ * Julia package detector.
+ *
+ * Scans `Project.toml` in the project directory and extracts dependencies
+ * from the `[deps]` section. All purls are versionless since Julia
+ * identifies packages by UUID.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const juliaDetector: PackageDetector;
+/**
+ * Julia package reader.
+ *
+ * Reads `[axm]` section from `~/.julia/packages/<pkg>/<hash>/Project.toml`
+ * for each detected Julia package.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const juliaReader: PackageReader;
+//# sourceMappingURL=julia.d.ts.map

package/dist/src/packaging/julia.js

@@ -0,0 +1,165 @@
+/**
+ * Julia package detector and reader for package-compatibility discovery.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+// Intentional escape hatch: node:os homedir() has no @effect/platform equivalent.
+import * as os from "node:os";
+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 Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import { PackageURL } from "packageurl-js";
+import { parseTomlValue } from "@agentxm/extension-workspace";
+import { PackageTypeSchema } from "@agentxm/extension-model/unstable/packaging/package-type";
+import { decodeAxmMeta, decodePurl, readFileOptional } from "./reader-io.js";
+const juliaType = Schema.decodeUnknownSync(PackageTypeSchema)("julia");
+/** UUID pattern for Julia dependency values. */
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+ * Parse a simple TOML [deps] section from Project.toml content.
+ * Julia's Project.toml uses TOML format with [deps] section containing:
+ *   PackageName = "uuid-string"
+ */
+const parseDepsSection = (content, source) => {
+    const results = [];
+    const lines = content.split("\n");
+    let inDepsSection = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Section headers
+        if (trimmed.startsWith("[")) {
+            inDepsSection = trimmed === "[deps]";
+            continue;
+        }
+        if (!inDepsSection)
+            continue;
+        // Skip empty lines and comments
+        if (trimmed === "" || trimmed.startsWith("#"))
+            continue;
+        // Parse key = "value" entries
+        const match = /^(\S+)\s*=\s*"([^"]*)"/.exec(trimmed);
+        if (match === null)
+            continue;
+        const name = match[1];
+        const value = match[2];
+        if (name === undefined || value === undefined)
+            continue;
+        // Validate it looks like a UUID
+        if (!UUID_PATTERN.test(value))
+            continue;
+        // Julia deps are always versionless (identified by UUID)
+        const purl = new PackageURL("julia", null, name, null, null, null);
+        const purlParts = decodePurl(purl.toString());
+        results.push({ purl: purlParts, type: juliaType, source });
+    }
+    return results;
+};
+/**
+ * Julia package detector.
+ *
+ * Scans `Project.toml` in the project directory and extracts dependencies
+ * from the `[deps]` section. All purls are versionless since Julia
+ * identifies packages by UUID.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const juliaDetector = {
+    type: juliaType,
+    detect: Effect.fn("detect.julia")(function* (projectDir) {
+        const path = yield* Path.Path;
+        const projectTomlPath = path.join(projectDir, "Project.toml");
+        const content = yield* readFileOptional(projectTomlPath);
+        if (Option.isNone(content))
+            return [];
+        const deps = parseDepsSection(content.value, projectTomlPath);
+        if (deps.length === 0 && content.value.trim().length > 0) {
+            // Content exists but no deps found - check if it looks like valid TOML
+            if (!content.value.includes("=") && !content.value.includes("[")) {
+                yield* Effect.logWarning("Malformed Project.toml, skipping");
+            }
+        }
+        return deps;
+    }, Effect.annotateLogs({ detector: "julia" }), Effect.withSpan("detect.julia")),
+};
+/**
+ * Parse a simple TOML [axm] section from Project.toml content.
+ * Returns the parsed fields as a record, or undefined if no [axm] section found.
+ */
+const parseAxmSection = (content) => {
+    const lines = content.split("\n");
+    let inAxmSection = false;
+    const fields = {};
+    let foundSection = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Section headers
+        if (trimmed.startsWith("[")) {
+            if (inAxmSection)
+                break; // End of [axm] section
+            inAxmSection = trimmed === "[axm]";
+            if (inAxmSection)
+                foundSection = true;
+            continue;
+        }
+        if (!inAxmSection)
+            continue;
+        // Skip empty lines and comments
+        if (trimmed === "" || trimmed.startsWith("#"))
+            continue;
+        // Parse key = value entries
+        const match = /^(\S+)\s*=\s*(.+)$/.exec(trimmed);
+        if (match === null)
+            continue;
+        const key = match[1];
+        const rawValue = match[2]?.trim();
+        if (key === undefined || rawValue === undefined)
+            continue;
+        // Parse TOML values
+        fields[key] = parseTomlValue(rawValue);
+    }
+    return foundSection ? fields : undefined;
+};
+/**
+ * Julia package reader.
+ *
+ * Reads `[axm]` section from `~/.julia/packages/<pkg>/<hash>/Project.toml`
+ * for each detected Julia package.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const juliaReader = {
+    type: juliaType,
+    read: Effect.fn("read.julia")(function* (pkg) {
+        const path = yield* Path.Path;
+        const fs = yield* FileSystem.FileSystem;
+        const pkgName = pkg.purl.name;
+        const home = os.homedir();
+        const juliaPkgsDir = path.join(home, ".julia", "packages", pkgName);
+        // Scan hash directories
+        const hashDirs = yield* fs.readDirectory(juliaPkgsDir).pipe(Effect.option);
+        if (Option.isNone(hashDirs))
+            return Option.none();
+        // Check each hash directory for Project.toml with [axm] section
+        for (const hashDir of hashDirs.value) {
+            const projectTomlPath = path.join(juliaPkgsDir, hashDir, "Project.toml");
+            const content = yield* readFileOptional(projectTomlPath);
+            if (Option.isNone(content))
+                continue;
+            const axmFields = parseAxmSection(content.value);
+            if (axmFields === undefined)
+                continue;
+            const metaResult = decodeAxmMeta(axmFields);
+            if (Result.isFailure(metaResult)) {
+                yield* Effect.logWarning(`Invalid axm metadata in ${pkgName}: schema validation failed`);
+                return Option.none();
+            }
+            return Option.some(metaResult.success.extensions);
+        }
+        return Option.none();
+    }, Effect.annotateLogs({ reader: "julia" }), Effect.withSpan("read.julia")),
+};
+//# sourceMappingURL=julia.js.map

package/dist/src/packaging/luarocks.d.ts

@@ -0,0 +1,28 @@
+/**
+ * LuaRocks package detector and reader for package-compatibility discovery.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { PackageDetector, PackageReader } from "./types.js";
+/**
+ * LuaRocks package detector.
+ *
+ * Scans `*.rockspec` files in the project directory and extracts
+ * dependencies from the `dependencies` table. Skips the `lua` runtime.
+ * Multiple rockspec files are processed and results deduplicated.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const luarocksDetector: PackageDetector;
+/**
+ * LuaRocks package reader.
+ *
+ * Reads `axm/axm.json` sidecar from the LuaRocks install tree.
+ * Checks system tree (`/usr/local/lib/luarocks/rocks-5.x/`) and
+ * user tree (`~/.luarocks/lib/luarocks/rocks-5.x/`).
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const luarocksReader: PackageReader;
+//# sourceMappingURL=luarocks.d.ts.map

package/dist/src/packaging/luarocks.js

@@ -0,0 +1,159 @@
+/**
+ * LuaRocks package detector and reader for package-compatibility discovery.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+// Intentional escape hatch: node:os homedir() has no @effect/platform equivalent.
+import * as os from "node:os";
+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 Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import { PackageURL } from "packageurl-js";
+import { PackageTypeSchema } from "@agentxm/extension-model/unstable/packaging/package-type";
+import { decodeAxmMeta, decodePurl, parseJsonOptional, readFileOptional } from "./reader-io.js";
+const luarocksType = Schema.decodeUnknownSync(PackageTypeSchema)("luarocks");
+/** Dependencies to skip (Lua runtime itself). */
+const SKIP_DEPS = new Set(["lua"]);
+/**
+ * Parse a single dependency string from a rockspec dependencies table.
+ * Format: "name [operator version]"
+ * Examples: "luasocket >= 3.0", "luafilesystem", "cjson == 1.0.0-1"
+ */
+const parseLuaDep = (entry) => {
+    const trimmed = entry.trim().replace(/^["']|["']$/g, "");
+    if (trimmed === "")
+        return undefined;
+    const parts = trimmed.split(/\s+/);
+    const name = parts[0];
+    if (name === undefined || name === "")
+        return undefined;
+    if (SKIP_DEPS.has(name.toLowerCase()))
+        return undefined;
+    // Check for exact version: name == version
+    if (parts[1] === "==" && parts[2] !== undefined) {
+        return { name, version: parts[2] };
+    }
+    // Any other operator or no version => versionless
+    return { name };
+};
+/**
+ * Parse a rockspec dependencies table from file content.
+ * The dependencies table has the form:
+ *   dependencies = { "dep1", "dep2 >= 1.0", ... }
+ * This is a Lua table literal, so we use regex to extract entries.
+ */
+const parseRockspecDeps = (content, source) => {
+    const results = [];
+    // Find dependencies table - may span multiple lines
+    const depsRegex = /dependencies\s*=\s*\{([^}]*)}/s;
+    const match = depsRegex.exec(content);
+    if (match === null || match[1] === undefined)
+        return [];
+    // Extract quoted strings from the table
+    const stringRegex = /["']([^"']+)["']/g;
+    let strMatch;
+    while ((strMatch = stringRegex.exec(match[1])) !== null) {
+        const entry = strMatch[1];
+        if (entry === undefined)
+            continue;
+        const parsed = parseLuaDep(entry);
+        if (parsed === undefined)
+            continue;
+        const purl = new PackageURL("luarocks", null, parsed.name, parsed.version ?? null, null, null);
+        const purlParts = decodePurl(purl.toString());
+        results.push({ purl: purlParts, type: luarocksType, source });
+    }
+    return results;
+};
+/**
+ * LuaRocks package detector.
+ *
+ * Scans `*.rockspec` files in the project directory and extracts
+ * dependencies from the `dependencies` table. Skips the `lua` runtime.
+ * Multiple rockspec files are processed and results deduplicated.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const luarocksDetector = {
+    type: luarocksType,
+    detect: Effect.fn("detect.luarocks")(function* (projectDir) {
+        const path = yield* Path.Path;
+        const fs = yield* FileSystem.FileSystem;
+        const entries = yield* fs.readDirectory(projectDir).pipe(Effect.option);
+        if (Option.isNone(entries))
+            return [];
+        const rockspecFiles = entries.value.filter((e) => e.endsWith(".rockspec"));
+        if (rockspecFiles.length === 0)
+            return [];
+        const allDeps = [];
+        const seenNames = new Set();
+        for (const rockspecFile of rockspecFiles) {
+            const filePath = path.join(projectDir, rockspecFile);
+            const content = yield* readFileOptional(filePath);
+            if (Option.isNone(content))
+                continue;
+            const deps = parseRockspecDeps(content.value, filePath);
+            if (deps.length === 0 && content.value.trim().length > 0) {
+                // Content exists but no deps - check if it looks like a valid rockspec
+                if (!content.value.includes("package") && !content.value.includes("rockspec_format")) {
+                    yield* Effect.logWarning(`Malformed rockspec file: ${rockspecFile}, skipping`);
+                }
+            }
+            for (const dep of deps) {
+                if (!seenNames.has(dep.purl.name)) {
+                    seenNames.add(dep.purl.name);
+                    allDeps.push(dep);
+                }
+            }
+        }
+        return allDeps;
+    }, Effect.annotateLogs({ detector: "luarocks" }), Effect.withSpan("detect.luarocks")),
+};
+/**
+ * LuaRocks package reader.
+ *
+ * Reads `axm/axm.json` sidecar from the LuaRocks install tree.
+ * Checks system tree (`/usr/local/lib/luarocks/rocks-5.x/`) and
+ * user tree (`~/.luarocks/lib/luarocks/rocks-5.x/`).
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const luarocksReader = {
+    type: luarocksType,
+    read: Effect.fn("read.luarocks")(function* (pkg) {
+        const path = yield* Path.Path;
+        const pkgName = pkg.purl.name;
+        const version = pkg.purl.version ?? "0.0.0-0";
+        const home = os.homedir();
+        // Lua version variants to check
+        const luaVersions = ["5.4", "5.3", "5.2", "5.1"];
+        // Candidate base paths
+        const basePaths = [
+            "/usr/local/lib/luarocks",
+            path.join(home, ".luarocks", "lib", "luarocks"),
+        ];
+        for (const basePath of basePaths) {
+            for (const luaVer of luaVersions) {
+                const axmJsonPath = path.join(basePath, `rocks-${luaVer}`, pkgName, version, "axm", "axm.json");
+                const content = yield* readFileOptional(axmJsonPath);
+                if (Option.isNone(content))
+                    continue;
+                const parsed = yield* parseJsonOptional(content.value, `${pkgName}/${version}/axm/axm.json`);
+                if (Option.isNone(parsed))
+                    return Option.none();
+                const metaResult = decodeAxmMeta(parsed.value);
+                if (Result.isFailure(metaResult)) {
+                    yield* Effect.logWarning(`Invalid axm metadata in ${pkgName}: schema validation failed`);
+                    return Option.none();
+                }
+                return Option.some(metaResult.success.extensions);
+            }
+        }
+        return Option.none();
+    }, Effect.annotateLogs({ reader: "luarocks" }), Effect.withSpan("read.luarocks")),
+};
+//# sourceMappingURL=luarocks.js.map

package/dist/src/packaging/maven.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Maven/Gradle package detector and reader for package-compatibility discovery.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { PackageDetector, PackageReader } from "./types.js";
+/**
+ * Maven package detector.
+ *
+ * Scans `pom.xml`, `build.gradle`, `build.gradle.kts`, and
+ * `gradle/libs.versions.toml` in the project directory. Also detects Clojure
+ * `deps.edn` Maven coordinates declared with `:mvn/version`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const mavenDetector: PackageDetector;
+/**
+ * Maven package reader.
+ *
+ * Reads `META-INF/axm.json` from local JAR files in `~/.m2/repository/`
+ * or Gradle cache `~/.gradle/caches/modules-2/files-2.1/`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const mavenReader: PackageReader;
+//# sourceMappingURL=maven.d.ts.map