@agentxm/workspace-state 0.28.4-bootstrap.0

package/dist/src/workspace/read-model-record-readers.js

@@ -0,0 +1,467 @@
+/**
+ * Read-model record readers.
+ *
+ * Centralizes read-model record projection over `WorkspaceReadModel` subject
+ * rows.
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { installableExtensionTypes, } from "@agentxm/extension-model/unstable/extensions/installable-types";
+import { isAxmManagedMcpEntry, isMcpServerApplicableToAgent } from "./mcp-entry-semantics.js";
+import { createDefaultSettings } from "../settings/index.js";
+import { configuredAgentLifecycleOutcomes } from "./configured-agent-outcomes.js";
+import { projectExtensionInventory, } from "./read-model/extensions/inventory.js";
+import { deriveSourceMetaFromLockType } from "./source-metadata.js";
+export const makeReadModelRecordReaders = (args) => {
+    const packagingKindForSource = (type, source) => {
+        if (type === "pack")
+            return "native";
+        if (type === "skill") {
+            return source.includes("/skills/") || source.startsWith("@") ? "native" : "non-native";
+        }
+        return source.includes("/") && source.startsWith("@") ? "native" : "non-native";
+    };
+    const packagingKindForResolved = (resolved, type, source) => Option.match(resolved, {
+        onNone: () => packagingKindForSource(type, source),
+        onSome: (row) => deriveSourceMetaFromLockType(row.lockEntry.type).packagingKind,
+    });
+    const stringProperty = (value, property) => {
+        if (typeof value !== "object" || value === null)
+            return null;
+        const candidate = property === "_tag"
+            ? "_tag" in value
+                ? value._tag
+                : undefined
+            : property === "agentId"
+                ? "agentId" in value
+                    ? value.agentId
+                    : undefined
+                : property === "packageRoot"
+                    ? "packageRoot" in value
+                        ? value.packageRoot
+                        : undefined
+                    : property === "contentRoot"
+                        ? "contentRoot" in value
+                            ? value.contentRoot
+                            : undefined
+                        : "configFile" in value
+                            ? value.configFile
+                            : undefined;
+        return typeof candidate === "string" ? candidate : null;
+    };
+    const observationFromActual = (actual) => {
+        if (typeof actual !== "object" || actual === null) {
+            return { agents: [], origins: [], paths: [] };
+        }
+        const origin = "origin" in actual ? actual.origin : undefined;
+        const originTag = stringProperty(origin, "_tag");
+        const agentId = stringProperty(origin, "agentId");
+        const packageRoot = stringProperty(actual, "packageRoot");
+        const contentRoot = stringProperty(actual, "contentRoot");
+        const configFile = stringProperty(actual, "configFile");
+        const actualPath = packageRoot ?? contentRoot ?? configFile;
+        return {
+            agents: agentId === null ? [] : [agentId],
+            origins: originTag === null ? [] : [originTag],
+            paths: actualPath === null ? [] : [args.path.relative(args.baseDir, actualPath)],
+        };
+    };
+    const mergeObservations = (actuals) => ({
+        agents: actuals.flatMap((actual) => observationFromActual(actual).agents),
+        origins: actuals.flatMap((actual) => observationFromActual(actual).origins),
+        paths: actuals.flatMap((actual) => observationFromActual(actual).paths),
+    });
+    const lifecycleCandidateFromInstalled = (row, defaultAgents) => {
+        const observations = mergeObservations(row.actual);
+        const observedAgents = observations.agents;
+        return {
+            key: row.key,
+            lifecycle: row.installationOrigin._tag === "direct" ? "configured" : "implicit",
+            enabled: row.activation === "enabled",
+            installed: row.actual.length > 0,
+            agents: observedAgents.length === 0 ? defaultAgents : observedAgents,
+            origins: observations.origins,
+            paths: observations.paths,
+        };
+    };
+    const lifecycleCandidateFromUnmanaged = (row) => ({
+        key: row.key,
+        lifecycle: "unmanaged",
+        enabled: null,
+        installed: true,
+        ...observationFromActual(row.actual),
+    });
+    const desiredPackMemberNames = (graph, type) => [
+        ...new Set(graph.nodes
+            .filter((node) => node.type === type && node.origins.some((origin) => origin.type === "pack"))
+            .map((node) => node.name)),
+    ].sort();
+    const getDesiredPackMemberNames = (type) => type === "pack"
+        ? Effect.succeed([])
+        : args
+            .getDesiredStateGraph()
+            .pipe(Effect.map((graph) => desiredPackMemberNames(graph, type)));
+    const packMemberToImplicit = (type, name) => ({
+        type,
+        name,
+        source: Option.none(),
+        enabled: true,
+        packagingKind: "native",
+        lifecycle: "implicit",
+    });
+    const installedRowToReadModelRecordRow = (type, row) => {
+        if (row.installationOrigin._tag === "direct") {
+            const source = row.installationOrigin.declared.entry.source;
+            const common = {
+                type,
+                name: row.key.name,
+                enabled: row.activation === "enabled",
+                ...(row.installationOrigin.declared.entry.origin === undefined
+                    ? {}
+                    : { origin: row.installationOrigin.declared.entry.origin }),
+                lifecycle: "configured",
+            };
+            return source === undefined
+                ? { ...common, authority: "inline", packagingKind: "non-native" }
+                : {
+                    ...common,
+                    source,
+                    packagingKind: packagingKindForResolved(row.resolved, type, source),
+                };
+        }
+        return packMemberToImplicit(type, row.key.name);
+    };
+    const unmanagedRowToReadModelRecordRow = (type, row) => ({
+        type,
+        name: row.key.name,
+        source: Option.none(),
+        enabled: true,
+        packagingKind: type === "pack" ? "native" : "non-native",
+        locations: typeof row.actual.packageRoot === "string"
+            ? [args.path.relative(args.baseDir, row.actual.packageRoot)]
+            : typeof row.actual.contentRoot === "string"
+                ? [args.path.relative(args.baseDir, row.actual.contentRoot)]
+                : typeof row.actual.configFile === "string"
+                    ? [args.path.relative(args.baseDir, row.actual.configFile)]
+                    : [],
+        agents: observationFromActual(row.actual).agents,
+        ownershipEvidence: row.actual.config !== undefined &&
+            row.actual.config !== null &&
+            isAxmManagedMcpEntry(row.actual.config)
+            ? ["x-axm:managed-entry"]
+            : [],
+        lifecycle: "unmanaged",
+    });
+    const collectReadModelRecordRows = (input) => {
+        const desiredPackMembers = new Set(input.packMemberNames);
+        const acceptedInstalled = input.installed.filter((row) => row.installationOrigin._tag === "direct" || desiredPackMembers.has(row.key.name));
+        const installedNames = new Set(acceptedInstalled.map((row) => row.key.name));
+        const implicitRows = input.packMemberNames
+            .filter((name) => !installedNames.has(name))
+            .map((name) => packMemberToImplicit(input.type, name));
+        const stalePackActuals = input.installed
+            .filter((row) => row.installationOrigin._tag === "pack-member" && !desiredPackMembers.has(row.key.name))
+            .flatMap((row) => row.actual.map((actual) => ({ key: row.key, actual })));
+        return [
+            ...acceptedInstalled.map((row) => installedRowToReadModelRecordRow(input.type, row)),
+            ...implicitRows,
+            ...[...input.unmanaged, ...stalePackActuals]
+                .filter((row) => !desiredPackMembers.has(row.key.name))
+                .map((row) => unmanagedRowToReadModelRecordRow(input.type, row)),
+        ];
+    };
+    const getReadModelRecordRows = (type) => Effect.gen(function* () {
+        const packMemberNames = yield* getDesiredPackMemberNames(type);
+        return yield* args.readScopedContext((scoped) => Effect.gen(function* () {
+            switch (type) {
+                case "skill": {
+                    const installed = yield* scoped.skills.installed;
+                    const unmanaged = yield* scoped.skills.unmanaged;
+                    return collectReadModelRecordRows({
+                        type,
+                        installed,
+                        unmanaged,
+                        packMemberNames,
+                    });
+                }
+                case "mcp-server": {
+                    const installed = yield* scoped.mcpServers.installed;
+                    const unmanaged = yield* scoped.mcpServers.unmanaged;
+                    return collectReadModelRecordRows({
+                        type,
+                        installed,
+                        unmanaged,
+                        packMemberNames,
+                    });
+                }
+                case "pack": {
+                    const installed = yield* scoped.packs.installed;
+                    const unmanaged = yield* scoped.packs.unmanaged;
+                    return collectReadModelRecordRows({
+                        type,
+                        installed,
+                        unmanaged,
+                        packMemberNames,
+                    });
+                }
+                case "subagent": {
+                    const installed = yield* scoped.subagents.installed;
+                    const unmanaged = yield* scoped.subagents.unmanaged;
+                    return collectReadModelRecordRows({
+                        type,
+                        installed,
+                        unmanaged,
+                        packMemberNames,
+                    });
+                }
+                case "rule": {
+                    const installed = yield* scoped.rules.installed;
+                    const unmanaged = yield* scoped.rules.unmanaged;
+                    return collectReadModelRecordRows({
+                        type,
+                        installed,
+                        unmanaged,
+                        packMemberNames,
+                    });
+                }
+                case "hook": {
+                    const installed = yield* scoped.hooks.installed;
+                    const unmanaged = yield* scoped.hooks.unmanaged;
+                    return collectReadModelRecordRows({
+                        type,
+                        installed,
+                        unmanaged,
+                        packMemberNames,
+                    });
+                }
+                case "knowledge": {
+                    const installed = yield* scoped.knowledge.installed;
+                    const unmanaged = yield* scoped.knowledge.unmanaged;
+                    return collectReadModelRecordRows({
+                        type,
+                        installed,
+                        unmanaged,
+                        packMemberNames,
+                    });
+                }
+            }
+        }));
+    });
+    const projectStandardInventory = (input) => {
+        const desiredPackMembers = new Set(input.packMemberNames);
+        const acceptedInstalled = input.installed.filter((row) => row.installationOrigin._tag === "direct" || desiredPackMembers.has(row.key.name));
+        const installedNames = new Set(acceptedInstalled.map((row) => row.key.name));
+        const desiredUnmanaged = input.unmanaged.filter((row) => desiredPackMembers.has(row.key.name));
+        const desiredUnmanagedNames = new Set(desiredUnmanaged.map((row) => row.key.name));
+        const implicitMissing = input.packMemberNames
+            .filter((name) => !installedNames.has(name) && !desiredUnmanagedNames.has(name))
+            .map((name) => ({
+            key: {
+                scope: input.scope,
+                type: input.type,
+                name,
+            },
+            lifecycle: "implicit",
+            enabled: true,
+            installed: false,
+            agents: input.configuredAgents,
+            origins: [],
+            paths: [],
+        }));
+        const implicitObserved = desiredUnmanaged.map((row) => ({
+            ...lifecycleCandidateFromUnmanaged(row),
+            lifecycle: "implicit",
+            enabled: true,
+        }));
+        const stalePackActuals = input.installed
+            .filter((row) => row.installationOrigin._tag === "pack-member" && !desiredPackMembers.has(row.key.name))
+            .flatMap((row) => row.actual.map((actual) => ({ key: row.key, actual })));
+        return projectExtensionInventory({
+            lifecycle: [
+                ...acceptedInstalled.map((row) => lifecycleCandidateFromInstalled(row, input.configuredAgents)),
+                ...implicitObserved,
+                ...implicitMissing,
+                ...input.unmanaged
+                    .filter((row) => !desiredPackMembers.has(row.key.name))
+                    .map(lifecycleCandidateFromUnmanaged),
+                ...stalePackActuals.map(lifecycleCandidateFromUnmanaged),
+            ],
+            agents: input.agents,
+        });
+    };
+    const getExtensionInventory = (type, options) => Effect.gen(function* () {
+        const packMemberNames = yield* getDesiredPackMemberNames(type);
+        return yield* args.readScopedContext((scoped) => Effect.gen(function* () {
+            const settingsOption = yield* scoped.state.settings;
+            const settings = Option.getOrElse(settingsOption, () => createDefaultSettings());
+            const agents = options.agents ?? [];
+            const configuredAgents = settings.agents ?? [];
+            const finalizeInventory = (inventory) => {
+                const withOutcomes = inventory.items.map((row) => {
+                    const mcpEntry = row.type === "mcp-server" ? settings.mcpServers?.[row.name] : undefined;
+                    return {
+                        ...row,
+                        agentOutcomes: row.classification.lifecycle === "unmanaged"
+                            ? []
+                            : configuredAgentLifecycleOutcomes({
+                                type: row.type,
+                                name: row.name,
+                                agentIds: configuredAgents,
+                                scope: row.scope,
+                                state: "current",
+                                targetState: row.enabled === false ? "disabled" : "enabled",
+                                installed: row.installed,
+                                observedAgentIds: row.agents,
+                                ...(mcpEntry === undefined
+                                    ? {}
+                                    : {
+                                        applicableAgentIds: configuredAgents.filter((agentId) => isMcpServerApplicableToAgent(mcpEntry, agentId)),
+                                    }),
+                            }),
+                    };
+                });
+                const items = withOutcomes.filter((row) => agents.length === 0 ||
+                    agents.some((agentId) => row.agents.includes(agentId) ||
+                        row.agentOutcomes.some((outcome) => outcome.agentId === agentId)));
+                return {
+                    items,
+                    count: items.length,
+                    configuredCount: items.filter((item) => item.classification.lifecycle === "configured").length,
+                    implicitCount: items.filter((item) => item.classification.lifecycle === "implicit")
+                        .length,
+                    installedCount: items.filter((item) => item.installed).length,
+                    unmanagedCount: items.filter((item) => item.classification.lifecycle === "unmanaged")
+                        .length,
+                };
+            };
+            switch (type) {
+                case "skill": {
+                    const installed = yield* scoped.skills.installed;
+                    const resolved = yield* scoped.skills.resolved;
+                    const unmanaged = yield* scoped.skills.unmanaged;
+                    return finalizeInventory(projectStandardInventory({
+                        scope: scoped.scope,
+                        type,
+                        installed,
+                        resolved: Option.getOrElse(resolved, () => []),
+                        unmanaged,
+                        agents: [],
+                        configuredAgents,
+                        packMemberNames,
+                    }));
+                }
+                case "mcp-server": {
+                    const installed = yield* scoped.mcpServers.installed;
+                    const resolved = yield* scoped.mcpServers.resolved;
+                    const unmanaged = yield* scoped.mcpServers.unmanaged;
+                    return finalizeInventory(projectStandardInventory({
+                        scope: scoped.scope,
+                        type,
+                        installed,
+                        resolved: Option.getOrElse(resolved, () => []),
+                        unmanaged,
+                        agents: [],
+                        configuredAgents,
+                        packMemberNames,
+                    }));
+                }
+                case "subagent": {
+                    const installed = yield* scoped.subagents.installed;
+                    const resolved = yield* scoped.subagents.resolved;
+                    const unmanaged = yield* scoped.subagents.unmanaged;
+                    return finalizeInventory(projectStandardInventory({
+                        scope: scoped.scope,
+                        type,
+                        installed,
+                        resolved: Option.getOrElse(resolved, () => []),
+                        unmanaged,
+                        agents: [],
+                        configuredAgents,
+                        packMemberNames,
+                    }));
+                }
+                case "pack": {
+                    const installed = yield* scoped.packs.installed;
+                    const resolved = yield* scoped.packs.resolved;
+                    const unmanaged = yield* scoped.packs.unmanaged;
+                    return finalizeInventory(projectStandardInventory({
+                        scope: scoped.scope,
+                        type,
+                        installed,
+                        resolved: Option.getOrElse(resolved, () => []),
+                        unmanaged,
+                        agents: [],
+                        configuredAgents,
+                        packMemberNames,
+                    }));
+                }
+                case "rule": {
+                    const installed = yield* scoped.rules.installed;
+                    const resolved = yield* scoped.rules.resolved;
+                    const unmanaged = yield* scoped.rules.unmanaged;
+                    return finalizeInventory(projectStandardInventory({
+                        scope: scoped.scope,
+                        type,
+                        installed,
+                        resolved: Option.getOrElse(resolved, () => []),
+                        unmanaged,
+                        agents: [],
+                        configuredAgents,
+                        packMemberNames,
+                    }));
+                }
+                case "hook": {
+                    const installed = yield* scoped.hooks.installed;
+                    const resolved = yield* scoped.hooks.resolved;
+                    const unmanaged = yield* scoped.hooks.unmanaged;
+                    return finalizeInventory(projectStandardInventory({
+                        scope: scoped.scope,
+                        type,
+                        installed,
+                        resolved: Option.getOrElse(resolved, () => []),
+                        unmanaged,
+                        agents: [],
+                        configuredAgents,
+                        packMemberNames,
+                    }));
+                }
+                case "knowledge": {
+                    const installed = yield* scoped.knowledge.installed;
+                    const resolved = yield* scoped.knowledge.resolved;
+                    const unmanaged = yield* scoped.knowledge.unmanaged;
+                    return finalizeInventory(projectStandardInventory({
+                        scope: scoped.scope,
+                        type,
+                        installed,
+                        resolved: Option.getOrElse(resolved, () => []),
+                        unmanaged,
+                        agents: [],
+                        configuredAgents,
+                        packMemberNames,
+                    }));
+                }
+            }
+        }));
+    });
+    const getInventory = (options) => Effect.gen(function* () {
+        const types = options.type === undefined ? installableExtensionTypes : [options.type];
+        const inventories = yield* Effect.forEach(types, (type) => getExtensionInventory(type, {}), {
+            concurrency: "unbounded",
+        });
+        const items = inventories
+            .flatMap((inventory) => inventory.items)
+            .sort((left, right) => left.type === right.type
+            ? left.name.localeCompare(right.name)
+            : left.type.localeCompare(right.type));
+        return {
+            items,
+            count: items.length,
+            configuredCount: inventories.reduce((total, inventory) => total + inventory.configuredCount, 0),
+            implicitCount: inventories.reduce((total, inventory) => total + inventory.implicitCount, 0),
+            installedCount: inventories.reduce((total, inventory) => total + inventory.installedCount, 0),
+            unmanagedCount: inventories.reduce((total, inventory) => total + inventory.unmanagedCount, 0),
+        };
+    });
+    return { getInventory, getReadModelRecordRows, getExtensionInventory };
+};
+//# sourceMappingURL=read-model-record-readers.js.map

package/dist/src/workspace/read-model-record-rows.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Lifecycle views over `ReadModelRecordRow`.
+ *
+ * `WorkspaceReadModelRecords.rows(type)` returns every row the read model
+ * projects for one extension type, tagged with its lifecycle. Callers that
+ * previously reached for a per-type accessor (`getConfiguredSkills`,
+ * `getInstalledPacks`, …) narrow the same rows here instead, so a new
+ * extension type needs no new accessor.
+ *
+ * @internal
+ */
+import type * as Record from "effect/Record";
+import type { ReadModelRecordRow } from "./read-model-record-types.js";
+/** A row declared in `axm.json`, carrying a concrete source string. */
+export type ConfiguredRecordRow = Extract<ReadModelRecordRow, {
+    lifecycle: "configured";
+}>;
+/** A row installed indirectly — a pack member or a lockfile-only entry. */
+export type ImplicitRecordRow = Extract<ReadModelRecordRow, {
+    lifecycle: "implicit";
+}>;
+/** A row observed on disk that no settings or lockfile entry claims. */
+export type UnmanagedRecordRow = Extract<ReadModelRecordRow, {
+    lifecycle: "unmanaged";
+}>;
+/** Configured plus implicit — everything the workspace considers installed. */
+export type InstalledRecordRow = ConfiguredRecordRow | ImplicitRecordRow;
+export declare const isConfiguredRecordRow: (row: ReadModelRecordRow) => row is ConfiguredRecordRow;
+export declare const isUnmanagedRecordRow: (row: ReadModelRecordRow) => row is UnmanagedRecordRow;
+export declare const isInstalledRecordRow: (row: ReadModelRecordRow) => row is InstalledRecordRow;
+export declare const configuredRecordRows: (rows: ReadonlyArray<ReadModelRecordRow>) => ReadonlyArray<ConfiguredRecordRow>;
+export declare const unmanagedRecordRows: (rows: ReadonlyArray<ReadModelRecordRow>) => ReadonlyArray<UnmanagedRecordRow>;
+export declare const installedRecordRows: (rows: ReadonlyArray<ReadModelRecordRow>) => ReadonlyArray<InstalledRecordRow>;
+/**
+ * Index rows by workspace name. Later rows win, matching the projection order
+ * where a direct declaration is emitted before any implicit or unmanaged row
+ * for the same name.
+ */
+export declare const recordRowsByName: <R extends {
+    readonly name: string;
+}>(rows: ReadonlyArray<R>) => Record.ReadonlyRecord<string, R>;
+export declare const configuredRowsByName: (rows: ReadonlyArray<ReadModelRecordRow>) => Record.ReadonlyRecord<string, ConfiguredRecordRow>;
+export declare const installedRowsByName: (rows: ReadonlyArray<ReadModelRecordRow>) => Record.ReadonlyRecord<string, InstalledRecordRow>;
+export declare const unmanagedRowsByName: (rows: ReadonlyArray<ReadModelRecordRow>) => Record.ReadonlyRecord<string, UnmanagedRecordRow>;
+//# sourceMappingURL=read-model-record-rows.d.ts.map

