@agentxm/workspace-configuration 0.28.12 → 0.28.13

package/dist/src/testing.js

@@ -1,9 +1,220 @@
 /**
- * Deterministic in-memory Layer implementations of the workspace-configuration
- * services. Tests and specifications may import this module; production
- * source composes the application's interaction implementation instead.
+ * @agentxm/workspace-configuration deterministic fixtures and ports.
+ *
+ * A throwaway workspace with settings, lockfile, and agent-native files
+ * written as the product writes them, plus every service a configuration use
+ * case reads or writes through: the workspace state and its transaction
+ * scope, the projection capability, the rule manager, and the plan pipeline's
+ * per-invocation services with a recording interaction port. Production
+ * source never imports this module.
  *
  * @experimental This API is unstable and may change without notice.
  */
-export { WorkspaceInitializationInteractionTest, } from "./initialization-interaction.js";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as nodePath from "node:path";
+import * as ConfigProvider from "effect/ConfigProvider";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import { AgentExecutableResolver } from "@agentxm/agent-integration";
+import { SourceHostProviders } from "@agentxm/extension-sources";
+import { decodeAbsolutePathSync } from "@agentxm/extension-model/unstable/path-types";
+import { RuleManagerLive } from "@agentxm/extension-materialization/live";
+import { PlanInvocationTest, ResolvePlanInteractionTest, } from "@agentxm/workspace-operations/testing";
+import { ProjectionParticipants, emptyProjectionParticipants } from "@agentxm/workspace-projection";
+import { CodingAgentRepositoryLive, NativeWriteAuthorityLive, WorkspaceCatalogLive, WorkspaceInvariantFactsLive, } from "@agentxm/workspace-projection/live";
+import { layer as WorkspaceLayerLive } from "@agentxm/workspace-state/live";
+import { WorkspaceInitializationInteractionTest, } from "./setup/initialization-interaction.js";
+export { WorkspaceInitializationInteractionTest };
+/**
+ * A throwaway workspace with every service a configuration use case needs
+ * over it, and a pinned user home so a project-scope run can be shown to
+ * leave the user scope alone.
+ */
+export const makeConfigurationFixture = (options = {}) => {
+    const scope = options.scope ?? "project";
+    const root = fs.realpathSync(fs.mkdtempSync(nodePath.join(os.tmpdir(), "axm-configuration-")));
+    const home = fs.realpathSync(fs.mkdtempSync(nodePath.join(os.tmpdir(), "axm-configuration-home-")));
+    const workspaceRoot = scope === "user" ? nodePath.join(home, ".axm", "workspace") : root;
+    fs.mkdirSync(nodePath.join(root, ".axm"), { recursive: true });
+    fs.mkdirSync(nodePath.join(home, ".axm", "workspace"), { recursive: true });
+    const writeUnder = (base) => (relativePath, contents) => {
+        const file = nodePath.join(base, relativePath);
+        fs.mkdirSync(nodePath.dirname(file), { recursive: true });
+        fs.writeFileSync(file, contents);
+    };
+    const writeFile = writeUnder(root);
+    const writeHomeFile = writeUnder(home);
+    const readFile = (relativePath) => fs.readFileSync(nodePath.join(root, relativePath), "utf8");
+    const exists = (relativePath) => fs.existsSync(nodePath.join(root, relativePath));
+    /** Every file, symlink, and directory under a root, so purity can be proven. */
+    const snapshotUnder = (base) => {
+        const entries = [];
+        const walk = (directory) => {
+            for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+                const absolute = nodePath.join(directory, entry.name);
+                const relative = nodePath.relative(base, absolute);
+                if (entry.isSymbolicLink()) {
+                    entries.push([relative, `symlink:${fs.readlinkSync(absolute)}`]);
+                    continue;
+                }
+                if (entry.isDirectory()) {
+                    entries.push([relative, "directory"]);
+                    walk(absolute);
+                    continue;
+                }
+                entries.push([relative, fs.readFileSync(absolute, "utf8")]);
+            }
+        };
+        walk(base);
+        return entries.sort((left, right) => left[0].localeCompare(right[0]));
+    };
+    if (options.settings !== undefined) {
+        fs.writeFileSync(nodePath.join(workspaceRoot, "axm.json"), JSON.stringify({ agents: [], ...options.settings }, null, 2));
+        // JSON is valid YAML, so the lockfile fixture needs no emitter.
+        fs.writeFileSync(nodePath.join(workspaceRoot, "axm-lock.yaml"), JSON.stringify({ lockfileVersion: 7, skills: {}, ...options.lockfile }));
+    }
+    for (const [relativePath, contents] of Object.entries(options.files ?? {})) {
+        writeFile(relativePath, contents);
+    }
+    for (const [relativePath, contents] of Object.entries(options.homeFiles ?? {})) {
+        writeHomeFile(relativePath, contents);
+    }
+    const interaction = ResolvePlanInteractionTest();
+    const environment = ConfigProvider.layer(ConfigProvider.fromEnv({ env: { AXM_USER_HOME: home } }));
+    // Configuration flows never fetch a source; a fixture that could would be
+    // describing a different use case.
+    const sourceProviders = Layer.succeed(SourceHostProviders, {
+        find: () => Effect.succeed([]),
+        resolveNamedRegistry: () => Effect.die("no named registry in this fixture"),
+        fetch: () => Effect.die("no source fetch in this fixture"),
+        cloneUrl: () => Option.none(),
+        origin: () => "fixture",
+    });
+    // No configuration flow reaches a network; a fixture that could would be
+    // describing a different use case.
+    const transport = Layer.succeed(HttpClient.HttpClient, HttpClient.make(() => Effect.die("no HTTP request in this fixture")));
+    // Configuration flows plan their own rule projection through the rule
+    // manager; the aggregate participant registry is a reconciliation concern
+    // these fixtures do not exercise, so it is present but empty.
+    const participants = Layer.succeed(ProjectionParticipants, emptyProjectionParticipants);
+    const installedExecutables = new Set(options.installedExecutables ?? []);
+    const executables = Layer.succeed(AgentExecutableResolver, {
+        exists: (name) => Effect.succeed(installedExecutables.has(name)),
+    });
+    // One environment, built outward: the workspace state and the ports over
+    // it, then the projection services that read them, then the rule manager
+    // that reads both. `provideMerge` keeps every layer's output in the result,
+    // so a service a manager keeps in `R` is still there when it is reached.
+    const base = Layer.provideMerge(Layer.mergeAll(WorkspaceLayerLive({
+        scope,
+        projectRoot: decodeAbsolutePathSync(root),
+        allowUninitialized: options.settings === undefined,
+    }), CodingAgentRepositoryLive, NativeWriteAuthorityLive, participants, sourceProviders, transport, interaction.layer, executables, PlanInvocationTest), environment);
+    const withProjection = Layer.provideMerge(Layer.mergeAll(WorkspaceInvariantFactsLive, WorkspaceCatalogLive), base);
+    const services = Layer.provideMerge(RuleManagerLive, withProjection);
+    return {
+        root,
+        home,
+        workspaceRoot,
+        writeFile,
+        writeHomeFile,
+        readFile,
+        exists,
+        /** Every file under the project root. */
+        snapshot: () => snapshotUnder(root),
+        /** Every file under the pinned user home. */
+        homeSnapshot: () => snapshotUnder(home),
+        /** What the plan interaction port was asked to present and confirm. */
+        interactionState: () => interaction.state,
+        provide: (effect) => effect.pipe(Effect.provide(services)),
+        cleanup: () => {
+            fs.rmSync(root, { recursive: true, force: true });
+            fs.rmSync(home, { recursive: true, force: true });
+        },
+    };
+};
+/**
+ * A bare directory and the services setup needs to turn it into a workspace.
+ *
+ * Setup builds its own workspace, so this fixture deliberately provides no
+ * workspace state: only the platform-adjacent ports it reads — the pinned
+ * user home, the coding-agent catalog and executable probe, and a recording
+ * initialization-interaction port whose calls are the evidence channel for
+ * every claim about what setup asked.
+ */
+export const makeSetupFixture = (options = {}) => {
+    const root = fs.realpathSync(fs.mkdtempSync(nodePath.join(os.tmpdir(), "axm-setup-")));
+    const home = fs.realpathSync(fs.mkdtempSync(nodePath.join(os.tmpdir(), "axm-setup-home-")));
+    const writeUnder = (base) => (relativePath, contents) => {
+        const file = nodePath.join(base, relativePath);
+        fs.mkdirSync(nodePath.dirname(file), { recursive: true });
+        fs.writeFileSync(file, contents);
+    };
+    const writeFile = writeUnder(root);
+    const writeHomeFile = writeUnder(home);
+    for (const [relativePath, contents] of Object.entries(options.files ?? {})) {
+        writeFile(relativePath, contents);
+    }
+    for (const [relativePath, contents] of Object.entries(options.homeFiles ?? {})) {
+        writeHomeFile(relativePath, contents);
+    }
+    const snapshotUnder = (base) => {
+        const entries = [];
+        const walk = (directory) => {
+            for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+                const absolute = nodePath.join(directory, entry.name);
+                const relative = nodePath.relative(base, absolute);
+                if (entry.isSymbolicLink()) {
+                    entries.push([relative, `symlink:${fs.readlinkSync(absolute)}`]);
+                    continue;
+                }
+                if (entry.isDirectory()) {
+                    entries.push([relative, "directory"]);
+                    walk(absolute);
+                    continue;
+                }
+                entries.push([relative, fs.readFileSync(absolute, "utf8")]);
+            }
+        };
+        walk(base);
+        return entries.sort((left, right) => left[0].localeCompare(right[0]));
+    };
+    const interaction = WorkspaceInitializationInteractionTest({
+        ...(options.selectAgents === undefined
+            ? {}
+            : { selectAgents: () => Effect.succeed(options.selectAgents ?? []) }),
+        ...(options.confirmSetupPlan === undefined
+            ? {}
+            : { confirmSetupPlan: () => Effect.succeed(options.confirmSetupPlan ?? true) }),
+        ...(options.confirmInstructionSync === undefined
+            ? {}
+            : { confirmInstructionSync: () => Effect.succeed(options.confirmInstructionSync ?? true) }),
+    });
+    const installedExecutables = new Set(options.installedExecutables ?? []);
+    const services = Layer.mergeAll(ConfigProvider.layer(ConfigProvider.fromEnv({ env: { AXM_USER_HOME: home, HOME: home } })), CodingAgentRepositoryLive, Layer.succeed(AgentExecutableResolver, {
+        exists: (name) => Effect.succeed(installedExecutables.has(name)),
+    }), interaction.layer);
+    return {
+        root,
+        home,
+        writeFile,
+        writeHomeFile,
+        readFile: (relativePath) => fs.readFileSync(nodePath.join(root, relativePath), "utf8"),
+        exists: (relativePath) => fs.existsSync(nodePath.join(root, relativePath)),
+        /** Every file under the bare project directory. */
+        snapshot: () => snapshotUnder(root),
+        /** Every file under the pinned user home. */
+        homeSnapshot: () => snapshotUnder(home),
+        /** What the initialization interaction port was asked. */
+        promptState: () => interaction.state,
+        provide: (effect) => effect.pipe(Effect.provide(services)),
+        cleanup: () => {
+            fs.rmSync(root, { recursive: true, force: true });
+            fs.rmSync(home, { recursive: true, force: true });
+        },
+    };
+};
 //# sourceMappingURL=testing.js.map

