@synergenius/flow-weaver-pack-weaver 0.8.1

package/src/bot/genesis-store.ts

@@ -0,0 +1,180 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as crypto from 'node:crypto';
+import type { GenesisConfig, GenesisHistory, GenesisCycleRecord, GenesisFingerprint, EscrowToken, GenesisSelfMigrationRecord } from './types.js';
+
+const DEFAULT_CONFIG: GenesisConfig = {
+  intent: 'Improve workflow reliability and efficiency',
+  focus: [],
+  constraints: [],
+  approvalThreshold: 'MINOR',
+  budgetPerCycle: 3,
+  stabilize: false,
+  targetWorkflow: '',
+  maxCyclesPerRun: 10,
+};
+
+export class GenesisStore {
+  private genesisDir: string;
+
+  constructor(projectDir: string) {
+    this.genesisDir = path.join(projectDir, '.genesis');
+  }
+
+  ensureDirs(): void {
+    fs.mkdirSync(path.join(this.genesisDir, 'snapshots'), { recursive: true });
+  }
+
+  loadConfig(): GenesisConfig {
+    const configPath = path.join(this.genesisDir, 'config.json');
+    if (!fs.existsSync(configPath)) {
+      this.ensureDirs();
+      fs.writeFileSync(configPath, JSON.stringify(DEFAULT_CONFIG, null, 2), 'utf-8');
+      return { ...DEFAULT_CONFIG };
+    }
+    const raw = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    return { ...DEFAULT_CONFIG, ...raw };
+  }
+
+  saveConfig(config: GenesisConfig): void {
+    this.ensureDirs();
+    fs.writeFileSync(path.join(this.genesisDir, 'config.json'), JSON.stringify(config, null, 2), 'utf-8');
+  }
+
+  loadHistory(): GenesisHistory {
+    const historyPath = path.join(this.genesisDir, 'history.json');
+    if (!fs.existsSync(historyPath)) {
+      return { configHash: '', cycles: [] };
+    }
+    return JSON.parse(fs.readFileSync(historyPath, 'utf-8'));
+  }
+
+  appendCycle(cycle: GenesisCycleRecord): void {
+    const history = this.loadHistory();
+    history.cycles.push(cycle);
+    this.ensureDirs();
+    fs.writeFileSync(path.join(this.genesisDir, 'history.json'), JSON.stringify(history, null, 2), 'utf-8');
+  }
+
+  saveSnapshot(cycleId: string, content: string): string {
+    this.ensureDirs();
+    const snapshotPath = path.join(this.genesisDir, 'snapshots', `${cycleId}.ts`);
+    fs.writeFileSync(snapshotPath, content, 'utf-8');
+    return snapshotPath;
+  }
+
+  loadSnapshot(snapshotPath: string): string | null {
+    try {
+      return fs.readFileSync(snapshotPath, 'utf-8');
+    } catch {
+      return null;
+    }
+  }
+
+  saveFingerprint(fingerprint: GenesisFingerprint): void {
+    this.ensureDirs();
+    fs.writeFileSync(path.join(this.genesisDir, 'fingerprint.json'), JSON.stringify(fingerprint, null, 2), 'utf-8');
+  }
+
+  getLastFingerprint(): GenesisFingerprint | null {
+    const fpPath = path.join(this.genesisDir, 'fingerprint.json');
+    if (!fs.existsSync(fpPath)) return null;
+    try {
+      return JSON.parse(fs.readFileSync(fpPath, 'utf-8'));
+    } catch {
+      return null;
+    }
+  }
+
+  getRecentOutcomes(count: number): string[] {
+    const history = this.loadHistory();
+    return history.cycles.slice(-count).map(c => c.outcome);
+  }
+
+  static newCycleId(): string {
+    return crypto.randomUUID().slice(0, 8);
+  }
+
+  static hashConfig(config: GenesisConfig): string {
+    return crypto.createHash('sha256').update(JSON.stringify(config)).digest('hex').slice(0, 12);
+  }
+
+  // --- Escrow ---
+
+  ensureEscrowDirs(): void {
+    fs.mkdirSync(path.join(this.genesisDir, 'escrow', 'staged'), { recursive: true });
+    fs.mkdirSync(path.join(this.genesisDir, 'escrow', 'backup'), { recursive: true });
+  }
+
+  loadEscrowToken(): EscrowToken | null {
+    const tokenPath = path.join(this.genesisDir, 'escrow', 'token.json');
+    if (!fs.existsSync(tokenPath)) return null;
+    try {
+      return JSON.parse(fs.readFileSync(tokenPath, 'utf-8'));
+    } catch {
+      return null;
+    }
+  }
+
+  saveEscrowToken(token: EscrowToken): void {
+    this.ensureEscrowDirs();
+    fs.writeFileSync(
+      path.join(this.genesisDir, 'escrow', 'token.json'),
+      JSON.stringify(token, null, 2),
+      'utf-8',
+    );
+  }
+
+  clearEscrow(): void {
+    const escrowDir = path.join(this.genesisDir, 'escrow');
+    if (fs.existsSync(escrowDir)) {
+      fs.rmSync(escrowDir, { recursive: true, force: true });
+    }
+  }
+
+  getEscrowStagedPath(relativePath: string): string {
+    return path.join(this.genesisDir, 'escrow', 'staged', relativePath);
+  }
+
+  getEscrowBackupPath(relativePath: string): string {
+    return path.join(this.genesisDir, 'escrow', 'backup', relativePath);
+  }
+
+  // --- Self-evolution history ---
+
+  loadSelfHistory(): GenesisSelfMigrationRecord[] {
+    const histPath = path.join(this.genesisDir, 'self-history.json');
+    if (!fs.existsSync(histPath)) return [];
+    try {
+      return JSON.parse(fs.readFileSync(histPath, 'utf-8'));
+    } catch {
+      return [];
+    }
+  }
+
+  appendSelfMigration(record: GenesisSelfMigrationRecord): void {
+    const records = this.loadSelfHistory();
+    records.push(record);
+    this.ensureDirs();
+    fs.writeFileSync(
+      path.join(this.genesisDir, 'self-history.json'),
+      JSON.stringify(records, null, 2),
+      'utf-8',
+    );
+  }
+
+  getSelfFailureCount(): number {
+    const records = this.loadSelfHistory();
+    let count = 0;
+    for (let i = records.length - 1; i >= 0; i--) {
+      if (records[i]!.outcome === 'rolled-back') count++;
+      else break;
+    }
+    return count;
+  }
+
+  static hashFile(filePath: string): string {
+    const content = fs.readFileSync(filePath);
+    return crypto.createHash('sha256').update(content).digest('hex');
+  }
+}

