@mrtrinhvn/ag-kit 1.5.2 → 1.6.0

package/template/src/services/ModelService.ts

@@ -0,0 +1,119 @@
+import { CdpService } from './CdpService.js';
+import { OllamaService } from './OllamaService.js';
+
+export interface ModelInfo {
+  name: string;
+  refreshText: string;
+  isActive: boolean;
+  provider: 'ide' | 'ollama';
+}
+
+/**
+ * ModelService - Bộ não điều phối danh sách Model danh cho ag-kit v1.6.0.
+ * Hỗ trợ Hybrid: Kết hợp Native IDE Cloud và Local Ollama.
+ */
+export class ModelService {
+  private ollama = new OllamaService();
+  private manualSelectedModel: string | null = null;
+
+  constructor(private cdp: CdpService) {}
+
+  /**
+   * Liệt kê các model khả dụng.
+   * "Tinh hoa": Tôn trọng sự lựa chọn thủ công của người dùng trên HUD.
+   */
+  async listModels(): Promise<ModelInfo[]> {
+    const ideModels = await this.listIdeModels();
+    const ollamaModels = await this.ollama.listModels();
+
+    // 1. Gộp danh sách model
+    const merged: ModelInfo[] = [
+      ...ideModels.map(m => ({ ...m, provider: 'ide' as const })),
+      ...ollamaModels.map(m => ({
+        name: `[Ollama] ${m.name}`,
+        refreshText: m.size ? `${(m.size / (1024 * 1024 * 1024)).toFixed(1)}GB` : 'Local',
+        isActive: false, 
+        provider: 'ollama' as const
+      }))
+    ];
+
+    // 2. Logic "Manual Lock": Nếu chưa chọn, ưu tiên lấy model đang Active của IDE
+    if (!this.manualSelectedModel) {
+      const activeIde = merged.find(m => m.provider === 'ide' && m.isActive);
+      if (activeIde) {
+        this.manualSelectedModel = activeIde.name;
+      } else if (merged.length > 0) {
+        this.manualSelectedModel = merged[0].name;
+      }
+    }
+
+    // 3. Buộc đồng bộ hóa trạng thái Active với sự lựa chọn của Sếp
+    if (this.manualSelectedModel) {
+      let foundMatch = false;
+      merged.forEach(m => {
+        if (m.name === this.manualSelectedModel) {
+          m.isActive = true;
+          foundMatch = true;
+        } else {
+          m.isActive = false;
+        }
+      });
+      
+      // Nếu model cũ không còn (bị xóa khỏi Ollama), quay về bản IDE mặc định
+      if (!foundMatch && merged.length > 0) {
+         this.manualSelectedModel = merged.find(m => m.provider === 'ide')?.name || merged[0].name;
+      }
+    }
+
+    return merged;
+  }
+
+  /**
+   * Scraper Shadow DOM cho các IDE dựa trên VS Code (Antigravity, Cursor).
+   */
+  private async listIdeModels(): Promise<Omit<ModelInfo, 'provider'>[]> {
+    const script = `(() => {
+      const findInShadow = (root, patterns) => {
+        let found = [];
+        const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT);
+        let node = walker.nextNode();
+        while (node) {
+          const el = node;
+          const text = el.innerText || "";
+          if (patterns.some(p => text.includes(p)) && el.offsetParent !== null) {
+            // Nhận diện Menu Item trong IDE
+            if (el.classList && (el.classList.contains('monaco-list-row') || el.classList.contains('menu-item'))) {
+               found.push({
+                 name: text.split('\\n')[0].trim(),
+                 refreshText: 'Ready',
+                 isActive: el.classList.contains('focused') || el.classList.contains('active') || el.getAttribute('aria-selected') === 'true'
+               });
+            }
+          }
+          if (el.shadowRoot) found = found.concat(findInShadow(el.shadowRoot, patterns));
+          node = walker.nextNode();
+        }
+        return found;
+      };
+
+      const patterns = ['Gemini', 'Claude', 'GPT', 'Llama', 'DeepSeek', 'o1'];
+      return findInShadow(document.body, patterns);
+    })()`;
+
+    try {
+      const raw = await this.cdp.evaluate(script) as any[];
+      // Deduplicate by name
+      return Array.from(new Map(raw.map((item: any) => [item['name'], item])).values());
+    } catch {
+      return [];
+    }
+  }
+
+  public async setModel(name: string) {
+    this.manualSelectedModel = name;
+  }
+
+  public getSelectedModel() {
+    return this.manualSelectedModel;
+  }
+}

