loopwork 0.3.0 → 0.3.1

package/src/plugins/cost-tracking.ts

@@ -1,402 +0,0 @@
-/**
- * Cost Tracking for Loopwork
- *
- * Tracks token usage and costs for AI CLI tools (Claude, OpenCode, Gemini)
- */
-
-import fs from 'fs'
-import path from 'path'
-import type { LoopworkPlugin, PluginTask, LoopStats } from '../contracts'
-
-// ============================================================================
-// Token Pricing (per 1M tokens, in USD)
-// ============================================================================
-
-export interface ModelPricing {
-  inputPer1M: number
-  outputPer1M: number
-  cacheReadPer1M?: number
-  cacheWritePer1M?: number
-}
-
-export const MODEL_PRICING: Record<string, ModelPricing> = {
-  // Claude models
-  'claude-3-opus': { inputPer1M: 15.00, outputPer1M: 75.00 },
-  'claude-3-sonnet': { inputPer1M: 3.00, outputPer1M: 15.00 },
-  'claude-3-haiku': { inputPer1M: 0.25, outputPer1M: 1.25 },
-  'claude-3.5-sonnet': { inputPer1M: 3.00, outputPer1M: 15.00 },
-  'claude-3.5-haiku': { inputPer1M: 0.80, outputPer1M: 4.00 },
-  'claude-opus-4': { inputPer1M: 15.00, outputPer1M: 75.00 },
-  'claude-sonnet-4': { inputPer1M: 3.00, outputPer1M: 15.00 },
-
-  // OpenAI models (for opencode)
-  'gpt-4': { inputPer1M: 30.00, outputPer1M: 60.00 },
-  'gpt-4-turbo': { inputPer1M: 10.00, outputPer1M: 30.00 },
-  'gpt-4o': { inputPer1M: 2.50, outputPer1M: 10.00 },
-  'gpt-4o-mini': { inputPer1M: 0.15, outputPer1M: 0.60 },
-  'o1': { inputPer1M: 15.00, outputPer1M: 60.00 },
-  'o1-mini': { inputPer1M: 3.00, outputPer1M: 12.00 },
-
-  // Google models (for gemini)
-  'gemini-1.5-pro': { inputPer1M: 1.25, outputPer1M: 5.00 },
-  'gemini-1.5-flash': { inputPer1M: 0.075, outputPer1M: 0.30 },
-  'gemini-2.0-flash': { inputPer1M: 0.10, outputPer1M: 0.40 },
-
-  // Default fallback
-  'default': { inputPer1M: 3.00, outputPer1M: 15.00 },
-}
-
-// ============================================================================
-// Usage Types
-// ============================================================================
-
-export interface TokenUsage {
-  inputTokens: number
-  outputTokens: number
-  cacheReadTokens?: number
-  cacheWriteTokens?: number
-}
-
-export interface UsageEntry {
-  taskId: string
-  model: string
-  usage: TokenUsage
-  cost: number
-  timestamp: Date
-  duration?: number // in seconds
-}
-
-export interface UsageSummary {
-  totalInputTokens: number
-  totalOutputTokens: number
-  totalCacheReadTokens: number
-  totalCacheWriteTokens: number
-  totalCost: number
-  taskCount: number
-  entries: UsageEntry[]
-}
-
-export interface DailySummary extends UsageSummary {
-  date: string // YYYY-MM-DD
-}
-
-// ============================================================================
-// Cost Tracker
-// ============================================================================
-
-export class CostTracker {
-  private entries: UsageEntry[] = []
-  private storageFile: string
-  private namespace: string
-
-  constructor(projectRoot: string, namespace = 'default') {
-    this.namespace = namespace
-    const suffix = namespace === 'default' ? '' : `-${namespace}`
-    this.storageFile = path.join(projectRoot, `.loopwork-cost-tracking${suffix}.json`)
-    this.load()
-  }
-
-  /**
-   * Calculate cost for token usage
-   */
-  calculateCost(model: string, usage: TokenUsage): number {
-    const pricing = MODEL_PRICING[model] || MODEL_PRICING['default']
-
-    let cost = 0
-    cost += (usage.inputTokens / 1_000_000) * pricing.inputPer1M
-    cost += (usage.outputTokens / 1_000_000) * pricing.outputPer1M
-
-    if (usage.cacheReadTokens && pricing.cacheReadPer1M) {
-      cost += (usage.cacheReadTokens / 1_000_000) * pricing.cacheReadPer1M
-    }
-    if (usage.cacheWriteTokens && pricing.cacheWritePer1M) {
-      cost += (usage.cacheWriteTokens / 1_000_000) * pricing.cacheWritePer1M
-    }
-
-    return cost
-  }
-
-  /**
-   * Record token usage for a task
-   */
-  record(taskId: string, model: string, usage: TokenUsage, duration?: number): UsageEntry {
-    const cost = this.calculateCost(model, usage)
-
-    const entry: UsageEntry = {
-      taskId,
-      model,
-      usage,
-      cost,
-      timestamp: new Date(),
-      duration,
-    }
-
-    this.entries.push(entry)
-    this.save()
-
-    return entry
-  }
-
-  /**
-   * Parse token usage from CLI output
-   * Supports various CLI output formats
-   */
-  parseUsageFromOutput(output: string): TokenUsage | null {
-    // Claude Code format: "Tokens: 1234 input, 567 output"
-    const claudeMatch = output.match(/Tokens:\s*(\d+)\s*input,\s*(\d+)\s*output/i)
-    if (claudeMatch) {
-      return {
-        inputTokens: parseInt(claudeMatch[1], 10),
-        outputTokens: parseInt(claudeMatch[2], 10),
-      }
-    }
-
-    // OpenCode format: "Usage: 1234 prompt tokens, 567 completion tokens"
-    const openCodeMatch = output.match(/Usage:\s*(\d+)\s*prompt\s*tokens?,\s*(\d+)\s*completion\s*tokens?/i)
-    if (openCodeMatch) {
-      return {
-        inputTokens: parseInt(openCodeMatch[1], 10),
-        outputTokens: parseInt(openCodeMatch[2], 10),
-      }
-    }
-
-    // Generic format: "input_tokens: 1234, output_tokens: 567"
-    const genericMatch = output.match(/input[_\s]tokens?:\s*(\d+).*output[_\s]tokens?:\s*(\d+)/i)
-    if (genericMatch) {
-      return {
-        inputTokens: parseInt(genericMatch[1], 10),
-        outputTokens: parseInt(genericMatch[2], 10),
-      }
-    }
-
-    // JSON format in output
-    const jsonMatch = output.match(/\{[^}]*"input[_\s]?tokens?":\s*(\d+)[^}]*"output[_\s]?tokens?":\s*(\d+)[^}]*\}/i)
-    if (jsonMatch) {
-      return {
-        inputTokens: parseInt(jsonMatch[1], 10),
-        outputTokens: parseInt(jsonMatch[2], 10),
-      }
-    }
-
-    return null
-  }
-
-  /**
-   * Get summary for a specific task
-   */
-  getTaskSummary(taskId: string): UsageSummary {
-    const taskEntries = this.entries.filter(e => e.taskId === taskId)
-    return this.summarize(taskEntries)
-  }
-
-  /**
-   * Get summary for today
-   */
-  getTodaySummary(): DailySummary {
-    const today = new Date().toISOString().split('T')[0]
-    const todayEntries = this.entries.filter(e =>
-      e.timestamp.toISOString().split('T')[0] === today
-    )
-
-    return {
-      date: today,
-      ...this.summarize(todayEntries),
-    }
-  }
-
-  /**
-   * Get summary for a date range
-   */
-  getRangeSummary(startDate: Date, endDate: Date): UsageSummary {
-    const rangeEntries = this.entries.filter(e =>
-      e.timestamp >= startDate && e.timestamp <= endDate
-    )
-    return this.summarize(rangeEntries)
-  }
-
-  /**
-   * Get all-time summary
-   */
-  getAllTimeSummary(): UsageSummary {
-    return this.summarize(this.entries)
-  }
-
-  /**
-   * Get daily summaries for the last N days
-   */
-  getDailySummaries(days = 7): DailySummary[] {
-    const summaries: DailySummary[] = []
-
-    for (let i = 0; i < days; i++) {
-      const date = new Date()
-      date.setDate(date.getDate() - i)
-      const dateStr = date.toISOString().split('T')[0]
-
-      const dayEntries = this.entries.filter(e =>
-        e.timestamp.toISOString().split('T')[0] === dateStr
-      )
-
-      summaries.push({
-        date: dateStr,
-        ...this.summarize(dayEntries),
-      })
-    }
-
-    return summaries
-  }
-
-  /**
-   * Get cost breakdown by model
-   */
-  getCostByModel(): Record<string, { cost: number; tokens: TokenUsage }> {
-    const byModel: Record<string, { cost: number; tokens: TokenUsage }> = {}
-
-    for (const entry of this.entries) {
-      if (!byModel[entry.model]) {
-        byModel[entry.model] = {
-          cost: 0,
-          tokens: { inputTokens: 0, outputTokens: 0 },
-        }
-      }
-
-      byModel[entry.model].cost += entry.cost
-      byModel[entry.model].tokens.inputTokens += entry.usage.inputTokens
-      byModel[entry.model].tokens.outputTokens += entry.usage.outputTokens
-    }
-
-    return byModel
-  }
-
-  /**
-   * Clear all entries
-   */
-  clear(): void {
-    this.entries = []
-    this.save()
-  }
-
-  private summarize(entries: UsageEntry[]): UsageSummary {
-    return entries.reduce(
-      (acc, entry) => ({
-        totalInputTokens: acc.totalInputTokens + entry.usage.inputTokens,
-        totalOutputTokens: acc.totalOutputTokens + entry.usage.outputTokens,
-        totalCacheReadTokens: acc.totalCacheReadTokens + (entry.usage.cacheReadTokens || 0),
-        totalCacheWriteTokens: acc.totalCacheWriteTokens + (entry.usage.cacheWriteTokens || 0),
-        totalCost: acc.totalCost + entry.cost,
-        taskCount: acc.taskCount + 1,
-        entries: [...acc.entries, entry],
-      }),
-      {
-        totalInputTokens: 0,
-        totalOutputTokens: 0,
-        totalCacheReadTokens: 0,
-        totalCacheWriteTokens: 0,
-        totalCost: 0,
-        taskCount: 0,
-        entries: [] as UsageEntry[],
-      }
-    )
-  }
-
-  private load(): void {
-    try {
-      if (fs.existsSync(this.storageFile)) {
-        const content = fs.readFileSync(this.storageFile, 'utf-8')
-        const data = JSON.parse(content)
-        this.entries = data.entries.map((e: any) => ({
-          ...e,
-          timestamp: new Date(e.timestamp),
-        }))
-      }
-    } catch {
-      this.entries = []
-    }
-  }
-
-  private save(): void {
-    try {
-      const data = { entries: this.entries, namespace: this.namespace }
-      fs.writeFileSync(this.storageFile, JSON.stringify(data, null, 2))
-    } catch {
-      // Ignore save errors
-    }
-  }
-}
-
-// ============================================================================
-// Cost Tracking Hook Plugin
-// ============================================================================
-
-export function createCostTrackingPlugin(
-  projectRoot: string,
-  namespace = 'default',
-  defaultModel = 'claude-3.5-sonnet'
-): LoopworkPlugin {
-  const tracker = new CostTracker(projectRoot, namespace)
-
-  return {
-    name: 'cost-tracking',
-
-    async onTaskStart(task: PluginTask) {
-      // Track task start time (stored in tracker)
-    },
-
-    async onTaskComplete(task: PluginTask, result: { output?: string; duration: number }) {
-      const output = (result as any).output || ''
-      const usage = tracker.parseUsageFromOutput(output)
-
-      if (usage) {
-        tracker.record(task.id, defaultModel, usage, result.duration)
-      }
-    },
-
-    async onLoopEnd(stats: LoopStats) {
-      const summary = tracker.getTodaySummary()
-      console.log(`\n📊 Cost Summary for today:`)
-      console.log(`   Tasks: ${summary.taskCount}`)
-      console.log(`   Tokens: ${summary.totalInputTokens.toLocaleString()} in / ${summary.totalOutputTokens.toLocaleString()} out`)
-      console.log(`   Cost: $${summary.totalCost.toFixed(4)}`)
-    },
-  }
-}
-
-// ============================================================================
-// Formatting Helpers
-// ============================================================================
-
-export function formatCost(cost: number): string {
-  if (cost < 0.01) {
-    return `$${cost.toFixed(4)}`
-  } else if (cost < 1) {
-    return `$${cost.toFixed(3)}`
-  } else {
-    return `$${cost.toFixed(2)}`
-  }
-}
-
-export function formatTokens(tokens: number): string {
-  if (tokens >= 1_000_000) {
-    return `${(tokens / 1_000_000).toFixed(2)}M`
-  } else if (tokens >= 1_000) {
-    return `${(tokens / 1_000).toFixed(1)}K`
-  }
-  return tokens.toString()
-}
-
-export function formatUsageSummary(summary: UsageSummary): string {
-  const lines = [
-    `Tasks: ${summary.taskCount}`,
-    `Input tokens: ${formatTokens(summary.totalInputTokens)}`,
-    `Output tokens: ${formatTokens(summary.totalOutputTokens)}`,
-    `Total cost: ${formatCost(summary.totalCost)}`,
-  ]
-
-  if (summary.totalCacheReadTokens > 0) {
-    lines.push(`Cache read: ${formatTokens(summary.totalCacheReadTokens)}`)
-  }
-  if (summary.totalCacheWriteTokens > 0) {
-    lines.push(`Cache write: ${formatTokens(summary.totalCacheWriteTokens)}`)
-  }
-
-  return lines.join('\n')
-}

