@ai.ntellect/core 1.0.0 → 1.1.1

package/test/persistence/neo4j-petri-checkpoint.test.ts

@@ -0,0 +1,89 @@
+import { expect } from "chai";
+import { Neo4jPetriCheckpointAdapter } from "../../persistence/neo4j/petri-checkpoint-adapter";
+import { PetriNet } from "../../routing/index";
+
+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("Neo4jPetriCheckpointAdapter", () => {
+  let driver: MockDriver;
+  let adapter: Neo4jPetriCheckpointAdapter;
+
+  beforeEach(() => {
+    driver = new MockDriver();
+    adapter = new Neo4jPetriCheckpointAdapter(driver as any);
+  });
+
+  it("should save checkpoint", async () => {
+    const net = new PetriNet("test-net");
+    net.addPlace({ id: "p1", type: "normal", tokens: [] });
+    net.state.marking.set("p1", [{ id: "t1", data: {}, createdAt: Date.now() }]);
+
+    const session: any = { id: "session1", createdAt: Date.now() };
+
+    const cpId = await adapter.save(net as any, session);
+
+    expect(cpId).to.include("petri-cp-");
+    expect(driver.lastSession?.queries.length).to.equal(1);
+    expect(driver.lastSession?.queries[0].query).to.include("CREATE (c:Checkpoint {id: $checkpointId");
+    expect(driver.lastSession?.queries[0].params.sessionId).to.equal("session1");
+    expect(driver.lastSession?.queries[0].params.marking).to.include("p1");
+  });
+
+  it("should load checkpoint", async () => {
+    const mockSession = new MockSession();
+    mockSession.records = [{
+      get: (key: string) => {
+        if (key === "c") return { properties: { id: "cp1", marking: '[{"placeId":"p1","tokens":[{"id":"t1","data":{},"createdAt":123}]}]' } };
+        if (key === "sess") return { properties: { id: "session1", createdAt: 123 } };
+      }
+    }];
+    driver.session = () => mockSession;
+
+    const result = await adapter.load("cp1");
+    
+    expect(result).to.not.be.null;
+    expect(result?.net.state.marking.has("p1")).to.be.true;
+    expect(result?.session?.id).to.equal("session1");
+  });
+
+  it("should list checkpoints", async () => {
+    const mockSession = new MockSession();
+    mockSession.records = [{
+      get: (key: string) => {
+        if (key === "id") return "cp1";
+        if (key === "timestamp") return 123456;
+        if (key === "sessionId") return "session1";
+      }
+    }];
+    driver.session = () => mockSession;
+
+    const list = await adapter.list();
+    expect(list.length).to.equal(1);
+    expect(list[0].id).to.equal("cp1");
+    expect(list[0].timestamp).to.equal(123456);
+  });
+
+  it("should delete checkpoint", async () => {
+    await adapter.delete("cp1");
+    expect(driver.lastSession?.queries.length).to.equal(1);
+    expect(driver.lastSession?.queries[0].query).to.include("DETACH DELETE c");
+    expect(driver.lastSession?.queries[0].params.checkpointId).to.equal("cp1");
+  });
+});

package/test/pipeline/agent-pipeline.test.ts