package/package.json

@@ -4,12 +4,14 @@
     "url": "https://github.com/agentxm/axm/issues"
   },
   "dependencies": {
-    "@agentxm/agent-integration": "^0.28.12",
-    "@agentxm/extension-model": "^0.28.12",
-    "@agentxm/extension-sources": "^0.28.12",
-    "@agentxm/extension-workspace": "^0.28.12",
-    "@agentxm/workspace-operations": "^0.28.12",
-    "@agentxm/workspace-state": "^0.28.12",
+    "@agentxm/agent-integration": "^0.28.13",
+    "@agentxm/extension-materialization": "^0.28.13",
+    "@agentxm/extension-model": "^0.28.13",
+    "@agentxm/extension-sources": "^0.28.13",
+    "@agentxm/workspace-operations": "^0.28.13",
+    "@agentxm/workspace-projection": "^0.28.13",
+    "@agentxm/workspace-state": "^0.28.13",
+    "@agentxm/workspace-transactions": "^0.28.13",
     "effect": "4.0.0-rc.112"
   },
   "description": "AXM workspace-configuration feature: setup, configured-agent membership, instruction management, and inline workspace capabilities for the axm CLI. Unstable and unsupported — use the axm.sh CLI.",
@@ -50,11 +52,11 @@
     "access": "public"
   },
   "repository": {
-    "directory": "packages/workspace-configuration",
+    "directory": "packages/core/workspace-configuration",
     "type": "git",
     "url": "https://github.com/agentxm/axm.git"
   },
   "sideEffects": false,
   "type": "module",
