@ai.ntellect/core 1.0.0 → 1.1.0

package/test/modules/agenda/node-cron.test.ts

@@ -0,0 +1,307 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { Agenda } from "../../../modules/agenda";
+import { NodeCronAdapter } from "../../../modules/agenda/adapters/node-cron";
+import { Memory } from "../../../modules/memory";
+import { InMemoryAdapter } from "../../../modules/memory/adapters/in-memory";
+
+before(function () {
+  this.timeout(10000);
+});
+
+describe("Agenda Service", () => {
+  let agenda: Agenda;
+  const scheduledIds: string[] = []; // Track all scheduled request IDs
+
+  beforeEach(() => {
+    const cronService = new NodeCronAdapter();
+    const inMemory = new InMemoryAdapter();
+    const memory = new Memory(inMemory);
+    agenda = new Agenda(cronService, memory);
+  });
+
+  afterEach(async () => {
+    // Cancel all scheduled requests by their IDs
+    scheduledIds.forEach((id) => agenda.cancelScheduledRequest(id));
+    scheduledIds.length = 0; // Clear the array
+
+    // Ensure all tasks are stopped
+    await agenda.stop();
+
+    await agenda.cancel({});
+
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  });
+
+  describe("Request Scheduling", () => {
+    it("should schedule a new request and return an id", async () => {
+      const request = {
+        originalRequest: "test request",
+        cronExpression: "0 0 * * *",
+      };
+
+      const id = await agenda.scheduleRequest(request);
+      scheduledIds.push(id); // Track the ID
+
+      expect(id).to.be.a("string");
+      expect(await agenda.getScheduledRequests()).to.have.lengthOf(1);
+
+      const scheduledRequest = (await agenda.getScheduledRequests())[0];
+      expect(scheduledRequest.originalRequest).to.equal(
+        request.originalRequest
+      );
+      expect(scheduledRequest.cronExpression).to.equal(request.cronExpression);
+      expect(scheduledRequest.isRecurring).to.be.false;
+
+      agenda.cancelScheduledRequest(id);
+    });
+
+    it("should execute callbacks when scheduling and executing", async function () {
+      this.timeout(5000);
+
+      const onScheduledSpy = sinon.spy();
+      const onExecutedSpy = sinon.spy();
+
+      const request = {
+        originalRequest: "test request",
+        cronExpression: `${(new Date().getSeconds() + 1) % 60} * * * * *`,
+      };
+
+      const id = await agenda.scheduleRequest(request, {
+        onScheduled: onScheduledSpy,
+        onExecuted: onExecutedSpy,
+      });
+      scheduledIds.push(id);
+
+      expect(onScheduledSpy.calledOnce).to.be.true;
+
+      await new Promise<void>((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          reject(new Error("Callback execution timeout"));
+        }, 4000);
+
+        const checkExecution = () => {
+          if (onExecutedSpy.calledOnce) {
+            clearTimeout(timeout);
+            agenda.cancelScheduledRequest(id);
+            resolve();
+            return;
+          }
+          setTimeout(checkExecution, 100);
+        };
+        checkExecution();
+      });
+
+      expect(onExecutedSpy.calledOnce).to.be.true;
+    });
+  });
+
+  describe("Request Management", () => {
+    it("should cancel a scheduled request", async () => {
+      const request = {
+        originalRequest: "test request",
+        cronExpression: "*/1 * * * *",
+      };
+
+      const id = await agenda.scheduleRequest(request);
+      scheduledIds.push(id);
+      expect(await agenda.getScheduledRequests()).to.have.lengthOf(1);
+
+      const cancelled = await agenda.cancelScheduledRequest(id);
+      expect(cancelled).to.be.true;
+      expect(await agenda.getScheduledRequests()).to.have.lengthOf(0);
+    });
+
+    it("should return false when cancelling non-existent request", async () => {
+      const cancelled = await agenda.cancelScheduledRequest("non-existent-id");
+      expect(cancelled).to.be.false;
+    });
+
+    it("should get all scheduled requests", async () => {
+      const requests = [
+        {
+          originalRequest: "request 1",
+          cronExpression: "*/1 * * * *",
+        },
+        {
+          originalRequest: "request 2",
+          cronExpression: "*/5 * * * *",
+        },
+      ];
+
+      for (const request of requests) {
+        const id = await agenda.scheduleRequest(request);
+        scheduledIds.push(id);
+      }
+
+      const scheduledRequests = await agenda.getScheduledRequests();
+      expect(scheduledRequests).to.have.lengthOf(2);
+      expect(scheduledRequests[0].originalRequest).to.equal("request 1");
+      expect(scheduledRequests[1].originalRequest).to.equal("request 2");
+    });
+
+    it("should stop all scheduled requests", async () => {
+      const requests = [
+        {
+          originalRequest: "request 1",
+          cronExpression: "*/1 * * * *",
+        },
+        {
+          originalRequest: "request 2",
+          cronExpression: "*/5 * * * *",
+        },
+      ];
+
+      for (const request of requests) {
+        await agenda.scheduleRequest(request);
+      }
+
+      expect(await agenda.getScheduledRequests()).to.have.lengthOf(2);
+
+      await agenda.stopAll();
+      expect(await agenda.getScheduledRequests()).to.have.lengthOf(0);
+    });
+  });
+
+  describe("Global Management", () => {
+    it("should stop all scheduled requests", async () => {
+      const requests = [
+        {
+          originalRequest: "request 1",
+          cronExpression: "*/1 * * * *",
+        },
+        {
+          originalRequest: "request 2",
+          cronExpression: "*/5 * * * *",
+        },
+      ];
+
+      for (const request of requests) {
+        await agenda.scheduleRequest(request);
+      }
+
+      expect(await agenda.getScheduledRequests()).to.have.lengthOf(2);
+
+      await agenda.stopAll();
+      expect(await agenda.getScheduledRequests()).to.have.lengthOf(0);
+    });
+  });
+
+  describe("Error Handling", () => {
+    it("should handle execution errors gracefully", async () => {
+      const consoleSpy = sinon.spy(console, "error");
+
+      const request = {
+        originalRequest: "error request",
+        cronExpression: "0 0 * * *",
+      };
+
+      const id = await agenda.scheduleRequest(request);
+
+      // Wait for execution
+      await new Promise((resolve) => setTimeout(resolve, 1100));
+
+      expect(consoleSpy.called).to.be.false;
+
+      agenda.cancelScheduledRequest(id);
+      consoleSpy.restore();
+    });
+  });
+
+  describe("Request Execution", () => {
+    it("should execute non-recurring requests only once", async function () {
+      this.timeout(5000);
+      const onExecutedSpy = sinon.spy();
+
+      const request = {
+        originalRequest: "single execution",
+        cronExpression: `${new Date().getSeconds() + 1} * * * * *`,
+      };
+
+      const id = await agenda.scheduleRequest(request, {
+        onExecuted: onExecutedSpy,
+      });
+
+      try {
+        await new Promise<void>((resolve, reject) => {
+          const timeout = setTimeout(
+            () => reject(new Error("Test timeout")),
+            4000
+          );
+          const checkExecution = () => {
+            if (onExecutedSpy.calledOnce) {
+              clearTimeout(timeout);
+              resolve();
+              return;
+            }
+            setTimeout(checkExecution, 100);
+          };
+          checkExecution();
+        });
+      } finally {
+        agenda.cancelScheduledRequest(id);
+      }
+
+      expect(onExecutedSpy.calledOnce).to.be.true;
+      expect(await agenda.getScheduledRequests()).to.have.lengthOf(0);
+    });
+
+    it("should log execution status", async function () {
+      this.timeout(10000);
+      const consoleLogSpy = sinon.spy(console, "log");
+
+      const request = {
+        originalRequest: "test request",
+        cronExpression: `${new Date().getSeconds() + 1} * * * * *`,
+      };
+
+      const id = await agenda.scheduleRequest(request);
+
+      await new Promise<void>((resolve) => {
+        const checkExecution = () => {
+          if (
+            consoleLogSpy.calledWith(`🔄 Executing scheduled request: ${id}`) &&
+            consoleLogSpy.calledWith(
+              `✅ Scheduled request executed successfully: ${id}`
+            )
+          ) {
+            agenda.cancelScheduledRequest(id);
+            resolve();
+            return;
+          }
+          setTimeout(checkExecution, 100);
+        };
+        checkExecution();
+      });
+
+      expect(consoleLogSpy.calledWith(`🔄 Executing scheduled request: ${id}`))
+        .to.be.true;
+      expect(
+        consoleLogSpy.calledWith(
+          `✅ Scheduled request executed successfully: ${id}`
+        )
+      ).to.be.true;
+
+      consoleLogSpy.restore();
+    });
+  });
+});
+
+let globalAgenda: Agenda;
+before(() => {
+  const cronService = new NodeCronAdapter();
+  const inMemoryAdapter = new InMemoryAdapter();
+  const memory = new Memory(inMemoryAdapter);
+  globalAgenda = new Agenda(cronService, memory);
+});
+
+after(async () => {
+  if (globalAgenda) {
+    globalAgenda.stopAll();
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+
+  await globalAgenda.stop();
+  await globalAgenda.cancel({});
+  await new Promise((resolve) => setTimeout(resolve, 100));
+});

package/test/modules/cli/index.test.ts

@@ -0,0 +1,125 @@
+import { expect, use } from "chai";
+import chaiAsPromised from "chai-as-promised";
+import { runCLI, CLIConfig } from "../../../modules/cli/index";
+import { Agent, Memory } from "../../../index";
+import { InMemoryAdapter } from "../../../modules/memory/adapters/in-memory";
+import { LLMProvider } from "../../../types/agent";
+
+use(chaiAsPromised);
+
+describe("CLI Module", function () {
+  describe("runCLI", function () {
+    it("should create an agent with ollama provider", async function () {
+      const config: CLIConfig = {
+        provider: "ollama" as LLMProvider,
+        model: "llama3.2:1b",
+        baseUrl: "http://localhost:11434",
+        role: "Test Assistant",
+        goal: "Test the CLI",
+        verbose: false,
+      };
+
+      const memory = new Memory(new InMemoryAdapter());
+      await memory.init();
+
+      const agent = new Agent({
+        role: config.role || "Helpful Assistant",
+        goal: config.goal || "Assist the user",
+        backstory: `You are a ${config.role || "assistant"}. Be concise.`,
+        tools: [],
+        llmConfig: {
+          provider: config.provider,
+          model: config.model,
+          baseUrl: config.baseUrl,
+        },
+        memory,
+        verbose: config.verbose,
+      });
+
+      expect(agent).to.exist;
+      expect(agent.constructor.name).to.equal("Agent");
+    });
+
+    it("should create an agent with openai provider", async function () {
+      const config: CLIConfig = {
+        provider: "openai" as LLMProvider,
+        model: "gpt-4o-mini",
+        apiKey: process.env.OPENAI_API_KEY || "test-key",
+        role: "OpenAI Assistant",
+        goal: "Test OpenAI provider",
+        verbose: false,
+      };
+
+      const memory = new Memory(new InMemoryAdapter());
+      await memory.init();
+
+      const agent = new Agent({
+        role: config.role!,
+        goal: config.goal!,
+        backstory: `You are a ${config.role}. Be concise.`,
+        tools: [],
+        llmConfig: {
+          provider: config.provider,
+          model: config.model,
+          apiKey: config.apiKey,
+        },
+        memory,
+        verbose: config.verbose,
+      });
+
+      expect(agent).to.exist;
+      expect(agent.constructor.name).to.equal("Agent");
+    });
+
+    it("should handle missing API key for OpenAI", function () {
+      const originalKey = process.env.OPENAI_API_KEY;
+      delete process.env.OPENAI_API_KEY;
+
+      const config: CLIConfig = {
+        provider: "openai" as LLMProvider,
+        model: "gpt-4o-mini",
+        role: "Test",
+      };
+
+      let errorThrown = false;
+      try {
+        if (!process.env.OPENAI_API_KEY && config.provider === "openai" && !config.apiKey) {
+          errorThrown = true;
+        }
+      } finally {
+        if (originalKey) {
+          process.env.OPENAI_API_KEY = originalKey;
+        }
+      }
+
+      expect(errorThrown).to.be.true;
+    });
+  });
+
+  describe("CLIConfig interface", function () {
+    it("should accept valid provider types", function () {
+      const providers: LLMProvider[] = ["openai", "anthropic", "ollama", "custom"];
+
+      providers.forEach((provider) => {
+        const config: CLIConfig = {
+          provider,
+          model: "test-model",
+        };
+        expect(config.provider).to.equal(provider);
+      });
+    });
+
+    it("should have optional fields", function () {
+      const config: CLIConfig = {
+        provider: "ollama" as LLMProvider,
+        model: "test-model",
+      };
+
+      expect(config.apiKey).to.be.undefined;
+      expect(config.baseUrl).to.be.undefined;
+      expect(config.role).to.be.undefined;
+      expect(config.goal).to.be.undefined;
+      expect(config.verbose).to.be.undefined;
+    });
+  });
+});

package/test/persistence/neo4j-execution-tracer.test.ts

@@ -0,0 +1,96 @@
+import { expect } from "chai";
+import { EventEmitter } from "events";
+import { Neo4jExecutionTracer } from "../../persistence/neo4j/execution-tracer";
+
+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() {}
+}
+
+class MockGraph extends EventEmitter {}
+
+describe("Neo4jExecutionTracer", () => {
+  let driver: MockDriver;
+  let graph: MockGraph;
+  let tracer: Neo4jExecutionTracer;
+
+  beforeEach(() => {
+    driver = new MockDriver();
+    graph = new MockGraph();
+    tracer = Neo4jExecutionTracer.attach(graph as any, driver as any, "exec-1");
+  });
+
+  afterEach(() => {
+    tracer.detach();
+  });
+
+  it("should initialize execution", async () => {
+    await tracer.initExecution("my-graph");
+    expect(driver.lastSession?.queries.length).to.equal(1);
+    expect(driver.lastSession?.queries[0].query).to.include("MERGE (e:Execution {id: $id})");
+    expect(driver.lastSession?.queries[0].params.graphName).to.equal("my-graph");
+  });
+
+  it("should complete execution", async () => {
+    await tracer.completeExecution("completed");
+    expect(driver.lastSession?.queries.length).to.equal(1);
+    expect(driver.lastSession?.queries[0].query).to.include("SET e.status = $status");
+    expect(driver.lastSession?.queries[0].params.status).to.equal("completed");
+  });
+
+  it("should trace node started event", async () => {
+    // We mock driver session explicitly before emitting
+    const mockSession = new MockSession();
+    driver.session = () => { driver.lastSession = mockSession; return mockSession; };
+
+    graph.emit("nodeStarted", { name: "node-1" });
+    
+    // give time for async handler
+    await new Promise(r => setTimeout(r, 10));
+
+    expect(mockSession.queries.length).to.equal(1);
+    expect(mockSession.queries[0].query).to.include("MERGE (n:NodeRun {id: $nodeRunId})");
+    expect(mockSession.queries[0].params.name).to.equal("node-1");
+  });
+
+  it("should trace node completed event", async () => {
+    const mockSession = new MockSession();
+    driver.session = () => { driver.lastSession = mockSession; return mockSession; };
+
+    graph.emit("nodeCompleted", { name: "node-1" });
+    
+    await new Promise(r => setTimeout(r, 10));
+
+    expect(mockSession.queries.length).to.equal(1);
+    expect(mockSession.queries[0].query).to.include("SET n.status = \"completed\"");
+    expect(mockSession.queries[0].params.nodeRunId).to.equal("exec-1-node-1");
+  });
+
+  it("should trace node error event", async () => {
+    const mockSession = new MockSession();
+    driver.session = () => { driver.lastSession = mockSession; return mockSession; };
+
+    graph.emit("nodeError", { payload: { name: "node-2", error: new Error("Test err") } });
+    
+    await new Promise(r => setTimeout(r, 10));
+
+    expect(mockSession.queries.length).to.equal(1);
+    expect(mockSession.queries[0].query).to.include("SET n.status = \"error\"");
+    expect(mockSession.queries[0].params.nodeRunId).to.equal("exec-1-node-2");
+    expect(mockSession.queries[0].params.error).to.equal("Test err");
+  });
+});

