@agentxm/workspace-configuration 0.28.4-bootstrap.0

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

@@ -0,0 +1,40 @@
+/**
+ * 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/mcp-import.js

@@ -0,0 +1,276 @@
+/**
+ * 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 Option from "effect/Option";
+import * as Path from "effect/Path";
+import { CONFIGURABLE_AGENTS_BY_ID, } from "@agentxm/extension-model/unstable/agent-capabilities";
+import { buildAxmMcpMetadataFromSettingsSource } from "@agentxm/extension-workspace";
+import { AXM_MCP_METADATA_KEY, isAxmManagedMcpEntry, } from "@agentxm/workspace-state";
+import { WorkspaceConfigurationFailed } from "./errors.js";
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isCapabilityAgentId = (id) => Object.hasOwn(CONFIGURABLE_AGENTS_BY_ID, id);
+const readAgentMcpConfig = (agent) => {
+    if (!isRecord(agent))
+        return Option.none();
+    const capabilities = agent["capabilities"];
+    if (!isRecord(capabilities))
+        return Option.none();
+    const mcp = capabilities["mcp-server"];
+    if (!isRecord(mcp))
+        return Option.none();
+    const axm = mcp["axm"];
+    if (!isRecord(axm))
+        return Option.none();
+    const writer = axm["writer"];
+    if (!isRecord(writer))
+        return Option.none();
+    const config = writer["config"];
+    if (!isRecord(config))
+        return Option.none();
+    const serversKey = config["serversKey"];
+    const targets = config["targets"];
+    if (typeof serversKey !== "string" || !Array.isArray(targets))
+        return Option.none();
+    const parsedTargets = [];
+    for (const target of targets) {
+        if (!isRecord(target))
+            continue;
+        const scope = target["scope"];
+        const targetPath = target["path"];
+        const format = target["format"];
+        if (typeof scope === "string" && typeof targetPath === "string" && typeof format === "string") {
+            parsedTargets.push({ scope, path: targetPath, format });
+        }
+    }
+    return Option.some({ serversKey, targets: parsedTargets });
+};
+const readJsonObject = (fs, filePath) => Effect.gen(function* () {
+    const exists = yield* fs.exists(filePath).pipe(Effect.catch(() => Effect.succeed(false)));
+    if (!exists)
+        return Option.none();
+    const raw = yield* fs.readFileString(filePath).pipe(Effect.mapError((error) => new WorkspaceConfigurationFailed({
+        category: "internal",
+        detail: `Failed to read MCP config: ${filePath}`,
+        cause: error,
+    })));
+    const parsed = yield* Effect.try({
+        try: () => JSON.parse(raw),
+        catch: (cause) => new WorkspaceConfigurationFailed({
+            category: "validation",
+            detail: `Invalid JSON in MCP config: ${filePath}`,
+            cause,
+        }),
+    });
+    return isRecord(parsed) ? Option.some(parsed) : Option.none();
+});
+/**
+ * Discover the native MCP config sources the configured agents contribute for
+ * this workspace scope, with unsupported-format findings.
+ */
+export const collectMcpImportSources = (ws, fs, path) => Effect.gen(function* () {
+    const sources = [];
+    const skipped = new Map();
+    const sourceKeys = new Set();
+    const addSource = (filePath, serversKey, agentId) => {
+        const sourceKey = `${agentId}\0${filePath}\0${serversKey}`;
+        if (sourceKeys.has(sourceKey))
+            return Effect.void;
+        sourceKeys.add(sourceKey);
+        return readJsonObject(fs, filePath).pipe(Effect.map(Option.match({
+            onNone: () => undefined,
+            onSome: (config) => sources.push({ filePath, serversKey, config, agents: [agentId] }),
+        })));
+    };
+    const agentIds = [...(yield* ws.getConfiguredAgents())].sort((left, right) => left.localeCompare(right));
+    for (const agentId of agentIds) {
+        if (!isCapabilityAgentId(agentId))
+            continue;
+        const mcpConfig = readAgentMcpConfig(CONFIGURABLE_AGENTS_BY_ID[agentId]);
+        if (Option.isNone(mcpConfig))
+            continue;
+        const targets = mcpConfig.value.targets
+            .filter((target) => target.scope === ws.scope)
+            .sort((left, right) => left.path.localeCompare(right.path));
+        for (const target of targets) {
+            const relativeTarget = target.path.startsWith("~/") ? target.path.slice(2) : target.path;
+            const configPath = path.resolve(ws.baseDir, relativeTarget);
+            if (target.format !== "json") {
+                const exists = yield* fs
+                    .exists(configPath)
+                    .pipe(Effect.catch(() => Effect.succeed(false)));
+                if (exists) {
+                    const finding = {
+                        name: path.relative(ws.baseDir, configPath),
+                        reason: `Unsupported MCP config format: ${target.format}`,
+                    };
+                    skipped.set(`${finding.name}\0${finding.reason}`, finding);
+                }
+                continue;
+            }
+            yield* addSource(configPath, mcpConfig.value.serversKey, agentId);
+        }
+    }
+    return { sources, skipped: Array.from(skipped.values()) };
+});
+const writeAdoptedMcpConfig = (fs, adoption) => Effect.gen(function* () {
+    const config = yield* readJsonObject(fs, adoption.filePath);
+    if (Option.isNone(config)) {
+        return yield* new WorkspaceConfigurationFailed({
+            category: "conflict",
+            detail: `MCP config disappeared before import: ${adoption.filePath}`,
+        });
+    }
+    const servers = config.value[adoption.serversKey];
+    const entry = isRecord(servers) ? servers[adoption.name] : undefined;
+    if (!isRecord(servers) || !isRecord(entry)) {
+        return yield* new WorkspaceConfigurationFailed({
+            category: "conflict",
+            detail: `MCP server ${adoption.name} changed before import`,
+        });
+    }
+    const updatedConfig = {
+        ...config.value,
+        [adoption.serversKey]: {
+            ...servers,
+            [adoption.name]: {
+                ...entry,
+                [AXM_MCP_METADATA_KEY]: buildAxmMcpMetadataFromSettingsSource("inline", adoption.name),
+            },
+        },
+    };
+    yield* fs
+        .writeFileString(adoption.filePath, `${JSON.stringify(updatedConfig, null, 2)}\n`)
+        .pipe(Effect.mapError((error) => new WorkspaceConfigurationFailed({
+        category: "internal",
+        detail: `Failed to write MCP config: ${adoption.filePath}`,
+        cause: error,
+    })));
+});
+/**
+ * Remove a native entry converted into a managed package, refusing when the
+ * native config changed since the conversion was planned.
+ */
+export const removeConvertedMcpConfig = (fs, adoption) => Effect.gen(function* () {
+    const config = yield* readJsonObject(fs, adoption.filePath);
+    if (Option.isNone(config)) {
+        return yield* new WorkspaceConfigurationFailed({
+            category: "conflict",
+            detail: `MCP config disappeared before package conversion: ${adoption.filePath}`,
+        });
+    }
+    const servers = config.value[adoption.serversKey];
+    if (!isRecord(servers)) {
+        return yield* new WorkspaceConfigurationFailed({
+            category: "conflict",
+            detail: `MCP server collection changed before package conversion: ${adoption.filePath}`,
+        });
+    }
+    const entry = servers[adoption.name];
+    if (entry === undefined)
+        return;
+    if (!isRecord(entry)) {
+        return yield* new WorkspaceConfigurationFailed({
+            category: "conflict",
+            detail: `MCP server ${adoption.name} changed before package conversion`,
+        });
+    }
+    const remainingServers = Object.fromEntries(Object.entries(servers).filter(([name]) => name !== adoption.name));
+    const updatedConfig = {
+        ...config.value,
+        [adoption.serversKey]: remainingServers,
+    };
+    yield* fs
+        .writeFileString(adoption.filePath, `${JSON.stringify(updatedConfig, null, 2)}\n`)
+        .pipe(Effect.mapError((error) => new WorkspaceConfigurationFailed({
+        category: "internal",
+        detail: `Failed to replace native MCP config: ${adoption.filePath}`,
+        cause: error,
+    })));
+});
+const recordsEqual = (left, right) => {
+    const leftEntries = Object.entries(left ?? {}).sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey));
+    const rightEntries = Object.entries(right ?? {}).sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey));
+    return (leftEntries.length === rightEntries.length &&
+        leftEntries.every(([key, value], index) => {
+            const rightEntry = rightEntries[index];
+            return rightEntry !== undefined && key === rightEntry[0] && value === rightEntry[1];
+        }));
+};
+const arraysEqual = (left, right) => JSON.stringify([...(left ?? [])].sort((a, b) => a.localeCompare(b))) ===
+    JSON.stringify([...(right ?? [])].sort((a, b) => a.localeCompare(b)));
+const candidateMatchesSettings = (candidate, entry) => entry !== undefined &&
+    entry.kind === "inline" &&
+    entry.enabled &&
+    entry.command ===
+        (candidate.definition.type === "stdio" ? candidate.definition.command : undefined) &&
+    JSON.stringify(entry.args ?? []) ===
+        JSON.stringify(candidate.definition.type === "stdio" ? candidate.definition.args : []) &&
+    entry.url === (candidate.definition.type === "http" ? candidate.definition.url : undefined) &&
+    recordsEqual(entry.headers, candidate.definition.type === "http" ? candidate.definition.headers : undefined) &&
+    recordsEqual(entry.env, candidate.env) &&
+    arraysEqual(entry.agents, candidate.agents);
+const validateAdoption = (fs, adoption) => Effect.gen(function* () {
+    const config = yield* readJsonObject(fs, adoption.filePath);
+    const servers = Option.isSome(config) ? config.value[adoption.serversKey] : undefined;
+    const entry = isRecord(servers) ? servers[adoption.name] : undefined;
+    if (!isRecord(entry) || !isAxmManagedMcpEntry(entry)) {
+        return yield* new WorkspaceConfigurationFailed({
+            category: "validation",
+            detail: `Failed to validate adopted MCP server ${adoption.name}`,
+        });
+    }
+});
+/**
+ * Adopt the losslessly importable candidates as inline settings entries and
+ * mark their native entries as AXM-managed, in one validated workspace
+ * transaction.
+ */
+export const applyMcpImport = (candidates, ws, fs, hooks = {}) => {
+    const adoptions = candidates.flatMap((candidate) => candidate.adoptions);
+    const settingsEntry = (candidate) => ({
+        kind: "inline",
+        ...(candidate.definition.type === "stdio"
+            ? { command: candidate.definition.command, args: candidate.definition.args }
+            : { url: candidate.definition.url, headers: candidate.definition.headers }),
+        env: candidate.env,
+        enabled: true,
+        ...(candidate.agents === undefined ? {} : { agents: candidate.agents }),
+    });
+    return ws.runTransaction({
+        targets: Array.from(new Set(adoptions.map((adoption) => adoption.filePath))).sort(),
+        transition: Effect.gen(function* () {
+            for (const candidate of candidates) {
+                yield* ws.setMcpServerEntry(candidate.name, settingsEntry(candidate));
+            }
+            for (const adoption of adoptions) {
+                if (hooks.beforeAdoptionWrite !== undefined) {
+                    yield* hooks.beforeAdoptionWrite(adoption);
+                }
+                yield* writeAdoptedMcpConfig(fs, adoption);
+            }
+        }),
+        validate: () => Effect.gen(function* () {
+            const configured = yield* ws.getConfiguredMcpServerEntries();
+            for (const candidate of candidates) {
+                if (!candidateMatchesSettings(candidate, configured[candidate.name])) {
+                    return yield* new WorkspaceConfigurationFailed({
+                        category: "validation",
+                        detail: `Failed to validate imported MCP server ${candidate.name}`,
+                    });
+                }
+            }
+            yield* Effect.forEach(adoptions, (adoption) => validateAdoption(fs, adoption), {
+                concurrency: 1,
+            });
+        }),
+    });
+};
+//# sourceMappingURL=mcp-import.js.map

