@agentxm/extension-lifecycle 0.28.4 → 0.28.6

package/dist/src/workflows/install-command/workflow.js

@@ -7,8 +7,7 @@
  * @experimental This API is unstable and may change without notice.
  */
 import * as Effect from "effect/Effect";
-import { previewOrApplyPlan } from "@agentxm/workspace-operations";
-import { LifecycleResolutionProgress } from "../../resolution-progress.js";
+import { observeUnit, previewOrApplyPlan, publishPhaseStarted, } from "@agentxm/workspace-operations";
 // -----------------------------------------------------------------------------
 // Install Command Workflow
 // -----------------------------------------------------------------------------
@@ -20,8 +19,10 @@ import { LifecycleResolutionProgress } from "../../resolution-progress.js";
  */
 export const buildInstallCommandPlan = (args, actions, options) => Effect.gen(function* () {
     const parsed = yield* actions.parseArgs(args);
-    const sourceRequests = yield* actions.resolveSourceRequests(parsed);
-    const refs = yield* actions.discoverRefs(sourceRequests);
+    // Source resolution is the first lifecycle phase: requested sources become
+    // concrete refs, observed as one unit under `resolution`.
+    yield* publishPhaseStarted("resolution");
+    const refs = yield* observeUnit({ id: "extension-sources", label: "extension sources" }, Effect.flatMap(actions.resolveSourceRequests(parsed), (sourceRequests) => actions.discoverRefs(sourceRequests)));
     const finalizedIntent = yield* actions.finalizeIntent(parsed, refs);
     const intent = options?.transformIntent?.(finalizedIntent) ?? finalizedIntent;
     const plan = yield* actions.buildPlan(intent);
@@ -34,8 +35,7 @@ export const buildInstallCommandPlan = (args, actions, options) => Effect.gen(fu
  * finalizeIntent -> buildPlan -> previewOrApplyPlan.
  */
 export const runInstallCommandWorkflow = (args, actions, options) => Effect.gen(function* () {
-    const progress = yield* LifecycleResolutionProgress;
-    const plan = yield* progress.withSourceResolution(buildInstallCommandPlan(args, actions, options));
+    const plan = yield* buildInstallCommandPlan(args, actions, options);
     return yield* previewOrApplyPlan(plan, { execution: options.execution });
 }).pipe(Effect.scoped, Effect.map((resolution) => resolution));
 //# sourceMappingURL=workflow.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentxm/extension-lifecycle",
-  "version": "0.28.4",
+  "version": "0.28.6",
   "description": "AXM extension-lifecycle feature: install, update, uninstall, enable, and disable policy across root and type-specific command forms for the axm CLI. Unstable and unsupported — use the axm.sh CLI.",
   "type": "module",
   "license": "FSL-1.1-MIT",
@@ -18,10 +18,12 @@
   "exports": {
     ".": {
       "types": "./dist/src/index.d.ts",
+      "axm-source": "./src/index.ts",
       "default": "./dist/src/index.js"
     },
     "./live": {
       "types": "./dist/src/live.d.ts",
+      "axm-source": "./src/live.ts",
       "default": "./dist/src/live.js"
     }
   },
@@ -41,13 +43,13 @@
   "dependencies": {
     "effect": "4.0.0-rc.112",
     "semver": "^7.8.5",
-    "@agentxm/extension-model": "^0.28.4",
-    "@agentxm/extension-sources": "^0.28.4",
-    "@agentxm/registry-protocol": "^0.28.4",
-    "@agentxm/workspace-operations": "^0.28.4",
-    "@agentxm/workspace-state": "^0.28.4",
-    "@agentxm/registry-client": "^0.28.4",
-    "@agentxm/extension-workspace": "^0.28.4"
+    "@agentxm/extension-sources": "^0.28.6",
+    "@agentxm/extension-model": "^0.28.6",
+    "@agentxm/extension-workspace": "^0.28.6",
+    "@agentxm/registry-client": "^0.28.6",
+    "@agentxm/workspace-operations": "^0.28.6",
+    "@agentxm/workspace-state": "^0.28.6",
+    "@agentxm/registry-protocol": "^0.28.6"
   },
   "devDependencies": {
     "@effect/platform-node": "4.0.0-rc.112",

package/dist/src/resolution-progress.d.ts

@@ -1,18 +0,0 @@
-/**
- * Presentation port for the source-resolution phase of lifecycle workflows.
- * The feature marks where progress feedback belongs; the application owns the
- * mechanism and wording (the CLI renders a spinner around the phase).
- *
- * @experimental This API is unstable and may change without notice.
- */
-import * as ServiceMap from "effect/Context";
-import type * as Effect from "effect/Effect";
-export interface LifecycleResolutionProgressService {
-    /** Surround the source-resolution phase with the application's progress feedback. */
-    readonly withSourceResolution: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
-}
-declare const LifecycleResolutionProgress_base: ServiceMap.ServiceClass<LifecycleResolutionProgress, "@agentxm/extension-lifecycle/resolution-progress/LifecycleResolutionProgress", LifecycleResolutionProgressService>;
-export declare class LifecycleResolutionProgress extends LifecycleResolutionProgress_base {
-}
-export {};
-//# sourceMappingURL=resolution-progress.d.ts.map

package/dist/src/resolution-progress.js

@@ -1,11 +0,0 @@
-/**
- * Presentation port for the source-resolution phase of lifecycle workflows.
- * The feature marks where progress feedback belongs; the application owns the
- * mechanism and wording (the CLI renders a spinner around the phase).
- *
- * @experimental This API is unstable and may change without notice.
- */
-import * as ServiceMap from "effect/Context";
-export class LifecycleResolutionProgress extends ServiceMap.Service()("@agentxm/extension-lifecycle/resolution-progress/LifecycleResolutionProgress") {
-}
-//# sourceMappingURL=resolution-progress.js.map

package/dist/src/skills/operations/uninstall.d.ts

@@ -1,40 +0,0 @@
-/**
- * Uninstall skill executor — orchestrates per-skill removal pipeline.
- *
- * Pipeline: resolve desired/observed state -> remove agent artifacts
- * concurrently -> remove canonical source -> clear settings and accepted resolution.
- *
- * @experimental This API is unstable and may change without notice.
- */
-import * as FileSystem from "effect/FileSystem";
-import * as Path from "effect/Path";
-import { LifecycleFailureAdapter } from "../../failure-adapter.js";
-import type { OperationHandler } from "@agentxm/workspace-operations";
-import type { Operation } from "@agentxm/workspace-operations";
-import { WorkspaceMutations } from "@agentxm/workspace-state";
-/**
- * Args for the uninstall-skill operation.
- */
-export interface UninstallSkillOperationArgs {
-    readonly skillName: string;
-    /** Agent filter for partial uninstall. Empty = all agents. */
-    readonly agents: ReadonlyArray<string>;
-}
-/**
- * Remove a skill from the workspace.
- *
- * @experimental This API is unstable and may change without notice.
- */
-export type UninstallSkillOperation = Operation<"uninstall-skill", UninstallSkillOperationArgs>;
-/**
- * Uninstall-skill operation handler.
- *
- * Reads workspace paths from the WorkspaceMutations service, then orchestrates:
- * 1. Sanitize skill name for filesystem
- * 2. Resolve configured and observed state
- * 3. Remove agent symlinks concurrently (skip missing)
- * 4. Remove from all known canonical locations (full uninstall only)
- * 5. Remove or update settings and accepted resolution
- */
-export declare const uninstallSkill: OperationHandler<UninstallSkillOperation, FileSystem.FileSystem | Path.Path | WorkspaceMutations | LifecycleFailureAdapter>;
-//# sourceMappingURL=uninstall.d.ts.map

package/dist/src/skills/operations/uninstall.js

@@ -1,157 +0,0 @@
-/**
- * Uninstall skill executor — orchestrates per-skill removal pipeline.
- *
- * Pipeline: resolve desired/observed state -> remove agent artifacts
- * concurrently -> remove canonical source -> clear settings and accepted resolution.
- *
- * @experimental This API is unstable and may change without notice.
- */
-import * as FileSystem from "effect/FileSystem";
-import * as Path from "effect/Path";
-import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
-import * as Layer from "effect/Layer";
-import { DefaultCodingAgentRepository } from "@agentxm/extension-workspace";
-import { AGENTS } from "@agentxm/extension-model/unstable/agents/registry";
-import { ExtensionLifecycleFailed } from "../../errors.js";
-import { LifecycleFailureAdapter, withAdaptedStepFailures } from "../../failure-adapter.js";
-import { WorkspaceMutations } from "@agentxm/workspace-state";
-import { removeIfExists } from "@agentxm/workspace-state";
-import { sanitizeName } from "@agentxm/workspace-state";
-import { acceptedCanonicalObservation, acceptedLockedCanonicalPath, removableAcceptedCanonicalPath, } from "@agentxm/workspace-state";
-// Operation types
-// -----------------------------------------------------------------------------
-const isKnownAgentId = (id) => Object.hasOwn(AGENTS, id);
-// -----------------------------------------------------------------------------
-// Public API
-// -----------------------------------------------------------------------------
-/**
- * Uninstall-skill operation handler.
- *
- * Reads workspace paths from the WorkspaceMutations service, then orchestrates:
- * 1. Sanitize skill name for filesystem
- * 2. Resolve configured and observed state
- * 3. Remove agent symlinks concurrently (skip missing)
- * 4. Remove from all known canonical locations (full uninstall only)
- * 5. Remove or update settings and accepted resolution
- */
-export const uninstallSkill = (op) => Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem;
-    const path = yield* Path.Path;
-    const ws = yield* WorkspaceMutations;
-    const base = ws.baseDir;
-    const fsPathLayer = Layer.mergeAll(Layer.succeed(FileSystem.FileSystem, fs), Layer.succeed(Path.Path, path));
-    const sanitizedName = sanitizeName(op.args.skillName);
-    const desired = yield* ws.getDesiredStateGraph();
-    if (!desired.complete) {
-        return yield* new ExtensionLifecycleFailed({
-            category: "conflict",
-            detail: "Cannot uninstall the skill while the desired extension graph is incomplete.",
-            recover: "Repair or reinstall the configured packs, then retry.",
-        });
-    }
-    const desiredNode = desired.nodes.find((node) => node.type === "skill" && node.name === op.args.skillName);
-    const acceptedCanonical = yield* acceptedCanonicalObservation({
-        workspace: ws,
-        type: "skill",
-        name: op.args.skillName,
-    });
-    const lockedCanonical = yield* acceptedLockedCanonicalPath({
-        workspace: ws,
-        type: "skill",
-        name: op.args.skillName,
-    });
-    const removableCanonical = Option.orElse(removableAcceptedCanonicalPath(acceptedCanonical), () => lockedCanonical);
-    const installedOnDisk = yield* Option.match(removableCanonical, {
-        onNone: () => Effect.succeed(false),
-        onSome: (canonicalPath) => fs.exists(canonicalPath).pipe(Effect.catch(() => Effect.succeed(false))),
-    });
-    if (desiredNode === undefined && !installedOnDisk) {
-        return { result: "success", message: "not installed" };
-    }
-    // Determine which configured agent artifacts to remove. Per-agent state is
-    // derived from settings and disk rather than persisted in the lockfile.
-    const agentFilter = op.args.agents;
-    const isPartialUninstall = agentFilter.length > 0;
-    const materializationAgents = yield* DefaultCodingAgentRepository.getMaterializationAgents().pipe(Effect.provideService(WorkspaceMutations, ws));
-    const agentsToRemove = isPartialUninstall
-        ? agentFilter
-        : materializationAgents.map((agent) => agent.id);
-    const remainingAgents = materializationAgents
-        .map((agent) => agent.id)
-        .filter((agent) => !agentsToRemove.includes(agent));
-    const agentsById = new Map(materializationAgents.map((agent) => [agent.id, agent]));
-    const resolveAgentArtifactPath = (agentId) => {
-        const configuredAgent = agentsById.get(agentId);
-        const agentEffect = configuredAgent !== undefined
-            ? Effect.succeed(Option.some(configuredAgent))
-            : isKnownAgentId(agentId)
-                ? DefaultCodingAgentRepository.get(agentId).pipe(Effect.map(Option.some))
-                : Effect.succeed(Option.none());
-        return agentEffect.pipe(Effect.flatMap((agentOption) => {
-            if (Option.isNone(agentOption))
-                return Effect.succeed(Option.none());
-            return agentOption.value
-                .resolveEffectiveSkillsDir({ workspaceRoot: base })
-                .pipe(Effect.map((outcome) => outcome._tag === "supported"
-                ? Option.some(path.normalize(path.join(outcome.dir, sanitizedName)))
-                : Option.none()));
-        }), Effect.provide(fsPathLayer));
-    };
-    const retainedArtifactOptions = yield* Effect.forEach(remainingAgents, resolveAgentArtifactPath, { concurrency: "unbounded" });
-    const retainedArtifactPaths = new Set(retainedArtifactOptions.flatMap((artifactPath) => Option.isSome(artifactPath) ? [artifactPath.value] : []));
-    // Remove agent symlinks/copies concurrently using adapter-derived paths.
-    yield* Effect.forEach(agentsToRemove, (agentId) => {
-        const configuredAgent = agentsById.get(agentId);
-        const agentEffect = configuredAgent !== undefined
-            ? Effect.succeed(Option.some(configuredAgent))
-            : isKnownAgentId(agentId)
-                ? DefaultCodingAgentRepository.get(agentId).pipe(Effect.map(Option.some))
-                : Effect.succeed(Option.none());
-        return agentEffect.pipe(Effect.flatMap((agentOption) => {
-            if (Option.isNone(agentOption)) {
-                return Effect.succeed({
-                    _tag: "unsupported",
-                    reason: `Unknown coding agent: ${agentId}`,
-                });
-            }
-            return agentOption.value.resolveEffectiveSkillsDir({ workspaceRoot: base });
-        }), Effect.provide(fsPathLayer), Effect.flatMap((outcome) => outcome._tag === "supported"
-            ? (() => {
-                const artifactPath = path.normalize(path.join(outcome.dir, sanitizedName));
-                return retainedArtifactPaths.has(artifactPath)
-                    ? Effect.void
-                    : fs
-                        .remove(artifactPath, { recursive: true })
-                        .pipe(Effect.catch(() => Effect.void));
-            })()
-            : Effect.void));
-    }, { concurrency: "unbounded" });
-    // Handle partial vs full uninstall
-    if (isPartialUninstall) {
-        const agentList = [...agentsToRemove].join(", ");
-        return {
-            result: "success",
-            message: `Uninstalled ${op.args.skillName} from ${agentList}`,
-        };
-    }
-    const packOwned = desiredNode?.origins.some((origin) => origin.type === "pack") ?? false;
-    if (packOwned) {
-        // Pack still references this skill — remove from settings only, keep lockfile + disk
-        yield* ws.removeSkillFromSettings(op.args.skillName).pipe(Effect.catch(() => Effect.void));
-        return {
-            result: "success",
-            message: `Uninstalled ${op.args.skillName}`,
-        };
-    }
-    // Full uninstall removes only the canonical package proven by accepted authority.
-    if (Option.isSome(removableCanonical))
-        yield* removeIfExists(fs, removableCanonical.value);
-    // Remove from both settings and lockfile (swallow errors on full uninstall)
-    yield* ws.removeSkill(op.args.skillName).pipe(Effect.catch(() => Effect.void));
-    return {
-        result: "success",
-        message: `Uninstalled ${op.args.skillName}`,
-    };
-}).pipe(withAdaptedStepFailures);
-//# sourceMappingURL=uninstall.js.map