@agentxm/extension-authoring 0.30.1 → 0.30.2

package/dist/src/adopt/adopt-extension.d.ts

@@ -8,6 +8,12 @@
  * was never declared becomes enabled — adopting content you cannot see would
  * leave the workspace holding authored work it never materializes.
  *
+ * A package already at its authoring location that nothing declares is
+ * adopted in place: the workspace declares it, enabled, and nothing moves.
+ * In-place adoption refuses when an installed copy of the same identity also
+ * exists, when the workspace already declares the name, and when the authored
+ * manifest is invalid or names a different identity.
+ *
  * `prepare` settles the identity, the destination, and the activation, and
  * writes nothing. `previewOrApply` resolves that same candidate inside the
  * workspace transaction, so a failed move restores both directories.
@@ -17,14 +23,15 @@
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import type * as HttpClient from "effect/unstable/http/HttpClient";
+import * as Option from "effect/Option";
 import * as Path from "effect/Path";
 import { ExtensionManagers, McpSecretStore, type ManagerRequirements } from "@agentxm/extension-materialization";
 import { type RecipeRequirements } from "@agentxm/workspace-reconciliation";
 import { type ExtensionType, type FqnInvalidError, type Handle } from "@agentxm/extension-model/unstable/extensions";
 import { type CandidateFingerprintFailed, type ExecutionCandidate, type PlanExecution } from "@agentxm/workspace-operations";
 import type { CodingAgentRepository } from "@agentxm/workspace-projection";
