@adhdev/daemon-core 0.5.3

package/src/providers/cli-provider-instance.ts

@@ -0,0 +1,207 @@
+/**
+ * CliProviderInstance — Runtime instance for CLI Provider
+ *
+ * Lifecycle layer on top of ProviderCliAdapter.
+ * collectCliData() + status transition logic from daemon-status.ts moved here.
+ */
+
+import * as path from 'path';
+import * as crypto from 'crypto';
+import type { ProviderModule } from './contracts.js';
+import type { ProviderInstance, ProviderState, ProviderEvent, InstanceContext } from './provider-instance.js';
+import { ProviderCliAdapter } from '../cli-adapters/provider-cli-adapter.js';
+import type { CliProviderModule } from '../cli-adapters/provider-cli-adapter.js';
+import { StatusMonitor } from './status-monitor.js';
+import { ChatHistoryWriter } from '../config/chat-history.js';
+
+export class CliProviderInstance implements ProviderInstance {
+    readonly type: string;
+    readonly category = 'cli' as const;
+
+    private adapter: ProviderCliAdapter;
+    private context: InstanceContext | null = null;
+    private events: ProviderEvent[] = [];
+    private lastStatus: string = 'starting';
+    private generatingStartedAt: number = 0;
+    private settings: Record<string, any> = {};
+    private monitor: StatusMonitor;
+    private historyWriter: ChatHistoryWriter;
+    readonly instanceId: string;
+
+    constructor(
+        private provider: ProviderModule,
+        private workingDir: string,
+        private cliArgs: string[] = [],
+        instanceId?: string,
+    ) {
+        this.type = provider.type;
+        this.instanceId = instanceId || crypto.randomUUID();
+        this.adapter = new ProviderCliAdapter(provider as any as CliProviderModule, workingDir, cliArgs);
+        this.monitor = new StatusMonitor();
+        this.historyWriter = new ChatHistoryWriter();
+    }
+
+ // ─── Lifecycle ─────────────────────────────────
+
+    async init(context: InstanceContext): Promise<void> {
+        this.context = context;
+        this.settings = context.settings || {};
+        this.monitor.updateConfig({
+            approvalAlert: this.settings.approvalAlert !== false,
+            longGeneratingAlert: this.settings.longGeneratingAlert !== false,
+            longGeneratingThresholdSec: this.settings.longGeneratingThresholdSec || 180,
+        });
+
+ // Server connection
+        if (context.serverConn) {
+            this.adapter.setServerConn(context.serverConn);
+        }
+
+ // PTY output callback
+        if (context.onPtyData) {
+            this.adapter.setOnPtyData(context.onPtyData);
+        }
+
+ // Emit event on status change
+        this.adapter.setOnStatusChange(() => {
+            this.detectStatusTransition();
+        });
+
+ // PTY spawn
+        await this.adapter.spawn();
+    }
+
+    async onTick(): Promise<void> {
+ // CLI is event-based so tick is unnecessary
+ // Health check etc here if needed
+    }
+
+    getState(): ProviderState {
+        const adapterStatus = this.adapter.getStatus();
+        const dirName = this.workingDir.split('/').filter(Boolean).pop() || 'session';
+
+ // Message truncate (recent 50, 2000 char limit)
+        const recentMessages = adapterStatus.messages.slice(-50).map(m => ({
+            role: m.role,
+            content: m.content.length > 2000 ? m.content.slice(0, 2000) + '\n... (truncated)' : m.content,
+            timestamp: m.timestamp,
+        }));
+
+ // generating during partial response add
+        const partial = this.adapter.getPartialResponse();
+        if (adapterStatus.status === 'generating' && partial) {
+            const cleaned = partial.trim();
+            if (cleaned && cleaned !== '(generating...)') {
+                recentMessages.push({
+                    role: 'assistant',
+                    content: (cleaned.length > 2000 ? cleaned.slice(0, 2000) + '...' : cleaned) + '...',
+                    timestamp: Date.now(),
+                });
+            }
+        }
+
+ // Save history
+        if (recentMessages.length > 0) {
+            const dirName = this.workingDir.split('/').filter(Boolean).pop() || 'session';
+            this.historyWriter.appendNewMessages(
+                this.type,
+                recentMessages,
+                `${this.provider.name} · ${dirName}`,
+                this.instanceId,
+            );
+        }
+
+        return {
+            type: this.type,
+            name: this.provider.name,
+            category: 'cli',
+            status: adapterStatus.status,
+            mode: (this.settings.mode as 'terminal' | 'chat') || 'terminal',
+            activeChat: {
+                id: `${this.type}_${this.workingDir}`,
+                title: `${this.provider.name} · ${dirName}`,
+                status: adapterStatus.status,
+                messages: recentMessages,
+                activeModal: adapterStatus.activeModal,
+                inputContent: '',
+            },
+            workingDir: this.workingDir,
+            instanceId: this.instanceId,
+            lastUpdated: Date.now(),
+            settings: this.settings,
+            pendingEvents: this.flushEvents(),
+        };
+    }
+
+    onEvent(event: string, data?: any): void {
+        if (event === 'send_message' && data?.text) {
+            this.adapter.sendMessage(data.text);
+        } else if (event === 'server_connected' && data?.serverConn) {
+            this.adapter.setServerConn(data.serverConn);
+        }
+    }
+
+    dispose(): void {
+        this.adapter.shutdown();
+        this.monitor.reset();
+    }
+
+ // ─── Status transition detection (moved from daemon-status.ts) ──────
+
+    private detectStatusTransition(): void {
+        const now = Date.now();
+        const adapterStatus = this.adapter.getStatus();
+        const newStatus = adapterStatus.status;
+        const dirName = this.workingDir.split('/').filter(Boolean).pop() || 'session';
+        const chatTitle = `${this.provider.name} · ${dirName}`;
+
+        if (newStatus !== this.lastStatus) {
+            if (this.lastStatus === 'idle' && newStatus === 'generating') {
+                this.generatingStartedAt = now;
+                this.pushEvent({ event: 'agent:generating_started', chatTitle, timestamp: now });
+            } else if (newStatus === 'waiting_approval') {
+                if (!this.generatingStartedAt) this.generatingStartedAt = now;
+                this.pushEvent({
+                    event: 'agent:waiting_approval', chatTitle, timestamp: now,
+                    modalMessage: adapterStatus.activeModal?.message,
+                    modalButtons: adapterStatus.activeModal?.buttons,
+                });
+            } else if (newStatus === 'idle' && (this.lastStatus === 'generating' || this.lastStatus === 'waiting_approval')) {
+                const duration = this.generatingStartedAt ? Math.round((now - this.generatingStartedAt) / 1000) : 0;
+                this.pushEvent({ event: 'agent:generating_completed', chatTitle, duration, timestamp: now });
+                this.generatingStartedAt = 0;
+            } else if (newStatus === 'stopped') {
+                this.pushEvent({ event: 'agent:stopped', chatTitle, timestamp: now });
+            }
+            this.lastStatus = newStatus;
+        }
+
+ // Monitor check (cooldown based notification, IDE/CLI common)
+        const agentKey = `${this.type}:cli`;
+        const monitorEvents = this.monitor.check(agentKey, newStatus, now);
+        for (const me of monitorEvents) {
+            this.pushEvent({ event: me.type, agentKey: me.agentKey, message: me.message, elapsedSec: me.elapsedSec, timestamp: me.timestamp });
+        }
+    }
+
+    private pushEvent(event: ProviderEvent): void {
+        this.events.push(event);
+ // Max 50
+        if (this.events.length > 50) this.events = this.events.slice(-50);
+    }
+
+    private flushEvents(): ProviderEvent[] {
+        const events = [...this.events];
+        this.events = [];
+        return events;
+    }
+
+ // ─── Adapter access (backward compat) ──────────────────
+
+    getAdapter(): ProviderCliAdapter {
+        return this.adapter;
+    }
+
+    get cliType(): string { return this.type; }
+    get cliName(): string { return this.provider.name; }
+}