@aion0/forge 0.6.1 → 0.6.3

package/.forge/worktrees/pipeline-0a33c50d/lib/project-sessions.ts

@@ -1,53 +0,0 @@
-/**
- * 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-0a33c50d/lib/projects.ts

@@ -1,86 +0,0 @@
-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-0a33c50d/lib/session-manager.ts

@@ -1,156 +0,0 @@
-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-0a33c50d/lib/session-utils.ts

@@ -1,53 +0,0 @@
-/**
- * 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-0a33c50d/lib/session-watcher.ts

@@ -1,345 +0,0 @@
-/**
- * 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, '\\$&');
-}