-import { WorkspaceMutations, type ConfiguredAgentOutcomesProvider, type LockfileValidationError, type WorkspaceLockfileReadFailure, type WorkspaceSettingsReadFailure } from "@agentxm/workspace-state";
-import type { AuthoredPackageError } from "../authored-package-errors.js";
+import { LockfileReader, WorkspaceMutations, type ConfiguredAgentOutcomesProvider, type LockfileValidationError, type WorkspaceLockfileReadFailure, type WorkspaceSettingsReadFailure, type WorkspaceStateReadFailure } from "@agentxm/workspace-state";
+import { type AuthoredPackageError } from "../authored-package-errors.js";
 import { AuthoringFailed } from "../errors.js";
 import { AuthoringScopeUnsupported, type AuthoringOwnerMismatch, type AuthoringOwnerRequired } from "../create/errors.js";
 export interface AdoptExtensionRequest {
@@ -44,9 +51,14 @@ export interface AdoptExtensionCandidate {
     readonly fqn: string;
     readonly owner: Handle;
     readonly name: string;
-    /** Workspace-relative directory the package is moved out of. */
-    readonly acquiredPath: string;
-    /** Workspace-relative directory the package is moved into. */
+    /**
+     * `move` relocates an installed copy into authorship; `in-place` declares a
+     * package already at its authoring location and moves nothing.
+     */
+    readonly mode: "move" | "in-place";
+    /** Workspace-relative directory the package is moved out of, when it moves. */
+    readonly acquiredPath: Option.Option<string>;
+    /** Workspace-relative authoring directory the adopted package occupies. */
     readonly authoredPath: string;
     /** Workspace-relative settings file the declaration is rewritten in. */
     readonly settingsPath: string;
@@ -55,9 +67,9 @@ export interface AdoptExtensionCandidate {
     readonly execution: ExecutionCandidate<AdoptExtensionRequirements>;
 }
 /** Every failure settling an adoption can surface before anything is written. */
-export type AdoptExtensionFailure = AuthoringFailed | AuthoredPackageError | AuthoringOwnerRequired | AuthoringOwnerMismatch | AuthoringScopeUnsupported | LockfileValidationError | WorkspaceLockfileReadFailure | WorkspaceSettingsReadFailure | CandidateFingerprintFailed | FqnInvalidError;
+export type AdoptExtensionFailure = AuthoringFailed | AuthoredPackageError | AuthoringOwnerRequired | AuthoringOwnerMismatch | AuthoringScopeUnsupported | LockfileValidationError | WorkspaceLockfileReadFailure | WorkspaceSettingsReadFailure | WorkspaceStateReadFailure | CandidateFingerprintFailed | FqnInvalidError;
 /** Everything settling an adoption reads before it freezes a candidate. */
-export type PrepareAdoptExtensionRequirements = FileSystem.FileSystem | Path.Path | HttpClient.HttpClient | WorkspaceMutations | ExtensionManagers | ConfiguredAgentOutcomesProvider;
+export type PrepareAdoptExtensionRequirements = FileSystem.FileSystem | Path.Path | HttpClient.HttpClient | WorkspaceMutations | LockfileReader | ExtensionManagers | ConfiguredAgentOutcomesProvider;
 /** The plan an adoption resolves. */
 export declare const adoptExtensionPlanName = "Adopt workspace extension";
 /** Settle an adoption without writing anything. */

package/dist/src/adopt/adopt-extension.js

@@ -8,6 +8,12 @@
  * was never declared becomes enabled — adopting content you cannot see would
  * leave the workspace holding authored work it never materializes.
  *
+ * A package already at its authoring location that nothing declares is
+ * adopted in place: the workspace declares it, enabled, and nothing moves.
+ * In-place adoption refuses when an installed copy of the same identity also
+ * exists, when the workspace already declares the name, and when the authored
+ * manifest is invalid or names a different identity.
+ *
  * `prepare` settles the identity, the destination, and the activation, and
  * writes nothing. `previewOrApply` resolves that same candidate inside the
  * workspace transaction, so a failed move restores both directories.
@@ -23,9 +29,11 @@ import { materializeAuthoredMcpServer } from "@agentxm/workspace-reconciliation"
 import { buildAuthoredExtensionStep, } from "@agentxm/workspace-reconciliation";
 import { extensionTypeToPlural, formatFqn, parseFqn, } from "@agentxm/extension-model/unstable/extensions";
 import { operationPresentation, prepareExecutionCandidate, resolveExecutionCandidate, } from "@agentxm/workspace-operations";
-import { WorkspaceMutations, resolveWorkspaceExtensionRef, } from "@agentxm/workspace-state";
+import { LockfileReader, WorkspaceMutations, observeInstallRoot, resolveWorkspaceExtensionRef, } from "@agentxm/workspace-state";
 import { protectCreatedAncestors } from "@agentxm/workspace-transactions";
+import { CreateDestinationExists } from "@agentxm/extension-materialization";
 import { authoredDeclaration } from "../authored-declaration.js";
+import { CreateDestinationInspectionFailed, } from "../authored-package-errors.js";
 import { preflightCreateOnly } from "../create-preflight.js";
 import { AuthoringFailed } from "../errors.js";
 import { requireAuthoredOwner, settingsRelativePath } from "../create/authoring-owner.js";
@@ -46,6 +54,7 @@ export const prepareAdoptExtension = Effect.fn("AdoptExtension.prepare")(functio
     const fs = yield* FileSystem.FileSystem;
     const path = yield* Path.Path;
     const managers = yield* ExtensionManagers;
+    const locks = yield* LockfileReader;
     const parsed = yield* Effect.fromResult(parseFqn(request.fqn));
     if (ws.layout.scope !== "project") {
         return yield* new AuthoringScopeUnsupported({ subject: "adoption", scope: ws.layout.scope });
@@ -58,6 +67,8 @@ export const prepareAdoptExtension = Effect.fn("AdoptExtension.prepare")(functio
     const acquiredPath = path.relative(ws.baseDir, sourceDir);
     const authoredPath = path.relative(ws.baseDir, targetDir);
     const settingsPath = settingsRelativePath(path, ws);
+    const declaration = authoredDeclaration(ws, parsed.type, name);
+    const current = yield* declaration.read;
     // Refuse an occupied authoring destination here, so a preview refuses it
     // too; the closure repeats the check under the transaction lock.
     const createOnly = preflightCreateOnly({
@@ -66,13 +77,50 @@ export const prepareAdoptExtension = Effect.fn("AdoptExtension.prepare")(functio
         configured: false,
         destinations: [targetDir],
     });
-    yield* createOnly;
-    const declaration = authoredDeclaration(ws, parsed.type, name);
-    const current = yield* declaration.read;
+    // In-place adoption is decided from what is on disk now and repeated under
+    // the transaction lock, so preview and apply refuse the same states.
+    const inPlaceRefusals = Effect.gen(function* () {
+        const inventory = yield* observeInstallRoot({
+            layout: ws.layout,
+            graph: yield* ws.getDesiredStateGraph(),
+            locks,
+        });
+        const installedCopy = inventory.packages.find((entry) => entry.type === parsed.type &&
+            entry.name === name &&
+            (entry.owner === undefined || entry.owner === parsed.owner));
+        // Two copies of one identity leave adoption no single content to author.
+        if (installedCopy !== undefined) {
+            return yield* new CreateDestinationExists({ subject: "Adopt target", path: targetDir });
+        }
+        const declared = yield* declaration.read;
+        if (declared.configured) {
+            return yield* new AuthoringFailed({
+                category: "conflict",
+                detail: `${fqn} is already declared in ${settingsPath}`,
+            });
+        }
+        yield* resolveWorkspaceExtensionRef({
+            settingsName: name,
+            source: "workspace",
+            expectedType: parsed.type,
+            layout: ws.layout,
+            scope: ws.scope,
+            staticPackage: { owner: parsed.owner, name, root: targetDir },
+        }).pipe(Effect.mapError((cause) => new AuthoringFailed({
+            category: "validation",
+            detail: `The authored package at ${authoredPath} is not a valid ${fqn} package`,
+            cause,
+        })));
+    });
+    const authoredExists = yield* fs
+        .exists(targetDir)
+        .pipe(Effect.mapError((cause) => new CreateDestinationInspectionFailed({ path: targetDir, cause })));
+    const mode = authoredExists ? "in-place" : "move";
+    yield* mode === "in-place" ? inPlaceRefusals : createOnly;
     // A package the workspace never declared becomes enabled: adopting content
     // that stays invisible is not what adoption was asked for.
-    const enabled = Option.getOrElse(current.enabled, () => true);
-    const artifact = {
+    const enabled = mode === "in-place" ? true : Option.getOrElse(current.enabled, () => true);
+    const moveArtifact = {
         path: authoredPath,
         scope: ws.scope,
         change: "created",
@@ -82,43 +130,63 @@ export const prepareAdoptExtension = Effect.fn("AdoptExtension.prepare")(functio
             { path: settingsPath, change: "updated" },
         ],
     };
-    const common = {
+    // In-place adoption writes only the declaration; the authored package keeps
+    // every byte, so it is not reported as a changed path.
+    const inPlaceArtifact = {
+        path: settingsPath,
+        scope: ws.scope,
+        change: "updated",
+        targets: [{ path: settingsPath, change: "updated" }],
+    };
+    const shared = {
         toStepFailure: authoringStepFailure,
         location: targetDir,
-        transactionTargets: [sourceDir],
         versionRange: Option.none(),
         label: `Adopt ${fqn}`,
-        message: `Adopted ${fqn}`,
         enabled,
-        allowConfiguredSourceTransition: true,
         markAuthored: Effect.andThen(declaration.retireExternalResolution, declaration.declare({ enabled: true, env: current.env })),
         finalizeAuthored: declaration.declare({ enabled, env: current.env }),
-        plannedArtifact: artifact,
-        buildArtifact: () => Effect.succeed(artifact),
-        preflight: Effect.gen(function* () {
-            yield* createOnly;
-            // The acquired directory must already hold a resolvable package: a move
-            // that lands unreadable content would leave the workspace authoring
-            // something it cannot materialize.
-            yield* resolveWorkspaceExtensionRef({
-                settingsName: name,
-                source: "workspace",
-                expectedType: parsed.type,
-                layout: ws.layout,
-                scope: ws.scope,
-                staticPackage: { owner: parsed.owner, name, root: sourceDir },
-            });
-        }).pipe(Effect.asVoid),
-        scaffold: Effect.gen(function* () {
-            yield* protectCreatedAncestors(fs, path, path.dirname(targetDir));
-            yield* fs.makeDirectory(path.dirname(targetDir), { recursive: true });
-            yield* fs.rename(sourceDir, targetDir);
-        }).pipe(Effect.mapError((cause) => new AuthoringFailed({
-            category: "internal",
-            detail: `Could not move ${fqn} into authored package storage`,
-            cause,
-        }))),
     };
+    const common = mode === "in-place"
+        ? {
+            ...shared,
+            message: `Adopted ${fqn} in place`,
+            plannedArtifact: inPlaceArtifact,
+            buildArtifact: () => Effect.succeed(inPlaceArtifact),
+            preflight: inPlaceRefusals,
+            scaffold: Effect.void,
+        }
+        : {
+            ...shared,
+            message: `Adopted ${fqn}`,
+            transactionTargets: [sourceDir],
+            allowConfiguredSourceTransition: true,
+            plannedArtifact: moveArtifact,
+            buildArtifact: () => Effect.succeed(moveArtifact),
+            preflight: Effect.gen(function* () {
+                yield* createOnly;
+                // The acquired directory must already hold a resolvable package: a move
+                // that lands unreadable content would leave the workspace authoring
+                // something it cannot materialize.
+                yield* resolveWorkspaceExtensionRef({
+                    settingsName: name,
+                    source: "workspace",
+                    expectedType: parsed.type,
+                    layout: ws.layout,
+                    scope: ws.scope,
+                    staticPackage: { owner: parsed.owner, name, root: sourceDir },
+                });
+            }).pipe(Effect.asVoid),
+            scaffold: Effect.gen(function* () {
+                yield* protectCreatedAncestors(fs, path, path.dirname(targetDir));
+                yield* fs.makeDirectory(path.dirname(targetDir), { recursive: true });
+                yield* fs.rename(sourceDir, targetDir);
+            }).pipe(Effect.mapError((cause) => new AuthoringFailed({
+                category: "internal",
+                detail: `Could not move ${fqn} into authored package storage`,
+                cause,
+            }))),
+        };
     const step = (() => {
         switch (parsed.type) {
             case "skill":
@@ -156,7 +224,8 @@ export const prepareAdoptExtension = Effect.fn("AdoptExtension.prepare")(functio
         fqn,
         owner: parsed.owner,
         name,
-        acquiredPath,
+        mode,
+        acquiredPath: mode === "move" ? Option.some(acquiredPath) : Option.none(),
         authoredPath,
         settingsPath,
         enabled,

package/package.json

@@ -4,26 +4,26 @@
     "url": "https://github.com/agentxm/axm/issues"
   },
   "dependencies": {
-    "@agentxm/extension-content": "^0.30.1",
-    "@agentxm/extension-materialization": "^0.30.1",
-    "@agentxm/extension-model": "^0.30.1",
-    "@agentxm/extension-sources": "^0.30.1",
-    "@agentxm/registry-auth": "^0.30.1",
-    "@agentxm/registry-client": "^0.30.1",
-    "@agentxm/workspace-operations": "^0.30.1",
-    "@agentxm/workspace-projection": "^0.30.1",
-    "@agentxm/workspace-reconciliation": "^0.30.1",
-    "@agentxm/workspace-state": "^0.30.1",
-    "@agentxm/workspace-transactions": "^0.30.1",
+    "@agentxm/extension-content": "^0.30.2",
+    "@agentxm/extension-materialization": "^0.30.2",
+    "@agentxm/extension-model": "^0.30.2",
+    "@agentxm/extension-sources": "^0.30.2",
+    "@agentxm/registry-auth": "^0.30.2",
+    "@agentxm/registry-client": "^0.30.2",
+    "@agentxm/workspace-operations": "^0.30.2",
+    "@agentxm/workspace-projection": "^0.30.2",
+    "@agentxm/workspace-reconciliation": "^0.30.2",
+    "@agentxm/workspace-state": "^0.30.2",
+    "@agentxm/workspace-transactions": "^0.30.2",
     "effect": "4.0.0-rc.115",
     "semver": "^7.8.5",
     "yaml": "^2.9.0"
   },
   "description": "AXM extension-authoring feature: new-extension scaffolding, fork, native import, adopt/demote identity policy, and authored pack membership for the axm CLI. Unstable and unsupported — use the axm.sh CLI.",
   "devDependencies": {
-    "@agentxm/agent-integration": "^0.30.1",
-    "@agentxm/extension-resolution": "^0.30.1",
-    "@agentxm/specification-metadata": "^0.30.1",
+    "@agentxm/agent-integration": "^0.30.2",
+    "@agentxm/extension-resolution": "^0.30.2",
+    "@agentxm/specification-metadata": "^0.30.2",
     "@effect/platform-node": "4.0.0-rc.115",
     "@effect/vitest": "4.0.0-rc.115",
     "@types/bun": "^1.3.14",
@@ -65,5 +65,5 @@
   },
   "sideEffects": false,
   "type": "module",
-  "version": "0.30.1"
+  "version": "0.30.2"
 }