package/dist/src/membership.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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

@@ -0,0 +1,162 @@
+/**
+ * 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

package/dist/src/testing.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export { WorkspaceInitializationInteractionTest, type WorkspaceInitializationInteractionTestState, } from "./initialization-interaction.js";
+//# sourceMappingURL=testing.d.ts.map

package/dist/src/testing.js

@@ -0,0 +1,9 @@
+/**
+ * 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.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export { WorkspaceInitializationInteractionTest, } from "./initialization-interaction.js";
+//# sourceMappingURL=testing.js.map

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@agentxm/workspace-configuration",
+  "version": "0.28.4-bootstrap.0",
+  "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.",
+  "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/workspace-configuration"
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js"
+    },
+    "./testing": {
+      "types": "./dist/src/testing.d.ts",
+      "default": "./dist/src/testing.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",
+    "@agentxm/extension-sources": "^0.28.4-bootstrap.0",
+    "@agentxm/workspace-state": "^0.28.4-bootstrap.0",
+    "@agentxm/extension-workspace": "^0.28.4-bootstrap.0",
+    "@agentxm/agent-integration": "^0.28.4-bootstrap.0",
+    "@agentxm/workspace-operations": "^0.28.4-bootstrap.0"
+  },
+  "devDependencies": {
+    "@effect/platform-node": "4.0.0-rc.112",
+    "@effect/vitest": "4.0.0-rc.112",
+    "@types/bun": "^1.3.14",
+    "@typescript/native": "npm:typescript@^7.0.2",
+    "typescript": "npm:@typescript/typescript6@^6.0.2",
+    "vitest": "^4.1.10"
+  }
+}