-  "version": "0.28.12"
-}
+  "version": "0.28.13"
+}

package/dist/src/instruction-reconciliation.d.ts

@@ -1,57 +0,0 @@
-/**
- * Instruction-management policy over the kernel's instruction semantics:
- * observation, readiness preflight, reconciliation transitions, and disabling
- * instruction-file management. Failures stay typed through this feature; the
- * application boundary owns their rendering.
- *
- * @experimental This API is unstable and may change without notice.
- */
-import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
-import type { WorkspaceMutationsService } from "@agentxm/workspace-state";
-import { assertInstructionTargetsSafe, assertInstructionsGitignoreSafe } from "@agentxm/extension-workspace";
-import type { InstructionProjectionSnapshot, ResolvedInstructionsConfig } from "@agentxm/extension-workspace";
-import { WorkspaceConfigurationFailed } from "./errors.js";
-/** The one observation a command's planning derives its views from. */
-export declare const observeInstructions: (args: {
-    readonly ws: WorkspaceMutationsService;
-    readonly config: ResolvedInstructionsConfig;
-}) => Effect.Effect<InstructionProjectionSnapshot, import("@agentxm/workspace-state").WorkspaceSettingsReadFailure, import("effect/FileSystem").FileSystem | import("effect/Path").Path>;
-export declare const activeInstructionsConfig: (ws: WorkspaceMutationsService) => Effect.Effect<Option.Option<ResolvedInstructionsConfig>, import("@agentxm/workspace-state").WorkspaceSettingsReadFailure, never>;
-export declare const instructionStateIsCurrent: (snapshot: InstructionProjectionSnapshot) => boolean;
-/** The typed failure a readiness preflight can surface. */
-export type InstructionReadinessFailure = Effect.Error<ReturnType<typeof assertInstructionTargetsSafe>> | Effect.Error<ReturnType<typeof assertInstructionsGitignoreSafe>>;
-export declare const instructionReconciliationReadiness: (args: {
-    readonly ws: WorkspaceMutationsService;
-    readonly snapshot: InstructionProjectionSnapshot;
-}) => Effect.Effect<Option.None<InstructionReadinessFailure> | Option.Some<InstructionReadinessFailure>, never, import("effect/FileSystem").FileSystem | import("effect/Path").Path>;
-/**
- * Remove every alias the given configuration owns, observing fresh so the
- * decision reflects the workspace at the moment of removal. Used before a new
- * configuration is reconciled, so a changed source filename or alias policy
- * never leaves the old arrangement behind. Refuses on an unowned target like
- * every other path.
- */
-export declare const removeInstructionTargetsFor: (args: {
-    readonly ws: WorkspaceMutationsService;
-    readonly config: ResolvedInstructionsConfig;
-}) => Effect.Effect<string[], import("@agentxm/workspace-state").WorkspaceSnapshotError | import("@agentxm/extension-workspace").InstructionMaintenanceFailed | import("@agentxm/workspace-state").WorkspaceSettingsReadFailure, import("effect/FileSystem").FileSystem | import("effect/Path").Path>;
-/**
- * Runs inside the workspace transaction: preflight against a fresh
- * observation (the plan's readiness check ran before the transaction opened),
- * apply the transition, reconcile, and verify from the sync's own readback.
- */
-export declare const reconcileInstructionTransition: <A, E>(args: {
-    readonly ws: WorkspaceMutationsService;
-    readonly config: ResolvedInstructionsConfig;
-    readonly preflightConfig?: ResolvedInstructionsConfig;
-    readonly transition: Effect.Effect<A, E>;
-}) => Effect.Effect<A, WorkspaceConfigurationFailed | import("@agentxm/extension-workspace").InstructionMaintenanceFailure | import("@agentxm/workspace-state").WorkspaceSettingsReadFailure | E, import("effect/FileSystem").FileSystem | import("effect/Path").Path>;
-export declare const disableInstructionManagement: (args: {
-    readonly ws: WorkspaceMutationsService;
-    readonly config: ResolvedInstructionsConfig;
-}) => Effect.Effect<{
-    removed: string[];
-    gitignore: string | undefined;
-}, import("@agentxm/workspace-state").WorkspaceSnapshotError | import("@agentxm/workspace-state").SettingsWriteError | import("@agentxm/extension-workspace").InstructionMaintenanceFailed | import("@agentxm/workspace-state").PathTraversalDetected | import("@agentxm/workspace-state").SymlinkCreationError | import("@agentxm/workspace-state").WorkspaceRootEscape | import("@agentxm/workspace-state").SettingsIoError | import("@agentxm/workspace-state").SettingsParseError | import("@agentxm/workspace-state").SettingsDecodeError, import("effect/FileSystem").FileSystem | import("effect/Path").Path>;
-//# sourceMappingURL=instruction-reconciliation.d.ts.map

