@agentxm/extension-materialization 0.28.14-preview.1789139351.5cd4595aa

package/dist/src/testing.d.ts

@@ -0,0 +1,87 @@
+/**
+ * In-memory materialization doubles for feature tests: a manager whose
+ * surfaces are recorded rather than written, a retention policy that never
+ * retains, and a structural serialization of a recipe's typed failure into the
+ * plan-step vocabulary.
+ *
+ * These are deliberately behavioural, not mocks of a shape: a test asserts on
+ * what the recorder observed, so a contract change that stops calling a
+ * surface fails the test rather than passing silently.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import { StepFailure } from "@agentxm/workspace-operations";
+import type { ExtensionRef } from "@agentxm/extension-model/unstable/extensions/refs/extension-ref";
+import type { ExtensionTarget } from "@agentxm/workspace-state";
+import type { ExtensionManager, ManagerRequirements, MaterializationFacts } from "./manager-contract.js";
+import type { CallerStepFailure, UninstallRetentionPolicy } from "./extensions/operations.js";
+import { McpSecretStore } from "./mcps/secret-store.js";
+/** The manager surfaces one recipe touched, in the order it touched them. */
+export type RecordedManagerSurface = "materializeInstall" | "materializeUninstall" | "materializeDeactivate" | "upsertSettingsEntry" | "removeSettingsEntry" | "upsertLockfileEntry" | "removeLockfileEntry" | "listMaterializable" | "projectionPlans";
+/** What an in-memory manager observed while a recipe ran against it. */
+export interface RecordedManager<TRef extends ExtensionRef> {
+    readonly manager: ExtensionManager<TRef, MaterializationFacts, ManagerRequirements>;
+    /** Every surface the recipe touched, in call order. */
+    readonly surfaces: ReadonlyArray<RecordedManagerSurface>;
+    /** Targets currently declared in the recorder's settings. */
+    readonly configured: ReadonlySet<string>;
+    /** Targets currently observable as installed. */
+    readonly installed: ReadonlySet<string>;
+}
+/**
+ * A materialization that observed nothing and acquired nothing. It satisfies
+ * every per-type facts shape, so a feature test that never asserts on content
+ * identity uses one value for any manager.
+ */
+export declare const NO_MATERIALIZATION_FACTS: {
+    readonly observation: import("./manager-contract.js").MaterializationObservation;
+    readonly treeIntegrity: Option.Option<never>;
+    readonly sourceHash: Option.Option<never>;
+    readonly acquired: Option.Option<never>;
+    readonly removal: Option.Option<never>;
+};
+/**
+ * A manager whose authoritative surfaces are in-memory sets. `materializable`
+ * is what `listMaterializable` answers; anything installed through the
+ * recorder becomes both configured and observable.
+ */
+export declare const makeRecordedManager: <TRef extends ExtensionRef>(args: {
+    readonly type: TRef["type"];
+    readonly materializable: ReadonlyArray<TRef>;
+    /** Targets already installed and declared before the recipe runs. */
+    readonly installed?: ReadonlyArray<string>;
+}) => RecordedManager<TRef>;
+/** A retention policy that never retains a package for an installed Pack. */
+export declare const noUninstallRetention: UninstallRetentionPolicy;
+/** A retention policy that always retains, for the retained-by-pack settlement. */
+export declare const alwaysUninstallRetention: UninstallRetentionPolicy;
+/**
+ * A structural serialization of a recipe's typed failure: the producing
+ * family's own detail sentence under an `internal` category. Assertions bind
+ * to this mapping, not to the application boundary's wording.
+ */
+export declare const structuralStepFailure: <F>(failure: CallerStepFailure<F>) => StepFailure;
+/** A retention target's plan-step identity, for assertions on recorded steps. */
+export declare const recordedTargetName: (target: ExtensionTarget) => string;
+/** What an in-memory credential store recorded, and the layer that backs it. */
+export interface MemoryMcpSecretStore {
+    readonly layer: Layer.Layer<McpSecretStore>;
+    /** Every account currently holding a value, keyed by account digest. */
+    readonly entries: ReadonlyMap<string, string>;
+}
+/**
+ * An in-memory credential store for MCP install tests.
+ *
+ * `failWrites` stands for a keychain that is present but refuses to persist —
+ * locked, full, or denied — which is the condition the install reports as a
+ * credential action rather than a failed closure.
+ */
+export declare const makeMemoryMcpSecretStore: (options?: {
+    readonly failWrites?: boolean;
+    /** Values already held, keyed by account digest. */
+    readonly initial?: Readonly<Record<string, string>>;
+}) => MemoryMcpSecretStore;
+//# sourceMappingURL=testing.d.ts.map

