societyai 0.1.3 → 0.1.5

package/bin/societyai.js

@@ -160,7 +160,7 @@ async function validateCommand(filePath) {
     const ext = path.extname(fullPath);
     if (ext === '.ts') {
       console.log(colorize('dim', '  Compiling TypeScript...'));
-      execSync(`npx tsc --noEmit "${fullPath}"`, { stdio: 'pipe' });
+      execSync(`npx tsc --noEmit "${fullPath}"`, { stdio: 'pipe', cwd: path.dirname(fullPath) });
     }
 
     // Try to load and validate the module
@@ -171,7 +171,16 @@ async function validateCommand(filePath) {
 
     // For TypeScript, we need to use ts-node/register
     if (ext === '.ts') {
-      require('ts-node/register');
+      const projectDir = path.dirname(fullPath);
+      const originalCwd = process.cwd();
+      process.chdir(projectDir);
+      const localTsNode = path.join(projectDir, 'node_modules', 'ts-node', 'register');
+      try {
+        require(localTsNode);
+      } catch (e) {
+        require('ts-node/register');
+      }
+      process.chdir(originalCwd);
     }
 
     const module = require(fullPath);
@@ -188,8 +197,12 @@ async function validateCommand(filePath) {
         console.warn(colorize('yellow', '⚠️  Warning: Society does not have an execute method'));
       }
 
-      if (!society.agents || society.agents.length === 0) {
-        console.warn(colorize('yellow', '⚠️  Warning: Society has no agents'));
+      // Use build() to get the SocietyConfig for structure validation
+      if (typeof society.build === 'function') {
+        const config = society.build();
+        if (!config.agents || config.agents.length === 0) {
+          console.warn(colorize('yellow', '⚠️  Warning: Society has no agents'));
+        }
       }
     }
 
@@ -236,23 +249,36 @@ async function visualizeCommand(filePath, options) {
     // Load the module
     const ext = path.extname(fullPath);
     if (ext === '.ts') {
-      require('ts-node/register');
+      const projectDir = path.dirname(fullPath);
+      const originalCwd = process.cwd();
+      process.chdir(projectDir);
+      const localTsNode = path.join(projectDir, 'node_modules', 'ts-node', 'register');
+      try {
+        require(localTsNode);
+      } catch (e) {
+        require('ts-node/register');
+      }
+      process.chdir(originalCwd);
     }
 
     const module = require(fullPath);
     const society = module.default || module.society;
 
-    if (!society || !society.engine) {
-      console.error(colorize('red', '❌ Error: Could not find Society engine in file'));
+    if (!society || typeof society.build !== 'function') {
+      console.error(colorize('red', '❌ Error: Could not find Society builder in file'));
       process.exit(1);
     }
 
+    const { SocietyExecutor } = require('../dist/agents/society-executor');
+    const config = society.build();
+    const engine = new SocietyExecutor().buildExecutionGraph(config);
+
     let result = '';
 
     switch (format.toLowerCase()) {
       case 'mermaid':
         const { GraphVisualizer } = require('../dist/execution/graph-visualizer');
-        result = GraphVisualizer.toMermaid(society.engine, {
+        result = GraphVisualizer.toMermaid(engine, {
           direction,
           theme,
           highlightPath: highlight,
@@ -262,27 +288,27 @@ async function visualizeCommand(filePath, options) {
       case 'dot':
       case 'graphviz':
         const { GraphVisualizer: GV2 } = require('../dist/execution/graph-visualizer');
-        result = GV2.toDOT(society.engine, { rankdir: direction });
+        result = GV2.toDOT(engine, { rankdir: direction });
         break;
 
       case 'json':
         const { GraphVisualizer: GV3 } = require('../dist/execution/graph-visualizer');
-        result = JSON.stringify(GV3.toJSON(society.engine), null, 2);
+        result = JSON.stringify(GV3.toJSON(engine), null, 2);
         break;
 
       case 'html':
         const { GraphVisualizer: GV4 } = require('../dist/execution/graph-visualizer');
-        result = GV4.toHTML(society.engine, { direction, theme, highlightPath: highlight });
+        result = GV4.toHTML(engine, { direction, theme, highlightPath: highlight });
         break;
 
       case 'ascii':
         const { GraphVisualizer: GV5 } = require('../dist/execution/graph-visualizer');
-        result = GV5.toASCII(society.engine);
+        result = GV5.toASCII(engine);
         break;
 
       case 'plantuml':
         const { GraphVisualizer: GV6 } = require('../dist/execution/graph-visualizer');
-        result = GV6.toPlantUML(society.engine, direction);
+        result = GV6.toPlantUML(engine, direction);
         break;
 
       default:
@@ -334,8 +360,19 @@ async function runCommand(filePath, options) {
   try {
     // Load the module
     const ext = path.extname(fullPath);
+    const projectDir = path.dirname(fullPath);
     if (ext === '.ts') {
-      require('ts-node/register');
+      // Change to project directory so ts-node picks up the local tsconfig.json
+      const originalCwd = process.cwd();
+      process.chdir(projectDir);
+      // Use ts-node from the project's own node_modules if available
+      const localTsNode = path.join(projectDir, 'node_modules', 'ts-node', 'register');
+      try {
+        require(localTsNode);
+      } catch (e) {
+        require('ts-node/register');
+      }
+      process.chdir(originalCwd);
     }
 
     const module = require(fullPath);
@@ -347,23 +384,29 @@ async function runCommand(filePath, options) {
     }
 
     // Setup observer for verbose mode
-    const observer = verbose ? {
-      onNodeStart: (nodeId, type, input) => {
-        console.log(colorize('dim', `  ▶️  Node ${nodeId} (${type}) starting...`));
-      },
-      onNodeEnd: (nodeId, output, duration) => {
-        console.log(colorize('dim', `  ✅ Node ${nodeId} completed in ${duration}ms`));
-      },
-      onAgentStart: (agentId, modelName, input) => {
-        console.log(colorize('blue', `    🤖 Agent ${agentId} (${modelName}) processing...`));
-      },
-      onAgentComplete: (agentId, modelName, output) => {
-        console.log(colorize('green', `    ✅ Agent ${agentId} completed`));
-      },
-      onAgentError: (agentId, modelName, error) => {
-        console.log(colorize('red', `    ❌ Agent ${agentId} error: ${error.message}`));
-      },
-    } : undefined;
+    if (verbose) {
+      society.withObserver({
+        onNodeStart: (nodeId, type, input) => {
+          console.log(colorize('dim', `  ▶️  Node ${nodeId} (${type}) starting...`));
+        },
+        onNodeEnd: (nodeId, output, duration) => {
+          console.log(colorize('dim', `  ✅ Node ${nodeId} completed in ${duration}ms`));
+        },
+        onAgentStart: (agentId, modelName, input) => {
+          console.log(colorize('blue', `    🤖 Agent ${agentId} (${modelName}) processing...`));
+        },
+        onAgentComplete: (agentId, modelName, output) => {
+          console.log(colorize('green', `    ✅ Agent ${agentId} completed`));
+        },
+        onAgentError: (agentId, modelName, error) => {
+          console.log(colorize('red', `    ❌ Agent ${agentId} error: ${error.message}`));
+        },
+        onPhaseStart: () => {},
+        onPhaseComplete: () => {},
+        onSocietyStart: () => {},
+        onSocietyComplete: () => {},
+      });
+    }
 
     // Execute with timeout
     const timeoutPromise = new Promise((_, reject) => {
@@ -371,7 +414,7 @@ async function runCommand(filePath, options) {
     });
 
     const result = await Promise.race([
-      society.execute({ input, observer }),
+      society.execute(input),
       timeoutPromise,
     ]);
 
@@ -408,6 +451,8 @@ async function runCommand(filePath, options) {
       console.log(colorize('green', `\n💾 State saved to: ${saveState}`));
     }
 
+    process.exit(0);
+
   } catch (error) {
     const duration = Date.now() - startTime;
     console.error(colorize('red', `\n❌ Execution failed after ${duration}ms: ${error.message}`));
@@ -420,7 +465,7 @@ async function runCommand(filePath, options) {
 
 // Init command
 async function initCommand(template, options) {
-  const templateName = template || options.template || options.t || 'basic';
+  const templateName = options.template || options.t || template || 'basic';
   const outputDir = options.output || options.o || '.';
   const projectName = options.name || 'my-society';
 
@@ -430,10 +475,9 @@ async function initCommand(template, options) {
 
   const templates = {
     basic: {
-      'society.ts': `import { Society } from 'societyai';
-import { MockModel } from 'societyai/adapters';
+      'society.ts': `import { Society, StandardModelBase } from 'societyai';
 
-const model = new MockModel();
+const model = new StandardModelBase({}, async () => 'Hello from mock model!').withName('mock');
 
 export const society = Society.create()
   .withName('${projectName}')
@@ -449,9 +493,9 @@ export const society = Society.create()
     .sequential()
   );
 
-// Execute
+// Execute (only when run directly, not when imported by CLI tools)
 if (require.main === module) {
-  society.execute({ input: 'Hello World' })
+  society.execute('Hello World')
     .then(result => console.log(result.output))
     .catch(console.error);
 }
@@ -495,13 +539,26 @@ npm start
 
 - \`society.ts\` - Main society configuration
 `,
+      'tsconfig.json': JSON.stringify({
+        compilerOptions: {
+          target: 'ES2020',
+          module: 'commonjs',
+          moduleResolution: 'node',
+          esModuleInterop: true,
+          strict: false,
+          skipLibCheck: true,
+          outDir: 'dist',
+        },
+        'ts-node': {
+          transpileOnly: true,
+        },
+      }, null, 2),
     },
 
     advanced: {
-      'society.ts': `import { Society } from 'societyai';
-import { MockModel } from 'societyai/adapters';
+      'society.ts': `import { Society, StandardModelBase, MiddlewareChain, Middlewares } from 'societyai';
 
-const model = new MockModel();
+const model = new StandardModelBase({}, async () => 'Hello from mock model!').withName('mock');
 
 export const society = Society.create()
   .withName('${projectName}')
@@ -509,7 +566,6 @@ export const society = Society.create()
     .withId('analyzer')
     .withRole(role => role.withSystemPrompt('Analyze the input and extract key insights'))
     .withModel(model)
-    .withExecutionMode('isolated')
   )
   .addAgent(agent => agent
     .withId('validator')
@@ -522,23 +578,34 @@ export const society = Society.create()
     .withModel(model)
   )
   .addTask(task => task
-    .withId('process')
-    .withAgents(['analyzer', 'validator', 'formatter'])
-    .withInstructions('Process input through analysis, validation, and formatting')
-    .withDependencies({
-      validator: ['analyzer'],
-      formatter: ['validator'],
-    })
+    .withId('analyze')
+    .withAgents(['analyzer'])
+    .withInstructions('Analyze the input')
     .sequential()
   )
-  .withMiddleware(chain => chain
-    .use(Middlewares.logging())
-    .use(Middlewares.timing())
+  .addTask(task => task
+    .withId('validate')
+    .withAgents(['validator'])
+    .withInstructions('Validate the analysis')
+    .dependsOn('analyze')
+    .sequential()
+  )
+  .addTask(task => task
+    .withId('format')
+    .withAgents(['formatter'])
+    .withInstructions('Format the final output')
+    .dependsOn('validate')
+    .sequential()
+  )
+  .addMiddleware(
+    MiddlewareChain.create()
+      .use(Middlewares.logging())
+      .use(Middlewares.timing())
   );
 
-// Execute
+// Execute (only when run directly, not when imported by CLI tools)
 if (require.main === module) {
-  society.execute({ input: 'Hello World' })
+  society.execute('Hello World')
     .then(result => console.log(result.output))
     .catch(console.error);
 }
@@ -586,6 +653,209 @@ npm start
 - Agents: analyzer, validator, formatter
 - Pipeline: analyzer → validator → formatter
 `,
+      'tsconfig.json': JSON.stringify({
+        compilerOptions: {
+          target: 'ES2020',
+          module: 'commonjs',
+          moduleResolution: 'node',
+          esModuleInterop: true,
+          strict: false,
+          skipLibCheck: true,
+          outDir: 'dist',
+        },
+        'ts-node': {
+          transpileOnly: true,
+        },
+      }, null, 2),
+    },
+
+    mcp: {
+      'society.ts': `import { Society, StandardModelBase, MCPServers } from 'societyai';
+
+const model = new StandardModelBase({}, async (input) => \`Processed: \${input}\`).withName('mock');
+
+async function main() {
+  // Connect to an MCP filesystem server (adjust the path as needed)
+  const fsTools = await MCPServers.filesystem(process.cwd());
+
+  const society = Society.create()
+    .withName('${projectName}')
+    .addAgent(agent => agent
+      .withId('assistant')
+      .withRole(role => role
+        .withSystemPrompt('You are a helpful assistant with access to filesystem tools.')
+        .withTools(fsTools.getTools())
+      )
+      .withModel(model)
+    )
+    .addTask(task => task
+      .withId('main')
+      .withAgents(['assistant'])
+      .withInstructions('Process the input using available tools')
+      .sequential()
+    );
+
+  try {
+    const result = await society.execute('Hello World');
+    console.log(result.output);
+  } finally {
+    await fsTools.disconnect();
+  }
+}
+
+main().catch(console.error);
+`,
+      'package.json': JSON.stringify({
+        name: projectName,
+        version: '1.0.0',
+        description: `A SocietyAI project with MCP tool integration`,
+        main: 'society.ts',
+        scripts: {
+          start: 'ts-node society.ts',
+          validate: 'societyai validate society.ts',
+          visualize: 'societyai visualize society.ts --format html --output graph.html',
+        },
+        dependencies: {
+          'societyai': '^0.1.0',
+        },
+        devDependencies: {
+          'ts-node': '^10.9.0',
+          'typescript': '^5.7.0',
+        },
+      }, null, 2),
+      'README.md': `# ${projectName}
+
+A SocietyAI project with Model Context Protocol (MCP) tool integration.
+
+## Getting Started
+
+\`\`\`bash
+npm install
+npm start
+\`\`\`
+
+## Structure
+
+- \`society.ts\` - Main society configuration with MCP tool support
+- Uses MCPServers.filesystem to give agents access to filesystem tools
+`,
+      'tsconfig.json': JSON.stringify({
+        compilerOptions: {
+          target: 'ES2020',
+          module: 'commonjs',
+          moduleResolution: 'node',
+          esModuleInterop: true,
+          strict: false,
+          skipLibCheck: true,
+          outDir: 'dist',
+        },
+        'ts-node': {
+          transpileOnly: true,
+        },
+      }, null, 2),
+    },
+
+    'multi-tenant': {
+      'society.ts': `import { Society, StandardModelBase } from 'societyai';
+
+const model = new StandardModelBase({}, async (input) => \`Tenant response: \${input}\`).withName('mock');
+
+// Factory function to create a society for a specific tenant
+function createTenantSociety(tenantId: string, tenantConfig: { name: string; instructions: string }) {
+  return Society.create(\`society-\${tenantId}\`)
+    .withName(\`\${tenantConfig.name} Society\`)
+    .withGlobalContext({ tenantId, tenantName: tenantConfig.name })
+    .addAgent(agent => agent
+      .withId(\`agent-\${tenantId}\`)
+      .withRole(role => role.withSystemPrompt(tenantConfig.instructions))
+      .withModel(model)
+    )
+    .addTask(task => task
+      .withId('main')
+      .withAgents([\`agent-\${tenantId}\`])
+      .withInstructions('Process the input for this tenant')
+      .sequential()
+    );
+}
+
+// Define tenants
+const tenants = [
+  { id: 'tenant-a', name: 'Tenant A', instructions: 'You handle support tickets for Tenant A. Be formal.' },
+  { id: 'tenant-b', name: 'Tenant B', instructions: 'You handle support tickets for Tenant B. Be friendly.' },
+];
+
+// Export the multi-tenant runner
+export async function runForTenant(tenantId: string, input: string) {
+  const tenant = tenants.find(t => t.id === tenantId);
+  if (!tenant) throw new Error(\`Unknown tenant: \${tenantId}\`);
+
+  const society = createTenantSociety(tenant.id, { name: tenant.name, instructions: tenant.instructions });
+  return society.execute(input);
+}
+
+// Run example with all tenants
+async function main() {
+  const input = 'Hello, I need help with my account';
+  for (const tenant of tenants) {
+    const society = createTenantSociety(tenant.id, { name: tenant.name, instructions: tenant.instructions });
+    const result = await society.execute(input);
+    console.log(\`[\${tenant.name}]: \${result.output}\`);
+  }
+}
+
+if (require.main === module) {
+  main().catch(console.error);
+}
+`,
+      'package.json': JSON.stringify({
+        name: projectName,
+        version: '1.0.0',
+        description: `A multi-tenant SocietyAI project`,
+        main: 'society.ts',
+        scripts: {
+          start: 'ts-node society.ts',
+          validate: 'societyai validate society.ts',
+          visualize: 'societyai visualize society.ts --format html --output graph.html',
+        },
+        dependencies: {
+          'societyai': '^0.1.0',
+        },
+        devDependencies: {
+          'ts-node': '^10.9.0',
+          'typescript': '^5.7.0',
+        },
+      }, null, 2),
+      'README.md': `# ${projectName}
+
+A multi-tenant SocietyAI project where each tenant gets an isolated society instance.
+
+## Getting Started
+
+\`\`\`bash
+npm install
+npm start
+\`\`\`
+
+## Structure
+
+- \`society.ts\` - Multi-tenant society factory and runner
+- Each tenant gets its own isolated society with custom instructions
+- Use \`runForTenant(tenantId, input)\` to execute for a specific tenant
+`,
+      'tsconfig.json': JSON.stringify({
+        compilerOptions: {
+          target: 'ES2020',
+          module: 'commonjs',
+          moduleResolution: 'node',
+          esModuleInterop: true,
+          strict: false,
+          skipLibCheck: true,
+          outDir: 'dist',
+        },
+        'ts-node': {
+          transpileOnly: true,
+        },
+      }, null, 2),
     },
   };
 
@@ -593,7 +863,7 @@ npm start
 
   if (!selectedTemplate) {
     console.error(colorize('red', `❌ Unknown template: ${templateName}`));
-    console.error(colorize('dim', 'Available templates: basic, advanced'));
+    console.error(colorize('dim', 'Available templates: basic, advanced, mcp, multi-tenant'));
     process.exit(1);
   }
 
@@ -618,6 +888,68 @@ npm start
 }
 
 // Diff command
+async function inspectCommand(filePath) {
+  if (!filePath) {
+    console.error(colorize('red', '❌ Error: No file specified'));
+    console.error(colorize('dim', 'Usage: societyai inspect <path-to-state.json>'));
+    process.exit(1);
+  }
+
+  const fullPath = path.resolve(filePath);
+  if (!fs.existsSync(fullPath)) {
+    console.error(colorize('red', `❌ File not found: ${fullPath}`));
+    process.exit(1);
+  }
+
+  try {
+    const content = fs.readFileSync(fullPath, 'utf-8');
+    const state = JSON.parse(content);
+
+    console.log('\n🔍 SocietyAI Execution State Inspector\n');
+    console.log(`🆔 Execution ID: ${colorize('cyan', state.executionId || 'N/A')}`);
+    console.log(`📅 Timestamp:    ${state.timestamp ? new Date(state.timestamp).toLocaleString() : 'N/A'}`);
+    console.log(`🚦 Status:       ${formatInspectStatus(state.status)}`);
+
+    if (state.executionPath && state.executionPath.length > 0) {
+      console.log(`🛣️  Path Length:  ${state.executionPath.length} steps`);
+      console.log(`    Start:       ${state.executionPath[0] || 'N/A'}`);
+      console.log(`    Current:     ${state.executionPath[state.executionPath.length - 1] || 'N/A'}`);
+    }
+
+    console.log('\n📋 Queue (Next Nodes):');
+    if (!state.queue || state.queue.length === 0) {
+      console.log('    (Empty)');
+    } else {
+      state.queue.forEach((nodeId, idx) => {
+        console.log(`    ${idx + 1}. ${nodeId}`);
+      });
+    }
+
+    if (state.status === 'paused' && state.waitingForNodeId) {
+      console.log(`\n⏸️  Waiting For: ${colorize('yellow', state.waitingForNodeId)} (Human Input)`);
+    }
+
+    if (state.deadLetterQueue && state.deadLetterQueue.length > 0) {
+      console.log(`\n💀 Dead Letter Queue: ${colorize('red', state.deadLetterQueue.join(', '))}`);
+    }
+
+    console.log(`\n🧠 Memory/Results Captured: ${state.results ? state.results.length : 0} nodes`);
+  } catch (error) {
+    console.error(colorize('red', `❌ Error reading state file: ${error.message}`));
+    process.exit(1);
+  }
+}
+
+function formatInspectStatus(status) {
+  switch (status) {
+    case 'active': return colorize('green', 'Active');
+    case 'completed': return colorize('cyan', 'Completed');
+    case 'failed': return colorize('red', 'Failed');
+    case 'paused': return colorize('yellow', 'Paused');
+    default: return status || 'Unknown';
+  }
+}
+
 async function diffCommand(file1, file2) {
   console.log(colorize('cyan', '🔍 Comparing Society configurations...'));
 
@@ -645,7 +977,16 @@ async function diffCommand(file1, file2) {
     const ext2 = path.extname(path2);
 
     if (ext1 === '.ts' || ext2 === '.ts') {
-      require('ts-node/register');
+      const projectDir = path.dirname(path1);
+      const originalCwd = process.cwd();
+      process.chdir(projectDir);
+      const localTsNode = path.join(projectDir, 'node_modules', 'ts-node', 'register');
+      try {
+        require(localTsNode);
+      } catch (e) {
+        require('ts-node/register');
+      }
+      process.chdir(originalCwd);
     }
 
     const module1 = require(path1);
@@ -654,16 +995,19 @@ async function diffCommand(file1, file2) {
     const society1 = module1.default || module1.society;
     const society2 = module2.default || module2.society;
 
-    if (!society1 || !society2) {
-      console.error(colorize('red', '❌ Error: Could not find Society in one or both files'));
+    if (!society1 || typeof society1.build !== 'function' || !society2 || typeof society2.build !== 'function') {
+      console.error(colorize('red', '❌ Error: Could not find Society builder in one or both files'));
       process.exit(1);
     }
 
+    const config1 = society1.build();
+    const config2 = society2.build();
+
     console.log(colorize('cyan', '\n📊 Comparison Results:'));
 
     // Compare agents
-    const agents1 = society1.agents || [];
-    const agents2 = society2.agents || [];
+    const agents1 = config1.agents || [];
+    const agents2 = config2.agents || [];
 
     console.log(colorize('blue', '\nAgents:'));
     console.log(colorize('dim', `  File 1: ${agents1.length} agents`));
@@ -688,8 +1032,8 @@ async function diffCommand(file1, file2) {
     }
 
     // Compare tasks
-    const tasks1 = society1.tasks || [];
-    const tasks2 = society2.tasks || [];
+    const tasks1 = config1.tasks || [];
+    const tasks2 = config2.tasks || [];
 
     console.log(colorize('blue', '\nTasks:'));
     console.log(colorize('dim', `  File 1: ${tasks1.length} tasks`));
@@ -783,8 +1127,7 @@ async function main() {
       break;
 
     case 'inspect':
-      // Delegate to inspect.js
-      require('./inspect');
+      await inspectCommand(args[0]);
       break;
 
     case 'diff':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "societyai",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "A powerful TypeScript library for creating collaborative multi-agent AI systems with DAG-based orchestration. Build sophisticated workflows where AI agents work together through dependency graphs, conditional routing, and pluggable execution strategies. Features thread-safe parallel execution, memory management, and circuit breaker patterns for production-grade reliability.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -108,7 +108,8 @@
     "prettier": "^3.1.1",
     "ts-jest": "^29.1.1",
     "ts-node": "^10.9.2",
-    "typescript": "^5.7.3"
+    "typescript": "^5.7.3",
+    "vitest": "^4.1.0"
   },
   "peerDependencies": {
     "@modelcontextprotocol/sdk": "^0.5.0",