opc-agent 4.1.0 → 4.1.2

package/src/core/heartbeat.ts

@@ -1,51 +1,51 @@
-export interface HeartbeatConfig {
-  interval: number;
-  checkFn: () => Promise<string>;
-}
-
-export class HeartbeatManager {
-  private config: HeartbeatConfig;
-  private timer: ReturnType<typeof setInterval> | null = null;
-  private callbacks: ((status: string) => void)[] = [];
-  private lastBeat: { timestamp: number; status: string } | null = null;
-
-  constructor(config: HeartbeatConfig) {
-    if (!config.interval || config.interval < 100) {
-      throw new Error('HeartbeatManager requires interval >= 100ms');
-    }
-    if (typeof config.checkFn !== 'function') {
-      throw new Error('HeartbeatManager requires checkFn');
-    }
-    this.config = config;
-  }
-
-  start(): void {
-    if (this.timer) return;
-    this.timer = setInterval(async () => {
-      try {
-        const status = await this.config.checkFn();
-        this.lastBeat = { timestamp: Date.now(), status };
-        for (const cb of this.callbacks) cb(status);
-      } catch (err: any) {
-        const status = `error: ${err.message}`;
-        this.lastBeat = { timestamp: Date.now(), status };
-        for (const cb of this.callbacks) cb(status);
-      }
-    }, this.config.interval);
-  }
-
-  stop(): void {
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = null;
-    }
-  }
-
-  onBeat(callback: (status: string) => void): void {
-    this.callbacks.push(callback);
-  }
-
-  getLastBeat(): { timestamp: number; status: string } | null {
-    return this.lastBeat;
-  }
-}
+export interface HeartbeatConfig {
+  interval: number;
+  checkFn: () => Promise<string>;
+}
+
+export class HeartbeatManager {
+  private config: HeartbeatConfig;
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private callbacks: ((status: string) => void)[] = [];
+  private lastBeat: { timestamp: number; status: string } | null = null;
+
+  constructor(config: HeartbeatConfig) {
+    if (!config.interval || config.interval < 100) {
+      throw new Error('HeartbeatManager requires interval >= 100ms');
+    }
+    if (typeof config.checkFn !== 'function') {
+      throw new Error('HeartbeatManager requires checkFn');
+    }
+    this.config = config;
+  }
+
+  start(): void {
+    if (this.timer) return;
+    this.timer = setInterval(async () => {
+      try {
+        const status = await this.config.checkFn();
+        this.lastBeat = { timestamp: Date.now(), status };
+        for (const cb of this.callbacks) cb(status);
+      } catch (err: any) {
+        const status = `error: ${err.message}`;
+        this.lastBeat = { timestamp: Date.now(), status };
+        for (const cb of this.callbacks) cb(status);
+      }
+    }, this.config.interval);
+  }
+
+  stop(): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  onBeat(callback: (status: string) => void): void {
+    this.callbacks.push(callback);
+  }
+
+  getLastBeat(): { timestamp: number; status: string } | null {
+    return this.lastBeat;
+  }
+}

package/src/core/hooks.ts

