@agentxm/extension-lifecycle 0.28.11 → 0.28.13

package/dist/src/update/selective/subagents.js

@@ -0,0 +1,331 @@
+/**
+ * Advancing the subagents a workspace selected.
+ *
+ * `subagents update` re-resolves each selected, enabled subagent against the
+ * source the workspace declared and advances the ones whose resolution
+ * differs from what was accepted. A subagent that cannot be re-resolved, is
+ * workspace-authored, or is held by the minimum release age is reported as a
+ * skipped unit rather than failing the sweep.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Array from "effect/Array";
+import * as DateTime from "effect/DateTime";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { decodeExtensionNameSync, parseSourceQualifiedRegistrySourcePatternParts, } from "@agentxm/extension-model/unstable/extensions";
+import { isWorkspaceSourceLocator } from "@agentxm/extension-model/unstable/sources/workspace";
+import { buildInstallOperation, SubagentManager } from "@agentxm/extension-materialization";
+import { classifyPublisherBindingTransition, makeConfiguredReleaseAgeEvaluation, normalizeReleaseAgeRecords, publisherTransitionWarning, registryBindingProposal, } from "@agentxm/extension-resolution";
+import { resolveSource, SourceHostProviders } from "@agentxm/extension-sources";
+import { operationPresentation, prepareExecutionCandidate, StepFailure, } from "@agentxm/workspace-operations";
+import { acceptedResolutionRef, configuredRowsByName, WorkspaceMutations, } from "@agentxm/workspace-state";
+import { ExtensionLifecycleFailed } from "../../errors.js";
+import { withPublisherTrustConditions } from "../../publisher-binding.js";
+import { StepFailureConversion } from "../../step-failure-conversion.js";
+import { buildSelectiveUpdatePlan } from "./plan.js";
+import { selectUpdateTargets, } from "./selection.js";
+import { ignoreVersionConstraintsCondition, selectiveUpdatePlanName, } from "./vocabulary.js";
+const PLAN_NAME = selectiveUpdatePlanName("subagent");
+const PLAN_DESCRIPTION = "Update installed subagents";
+const NOTHING_INSTALLED = "No subagents installed.";
+/**
+ * Every selected entry failed to re-resolve: a source-reachability problem,
+ * not a per-entry skip.
+ */
+const allSubagentResolutionsFailed = new ExtensionLifecycleFailed({
+    category: "network",
+    detail: "All matched subagent source re-resolutions failed.",
+    suggestions: [{ description: "Verify the original source paths are still accessible." }],
+});
+const appendWarning = (warning) => (result) => warning === undefined || result.result === "error"
+    ? result
+    : {
+        ...result,
+        message: result.message.length === 0 ? warning : `${result.message}; ${warning}`,
+    };
+const skippedSubagentStep = (scope, outcome) => ({
+    readiness: "ready",
+    label: `Skip ${outcome.name}`,
+    run: Effect.succeed({
+        result: "success",
+        disposition: "skipped",
+        message: outcome.reason,
+        artifact: {
+            path: outcome.source,
+            scope,
+            change: "unchanged",
+            targets: [{ path: outcome.source, change: "unchanged" }],
+        },
+    }),
+});
+const toRegistrySubagentPattern = (source) => {
+    const parsed = parseSourceQualifiedRegistrySourcePatternParts(source);
+    if (parsed === undefined)
+        return Option.none();
+    if (parsed.type !== undefined && parsed.type !== "subagents")
+        return Option.none();
+    return Option.some(parsed);
+};
+const releaseAgeRecord = (args) => ({
+    reason: "minimum-release-age",
+    target: args.target,
+    dependencyPath: [args.target],
+    ...(args.requestedRange === undefined ? {} : { requestedRange: args.requestedRange }),
+    ...(args.selectedVersion === undefined ? {} : { selectedVersion: args.selectedVersion }),
+    candidateVersion: args.evidence.version,
+    publishedAt: args.evidence.publishedAt,
+    eligibleAt: args.evidence.eligibleAt,
+    minimumReleaseAgeSeconds: args.evidence.minimumReleaseAgeSeconds,
+});
+/** Settle a `subagents update` request: decide everything, write nothing. */
+export const prepareSelectiveSubagentUpdate = Effect.fn("SelectiveSubagentUpdate.prepare")(function* (request) {
+    const ws = yield* WorkspaceMutations;
+    const sources = yield* SourceHostProviders;
+    const releaseAgeEvaluation = yield* makeConfiguredReleaseAgeEvaluation();
+    const allSubagents = yield* ws.records.rows("subagent").pipe(Effect.map(configuredRowsByName));
+    const lockedSubagents = yield* ws.getLockedSubagents();
+    const subagentEntries = Object.entries(allSubagents).flatMap(([name, entry]) => entry.enabled && entry.source !== undefined ? [[name, entry.source]] : []);
+    if (subagentEntries.length === 0) {
+        return {
+            outcome: "nothing",
+            reason: "none-installed",
+            message: NOTHING_INSTALLED,
+            subjectType: "subagent",
+            planName: PLAN_NAME,
+            planDescription: PLAN_DESCRIPTION,
+        };
+    }
+    const selection = yield* selectUpdateTargets({
+        entries: subagentEntries,
+        source: request.source,
+        nameFilters: request.nameFilters,
+        nameFilterFlag: request.nameFilterFlag,
+        resourceType: "subagent",
+        resourceLabel: "subagent",
+        resourceLabelPlural: "subagents",
+    });
+    if (selection.kind === "nothing") {
+        return {
+            outcome: "nothing",
+            reason: selection.reason,
+            message: selection.message,
+            subjectType: "subagent",
+            planName: PLAN_NAME,
+            planDescription: PLAN_DESCRIPTION,
+        };
+    }
+    const filteredEntries = selection.entries;
+    const findSubagentRefs = (source, options) => sources
+        .find(source, {
+        names: options.subagentNames,
+        type: "subagent",
+        owner: options.owner,
+        versionRange: options.versionRange,
+    })
+        .pipe(Effect.map((refs) => Array.filter(refs, (ref) => ref.type === "subagent")));
+    const results = yield* Effect.forEach(filteredEntries, ([name, sourceStr]) => Effect.gen(function* () {
+        if (isWorkspaceSourceLocator(sourceStr)) {
+            return {
+                type: "skip",
+                name,
+                source: sourceStr,
+                reason: `Subagent "${name}" is workspace-sourced and unchanged`,
+            };
+        }
+        const source = yield* resolveSource(sourceStr);
+        const registryPattern = toRegistrySubagentPattern(sourceStr);
+        if (source.type === "registry" && Option.isSome(registryPattern)) {
+            const lookupName = registryPattern.value.name ?? decodeExtensionNameSync(name);
+            const requestedRange = registryPattern.value.versionRange;
+            const registryResolution = yield* sources.resolveNamedRegistry(source, {
+                owner: registryPattern.value.owner,
+                type: "subagent",
+                name: lookupName,
+                versionRange: requestedRange === undefined ? Option.none() : Option.some(requestedRange),
+                releaseAgeEvaluation,
+            });
+            if (registryResolution.kind === "selected" || registryResolution.kind === "exempted") {
+                if (registryResolution.ref.type !== "subagent") {
+                    return yield* new ExtensionLifecycleFailed({
+                        category: "internal",
+                        detail: `Registry resolved ${registryResolution.target} as ${registryResolution.ref.type}, expected subagent`,
+                    });
+                }
+                return {
+                    type: "match",
+                    ref: registryResolution.ref,
+                    holdbacks: registryResolution.kind === "exempted" ||
+                        registryResolution.newerHeld === undefined
+                        ? []
+                        : [
+                            releaseAgeRecord({
+                                target: registryResolution.target,
+                                ...(requestedRange === undefined ? {} : { requestedRange }),
+                                selectedVersion: registryResolution.ref.version,
+                                evidence: registryResolution.newerHeld,
+                            }),
+                        ],
+                    ...(registryResolution.kind === "selected"
+                        ? {}
+                        : {
+                            bypasses: [
+                                {
+                                    ...releaseAgeRecord({
+                                        target: registryResolution.target,
+                                        ...(requestedRange === undefined ? {} : { requestedRange }),
+                                        selectedVersion: registryResolution.ref.version,
+                                        evidence: registryResolution.bypassed,
+                                    }),
+                                    ...registryResolution.exemption,
+                                },
+                            ],
+                        }),
+                };
+            }
+            if (registryResolution.kind === "policy_held") {
+                const holdback = releaseAgeRecord({
+                    target: registryResolution.target,
+                    ...(registryResolution.requestedRange === undefined
+                        ? {}
+                        : { requestedRange: registryResolution.requestedRange }),
+                    evidence: registryResolution.candidate,
+                });
+                return {
+                    type: "skip",
+                    name,
+                    source: sourceStr,
+                    reason: `Subagent "${name}" is held by the minimum release age until ${holdback.eligibleAt}`,
+                    holdback,
+                };
+            }
+            return {
+                type: "skip",
+                name,
+                source: sourceStr,
+                reason: registryResolution.kind === "not_found"
+                    ? `Subagent "${name}" not found in source ${sources.origin(source)}`
+                    : `No version of subagent "${name}" satisfies ${registryResolution.requestedRange}`,
+            };
+        }
+        const requestedOwner = Option.match(registryPattern, {
+            onNone: () => Option.none(),
+            onSome: (pattern) => Option.some(pattern.owner),
+        });
+        const namedRefs = yield* findSubagentRefs(source, {
+            subagentNames: [name],
+            owner: requestedOwner,
+            versionRange: Option.none(),
+        });
+        const subagentRef = namedRefs.find((r) => r.subagent.name === name);
+        if (subagentRef) {
+            return { type: "match", ref: subagentRef, holdbacks: [] };
+        }
+        return {
+            type: "skip",
+            name,
+            source: sourceStr,
+            reason: `Subagent "${name}" not found in source ${sources.origin(source)}`,
+        };
+    }).pipe(Effect.catch((error) => Effect.succeed({
+        type: "skip",
+        name,
+        source: sourceStr,
+        reason: `Failed to resolve "${name}": ${String(error)}`,
+    }))), { concurrency: "unbounded" });
+    const resolved = results.filter((result) => result.type === "match");
+    const skipped = results.filter((result) => result.type === "skip");
+    if (resolved.length === 0 && skipped.length === 0) {
+        return yield* Effect.fail(allSubagentResolutionsFailed);
+    }
+    const subagentManager = yield* SubagentManager;
+    const failureConversion = yield* StepFailureConversion;
+    // Classify every proposed Registry acceptance against the accepted
+    // resolution. A replaced publisher binding is a trust decision a person
+    // makes at a prompt; the plan carries it as an interactive-only condition.
+    const warningsBySubagent = new Map();
+    const publisherTransitions = [];
+    for (const item of resolved) {
+        const proposed = registryBindingProposal(item.ref);
+        const accepted = lockedSubagents[item.ref.subagent.name];
+        if (proposed === undefined || accepted?.type !== "registry")
+            continue;
+        const transition = classifyPublisherBindingTransition({
+            accepted: yield* acceptedResolutionRef({
+                workspace: ws,
+                type: "subagent",
+                name: proposed.target,
+            }).pipe(Effect.mapError((cause) => new ExtensionLifecycleFailed({
+                category: "conflict",
+                detail: `The accepted resolution for subagent "${proposed.target}" could not be read, so the proposed publisher binding cannot be checked`,
+                cause,
+            }))),
+            proposed,
+        });
+        if (Option.isSome(transition)) {
+            publisherTransitions.push(transition.value);
+            warningsBySubagent.set(item.ref.subagent.name, publisherTransitionWarning(transition.value));
+        }
+    }
+    const makeRunClosure = (ref) => {
+        const step = buildInstallOperation(subagentManager, {
+            toStepFailure: failureConversion.toStepFailure,
+            ref,
+            versionRange: Option.none(),
+        });
+        if (step.readiness === "error") {
+            return Effect.fail(new StepFailure({ category: "conflict", detail: step.errorMessage }));
+        }
+        return step.run.pipe(Effect.map(appendWarning(warningsBySubagent.get(ref.subagent.name))));
+    };
+    const units = resolved.map((item) => ({
+        name: item.ref.subagent.name,
+        ref: item.ref,
+        force: request.ignoreVersionConstraints,
+        operation: item.ref,
+    }));
+    const rawPlan = buildSelectiveUpdatePlan(units, lockedSubagents, PLAN_NAME, Option.some(PLAN_DESCRIPTION), makeRunClosure);
+    const basePlanWithReleaseAge = {
+        ...rawPlan,
+        presentation: operationPresentation({ imperative: "update", past: "Updated", gerund: "Updating" }, "subagent"),
+        releaseAge: {
+            evaluatedAt: DateTime.formatIso(releaseAgeEvaluation.evaluatedAt),
+            holdbacks: normalizeReleaseAgeRecords([
+                ...resolved.flatMap((item) => item.holdbacks),
+                ...skipped.flatMap((item) => (item.holdback === undefined ? [] : [item.holdback])),
+            ]),
+            bypasses: normalizeReleaseAgeRecords(resolved.flatMap((item) => item.bypasses ?? [])),
+        },
+    };
+    const skippedSteps = skipped
+        .filter((item) => item.holdback === undefined)
+        .map((item) => skippedSubagentStep(ws.scope, item));
+    const [firstJob, ...restJobs] = basePlanWithReleaseAge.jobs;
+    const plan = skippedSteps.length === 0
+        ? basePlanWithReleaseAge
+        : firstJob === undefined
+            ? { ...basePlanWithReleaseAge, jobs: [{ concurrency: 1, steps: skippedSteps }] }
+            : {
+                ...basePlanWithReleaseAge,
+                jobs: [{ ...firstJob, steps: [...firstJob.steps, ...skippedSteps] }, ...restJobs],
+            };
+    const configuredAgentOperations = [
+        ...new Set(request.nameFilters.length > 0
+            ? request.nameFilters
+            : plan.jobs.flatMap((job) => job.steps.map((step) => step.label.replace(/^(?:Skip|Update)\s+/u, "")))),
+    ].map((name) => ({ extensionType: "subagent", name, plannedState: "enabled" }));
+    const executionPlan = withPublisherTrustConditions({
+        ...plan,
+        riskConditions: [
+            ...(plan.riskConditions ?? []),
+            ...(request.ignoreVersionConstraints ? [ignoreVersionConstraintsCondition] : []),
+        ],
+    }, publisherTransitions);
+    return {
+        outcome: "planned",
+        subjectType: "subagent",
+        planName: PLAN_NAME,
+        execution: yield* prepareExecutionCandidate(executionPlan, { configuredAgentOperations }),
+    };
+});
+//# sourceMappingURL=subagents.js.map

