@evo-dev/core 0.0.1-alpha

package/src/sync/orchestrator.ts

@@ -0,0 +1,298 @@
+import { join } from "node:path";
+import { type AssetScanResult, type ScannedAsset, scanAssets } from "../assets/index.ts";
+import type { AgentManifest, SkillManifest } from "../assets/manifest.ts";
+import {
+  type CoreConfigStore,
+  type EvoDevRegistry,
+  type EvoDevSettings,
+  type RegisteredAsset,
+  type SyncState,
+  createCoreConfigStore,
+  createDefaultRegistry,
+  createDefaultSyncState,
+} from "../config/index.ts";
+import {
+  type CodeAgentPlugin,
+  type PluginId,
+  type PluginRegistry,
+  type SyncPlan,
+  type SyncResult,
+  getEnabledPluginIds,
+} from "../plugins/index.ts";
+
+export interface SyncOrchestratorOptions {
+  homeDir: string;
+  assetsRootDir: string;
+  pluginRegistry: PluginRegistry;
+  dryRun?: boolean;
+  targetPlugins?: PluginId[];
+  includeSkills?: boolean;
+  includeAgents?: boolean;
+  now?: () => string;
+}
+
+export interface SyncRunResult {
+  plans: SyncPlan[];
+  results: SyncResult[];
+  registry: EvoDevRegistry;
+  syncState: SyncState;
+}
+
+export async function runSync(options: SyncOrchestratorOptions): Promise<SyncRunResult> {
+  const store = createCoreConfigStore(options.homeDir);
+
+  const settings = await store.readSettings();
+  const assets = await scanAssets(resolveAssetScannerPaths(options.assetsRootDir));
+  const plugins = getSyncTargetPlugins(settings, options.pluginRegistry, options.targetPlugins);
+  const plans = buildSyncPlans({
+    settings,
+    assets,
+    plugins,
+    dryRun: options.dryRun ?? false,
+    includeSkills: options.includeSkills,
+    includeAgents: options.includeAgents,
+  });
+  const results = await executeSyncPlans(plans, plugins);
+  const registry = updateRegistryWithSyncResults(
+    await readRegistryOrDefault(store),
+    assets,
+    results,
+  );
+  const syncState = updateSyncStateWithResults(
+    await readSyncStateOrDefault(store),
+    results,
+    options.now?.() ?? new Date().toISOString(),
+  );
+
+  if (!(options.dryRun ?? false) && shouldPersistSyncResults(results)) {
+    await store.writeRegistry(registry);
+    await store.writeSyncState(syncState);
+  }
+
+  return { plans, results, registry, syncState };
+}
+
+export interface BuildSyncPlansInput {
+  settings: EvoDevSettings;
+  assets: AssetScanResult;
+  plugins: CodeAgentPlugin[];
+  dryRun: boolean;
+  includeSkills?: boolean;
+  includeAgents?: boolean;
+}
+
+export function buildSyncPlans(input: BuildSyncPlansInput): SyncPlan[] {
+  const shouldIncludeSkills = input.includeSkills ?? true;
+  const shouldIncludeAgents = input.includeAgents ?? true;
+  const skills =
+    input.settings.assets.skills.enabled && shouldIncludeSkills ? input.assets.skills : [];
+  const agents =
+    input.settings.assets.agents.enabled && shouldIncludeAgents ? input.assets.agents : [];
+
+  return input.plugins.map((plugin) => ({
+    targetPlugin: plugin.id,
+    skills: filterAssetsForTarget(skills, plugin.id),
+    agents: filterAssetsForTarget(agents, plugin.id),
+    dryRun: input.dryRun,
+  }));
+}
+
+async function executeSyncPlans(
+  plans: SyncPlan[],
+  plugins: CodeAgentPlugin[],
+): Promise<SyncResult[]> {
+  const pluginById = new Map(plugins.map((plugin) => [plugin.id, plugin]));
+  const results: SyncResult[] = [];
+
+  for (const plan of plans) {
+    const plugin = pluginById.get(plan.targetPlugin);
+
+    if (plugin === undefined) {
+      throw new Error(`Cannot execute sync plan for unregistered plugin: ${plan.targetPlugin}`);
+    }
+
+    const [skillsResult, agentsResult] = await Promise.all([
+      plugin.syncSkills({
+        targetPlugin: plan.targetPlugin,
+        skills: plan.skills,
+        dryRun: plan.dryRun,
+      }),
+      plugin.syncAgents({
+        targetPlugin: plan.targetPlugin,
+        agents: plan.agents,
+        dryRun: plan.dryRun,
+      }),
+    ]);
+
+    results.push(mergeSyncResults(plan.targetPlugin, skillsResult, agentsResult));
+  }
+
+  return results;
+}
+
+function mergeSyncResults(
+  targetPlugin: string,
+  skillsResult: SyncResult,
+  agentsResult: SyncResult,
+): SyncResult {
+  return {
+    targetPlugin,
+    syncedSkills: unique([...skillsResult.syncedSkills, ...agentsResult.syncedSkills]),
+    syncedAgents: unique([...skillsResult.syncedAgents, ...agentsResult.syncedAgents]),
+    skipped: unique([...skillsResult.skipped, ...agentsResult.skipped]),
+    warnings: [...skillsResult.warnings, ...agentsResult.warnings],
+    errors: [...skillsResult.errors, ...agentsResult.errors],
+  };
+}
+
+function updateRegistryWithSyncResults(
+  registry: EvoDevRegistry,
+  assets: AssetScanResult,
+  results: SyncResult[],
+): EvoDevRegistry {
+  const next: EvoDevRegistry = {
+    version: 1,
+    skills: { ...registry.skills },
+    agents: { ...registry.agents },
+  };
+
+  for (const result of results) {
+    for (const key of result.syncedSkills) {
+      const asset = assets.skills.find((candidate) => candidate.registryKey === key);
+      if (asset !== undefined) {
+        next.skills[key] = mergeRegisteredAsset(
+          next.skills[key],
+          asset.manifest.version,
+          result.targetPlugin,
+        );
+      }
+    }
+
+    for (const key of result.syncedAgents) {
+      const asset = assets.agents.find((candidate) => candidate.registryKey === key);
+      if (asset !== undefined) {
+        next.agents[key] = mergeRegisteredAsset(
+          next.agents[key],
+          asset.manifest.version,
+          result.targetPlugin,
+        );
+      }
+    }
+  }
+
+  return next;
+}
+
+function updateSyncStateWithResults(
+  syncState: SyncState,
+  results: SyncResult[],
+  timestamp: string,
+): SyncState {
+  const next: SyncState = {
+    version: 1,
+    lastSyncAt: timestamp,
+    targets: { ...syncState.targets },
+  };
+
+  for (const result of results) {
+    next.targets[result.targetPlugin] = {
+      skills: result.syncedSkills.length,
+      agents: result.syncedAgents.length,
+      status: getSyncStatus(result),
+    };
+  }
+
+  return next;
+}
+
+function getSyncTargetPlugins(
+  settings: EvoDevSettings,
+  pluginRegistry: PluginRegistry,
+  targetPlugins: PluginId[] | undefined,
+): CodeAgentPlugin[] {
+  const enabledPluginIds = getEnabledPluginIds(settings);
+  const selectedPluginIds =
+    targetPlugins === undefined
+      ? enabledPluginIds
+      : unique(targetPlugins).filter((pluginId) => enabledPluginIds.includes(pluginId));
+
+  return selectedPluginIds.map((pluginId) => pluginRegistry.require(pluginId));
+}
+
+function shouldPersistSyncResults(results: SyncResult[]): boolean {
+  if (results.length === 0) return false;
+  if (results.every((result) => result.errors.length === 0)) return true;
+  return results.some((result) => result.syncedSkills.length > 0 || result.syncedAgents.length > 0);
+}
+
+function getSyncStatus(result: SyncResult): "success" | "partial" | "failed" {
+  if (result.errors.length === 0) {
+    return "success";
+  }
+
+  if (result.syncedSkills.length > 0 || result.syncedAgents.length > 0) {
+    return "partial";
+  }
+
+  return "failed";
+}
+
+function mergeRegisteredAsset(
+  existing: RegisteredAsset | undefined,
+  version: string,
+  targetPlugin: string,
+): RegisteredAsset {
+  return {
+    version,
+    source: existing?.source ?? "builtin",
+    targets: unique([...(existing?.targets ?? []), targetPlugin]),
+  };
+}
+
+function filterAssetsForTarget<TManifest extends SkillManifest | AgentManifest>(
+  assets: ScannedAsset<TManifest>[],
+  targetPlugin: string,
+): ScannedAsset<TManifest>[] {
+  return assets.filter((asset) =>
+    asset.manifest.targets.includes(targetPlugin as "claude" | "codex"),
+  );
+}
+
+function resolveAssetScannerPaths(assetsRootDir: string): { skillsDir: string; agentsDir: string } {
+  return {
+    skillsDir: join(assetsRootDir, "skills"),
+    agentsDir: join(assetsRootDir, "agents"),
+  };
+}
+
+async function readRegistryOrDefault(store: CoreConfigStore): Promise<EvoDevRegistry> {
+  try {
+    return await store.readRegistry();
+  } catch (error) {
+    if (isNotFoundError(error)) {
+      return createDefaultRegistry();
+    }
+
+    throw error;
+  }
+}
+
+async function readSyncStateOrDefault(store: CoreConfigStore): Promise<SyncState> {
+  try {
+    return await store.readSyncState();
+  } catch (error) {
+    if (isNotFoundError(error)) {
+      return createDefaultSyncState();
+    }
+
+    throw error;
+  }
+}
+
+function isNotFoundError(error: unknown): boolean {
+  return error instanceof Error && error.message.includes("ENOENT");
+}
+
+function unique<T>(values: T[]): T[] {
+  return [...new Set(values)];
+}