wip

Author: tripolskypetr

TODO.md

@@ -446,7 +446,31 @@ complete=HANG)
 - AQUIRE_LOCK: поллинг sleep(100) без таймаута; _navigationStack растёт на
   каждый переход (write amplification при persist).
 
-## Найденные и исправленные баги (23 итого)
+## 21-й заход: createNumericIndex и контракт fork (+6 тестов, +1 баг)
+
+### Новые тесты (6), сьют вырос до 234/234 — test/spec/numindex.test.mjs
+- регрессия бага №24: после remove новый индекс НЕ коллидирует с живыми id
+  ([1,2,3] − 1 → next=4, «three» не перезаписан);
+- нечисловые id (uuid) игнорируются при вычислении следующего индекса;
+- пустой сторэдж → индекс 1;
+- fork: ошибка runFn уходит в onError, результат null, сессия зачищена
+  (контракт «fork не пробрасывает ошибки» закреплён);
+- fork happy path: возврат значения, clientId/agentName в runFn, cleanup;
+- fork на живой clientId кидает "already exists".
+
+### Баг №24: createNumericIndex терял данные после удаления элементов
+Файл: `src/classes/Storage.ts` (найден пробой: next=3 при живом id=3, элемент
+«three» молча перезаписан upsert'ом)
+- Индекс считался как list().length + 1: после удаления элемента длина меньше
+  максимального id, и новый индекс коллидировал с живым элементом — upsert
+  затирал чужие данные.
+- Исправление: индекс = max(числовых id) + 1; нечисловые id игнорируются;
+  пустой сторэдж → 1.
+- Ограничение (задокументировано): параллельные createNumericIndex без upsert
+  между ними по-прежнему возвращают одинаковое значение — метод вычисляет
+  «следующий свободный» от ТЕКУЩИХ данных и не резервирует его.
+
+## Найденные и исправленные баги (24 итого)
 
 ### 1. Дедлок waitForOutput при functools-kit v4 (причина 39 упавших тестов)
 Файл: `src/client/ClientSwarm.ts`

src/classes/Storage.ts

@@ -341,12 +341,22 @@ export class StorageUtils implements TStorage {
           `agent-swarm StorageUtils ${payload.storageName} not registered in ${payload.agentName} (createNumericIndex)`
         );
       }
-      const { length } = await swarm.storagePublicService.list(
+      const items = await swarm.storagePublicService.list(
         METHOD_NAME_CREATE_NUMERIC_INDEX,
         payload.clientId,
         payload.storageName
       );
-      return length + 1;
+      // length + 1 collides with surviving ids once anything was removed
+      // (items [1,2,3] minus 1 -> length 2 -> next "3" overwrites live item 3),
+      // so the next index must come from the maximum numeric id instead.
+      let maxId = 0;
+      for (const { id } of items) {
+        const numericId = Number(id);
+        if (!Number.isNaN(numericId)) {
+          maxId = Math.max(maxId, numericId);
+        }
+      }
+      return maxId + 1;
     }
   );
 

test/index.mjs

@@ -33,6 +33,7 @@ import "./spec/aliastools.test.mjs";
 import "./spec/multiclient.test.mjs";
 import "./spec/doublesend.test.mjs";
 import "./spec/lifecycle.test.mjs";
