@ai.ntellect/core 0.8.3 → 1.1.0

package/test/execution/plan-real-onchain.test.ts

@@ -0,0 +1,226 @@
+import { expect } from 'chai';
+import { z } from 'zod';
+import { createPublicClient, createWalletClient, http, parseEther, formatEther } from 'viem';
+import { sepolia } from 'viem/chains';
+import { privateKeyToAccount } from 'viem/accounts';
+import { GraphFlow } from '../../execution/index';
+import { ToolRegistry } from '../../execution/registry';
+import { generatePlan, PlanSchema, renderPlan } from '../../execution/planner';
+import { compilePlan } from '../../execution/compiler';
+
+// Load env
+function loadEnv() {
+  const fs = require('fs');
+  const content = fs.readFileSync('.env', 'utf-8');
+  const env: Record<string, string> = {};
+  content.split('\n').forEach((line: string) => {
+    const idx = line.indexOf('=');
+    if (idx > 0) env[line.slice(0, idx).trim()] = line.slice(idx + 1).trim();
+  });
+  return env;
+}
+
+const env = loadEnv();
+const RPC_URL = env['RPC_URL'];
+const PRIVATE_KEY_1 = env['PRIVATE_KEY_1'];
+
+// Real viem clients
+const publicClient = createPublicClient({ chain: sepolia, transport: http(RPC_URL) });
+const account = privateKeyToAccount(PRIVATE_KEY_1 as `0x${string}`);
+const walletClient = createWalletClient({ account, chain: sepolia, transport: http(RPC_URL) });
+
+// Real LLM call via Groq
+async function callGroq(prompt: string): Promise<string> {
+  const response = await fetch('https://api.groq.com/openai/v1/chat/completions', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${env['GROQ_API_KEY']}`,
+    },
+    body: JSON.stringify({
+      model: 'llama-3.1-8b-instant',
+      messages: [
+        { role: 'system', content: 'You are a workflow planner. Output valid JSON only.' },
+        { role: 'user', content: prompt },
+      ],
+      temperature: 0.1,
+      response_format: { type: 'json_object' },
+    }),
+  });
+
+  if (!response.ok) throw new Error(`Groq API error: ${await response.text()}`);
+  return (await response.json()).choices[0].message.content;
+}
+
+// Real onchain tools
+function createRealCheckBalanceTool() {
+  const g = new GraphFlow<any>({
+    name: 'check_balance',
+    context: { balance: '', address: '' },
+    schema: z.object({ balance: z.string(), address: z.string() }).passthrough(),
+    nodes: [{
+      name: 'run',
+      execute: async (ctx: any) => {
+        const address = ctx.address || account.address;
+        console.log(`  [check_balance] Checking real balance for ${address}`);
+        const balance = await publicClient.getBalance({ address });
+        ctx.balance = formatEther(balance);
+        ctx.address = address;
+        console.log(`  [check_balance] Balance: ${ctx.balance} ETH`);
+        return ctx;
+      },
+    }],
+    entryNode: 'run',
+  });
+  return g;
+}
+
+function createRealEstimateGasTool() {
+  const g = new GraphFlow<any>({
+    name: 'estimate_gas',
+    context: { gas: 0, to: '', amount: '' },
+    schema: z.object({ gas: z.number(), to: z.string(), amount: z.string() }).passthrough(),
+    nodes: [{
+      name: 'run',
+      execute: async (ctx: any) => {
+        console.log(`  [estimate_gas] Estimating gas for ${ctx.amount} ETH to ${ctx.to}`);
+        const gas = await publicClient.estimateGas({
+          account,
+          to: ctx.to,
+          value: parseEther(ctx.amount || '0.001'),
+        });
+        ctx.gas = Number(gas);
+        console.log(`  [estimate_gas] Estimated gas: ${ctx.gas}`);
+        return ctx;
+      },
+    }],
+    entryNode: 'run',
+  });
+  return g;
+}
+
+function createRealSendEthTool() {
+  const g = new GraphFlow<any>({
+    name: 'send_eth',
+    context: { txHash: '', to: '', amount: '', balance: '' },
+    schema: z.object({ txHash: z.string(), to: z.string(), amount: z.string(), balance: z.string() }).passthrough(),
+    nodes: [{
+      name: 'run',
+      execute: async (ctx: any) => {
+        console.log(`  [send_eth] Sending REAL ${ctx.amount} ETH to ${ctx.to}`);
+        const hash = await walletClient.sendTransaction({
+          to: ctx.to,
+          value: parseEther(ctx.amount || '0.001'),
+        });
+        ctx.txHash = hash;
+        console.log(`  [send_eth] TX sent: ${hash}`);
+        console.log(`  [send_eth] View: https://sepolia.etherscan.io/tx/${hash}`);
+
+        // Wait for confirmation
+        const receipt = await publicClient.waitForTransactionReceipt({ hash });
+        console.log(`  [send_eth] Confirmed! Block: ${receipt.blockNumber}`);
+        return ctx;
+      },
+    }],
+    entryNode: 'run',
+  });
+  return g;
+}
+
+describe('Plan → Compile → Execute (REAL Onchain + LLM)', function () {
+  this.timeout(120000); // Onchain + LLM calls take time
+
+  let registry: ToolRegistry;
+
+  beforeEach(() => {
+    registry = new ToolRegistry();
+    registry.register({
+      name: 'check_balance',
+      description: 'Check wallet ETH balance on Sepolia',
+      graph: createRealCheckBalanceTool(),
+      startNode: 'run',
+    });
+    registry.register({
+      name: 'estimate_gas',
+      description: 'Estimate gas for a transaction on Sepolia',
+      graph: createRealEstimateGasTool(),
+      startNode: 'run',
+    });
+    registry.register({
+      name: 'send_eth',
+      description: 'Send ETH to an address on Sepolia',
+      graph: createRealSendEthTool(),
+      startNode: 'run',
+    });
+  });
+
+  it('USE CASE 1 (REAL): Check balance + Send 0.001 ETH to another wallet', async () => {
+    console.log('\n=== USE CASE 1 (REAL): Send 0.001 ETH to STUDENT_2 ===\n');
+
+    const plan = await generatePlan(
+      `Check my balance, estimate gas, then send 0.001 ETH to ${env['STUDENT_2']}`,
+      registry,
+      callGroq
+    );
+
+    console.log('Generated plan:', JSON.stringify(plan, null, 2));
+    console.log('\n' + renderPlan(plan));
+
+    // Validate
+    const validated = PlanSchema.parse(plan);
+    expect(validated.steps).to.be.an('array').that.is.not.empty;
+
+    const validation = registry.validateSteps(validated.steps);
+    expect(validation.valid).to.be.true;
+
+    // Execute REAL onchain
+    const { graph, startNode } = compilePlan(plan, registry);
+    console.log(`\nExecuting REAL onchain plan from node: ${startNode}`);
+
+    const ctx = await graph.execute(startNode, {});
+    console.log('\nFinal context:', JSON.stringify(ctx, null, 2));
+
+    expect(ctx.txHash).to.be.a('string');
+    expect(ctx.txHash).to.include('0x');
+    console.log('\n✅ USE CASE 1 COMPLETED - REAL TX SENT!\n');
+    console.log(`   TX: https://sepolia.etherscan.io/tx/${ctx.txHash}`);
+  });
+
+  it('USE CASE 2 (REAL): Just check balance', async () => {
+    console.log('\n=== USE CASE 2 (REAL): Check balance ===\n');
+
+    const plan = await generatePlan(
+      'Check my wallet balance on Sepolia',
+      registry,
+      callGroq
+    );
+
+    console.log('Generated plan:', JSON.stringify(plan, null, 2));
+
+    const { graph, startNode } = compilePlan(plan, registry);
+    const ctx = await graph.execute(startNode, {});
+
+    console.log('\nBalance:', ctx.balance, 'ETH');
+    expect(ctx.balance).to.be.a('string');
+    console.log('\n✅ USE CASE 2 COMPLETED\n');
+  });
+
+  it('USE CASE 3 (REAL): Estimate gas without sending', async () => {
+    console.log('\n=== USE CASE 3 (REAL): Estimate gas ===\n');
+
+    const plan = await generatePlan(
+      `Estimate gas to send 0.001 ETH to ${env['STUDENT_3']}`,
+      registry,
+      callGroq
+    );
+
+    console.log('Generated plan:', JSON.stringify(plan, null, 2));
+
+    const { graph, startNode } = compilePlan(plan, registry);
+    const ctx = await graph.execute(startNode, {});
+
+    console.log('\nEstimated gas:', ctx.gas);
+    expect(ctx.gas).to.be.a('number').above(21000);
+    console.log('\n✅ USE CASE 3 COMPLETED\n');
+  });
+});