@@ -1,105 +1,105 @@
-/**
- * Hooks Module - v1.0.0
- * Event hook system with priority ordering and context modification.
- */
-
-export type HookEvent =
-  | 'before:message' | 'after:message'
-  | 'before:tool' | 'after:tool'
-  | 'before:llm' | 'after:llm'
-  | 'before:send' | 'after:send'
-  | 'before:learn' | 'after:learn'
-  | 'before:recall' | 'after:recall'
-  | 'on:error' | 'on:start' | 'on:stop';
-
-export const ALL_HOOK_EVENTS: HookEvent[] = [
-  'before:message', 'after:message',
-  'before:tool', 'after:tool',
-  'before:llm', 'after:llm',
-  'before:send', 'after:send',
-  'before:learn', 'after:learn',
-  'before:recall', 'after:recall',
-  'on:error', 'on:start', 'on:stop',
-];
-
-export interface HookContext {
-  [key: string]: unknown;
-}
-
-export type HookHandler = (ctx: HookContext) => HookContext | void | Promise<HookContext | void>;
-
-interface RegisteredHook {
-  id: string;
-  event: HookEvent;
-  handler: HookHandler;
-  priority: number;
-  name?: string;
-}
-
-let hookIdCounter = 0;
-
-export class HookManager {
-  private hooks: Map<HookEvent, RegisteredHook[]> = new Map();
-
-  register(event: HookEvent, handler: HookHandler, options?: { priority?: number; name?: string }): string {
-    const id = `hook_${++hookIdCounter}`;
-    const entry: RegisteredHook = {
-      id,
-      event,
-      handler,
-      priority: options?.priority ?? 100,
-      name: options?.name,
-    };
-    if (!this.hooks.has(event)) this.hooks.set(event, []);
-    const list = this.hooks.get(event)!;
-    list.push(entry);
-    list.sort((a, b) => a.priority - b.priority);
-    return id;
-  }
-
-  unregister(id: string): boolean {
-    for (const [event, list] of this.hooks) {
-      const idx = list.findIndex(h => h.id === id);
-      if (idx !== -1) {
-        list.splice(idx, 1);
-        return true;
-      }
-    }
-    return false;
-  }
-
-  async run(event: HookEvent, ctx: HookContext = {}): Promise<HookContext> {
-    const list = this.hooks.get(event);
-    if (!list || list.length === 0) return ctx;
-    let current = { ...ctx };
-    for (const hook of list) {
-      const result = await hook.handler(current);
-      if (result) current = { ...current, ...result };
-    }
-    return current;
-  }
-
-  getRegistered(event?: HookEvent): { id: string; event: HookEvent; priority: number; name?: string }[] {
-    const results: { id: string; event: HookEvent; priority: number; name?: string }[] = [];
-    const events = event ? [event] : ALL_HOOK_EVENTS;
-    for (const e of events) {
-      const list = this.hooks.get(e) ?? [];
-      for (const h of list) {
-        results.push({ id: h.id, event: h.event, priority: h.priority, name: h.name });
-      }
-    }
-    return results;
-  }
-
-  clear(event?: HookEvent): void {
-    if (event) {
-      this.hooks.delete(event);
-    } else {
-      this.hooks.clear();
-    }
-  }
-
-  hasHooks(event: HookEvent): boolean {
-    return (this.hooks.get(event)?.length ?? 0) > 0;
-  }
-}
+/**
+ * Hooks Module - v1.0.0
+ * Event hook system with priority ordering and context modification.
+ */
+
+export type HookEvent =
+  | 'before:message' | 'after:message'
+  | 'before:tool' | 'after:tool'
+  | 'before:llm' | 'after:llm'
+  | 'before:send' | 'after:send'
+  | 'before:learn' | 'after:learn'
+  | 'before:recall' | 'after:recall'
+  | 'on:error' | 'on:start' | 'on:stop';
+
+export const ALL_HOOK_EVENTS: HookEvent[] = [
+  'before:message', 'after:message',
+  'before:tool', 'after:tool',
+  'before:llm', 'after:llm',
+  'before:send', 'after:send',
+  'before:learn', 'after:learn',
+  'before:recall', 'after:recall',
+  'on:error', 'on:start', 'on:stop',
+];
+
+export interface HookContext {
+  [key: string]: unknown;
+}
+
+export type HookHandler = (ctx: HookContext) => HookContext | void | Promise<HookContext | void>;
+
+interface RegisteredHook {
+  id: string;
+  event: HookEvent;
+  handler: HookHandler;
+  priority: number;
+  name?: string;
+}
+
+let hookIdCounter = 0;
+
+export class HookManager {
+  private hooks: Map<HookEvent, RegisteredHook[]> = new Map();
+
+  register(event: HookEvent, handler: HookHandler, options?: { priority?: number; name?: string }): string {
+    const id = `hook_${++hookIdCounter}`;
+    const entry: RegisteredHook = {
+      id,
+      event,
+      handler,
+      priority: options?.priority ?? 100,
+      name: options?.name,
+    };
+    if (!this.hooks.has(event)) this.hooks.set(event, []);
+    const list = this.hooks.get(event)!;
+    list.push(entry);
+    list.sort((a, b) => a.priority - b.priority);
+    return id;
+  }
+
+  unregister(id: string): boolean {
+    for (const [event, list] of this.hooks) {
+      const idx = list.findIndex(h => h.id === id);
+      if (idx !== -1) {
+        list.splice(idx, 1);
+        return true;
+      }
+    }
+    return false;
+  }
+
+  async run(event: HookEvent, ctx: HookContext = {}): Promise<HookContext> {
+    const list = this.hooks.get(event);
+    if (!list || list.length === 0) return ctx;
+    let current = { ...ctx };
+    for (const hook of list) {
+      const result = await hook.handler(current);
+      if (result) current = { ...current, ...result };
+    }
+    return current;
+  }
+
+  getRegistered(event?: HookEvent): { id: string; event: HookEvent; priority: number; name?: string }[] {
+    const results: { id: string; event: HookEvent; priority: number; name?: string }[] = [];
+    const events = event ? [event] : ALL_HOOK_EVENTS;
+    for (const e of events) {
+      const list = this.hooks.get(e) ?? [];
+      for (const h of list) {
+        results.push({ id: h.id, event: h.event, priority: h.priority, name: h.name });
+      }
+    }
+    return results;
+  }
+
+  clear(event?: HookEvent): void {
+    if (event) {
+      this.hooks.delete(event);
+    } else {
+      this.hooks.clear();
+    }
+  }
+
+  hasHooks(event: HookEvent): boolean {
+    return (this.hooks.get(event)?.length ?? 0) > 0;
+  }
+}