@@ -0,0 +1,118 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { AgentPipeline, Stage, PricePollingTrigger } from "../../pipeline/agent-pipeline";
+import { InMemoryPetriCheckpointAdapter } from "../../routing/checkpoint-adapter";
+
+describe("AgentPipeline", () => {
+  let pipeline: AgentPipeline;
+  let stages: Stage[];
+  let trigger: { type: string; start: sinon.SinonSpy; stop: sinon.SinonSpy };
+
+  beforeEach(() => {
+    stages = [
+      {
+        id: "fetch",
+        run: async (ctx: any) => ({ data: "fetched" }),
+        description: "Fetch data",
+      },
+      {
+        id: "process",
+        run: async (ctx: any) => ({ result: "processed" }),
+        description: "Process data",
+      },
+    ];
+
+    trigger = { type: "test", start: sinon.spy(), stop: sinon.spy() };
+
+    pipeline = new AgentPipeline({
+      name: "test-pipeline",
+      stages,
+      trigger: trigger as any,
+      sessionId: "test-session",
+    });
+  });
+
+  afterEach(() => {
+    pipeline.stop();
+    sinon.restore();
+  });
+
+  describe("constructor", () => {
+    it("should initialize with stages and session", () => {
+      expect(pipeline).to.exist;
+      expect(pipeline.getSessionId()).to.equal("test-session");
+    });
+
+    it("should set up checkpoint adapter if provided", () => {
+      const checkpointAdapter = new InMemoryPetriCheckpointAdapter();
+      const pipelineWithCheckpoint = new AgentPipeline({
+        name: "test-pipeline",
+        stages,
+        trigger: trigger as any,
+        checkpointAdapter,
+      });
+      expect(pipelineWithCheckpoint).to.exist;
+    });
+  });
+
+  describe("trigger handling", () => {
+    it("should start trigger when pipeline starts", () => {
+      pipeline.start();
+      expect(trigger.start.calledOnce).to.be.true;
+    });
+
+    it("should stop trigger when pipeline stops", () => {
+      pipeline.start();
+      pipeline.stop();
+      expect(trigger.stop.calledOnce).to.be.true;
+    });
+
+    it("should use PricePollingTrigger correctly", (done) => {
+      const priceTrigger = new PricePollingTrigger("BTC", 50000, 60000, 100);
+      expect(priceTrigger.type).to.equal("price");
+      
+      priceTrigger.start(async (data) => {
+        expect(data.asset).to.equal("BTC");
+        priceTrigger.stop();
+        done();
+      });
+    });
+  });
+
+  describe("events", () => {
+    it("should emit pipeline_started event", async () => {
+      let eventFired = false;
+      
+      pipeline.on("pipeline_started", (data) => {
+        expect(data.sessionId).to.equal("test-session");
+        eventFired = true;
+        pipeline.stop();
+      });
+
+      await pipeline.start();
+      
+      await new Promise(resolve => setTimeout(resolve, 50));
+      expect(eventFired).to.be.true;
+    });
+  });
+
+  describe("static resume", () => {
+    it("should have resume method", () => {
+      expect(AgentPipeline.resume).to.be.a("function");
+    });
+  });
+
+  describe("PricePollingTrigger", () => {
+    it("should expose pollMsValue getter", () => {
+      const trigger = new PricePollingTrigger("ETH", 2000, 3000, 5000);
+      expect(trigger.pollMsValue).to.equal(5000);
+    });
+
+    it("should stop timer on stop()", () => {
+      const priceTrigger = new PricePollingTrigger("BTC", 50000, 60000, 100);
+      priceTrigger.start(async () => {});
+      priceTrigger.stop();
+      expect(true).to.be.true;
+    });
+  });
+});

package/test/routing/checkpoint-persistence.test.ts

@@ -0,0 +1,58 @@
+import { PetriNet } from '../../routing/index';
+import { CortexFlowOrchestrator } from '../../routing/orchestrator';
+import { ToolRegistry } from '../../execution/registry';
+import { InMemoryPetriCheckpointAdapter } from '../../routing/checkpoint-adapter';
+
+async function testCheckpoint() {
+  console.log('🚀 Testing Petri Checkpoint Persistence...\n');
+
+  const toolRegistry = new ToolRegistry();
+  const orchestrator = new CortexFlowOrchestrator('test_net', toolRegistry);
+
+  // Setup Petri net
+  const net = orchestrator.petri;
+  net.addPlace({ id: 'idle', type: 'initial', tokens: [{ id: 'start', data: {}, createdAt: 0 }] });
+  net.addPlace({ id: 'processing', type: 'normal', tokens: [] });
+  net.addPlace({ id: 'done', type: 'final', tokens: [] });
+
+  net.addTransition({ id: 'process', from: ['idle'], to: 'processing' });
+  net.addTransition({ id: 'complete', from: ['processing'], to: 'done' });
+
+  // Set checkpoint adapter
+  const adapter = new InMemoryPetriCheckpointAdapter();
+  orchestrator.setPetriCheckpointAdapter(adapter);
+
+  // Start session
+  const sessionId = orchestrator.startSession();
+  console.log(`Session started: ${sessionId}`);
+
+  // Save initial state
+  const cpId1 = await orchestrator.savePetriState(sessionId);
+  console.log(`✅ Checkpoint 1 saved: ${cpId1}`);
+
+  // Fire a transition
+  const result = await orchestrator.fire('process', sessionId);
+  console.log(`✅ Transition "process" fired: ${result.success}`);
+  console.log(`   Marking after fire: idle=${net.state.marking.get('idle')?.length}, processing=${net.state.marking.get('processing')?.length}`);
+
+  // Save state after transition
+  const cpId2 = await orchestrator.savePetriState(sessionId);
+  console.log(`✅ Checkpoint 2 saved: ${cpId2}`);
+
+  // List checkpoints
+  const checkpoints = await orchestrator.listPetriCheckpoints();
+  console.log(`✅ Found ${checkpoints.length} checkpoints`);
+
+  // Restore from checkpoint 1 (initial state)
+  const restoredSessionId = await orchestrator.restorePetriState(cpId1!);
+  if (restoredSessionId) {
+    const restoredSession = orchestrator.getSession(restoredSessionId);
+    const restoredNet = restoredSession!.petriNet;
+    console.log(`✅ Restored session: ${restoredSessionId}`);
+    console.log(`   Marking after restore: idle=${restoredNet.state.marking.get('idle')?.length}, processing=${restoredNet.state.marking.get('processing')?.length}`);
+  }
+
+  console.log('\n✅ Petri Checkpoint Persistence test passed!\n');
+}
+
+testCheckpoint().catch(console.error);

