@vikasitai/vikasit-code 2.0.4 → 2.0.6

package/src/cost/index.ts

@@ -0,0 +1,173 @@
+import { CostSchema } from "./schema"
+import { Log } from "@/util/log"
+
+export namespace Cost {
+  const log = Log.create({ service: "cost" })
+
+  // In-memory cost tracking per session
+  const sessionEntries = new Map<string, CostSchema.CostEntry[]>()
+  let entryId = 0
+
+  /**
+   * Record a cost entry for a session. Called after each LLM response.
+   */
+  export function record(input: {
+    sessionID: string
+    messageID: string
+    providerID: string
+    modelID: string
+    inputTokens: number
+    outputTokens: number
+    cacheReadTokens?: number
+    cacheWriteTokens?: number
+    reasoningTokens?: number
+    estimatedCostUSD: number
+  }): CostSchema.CostEntry {
+    const entry: CostSchema.CostEntry = {
+      id: `cost_${++entryId}`,
+      sessionID: input.sessionID,
+      messageID: input.messageID,
+      providerID: input.providerID,
+      modelID: input.modelID,
+      inputTokens: input.inputTokens,
+      outputTokens: input.outputTokens,
+      cacheReadTokens: input.cacheReadTokens,
+      cacheWriteTokens: input.cacheWriteTokens,
+      reasoningTokens: input.reasoningTokens,
+      estimatedCostUSD: input.estimatedCostUSD,
+      timeCreated: Date.now(),
+    }
+
+    const entries = sessionEntries.get(input.sessionID) ?? []
+    entries.push(entry)
+    sessionEntries.set(input.sessionID, entries)
+
+    return entry
+  }
+
+  /**
+   * Get aggregated cost for a session.
+   */
+  export function sessionCost(sessionID: string): CostSchema.SessionCost {
+    const entries = sessionEntries.get(sessionID) ?? []
+
+    const byModel: Record<string, CostSchema.ModelUsage> = {}
+    let totalInputTokens = 0
+    let totalOutputTokens = 0
+    let totalCacheReadTokens = 0
+    let totalCacheWriteTokens = 0
+    let totalReasoningTokens = 0
+    let totalEstimatedCostUSD = 0
+
+    for (const entry of entries) {
+      totalInputTokens += entry.inputTokens
+      totalOutputTokens += entry.outputTokens
+      totalCacheReadTokens += entry.cacheReadTokens ?? 0
+      totalCacheWriteTokens += entry.cacheWriteTokens ?? 0
+      totalReasoningTokens += entry.reasoningTokens ?? 0
+      totalEstimatedCostUSD += entry.estimatedCostUSD
+
+      const modelKey = entry.modelID
+      if (!byModel[modelKey]) {
+        byModel[modelKey] = {
+          inputTokens: 0,
+          outputTokens: 0,
+          cacheReadTokens: 0,
+          cacheWriteTokens: 0,
+          reasoningTokens: 0,
+          estimatedCostUSD: 0,
+          requestCount: 0,
+        }
+      }
+      const m = byModel[modelKey]!
+      m.inputTokens += entry.inputTokens
+      m.outputTokens += entry.outputTokens
+      m.cacheReadTokens += entry.cacheReadTokens ?? 0
+      m.cacheWriteTokens += entry.cacheWriteTokens ?? 0
+      m.reasoningTokens += entry.reasoningTokens ?? 0
+      m.estimatedCostUSD += entry.estimatedCostUSD
+      m.requestCount += 1
+    }
+
+    return {
+      sessionID,
+      totalInputTokens,
+      totalOutputTokens,
+      totalCacheReadTokens,
+      totalCacheWriteTokens,
+      totalReasoningTokens,
+      totalEstimatedCostUSD,
+      totalRequests: entries.length,
+      byModel,
+    }
+  }
+
+  /**
+   * Get total cost across all sessions.
+   */
+  export function totalCost(): number {
+    let total = 0
+    for (const entries of sessionEntries.values()) {
+      for (const entry of entries) {
+        total += entry.estimatedCostUSD
+      }
+    }
+    return total
+  }
+
+  /**
+   * Estimate cost from token counts and model pricing.
+   * Prices are in USD per million tokens.
+   */
+  export function estimateCost(input: {
+    inputTokens: number
+    outputTokens: number
+    cacheReadTokens?: number
+    cacheWriteTokens?: number
+    reasoningTokens?: number
+    pricing: {
+      input: number // $/M tokens
+      output: number // $/M tokens
+      cacheRead?: number
+      cacheWrite?: number
+    }
+  }): number {
+    const { inputTokens, outputTokens, pricing } = input
+    const cacheRead = input.cacheReadTokens ?? 0
+    const cacheWrite = input.cacheWriteTokens ?? 0
+    const reasoning = input.reasoningTokens ?? 0
+
+    const inputCost = (inputTokens / 1_000_000) * pricing.input
+    const outputCost = ((outputTokens + reasoning) / 1_000_000) * pricing.output
+    const cacheReadCost = pricing.cacheRead ? (cacheRead / 1_000_000) * pricing.cacheRead : 0
+    const cacheWriteCost = pricing.cacheWrite ? (cacheWrite / 1_000_000) * pricing.cacheWrite : 0
+
+    return inputCost + outputCost + cacheReadCost + cacheWriteCost
+  }
+
+  /**
+   * Format cost as human-readable string.
+   */
+  export function formatCost(usd: number): string {
+    if (usd < 0.01) return `$${usd.toFixed(6)}`
+    if (usd < 1) return `$${usd.toFixed(4)}`
+    return `$${usd.toFixed(2)}`
+  }
+
+  /**
+   * Format token count as human-readable string.
+   */
+  export function formatTokens(tokens: number): string {
+    if (tokens >= 1_000_000) return `${(tokens / 1_000_000).toFixed(1)}M`
+    if (tokens >= 1_000) return `${(tokens / 1_000).toFixed(1)}K`
+    return `${tokens}`
+  }
+
+  /**
+   * Reset all tracked costs. Used for testing.
+   */
+  export function reset() {
+    sessionEntries.clear()
+    entryId = 0
+  }
+}

