@pixelbyte-software/pixcode 1.54.10 → 1.55.0

package/server/modules/orchestration/a2a/adapters/cursor.adapter.ts

@@ -1,249 +0,0 @@
-// server/modules/orchestration/a2a/adapters/cursor.adapter.ts
-// Wraps the existing server/cursor-cli.js runtime, which emits
-// provider-neutral NormalizedMessage frames over a writer interface.
-
-import crypto from 'node:crypto';
-
-// eslint-disable-next-line boundaries/no-unknown -- cursor-cli.js is a top-level CLI runtime not yet classified by eslint.config.js; cleanup deferred.
-import { abortCursorSession, spawnCursor } from '@/cursor-cli.js';
-import { AbstractA2AAdapter } from '@/modules/orchestration/a2a/adapters/abstract-a2a.adapter.js';
-import type {
-  AdapterContext,
-  TaskHandle,
-} from '@/modules/orchestration/a2a/adapters/abstract-a2a.adapter.js';
-import type { AgentCard, Part, Task } from '@/modules/orchestration/a2a/types.js';
-import type { NormalizedMessage } from '@/shared/types.js';
-
-interface FakeWriter {
-  send(data: unknown): void;
-  getSessionId(): string | null;
-  setSessionId(sessionId: string): void;
-}
-
-function joinPartsToPrompt(parts: Part[]): string {
-  return parts
-    .map((part) => {
-      if (part.kind === 'text') return part.text;
-      if (part.kind === 'data') return JSON.stringify(part.data);
-      return `[file:${part.name}${part.uri ? ` uri=${part.uri}` : ''}]`;
-    })
-    .join('\n');
-}
-
-function newId(prefix: string): string {
-  return `${prefix}_${crypto.randomBytes(8).toString('hex')}`;
-}
-
-export class CursorA2AAdapter extends AbstractA2AAdapter {
-  readonly id = 'cursor';
-
-  readonly agentCard: AgentCard = {
-    name: 'pixcode-cursor',
-    description: 'Cursor CLI, accessed via Pixcode',
-    url: '/api/orchestration/agents/cursor',
-    version: '1.0.0',
-    capabilities: ['streaming', 'fileEdit', 'commandExec'],
-    skills: [
-      {
-        id: 'rapid-prototyping',
-        description: 'Fast implementation for coding tasks in Cursor CLI',
-      },
-      {
-        id: 'reasoning-assist',
-        description: 'Emit reasoning and tool traces during execution',
-      },
-      {
-        id: 'multi-file-refactor',
-        description: 'Coordinate edits across multiple files',
-      },
-    ],
-    authentication: { type: 'bearer' },
-  };
-
-  private readonly active = new Map<string, { sessionId: string | null }>();
-
-  async submitTask(task: Task, ctx: AdapterContext): Promise<TaskHandle> {
-    const promptText = joinPartsToPrompt(
-      task.history[task.history.length - 1]?.parts ?? [],
-    );
-    const session = { sessionId: null as string | null };
-    this.active.set(task.id, session);
-
-    this.emitState(task.id, 'working');
-
-    const fakeWriter: FakeWriter = {
-      send: (data) => this.handleRuntimeFrame(task.id, data, session),
-      getSessionId: () => session.sessionId,
-      setSessionId: (sessionId) => {
-        session.sessionId = sessionId;
-      },
-    };
-
-    const finished = (async () => {
-      try {
-        await spawnCursor(
-          promptText,
-          {
-            cwd: ctx.cwd,
-            model: ctx.model,
-            toolsSettings: ctx.toolsSettings,
-            skipPermissions:
-              ctx.permissionMode === 'acceptEdits' || ctx.permissionMode === 'bypassPermissions',
-          },
-          fakeWriter,
-        );
-
-        if (this.active.has(task.id)) {
-          this.emitState(task.id, 'completed');
-        }
-      } catch (err) {
-        if (this.active.has(task.id)) {
-          this.emitState(task.id, 'failed', {
-            code: 'ADAPTER_RUNTIME_ERROR',
-            message: err instanceof Error ? err.message : String(err),
-          });
-        }
-      } finally {
-        this.active.delete(task.id);
-      }
-    })();
-
-    return {
-      cancel: () => this.cancelTask(task.id),
-      finished,
-    };
-  }
-
-  async cancelTask(taskId: string): Promise<void> {
-    const session = this.active.get(taskId);
-    if (!session) {
-      this.emitState(taskId, 'canceled');
-      return;
-    }
-
-    this.active.delete(taskId);
-    if (session.sessionId) {
-      abortCursorSession(session.sessionId);
-    }
-    this.emitState(taskId, 'canceled');
-  }
-
-  private handleRuntimeFrame(
-    taskId: string,
-    frame: unknown,
-    session: { sessionId: string | null },
-  ): void {
-    if (!frame || typeof frame !== 'object') return;
-    const message = frame as Partial<NormalizedMessage>;
-
-    if (
-      message.kind === 'session_created' &&
-      typeof message.newSessionId === 'string' &&
-      !session.sessionId
-    ) {
-      session.sessionId = message.newSessionId;
-      return;
-    }
-
-    switch (message.kind) {
-      case 'stream_delta':
-      case 'text': {
-        const text = typeof message.content === 'string' ? message.content : null;
-        if (text && text.trim()) {
-          this.emitMessage(taskId, {
-            messageId: typeof message.id === 'string' ? message.id : newId('msg'),
-            role: message.role === 'user' ? 'user' : 'agent',
-            parts: [{ kind: 'text', text }],
-            taskId,
-          });
-        }
-        return;
-      }
-
-      case 'thinking': {
-        this.emitArtifact(taskId, {
-          artifactId: typeof message.id === 'string' ? message.id : newId('art'),
-          type: 'data',
-          parts: [
-            {
-              kind: 'data',
-              data: {
-                kind: 'thinking',
-                content: message.content,
-              },
-            },
-          ],
-          metadata: { source: 'cursor-thinking' },
-        });
-        return;
-      }
-
-      case 'tool_use': {
-        this.emitArtifact(taskId, {
-          artifactId: typeof message.id === 'string' ? message.id : newId('art'),
-          type: 'command-output',
-          parts: [
-            {
-              kind: 'data',
-              data: {
-                toolName: message.toolName,
-                toolInput: message.toolInput,
-                toolId: message.toolId,
-                toolResult: message.toolResult,
-              },
-            },
-          ],
-          metadata: { source: 'cursor-tool-use' },
-        });
-        return;
-      }
-
-      case 'tool_result': {
-        this.emitArtifact(taskId, {
-          artifactId: typeof message.id === 'string' ? message.id : newId('art'),
-          type: 'command-output',
-          parts: [
-            {
-              kind: 'data',
-              data: {
-                toolId: message.toolId,
-                content: message.content,
-                isError: message.isError,
-              },
-            },
-          ],
-          metadata: { source: 'cursor-tool-result' },
-        });
-        return;
-      }
-
-      case 'status':
-      case 'stream_end':
-      case 'complete':
-      case 'session_created':
-        return;
-
-      case 'error': {
-        const text =
-          typeof message.content === 'string' && message.content.length > 0
-            ? message.content
-            : 'Cursor reported an error';
-        this.emitState(taskId, 'failed', {
-          code: 'ADAPTER_RUNTIME_ERROR',
-          message: text,
-        });
-        this.active.delete(taskId);
-        return;
-      }
-
-      default: {
-        this.emitArtifact(taskId, {
-          artifactId: typeof message.id === 'string' ? message.id : newId('art'),
-          type: 'data',
-          parts: [{ kind: 'data', data: message as Record<string, unknown> }],
-          metadata: { source: `cursor-${String(message.kind ?? 'event')}` },
-        });
-      }
-    }
-  }
-}