package/dist/src/instruction-reconciliation.js

@@ -1,93 +0,0 @@
-/**
- * Instruction-management policy over the kernel's instruction semantics:
- * observation, readiness preflight, reconciliation transitions, and disabling
- * instruction-file management. Failures stay typed through this feature; the
- * application boundary owns their rendering.
- *
- * @experimental This API is unstable and may change without notice.
- */
-import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
-import { assertInstructionTargetsSafe, assertInstructionsGitignoreSafe, instructionProjectionIsCurrent, observeInstructionProjection, removeManagedInstructionTargets, removeInstructionsGitignore, resolveInstructionsConfig, syncInstructions, } from "@agentxm/extension-workspace";
-import { WorkspaceConfigurationFailed } from "./errors.js";
-const configuredAgents = (ws) => ws.getConfiguredAgents();
-/** The one observation a command's planning derives its views from. */
-export const observeInstructions = Effect.fn("Instructions.observe")(function* (args) {
-    const agents = yield* configuredAgents(args.ws);
-    return yield* observeInstructionProjection({
-        workspaceRoot: args.ws.baseDir,
-        scope: args.ws.scope,
-        configuredAgents: agents,
-        config: args.config,
-    });
-});
-export const activeInstructionsConfig = Effect.fn("Instructions.activeConfig")(function* (ws) {
-    const value = yield* ws.getInstructionsConfig();
-    if (Option.isNone(value) || value.value === false) {
-        return Option.none();
-    }
-    return Option.some(resolveInstructionsConfig(value.value));
-});
-export const instructionStateIsCurrent = (snapshot) => snapshot.status.missingSources.length === 0 && instructionProjectionIsCurrent(snapshot);
-export const instructionReconciliationReadiness = Effect.fn("Instructions.reconciliationReadiness")(function* (args) {
-    return yield* Effect.result(Effect.all([
-        assertInstructionTargetsSafe(args.snapshot.status),
-        assertInstructionsGitignoreSafe(args.ws.baseDir),
-    ], { concurrency: 1, discard: true })).pipe(Effect.map((result) => result._tag === "Success"
-        ? Option.none()
-        : Option.some(result.failure)));
-});
-/**
- * Remove every alias the given configuration owns, observing fresh so the
- * decision reflects the workspace at the moment of removal. Used before a new
- * configuration is reconciled, so a changed source filename or alias policy
- * never leaves the old arrangement behind. Refuses on an unowned target like
- * every other path.
- */
-export const removeInstructionTargetsFor = (args) => Effect.gen(function* () {
-    const snapshot = yield* observeInstructions(args);
-    return yield* removeManagedInstructionTargets({ snapshot, dryRun: false });
-});
-/**
- * Runs inside the workspace transaction: preflight against a fresh
- * observation (the plan's readiness check ran before the transaction opened),
- * apply the transition, reconcile, and verify from the sync's own readback.
- */
-export const reconcileInstructionTransition = (args) => Effect.gen(function* () {
-    const agents = yield* configuredAgents(args.ws);
-    const preflight = yield* observeInstructions({
-        ws: args.ws,
-        config: args.preflightConfig ?? args.config,
-    });
-    yield* assertInstructionTargetsSafe(preflight.status);
-    yield* assertInstructionsGitignoreSafe(args.ws.baseDir);
-    const transitionResult = yield* args.transition;
-    const syncResult = yield* syncInstructions({
-        workspaceRoot: args.ws.baseDir,
-        scope: args.ws.scope,
-        configuredAgents: agents,
-        config: args.config,
-        dryRun: false,
-    });
-    if (!instructionProjectionIsCurrent(syncResult.snapshot)) {
-        return yield* new WorkspaceConfigurationFailed({
-            category: "internal",
-            detail: "Instruction reconciliation did not reach the desired state",
-        });
-    }
-    return transitionResult;
-}).pipe(Effect.withSpan("Instructions.reconcileTransition"));
-export const disableInstructionManagement = Effect.fn("Instructions.disableManagement")(function* (args) {
-    yield* assertInstructionsGitignoreSafe(args.ws.baseDir);
-    const removed = yield* removeInstructionTargetsFor(args);
-    const gitignore = yield* removeInstructionsGitignore({
-        workspaceRoot: args.ws.baseDir,
-        dryRun: false,
-    });
-    yield* args.ws.setInstructionsConfig(false);
-    return {
-        removed,
-        gitignore: Option.getOrUndefined(gitignore),
-    };
-});
-//# sourceMappingURL=instruction-reconciliation.js.map

