@synergenius/flow-weaver-pack-weaver 0.8.1

package/src/bot/cli-stream-parser.ts

@@ -0,0 +1,59 @@
+import type { StreamChunk } from './types.js';
+
+/**
+ * Parse one NDJSON line from `claude --output-format stream-json`.
+ * Returns null for unrecognized event types.
+ */
+export function parseStreamLine(line: string): StreamChunk | null {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+
+  let parsed: Record<string, unknown>;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+
+  const type = parsed.type as string | undefined;
+
+  if (type === 'content_block_delta') {
+    const delta = parsed.delta as { type?: string; text?: string } | undefined;
+    if (delta?.type === 'text_delta' && typeof delta.text === 'string') {
+      return { type: 'text', text: delta.text };
+    }
+    return null;
+  }
+
+  if (type === 'message_delta') {
+    const usage = parsed.usage as Record<string, number> | undefined;
+    if (usage) {
+      return {
+        type: 'usage',
+        usage: {
+          inputTokens: usage.input_tokens ?? 0,
+          outputTokens: usage.output_tokens ?? 0,
+          cacheCreationInputTokens: usage.cache_creation_input_tokens,
+          cacheReadInputTokens: usage.cache_read_input_tokens,
+        },
+      };
+    }
+    return null;
+  }
+
+  if (type === 'message_stop') {
+    return { type: 'done' };
+  }
+
+  return null;
+}
+
+/**
+ * Concatenate text from collected StreamChunks into a single string.
+ */
+export function extractTextFromChunks(chunks: StreamChunk[]): string {
+  return chunks
+    .filter((c) => c.type === 'text' && c.text)
+    .map((c) => c.text!)
+    .join('');
+}

package/src/bot/cost-store.ts

@@ -0,0 +1,92 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import type { CostRecord, CostSummary } from './types.js';
+
+const MAX_ENTRIES = 10_000;
+const CAP_CHECK_INTERVAL = 100;
+
+export class CostStore {
+  private readonly dir: string;
+  private readonly filePath: string;
+  private appendCount = 0;
+
+  constructor(dir?: string) {
+    this.dir = dir ?? process.env.WEAVER_DATA_DIR ?? path.join(os.homedir(), '.weaver');
+    fs.mkdirSync(this.dir, { recursive: true });
+    this.filePath = path.join(this.dir, 'costs.ndjson');
+  }
+
+  append(record: CostRecord): void {
+    fs.appendFileSync(this.filePath, JSON.stringify(record) + '\n', 'utf-8');
+    this.appendCount++;
+    if (this.appendCount % CAP_CHECK_INTERVAL === 0) {
+      this.enforceCap();
+    }
+  }
+
+  query(filters?: { since?: number; model?: string }): CostRecord[] {
+    if (!fs.existsSync(this.filePath)) return [];
+
+    const content = fs.readFileSync(this.filePath, 'utf-8');
+    const lines = content.split('\n').filter((l) => l.trim().length > 0);
+    const records: CostRecord[] = [];
+
+    for (const line of lines) {
+      try {
+        const record = JSON.parse(line) as CostRecord;
+        if (filters?.since && record.timestamp < filters.since) continue;
+        if (filters?.model && record.model !== filters.model) continue;
+        records.push(record);
+      } catch {
+        // skip corrupt lines
+      }
+    }
+
+    return records;
+  }
+
+  summarize(filters?: { since?: number; model?: string }): CostSummary {
+    const records = this.query(filters);
+
+    const summary: CostSummary = {
+      totalCost: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalRuns: records.length,
+      byModel: {},
+    };
+
+    for (const r of records) {
+      summary.totalCost += r.estimatedCost;
+      summary.totalInputTokens += r.inputTokens;
+      summary.totalOutputTokens += r.outputTokens;
+
+      const model = r.model || 'unknown';
+      if (!summary.byModel[model]) {
+        summary.byModel[model] = { runs: 0, inputTokens: 0, outputTokens: 0, cost: 0 };
+      }
+      const m = summary.byModel[model]!;
+      m.runs++;
+      m.inputTokens += r.inputTokens;
+      m.outputTokens += r.outputTokens;
+      m.cost += r.estimatedCost;
+    }
+
+    return summary;
+  }
+
+  private enforceCap(): void {
+    if (!fs.existsSync(this.filePath)) return;
+
+    const content = fs.readFileSync(this.filePath, 'utf-8');
+    const lines = content.split('\n').filter((l) => l.trim().length > 0);
+
+    if (lines.length <= MAX_ENTRIES) return;
+
+    const kept = lines.slice(lines.length - MAX_ENTRIES);
+    const tmpPath = this.filePath + '.tmp';
+    fs.writeFileSync(tmpPath, kept.join('\n') + '\n', 'utf-8');
+    fs.renameSync(tmpPath, this.filePath);
+  }
+}

