@ai.ntellect/core 1.0.0 → 1.1.1

package/routing/web-server.ts

@@ -0,0 +1,260 @@
+import express from 'express';
+import { createServer } from 'http';
+import { Server } from 'socket.io';
+import * as path from 'path';
+import { PetriNet } from '../routing/index';
+import { CortexFlowOrchestrator } from '../routing/orchestrator';
+import { ToolRegistry } from '../execution/registry';
+
+export class PetriWebServer {
+  private app: express.Application;
+  private server: any;
+  private io: any;
+  private orchestrator?: CortexFlowOrchestrator;
+  private sessionId?: string;
+
+  constructor(private port: number = 3001) {
+    this.app = express();
+    this.server = createServer(this.app);
+    this.io = new Server(this.server);
+    this.setupRoutes();
+    this.setupSocket();
+  }
+
+  setOrchestrator(orchestrator: CortexFlowOrchestrator, sessionId?: string) {
+    this.orchestrator = orchestrator;
+    this.sessionId = sessionId;
+  }
+
+  private setupRoutes() {
+    // Serve static HTML
+    this.app.get('/', (_req, res) => {
+      res.send(this.getHTML());
+    });
+
+    // API: Get current state
+    this.app.get('/api/state', (_req, res) => {
+      if (!this.orchestrator) {
+        res.json({ error: 'No orchestrator set' });
+        return;
+      }
+      const net = this.orchestrator.petri;
+      const marking = (net as any).state.marking as Map<string, any[]>;
+      const places = Array.from(net.places.entries()).map(([id, place]) => ({
+        id,
+        type: place.type,
+        tokens: marking.get(id)?.length || 0,
+        tokenDetails: marking.get(id) || [],
+      }));
+      const transitions = Array.from(net.transitions.entries()).map(([id, trans]) => ({
+        id,
+        from: trans.from,
+        to: trans.to,
+        description: (trans as any).description || id,
+      }));
+      const enabled = net.getEnabledTransitions();
+
+      res.json({
+        name: net.name,
+        places,
+        transitions,
+        enabledTransitions: enabled,
+        history: (net as any).state.history || [],
+      });
+    });
+
+    // API: Fire transition
+    this.app.post('/api/fire/:transitionId', async (req, res) => {
+      if (!this.orchestrator || !this.sessionId) {
+        res.json({ error: 'No orchestrator/session' });
+        return;
+      }
+      try {
+        const result = await this.orchestrator.fire(req.params.transitionId, this.sessionId);
+        this.io.emit('stateUpdate', await this.getState());
+        res.json(result);
+      } catch (error) {
+        res.json({ error: (error as Error).message });
+      }
+    });
+
+    // API: Get DOT
+    this.app.get('/api/dot', (_req, res) => {
+      if (!this.orchestrator) {
+        res.json({ error: 'No orchestrator set' });
+        return;
+      }
+      res.type('text/vnd.graphviz').send(this.orchestrator.petri.toDot());
+    });
+  }
+
+  private setupSocket() {
+    this.io.on('connection', (socket: any) => {
+      console.log('Web client connected');
+      socket.emit('stateUpdate', this.getState());
+    });
+  }
+
+  private async getState() {
+    if (!this.orchestrator) return { error: 'No orchestrator set' };
+    const net = this.orchestrator.petri;
+    const marking = (net as any).state.marking as Map<string, any[]>;
+    const places = Array.from(net.places.entries()).map(([id, place]) => ({
+      id,
+      type: place.type,
+      tokens: marking.get(id)?.length || 0,
+      tokenDetails: marking.get(id) || [],
+    }));
+    const transitions = Array.from(net.transitions.entries()).map(([id, trans]) => ({
+      id,
+      from: trans.from,
+      to: trans.to,
+      description: (trans as any).description || id,
+    }));
+    const enabled = net.getEnabledTransitions();
+
+    return {
+      name: net.name,
+      places,
+      transitions,
+      enabledTransitions: enabled,
+      history: (net as any).state.history || [],
+    };
+  }
+
+  start() {
+    this.server.listen(this.port, () => {
+      console.log(`🌐 Petri Web Interface running at http://localhost:${this.port}`);
+    });
+  }
+
+  stop() {
+    this.server.close();
+  }
+
+  private getHTML(): string {
+    return `<!DOCTYPE html>
+<html>
+<head>
+  <title>CortexFlow Petri Visualizer</title>
+  <script src="https://cdn.socket.io/4.7.2/socket.io.min.js"></script>
+  <script src="https://cdn.jsdelivr.net/npm/viz.js@2.1.2/viz.js"></script>
+  <script src="https://cdn.jsdelivr.net/npm/viz.js@2.1.2/full.render.js"></script>
+  <style>
+    body { font-family: Arial, sans-serif; margin: 20px; background: #f5f5f5; }
+    .container { display: flex; gap: 20px; }
+    .panel { background: white; padding: 20px; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
+    .left { flex: 1; }
+    .right { flex: 2; }
+    h2 { margin-top: 0; color: #333; }
+    .place { padding: 10px; margin: 5px 0; background: #e3f2fd; border-left: 4px solid #2196F3; }
+    .place.initial { border-left-color: #4CAF50; }
+    .place.final { border-left-color: #F44336; }
+    .token-count { display: inline-block; background: #2196F3; color: white; border-radius: 50%; width: 24px; height: 24px; text-align: center; line-height: 24px; margin-left: 10px; }
+    .transition { padding: 10px; margin: 5px 0; background: #fff3e0; border-left: 4px solid #FF9800; cursor: pointer; }
+    .transition.enabled { background: #e8f5e9; border-left-color: #4CAF50; }
+    .dot-container { background: white; padding: 10px; border: 1px solid #ddd; min-height: 400px; }
+    button { padding: 8px 16px; margin: 5px; cursor: pointer; background: #2196F3; color: white; border: none; border-radius: 4px; }
+    button:hover { background: #1976D2; }
+    .history { font-size: 12px; color: #666; max-height: 200px; overflow-y: auto; }
+  </style>
+</head>
+<body>
+  <h1>🕸 CortexFlow Petri Visualizer</h1>
+  <div class="container">
+    <div class="panel left">
+      <h2>Places & Tokens</h2>
+      <div id="places"></div>
+      <h2>Transitions</h2>
+      <div id="transitions"></div>
+      <h2>History</h2>
+      <div id="history" class="history"></div>
+    </div>
+    <div class="panel right">
+      <h2>Graph Visualization (DOT)</h2>
+      <div>
+        <button onclick="refreshDot()">Refresh DOT</button>
+        <button onclick="fireTransition(prompt('Transition ID?'))">Fire Transition</button>
+      </div>
+      <div id="dot" class="dot-container"></div>
+    </div>
+  </div>
+
+  <script>
+    const socket = io();
+    let currentState = {};
+
+    socket.on('stateUpdate', (state) => {
+      currentState = state;
+      updatePlaces(state.places || []);
+      updateTransitions(state.transitions || [], state.enabledTransitions || []);
+      updateHistory(state.history || []);
+      updateDot();
+    });
+
+    function updatePlaces(places) {
+      const div = document.getElementById('places');
+      div.innerHTML = places.map(p => {
+        const cls = p.type === 'initial' ? 'initial' : p.type === 'final' ? 'final' : '';
+        return '<div class="place ' + cls + '">' +
+          '<strong>' + p.id + '</strong> (' + p.type + ')' +
+          '<span class="token-count">' + p.tokens + '</span>' +
+          '</div>';
+      }).join('');
+    }
+
+    function updateTransitions(transitions, enabled) {
+      const div = document.getElementById('transitions');
+      div.innerHTML = transitions.map(t => {
+        const isEnabled = enabled.includes(t.id);
+        return '<div class="transition ' + (isEnabled ? 'enabled' : '') + '" onclick="fireTransition(\'' + t.id + '\')">' +
+          '<strong>' + t.description + '</strong> (' + t.id + ')' +
+          (isEnabled ? ' ✅ ENABLED' : '') +
+          '</div>';
+      }).join('');
+    }
+
+    function updateHistory(history) {
+      const div = document.getElementById('history');
+      div.innerHTML = history.slice(-10).map((h, i) => (history.length - 10 + i) + ': ' + h).join('<br>');
+    }
+
+    function updateDot() {
+      fetch('/api/dot')
+        .then(r => r.text())
+        .then(dot => {
+          try {
+            const result = Viz(dot, { format: 'svg', engine: 'dot' });
+            document.getElementById('dot').innerHTML = result;
+          } catch (e) {
+            document.getElementById('dot').innerHTML = '<pre>' + dot + '</pre><p>Error rendering: ' + e + '</p>';
+          }
+        });
+    }
+
+    function fireTransition(id) {
+      if (!id) return;
+      fetch('/api/fire/' + id, { method: 'POST' })
+        .then(() => console.log('Fired:', id))
+        .catch(e => alert('Error: ' + e));
+    }
+
+    function refreshDot() {
+      updateDot();
+    }
+
+    // Initial load
+    fetch('/api/state')
+      .then(r => r.json())
+      .then(state => {
+        currentState = state;
+        updatePlaces(state.places || []);
+        updateTransitions(state.transitions || [], state.enabledTransitions || []);
+        updateHistory(state.history || []);
+        updateDot();
+      });
+  </script>
+</body>
+</html>`;
+  }
+}