package/template/src/services/OllamaService.ts

@@ -0,0 +1,91 @@
+import http from 'http';
+
+export interface OllamaModel {
+  name: string;
+  model: string;
+  modified_at: string;
+  size: number;
+}
+
+export class OllamaService {
+  private baseUrl = 'http://localhost:11434';
+
+  /**
+   * List available Ollama models
+   */
+  async listModels(): Promise<OllamaModel[]> {
+    return new Promise((resolve, reject) => {
+      const req = http.get(`${this.baseUrl}/api/tags`, (res) => {
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => {
+          try {
+            const parsed = JSON.parse(data);
+            const validModels = (parsed.models || []).filter((m: any) => !m.name.includes('nomic-embed-text'));
+            resolve(validModels);
+          } catch (e) {
+            reject(new Error('Failed to parse Ollama response'));
+          }
+        });
+      });
+      req.on('error', (err) => {
+        // Silently fail if Ollama is not running, return empty list
+        resolve([]);
+      });
+      req.setTimeout(2000, () => {
+        req.destroy();
+        resolve([]);
+      });
+    });
+  }
+
+  /**
+   * Generate response from an Ollama model (Streaming)
+   */
+  async generateResponse(model: string, prompt: string, onProgress: (chunk: string) => void): Promise<string> {
+    return new Promise((resolve, reject) => {
+      const postData = JSON.stringify({
+        model: model,
+        prompt: prompt,
+        stream: true
+      });
+
+      const options = {
+        hostname: 'localhost',
+        port: 11434,
+        path: '/api/generate',
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(postData)
+        }
+      };
+
+      let fullResponse = '';
+      const req = http.request(options, (res) => {
+        res.on('data', (chunk) => {
+          try {
+            const lines = chunk.toString().split('\n');
+            for (const line of lines) {
+              if (!line.trim()) continue;
+              const json = JSON.parse(line);
+              if (json.response) {
+                fullResponse += json.response;
+                onProgress(json.response);
+              }
+              if (json.done) {
+                resolve(fullResponse);
+              }
+            }
+          } catch (e) {
+            // Ignore partial parse errors during streaming
+          }
+        });
+      });
+
+      req.on('error', reject);
+      req.write(postData);
+      req.end();
+    });
+  }
+}

package/template/src/services/SessionService.ts