package/dist/src/update/selective/use-case.d.ts

@@ -0,0 +1,121 @@
+/**
+ * The selective update use case.
+ *
+ * `skills update` and `subagents update` narrow the configured entries with
+ * the selectors a person typed, then advance the ones whose source now
+ * resolves to something other than what was accepted. Both settle through the
+ * same shape every other lifecycle use case does: `prepare` decides
+ * everything and writes nothing, `previewOrApply` resolves the frozen
+ * candidate into one operation outcome.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import { type SelectiveSkillUpdateRequest } from "./skills.js";
+import { type SelectiveSubagentUpdateRequest } from "./subagents.js";
+/** Everything a selective update route can ask for. */
+export type SelectiveUpdateRequest = SelectiveSkillUpdateRequest | SelectiveSubagentUpdateRequest;
+/** Settle a selective update: decide what may advance, write nothing. */
+export declare const prepareSelectiveUpdate: (request: SelectiveUpdateRequest) => Effect.Effect<{
+    outcome: "nothing";
+    reason: "none-installed";
+    message: string;
+    subjectType: "skill";
+    planName: string;
+    planDescription: string;
+    execution?: never;
+} | {
+    outcome: "nothing";
+    reason: "no-source-match" | "no-name-match";
+    message: string;
+    subjectType: "skill";
+    planName: string;
+    planDescription: string;
+    execution?: never;
+} | {
+    outcome: "planned";
+    subjectType: "skill";
+    planName: string;
+    execution: import("@agentxm/workspace-operations").ExecutionCandidate<import("./requirements.ts").SelectiveUpdateStepRequirements, never>;
+    reason?: never;
+    message?: never;
+    planDescription?: never;
+} | {
+    outcome: "nothing";
+    reason: "none-installed";
+    message: string;
+    subjectType: "subagent";
+    planName: string;
+    planDescription: string;
+    execution?: never;
+} | {
+    outcome: "nothing";
+    reason: "no-source-match" | "no-name-match";
+    message: string;
+    subjectType: "subagent";
+    planName: string;
+    planDescription: string;
+    execution?: never;
+} | {
+    outcome: "planned";
+    subjectType: "subagent";
+    planName: string;
+    execution: import("@agentxm/workspace-operations").ExecutionCandidate<import("./requirements.ts").SelectiveUpdateStepRequirements, never>;
+    reason?: never;
+    message?: never;
+    planDescription?: never;
+}, import("../../errors.ts").ExtensionLifecycleFailed | import("@agentxm/extension-sources").SourceSyntaxInvalid | import("@agentxm/extension-sources").SourceHostNotConfigured | import("@agentxm/extension-sources").SourceNotResolvable | import("@agentxm/extension-sources").SourceNetworkFailure | import("@agentxm/extension-sources").GitOperationFailed | import("@agentxm/extension-sources").WorkspaceCatalogUnavailable | import("@agentxm/extension-sources").AxmSkillGateUnavailable | import("@agentxm/registry-client").RegistryProblem | import("@agentxm/registry-client").RegistryRequestFailed | import("@agentxm/registry-client").RegistryOperationFailed | import("@agentxm/workspace-state").SettingsIoError | import("@agentxm/workspace-state").SettingsParseError | import("@agentxm/workspace-state").SettingsDecodeError | import("@agentxm/workspace-state").LockfileIoError | import("@agentxm/workspace-state").LockfileParseError | import("@agentxm/workspace-state").LockfileDecodeError | import("@agentxm/workspace-state").LockfileVersionUnsupported | import("@agentxm/workspace-state").WorkspaceRootEscape | import("@agentxm/workspace-state").LockfileValidationError | import("@agentxm/extension-resolution").ExtensionResolutionFailed | import("@agentxm/workspace-operations").CandidateFingerprintFailed, import("../../step-failure-conversion.ts").StepFailureConversion | import("effect/FileSystem").FileSystem | import("effect/Path").Path | import("@agentxm/workspace-state").WorkspaceMutations | import("@agentxm/workspace-state").ConfiguredAgentOutcomesProvider | import("effect/unstable/http/HttpClient").HttpClient | import("@agentxm/extension-resolution").ReleaseAgePosture | import("effect/Scope").Scope | import("@agentxm/extension-sources").SourceHostProviders | import("@agentxm/extension-materialization").SubagentManager | import("@agentxm/extension-sources").WorkspaceCatalog>;
+/** Settle a selective update, then preview or apply it. */
+export declare const SelectiveUpdate: {
+    readonly prepare: (request: SelectiveUpdateRequest) => Effect.Effect<{
+        outcome: "nothing";
+        reason: "none-installed";
+        message: string;
+        subjectType: "skill";
+        planName: string;
+        planDescription: string;
+        execution?: never;
+    } | {
+        outcome: "nothing";
+        reason: "no-source-match" | "no-name-match";
+        message: string;
+        subjectType: "skill";
+        planName: string;
+        planDescription: string;
+        execution?: never;
+    } | {
+        outcome: "planned";
+        subjectType: "skill";
+        planName: string;
+        execution: import("@agentxm/workspace-operations").ExecutionCandidate<import("./requirements.ts").SelectiveUpdateStepRequirements, never>;
+        reason?: never;
+        message?: never;
+        planDescription?: never;
+    } | {
+        outcome: "nothing";
+        reason: "none-installed";
+        message: string;
+        subjectType: "subagent";
+        planName: string;
+        planDescription: string;
+        execution?: never;
+    } | {
+        outcome: "nothing";
+        reason: "no-source-match" | "no-name-match";
+        message: string;
+        subjectType: "subagent";
+        planName: string;
+        planDescription: string;
+        execution?: never;
+    } | {
+        outcome: "planned";
+        subjectType: "subagent";
+        planName: string;
+        execution: import("@agentxm/workspace-operations").ExecutionCandidate<import("./requirements.ts").SelectiveUpdateStepRequirements, never>;
+        reason?: never;
+        message?: never;
+        planDescription?: never;
+    }, import("../../errors.ts").ExtensionLifecycleFailed | import("@agentxm/extension-sources").SourceSyntaxInvalid | import("@agentxm/extension-sources").SourceHostNotConfigured | import("@agentxm/extension-sources").SourceNotResolvable | import("@agentxm/extension-sources").SourceNetworkFailure | import("@agentxm/extension-sources").GitOperationFailed | import("@agentxm/extension-sources").WorkspaceCatalogUnavailable | import("@agentxm/extension-sources").AxmSkillGateUnavailable | import("@agentxm/registry-client").RegistryProblem | import("@agentxm/registry-client").RegistryRequestFailed | import("@agentxm/registry-client").RegistryOperationFailed | import("@agentxm/workspace-state").SettingsIoError | import("@agentxm/workspace-state").SettingsParseError | import("@agentxm/workspace-state").SettingsDecodeError | import("@agentxm/workspace-state").LockfileIoError | import("@agentxm/workspace-state").LockfileParseError | import("@agentxm/workspace-state").LockfileDecodeError | import("@agentxm/workspace-state").LockfileVersionUnsupported | import("@agentxm/workspace-state").WorkspaceRootEscape | import("@agentxm/workspace-state").LockfileValidationError | import("@agentxm/extension-resolution").ExtensionResolutionFailed | import("@agentxm/workspace-operations").CandidateFingerprintFailed, import("../../step-failure-conversion.ts").StepFailureConversion | import("effect/FileSystem").FileSystem | import("effect/Path").Path | import("@agentxm/workspace-state").WorkspaceMutations | import("@agentxm/workspace-state").ConfiguredAgentOutcomesProvider | import("effect/unstable/http/HttpClient").HttpClient | import("@agentxm/extension-resolution").ReleaseAgePosture | import("effect/Scope").Scope | import("@agentxm/extension-sources").SourceHostProviders | import("@agentxm/extension-materialization").SubagentManager | import("@agentxm/extension-sources").WorkspaceCatalog>;
+    readonly previewOrApply: (candidate: import("./vocabulary.js").PlannedSelectiveUpdateCandidate, execution: import("@agentxm/workspace-operations").PlanExecution) => Effect.Effect<import("@agentxm/workspace-operations").OperationResolution<never>, import("@agentxm/workspace-state").WorkspaceSettingsReadFailure | import("@agentxm/workspace-operations").ApprovalRecoveryMissing | import("@agentxm/workspace-operations").PlanInteractionFailed | import("@agentxm/workspace-transactions").WorkspaceTransitionAcquireFailure, import("@agentxm/workspace-state").ConfiguredAgentOutcomesProvider | import("@agentxm/workspace-transactions").FootprintRecorder | import("@agentxm/workspace-operations").OperationJournal | import("@agentxm/workspace-operations").ResolvePlanInteraction | import("./requirements.ts").SelectiveUpdateStepRequirements>;
+};
+//# sourceMappingURL=use-case.d.ts.map