package/scripts/generate-petri-docs.ts

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+/**
+ * Generate living documentation for CortexFlow Petri nets
+ * Usage: npx ts-node scripts/generate-petri-docs.ts [petri-net.json] [output-dir]
+ */
+
+import { PetriNet } from '../routing/index';
+import { PetriDocumentationGenerator } from '../routing/documentation-generator';
+import * as fs from 'fs';
+import * as path from 'path';
+
+async function main() {
+  const args = process.argv.slice(2);
+  
+  if (args.length === 0) {
+    console.log('Usage: npx ts-node scripts/generate-petri-docs.ts <petri-net.json> [output-dir]');
+    console.log('');
+    console.log('Examples:');
+    console.log('  npx ts-node scripts/generate-petri-docs.ts examples/my-net.json');
+    console.log('  npx ts-node scripts/generate-petri-docs.ts examples/my-net.json ./docs');
+    process.exit(1);
+  }
+
+  const inputFile = args[0];
+  const outputDir = args[1] || './docs/petri';
+
+  if (!fs.existsSync(inputFile)) {
+    console.error(`Error: File not found: ${inputFile}`);
+    process.exit(1);
+  }
+
+  console.log(`📖 Generating documentation for ${inputFile}...`);
+
+  // Load Petri net from JSON
+  const json = JSON.parse(fs.readFileSync(inputFile, 'utf8'));
+  
+  const net = new PetriNet(json.name || path.basename(inputFile, '.json'));
+  
+  // Add places
+  for (const place of json.places || []) {
+    net.addPlace(place);
+  }
+  
+  // Add transitions
+  for (const trans of json.transitions || []) {
+    net.addTransition(trans);
+  }
+
+  // Generate documentation
+  const generator = new PetriDocumentationGenerator();
+  await generator.generateForPetri(net, {
+    outputDir,
+    format: 'all',  // Generate markdown + mermaid + html
+    includeHistory: true,
+    includeState: true,
+  });
+
+  console.log(`✅ Documentation generated in ${outputDir}`);
+  console.log('');
+  console.log('Generated files:');
+  console.log(`  - ${outputDir}/${net.name}.md`);
+  console.log(`  - ${outputDir}/${net.name}-diagram.mmd`);
+  console.log(`  - ${outputDir}/${net.name}.html`);
+}
+
+main().catch(err => {
+  console.error('Error:', err.message);
+  process.exit(1);
+});

