opc-agent 2.0.2 → 3.0.0

package/src/cli.ts

@@ -23,6 +23,7 @@ import { AnalyticsEngine } from './core/analytics-engine';
 import { runTests, formatReport } from './testing';
 import { deployToOpenClaw } from './deploy/openclaw';
 import { deployToHermes } from './deploy/hermes';
+import { AgentDeployer } from './deploy/index';
 import { WorkflowEngine } from './core/workflow';
 import { VersionManager } from './core/versioning';
 import { createProvider } from './providers';
@@ -170,11 +171,25 @@ program
       fs.mkdirSync(dir, { recursive: true });
       fs.mkdirSync(path.join(dir, 'src', 'skills'), { recursive: true });
       fs.mkdirSync(path.join(dir, 'data'), { recursive: true });
+      fs.mkdirSync(path.join(dir, 'brain-seeds'), { recursive: true });
 
       // Get system prompt content
       const systemPromptContent = roleData.files['system-prompt.md'] || roleData.files['prompts/system.md'] || '';
 
-      // agent.yaml with role system prompt
+      // Generate brain-seeds/ files from role data
+      const brainSeedContent = roleData.files['brain-seed.md'] || '';
+      const industryMatch = brainSeedContent ? brainSeedContent.match(/# Industry Knowledge[\s\S]*?(?=# Job Knowledge|# Workstation Knowledge|$)/i) : null;
+      const jobMatch = brainSeedContent ? brainSeedContent.match(/# Job Knowledge[\s\S]*?(?=# Industry Knowledge|# Workstation Knowledge|$)/i) : null;
+      const workstationMatch = brainSeedContent ? brainSeedContent.match(/# Workstation Knowledge[\s\S]*?(?=# Industry Knowledge|# Job Knowledge|$)/i) : null;
+
+      fs.writeFileSync(path.join(dir, 'brain-seeds', 'industry.md'), industryMatch?.[0]?.trim() || `# Industry Knowledge\n\n## Overview\n\nAdd industry-specific knowledge for your domain.\n`);
+      fs.writeFileSync(path.join(dir, 'brain-seeds', 'job.md'), jobMatch?.[0]?.trim() || `# Job Knowledge\n\n## Core Skills\n\nAdd role-specific knowledge for ${roleDisplayName}.\n`);
+      // workstation.md: public workstation knowledge (tools, workflows, best practices)
+      // Company-specific knowledge belongs to Desk (closed-source), not here.
+      const workstationSeedFromRole = workstationMatch?.[0]?.trim() || '';
+      fs.writeFileSync(path.join(dir, 'brain-seeds', 'workstation.md'), workstationSeedFromRole || `# Workstation Knowledge\n\n## Tools & Environment\n\nCommon tools and setup for this workstation role.\n\n## Workflows\n\nStandard operating procedures and workflows.\n\n## Best Practices\n\nIndustry best practices for this role.\n`);
+
+      // agent.yaml with role system prompt and brain seeds
       const firstLine = systemPromptContent.split('\n').find((l: string) => l.trim() && !l.startsWith('#'))?.trim() || 'You are a helpful AI assistant.';
       fs.writeFileSync(
         path.join(dir, 'agent.yaml'),
@@ -198,6 +213,15 @@ spec:
     longTerm:
       provider: deepbrain
       database: ./data/brain.db
+  brain:
+    seeds:
+      - brain-seeds/industry.md
+      - brain-seeds/job.md
+      - brain-seeds/workstation.md
+    autoSeed: true
+    evolve:
+      enabled: true
+      direction: bottom-up
   skills: []
 `,
       );
@@ -317,8 +341,12 @@ export class EchoSkill extends BaseSkill {
       console.log(`   ${icon.file} agent.yaml       - Agent definition with role system prompt`);
       console.log(`   ${icon.file} SOUL.md          - Role personality (${systemPromptContent.split('\n').length} lines)`);
       console.log(`   ${icon.file} CONTEXT.md       - Role context & documentation`);
+      console.log(`   ${icon.file} brain-seeds/     - 3-tier brain seed knowledge`);
+      console.log(`     ${color.dim('├')} industry.md    - Industry knowledge`);
+      console.log(`     ${color.dim('├')} job.md         - Job/role knowledge`);
+      console.log(`     ${color.dim('└')} workstation.md - Workstation knowledge`);
       if (roleData.files['brain-seed.md']) {
-        console.log(`   ${icon.file} data/brain-seed.md - Role brain seed knowledge`);
+        console.log(`   ${icon.file} data/brain-seed.md - Role brain seed knowledge (legacy)`);
       }
       console.log(`   ${icon.file} src/index.ts     - Entry point`);
       console.log(`   ${icon.file} package.json     - Dependencies`);
@@ -1063,9 +1091,68 @@ program
   .option('-t, --target <target>', 'Deploy target', 'openclaw')
   .option('-o, --output <dir>', 'Output directory')
   .option('--install', 'Also register in OpenClaw config')
-  .action(async (opts: { file: string; target: string; output?: string; install?: boolean }) => {
+  .option('--docker', 'Generate Dockerfile + docker-compose.yml')
+  .option('--railway', 'Deploy to Railway')
+  .option('--fly', 'Deploy to Fly.io')
+  .option('--local', 'Deploy locally via Docker Compose')
+  .option('-p, --port <port>', 'Port number', '3000')
+  .option('--replicas <n>', 'Number of replicas', '1')
+  .action(async (opts: { file: string; target: string; output?: string; install?: boolean; docker?: boolean; railway?: boolean; fly?: boolean; local?: boolean; port: string; replicas: string }) => {
+    const deployer = new AgentDeployer();
+    const agentDir = path.resolve(opts.output || '.');
+
+    // New deploy modes
+    if (opts.docker) {
+      console.log(`\n${icon.rocket} ${color.bold('Generating Docker deployment files')}\n`);
+      const result = await deployer.generateFiles(agentDir, { port: parseInt(opts.port), replicas: parseInt(opts.replicas) });
+      console.log(`${icon.success} ${result.message}`);
+      for (const f of (result.files || [])) console.log(`   ${icon.file} ${f}`);
+      console.log();
+      return;
+    }
+
+    if (opts.railway) {
+      console.log(`\n${icon.rocket} ${color.bold('Deploying to Railway')}\n`);
+      const result = await deployer.deployRailway(agentDir);
+      if (result.success) {
+        console.log(`${icon.success} ${result.message}`);
+        if (result.url) console.log(`   URL: ${color.cyan(result.url)}`);
+      } else {
+        console.error(`${icon.error} ${result.message}`);
+        process.exit(1);
+      }
+      return;
+    }
+
+    if (opts.fly) {
+      console.log(`\n${icon.rocket} ${color.bold('Deploying to Fly.io')}\n`);
+      const result = await deployer.deployFly(agentDir);
+      if (result.success) {
+        console.log(`${icon.success} ${result.message}`);
+        if (result.url) console.log(`   URL: ${color.cyan(result.url)}`);
+      } else {
+        console.error(`${icon.error} ${result.message}`);
+        process.exit(1);
+      }
+      return;
+    }
+
+    if (opts.local) {
+      console.log(`\n${icon.rocket} ${color.bold('Deploying locally via Docker')}\n`);
+      const result = await deployer.deployLocal(agentDir, { port: parseInt(opts.port), replicas: parseInt(opts.replicas) });
+      if (result.success) {
+        console.log(`${icon.success} ${result.message}`);
+        if (result.url) console.log(`   URL: ${color.cyan(result.url)}`);
+      } else {
+        console.error(`${icon.error} ${result.message}`);
+        process.exit(1);
+      }
+      return;
+    }
+
+    // Legacy deploy modes
     if (opts.target !== 'openclaw' && opts.target !== 'hermes') {
-      console.error(`${icon.error} Unknown target: ${color.bold(opts.target)}. Supported: openclaw, hermes`);
+      console.error(`${icon.error} Unknown target: ${color.bold(opts.target)}. Supported: openclaw, hermes, --docker, --railway, --fly, --local`);
       process.exit(1);
     }
     try {
@@ -1516,9 +1603,13 @@ program
 
 // ── Brain command ────────────────────────────────────────────
 
-program
+const brainCmd = program
   .command('brain')
-  .description('Show agent memory/brain status from DeepBrain')
+  .description('Manage agent brain (memory, seeds, evolve)');
+
+brainCmd
+  .command('status')
+  .description('Show brain stats (pages, tiers, last evolve)')
   .option('--url <url>', 'DeepBrain server URL', 'http://localhost:3333')
   .action(async (opts: { url: string }) => {
     console.log(`\n${icon.gear} ${color.bold('DeepBrain Status')} — ${color.dim(opts.url)}\n`);
@@ -1549,6 +1640,89 @@ program
     }
   });
 
+brainCmd
+  .command('seed')
+  .description('Import brain seed files into memory')
+  .option('-f, --file <file>', 'OAD file', 'agent.yaml')
+  .option('--status', 'Check if seeds have been imported')
+  .option('--reset', 'Re-import seeds (clear marker and re-seed)')
+  .action(async (opts: { file: string; status?: boolean; reset?: boolean }) => {
+    const { BrainSeedLoader } = require('./memory/seed-loader');
+    let config: any = {};
+    try { config = yaml.load(fs.readFileSync(opts.file, 'utf-8')) as any; } catch { /* ignore */ }
+    const brainConfig = config?.spec?.brain;
+    if (!brainConfig?.seeds?.length) {
+      console.log(`${icon.info} No brain seeds configured in ${opts.file}.`);
+      console.log(`  Add spec.brain.seeds to your agent.yaml.`);
+      return;
+    }
+
+    const loader = new BrainSeedLoader(process.cwd(), {
+      seeds: brainConfig.seeds,
+      autoSeed: brainConfig.autoSeed !== false,
+    });
+
+    if (opts.status) {
+      const seeded = await loader.isSeeded();
+      console.log(`\n  Brain seed status: ${seeded ? color.green('seeded ✔') : color.yellow('not seeded')}`);
+      console.log(`  Seeds configured: ${brainConfig.seeds.map((s: string) => color.cyan(s)).join(', ')}\n`);
+      return;
+    }
+
+    if (opts.reset) {
+      const markerPath = path.resolve(process.cwd(), '.brain-seeded');
+      if (fs.existsSync(markerPath)) {
+        fs.unlinkSync(markerPath);
+        console.log(`  ${icon.success} Cleared seed marker.`);
+      }
+    }
+
+    if (await loader.isSeeded() && !opts.reset) {
+      console.log(`${icon.info} Brain already seeded. Use --reset to re-import.`);
+      return;
+    }
+
+    console.log(`\n${icon.gear} Importing brain seeds...\n`);
+    // Use a simple mock brain that logs imports (real usage would connect to DeepBrain)
+    const pages: string[] = [];
+    const mockBrain = {
+      learn: async (content: string, meta: any) => { pages.push(meta?.slug || 'unknown'); },
+    };
+    const result = await loader.seedBrain(mockBrain);
+    await loader.markSeeded();
+
+    console.log(`  ${icon.success} Imported ${color.bold(String(result.imported))} pages from ${brainConfig.seeds.length} seed files.`);
+    for (const p of result.pages) {
+      console.log(`    ${color.dim('•')} ${p}`);
+    }
+    console.log();
+  });
+
+brainCmd
+  .command('evolve')
+  .description('Trigger manual knowledge evolution cycle')
+  .option('--dry-run', 'Show what would be promoted without doing it')
+  .action(async (opts: { dryRun?: boolean }) => {
+    const { KnowledgeEvolver } = require('./memory/seed-loader');
+    const evolver = new KnowledgeEvolver();
+    console.log(`\n${icon.gear} ${color.bold('Knowledge Evolution')}\n`);
+    console.log(`  ${icon.info} Checking for promotion candidates...`);
+    // Would connect to real brain in production
+    const result = await evolver.checkPromotion(null);
+    if (result.candidates.length === 0) {
+      console.log(`  ${icon.info} No knowledge ready for promotion yet.\n`);
+    } else {
+      for (const c of result.candidates) {
+        console.log(`  ${color.cyan(c.slug)} → ${c.fromTier} → ${c.toTier} (confidence: ${(c.confidence * 100).toFixed(0)}%)`);
+      }
+      if (opts.dryRun) {
+        console.log(`\n  ${icon.info} Dry run — no changes made.\n`);
+      } else {
+        console.log(`\n  ${icon.success} Promoted ${result.promoted} knowledge entries.\n`);
+      }
+    }
+  });
+
 // ── Logs command ─────────────────────────────────────────────
 
 program
@@ -1989,6 +2163,86 @@ program
     console.log(`\n${color.bold('Summary:')} ${allPassed}/${allTotal} passed (${allTotal ? Math.round(allPassed / allTotal * 100) : 0}%)`);
   });
 
+// ── Guardrails command ────────────────────────────────────────
+
+const guardrailsCmd = program.command('guardrails').description('Guardrail utilities');
+
+guardrailsCmd
+  .command('test <message>')
+  .description('Test guardrails against a message')
+  .option('-c, --config <file>', 'OAD config file with guardrails')
+  .action(async (message: string, opts: any) => {
+    const { GuardrailManager, createGuardrailsFromConfig } = await import('./security/guardrails');
+
+    let manager: InstanceType<typeof GuardrailManager>;
+    if (opts.config) {
+      const raw = fs.readFileSync(opts.config, 'utf-8');
+      const doc = yaml.load(raw) as any;
+      manager = createGuardrailsFromConfig(doc.spec?.guardrails ?? {});
+    } else {
+      // Default: all built-in rules
+      manager = new GuardrailManager({
+        input: [
+          { name: 'pii-detector', type: 'regex', action: 'redact' },
+          { name: 'prompt-injection', type: 'keyword', action: 'block' },
+          { name: 'toxicity', type: 'keyword', action: 'block' },
+          { name: 'compliance-filter', type: 'keyword', action: 'block' },
+        ],
+        output: [],
+      });
+    }
+
+    console.log(color.bold('Testing guardrails against:'), message);
+    console.log();
+
+    const result = await manager.checkInput(message);
+    if (result.passed) {
+      console.log(color.green('✓ PASSED — no violations'));
+    } else {
+      if (result.blocked) console.log(color.red('✗ BLOCKED'));
+      if (result.warned) console.log(color.yellow('⚠ WARNING'));
+      if (result.redacted) {
+        console.log(color.yellow('✎ REDACTED'));
+        console.log('  Redacted text:', result.redactedText);
+      }
+      for (const v of result.violations) {
+        console.log(`  [${v.action}] ${v.rule}: ${v.detail}`);
+      }
+    }
+  });
+
+// ── Voice command ─────────────────────────────────────────────
+
+program
+  .command('voice')
+  .description('Voice conversation utilities')
+  .command('start')
+  .description('Start voice conversation (requires STT/TTS providers)')
+  .option('--stt <provider>', 'STT provider: whisper, deepgram', 'whisper')
+  .option('--tts <provider>', 'TTS provider: edge-tts, openai-tts, elevenlabs', 'edge-tts')
+  .option('--voice <name>', 'Voice name/id')
+  .option('--language <lang>', 'Language code', 'en')
+  .action(async (opts: any) => {
+    console.log(color.bold('🎤 Voice Conversation Mode'));
+    console.log(`  STT: ${opts.stt} | TTS: ${opts.tts} | Voice: ${opts.voice ?? 'default'} | Language: ${opts.language}`);
+    console.log(color.dim('  (Voice conversation requires audio input integration — use as library)'));
+    console.log();
+    console.log('To use voice in your agent:');
+    console.log(color.cyan(`
+  import { VoiceChannel, createVoiceProviders } from 'opc-agent';
+
+  const { stt, tts } = createVoiceProviders({
+    sttProvider: '${opts.stt}',
+    ttsProvider: '${opts.tts}',
+    voice: '${opts.voice ?? 'en-US-AriaNeural'}',
+    language: '${opts.language}',
+  });
+
+  const voice = new VoiceChannel({ sttProvider: stt, ttsProvider: tts });
+  await voice.start();
+`));
+  });
+
 program.parse();
 
 // ── Keys command ──────────────────────────────────────────────
@@ -2279,3 +2533,37 @@ mcpCmd
     }
     console.log();
   });
+
+mcpCmd
+  .command('list')
+  .description('List available pre-built MCP servers')
+  .action(() => {
+    const { listMCPServers } = require('./mcp/servers');
+    const servers = listMCPServers();
+    console.log(`\n${icon.gear} Available MCP Servers:\n`);
+    for (const s of servers) {
+      console.log(`  ${color.green(s.name.padEnd(14))} ${s.description} ${color.dim(`(${s.toolCount} tools, v${s.version})`)}`);
+    }
+    console.log(`\n  Total: ${servers.length} servers\n`);
+  });
+
+mcpCmd
+  .command('start')
+  .argument('<name>', 'Server name (e.g. filesystem, github, calculator)')
+  .option('--port <port>', 'Start in HTTP+SSE mode on given port')
+  .description('Start a pre-built MCP server (stdio by default)')
+  .action(async (name: string, opts: { port?: string }) => {
+    const { getMCPServer } = require('./mcp/servers');
+    const { MCPServer } = require('./protocols/mcp');
+    const config = getMCPServer(name);
+    const server = new MCPServer(config);
+    if (opts.port) {
+      const port = parseInt(opts.port) || 3100;
+      await server.serveHTTP(port);
+      console.log(`${icon.success} MCP server ${color.cyan(name)} running on http://localhost:${port}`);
+      console.log(`${icon.info} Tools: ${server.getToolCount()}`);
+    } else {
+      console.error(`${icon.success} MCP server ${color.cyan(name)} (stdio) — ${server.getToolCount()} tools`);
+      await server.serveStdio();
+    }
+  });

package/src/core/agent.ts

@@ -8,6 +8,8 @@ import { MCPToolRegistry } from '../tools/mcp';
 import { SubAgentManager, type SubAgentConfig, type SubAgentResult } from './subagent';
 import { Tracer } from '../telemetry';
 import type { Span as TelemetrySpan } from '../telemetry';
+import { BrainSeedLoader, type BrainSeedConfig } from '../memory/seed-loader';
+import { GuardrailManager, type GuardrailConfig } from '../security/guardrails';
 
 export class BaseAgent extends EventEmitter implements IAgent {
   readonly name: string;
@@ -26,6 +28,9 @@ export class BaseAgent extends EventEmitter implements IAgent {
   private longTermMemory?: any;
   private longTermMemoryConfig: { autoLearn: boolean; autoRecall: boolean } = { autoLearn: true, autoRecall: true };
   private tracer?: Tracer;
+  private brainSeedConfig?: BrainSeedConfig;
+  private agentDir: string;
+  private guardrails?: GuardrailManager;
 
   constructor(options: {
     name: string;
@@ -42,6 +47,8 @@ export class BaseAgent extends EventEmitter implements IAgent {
     };
     maxToolRounds?: number;
     tracer?: Tracer;
+    agentDir?: string;
+    brainSeedConfig?: BrainSeedConfig;
   }) {
     super();
     this.name = options.name;
@@ -59,6 +66,8 @@ export class BaseAgent extends EventEmitter implements IAgent {
       this.skillLearner = new SkillLearner(options.skillsDir);
     }
     this.tracer = options.tracer;
+    this.agentDir = options.agentDir ?? process.cwd();
+    this.brainSeedConfig = options.brainSeedConfig;
   }
 
   setLongTermMemory(brain: any, config?: { autoLearn?: boolean; autoRecall?: boolean }): void {
@@ -71,6 +80,14 @@ export class BaseAgent extends EventEmitter implements IAgent {
     }
   }
 
+  setGuardrails(config: GuardrailConfig): void {
+    this.guardrails = new GuardrailManager(config);
+  }
+
+  getGuardrails(): GuardrailManager | undefined {
+    return this.guardrails;
+  }
+
   getLongTermMemory(): any {
     return this.longTermMemory;
   }
@@ -125,6 +142,17 @@ export class BaseAgent extends EventEmitter implements IAgent {
     if (this.skillLearner) {
       await this.skillLearner.loadLearnedSkills();
     }
+
+    // Auto-seed brain if configured
+    if (this.brainSeedConfig?.autoSeed && this.longTermMemory) {
+      const loader = new BrainSeedLoader(this.agentDir, this.brainSeedConfig);
+      if (!await loader.isSeeded()) {
+        const result = await loader.seedBrain(this.longTermMemory);
+        this.emit('brain:seeded', result);
+        await loader.markSeeded();
+      }
+    }
+
     this.transition('ready');
   }
 
@@ -193,6 +221,24 @@ export class BaseAgent extends EventEmitter implements IAgent {
     const sessionId = (message.metadata?.sessionId as string) ?? 'default';
     await this.memory.addMessage(sessionId, message);
 
+    // === Guardrails: check input ===
+    if (this.guardrails) {
+      const inputCheck = await this.guardrails.checkInput(message.content);
+      if (inputCheck.blocked) {
+        const blockedResponse = this.createResponse(inputCheck.message ?? 'Message blocked by guardrails.', message);
+        await this.memory.addMessage(sessionId, blockedResponse);
+        this.emit('message:out', blockedResponse);
+        if (rootSpan && this.tracer) {
+          this.tracer.addEvent(rootSpan, 'guardrail.blocked', { rule: inputCheck.violations[0]?.rule ?? 'unknown' });
+          this.tracer.endSpan(rootSpan, 'ok');
+        }
+        return blockedResponse;
+      }
+      if (inputCheck.redacted && inputCheck.redactedText) {
+        message = { ...message, content: inputCheck.redactedText };
+      }
+    }
+
     // === Recall from long-term memory ===
     let memoryContext = '';
     if (this.longTermMemory && this.longTermMemoryConfig.autoRecall) {
@@ -323,6 +369,16 @@ export class BaseAgent extends EventEmitter implements IAgent {
       });
     }
 
+    // === Guardrails: check output ===
+    if (this.guardrails) {
+      const outputCheck = await this.guardrails.checkOutput(finalResponse);
+      if (outputCheck.blocked) {
+        finalResponse = outputCheck.message ?? 'Response blocked by guardrails.';
+      } else if (outputCheck.redacted && outputCheck.redactedText) {
+        finalResponse = outputCheck.redactedText;
+      }
+    }
+
     const response = this.createResponse(finalResponse, message);
     await this.memory.addMessage(sessionId, response);
     this.emit('message:out', response);