opc-agent 4.1.0 → 4.1.1

package/src/core/context-discovery.ts

@@ -1,85 +1,85 @@
-import * as fs from 'fs';
-import * as path from 'path';
-
-export interface ContextFile {
-  path: string;
-  type: 'agents' | 'soul' | 'user' | 'memory' | 'tools' | 'identity' | 'heartbeat' | 'bootstrap' | 'custom';
-  content: string;
-}
-
-const FILE_TYPE_MAP: Record<string, ContextFile['type']> = {
-  'AGENTS.md': 'agents',
-  'SOUL.md': 'soul',
-  'USER.md': 'user',
-  'MEMORY.md': 'memory',
-  'TOOLS.md': 'tools',
-  'IDENTITY.md': 'identity',
-  'HEARTBEAT.md': 'heartbeat',
-  'BOOTSTRAP.md': 'bootstrap',
-  '.opc.md': 'custom',
-  '.opc/config.md': 'custom',
-};
-
-export class ContextDiscovery {
-  static STANDARD_FILES = [
-    'AGENTS.md', 'SOUL.md', 'USER.md', 'MEMORY.md', 'TOOLS.md',
-    'IDENTITY.md', 'HEARTBEAT.md', 'BOOTSTRAP.md',
-    '.opc.md', '.opc/config.md',
-  ];
-
-  private customFiles: string[] = [];
-  private watchers: fs.FSWatcher[] = [];
-
-  discover(workDir?: string): ContextFile[] {
-    const dir = workDir || process.cwd();
-    const found: ContextFile[] = [];
-
-    for (const file of ContextDiscovery.STANDARD_FILES) {
-      const fullPath = path.join(dir, file);
-      if (fs.existsSync(fullPath)) {
-        found.push({
-          path: fullPath,
-          type: FILE_TYPE_MAP[file] || 'custom',
-          content: fs.readFileSync(fullPath, 'utf-8'),
-        });
-      }
-    }
-
-    for (const file of this.customFiles) {
-      const fullPath = path.isAbsolute(file) ? file : path.join(dir, file);
-      if (fs.existsSync(fullPath)) {
-        found.push({
-          path: fullPath,
-          type: 'custom',
-          content: fs.readFileSync(fullPath, 'utf-8'),
-        });
-      }
-    }
-
-    return found;
-  }
-
-  load(files: ContextFile[]): string {
-    return files.map(f => `# ${f.type.toUpperCase()}\n${f.content}`).join('\n\n');
-  }
-
-  watch(workDir: string, onChange: Function): void {
-    const watcher = fs.watch(workDir, { recursive: false }, (event, filename) => {
-      if (filename && ContextDiscovery.STANDARD_FILES.includes(filename)) {
-        onChange(filename, event);
-      }
-    });
-    this.watchers.push(watcher);
-  }
-
-  stopWatching(): void {
-    for (const w of this.watchers) w.close();
-    this.watchers = [];
-  }
-
-  addCustomFile(filePath: string): void {
-    if (!this.customFiles.includes(filePath)) {
-      this.customFiles.push(filePath);
-    }
-  }
-}
+import * as fs from 'fs';
+import * as path from 'path';
+
+export interface ContextFile {
+  path: string;
+  type: 'agents' | 'soul' | 'user' | 'memory' | 'tools' | 'identity' | 'heartbeat' | 'bootstrap' | 'custom';
+  content: string;
+}
+
+const FILE_TYPE_MAP: Record<string, ContextFile['type']> = {
+  'AGENTS.md': 'agents',
+  'SOUL.md': 'soul',
+  'USER.md': 'user',
+  'MEMORY.md': 'memory',
+  'TOOLS.md': 'tools',
+  'IDENTITY.md': 'identity',
+  'HEARTBEAT.md': 'heartbeat',
+  'BOOTSTRAP.md': 'bootstrap',
+  '.opc.md': 'custom',
+  '.opc/config.md': 'custom',
+};
+
+export class ContextDiscovery {
+  static STANDARD_FILES = [
+    'AGENTS.md', 'SOUL.md', 'USER.md', 'MEMORY.md', 'TOOLS.md',
+    'IDENTITY.md', 'HEARTBEAT.md', 'BOOTSTRAP.md',
+    '.opc.md', '.opc/config.md',
+  ];
+
+  private customFiles: string[] = [];
+  private watchers: fs.FSWatcher[] = [];
+
+  discover(workDir?: string): ContextFile[] {
+    const dir = workDir || process.cwd();
+    const found: ContextFile[] = [];
+
+    for (const file of ContextDiscovery.STANDARD_FILES) {
+      const fullPath = path.join(dir, file);
+      if (fs.existsSync(fullPath)) {
+        found.push({
+          path: fullPath,
+          type: FILE_TYPE_MAP[file] || 'custom',
+          content: fs.readFileSync(fullPath, 'utf-8'),
+        });
+      }
+    }
+
+    for (const file of this.customFiles) {
+      const fullPath = path.isAbsolute(file) ? file : path.join(dir, file);
+      if (fs.existsSync(fullPath)) {
+        found.push({
+          path: fullPath,
+          type: 'custom',
+          content: fs.readFileSync(fullPath, 'utf-8'),
+        });
+      }
+    }
+
+    return found;
+  }
+
+  load(files: ContextFile[]): string {
+    return files.map(f => `# ${f.type.toUpperCase()}\n${f.content}`).join('\n\n');
+  }
+
+  watch(workDir: string, onChange: Function): void {
+    const watcher = fs.watch(workDir, { recursive: false }, (event, filename) => {
+      if (filename && ContextDiscovery.STANDARD_FILES.includes(filename)) {
+        onChange(filename, event);
+      }
+    });
+    this.watchers.push(watcher);
+  }
+
+  stopWatching(): void {
+    for (const w of this.watchers) w.close();
+    this.watchers = [];
+  }
+
+  addCustomFile(filePath: string): void {
+    if (!this.customFiles.includes(filePath)) {
+      this.customFiles.push(filePath);
+    }
+  }
+}

