@aion0/forge 0.1.0

package/src/core/db/database.ts

@@ -0,0 +1,133 @@
+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
+  try { db.exec('ALTER TABLE tasks ADD COLUMN scheduled_at TEXT'); } catch {}
+  try { db.exec('ALTER TABLE tasks ADD COLUMN mode TEXT NOT NULL DEFAULT \'prompt\''); } catch {}
+  try { db.exec('ALTER TABLE tasks ADD COLUMN watch_config TEXT'); } 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);
+
+    -- 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'))
+    );
+  `);
+}
+
+export function closeDb() {
+  if (db) {
+    db.close();
+    db = null;
+  }
+}

package/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/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/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/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,
+    };
+  }
+}

package/src/types/index.ts

@@ -0,0 +1,128 @@
+export type MemoryStrategy = 'none' | 'sliding_window' | 'full' | 'full_with_summary' | 'external';
+
+export type SessionStatus = 'running' | 'idle' | 'paused' | 'archived' | 'error';
+
+export type ProviderName = 'anthropic' | 'google' | 'openai' | 'grok';
+
+export interface ProviderConfig {
+  name: ProviderName;
+  displayName: string;
+  apiKey?: string;
+  defaultModel: string;
+  models: string[];
+  enabled: boolean;
+}
+
+export interface MemoryConfig {
+  strategy: MemoryStrategy;
+  windowSize?: number;       // for sliding_window
+  compressAfter?: number;    // for full — compress after N messages
+  summaryModel?: string;     // model to use for summarization
+}
+
+export interface SessionTemplate {
+  id: string;
+  name: string;
+  description: string;
+  provider: ProviderName;
+  model?: string;
+  fallbackProvider?: ProviderName;
+  memory: MemoryConfig;
+  systemPrompt: string;
+  context?: {
+    files?: string[];
+  };
+  commands?: Record<string, { description: string; action: string; prompt?: string }>;
+  ui?: {
+    icon?: string;
+    color?: string;
+    pinned?: boolean;
+  };
+}
+
+export interface Message {
+  id: number;
+  sessionId: string;
+  role: 'user' | 'assistant' | 'system';
+  content: string;
+  provider: ProviderName;
+  model: string;
+  tokenCount?: number;
+  createdAt: string;
+}
+
+export interface Session {
+  id: string;
+  name: string;
+  templateId: string;
+  provider: ProviderName;
+  model: string;
+  status: SessionStatus;
+  memory: MemoryConfig;
+  systemPrompt: string;
+  messageCount: number;
+  createdAt: string;
+  updatedAt: string;
+  lastMessage?: string;
+}
+
+export interface UsageRecord {
+  provider: ProviderName;
+  model: string;
+  inputTokens: number;
+  outputTokens: number;
+  cost: number;
+  date: string;
+}
+
+export type TaskStatus = 'queued' | 'running' | 'done' | 'failed' | 'cancelled';
+export type TaskMode = 'prompt' | 'monitor';
+
+export interface WatchConfig {
+  condition: 'change' | 'idle' | 'complete' | 'error' | 'keyword';
+  keyword?: string;          // for 'keyword' condition
+  idleMinutes?: number;      // for 'idle' condition (default 10)
+  action: 'notify' | 'message' | 'task';
+  actionPrompt?: string;     // message to send or task prompt
+  actionProject?: string;    // for 'task' action
+  repeat?: boolean;          // keep watching after trigger (default false)
+}
+
+export interface Task {
+  id: string;
+  projectName: string;
+  projectPath: string;
+  prompt: string;
+  mode: TaskMode;
+  status: TaskStatus;
+  priority: number;
+  conversationId?: string;
+  watchConfig?: WatchConfig;
+  log: TaskLogEntry[];
+  resultSummary?: string;
+  gitDiff?: string;
+  gitBranch?: string;
+  costUSD?: number;
+  error?: string;
+  createdAt: string;
+  startedAt?: string;
+  completedAt?: string;
+  scheduledAt?: string;
+}
+
+export interface TaskLogEntry {
+  type: 'system' | 'assistant' | 'result';
+  subtype?: string;
+  content: string;
+  tool?: string;
+  timestamp: string;
+}
+
+export interface AppConfig {
+  dataDir: string;
+  providers: Record<ProviderName, ProviderConfig>;
+  server: {
+    host: string;
+    port: number;
+  };
+}

package/tsconfig.json

@@ -0,0 +1,41 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": [
+        "./*"
+      ]
+    }
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}