package/scripts/get-gmail-token.js

@@ -0,0 +1,65 @@
+const { google } = require('googleapis');
+const http = require('http');
+const { parse } = require('url');
+const fs = require('fs');
+const open = require('open').default || require('open');
+
+const CLIENT_SECRET_PATH = './client_secret.json';
+const TOKEN_PATH = './gmail_token.json';
+
+async function getToken() {
+  const credentials = JSON.parse(fs.readFileSync(CLIENT_SECRET_PATH, 'utf8'));
+  const { client_id, client_secret } = credentials.web;
+
+  const oauth2Client = new google.auth.OAuth2(
+    client_id,
+    client_secret,
+    'http://localhost:3000/oauth2callback'
+  );
+
+  const scopes = [
+    'https://www.googleapis.com/auth/gmail.readonly',
+    'https://www.googleapis.com/auth/gmail.modify',
+  ];
+
+  const authorizeUrl = oauth2Client.generateAuthUrl({
+    access_type: 'offline',
+    scope: scopes,
+    prompt: 'consent',
+  });
+
+  console.log('Opening browser for authorization...');
+  console.log('URL:', authorizeUrl);
+
+  await open(authorizeUrl);
+
+  const server = http.createServer(async (req, res) => {
+    const queryParams = parse(req.url, true).query;
+    const code = queryParams.code;
+
+    if (code) {
+      try {
+        const { tokens } = await oauth2Client.getToken(code);
+        fs.writeFileSync(TOKEN_PATH, JSON.stringify(tokens, null, 2));
+
+        res.writeHead(200, { 'Content-Type': 'text/html' });
+        res.end('<h1>Authorization successful!</h1><p>You can close this window.</p>');
+
+        console.log('Token saved to', TOKEN_PATH);
+        server.close();
+        process.exit(0);
+      } catch (error) {
+        console.error('Error getting tokens:', error);
+        res.writeHead(500);
+        res.end('Error');
+        process.exit(1);
+      }
+    }
+  });
+
+  server.listen(3000, () => {
+    console.log('Listening on http://localhost:3000');
+  });
+}
+
+getToken().catch(console.error);

