@agentxm/extension-discovery 0.28.4-bootstrap.0

package/dist/src/packaging/golang.js

@@ -0,0 +1,169 @@
+/**
+ * Go module 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 Option from "effect/Option";
+import * as Path from "effect/Path";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import { readEnv } from "../internal/environment.js";
+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 golangType = Schema.decodeUnknownSync(PackageTypeSchema)("golang");
+/** Regex matching a major-version path suffix like /v2, /v3, etc. */
+const MAJOR_VERSION_SUFFIX = /\/v\d+$/;
+/**
+ * Strip major version path suffix (/v2, /v3, etc.) from a Go module path.
+ */
+const stripMajorVersionSuffix = (modulePath) => modulePath.replace(MAJOR_VERSION_SUFFIX, "");
+/**
+ * Split a Go module path into purl namespace and name.
+ * The namespace is the path prefix (lowercased), and the name is the last segment.
+ */
+const parseModulePath = (rawModulePath) => {
+    const modulePath = stripMajorVersionSuffix(rawModulePath);
+    const lastSlash = modulePath.lastIndexOf("/");
+    if (lastSlash === -1) {
+        return { namespace: "", name: modulePath.toLowerCase() };
+    }
+    return {
+        namespace: modulePath.slice(0, lastSlash).toLowerCase(),
+        name: modulePath.slice(lastSlash + 1).toLowerCase(),
+    };
+};
+/**
+ * Parse a single require line into a DetectedPackage, or undefined if invalid/indirect.
+ * A require line has the form: module_path version [// indirect]
+ */
+const parseRequireLine = (line, source) => {
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("//"))
+        return undefined;
+    // Filter out indirect dependencies
+    if (trimmed.includes("// indirect"))
+        return undefined;
+    // Split into module path and version
+    const parts = trimmed.split(/\s+/);
+    if (parts.length < 2)
+        return undefined;
+    const modulePath = parts[0];
+    const version = parts[1];
+    if (modulePath === undefined || version === undefined)
+        return undefined;
+    const { namespace, name } = parseModulePath(modulePath);
+    return Option.getOrUndefined(makeDetectedPackage({
+        type: golangType,
+        ...(namespace === "" ? {} : { namespace }),
+        name,
+        version,
+        source,
+    }));
+};
+/**
+ * Parse go.mod content and extract direct dependencies.
+ */
+const parseGoMod = (content, source) => {
+    const lines = content.split("\n");
+    const results = [];
+    let inRequireBlock = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Single-line require: require module_path version
+        if (trimmed.startsWith("require ") && !trimmed.includes("(")) {
+            const rest = trimmed.slice("require ".length);
+            const detected = parseRequireLine(rest, source);
+            if (detected !== undefined)
+                results.push(detected);
+            continue;
+        }
+        // Start of require block
+        if (trimmed.startsWith("require (") || trimmed === "require (") {
+            inRequireBlock = true;
+            continue;
+        }
+        // End of require block
+        if (inRequireBlock && trimmed === ")") {
+            inRequireBlock = false;
+            continue;
+        }
+        // Line inside require block
+        if (inRequireBlock) {
+            const detected = parseRequireLine(trimmed, source);
+            if (detected !== undefined)
+                results.push(detected);
+        }
+    }
+    return results;
+};
+/**
+ * Resolve the GOPATH, defaulting to ~/go when not set.
+ */
+const resolveGopath = () => Effect.sync(() => readEnv("GOPATH") ?? `${os.homedir()}/go`);
+/**
+ * Go module package detector.
+ *
+ * Scans `go.mod` in the project directory and extracts direct dependencies
+ * from `require` directives, filtering out `// indirect` entries.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const golangDetector = {
+    type: golangType,
+    detect: Effect.fn("detect.golang")(function* (projectDir) {
+        const path = yield* Path.Path;
+        const goModPath = path.join(projectDir, "go.mod");
+        const content = yield* readFileOptional(goModPath);
+        if (Option.isNone(content))
+            return [];
+        const deps = parseGoMod(content.value, goModPath);
+        if (deps.length === 0 && content.value.trim().length > 0) {
+            // Content exists but no deps found - could be valid go.mod with no deps,
+            // or malformed. Only warn if it looks malformed (no module directive).
+            if (!content.value.includes("module ")) {
+                yield* Effect.logWarning("Malformed go.mod: missing module directive, skipping");
+            }
+        }
+        return deps;
+    }, Effect.annotateLogs({ detector: "golang" }), Effect.withSpan("detect.golang")),
+};
+/**
+ * Go module package reader.
+ *
+ * Reads `axm.json` from `$GOPATH/pkg/mod/<module>@<version>/` for each
+ * detected Go module and extracts recommendation metadata.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const golangReader = {
+    type: golangType,
+    read: Effect.fn("read.golang")(function* (pkg) {
+        const path = yield* Path.Path;
+        const gopath = yield* resolveGopath();
+        // Reconstruct the module path from purl parts
+        const modulePath = pkg.purl.namespace
+            ? `${pkg.purl.namespace}/${pkg.purl.name}`
+            : pkg.purl.name;
+        const version = pkg.purl.version ?? "v0.0.0";
+        const axmJsonPath = path.join(gopath, "pkg", "mod", `${modulePath}@${version}`, "axm.json");
+        const content = yield* readFileOptional(axmJsonPath);
+        if (Option.isNone(content))
+            return Option.none();
+        const parsed = yield* parseJsonOptional(content.value, `${modulePath}@${version}/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 ${modulePath}@${version}: schema validation failed`);
+            return Option.none();
+        }
+        return Option.some(metaResult.success.extensions);
+    }, Effect.annotateLogs({ reader: "golang" }), Effect.withSpan("read.golang")),
+};
+//# sourceMappingURL=golang.js.map

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

@@ -0,0 +1,26 @@
+/**
+ * Hackage (Haskell) 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";
+/**
+ * Hackage package detector.
+ *
+ * Scans `*.cabal` files for `build-depends` fields and `stack.yaml` for
+ * `extra-deps` entries. Dependencies are deduplicated by name.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const hackageDetector: PackageDetector;
+/**
+ * Hackage package reader.
+ *
+ * Reads `x-axm` prefixed custom fields from `.cabal` files in
+ * `~/.cabal/store/ghc-<version>/<pkg>-<version>/` or `dist-newstyle/`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const hackageReader: PackageReader;
+//# sourceMappingURL=hackage.d.ts.map

package/dist/src/packaging/hackage.js

@@ -0,0 +1,305 @@
+/**
+ * Hackage (Haskell) 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, readFileOptional } from "./reader-io.js";
+const hackageType = Schema.decodeUnknownSync(PackageTypeSchema)("hackage");
+/**
+ * Parse a cabal build-depends line into individual dependency entries.
+ * build-depends can span multiple lines with comma separation.
+ * Each entry is: package-name [version-constraint]
+ */
+const parseBuildDependsEntry = (entry) => {
+    const trimmed = entry.trim();
+    if (trimmed === "")
+        return undefined;
+    // Split on whitespace to get name and optional version constraint
+    const parts = trimmed.split(/\s+/);
+    const name = parts[0];
+    if (name === undefined || name === "")
+        return undefined;
+    // Check for exact version pin: ==version
+    const rest = parts.slice(1).join(" ").trim();
+    const exactMatch = /^==\s*(\S+)$/.exec(rest);
+    if (exactMatch?.[1]) {
+        return { name, version: exactMatch[1] };
+    }
+    // Any other constraint or no constraint => versionless
+    return { name };
+};
+/**
+ * Parse all build-depends fields from a cabal file.
+ * Extracts dependencies from all sections (library, executable, etc.)
+ * and all conditional branches.
+ */
+const parseCabalBuildDepends = (content, source) => {
+    const results = [];
+    const seen = new Set();
+    // Match all build-depends fields, handling multi-line values.
+    // build-depends: entries are comma-separated and may span multiple lines
+    // (continuation lines are indented further than the field name).
+    const buildDependsRegex = /build-depends\s*:\s*([^\n]*(?:\n[ \t]+[^\n]*)*)/gi;
+    let match;
+    while ((match = buildDependsRegex.exec(content)) !== null) {
+        const depsBlock = match[1];
+        if (depsBlock === undefined)
+            continue;
+        // Split on commas, handling multi-line
+        const entries = depsBlock.split(",");
+        for (const entry of entries) {
+            const parsed = parseBuildDependsEntry(entry);
+            if (parsed === undefined)
+                continue;
+            if (seen.has(parsed.name))
+                continue;
+            seen.add(parsed.name);
+            const purl = new PackageURL("hackage", null, parsed.name, parsed.version ?? null, null, null);
+            const purlParts = decodePurl(purl.toString());
+            results.push({ purl: purlParts, type: hackageType, source });
+        }
+    }
+    return results;
+};
+/**
+ * Parse stack.yaml extra-deps entries.
+ * extra-deps entries have the format: package-version (e.g. aeson-2.1.0.0)
+ * The last hyphen-separated segment that starts with a digit is the version.
+ */
+const parseExtraDep = (entry) => {
+    const trimmed = entry.trim().replace(/^-\s*/, "");
+    if (trimmed === "" || trimmed.startsWith("#"))
+        return undefined;
+    // Skip entries that look like git references or URLs
+    if (trimmed.includes("/") || trimmed.includes(":"))
+        return undefined;
+    // Find the last hyphen that separates name from version
+    // Version starts with a digit
+    const lastHyphen = trimmed.lastIndexOf("-");
+    if (lastHyphen === -1)
+        return undefined;
+    const possibleVersion = trimmed.slice(lastHyphen + 1);
+    if (!/^\d/.test(possibleVersion))
+        return undefined;
+    const name = trimmed.slice(0, lastHyphen);
+    if (name === "")
+        return undefined;
+    return { name, version: possibleVersion };
+};
+/**
+ * Parse stack.yaml content for extra-deps.
+ */
+const parseStackYaml = (content, source) => {
+    const results = [];
+    const seen = new Set();
+    const lines = content.split("\n");
+    let inExtraDeps = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Start of extra-deps block (YAML list)
+        if (trimmed.startsWith("extra-deps:")) {
+            inExtraDeps = true;
+            // Check inline list format: extra-deps: [item1, item2]
+            const inlineMatch = /extra-deps:\s*\[([^\]]*)\]/.exec(trimmed);
+            if (inlineMatch?.[1]) {
+                const entries = inlineMatch[1].split(",");
+                for (const entry of entries) {
+                    const parsed = parseExtraDep(entry);
+                    if (parsed === undefined)
+                        continue;
+                    if (seen.has(parsed.name))
+                        continue;
+                    seen.add(parsed.name);
+                    const purl = new PackageURL("hackage", null, parsed.name, parsed.version, null, null);
+                    const purlParts = decodePurl(purl.toString());
+                    results.push({ purl: purlParts, type: hackageType, source });
+                }
+                inExtraDeps = false;
+            }
+            continue;
+        }
+        // End of extra-deps block (next top-level key)
+        if (inExtraDeps &&
+            !line.startsWith(" ") &&
+            !line.startsWith("\t") &&
+            trimmed !== "" &&
+            !trimmed.startsWith("-") &&
+            !trimmed.startsWith("#")) {
+            inExtraDeps = false;
+            continue;
+        }
+        // List item in extra-deps
+        if (inExtraDeps && trimmed.startsWith("-")) {
+            const parsed = parseExtraDep(trimmed);
+            if (parsed === undefined)
+                continue;
+            if (seen.has(parsed.name))
+                continue;
+            seen.add(parsed.name);
+            const purl = new PackageURL("hackage", null, parsed.name, parsed.version, null, null);
+            const purlParts = decodePurl(purl.toString());
+            results.push({ purl: purlParts, type: hackageType, source });
+        }
+    }
+    return results;
+};
+/**
+ * Hackage package detector.
+ *
+ * Scans `*.cabal` files for `build-depends` fields and `stack.yaml` for
+ * `extra-deps` entries. Dependencies are deduplicated by name.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const hackageDetector = {
+    type: hackageType,
+    detect: Effect.fn("detect.hackage")(function* (projectDir) {
+        const path = yield* Path.Path;
+        const fs = yield* FileSystem.FileSystem;
+        const allDeps = [];
+        const seenNames = new Set();
+        const addDeps = (deps) => {
+            for (const dep of deps) {
+                if (!seenNames.has(dep.purl.name)) {
+                    seenNames.add(dep.purl.name);
+                    allDeps.push(dep);
+                }
+            }
+        };
+        // Scan for *.cabal files
+        const entries = yield* fs.readDirectory(projectDir).pipe(Effect.option);
+        if (Option.isSome(entries)) {
+            const cabalFiles = entries.value.filter((e) => e.endsWith(".cabal"));
+            for (const cabalFile of cabalFiles) {
+                const cabalPath = path.join(projectDir, cabalFile);
+                const content = yield* readFileOptional(cabalPath);
+                if (Option.isSome(content)) {
+                    const deps = parseCabalBuildDepends(content.value, cabalPath);
+                    if (deps.length === 0 && content.value.trim().length > 0) {
+                        // Check if it looks like a valid cabal file
+                        if (!content.value.includes("name:") && !content.value.includes("cabal-version:")) {
+                            yield* Effect.logWarning(`Malformed cabal file: ${cabalFile}, skipping`);
+                        }
+                    }
+                    addDeps(deps);
+                }
+            }
+        }
+        // Parse stack.yaml
+        const stackPath = path.join(projectDir, "stack.yaml");
+        const stackContent = yield* readFileOptional(stackPath);
+        if (Option.isSome(stackContent)) {
+            const stackDeps = parseStackYaml(stackContent.value, stackPath);
+            addDeps(stackDeps);
+        }
+        return allDeps;
+    }, Effect.annotateLogs({ detector: "hackage" }), Effect.withSpan("detect.hackage")),
+};
+/**
+ * Parse x-axm custom fields from a cabal file content.
+ * Returns a record mapping field names (without x-axm- prefix) to values.
+ */
+const parseXAxmFields = (content) => {
+    const fields = {};
+    const regex = /^x-axm-(\S+)\s*:\s*(.+)$/gim;
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+        const fieldName = match[1];
+        const rawValue = match[2]?.trim();
+        if (fieldName === undefined || rawValue === undefined)
+            continue;
+        // Try to parse JSON value, otherwise use as string
+        try {
+            fields[fieldName] = JSON.parse(rawValue);
+        }
+        catch {
+            fields[fieldName] = rawValue;
+        }
+    }
+    return fields;
+};
+/**
+ * Hackage package reader.
+ *
+ * Reads `x-axm` prefixed custom fields from `.cabal` files in
+ * `~/.cabal/store/ghc-<version>/<pkg>-<version>/` or `dist-newstyle/`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const hackageReader = {
+    type: hackageType,
+    read: Effect.fn("read.hackage")(function* (pkg) {
+        const path = yield* Path.Path;
+        const fs = yield* FileSystem.FileSystem;
+        const pkgName = pkg.purl.name;
+        const version = pkg.purl.version;
+        const home = os.homedir();
+        // Try to find the .cabal file in known locations
+        // 1. Try ~/.cabal/store/ghc-*/pkg-version/
+        const cabalStoreDir = path.join(home, ".cabal", "store");
+        const storeExists = yield* fs.readDirectory(cabalStoreDir).pipe(Effect.option);
+        if (Option.isSome(storeExists)) {
+            // Look for ghc-* directories
+            for (const ghcDir of storeExists.value) {
+                if (!ghcDir.startsWith("ghc-"))
+                    continue;
+                const pkgDirName = version ? `${pkgName}-${version}` : pkgName;
+                const pkgDir = path.join(cabalStoreDir, ghcDir, pkgDirName);
+                const pkgEntries = yield* fs.readDirectory(pkgDir).pipe(Effect.option);
+                if (Option.isSome(pkgEntries)) {
+                    const cabalFile = pkgEntries.value.find((e) => e.endsWith(".cabal"));
+                    if (cabalFile !== undefined) {
+                        const cabalPath = path.join(pkgDir, cabalFile);
+                        const content = yield* readFileOptional(cabalPath);
+                        if (Option.isSome(content)) {
+                            const xAxmFields = parseXAxmFields(content.value);
+                            if (Object.keys(xAxmFields).length === 0)
+                                return Option.none();
+                            const metaResult = decodeAxmMeta(xAxmFields);
+                            if (Result.isFailure(metaResult)) {
+                                yield* Effect.logWarning(`Invalid axm metadata in ${pkgName}: schema validation failed`);
+                                return Option.none();
+                            }
+                            return Option.some(metaResult.success.extensions);
+                        }
+                    }
+                }
+            }
+        }
+        // 2. Try dist-newstyle/ relative to project dir
+        const projectDir = path.dirname(pkg.source);
+        const distDir = path.join(projectDir, "dist-newstyle");
+        const distExists = yield* fs.access(distDir).pipe(Effect.option);
+        if (Option.isSome(distExists)) {
+            // Search recursively for the package's .cabal file
+            // dist-newstyle has a deep structure, so look for any .cabal file matching the package name
+            const pkgDirName = version ? `${pkgName}-${version}` : pkgName;
+            const candidatePath = path.join(distDir, "build", pkgDirName, `${pkgName}.cabal`);
+            const content = yield* readFileOptional(candidatePath);
+            if (Option.isSome(content)) {
+                const xAxmFields = parseXAxmFields(content.value);
+                if (Object.keys(xAxmFields).length === 0)
+                    return Option.none();
+                const metaResult = decodeAxmMeta(xAxmFields);
+                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: "hackage" }), Effect.withSpan("read.hackage")),
+};
+//# sourceMappingURL=hackage.js.map

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

@@ -0,0 +1,28 @@
+/**
+ * Hex package detector and reader for package-compatibility discovery.
+ *
+ * Supports both Elixir (mix.exs) and Gleam (gleam.toml) projects.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { PackageDetector, PackageReader } from "./types.js";
+/**
+ * Hex package detector.
+ *
+ * Scans `mix.exs` and `gleam.toml` in the project directory and extracts
+ * dependencies from Elixir dependency tuples and Gleam TOML sections.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const hexDetector: PackageDetector;
+/**
+ * Hex package reader.
+ *
+ * Reads `deps/<package-name>/axm.json` as the primary source, falling back to
+ * parsing `hex_metadata.config` for each detected Hex package.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const hexReader: PackageReader;
+//# sourceMappingURL=hex.d.ts.map