package/server/modules/orchestration/a2a/adapters/gemini.adapter.ts

@@ -1,248 +0,0 @@
-// server/modules/orchestration/a2a/adapters/gemini.adapter.ts
-// Wraps the existing server/gemini-cli.js runtime, which emits
-// provider-neutral NormalizedMessage frames over a writer interface.
-
-import crypto from 'node:crypto';
-
-// eslint-disable-next-line boundaries/no-unknown -- gemini-cli.js is a top-level CLI runtime not yet classified by eslint.config.js; cleanup deferred.
-import { abortGeminiSession, spawnGemini } from '@/gemini-cli.js';
-import { AbstractA2AAdapter } from '@/modules/orchestration/a2a/adapters/abstract-a2a.adapter.js';
-import type {
-  AdapterContext,
-  TaskHandle,
-} from '@/modules/orchestration/a2a/adapters/abstract-a2a.adapter.js';
-import type { AgentCard, Part, Task } from '@/modules/orchestration/a2a/types.js';
-import type { NormalizedMessage } from '@/shared/types.js';
-
-interface FakeWriter {
-  send(data: unknown): void;
-  getSessionId(): string | null;
-  setSessionId(sessionId: string): void;
-}
-
-function joinPartsToPrompt(parts: Part[]): string {
-  return parts
-    .map((part) => {
-      if (part.kind === 'text') return part.text;
-      if (part.kind === 'data') return JSON.stringify(part.data);
-      return `[file:${part.name}${part.uri ? ` uri=${part.uri}` : ''}]`;
-    })
-    .join('\n');
-}
-
-function newId(prefix: string): string {
-  return `${prefix}_${crypto.randomBytes(8).toString('hex')}`;
-}
-
-export class GeminiA2AAdapter extends AbstractA2AAdapter {
-  readonly id = 'gemini';
-
-  readonly agentCard: AgentCard = {
-    name: 'pixcode-gemini',
-    description: 'Google Gemini CLI, accessed via Pixcode',
-    url: '/api/orchestration/agents/gemini',
-    version: '1.0.0',
-    capabilities: ['streaming', 'fileEdit', 'commandExec', 'mcp'],
-    skills: [
-      {
-        id: 'rapid-prototyping',
-        description: 'Fast implementation and iteration for coding tasks',
-      },
-      {
-        id: 'tool-augmented-editing',
-        description: 'Use CLI tools and MCP servers while editing code',
-      },
-      {
-        id: 'multi-file-refactor',
-        description: 'Coordinate edits across multiple files',
-      },
-    ],
-    authentication: { type: 'bearer' },
-  };
-
-  private readonly active = new Map<string, { sessionId: string | null }>();
-
-  async submitTask(task: Task, ctx: AdapterContext): Promise<TaskHandle> {
-    const promptText = joinPartsToPrompt(
-      task.history[task.history.length - 1]?.parts ?? [],
-    );
-    const session = { sessionId: null as string | null };
-    this.active.set(task.id, session);
-
-    this.emitState(task.id, 'working');
-
-    const fakeWriter: FakeWriter = {
-      send: (data) => this.handleRuntimeFrame(task.id, data, session),
-      getSessionId: () => session.sessionId,
-      setSessionId: (sessionId) => {
-        session.sessionId = sessionId;
-      },
-    };
-
-    const finished = (async () => {
-      try {
-        await spawnGemini(
-          promptText,
-          {
-            cwd: ctx.cwd,
-            model: ctx.model,
-            permissionMode: ctx.permissionMode === 'bypassPermissions' ? 'yolo' : ctx.permissionMode,
-            toolsSettings: ctx.toolsSettings,
-          },
-          fakeWriter,
-        );
-
-        if (this.active.has(task.id)) {
-          this.emitState(task.id, 'completed');
-        }
-      } catch (err) {
-        if (this.active.has(task.id)) {
-          this.emitState(task.id, 'failed', {
-            code: 'ADAPTER_RUNTIME_ERROR',
-            message: err instanceof Error ? err.message : String(err),
-          });
-        }
-      } finally {
-        this.active.delete(task.id);
-      }
-    })();
-
-    return {
-      cancel: () => this.cancelTask(task.id),
-      finished,
-    };
-  }
-
-  async cancelTask(taskId: string): Promise<void> {
-    const session = this.active.get(taskId);
-    if (!session) {
-      this.emitState(taskId, 'canceled');
-      return;
-    }
-
-    this.active.delete(taskId);
-    if (session.sessionId) {
-      abortGeminiSession(session.sessionId);
-    }
-    this.emitState(taskId, 'canceled');
-  }
-
-  private handleRuntimeFrame(
-    taskId: string,
-    frame: unknown,
-    session: { sessionId: string | null },
-  ): void {
-    if (!frame || typeof frame !== 'object') return;
-    const message = frame as Partial<NormalizedMessage>;
-
-    if (
-      message.kind === 'session_created' &&
-      typeof message.newSessionId === 'string' &&
-      !session.sessionId
-    ) {
-      session.sessionId = message.newSessionId;
-      return;
-    }
-
-    switch (message.kind) {
-      case 'stream_delta':
-      case 'text': {
-        const text = typeof message.content === 'string' ? message.content : null;
-        if (text && text.trim()) {
-          this.emitMessage(taskId, {
-            messageId: typeof message.id === 'string' ? message.id : newId('msg'),
-            role: 'agent',
-            parts: [{ kind: 'text', text }],
-            taskId,
-          });
-        }
-        return;
-      }
-
-      case 'tool_use': {
-        this.emitArtifact(taskId, {
-          artifactId: typeof message.id === 'string' ? message.id : newId('art'),
-          type: 'command-output',
-          parts: [
-            {
-              kind: 'data',
-              data: {
-                toolName: message.toolName,
-                toolInput: message.toolInput,
-                toolId: message.toolId,
-                toolResult: message.toolResult,
-              },
-            },
-          ],
-          metadata: { source: 'gemini-tool-use' },
-        });
-        return;
-      }
-
-      case 'tool_result': {
-        this.emitArtifact(taskId, {
-          artifactId: typeof message.id === 'string' ? message.id : newId('art'),
-          type: 'command-output',
-          parts: [
-            {
-              kind: 'data',
-              data: {
-                toolId: message.toolId,
-                content: message.content,
-                isError: message.isError,
-              },
-            },
-          ],
-          metadata: { source: 'gemini-tool-result' },
-        });
-        return;
-      }
-
-      case 'status': {
-        this.emitArtifact(taskId, {
-          artifactId: typeof message.id === 'string' ? message.id : newId('art'),
-          type: 'data',
-          parts: [
-            {
-              kind: 'data',
-              data: {
-                kind: 'status',
-                text: message.text,
-                tokens: message.tokens,
-              },
-            },
-          ],
-          metadata: { source: 'gemini-status' },
-        });
-        return;
-      }
-
-      case 'stream_end':
-      case 'complete':
-      case 'session_created':
-        return;
-
-      case 'error': {
-        const text =
-          typeof message.content === 'string' && message.content.length > 0
-            ? message.content
-            : 'Gemini reported an error';
-        this.emitState(taskId, 'failed', {
-          code: 'ADAPTER_RUNTIME_ERROR',
-          message: text,
-        });
-        this.active.delete(taskId);
-        return;
-      }
-
-      default: {
-        this.emitArtifact(taskId, {
-          artifactId: typeof message.id === 'string' ? message.id : newId('art'),
-          type: 'data',
-          parts: [{ kind: 'data', data: message as Record<string, unknown> }],
-          metadata: { source: `gemini-${String(message.kind ?? 'event')}` },
-        });
-      }
-    }
-  }
-}

