@ai.ntellect/core 1.0.0 → 1.1.1

package/test/agent/cognitive-handler.test.ts

@@ -0,0 +1,78 @@
+import { expect } from "chai";
+import { CognitiveHandler, COGNITIVE_NODES } from "../../agent/handlers/cognitive-handler";
+import { AgentLogger } from "../../agent/tools/logger";
+import { AgentContext } from "../../types/agent";
+import sinon from "sinon";
+
+describe("CognitiveHandler", () => {
+  let llmMock: any;
+  let loggerMock: any;
+  let handler: CognitiveHandler;
+  let context: AgentContext;
+
+  beforeEach(() => {
+    llmMock = {
+      generate: sinon.stub()
+    };
+    loggerMock = {
+      log: sinon.stub()
+    } as unknown as AgentLogger;
+
+    context = {
+      input: { raw: "test input" },
+      actions: [],
+      response: "",
+      executedActions: [],
+    };
+  });
+
+  describe("computeGoal", () => {
+    it("should return current goal if dynamicGoal is disabled", async () => {
+      handler = new CognitiveHandler(llmMock, loggerMock, { dynamicGoal: false, initialGoal: "static goal" });
+      const goal = await handler.computeGoal(context);
+      expect(goal).to.equal("static goal");
+      expect(llmMock.generate.called).to.be.false;
+    });
+
+    it("should call LLM and return dynamic goal if enabled", async () => {
+      llmMock.generate.resolves({ object: { goal: "dynamic goal from LLM" } });
+      handler = new CognitiveHandler(llmMock, loggerMock, { dynamicGoal: true, initialGoal: "static goal" });
+      
+      const goal = await handler.computeGoal(context);
+      
+      expect(goal).to.equal("dynamic goal from LLM");
+      expect(llmMock.generate.calledOnce).to.be.true;
+      expect(handler.getCurrentGoal()).to.equal("dynamic goal from LLM");
+    });
+  });
+
+  describe("computeNext", () => {
+    it("should return default next state if dynamicNext is disabled", async () => {
+      handler = new CognitiveHandler(llmMock, loggerMock, { dynamicNext: false });
+      const next = await handler.computeNext(context, "defineGoal", 1);
+      expect(next).to.equal("think");
+      expect(llmMock.generate.called).to.be.false;
+    });
+
+    it("should call LLM and return next state if enabled", async () => {
+      llmMock.generate.resolves({ object: { next: "execute", reason: "testing" } });
+      handler = new CognitiveHandler(llmMock, loggerMock, { dynamicNext: true });
+      
+      const next = await handler.computeNext(context, "think", 1);
+      
+      expect(next).to.equal("execute");
+      expect(llmMock.generate.calledOnce).to.be.true;
+      expect(handler.getCurrentState()).to.equal("execute");
+    });
+
+    it("should fallback to 'think' if LLM returns unknown state", async () => {
+      // Mocking the Zod transformed output which would return "think"
+      llmMock.generate.resolves({ object: { next: "think", reason: "testing fallback" } });
+      handler = new CognitiveHandler(llmMock, loggerMock, { dynamicNext: true });
+      
+      const next = await handler.computeNext(context, "think", 1);
+      
+      expect(next).to.equal("think");
+    });
+  });
+});

package/test/agent/entity-store.test.ts