package/dist/src/mcp-import.d.ts

@@ -1,40 +0,0 @@
-/**
- * Inline MCP adoption policy: discover import sources from configured agents'
- * native MCP configs, rewrite adopted entries with AXM management metadata,
- * remove entries converted into managed packages, and apply an inline import
- * as one validated workspace transaction. Prompting, planning, and rendering
- * stay with the application.
- *
- * @experimental This API is unstable and may change without notice.
- */
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import * as Path from "effect/Path";
-import { type WorkspaceMutationsService } from "@agentxm/workspace-state";
-import { WorkspaceConfigurationFailed } from "./errors.js";
-import type { McpImportAdoption, McpImportCandidate, McpImportSource } from "./mcp-import-preflight.js";
-/**
- * Discover the native MCP config sources the configured agents contribute for
- * this workspace scope, with unsupported-format findings.
- */
-export declare const collectMcpImportSources: (ws: WorkspaceMutationsService, fs: FileSystem.FileSystem, path: Path.Path) => Effect.Effect<{
-    sources: McpImportSource[];
-    skipped: {
-        readonly name: string;
-        readonly reason: string;
-    }[];
-}, WorkspaceConfigurationFailed | import("@agentxm/workspace-state").WorkspaceSettingsReadFailure, never>;
-/**
- * Remove a native entry converted into a managed package, refusing when the
- * native config changed since the conversion was planned.
- */
-export declare const removeConvertedMcpConfig: (fs: FileSystem.FileSystem, adoption: McpImportAdoption) => Effect.Effect<void, WorkspaceConfigurationFailed>;
-/**
- * Adopt the losslessly importable candidates as inline settings entries and
- * mark their native entries as AXM-managed, in one validated workspace
- * transaction.
- */
-export declare const applyMcpImport: <HookError = never>(candidates: ReadonlyArray<McpImportCandidate>, ws: WorkspaceMutationsService, fs: FileSystem.FileSystem, hooks?: {
-    readonly beforeAdoptionWrite?: (adoption: McpImportAdoption) => Effect.Effect<void, HookError>;
-}) => Effect.Effect<void, WorkspaceConfigurationFailed | import("@agentxm/workspace-state").WorkspaceSnapshotError | import("@agentxm/workspace-state").SettingsWriteError | import("@agentxm/workspace-state").WorkspaceRootEscape | import("@agentxm/workspace-state").SettingsIoError | import("@agentxm/workspace-state").SettingsParseError | import("@agentxm/workspace-state").SettingsDecodeError | import("@agentxm/workspace-state").WorkspaceDirectoryError | import("@agentxm/workspace-state").TransitionLockError | import("@agentxm/workspace-state").TransitionLockUnavailable | import("@agentxm/workspace-state").WorkspaceTransitionCompromised | import("@agentxm/workspace-state").WorkspaceRestorationIncomplete | HookError, never>;
-//# sourceMappingURL=mcp-import.d.ts.map