package/src/bot/index.ts

@@ -0,0 +1,127 @@
+export type {
+  BotConfig,
+  BotProviderConfig,
+  BotApprovalConfig,
+  BotNotifyConfig,
+  NotificationEvent,
+  NotificationEventType,
+  ExecutionEvent,
+  ExecutionEventType,
+  ApprovalMode,
+  WeaverConfig,
+  WeaverEnv,
+  ProviderInfo,
+  WorkflowResult,
+  ProviderName,
+  RunRecord,
+  RunFilter,
+  RetentionPolicy,
+  RunOutcome,
+  TokenUsage,
+  OnUsageCallback,
+  RunCostEntry,
+  RunCostSummary,
+  CostRecord,
+  CostSummary,
+  BotAgentProvider,
+  ProviderMetadata,
+  ProviderFactory,
+  ProviderFactoryConfig,
+  ProviderModule,
+  CronExpression,
+  ParsedCron,
+  CronField,
+  TriggerSource,
+  WatchDaemonOptions,
+  WatchDaemonState,
+  StageCondition,
+  StageStatus,
+  PipelineStage,
+  PipelineConfig,
+  StageResult,
+  PipelineResult,
+  DashboardEventType,
+  DashboardNodeStatus,
+  DashboardEvent,
+  DashboardNodeState,
+  DashboardServerOptions,
+  BotTask,
+  BotPlan,
+  BotPlanStep,
+  BotValidationResult,
+  BotExecutionResult,
+  BotNotificationEventType,
+  ToolDefinition,
+  ToolUseResult,
+  StreamChunk,
+  GenesisImpactLevel,
+  GenesisOperationType,
+  GenesisConfig,
+  GenesisOperation,
+  GenesisProposal,
+  GenesisFingerprint,
+  GenesisCycleRecord,
+  GenesisHistory,
+} from './types.js';
+
+export {
+  AnthropicAgentProvider,
+  resolveProviderConfig,
+  createProvider,
+  detectProvider,
+} from './agent-provider.js';
+export { CliAgentProvider } from './cli-provider.js';
+export { ProviderRegistry, defaultRegistry, loadExternalProvider, discoverProviders } from './provider-registry.js';
+export { BotAgentChannel } from './bot-agent-channel.js';
+export type { BotChannelContext } from './bot-agent-channel.js';
+export {
+  WebhookNotificationChannel,
+  createNotifier,
+} from './notifications.js';
+export type { NotificationChannel, NotificationErrorHandler } from './notifications.js';
+export { buildSystemPrompt } from './system-prompt.js';
+export { runWorkflow } from './runner.js';
+export { createApprovalHandler } from './approvals.js';
+export type { ApprovalHandler, ApprovalResult } from './approvals.js';
+
+export { RunStore } from './run-store.js';
+export { CostTracker, MODEL_PRICING } from './cost-tracker.js';
+export { CostStore } from './cost-store.js';
+
+// Watch/Cron (F4)
+export { parseCron, matches as cronMatches, nextMatch as cronNextMatch } from './cron-parser.js';
+export { FileWatcher } from './file-watcher.js';
+export { CronScheduler } from './cron-scheduler.js';
+export { WatchDaemon } from './watch-daemon.js';
+
+// Pipelines (F1)
+export { PipelineRunner } from './pipeline-runner.js';
+export type { PipelineRunOptions } from './pipeline-runner.js';
+
+// Dashboard (F3)
+export { DashboardServer } from './dashboard.js';
+export { openBrowser } from './utils.js';
+
+// Web Approval (F6)
+export { WebApprovalHandler } from './web-approval.js';
+
+// Genesis
+export { GenesisStore } from './genesis-store.js';
+
+// File locking
+export { withFileLock } from './file-lock.js';
+export type { FileLockOptions } from './file-lock.js';
+
+// Shared modules
+export { callCli, callApi, parseJsonResponse } from './ai-client.js';
+export { executeStep } from './step-executor.js';
+export { validateFiles } from './file-validator.js';
+
+// Bot infrastructure
+export { SteeringController } from './steering.js';
+export type { SteeringCommand } from './steering.js';
+export { TaskQueue } from './task-queue.js';
+export type { QueuedTask } from './task-queue.js';
+export { SessionStore } from './session-state.js';
+export type { SessionState } from './session-state.js';
+export { buildBotSystemPrompt } from './system-prompt.js';