package/src/core/ide-bridge.ts

@@ -1,133 +1,133 @@
-import { execSync } from 'child_process';
-
-export interface IDEConfig {
-  editor: 'vscode' | 'jetbrains' | 'zed' | 'cursor';
-  workspacePath?: string;
-}
-
-export interface Diagnostic {
-  path: string;
-  line: number;
-  column: number;
-  severity: 'error' | 'warning' | 'info';
-  message: string;
-}
-
-export interface TextEdit {
-  range: Range;
-  newText: string;
-}
-
-export interface Range {
-  startLine: number;
-  startColumn: number;
-  endLine: number;
-  endColumn: number;
-}
-
-export interface SearchOptions {
-  caseSensitive?: boolean;
-  regex?: boolean;
-  include?: string;
-  exclude?: string;
-  maxResults?: number;
-}
-
-export interface SearchResult {
-  path: string;
-  line: number;
-  column: number;
-  text: string;
-}
-
-export class IDEBridge {
-  private config: IDEConfig;
-
-  constructor(config: IDEConfig) {
-    this.config = config;
-  }
-
-  private getCliCommand(): string {
-    switch (this.config.editor) {
-      case 'vscode': case 'cursor': return this.config.editor === 'cursor' ? 'cursor' : 'code';
-      case 'jetbrains': return 'idea';
-      case 'zed': return 'zed';
-    }
-  }
-
-  private exec(cmd: string): string {
-    try {
-      return execSync(cmd, { encoding: 'utf-8', timeout: 10000, cwd: this.config.workspacePath }).trim();
-    } catch (e: any) {
-      throw new Error(`IDE command failed: ${e.message}`);
-    }
-  }
-
-  async openFile(path: string, line?: number): Promise<void> {
-    const cli = this.getCliCommand();
-    const target = line ? `${path}:${line}` : path;
-    if (this.config.editor === 'vscode' || this.config.editor === 'cursor') {
-      this.exec(`${cli} --goto "${target}"`);
-    } else if (this.config.editor === 'zed') {
-      this.exec(`zed "${target}"`);
-    } else {
-      this.exec(`${cli} --line ${line || 1} "${path}"`);
-    }
-  }
-
-  async getDiagnostics(path?: string): Promise<Diagnostic[]> {
-    // VS Code doesn't expose diagnostics via CLI; return empty as stub
-    return [];
-  }
-
-  async runCommand(command: string): Promise<string> {
-    const cli = this.getCliCommand();
-    if (this.config.editor === 'vscode' || this.config.editor === 'cursor') {
-      return this.exec(`${cli} --command "${command}"`);
-    }
-    throw new Error(`runCommand not supported for ${this.config.editor}`);
-  }
-
-  async getOpenFiles(): Promise<string[]> {
-    // Stub — no standard CLI to get open files
-    return [];
-  }
-
-  async applyEdit(path: string, edits: TextEdit[]): Promise<void> {
-    // Stub — would use editor's API/extension
-    if (edits.length === 0) return;
-    throw new Error('applyEdit requires an IDE extension to be installed. Use file system edits as fallback.');
-  }
-
-  async search(query: string, options?: SearchOptions): Promise<SearchResult[]> {
-    const cli = this.getCliCommand();
-    if (this.config.editor === 'vscode' || this.config.editor === 'cursor') {
-      try {
-        const args = [`--search "${query}"`];
-        if (options?.include) args.push(`--include "${options.include}"`);
-        const output = this.exec(`${cli} ${args.join(' ')}`);
-        // Parse output lines
-        return output.split('\n').filter(Boolean).map(line => {
-          const match = line.match(/^(.+):(\d+):(\d+):(.*)$/);
-          if (!match) return { path: '', line: 0, column: 0, text: line };
-          return { path: match[1], line: parseInt(match[2]), column: parseInt(match[3]), text: match[4] };
-        });
-      } catch { return []; }
-    }
-    return [];
-  }
-
-  async getSelection(): Promise<{ path: string; text: string; range: Range } | null> {
-    // Stub — requires editor extension
-    return null;
-  }
-
-  async installExtension(extensionId: string): Promise<void> {
-    const cli = this.getCliCommand();
-    if (this.config.editor === 'vscode' || this.config.editor === 'cursor') {
-      this.exec(`${cli} --install-extension ${extensionId}`);
-    } else {
-      throw new Error(`installExtension not supported for ${this.config.editor}`);
-    }
-  }
-}
+import { execSync } from 'child_process';
+
+export interface IDEConfig {
+  editor: 'vscode' | 'jetbrains' | 'zed' | 'cursor';
+  workspacePath?: string;
+}
+
+export interface Diagnostic {
+  path: string;
+  line: number;
+  column: number;
+  severity: 'error' | 'warning' | 'info';
+  message: string;
+}
+
+export interface TextEdit {
+  range: Range;
+  newText: string;
+}
+
+export interface Range {
+  startLine: number;
+  startColumn: number;
+  endLine: number;
+  endColumn: number;
+}
+
+export interface SearchOptions {
+  caseSensitive?: boolean;
+  regex?: boolean;
+  include?: string;
+  exclude?: string;
+  maxResults?: number;
+}
+
+export interface SearchResult {
+  path: string;
+  line: number;
+  column: number;
+  text: string;
+}
+
+export class IDEBridge {
+  private config: IDEConfig;
+
+  constructor(config: IDEConfig) {
+    this.config = config;
+  }
+
+  private getCliCommand(): string {
+    switch (this.config.editor) {
+      case 'vscode': case 'cursor': return this.config.editor === 'cursor' ? 'cursor' : 'code';
+      case 'jetbrains': return 'idea';
+      case 'zed': return 'zed';
+    }
+  }
+
+  private exec(cmd: string): string {
+    try {
+      return execSync(cmd, { encoding: 'utf-8', timeout: 10000, cwd: this.config.workspacePath }).trim();
+    } catch (e: any) {
+      throw new Error(`IDE command failed: ${e.message}`);
+    }
+  }
+
+  async openFile(path: string, line?: number): Promise<void> {
+    const cli = this.getCliCommand();
+    const target = line ? `${path}:${line}` : path;
+    if (this.config.editor === 'vscode' || this.config.editor === 'cursor') {
+      this.exec(`${cli} --goto "${target}"`);
+    } else if (this.config.editor === 'zed') {
+      this.exec(`zed "${target}"`);
+    } else {
+      this.exec(`${cli} --line ${line || 1} "${path}"`);
+    }
+  }
+
+  async getDiagnostics(path?: string): Promise<Diagnostic[]> {
+    // VS Code doesn't expose diagnostics via CLI; return empty as stub
+    return [];
+  }
+
+  async runCommand(command: string): Promise<string> {
+    const cli = this.getCliCommand();
+    if (this.config.editor === 'vscode' || this.config.editor === 'cursor') {
+      return this.exec(`${cli} --command "${command}"`);
+    }
+    throw new Error(`runCommand not supported for ${this.config.editor}`);
+  }
+
+  async getOpenFiles(): Promise<string[]> {
+    // Stub — no standard CLI to get open files
+    return [];
+  }
+
+  async applyEdit(path: string, edits: TextEdit[]): Promise<void> {
+    // Stub — would use editor's API/extension
+    if (edits.length === 0) return;
+    throw new Error('applyEdit requires an IDE extension to be installed. Use file system edits as fallback.');
+  }
+
+  async search(query: string, options?: SearchOptions): Promise<SearchResult[]> {
+    const cli = this.getCliCommand();
+    if (this.config.editor === 'vscode' || this.config.editor === 'cursor') {
+      try {
+        const args = [`--search "${query}"`];
+        if (options?.include) args.push(`--include "${options.include}"`);
+        const output = this.exec(`${cli} ${args.join(' ')}`);
+        // Parse output lines
+        return output.split('\n').filter(Boolean).map(line => {
+          const match = line.match(/^(.+):(\d+):(\d+):(.*)$/);
+          if (!match) return { path: '', line: 0, column: 0, text: line };
+          return { path: match[1], line: parseInt(match[2]), column: parseInt(match[3]), text: match[4] };
+        });
+      } catch { return []; }
+    }
+    return [];
+  }
+
+  async getSelection(): Promise<{ path: string; text: string; range: Range } | null> {
+    // Stub — requires editor extension
+    return null;
+  }
+
+  async installExtension(extensionId: string): Promise<void> {
+    const cli = this.getCliCommand();
+    if (this.config.editor === 'vscode' || this.config.editor === 'cursor') {
+      this.exec(`${cli} --install-extension ${extensionId}`);
+    } else {
+      throw new Error(`installExtension not supported for ${this.config.editor}`);
+    }
+  }
+}