@agentxm/extension-lifecycle 0.28.12 → 0.28.13

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

@@ -8,10 +8,11 @@
  */
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
-import { LifecycleFailureAdapter } from "../../failure-adapter.js";
+import { StepFailureConversion } from "../../step-failure-conversion.js";
 import type { OperationHandler } from "@agentxm/workspace-operations";
 import type { Operation } from "@agentxm/workspace-operations";
 import { WorkspaceMutations } from "@agentxm/workspace-state";
+import { WorkspaceTransactionScope } from "@agentxm/workspace-transactions";
 /**
  * Disable a skill (remove files but keep settings/lockfile entry).
  *
@@ -27,5 +28,5 @@ export type DisableSkillOperation = Operation<"disable-skill", {
  * materialized targets, and promotes implicit pack members to a direct disabled
  * preference. Canonical files are preserved for later re-enablement.
  */
-export declare const disableSkill: OperationHandler<DisableSkillOperation, FileSystem.FileSystem | Path.Path | WorkspaceMutations | LifecycleFailureAdapter>;
+export declare const disableSkill: OperationHandler<DisableSkillOperation, FileSystem.FileSystem | Path.Path | WorkspaceMutations | WorkspaceTransactionScope | StepFailureConversion>;
 //# sourceMappingURL=disable.d.ts.map

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

@@ -12,14 +12,15 @@ import * as Array from "effect/Array";
 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 { DefaultCodingAgentRepository } from "@agentxm/workspace-projection";
 import { ExtensionLifecycleFailed } from "../../errors.js";
-import { LifecycleFailureAdapter, withAdaptedStepFailures } from "../../failure-adapter.js";
+import { StepFailureConversion, withAdaptedStepFailures } from "../../step-failure-conversion.js";
 import { WorkspaceMutations } from "@agentxm/workspace-state";
+import { WorkspaceTransactionScope, runWorkspaceTransaction, } from "@agentxm/workspace-transactions";
 import { sanitizeName } from "@agentxm/workspace-state";
-import { skillArtifactFromTargets, } from "@agentxm/extension-workspace";
+import { skillArtifactFromTargets, } from "@agentxm/extension-materialization";
 import { installedRowsByName } from "@agentxm/workspace-state";
-import { removeSkillAgentArtifact } from "../materialization.js";
+import { removeSkillAgentArtifact } from "@agentxm/extension-materialization";
 // -----------------------------------------------------------------------------
 // Public API
 // -----------------------------------------------------------------------------
