cozy-search 2.5.1 → 2.6.0

package/README.md

@@ -59,48 +59,72 @@ of verbs (cozy-home and cozy-drive use `ALL`).
 
 ### RAG indexing setup
 
-Opening the assistant (`AssistantView` or `AssistantDialog`) calls
-`autoprovisionAssistants(client)` once per session: when the
-`cozy.assistant.autoprovision` flag lists assistants, it makes sure the
-`rag-index` triggers exist, gives the root folder to the assistants that
-have no knowledge base folder, then runs
-`ensureProvisionedAssistants(client, entries)`.
-
-A host app should only call the `useRagIndexTriggers` hook (or
-`ensureRagIndexTriggers(client)`) at startup: one request when the
-triggers already exist, and the knowledge base folders get indexed as
-they change before the assistant is ever opened. The assistants are
-provisioned when the assistant opens; a host app that wants that earlier
-can call `autoprovisionAssistants(client)` or the
-`useAssistantsAutoprovision` hook. Every call shares the first one's
-promise, the triggers step included, so nothing runs twice.
-
-`setupRagIndexing(client)` makes sure the instance's two
-`rag-index` triggers exist (one on `io.cozy.files`, one on
-`io.cozy.ai.chat.assistants`) and gives the root folder to any assistant
-that has no knowledge base folder yet — the stack's `rag-index` worker
-reads the assistants to know what to index, cozy-search only has to keep
-the triggers and the assistants' `knowledgeBase` in shape.
-
-It needs the following permissions: `io.cozy.triggers` and `io.cozy.jobs`
-(to create and launch the triggers), `io.cozy.ai.chat.assistants` and
-`io.cozy.files` (to read and migrate the assistants). It is idempotent and
-never throws: on a stack whose `rag-index` worker is still reserved, the
-403 is logged and the app keeps working. `ensureProvisionedAssistants`
-additionally creates one `io.cozy.accounts` document per provisioned
-assistant, and the `dirName` folder in `io.cozy.files`.
-
-An entry of `cozy.assistant.autoprovision` can carry `"default": true`
-(the first flagged entry wins if there are several). Every NEW
-conversation then starts on that assistant once its document exists —
-from the session after it was provisioned onward. Existing conversations
-are unaffected: they keep their own assistant, or stay unscoped if they
-had none.
+The stack's `rag-index` worker indexes the files of the assistants'
+knowledge base folders. For that an instance needs two things: its two
+`rag-index` triggers (one on `io.cozy.files`, one on
+`io.cozy.ai.chat.assistants`), and assistants that carry a knowledge base
+folder. cozy-search sets both up when the `cozy.assistant.autoprovision`
+flag lists assistants. Without the flag, it does nothing.
+
+#### The flag
+
+A list of assistants to create, one entry each:
 
 ```json
-{ "name": "Mes documents", "dirName": "Documents", "default": true }
+[{ "name": "Mes documents", "dirName": "Documents", "default": true }]
 ```
 
+- `name`: the name of the assistant. Its id is derived from it.
+- `dirId` or `dirName`: its knowledge base folder. `dirId` wins; it can be
+  the root folder or a magic folder (`io.cozy.apps/<slug>`). `dirName` is
+  a folder at the root of the Drive, created when it does not exist.
+- `prompt`, `icon`: optional.
+- `default`: new conversations start on this assistant once it exists
+  (the first entry flagged so wins). Existing conversations keep their
+  own assistant.
+
+#### Normal behaviour
+
+A host app calls `ensureAssistantsSetup(client)` at startup (or its
+`useAssistantsSetup` hook):
+
+1. It fetches the `rag-index` triggers. When both exist, an earlier
+   session went through the setup and it stops there: one request.
+2. Otherwise it runs the whole setup, `autoprovisionAssistants(client)`:
+   each entry of the flag gets its `io.cozy.accounts` document, its
+   assistant and its knowledge base folder, then the two triggers are
+   created and the files one is launched, which starts the indexing of
+   the folders. The triggers come last so that their presence means the
+   setup completed.
+
+cozy-search also runs `autoprovisionAssistants(client)` itself when the
+assistant is opened. On an instance already set up it only lists the
+assistants; it is there to catch a flag changed since the setup, and to
+give its folder back to a provisioned assistant that lost it.
+
+Both run once per session and share their work, so nothing runs twice.
+They never throw: on a stack whose `rag-index` worker is still reserved,
+the 403 on the triggers is logged and the app keeps working.
+
+#### Migration of the existing assistants
+
+Assistants created before a knowledge base folder became mandatory have
+none, and the worker indexes nothing for them. The setup gives them the
+root folder, that is the whole Drive. This is a one-off data migration,
+unrelated to the entries of the flag: once every assistant has a folder,
+it finds nothing to do.
+
+An app that manages its assistants itself, without the flag, can call
+`setupRagIndexing(client)`: the triggers and this migration, no
+provisioning.
+
+#### Permissions
+
+`io.cozy.triggers` and `io.cozy.jobs` (to create and launch the
+triggers), `io.cozy.ai.chat.assistants` and `io.cozy.files` (to read,
+migrate and provision the assistants and their folders), and
+`io.cozy.accounts` (one document per provisioned assistant).
+
 ### On desktop
 
 You can add the search bar like this :

