@agentxm/extension-discovery 0.28.4-bootstrap.0

package/dist/src/packaging/cargo.js

@@ -0,0 +1,270 @@
+/**
+ * Cargo (Rust) 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 { envWithDefault } from "../internal/environment.js";
+import { PackageTypeSchema } from "@agentxm/extension-model/unstable/packaging/package-type";
+import { decodeAxmMeta, decodePurl, readFileOptional } from "./reader-io.js";
+const cargoType = Schema.decodeUnknownSync(PackageTypeSchema)("cargo");
+/**
+ * Returns true if the version specifier is an exact pin (starts with `=`).
+ * In Cargo, `=1.0.193` means exact; bare `1.0` is a caret range.
+ */
+const isExactVersion = (specifier) => specifier.startsWith("=");
+/**
+ * Strip leading `=` from an exact version pin.
+ */
+const stripExactPrefix = (specifier) => specifier.startsWith("=") ? specifier.slice(1) : specifier;
+/** Regex to detect section headers like [dependencies] or [build-dependencies]. */
+const SECTION_RE = /^\[([^\]]+)\]/;
+/** Dependency section names we care about. */
+const DEP_SECTIONS = new Set(["dependencies", "dev-dependencies", "build-dependencies"]);
+/**
+ * Parse a dependency value (the right-hand side of `name = ...`).
+ * Handles:
+ * - Shorthand string: `"1.0"` or `"=1.0.193"`
+ * - Inline table: `{ version = "1.0", features = ["derive"] }`
+ */
+const parseDependencyValue = (name, value) => {
+    const trimmed = value.trim();
+    // Shorthand string syntax: name = "1.0"
+    if (trimmed.startsWith('"') || trimmed.startsWith("'")) {
+        const inner = trimmed.slice(1, -1);
+        return { name, version: inner, isPathOrGit: false, packageName: undefined };
+    }
+    // Inline table syntax: name = { version = "1.0", ... }
+    if (trimmed.startsWith("{")) {
+        const hasPath = /\bpath\s*=/.test(trimmed);
+        const hasGit = /\bgit\s*=/.test(trimmed);
+        if (hasPath || hasGit) {
+            return { name, version: undefined, isPathOrGit: true, packageName: undefined };
+        }
+        // Extract version
+        const versionMatch = /\bversion\s*=\s*"([^"]*)"/.exec(trimmed);
+        const version = versionMatch?.[1];
+        // Extract package rename
+        const packageMatch = /\bpackage\s*=\s*"([^"]*)"/.exec(trimmed);
+        const packageName = packageMatch?.[1];
+        return { name, version, isPathOrGit: false, packageName };
+    }
+    // Unknown format, skip
+    return { name, version: undefined, isPathOrGit: false, packageName: undefined };
+};
+/**
+ * Parse Cargo.toml content and extract dependencies.
+ */
+const parseCargoToml = (content, source) => {
+    const lines = content.split("\n");
+    const results = [];
+    let currentSection = "";
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Skip empty lines and comments
+        if (trimmed === "" || trimmed.startsWith("#"))
+            continue;
+        // Check for section header
+        const sectionMatch = SECTION_RE.exec(trimmed);
+        if (sectionMatch !== undefined && sectionMatch !== null && sectionMatch[1] !== undefined) {
+            currentSection = sectionMatch[1];
+            continue;
+        }
+        // Only process lines in dependency sections
+        if (!DEP_SECTIONS.has(currentSection))
+            continue;
+        // Parse key = value
+        const eqIdx = trimmed.indexOf("=");
+        if (eqIdx === -1)
+            continue;
+        const depName = trimmed.slice(0, eqIdx).trim();
+        const depValue = trimmed.slice(eqIdx + 1).trim();
+        if (depName === "" || depValue === "")
+            continue;
+        const dep = parseDependencyValue(depName, depValue);
+        // Skip path and git dependencies
+        if (dep.isPathOrGit)
+            continue;
+        // Use the real package name if renamed
+        const resolvedName = dep.packageName ?? dep.name;
+        // Determine version: only exact pins get a version in the purl
+        const version = dep.version !== undefined && isExactVersion(dep.version)
+            ? stripExactPrefix(dep.version)
+            : undefined;
+        const purl = new PackageURL("cargo", null, resolvedName, version ?? null, null, null);
+        const purlParts = decodePurl(purl.toString());
+        results.push({ purl: purlParts, type: cargoType, source });
+    }
+    return results;
+};
+/**
+ * Cargo package detector.
+ *
+ * Scans `Cargo.toml` in the project directory and extracts dependencies
+ * from `[dependencies]`, `[dev-dependencies]`, and `[build-dependencies]`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const cargoDetector = {
+    type: cargoType,
+    detect: Effect.fn("detect.cargo")(function* (projectDir) {
+        const path = yield* Path.Path;
+        const cargoTomlPath = path.join(projectDir, "Cargo.toml");
+        const content = yield* readFileOptional(cargoTomlPath);
+        if (Option.isNone(content))
+            return [];
+        // Validate that it looks like TOML (basic check)
+        const trimmed = content.value.trim();
+        if (trimmed.length > 0 && !trimmed.includes("=") && !trimmed.includes("[")) {
+            yield* Effect.logWarning("Malformed Cargo.toml, skipping");
+            return [];
+        }
+        return parseCargoToml(content.value, cargoTomlPath);
+    }, Effect.annotateLogs({ detector: "cargo" }), Effect.withSpan("detect.cargo")),
+};
+/**
+ * Resolve the CARGO_HOME, defaulting to ~/.cargo when not set.
+ */
+const resolveCargoHome = () => envWithDefault("CARGO_HOME", `${os.homedir()}/.cargo`);
+/**
+ * Parse the `[package.metadata.axm]` table from a Cargo.toml string.
+ *
+ * Returns `undefined` when the section is absent. `Cargo.toml` is TOML; we
+ * scan section headers line-by-line rather than depending on a full TOML
+ * parser, mirroring `julia.ts`/`parseAxmSection`. Supported forms:
+ *
+ *   [package.metadata.axm]
+ *   extensions = [{ ref = "@owner/packs/example", versionRange = "^1.0.0" }]
+ *
+ *   [[package.metadata.axm.extensions]]
+ *   ref = "@owner/packs/example"
+ *   versionRange = "^1.0.0"
+ */
+const parsePackageMetadataAxm = (content) => {
+    const lines = content.split("\n");
+    let inAxmSection = false;
+    let found = false;
+    const fields = {};
+    const extensionEntries = [];
+    let currentTable;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Skip empty lines and comments
+        if (trimmed === "" || trimmed.startsWith("#"))
+            continue;
+        // Section headers (`[section.path]` or `[[array.of.tables]]`)
+        if (trimmed.startsWith("[")) {
+            const arrayTableMatch = /^\[\[package\.metadata\.axm\.([A-Za-z0-9_-]+)\]\]$/.exec(trimmed);
+            const arrayTableKey = arrayTableMatch?.[1];
+            if (arrayTableKey !== undefined) {
+                found = true;
+                inAxmSection = false;
+                if (arrayTableKey === "extensions") {
+                    const entry = {};
+                    extensionEntries.push(entry);
+                    fields["extensions"] = extensionEntries;
+                    currentTable = entry;
+                }
+                else {
+                    currentTable = undefined;
+                }
+                continue;
+            }
+            const axmTableMatch = /^\[package\.metadata\.axm(?:\.([A-Za-z0-9_-]+))?\]$/.exec(trimmed);
+            if (axmTableMatch !== null) {
+                found = true;
+                inAxmSection = axmTableMatch[1] === undefined;
+                currentTable = undefined;
+                continue;
+            }
+            inAxmSection = false;
+            currentTable = undefined;
+            continue;
+        }
+        const target = currentTable ?? (inAxmSection ? fields : undefined);
+        if (target === undefined)
+            continue;
+        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;
+        target[key] = parseTomlValue(rawValue);
+    }
+    return found ? fields : undefined;
+};
+/**
+ * Cargo package reader.
+ *
+ * Reads `[package.metadata.axm]` from
+ * `$CARGO_HOME/registry/src/<index>/<crate>-<version>/Cargo.toml` for each
+ * detected cargo crate. `[package.metadata.*]` is Cargo's standard
+ * extensibility mechanism for third-party tools (used by docs.rs, cargo-deb,
+ * cargo-bundle, etc.).
+ *
+ * When the crate version is unknown, scans the registry source directory
+ * for any matching crate directory.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const cargoReader = {
+    type: cargoType,
+    read: Effect.fn("read.cargo")(function* (pkg) {
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+        const cargoHome = yield* resolveCargoHome();
+        const crateName = pkg.purl.name;
+        const version = pkg.purl.version;
+        const registrySrcDir = path.join(cargoHome, "registry", "src");
+        const indexDirs = yield* fs.readDirectory(registrySrcDir).pipe(Effect.option);
+        if (Option.isNone(indexDirs))
+            return Option.none();
+        for (const indexDir of indexDirs.value) {
+            const indexPath = path.join(registrySrcDir, indexDir);
+            const crateDir = version !== undefined
+                ? `${crateName}-${version}`
+                : yield* findMatchingCrateDir(fs, indexPath, crateName);
+            if (crateDir === undefined)
+                continue;
+            const cargoTomlPath = path.join(indexPath, crateDir, "Cargo.toml");
+            const content = yield* readFileOptional(cargoTomlPath);
+            if (Option.isNone(content)) {
+                if (version !== undefined)
+                    return Option.none();
+                continue;
+            }
+            const axmFields = parsePackageMetadataAxm(content.value);
+            if (axmFields === undefined) {
+                if (version !== undefined)
+                    return Option.none();
+                continue;
+            }
+            const metaResult = decodeAxmMeta(axmFields);
+            if (Result.isFailure(metaResult)) {
+                yield* Effect.logWarning(`Invalid axm metadata in ${crateDir}/Cargo.toml: schema validation failed`);
+                return Option.none();
+            }
+            return Option.some(metaResult.success.extensions);
+        }
+        return Option.none();
+    }, Effect.annotateLogs({ reader: "cargo" }), Effect.withSpan("read.cargo")),
+};
+const findMatchingCrateDir = (fs, indexPath, crateName) => Effect.gen(function* () {
+    const entries = yield* fs.readDirectory(indexPath).pipe(Effect.option);
+    if (Option.isNone(entries))
+        return undefined;
+    return entries.value.find((entry) => entry === crateName || entry.startsWith(`${crateName}-`));
+});
+//# sourceMappingURL=cargo.js.map

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

@@ -0,0 +1,26 @@
+/**
+ * CocoaPods 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";
+/**
+ * CocoaPods package detector.
+ *
+ * Scans `Podfile` and `*.podspec` files in the project directory
+ * for pod dependencies.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const cocoapodsDetector: PackageDetector;
+/**
+ * CocoaPods package reader.
+ *
+ * Reads `Pods/<pod-name>/axm.json` for each detected pod
+ * and extracts recommendation metadata.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const cocoapodsReader: PackageReader;
+//# sourceMappingURL=cocoapods.d.ts.map

package/dist/src/packaging/cocoapods.js

@@ -0,0 +1,187 @@
+/**
+ * CocoaPods 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 { PackageTypeSchema } from "@agentxm/extension-model/unstable/packaging/package-type";
+import { decodeAxmMeta, decodePurl, parseJsonOptional, readFileOptional } from "./reader-io.js";
+const cocoapodsType = Schema.decodeUnknownSync(PackageTypeSchema)("cocoapods");
+/**
+ * Returns true if the specifier is an exact semver version (no range operators).
+ */
+const isExactVersion = (specifier) => /^\d+\.\d+\.\d+(?:[-+][a-zA-Z0-9._+-]*)?$/.test(specifier);
+/**
+ * Convert a pod name (possibly with subspec) and version to a DetectedPackage.
+ */
+const podToPurl = (podFullName, version, source) => {
+    // Split on '/' to separate name from subspecs
+    const parts = podFullName.split("/");
+    const name = parts[0];
+    if (name === undefined || name.length === 0)
+        return undefined;
+    const subpath = parts.length > 1 ? parts.slice(1).join("/") : null;
+    const resolvedVersion = version !== undefined && isExactVersion(version) ? version : undefined;
+    const purl = new PackageURL("cocoapods", null, name, resolvedVersion ?? null, null, subpath);
+    const purlParts = decodePurl(purl.toString());
+    return { purl: purlParts, type: cocoapodsType, source };
+};
+/**
+ * Parse a Podfile and extract pod directives.
+ *
+ * Matches lines like:
+ * - pod 'Alamofire', '~> 5.0'
+ * - pod 'Alamofire', '5.6.2'
+ * - pod 'Alamofire'
+ * - pod 'ShareKit/Twitter'
+ * - pod 'MyPod', :path => '../MyPod'  (skipped)
+ * - pod 'MyPod', :git => 'https://...'  (skipped)
+ */
+const parsePodfile = (content, source) => {
+    const lines = content.split("\n");
+    const results = [];
+    // Match: pod 'Name' or pod "Name" with optional version and options
+    const podPattern = /^\s*pod\s+['"]([^'"]+)['"]\s*(?:,\s*(.*))?$/;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("#"))
+            continue;
+        const match = podPattern.exec(trimmed);
+        if (match === null)
+            continue;
+        const podName = match[1];
+        const rest = match[2];
+        if (podName === undefined)
+            continue;
+        // Skip :path and :git dependencies
+        if (rest !== undefined) {
+            if (rest.includes(":path") || rest.includes(":git"))
+                continue;
+        }
+        // Extract version from rest
+        let version;
+        if (rest !== undefined) {
+            // Match version string: '5.6.2' or '~> 5.0' or '>= 5.0'
+            const versionMatch = /^['"]([^'"]+)['"]/.exec(rest.trim());
+            if (versionMatch !== null && versionMatch[1] !== undefined) {
+                const versionStr = versionMatch[1];
+                // Only use exact versions, not ranges
+                if (isExactVersion(versionStr)) {
+                    version = versionStr;
+                }
+            }
+        }
+        const detected = podToPurl(podName, version, source);
+        if (detected !== undefined)
+            results.push(detected);
+    }
+    return results;
+};
+/**
+ * Parse a .podspec file and extract dependency directives.
+ *
+ * Matches lines like:
+ * - s.dependency 'Alamofire', '~> 5.0'
+ * - spec.dependency 'SwiftyJSON'
+ * - ss.dependency 'Something'
+ */
+const parsePodspec = (content, source) => {
+    const lines = content.split("\n");
+    const results = [];
+    // Match: <var>.dependency 'Name', 'version' or <var>.dependency 'Name'
+    const depPattern = /^\s*\w+\.dependency\s+['"]([^'"]+)['"]\s*(?:,\s*['"]([^'"]+)['"])?/;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("#"))
+            continue;
+        const match = depPattern.exec(trimmed);
+        if (match === null)
+            continue;
+        const depName = match[1];
+        const versionStr = match[2];
+        if (depName === undefined)
+            continue;
+        const version = versionStr !== undefined && isExactVersion(versionStr) ? versionStr : undefined;
+        const detected = podToPurl(depName, version, source);
+        if (detected !== undefined)
+            results.push(detected);
+    }
+    return results;
+};
+/**
+ * CocoaPods package detector.
+ *
+ * Scans `Podfile` and `*.podspec` files in the project directory
+ * for pod dependencies.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const cocoapodsDetector = {
+    type: cocoapodsType,
+    detect: Effect.fn("detect.cocoapods")(function* (projectDir) {
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+        const results = [];
+        // Parse Podfile
+        const podfilePath = path.join(projectDir, "Podfile");
+        const podfileContent = yield* readFileOptional(podfilePath);
+        if (Option.isSome(podfileContent)) {
+            const deps = parsePodfile(podfileContent.value, podfilePath);
+            results.push(...deps);
+        }
+        // Parse *.podspec files
+        const dirEntries = yield* fs.readDirectory(projectDir).pipe(Effect.option);
+        if (Option.isSome(dirEntries)) {
+            const podspecFiles = dirEntries.value.filter((f) => f.endsWith(".podspec"));
+            for (const podspecFile of podspecFiles) {
+                const podspecPath = path.join(projectDir, podspecFile);
+                const podspecContent = yield* readFileOptional(podspecPath);
+                if (Option.isSome(podspecContent)) {
+                    const deps = parsePodspec(podspecContent.value, podspecPath);
+                    results.push(...deps);
+                }
+            }
+        }
+        return results;
+    }, Effect.annotateLogs({ detector: "cocoapods" }), Effect.withSpan("detect.cocoapods")),
+};
+/**
+ * CocoaPods package reader.
+ *
+ * Reads `Pods/<pod-name>/axm.json` for each detected pod
+ * and extracts recommendation metadata.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const cocoapodsReader = {
+    type: cocoapodsType,
+    read: Effect.fn("read.cocoapods")(function* (pkg) {
+        const path = yield* Path.Path;
+        // Derive project directory from the source manifest path
+        const projectDir = path.dirname(pkg.source);
+        // Pod name from purl
+        const podName = pkg.purl.name;
+        const axmJsonPath = path.join(projectDir, "Pods", podName, "axm.json");
+        const content = yield* readFileOptional(axmJsonPath);
+        if (Option.isNone(content))
+            return Option.none();
+        const parsed = yield* parseJsonOptional(content.value, `${podName}/axm.json`);
+        if (Option.isNone(parsed))
+            return Option.none();
+        // Validate axm metadata structure
+        const metaResult = decodeAxmMeta(parsed.value);
+        if (Result.isFailure(metaResult)) {
+            yield* Effect.logWarning(`Invalid axm metadata in ${podName}: schema validation failed`);
+            return Option.none();
+        }
+        return Option.some(metaResult.success.extensions);
+    }, Effect.annotateLogs({ reader: "cocoapods" }), Effect.withSpan("read.cocoapods")),
+};
+//# sourceMappingURL=cocoapods.js.map

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

@@ -0,0 +1,26 @@
+/**
+ * Composer 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";
+/**
+ * Composer package detector.
+ *
+ * Scans `composer.json` in the project directory and extracts dependencies
+ * from `require` and `require-dev`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const composerDetector: PackageDetector;
+/**
+ * Composer package reader.
+ *
+ * Reads `vendor/<namespace>/<name>/composer.json` for each detected Composer
+ * package and extracts the `"extra"."axm"` field containing recommendation metadata.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const composerReader: PackageReader;
+//# sourceMappingURL=composer.d.ts.map

package/dist/src/packaging/composer.js

@@ -0,0 +1,144 @@
+/**
+ * Composer 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 Option from "effect/Option";
+import * as Path from "effect/Path";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import { makeDetectedPackage } from "./detected-package.js";
+import { PackageTypeSchema } from "@agentxm/extension-model/unstable/packaging/package-type";
+import { decodeAxmMeta, parseJsonOptional, readFileOptional } from "./reader-io.js";
+const composerType = Schema.decodeUnknownSync(PackageTypeSchema)("composer");
+/** Schema to extract the optional "extra" field from a composer.json object. */
+const ExtraContainerSchema = Schema.Struct({
+    extra: Schema.optional(Schema.Struct({
+        axm: Schema.optional(Schema.Unknown),
+    })),
+});
+const decodeExtraContainer = Schema.decodeUnknownResult(ExtraContainerSchema);
+/**
+ * Returns true if the specifier is an exact semver version (no range operators).
+ * Exact versions match: digits and dots only, e.g. "7.5.0", "1.0.0-beta.1".
+ */
+const isExactVersion = (specifier) => /^\d+\.\d+\.\d+(?:[-+][a-zA-Z0-9._+-]*)?$/.test(specifier);
+/** Returns true if the dependency key is a platform requirement. */
+const isPlatformRequirement = (name) => name === "php" || name.startsWith("ext-");
+/**
+ * Convert a single composer dependency entry to a DetectedPackage, or undefined if skipped.
+ */
+const depToPurl = (depName, specifier, source) => {
+    if (isPlatformRequirement(depName))
+        return undefined;
+    // Composer packages must be vendor/name format
+    const slashIdx = depName.indexOf("/");
+    if (slashIdx <= 0)
+        return undefined;
+    const namespace = depName.slice(0, slashIdx).toLowerCase();
+    const name = depName.slice(slashIdx + 1).toLowerCase();
+    const version = isExactVersion(specifier) ? specifier : undefined;
+    return Option.getOrUndefined(makeDetectedPackage({
+        type: composerType,
+        namespace,
+        name,
+        ...(version === undefined ? {} : { version }),
+        source,
+    }));
+};
+/**
+ * Schema to loosely decode the dependency-relevant shape of composer.json.
+ */
+const DependencySectionsSchema = Schema.Struct({
+    require: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+    "require-dev": Schema.optional(Schema.Record(Schema.String, Schema.String)),
+});
+const decodeDependencySections = Schema.decodeUnknownResult(DependencySectionsSchema);
+/**
+ * Extract dependencies from a parsed composer.json value.
+ */
+const extractDeps = (manifest, source) => {
+    const decoded = decodeDependencySections(manifest);
+    if (Result.isFailure(decoded))
+        return [];
+    const sections = [decoded.success.require, decoded.success["require-dev"]];
+    const results = [];
+    for (const deps of sections) {
+        if (deps === undefined)
+            continue;
+        for (const [name, specifier] of Object.entries(deps)) {
+            const detected = depToPurl(name, specifier, source);
+            if (detected !== undefined)
+                results.push(detected);
+        }
+    }
+    return results;
+};
+/**
+ * Composer package detector.
+ *
+ * Scans `composer.json` in the project directory and extracts dependencies
+ * from `require` and `require-dev`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const composerDetector = {
+    type: composerType,
+    detect: Effect.fn("detect.composer")(function* (projectDir) {
+        const path = yield* Path.Path;
+        const manifestPath = path.join(projectDir, "composer.json");
+        const content = yield* readFileOptional(manifestPath);
+        if (Option.isNone(content))
+            return [];
+        const parsed = yield* parseJsonOptional(content.value, "composer.json");
+        if (Option.isNone(parsed))
+            return [];
+        return extractDeps(parsed.value, manifestPath);
+    }, Effect.annotateLogs({ detector: "composer" }), Effect.withSpan("detect.composer")),
+};
+/**
+ * Composer package reader.
+ *
+ * Reads `vendor/<namespace>/<name>/composer.json` for each detected Composer
+ * package and extracts the `"extra"."axm"` field containing recommendation metadata.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const composerReader = {
+    type: composerType,
+    read: Effect.fn("read.composer")(function* (pkg) {
+        const path = yield* Path.Path;
+        // Derive project directory from the source manifest path
+        const projectDir = path.dirname(pkg.source);
+        // Reconstruct the package path from purl parts
+        const pkgPath = pkg.purl.namespace ? `${pkg.purl.namespace}/${pkg.purl.name}` : pkg.purl.name;
+        const composerJsonPath = path.join(projectDir, "vendor", pkgPath, "composer.json");
+        const content = yield* readFileOptional(composerJsonPath);
+        if (Option.isNone(content))
+            return Option.none();
+        const parsed = yield* parseJsonOptional(content.value, pkgPath);
+        if (Option.isNone(parsed))
+            return Option.none();
+        // Extract and validate the "extra"."axm" field using schema
+        const extraContainerResult = decodeExtraContainer(parsed.value);
+        if (Result.isFailure(extraContainerResult)) {
+            return Option.none();
+        }
+        const extra = extraContainerResult.success.extra;
+        if (extra === undefined)
+            return Option.none();
+        const axmRaw = extra.axm;
+        if (axmRaw === undefined)
+            return Option.none();
+        // Validate axm metadata structure
+        const metaResult = decodeAxmMeta(axmRaw);
+        if (Result.isFailure(metaResult)) {
+            yield* Effect.logWarning(`Invalid axm metadata in ${pkgPath}: schema validation failed`);
+            return Option.none();
+        }
+        return Option.some(metaResult.success.extensions);
+    }, Effect.annotateLogs({ reader: "composer" }), Effect.withSpan("read.composer")),
+};
+//# sourceMappingURL=composer.js.map

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

@@ -0,0 +1,30 @@
+/**
+ * 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
+ */
+import type { PackageDetector, PackageReader } from "./types.js";
+/**
+ * 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 declare const conanDetector: PackageDetector;
+/**
+ * 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 declare const conanReader: PackageReader;
+//# sourceMappingURL=conan.d.ts.map