package/scripts/get-gmail-token.ts

@@ -0,0 +1,65 @@
+import { google } from 'googleapis';
+import http from 'http';
+import { parse } from 'url';
+import fs from 'fs';
+import open from 'open';
+
+const CLIENT_SECRET_PATH = './client_secret.json';
+const TOKEN_PATH = './gmail_token.json';
+
+async function getToken() {
+  const credentials = JSON.parse(fs.readFileSync(CLIENT_SECRET_PATH, 'utf8'));
+  const { client_id, client_secret } = credentials.web;
+
+  const oauth2Client = new google.auth.OAuth2(
+    client_id,
+    client_secret,
+    'http://localhost:3000/oauth2callback'
+  );
+
+  const scopes = [
+    'https://www.googleapis.com/auth/gmail.readonly',
+    'https://www.googleapis.com/auth/gmail.modify',
+  ];
+
+  const authorizeUrl = oauth2Client.generateAuthUrl({
+    access_type: 'offline',
+    scope: scopes,
+    prompt: 'consent',
+  });
+
+  console.log('Opening browser for authorization...');
+  console.log('URL:', authorizeUrl);
+
+  await open(authorizeUrl);
+
+  const server = http.createServer(async (req, res) => {
+    const queryParams = parse(req.url!, true).query;
+    const code = queryParams.code as string;
+
+    if (code) {
+      try {
+        const { tokens } = await oauth2Client.getToken(code);
+        fs.writeFileSync(TOKEN_PATH, JSON.stringify(tokens, null, 2));
+
+        res.writeHead(200, { 'Content-Type': 'text/html' });
+        res.end('<h1>Authorization successful!</h1><p>You can close this window.</p>');
+
+        console.log('Token saved to', TOKEN_PATH);
+        server.close();
+        process.exit(0);
+      } catch (error) {
+        console.error('Error getting tokens:', error);
+        res.writeHead(500);
+        res.end('Error');
+        process.exit(1);
+      }
+    }
+  });
+
+  server.listen(3000, () => {
+    console.log('Listening on http://localhost:3000');
+  });
+}
+
+getToken().catch(console.error);

package/test/agent/agent.test.ts

@@ -0,0 +1,92 @@
+import { expect } from "chai";
+import { z } from "zod";
+import { GraphFlow } from "../../execution/index";
+import { Agent } from "../../agent/agent";
+
+describe("Agent", () => {
+  it("process completes when LLM returns no actions", async () => {
+    const agent = new Agent({
+      role: "Echo",
+      goal: "Reply only",
+      backstory: "Minimal",
+      tools: [],
+      verbose: false,
+      llmConfig: {
+        provider: "custom",
+        model: "mock",
+        apiKey: "unused",
+        customCall: async () => ({
+          object: { actions: [], response: "Hello back." },
+        }),
+      },
+    });
+
+    const ctx = await agent.process("hi");
+    expect(ctx.response).to.equal("Hello back.");
+    expect(ctx.actions).to.be.an("array").that.is.empty;
+  });
+
+  it("process runs tool graph when LLM requests an action", async () => {
+    const ToolSchema = z.object({
+      message: z.string(),
+    });
+
+    const tool = new GraphFlow({
+      name: "setMessage",
+      schema: ToolSchema,
+      context: { message: "" },
+      nodes: [
+        {
+          name: "write",
+          execute: async (c) => {
+            c.message = "from-tool";
+          },
+          next: [],
+        },
+      ],
+    });
+
+    let callCount = 0;
+    const agent = new Agent({
+      role: "Writer",
+      goal: "Use tool",
+      backstory: "Test",
+      tools: [tool],
+      verbose: false,
+      maxIterations: 3,
+      llmConfig: {
+        provider: "custom",
+        model: "mock",
+        apiKey: "unused",
+        customCall: async () => {
+          callCount++;
+          if (callCount === 1) {
+            return {
+              object: {
+                actions: [
+                  {
+                    name: "setMessage",
+                    parameters: { message: "ignored" },
+                  },
+                ],
+                response: "Used tool.",
+              },
+            };
+          }
+          return {
+            object: {
+              actions: [],
+              response: "Done.",
+            },
+          };
+        },
+      },
+    });
+
+    const ctx = await agent.process("run tool");
+    expect(ctx.response).to.equal("Done.");
+    expect(ctx.knowledge).to.be.a("string");
+    expect(ctx.executedActions).to.have.length(1);
+    expect(ctx.executedActions[0].name).to.equal("setMessage");
+  });
+});