package/dist/components/KnowledgeBase/autoprovision.d.ts

@@ -1,9 +1,5 @@
 export function resetAutoprovisionForTests(): void;
 export function autoprovisionEntries(): Array<object> | null;
-export function ensureRagIndexTriggers(client: import("cozy-client").CozyClient): Promise<{
-    triggers: string[];
-    error: Error | null;
-}>;
 export function autoprovisionAssistants(client: import("cozy-client").CozyClient): Promise<null | {
     setup: object;
     created: string[];
@@ -13,3 +9,4 @@ export function autoprovisionAssistants(client: import("cozy-client").CozyClient
         reason: string;
     }[];
 }>;
+export function ensureAssistantsSetup(client: import("cozy-client").CozyClient): Promise<null | object>;

package/dist/components/KnowledgeBase/autoprovision.js

@@ -5,7 +5,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.resetAutoprovisionForTests = exports.ensureRagIndexTriggers = exports.autoprovisionEntries = exports.autoprovisionAssistants = void 0;
+exports.resetAutoprovisionForTests = exports.ensureAssistantsSetup = exports.autoprovisionEntries = exports.autoprovisionAssistants = void 0;
 
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 
@@ -34,12 +34,12 @@ var warn = function warn() {
   (_console = console).warn.apply(_console, ['cozy-search autoprovision:'].concat(args));
 };
 
-var triggersPending = null;
 var pending = null;
+var setupPending = null;
 
 var resetAutoprovisionForTests = function resetAutoprovisionForTests() {
-  triggersPending = null;
   pending = null;
+  setupPending = null;
 };
 /**
  * The entries of the autoprovision flag, or null when it lists nothing.
@@ -53,44 +53,12 @@ var autoprovisionEntries = function autoprovisionEntries() {
   var entries = (0, _cozyFlags.default)(_provisioning.AUTOPROVISION_FLAG);
   return Array.isArray(entries) && entries.length > 0 ? entries : null;
 };
-/**
- * Makes sure the instance has its rag-index triggers, so the files of the
- * knowledge base folders get indexed as they change. Runs once per session
- * and never rejects: a host app can call it at startup, it costs a single
- * request when the triggers already exist.
- * @param {import('cozy-client').CozyClient} client - The cozy client.
- * @returns {Promise<{triggers: string[], error: Error|null}>} The
- * `arguments` of the triggers created, and the failure if any.
- */
-
 
 exports.autoprovisionEntries = autoprovisionEntries;
 
