@agentxm/agent-integration 0.28.4-bootstrap.0

package/LICENSE

@@ -0,0 +1,110 @@
+# Functional Source License, Version 1.1, MIT Future License
+
+## Abbreviation
+
+FSL-1.1-MIT
+
+## Notice
+
+Copyright 2025-2026 AgentXM, Inc.
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the MIT license that is effective on the second anniversary of the date we make
+the Software available. On or after that date, you may use the Software under
+the MIT license, in which case the following will apply:
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,9 @@
+# @agentxm/agent-integration
+
+The AXM agent integration: effectful detection of installed AI coding agents
+(project- and user-scope marker evidence, executable resolution) plus
+native-surface path primitives (home and config directories, catalog-derived
+agent install paths). The environment-backed executable resolver layer lives
+behind `./live`.
+
+Unstable and unsupported — use the [axm.sh](https://axm.sh) CLI.

package/dist/src/constants.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Effectful path helpers for agent configuration directories.
+ *
+ * All path computation uses `@effect/platform` Path service. Consumers
+ * must yield these in an Effect context.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Path from "effect/Path";
+import * as Effect from "effect/Effect";
+/**
+ * Resolve the user's home directory.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const getHome: Effect.Effect<string, never, never>;
+/**
+ * Resolve the XDG config home directory.
+ *
+ * Uses `XDG_CONFIG_HOME` environment variable if set, otherwise defaults to `~/.config`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const getConfigHome: Effect.Effect<string, never, Path.Path>;
+//# sourceMappingURL=constants.d.ts.map

package/dist/src/constants.js

@@ -0,0 +1,38 @@
+/**
+ * Effectful path helpers for agent configuration directories.
+ *
+ * All path computation uses `@effect/platform` Path service. Consumers
+ * must yield these in an Effect context.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+// Intentional escape hatch: node:os homedir() has no @effect/platform equivalent.
+// Wrapped in Effect.sync so execution is deferred — no eager module-level I/O.
+import * as os from "node:os";
+import * as Option from "effect/Option";
+import * as Path from "effect/Path";
+import * as Effect from "effect/Effect";
+import { envOption } from "./environment.js";
+/**
+ * Resolve the user's home directory.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const getHome = Effect.sync(() => os.homedir());
+/**
+ * Resolve the XDG config home directory.
+ *
+ * Uses `XDG_CONFIG_HOME` environment variable if set, otherwise defaults to `~/.config`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const getConfigHome = Effect.gen(function* () {
+    const p = yield* Path.Path;
+    const envOpt = yield* envOption("XDG_CONFIG_HOME");
+    if (Option.isSome(envOpt))
+        return envOpt.value;
+    const home = yield* getHome;
+    return p.join(home, ".config");
+});
+//# sourceMappingURL=constants.js.map

package/dist/src/descriptor-paths.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Catalog-derived agent path helpers.
+ *
+ * Agent service implementations can have custom runtime behavior, but their
+ * project-scope install paths should come from the capability catalog.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import type { AgentId } from "@agentxm/extension-model/unstable/agents/types";
+/** @experimental */
+export declare const agentSkillsProjectDir: (agentId: AgentId) => string;
+/** @experimental */
+export declare const agentSubagentsProjectDirOptional: (agentId: AgentId) => string | undefined;
+/** @experimental */
+export declare const agentSubagentsProjectDir: (agentId: AgentId) => string;
+//# sourceMappingURL=descriptor-paths.d.ts.map

package/dist/src/descriptor-paths.js

@@ -0,0 +1,31 @@
+/**
+ * Catalog-derived agent path helpers.
+ *
+ * Agent service implementations can have custom runtime behavior, but their
+ * project-scope install paths should come from the capability catalog.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import { AGENTS } from "@agentxm/extension-model/unstable/agents/registry";
+const unsupportedCapability = (agentId, capability) => {
+    throw new Error(`Agent ${agentId} does not support ${capability}`);
+};
+/** @experimental */
+export const agentSkillsProjectDir = (agentId) => {
+    const skills = AGENTS[agentId].skills;
+    if (skills === undefined) {
+        return unsupportedCapability(agentId, "skills");
+    }
+    return skills.dir;
+};
+/** @experimental */
+export const agentSubagentsProjectDirOptional = (agentId) => AGENTS[agentId].subagents?.dir;
+/** @experimental */
+export const agentSubagentsProjectDir = (agentId) => {
+    const subagents = AGENTS[agentId].subagents;
+    if (subagents === undefined) {
+        return unsupportedCapability(agentId, "subagents");
+    }
+    return subagents.dir;
+};
+//# sourceMappingURL=descriptor-paths.js.map

package/dist/src/detection.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Agent detection functions for identifying installed AI coding agents.
+ *
+ * Detection is effectful and separated from the pure descriptor registry.
+ * Uses FileSystem service for testability.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as ServiceMap from "effect/Context";
+import { AgentDetectionFailed } from "./errors.js";
+import type { AgentDescriptor } from "@agentxm/extension-model/unstable/agents/types";
+export interface AgentExecutableResolverService {
+    readonly exists: (name: string) => Effect.Effect<boolean>;
+}
+declare const AgentExecutableResolver_base: ServiceMap.ServiceClass<AgentExecutableResolver, "@agentxm/agent-integration/detection/AgentExecutableResolver", AgentExecutableResolverService>;
+export declare class AgentExecutableResolver extends AgentExecutableResolver_base {
+}
+export declare const AgentExecutableResolverLive: Layer.Layer<AgentExecutableResolver, never, Path.Path | FileSystem.FileSystem>;
+/**
+ * Check whether an agent can be detected from a single filesystem root.
+ *
+ * Uses the first segment of the agent's skills, MCP servers, and subagents
+ * descriptors.
+ */
+export declare const detectAgentInRoot: (agent: AgentDescriptor, rootDir: string) => Effect.Effect<boolean, AgentDetectionFailed, Path.Path | FileSystem.FileSystem>;
+export interface AgentScopeDetection {
+    readonly agent: AgentDescriptor;
+    readonly project: boolean;
+    readonly user: boolean;
+}
+/** Detect project and user evidence independently for one agent. */
+export declare const detectAgentScopes: (agent: AgentDescriptor, projectDir: string) => Effect.Effect<{
+    agent: AgentDescriptor;
+    project: boolean;
+    user: boolean;
+}, AgentDetectionFailed, Path.Path | FileSystem.FileSystem>;
+/**
+ * Check if a specific agent is installed by checking project-level and
+ * user-scope roots.
+ *
+ * Returns `true` if any supported location exists.
+ *
+ * @param agent - The agent descriptor to check
+ * @param projectDir - The project directory to check for agent config
+ * @returns Effect that resolves to boolean indicating detection status
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const detectAgent: (agent: AgentDescriptor, projectDir: string) => Effect.Effect<boolean, AgentDetectionFailed, Path.Path | FileSystem.FileSystem>;
+/**
+ * Detect all installed agents from a single filesystem root.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const detectAgentsInRoot: (rootDir: string) => Effect.Effect<AgentDescriptor[], AgentDetectionFailed, Path.Path | FileSystem.FileSystem>;
+/**
+ * Detect all installed agents concurrently.
+ *
+ * Checks all registered agents and returns descriptors for those
+ * that appear to be installed on the system.
+ *
+ * @param projectDir - The project directory to check for agent config
+ * @returns Effect that resolves to array of detected agent descriptors
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const detectAgents: (projectDir: string) => Effect.Effect<AgentDescriptor[], AgentDetectionFailed, Path.Path | FileSystem.FileSystem>;
+/** Detect all agents while retaining the scope that supplied each signal. */
+export declare const detectAgentScopeResults: (projectDir: string) => Effect.Effect<{
+    agent: AgentDescriptor;
+    project: boolean;
+    user: boolean;
+}[], AgentDetectionFailed, Path.Path | FileSystem.FileSystem>;
+/** Detect agents whose structured evidence satisfies one selected scope. */
+export declare const detectAgentsForScope: (projectDir: string, scope: "project" | "user") => Effect.Effect<AgentDescriptor[], AgentDetectionFailed, Path.Path | FileSystem.FileSystem>;
+export {};
+//# sourceMappingURL=detection.d.ts.map

package/dist/src/detection.js

@@ -0,0 +1,173 @@
+/**
+ * Agent detection functions for identifying installed AI coding agents.
+ *
+ * Detection is effectful and separated from the pure descriptor registry.
+ * Uses FileSystem service for testability.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as ServiceMap from "effect/Context";
+import { envOption } from "./environment.js";
+import { AgentDetectionFailed } from "./errors.js";
+import { getConfigHome, getHome } from "./constants.js";
+import { AGENTS } from "@agentxm/extension-model/unstable/agents/registry";
+// -----------------------------------------------------------------------------
+// Detection Functions
+// -----------------------------------------------------------------------------
+const wrapDetectionError = (message) => (error) => new AgentDetectionFailed({ detail: message, cause: error });
+export class AgentExecutableResolver extends ServiceMap.Service()("@agentxm/agent-integration/detection/AgentExecutableResolver") {
+}
+const hasPathSeparator = (command) => command.includes("/") || command.includes("\\");
+const getExecutableCandidates = (command, pathExt) => {
+    if (process.platform !== "win32")
+        return [command];
+    const lower = command.toLowerCase();
+    if (lower.endsWith(".exe") || lower.endsWith(".cmd"))
+        return [command];
+    const extensions = pathExt
+        .split(";")
+        .map((segment) => segment.trim().toLowerCase())
+        .filter((segment) => segment.length > 0);
+    return [command, ...extensions.map((extension) => `${command}${extension}`)];
+};
+const makeAgentExecutableResolver = Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const p = yield* Path.Path;
+    return {
+        exists: (command) => Effect.gen(function* () {
+            if (command.trim().length === 0)
+                return false;
+            const pathExtOpt = yield* envOption("PATHEXT");
+            const pathExt = Option.getOrElse(pathExtOpt, () => ".EXE;.CMD;.BAT;.COM");
+            const candidates = getExecutableCandidates(command, pathExt);
+            if (p.isAbsolute(command) || hasPathSeparator(command)) {
+                const checks = yield* Effect.forEach(candidates, (candidate) => fs.exists(candidate).pipe(Effect.catch(() => Effect.succeed(false))), { concurrency: "unbounded" });
+                return checks.some(Boolean);
+            }
+            const rawPathOpt = yield* envOption("PATH");
+            const rawPath = Option.getOrElse(rawPathOpt, () => "");
+            if (rawPath.trim().length === 0)
+                return false;
+            const delimiter = process.platform === "win32" ? ";" : ":";
+            const dirs = rawPath
+                .split(delimiter)
+                .map((segment) => segment.trim())
+                .filter((segment) => segment.length > 0);
+            const checks = yield* Effect.forEach(dirs, (dir) => Effect.forEach(candidates, (candidate) => fs.exists(p.join(dir, candidate)).pipe(Effect.catch(() => Effect.succeed(false))), { concurrency: "unbounded" }).pipe(Effect.map((results) => results.some(Boolean))), { concurrency: "unbounded" });
+            return checks.some(Boolean);
+        }),
+    };
+});
+export const AgentExecutableResolverLive = Layer.effect(AgentExecutableResolver, makeAgentExecutableResolver);
+const markerKey = (marker) => marker.kind === "executable" ? `executable:${marker.name}` : `${marker.kind}:${marker.path}`;
+const detectAgentInRootRaw = (agent, rootDir) => detectScopeRaw(agent.detection.project, rootDir, "project");
+const resolveUserDetectionPath = (marker) => Effect.gen(function* () {
+    const p = yield* Path.Path;
+    if (marker === "$XDG_CONFIG_HOME")
+        return yield* getConfigHome;
+    if (marker.startsWith("$XDG_CONFIG_HOME/")) {
+        const configHome = yield* getConfigHome;
+        return p.join(configHome, marker.slice("$XDG_CONFIG_HOME/".length));
+    }
+    const home = yield* getHome;
+    if (marker === "~")
+        return home;
+    if (marker.startsWith("~/"))
+        return p.join(home, marker.slice("~/".length));
+    return p.join(home, marker);
+});
+const resolveProjectPath = (marker, rootDir) => Effect.gen(function* () {
+    const p = yield* Path.Path;
+    return p.join(rootDir, marker);
+});
+const resolvePathMarker = (marker, rootDir, scope) => scope === "project"
+    ? resolveProjectPath(marker.path, rootDir)
+    : resolveUserDetectionPath(marker.path);
+const resolveMarker = (marker, rootDir, scope) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    if (marker.kind === "executable") {
+        const resolverOption = yield* Effect.serviceOption(AgentExecutableResolver);
+        if (Option.isSome(resolverOption)) {
+            return yield* resolverOption.value.exists(marker.name);
+        }
+        const resolver = yield* makeAgentExecutableResolver;
+        return yield* resolver.exists(marker.name);
+    }
+    const resolvedPath = yield* resolvePathMarker(marker, rootDir, scope);
+    return yield* fs.exists(resolvedPath);
+});
+const isScopeDetected = (markers) => {
+    const resolvedMarkers = markers.filter((entry) => entry.resolved);
+    if (resolvedMarkers.some((entry) => entry.marker.signal === "definitive"))
+        return true;
+    const corroborating = new Set(resolvedMarkers
+        .filter((entry) => entry.marker.signal === "supporting" || entry.marker.signal === "ambiguous")
+        .map((entry) => markerKey(entry.marker)));
+    return corroborating.size >= 2;
+};
+const detectScopeRaw = (detection, rootDir, scope) => Effect.gen(function* () {
+    const results = yield* Effect.forEach(detection.markers, (marker) => resolveMarker(marker, rootDir, scope).pipe(Effect.map((resolved) => ({
+        marker,
+        resolved,
+    }))), { concurrency: "unbounded" });
+    return isScopeDetected(results);
+});
+/**
+ * Check whether an agent can be detected from a single filesystem root.
+ *
+ * Uses the first segment of the agent's skills, MCP servers, and subagents
+ * descriptors.
+ */
+export const detectAgentInRoot = (agent, rootDir) => detectAgentInRootRaw(agent, rootDir).pipe(Effect.mapError(wrapDetectionError(`Failed to detect ${agent.name}`)));
+/** Detect project and user evidence independently for one agent. */
+export const detectAgentScopes = (agent, projectDir) => Effect.gen(function* () {
+    const home = yield* getHome;
+    const [project, user] = yield* Effect.all([detectAgentInRootRaw(agent, projectDir), detectScopeRaw(agent.detection.user, home, "user")], { concurrency: "unbounded" });
+    return { agent, project, user };
+}).pipe(Effect.mapError(wrapDetectionError(`Failed to detect ${agent.name}`)));
+/**
+ * Check if a specific agent is installed by checking project-level and
+ * user-scope roots.
+ *
+ * Returns `true` if any supported location exists.
+ *
+ * @param agent - The agent descriptor to check
+ * @param projectDir - The project directory to check for agent config
+ * @returns Effect that resolves to boolean indicating detection status
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const detectAgent = (agent, projectDir) => detectAgentScopes(agent, projectDir).pipe(Effect.map((detection) => detection.project || detection.user));
+/**
+ * Detect all installed agents from a single filesystem root.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const detectAgentsInRoot = (rootDir) => Effect.filter(Object.values(AGENTS), (agent) => detectAgentInRootRaw(agent, rootDir), {
+    concurrency: "unbounded",
+}).pipe(Effect.mapError(wrapDetectionError(`Failed to detect installed agents in ${rootDir}`)));
+/**
+ * Detect all installed agents concurrently.
+ *
+ * Checks all registered agents and returns descriptors for those
+ * that appear to be installed on the system.
+ *
+ * @param projectDir - The project directory to check for agent config
+ * @returns Effect that resolves to array of detected agent descriptors
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const detectAgents = (projectDir) => detectAgentScopeResults(projectDir).pipe(Effect.map((detections) => detections.map((detection) => detection.agent)));
+/** Detect all agents while retaining the scope that supplied each signal. */
+export const detectAgentScopeResults = (projectDir) => Effect.forEach(Object.values(AGENTS), (agent) => detectAgentScopes(agent, projectDir), {
+    concurrency: "unbounded",
+}).pipe(Effect.map((detections) => detections.filter(({ project, user }) => project || user)));
+/** Detect agents whose structured evidence satisfies one selected scope. */
+export const detectAgentsForScope = (projectDir, scope) => detectAgentScopeResults(projectDir).pipe(Effect.map((detections) => detections.flatMap((detection) => (detection[scope] ? [detection.agent] : []))));
+//# sourceMappingURL=detection.js.map

package/dist/src/environment.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Private environment helpers for agent-integration.
+ *
+ * Deliberately duplicated from the CLI-destined environment module: the
+ * integration may not depend on application utilities, and these helpers are
+ * within the sanctioned duplication budget for small pure functions.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+/** Read an optional env var. Centralized access point for process.env. */
+export declare const envOption: (name: string) => Effect.Effect<Option.Option<string>>;
+//# sourceMappingURL=environment.d.ts.map

package/dist/src/environment.js

@@ -0,0 +1,16 @@
+/**
+ * Private environment helpers for agent-integration.
+ *
+ * Deliberately duplicated from the CLI-destined environment module: the
+ * integration may not depend on application utilities, and these helpers are
+ * within the sanctioned duplication budget for small pure functions.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+// eslint-disable-next-line no-restricted-properties -- Centralized env var access point; all callers use these helpers
+const readEnv = (name) => process.env[name];
+/** Read an optional env var. Centralized access point for process.env. */
+export const envOption = (name) => Effect.sync(() => Option.fromUndefinedOr(readEnv(name)));
+//# sourceMappingURL=environment.js.map

package/dist/src/errors.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Failure vocabulary for the agent-integration layer.
+ *
+ * Fields are domain facts; the application boundary owns the mapping into
+ * the CLI-facing error envelope.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+declare const AgentDetectionFailed_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "AgentDetectionFailed";
+} & Readonly<A>;
+/**
+ * Filesystem evidence gathering for agent detection failed. `detail` is the
+ * fact sentence naming what was being detected; `cause` retains the
+ * originating platform failure.
+ */
+export declare class AgentDetectionFailed extends AgentDetectionFailed_base<{
+    readonly detail: string;
+    readonly cause: unknown;
+}> {
+}
+/** Every typed failure the agent-integration modules construct. */
+export type AgentIntegrationError = AgentDetectionFailed;
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/src/errors.js