package/src/bot/cost-tracker.ts

@@ -0,0 +1,72 @@
+import type { TokenUsage, RunCostEntry, RunCostSummary } from './types.js';
+
+// Snapshot date: 2026-03-06
+export const MODEL_PRICING: Record<
+  string,
+  { inputPer1M: number; outputPer1M: number; cacheReadPer1M?: number; cacheCreationPer1M?: number }
+> = {
+  'claude-sonnet-4-6': { inputPer1M: 3, outputPer1M: 15, cacheReadPer1M: 0.3, cacheCreationPer1M: 3.75 },
+  'claude-sonnet-4-20250514': { inputPer1M: 3, outputPer1M: 15, cacheReadPer1M: 0.3, cacheCreationPer1M: 3.75 },
+  'claude-opus-4-6': { inputPer1M: 15, outputPer1M: 75, cacheReadPer1M: 1.5, cacheCreationPer1M: 18.75 },
+  'claude-opus-4-20250514': { inputPer1M: 15, outputPer1M: 75, cacheReadPer1M: 1.5, cacheCreationPer1M: 18.75 },
+  'claude-haiku-4-5': { inputPer1M: 0.8, outputPer1M: 4, cacheReadPer1M: 0.08, cacheCreationPer1M: 1.0 },
+  'claude-3-5-haiku-20241022': { inputPer1M: 0.8, outputPer1M: 4, cacheReadPer1M: 0.08, cacheCreationPer1M: 1.0 },
+  'claude-3-5-sonnet-20241022': { inputPer1M: 3, outputPer1M: 15, cacheReadPer1M: 0.3, cacheCreationPer1M: 3.75 },
+};
+
+export class CostTracker {
+  private entries: RunCostEntry[] = [];
+
+  constructor(
+    private defaultModel: string,
+    private provider: string,
+  ) {}
+
+  track(step: string, model: string, usage: TokenUsage): void {
+    this.entries.push({
+      step,
+      model,
+      usage,
+      estimatedCost: CostTracker.estimateCost(model, usage),
+      timestamp: Date.now(),
+    });
+  }
+
+  static estimateCost(model: string, usage: TokenUsage): number {
+    const pricing = MODEL_PRICING[model];
+    if (!pricing) return 0;
+
+    return (
+      (usage.inputTokens * pricing.inputPer1M +
+        usage.outputTokens * pricing.outputPer1M +
+        (usage.cacheReadInputTokens ?? 0) * (pricing.cacheReadPer1M ?? pricing.inputPer1M) +
+        (usage.cacheCreationInputTokens ?? 0) * (pricing.cacheCreationPer1M ?? pricing.inputPer1M)) /
+      1_000_000
+    );
+  }
+
+  getRunSummary(): RunCostSummary {
+    let totalIn = 0;
+    let totalOut = 0;
+    let totalCost = 0;
+
+    for (const entry of this.entries) {
+      totalIn += entry.usage.inputTokens;
+      totalOut += entry.usage.outputTokens;
+      totalCost += entry.estimatedCost;
+    }
+
+    return {
+      entries: [...this.entries],
+      totalInputTokens: totalIn,
+      totalOutputTokens: totalOut,
+      totalCost,
+      model: this.entries[0]?.model ?? this.defaultModel,
+      provider: this.provider,
+    };
+  }
+
+  hasEntries(): boolean {
+    return this.entries.length > 0;
+  }
+}