+import "./spec/numindex.test.mjs";
 
 run(import.meta.url, () => {
     console.log("All tests are finished");

test/spec/numindex.test.mjs

@@ -0,0 +1,204 @@
+import { test } from "worker-testbed";
+
+import {
+  addAgent,
+  addCompletion,
+  addEmbedding,
+  addStorage,
+  addSwarm,
+  fork,
+  hasSession,
+  session,
+  setConfig,
+  Storage,
+} from "../../build/index.mjs";
+import { randomString } from "functools-kit";
+
+const addEcho = (name) =>
+  addCompletion({
+    completionName: name,
+    getCompletion: async ({ agentName, messages }) => {
+      const [last] = messages.slice(-1);
+      return { agentName, content: `echo:${last.content}`, role: "assistant" };
+    },
+  });
+
+const makeStorageSwarm = (suffix) => {
+  const COMPLETION = addEcho(`${suffix}-completion`);
+  addEmbedding({
+    embeddingName: `${suffix}-embedding`,
+    createEmbedding: async (t) => [t.length],
+    calculateSimilarity: async (a, b) => (a[0] === b[0] ? 1 : 0),
+  });
+  addStorage({
+    storageName: `${suffix}-storage`,
+    embedding: `${suffix}-embedding`,
+    createIndex: (i) => i.text,
+  });
+  const AGENT = addAgent({
+    agentName: `${suffix}-agent`,
+    completion: COMPLETION,
+    prompt: "",
+    storages: [`${suffix}-storage`],
+  });
+  return addSwarm({
+    swarmName: `${suffix}-swarm`,
+    agentList: [AGENT],
+    defaultAgent: AGENT,
+  });
+};
+
+test("Will skip surviving ids in numeric index after remove", async ({ pass, fail }) => {
+  setConfig({ CC_PERSIST_ENABLED_BY_DEFAULT: false });
+
+  const SWARM = makeStorageSwarm("n1");
+  const CLIENT_ID = randomString();
+  const chatSession = session(CLIENT_ID, SWARM);
+  const base = { clientId: CLIENT_ID, agentName: "n1-agent", storageName: "n1-storage" };
+
+  await Storage.upsert({ ...base, item: { id: 1, text: "one" } });
+  await Storage.upsert({ ...base, item: { id: 2, text: "two" } });
+  await Storage.upsert({ ...base, item: { id: 3, text: "three" } });
+  await Storage.remove({ ...base, itemId: 1 });
+  const nextIndex = await Storage.createNumericIndex(base);
+  await Storage.upsert({ ...base, item: { id: nextIndex, text: "new-item" } });
+  const items = await Storage.list(base);
+  await chatSession.dispose();
+
+  const ids = items.map((i) => i.id).sort();
+  const three = items.find((i) => i.id === 3);
+  const ok =
+    nextIndex === 4 && items.length === 3 && three?.text === "three" && ids.join(",") === "2,3,4";
+
+  if (ok) {
+    pass();
+    return;
+  }
+  fail(`nextIndex=${nextIndex} items=${JSON.stringify(items.map((i) => [i.id, i.text]))}`);
+});
+
+test("Will ignore non-numeric ids in numeric index", async ({ pass, fail }) => {
+  setConfig({ CC_PERSIST_ENABLED_BY_DEFAULT: false });
+
+  const SWARM = makeStorageSwarm("n2");
+  const CLIENT_ID = randomString();
+  const chatSession = session(CLIENT_ID, SWARM);
+  const base = { clientId: CLIENT_ID, agentName: "n2-agent", storageName: "n2-storage" };
+
+  await Storage.upsert({ ...base, item: { id: "uuid-like", text: "alpha" } });
+  await Storage.upsert({ ...base, item: { id: 5, text: "beta" } });
+  const nextIndex = await Storage.createNumericIndex(base);
+  await chatSession.dispose();
+
+  const ok =
+    nextIndex === 6;
+
+  if (ok) {
+    pass();
+    return;
+  }
+  fail(`nextIndex=${nextIndex}`);
+});
+
+test("Will start numeric index from one on empty storage", async ({ pass, fail }) => {
+  setConfig({ CC_PERSIST_ENABLED_BY_DEFAULT: false });
+
+  const SWARM = makeStorageSwarm("n3");
+  const CLIENT_ID = randomString();
+  const chatSession = session(CLIENT_ID, SWARM);
+  const base = { clientId: CLIENT_ID, agentName: "n3-agent", storageName: "n3-storage" };
+  const nextIndex = await Storage.createNumericIndex(base);
+  await chatSession.dispose();
+
+  const ok =
+    nextIndex === 1;
+
+  if (ok) {
+    pass();
+    return;
+  }
+  fail(`nextIndex=${nextIndex}`);
+});
+
+test("Will route fork error to onError and clean up session", async ({ pass, fail }) => {
+  setConfig({ CC_PERSIST_ENABLED_BY_DEFAULT: false });
+
+  const COMPLETION = addEcho("f1-completion");
+  const AGENT = addAgent({ agentName: "f1-agent", completion: COMPLETION, prompt: "" });
+  const SWARM = addSwarm({ swarmName: "f1-swarm", agentList: [AGENT], defaultAgent: AGENT });
+
+  const CLIENT_ID = randomString();
+  let capturedError = "";
+  const result = await fork(
+    async () => {
+      throw new Error("fork boom");
+    },
+    {
+      clientId: CLIENT_ID,
+      swarmName: SWARM,
+      onError: (error) => {
+        capturedError = error.message;
+      },
+    }
+  );
+
+  const ok =
+    result === null && capturedError === "fork boom" && hasSession(CLIENT_ID) === false;
+
+  if (ok) {
+    pass();
+    return;
+  }
+  fail(`result=${JSON.stringify(result)} error=${capturedError} hasSession=${hasSession(CLIENT_ID)}`);
+});
+
+test("Will return fork value and clean up session", async ({ pass, fail }) => {
+  setConfig({ CC_PERSIST_ENABLED_BY_DEFAULT: false });
+
+  const COMPLETION = addEcho("f2-completion");
+  const AGENT = addAgent({ agentName: "f2-agent", completion: COMPLETION, prompt: "" });
+  const SWARM = addSwarm({ swarmName: "f2-swarm", agentList: [AGENT], defaultAgent: AGENT });
+
+  const CLIENT_ID = randomString();
+  const result = await fork(
+    async (clientId, agentName) => `ran:${clientId === CLIENT_ID}:${agentName}`,
+    { clientId: CLIENT_ID, swarmName: SWARM }
+  );
+
+  const ok =
+    result === `ran:true:f2-agent` && hasSession(CLIENT_ID) === false;
+
+  if (ok) {
+    pass();
+    return;
+  }
+  fail(`result=${JSON.stringify(result)} hasSession=${hasSession(CLIENT_ID)}`);
+});
+
+test("Will reject fork with live duplicate clientId", async ({ pass, fail }) => {
+  setConfig({ CC_PERSIST_ENABLED_BY_DEFAULT: false });
+
+  const COMPLETION = addEcho("f3-completion");
+  const AGENT = addAgent({ agentName: "f3-agent", completion: COMPLETION, prompt: "" });
+  const SWARM = addSwarm({ swarmName: "f3-swarm", agentList: [AGENT], defaultAgent: AGENT });
+
+  const CLIENT_ID = randomString();
+  const chatSession = session(CLIENT_ID, SWARM);
+  let duplicateError = "";
+  try {
+    await fork(async () => "never", { clientId: CLIENT_ID, swarmName: SWARM });
+  } catch (error) {
+    duplicateError = error.message;
+  }
+  await chatSession.dispose();
+
+  const ok =
+    duplicateError.includes("already exists");
+
+  if (ok) {
+    pass();
+    return;
+  }
+  fail(`error=${duplicateError}`);
+});
+