@arcteninc/core 0.0.176 → 0.0.177

package/scripts/dashboard-sync.ts

@@ -1,454 +0,0 @@
-#!/usr/bin/env node
-/**
- * Dashboard Sync - Bidirectional sync between local config and Convex dashboard
- *
- * Handles:
- * - Fetching current agent/tool state from dashboard
- * - Pushing local changes to dashboard
- * - Detecting and resolving conflicts
- * - Auto-sync after modifications
- */
-
-import type { ParsedConfig, ParsedAgent } from './config-parser.js';
-
-// Types matching Convex schema
-export interface DashboardAgent {
-  _id: string;
-  projectId: string;
-  name: string;
-  systemPrompt?: string;
-  description?: string;
-  isDefault?: boolean;
-  toolMode?: 'inherit' | 'custom' | 'additive';
-  createdAt: number;
-  updatedAt: number;
-}
-
-export interface DashboardTool {
-  _id: string;
-  projectId: string;
-  name: string;
-  description?: string;
-  signature: string;
-  sourceFile?: string;
-  category?: string;
-  isEnabled: boolean;
-  isOverridable: boolean;
-  requiresApproval: boolean;
-  sensitiveParams?: string[];
-  // Codebase is source of truth - these fields are readonly in dashboard
-  readonly?: boolean; // If true, name/description/signature cannot be edited in dashboard
-  syncedAt?: number; // Timestamp of last sync from codebase
-}
-
-export interface DashboardAgentTool {
-  agentId: string;
-  toolId: string;
-  isEnabled: boolean;
-  isOverridable?: boolean;
-  requiresApproval?: boolean;
-  customDescription?: string;
-}
-
-export interface DashboardState {
-  agents: DashboardAgent[];
-  tools: DashboardTool[];
-  agentTools: DashboardAgentTool[];
-}
-
-export interface SyncDiff {
-  // Agents
-  agentsToCreate: ParsedAgent[];
-  agentsToUpdate: Array<{ local: ParsedAgent; remote: DashboardAgent }>;
-  agentsToDelete: DashboardAgent[];
-  agentsOnlyInDashboard: DashboardAgent[];
-
-  // Tools per agent
-  toolsToAdd: Map<string, string[]>; // agentName -> tool names to add
-  toolsToRemove: Map<string, string[]>; // agentName -> tool names to remove
-
-  // Conflicts
-  conflicts: SyncConflict[];
-}
-
-export interface SyncConflict {
-  type: 'agent_mismatch' | 'tool_mismatch' | 'prompt_mismatch';
-  agentName: string;
-  localValue?: string;
-  dashboardValue?: string;
-  description: string;
-}
-
-export interface SyncResult {
-  success: boolean;
-  created: number;
-  updated: number;
-  deleted: number;
-  errors: string[];
-}
-
-/**
- * Dashboard API client for sync operations
- */
-export class DashboardSyncClient {
-  private apiBaseUrl: string;
-  private apiKey: string;
-
-  constructor(options: { apiBaseUrl: string; apiKey: string }) {
-    this.apiBaseUrl = options.apiBaseUrl;
-    this.apiKey = options.apiKey;
-  }
-
-  /**
-   * Fetch current state from dashboard
-   */
-  async fetchDashboardState(): Promise<DashboardState> {
-    const response = await fetch(`${this.apiBaseUrl}/api/ai-init/agents`, {
-      method: 'GET',
-      headers: {
-        'Content-Type': 'application/json',
-        'x-arcten-api-key': this.apiKey,
-      },
-    });
-
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Failed to fetch dashboard state: ${error}`);
-    }
-
-    return response.json();
-  }
-
-  /**
-   * Push agents to dashboard (create/update)
-   */
-  async pushAgents(agents: ParsedAgent[]): Promise<SyncResult> {
-    const response = await fetch(`${this.apiBaseUrl}/api/ai-init/sync`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'x-arcten-api-key': this.apiKey,
-      },
-      body: JSON.stringify({
-        action: 'push_agents',
-        agents: agents.map((a) => ({
-          name: a.name,
-          systemPrompt: a.systemPrompt,
-          description: a.description,
-          tools: a.tools,
-        })),
-      }),
-    });
-
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Failed to push agents: ${error}`);
-    }
-
-    return response.json();
-  }
-
-  /**
-   * Delete an agent from dashboard
-   */
-  async deleteAgent(agentName: string): Promise<void> {
-    const response = await fetch(`${this.apiBaseUrl}/api/ai-init/sync`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'x-arcten-api-key': this.apiKey,
-      },
-      body: JSON.stringify({
-        action: 'delete_agent',
-        agentName,
-      }),
-    });
-
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Failed to delete agent: ${error}`);
-    }
-  }
-
-  /**
-   * Update tool assignments for an agent
-   */
-  async updateAgentTools(
-    agentName: string,
-    toolsToAdd: string[],
-    toolsToRemove: string[]
-  ): Promise<void> {
-    const response = await fetch(`${this.apiBaseUrl}/api/ai-init/sync`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'x-arcten-api-key': this.apiKey,
-      },
-      body: JSON.stringify({
-        action: 'update_agent_tools',
-        agentName,
-        toolsToAdd,
-        toolsToRemove,
-      }),
-    });
-
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Failed to update agent tools: ${error}`);
-    }
-  }
-
-  /**
-   * Sync tools (discovered functions) to dashboard
-   */
-  async syncTools(
-    tools: Array<{
-      name: string;
-      description?: string;
-      signature: string;
-      sourceFile?: string;
-      category?: string;
-      isEnabled?: boolean;
-      requiresApproval?: boolean;
-    }>
-  ): Promise<SyncResult> {
-    const response = await fetch(`${this.apiBaseUrl}/api/ai-init/sync`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'x-arcten-api-key': this.apiKey,
-      },
-      body: JSON.stringify({
-        action: 'sync_tools',
-        tools,
-      }),
-    });
-
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Failed to sync tools: ${error}`);
-    }
-
-    return response.json();
-  }
-}
-
-/**
- * Compare local config with dashboard state to find differences
- */
-export function computeSyncDiff(
-  local: ParsedConfig,
-  dashboard: DashboardState
-): SyncDiff {
-  const diff: SyncDiff = {
-    agentsToCreate: [],
-    agentsToUpdate: [],
-    agentsToDelete: [],
-    agentsOnlyInDashboard: [],
-    toolsToAdd: new Map(),
-    toolsToRemove: new Map(),
-    conflicts: [],
-  };
-
-  const localAgentNames = new Set(local.agents.map((a) => a.name));
-  const dashboardAgentNames = new Set(dashboard.agents.map((a) => a.name));
-
-  // Find agents to create (in local but not in dashboard)
-  for (const localAgent of local.agents) {
-    if (!dashboardAgentNames.has(localAgent.name)) {
-      diff.agentsToCreate.push(localAgent);
-    }
-  }
-
-  // Find agents only in dashboard (not in local)
-  for (const dashboardAgent of dashboard.agents) {
-    if (!localAgentNames.has(dashboardAgent.name)) {
-      diff.agentsOnlyInDashboard.push(dashboardAgent);
-    }
-  }
-
-  // Find agents to update (in both, but may have differences)
-  for (const localAgent of local.agents) {
-    const dashboardAgent = dashboard.agents.find((a) => a.name === localAgent.name);
-    if (dashboardAgent) {
-      // Check for prompt mismatch
-      if (
-        localAgent.systemPrompt &&
-        dashboardAgent.systemPrompt &&
-        localAgent.systemPrompt !== dashboardAgent.systemPrompt
-      ) {
-        diff.conflicts.push({
-          type: 'prompt_mismatch',
-          agentName: localAgent.name,
-          localValue: localAgent.systemPrompt.substring(0, 100) + '...',
-          dashboardValue: dashboardAgent.systemPrompt.substring(0, 100) + '...',
-          description: `System prompt differs for "${localAgent.name}"`,
-        });
-      }
-
-      // Compare tool assignments
-      const dashboardToolsForAgent = dashboard.agentTools
-        .filter((at) => at.agentId === dashboardAgent._id && at.isEnabled)
-        .map((at) => {
-          const tool = dashboard.tools.find((t) => t._id === at.toolId);
-          return tool?.name;
-        })
-        .filter(Boolean) as string[];
-
-      const localToolSet = new Set(localAgent.tools);
-      const dashboardToolSet = new Set(dashboardToolsForAgent);
-
-      // Tools to add (in local but not in dashboard)
-      const toAdd = localAgent.tools.filter((t) => !dashboardToolSet.has(t));
-      if (toAdd.length > 0) {
-        diff.toolsToAdd.set(localAgent.name, toAdd);
-      }
-
-      // Tools to remove (in dashboard but not in local)
-      const toRemove = dashboardToolsForAgent.filter((t) => !localToolSet.has(t));
-      if (toRemove.length > 0) {
-        diff.toolsToRemove.set(localAgent.name, toRemove);
-      }
-
-      // Add to update list if there are any differences
-      if (
-        toAdd.length > 0 ||
-        toRemove.length > 0 ||
-        localAgent.systemPrompt !== dashboardAgent.systemPrompt
-      ) {
-        diff.agentsToUpdate.push({ local: localAgent, remote: dashboardAgent });
-      }
-    }
-  }
-
-  return diff;
-}
-
-/**
- * Generate a human-readable summary of the sync diff
- */
-export function formatSyncDiff(diff: SyncDiff): string {
-  const lines: string[] = [];
-
-  if (diff.agentsToCreate.length > 0) {
-    lines.push(`📦 Agents to create: ${diff.agentsToCreate.map((a) => a.name).join(', ')}`);
-  }
-
-  if (diff.agentsOnlyInDashboard.length > 0) {
-    lines.push(
-      `☁️  Agents only in dashboard: ${diff.agentsOnlyInDashboard.map((a) => a.name).join(', ')}`
-    );
-  }
-
-  if (diff.agentsToUpdate.length > 0) {
-    lines.push(`🔄 Agents to update: ${diff.agentsToUpdate.map((a) => a.local.name).join(', ')}`);
-  }
-
-  if (diff.toolsToAdd.size > 0) {
-    for (const [agent, tools] of diff.toolsToAdd) {
-      lines.push(`  ➕ Add to "${agent}": ${tools.join(', ')}`);
-    }
-  }
-
-  if (diff.toolsToRemove.size > 0) {
-    for (const [agent, tools] of diff.toolsToRemove) {
-      lines.push(`  ➖ Remove from "${agent}": ${tools.join(', ')}`);
-    }
-  }
-
-  if (diff.conflicts.length > 0) {
-    lines.push('');
-    lines.push('⚠️  Conflicts detected:');
-    for (const conflict of diff.conflicts) {
-      lines.push(`  • ${conflict.description}`);
-    }
-  }
-
-  if (lines.length === 0) {
-    return '✅ Local and dashboard are in sync';
-  }
-
-  return lines.join('\n');
-}
-
-/**
- * Perform a full bidirectional sync
- */
-export async function performSync(
-  client: DashboardSyncClient,
-  localConfig: ParsedConfig,
-  options: {
-    pushOnly?: boolean;
-    pullOnly?: boolean;
-    resolveConflicts?: (conflicts: SyncConflict[]) => Promise<'local' | 'dashboard' | 'skip'>;
-  } = {}
-): Promise<{
-  success: boolean;
-  diff: SyncDiff;
-  result?: SyncResult;
-  error?: string;
-}> {
-  try {
-    // Fetch current dashboard state
-    const dashboardState = await client.fetchDashboardState();
-
-    // Compute differences
-    const diff = computeSyncDiff(localConfig, dashboardState);
-
-    // Handle conflicts if any
-    if (diff.conflicts.length > 0 && options.resolveConflicts) {
-      const resolution = await options.resolveConflicts(diff.conflicts);
-      if (resolution === 'skip') {
-        return { success: false, diff, error: 'Sync skipped due to unresolved conflicts' };
-      }
-      // Apply resolution (local wins or dashboard wins)
-      // This would modify the diff based on resolution
-    }
-
-    // Push local changes to dashboard
-    if (!options.pullOnly) {
-      // Create new agents
-      if (diff.agentsToCreate.length > 0) {
-        await client.pushAgents(diff.agentsToCreate);
-      }
-
-      // Update existing agents
-      for (const { local } of diff.agentsToUpdate) {
-        const toAdd = diff.toolsToAdd.get(local.name) || [];
-        const toRemove = diff.toolsToRemove.get(local.name) || [];
-
-        if (toAdd.length > 0 || toRemove.length > 0) {
-          await client.updateAgentTools(local.name, toAdd, toRemove);
-        }
-      }
-    }
-
-    return {
-      success: true,
-      diff,
-      result: {
-        success: true,
-        created: diff.agentsToCreate.length,
-        updated: diff.agentsToUpdate.length,
-        deleted: 0,
-        errors: [],
-      },
-    };
-  } catch (error) {
-    return {
-      success: false,
-      diff: {
-        agentsToCreate: [],
-        agentsToUpdate: [],
-        agentsToDelete: [],
-        agentsOnlyInDashboard: [],
-        toolsToAdd: new Map(),
-        toolsToRemove: new Map(),
-        conflicts: [],
-      },
-      error: error instanceof Error ? error.message : String(error),
-    };
-  }
-}
-
-export { DashboardSyncClient as default };