@agentxm/extension-discovery 0.28.4-bootstrap.0

package/dist/src/packaging/conan.js

@@ -0,0 +1,238 @@
+/**
+ * Conan (C++) package detector and reader for package-compatibility discovery.
+ *
+ * Parses `conanfile.txt` `[requires]` sections and `conanfile.py` `requires`
+ * attributes. Reads axm metadata from Conan cache `conandata.yml` or
+ * `extension_properties`.
+ *
+ * @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 Option from "effect/Option";
+import * as Path from "effect/Path";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import YAML from "yaml";
+import { readEnv } from "../internal/environment.js";
+import { PackageTypeSchema } from "@agentxm/extension-model/unstable/packaging/package-type";
+import { decodeAxmMeta, readFileOptional } from "./reader-io.js";
+const conanType = Schema.decodeUnknownSync(PackageTypeSchema)("conan");
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Parse a Conan reference string like "name/version" or "name/version@user/channel".
+ * Returns name and optional version.
+ */
+const parseConanRef = (ref) => {
+    const trimmed = ref.trim();
+    if (trimmed === "" || trimmed.startsWith("#"))
+        return undefined;
+    // Strip user/channel suffix if present: name/version@user/channel
+    const atIdx = trimmed.indexOf("@");
+    const refPart = atIdx >= 0 ? trimmed.slice(0, atIdx) : trimmed;
+    const slashIdx = refPart.indexOf("/");
+    if (slashIdx <= 0)
+        return undefined;
+    const name = refPart.slice(0, slashIdx).trim();
+    const version = refPart.slice(slashIdx + 1).trim();
+    if (name === "")
+        return undefined;
+    return { name, version: version !== "" ? version : undefined };
+};
+/**
+ * Parse `conanfile.txt` content and extract dependencies from [requires] section.
+ */
+const parseConanfileTxt = (content, source) => {
+    const lines = content.split("\n");
+    const results = [];
+    let inRequiresSection = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Section header
+        if (trimmed.startsWith("[")) {
+            inRequiresSection = trimmed === "[requires]";
+            continue;
+        }
+        if (!inRequiresSection)
+            continue;
+        if (trimmed === "" || trimmed.startsWith("#"))
+            continue;
+        const parsed = parseConanRef(trimmed);
+        if (parsed !== undefined) {
+            results.push({
+                purl: {
+                    type: conanType,
+                    name: parsed.name,
+                    ...(parsed.version !== undefined ? { version: parsed.version } : {}),
+                },
+                type: conanType,
+                source,
+            });
+        }
+    }
+    return results;
+};
+/**
+ * Parse `conanfile.py` content and extract dependencies from `requires` attribute.
+ * Looks for patterns like: requires = "name/version", "name2/version2"
+ * and self.requires("name/version")
+ */
+const parseConanfilePy = (content, source) => {
+    const results = [];
+    const seenNames = new Set();
+    // Match class-level `requires = "ref", "ref2"` or `requires = ("ref", "ref2")`
+    const classRequiresRegex = /requires\s*=\s*(?:\(([^)]*)\)|([^\n]*))/g;
+    let match;
+    while ((match = classRequiresRegex.exec(content)) !== null) {
+        const value = match[1] ?? match[2] ?? "";
+        const refs = value.match(/"([^"]+)"/g);
+        if (refs) {
+            for (const quotedRef of refs) {
+                const ref = quotedRef.slice(1, -1);
+                const parsed = parseConanRef(ref);
+                if (parsed !== undefined && !seenNames.has(parsed.name)) {
+                    seenNames.add(parsed.name);
+                    results.push({
+                        purl: {
+                            type: conanType,
+                            name: parsed.name,
+                            ...(parsed.version !== undefined ? { version: parsed.version } : {}),
+                        },
+                        type: conanType,
+                        source,
+                    });
+                }
+            }
+        }
+    }
+    // Match self.requires("ref")
+    const selfRequiresRegex = /self\.requires\s*\(\s*"([^"]+)"/g;
+    while ((match = selfRequiresRegex.exec(content)) !== null) {
+        const ref = match[1];
+        if (ref === undefined)
+            continue;
+        const parsed = parseConanRef(ref);
+        if (parsed !== undefined && !seenNames.has(parsed.name)) {
+            seenNames.add(parsed.name);
+            results.push({
+                purl: {
+                    type: conanType,
+                    name: parsed.name,
+                    ...(parsed.version !== undefined ? { version: parsed.version } : {}),
+                },
+                type: conanType,
+                source,
+            });
+        }
+    }
+    return results;
+};
+// ---------------------------------------------------------------------------
+// Detector
+// ---------------------------------------------------------------------------
+/**
+ * Conan package detector.
+ *
+ * Scans `conanfile.txt` `[requires]` section and `conanfile.py` `requires`
+ * attribute in the project directory.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const conanDetector = {
+    type: conanType,
+    detect: Effect.fn("detect.conan")(function* (projectDir) {
+        const path = yield* Path.Path;
+        const allPackages = [];
+        const seenNames = new Set();
+        const addUnique = (pkgs) => {
+            for (const pkg of pkgs) {
+                if (!seenNames.has(pkg.purl.name)) {
+                    seenNames.add(pkg.purl.name);
+                    allPackages.push(pkg);
+                }
+            }
+        };
+        // 1. conanfile.txt
+        const conanfileTxtPath = path.join(projectDir, "conanfile.txt");
+        const conanfileTxtContent = yield* readFileOptional(conanfileTxtPath);
+        if (Option.isSome(conanfileTxtContent)) {
+            addUnique(parseConanfileTxt(conanfileTxtContent.value, conanfileTxtPath));
+        }
+        // 2. conanfile.py
+        const conanfilePyPath = path.join(projectDir, "conanfile.py");
+        const conanfilePyContent = yield* readFileOptional(conanfilePyPath);
+        if (Option.isSome(conanfilePyContent)) {
+            addUnique(parseConanfilePy(conanfilePyContent.value, conanfilePyPath));
+        }
+        return allPackages;
+    }, Effect.annotateLogs({ detector: "conan" }), Effect.withSpan("detect.conan")),
+};
+// ---------------------------------------------------------------------------
+// Reader
+// ---------------------------------------------------------------------------
+/**
+ * Parse YAML content, returning Option.none and logging a warning on failure.
+ */
+const parseYamlOptional = (content, context) => Effect.gen(function* () {
+    const result = yield* Effect.try({
+        try: () => YAML.parse(content),
+        catch: () => ({ _tag: "YamlParseError" }),
+    }).pipe(Effect.option);
+    if (Option.isNone(result)) {
+        yield* Effect.logWarning(`Malformed YAML in ${context}, skipping`);
+        return Option.none();
+    }
+    return Option.some(result.value);
+});
+/** Schema for extracting the axm field from conandata.yml */
+const ConanDataAxmSchema = Schema.Struct({
+    axm: Schema.optional(Schema.Unknown),
+});
+const decodeConanDataAxm = Schema.decodeUnknownResult(ConanDataAxmSchema);
+/**
+ * Resolve the Conan cache directory.
+ * Checks CONAN_USER_HOME, then defaults to ~/.conan2.
+ */
+const resolveConanCache = () => Effect.sync(() => readEnv("CONAN_USER_HOME") ?? `${os.homedir()}/.conan2`);
+/**
+ * Conan package reader.
+ *
+ * Reads axm metadata from `conandata.yml` in the Conan cache or
+ * `extension_properties` for each detected Conan package.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const conanReader = {
+    type: conanType,
+    read: Effect.fn("read.conan")(function* (pkg) {
+        const path = yield* Path.Path;
+        const conanCache = yield* resolveConanCache();
+        // Try conandata.yml in the package's cache directory
+        const version = pkg.purl.version ?? "0.0.0";
+        const conanDataPath = path.join(conanCache, "p", pkg.purl.name, version, "export", "conandata.yml");
+        const content = yield* readFileOptional(conanDataPath);
+        if (Option.isNone(content))
+            return Option.none();
+        const parsed = yield* parseYamlOptional(content.value, `${pkg.purl.name}/conandata.yml`);
+        if (Option.isNone(parsed))
+            return Option.none();
+        // Extract axm metadata from conandata.yml
+        const containerResult = decodeConanDataAxm(parsed.value);
+        if (Result.isFailure(containerResult))
+            return Option.none();
+        const axmRaw = containerResult.success.axm;
+        if (axmRaw === undefined)
+            return Option.none();
+        const metaResult = decodeAxmMeta(axmRaw);
+        if (Result.isFailure(metaResult)) {
+            yield* Effect.logWarning(`Invalid axm metadata in ${pkg.purl.name}: schema validation failed`);
+            return Option.none();
+        }
+        return Option.some(metaResult.success.extensions);
+    }, Effect.annotateLogs({ reader: "conan" }), Effect.withSpan("read.conan")),
+};
+//# sourceMappingURL=conan.js.map

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

@@ -0,0 +1,26 @@
+/**
+ * Conda 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";
+/**
+ * Conda package detector.
+ *
+ * Scans `environment.yml` and `meta.yaml` in the project directory
+ * for conda dependencies.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const condaDetector: PackageDetector;
+/**
+ * Conda package reader.
+ *
+ * Reads `$CONDA_PREFIX/share/axm/<package>/axm.json` as primary source,
+ * falling back to package cache `info/about.json` with `extra.axm` key.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const condaReader: PackageReader;
+//# sourceMappingURL=conda.d.ts.map

package/dist/src/packaging/conda.js

@@ -0,0 +1,320 @@
+/**
+ * Conda package detector and reader for package-compatibility discovery.
+ *
+ * @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 * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import { PackageURL } from "packageurl-js";
+import { envOption } from "../internal/environment.js";
+import { PackageTypeSchema } from "@agentxm/extension-model/unstable/packaging/package-type";
+import { decodeAxmMeta, decodePurl, parseJsonOptional, readFileOptional } from "./reader-io.js";
+const condaType = Schema.decodeUnknownSync(PackageTypeSchema)("conda");
+const pypiType = Schema.decodeUnknownSync(PackageTypeSchema)("pypi");
+/**
+ * Parse a conda dependency string like "numpy=1.24.0=py311h..." or "numpy >=1.24".
+ *
+ * Returns name, version (exact only), and optional channel.
+ */
+const parseCondaDep = (dep) => {
+    const trimmed = dep.trim();
+    if (trimmed.length === 0)
+        return undefined;
+    // Check for channel prefix: conda-forge::numpy=1.24.0
+    let channel;
+    let rest;
+    const channelIdx = trimmed.indexOf("::");
+    if (channelIdx > 0) {
+        channel = trimmed.slice(0, channelIdx);
+        rest = trimmed.slice(channelIdx + 2);
+    }
+    else {
+        channel = undefined;
+        rest = trimmed;
+    }
+    // Check for range operators - produce versionless purl
+    if (rest.includes(">=") ||
+        rest.includes("<=") ||
+        rest.includes(">") ||
+        rest.includes("<") ||
+        rest.includes("!=")) {
+        // Extract just the name
+        const name = rest.split(/[><=!]/)[0]?.trim();
+        if (name === undefined || name.length === 0)
+            return undefined;
+        return { name, version: undefined, channel };
+    }
+    // Parse name=version=build or name=version or name
+    const parts = rest.split("=");
+    const name = parts[0]?.trim();
+    if (name === undefined || name.length === 0)
+        return undefined;
+    const version = parts[1]?.trim();
+    if (version === undefined || version.length === 0) {
+        return { name, version: undefined, channel };
+    }
+    return { name, version, channel };
+};
+/**
+ * Parse a pip dependency string like "requests==2.31.0" or "flask>=2.0".
+ *
+ * Returns name and version (exact == only).
+ */
+const parsePipDep = (dep) => {
+    const trimmed = dep.trim();
+    if (trimmed.length === 0)
+        return undefined;
+    // Check for exact version pin: ==
+    const eqIdx = trimmed.indexOf("==");
+    if (eqIdx > 0) {
+        const name = trimmed.slice(0, eqIdx).trim();
+        const version = trimmed.slice(eqIdx + 2).trim();
+        if (name.length === 0)
+            return undefined;
+        // Normalize Python package name: lowercase, replace _ and . with -
+        const normalizedName = name.toLowerCase().replace(/[_.]/g, "-");
+        return { name: normalizedName, version: version.length > 0 ? version : undefined };
+    }
+    // Range specifiers: >=, <=, !=, ~=, >, <
+    const rangeMatch = /^([a-zA-Z0-9._-]+)/.exec(trimmed);
+    if (rangeMatch !== null && rangeMatch[1] !== undefined) {
+        const normalizedName = rangeMatch[1].toLowerCase().replace(/[_.]/g, "-");
+        return { name: normalizedName, version: undefined };
+    }
+    return undefined;
+};
+/**
+ * Parse environment.yml content using line-based parsing.
+ * Extracts conda dependencies and pip sub-list items.
+ */
+const parseEnvironmentYml = (content, source) => {
+    const lines = content.split("\n");
+    const results = [];
+    let inDependencies = false;
+    let inPipSection = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("#"))
+            continue;
+        const indent = line.length - line.trimStart().length;
+        // Top-level section detection
+        if (indent === 0 && trimmed.length > 0) {
+            if (trimmed === "dependencies:") {
+                inDependencies = true;
+                inPipSection = false;
+                continue;
+            }
+            if (trimmed.endsWith(":") || trimmed.includes(":")) {
+                inDependencies = false;
+                inPipSection = false;
+                continue;
+            }
+        }
+        if (!inDependencies)
+            continue;
+        if (trimmed.length === 0)
+            continue;
+        // Detect pip: sub-section
+        if (trimmed === "- pip:" || trimmed === "pip:") {
+            inPipSection = true;
+            continue;
+        }
+        // pip sub-list items are more deeply indented
+        if (inPipSection) {
+            if (trimmed.startsWith("- ")) {
+                const dep = trimmed.slice(2).trim();
+                const parsed = parsePipDep(dep);
+                if (parsed !== undefined) {
+                    const purl = new PackageURL("pypi", null, parsed.name, parsed.version ?? null, null, null);
+                    const purlParts = decodePurl(purl.toString());
+                    results.push({ purl: purlParts, type: pypiType, source });
+                }
+                continue;
+            }
+            // Non-list item after pip section means pip section ended
+            if (!trimmed.startsWith("-")) {
+                inPipSection = false;
+            }
+        }
+        // Regular conda dependency
+        if (!inPipSection && trimmed.startsWith("- ")) {
+            const dep = trimmed.slice(2).trim();
+            // Skip if it's a map item (pip: or other structured entries)
+            if (dep.endsWith(":") || dep.includes(": "))
+                continue;
+            const parsed = parseCondaDep(dep);
+            if (parsed !== undefined) {
+                const qualifiers = parsed.channel !== undefined ? { channel: parsed.channel } : null;
+                const purl = new PackageURL("conda", null, parsed.name, parsed.version ?? null, qualifiers, null);
+                const purlParts = decodePurl(purl.toString());
+                results.push({ purl: purlParts, type: condaType, source });
+            }
+        }
+    }
+    return results;
+};
+/**
+ * Parse meta.yaml content using line-based parsing.
+ * Extracts dependencies from `requirements.host` and `requirements.run` lists.
+ */
+const parseMetaYaml = (content, source) => {
+    const lines = content.split("\n");
+    const results = [];
+    let inRequirements = false;
+    let inSubSection = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("#"))
+            continue;
+        const indent = line.length - line.trimStart().length;
+        // Top-level section detection
+        if (indent === 0 && trimmed.length > 0) {
+            if (trimmed === "requirements:") {
+                inRequirements = true;
+                inSubSection = false;
+                continue;
+            }
+            if (trimmed.endsWith(":") || trimmed.includes(":")) {
+                inRequirements = false;
+                inSubSection = false;
+                continue;
+            }
+        }
+        if (!inRequirements)
+            continue;
+        if (trimmed.length === 0)
+            continue;
+        // Detect host: or run: sub-sections
+        if ((trimmed === "host:" || trimmed === "run:") && indent > 0) {
+            inSubSection = true;
+            continue;
+        }
+        // Other sub-sections like build:
+        if (trimmed.endsWith(":") && indent > 0 && !trimmed.startsWith("-")) {
+            if (trimmed === "build:") {
+                inSubSection = false;
+                continue;
+            }
+            inSubSection = true;
+            continue;
+        }
+        // List items in host: or run: sections
+        if (inSubSection && trimmed.startsWith("- ")) {
+            const dep = trimmed.slice(2).trim();
+            const parsed = parseCondaDep(dep);
+            if (parsed !== undefined) {
+                const purl = new PackageURL("conda", null, parsed.name, parsed.version ?? null, null, null);
+                const purlParts = decodePurl(purl.toString());
+                results.push({ purl: purlParts, type: condaType, source });
+            }
+        }
+    }
+    return results;
+};
+/**
+ * Conda package detector.
+ *
+ * Scans `environment.yml` and `meta.yaml` in the project directory
+ * for conda dependencies.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const condaDetector = {
+    type: condaType,
+    detect: Effect.fn("detect.conda")(function* (projectDir) {
+        const path = yield* Path.Path;
+        const results = [];
+        // Parse environment.yml
+        const envYmlPath = path.join(projectDir, "environment.yml");
+        const envYmlContent = yield* readFileOptional(envYmlPath);
+        if (Option.isSome(envYmlContent)) {
+            const deps = parseEnvironmentYml(envYmlContent.value, envYmlPath);
+            results.push(...deps);
+        }
+        // Parse meta.yaml
+        const metaYamlPath = path.join(projectDir, "meta.yaml");
+        const metaYamlContent = yield* readFileOptional(metaYamlPath);
+        if (Option.isSome(metaYamlContent)) {
+            const deps = parseMetaYaml(metaYamlContent.value, metaYamlPath);
+            results.push(...deps);
+        }
+        return results;
+    }, Effect.annotateLogs({ detector: "conda" }), Effect.withSpan("detect.conda")),
+};
+/**
+ * Schema to extract the optional extra.axm field from about.json.
+ */
+const AboutJsonSchema = Schema.Struct({
+    extra: Schema.optional(Schema.Struct({
+        axm: Schema.optional(Schema.Unknown),
+    })),
+});
+const decodeAboutJson = Schema.decodeUnknownResult(AboutJsonSchema);
+/**
+ * Conda package reader.
+ *
+ * Reads `$CONDA_PREFIX/share/axm/<package>/axm.json` as primary source,
+ * falling back to package cache `info/about.json` with `extra.axm` key.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const condaReader = {
+    type: condaType,
+    read: Effect.fn("read.conda")(function* (pkg) {
+        const path = yield* Path.Path;
+        const condaPrefix = yield* envOption("CONDA_PREFIX");
+        if (Option.isNone(condaPrefix))
+            return Option.none();
+        const pkgName = pkg.purl.name;
+        // Primary: $CONDA_PREFIX/share/axm/<package>/axm.json
+        const axmJsonPath = path.join(condaPrefix.value, "share", "axm", pkgName, "axm.json");
+        const primaryContent = yield* readFileOptional(axmJsonPath);
+        if (Option.isSome(primaryContent)) {
+            const parsed = yield* parseJsonOptional(primaryContent.value, `conda share/axm/${pkgName}/axm.json`);
+            if (Option.isSome(parsed)) {
+                const metaResult = decodeAxmMeta(parsed.value);
+                if (Result.isFailure(metaResult)) {
+                    yield* Effect.logWarning(`Invalid axm metadata in conda ${pkgName}: schema validation failed`);
+                    return Option.none();
+                }
+                return Option.some(metaResult.success.extensions);
+            }
+        }
+        // Fallback: $CONDA_PREFIX/pkgs/<package>*/info/about.json
+        const fs = yield* FileSystem.FileSystem;
+        const pkgsDir = path.join(condaPrefix.value, "pkgs");
+        const pkgsDirEntries = yield* fs.readDirectory(pkgsDir).pipe(Effect.option);
+        if (Option.isSome(pkgsDirEntries)) {
+            // Find the first matching package directory
+            const matchingDir = pkgsDirEntries.value.find((entry) => entry.startsWith(`${pkgName}-`));
+            if (matchingDir !== undefined) {
+                const aboutJsonPath = path.join(pkgsDir, matchingDir, "info", "about.json");
+                const aboutContent = yield* readFileOptional(aboutJsonPath);
+                if (Option.isSome(aboutContent)) {
+                    const parsed = yield* parseJsonOptional(aboutContent.value, `conda ${matchingDir}/info/about.json`);
+                    if (Option.isSome(parsed)) {
+                        const aboutResult = decodeAboutJson(parsed.value);
+                        if (Result.isSuccess(aboutResult)) {
+                            const axmRaw = aboutResult.success.extra?.axm;
+                            if (axmRaw !== undefined) {
+                                const metaResult = decodeAxmMeta(axmRaw);
+                                if (Result.isFailure(metaResult)) {
+                                    yield* Effect.logWarning(`Invalid axm metadata in conda cache ${pkgName}: schema validation failed`);
+                                    return Option.none();
+                                }
+                                return Option.some(metaResult.success.extensions);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return Option.none();
+    }, Effect.annotateLogs({ reader: "conda" }), Effect.withSpan("read.conda")),
+};
+//# sourceMappingURL=conda.js.map

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

@@ -0,0 +1,29 @@
+/**
+ * CPAN (Perl) package detector and reader for package-compatibility discovery.
+ *
+ * Parses `cpanfile` (`requires 'Name'` lines) and `Makefile.PL` (`PREREQ_PM`).
+ * Reads `x_axm` from `<lib-path>/.meta/<dist>/MYMETA.json`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { PackageDetector, PackageReader } from "./types.js";
+/**
+ * CPAN package detector.
+ *
+ * Scans `cpanfile` and `Makefile.PL` in the project directory and extracts
+ * dependencies.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const cpanDetector: PackageDetector;
+/**
+ * CPAN package reader.
+ *
+ * Reads `x_axm` from `<lib-path>/.meta/<dist>/MYMETA.json` for each
+ * detected CPAN package and extracts recommendation metadata.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const cpanReader: PackageReader;
+//# sourceMappingURL=cpan.d.ts.map