@@ -0,0 +1,17 @@
+/**
+ * Failure vocabulary for the agent-integration layer.
+ *
+ * Fields are domain facts; the application boundary owns the mapping into
+ * the CLI-facing error envelope.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Data from "effect/Data";
+/**
+ * Filesystem evidence gathering for agent detection failed. `detail` is the
+ * fact sentence naming what was being detected; `cause` retains the
+ * originating platform failure.
+ */
+export class AgentDetectionFailed extends Data.TaggedError("AgentDetectionFailed") {
+}
+//# sourceMappingURL=errors.js.map

package/dist/src/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @agentxm/agent-integration public API.
+ *
+ * Effectful detection of installed AI coding agents plus native-surface path
+ * primitives (home and config directories, catalog-derived agent install
+ * paths). The environment-backed executable resolver layer lives behind
+ * `./live`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+export { AgentExecutableResolver, detectAgent, detectAgentInRoot, detectAgentScopeResults, detectAgentScopes, detectAgents, detectAgentsForScope, detectAgentsInRoot, type AgentScopeDetection, type AgentExecutableResolverService, } from "./detection.js";
+export { AgentDetectionFailed, type AgentIntegrationError } from "./errors.js";
+export { getHome, getConfigHome } from "./constants.js";
+export { agentSkillsProjectDir, agentSubagentsProjectDir, agentSubagentsProjectDirOptional, } from "./descriptor-paths.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.js