@@ -0,0 +1,80 @@
+import { expect } from "chai";
+import { Neo4jEntityStore } from "../../persistence/neo4j/entity-store";
+
+class MockSession {
+  queries: { query: string; params: any }[] = [];
+  records: any[] = [];
+  async run(query: string, params?: Record<string, any>): Promise<{ records: any[] }> {
+    this.queries.push({ query, params });
+    return { records: this.records };
+  }
+  async close(): Promise<void> {}
+}
+
+class MockDriver {
+  lastSession?: MockSession;
+  session() {
+    this.lastSession = new MockSession();
+    return this.lastSession;
+  }
+  async close() {}
+}
+
+describe("Neo4jEntityStore", () => {
+  let driver: MockDriver;
+  let store: Neo4jEntityStore;
+
+  beforeEach(() => {
+    driver = new MockDriver();
+    store = new Neo4jEntityStore(driver as any);
+  });
+
+  it("should upsert many entities", async () => {
+    await store.upsertMany([
+      { id: "e1", category: "file", filename: "test.ts", stem: "test", extension: ".ts", path: "src/test.ts", tokens: ["test"] }
+    ]);
+    
+    expect(driver.lastSession?.queries.length).to.equal(2);
+    expect(driver.lastSession?.queries[0].query).to.include("MERGE (e:Entity {id: $id})");
+    expect(driver.lastSession?.queries[0].params.id).to.equal("e1");
+    expect(driver.lastSession?.queries[0].params.filename).to.equal("test.ts");
+    expect(driver.lastSession?.queries[0].params.scope).to.equal("src");
+    
+    expect(driver.lastSession?.queries[1].query).to.include("MERGE (d:Dir {path: $dir})");
+  });
+
+  it("should load all entities", async () => {
+    const mockSession = new MockSession();
+    mockSession.records = [{
+      get: (key: string) => {
+        if (key === "e") return { properties: { id: "e1", category: "file", filename: "test.ts", stem: "test", extension: ".ts", path: "src/test.ts" } };
+        if (key === "tokens") return ["test"];
+      }
+    }];
+    driver.session = () => mockSession;
+
+    const entities = await store.loadAll();
+    
+    expect(entities.length).to.equal(1);
+    expect(entities[0].id).to.equal("e1");
+    expect(entities[0].tokens).to.deep.equal(["test"]);
+  });
+
+  it("should record resolution", async () => {
+    await store.recordResolution("e1", "find test", 0.9);
+    
+    expect(driver.lastSession?.queries.length).to.equal(1);
+    expect(driver.lastSession?.queries[0].query).to.include("CREATE (r:Resolution");
+    expect(driver.lastSession?.queries[0].params.entityId).to.equal("e1");
+    expect(driver.lastSession?.queries[0].params.query).to.equal("find test");
+    expect(driver.lastSession?.queries[0].params.confidence).to.equal(0.9);
+  });
+
+  it("should clear entities", async () => {
+    await store.clear("src");
+    
+    expect(driver.lastSession?.queries.length).to.equal(1);
+    expect(driver.lastSession?.queries[0].query).to.include("DETACH DELETE e");
+    expect(driver.lastSession?.queries[0].params.scope).to.equal("src");
+  });
+});

package/test/agent/generic-executor.test.ts