package/src/cost/schema.ts

@@ -0,0 +1,43 @@
+import z from "zod"
+
+export namespace CostSchema {
+  export const CostEntry = z.object({
+    id: z.string(),
+    sessionID: z.string(),
+    messageID: z.string(),
+    providerID: z.string(),
+    modelID: z.string(),
+    inputTokens: z.number(),
+    outputTokens: z.number(),
+    cacheReadTokens: z.number().optional(),
+    cacheWriteTokens: z.number().optional(),
+    reasoningTokens: z.number().optional(),
+    estimatedCostUSD: z.number(),
+    timeCreated: z.number(),
+  })
+  export type CostEntry = z.infer<typeof CostEntry>
+
+  export const ModelUsage = z.object({
+    inputTokens: z.number(),
+    outputTokens: z.number(),
+    cacheReadTokens: z.number(),
+    cacheWriteTokens: z.number(),
+    reasoningTokens: z.number(),
+    estimatedCostUSD: z.number(),
+    requestCount: z.number(),
+  })
+  export type ModelUsage = z.infer<typeof ModelUsage>
+
+  export const SessionCost = z.object({
+    sessionID: z.string(),
+    totalInputTokens: z.number(),
+    totalOutputTokens: z.number(),
+    totalCacheReadTokens: z.number(),
+    totalCacheWriteTokens: z.number(),
+    totalReasoningTokens: z.number(),
+    totalEstimatedCostUSD: z.number(),
+    totalRequests: z.number(),
+    byModel: z.record(z.string(), ModelUsage),
+  })
+  export type SessionCost = z.infer<typeof SessionCost>
+}

package/src/cron/index.ts

