@aion0/forge 0.5.25 → 0.5.26

package/.forge/worktrees/pipeline-d6a6ef23/lib/project-sessions.ts

@@ -0,0 +1,53 @@
+/**
+ * Project-level fixed session binding.
+ * Stores { projectPath: sessionId } in ~/.forge/data/project-sessions.json
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { getDataDir } from './dirs';
+
+function getFilePath(): string {
+  const dir = getDataDir();
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  return join(dir, 'project-sessions.json');
+}
+
+let cache: Record<string, string> | null = null;
+
+function loadAll(): Record<string, string> {
+  if (cache !== null) return cache;
+  const fp = getFilePath();
+  if (!existsSync(fp)) { cache = {}; return cache; }
+  try { cache = JSON.parse(readFileSync(fp, 'utf-8')) as Record<string, string>; } catch { cache = {}; }
+  return cache;
+}
+
+function saveAll(data: Record<string, string>): void {
+  cache = data;
+  writeFileSync(getFilePath(), JSON.stringify(data, null, 2));
+}
+
+/** Get the fixed session ID for a project */
+export function getFixedSession(projectPath: string): string | undefined {
+  return loadAll()[projectPath] || undefined;
+}
+
+/** Set the fixed session ID for a project */
+export function setFixedSession(projectPath: string, sessionId: string): void {
+  const data = loadAll();
+  data[projectPath] = sessionId;
+  saveAll(data);
+}
+
+/** Clear the fixed session for a project */
+export function clearFixedSession(projectPath: string): void {
+  const data = loadAll();
+  delete data[projectPath];
+  saveAll(data);
+}
+
+/** Get all bindings */
+export function getAllFixedSessions(): Record<string, string> {
+  return loadAll();
+}

package/.forge/worktrees/pipeline-d6a6ef23/lib/projects.ts

@@ -0,0 +1,86 @@
+import { readdirSync, existsSync, statSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { loadSettings } from './settings';
+
+export interface LocalProject {
+  name: string;
+  path: string;
+  root: string;              // Which project root it came from
+  hasGit: boolean;
+  hasClaudeMd: boolean;
+  language: string | null;
+  lastModified: string;
+}
+
+export function scanProjects(): LocalProject[] {
+  const settings = loadSettings();
+  const roots = settings.projectRoots;
+
+  if (roots.length === 0) return [];
+
+  const projects: LocalProject[] = [];
+
+  for (const root of roots) {
+    if (!existsSync(root)) continue;
+
+    const entries = readdirSync(root, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith('.')) continue;
+
+      const projectPath = join(root, entry.name);
+
+      try {
+        const hasGit = existsSync(join(projectPath, '.git'));
+        const hasClaudeMd = existsSync(join(projectPath, 'CLAUDE.md'));
+        const language = detectLanguage(projectPath);
+        const stat = statSync(projectPath);
+
+        projects.push({
+          name: entry.name,
+          path: projectPath,
+          root,
+          hasGit,
+          hasClaudeMd,
+          language,
+          lastModified: stat.mtime.toISOString(),
+        });
+      } catch {
+        // Skip inaccessible directories
+      }
+    }
+  }
+
+  return projects.sort((a, b) => b.lastModified.localeCompare(a.lastModified));
+}
+
+function detectLanguage(projectPath: string): string | null {
+  const markers: [string, string][] = [
+    ['pom.xml', 'java'],
+    ['build.gradle', 'java'],
+    ['build.gradle.kts', 'kotlin'],
+    ['package.json', 'typescript'],
+    ['tsconfig.json', 'typescript'],
+    ['requirements.txt', 'python'],
+    ['pyproject.toml', 'python'],
+    ['go.mod', 'go'],
+    ['Cargo.toml', 'rust'],
+  ];
+
+  for (const [file, lang] of markers) {
+    if (existsSync(join(projectPath, file))) return lang;
+  }
+  return null;
+}
+
+export function getProjectInfo(name: string): LocalProject | null {
+  const projects = scanProjects();
+  return projects.find(p => p.name === name) || null;
+}
+
+export function getProjectClaudeMd(projectPath: string): string | null {
+  const claudeMdPath = join(projectPath, 'CLAUDE.md');
+  if (!existsSync(claudeMdPath)) return null;
+  return readFileSync(claudeMdPath, 'utf-8');
+}