@@ -0,0 +1,20 @@
+/**
+ * @agentxm/agent-integration public API.
+ *
+ * Effectful detection of installed AI coding agents plus native-surface path
+ * primitives (home and config directories, catalog-derived agent install
+ * paths). The environment-backed executable resolver layer lives behind
+ * `./live`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+// Detection (effectful)
+export { AgentExecutableResolver, detectAgent, detectAgentInRoot, detectAgentScopeResults, detectAgentScopes, detectAgents, detectAgentsForScope, detectAgentsInRoot, } from "./detection.js";
+// Failure vocabulary
+export { AgentDetectionFailed } from "./errors.js";
+// Constants (path helpers)
+export { getHome, getConfigHome } from "./constants.js";
+// Catalog-derived agent path helpers
+export { agentSkillsProjectDir, agentSubagentsProjectDir, agentSubagentsProjectDirOptional, } from "./descriptor-paths.js";
+//# sourceMappingURL=index.js.map

package/dist/src/live.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @agentxm/agent-integration environment-backed composition.
+ *
+ * The PATH-probing executable resolver layer. Only application composition
+ * roots import this module; feature logic resolves `AgentExecutableResolver`
+ * from its Effect environment.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+export { AgentExecutableResolverLive } from "./detection.js";
+//# sourceMappingURL=live.d.ts.map

package/dist/src/live.js

@@ -0,0 +1,12 @@
+/**
+ * @agentxm/agent-integration environment-backed composition.
+ *
+ * The PATH-probing executable resolver layer. Only application composition
+ * roots import this module; feature logic resolves `AgentExecutableResolver`
+ * from its Effect environment.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+export { AgentExecutableResolverLive } from "./detection.js";
+//# sourceMappingURL=live.js.map

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@agentxm/agent-integration",
+  "version": "0.28.4-bootstrap.0",
+  "description": "AXM agent integration: effectful detection of installed AI coding agents and native-surface path primitives for the axm CLI. Unstable and unsupported — use the axm.sh CLI.",
+  "type": "module",
+  "license": "FSL-1.1-MIT",
+  "homepage": "https://axm.sh",
+  "bugs": {
+    "url": "https://github.com/agentxm/axm/issues"
+  },
+  "author": "AgentXM <hello@agentxm.ai> (https://agentxm.ai)",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/agentxm/axm.git",
+    "directory": "packages/agent-integration"
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js"
+    },
+    "./live": {
+      "types": "./dist/src/live.d.ts",
+      "default": "./dist/src/live.js"
+    }
+  },
+  "files": [
+    "dist/src/",
+    "!**/*.map"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "nx": {
+    "includedScripts": []
+  },
+  "dependencies": {
+    "effect": "4.0.0-rc.112",
+    "@agentxm/extension-model": "^0.28.4-bootstrap.0"
+  },
+  "devDependencies": {
+    "@effect/platform-node": "4.0.0-rc.112",
+    "@effect/vitest": "4.0.0-rc.112",
+    "@typescript/native": "npm:typescript@^7.0.2",
+    "typescript": "npm:@typescript/typescript6@^6.0.2",
+    "vitest": "^4.1.10"
+  }
+}