package/dist/src/testing.js

@@ -0,0 +1,116 @@
+/**
+ * In-memory materialization doubles for feature tests: a manager whose
+ * surfaces are recorded rather than written, a retention policy that never
+ * retains, and a structural serialization of a recipe's typed failure into the
+ * plan-step vocabulary.
+ *
+ * These are deliberately behavioural, not mocks of a shape: a test asserts on
+ * what the recorder observed, so a contract change that stops calling a
+ * surface fails the test rather than passing silently.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import { StepFailure } from "@agentxm/workspace-operations";
+import { NO_MATERIALIZATION_OBSERVATION } from "./manager-contract.js";
+import { targetFromRef } from "./extensions/operations.js";
+import { McpSecretStore } from "./mcps/secret-store.js";
+/**
+ * A materialization that observed nothing and acquired nothing. It satisfies
+ * every per-type facts shape, so a feature test that never asserts on content
+ * identity uses one value for any manager.
+ */
+export const NO_MATERIALIZATION_FACTS = {
+    observation: NO_MATERIALIZATION_OBSERVATION,
+    treeIntegrity: Option.none(),
+    sourceHash: Option.none(),
+    acquired: Option.none(),
+    removal: Option.none(),
+};
+const NO_FACTS = NO_MATERIALIZATION_FACTS;
+/**
+ * A manager whose authoritative surfaces are in-memory sets. `materializable`
+ * is what `listMaterializable` answers; anything installed through the
+ * recorder becomes both configured and observable.
+ */
+export const makeRecordedManager = (args) => {
+    const surfaces = [];
+    const configured = new Set(args.installed ?? []);
+    const installed = new Set(args.installed ?? []);
+    const record = (surface, effect) => Effect.sync(() => surfaces.push(surface)).pipe(Effect.andThen(effect));
+    const manager = {
+        type: args.type,
+        isInstalled: ({ target }) => Effect.succeed(installed.has(target.name)),
+        materializeInstall: ({ ref }) => record("materializeInstall", Effect.sync(() => {
+            installed.add(targetFromRef(ref).name);
+            return NO_FACTS;
+        })),
+        materializeUninstall: ({ target }) => record("materializeUninstall", Effect.sync(() => {
+            installed.delete(target.name);
+            return NO_FACTS;
+        })),
+        materializeDeactivate: () => record("materializeDeactivate", Effect.succeed(NO_FACTS)),
+        getConfiguredSource: ({ target }) => Effect.succeed(configured.has(target.name) ? Option.some("workspace:") : Option.none()),
+        isConfigured: ({ target }) => Effect.succeed(configured.has(target.name)),
+        listMaterializable: () => record("listMaterializable", Effect.succeed(args.materializable)),
+        upsertSettingsEntry: ({ ref }) => record("upsertSettingsEntry", Effect.sync(() => {
+            configured.add(targetFromRef(ref).name);
+        })),
+        removeSettingsEntry: ({ target }) => record("removeSettingsEntry", Effect.sync(() => {
+            configured.delete(target.name);
+        })),
+        upsertLockfileEntry: () => record("upsertLockfileEntry", Effect.void),
+        removeLockfileEntry: () => record("removeLockfileEntry", Effect.void),
+    };
+    return { manager, surfaces, configured, installed };
+};
+/** A retention policy that never retains a package for an installed Pack. */
+export const noUninstallRetention = {
+    isRequiredByInstalledPack: () => Effect.succeed(false),
+};
+/** A retention policy that always retains, for the retained-by-pack settlement. */
+export const alwaysUninstallRetention = {
+    isRequiredByInstalledPack: () => Effect.succeed(true),
+};
+/**
+ * A structural serialization of a recipe's typed failure: the producing
+ * family's own detail sentence under an `internal` category. Assertions bind
+ * to this mapping, not to the application boundary's wording.
+ */
+export const structuralStepFailure = (failure) => {
+    const detail = typeof failure === "object" &&
+        failure !== null &&
+        "detail" in failure &&
+        typeof failure.detail === "string"
+        ? failure.detail
+        : String(failure);
+    return new StepFailure({ category: "internal", detail, cause: failure });
+};
+/** A retention target's plan-step identity, for assertions on recorded steps. */
+export const recordedTargetName = (target) => target.name;
+/**
+ * An in-memory credential store for MCP install tests.
+ *
+ * `failWrites` stands for a keychain that is present but refuses to persist —
+ * locked, full, or denied — which is the condition the install reports as a
+ * credential action rather than a failed closure.
+ */
+export const makeMemoryMcpSecretStore = (options) => {
+    const entries = new Map(Object.entries(options?.initial ?? {}));
+    const failWrites = options?.failWrites ?? false;
+    const service = {
+        read: (account) => Effect.sync(() => Option.fromNullOr(entries.get(account) ?? null)),
+        write: (account, value) => Effect.sync(() => {
+            if (failWrites)
+                return "failed";
+            entries.set(account, value);
+            return "saved";
+        }),
+        erase: (account) => Effect.sync(() => (entries.delete(account) ? "deleted" : "absent")),
+    };
+    return { layer: Layer.succeed(McpSecretStore, service), entries };
+};
+//# sourceMappingURL=testing.js.map