package/src/bot/notifications.ts

@@ -0,0 +1,263 @@
+import type {
+  BotNotifyConfig,
+  NotificationEvent,
+  NotificationEventType,
+} from './types.js';
+
+export interface NotificationChannel {
+  name: string;
+  shouldSend(eventType: NotificationEventType): boolean;
+  send(event: NotificationEvent): Promise<void>;
+}
+
+export type NotificationErrorHandler = (
+  channel: string,
+  event: NotificationEvent,
+  error: string,
+) => void;
+
+const EVENT_COLORS: Record<NotificationEventType, number> = {
+  'workflow-start': 0x3498db,
+  'workflow-complete': 0x2ecc71,
+  'cycle-start': 0x3498db,
+  'cycle-complete': 0x2ecc71,
+  'approval-needed': 0xf1c40f,
+  error: 0xe74c3c,
+  'pipeline-start': 0x9b59b6,
+  'pipeline-complete': 0x2ecc71,
+  'stage-start': 0x3498db,
+  'stage-complete': 0x2ecc71,
+  'bot-task-start': 0x3498db,
+  'bot-task-complete': 0x2ecc71,
+  'bot-plan-ready': 0x9b59b6,
+  'bot-step-complete': 0x1abc9c,
+  'bot-validation-failed': 0xe67e22,
+  'bot-fix-attempt': 0xf39c12,
+  'bot-session-start': 0x3498db,
+  'bot-session-end': 0x2ecc71,
+  'bot-steering-received': 0x95a5a6,
+};
+
+const EVENT_LABELS: Record<NotificationEventType, string> = {
+  'workflow-start': 'Workflow Started',
+  'workflow-complete': 'Workflow Complete',
+  'cycle-start': 'Cycle Started',
+  'cycle-complete': 'Cycle Complete',
+  'approval-needed': 'Approval Needed',
+  error: 'Error',
+  'pipeline-start': 'Pipeline Started',
+  'pipeline-complete': 'Pipeline Complete',
+  'stage-start': 'Stage Started',
+  'stage-complete': 'Stage Complete',
+  'bot-task-start': 'Bot Task Started',
+  'bot-task-complete': 'Bot Task Complete',
+  'bot-plan-ready': 'Bot Plan Ready',
+  'bot-step-complete': 'Bot Step Complete',
+  'bot-validation-failed': 'Bot Validation Failed',
+  'bot-fix-attempt': 'Bot Fix Attempt',
+  'bot-session-start': 'Bot Session Started',
+  'bot-session-end': 'Bot Session Ended',
+  'bot-steering-received': 'Bot Steering Received',
+};
+
+function formatDiscordBody(event: NotificationEvent): object {
+  const color = EVENT_COLORS[event.type];
+  const context =
+    event.cycle != null
+      ? `Cycle ${event.cycle}`
+      : (event.workflowFile ?? 'Workflow');
+  const title = `Weaver: ${EVENT_LABELS[event.type]} (${context})`;
+
+  const fields: Array<{ name: string; value: string; inline?: boolean }> = [];
+
+  if (event.summary) {
+    fields.push({ name: 'Summary', value: event.summary });
+  }
+  if (event.outcome) {
+    fields.push({ name: 'Outcome', value: event.outcome, inline: true });
+  }
+  if (event.diff) {
+    const s = event.diff.summary as Record<string, number> | undefined;
+    if (s) {
+      fields.push({
+        name: 'Nodes',
+        value: `+${s.nodeTypesAdded ?? 0} / -${s.nodeTypesRemoved ?? 0}`,
+        inline: true,
+      });
+      fields.push({
+        name: 'Connections',
+        value: `+${s.connectionsAdded ?? 0} / -${s.connectionsRemoved ?? 0}`,
+        inline: true,
+      });
+    }
+  }
+  if (event.pipelineName) {
+    fields.push({ name: 'Pipeline', value: event.pipelineName, inline: true });
+  }
+  if (event.stageId) {
+    fields.push({ name: 'Stage', value: event.stageId, inline: true });
+  }
+  if (event.totalStages != null) {
+    fields.push({ name: 'Progress', value: `${event.completedStages ?? 0}/${event.totalStages}`, inline: true });
+  }
+  if (event.error) {
+    fields.push({ name: 'Error', value: event.error.slice(0, 1024) });
+  }
+
+  return {
+    embeds: [
+      {
+        title,
+        description: event.projectDir,
+        color,
+        fields: fields.length > 0 ? fields : undefined,
+        timestamp: new Date().toISOString(),
+      },
+    ],
+  };
+}
+
+function formatSlackBody(event: NotificationEvent): object {
+  const label = EVENT_LABELS[event.type];
+  const blocks: Array<Record<string, unknown>> = [
+    {
+      type: 'header',
+      text: {
+        type: 'plain_text',
+        text: `Weaver: ${label}${event.cycle != null ? ` (Cycle ${event.cycle})` : ''}`,
+      },
+    },
+  ];
+
+  const parts: string[] = [`*Project:* ${event.projectDir}`];
+  if (event.summary) parts.push(`*Summary:* ${event.summary}`);
+  if (event.outcome) parts.push(`*Outcome:* ${event.outcome}`);
+  if (event.pipelineName) parts.push(`*Pipeline:* ${event.pipelineName}`);
+  if (event.stageId) parts.push(`*Stage:* ${event.stageId}`);
+  if (event.totalStages != null) parts.push(`*Progress:* ${event.completedStages ?? 0}/${event.totalStages}`);
+  if (event.error) parts.push(`*Error:* ${event.error.slice(0, 500)}`);
+
+  blocks.push({
+    type: 'section',
+    text: { type: 'mrkdwn', text: parts.join('\n') },
+  });
+
+  return { blocks };
+}
+
+function formatWebhookBody(event: NotificationEvent): object {
+  return { event };
+}
+
+async function fetchWithRetry(
+  url: string,
+  init: RequestInit,
+  maxAttempts: number,
+  onError?: NotificationErrorHandler,
+  channelName?: string,
+  event?: NotificationEvent,
+): Promise<Response | null> {
+  const delays = [1000, 2000, 4000];
+
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      const resp = await fetch(url, init);
+      if (resp.ok) return resp;
+
+      const msg = `${resp.status} ${resp.statusText}`;
+      if (attempt < maxAttempts - 1) {
+        console.error(
+          `[weaver] ${channelName} notification failed (attempt ${attempt + 1}/${maxAttempts}): ${msg}`,
+        );
+        await new Promise((r) => setTimeout(r, delays[attempt] ?? 4000));
+      } else {
+        const errorMsg = `${channelName} notification failed after ${maxAttempts} attempts: ${msg}`;
+        console.error(`[weaver] ${errorMsg}`);
+        if (onError && event) onError(channelName ?? 'unknown', event, errorMsg);
+      }
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (attempt < maxAttempts - 1) {
+        console.error(
+          `[weaver] ${channelName} notification error (attempt ${attempt + 1}/${maxAttempts}): ${msg}`,
+        );
+        await new Promise((r) => setTimeout(r, delays[attempt] ?? 4000));
+      } else {
+        const errorMsg = `${channelName} notification error after ${maxAttempts} attempts: ${msg}`;
+        console.error(`[weaver] ${errorMsg}`);
+        if (onError && event) onError(channelName ?? 'unknown', event, errorMsg);
+      }
+    }
+  }
+
+  return null;
+}
+
+export class WebhookNotificationChannel implements NotificationChannel {
+  name: string;
+  private url: string;
+  private channelType: 'discord' | 'slack' | 'webhook';
+  private events: Set<NotificationEventType>;
+  private headers: Record<string, string>;
+  private onError?: NotificationErrorHandler;
+
+  constructor(config: BotNotifyConfig, onError?: NotificationErrorHandler) {
+    this.name = config.channel;
+    this.url = config.url;
+    this.channelType = config.channel;
+    this.events = new Set(
+      config.events ?? [
+        'cycle-start',
+        'cycle-complete',
+        'approval-needed',
+        'error',
+      ],
+    );
+    this.headers = config.headers ?? {};
+    this.onError = onError;
+  }
+
+  shouldSend(eventType: NotificationEventType): boolean {
+    return this.events.has(eventType);
+  }
+
+  async send(event: NotificationEvent): Promise<void> {
+    if (!this.shouldSend(event.type)) return;
+
+    let body: object;
+    switch (this.channelType) {
+      case 'discord':
+        body = formatDiscordBody(event);
+        break;
+      case 'slack':
+        body = formatSlackBody(event);
+        break;
+      default:
+        body = formatWebhookBody(event);
+    }
+
+    await fetchWithRetry(
+      this.url,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          ...this.headers,
+        },
+        body: JSON.stringify(body),
+      },
+      3,
+      this.onError,
+      this.channelType,
+      event,
+    );
+  }
+}
+
+export function createNotifier(
+  channels: NotificationChannel[],
+): (event: NotificationEvent) => Promise<void> {
+  return async (event: NotificationEvent) => {
+    await Promise.allSettled(channels.map((ch) => ch.send(event)));
+  };
+}