@@ -0,0 +1,230 @@
+import { expect } from "chai";
+import { z } from "zod";
+import { GraphFlow } from "../../execution/index";
+import { BaseAgent } from "../../agent/base";
+import { GenericExecutor } from "../../agent/generic-executor";
+import { AgentContext } from "../../types/agent";
+
+describe("GenericExecutor", () => {
+  const llmConfig = {
+    provider: "custom" as const,
+    model: "mock",
+    apiKey: "unused",
+    customCall: async () => ({
+      object: {
+        actions: [] as { name: string; parameters: { name: string; value: unknown }[] }[],
+        response: "Done.",
+      },
+    }),
+  };
+
+  function createExecutor(
+    tools: GraphFlow<any>[] = [],
+    customCall?: typeof llmConfig.customCall,
+    options?: { dynamicGoal?: boolean; dynamicGoalPrompt?: string }
+  ) {
+    const agent = new BaseAgent({
+      role: "Tester",
+      goal: "Run tests",
+      backstory: "Concise",
+      tools,
+      llmConfig: customCall
+        ? { ...llmConfig, customCall }
+        : llmConfig,
+    });
+    return new GenericExecutor(agent, tools, {
+      llmConfig: customCall ? { ...llmConfig, customCall } : llmConfig,
+      verbose: false,
+    }, undefined, options);
+  }
+
+  it("makeDecision returns response and actions from customCall", async () => {
+    const executor = createExecutor([], async () => ({
+      object: {
+        actions: [
+          {
+            name: "noop",
+            parameters: [{ name: "x", value: 1 }],
+          },
+        ],
+        response: "Taking action.",
+      },
+    }));
+
+    const context: AgentContext = {
+      input: { raw: "hello" },
+      actions: [],
+      response: "",
+      executedActions: [],
+    };
+
+    const out = await executor.makeDecision(context);
+    expect(out.response).to.equal("Taking action.");
+    expect(out.actions).to.have.lengthOf(1);
+    expect(out.actions[0].name).to.equal("noop");
+  });
+
+  it("executeActions runs matching GraphFlow tool", async () => {
+    const ToolSchema = z.object({
+      counter: z.number(),
+    });
+
+    const toolGraph = new GraphFlow({
+      name: "counterTool",
+      schema: ToolSchema,
+      context: { counter: 0 },
+      nodes: [
+        {
+          name: "bump",
+          execute: async (ctx) => {
+            ctx.counter = (ctx.counter ?? 0) + 1;
+          },
+          next: [],
+        },
+      ],
+    });
+
+    const executor = createExecutor([toolGraph], async () => ({
+      object: {
+        actions: [
+          {
+            name: "counterTool",
+            parameters: [{ name: "counter", value: 5 }],
+          },
+        ],
+        response: "Incrementing.",
+      },
+    }));
+
+    const context: AgentContext = {
+      input: { raw: "go" },
+      actions: [],
+      response: "",
+      executedActions: [],
+    };
+
+    await executor.executeActions(
+      [
+        {
+          name: "counterTool",
+          parameters: [{ name: "counter", value: 5 }],
+        },
+      ],
+      context
+    );
+
+    expect(context.executedActions).to.have.lengthOf(1);
+    expect(context.executedActions[0].name).to.equal("counterTool");
+  });
+
+  describe("Dynamic Goal", () => {
+    it("should use static goal when dynamicGoal is disabled", async () => {
+      const executor = createExecutor([], undefined, { dynamicGoal: false });
+      
+      const context: AgentContext = {
+        input: { raw: "test input" },
+        actions: [],
+        response: "",
+        executedActions: [],
+      };
+
+      const goal = executor.getCurrentGoal();
+      expect(goal).to.equal("Run tests");
+    });
+
+    it("should update dynamic goal via updateDynamicGoal method", async () => {
+      let goalCallCount = 0;
+      const goalLlmConfig = {
+        provider: "custom" as const,
+        model: "mock",
+        apiKey: "unused",
+        customCall: async () => {
+          goalCallCount++;
+          return {
+            object: {
+              goal: goalCallCount === 1 ? "Step 1: Initialize" : "Step 2: Execute",
+            },
+          };
+        },
+      };
+
+      const agent = new BaseAgent({
+        role: "Tester",
+        goal: "Run tests",
+        backstory: "Concise",
+        tools: [],
+        llmConfig: goalLlmConfig,
+      });
+
+      const executor = new GenericExecutor(agent, [], {
+        llmConfig: goalLlmConfig,
+        verbose: false,
+      }, undefined, { dynamicGoal: true });
+
+      const context1: AgentContext = {
+        input: { raw: "test input" },
+        actions: [],
+        response: "",
+        executedActions: [],
+      };
+
+      await executor.updateDynamicGoal(context1);
+      expect(executor.getCurrentGoal()).to.equal("Step 1: Initialize");
+
+      const context2: AgentContext = {
+        input: { raw: "test input" },
+        actions: [],
+        response: "",
+        executedActions: [{ name: "tool1", result: { success: true }, isExecuted: true, timestamp: new Date().toISOString() }],
+      };
+
+      await executor.updateDynamicGoal(context2);
+      expect(executor.getCurrentGoal()).to.equal("Step 2: Execute");
+    });
+
+    it("should call LLM when dynamicGoal is enabled", async () => {
+      let callCount = 0;
+
+      const sharedLlmConfig = {
+        provider: "custom" as const,
+        model: "mock",
+        apiKey: "unused",
+        customCall: async () => {
+          callCount++;
+          return {
+            object: {
+              goal: `Dynamic goal`,
+              actions: [],
+              response: `Agent response`,
+            },
+          };
+        },
+      };
+
+      const agent = new BaseAgent({
+        role: "Tester",
+        goal: "Run tests",
+        backstory: "Concise",
+        tools: [],
+        llmConfig: sharedLlmConfig,
+      });
+
+      const executor = new GenericExecutor(agent, [], {
+        llmConfig: sharedLlmConfig,
+        verbose: false,
+      }, undefined, { dynamicGoal: true });
+
+      const context: AgentContext = {
+        input: { raw: "test input" },
+        actions: [],
+        response: "",
+        executedActions: [],
+      };
+
+      await executor.updateDynamicGoal(context);
+      await executor.makeDecision(context);
+      
+      expect(callCount).to.equal(2);
+    });
+  });
+});

package/test/agent/handoff.test.ts