package/src/plugins/discord.ts

@@ -1,269 +0,0 @@
-/**
- * Discord Plugin for Loopwork
- *
- * Sends notifications to Discord channels via webhooks.
- *
- * Setup:
- * 1. Create a webhook in Discord: Server Settings > Integrations > Webhooks
- * 2. Copy the webhook URL
- * 3. Set DISCORD_WEBHOOK_URL env var
- */
-
-import type { LoopworkPlugin, PluginTask } from '../contracts'
-
-export interface DiscordConfig {
-  webhookUrl?: string
-  /** Username to display for bot messages */
-  username?: string
-  /** Avatar URL for bot messages */
-  avatarUrl?: string
-  /** Send notification when task starts */
-  notifyOnStart?: boolean
-  /** Send notification when task completes */
-  notifyOnComplete?: boolean
-  /** Send notification when task fails */
-  notifyOnFail?: boolean
-  /** Send summary when loop ends */
-  notifyOnLoopEnd?: boolean
-  /** Mention role/user on failures (e.g., "<@&123456>" for role, "<@123456>" for user) */
-  mentionOnFail?: string
-}
-
-interface DiscordEmbed {
-  title?: string
-  description?: string
-  color?: number
-  fields?: Array<{ name: string; value: string; inline?: boolean }>
-  timestamp?: string
-  footer?: { text: string }
-}
-
-interface DiscordWebhookPayload {
-  content?: string
-  username?: string
-  avatar_url?: string
-  embeds?: DiscordEmbed[]
-}
-
-// Discord embed colors
-const COLORS = {
-  blue: 0x3498db,    // info/start
-  green: 0x2ecc71,   // success
-  red: 0xe74c3c,     // error
-  yellow: 0xf1c40f,  // warning
-  purple: 0x9b59b6,  // summary
-}
-
-export class DiscordClient {
-  private webhookUrl: string
-  private username?: string
-  private avatarUrl?: string
-
-  constructor(webhookUrl: string, options?: { username?: string; avatarUrl?: string }) {
-    this.webhookUrl = webhookUrl
-    this.username = options?.username
-    this.avatarUrl = options?.avatarUrl
-  }
-
-  /**
-   * Send a message to Discord
-   */
-  async send(payload: DiscordWebhookPayload): Promise<void> {
-    const body: DiscordWebhookPayload = {
-      ...payload,
-      username: payload.username || this.username,
-      avatar_url: payload.avatar_url || this.avatarUrl,
-    }
-
-    const response = await fetch(this.webhookUrl, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(body),
-    })
-
-    if (!response.ok) {
-      const error = await response.text()
-      throw new Error(`Discord webhook error: ${response.status} - ${error}`)
-    }
-  }
-
-  /**
-   * Send a simple text message
-   */
-  async sendText(content: string): Promise<void> {
-    await this.send({ content })
-  }
-
-  /**
-   * Send an embed message
-   */
-  async sendEmbed(embed: DiscordEmbed): Promise<void> {
-    await this.send({ embeds: [embed] })
-  }
-
-  /**
-   * Send task started notification
-   */
-  async notifyTaskStart(task: PluginTask): Promise<void> {
-    await this.sendEmbed({
-      title: `🔄 Task Started`,
-      description: `**${task.id}**: ${task.title}`,
-      color: COLORS.blue,
-      timestamp: new Date().toISOString(),
-    })
-  }
-
-  /**
-   * Send task completed notification
-   */
-  async notifyTaskComplete(task: PluginTask, duration: number): Promise<void> {
-    await this.sendEmbed({
-      title: `✅ Task Completed`,
-      description: `**${task.id}**: ${task.title}`,
-      color: COLORS.green,
-      fields: [
-        { name: 'Duration', value: formatDuration(duration), inline: true },
-      ],
-      timestamp: new Date().toISOString(),
-    })
-  }
-
-  /**
-   * Send task failed notification
-   */
-  async notifyTaskFailed(task: PluginTask, error: string, mention?: string): Promise<void> {
-    await this.send({
-      content: mention ? `${mention} Task failed!` : undefined,
-      embeds: [{
-        title: `❌ Task Failed`,
-        description: `**${task.id}**: ${task.title}`,
-        color: COLORS.red,
-        fields: [
-          { name: 'Error', value: error.slice(0, 1000) },
-        ],
-        timestamp: new Date().toISOString(),
-      }],
-    })
-  }
-
-  /**
-   * Send loop summary notification
-   */
-  async notifyLoopEnd(stats: { completed: number; failed: number; duration: number }): Promise<void> {
-    const color = stats.failed > 0 ? COLORS.yellow : COLORS.green
-    await this.sendEmbed({
-      title: `📊 Loop Summary`,
-      color,
-      fields: [
-        { name: 'Completed', value: `${stats.completed}`, inline: true },
-        { name: 'Failed', value: `${stats.failed}`, inline: true },
-        { name: 'Duration', value: formatDuration(stats.duration), inline: true },
-      ],
-      timestamp: new Date().toISOString(),
-    })
-  }
-}
-
-/**
- * Format seconds to human readable duration
- */
-function formatDuration(seconds: number): string {
-  if (seconds < 60) return `${Math.round(seconds)}s`
-  const mins = Math.floor(seconds / 60)
-  const secs = Math.round(seconds % 60)
-  if (mins < 60) return `${mins}m ${secs}s`
-  const hours = Math.floor(mins / 60)
-  const remainMins = mins % 60
-  return `${hours}h ${remainMins}m`
-}
-
-/**
- * Create Discord plugin wrapper
- */
-export function withDiscord(config: DiscordConfig = {}) {
-  const webhookUrl = config.webhookUrl || process.env.DISCORD_WEBHOOK_URL
-
-  return (baseConfig: any) => ({
-    ...baseConfig,
-    discord: {
-      webhookUrl,
-      username: config.username || 'Loopwork',
-      avatarUrl: config.avatarUrl,
-      notifyOnStart: config.notifyOnStart ?? false,
-      notifyOnComplete: config.notifyOnComplete ?? true,
-      notifyOnFail: config.notifyOnFail ?? true,
-      notifyOnLoopEnd: config.notifyOnLoopEnd ?? true,
-      mentionOnFail: config.mentionOnFail,
-    },
-  })
-}
-
-/**
- * Create Discord hook plugin
- */
-export function createDiscordPlugin(config: DiscordConfig = {}): LoopworkPlugin {
-  const webhookUrl = config.webhookUrl || process.env.DISCORD_WEBHOOK_URL || ''
-  const notifyOnStart = config.notifyOnStart ?? false
-  const notifyOnComplete = config.notifyOnComplete ?? true
-  const notifyOnFail = config.notifyOnFail ?? true
-  const notifyOnLoopEnd = config.notifyOnLoopEnd ?? true
-
-  if (!webhookUrl) {
-    return {
-      name: 'discord',
-      onConfigLoad: (cfg) => {
-        console.warn('Discord plugin: Missing DISCORD_WEBHOOK_URL')
-        return cfg
-      },
-    }
-  }
-
-  const client = new DiscordClient(webhookUrl, {
-    username: config.username || 'Loopwork',
-    avatarUrl: config.avatarUrl,
-  })
-
-  return {
-    name: 'discord',
-
-    async onTaskStart(task) {
-      if (!notifyOnStart) return
-
-      try {
-        await client.notifyTaskStart(task)
-      } catch (e: any) {
-        console.warn(`Discord: Failed to send notification: ${e.message}`)
-      }
-    },
-
-    async onTaskComplete(task, result) {
-      if (!notifyOnComplete) return
-
-      try {
-        await client.notifyTaskComplete(task, result.duration)
-      } catch (e: any) {
-        console.warn(`Discord: Failed to send notification: ${e.message}`)
-      }
-    },
-
-    async onTaskFailed(task, error) {
-      if (!notifyOnFail) return
-
-      try {
-        await client.notifyTaskFailed(task, error, config.mentionOnFail)
-      } catch (e: any) {
-        console.warn(`Discord: Failed to send notification: ${e.message}`)
-      }
-    },
-
-    async onLoopEnd(stats) {
-      if (!notifyOnLoopEnd) return
-
-      try {
-        await client.notifyLoopEnd(stats)
-      } catch (e: any) {
-        console.warn(`Discord: Failed to send notification: ${e.message}`)
-      }
-    },
-  }
-}