package/test/agent/clone.test.ts

@@ -0,0 +1,143 @@
+import { expect } from "chai";
+import { z } from "zod";
+import { GraphFlow } from "../../execution/index";
+import { Agent } from "../../agent/agent";
+
+describe("Clone / Decompose", () => {
+  it("with enableClone, actions decompose into parallel groups", async () => {
+    const toolA = new GraphFlow({
+      name: "toolA",
+      schema: z.object({ msg: z.string() }),
+      context: { msg: "" },
+      nodes: [{ name: "run", execute: async (c) => { c.msg = "A"; }, next: [] }],
+    });
+    const toolB = new GraphFlow({
+      name: "toolB",
+      schema: z.object({ msg: z.string() }),
+      context: { msg: "" },
+      nodes: [{ name: "run", execute: async (c) => { c.msg = "B"; }, next: [] }],
+    });
+
+    let callCount = 0;
+    const agent = new Agent({
+      role: "CloneAgent",
+      goal: "Use both tools in parallel",
+      backstory: "I parallelize",
+      tools: [toolA, toolB],
+      verbose: false,
+      maxIterations: 2,
+      enableClone: true,
+      llmConfig: {
+        provider: "custom",
+        model: "mock",
+        apiKey: "unused",
+        customCall: async () => {
+          callCount++;
+          if (callCount === 1) {
+            return {
+              object: {
+                actions: [
+                  { name: "toolA", parameters: { msg: "doA" } },
+                  { name: "toolB", parameters: { msg: "doB" } },
+                ],
+                response: "Using both tools.",
+              },
+            };
+          }
+          if (callCount === 2) {
+            return {
+              object: {
+                groups: [
+                  [{ name: "toolA", parameters: { msg: "doA" } }],
+                  [{ name: "toolB", parameters: { msg: "doB" } }],
+                ],
+                reasoning: "These tools are independent",
+              },
+            };
+          }
+          return {
+            object: { actions: [], response: "Done." },
+          };
+        },
+      },
+    });
+
+    const ctx = await agent.process("run both tools");
+    expect(ctx.executedActions).to.have.length(2);
+    const names = ctx.executedActions.map((a: any) => a.name);
+    expect(names).to.include("toolA");
+    expect(names).to.include("toolB");
+  });
+
+  it("without enableClone, actions run sequentially (default behavior)", async () => {
+    const toolA = new GraphFlow({
+      name: "toolA",
+      schema: z.object({ msg: z.string() }),
+      context: { msg: "" },
+      nodes: [{ name: "run", execute: async (c) => { c.msg = "A"; }, next: [] }],
+    });
+
+    let callCount = 0;
+    const agent = new Agent({
+      role: "SeqAgent",
+      goal: "Use tool",
+      backstory: "Sequential",
+      tools: [toolA],
+      verbose: false,
+      maxIterations: 2,
+      llmConfig: {
+        provider: "custom",
+        model: "mock",
+        apiKey: "unused",
+        customCall: async () => {
+          callCount++;
+          if (callCount === 1) {
+            return {
+              object: {
+                actions: [{ name: "toolA", parameters: { msg: "test" } }],
+                response: "Using tool.",
+              },
+            };
+          }
+          return {
+            object: { actions: [], response: "Done." },
+          };
+        },
+      },
+    });
+
+    const ctx = await agent.process("run tool");
+    expect(ctx.executedActions).to.have.length(1);
+    expect(ctx.executedActions[0].name).to.equal("toolA");
+  });
+
+  it("decompose can work with registered tools", async () => {
+    let callCount = 0;
+    const agent = new Agent({
+      role: "Helper",
+      goal: "Task",
+      backstory: "Helper",
+      tools: [],
+      verbose: false,
+      maxIterations: 2,
+      enableClone: true,
+      llmConfig: {
+        provider: "custom",
+        model: "mock",
+        apiKey: "unused",
+        customCall: async () => {
+          callCount++;
+          return {
+            object: {
+              actions: [],
+              response: callCount === 1 ? "Thinking..." : "Done.",
+            },
+          };
+        },
+      },
+    });
+
+    const ctx = await agent.process("simple task");
+    expect(ctx.response).to.equal("Done.");
+  });
+});