cozy-search 2.3.3 → 2.5.0

package/README.md

@@ -59,9 +59,23 @@ of verbs (cozy-home and cozy-drive use `ALL`).
 
 ### RAG indexing setup
 
-Call `setupRagIndexing(client)` once per session at startup (before
-`ensureProvisionedAssistants` if your app provisions assistants from the
-`rag.assistants.autoprovision` flag). It makes sure the instance's two
+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
@@ -76,7 +90,7 @@ never throws: on a stack whose `rag-index` worker is still reserved, the
 additionally creates one `io.cozy.accounts` document per provisioned
 assistant, and the `dirName` folder in `io.cozy.files`.
 
-An entry of `rag.assistants.autoprovision` can carry `"default": true`
+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

package/dist/components/Assistant/AssistantContainer.js

@@ -21,6 +21,8 @@ var _Conversation = _interopRequireDefault(require("../Conversations/Conversatio
 
 var _CozyAssistantRuntimeProvider = _interopRequireDefault(require("../CozyAssistantRuntimeProvider"));
 
+var _useAssistantsAutoprovision = require("../KnowledgeBase/useAssistantsAutoprovision");
+
 var _SearchConversation = _interopRequireDefault(require("../Search/SearchConversation"));
 
 var _Sidebar = _interopRequireDefault(require("../Sidebar"));
@@ -43,6 +45,7 @@ var AssistantContainer = function AssistantContainer() {
   var _useAssistant = (0, _AssistantProvider.useAssistant)(),
       isOpenSearchConversation = _useAssistant.isOpenSearchConversation;
 
+  (0, _useAssistantsAutoprovision.useAssistantsAutoprovision)();
   return /*#__PURE__*/_react.default.createElement("div", {
     className: (0, _classnames.default)('u-flex u-ov-hidden u-h-100', styles['assistant-container'])
   }, /*#__PURE__*/_react.default.createElement(_Sidebar.default, {

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

@@ -0,0 +1,15 @@
+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[];
+    ensured: string[];
+    skipped: {
+        id: string;
+        reason: string;
+    }[];
+}>;

package/dist/components/KnowledgeBase/autoprovision.js

@@ -0,0 +1,195 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resetAutoprovisionForTests = exports.ensureRagIndexTriggers = exports.autoprovisionEntries = exports.autoprovisionAssistants = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _cozyFlags = _interopRequireDefault(require("cozy-flags"));
+
+var _provisioning = require("./provisioning");
+
+var _ragIndexing = require("./ragIndexing");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+var warn = function warn() {
+  var _console;
+
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+
+  // eslint-disable-next-line no-console
+  (_console = console).warn.apply(_console, ['cozy-search autoprovision:'].concat(args));
+};
+
+var triggersPending = null;
+var pending = null;
+
+var resetAutoprovisionForTests = function resetAutoprovisionForTests() {
+  triggersPending = null;
+  pending = null;
+};
+/**
+ * The entries of the autoprovision flag, or null when it lists nothing.
+ * @returns {Array<object>|null}
+ */
+
+
+exports.resetAutoprovisionForTests = resetAutoprovisionForTests;
+
+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;
+
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            entries = autoprovisionEntries();
+
+            if (entries) {
+              _context.next = 3;
+              break;
+            }
+
+            return _context.abrupt("return", null);
+
+          case 3:
+            setup = {
+              triggers: [],
+              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;
+            return (0, _ragIndexing.fetchAssistants)(client);
+
+          case 15:
+            assistants = _context.sent;
+            _context.next = 18;
+            return (0, _ragIndexing.migrateAssistantsWithoutFolder)(client, assistants);
+
+          case 18:
+            setup.migrated = _context.sent;
+            _context.next = 25;
+            break;
+
+          case 21:
+            _context.prev = 21;
+            _context.t0 = _context["catch"](12);
+            warn('cannot migrate the assistants without folder', _context.t0);
+            setup.errors.push(_context.t0);
+
+          case 25:
+            _context.next = 27;
+            return (0, _provisioning.ensureProvisionedAssistants)(client, entries, {
+              assistants: assistants
+            });
+
+          case 27:
+            result = _context.sent;
+
+            if (result.skipped.length > 0) {
+              warn('skipped entries', result.skipped);
+            }
+
+            return _context.abrupt("return", _objectSpread({
+              setup: setup
+            }, result));
+
+          case 30:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, null, [[12, 21]]);
+  }));
+
+  return function run(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+/**
+ * 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.
+ * @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.
+ */
+
+
+var autoprovisionAssistants = function autoprovisionAssistants(client) {
+  if (!pending) {
+    pending = run(client).catch(function (error) {
+      warn('failed', error);
+      return null;
+    });
+  }
+
+  return pending;
+};
+
+exports.autoprovisionAssistants = autoprovisionAssistants;

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,199 @@
+import flag from 'cozy-flags'
+
+import {
+  autoprovisionAssistants,
+  autoprovisionEntries,
+  ensureRagIndexTriggers,
+  resetAutoprovisionForTests
+} from './autoprovision'
+import { ensureProvisionedAssistants } from './provisioning'
+import {
+  createRagIndexTriggers,
+  fetchAssistants,
+  migrateAssistantsWithoutFolder
+} from './ragIndexing'
+
+jest.mock('cozy-flags', () => jest.fn())
+jest.mock('./provisioning', () => ({
+  AUTOPROVISION_FLAG: 'cozy.assistant.autoprovision',
+  ensureProvisionedAssistants: jest.fn()
+}))
+jest.mock('./ragIndexing', () => ({
+  createRagIndexTriggers: jest.fn(),
+  fetchAssistants: jest.fn(),
+  migrateAssistantsWithoutFolder: jest.fn()
+}))
+
+const client = { id: 'client' }
+const entries = [{ name: 'Docs', dirName: 'Docs' }]
+const assistants = [{ _id: 'legacy' }]
+let warnSpy
+
+beforeEach(() => {
+  resetAutoprovisionForTests()
+  flag.mockReset()
+  warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
+  createRagIndexTriggers.mockReset().mockResolvedValue(['io.cozy.files'])
+  fetchAssistants.mockReset().mockResolvedValue(assistants)
+  migrateAssistantsWithoutFolder.mockReset().mockResolvedValue([])
+  ensureProvisionedAssistants
+    .mockReset()
+    .mockResolvedValue({ created: ['docs'], ensured: [], skipped: [] })
+})
+
+afterEach(() => {
+  warnSpy.mockRestore()
+})
+
+describe('autoprovisionEntries', () => {
+  it('returns the flag entries', () => {
+    flag.mockReturnValue(entries)
+    expect(autoprovisionEntries()).toBe(entries)
+    expect(flag).toHaveBeenCalledWith('cozy.assistant.autoprovision')
+  })
+
+  it.each([null, undefined, [], 'docs', {}])('returns null for %p', value => {
+    flag.mockReturnValue(value)
+    expect(autoprovisionEntries()).toBeNull()
+  })
+})
+
+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)
+    await expect(autoprovisionAssistants(client)).resolves.toBeNull()
+    expect(createRagIndexTriggers).not.toHaveBeenCalled()
+    expect(fetchAssistants).not.toHaveBeenCalled()
+    expect(migrateAssistantsWithoutFolder).not.toHaveBeenCalled()
+    expect(ensureProvisionedAssistants).not.toHaveBeenCalled()
+  })
+
+  it('lets the provisioning query the assistants when listing them failed', async () => {
+    flag.mockReturnValue(entries)
+    fetchAssistants.mockRejectedValue(new Error('nope'))
+    const result = await autoprovisionAssistants(client)
+
+    expect(migrateAssistantsWithoutFolder).not.toHaveBeenCalled()
+    expect(ensureProvisionedAssistants).toHaveBeenCalledWith(client, entries, {
+      assistants: null
+    })
+    expect(result.setup.errors.map(e => e.message)).toEqual(['nope'])
+  })
+
+  it('ensures the triggers, migrates, then provisions the flag entries', async () => {
+    flag.mockReturnValue(entries)
+    migrateAssistantsWithoutFolder.mockResolvedValue(['legacy'])
+    const result = await autoprovisionAssistants(client)
+
+    expect(createRagIndexTriggers).toHaveBeenCalledWith(client)
+    expect(fetchAssistants).toHaveBeenCalledTimes(1)
+    expect(migrateAssistantsWithoutFolder).toHaveBeenCalledWith(
+      client,
+      assistants
+    )
+    expect(ensureProvisionedAssistants).toHaveBeenCalledWith(client, entries, {
+      assistants
+    })
+    const order = [
+      createRagIndexTriggers,
+      migrateAssistantsWithoutFolder,
+      ensureProvisionedAssistants
+    ].map(fn => fn.mock.invocationCallOrder[0])
+    expect(order).toEqual([...order].sort((a, b) => a - b))
+    expect(result).toEqual({
+      setup: { triggers: ['io.cozy.files'], migrated: ['legacy'], errors: [] },
+      created: ['docs'],
+      ensured: [],
+      skipped: []
+    })
+  })
+
+  it('runs once per session, sharing the promise', async () => {
+    flag.mockReturnValue(entries)
+    const first = autoprovisionAssistants(client)
+    expect(autoprovisionAssistants(client)).toBe(first)
+    await first
+    await autoprovisionAssistants(client)
+
+    expect(createRagIndexTriggers).toHaveBeenCalledTimes(1)
+    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'))
+    migrateAssistantsWithoutFolder.mockRejectedValue(new Error('nope'))
+    const result = await autoprovisionAssistants(client)
+
+    expect(ensureProvisionedAssistants).toHaveBeenCalledTimes(1)
+    expect(result.setup.errors.map(e => e.message)).toEqual([
+      'forbidden',
+      'nope'
+    ])
+  })
+
+  it('logs the skipped entries', async () => {
+    flag.mockReturnValue(entries)
+    ensureProvisionedAssistants.mockResolvedValue({
+      created: [],
+      ensured: [],
+      skipped: [{ id: 'docs', reason: 'nope' }]
+    })
+    await autoprovisionAssistants(client)
+
+    expect(warnSpy).toHaveBeenCalledWith(
+      'cozy-search autoprovision:',
+      'skipped entries',
+      [{ id: 'docs', reason: 'nope' }]
+    )
+  })
+
+  it('never rejects', async () => {
+    flag.mockReturnValue(entries)
+    ensureProvisionedAssistants.mockRejectedValue(new Error('boom'))
+    await expect(autoprovisionAssistants(client)).resolves.toBeNull()
+    expect(warnSpy).toHaveBeenCalledWith(
+      'cozy-search autoprovision:',
+      'failed',
+      expect.any(Error)
+    )
+  })
+})

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

@@ -1,4 +1,4 @@
-export const AUTOPROVISION_FLAG: "rag.assistants.autoprovision";
+export const AUTOPROVISION_FLAG: "cozy.assistant.autoprovision";
 export function assistantIdFromName(name: any): string;
 export function getDefaultProvisionedAssistantId(): string | null;
 export function isMagicFolderId(dirId: any): boolean;
@@ -14,7 +14,9 @@ export function ensureProvisionedAssistants(client: import("cozy-client").CozyCl
     prompt?: string;
     icon?: string | null;
     default?: boolean;
-}>): Promise<{
+}>, { assistants }?: {
+    assistants?: object[] | undefined;
+} | undefined): Promise<{
     created: string[];
     ensured: string[];
     skipped: {