package/dist/src/update/selective/use-case.js

@@ -0,0 +1,28 @@
+/**
+ * The selective update use case.
+ *
+ * `skills update` and `subagents update` narrow the configured entries with
+ * the selectors a person typed, then advance the ones whose source now
+ * resolves to something other than what was accepted. Both settle through the
+ * same shape every other lifecycle use case does: `prepare` decides
+ * everything and writes nothing, `previewOrApply` resolves the frozen
+ * candidate into one operation outcome.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import { prepareSelectiveSkillUpdate } from "./skills.js";
+import { prepareSelectiveSubagentUpdate, } from "./subagents.js";
+import { previewOrApplySelectiveUpdate } from "./vocabulary.js";
+/** Settle a selective update: decide what may advance, write nothing. */
+export const prepareSelectiveUpdate = Effect.fn("SelectiveUpdate.prepare")(function* (request) {
+    return request.kind === "selective-skills"
+        ? yield* prepareSelectiveSkillUpdate(request)
+        : yield* prepareSelectiveSubagentUpdate(request);
+});
+/** Settle a selective update, then preview or apply it. */
+export const SelectiveUpdate = {
+    prepare: prepareSelectiveUpdate,
+    previewOrApply: previewOrApplySelectiveUpdate,
+};
+//# sourceMappingURL=use-case.js.map