package/test/execution/send-api.test.ts

@@ -0,0 +1,121 @@
+import { expect } from "chai";
+import { GraphFlow } from "../../execution";
+import { nodeRegistry } from "../../execution/registry";
+import { ParallelNodeConfig } from "../../execution/types.parallel";
+
+describe("Send API (Fan-out dynamique)", () => {
+  beforeEach(() => {
+    (nodeRegistry as any).executeFunctions.clear();
+    (nodeRegistry as any).nodeConfigs.clear();
+  });
+
+  it("should fan-out to dynamic number of branches", async () => {
+    const items = ["item1", "item2", "item3"];
+    let processedCount = 0;
+
+    const nodes: ParallelNodeConfig<any>[] = [
+      {
+        name: "start",
+        execute: async (ctx: any) => {
+          ctx.processed = [];
+        },
+        send: (ctx: any) => {
+          return ctx.items.map((item: string, i: number) => ({
+            to: "processItem",
+            input: { currentItem: item, index: i },
+            branchId: `item_${i}`,
+          }));
+        },
+        parallel: { enabled: true, joinNode: "done" },
+      },
+      {
+        name: "processItem",
+        execute: async (ctx: any) => {
+          ctx.processed.push(`Processed: ${ctx.currentItem}`);
+        },
+      },
+      {
+        name: "done",
+        execute: async (ctx: any) => {
+          ctx.finished = true;
+        },
+      },
+    ];
+
+    const graph = new GraphFlow({
+      name: "send-api-test",
+      schema: { parse: (ctx: any) => ctx } as any,
+      context: { items, processed: [] as string[] },
+      nodes: nodes,
+      entryNode: "start",
+    });
+
+    nodes.forEach(node => nodeRegistry.registerParallel(node));
+
+    const context = await graph.execute("start");
+
+    expect(context.processed).to.have.length(3);
+    expect(context.finished).to.be.true;
+    expect(context.processed[0]).to.include("item1");
+    expect(context.processed[1]).to.include("item2");
+    expect(context.processed[2]).to.include("item3");
+  });
+
+  it("should use reducers for state merge", async () => {
+    const nodes: ParallelNodeConfig<any>[] = [
+      {
+        name: "start",
+        execute: async (ctx: any) => {
+          ctx.results = [];
+        },
+        send: (ctx: any) => {
+          return [
+            { to: "addOne", input: { value: "A" } },
+            { to: "addTwo", input: { value: "B" } },
+          ];
+        },
+        parallel: { enabled: true, joinNode: "merge" },
+        reducers: [
+          {
+            key: "results",
+            reducer: (acc: string[], val: string) => [...acc, val],
+            initial: [],
+          },
+        ],
+      },
+      {
+        name: "addOne",
+        execute: async (ctx: any) => {
+          ctx.results.push(ctx.value);
+        },
+      },
+      {
+        name: "addTwo",
+        execute: async (ctx: any) => {
+          ctx.results.push(ctx.value);
+        },
+      },
+      {
+        name: "merge",
+        execute: async (ctx: any) => {
+          ctx.merged = true;
+        },
+      },
+    ];
+
+    const graph = new GraphFlow({
+      name: "reducer-test",
+      schema: { parse: (ctx: any) => ctx } as any,
+      context: {} as any,
+      nodes: nodes,
+      entryNode: "start",
+    });
+
+    nodes.forEach(node => nodeRegistry.registerParallel(node));
+
+    const context = await graph.execute("start");
+
+    expect(context.results).to.have.length(2);
+    expect(context.merged).to.be.true;
+  });
+});

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);
+  });
+});