cognova 0.1.0

package/server/routes/terminal.ts

@@ -0,0 +1,98 @@
+import {
+  getOrCreatePtySession,
+  getOutputBuffer,
+  resizePty,
+  writeToPty,
+  getPtySession
+} from '../utils/pty-manager'
+
+interface TerminalMessage {
+  type: 'input' | 'resize' | 'ping'
+  data?: string
+  cols?: number
+  rows?: number
+}
+
+export default defineWebSocketHandler({
+  open(peer) {
+    const sessionId = 'default' // For now, single session per app
+    const cols = 80
+    const rows = 24
+
+    console.log(`Terminal WebSocket opened: ${peer.id}`)
+
+    try {
+      const { isNew } = getOrCreatePtySession(sessionId, cols, rows)
+
+      // If reconnecting, replay buffer
+      if (!isNew) {
+        const buffer = getOutputBuffer(sessionId)
+        if (buffer.length > 0) {
+          peer.send(JSON.stringify({
+            type: 'output',
+            data: buffer.join('')
+          }))
+        }
+      }
+
+      // Forward PTY output to client
+      const session = getPtySession(sessionId)
+      if (session) {
+        session.pty.onData((data: string) => {
+          try {
+            peer.send(JSON.stringify({
+              type: 'output',
+              data
+            }))
+          } catch {
+            // Client disconnected
+          }
+        })
+      }
+    } catch (error) {
+      console.error('Failed to create PTY session:', error)
+      peer.send(JSON.stringify({
+        type: 'error',
+        data: `Failed to start terminal: ${error instanceof Error ? error.message : 'Unknown error'}\r\n`
+      }))
+    }
+  },
+
+  message(peer, message) {
+    const sessionId = 'default'
+
+    try {
+      const msg = JSON.parse(message.text()) as TerminalMessage
+
+      switch (msg.type) {
+        case 'input':
+          if (msg.data) {
+            writeToPty(sessionId, msg.data)
+          }
+          break
+
+        case 'resize':
+          if (msg.cols && msg.rows) {
+            resizePty(sessionId, msg.cols, msg.rows)
+          }
+          break
+
+        case 'ping':
+          peer.send(JSON.stringify({ type: 'pong' }))
+          break
+      }
+    } catch (e) {
+      console.error('Terminal message error:', e)
+    }
+  },
+
+  close(peer) {
+    console.log(`Terminal WebSocket closed: ${peer.id}`)
+    // Don't destroy session on close - allow reconnection
+    // Session will be cleaned up by timeout in pty-manager
+  },
+
+  error(peer, error) {
+    console.error(`Terminal WebSocket error for ${peer.id}:`, error)
+  }
+})

package/server/services/agent-executor.ts