package/.forge/worktrees/pipeline-d6a6ef23/lib/session-manager.ts

@@ -0,0 +1,156 @@
+import { randomUUID } from 'node:crypto';
+import { getDb } from '@/src/core/db/database';
+import { getDbPath, loadTemplate } from '@/src/config';
+import { chatStream, type ChatResult } from '@/src/core/providers/chat';
+import { getMemoryMessages } from '@/src/core/memory/strategy';
+import type { Session, SessionStatus, Message, ProviderName, MemoryConfig } from '@/src/types';
+
+// Re-export the SessionManager but as a singleton for server-side use
+class SessionManager {
+  private db;
+
+  constructor() {
+    this.db = getDb(getDbPath());
+  }
+
+  create(opts: { name: string; templateId: string; provider?: ProviderName; model?: string }): Session {
+    const template = loadTemplate(opts.templateId);
+    if (!template) throw new Error(`Template not found: ${opts.templateId}`);
+
+    const id = randomUUID().slice(0, 8);
+    const provider = opts.provider || template.provider;
+    const model = opts.model || template.model || '';
+    const memoryConfig = JSON.stringify(template.memory);
+
+    this.db.prepare(`
+      INSERT INTO sessions (id, name, template_id, provider, model, status, memory_config, system_prompt)
+      VALUES (?, ?, ?, ?, ?, 'idle', ?, ?)
+    `).run(id, opts.name, opts.templateId, provider, model, memoryConfig, template.systemPrompt);
+
+    return this.get(id)!;
+  }
+
+  get(id: string): Session | null {
+    const row = this.db.prepare(`
+      SELECT s.*, COUNT(m.id) as message_count,
+        (SELECT content FROM messages WHERE session_id = s.id ORDER BY created_at DESC LIMIT 1) as last_message
+      FROM sessions s
+      LEFT JOIN messages m ON m.session_id = s.id
+      WHERE s.id = ?
+      GROUP BY s.id
+    `).get(id) as any;
+
+    if (!row) return null;
+    return this.rowToSession(row);
+  }
+
+  getByName(name: string): Session | null {
+    const row = this.db.prepare(`
+      SELECT s.*, COUNT(m.id) as message_count,
+        (SELECT content FROM messages WHERE session_id = s.id ORDER BY created_at DESC LIMIT 1) as last_message
+      FROM sessions s
+      LEFT JOIN messages m ON m.session_id = s.id
+      WHERE s.name = ?
+      GROUP BY s.id
+    `).get(name) as any;
+
+    if (!row) return null;
+    return this.rowToSession(row);
+  }
+
+  list(status?: SessionStatus): Session[] {
+    let query = `
+      SELECT s.*, COUNT(m.id) as message_count,
+        (SELECT content FROM messages WHERE session_id = s.id ORDER BY created_at DESC LIMIT 1) as last_message
+      FROM sessions s
+      LEFT JOIN messages m ON m.session_id = s.id
+    `;
+    const params: string[] = [];
+    if (status) {
+      query += ' WHERE s.status = ?';
+      params.push(status);
+    }
+    query += ' GROUP BY s.id ORDER BY s.updated_at DESC';
+
+    const rows = this.db.prepare(query).all(...params) as any[];
+    return rows.map(r => this.rowToSession(r));
+  }
+
+  updateStatus(id: string, status: SessionStatus) {
+    this.db.prepare(`UPDATE sessions SET status = ?, updated_at = datetime('now') WHERE id = ?`).run(status, id);
+  }
+
+  addMessage(sessionId: string, role: string, content: string, provider: string, model: string) {
+    this.db.prepare(`
+      INSERT INTO messages (session_id, role, content, provider, model)
+      VALUES (?, ?, ?, ?, ?)
+    `).run(sessionId, role, content, provider, model);
+    this.db.prepare(`UPDATE sessions SET updated_at = datetime('now') WHERE id = ?`).run(sessionId);
+  }
+
+  getMessages(sessionId: string, limit?: number): Message[] {
+    let query = 'SELECT * FROM messages WHERE session_id = ? ORDER BY created_at ASC';
+    const params: (string | number)[] = [sessionId];
+    if (limit) {
+      query = `SELECT * FROM (
+        SELECT * FROM messages WHERE session_id = ? ORDER BY created_at DESC LIMIT ?
+      ) ORDER BY created_at ASC`;
+      params.push(limit);
+    }
+    return this.db.prepare(query).all(...params) as Message[];
+  }
+
+  getMemoryMessages(sessionId: string): Message[] {
+    const session = this.get(sessionId);
+    if (!session) return [];
+    const allMessages = this.getMessages(sessionId);
+    return getMemoryMessages(allMessages, session.memory);
+  }
+
+  delete(id: string) {
+    this.db.prepare('DELETE FROM sessions WHERE id = ?').run(id);
+  }
+
+  recordUsage(sessionId: string, result: ChatResult) {
+    this.db.prepare(`
+      INSERT INTO usage (provider, model, session_id, input_tokens, output_tokens, cost)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(result.provider, result.model, sessionId, result.inputTokens, result.outputTokens, 0);
+  }
+
+  getUsageSummary() {
+    return this.db.prepare(`
+      SELECT provider,
+        SUM(input_tokens) as totalInput,
+        SUM(output_tokens) as totalOutput,
+        SUM(cost) as totalCost
+      FROM usage
+      WHERE created_at >= date('now', '-30 days')
+      GROUP BY provider
+    `).all() as any[];
+  }
+
+  private rowToSession(row: any): Session {
+    return {
+      id: row.id,
+      name: row.name,
+      templateId: row.template_id,
+      provider: row.provider,
+      model: row.model,
+      status: row.status,
+      memory: JSON.parse(row.memory_config),
+      systemPrompt: row.system_prompt,
+      messageCount: row.message_count || 0,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      lastMessage: row.last_message || undefined,
+    };
+  }
+}
+
+// Singleton
+let instance: SessionManager | null = null;
+export function getSessionManager(): SessionManager {
+  if (!instance) instance = new SessionManager();
+  return instance;
+}

package/.forge/worktrees/pipeline-d6a6ef23/lib/session-utils.ts

@@ -0,0 +1,53 @@
+/**
+ * Shared session utilities for client-side components.
+ * Resolves fixedSessionId from project-level binding.
+ */
+
+/** Fetch the fixedSessionId for a project. If not set, auto-binds the latest session. */
+export async function resolveFixedSession(projectPath: string): Promise<string | null> {
+  try {
+    // Check existing binding
+    const res = await fetch(`/api/project-sessions?projectPath=${encodeURIComponent(projectPath)}`);
+    const data = await res.json();
+    if (data?.fixedSessionId) return data.fixedSessionId;
+
+    // Not set — find latest session and auto-bind
+    const projectName = projectPath.replace(/\/+$/, '').split('/').pop() || '';
+    const sessRes = await fetch(`/api/claude-sessions/${encodeURIComponent(projectName)}`);
+    const sessions = await sessRes.json();
+    if (!Array.isArray(sessions) || sessions.length === 0) return null;
+
+    const latestId = sessions[0].sessionId || sessions[0].id;
+    if (!latestId) return null;
+
+    // Save binding
+    await fetch('/api/project-sessions', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ projectPath, fixedSessionId: latestId }),
+    });
+
+    return latestId;
+  } catch {
+    return null;
+  }
+}
+
+/** Build the resume flag: --resume <id> if fixedSession exists, else -c if hasSession */
+export function buildResumeFlag(fixedSessionId: string | null, hasExistingSessions: boolean): string {
+  if (fixedSessionId) return ` --resume ${fixedSessionId}`;
+  if (hasExistingSessions) return ' -c';
+  return '';
+}
+
+const _mcpReady = new Set<string>();
+
+/** Get --mcp-config flag for claude-code. Triggers server-side mcp.json creation (once per projectPath). */
+export async function getMcpFlag(projectPath: string): Promise<string> {
+  if (!_mcpReady.has(projectPath)) {
+    await fetch(`/api/project-sessions?projectPath=${encodeURIComponent(projectPath)}`).catch(() => {});
+    _mcpReady.add(projectPath);
+  }
+  return ` --mcp-config "${projectPath}/.forge/mcp.json"`;
+}
+

package/.forge/worktrees/pipeline-d6a6ef23/lib/session-watcher.ts

@@ -0,0 +1,345 @@
+/**
+ * Session Watcher — monitors Claude CLI sessions and sends Telegram notifications.
+ *
+ * Watchers track entry counts in sessions. When new entries appear,
+ * a summary is sent to Telegram. Also detects idle/completed sessions.
+ */
+
+import { randomUUID } from 'node:crypto';
+import { getDb } from '@/src/core/db/database';
+import { join } from 'node:path';
+import { getDataDir } from './dirs';
+import {
+  listClaudeSessions,
+  getSessionFilePath,
+  readSessionEntries,
+  type ClaudeSessionInfo,
+  type SessionEntry,
+} from './claude-sessions';
+import { scanProjects } from './projects';
+import { loadSettings } from './settings';
+
+const DB_PATH = join(getDataDir(), 'workflow.db');
+
+// ─── Types ───────────────────────────────────────────────────
+
+export interface SessionWatcher {
+  id: string;
+  projectName: string;
+  sessionId: string | null;    // null = watch all sessions in project
+  label: string | null;
+  checkInterval: number;       // seconds
+  lastEntryCount: number;
+  lastChecked: string | null;
+  notifyOnChange: boolean;
+  notifyOnIdle: boolean;
+  idleThreshold: number;       // seconds
+  active: boolean;
+  createdAt: string;
+}
+
+// ─── Session cache sync ──────────────────────────────────────
+
+export function syncSessionsToDb(projectName?: string) {
+  const db = getDb(DB_PATH);
+  const projects = projectName
+    ? [{ name: projectName }]
+    : scanProjects().map((p: { name: string }) => ({ name: p.name }));
+
+  const upsert = db.prepare(`
+    INSERT INTO cached_sessions (project_name, session_id, summary, first_prompt, message_count, created, modified, git_branch, file_size, last_synced)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))
+    ON CONFLICT(project_name, session_id) DO UPDATE SET
+      summary = excluded.summary,
+      first_prompt = excluded.first_prompt,
+      message_count = excluded.message_count,
+      created = excluded.created,
+      modified = excluded.modified,
+      git_branch = excluded.git_branch,
+      file_size = excluded.file_size,
+      last_synced = datetime('now')
+  `);
+
+  const updateEntryCount = db.prepare(`
+    UPDATE cached_sessions SET entry_count = ? WHERE project_name = ? AND session_id = ?
+  `);
+
+  let totalSynced = 0;
+
+  for (const proj of projects) {
+    const sessions = listClaudeSessions(proj.name);
+    for (const s of sessions) {
+      upsert.run(
+        proj.name, s.sessionId, s.summary || null, s.firstPrompt || null,
+        s.messageCount || 0, s.created || null, s.modified || null,
+        s.gitBranch || null, s.fileSize,
+      );
+
+      // Count entries for watcher comparison
+      const fp = getSessionFilePath(proj.name, s.sessionId);
+      if (fp) {
+        try {
+          const entries = readSessionEntries(fp);
+          updateEntryCount.run(entries.length, proj.name, s.sessionId);
+        } catch {}
+      }
+
+      totalSynced++;
+    }
+  }
+
+  return totalSynced;
+}
+
+export function getCachedSessions(projectName: string): ClaudeSessionInfo[] {
+  const db = getDb(DB_PATH);
+  const rows = db.prepare(`
+    SELECT session_id, summary, first_prompt, message_count, created, modified, git_branch, file_size
+    FROM cached_sessions WHERE project_name = ? ORDER BY modified DESC
+  `).all(projectName) as any[];
+
+  return rows.map(r => ({
+    sessionId: r.session_id,
+    summary: r.summary,
+    firstPrompt: r.first_prompt,
+    messageCount: r.message_count,
+    created: r.created,
+    modified: r.modified,
+    gitBranch: r.git_branch,
+    fileSize: r.file_size,
+  }));
+}
+
+export function getAllCachedSessions(): Record<string, ClaudeSessionInfo[]> {
+  const db = getDb(DB_PATH);
+  const rows = db.prepare(`
+    SELECT project_name, session_id, summary, first_prompt, message_count, created, modified, git_branch, file_size
+    FROM cached_sessions ORDER BY project_name, modified DESC
+  `).all() as any[];
+
+  const result: Record<string, ClaudeSessionInfo[]> = {};
+  for (const r of rows) {
+    if (!result[r.project_name]) result[r.project_name] = [];
+    result[r.project_name].push({
+      sessionId: r.session_id,
+      summary: r.summary,
+      firstPrompt: r.first_prompt,
+      messageCount: r.message_count,
+      created: r.created,
+      modified: r.modified,
+      gitBranch: r.git_branch,
+      fileSize: r.file_size,
+    });
+  }
+  return result;
+}
+
+// ─── Watcher CRUD ────────────────────────────────────────────
+
+export function createWatcher(opts: {
+  projectName: string;
+  sessionId?: string;
+  label?: string;
+  checkInterval?: number;
+}): SessionWatcher {
+  const db = getDb(DB_PATH);
+  const id = randomUUID().slice(0, 8);
+
+  db.prepare(`
+    INSERT INTO session_watchers (id, project_name, session_id, label, check_interval)
+    VALUES (?, ?, ?, ?, ?)
+  `).run(id, opts.projectName, opts.sessionId || null, opts.label || null, opts.checkInterval || 60);
+
+  return getWatcher(id)!;
+}
+
+export function getWatcher(id: string): SessionWatcher | null {
+  const db = getDb(DB_PATH);
+  const row = db.prepare('SELECT * FROM session_watchers WHERE id = ?').get(id) as any;
+  return row ? mapWatcherRow(row) : null;
+}
+
+export function listWatchers(activeOnly = false): SessionWatcher[] {
+  const db = getDb(DB_PATH);
+  const sql = activeOnly
+    ? 'SELECT * FROM session_watchers WHERE active = 1 ORDER BY created_at DESC'
+    : 'SELECT * FROM session_watchers ORDER BY created_at DESC';
+  return (db.prepare(sql).all() as any[]).map(mapWatcherRow);
+}
+
+export function toggleWatcher(id: string, active: boolean) {
+  const db = getDb(DB_PATH);
+  db.prepare('UPDATE session_watchers SET active = ? WHERE id = ?').run(active ? 1 : 0, id);
+}
+
+export function deleteWatcher(id: string) {
+  const db = getDb(DB_PATH);
+  db.prepare('DELETE FROM session_watchers WHERE id = ?').run(id);
+}
+
+function mapWatcherRow(row: any): SessionWatcher {
+  return {
+    id: row.id,
+    projectName: row.project_name,
+    sessionId: row.session_id,
+    label: row.label,
+    checkInterval: row.check_interval,
+    lastEntryCount: row.last_entry_count,
+    lastChecked: row.last_checked,
+    notifyOnChange: !!row.notify_on_change,
+    notifyOnIdle: !!row.notify_on_idle,
+    idleThreshold: row.idle_threshold,
+    active: !!row.active,
+    createdAt: row.created_at,
+  };
+}
+
+// ─── Watcher check loop ─────────────────────────────────────
+
+let watcherInterval: ReturnType<typeof setInterval> | null = null;
+
+export function startWatcherLoop() {
+  if (watcherInterval) return;
+
+  // Initial sync
+  try { syncSessionsToDb(); } catch (e) { console.error('[watcher] Initial sync error:', e); }
+
+  // Check every 30 seconds
+  watcherInterval = setInterval(runWatcherCheck, 30_000);
+  console.log('[watcher] Started session watcher loop');
+}
+
+export function stopWatcherLoop() {
+  if (watcherInterval) {
+    clearInterval(watcherInterval);
+    watcherInterval = null;
+  }
+}
+
+async function runWatcherCheck() {
+  const db = getDb(DB_PATH);
+  const watchers = listWatchers(true);
+  if (watchers.length === 0) return;
+
+  const now = Date.now();
+
+  for (const w of watchers) {
+    // Check if it's time
+    if (w.lastChecked) {
+      const elapsed = (now - new Date(w.lastChecked).getTime()) / 1000;
+      if (elapsed < w.checkInterval) continue;
+    }
+
+    try {
+      if (w.sessionId) {
+        // Watch specific session
+        await checkSession(db, w, w.projectName, w.sessionId);
+      } else {
+        // Watch all sessions in project
+        const sessions = listClaudeSessions(w.projectName);
+        for (const s of sessions) {
+          await checkSession(db, w, w.projectName, s.sessionId);
+        }
+      }
+
+      // Update last checked
+      db.prepare('UPDATE session_watchers SET last_checked = datetime(\'now\') WHERE id = ?').run(w.id);
+    } catch (e) {
+      console.error(`[watcher] Error checking ${w.id}:`, e);
+    }
+  }
+
+  // Periodic session sync (every check cycle)
+  try { syncSessionsToDb(); } catch {}
+}
+
+async function checkSession(
+  db: ReturnType<typeof getDb>,
+  watcher: SessionWatcher,
+  projectName: string,
+  sessionId: string,
+) {
+  const fp = getSessionFilePath(projectName, sessionId);
+  if (!fp) return;
+
+  const entries = readSessionEntries(fp);
+  const currentCount = entries.length;
+
+  // Get last known count from cached_sessions
+  const cached = db.prepare(
+    'SELECT entry_count FROM cached_sessions WHERE project_name = ? AND session_id = ?'
+  ).get(projectName, sessionId) as any;
+
+  const lastCount = cached?.entry_count || 0;
+
+  if (currentCount > lastCount && watcher.notifyOnChange) {
+    // New entries! Summarize the changes
+    const newEntries = entries.slice(lastCount);
+    const summary = summarizeEntries(newEntries);
+    const label = watcher.label || `${projectName}/${sessionId.slice(0, 8)}`;
+
+    await sendWatcherNotification(
+      `📋 *${esc(label)}*\n\n` +
+      `${summary}\n\n` +
+      `_${currentCount} total entries (+${currentCount - lastCount} new)_`
+    );
+
+    // Update cached entry count
+    db.prepare(
+      'UPDATE cached_sessions SET entry_count = ? WHERE project_name = ? AND session_id = ?'
+    ).run(currentCount, projectName, sessionId);
+  }
+}
+
+function summarizeEntries(entries: SessionEntry[]): string {
+  const parts: string[] = [];
+  let assistantText = '';
+  let toolNames: string[] = [];
+
+  for (const e of entries) {
+    if (e.type === 'user') {
+      parts.push(`👤 ${e.content.slice(0, 150)}`);
+    } else if (e.type === 'assistant_text') {
+      assistantText = e.content.slice(0, 300);
+    } else if (e.type === 'tool_use' && e.toolName) {
+      toolNames.push(e.toolName);
+    }
+  }
+
+  if (toolNames.length > 0) {
+    const unique = [...new Set(toolNames)];
+    parts.push(`🔧 Tools: ${unique.join(', ')}`);
+  }
+
+  if (assistantText) {
+    parts.push(`🤖 ${assistantText}`);
+  }
+
+  return parts.join('\n') || 'Activity detected';
+}
+
+async function sendWatcherNotification(text: string) {
+  const settings = loadSettings();
+  const { telegramBotToken, telegramChatId } = settings;
+  if (!telegramBotToken || !telegramChatId) return;
+
+  try {
+    const url = `https://api.telegram.org/bot${telegramBotToken}/sendMessage`;
+    await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        chat_id: telegramChatId,
+        text,
+        parse_mode: 'Markdown',
+        disable_web_page_preview: true,
+      }),
+    });
+  } catch (err) {
+    console.error('[watcher] Telegram send failed:', err);
+  }
+}
+
+function esc(s: string): string {
+  return s.replace(/[_*[\]()~`>#+=|{}.!-]/g, '\\$&');
+}