package/dist/src/membership.d.ts

@@ -1,29 +0,0 @@
-/**
- * Configured-agent membership policy: agent-id validation for membership
- * changes and the atomic application of membership and materialization steps
- * through one workspace transaction. The application supplies the failure
- * conversion so step categories and details stay byte-identical with its
- * rendered errors.
- *
- * @experimental This API is unstable and may change without notice.
- */
-import * as Effect from "effect/Effect";
-import { StepFailure, type JobStepResult, type PlannedJobStep } from "@agentxm/workspace-operations";
-import type { WorkspaceMutationsService } from "@agentxm/workspace-state";
-import { WorkspaceConfigurationFailed } from "./errors.js";
-export declare const dedupe: (values: ReadonlyArray<string>) => ReadonlyArray<string>;
-export declare const validateAgentIds: (ids: ReadonlyArray<string>) => Effect.Effect<ReadonlyArray<string>, WorkspaceConfigurationFailed>;
-interface AtomicMembershipStepsArgs<Requirements, Output, ValidateError> {
-    readonly ws: WorkspaceMutationsService;
-    readonly steps: ReadonlyArray<PlannedJobStep<Requirements, Output>>;
-    readonly validate: (results: ReadonlyArray<JobStepResult<Output>>) => Effect.Effect<void, ValidateError, Requirements>;
-    /** Application-owned conversion into the plan-step failure vocabulary. */
-    readonly toStepFailure: (failure: unknown) => StepFailure;
-}
-/**
- * Keep plan-level preview and per-step results while applying every membership
- * and artifact step through one workspace transaction.
- */
-export declare const makeAtomicMembershipSteps: <Requirements, Output, ValidateError>(args: AtomicMembershipStepsArgs<Requirements, Output, ValidateError>) => Effect.Effect<readonly PlannedJobStep<Requirements, Output>[], never, never>;
-export {};
-//# sourceMappingURL=membership.d.ts.map