package/test/routing/documentation-generator.test.ts

@@ -0,0 +1,76 @@
+import { expect } from 'chai';
+import { PetriNet, Place, Transition } from '../../routing/index';
+import { PetriDocumentationGenerator } from '../../routing/documentation-generator';
+
+describe('Petri Documentation Generator', () => {
+  let net: PetriNet;
+  let generator: PetriDocumentationGenerator;
+
+  beforeEach(() => {
+    net = new PetriNet('test-doc-net');
+    
+    const idlePlace: Place = { id: 'idle', type: 'initial', tokens: [] };
+    const processingPlace: Place = { id: 'processing', type: 'normal', tokens: [] };
+    const donePlace: Place = { id: 'done', type: 'final', tokens: [] };
+    
+    net.addPlace(idlePlace);
+    net.addPlace(processingPlace);
+    net.addPlace(donePlace);
+    
+    const startTrans: Transition = { 
+      id: 'start', 
+      from: ['idle'], 
+      to: ['processing'], 
+      description: 'Start processing' 
+    };
+    const completeTrans: Transition = { 
+      id: 'complete', 
+      from: ['processing'], 
+      to: ['done'], 
+      description: 'Complete task' 
+    };
+    
+    net.addTransition(startTrans);
+    net.addTransition(completeTrans);
+    
+    // Use internal state to add tokens
+    const marking = (net as any).state.marking as Map<string, any[]>;
+    marking.set('idle', [{ id: 't1', data: { task: 'test' }, createdAt: Date.now() }]);
+
+    generator = new PetriDocumentationGenerator();
+  });
+
+  it('should generate Mermaid diagram via public generateForPetri', async () => {
+    const outputDir = '/tmp/test-doc';
+    await generator.generateForPetri(net, { outputDir, format: 'markdown' });
+    
+    // Read generated file
+    const fs = require('fs');
+    const files = fs.readdirSync(outputDir);
+    
+    expect(files).to.include('test-doc-net.md');
+    expect(files).to.include('test-doc-net-diagram.mmd');
+    
+    const markdown = fs.readFileSync(`${outputDir}/test-doc-net.md`, 'utf8');
+    expect(markdown).to.include('# Petri Net: test-doc-net');
+    expect(markdown).to.include('Start processing');
+    
+    const mermaid = fs.readFileSync(`${outputDir}/test-doc-net-diagram.mmd`, 'utf8');
+    expect(mermaid).to.include('graph TD');
+    expect(mermaid).to.include('idle((idle');
+  });
+
+  it('should generate HTML when format is all', async () => {
+    const outputDir = '/tmp/test-doc-html';
+    await generator.generateForPetri(net, { outputDir, format: 'all' });
+    
+    const fs = require('fs');
+    const files = fs.readdirSync(outputDir);
+    
+    expect(files).to.include('test-doc-net.html');
+    
+    const html = fs.readFileSync(`${outputDir}/test-doc-net.html`, 'utf8');
+    expect(html).to.include('<!DOCTYPE html>');
+    expect(html).to.include('mermaid.initialize');
+  });
+});