package/dist/src/workspace/read-model-record-rows.js

@@ -0,0 +1,33 @@
+/**
+ * Lifecycle views over `ReadModelRecordRow`.
+ *
+ * `WorkspaceReadModelRecords.rows(type)` returns every row the read model
+ * projects for one extension type, tagged with its lifecycle. Callers that
+ * previously reached for a per-type accessor (`getConfiguredSkills`,
+ * `getInstalledPacks`, …) narrow the same rows here instead, so a new
+ * extension type needs no new accessor.
+ *
+ * @internal
+ */
+export const isConfiguredRecordRow = (row) => row.lifecycle === "configured";
+export const isUnmanagedRecordRow = (row) => row.lifecycle === "unmanaged";
+export const isInstalledRecordRow = (row) => row.lifecycle !== "unmanaged";
+export const configuredRecordRows = (rows) => rows.filter(isConfiguredRecordRow);
+export const unmanagedRecordRows = (rows) => rows.filter(isUnmanagedRecordRow);
+export const installedRecordRows = (rows) => rows.filter(isInstalledRecordRow);
+/**
+ * Index rows by workspace name. Later rows win, matching the projection order
+ * where a direct declaration is emitted before any implicit or unmanaged row
+ * for the same name.
+ */
+export const recordRowsByName = (rows) => {
+    const result = {};
+    for (const row of rows) {
+        result[row.name] = row;
+    }
+    return result;
+};
+export const configuredRowsByName = (rows) => recordRowsByName(configuredRecordRows(rows));
+export const installedRowsByName = (rows) => recordRowsByName(installedRecordRows(rows));
+export const unmanagedRowsByName = (rows) => recordRowsByName(unmanagedRecordRows(rows));
+//# sourceMappingURL=read-model-record-rows.js.map