package/server/modules/orchestration/a2a/adapters/json-event.adapter.test.ts

@@ -1,60 +0,0 @@
-import assert from 'node:assert/strict';
-import test, { beforeEach } from 'node:test';
-
-import { a2aBus } from '@/modules/orchestration/a2a/bus.js';
-import type { Task } from '@/modules/orchestration/a2a/types.js';
-
-import { JsonEventA2AAdapter } from './json-event.adapter.js';
-import type { AdapterContext } from './abstract-a2a.adapter.js';
-
-// Capture bus events by monkeypatching publish — the repo has no test runner
-// with module mocking (node:test style, see providers/tests/mcp.test.ts).
-const publishedEvents: any[] = [];
-const originalPublish = a2aBus.publish.bind(a2aBus);
-(a2aBus as any).publish = (event: any) => {
-  publishedEvents.push(event);
-};
-
-void originalPublish; // retained for symmetry; process exits after tests
-
-beforeEach(() => {
-  publishedEvents.length = 0;
-});
-
-const makeTask = (id: string): Task => ({ id, history: [], artifacts: [] } as any);
-const ctx = { cwd: '/tmp' } as unknown as AdapterContext;
-
-test('JsonEventA2AAdapter initializes task state to working', async () => {
-  const adapter = new JsonEventA2AAdapter();
-  await adapter.submitTask(makeTask('test-task'), ctx);
-
-  const stateEvent = publishedEvents.find((event) => event.kind === 'task-state');
-  assert.ok(stateEvent, 'expected a task-state event');
-  assert.equal(stateEvent.taskId, 'test-task');
-  assert.equal(stateEvent.state, 'working');
-});
-
-test('JsonEventA2AAdapter handles external text events', async () => {
-  const adapter = new JsonEventA2AAdapter();
-  await adapter.submitTask(makeTask('test-task'), ctx);
-
-  adapter.handleExternalEvent('test-task', { kind: 'text', text: 'Hello World' });
-
-  const messageEvent = publishedEvents.find((event) => event.kind === 'message');
-  assert.ok(messageEvent, 'expected a message event');
-  assert.equal(messageEvent.taskId, 'test-task');
-  assert.deepEqual(messageEvent.message.parts, [{ kind: 'text', text: 'Hello World' }]);
-});
-
-test('JsonEventA2AAdapter transitions to completed on terminal event', async () => {
-  const adapter = new JsonEventA2AAdapter();
-  await adapter.submitTask(makeTask('test-task'), ctx);
-
-  adapter.handleExternalEvent('test-task', { kind: 'completed' });
-
-  const completedEvent = publishedEvents.find(
-    (event) => event.kind === 'task-state' && event.state === 'completed',
-  );
-  assert.ok(completedEvent, 'expected a completed task-state event');
-  assert.equal(completedEvent.taskId, 'test-task');
-});