@@ -0,0 +1,188 @@
+import { CdpService } from './CdpService.js';
+
+export interface SessionListItem {
+  title: string;
+  isActive: boolean;
+}
+
+const SELECTORS = {
+  NEW_CHAT_BTN: '[data-tooltip-id="new-conversation-tooltip"]',
+  PAST_CONVERSATIONS_BTN: '[data-tooltip-id*="history"], [data-tooltip-id*="past-conversations"], [class*="lucide-history"]',
+  SESSION_ROWS: 'div[class*="cursor-pointer"]',
+};
+
+export class SessionService {
+  private cdp: CdpService;
+
+  constructor(cdp: CdpService) {
+    this.cdp = cdp;
+  }
+
+  /**
+   * Click the "New Chat" (+) button in the IDE.
+   */
+  async startNewChat(): Promise<boolean> {
+    const script = `(() => {
+      const selectors = [
+        '${SELECTORS.NEW_CHAT_BTN}',
+        '[data-tooltip-id*="new-conversation"]',
+        '[data-tooltip-id*="new-chat"]',
+        '[aria-label*="New Conversation"]',
+        '[aria-label*="New Chat"]'
+      ];
+      let btn = null;
+      for (const s of selectors) {
+        btn = document.querySelector(s);
+        if (btn) break;
+      }
+      if (!btn) return null;
+      const rect = btn.getBoundingClientRect();
+      return { x: Math.round(rect.x + rect.width / 2), y: Math.round(rect.y + rect.height / 2) };
+    })()`;
+
+    const coords = await this.evaluateOnAnyContext(script);
+    if (!coords) return false;
+
+    await this.cdpClick(coords.x, coords.y);
+    return true;
+  }
+
+  /**
+   * Scrape session list from the "Past Conversations" panel.
+   */
+  async listSessions(): Promise<SessionListItem[]> {
+    // 1. Open Past Conversations panel
+    const btnScript = `(() => {
+      const btn = document.querySelector('${SELECTORS.PAST_CONVERSATIONS_BTN}');
+      if (!btn) return null;
+      const rect = btn.getBoundingClientRect();
+      return { x: Math.round(rect.x + rect.width / 2), y: Math.round(rect.y + rect.height / 2) };
+    })()`;
+
+    const btnCoords = await this.evaluateOnAnyContext(btnScript);
+    if (!btnCoords) return [];
+
+    await this.cdpClick(btnCoords.x, btnCoords.y);
+    await this.sleep(800); // Wait for panel
+
+    // 2. Scrape sessions
+    const scrapeScript = `(() => {
+      const rows = Array.from(document.querySelectorAll('div[class*="cursor-pointer"]'));
+      const items = [];
+      for (const row of rows) {
+        const text = (row.textContent || '').trim();
+        if (text.length < 2 || text.length > 100) continue;
+        if (/history|new|past/i.test(text)) continue;
+        const isActive = /focusBackground/i.test(row.className || '');
+        items.push({ title: text, isActive });
+      }
+      return items;
+    })()`;
+
+    const sessions = await this.evaluateOnAnyContext(scrapeScript);
+
+    // 3. Close panel (Escape)
+    await this.cdp.call('Input.dispatchKeyEvent', { type: 'keyDown', key: 'Escape', code: 'Escape', windowsVirtualKeyCode: 27 });
+    await this.cdp.call('Input.dispatchKeyEvent', { type: 'keyUp', key: 'Escape', code: 'Escape', windowsVirtualKeyCode: 27 });
+
+    return sessions || [];
+  }
+
+  /**
+   * Switch to a session by clicking its title in the panel.
+   */
+  async activateSession(title: string): Promise<boolean> {
+    const script = `(() => {
+      const rows = Array.from(document.querySelectorAll('div[class*="cursor-pointer"]'));
+      const target = rows.find(r => (r.textContent || '').trim() === ${JSON.stringify(title)});
+      if (!target) return null;
+      const rect = target.getBoundingClientRect();
+      return { x: Math.round(rect.x + rect.width / 2), y: Math.round(rect.y + rect.height / 2) };
+    })()`;
+
+    // 1. Open panel first
+    await this.listSessions(); 
+    await this.sleep(500);
+
+    const coords = await this.evaluateOnAnyContext(script);
+    if (!coords) return false;
+
+    await this.cdpClick(coords.x, coords.y);
+    return true;
+  }
+
+  /**
+   * Find a session that starts with [TG-Topic-ID] or [TG-Chat-ID]
+   */
+  async findSessionByTopic(id: number, isPrivate: boolean): Promise<string | null> {
+    const prefix = isPrivate ? `[TG-Chat-${id}]` : `[TG-Topic-${id}]`;
+    const sessions = await this.listSessions();
+    const found = sessions.find(s => s.title.startsWith(prefix));
+    return found ? found.title : null;
+  }
+
+  /**
+   * Create a new chat and immediately rename it (or just return the initial title)
+   * Note: Renaming in IDE is tricky via CDP, so we just use the default new chat
+   * and the first message will set the title.
+   */
+  async startNewChatWithTopic(id: number, isPrivate: boolean): Promise<boolean> {
+    const ok = await this.startNewChat();
+    // We can't easily rename via CDP without more complex DOM interaction.
+    // However, the IDE usually titles by the first prompt.
+    // For now, we'll just return 'true' and the bot will inject a hidden prefix if possible,
+    // or we just rely on the fact that we can't perfectly name it but we can *find* it
+    // if we manage to inject the prefix in the first message.
+    return ok;
+  }
+
+  /**
+   * Scrape the last 40 lines of the currently active terminal in the IDE.
+   */
+  async getTerminalOutput(): Promise<string> {
+    const script = `(() => {
+      // 1. Try to find accessibility tree (contains text nodes even if canvas renderer is used)
+      const ariaRows = Array.from(document.querySelectorAll('.xterm-accessibility-tree .xterm-rows > div, .xterm-accessibility .live-region'));
+      
+      // 2. Fallback to normal rows if DOM renderer is used
+      const normalRows = Array.from(document.querySelectorAll('.xterm-rows > div'));
+      
+      // 3. Fallback to aria-live region which contains the terminal stream
+      const liveRegion = document.querySelector('.xterm-accessibility-tree [aria-live], .live-region[aria-live="polite"]');
+      
+      let lines = [];
+      if (ariaRows.length > 0) {
+        lines = ariaRows.map(r => r.textContent || '');
+      } else if (normalRows.length > 0) {
+        lines = normalRows.map(r => r.textContent || '');
+      } else if (liveRegion && liveRegion.textContent) {
+        lines = liveRegion.textContent.split('\\n');
+      }
+      
+      lines = lines.filter(t => t.trim().length > 0);
+      if (lines.length === 0) return null;
+      return lines.slice(-40).join('\\n');
+    })()`;
+    
+    try {
+        const text = await this.evaluateOnAnyContext(script);
+        return text || '📭 [DOM Trống: IDE đang ẩn hoặc chưa bật Tab Terminal. Sếp hãy mở/focus Panel Terminal trên màn hình IDE trước nhé do cơ chế tiết kiệm RAM của VS Code!]';
+    } catch(e) {
+        return '❌ Lỗi đọc Terminal từ IDE';
+    }
+  }
+
+  private async evaluateOnAnyContext(expression: string): Promise<any> {
+    return this.cdp.evaluateOnAnyContext(expression);
+  }
+
+  private async cdpClick(x: number, y: number): Promise<void> {
+    await this.cdp.call('Input.dispatchMouseEvent', { type: 'mouseMoved', x, y });
+    await this.cdp.call('Input.dispatchMouseEvent', { type: 'mousePressed', x, y, button: 'left', clickCount: 1 });
+    await this.cdp.call('Input.dispatchMouseEvent', { type: 'mouseReleased', x, y, button: 'left', clickCount: 1 });
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise(r => setTimeout(r, ms));
+  }
+}