package/dist/src/update/selective/vocabulary.d.ts

@@ -0,0 +1,43 @@
+/**
+ * What a selective update settles with.
+ *
+ * `skills update` and `subagents update` both settle as one of two things: a
+ * frozen execution candidate, or the reason there is nothing to execute. The
+ * reason is a bounded classification, never a rendered sentence plus
+ * suggestions — the application decides what to offer a person for each one.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import { type ExecutionCandidate, type PlanExecution, type PlanRiskCondition } from "@agentxm/workspace-operations";
+import type { SelectiveUpdateStepRequirements } from "./requirements.js";
+import type { SelectiveUpdateNothingReason } from "./selection.js";
+/** Which extension type a selective update is about. */
+export type SelectiveUpdateSubjectType = "skill" | "subagent";
+/** The plan name each selective update reports under. */
+export declare const selectiveUpdatePlanName: (type: SelectiveUpdateSubjectType) => string;
+/**
+ * Advancing outside the version ranges installed Packs declare is an override
+ * a person states on the command line, so the plan carries it as a condition
+ * the operator already met rather than a silent policy.
+ */
+export declare const ignoreVersionConstraintsCondition: PlanRiskCondition;
+/** A settled selective update that has work to execute. */
+export interface PlannedSelectiveUpdateCandidate {
+    readonly outcome: "planned";
+    readonly subjectType: SelectiveUpdateSubjectType;
+    readonly planName: string;
+    readonly execution: ExecutionCandidate<SelectiveUpdateStepRequirements>;
+}
+/** A settled selective update with nothing to execute, and why. */
+export interface NothingSelectiveUpdateCandidate {
+    readonly outcome: "nothing";
+    readonly reason: SelectiveUpdateNothingReason;
+    readonly message: string;
+    readonly subjectType: SelectiveUpdateSubjectType;
+    readonly planName: string;
+    readonly planDescription: string;
+}
+export type SelectiveUpdateCandidate = PlannedSelectiveUpdateCandidate | NothingSelectiveUpdateCandidate;
+/** Preview or apply a settled selective update. */
+export declare const previewOrApplySelectiveUpdate: (candidate: PlannedSelectiveUpdateCandidate, execution: PlanExecution) => import("effect/Effect").Effect<import("@agentxm/workspace-operations").OperationResolution<never>, import("@agentxm/workspace-state").WorkspaceSettingsReadFailure | import("@agentxm/workspace-operations").ApprovalRecoveryMissing | import("@agentxm/workspace-operations").PlanInteractionFailed | import("@agentxm/workspace-transactions").WorkspaceTransitionAcquireFailure, import("@agentxm/workspace-state").ConfiguredAgentOutcomesProvider | import("@agentxm/workspace-transactions").FootprintRecorder | import("@agentxm/workspace-operations").OperationJournal | import("@agentxm/workspace-operations").ResolvePlanInteraction | SelectiveUpdateStepRequirements>;
+//# sourceMappingURL=vocabulary.d.ts.map