package/dist/src/workspace/read-model-record-types.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Read-model record row shape returned by `WorkspaceReadModelRecords.rows`.
+ *
+ * One row union covers every extension type; the `lifecycle` discriminant
+ * carries whether the row is declared in settings (`configured`), installed
+ * indirectly through a pack or lockfile entry (`implicit`), or observed on
+ * disk without a claim (`unmanaged`). Narrowing helpers live in
+ * `read-model-record-rows.ts`.
+ *
+ * @internal
+ */
+import type * as Option from "effect/Option";
+export type PackagingKind = "native" | "non-native";
+export type ReadModelRecordRow = ({
+    readonly type: string;
+    readonly name: string;
+    readonly enabled: boolean;
+    readonly origin?: "bundled";
+    readonly packagingKind: PackagingKind;
+    readonly lifecycle: "configured";
+} & ({
+    readonly authority?: "sourced";
+    readonly source: string;
+} | {
+    readonly authority: "inline";
+    readonly source?: undefined;
+})) | {
+    readonly type: string;
+    readonly name: string;
+    readonly source: Option.Option<string>;
+    readonly enabled: true;
+    readonly packagingKind: PackagingKind;
+    readonly lifecycle: "implicit";
+} | {
+    readonly type: string;
+    readonly name: string;
+    readonly source: Option.Option<string>;
+    readonly enabled: true;
+    readonly packagingKind: PackagingKind;
+    readonly locations: ReadonlyArray<string>;
+    readonly agents: ReadonlyArray<string>;
+    readonly ownershipEvidence: ReadonlyArray<string>;
+    readonly lifecycle: "unmanaged";
+};
+//# sourceMappingURL=read-model-record-types.d.ts.map