@@ -0,0 +1,218 @@
+import { query } from '@anthropic-ai/claude-agent-sdk'
+import { eq } from 'drizzle-orm'
+import { getDb } from '../db'
+import * as schema from '../db/schema'
+import { notificationBus } from '../utils/notification-bus'
+import { agentRegistry } from '../utils/agent-registry'
+
+// Custom error for cancellation
+export class AgentCancelledError extends Error {
+  constructor() {
+    super('Agent execution was cancelled')
+    this.name = 'AgentCancelledError'
+  }
+}
+
+export interface AgentConfig {
+  id: string
+  name: string
+  prompt: string
+  maxTurns?: number
+  maxBudgetUsd?: number | null
+}
+
+// Result type matching SDK structure
+interface AgentResult {
+  subtype: string
+  total_cost_usd: number
+  num_turns: number
+  result?: string
+  errors?: string[]
+  usage: {
+    input_tokens: number
+    output_tokens: number
+  }
+}
+
+export async function executeAgent(config: AgentConfig): Promise<void> {
+  const db = getDb()
+  const startTime = Date.now()
+
+  // Create run record
+  const [run] = await db.insert(schema.cronAgentRuns)
+    .values({ agentId: config.id, status: 'running' })
+    .returning()
+
+  const runId = run!.id
+
+  // Register in the agent registry for cancellation support
+  agentRegistry.register(runId, config.id, config.name)
+
+  // Notify: agent started
+  notificationBus.broadcast({
+    type: 'agent:started',
+    agentId: config.id,
+    agentName: config.name,
+    runId
+  })
+
+  try {
+    const result = await runAgentSDK(config, runId)
+    const durationMs = Date.now() - startTime
+
+    // Determine status based on result subtype
+    const status = result.subtype === 'success'
+      ? 'success'
+      : result.subtype === 'error_max_budget_usd'
+        ? 'budget_exceeded'
+        : 'error'
+
+    // Update run record with full metrics
+    await db.update(schema.cronAgentRuns)
+      .set({
+        status,
+        output: result.subtype === 'success' ? result.result : undefined,
+        error: result.subtype !== 'success' ? result.errors?.join('\n') : undefined,
+        costUsd: result.total_cost_usd,
+        inputTokens: result.usage.input_tokens,
+        outputTokens: result.usage.output_tokens,
+        numTurns: result.num_turns,
+        completedAt: new Date(),
+        durationMs
+      })
+      .where(eq(schema.cronAgentRuns.id, run!.id))
+
+    // Update agent last run
+    await db.update(schema.cronAgents)
+      .set({ lastRunAt: new Date(), lastStatus: status })
+      .where(eq(schema.cronAgents.id, config.id))
+
+    console.log(`[agent] ${config.name} completed: ${status} (${durationMs}ms, $${result.total_cost_usd.toFixed(4)})`)
+
+    // Notify: agent completed
+    notificationBus.broadcast({
+      type: 'agent:completed',
+      agentId: config.id,
+      agentName: config.name,
+      runId,
+      status,
+      color: status === 'success' ? 'success' : 'warning'
+    })
+  } catch (error) {
+    const durationMs = Date.now() - startTime
+    const isCancelled = error instanceof AgentCancelledError
+
+    if (isCancelled) {
+      // Handle cancellation
+      await db.update(schema.cronAgentRuns)
+        .set({
+          status: 'cancelled',
+          error: 'Cancelled by user',
+          completedAt: new Date(),
+          durationMs
+        })
+        .where(eq(schema.cronAgentRuns.id, runId))
+
+      await db.update(schema.cronAgents)
+        .set({ lastRunAt: new Date(), lastStatus: 'cancelled' })
+        .where(eq(schema.cronAgents.id, config.id))
+
+      console.log(`[agent] ${config.name} cancelled after ${durationMs}ms`)
+
+      notificationBus.broadcast({
+        type: 'agent:failed',
+        agentId: config.id,
+        agentName: config.name,
+        runId,
+        message: 'Cancelled by user',
+        color: 'warning'
+      })
+    } else {
+      // Handle other errors
+      const errorMessage = error instanceof Error ? error.message : String(error)
+
+      await db.update(schema.cronAgentRuns)
+        .set({
+          status: 'error',
+          error: errorMessage,
+          completedAt: new Date(),
+          durationMs
+        })
+        .where(eq(schema.cronAgentRuns.id, runId))
+
+      await db.update(schema.cronAgents)
+        .set({ lastRunAt: new Date(), lastStatus: 'error' })
+        .where(eq(schema.cronAgents.id, config.id))
+
+      console.error(`[agent] ${config.name} failed:`, errorMessage)
+
+      notificationBus.broadcast({
+        type: 'agent:failed',
+        agentId: config.id,
+        agentName: config.name,
+        runId,
+        message: errorMessage,
+        color: 'error'
+      })
+    }
+  } finally {
+    // Always unregister the agent when done
+    agentRegistry.unregister(runId)
+  }
+}
+
+async function runAgentSDK(config: AgentConfig, runId: string): Promise<AgentResult> {
+  // SDK checks CLAUDE_CODE_OAUTH_TOKEN first (Max subscription),
+  // then falls back to ANTHROPIC_API_KEY (API billing)
+  const conversation = query({
+    prompt: config.prompt,
+    options: {
+      cwd: process.env.VAULT_PATH || process.cwd(),
+      settingSources: ['user', 'project'],
+      permissionMode: 'bypassPermissions',
+      allowDangerouslySkipPermissions: true,
+      maxTurns: config.maxTurns ?? 50,
+      maxBudgetUsd: config.maxBudgetUsd ?? undefined
+    }
+  })
+
+  let resultMessage: AgentResult | undefined
+
+  // Stream through messages and collect output
+  for await (const message of conversation) {
+    // Check for cancellation between messages
+    if (agentRegistry.isCancelled(runId)) {
+      throw new AgentCancelledError()
+    }
+
+    if (message.type === 'result') {
+      // Extract the fields we need from the SDK result
+      // Cast through unknown as SDK types don't expose usage properties correctly
+      const msg = message as unknown as {
+        subtype: string
+        total_cost_usd: number
+        num_turns: number
+        result?: string
+        errors?: string[]
+        usage: { input_tokens: number, output_tokens: number }
+      }
+      resultMessage = {
+        subtype: msg.subtype,
+        total_cost_usd: msg.total_cost_usd,
+        num_turns: msg.num_turns,
+        result: msg.result,
+        errors: msg.errors,
+        usage: {
+          input_tokens: msg.usage.input_tokens,
+          output_tokens: msg.usage.output_tokens
+        }
+      }
+    }
+  }
+
+  if (!resultMessage) {
+    throw new Error('No result message received from SDK')
+  }
+
+  return resultMessage
+}