package/server/modules/orchestration/a2a/adapters/json-event.adapter.ts

@@ -1,101 +0,0 @@
-// server/modules/orchestration/a2a/adapters/json-event.adapter.ts
-// A specialty adapter that consumes JSON event streams from external providers
-// and translates them into the A2A bus protocol.
-
-import crypto from 'node:crypto';
-
-import { AbstractA2AAdapter } from '@/modules/orchestration/a2a/adapters/abstract-a2a.adapter.js';
-import type {
-  AdapterContext,
-  TaskHandle,
-} from '@/modules/orchestration/a2a/adapters/abstract-a2a.adapter.js';
-import type { AgentCard, Task } from '@/modules/orchestration/a2a/types.js';
-
-function newId(prefix: string): string {
-  return `${prefix}_${crypto.randomBytes(8).toString('hex')}`;
-}
-
-export class JsonEventA2AAdapter extends AbstractA2AAdapter {
-  readonly id = 'json-event';
-
-  readonly agentCard: AgentCard = {
-    name: 'pixcode-json-event',
-    description: 'JSON Event Stream Adapter for Pixcode Orchestration',
-    url: '/api/orchestration/agents/json-event',
-    version: '1.0.0',
-    capabilities: ['streaming', 'event-driven'],
-    skills: [
-      {
-        id: 'event-processing',
-        description: 'Process external JSON event streams and map them to task progress',
-      },
-    ],
-    authentication: { type: 'bearer' },
-  };
-
-  private readonly active = new Set<string>();
-
-  async submitTask(task: Task, _ctx: AdapterContext): Promise<TaskHandle> {
-    this.active.add(task.id);
-    this.emitState(task.id, 'working');
-
-    // This is a specialty adapter; the actual event ingestion happens
-    // externally (e.g. via an ingest endpoint) which publishes to the bus.
-    
-    const finished = (async () => {
-        // Lifecycle managed by external events
-    })();
-
-    return {
-      cancel: () => this.cancelTask(task.id),
-      finished,
-    };
-  }
-
-  async cancelTask(taskId: string): Promise<void> {
-    if (this.active.has(taskId)) {
-      this.active.delete(taskId);
-      this.emitState(taskId, 'canceled');
-    }
-  }
-
-  /**
-   * External event handlers call this to bridge native JSON events to A2A.
-   */
-  handleExternalEvent(taskId: string, event: Record<string, unknown>): void {
-    if (!this.active.has(taskId)) return;
-
-    const kind = event.kind || event.type;
-
-    switch (kind) {
-      case 'message':
-      case 'text':
-        this.emitMessage(taskId, {
-          messageId: newId('msg'),
-          role: 'agent',
-          parts: [{ kind: 'text', text: String(event.text || event.content || '') }],
-          taskId,
-        });
-        break;
-      case 'artifact':
-        this.emitArtifact(taskId, {
-          artifactId: newId('art'),
-          type: (event.artifactType as any) || 'data',
-          parts: [{ kind: 'data', data: event.data as Record<string, unknown> }],
-          metadata: { source: 'external-json-event' },
-        });
-        break;
-      case 'completed':
-        this.emitState(taskId, 'completed');
-        this.active.delete(taskId);
-        break;
-      case 'failed':
-        this.emitState(taskId, 'failed', {
-          code: String(event.errorCode || 'EXTERNAL_ERROR'),
-          message: String(event.errorMessage || 'External event reported failure'),
-        });
-        this.active.delete(taskId);
-        break;
-    }
-  }
-}