package/package.json

@@ -0,0 +1,70 @@
+{
+  "author": "AgentXM <hello@agentxm.ai> (https://agentxm.ai)",
+  "bugs": {
+    "url": "https://github.com/agentxm/axm/issues"
+  },
+  "dependencies": {
+    "@agentxm/agent-integration": "^0.28.14-preview.1789139351.5cd4595aa",
+    "@agentxm/extension-content": "^0.28.14-preview.1789139351.5cd4595aa",
+    "@agentxm/extension-model": "^0.28.14-preview.1789139351.5cd4595aa",
+    "@agentxm/extension-resolution": "^0.28.14-preview.1789139351.5cd4595aa",
+    "@agentxm/extension-sources": "^0.28.14-preview.1789139351.5cd4595aa",
+    "@agentxm/registry-client": "^0.28.14-preview.1789139351.5cd4595aa",
+    "@agentxm/workspace-operations": "^0.28.14-preview.1789139351.5cd4595aa",
+    "@agentxm/workspace-projection": "^0.28.14-preview.1789139351.5cd4595aa",
+    "@agentxm/workspace-state": "^0.28.14-preview.1789139351.5cd4595aa",
+    "@agentxm/workspace-transactions": "^0.28.14-preview.1789139351.5cd4595aa",
+    "@napi-rs/keyring": "^1.3.0",
+    "effect": "4.0.0-rc.112"
+  },
+  "description": "AXM extension materialization: the per-extension-type manager contract and implementations, canonical package staging, registry materialization, and the install/uninstall/authored closure recipes for the axm CLI. Unstable and unsupported — use the axm.sh CLI.",
+  "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",
+    "yaml": "^2.9.0"
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "exports": {
+    ".": {
+      "axm-source": "./src/index.ts",
+      "default": "./dist/src/index.js",
+      "types": "./dist/src/index.d.ts"
+    },
+    "./live": {
+      "axm-source": "./src/live.ts",
+      "default": "./dist/src/live.js",
+      "types": "./dist/src/live.d.ts"
+    },
+    "./testing": {
+      "axm-source": "./src/testing.ts",
+      "default": "./dist/src/testing.js",
+      "types": "./dist/src/testing.d.ts"
+    }
+  },
+  "files": [
+    "dist/src/",
+    "!**/*.map"
+  ],
+  "homepage": "https://axm.sh",
+  "license": "FSL-1.1-MIT",
+  "name": "@agentxm/extension-materialization",
+  "nx": {
+    "includedScripts": []
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "directory": "packages/core/extension-materialization",
+    "type": "git",
+    "url": "https://github.com/agentxm/axm.git"
+  },
+  "sideEffects": false,
+  "type": "module",
+  "version": "0.28.14-preview.1789139351.5cd4595aa"
+}