package/server/services/cron-scheduler.ts

@@ -0,0 +1,78 @@
+import { CronJob } from 'cron'
+import { eq } from 'drizzle-orm'
+import { getDb } from '../db'
+import * as schema from '../db/schema'
+import { executeAgent } from './agent-executor'
+
+// Use globalThis to ensure the same Map instance across Nitro module boundaries
+// This prevents issues where the plugin and API handlers get different module instances
+const JOBS_KEY = '__secondBrain_cronJobs__' as const
+declare global {
+
+  var __secondBrain_cronJobs__: Map<string, CronJob> | undefined
+}
+
+function getJobs(): Map<string, CronJob> {
+  if (!globalThis[JOBS_KEY])
+    globalThis[JOBS_KEY] = new Map<string, CronJob>()
+  return globalThis[JOBS_KEY]
+}
+
+export async function initCronScheduler(): Promise<number> {
+  const db = getDb()
+  const agents = await db.query.cronAgents.findMany({
+    where: eq(schema.cronAgents.enabled, true)
+  })
+
+  for (const agent of agents) {
+    scheduleAgent(agent)
+  }
+
+  return agents.length
+}
+
+export function scheduleAgent(agent: typeof schema.cronAgents.$inferSelect) {
+  unscheduleAgent(agent.id)
+
+  if (!agent.enabled) return
+
+  const jobs = getJobs()
+
+  try {
+    const job = new CronJob(
+      agent.schedule,
+      () => {
+        console.log(`[cron] Triggering agent: ${agent.name}`)
+        executeAgent({
+          id: agent.id,
+          name: agent.name,
+          prompt: agent.prompt,
+          maxTurns: agent.maxTurns ?? 50,
+          maxBudgetUsd: agent.maxBudgetUsd ?? undefined
+        }).catch(err => console.error(`[cron] Agent ${agent.name} error:`, err))
+      },
+      null,
+      true,
+      'UTC'
+    )
+
+    jobs.set(agent.id, job)
+    console.log(`[cron] Scheduled: ${agent.name} (${agent.schedule})`)
+  } catch {
+    console.error(`[cron] Invalid schedule for ${agent.name}: ${agent.schedule}`)
+  }
+}
+
+export function unscheduleAgent(agentId: string) {
+  const jobs = getJobs()
+  const job = jobs.get(agentId)
+  if (job) {
+    job.stop()
+    jobs.delete(agentId)
+    console.log(`[cron] Unscheduled agent: ${agentId}`)
+  }
+}
+
+export function getScheduledAgentIds(): string[] {
+  return Array.from(getJobs().keys())
+}

package/server/services/memory-extractor.ts