package/dist/src/update/selective/vocabulary.js

@@ -0,0 +1,28 @@
+/**
+ * What a selective update settles with.
+ *
+ * `skills update` and `subagents update` both settle as one of two things: a
+ * frozen execution candidate, or the reason there is nothing to execute. The
+ * reason is a bounded classification, never a rendered sentence plus
+ * suggestions — the application decides what to offer a person for each one.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import { resolveExecutionCandidate, } from "@agentxm/workspace-operations";
+/** The plan name each selective update reports under. */
+export const selectiveUpdatePlanName = (type) => type === "skill" ? "Update skills" : "Update subagents";
+/**
+ * Advancing outside the version ranges installed Packs declare is an override
+ * a person states on the command line, so the plan carries it as a condition
+ * the operator already met rather than a silent policy.
+ */
+export const ignoreVersionConstraintsCondition = {
+    level: "override-required",
+    id: "ignore-pack-version-constraints",
+    policy: "ignore-version-constraints",
+    requiredFlag: "--ignore-version-constraints",
+    detail: "Allow updates outside version constraints declared by installed packs.",
+};
+/** Preview or apply a settled selective update. */
+export const previewOrApplySelectiveUpdate = (candidate, execution) => resolveExecutionCandidate(candidate.execution, execution);
+//# sourceMappingURL=vocabulary.js.map