package/test/routing/integration.test.ts

@@ -0,0 +1,261 @@
+import { expect } from 'chai';
+import { describe, it, beforeEach } from 'mocha';
+import { PetriNet, TransitionAction } from '../../routing/index';
+import { CortexFlowOrchestrator } from '../../routing/orchestrator';
+import { ToolRegistry } from '../../execution/registry';
+import { GraphFlow } from '../../execution/index';
+import { z } from 'zod';
+
+describe('CortexFlow Integration - Mail Assistant', () => {
+  let orchestrator: CortexFlowOrchestrator;
+  let toolRegistry: ToolRegistry;
+  let net: PetriNet;
+
+  beforeEach(() => {
+    toolRegistry = new ToolRegistry();
+    orchestrator = new CortexFlowOrchestrator('mail_assistant', toolRegistry);
+
+    net = orchestrator.petri;
+    net.addPlace({ id: 'idle', type: 'initial', tokens: [{ id: 'start', data: {}, createdAt: 0 }] });
+    net.addPlace({ id: 'fetched', type: 'normal', tokens: [] });
+    net.addPlace({ id: 'summarized', type: 'normal', tokens: [] });
+    net.addPlace({ id: 'done', type: 'final', tokens: [] });
+    net.addPlace({ id: 'error', type: 'final', tokens: [] });
+
+    net.addTransition({
+      id: 'fetch',
+      from: ['idle'],
+      to: 'fetched',
+      action: {
+        type: 'graphflow',
+        name: 'fetch_and_summarize',
+        contextMapper: (ctx) => ({ maxMails: ctx.maxMails || 5 }),
+      } as TransitionAction,
+    });
+
+    net.addTransition({
+      id: 'summarize',
+      from: ['fetched'],
+      to: 'summarized',
+      action: {
+        type: 'graphflow',
+        name: 'fetch_and_summarize',
+        contextMapper: (ctx) => ({ mails: ctx.fetchedMails }),
+      } as TransitionAction,
+    });
+
+    net.addTransition({
+      id: 'complete',
+      from: ['summarized'],
+      to: 'done',
+    });
+
+    net.addTransition({
+      id: 'fail',
+      from: ['fetched', 'summarized'],
+      to: 'error',
+    });
+  });
+
+  it('should execute a simple GraphFlow action via Petri transition', async () => {
+    let mailsFetched = false;
+    let summaryGenerated = false;
+
+    const fetchGraph = new GraphFlow<any>({
+      name: 'fetch_mails',
+      context: { maxMails: 5 },
+      schema: z.object({ maxMails: z.number() }).passthrough(),
+      nodes: [
+        {
+          name: 'fetch_mails',
+          execute: async (ctx: any) => {
+            mailsFetched = true;
+            ctx.fetchedMails = [
+              { id: 1, subject: 'Hello', body: 'World' },
+              { id: 2, subject: 'Test', body: 'Content' },
+            ];
+          },
+          next: 'summarize_mail',
+        },
+        {
+          name: 'summarize_mail',
+          execute: async (ctx: any) => {
+            summaryGenerated = true;
+            ctx.summary = `Summary of ${ctx.fetchedMails.length} mails`;
+          },
+        },
+      ],
+      entryNode: 'fetch_mails',
+    });
+
+    toolRegistry.register({
+      name: 'fetch_and_summarize',
+      description: 'Fetch and summarize mails',
+      graph: fetchGraph,
+      startNode: 'fetch_mails',
+    });
+
+    const sessionId = orchestrator.startSession();
+    const result = await orchestrator.fire('fetch', sessionId, { maxMails: 5 });
+
+    expect(result.success).to.be.true;
+    expect(mailsFetched).to.be.true;
+    expect(summaryGenerated).to.be.true;
+    expect(result.actionResult).to.have.property('summary');
+
+    // Check the session's PetriNet (not the original)
+    const session = orchestrator.getSession(sessionId)!;
+    expect(session.petriNet.state.marking.get('fetched')).to.have.lengthOf(1);
+  });
+
+  it('should handle GraphFlow timeout', async () => {
+    const slowGraph = new GraphFlow<any>({
+      name: 'slow_graph',
+      context: {},
+      schema: z.object({}).passthrough(),
+      nodes: [
+        {
+          name: 'slow_node',
+          execute: async () => {
+            await new Promise(resolve => setTimeout(resolve, 5000));
+          },
+        },
+      ],
+      entryNode: 'slow_node',
+    });
+
+    toolRegistry.register({
+      name: 'slow_action',
+      description: 'A slow action',
+      graph: slowGraph,
+      startNode: 'slow_node',
+    });
+
+    net.addTransition({
+      id: 'slow_transition',
+      from: ['idle'],
+      to: 'done',
+      action: {
+        type: 'graphflow',
+        name: 'slow_action',
+        timeout: 100,
+      } as any,
+    });
+
+    const sessionId = orchestrator.startSession();
+    try {
+      await orchestrator.fire('slow_transition', sessionId);
+      expect.fail('Should have thrown timeout error');
+    } catch (error: any) {
+      expect(error.message).to.include('timeout');
+    }
+  });
+
+  it('should handle GraphFlow execution error', async () => {
+    const errorGraph = new GraphFlow<any>({
+      name: 'error_graph',
+      context: {},
+      schema: z.object({}).passthrough(),
+      nodes: [
+        {
+          name: 'error_node',
+          execute: async () => {
+            throw new Error('Simulated failure');
+          },
+        },
+      ],
+      entryNode: 'error_node',
+    });
+
+    toolRegistry.register({
+      name: 'error_action',
+      description: 'An action that fails',
+      graph: errorGraph,
+      startNode: 'error_node',
+    });
+
+    net.addTransition({
+      id: 'error_transition',
+      from: ['idle'],
+      to: 'done',
+      action: {
+        type: 'graphflow',
+        name: 'error_action',
+      } as TransitionAction,
+    });
+
+    const sessionId = orchestrator.startSession();
+    const result = await orchestrator.fire('error_transition', sessionId);
+
+    expect(result.success).to.be.false;
+    expect(result.error).to.include('Simulated failure');
+  });
+
+  it('should not detect deadlock with event-driven transitions', () => {
+    const eventNet = new PetriNet('event_test');
+    eventNet.addPlace({ id: 'start', type: 'initial', tokens: [{ id: 't0', data: {}, createdAt: 0 }] });
+    eventNet.addPlace({ id: 'waiting', type: 'normal', tokens: [] });
+
+    eventNet.addTransition({
+      id: 'wait_for_approval',
+      from: ['start'],
+      to: 'waiting',
+      when: { events: ['human_approved'], timeout: 30000 },
+    });
+
+    expect(eventNet.detectDeadlock()).to.be.false;
+  });
+
+  it('should execute dynamic action with LLM mock', async () => {
+    let llmCalled = false;
+
+    orchestrator.setLLMCall(async (prompt: string) => {
+      llmCalled = true;
+      return JSON.stringify({
+        goal: 'Process request',
+        steps: [{ node: 'echo', params: { message: 'processed' } }],
+      });
+    });
+
+    const echoGraph = new GraphFlow<any>({
+      name: 'echo_graph',
+      context: {},
+      schema: z.object({}).passthrough(),
+      nodes: [
+        {
+          name: 'echo',
+          execute: async (ctx: any) => {
+            ctx.result = ctx.message;
+          },
+        },
+      ],
+      entryNode: 'echo',
+    });
+
+    toolRegistry.register({
+      name: 'echo',
+      description: 'Echo action',
+      graph: echoGraph,
+      startNode: 'echo',
+    });
+
+    net.addTransition({
+      id: 'dynamic_transition',
+      from: ['idle'],
+      to: 'done',
+      action: {
+        type: 'dynamic',
+        prompt: 'Process this request',
+        maxSteps: 1,
+        timeout: 5000,
+      } as TransitionAction,
+    });
+
+    const sessionId = orchestrator.startSession();
+    const result = await orchestrator.fire('dynamic_transition', sessionId);
+
+    expect(result.success).to.be.true;
+    expect(llmCalled).to.be.true;
+    expect(result.actionResult).to.have.property('result', 'processed');
+  });
+});