@vikasitai/vikasit-code 2.0.7 → 2.0.8

package/src/cost/index.ts

@@ -1,173 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,200 +0,0 @@
-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
-  }
-}