package/dist/src/update/selector.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Resolving what a `<type> update` selector names.
+ *
+ * A person narrows a configured sweep two ways: a positional that may be an
+ * installed name or a source, and repeated `--name` filters that may be exact
+ * names or globs. Deciding which configured entries those name is update's
+ * own question — it re-reads the configured entries, re-resolves their
+ * declared sources, and compares origins — so it is settled here, beside the
+ * sweep it narrows, rather than by whichever surface parsed the flags.
+ *
+ * A selector that matches nothing is a settled answer, not a failure: the
+ * sweep reports it as nothing to advance, in the same shape as a workspace
+ * with nothing configured.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { SourceHostProviders } from "@agentxm/extension-sources";
+import { WorkspaceRecords } from "@agentxm/workspace-state";
+import type { WorkspaceUpdatableType } from "./configured.js";
+/** The flag spelling reported when a `--name` filter matches nothing. */
+export declare const UPDATE_NAME_FILTER_FLAG = "--name";
+/** Every type a selector can narrow: whatever a configured sweep can cover. */
+export type ConfiguredUpdateSelectorType = WorkspaceUpdatableType;
+/** What one `<type> update` invocation asked for, before it is resolved. */
+export interface ConfiguredUpdateSelector {
+    readonly resourceType: ConfiguredUpdateSelectorType;
+    /** The positional selector, which may name an installed extension or a source. */
+    readonly source: Option.Option<string>;
+    /** Repeated `--name` filters; exact names or globs over installed names. */
+    readonly nameFilters: ReadonlyArray<string>;
+    /** False where the positional is a source spelling only (MCP connections). */
+    readonly sourceMayMatchName?: boolean;
+}
+/** What a selector resolved to. */
+export type ConfiguredUpdateSelection = 
+/** No selector was given: every configured entry of the type is in scope. */
+{
+    readonly _tag: "All";
+}
+/** The selector matched these installed names. */
+ | {
+    readonly _tag: "Names";
+    readonly names: ReadonlyArray<string>;
+}
+/** The selector matched nothing, and this says which selector and why. */
+ | {
+    readonly _tag: "NoMatch";
+    readonly message: string;
+};
+/**
+ * Resolve a selector against the type's configured, enabled entries.
+ *
+ * Returns `All` when no selector was given, so a workspace with nothing
+ * configured still reports through the sweep's own "no configured …" message
+ * rather than a selector no-op.
+ */
+export declare const resolveConfiguredUpdateSelection: (selector: ConfiguredUpdateSelector) => Effect.Effect<{
+    _tag: "All";
+    message?: never;
+    names?: never;
+} | {
+    _tag: "NoMatch";
+    message: string;
+    names?: never;
+} | {
+    _tag: "Names";
+    names: string[];
+    message?: never;
+}, import("@agentxm/extension-sources").SourceSyntaxInvalid | import("@agentxm/extension-sources").SourceHostNotConfigured | import("@agentxm/extension-sources").SourceNotResolvable | import("@agentxm/extension-sources").SourceNetworkFailure | import("@agentxm/extension-sources").GitOperationFailed | import("@agentxm/extension-sources").WorkspaceCatalogUnavailable | import("@agentxm/extension-sources").AxmSkillGateUnavailable | import("@agentxm/registry-client").RegistryProblem | import("@agentxm/registry-client").RegistryRequestFailed | import("@agentxm/registry-client").RegistryOperationFailed | import("@agentxm/workspace-state").WorkspaceStateReadFailure, import("effect/FileSystem").FileSystem | import("effect/Path").Path | import("effect/unstable/http/HttpClient").HttpClient | SourceHostProviders | import("@agentxm/extension-sources").WorkspaceCatalog | WorkspaceRecords>;
+//# sourceMappingURL=selector.d.ts.map