plumb-bridge 0.1.1 → 0.1.3

package/src/adapters/generic.ts

@@ -1,13 +1,9 @@
 // PLUMB — Generic Adapter
 // Text passthrough. Wraps any CLI that reads stdin and writes to stdout.
-// Every non-empty line becomes a progress event. Exit 0 = complete.
 
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
+import { detectBinary } from './detect.ts';
 import type { AgentAdapter, AgentTask, AdapterEvent, DetectionResult, PlumbConfig } from '../types.ts';
 
-const execFileAsync = promisify(execFile);
-
 export class GenericAdapter implements AgentAdapter {
   readonly id = 'generic';
   readonly binary = '';
@@ -22,7 +18,7 @@ export class GenericAdapter implements AgentAdapter {
     this.cliCommand = cliCommand;
   }
 
-  buildArgs(_task: AgentTask, _config: PlumbConfig): string[] { return []; }
+  buildArgs(): string[] { return []; }
 
   formatInput(task: AgentTask): string { return task.message + '\n'; }
 
@@ -33,13 +29,8 @@ export class GenericAdapter implements AgentAdapter {
 
   async detect(): Promise<DetectionResult | null> {
     if (!this.cliCommand) return null;
-    try {
-      const [cmd] = this.cliCommand.trim().split(/\s+/);
-      if (!cmd) return null;
-      const { stdout } = await execFileAsync('which', [cmd], { timeout: 5000 });
-      return { binary: cmd, version: 'unknown', path: stdout.trim(), tier: 3, protocol: 'text' };
-    } catch {
-      return null;
-    }
+    const [cmd] = this.cliCommand.trim().split(/\s+/);
+    if (!cmd) return null;
+    return detectBinary(cmd, 3, 'text');
   }
 }

package/src/adapters/opencode.ts

@@ -1,31 +1,8 @@
 // PLUMB — OpenCode Adapter
-// Wraps `opencode run --format json`. JSON event stream.
-// Filters log/status events. Captures text content and results.
+// Wraps `opencode run --format json`.
 
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
 import type { AgentAdapter, AgentTask, AdapterEvent, DetectionResult, PlumbConfig } from '../types.ts';
-
-const execFileAsync = promisify(execFile);
-
-interface OpenCodePart {
-  type?: string;
-  text?: string;
-  reason?: string;
-  [key: string]: unknown;
-}
-
-interface OpenCodeEvent {
-  type: string;
-  content?: string;
-  text?: string;
-  part?: OpenCodePart;
-  delta?: string;
-  error?: string;
-  message?: string;
-  result?: string;
-  [key: string]: unknown;
-}
+import { detectBinary } from './detect.ts';
 
 export class OpenCodeAdapter implements AgentAdapter {
   readonly id = 'opencode';
@@ -40,78 +17,53 @@ export class OpenCodeAdapter implements AgentAdapter {
     { id: 'read', name: 'Read files', tags: ['read', 'file'] },
   ];
 
-  buildArgs(_task: AgentTask, _config: PlumbConfig): string[] {
+  buildArgs(): string[] {
     return ['run', '--format', 'json'];
   }
 
   formatInput(task: AgentTask): string {
-    // OpenCode reads one JSON line per stdin message with `prompt` (see fangai OpenCodeAdapter).
     return JSON.stringify({ prompt: task.message }) + '\n';
   }
 
   parseLine(line: string): AdapterEvent[] {
     if (!line.trim()) return [];
 
-    let event: OpenCodeEvent;
+    let event: Record<string, unknown>;
     try {
       event = JSON.parse(line);
     } catch {
-      // Non-JSON line — treat as raw text
       return [{ type: 'text-delta', text: line + '\n' }];
     }
 
-    // Text content — OpenCode JSON uses part.text for assistant output
     if (event.type === 'text' || event.type === 'content' || event.type === 'text-delta') {
-      const fromPart = typeof event.part?.text === 'string' ? event.part.text : '';
+      const fromPart = typeof (event.part as Record<string, unknown>)?.text === 'string' ? (event.part as Record<string, unknown>).text as string : '';
       const text = fromPart || (event.text ?? event.content ?? event.delta ?? '');
-      if (text) return [{ type: 'text-delta', text }];
+      if (text) return [{ type: 'text-delta', text: text as string }];
       return [];
     }
 
-    // Message part updated — streaming content
     if (event.type === 'message.part.updated') {
       const text = event.content ?? event.text ?? '';
-      if (text) return [{ type: 'text-delta', text }];
+      if (text) return [{ type: 'text-delta', text: text as string }];
       return [];
     }
 
-    // End of agent step — primary completion signal for `opencode run --format json`
-    if (event.type === 'step_finish' && event.part?.reason === 'stop') {
+    if (event.type === 'step_finish' && (event.part as Record<string, unknown>)?.reason === 'stop') {
       return [{ type: 'status', state: 'completed' }];
     }
 
-    // Session / run completed (alternate event names)
     if (event.type === 'session.completed' || event.type === 'done' || event.type === 'complete') {
       return [{ type: 'status', state: 'completed' }];
     }
 
-    // Error events
     if (event.type === 'error') {
-      return [{ type: 'error', message: event.error ?? event.message ?? 'Unknown error' }];
+      return [{ type: 'error', message: (event.error ?? event.message ?? 'Unknown error') as string }];
     }
 
     return [];
   }
 
-  async detect(): Promise<DetectionResult | null> {
-    try {
-      const { stdout } = await execFileAsync('which', ['opencode'], { timeout: 5000 });
-      let version = 'unknown';
-      try {
-        const { stdout: vOut } = await execFileAsync('opencode', ['--version'], { timeout: 5000 });
-        version = vOut.trim().split('\n')[0] ?? 'unknown';
-      } catch {
-        // Version check failed
-      }
-      return {
-        binary: 'opencode',
-        version,
-        path: stdout.trim(),
-        tier: 2,
-        protocol: 'json-stream',
-      };
-    } catch {
-      return null;
-    }
+  detect(): Promise<DetectionResult | null> {
+    return detectBinary('opencode', 2, 'json-stream');
   }
 }

package/src/adapters/pi.ts

@@ -1,30 +1,15 @@
 // PLUMB — Pi Adapter
-// Wraps `pi --mode rpc --print`. JSONL protocol. Highest value adapter.
-// Extension UI requests are filtered. Text deltas and responses are captured.
+// Wraps `pi --mode json --print --no-session`.
 
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
 import type { AgentAdapter, AgentTask, AdapterEvent, DetectionResult, PlumbConfig } from '../types.ts';
-
-const execFileAsync = promisify(execFile);
-
-interface PiRpcEvent {
-  type: string;
-  text?: string;
-  content?: string;
-  success?: boolean;
-  error?: string;
-  delta?: string;
-  assistantMessageEvent?: { type?: string; delta?: string };
-  [key: string]: unknown;
-}
+import { detectBinary } from './detect.ts';
 
 export class PiAdapter implements AgentAdapter {
   readonly id = 'pi';
   readonly binary = 'pi';
   readonly tier = 1 as const;
   readonly displayName = 'Pi';
-  readonly mode = 'persistent' as const;
+  readonly mode = 'oneshot' as const;
 
   skills = [
     { id: 'code', name: 'Code generation and editing', tags: ['code', 'edit', 'write'] },
@@ -33,7 +18,7 @@ export class PiAdapter implements AgentAdapter {
   ];
 
   buildArgs(_task: AgentTask, _config: PlumbConfig): string[] {
-    return ['--mode', 'rpc', '--print', '--no-session'];
+    return ['--mode', 'json', '--print', '--no-session'];
   }
 
   formatInput(task: AgentTask): string {
@@ -48,91 +33,80 @@ export class PiAdapter implements AgentAdapter {
   parseLine(line: string): AdapterEvent[] {
     if (!line.trim()) return [];
 
-    let event: PiRpcEvent;
+    let event: Record<string, unknown>;
     try {
       event = JSON.parse(line);
     } catch {
-      // Non-JSON line — treat as raw text
       return [{ type: 'text-delta', text: line + '\n' }];
     }
 
-    // Filter extension UI requests — these are status updates, not task output
-    if (event.type === 'extension_ui_request') {
-      return [];
-    }
+    if (event.type === 'extension_ui_request') return [];
 
-    // Text delta events — streaming output
     if (event.type === 'text-delta' || event.type === 'delta') {
       const text = event.text ?? event.delta ?? event.content ?? '';
-      if (text) return [{ type: 'text-delta', text }];
+      if (text) return [{ type: 'text-delta', text: text as string }];
       return [];
     }
 
-    // Pi message_update — streaming text from assistant
-    // Format: { type: 'message_update', assistantMessageEvent: { type: 'text_delta', delta: 'text' } }
-    if (event.type === 'message_update') {
-      const ame = event.assistantMessageEvent as { type?: string; delta?: string } | undefined;
-      if (ame?.type === 'text_delta' && typeof ame.delta === 'string') {
+    if (event.type === 'message_update' && event.assistantMessageEvent) {
+      const ame = event.assistantMessageEvent as Record<string, unknown>;
+      if (ame.type === 'text_delta' && typeof ame.delta === 'string' && ame.delta) {
         return [{ type: 'text-delta', text: ame.delta }];
       }
+      if (ame.type && String(ame.type).startsWith('thinking_')) return [];
+      if (ame.type === 'text_start' || ame.type === 'text_end') return [];
       const text = event.text ?? event.delta ?? event.content ?? '';
-      if (text) return [{ type: 'text-delta', text }];
+      if (text) return [{ type: 'text-delta', text: text as string }];
       return [];
     }
 
-    // Content block — full text
     if (event.type === 'content' || event.type === 'text') {
       const text = event.text ?? event.content ?? '';
-      if (text) return [{ type: 'text-delta', text }];
+      if (text) return [{ type: 'text-delta', text: text as string }];
       return [];
     }
 
-    // Response event — task result
     if (event.type === 'response') {
       if (event.success === false && event.error) {
-        return [{ type: 'error', message: event.error }];
+        return [{ type: 'error', message: event.error as string }];
       }
-      // Successful response with content
       const text = event.text ?? event.content ?? '';
-      if (text) return [{ type: 'text-delta', text }];
-      return [];
+      if (text) return [{ type: 'text-delta', text: text as string }, { type: 'status', state: 'completed' }];
+      return [{ type: 'status', state: 'completed' }];
     }
 
-    // Error event
     if (event.type === 'error') {
-      return [{ type: 'error', message: event.error ?? 'Unknown error' }];
+      return [{ type: 'error', message: (event.error ?? 'Unknown error') as string }];
     }
 
-    // Done/complete signals (Pi uses agent_end and turn_end)
     if (event.type === 'done' || event.type === 'complete' || event.type === 'finished' ||
         event.type === 'agent_end' || event.type === 'turn_end') {
-      return [{ type: 'status', state: 'completed' }];
+      const events: AdapterEvent[] = [];
+      if (event.type === 'agent_end' || event.type === 'turn_end') {
+        const messages = event.messages as Array<Record<string, unknown>> | undefined;
+        if (messages) {
+          for (const msg of messages) {
+            if (msg.role === 'assistant') {
+              const content = msg.content as Array<Record<string, unknown>> | undefined;
+              if (content) {
+                for (const block of content) {
+                  if (block.type === 'text' && typeof block.text === 'string') {
+                    events.push({ type: 'text-delta', text: block.text });
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      events.push({ type: 'status', state: 'completed' });
+      return events;
     }
 
-    // Unknown event type — log but don't emit
     return [];
   }
 
-  async detect(): Promise<DetectionResult | null> {
-    try {
-      const { stdout } = await execFileAsync('which', ['pi'], { timeout: 5000 });
-      // Get version
-      let version = 'unknown';
-      try {
-        const { stdout: vOut } = await execFileAsync('pi', ['--version'], { timeout: 5000 });
-        version = vOut.trim().split('\n')[0] ?? 'unknown';
-      } catch {
-        // Version check failed, continue with unknown
-      }
-      return {
-        binary: 'pi',
-        version,
-        path: stdout.trim(),
-        tier: 1,
-        protocol: 'jsonl-rpc',
-      };
-    } catch {
-      return null;
-    }
+  detect(): Promise<DetectionResult | null> {
+    return detectBinary('pi', 1, 'jsonl-rpc');
   }
 }

package/src/adapters/registry.ts

@@ -1,12 +1,14 @@
 // PLUMB — Adapter Registry
 // detectAdapter: returns the first adapter whose binary matches the CLI command.
 // EchoAdapter for 'cat'. GenericAdapter for everything else.
-// Add real adapters here as they are built (Pi, Claude, Cursor...).
 
 import { EchoAdapter } from './echo.ts';
 import { PiAdapter } from './pi.ts';
 import { ClaudeAdapter } from './claude.ts';
+import { CursorAdapter } from './cursor.ts';
 import { OpenCodeAdapter } from './opencode.ts';
+import { WolfyAdapter } from './wolfy.ts';
+import { VenomAdapter } from './venom.ts';
 import { GenericAdapter } from './generic.ts';
 import type { AgentAdapter } from '../types.ts';
 
@@ -14,14 +16,35 @@ import type { AgentAdapter } from '../types.ts';
 const KNOWN_ADAPTERS: AgentAdapter[] = [
   new EchoAdapter(),
   new PiAdapter(),
+  new WolfyAdapter(),
   new ClaudeAdapter(),
+  new CursorAdapter(),
   new OpenCodeAdapter(),
+  new VenomAdapter(),
 ];
 
 function escapeRegex(s: string): string {
   return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
+/** Detect all registered adapters. Returns {name, found, version, path, error} for each. */
+export async function detectAll(): Promise<Array<{ name: string; found: boolean; version?: string; path?: string; error?: string }>> {
+  const results: Array<{ name: string; found: boolean; version?: string; path?: string; error?: string }> = [];
+  for (const adapter of KNOWN_ADAPTERS) {
+    try {
+      const result = await adapter.detect();
+      if (result) {
+        results.push({ name: adapter.displayName, found: true, version: result.version, path: result.path });
+      } else {
+        results.push({ name: adapter.displayName, found: false, error: 'Not found' });
+      }
+    } catch (err) {
+      results.push({ name: adapter.displayName, found: false, error: err instanceof Error ? err.message : String(err) });
+    }
+  }
+  return results;
+}
+
 export function detectAdapter(cli: string): AgentAdapter {
   for (const adapter of KNOWN_ADAPTERS) {
     if (!adapter.binary) continue;

package/src/adapters/stream-json.ts

@@ -0,0 +1,89 @@
+// PLUMB — Stream JSON Parser Utility
+// Shared parseLine logic for stream-json adapters (Cursor, Claude, Venom).
+// Reduces duplication: every oneshot JSON-line agent has the same skeleton.
+
+import type { AdapterEvent } from '../types.ts';
+
+/** Minimal base for any stream-json line. `message` is intentionally `unknown`
+ *  because different agents use it differently (string for some, object for others). */
+interface StreamJsonBaseEvent {
+  type: string;
+  subtype?: string;
+  timestamp_ms?: number;
+  is_error?: boolean;
+  error?: string;
+  [key: string]: unknown;
+}
+
+/** Event with a structured .message.content array (Cursor, Venom). */
+export interface ContentBlockEvent {
+  type: string;
+  subtype?: string;
+  timestamp_ms?: number;
+  is_error?: boolean;
+  error?: string;
+  message?: {
+    role?: string;
+    content?: Array<{ type: string; text?: string }>;
+  };
+  [key: string]: unknown;
+}
+
+/** Parsed result from tryParseStreamLine. */
+export interface ParsedLine {
+  json: StreamJsonBaseEvent | null;
+  raw: string;
+}
+
+/**
+ * Attempt to parse a stdout line as JSON. Fallback to raw text-delta.
+ * Returns { json: null, raw: '' } for empty/whitespace lines (callers skip these).
+ */
+export function tryParseLine(line: string): ParsedLine {
+  const trimmed = line.trim();
+  if (!trimmed) return { json: null, raw: '' };
+  try {
+    return { json: JSON.parse(trimmed) as StreamJsonBaseEvent, raw: line };
+  } catch {
+    return { json: null, raw: line };
+  }
+}
+
+/**
+ * Extract text from a message.content array (Cursor/Venom format).
+ * Filters for { type: "text", text: string } blocks, joins with newline.
+ */
+export function extractContentText(event: ContentBlockEvent): string | null {
+  const content = event.message?.content;
+  if (!content || !Array.isArray(content)) return null;
+  const texts = content
+    .filter((c): c is { type: string; text: string } =>
+      c.type === 'text' && typeof c.text === 'string'
+    )
+    .map(c => c.text);
+  return texts.length > 0 ? texts.join('\n') : null;
+}
+
+/**
+ * Check if a stream-json event is a consolidated (non-streaming) assistant event
+ * that should be skipped when streamPartial is enabled.
+ * Consolidated events lack timestamp_ms; streaming deltas have it.
+ */
+export function isConsolidatedAssistant(event: ContentBlockEvent, streamPartial: boolean): boolean {
+  return streamPartial && !event.timestamp_ms;
+}
+
+/** Build a text-delta event. */
+export function textDelta(text: string): AdapterEvent {
+  return { type: 'text-delta', text };
+}
+
+/** Build a status event. */
+export function statusEvent(state: 'working' | 'completed' | 'failed'): AdapterEvent {
+  return { type: 'status', state };
+}
+
+/** Build an error event. */
+export function errorEvent(message: string, code?: string): AdapterEvent {
+  return { type: 'error', message, ...(code ? { code } : {}) };
+}

package/src/adapters/venom.ts

@@ -0,0 +1,78 @@
+// PLUMB — VENOM Adapter
+// Wraps `venom --output-format stream-json --permission-mode danger-full-access`.
+
+import type { AgentAdapter, AgentTask, AdapterEvent, DetectionResult, PlumbConfig } from '../types.ts';
+import { tryParseLine, extractContentText, isConsolidatedAssistant, textDelta, statusEvent, errorEvent } from './stream-json.ts';
+import type { ContentBlockEvent } from './stream-json.ts';
+import { detectBinary } from './detect.ts';
+
+export class VenomAdapter implements AgentAdapter {
+  readonly id = 'venom';
+  readonly binary = 'venom';
+  readonly tier = 3 as const;
+  readonly displayName = 'VENOM';
+  readonly mode = 'oneshot' as const;
+
+  /** Stream-json dedup: skip consolidated assistant events when streaming. */
+  streamPartial = true;
+
+  skills = [
+    { id: 'code', name: 'Code generation and editing', tags: ['code', 'edit', 'write'] },
+    { id: 'bash', name: 'Execute shell commands', tags: ['bash', 'shell', 'terminal'] },
+    { id: 'read', name: 'Read files', tags: ['read', 'file'] },
+    { id: 'rust', name: 'Rust development', tags: ['rust', 'cargo'] },
+  ];
+
+  buildArgs(): string[] {
+    return ['--output-format', 'stream-json', '--permission-mode', 'danger-full-access'];
+  }
+
+  formatInput(task: AgentTask): string {
+    return task.message + '\n';
+  }
+
+  parseLine(line: string): AdapterEvent[] {
+    const { json, raw } = tryParseLine(line);
+    if (!json) {
+      if (!raw) return [];
+      return [textDelta(raw + '\n')];
+    }
+
+    // System/user events — metadata only
+    if (json.type === 'system' || json.type === 'user') return [];
+
+    if (json.type === 'assistant') {
+      const extracted = extractContentText(json as ContentBlockEvent);
+      if (isConsolidatedAssistant(json as ContentBlockEvent, this.streamPartial)) return [];
+      return extracted ? [textDelta(extracted)] : [];
+    }
+
+    // Tool call
+    if (json.type === 'tool_call') {
+      const tc = (json as Record<string, unknown>).tool_call as { shellToolCall?: { args?: Record<string, unknown>; result?: string } } | undefined;
+      if (tc?.shellToolCall) {
+        return [{ type: 'tool-call', tool: 'shell', input: tc.shellToolCall.args ?? {} }];
+      }
+      return [];
+    }
+
+    // Result — completion or error
+    if (json.type === 'result') {
+      if (json.subtype === 'error' || json.is_error) {
+        return [errorEvent(json.error ?? 'VENOM execution failed')];
+      }
+      return [statusEvent('completed')];
+    }
+
+    // Error event
+    if (json.type === 'error') {
+      return [errorEvent(String(json.error ?? json.message ?? 'Unknown error'))];
+    }
+
+    return [];
+  }
+
+  detect(): Promise<DetectionResult | null> {
+    return detectBinary('venom', 3, 'stream-json');
+  }
+}

package/src/adapters/wolfy.ts

@@ -0,0 +1,94 @@
+// PLUMB — Wolfy Adapter
+// Wraps `wolfy --mode json --print --no-session`.
+
+import type { AgentAdapter, AgentTask, AdapterEvent, DetectionResult, PlumbConfig } from '../types.ts';
+import { detectBinary } from './detect.ts';
+
+export class WolfyAdapter implements AgentAdapter {
+  readonly id = 'wolfy';
+  readonly binary = 'wolfy';
+  readonly tier = 1 as const;
+  readonly displayName = 'Wolfy';
+  readonly mode = 'oneshot' as const;
+
+  skills = [
+    { id: 'code', name: 'Code generation and editing', tags: ['code', 'edit', 'write', 'build'] },
+    { id: 'bash', name: 'Shell command execution', tags: ['bash', 'shell', 'terminal', 'deploy'] },
+    { id: 'read', name: 'File reading and analysis', tags: ['read', 'file', 'audit'] },
+    { id: 'memory', name: 'Persistent memory with semantic search', tags: ['memory', 'search', 'context'] },
+    { id: 'knowledge', name: 'Knowledge graph with temporal facts', tags: ['knowledge', 'facts', 'timeline'] },
+    { id: 'subagents', name: 'Parallel and chained subagent delegation', tags: ['subagents', 'parallel', 'chain'] },
+    { id: 'architecture', name: 'System architecture and API design', tags: ['architecture', 'api', 'schema'] },
+    { id: 'deepseek', name: 'DeepSeek V4 Pro — deep reasoning, 200K context', tags: ['deepseek', 'reasoning'] },
+    { id: 'kimi', name: 'Kimi K2.6 — long context analysis, 262K context', tags: ['kimi', 'analysis'] },
+  ];
+
+  buildArgs(): string[] {
+    return ['--mode', 'json', '--print', '--no-session'];
+  }
+
+  formatInput(task: AgentTask): string {
+    const meta = task.context?.metadata ?? {};
+    return `[${meta.source ?? 'plumb-mesh'}][${meta.project ?? 'general'}] ${task.message}\n`;
+  }
+
+  parseLine(line: string): AdapterEvent[] {
+    if (!line.trim()) return [];
+
+    let event: Record<string, unknown>;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      return [{ type: 'text-delta', text: line + '\n' }];
+    }
+
+    if (event.type === 'extension_ui_request' || event.type === 'session') return [];
+
+    if (event.type === 'message_update' && event.assistantMessageEvent) {
+      const ame = event.assistantMessageEvent as Record<string, unknown>;
+      if (ame.type === 'text_delta' && typeof ame.delta === 'string' && ame.delta) {
+        return [{ type: 'text-delta', text: ame.delta }];
+      }
+      if (ame.type === 'thinking_delta' || ame.type === 'thinking_start' || ame.type === 'thinking_end') return [];
+      if (ame.type === 'text_start' || ame.type === 'text_end') return [];
+      return [];
+    }
+
+    if (event.type === 'message_end') return [];
+
+    if (event.type === 'turn_end' || event.type === 'agent_end') {
+      const events: AdapterEvent[] = [];
+      const messages = event.messages as Array<Record<string, unknown>> | undefined;
+      if (messages) {
+        for (const msg of messages) {
+          if (msg.role === 'assistant') {
+            const content = msg.content as Array<Record<string, unknown>> | undefined;
+            if (content) {
+              for (const block of content) {
+                if (block.type === 'text' && typeof block.text === 'string') {
+                  events.push({ type: 'text-delta', text: block.text });
+                }
+              }
+            }
+          }
+        }
+      }
+      events.push({ type: 'status', state: 'completed' });
+      return events;
+    }
+
+    if (event.type === 'error') {
+      return [{ type: 'error', message: (event.error ?? 'Unknown error') as string }];
+    }
+
+    return [];
+  }
+
+  async detect(): Promise<DetectionResult | null> {
+    const result = await detectBinary('wolfy', 1, 'jsonl');
+    if (result) {
+      result.version = `Wolfy (Pi ${result.version})`;
+    }
+    return result;
+  }
+}