-var ensureRagIndexTriggers = function ensureRagIndexTriggers(client) {
-  if (!triggersPending) {
-    triggersPending = (0, _ragIndexing.createRagIndexTriggers)(client).then(function (triggers) {
-      return {
-        triggers: triggers,
-        error: null
-      };
-    }, function (error) {
-      warn('cannot set up the rag-index triggers', error);
-      return {
-        triggers: [],
-        error: error
-      };
-    });
-  }
-
-  return triggersPending;
-};
-
-exports.ensureRagIndexTriggers = ensureRagIndexTriggers;
-
 var run = /*#__PURE__*/function () {
   var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(client) {
-    var entries, setup, _yield$ensureRagIndex, triggers, error, assistants, result;
-
+    var entries, setup, assistants, result;
     return _regenerator.default.wrap(function _callee$(_context) {
       while (1) {
         switch (_context.prev = _context.next) {
@@ -110,59 +78,68 @@ var run = /*#__PURE__*/function () {
               migrated: [],
               errors: []
             };
-            _context.next = 6;
-            return ensureRagIndexTriggers(client);
-
-          case 6:
-            _yield$ensureRagIndex = _context.sent;
-            triggers = _yield$ensureRagIndex.triggers;
-            error = _yield$ensureRagIndex.error;
-            setup.triggers = triggers;
-            if (error) setup.errors.push(error);
             assistants = null;
-            _context.prev = 12;
-            _context.next = 15;
+            _context.prev = 5;
+            _context.next = 8;
             return (0, _ragIndexing.fetchAssistants)(client);
 
-          case 15:
+          case 8:
             assistants = _context.sent;
-            _context.next = 18;
+            _context.next = 11;
             return (0, _ragIndexing.migrateAssistantsWithoutFolder)(client, assistants);
 
-          case 18:
+          case 11:
             setup.migrated = _context.sent;
-            _context.next = 25;
+            _context.next = 18;
             break;
 
-          case 21:
-            _context.prev = 21;
-            _context.t0 = _context["catch"](12);
+          case 14:
+            _context.prev = 14;
+            _context.t0 = _context["catch"](5);
             warn('cannot migrate the assistants without folder', _context.t0);
             setup.errors.push(_context.t0);
 
-          case 25:
-            _context.next = 27;
+          case 18:
+            _context.next = 20;
             return (0, _provisioning.ensureProvisionedAssistants)(client, entries, {
               assistants: assistants
             });
 
-          case 27:
+          case 20:
             result = _context.sent;
 
             if (result.skipped.length > 0) {
               warn('skipped entries', result.skipped);
-            }
+            } // Last: the triggers tell ensureAssistantsSetup that the setup completed,
+            // and the launch of the files one indexes the folders just provisioned.
 
+
+            _context.prev = 22;
+            _context.next = 25;
+            return (0, _ragIndexing.createRagIndexTriggers)(client);
+
+          case 25:
+            setup.triggers = _context.sent;
+            _context.next = 32;
+            break;
+
+          case 28:
+            _context.prev = 28;
+            _context.t1 = _context["catch"](22);
+            warn('cannot set up the rag-index triggers', _context.t1);
+            setup.errors.push(_context.t1);
+
+          case 32:
             return _context.abrupt("return", _objectSpread({
               setup: setup
             }, result));
 
-          case 30:
+          case 33:
           case "end":
             return _context.stop();
         }
       }
-    }, _callee, null, [[12, 21]]);
+    }, _callee, null, [[5, 14], [22, 28]]);
   }));
 
   return function run(_x) {
@@ -170,12 +147,10 @@ var run = /*#__PURE__*/function () {
   };
 }();
 /**
- * Sets up the rag-index triggers, gives a folder to the assistants that
- * lack one, then provisions the assistants listed in the autoprovision
- * flag. Runs once per session: every call shares the first one's promise,
- * and the triggers step is shared with ensureRagIndexTriggers, so a host
- * app that ensured them at startup does not pay for them twice. Never
- * rejects.
+ * Gives a folder to the assistants that lack one, provisions the
+ * assistants listed in the autoprovision flag, then sets up the rag-index
+ * triggers. Runs once per session: every call shares the first one's
+ * promise. Never rejects.
  * @param {import('cozy-client').CozyClient} client - The cozy client.
  * @returns {Promise<null|{setup: object, created: string[], ensured: string[], skipped: {id: string, reason: string}[]}>} Null when the flag lists nothing.
  */
@@ -191,5 +166,68 @@ var autoprovisionAssistants = function autoprovisionAssistants(client) {
 
   return pending;
 };