@@ -0,0 +1,120 @@
+import { query } from '@anthropic-ai/claude-agent-sdk'
+import type { ExtractedMemory, MemoryChunkType } from '~~/shared/types'
+
+const EXTRACTION_PROMPT = `You are a memory extraction assistant. Analyze this conversation excerpt and extract key memories worth preserving for future reference.
+
+Output ONLY a JSON array with this exact structure (no markdown, no code blocks, no explanation):
+[{"type": "decision|fact|solution|pattern|preference", "content": "concise statement", "relevance": 0.0-1.0}]
+
+Memory types:
+- decision: Choices made about implementation, architecture, or approach
+- fact: Important information about the codebase, APIs, or constraints
+- solution: How a problem was solved or a bug was fixed
+- pattern: Recurring patterns or conventions identified
+- preference: User preferences for code style, tools, or workflows
+
+Rules:
+- Only extract genuinely useful information
+- Skip routine acknowledgments ("I'll do that", "Sure", "Let me...")
+- Skip obvious facts already in code, debugging steps, greetings
+- Content max 100 characters
+- relevance: 1.0 = highly important, 0.5 = moderately useful, 0.1 = minor detail
+- If nothing worth extracting, return []
+
+Conversation to analyze:
+`
+
+export async function extractMemories(transcript: string): Promise<ExtractedMemory[]> {
+  if (!transcript || transcript.trim().length < 50)
+    return []
+
+  try {
+    // Use Agent SDK which checks CLAUDE_CODE_OAUTH_TOKEN first (Max subscription),
+    // then falls back to ANTHROPIC_API_KEY (API billing)
+    const conversation = query({
+      prompt: `${EXTRACTION_PROMPT}\n\n${transcript.slice(0, 8000)}`,
+      options: {
+        maxTurns: 1, // Single turn extraction
+        permissionMode: 'bypassPermissions',
+        allowDangerouslySkipPermissions: true
+      }
+    })
+
+    let result = ''
+
+    // Stream through messages and get the result
+    for await (const message of conversation) {
+      if (message.type === 'result') {
+        const msg = message as unknown as {
+          subtype: string
+          result?: string
+        }
+        if (msg.subtype === 'success' && msg.result)
+          result = msg.result
+      }
+    }
+
+    if (!result)
+      return []
+
+    // Extract JSON array from result (may have surrounding text)
+    const jsonMatch = result.match(/\[[\s\S]*\]/)
+    if (!jsonMatch)
+      return []
+
+    const memories = JSON.parse(jsonMatch[0]) as Array<{
+      type: string
+      content: string
+      relevance: number
+    }>
+
+    return memories
+      .filter(m => isValidMemoryType(m.type) && m.content && typeof m.relevance === 'number')
+      .map(m => ({
+        type: m.type as MemoryChunkType,
+        content: m.content.slice(0, 200),
+        relevance: Math.max(0, Math.min(1, m.relevance))
+      }))
+  } catch (error) {
+    console.error('[memory-extractor] Failed to extract memories:', error)
+    return []
+  }
+}
+
+function isValidMemoryType(type: string): type is MemoryChunkType {
+  return ['decision', 'fact', 'solution', 'pattern', 'preference', 'summary'].includes(type)
+}
+
+export async function extractMemoriesFromTranscriptFile(transcriptPath: string): Promise<ExtractedMemory[]> {
+  const fs = await import('node:fs/promises')
+
+  try {
+    const content = await fs.readFile(transcriptPath, 'utf-8')
+    const lines = content.trim().split('\n')
+
+    // Parse JSONL and extract recent messages
+    const messages: Array<{ role: string, content: string }> = []
+    for (const line of lines.slice(-20)) {
+      try {
+        const entry = JSON.parse(line)
+        if (entry.role && entry.content)
+          messages.push({ role: entry.role, content: entry.content })
+      } catch {
+        // Skip invalid lines
+      }
+    }
+
+    if (messages.length === 0)
+      return []
+
+    // Format for extraction
+    const formatted = messages
+      .map(m => `${m.role.toUpperCase()}: ${m.content.slice(0, 1000)}`)
+      .join('\n\n')
+
+    return extractMemories(formatted)
+  } catch (error) {
+    console.error('[memory-extractor] Failed to read transcript:', error)
+    return []
+  }
+}

package/server/utils/agent-cleanup.ts