package/src/bot/cron-parser.ts

@@ -0,0 +1,153 @@
+import type { ParsedCron, CronField } from './types.js';
+
+export function parseCron(expression: string): ParsedCron {
+  const parts = expression.trim().split(/\s+/);
+  if (parts.length !== 5) {
+    throw new Error(
+      `Invalid cron expression "${expression}": expected 5 fields (minute hour day-of-month month day-of-week)`,
+    );
+  }
+
+  return {
+    minute: parseField(parts[0]!, 0, 59),
+    hour: parseField(parts[1]!, 0, 23),
+    dayOfMonth: parseField(parts[2]!, 1, 31),
+    month: parseField(parts[3]!, 1, 12),
+    dayOfWeek: parseField(parts[4]!, 0, 6),
+    source: expression,
+  };
+}
+
+function parseField(token: string, min: number, max: number): CronField {
+  if (token === '*') {
+    return { type: 'wildcard', values: range(min, max) };
+  }
+
+  const values = new Set<number>();
+
+  for (const part of token.split(',')) {
+    if (part.includes('/')) {
+      const [rangeStr, stepStr] = part.split('/');
+      const step = parseInt(stepStr!, 10);
+      if (isNaN(step) || step <= 0) throw new Error(`Invalid step in "${part}"`);
+
+      let start: number;
+      let end: number;
+      if (rangeStr === '*') {
+        start = min;
+        end = max;
+      } else if (rangeStr!.includes('-')) {
+        [start, end] = rangeStr!.split('-').map(Number) as [number, number];
+      } else {
+        start = parseInt(rangeStr!, 10);
+        end = max;
+      }
+
+      for (let i = start; i <= end; i += step) {
+        if (i >= min && i <= max) values.add(i);
+      }
+    } else if (part.includes('-')) {
+      const [startStr, endStr] = part.split('-');
+      const start = parseInt(startStr!, 10);
+      const end = parseInt(endStr!, 10);
+      if (isNaN(start) || isNaN(end)) throw new Error(`Invalid range in "${part}"`);
+      for (let i = start; i <= end; i++) {
+        if (i >= min && i <= max) values.add(i);
+      }
+    } else {
+      const val = parseInt(part, 10);
+      if (isNaN(val) || val < min || val > max) {
+        throw new Error(`Invalid value "${part}" (expected ${min}-${max})`);
+      }
+      values.add(val);
+    }
+  }
+
+  return {
+    type: values.size === max - min + 1 ? 'wildcard' : 'list',
+    values: [...values].sort((a, b) => a - b),
+  };
+}
+
+function range(min: number, max: number): number[] {
+  const result: number[] = [];
+  for (let i = min; i <= max; i++) result.push(i);
+  return result;
+}
+
+export function matches(parsed: ParsedCron, date: Date): boolean {
+  const minute = date.getMinutes();
+  const hour = date.getHours();
+  const dayOfMonth = date.getDate();
+  const month = date.getMonth() + 1;
+  const dayOfWeek = date.getDay();
+
+  if (!includes(parsed.minute, minute)) return false;
+  if (!includes(parsed.hour, hour)) return false;
+  if (!includes(parsed.month, month)) return false;
+
+  // Vixie cron: if both dayOfMonth and dayOfWeek are restricted, match on EITHER
+  const domRestricted = parsed.dayOfMonth.type === 'list';
+  const dowRestricted = parsed.dayOfWeek.type === 'list';
+
+  if (domRestricted && dowRestricted) {
+    return includes(parsed.dayOfMonth, dayOfMonth) || includes(parsed.dayOfWeek, dayOfWeek);
+  }
+
+  if (!includes(parsed.dayOfMonth, dayOfMonth)) return false;
+  if (!includes(parsed.dayOfWeek, dayOfWeek)) return false;
+
+  return true;
+}
+
+function includes(field: CronField, value: number): boolean {
+  if (field.type === 'wildcard') return true;
+  return field.values.includes(value);
+}
+
+export function nextMatch(parsed: ParsedCron, after: Date): Date {
+  const candidate = new Date(after.getTime());
+  candidate.setSeconds(0, 0);
+  candidate.setMinutes(candidate.getMinutes() + 1);
+
+  // Safety cap: 2 years
+  const limit = after.getTime() + 2 * 365 * 24 * 60 * 60 * 1000;
+
+  while (candidate.getTime() < limit) {
+    if (matches(parsed, candidate)) return candidate;
+
+    // Skip non-matching months
+    if (!includes(parsed.month, candidate.getMonth() + 1)) {
+      candidate.setMonth(candidate.getMonth() + 1, 1);
+      candidate.setHours(0, 0, 0, 0);
+      continue;
+    }
+
+    // Skip non-matching days
+    const dayOfMonth = candidate.getDate();
+    const dayOfWeek = candidate.getDay();
+    const domRestricted = parsed.dayOfMonth.type === 'list';
+    const dowRestricted = parsed.dayOfWeek.type === 'list';
+
+    const dayMatches = domRestricted && dowRestricted
+      ? includes(parsed.dayOfMonth, dayOfMonth) || includes(parsed.dayOfWeek, dayOfWeek)
+      : includes(parsed.dayOfMonth, dayOfMonth) && includes(parsed.dayOfWeek, dayOfWeek);
+
+    if (!dayMatches) {
+      candidate.setDate(candidate.getDate() + 1);
+      candidate.setHours(0, 0, 0, 0);
+      continue;
+    }
+
+    // Skip non-matching hours
+    if (!includes(parsed.hour, candidate.getHours())) {
+      candidate.setHours(candidate.getHours() + 1, 0, 0, 0);
+      continue;
+    }
+
+    // Advance by one minute
+    candidate.setMinutes(candidate.getMinutes() + 1);
+  }
+
+  throw new Error(`No cron match found within 2 years for "${parsed.source}"`);
+}