package/dist/src/workspace/read-model-record-types.js

@@ -0,0 +1,13 @@
+/**
+ * Read-model record row shape returned by `WorkspaceReadModelRecords.rows`.
+ *
+ * One row union covers every extension type; the `lifecycle` discriminant
+ * carries whether the row is declared in settings (`configured`), installed
+ * indirectly through a pack or lockfile entry (`implicit`), or observed on
+ * disk without a claim (`unmanaged`). Narrowing helpers live in
+ * `read-model-record-rows.ts`.
+ *
+ * @internal
+ */
+export {};
+//# sourceMappingURL=read-model-record-types.js.map

package/dist/src/workspace/remove-if-exists.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Transaction-aware removal of canonical extension paths.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as FileSystem from "effect/FileSystem";
+import * as Effect from "effect/Effect";
+import { CanonicalPathRemovalError } from "./errors.js";
+/**
+ * Remove a directory if it exists.
+ */
+export declare const removeIfExists: (fsService: FileSystem.FileSystem, dirPath: string) => Effect.Effect<void, import("./transaction.js").WorkspaceSnapshotError | CanonicalPathRemovalError, never>;
+//# sourceMappingURL=remove-if-exists.d.ts.map

package/dist/src/workspace/remove-if-exists.js

@@ -0,0 +1,26 @@
+/**
+ * Transaction-aware removal of canonical extension paths.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as FileSystem from "effect/FileSystem";
+import * as Effect from "effect/Effect";
+import { CanonicalPathRemovalError } from "./errors.js";
+import { protectWorkspacePath } from "./transaction.js";
+import { recordFootprint } from "./footprint-recorder.js";
+/**
+ * Remove a directory if it exists.
+ */
+export const removeIfExists = (fsService, dirPath) => Effect.gen(function* () {
+    const exists = yield* fsService
+        .exists(dirPath)
+        .pipe(Effect.mapError((cause) => new CanonicalPathRemovalError({ path: dirPath, step: "inspect", cause })));
+    if (!exists)
+        return;
+    yield* protectWorkspacePath(dirPath);
+    yield* fsService
+        .remove(dirPath, { recursive: true })
+        .pipe(Effect.mapError((cause) => new CanonicalPathRemovalError({ path: dirPath, step: "remove", cause })));
+    yield* recordFootprint({ path: dirPath, change: "removed" });
+});
+//# sourceMappingURL=remove-if-exists.js.map