@@ -0,0 +1,91 @@
+import { eq, and, isNull } from 'drizzle-orm'
+import { getDb, schema } from '../db'
+
+/**
+ * Cleans up orphaned agent runs on server startup.
+ *
+ * Scenarios handled:
+ * 1. Runs with status='running' - server shutdown mid-execution
+ * 2. Terminal runs (success/error/budget_exceeded) missing completedAt timestamp
+ */
+export async function cleanupOrphanedRuns(): Promise<{ cancelled: number, fixed: number }> {
+  const db = getDb()
+
+  let cancelled = 0
+  let fixed = 0
+
+  // 1. Cancel all currently 'running' runs (server must have shut down mid-run)
+  const runningRuns = await db
+    .update(schema.cronAgentRuns)
+    .set({
+      status: 'cancelled',
+      error: 'Server shutdown during execution',
+      completedAt: new Date(),
+      durationMs: null // We don't know the actual duration
+    })
+    .where(eq(schema.cronAgentRuns.status, 'running'))
+    .returning({ id: schema.cronAgentRuns.id, agentId: schema.cronAgentRuns.agentId })
+
+  cancelled = runningRuns.length
+
+  // 2. For each cancelled run, update the agent's lastStatus if this was their latest run
+  for (const run of runningRuns) {
+    // Check if this was the agent's most recent run
+    const latestRun = await db.query.cronAgentRuns.findFirst({
+      where: eq(schema.cronAgentRuns.agentId, run.agentId),
+      orderBy: (runs, { desc }) => [desc(runs.startedAt)]
+    })
+
+    if (latestRun && latestRun.id === run.id) {
+      await db
+        .update(schema.cronAgents)
+        .set({ lastStatus: 'cancelled' })
+        .where(eq(schema.cronAgents.id, run.agentId))
+    }
+  }
+
+  // 3. Fix terminal runs missing completedAt timestamp
+  const fixedRuns = await db
+    .update(schema.cronAgentRuns)
+    .set({
+      completedAt: new Date()
+    })
+    .where(
+      and(
+        // Terminal statuses that should have completedAt
+        eq(schema.cronAgentRuns.status, 'success'),
+        isNull(schema.cronAgentRuns.completedAt)
+      )
+    )
+    .returning({ id: schema.cronAgentRuns.id })
+
+  const fixedErrorRuns = await db
+    .update(schema.cronAgentRuns)
+    .set({
+      completedAt: new Date()
+    })
+    .where(
+      and(
+        eq(schema.cronAgentRuns.status, 'error'),
+        isNull(schema.cronAgentRuns.completedAt)
+      )
+    )
+    .returning({ id: schema.cronAgentRuns.id })
+
+  const fixedBudgetRuns = await db
+    .update(schema.cronAgentRuns)
+    .set({
+      completedAt: new Date()
+    })
+    .where(
+      and(
+        eq(schema.cronAgentRuns.status, 'budget_exceeded'),
+        isNull(schema.cronAgentRuns.completedAt)
+      )
+    )
+    .returning({ id: schema.cronAgentRuns.id })
+
+  fixed = fixedRuns.length + fixedErrorRuns.length + fixedBudgetRuns.length
+
+  return { cancelled, fixed }
+}

package/server/utils/agent-registry.ts

@@ -0,0 +1,95 @@
+/**
+ * Registry for tracking running agent executions.
+ * Allows cancellation of in-progress agent runs.
+ */
+
+interface RunningAgent {
+  agentId: string
+  runId: string
+  agentName: string
+  startedAt: Date
+  cancelled: boolean
+}
+
+class AgentRegistry {
+  private runningAgents = new Map<string, RunningAgent>()
+
+  /**
+   * Register a new running agent
+   */
+  register(runId: string, agentId: string, agentName: string): void {
+    this.runningAgents.set(runId, {
+      agentId,
+      runId,
+      agentName,
+      startedAt: new Date(),
+      cancelled: false
+    })
+  }
+
+  /**
+   * Unregister a completed/cancelled agent
+   */
+  unregister(runId: string): void {
+    this.runningAgents.delete(runId)
+  }
+
+  /**
+   * Check if a specific run is cancelled
+   */
+  isCancelled(runId: string): boolean {
+    return this.runningAgents.get(runId)?.cancelled ?? false
+  }
+
+  /**
+   * Cancel a running agent by run ID
+   * Returns true if the agent was found and cancelled
+   */
+  cancelByRunId(runId: string): boolean {
+    const agent = this.runningAgents.get(runId)
+    if (agent && !agent.cancelled) {
+      agent.cancelled = true
+      return true
+    }
+    return false
+  }
+
+  /**
+   * Cancel all running agents for a specific agent ID
+   * Returns the number of runs cancelled
+   */
+  cancelByAgentId(agentId: string): number {
+    let cancelled = 0
+    for (const agent of this.runningAgents.values()) {
+      if (agent.agentId === agentId && !agent.cancelled) {
+        agent.cancelled = true
+        cancelled++
+      }
+    }
+    return cancelled
+  }
+
+  /**
+   * Get all running agents
+   */
+  getRunning(): RunningAgent[] {
+    return Array.from(this.runningAgents.values()).filter(a => !a.cancelled)
+  }
+
+  /**
+   * Get running agent IDs
+   */
+  getRunningAgentIds(): string[] {
+    return [...new Set(this.getRunning().map(a => a.agentId))]
+  }
+
+  /**
+   * Check if an agent has any running executions
+   */
+  isAgentRunning(agentId: string): boolean {
+    return this.getRunning().some(a => a.agentId === agentId)
+  }
+}
+
+// Singleton instance
+export const agentRegistry = new AgentRegistry()