@aion0/forge 0.5.25 → 0.5.26

package/.forge/worktrees/pipeline-ecd7cb0f/src/core/db/database.ts

@@ -0,0 +1,259 @@
+import Database from 'better-sqlite3';
+import { existsSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+let db: Database.Database | null = null;
+
+export function getDb(dbPath: string): Database.Database {
+  if (db) return db;
+
+  const dir = dirname(dbPath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+
+  db = new Database(dbPath);
+  db.pragma('journal_mode = WAL');
+  db.pragma('foreign_keys = ON');
+  initSchema(db);
+  return db;
+}
+
+function initSchema(db: Database.Database) {
+  // Migrations for existing tables (catch duplicate column errors silently)
+  const migrate = (sql: string) => {
+    try { db.exec(sql); } catch (e: any) {
+      if (!String(e.message).includes('duplicate column')) console.error('[db] Migration failed:', sql, e.message);
+    }
+  };
+  migrate('ALTER TABLE tasks ADD COLUMN scheduled_at TEXT');
+  migrate("ALTER TABLE tasks ADD COLUMN mode TEXT NOT NULL DEFAULT 'prompt'");
+  migrate('ALTER TABLE tasks ADD COLUMN watch_config TEXT');
+  migrate("ALTER TABLE skills ADD COLUMN type TEXT NOT NULL DEFAULT 'skill'");
+  migrate('ALTER TABLE skills ADD COLUMN archive TEXT');
+  migrate("ALTER TABLE skills ADD COLUMN installed_version TEXT NOT NULL DEFAULT ''");
+  migrate('ALTER TABLE skills ADD COLUMN rating REAL DEFAULT 0');
+  migrate('ALTER TABLE skills ADD COLUMN deleted_remotely INTEGER NOT NULL DEFAULT 0');
+  migrate('ALTER TABLE project_pipelines ADD COLUMN last_run_at TEXT');
+  migrate('ALTER TABLE pipeline_runs ADD COLUMN dedup_key TEXT');
+  migrate("ALTER TABLE tasks ADD COLUMN agent TEXT DEFAULT 'claude'");
+  // Recreate token_usage with day column (drop old version if schema changed)
+  try { db.exec("SELECT day FROM token_usage LIMIT 1"); } catch { try { db.exec("DROP TABLE IF EXISTS token_usage"); db.exec("DROP TABLE IF EXISTS usage_scan_state"); } catch {} }
+  // Unique index for dedup (only applies when dedup_key is NOT NULL)
+  try { db.exec('CREATE UNIQUE INDEX IF NOT EXISTS idx_pipeline_runs_dedup ON pipeline_runs(project_path, workflow_name, dedup_key)'); } catch {}
+  // Migrate old issue_autofix_processed → pipeline_runs
+  try {
+    const old = db.prepare('SELECT * FROM issue_autofix_processed').all() as any[];
+    if (old.length > 0) {
+      const ins = db.prepare('INSERT OR IGNORE INTO pipeline_runs (id, project_path, workflow_name, pipeline_id, status, dedup_key, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)');
+      for (const r of old) {
+        ins.run(
+          r.pipeline_id?.slice(0, 8) || ('mig-' + r.issue_number),
+          r.project_path, 'issue-fix-and-review', r.pipeline_id || '',
+          r.status === 'processing' ? 'running' : (r.status || 'done'),
+          `issue:${r.issue_number}`, r.created_at || new Date().toISOString()
+        );
+      }
+      console.log(`[db] Migrated ${old.length} issue_autofix_processed records to pipeline_runs`);
+    }
+  } catch {}
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      template_id TEXT NOT NULL,
+      provider TEXT NOT NULL,
+      model TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'idle',
+      memory_config TEXT NOT NULL,
+      system_prompt TEXT NOT NULL DEFAULT '',
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS messages (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+      role TEXT NOT NULL,
+      content TEXT NOT NULL,
+      provider TEXT NOT NULL,
+      model TEXT NOT NULL,
+      token_count INTEGER DEFAULT 0,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id, created_at);
+
+    CREATE TABLE IF NOT EXISTS usage (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      provider TEXT NOT NULL,
+      model TEXT NOT NULL,
+      session_id TEXT REFERENCES sessions(id),
+      input_tokens INTEGER NOT NULL DEFAULT 0,
+      output_tokens INTEGER NOT NULL DEFAULT 0,
+      cost REAL NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_usage_provider ON usage(provider, created_at);
+
+    CREATE TABLE IF NOT EXISTS tasks (
+      id TEXT PRIMARY KEY,
+      project_name TEXT NOT NULL,
+      project_path TEXT NOT NULL,
+      prompt TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'queued',
+      priority INTEGER NOT NULL DEFAULT 0,
+      conversation_id TEXT,
+      log TEXT NOT NULL DEFAULT '[]',
+      result_summary TEXT,
+      git_diff TEXT,
+      git_branch TEXT,
+      cost_usd REAL,
+      error TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      started_at TEXT,
+      completed_at TEXT,
+      scheduled_at TEXT,
+      mode TEXT NOT NULL DEFAULT 'prompt',
+      watch_config TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status, created_at);
+
+    -- Cached Claude CLI sessions for tree view
+    CREATE TABLE IF NOT EXISTS cached_sessions (
+      project_name TEXT NOT NULL,
+      session_id TEXT NOT NULL,
+      summary TEXT,
+      first_prompt TEXT,
+      message_count INTEGER DEFAULT 0,
+      entry_count INTEGER DEFAULT 0,
+      created TEXT,
+      modified TEXT,
+      git_branch TEXT,
+      file_size INTEGER DEFAULT 0,
+      last_synced TEXT NOT NULL DEFAULT (datetime('now')),
+      PRIMARY KEY (project_name, session_id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_cached_sessions_project ON cached_sessions(project_name, modified);
+
+    -- In-app notifications
+    CREATE TABLE IF NOT EXISTS notifications (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      type TEXT NOT NULL,
+      title TEXT NOT NULL,
+      body TEXT,
+      read INTEGER NOT NULL DEFAULT 0,
+      task_id TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_notifications_read ON notifications(read, created_at);
+
+    -- Skills registry cache
+    CREATE TABLE IF NOT EXISTS skills (
+      name TEXT PRIMARY KEY,
+      type TEXT NOT NULL DEFAULT 'skill',
+      display_name TEXT NOT NULL,
+      description TEXT,
+      author TEXT,
+      version TEXT,
+      tags TEXT,
+      score INTEGER DEFAULT 0,
+      rating REAL DEFAULT 0,
+      source_url TEXT,
+      archive TEXT,
+      installed_global INTEGER NOT NULL DEFAULT 0,
+      installed_projects TEXT NOT NULL DEFAULT '[]',
+      installed_version TEXT NOT NULL DEFAULT '',
+      synced_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    -- Tab state (projects, docs, etc)
+    CREATE TABLE IF NOT EXISTS tab_state (
+      type TEXT PRIMARY KEY,
+      data TEXT NOT NULL DEFAULT '{}'
+    );
+
+    -- Project pipeline bindings (which workflows are attached to which projects)
+    CREATE TABLE IF NOT EXISTS project_pipelines (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      project_path TEXT NOT NULL,
+      project_name TEXT NOT NULL,
+      workflow_name TEXT NOT NULL,
+      enabled INTEGER NOT NULL DEFAULT 1,
+      config TEXT NOT NULL DEFAULT '{}',
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      UNIQUE(project_path, workflow_name)
+    );
+
+    -- Pipeline execution log (per project, replaces issue_autofix_processed)
+    CREATE TABLE IF NOT EXISTS pipeline_runs (
+      id TEXT PRIMARY KEY,
+      project_path TEXT NOT NULL,
+      workflow_name TEXT NOT NULL,
+      pipeline_id TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'running',
+      summary TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    -- Project favorites
+    CREATE TABLE IF NOT EXISTS project_favorites (
+      project_path TEXT PRIMARY KEY,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    -- Session watchers — monitor sessions and notify via Telegram
+    CREATE TABLE IF NOT EXISTS session_watchers (
+      id TEXT PRIMARY KEY,
+      project_name TEXT NOT NULL,
+      session_id TEXT,
+      label TEXT,
+      check_interval INTEGER NOT NULL DEFAULT 60,
+      last_entry_count INTEGER DEFAULT 0,
+      last_checked TEXT,
+      notify_on_change INTEGER NOT NULL DEFAULT 1,
+      notify_on_idle INTEGER NOT NULL DEFAULT 1,
+      idle_threshold INTEGER NOT NULL DEFAULT 300,
+      active INTEGER NOT NULL DEFAULT 1,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    -- Token usage tracking (per session + day + model for accurate daily breakdown)
+    CREATE TABLE IF NOT EXISTS token_usage (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      source TEXT NOT NULL DEFAULT 'terminal',
+      project_path TEXT NOT NULL,
+      project_name TEXT NOT NULL,
+      model TEXT NOT NULL DEFAULT 'unknown',
+      day TEXT NOT NULL,
+      input_tokens INTEGER NOT NULL DEFAULT 0,
+      output_tokens INTEGER NOT NULL DEFAULT 0,
+      cache_read_tokens INTEGER NOT NULL DEFAULT 0,
+      cache_create_tokens INTEGER NOT NULL DEFAULT 0,
+      cost_usd REAL NOT NULL DEFAULT 0,
+      message_count INTEGER NOT NULL DEFAULT 0,
+      task_id TEXT,
+      UNIQUE(session_id, source, model, day)
+    );
+
+    -- Track scan progress for incremental JSONL scanning
+    CREATE TABLE IF NOT EXISTS usage_scan_state (
+      file_path TEXT PRIMARY KEY,
+      last_size INTEGER NOT NULL DEFAULT 0,
+      last_scan TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+  `);
+}
+
+export function closeDb() {
+  if (db) {
+    db.close();
+    db = null;
+  }
+}

package/.forge/worktrees/pipeline-ecd7cb0f/src/core/memory/strategy.ts

@@ -0,0 +1,32 @@
+import type { Message, MemoryConfig } from '@/src/types';
+
+/**
+ * Apply memory strategy to filter/transform messages before sending to AI.
+ */
+export function getMemoryMessages(messages: Message[], config: MemoryConfig): Message[] {
+  switch (config.strategy) {
+    case 'none':
+      // Only return the last user message
+      return messages.length > 0 ? [messages[messages.length - 1]] : [];
+
+    case 'sliding_window': {
+      const windowSize = config.windowSize || 20;
+      return messages.slice(-windowSize);
+    }
+
+    case 'full':
+      return messages;
+
+    case 'full_with_summary':
+      // TODO: Implement compression — for now, same as full
+      // Future: compress older messages into a summary using summaryModel
+      return messages;
+
+    case 'external':
+      // Only return the last user message; full history is in Obsidian
+      return messages.length > 0 ? [messages[messages.length - 1]] : [];
+
+    default:
+      return messages;
+  }
+}

package/.forge/worktrees/pipeline-ecd7cb0f/src/core/providers/chat.ts

@@ -0,0 +1,65 @@
+import { streamText, generateText, type ModelMessage } from 'ai';
+import { getModel } from '@/src/core/providers/registry';
+import type { ProviderName } from '@/src/types';
+
+export interface ChatOptions {
+  provider: ProviderName;
+  model?: string;
+  systemPrompt?: string;
+  messages: ModelMessage[];
+  onToken?: (token: string) => void;
+}
+
+export interface ChatResult {
+  content: string;
+  inputTokens: number;
+  outputTokens: number;
+  model: string;
+  provider: ProviderName;
+}
+
+export async function chat(options: ChatOptions): Promise<ChatResult> {
+  const model = getModel(options.provider, options.model);
+  const modelId = options.model || (model as any).modelId || options.model || 'unknown';
+
+  const result = await generateText({
+    model,
+    system: options.systemPrompt,
+    messages: options.messages,
+  });
+
+  return {
+    content: result.text,
+    inputTokens: result.usage?.inputTokens ?? 0,
+    outputTokens: result.usage?.outputTokens ?? 0,
+    model: modelId,
+    provider: options.provider,
+  };
+}
+
+export async function chatStream(options: ChatOptions): Promise<ChatResult> {
+  const model = getModel(options.provider, options.model);
+  const modelId = options.model || (model as any).modelId || options.model || 'unknown';
+
+  const result = streamText({
+    model,
+    system: options.systemPrompt,
+    messages: options.messages,
+  });
+
+  let content = '';
+  for await (const chunk of result.textStream) {
+    content += chunk;
+    options.onToken?.(chunk);
+  }
+
+  const usage = await result.usage;
+
+  return {
+    content,
+    inputTokens: usage?.inputTokens ?? 0,
+    outputTokens: usage?.outputTokens ?? 0,
+    model: modelId,
+    provider: options.provider,
+  };
+}

package/.forge/worktrees/pipeline-ecd7cb0f/src/core/providers/registry.ts

@@ -0,0 +1,60 @@
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { createGoogleGenerativeAI } from '@ai-sdk/google';
+import { createOpenAI } from '@ai-sdk/openai';
+import type { LanguageModel } from 'ai';
+import { loadConfig, getProviderApiKey } from '@/src/config';
+import type { ProviderName } from '@/src/types';
+
+const providerInstances = new Map<string, LanguageModel>();
+
+export function getModel(provider: ProviderName, model?: string): LanguageModel {
+  const config = loadConfig();
+  const providerConfig = config.providers[provider];
+  const modelId = model || providerConfig.defaultModel;
+  const cacheKey = `${provider}:${modelId}`;
+
+  const cached = providerInstances.get(cacheKey);
+  if (cached) return cached;
+
+  const apiKey = providerConfig.apiKey || getProviderApiKey(provider);
+  const instance = createModel(provider, modelId, apiKey);
+  providerInstances.set(cacheKey, instance);
+  return instance;
+}
+
+function createModel(provider: ProviderName, modelId: string, apiKey?: string): LanguageModel {
+  switch (provider) {
+    case 'anthropic': {
+      const anthropic = createAnthropic({ apiKey });
+      return anthropic(modelId);
+    }
+    case 'google': {
+      const google = createGoogleGenerativeAI({ apiKey });
+      return google(modelId);
+    }
+    case 'openai': {
+      const openai = createOpenAI({ apiKey });
+      return openai(modelId);
+    }
+    case 'grok': {
+      // Grok uses OpenAI-compatible API
+      const grok = createOpenAI({
+        apiKey,
+        baseURL: 'https://api.x.ai/v1',
+      });
+      return grok(modelId);
+    }
+    default:
+      throw new Error(`Unknown provider: ${provider}`);
+  }
+}
+
+export function listAvailableProviders(): { name: ProviderName; displayName: string; hasKey: boolean; enabled: boolean }[] {
+  const config = loadConfig();
+  return Object.values(config.providers).map(p => ({
+    name: p.name,
+    displayName: p.displayName,
+    hasKey: !!(p.apiKey || getProviderApiKey(p.name)),
+    enabled: p.enabled,
+  }));
+}

package/.forge/worktrees/pipeline-ecd7cb0f/src/core/session/manager.ts

@@ -0,0 +1,190 @@
+import { randomUUID } from 'node:crypto';
+import type { ModelMessage } from 'ai';
+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';
+
+export 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);
+  }
+
+  async sendMessage(
+    sessionId: string,
+    userMessage: string,
+    onToken?: (token: string) => void
+  ): Promise<ChatResult> {
+    const session = this.get(sessionId);
+    if (!session) throw new Error(`Session not found: ${sessionId}`);
+
+    // Save user message
+    this.addMessage(sessionId, 'user', userMessage, session.provider, session.model);
+
+    // Get messages based on memory strategy
+    const allMessages = this.getMessages(sessionId);
+    const memoryMessages = getMemoryMessages(allMessages, session.memory);
+
+    // Convert to ModelMessage format
+    const coreMessages: ModelMessage[] = memoryMessages.map(m => ({
+      role: m.role as 'user' | 'assistant',
+      content: m.content,
+    }));
+
+    this.updateStatus(sessionId, 'running');
+
+    try {
+      const result = await chatStream({
+        provider: session.provider,
+        model: session.model || undefined,
+        systemPrompt: session.systemPrompt,
+        messages: coreMessages,
+        onToken,
+      });
+
+      // Save assistant message
+      this.addMessage(sessionId, 'assistant', result.content, result.provider, result.model);
+
+      // Record usage
+      this.recordUsage(sessionId, result);
+
+      this.updateStatus(sessionId, 'idle');
+      return result;
+    } catch (err) {
+      this.updateStatus(sessionId, 'error');
+      throw err;
+    }
+  }
+
+  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) {
+      // Get last N messages
+      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[];
+  }
+
+  delete(id: string) {
+    this.db.prepare('DELETE FROM sessions WHERE id = ?').run(id);
+  }
+
+  getUsageSummary(): { provider: string; totalInput: number; totalOutput: number; totalCost: number }[] {
+    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 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);
+  }
+
+  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,
+    };
+  }
+}