package/template/src/services/TopicManager.ts

@@ -0,0 +1,53 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+export interface SessionState {
+  topicId: string;
+  metadata: Record<string, any>;
+}
+
+/**
+ * TopicManager - Quản lý phiên hội thoại (Sessions) dựa trên chủ đề.
+ * Giúp đồng bộ hóa ngữ cảnh giữa các Agent.
+ */
+export class TopicManager {
+  private stateFile: string;
+  private chatToSession: Map<number, SessionState> = new Map();
+
+  constructor(storagePath: string = '.topic_state.json') {
+    this.stateFile = path.resolve(storagePath);
+    this.loadState();
+  }
+
+  private loadState() {
+    try {
+      if (fs.existsSync(this.stateFile)) {
+        const raw = fs.readFileSync(this.stateFile, 'utf8');
+        const data = JSON.parse(raw);
+        for (const [id, state] of Object.entries(data)) {
+          this.chatToSession.set(Number(id), state as SessionState);
+        }
+      }
+    } catch (e) {
+      console.error('[TopicManager] Error loading state:', e);
+    }
+  }
+
+  private saveState() {
+    try {
+      const data = Object.fromEntries(this.chatToSession);
+      fs.writeFileSync(this.stateFile, JSON.stringify(data, null, 2));
+    } catch (e) {
+      console.error('[TopicManager] Error saving state:', e);
+    }
+  }
+
+  public setSession(chatId: number, state: SessionState) {
+    this.chatToSession.set(chatId, state);
+    this.saveState();
+  }
+
+  public getSession(chatId: number): SessionState | undefined {
+    return this.chatToSession.get(chatId);
+  }
+}