package/dist/src/membership.js

@@ -1,162 +0,0 @@
-/**
- * Configured-agent membership policy: agent-id validation for membership
- * changes and the atomic application of membership and materialization steps
- * through one workspace transaction. The application supplies the failure
- * conversion so step categories and details stay byte-identical with its
- * rendered errors.
- *
- * @experimental This API is unstable and may change without notice.
- */
-import * as Effect from "effect/Effect";
-import * as Ref from "effect/Ref";
-import { HOSTED_AGENTS_BY_ID, HOSTED_AGENT_IDS, } from "@agentxm/extension-model/unstable/agent-capabilities";
-import { CONFIGURABLE_AGENT_IDS } from "@agentxm/extension-model/unstable/agents/types";
-import { StepFailure, } from "@agentxm/workspace-operations";
-import { WorkspaceConfigurationFailed } from "./errors.js";
-const configurableAgentIds = new Set(CONFIGURABLE_AGENT_IDS);
-const hostedAgentIds = new Set(HOSTED_AGENT_IDS);
-const isHostedAgentId = (id) => hostedAgentIds.has(id);
-const numberAt = (values, index) => values[index] ?? 0;
-const editDistance = (left, right) => {
-    const previous = Array.from({ length: right.length + 1 }, (_value, index) => index);
-    for (let leftIndex = 0; leftIndex < left.length; leftIndex += 1) {
-        const current = [leftIndex + 1];
-        for (let rightIndex = 0; rightIndex < right.length; rightIndex += 1) {
-            const substitutionCost = left[leftIndex] === right[rightIndex] ? 0 : 1;
-            current[rightIndex + 1] = Math.min(numberAt(current, rightIndex) + 1, numberAt(previous, rightIndex + 1) + 1, numberAt(previous, rightIndex) + substitutionCost);
-        }
-        previous.splice(0, previous.length, ...current);
-    }
-    return previous[right.length] ?? left.length;
-};
-const nearestAgentId = (input) => {
-    let best;
-    for (const id of CONFIGURABLE_AGENT_IDS) {
-        const distance = editDistance(input, id);
-        if (best === undefined || distance < best.distance) {
-            best = { id, distance };
-        }
-    }
-    if (best === undefined)
-        return undefined;
-    return best.distance <= Math.max(3, Math.floor(input.length / 2)) ? best.id : undefined;
-};
-export const dedupe = (values) => Array.from(new Set(values));
-export const validateAgentIds = (ids) => Effect.gen(function* () {
-    for (const id of ids) {
-        if (id === "universal") {
-            return yield* new WorkspaceConfigurationFailed({
-                category: "validation",
-                detail: "`universal` is always materialized automatically and cannot be added or removed.",
-                suggestions: [{ description: "Choose one of the configurable coding-agent IDs." }],
-            });
-        }
-        if (isHostedAgentId(id)) {
-            const agent = HOSTED_AGENTS_BY_ID[id];
-            return yield* new WorkspaceConfigurationFailed({
-                category: "validation",
-                detail: `${agent.name} is a hosted agent and cannot be added to local workspace configuration. ${agent.installTarget.instructions}`,
-                suggestions: [
-                    {
-                        description: `Open the ${agent.name} skill installation guide.`,
-                        url: agent.installTarget.docs,
-                    },
-                ],
-            });
-        }
-        if (!configurableAgentIds.has(id)) {
-            const nearest = nearestAgentId(id);
-            return yield* new WorkspaceConfigurationFailed({
-                category: "validation",
-                detail: `Unknown agent ID: ${id}`,
-                suggestions: [
-                    nearest === undefined
-                        ? { description: "Inspect supported agent IDs.", cmd: "axm agents list --available" }
-                        : {
-                            description: `Did you mean "${nearest}"?`,
-                            cmd: `axm agents add ${nearest}`,
-                        },
-                ],
-            });
-        }
-    }
-    return dedupe(ids);
-});
-const failedResult = (error, message = error.detail) => ({
-    result: "error",
-    message,
-    error,
-});
-const blockedResult = (message) => failedResult(new StepFailure({
-    category: "conflict",
-    detail: message,
-}), message);
-const rollbackResults = (executable, attempt, transactionError) => {
-    const actualFailureIndex = attempt.failedIndex ?? Math.max(0, attempt.results.length - 1);
-    const failedLabel = executable[actualFailureIndex]?.label ?? "atomic agent membership validation";
-    return executable.map((_, index) => {
-        if (index < actualFailureIndex) {
-            return blockedResult(`blocked: rolled back after ${failedLabel} failed`);
-        }
-        if (index > actualFailureIndex) {
-            return blockedResult(`blocked by ${failedLabel} failure`);
-        }
-        const attempted = attempt.results[index];
-        return attempted?.result === "error"
-            ? attempted
-            : failedResult(transactionError, transactionError.detail);
-    });
-};
-/**
- * Keep plan-level preview and per-step results while applying every membership
- * and artifact step through one workspace transaction.
- */
-export const makeAtomicMembershipSteps = Effect.fn("Agents.makeAtomicMembershipSteps")(function* (args) {
-    if (args.steps.some((step) => step.readiness === "error"))
-        return args.steps;
-    const executable = args.steps.filter((step) => step.readiness !== "error");
-    const attemptRef = yield* Ref.make({ results: [] });
-    const transition = args.ws
-        .runTransaction({
-        transition: Effect.gen(function* () {
-            const results = [];
-            for (const [index, step] of executable.entries()) {
-                const result = yield* step.run.pipe(Effect.catch((error) => Effect.succeed(failedResult(error))));
-                results.push(result);
-                yield* Ref.set(attemptRef, {
-                    results: [...results],
-                    ...(result.result === "error" ? { failedIndex: index } : {}),
-                });
-                if (result.result === "error") {
-                    return yield* result.error;
-                }
-            }
-            return results;
-        }),
-        validate: (results) => args.validate(results).pipe(Effect.mapError(args.toStepFailure)),
-    })
-        .pipe(Effect.catch((transactionError) => Ref.get(attemptRef).pipe(Effect.map((attempt) => rollbackResults(executable, attempt, transactionError._tag === "StepFailure"
-        ? transactionError
-        : args.toStepFailure(transactionError))))));
-    const sharedTransition = yield* Effect.cached(transition);
-    let resultIndex = 0;
-    return args.steps.map((step) => {
-        if (step.readiness === "error")
-            return step;
-        const index = resultIndex;
-        resultIndex += 1;
-        return {
-            ...step,
-            run: sharedTransition.pipe(Effect.flatMap((results) => {
-                const result = results[index];
-                return result === undefined
-                    ? new StepFailure({
-                        category: "internal",
-                        detail: `Atomic agent membership transition omitted step ${index + 1}`,
-                    })
-                    : Effect.succeed(result);
-            })),
-        };
-    });
-});
-//# sourceMappingURL=membership.js.map