@@ -0,0 +1,200 @@
+import { Log } from "@/util/log"
+import z from "zod"
+import { readFile, writeFile } from "fs/promises"
+import path from "path"
+
+const log = Log.create({ service: "cron" })
+
+export namespace Cron {
+  export const CronTask = z.object({
+    id: z.string(),
+    projectID: z.string(),
+    expression: z.string().describe("5-field cron expression: M H DoM Mon DoW"),
+    prompt: z.string().describe("Prompt to execute"),
+    agent: z.string().default("build"),
+    recurring: z.boolean().default(true),
+    durable: z.boolean().default(false).describe("Persist across session restarts"),
+    timeCreated: z.number(),
+    timeLastRun: z.number().optional(),
+    timeNextRun: z.number().optional(),
+    timeExpires: z.number().optional(),
+  })
+  export type CronTask = z.infer<typeof CronTask>
+
+  // In-memory store
+  const tasks = new Map<string, CronTask>()
+  let nextId = 0
+  let tickInterval: NodeJS.Timeout | undefined
+  let tickCallback: ((task: CronTask) => Promise<void>) | undefined
+
+  const MAX_TASKS = 50
+  const DEFAULT_EXPIRY_DAYS = 7
+
+  /**
+   * Create a new cron task.
+   */
+  export function create(input: {
+    projectID: string
+    expression: string
+    prompt: string
+    agent?: string
+    recurring?: boolean
+    durable?: boolean
+  }): CronTask {
+    if (tasks.size >= MAX_TASKS) {
+      throw new Error(`Maximum of ${MAX_TASKS} cron tasks reached`)
+    }
+
+    const task: CronTask = {
+      id: `cron_${++nextId}`,
+      projectID: input.projectID,
+      expression: input.expression,
+      prompt: input.prompt,
+      agent: input.agent ?? "build",
+      recurring: input.recurring ?? true,
+      durable: input.durable ?? false,
+      timeCreated: Date.now(),
+      timeNextRun: nextRunTime(input.expression),
+      timeExpires: Date.now() + DEFAULT_EXPIRY_DAYS * 24 * 60 * 60 * 1000,
+    }
+
+    tasks.set(task.id, task)
+    return task
+  }
+
+  /**
+   * List all cron tasks.
+   */
+  export function list(projectID?: string): CronTask[] {
+    const all = Array.from(tasks.values())
+    if (projectID) return all.filter((t) => t.projectID === projectID)
+    return all
+  }
+
+  /**
+   * Get a specific cron task.
+   */
+  export function get(id: string): CronTask | undefined {
+    return tasks.get(id)
+  }
+
+  /**
+   * Delete a cron task.
+   */
+  export function remove(id: string): boolean {
+    return tasks.delete(id)
+  }
+
+  /**
+   * Register a callback for when cron tasks should fire.
+   */
+  export function onTick(callback: (task: CronTask) => Promise<void>) {
+    tickCallback = callback
+  }
+
+  /**
+   * Start the cron tick loop.
+   */
+  export function start(intervalMs: number = 60000) {
+    if (tickInterval) return
+
+    tickInterval = setInterval(async () => {
+      const now = Date.now()
+
+      for (const [id, task] of tasks) {
+        // Check expiry
+        if (task.timeExpires && now > task.timeExpires) {
+          tasks.delete(id)
+          continue
+        }
+
+        // Check if it's time to run
+        if (task.timeNextRun && now >= task.timeNextRun) {
+          task.timeLastRun = now
+          task.timeNextRun = task.recurring ? nextRunTime(task.expression) : undefined
+
+          if (!task.recurring) {
+            tasks.delete(id)
+          }
+
+          if (tickCallback) {
+            try {
+              await tickCallback(task)
+            } catch (e) {
+              log.error("Cron task failed", { id: task.id, error: String(e) })
+            }
+          }
+        }
+      }
+    }, intervalMs)
+  }
+
+  /**
+   * Stop the cron tick loop.
+   */
+  export function stop() {
+    if (tickInterval) {
+      clearInterval(tickInterval)
+      tickInterval = undefined
+    }
+  }
+
+  /**
+   * Save durable tasks to disk.
+   */
+  export async function saveDurable(directory: string) {
+    const durableTasks = Array.from(tasks.values()).filter((t) => t.durable)
+    const filePath = path.join(directory, ".vikasit", "scheduled_tasks.json")
+    await writeFile(filePath, JSON.stringify(durableTasks, null, 2), "utf-8")
+  }
+
+  /**
+   * Load durable tasks from disk.
+   */
+  export async function loadDurable(directory: string, projectID: string) {
+    const filePath = path.join(directory, ".vikasit", "scheduled_tasks.json")
+    try {
+      const raw = await readFile(filePath, "utf-8")
+      const loaded = JSON.parse(raw) as CronTask[]
+      for (const task of loaded) {
+        if (!tasks.has(task.id)) {
+          task.projectID = projectID
+          tasks.set(task.id, task)
+        }
+      }
+    } catch {
+      // File doesn't exist or is invalid — that's fine
+    }
+  }
+
+  /**
+   * Calculate next run time from cron expression.
+   * Simple implementation — for full cron parsing, use a library like cron-parser.
+   */
+  function nextRunTime(expression: string): number {
+    // Simple: add 1 minute for now. In production, use a proper cron parser.
+    const parts = expression.trim().split(/\s+/)
+    if (parts.length !== 5) {
+      throw new Error(`Invalid cron expression: "${expression}". Expected 5 fields: M H DoM Mon DoW`)
+    }
+
+    // For "every N minutes" patterns like "*/5 * * * *"
+    const minutesPart = parts[0]!
+    if (minutesPart.startsWith("*/")) {
+      const interval = parseInt(minutesPart.slice(2), 10)
+      if (!isNaN(interval) && interval > 0) {
+        return Date.now() + interval * 60 * 1000
+      }
+    }
+
+    // Default: run in 1 hour for complex expressions
+    return Date.now() + 60 * 60 * 1000
+  }
+
+  export function reset() {
+    stop()
+    tasks.clear()
+    nextId = 0
+    tickCallback = undefined
+  }
+}