package/src/core/context-refs.ts

@@ -1,140 +1,140 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { execSync } from 'child_process';
-
-export type RefType = 'file' | 'folder' | 'url' | 'git-diff' | 'git-log';
-
-export interface ContextRef {
-  type: RefType;
-  path: string;
-  content?: string;
-}
-
-export interface Message {
-  role: string;
-  content: string;
-  [key: string]: unknown;
-}
-
-const MAX_CONTENT_LENGTH = 5000;
-
-function truncate(text: string, max: number = MAX_CONTENT_LENGTH): string {
-  if (text.length <= max) return text;
-  return text.slice(0, max) + `\n...[truncated, ${text.length - max} chars omitted]`;
-}
-
-export class ContextRefResolver {
-  /**
-   * Parse @-references from text without resolving content.
-   */
-  parseRefs(text: string): ContextRef[] {
-    const refs: ContextRef[] = [];
-    const patterns: [RegExp, RefType, (m: RegExpMatchArray) => string][] = [
-      [/@file:(\S+)/g, 'file', (m) => m[1]],
-      [/@folder:(\S+)/g, 'folder', (m) => m[1]],
-      [/@url:(https?:\/\/\S+)/g, 'url', (m) => m[1]],
-      [/@git-diff\b/g, 'git-diff', () => 'git-diff'],
-      [/@git-log:(\d+)/g, 'git-log', (m) => m[1]],
-      [/@git-log\b(?!:)/g, 'git-log', () => '10'],
-    ];
-
-    for (const [regex, type, extract] of patterns) {
-      let match: RegExpExecArray | null;
-      while ((match = regex.exec(text)) !== null) {
-        refs.push({ type, path: extract(match) });
-      }
-    }
-    return refs;
-  }
-
-  /**
-   * Resolve content for each ref. Returns new array with content filled in.
-   */
-  async resolveRefs(refs: ContextRef[]): Promise<ContextRef[]> {
-    return Promise.all(refs.map(async (ref) => {
-      try {
-        const content = await this.resolveOne(ref);
-        return { ...ref, content: truncate(content) };
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        return { ...ref, content: `[Error resolving @${ref.type}:${ref.path}]: ${msg}` };
-      }
-    }));
-  }
-
-  private async resolveOne(ref: ContextRef): Promise<string> {
-    switch (ref.type) {
-      case 'file':
-        return fs.readFileSync(ref.path, 'utf-8');
-      case 'folder':
-        return this.listDir(ref.path);
-      case 'url':
-        return await this.fetchUrl(ref.path);
-      case 'git-diff':
-        return execSync('git diff', { encoding: 'utf-8', timeout: 10000 });
-      case 'git-log': {
-        const n = parseInt(ref.path) || 10;
-        return execSync(`git log --oneline -${n}`, { encoding: 'utf-8', timeout: 10000 });
-      }
-      default:
-        return `[Unknown ref type: ${ref.type}]`;
-    }
-  }
-
-  private listDir(dirPath: string, prefix: string = '', depth: number = 0): string {
-    if (depth > 5) return prefix + '...(max depth)\n';
-    if (!fs.existsSync(dirPath)) throw new Error(`Directory not found: ${dirPath}`);
-    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
-    let result = '';
-    for (const entry of entries) {
-      if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
-      result += `${prefix}${entry.isDirectory() ? '📁 ' : '📄 '}${entry.name}\n`;
-      if (entry.isDirectory()) {
-        result += this.listDir(path.join(dirPath, entry.name), prefix + '  ', depth + 1);
-      }
-    }
-    return result;
-  }
-
-  private async fetchUrl(url: string): Promise<string> {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 10000);
-    try {
-      const res = await fetch(url, { signal: controller.signal });
-      const text = await res.text();
-      return text;
-    } finally {
-      clearTimeout(timeout);
-    }
-  }
-
-  /**
-   * Inject resolved refs as system messages before the user's last message.
-   */
-  injectRefs(messages: Message[], refs: ContextRef[]): Message[] {
-    if (refs.length === 0) return messages;
-
-    const resolvedRefs = refs.filter(r => r.content);
-    if (resolvedRefs.length === 0) return messages;
-
-    const contextMessages: Message[] = resolvedRefs.map(ref => ({
-      role: 'system',
-      content: `[Context from @${ref.type}:${ref.path}]\n\`\`\`\n${ref.content}\n\`\`\``,
-    }));
-
-    // Insert before the last user message
-    const result = [...messages];
-    let lastUserIdx = -1;
-    for (let i = result.length - 1; i >= 0; i--) {
-      if (result[i].role === 'user') { lastUserIdx = i; break; }
-    }
-
-    if (lastUserIdx >= 0) {
-      result.splice(lastUserIdx, 0, ...contextMessages);
-    } else {
-      result.push(...contextMessages);
-    }
-
-    return result;
-  }
-}
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+
+export type RefType = 'file' | 'folder' | 'url' | 'git-diff' | 'git-log';
+
+export interface ContextRef {
+  type: RefType;
+  path: string;
+  content?: string;
+}
+
+export interface Message {
+  role: string;
+  content: string;
+  [key: string]: unknown;
+}
+
+const MAX_CONTENT_LENGTH = 5000;
+
+function truncate(text: string, max: number = MAX_CONTENT_LENGTH): string {
+  if (text.length <= max) return text;
+  return text.slice(0, max) + `\n...[truncated, ${text.length - max} chars omitted]`;
+}
+
+export class ContextRefResolver {
+  /**
+   * Parse @-references from text without resolving content.
+   */
+  parseRefs(text: string): ContextRef[] {
+    const refs: ContextRef[] = [];
+    const patterns: [RegExp, RefType, (m: RegExpMatchArray) => string][] = [
+      [/@file:(\S+)/g, 'file', (m) => m[1]],
+      [/@folder:(\S+)/g, 'folder', (m) => m[1]],
+      [/@url:(https?:\/\/\S+)/g, 'url', (m) => m[1]],
+      [/@git-diff\b/g, 'git-diff', () => 'git-diff'],
+      [/@git-log:(\d+)/g, 'git-log', (m) => m[1]],
+      [/@git-log\b(?!:)/g, 'git-log', () => '10'],
+    ];
+
+    for (const [regex, type, extract] of patterns) {
+      let match: RegExpExecArray | null;
+      while ((match = regex.exec(text)) !== null) {
+        refs.push({ type, path: extract(match) });
+      }
+    }
+    return refs;
+  }
+
+  /**
+   * Resolve content for each ref. Returns new array with content filled in.
+   */
+  async resolveRefs(refs: ContextRef[]): Promise<ContextRef[]> {
+    return Promise.all(refs.map(async (ref) => {
+      try {
+        const content = await this.resolveOne(ref);
+        return { ...ref, content: truncate(content) };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { ...ref, content: `[Error resolving @${ref.type}:${ref.path}]: ${msg}` };
+      }
+    }));
+  }
+
+  private async resolveOne(ref: ContextRef): Promise<string> {
+    switch (ref.type) {
+      case 'file':
+        return fs.readFileSync(ref.path, 'utf-8');
+      case 'folder':
+        return this.listDir(ref.path);
+      case 'url':
+        return await this.fetchUrl(ref.path);
+      case 'git-diff':
+        return execSync('git diff', { encoding: 'utf-8', timeout: 10000 });
+      case 'git-log': {
+        const n = parseInt(ref.path) || 10;
+        return execSync(`git log --oneline -${n}`, { encoding: 'utf-8', timeout: 10000 });
+      }
+      default:
+        return `[Unknown ref type: ${ref.type}]`;
+    }
+  }
+
+  private listDir(dirPath: string, prefix: string = '', depth: number = 0): string {
+    if (depth > 5) return prefix + '...(max depth)\n';
+    if (!fs.existsSync(dirPath)) throw new Error(`Directory not found: ${dirPath}`);
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    let result = '';
+    for (const entry of entries) {
+      if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+      result += `${prefix}${entry.isDirectory() ? '📁 ' : '📄 '}${entry.name}\n`;
+      if (entry.isDirectory()) {
+        result += this.listDir(path.join(dirPath, entry.name), prefix + '  ', depth + 1);
+      }
+    }
+    return result;
+  }
+
+  private async fetchUrl(url: string): Promise<string> {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 10000);
+    try {
+      const res = await fetch(url, { signal: controller.signal });
+      const text = await res.text();
+      return text;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+
+  /**
+   * Inject resolved refs as system messages before the user's last message.
+   */
+  injectRefs(messages: Message[], refs: ContextRef[]): Message[] {
+    if (refs.length === 0) return messages;
+
+    const resolvedRefs = refs.filter(r => r.content);
+    if (resolvedRefs.length === 0) return messages;
+
+    const contextMessages: Message[] = resolvedRefs.map(ref => ({
+      role: 'system',
+      content: `[Context from @${ref.type}:${ref.path}]\n\`\`\`\n${ref.content}\n\`\`\``,
+    }));
+
+    // Insert before the last user message
+    const result = [...messages];
+    let lastUserIdx = -1;
+    for (let i = result.length - 1; i >= 0; i--) {
+      if (result[i].role === 'user') { lastUserIdx = i; break; }
+    }
+
+    if (lastUserIdx >= 0) {
+      result.splice(lastUserIdx, 0, ...contextMessages);
+    } else {
+      result.push(...contextMessages);
+    }
+
+    return result;
+  }
+}

package/src/core/gateway.ts

@@ -1,106 +1,106 @@
-import { EventEmitter } from 'events';
-import { randomUUID } from 'crypto';
-
-export interface AgentConfig {
-  id: string;
-  name: string;
-  model?: string;
-  skills?: string[];
-}
-
-export interface ChannelConfig {
-  id: string;
-  type: string;
-  config?: Record<string, unknown>;
-}
-
-export interface GatewayConfig {
-  port: number;
-  agents: AgentConfig[];
-  channels: ChannelConfig[];
-}
-
-interface GatewayMessage {
-  id: string;
-  content: string;
-  channel: string;
-  timestamp: number;
-}
-
-export class Gateway extends EventEmitter {
-  private config: GatewayConfig;
-  private agents = new Map<string, AgentConfig>();
-  private channels = new Map<string, ChannelConfig>();
-  private running = false;
-  private startTime = 0;
-  private messagesProcessed = 0;
-  private latencies: number[] = [];
-  private errors = 0;
-
-  constructor(config: GatewayConfig) {
-    super();
-    this.config = config;
-    for (const a of config.agents) this.agents.set(a.id, a);
-    for (const c of config.channels) this.channels.set(c.id, c);
-  }
-
-  async start(): Promise<void> {
-    if (this.running) throw new Error('Gateway already running');
-    this.running = true;
-    this.startTime = Date.now();
-    this.emit('started');
-  }
-
-  async stop(): Promise<void> {
-    if (!this.running) throw new Error('Gateway not running');
-    this.running = false;
-    this.emit('stopped');
-  }
-
-  async routeMessage(message: GatewayMessage, channel: string): Promise<string> {
-    if (!this.running) throw new Error('Gateway not running');
-    const start = Date.now();
-    this.messagesProcessed++;
-    // Simple round-robin routing
-    const agentIds = Array.from(this.agents.keys());
-    if (agentIds.length === 0) {
-      this.errors++;
-      throw new Error('No agents available');
-    }
-    const agentId = agentIds[this.messagesProcessed % agentIds.length];
-    this.latencies.push(Date.now() - start);
-    return agentId;
-  }
-
-  addAgent(config: AgentConfig): void {
-    this.agents.set(config.id, config);
-  }
-
-  removeAgent(id: string): void {
-    if (!this.agents.has(id)) throw new Error(`Agent ${id} not found`);
-    this.agents.delete(id);
-  }
-
-  addChannel(config: ChannelConfig): void {
-    this.channels.set(config.id, config);
-  }
-
-  getStatus(): { uptime: number; agents: number; channels: number; messagesProcessed: number } {
-    return {
-      uptime: this.running ? Date.now() - this.startTime : 0,
-      agents: this.agents.size,
-      channels: this.channels.size,
-      messagesProcessed: this.messagesProcessed,
-    };
-  }
-
-  getMetrics(): { messagesPerMinute: number; avgLatency: number; errorRate: number } {
-    const upMinutes = this.running ? (Date.now() - this.startTime) / 60000 : 1;
-    const avgLatency = this.latencies.length ? this.latencies.reduce((a, b) => a + b, 0) / this.latencies.length : 0;
-    return {
-      messagesPerMinute: this.messagesProcessed / Math.max(upMinutes, 0.001),
-      avgLatency,
-      errorRate: this.messagesProcessed ? this.errors / this.messagesProcessed : 0,
-    };
-  }
-}
+import { EventEmitter } from 'events';
+import { randomUUID } from 'crypto';
+
+export interface AgentConfig {
+  id: string;
+  name: string;
+  model?: string;
+  skills?: string[];
+}
+
+export interface ChannelConfig {
+  id: string;
+  type: string;
+  config?: Record<string, unknown>;
+}
+
+export interface GatewayConfig {
+  port: number;
+  agents: AgentConfig[];
+  channels: ChannelConfig[];
+}
+
+interface GatewayMessage {
+  id: string;
+  content: string;
+  channel: string;
+  timestamp: number;
+}
+
+export class Gateway extends EventEmitter {
+  private config: GatewayConfig;
+  private agents = new Map<string, AgentConfig>();
+  private channels = new Map<string, ChannelConfig>();
+  private running = false;
+  private startTime = 0;
+  private messagesProcessed = 0;
+  private latencies: number[] = [];
+  private errors = 0;
+
+  constructor(config: GatewayConfig) {
+    super();
+    this.config = config;
+    for (const a of config.agents) this.agents.set(a.id, a);
+    for (const c of config.channels) this.channels.set(c.id, c);
+  }
+
+  async start(): Promise<void> {
+    if (this.running) throw new Error('Gateway already running');
+    this.running = true;
+    this.startTime = Date.now();
+    this.emit('started');
+  }
+
+  async stop(): Promise<void> {
+    if (!this.running) throw new Error('Gateway not running');
+    this.running = false;
+    this.emit('stopped');
+  }
+
+  async routeMessage(message: GatewayMessage, channel: string): Promise<string> {
+    if (!this.running) throw new Error('Gateway not running');
+    const start = Date.now();
+    this.messagesProcessed++;
+    // Simple round-robin routing
+    const agentIds = Array.from(this.agents.keys());
+    if (agentIds.length === 0) {
+      this.errors++;
+      throw new Error('No agents available');
+    }
+    const agentId = agentIds[this.messagesProcessed % agentIds.length];
+    this.latencies.push(Date.now() - start);
+    return agentId;
+  }
+
+  addAgent(config: AgentConfig): void {
+    this.agents.set(config.id, config);
+  }
+
+  removeAgent(id: string): void {
+    if (!this.agents.has(id)) throw new Error(`Agent ${id} not found`);
+    this.agents.delete(id);
+  }
+
+  addChannel(config: ChannelConfig): void {
+    this.channels.set(config.id, config);
+  }
+
+  getStatus(): { uptime: number; agents: number; channels: number; messagesProcessed: number } {
+    return {
+      uptime: this.running ? Date.now() - this.startTime : 0,
+      agents: this.agents.size,
+      channels: this.channels.size,
+      messagesProcessed: this.messagesProcessed,
+    };
+  }
+
+  getMetrics(): { messagesPerMinute: number; avgLatency: number; errorRate: number } {
+    const upMinutes = this.running ? (Date.now() - this.startTime) / 60000 : 1;
+    const avgLatency = this.latencies.length ? this.latencies.reduce((a, b) => a + b, 0) / this.latencies.length : 0;
+    return {
+      messagesPerMinute: this.messagesProcessed / Math.max(upMinutes, 0.001),
+      avgLatency,
+      errorRate: this.messagesProcessed ? this.errors / this.messagesProcessed : 0,
+    };
+  }
+}