+/**
+ * The startup entry point of a host app: one request when the instance is
+ * already set up. The rag-index triggers are created last by
+ * autoprovisionAssistants, so finding both means an earlier session went
+ * through; anything changed since is caught when the assistant opens.
+ * Runs once per session, never rejects.
+ * @param {import('cozy-client').CozyClient} client - The cozy client.
+ * @returns {Promise<null|object>} Null when there was nothing to do, the
+ * result of autoprovisionAssistants otherwise.
+ */
+
+
+exports.autoprovisionAssistants = autoprovisionAssistants;
+
+var ensureAssistantsSetup = function ensureAssistantsSetup(client) {
+  if (!setupPending) {
+    setupPending = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2() {
+      var _yield$findRagIndexTr, files, assistants;
+
+      return _regenerator.default.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              if (autoprovisionEntries()) {
+                _context2.next = 2;
+                break;
+              }
+
+              return _context2.abrupt("return", null);
+
+            case 2:
+              _context2.next = 4;
+              return (0, _ragIndexing.findRagIndexTriggers)(client);
+
+            case 4:
+              _yield$findRagIndexTr = _context2.sent;
+              files = _yield$findRagIndexTr.files;
+              assistants = _yield$findRagIndexTr.assistants;
+
+              if (!(files && assistants)) {
+                _context2.next = 9;
+                break;
+              }
+
+              return _context2.abrupt("return", null);
+
+            case 9:
+              return _context2.abrupt("return", autoprovisionAssistants(client));
+
+            case 10:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2);
+    }))().catch(function (error) {
+      warn('cannot check the rag-index triggers', error);
+      return null;
+    });
+  }
+
+  return setupPending;
+};
 
-exports.autoprovisionAssistants = autoprovisionAssistants;
+exports.ensureAssistantsSetup = ensureAssistantsSetup;

package/dist/components/KnowledgeBase/autoprovision.spec.js

@@ -3,13 +3,14 @@ import flag from 'cozy-flags'
 import {
   autoprovisionAssistants,
   autoprovisionEntries,
-  ensureRagIndexTriggers,
+  ensureAssistantsSetup,
   resetAutoprovisionForTests
 } from './autoprovision'
 import { ensureProvisionedAssistants } from './provisioning'
 import {
   createRagIndexTriggers,
   fetchAssistants,
+  findRagIndexTriggers,
   migrateAssistantsWithoutFolder
 } from './ragIndexing'
 