package/test/persistence/neo4j-memory-adapter.test.ts

@@ -0,0 +1,107 @@
+import { expect } from "chai";
+import { Neo4jMemoryAdapter } from "../../persistence/neo4j/memory-adapter";
+
+class MockSession {
+  queries: { query: string; params: any }[] = [];
+  records: any[] = [];
+  shouldFail: boolean = false;
+
+  async run(query: string, params?: Record<string, any>): Promise<{ records: any[] }> {
+    this.queries.push({ query, params });
+    if (this.shouldFail) throw new Error("Mocked failure");
+    return { records: this.records };
+  }
+
+  async close(): Promise<void> {}
+}
+
+class MockDriver {
+  lastSession?: MockSession;
+  session(config?: { database?: string }) {
+    this.lastSession = new MockSession();
+    return this.lastSession;
+  }
+  async close() {}
+}
+
+describe("Neo4jMemoryAdapter", () => {
+  let driver: MockDriver;
+  let adapter: Neo4jMemoryAdapter;
+
+  beforeEach(() => {
+    driver = new MockDriver();
+    adapter = new Neo4jMemoryAdapter(driver as any);
+  });
+
+  it("should initialize and create a room", async () => {
+    await adapter.init("room1");
+    expect(driver.lastSession?.queries.length).to.equal(1);
+    expect(driver.lastSession?.queries[0].query).to.include("MERGE (:Room {id: $roomId})");
+    expect(driver.lastSession?.queries[0].params.roomId).to.equal("room1");
+  });
+
+  it("should create memory without embedding", async () => {
+    const memory = await adapter.createMemory({
+      id: "mem1",
+      content: "hello",
+      roomId: "room1",
+      metadata: { source: "test" }
+    });
+
+    expect(memory?.id).to.equal("mem1");
+    expect(driver.lastSession?.queries.length).to.equal(1);
+    expect(driver.lastSession?.queries[0].query).to.include("CREATE (m:Memory");
+    expect(driver.lastSession?.queries[0].params.roomId).to.equal("room1");
+    expect(driver.lastSession?.queries[0].params.metadata).to.equal('{"source":"test"}');
+  });
+
+  it("should create memory with embedding", async () => {
+    const memory = await adapter.createMemory({
+      id: "mem2",
+      content: "hello",
+      roomId: "room1",
+      embedding: [0.1, 0.2]
+    });
+
+    expect(memory?.embedding).to.deep.equal([0.1, 0.2]);
+    expect(driver.lastSession?.queries.length).to.equal(2);
+    expect(driver.lastSession?.queries[1].query).to.include("SET m.embedding = $embedding");
+    expect(driver.lastSession?.queries[1].params.embedding).to.deep.equal([0.1, 0.2]);
+  });
+
+  it("should get memory by ID", async () => {
+    if (driver.lastSession) {
+      driver.lastSession.records = [{
+        get: () => ({ properties: { id: "mem1", content: "hello", roomId: "room1", createdAt: new Date().toISOString() } })
+      }];
+    }
+    
+    // Workaround to prepopulate session for the next call
+    const mockSession = new MockSession();
+    mockSession.records = [{
+      get: () => ({ properties: { id: "mem1", content: "hello", roomId: "room1", createdAt: new Date().toISOString() } })
+    }];
+    driver.session = () => mockSession;
+
+    const memory = await adapter.getMemoryById("mem1", "room1");
+    expect(memory?.content).to.equal("hello");
+    expect(mockSession.queries.length).to.equal(1);
+    expect(mockSession.queries[0].query).to.include("MATCH (m:Memory {id: $id})-[:IN_ROOM]->(:Room {id: $roomId})");
+  });
+
+  it("should add relation", async () => {
+    await adapter.addRelation({
+      fromId: "m1",
+      toId: "m2",
+      type: "SIMILAR",
+      roomId: "room1",
+      properties: { weight: 0.8 }
+    });
+
+    expect(driver.lastSession?.queries.length).to.equal(1);
+    expect(driver.lastSession?.queries[0].query).to.include("MERGE (from)-[r:RELATES_TO {type: $type}]->(to)");
+    expect(driver.lastSession?.queries[0].params.fromId).to.equal("m1");
+    expect(driver.lastSession?.queries[0].params.toId).to.equal("m2");
+    expect(driver.lastSession?.queries[0].params.weight).to.equal(0.8);
+  });
+});