sofia-cli 0.1.1

package/dist/src/shared/copilotClient.js

@@ -0,0 +1,129 @@
+import { createTextDeltaEvent } from './events.js';
+/**
+ * Create a fake CopilotClient that returns predetermined responses.
+ * Used in unit and integration tests for deterministic behavior.
+ */
+export function createFakeCopilotClient(responses, _options) {
+    let responseIndex = 0;
+    return {
+        async createSession(_sessionOptions) {
+            const history = [];
+            return {
+                send(message) {
+                    history.push(message);
+                    // If onChat override is provided, use it (allows throwing for retry tests)
+                    if (_options?.onChat) {
+                        const chatFn = _options.onChat;
+                        return {
+                            async *[Symbol.asyncIterator]() {
+                                const response = await chatFn(message);
+                                history.push(response);
+                                yield createTextDeltaEvent(response.content);
+                            },
+                        };
+                    }
+                    const response = responses[responseIndex] ?? {
+                        role: 'assistant',
+                        content: '[No more responses configured]',
+                    };
+                    responseIndex++;
+                    history.push(response);
+                    return {
+                        async *[Symbol.asyncIterator]() {
+                            // Simulate streaming by yielding the full content as a single TextDelta
+                            yield createTextDeltaEvent(response.content);
+                        },
+                    };
+                },
+                getHistory() {
+                    return [...history];
+                },
+            };
+        },
+    };
+}
+// ── Live Copilot SDK client (created when SDK is available) ──────────────────
+/**
+ * Create a real CopilotClient using the GitHub Copilot SDK.
+ * Wraps the SDK's CopilotClient + CopilotSession behind our
+ * CopilotClient / ConversationSession interfaces so the rest of
+ * the codebase (ConversationLoop, phaseHandlers) stays decoupled.
+ *
+ * Throws a clear error if the SDK is not installed.
+ */
+export async function createCopilotClient() {
+    // Dynamic import — SDK is listed in dependencies but may fail in
+    // environments where the native add-on cannot build.
+    let sdk;
+    try {
+        sdk = await import('@github/copilot-sdk');
+    }
+    catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        throw new Error(`GitHub Copilot SDK (@github/copilot-sdk) is not available: ${detail}`);
+    }
+    const { CopilotClient: SdkClient, approveAll } = sdk;
+    // A single SDK client instance is shared across sessions.
+    // autoStart: true (default) means `start()` is called lazily on
+    // the first `createSession`.
+    const sdkClient = new SdkClient();
+    return {
+        async createSession(options) {
+            const sessionConfig = {
+                onPermissionRequest: approveAll,
+                systemMessage: {
+                    mode: 'replace',
+                    content: options.systemPrompt,
+                },
+                // Forward MCP server configs to the SDK so it manages server lifecycle
+                // (spawn, connect, JSON-RPC dispatch) for LLM-initiated tool calls.
+                // Cast needed because our SessionOptions uses a portable shape that
+                // doesn't carry the SDK's discriminated-union literal types.
+                ...(options.mcpServers && Object.keys(options.mcpServers).length > 0
+                    ? {
+                        mcpServers: options.mcpServers,
+                    }
+                    : {}),
+                // Forward SDK hooks for tool-call visibility (FR-021, FR-022).
+                ...(options.hooks ? { hooks: options.hooks } : {}),
+                // Forward infinite sessions config for context management (FR-023).
+                ...(options.infiniteSessions ? { infiniteSessions: options.infiniteSessions } : {}),
+            };
+            const sdkSession = await sdkClient.createSession(sessionConfig);
+            // Subscribe to assistant.usage events for token usage tracking (FR-024).
+            if (options.onUsage) {
+                const usageCb = options.onUsage;
+                sdkSession.on('assistant.usage', (event) => {
+                    usageCb(event.data);
+                });
+            }
+            const history = [];
+            return {
+                send(message) {
+                    history.push(message);
+                    // Return an AsyncIterable that bridges SDK events → SofiaEvents.
+                    // We use `sendAndWait` which blocks until the assistant is idle
+                    // and then yield the complete response as a single TextDelta,
+                    // keeping the same contract the fake client provides.
+                    return {
+                        async *[Symbol.asyncIterator]() {
+                            const response = await sdkSession.sendAndWait({ prompt: message.content }, 120_000);
+                            const content = response?.data.content ?? '';
+                            if (content) {
+                                const assistantMsg = {
+                                    role: 'assistant',
+                                    content,
+                                };
+                                history.push(assistantMsg);
+                                yield createTextDeltaEvent(content);
+                            }
+                        },
+                    };
+                },
+                getHistory() {
+                    return [...history];
+                },
+            };
+        },
+    };
+}