@@ -21,6 +22,7 @@ jest.mock('./provisioning', () => ({
 jest.mock('./ragIndexing', () => ({
   createRagIndexTriggers: jest.fn(),
   fetchAssistants: jest.fn(),
+  findRagIndexTriggers: jest.fn(),
   migrateAssistantsWithoutFolder: jest.fn()
 }))
 
@@ -35,6 +37,9 @@ beforeEach(() => {
   warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
   createRagIndexTriggers.mockReset().mockResolvedValue(['io.cozy.files'])
   fetchAssistants.mockReset().mockResolvedValue(assistants)
+  findRagIndexTriggers
+    .mockReset()
+    .mockResolvedValue({ files: null, assistants: null })
   migrateAssistantsWithoutFolder.mockReset().mockResolvedValue([])
   ensureProvisionedAssistants
     .mockReset()
@@ -58,35 +63,6 @@ describe('autoprovisionEntries', () => {
   })
 })
 
-describe('ensureRagIndexTriggers', () => {
-  it('creates the missing triggers once per session', async () => {
-    const first = ensureRagIndexTriggers(client)
-    expect(ensureRagIndexTriggers(client)).toBe(first)
-    await expect(first).resolves.toEqual({
-      triggers: ['io.cozy.files'],
-      error: null
-    })
-    await ensureRagIndexTriggers(client)
-
-    expect(createRagIndexTriggers).toHaveBeenCalledTimes(1)
-    expect(createRagIndexTriggers).toHaveBeenCalledWith(client)
-  })
-
-  it('reports a failure without rejecting', async () => {
-    const error = new Error('forbidden')
-    createRagIndexTriggers.mockRejectedValue(error)
-    await expect(ensureRagIndexTriggers(client)).resolves.toEqual({
-      triggers: [],
-      error
-    })
-    expect(warnSpy).toHaveBeenCalledWith(
-      'cozy-search autoprovision:',
-      'cannot set up the rag-index triggers',
-      error
-    )
-  })
-})
-
 describe('autoprovisionAssistants', () => {
   it('does nothing without flag entries', async () => {
     flag.mockReturnValue(null)
@@ -109,7 +85,7 @@ describe('autoprovisionAssistants', () => {
     expect(result.setup.errors.map(e => e.message)).toEqual(['nope'])
   })
 
-  it('ensures the triggers, migrates, then provisions the flag entries', async () => {
+  it('migrates, provisions the flag entries, then ensures the triggers', async () => {
     flag.mockReturnValue(entries)
     migrateAssistantsWithoutFolder.mockResolvedValue(['legacy'])
     const result = await autoprovisionAssistants(client)
@@ -124,9 +100,9 @@ describe('autoprovisionAssistants', () => {
       assistants
     })
     const order = [
-      createRagIndexTriggers,
       migrateAssistantsWithoutFolder,
-      ensureProvisionedAssistants
+      ensureProvisionedAssistants,
+      createRagIndexTriggers
     ].map(fn => fn.mock.invocationCallOrder[0])
     expect(order).toEqual([...order].sort((a, b) => a - b))
     expect(result).toEqual({
@@ -148,15 +124,6 @@ describe('autoprovisionAssistants', () => {
     expect(ensureProvisionedAssistants).toHaveBeenCalledTimes(1)
   })
 
-  it('shares the triggers step with ensureRagIndexTriggers', async () => {
-    flag.mockReturnValue(entries)
-    await ensureRagIndexTriggers(client)
-    await autoprovisionAssistants(client)
-
-    expect(createRagIndexTriggers).toHaveBeenCalledTimes(1)
-    expect(ensureProvisionedAssistants).toHaveBeenCalledTimes(1)
-  })
-
   it('still provisions when the setup steps failed', async () => {
     flag.mockReturnValue(entries)
     createRagIndexTriggers.mockRejectedValue(new Error('forbidden'))
@@ -165,8 +132,8 @@ describe('autoprovisionAssistants', () => {
 
     expect(ensureProvisionedAssistants).toHaveBeenCalledTimes(1)
     expect(result.setup.errors.map(e => e.message)).toEqual([
-      'forbidden',
-      'nope'
+      'nope',
+      'forbidden'
     ])
   })
 
@@ -197,3 +164,61 @@ describe('autoprovisionAssistants', () => {
     )
   })
 })
+
+describe('ensureAssistantsSetup', () => {
+  it('does nothing without flag entries', async () => {
+    flag.mockReturnValue(null)
+    await expect(ensureAssistantsSetup(client)).resolves.toBeNull()
+    expect(findRagIndexTriggers).not.toHaveBeenCalled()
+  })
+
+  it('stops at the triggers when both exist', async () => {
+    flag.mockReturnValue(entries)
+    findRagIndexTriggers.mockResolvedValue({
+      files: { _id: 'files' },
+      assistants: { _id: 'assistants' }
+    })
+    await expect(ensureAssistantsSetup(client)).resolves.toBeNull()
+
+    expect(findRagIndexTriggers).toHaveBeenCalledWith(client)
+    expect(fetchAssistants).not.toHaveBeenCalled()
+    expect(ensureProvisionedAssistants).not.toHaveBeenCalled()
+    expect(createRagIndexTriggers).not.toHaveBeenCalled()
+  })
+
+  it.each([
+    ['none', { files: null, assistants: null }],
+    ['only the files one', { files: { _id: 'files' }, assistants: null }],
+    ['only the assistants one', { files: null, assistants: { _id: 'a' } }]
+  ])('runs the whole setup with %s', async (_label, found) => {
+    flag.mockReturnValue(entries)
+    findRagIndexTriggers.mockResolvedValue(found)
+    const result = await ensureAssistantsSetup(client)
+
+    expect(ensureProvisionedAssistants).toHaveBeenCalledTimes(1)
+    expect(createRagIndexTriggers).toHaveBeenCalledTimes(1)
+    expect(result.created).toEqual(['docs'])
+  })
+
+  it('runs once per session and shares the setup with the assistant', async () => {
+    flag.mockReturnValue(entries)
+    const first = ensureAssistantsSetup(client)
+    expect(ensureAssistantsSetup(client)).toBe(first)
+    await first
+    await autoprovisionAssistants(client)
+
+    expect(findRagIndexTriggers).toHaveBeenCalledTimes(1)
+    expect(ensureProvisionedAssistants).toHaveBeenCalledTimes(1)
+  })
+
+  it('never rejects', async () => {
+    flag.mockReturnValue(entries)
+    findRagIndexTriggers.mockRejectedValue(new Error('offline'))
+    await expect(ensureAssistantsSetup(client)).resolves.toBeNull()
+    expect(warnSpy).toHaveBeenCalledWith(
+      'cozy-search autoprovision:',
+      'cannot check the rag-index triggers',
+      expect.any(Error)
+    )
+  })
+})

package/dist/components/KnowledgeBase/useAssistantsSetup.d.ts

@@ -0,0 +1 @@
+export function useAssistantsSetup(): void;

package/dist/components/KnowledgeBase/useAssistantsSetup.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useAssistantsSetup = void 0;
+
+var _react = require("react");
+
+var _cozyClient = require("cozy-client");
+
+var _autoprovision = require("./autoprovision");
+
+/**
+ * Sets the flagged assistants and their RAG indexing up at the startup of
+ * a host app, the first time only: see ensureAssistantsSetup.
+ */
+var useAssistantsSetup = function useAssistantsSetup() {
+  var client = (0, _cozyClient.useClient)();
+  (0, _react.useEffect)(function () {
+    if (client) (0, _autoprovision.ensureAssistantsSetup)(client);
+  }, [client]);
+};
+
+exports.useAssistantsSetup = useAssistantsSetup;

package/dist/components/KnowledgeBase/useAssistantsSetup.spec.js

@@ -0,0 +1,33 @@
+import { renderHook } from '@testing-library/react-hooks/dom'
+
+import { useClient } from 'cozy-client'
+
+import { ensureAssistantsSetup } from './autoprovision'
+import { useAssistantsSetup } from './useAssistantsSetup'
+
+jest.mock('cozy-client', () => ({ useClient: jest.fn() }))
+jest.mock('./autoprovision', () => ({ ensureAssistantsSetup: jest.fn() }))
+
+const client = { id: 'client' }
+
+describe('useAssistantsSetup', () => {
+  beforeEach(() => {
+    useClient.mockReset().mockReturnValue(client)
+    ensureAssistantsSetup.mockReset().mockResolvedValue(null)
+  })
+
+  it('ensures the setup with the client on mount', () => {
+    const { rerender } = renderHook(() => useAssistantsSetup())
+    rerender()
+
+    expect(ensureAssistantsSetup).toHaveBeenCalledTimes(1)
+    expect(ensureAssistantsSetup).toHaveBeenCalledWith(client)
+  })
+
+  it('waits for a client', () => {
+    useClient.mockReturnValue(null)
+    renderHook(() => useAssistantsSetup())
+
+    expect(ensureAssistantsSetup).not.toHaveBeenCalled()
+  })
+})

package/dist/index.d.ts

@@ -11,6 +11,6 @@ export { StreamBridge, createCozyRealtimeChatAdapter } from './components/adapte
 export { default as AssistantView } from './components/Views/AssistantView';
 export { assistantIdFromName, AUTOPROVISION_FLAG, ensureProvisionedAssistants, getDefaultProvisionedAssistantId } from './components/KnowledgeBase/provisioning';
 export { setupRagIndexing } from './components/KnowledgeBase/ragIndexing';
-export { autoprovisionAssistants, ensureRagIndexTriggers } from './components/KnowledgeBase/autoprovision';
-export { useRagIndexTriggers } from './components/KnowledgeBase/useRagIndexTriggers';
+export { autoprovisionAssistants, ensureAssistantsSetup } from './components/KnowledgeBase/autoprovision';
+export { useAssistantsSetup } from './components/KnowledgeBase/useAssistantsSetup';
 export { useAssistantsAutoprovision } from './components/KnowledgeBase/useAssistantsAutoprovision';

package/dist/index.js

@@ -95,16 +95,16 @@ Object.defineProperty(exports, "createCozyRealtimeChatAdapter", {
     return _adapters.createCozyRealtimeChatAdapter;
   }
 });
-Object.defineProperty(exports, "ensureProvisionedAssistants", {
+Object.defineProperty(exports, "ensureAssistantsSetup", {
   enumerable: true,
   get: function get() {
-    return _provisioning.ensureProvisionedAssistants;
+    return _autoprovision.ensureAssistantsSetup;
   }
 });
-Object.defineProperty(exports, "ensureRagIndexTriggers", {
+Object.defineProperty(exports, "ensureProvisionedAssistants", {
   enumerable: true,
   get: function get() {
-    return _autoprovision.ensureRagIndexTriggers;
+    return _provisioning.ensureProvisionedAssistants;
   }
 });
 Object.defineProperty(exports, "getDefaultProvisionedAssistantId", {
@@ -125,10 +125,10 @@ Object.defineProperty(exports, "useAssistantsAutoprovision", {
     return _useAssistantsAutoprovision.useAssistantsAutoprovision;
   }
 });
-Object.defineProperty(exports, "useRagIndexTriggers", {
+Object.defineProperty(exports, "useAssistantsSetup", {
   enumerable: true,
   get: function get() {
-    return _useRagIndexTriggers.useRagIndexTriggers;
+    return _useAssistantsSetup.useAssistantsSetup;
   }
 });
 
@@ -160,6 +160,6 @@ var _ragIndexing = require("./components/KnowledgeBase/ragIndexing");
 
 var _autoprovision = require("./components/KnowledgeBase/autoprovision");
 
-var _useRagIndexTriggers = require("./components/KnowledgeBase/useRagIndexTriggers");
+var _useAssistantsSetup = require("./components/KnowledgeBase/useAssistantsSetup");
 
 var _useAssistantsAutoprovision = require("./components/KnowledgeBase/useAssistantsAutoprovision");

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "cozy-search",
   "description": "UI components about search bar and IA assistant",
-  "version": "2.5.1",
+  "version": "2.6.0",
   "author": {
     "name": "Cozy Cloud",
     "url": "https://github.com/cozy"
@@ -96,5 +96,5 @@
     "lint": "cd .. && yarn eslint --ext js,jsx,ts packages/cozy-search"
   },
   "types": "dist/index.d.ts",
-  "gitHead": "368b1e85eb1f6a6a0731681ef2a38a7bbc3fe779"
+  "gitHead": "2103fb9d929275519efab0419630593d07d1ce8a"
 }

package/dist/components/KnowledgeBase/useRagIndexTriggers.d.ts

@@ -1 +0,0 @@
-export function useRagIndexTriggers(): void;

package/dist/components/KnowledgeBase/useRagIndexTriggers.js

@@ -1,27 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useRagIndexTriggers = void 0;
-
-var _react = require("react");
-
-var _cozyClient = require("cozy-client");
-
-var _autoprovision = require("./autoprovision");
-
-/**
- * Ensures the rag-index triggers at startup, when the autoprovision flag
- * lists assistants: the knowledge base folders are then indexed as they
- * change, before the assistant is ever opened. The assistants themselves
- * are provisioned when the assistant opens.
- */
-var useRagIndexTriggers = function useRagIndexTriggers() {
-  var client = (0, _cozyClient.useClient)();
-  (0, _react.useEffect)(function () {
-    if (client && (0, _autoprovision.autoprovisionEntries)()) (0, _autoprovision.ensureRagIndexTriggers)(client);
-  }, [client]);
-};
-
-exports.useRagIndexTriggers = useRagIndexTriggers;

package/dist/components/KnowledgeBase/useRagIndexTriggers.spec.js

@@ -1,47 +0,0 @@
-import { renderHook } from '@testing-library/react-hooks/dom'
-
-import { useClient } from 'cozy-client'
-
-import { autoprovisionEntries, ensureRagIndexTriggers } from './autoprovision'
-import { useRagIndexTriggers } from './useRagIndexTriggers'
-
-jest.mock('cozy-client', () => ({ useClient: jest.fn() }))
-jest.mock('./autoprovision', () => ({
-  autoprovisionEntries: jest.fn(),
-  ensureRagIndexTriggers: jest.fn()
-}))
-
-const client = { id: 'client' }
-
-describe('useRagIndexTriggers', () => {
-  beforeEach(() => {
-    useClient.mockReset().mockReturnValue(client)
-    autoprovisionEntries.mockReset().mockReturnValue([{ name: 'Docs' }])
-    ensureRagIndexTriggers.mockReset().mockResolvedValue({
-      triggers: [],
-      error: null
-    })
-  })
-
-  it('ensures the triggers with the client on mount', () => {
-    const { rerender } = renderHook(() => useRagIndexTriggers())
-    rerender()
-
-    expect(ensureRagIndexTriggers).toHaveBeenCalledTimes(1)
-    expect(ensureRagIndexTriggers).toHaveBeenCalledWith(client)
-  })
-
-  it('does nothing without flag entries', () => {
-    autoprovisionEntries.mockReturnValue(null)
-    renderHook(() => useRagIndexTriggers())
-
-    expect(ensureRagIndexTriggers).not.toHaveBeenCalled()
-  })
-
-  it('waits for a client', () => {
-    useClient.mockReturnValue(null)
-    renderHook(() => useRagIndexTriggers())
-
-    expect(ensureRagIndexTriggers).not.toHaveBeenCalled()
-  })
-})