@@ -0,0 +1,163 @@
+import { expect } from "chai";
+import { z } from "zod";
+import { GraphFlow } from "../../execution/index";
+import { Agent } from "../../agent/agent";
+import { AgentRegistry } from "../../agent/registry";
+import { createHandoffTool } from "../../agent/handoff";
+
+describe("Handoff Integration", () => {
+  let registry: AgentRegistry;
+  let specialistAgent: Agent;
+
+  beforeEach(() => {
+    registry = new AgentRegistry();
+
+    specialistAgent = new Agent({
+      role: "Specialist",
+      goal: "Handle specific tasks",
+      backstory: "I am a specialist agent",
+      tools: [],
+      verbose: false,
+      llmConfig: {
+        provider: "custom",
+        model: "mock",
+        apiKey: "unused",
+        customCall: async () => ({
+          object: { actions: [], response: "Specialist handled it." },
+        }),
+      },
+    });
+
+    registry.register(
+      "code-expert",
+      specialistAgent,
+      "coder",
+      "Expert en TypeScript"
+    );
+  });
+
+  it("handoff tool sets _handoff on context via GraphFlow", async () => {
+    const tool = createHandoffTool(registry);
+
+    const result = await tool.execute("handoff", {
+      targetAgent: "code-expert",
+      task: "Refactor this function",
+    });
+
+    expect((result as any)._handoff).to.not.be.undefined;
+    expect((result as any)._handoff.goto).to.equal("code-expert");
+    expect((result as any)._handoff.graph).to.equal("PARENT");
+  });
+
+  it("handoff tool warns for unknown agent (does not throw)", async () => {
+    const tool = createHandoffTool(registry);
+
+    const result = await tool.execute("handoff", {
+      targetAgent: "nonexistent",
+      task: "Do something",
+    });
+
+    expect((result as any)._handoff).to.be.undefined;
+  });
+
+  it("handoff tool works without registry (no validation)", async () => {
+    const tool = createHandoffTool();
+
+    const result = await tool.execute("handoff", {
+      targetAgent: "any-agent",
+      task: "Do something",
+    });
+
+    expect((result as any)._handoff.goto).to.equal("any-agent");
+  });
+
+  it("GraphFlow stops sequential execution after handoff", async () => {
+    const flow = new GraphFlow({
+      name: "handoff-test",
+      schema: z.object({ steps: z.array(z.string()).optional(), _handoff: z.any().optional() }),
+      context: { steps: [], _handoff: undefined },
+      nodes: [
+        {
+          name: "start",
+          execute: async (ctx: any) => {
+            ctx.steps = ["start"];
+          },
+          next: ["handoff-node", "after-handoff"],
+        },
+        {
+          name: "handoff-node",
+          execute: async (ctx: any) => {
+            ctx.steps.push("handoff-node");
+            ctx._handoff = {
+              goto: "specialist",
+              graph: "PARENT",
+              update: { handoffTask: "test" },
+            };
+          },
+          next: ["should-not-run"],
+        },
+        {
+          name: "after-handoff",
+          execute: async (ctx: any) => {
+            ctx.steps.push("after-handoff");
+          },
+          next: [],
+        },
+        {
+          name: "should-not-run",
+          execute: async (_ctx: any) => {
+            throw new Error("This node should not be executed after handoff");
+          },
+          next: [],
+        },
+      ],
+    });
+
+    await flow.execute("start");
+    const ctx = flow.getContext() as any;
+
+    expect(ctx.steps).to.include("start");
+    expect(ctx.steps).to.include("handoff-node");
+    expect(ctx.steps).to.not.include("should-not-run");
+    expect(ctx._handoff.goto).to.equal("specialist");
+  });
+
+  it("handoff in agent workflow stops execution", async () => {
+    const handoffTool = createHandoffTool(registry);
+
+    let callCount = 0;
+    const agent = new Agent({
+      role: "Router",
+      goal: "Route tasks to specialists",
+      backstory: "I route tasks",
+      tools: [handoffTool],
+      verbose: false,
+      maxIterations: 3,
+      llmConfig: {
+        provider: "custom",
+        model: "mock",
+        apiKey: "unused",
+        customCall: async () => {
+          callCount++;
+          return {
+            object: {
+              actions: [{
+                name: "handoff",
+                parameters: { targetAgent: "code-expert", task: "Fix bug" },
+              }],
+              response: "Handing off to code-expert.",
+            },
+          };
+        },
+      },
+    });
+
+    const ctx = await agent.process("Fix this bug please");
+    expect(ctx.response).to.equal("Handing off to code-expert.");
+
+    // Le fait que handoff-exists n'ait pas bloqué est déjà un bon signe.
+    // Le workflow s'est arrêté après avoir exécuté le handoff tool.
+    expect(ctx.executedActions).to.have.length(1);
+    expect(ctx.executedActions[0].name).to.equal("handoff");
+  });
+});

package/test/agent/llm-factory.test.ts

@@ -0,0 +1,40 @@
+import { expect } from "chai";
+import { z } from "zod";
+import { LLMFactory } from "../../agent/llm-factory";
+
+describe("LLMFactory", () => {
+  it("throws for unsupported provider", () => {
+    expect(() =>
+      LLMFactory.createLLM({
+        provider: "anthropic",
+        model: "claude-2",
+        apiKey: "x",
+      })
+    ).to.throw("Unsupported LLM provider");
+  });
+
+  it("throws when custom provider has no customCall", () => {
+    expect(() =>
+      LLMFactory.createLLM({
+        provider: "custom",
+        model: "mock",
+        apiKey: "unused",
+      })
+    ).to.throw("Custom LLM provider requires a customCall function");
+  });
+
+  it("custom provider uses customCall and returns structured object", async () => {
+    const schema = z.object({ answer: z.string() });
+    const llm = LLMFactory.createLLM({
+      provider: "custom",
+      model: "mock",
+      apiKey: "unused",
+      customCall: async (_prompt, _schema) => ({
+        object: { answer: "yes" },
+      }),
+    });
+
+    const result = await llm.generate("ignored", schema);
+    expect(result.object.answer).to.equal("yes");
+  });
+});