@@ -50,7 +51,7 @@ export const disableSkill = (op) => Effect.gen(function* () {
     const desiredBeforeDisable = graph.nodes.find((node) => node.type === "skill" && node.name === op.args.skillName);
     const sanitizedName = sanitizeName(op.args.skillName);
     const materializationAgents = yield* DefaultCodingAgentRepository.getMaterializationAgents().pipe(Effect.provideService(WorkspaceMutations, ws));
-    const installableTargetOptions = yield* ws.runTransaction({
+    const installableTargetOptions = yield* runWorkspaceTransaction({
         transition: Effect.gen(function* () {
             if (isImplicit) {
                 const source = desiredBeforeDisable?.source ?? Option.getOrElse(installed.source, () => undefined);
@@ -72,12 +73,7 @@ export const disableSkill = (op) => Effect.gen(function* () {
             return yield* Effect.forEach(materializationAgents, (agent) => agent.resolveEffectiveSkillsDir({ workspaceRoot: base }).pipe(Effect.provide(fsPathLayer), Effect.flatMap((outcome) => outcome._tag === "supported"
                 ? Effect.gen(function* () {
                     const targetDir = path.normalize(outcome.dir);
-                    yield* removeSkillAgentArtifact({
-                        fs,
-                        pathService: path,
-                        targetDir,
-                        sanitizedName,
-                    });
+                    yield* removeSkillAgentArtifact({ targetDir, sanitizedName });
                     return Option.some({
                         agentId: agent.id,
                         targetDir,

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

@@ -8,10 +8,11 @@
  */
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
-import { LifecycleFailureAdapter } from "../../failure-adapter.js";
+import { StepFailureConversion } from "../../step-failure-conversion.js";
 import type { OperationHandler } from "@agentxm/workspace-operations";
 import type { Operation } from "@agentxm/workspace-operations";
 import { WorkspaceMutations } from "@agentxm/workspace-state";
+import { WorkspaceTransactionScope } from "@agentxm/workspace-transactions";
 /**
  * Enable a previously disabled skill (re-install files and update state).
  *
@@ -27,5 +28,5 @@ export type EnableSkillOperation = Operation<"enable-skill", {
  * 2. Create agent artifacts.
  * 3. Update settings to set enabled: true.
  */
-export declare const enableSkill: OperationHandler<EnableSkillOperation, FileSystem.FileSystem | Path.Path | WorkspaceMutations | LifecycleFailureAdapter>;
+export declare const enableSkill: OperationHandler<EnableSkillOperation, FileSystem.FileSystem | Path.Path | WorkspaceMutations | WorkspaceTransactionScope | StepFailureConversion>;
 //# sourceMappingURL=enable.d.ts.map

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

@@ -11,13 +11,14 @@ 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 { DefaultCodingAgentRepository } from "@agentxm/workspace-projection";
 import { ExtensionLifecycleFailed } from "../../errors.js";
-import { LifecycleFailureAdapter, withAdaptedStepFailures } from "../../failure-adapter.js";
+import { StepFailureConversion, withAdaptedStepFailures } from "../../step-failure-conversion.js";
 import { WorkspaceMutations } from "@agentxm/workspace-state";
+import { WorkspaceTransactionScope, runWorkspaceTransaction, } from "@agentxm/workspace-transactions";
 import { sanitizeName } from "@agentxm/workspace-state";
-import { ensureSkillAgentArtifact } from "../materialization.js";
-import { skillArtifactFromTargets, } from "@agentxm/extension-workspace";
+import { ensureSkillAgentArtifact } from "@agentxm/extension-materialization";
+import { skillArtifactFromTargets, } from "@agentxm/extension-materialization";
 import { usableAcceptedCanonicalObservation } from "@agentxm/workspace-state";
 // -----------------------------------------------------------------------------
 // Public API
@@ -35,7 +36,6 @@ export const enableSkill = (op) => Effect.gen(function* () {
     const ws = yield* WorkspaceMutations;
     const base = ws.baseDir;
     const fsPathLayer = Layer.mergeAll(Layer.succeed(FileSystem.FileSystem, fs), Layer.succeed(Path.Path, path));
-    const provide = (effect) => Effect.provide(effect, fsPathLayer);
     const canonical = yield* usableAcceptedCanonicalObservation({
         workspace: ws,
         type: "skill",
@@ -62,7 +62,7 @@ export const enableSkill = (op) => Effect.gen(function* () {
     const skillSrcPath = portable
         ? canonical.value.observation.path
         : path.join(canonical.value.observation.path, "src");
-    const installableTargets = yield* ws.runTransaction({
+    const installableTargets = yield* runWorkspaceTransaction({
         transition: Effect.gen(function* () {
             const resolvedTargets = yield* Effect.forEach(materializationAgents, (agent) => agent.resolveEffectiveSkillsDir({ workspaceRoot: base }).pipe(Effect.provide(fsPathLayer), Effect.map((outcome) => ({ agent, outcome }))), { concurrency: "unbounded" });
             const targets = resolvedTargets.flatMap(({ agent, outcome }) => outcome._tag === "supported"
@@ -85,9 +85,7 @@ export const enableSkill = (op) => Effect.gen(function* () {
                 canonicalSkillSrcPath: skillSrcPath,
                 targetDir: location.targetDir,
                 sanitizedName,
-                pathService: path,
                 baseDir: base,
-                provide,
             }), { concurrency: "unbounded" });
             yield* ws.updateSkillEntry(op.args.skillName, (entry) => ({
                 ...entry,

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

@@ -14,8 +14,8 @@ import type { AgentId } from "@agentxm/extension-model/unstable/agents/types";
 import { type RenderedFilesMap } from "@agentxm/workspace-state";
 import type { SkillExtensionRef } from "@agentxm/extension-model/unstable/extensions/refs/skill";
 import { SourceHostProviders } from "@agentxm/extension-sources";
-import { CodingAgentRepository } from "@agentxm/extension-workspace";
-import { LifecycleFailureAdapter } from "../../failure-adapter.js";
+import { CodingAgentRepository } from "@agentxm/workspace-projection";
+import { StepFailureConversion } from "../../step-failure-conversion.js";
 import type { OperationHandler } from "@agentxm/workspace-operations";
 import type { Operation } from "@agentxm/workspace-operations";
 import type { JobStepArtifactSource } from "@agentxm/workspace-operations";
@@ -43,7 +43,7 @@ export type InstallSkillOperationArgs = {
  */
 export type InstallSkillOperation = Operation<"install-skill", InstallSkillOperationArgs>;
 export declare const gitHostedSkillArtifactSource: (ref: SkillExtensionRef) => JobStepArtifactSource | undefined;
-export { computeSkillSourceHash } from "./source-hash.js";
+export { computeSkillSourceHash } from "@agentxm/extension-materialization";
 /**
  * Build a RenderedFilesMap from per-agent copy-mode install results.
  * Only includes agents where mode === "copy" and success === true.
@@ -63,5 +63,5 @@ export declare const buildRenderedFilesFromResults: (installableTargets: Readonl
  * 2. Update lockfile/settings entry (failures logged as warnings)
  * 3. Compute and return overall result
  */
-export declare const installSkill: OperationHandler<InstallSkillOperation, FileSystem.FileSystem | HttpClient.HttpClient | Path.Path | WorkspaceMutations | SourceHostProviders | CodingAgentRepository | LifecycleFailureAdapter>;
+export declare const installSkill: OperationHandler<InstallSkillOperation, FileSystem.FileSystem | HttpClient.HttpClient | Path.Path | WorkspaceMutations | SourceHostProviders | CodingAgentRepository | StepFailureConversion>;
 //# sourceMappingURL=install.d.ts.map

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

@@ -7,6 +7,7 @@
  * @experimental This API is unstable and may change without notice.
  */
 import * as FileSystem from "effect/FileSystem";
+import { stripFileProtocol } from "@agentxm/registry-client";
 import * as Path from "effect/Path";
 import * as Array from "effect/Array";
 import * as Effect from "effect/Effect";
@@ -14,29 +15,29 @@ import * as Option from "effect/Option";
 import { printSourceParams } from "@agentxm/extension-model/unstable/sources/printer";
 import { printSkillLockSourceLocator } from "@agentxm/workspace-state";
 import { sourceToLockEntry } from "@agentxm/workspace-state";
-import { canReuseInstalledPackage, materializeExternalPackage } from "@agentxm/extension-workspace";
-import { materializeRegistryPackage } from "../../registry-materialization.js";
+import { canReuseInstalledPackage, materializeExternalPackage, } from "@agentxm/extension-materialization";
+import { materializeRegistryPackage } from "@agentxm/extension-materialization";
 import { computePackageContentHash } from "@agentxm/workspace-state";
 import { RenderedFilePathSchema, } from "@agentxm/workspace-state";
 import { computeMaterializedTreeIntegrity } from "@agentxm/workspace-state";
 import * as Schema from "effect/Schema";
 import { SourceHostProviders } from "@agentxm/extension-sources";
-import { CodingAgentRepository, validateAxmSkillCandidate } from "@agentxm/extension-workspace";
-import { stripFileProtocol } from "../../internal/fs-helpers.js";
-import { isPathSafe } from "@agentxm/workspace-state";
+import { CodingAgentRepository } from "@agentxm/workspace-projection";
+import { isPathSafe } from "@agentxm/extension-model/unstable/path-types";
 import { makeWorkspaceRelativeSourcePath } from "@agentxm/extension-model/unstable/path-types";
 import { createSymlink } from "@agentxm/workspace-state";
 import { validatePathSafety } from "@agentxm/workspace-state";
 import { StepFailure } from "@agentxm/workspace-operations";
 import { acceptedRegistryVersionForRef, validateExactResolvedVersion, } from "@agentxm/workspace-state";
 import { ExtensionLifecycleFailed } from "../../errors.js";
-import { LifecycleFailureAdapter, withAdaptedStepFailures } from "../../failure-adapter.js";
+import { StepFailureConversion, withAdaptedStepFailures } from "../../step-failure-conversion.js";
 import { appendWarningsToMessage } from "@agentxm/workspace-operations";
 import { WorkspaceMutations } from "@agentxm/workspace-state";
-import { copyExtensionDirectory, formatCopyExtensionDirectoryFailure, } from "@agentxm/extension-workspace";
-import { artifactAgentIdsFromTargets, artifactTargetAgentIds, groupInstallTargetsByDirectory, } from "@agentxm/extension-workspace";
+import { copyExtensionDirectory, formatCopyExtensionDirectoryFailure, } from "@agentxm/extension-materialization";
+import { artifactAgentIdsFromTargets, artifactTargetAgentIds, groupInstallTargetsByDirectory, } from "@agentxm/extension-materialization";
 import { sanitizeName } from "@agentxm/workspace-state";
-import { computeSkillSourceHash } from "./source-hash.js";
+import { computeSkillSourceHash } from "@agentxm/extension-materialization";
+import { validateAxmSkillCandidate } from "@agentxm/extension-resolution";
 const countFiles = (dir) => Effect.gen(function* () {
     const fs = yield* FileSystem.FileSystem;
     const path = yield* Path.Path;
@@ -134,7 +135,7 @@ export const gitHostedSkillArtifactSource = (ref) => {
 // Shared helpers
 // -----------------------------------------------------------------------------
 const preCleanAndCopy = (sanitizedName, sourcePath, copyTarget) => Effect.gen(function* () {
-    const adapter = yield* LifecycleFailureAdapter;
+    const adapter = yield* StepFailureConversion;
     const fs = yield* FileSystem.FileSystem;
     const ws = yield* WorkspaceMutations;
     const sourceExists = yield* fs
@@ -171,7 +172,7 @@ const preCleanAndCopy = (sanitizedName, sourcePath, copyTarget) => Effect.gen(fu
     })));
 });
 const decodeRenderedFilePath = Schema.decodeUnknownSync(RenderedFilePathSchema);
-export { computeSkillSourceHash } from "./source-hash.js";
+export { computeSkillSourceHash } from "@agentxm/extension-materialization";
 /**
  * Build a RenderedFilesMap from per-agent copy-mode install results.
  * Only includes agents where mode === "copy" and success === true.
@@ -371,7 +372,7 @@ const materializeSkill = (ref, sanitizedName, versionRange, reuse) => {
  * 3. Compute and return overall result
  */
 export const installSkill = (op) => Effect.gen(function* () {
-    const adapter = yield* LifecycleFailureAdapter;
+    const adapter = yield* StepFailureConversion;
     const ws = yield* WorkspaceMutations;
     const path = yield* Path.Path;
     const agentRepo = yield* CodingAgentRepository;

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

@@ -0,0 +1,23 @@
+/**
+ * Uninstalling skills.
+ *
+ * A skill's removal withdraws its projection from every configured agent's
+ * skills directory as well as its canonical package, so the artifact names
+ * both. What the removal actually settled — package removed, retained for a
+ * pack, or already absent — comes from the settlement, not from its sentence.
+ *
+ * @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 { SkillManager } from "@agentxm/extension-materialization";
+import type { Plan } from "@agentxm/workspace-operations";
+import type { ExtensionLifecycleFailed } from "../../errors.js";
+import { type InstallStepRequirements, type ResolveInstallRequirements } from "../../install/vocabulary.js";
+import type { SkillUninstallIntent } from "../../uninstall/vocabulary.js";
+/** Expand the selector against installed skills; a glob may match nothing. */
+export declare const parseSkillUninstallRequest: (selector: string) => Effect.Effect<SkillUninstallIntent, ExtensionLifecycleFailed, InstallStepRequirements | ResolveInstallRequirements>;
+/** The closures a settled skill removal becomes. */
+export declare const planSkillUninstall: (intent: SkillUninstallIntent) => Effect.Effect<Plan<InstallStepRequirements>, ExtensionLifecycleFailed, InstallStepRequirements | SkillManager | FileSystem.FileSystem | Path.Path>;
+//# sourceMappingURL=plan.d.ts.map

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

@@ -0,0 +1,165 @@
+/**
+ * Uninstalling skills.
+ *
+ * A skill's removal withdraws its projection from every configured agent's
+ * skills directory as well as its canonical package, so the artifact names
+ * both. What the removal actually settled — package removed, retained for a
+ * pack, or already absent — comes from the settlement, not from its sentence.
+ *
+ * @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 { SkillManager, buildUninstallOperation, skillArtifactFromTargets, } from "@agentxm/extension-materialization";
+import { resolveInstalledIdentifierNameOrInput } from "@agentxm/extension-sources";
+import { CodingAgentRepository } from "@agentxm/workspace-projection";
+import { WorkspaceMutations, acquiredExtensionDisplayPathFromLockEntry, installedRowsByName, sanitizeName, } from "@agentxm/workspace-state";
+import { expandGlob } from "../../glob.js";
+import { lifecycleStepFailure } from "../../step-failure.js";
+import { installRefused, } from "../../install/vocabulary.js";
+import { makeWorkspaceRetentionPolicy } from "../../uninstall/retention-policy.js";
+import { workspaceAuthoredPath, workspaceCanonicalPath, workspaceCanonicalRoot, workspaceLockfilePath, workspaceSettingsPath, } from "../../workspace-paths.js";
+const skillSourceTarget = (ws, path, configuredSource, lockEntry, sanitizedName) => {
+    if (Option.isSome(configuredSource) && configuredSource.value === "workspace") {
+        return { path: workspaceAuthoredPath(path, ws, "skill", sanitizedName), change: "unchanged" };
+    }
+    if (Option.isSome(lockEntry)) {
+        const entry = lockEntry.value;
+        return {
+            path: acquiredExtensionDisplayPathFromLockEntry(workspaceCanonicalRoot(ws.scope), entry, "skills", entry.workspaceName),
+            change: "removed",
+        };
+    }
+    return { path: workspaceCanonicalPath(ws.scope, sanitizedName), change: "removed" };
+};
+/** Expand the selector against installed skills; a glob may match nothing. */
+export const parseSkillUninstallRequest = Effect.fn("UninstallExtensions.parseSkillRequest")(function* (selector) {
+    const ws = yield* WorkspaceMutations;
+    const installedSkills = yield* ws.records.rows("skill").pipe(Effect.mapError((cause) => installRefused({
+        category: "internal",
+        detail: "Installed skills could not be read",
+        cause,
+    })), Effect.map(installedRowsByName));
+    const installedNames = Object.keys(installedSkills);
+    const matched = expandGlob(selector, installedNames);
+    if (selector.includes("*") && matched.length === 0) {
+        return { targets: [] };
+    }
+    const names = matched.length > 0
+        ? matched
+        : [
+            yield* resolveInstalledIdentifierNameOrInput({
+                input: selector,
+                resourceType: "skill",
+            }).pipe(Effect.mapError((cause) => installRefused({
+                category: "not_found",
+                detail: `Skill "${selector}" could not be resolved`,
+                cause,
+            }))),
+        ];
+    return {
+        targets: names.map((name) => ({ type: "skill", name })),
+    };
+});
+/** The closures a settled skill removal becomes. */
+export const planSkillUninstall = Effect.fn("UninstallExtensions.planSkills")(function* (intent) {
+    const ws = yield* WorkspaceMutations;
+    const skillManager = yield* SkillManager;
+    const agentRepo = yield* CodingAgentRepository;
+    const path = yield* Path.Path;
+    const retentionPolicy = makeWorkspaceRetentionPolicy(ws);
+    const configuredAgents = yield* agentRepo.getMaterializationAgents().pipe(Effect.mapError((cause) => installRefused({
+        category: "internal",
+        detail: "Configured agents could not be read",
+        cause,
+    })));
+    const resolvedAgents = yield* Effect.forEach(configuredAgents, (agent) => agent
+        .resolveEffectiveSkillsDir({ workspaceRoot: ws.baseDir })
+        .pipe(Effect.map((outcome) => ({ agentId: agent.id, outcome }))), { concurrency: "unbounded" }).pipe(Effect.mapError((cause) => installRefused({
+        category: "internal",
+        detail: "Configured skill placement could not be resolved",
+        cause,
+    })));
+    const installableTargets = [];
+    for (const { agentId, outcome } of resolvedAgents) {
+        if (outcome._tag === "supported") {
+            installableTargets.push({ agentId, targetDir: path.normalize(outcome.dir) });
+        }
+    }
+    const steps = yield* Effect.forEach(intent.targets, (target) => Effect.gen(function* () {
+        const sanitizedName = sanitizeName(target.name);
+        const configuredSource = skillManager.getConfiguredSource === undefined
+            ? Option.none()
+            : yield* skillManager.getConfiguredSource({ target });
+        const lockEntry = yield* ws
+            .getLockedSkill(target.name)
+            .pipe(Effect.catch(() => Effect.succeed(Option.none())));
+        const sourceTarget = skillSourceTarget(ws, path, configuredSource, lockEntry, sanitizedName);
+        const removedArtifact = yield* skillArtifactFromTargets({
+            targets: installableTargets,
+            workspaceRoot: ws.baseDir,
+            sanitizedName,
+            scope: ws.scope,
+            change: "removed",
+            workspaceTargets: [
+                { path: workspaceLockfilePath(ws.scope), change: "updated" },
+                { path: workspaceSettingsPath(ws.scope), change: "updated" },
+                sourceTarget,
+            ],
+        });
+        // A skill another desired route still reaches keeps its resolution,
+        // its package, and its projections: only the direct declaration goes.
+        const retainedArtifact = yield* skillArtifactFromTargets({
+            targets: installableTargets,
+            workspaceRoot: ws.baseDir,
+            sanitizedName,
+            scope: ws.scope,
+            change: "unchanged",
+            workspaceTargets: [
+                { path: workspaceLockfilePath(ws.scope), change: "unchanged" },
+                { path: workspaceSettingsPath(ws.scope), change: "updated" },
+                { path: sourceTarget.path, change: "unchanged" },
+            ],
+        });
+        const step = buildUninstallOperation(skillManager, retentionPolicy, {
+            target,
+            toStepFailure: lifecycleStepFailure,
+            // The settlement says what the removal withdrew, so a package
+            // retained for a pack — or one that was never there — is reported
+            // from the settlement rather than read out of a sentence.
+            buildArtifact: ({ settlement }) => {
+                if (settlement.declaration === "absent") {
+                    return Effect.succeed({ ...removedArtifact, change: "unchanged" });
+                }
+                if (settlement.canonical === "retained-by-pack" ||
+                    settlement.canonical === "preserved-unreadable") {
+                    // The declaration was withdrawn, so this changed the workspace
+                    // even though nothing on disk was deleted.
+                    return Effect.succeed({ ...retainedArtifact, change: "updated" });
+                }
+                return Effect.succeed(removedArtifact);
+            },
+        });
+        return {
+            ...step,
+            artifact: removedArtifact,
+        };
+    }).pipe(Effect.mapError((cause) => installRefused({
+        category: "internal",
+        detail: `Skill uninstall planning failed for ${target.name}`,
+        cause,
+    }))), { concurrency: "unbounded" });
+    return {
+        _tag: "Plan",
+        name: intent.targets.length === 0
+            ? "Uninstall skills"
+            : intent.targets.length === 1
+                ? "Uninstall skill"
+                : `Uninstall ${intent.targets.length} skills`,
+        description: Option.none(),
+        jobs: [{ concurrency: 1, steps }],
+    };
+});
+//# sourceMappingURL=plan.js.map

package/dist/src/skills/utils.js

@@ -6,7 +6,7 @@
  *
  * @experimental This API is unstable and may change without notice.
  */
-import { stripFileProtocol } from "../internal/fs-helpers.js";
+import { stripFileProtocol } from "@agentxm/registry-client";
 // -----------------------------------------------------------------------------
 // Display Name
 // -----------------------------------------------------------------------------

package/dist/src/step-failure-conversion.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The application-supplied conversion from a lifecycle operation's typed
+ * failure union into the plan-step vocabulary and into display text.
+ *
+ * Error rendering is application-owned: the CLI implements this with the same
+ * dispatcher it uses at its output boundary, so step categories and details
+ * inside lifecycle plans stay byte-identical with rendered errors. Nothing in
+ * the channel is `unknown` — the port names the exact union a lifecycle
+ * operation can surface, so a new failure family is a compile error here
+ * rather than a silently mis-rendered step.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as ServiceMap from "effect/Context";
+import * as Effect from "effect/Effect";
+import type { StepFailure } from "@agentxm/workspace-operations";
+import type { ExtensionManagerFailure } from "@agentxm/extension-materialization";
+import type { ExtensionResolutionFailed } from "@agentxm/extension-resolution";
+import type { ExtensionLifecycleFailed } from "./errors.js";
+/**
+ * Every failure a lifecycle operation can surface: the materialization
+ * families and the integration families they carry, the resolution refusal a
+ * configured entry's source can produce before any plan exists, plus the
+ * feature's own typed failure.
+ */
+export type LifecycleFailure = ExtensionManagerFailure | ExtensionResolutionFailed | ExtensionLifecycleFailed | StepFailure;
+export interface StepFailureConversionService {
+    /** Serialize one lifecycle failure into the plan-step vocabulary. */
+    readonly toStepFailure: (failure: LifecycleFailure) => StepFailure;
+    /** Render one failure as the detail sentence the boundary would print. */
+    readonly describeFailure: (failure: LifecycleFailure) => string;
+    /** Render one failure as the boundary envelope's `message` property. */
+    readonly describeFailureMessage: (failure: LifecycleFailure) => string;
+}
+declare const StepFailureConversion_base: ServiceMap.ServiceClass<StepFailureConversion, "@agentxm/extension-lifecycle/step-failure-conversion/StepFailureConversion", StepFailureConversionService>;
+export declare class StepFailureConversion extends StepFailureConversion_base {
+}
+/**
+ * Serialize every failure of one lifecycle operation into the plan-step
+ * vocabulary through the application-supplied conversion.
+ */
+export declare const withAdaptedStepFailures: <A, E extends LifecycleFailure, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, StepFailure, R | StepFailureConversion>;
+export {};
+//# sourceMappingURL=step-failure-conversion.d.ts.map

package/dist/src/step-failure-conversion.js

@@ -0,0 +1,26 @@
+/**
+ * The application-supplied conversion from a lifecycle operation's typed
+ * failure union into the plan-step vocabulary and into display text.
+ *
+ * Error rendering is application-owned: the CLI implements this with the same
+ * dispatcher it uses at its output boundary, so step categories and details
+ * inside lifecycle plans stay byte-identical with rendered errors. Nothing in
+ * the channel is `unknown` — the port names the exact union a lifecycle
+ * operation can surface, so a new failure family is a compile error here
+ * rather than a silently mis-rendered step.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as ServiceMap from "effect/Context";
+import * as Effect from "effect/Effect";
+export class StepFailureConversion extends ServiceMap.Service()("@agentxm/extension-lifecycle/step-failure-conversion/StepFailureConversion") {
+}
+/**
+ * Serialize every failure of one lifecycle operation into the plan-step
+ * vocabulary through the application-supplied conversion.
+ */
+export const withAdaptedStepFailures = (effect) => Effect.gen(function* () {
+    const conversion = yield* StepFailureConversion;
+    return yield* effect.pipe(Effect.mapError((failure) => conversion.toStepFailure(failure)));
+});
+//# sourceMappingURL=step-failure-conversion.js.map

package/dist/src/step-failure.d.ts

@@ -0,0 +1,29 @@
+/**
+ * How a lifecycle closure serializes a failure into the plan-step vocabulary.
+ *
+ * The feature owns this: a lifecycle step that failed must report the same
+ * category, sentence, and recovery whether the failure came from lifecycle
+ * policy, from the materialization machinery underneath it, from workspace
+ * state, or from the transaction around it. Nothing is supplied by the
+ * application, so a lifecycle use case carries no failure adapter in its
+ * requirements.
+ *
+ * Categories and detail sentences are the serialized contract of machine
+ * output; families that already carry their own category and fact sentence
+ * keep both rather than being replaced with a generic sentence.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import { StepFailure } from "@agentxm/workspace-operations";
+import type { LifecycleFailure } from "./step-failure-conversion.js";
+/** Every failure a lifecycle closure can settle a plan step with. */
+export type LifecycleStepFailure = LifecycleFailure;
+/**
+ * Serialize one lifecycle-closure failure into the plan-step vocabulary.
+ *
+ * Families this feature or the machinery beneath it constructs are rendered
+ * exactly; families the kernel already serializes are delegated to it; and
+ * anything else carries its producer's own category and sentence through.
+ */
+export declare const lifecycleStepFailure: (failure: LifecycleStepFailure) => StepFailure;
+//# sourceMappingURL=step-failure.d.ts.map