@agentxm/client-core 0.13.1 → 0.13.2

package/dist/src/unstable/workspace/service.js

@@ -262,40 +262,40 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
             yield* writeSettings(workspaceDir, updatedSettings).pipe(Effect.provide(fsLayer));
         })).pipe(Effect.withSpan("WorkspaceMutations.setInstructionsConfig")),
         getConfiguredMcpServerEntries: () => readSettingsSafe(workspaceDir).pipe(Effect.map((s) => s.mcpServers ?? {}), Effect.withSpan("WorkspaceMutations.getConfiguredMcpServerEntries")),
-        getConfiguredDocsEntries: () => readSettingsSafe(workspaceDir).pipe(Effect.map((s) => s.docs ?? {}), Effect.withSpan("WorkspaceMutations.getConfiguredDocsEntries")),
+        getConfiguredFilesEntries: () => readSettingsSafe(workspaceDir).pipe(Effect.map((s) => s.files ?? {}), Effect.withSpan("WorkspaceMutations.getConfiguredFilesEntries")),
         getWorkspaceVars: () => readSettingsSafe(workspaceDir).pipe(Effect.map((s) => s.vars ?? {}), Effect.withSpan("WorkspaceMutations.getWorkspaceVars")),
-        getLockedDocs: () => readLockfileSafe(workspaceDir).pipe(Effect.map((lf) => lf.docs ?? {})),
-        getLockedDocsEntry: (name) => readLockfileSafe(workspaceDir).pipe(Effect.map((lf) => Option.fromUndefinedOr((lf.docs ?? {})[name]))),
-        setDocs: ({ name, lockEntry, versionRange }) => withMutex(Effect.gen(function* () {
+        getLockedFiles: () => readLockfileSafe(workspaceDir).pipe(Effect.map((lf) => lf.files ?? {})),
+        getLockedFilesEntry: (name) => readLockfileSafe(workspaceDir).pipe(Effect.map((lf) => Option.fromUndefinedOr((lf.files ?? {})[name]))),
+        setFiles: ({ name, lockEntry, versionRange }) => withMutex(Effect.gen(function* () {
             const source = lockEntry.type === "registry"
                 ? (() => {
                     const fqn = formatFqn({
                         owner: lockEntry.owner,
-                        type: "docs",
+                        type: "files",
                         name: decodeExtensionNameSync(name),
                     });
                     return Option.isSome(versionRange) ? `${fqn}@${versionRange.value}` : fqn;
                 })()
                 : printSourceParams(lockEntryToSourceParams(lockEntry));
             const currentSettings = yield* readSettingsSafe(workspaceDir);
-            const currentContext = currentSettings.docs ?? {};
+            const currentContext = currentSettings.files ?? {};
             const currentEntry = currentContext[name];
             const authored = currentEntry?.authored ?? false;
             const inputs = currentEntry?.inputs ?? {};
             const updatedSettings = {
                 ...currentSettings,
-                docs: {
+                files: {
                     ...currentContext,
                     [name]: { source, enabled: true, authored, inputs },
                 },
             };
             yield* writeSettings(workspaceDir, updatedSettings).pipe(Effect.provide(fsLayer));
             const currentLockfile = yield* readLockfileSafe(workspaceDir);
-            const currentLockedContext = currentLockfile.docs ?? {};
+            const currentLockedContext = currentLockfile.files ?? {};
             const previous = currentLockedContext[name];
             const updatedLockfile = {
                 ...currentLockfile,
-                docs: {
+                files: {
                     ...currentLockedContext,
                     [name]: {
                         ...lockEntry,
@@ -305,14 +305,14 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
                 },
             };
             yield* writeLockfile(workspaceDir, updatedLockfile).pipe(Effect.provide(fsLayer));
-        })).pipe(Effect.withSpan("WorkspaceMutations.setDocs")),
-        setDocsLock: ({ name, lockEntry }) => withMutex(Effect.gen(function* () {
+        })).pipe(Effect.withSpan("WorkspaceMutations.setFiles")),
+        setFilesLock: ({ name, lockEntry }) => withMutex(Effect.gen(function* () {
             const currentLockfile = yield* readLockfileSafe(workspaceDir);
-            const currentLockedContext = currentLockfile.docs ?? {};
+            const currentLockedContext = currentLockfile.files ?? {};
             const previous = currentLockedContext[name];
             const updatedLockfile = {
                 ...currentLockfile,
-                docs: {
+                files: {
                     ...currentLockedContext,
                     [name]: {
                         ...lockEntry,
@@ -322,72 +322,314 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
                 },
             };
             yield* writeLockfile(workspaceDir, updatedLockfile).pipe(Effect.provide(fsLayer));
-        })).pipe(Effect.withSpan("WorkspaceMutations.setDocsLock")),
-        removeDocs: (name) => withMutex(Effect.gen(function* () {
+        })).pipe(Effect.withSpan("WorkspaceMutations.setFilesLock")),
+        removeFiles: (name) => withMutex(Effect.gen(function* () {
             const currentSettings = yield* readSettingsSafe(workspaceDir);
-            const currentContext = currentSettings.docs ?? {};
+            const currentContext = currentSettings.files ?? {};
             const remainingSettings = name in currentContext
                 ? (() => {
                     const { [name]: _, ...remainingContext } = currentContext;
                     void _;
-                    return { ...currentSettings, docs: remainingContext };
+                    return { ...currentSettings, files: remainingContext };
                 })()
                 : currentSettings;
             const currentLockfile = yield* readLockfileSafe(workspaceDir);
-            const currentLockedContext = currentLockfile.docs ?? {};
+            const currentLockedContext = currentLockfile.files ?? {};
             const remainingLockfile = name in currentLockedContext
                 ? (() => {
                     const { [name]: _, ...remainingContext } = currentLockedContext;
                     void _;
-                    return { ...currentLockfile, docs: remainingContext };
+                    return { ...currentLockfile, files: remainingContext };
                 })()
                 : currentLockfile;
             yield* writeSettings(workspaceDir, remainingSettings).pipe(Effect.provide(fsLayer));
             yield* writeLockfile(workspaceDir, remainingLockfile).pipe(Effect.provide(fsLayer));
-        })).pipe(Effect.withSpan("WorkspaceMutations.removeDocs")),
-        removeDocsSettings: (name) => withMutex(Effect.gen(function* () {
+        })).pipe(Effect.withSpan("WorkspaceMutations.removeFiles")),
+        removeFilesSettings: (name) => withMutex(Effect.gen(function* () {
             const currentSettings = yield* readSettingsSafe(workspaceDir);
-            const currentContext = currentSettings.docs ?? {};
+            const currentContext = currentSettings.files ?? {};
             if (!(name in currentContext))
                 return;
             const { [name]: _, ...remainingContext } = currentContext;
             void _;
             yield* writeSettings(workspaceDir, {
                 ...currentSettings,
-                docs: remainingContext,
+                files: remainingContext,
             }).pipe(Effect.provide(fsLayer));
-        })).pipe(Effect.withSpan("WorkspaceMutations.removeDocsSettings")),
-        removeDocsLock: (name) => withMutex(Effect.gen(function* () {
+        })).pipe(Effect.withSpan("WorkspaceMutations.removeFilesSettings")),
+        removeFilesLock: (name) => withMutex(Effect.gen(function* () {
             const currentLockfile = yield* readLockfileSafe(workspaceDir);
-            const currentLockedContext = currentLockfile.docs ?? {};
+            const currentLockedContext = currentLockfile.files ?? {};
             if (!(name in currentLockedContext))
                 return;
             const { [name]: _, ...remainingContext } = currentLockedContext;
             void _;
             yield* writeLockfile(workspaceDir, {
                 ...currentLockfile,
-                docs: remainingContext,
+                files: remainingContext,
             }).pipe(Effect.provide(fsLayer));
-        })).pipe(Effect.withSpan("WorkspaceMutations.removeDocsLock")),
-        updateDocsEntry: (name, updater) => withMutex(Effect.gen(function* () {
+        })).pipe(Effect.withSpan("WorkspaceMutations.removeFilesLock")),
+        updateFilesEntry: (name, updater) => withMutex(Effect.gen(function* () {
             const currentSettings = yield* readSettingsSafe(workspaceDir);
-            const currentContext = currentSettings.docs ?? {};
+            const currentContext = currentSettings.files ?? {};
             const existingEntry = currentContext[name];
             if (existingEntry === undefined)
                 return;
             yield* writeSettings(workspaceDir, {
                 ...currentSettings,
-                docs: { ...currentContext, [name]: updater(existingEntry) },
+                files: { ...currentContext, [name]: updater(existingEntry) },
             }).pipe(Effect.provide(fsLayer));
-        })).pipe(Effect.withSpan("WorkspaceMutations.updateDocsEntry")),
-        setDocsEntry: (name, entry) => withMutex(Effect.gen(function* () {
+        })).pipe(Effect.withSpan("WorkspaceMutations.updateFilesEntry")),
+        setFilesEntry: (name, entry) => withMutex(Effect.gen(function* () {
             const currentSettings = yield* readSettingsSafe(workspaceDir);
-            const currentContext = currentSettings.docs ?? {};
+            const currentContext = currentSettings.files ?? {};
             yield* writeSettings(workspaceDir, {
                 ...currentSettings,
-                docs: { ...currentContext, [name]: entry },
+                files: { ...currentContext, [name]: entry },
             }).pipe(Effect.provide(fsLayer));
-        })).pipe(Effect.withSpan("WorkspaceMutations.setDocsEntry")),
+        })).pipe(Effect.withSpan("WorkspaceMutations.setFilesEntry")),
+        getConfiguredRuleEntries: () => readSettingsSafe(workspaceDir).pipe(Effect.map((s) => s.rules ?? {}), Effect.withSpan("WorkspaceMutations.getConfiguredRuleEntries")),
+        getLockedRules: () => readLockfileSafe(workspaceDir).pipe(Effect.map((lf) => lf.rules ?? {})),
+        getLockedRuleEntry: (name) => readLockfileSafe(workspaceDir).pipe(Effect.map((lf) => Option.fromUndefinedOr((lf.rules ?? {})[name]))),
+        setRule: ({ name, lockEntry, versionRange }) => withMutex(Effect.gen(function* () {
+            const source = lockEntry.type === "registry"
+                ? (() => {
+                    const fqn = formatFqn({
+                        owner: lockEntry.owner,
+                        type: "rule",
+                        name: decodeExtensionNameSync(name),
+                    });
+                    return Option.isSome(versionRange) ? `${fqn}@${versionRange.value}` : fqn;
+                })()
+                : printSourceParams(lockEntryToSourceParams(lockEntry));
+            const currentSettings = yield* readSettingsSafe(workspaceDir);
+            const currentRules = currentSettings.rules ?? {};
+            const currentEntry = currentRules[name];
+            const authored = currentEntry?.authored ?? false;
+            yield* writeSettings(workspaceDir, {
+                ...currentSettings,
+                rules: {
+                    ...currentRules,
+                    [name]: { source, enabled: true, authored },
+                },
+            }).pipe(Effect.provide(fsLayer));
+            const currentLockfile = yield* readLockfileSafe(workspaceDir);
+            const currentLockedRules = currentLockfile.rules ?? {};
+            const previous = currentLockedRules[name];
+            yield* writeLockfile(workspaceDir, {
+                ...currentLockfile,
+                rules: {
+                    ...currentLockedRules,
+                    [name]: {
+                        ...lockEntry,
+                        installedAt: previous?.installedAt ?? lockEntry.installedAt,
+                        updatedAt: new Date(),
+                    },
+                },
+            }).pipe(Effect.provide(fsLayer));
+        })).pipe(Effect.withSpan("WorkspaceMutations.setRule")),
+        setRuleLock: ({ name, lockEntry }) => withMutex(Effect.gen(function* () {
+            const currentLockfile = yield* readLockfileSafe(workspaceDir);
+            const currentLockedRules = currentLockfile.rules ?? {};
+            const previous = currentLockedRules[name];
+            yield* writeLockfile(workspaceDir, {
+                ...currentLockfile,
+                rules: {
+                    ...currentLockedRules,
+                    [name]: {
+                        ...lockEntry,
+                        installedAt: previous?.installedAt ?? lockEntry.installedAt,
+                        updatedAt: new Date(),
+                    },
+                },
+            }).pipe(Effect.provide(fsLayer));
+        })).pipe(Effect.withSpan("WorkspaceMutations.setRuleLock")),
+        removeRule: (name) => withMutex(Effect.gen(function* () {
+            const currentSettings = yield* readSettingsSafe(workspaceDir);
+            const currentRules = currentSettings.rules ?? {};
+            const remainingSettings = name in currentRules
+                ? (() => {
+                    const { [name]: _, ...remainingRules } = currentRules;
+                    void _;
+                    return { ...currentSettings, rules: remainingRules };
+                })()
+                : currentSettings;
+            const currentLockfile = yield* readLockfileSafe(workspaceDir);
+            const currentLockedRules = currentLockfile.rules ?? {};
+            const remainingLockfile = name in currentLockedRules
+                ? (() => {
+                    const { [name]: _, ...remainingRules } = currentLockedRules;
+                    void _;
+                    return { ...currentLockfile, rules: remainingRules };
+                })()
+                : currentLockfile;
+            yield* writeSettings(workspaceDir, remainingSettings).pipe(Effect.provide(fsLayer));
+            yield* writeLockfile(workspaceDir, remainingLockfile).pipe(Effect.provide(fsLayer));
+        })).pipe(Effect.withSpan("WorkspaceMutations.removeRule")),
+        removeRuleSettings: (name) => withMutex(Effect.gen(function* () {
+            const currentSettings = yield* readSettingsSafe(workspaceDir);
+            const currentRules = currentSettings.rules ?? {};
+            if (!(name in currentRules))
+                return;
+            const { [name]: _, ...remainingRules } = currentRules;
+            void _;
+            yield* writeSettings(workspaceDir, {
+                ...currentSettings,
+                rules: remainingRules,
+            }).pipe(Effect.provide(fsLayer));
+        })).pipe(Effect.withSpan("WorkspaceMutations.removeRuleSettings")),
+        removeRuleLock: (name) => withMutex(Effect.gen(function* () {
+            const currentLockfile = yield* readLockfileSafe(workspaceDir);
+            const currentLockedRules = currentLockfile.rules ?? {};
+            if (!(name in currentLockedRules))
+                return;
+            const { [name]: _, ...remainingRules } = currentLockedRules;
+            void _;
+            yield* writeLockfile(workspaceDir, {
+                ...currentLockfile,
+                rules: remainingRules,
+            }).pipe(Effect.provide(fsLayer));
+        })).pipe(Effect.withSpan("WorkspaceMutations.removeRuleLock")),
+        updateRuleEntry: (name, updater) => withMutex(Effect.gen(function* () {
+            const currentSettings = yield* readSettingsSafe(workspaceDir);
+            const currentRules = currentSettings.rules ?? {};
+            const existingEntry = currentRules[name];
+            if (existingEntry === undefined)
+                return;
+            yield* writeSettings(workspaceDir, {
+                ...currentSettings,
+                rules: { ...currentRules, [name]: updater(existingEntry) },
+            }).pipe(Effect.provide(fsLayer));
+        })).pipe(Effect.withSpan("WorkspaceMutations.updateRuleEntry")),
+        setRuleEntry: (name, entry) => withMutex(Effect.gen(function* () {
+            const currentSettings = yield* readSettingsSafe(workspaceDir);
+            const currentRules = currentSettings.rules ?? {};
+            yield* writeSettings(workspaceDir, {
+                ...currentSettings,
+                rules: { ...currentRules, [name]: entry },
+            }).pipe(Effect.provide(fsLayer));
+        })).pipe(Effect.withSpan("WorkspaceMutations.setRuleEntry")),
+        getConfiguredHookEntries: () => readSettingsSafe(workspaceDir).pipe(Effect.map((s) => s.hooks ?? {}), Effect.withSpan("WorkspaceMutations.getConfiguredHookEntries")),
+        getLockedHooks: () => readLockfileSafe(workspaceDir).pipe(Effect.map((lf) => lf.hooks ?? {})),
+        getLockedHookEntry: (name) => readLockfileSafe(workspaceDir).pipe(Effect.map((lf) => Option.fromUndefinedOr((lf.hooks ?? {})[name]))),
+        setHook: ({ name, lockEntry, versionRange }) => withMutex(Effect.gen(function* () {
+            const source = lockEntry.type === "registry"
+                ? (() => {
+                    const fqn = formatFqn({
+                        owner: lockEntry.owner,
+                        type: "hook",
+                        name: decodeExtensionNameSync(name),
+                    });
+                    return Option.isSome(versionRange) ? `${fqn}@${versionRange.value}` : fqn;
+                })()
+                : printSourceParams(lockEntryToSourceParams(lockEntry));
+            const currentSettings = yield* readSettingsSafe(workspaceDir);
+            const currentHooks = currentSettings.hooks ?? {};
+            const currentEntry = currentHooks[name];
+            const authored = currentEntry?.authored ?? false;
+            yield* writeSettings(workspaceDir, {
+                ...currentSettings,
+                hooks: {
+                    ...currentHooks,
+                    [name]: { source, enabled: true, authored },
+                },
+            }).pipe(Effect.provide(fsLayer));
+            const currentLockfile = yield* readLockfileSafe(workspaceDir);
+            const currentLockedHooks = currentLockfile.hooks ?? {};
+            const previous = currentLockedHooks[name];
+            yield* writeLockfile(workspaceDir, {
+                ...currentLockfile,
+                hooks: {
+                    ...currentLockedHooks,
+                    [name]: {
+                        ...lockEntry,
+                        installedAt: previous?.installedAt ?? lockEntry.installedAt,
+                        updatedAt: new Date(),
+                    },
+                },
+            }).pipe(Effect.provide(fsLayer));
+        })).pipe(Effect.withSpan("WorkspaceMutations.setHook")),
+        setHookLock: ({ name, lockEntry }) => withMutex(Effect.gen(function* () {
+            const currentLockfile = yield* readLockfileSafe(workspaceDir);
+            const currentLockedHooks = currentLockfile.hooks ?? {};
+            const previous = currentLockedHooks[name];
+            yield* writeLockfile(workspaceDir, {
+                ...currentLockfile,
+                hooks: {
+                    ...currentLockedHooks,
+                    [name]: {
+                        ...lockEntry,
+                        installedAt: previous?.installedAt ?? lockEntry.installedAt,
+                        updatedAt: new Date(),
+                    },
+                },
+            }).pipe(Effect.provide(fsLayer));
+        })).pipe(Effect.withSpan("WorkspaceMutations.setHookLock")),
+        removeHook: (name) => withMutex(Effect.gen(function* () {
+            const currentSettings = yield* readSettingsSafe(workspaceDir);
+            const currentHooks = currentSettings.hooks ?? {};
+            const remainingSettings = name in currentHooks
+                ? (() => {
+                    const { [name]: _, ...remainingHooks } = currentHooks;
+                    void _;
+                    return { ...currentSettings, hooks: remainingHooks };
+                })()
+                : currentSettings;
+            const currentLockfile = yield* readLockfileSafe(workspaceDir);
+            const currentLockedHooks = currentLockfile.hooks ?? {};
+            const remainingLockfile = name in currentLockedHooks
+                ? (() => {
+                    const { [name]: _, ...remainingHooks } = currentLockedHooks;
+                    void _;
+                    return { ...currentLockfile, hooks: remainingHooks };
+                })()
+                : currentLockfile;
+            yield* writeSettings(workspaceDir, remainingSettings).pipe(Effect.provide(fsLayer));
+            yield* writeLockfile(workspaceDir, remainingLockfile).pipe(Effect.provide(fsLayer));
+        })).pipe(Effect.withSpan("WorkspaceMutations.removeHook")),
+        removeHookSettings: (name) => withMutex(Effect.gen(function* () {
+            const currentSettings = yield* readSettingsSafe(workspaceDir);
+            const currentHooks = currentSettings.hooks ?? {};
+            if (!(name in currentHooks))
+                return;
+            const { [name]: _, ...remainingHooks } = currentHooks;
+            void _;
+            yield* writeSettings(workspaceDir, {
+                ...currentSettings,
+                hooks: remainingHooks,
+            }).pipe(Effect.provide(fsLayer));
+        })).pipe(Effect.withSpan("WorkspaceMutations.removeHookSettings")),
+        removeHookLock: (name) => withMutex(Effect.gen(function* () {
+            const currentLockfile = yield* readLockfileSafe(workspaceDir);
+            const currentLockedHooks = currentLockfile.hooks ?? {};
+            if (!(name in currentLockedHooks))
+                return;
+            const { [name]: _, ...remainingHooks } = currentLockedHooks;
+            void _;
+            yield* writeLockfile(workspaceDir, {
+                ...currentLockfile,
+                hooks: remainingHooks,
+            }).pipe(Effect.provide(fsLayer));
+        })).pipe(Effect.withSpan("WorkspaceMutations.removeHookLock")),
+        updateHookEntry: (name, updater) => withMutex(Effect.gen(function* () {
+            const currentSettings = yield* readSettingsSafe(workspaceDir);
+            const currentHooks = currentSettings.hooks ?? {};
+            const existingEntry = currentHooks[name];
+            if (existingEntry === undefined)
+                return;
+            yield* writeSettings(workspaceDir, {
+                ...currentSettings,
+                hooks: { ...currentHooks, [name]: updater(existingEntry) },
+            }).pipe(Effect.provide(fsLayer));
+        })).pipe(Effect.withSpan("WorkspaceMutations.updateHookEntry")),
+        setHookEntry: (name, entry) => withMutex(Effect.gen(function* () {
+            const currentSettings = yield* readSettingsSafe(workspaceDir);
+            const currentHooks = currentSettings.hooks ?? {};
+            yield* writeSettings(workspaceDir, {
+                ...currentSettings,
+                hooks: { ...currentHooks, [name]: entry },
+            }).pipe(Effect.provide(fsLayer));
+        })).pipe(Effect.withSpan("WorkspaceMutations.setHookEntry")),
         getLockedSkills: () => readLockfileSafe(workspaceDir).pipe(Effect.map((lf) => lf.skills)),
         getLockedSkill: (name) => readLockfileSafe(workspaceDir).pipe(Effect.map((lf) => Option.fromUndefinedOr(lf.skills[name]))),
         getSkillDir: (name, source) => Effect.gen(function* () {
@@ -1033,7 +1275,11 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
                         ? packEntry.resolvedCommands
                         : target.type === "mcp-server"
                             ? packEntry.resolvedMcpServers
-                            : (packEntry.resolvedDocs ?? {});
+                            : target.type === "files"
+                                ? (packEntry.resolvedFiles ?? {})
+                                : target.type === "rule"
+                                    ? (packEntry.resolvedRules ?? {})
+                                    : (packEntry.resolvedHooks ?? {});
                 // Check if any FQN key in the resolved map ends with the target name
                 for (const fqn of Object.keys(resolvedMap)) {
                     const resolvedName = parseExtensionFqnParts(fqn)?.name;
@@ -1090,15 +1336,45 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
                     yield* writeLockfile(workspaceDir, updatedLockfile).pipe(Effect.provide(fsLayer));
                     break;
                 }
-                case "docs": {
-                    const docs = currentLockfile.docs ?? {};
-                    const entry = docs[target.name];
+                case "files": {
+                    const files = currentLockfile.files ?? {};
+                    const entry = files[target.name];
+                    if (entry === undefined)
+                        return;
+                    const updatedLockfile = {
+                        ...currentLockfile,
+                        files: {
+                            ...files,
+                            [target.name]: { ...entry, retainedByPack: true },
+                        },
+                    };
+                    yield* writeLockfile(workspaceDir, updatedLockfile).pipe(Effect.provide(fsLayer));
+                    break;
+                }
+                case "rule": {
+                    const rules = currentLockfile.rules ?? {};
+                    const entry = rules[target.name];
+                    if (entry === undefined)
+                        return;
+                    const updatedLockfile = {
+                        ...currentLockfile,
+                        rules: {
+                            ...rules,
+                            [target.name]: { ...entry, retainedByPack: true },
+                        },
+                    };
+                    yield* writeLockfile(workspaceDir, updatedLockfile).pipe(Effect.provide(fsLayer));
+                    break;
+                }
+                case "hook": {
+                    const hooks = currentLockfile.hooks ?? {};
+                    const entry = hooks[target.name];
                     if (entry === undefined)
                         return;
                     const updatedLockfile = {
                         ...currentLockfile,
-                        docs: {
-                            ...docs,
+                        hooks: {
+                            ...hooks,
                             [target.name]: { ...entry, retainedByPack: true },
                         },
                     };