package/src/bot/cron-scheduler.ts

@@ -0,0 +1,48 @@
+import { EventEmitter } from 'node:events';
+import type { ParsedCron } from './types.js';
+import { nextMatch } from './cron-parser.js';
+
+const MAX_TIMEOUT = 2_147_483_647; // ~24.8 days (2^31 - 1)
+
+export class CronScheduler extends EventEmitter {
+  private parsed: ParsedCron;
+  private timer: ReturnType<typeof setTimeout> | null = null;
+  private stopped = false;
+
+  constructor(parsed: ParsedCron) {
+    super();
+    this.parsed = parsed;
+  }
+
+  start(): void {
+    this.stopped = false;
+    this.scheduleNext();
+  }
+
+  stop(): void {
+    this.stopped = true;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+
+  private scheduleNext(): void {
+    if (this.stopped) return;
+
+    const now = new Date();
+    const next = nextMatch(this.parsed, now);
+    const delayMs = next.getTime() - Date.now();
+
+    if (delayMs > MAX_TIMEOUT) {
+      // Chain intermediate timeouts for very long delays
+      this.timer = setTimeout(() => this.scheduleNext(), MAX_TIMEOUT);
+    } else {
+      this.timer = setTimeout(() => {
+        if (this.stopped) return;
+        this.emit('tick');
+        this.scheduleNext();
+      }, Math.max(delayMs, 0));
+    }
+  }
+}