claude-code-swarm 0.3.2 → 0.3.4

package/references/openteams/editor/src/stores/canvas-store.ts

@@ -1,80 +0,0 @@
-import { create } from 'zustand';
-import { applyNodeChanges, applyEdgeChanges } from '@xyflow/react';
-import type { EditorNode, EditorEdge } from '../types/editor';
-
-interface CanvasStore {
-  nodes: EditorNode[];
-  edges: EditorEdge[];
-  selectedNodeId: string | null;
-  selectedEdgeId: string | null;
-
-  onNodesChange: (changes: any) => void;
-  onEdgesChange: (changes: any) => void;
-  setSelection: (nodeId: string | null, edgeId: string | null) => void;
-  setNodes: (nodes: EditorNode[]) => void;
-  setEdges: (edges: EditorEdge[]) => void;
-  addNode: (node: EditorNode) => void;
-  removeNode: (nodeId: string) => void;
-  addEdge: (edge: EditorEdge) => void;
-  removeEdge: (edgeId: string) => void;
-  updateNodeData: (nodeId: string, data: Record<string, unknown>) => void;
-  clear: () => void;
-}
-
-export const useCanvasStore = create<CanvasStore>((set, get) => ({
-  nodes: [],
-  edges: [],
-  selectedNodeId: null,
-  selectedEdgeId: null,
-
-  onNodesChange: (changes: any) => {
-    set({ nodes: applyNodeChanges(changes, get().nodes as any) as any });
-  },
-
-  onEdgesChange: (changes: any) => {
-    set({ edges: applyEdgeChanges(changes, get().edges as any) as any });
-  },
-
-  setSelection: (nodeId, edgeId) => {
-    set({ selectedNodeId: nodeId, selectedEdgeId: edgeId });
-  },
-
-  setNodes: (nodes) => set({ nodes }),
-  setEdges: (edges) => set({ edges }),
-
-  addNode: (node) => {
-    set({ nodes: [...get().nodes, node] });
-  },
-
-  removeNode: (nodeId) => {
-    const { nodes, edges } = get();
-    set({
-      nodes: nodes.filter(n => n.id !== nodeId),
-      edges: edges.filter(e => e.source !== nodeId && e.target !== nodeId),
-      selectedNodeId: get().selectedNodeId === nodeId ? null : get().selectedNodeId,
-    });
-  },
-
-  addEdge: (edge) => {
-    set({ edges: [...get().edges, edge] });
-  },
-
-  removeEdge: (edgeId) => {
-    set({
-      edges: get().edges.filter(e => e.id !== edgeId),
-      selectedEdgeId: get().selectedEdgeId === edgeId ? null : get().selectedEdgeId,
-    });
-  },
-
-  updateNodeData: (nodeId, data) => {
-    set({
-      nodes: get().nodes.map(n =>
-        n.id === nodeId ? { ...n, data: { ...n.data, ...data } } : n
-      ) as EditorNode[],
-    });
-  },
-
-  clear: () => {
-    set({ nodes: [], edges: [], selectedNodeId: null, selectedEdgeId: null });
-  },
-}));

package/references/openteams/editor/src/stores/config-store.ts

@@ -1,243 +0,0 @@
-import { create } from 'zustand';
-import type {
-  ChannelDefinition,
-  SubscriptionEntry,
-  PeerRoute,
-} from '@openteams/template/types';
-
-export interface EditorRoleConfig {
-  name: string;
-  displayName: string;
-  description: string;
-  extends?: string;
-  capabilities: string[];
-  promptContent?: string;
-  additionalPrompts?: { name: string; content: string }[];
-}
-
-export interface EditorTeamConfig {
-  name: string;
-  description: string;
-  version: 1;
-  enforcement: 'strict' | 'permissive' | 'audit';
-  extensions: Record<string, unknown>;
-}
-
-interface ConfigStore {
-  team: EditorTeamConfig;
-  roles: Map<string, EditorRoleConfig>;
-  channels: Record<string, ChannelDefinition>;
-  subscriptions: Record<string, SubscriptionEntry[]>;
-  emissions: Record<string, string[]>;
-  peerRoutes: PeerRoute[];
-  spawnRules: Record<string, string[]>;
-  roleModels: Record<string, string>;
-  topologyRoot: string;
-  topologyCompanions: string[];
-
-  setTeam: (team: Partial<EditorTeamConfig>) => void;
-  setRole: (name: string, role: EditorRoleConfig) => void;
-  removeRole: (name: string) => void;
-  renameRole: (oldName: string, newName: string) => void;
-  setChannel: (name: string, channel: ChannelDefinition) => void;
-  removeChannel: (name: string) => void;
-  setSubscriptions: (role: string, subs: SubscriptionEntry[]) => void;
-  setEmissions: (role: string, signals: string[]) => void;
-  addPeerRoute: (route: PeerRoute) => void;
-  removePeerRoute: (index: number) => void;
-  setPeerRoutes: (routes: PeerRoute[]) => void;
-  setSpawnRules: (role: string, canSpawn: string[]) => void;
-  setRoleModel: (role: string, model: string | undefined) => void;
-  setTopologyRoot: (role: string) => void;
-  setTopologyCompanions: (roles: string[]) => void;
-  clear: () => void;
-  loadFromManifest: (
-    team: EditorTeamConfig,
-    roles: Map<string, EditorRoleConfig>,
-    channels: Record<string, ChannelDefinition>,
-    subscriptions: Record<string, SubscriptionEntry[]>,
-    emissions: Record<string, string[]>,
-    peerRoutes: PeerRoute[],
-    spawnRules: Record<string, string[]>,
-    roleModels: Record<string, string>,
-    topologyRoot: string,
-    topologyCompanions: string[],
-  ) => void;
-}
-
-const defaultTeam: EditorTeamConfig = {
-  name: 'new-team',
-  description: '',
-  version: 1,
-  enforcement: 'permissive',
-  extensions: {},
-};
-
-export const useConfigStore = create<ConfigStore>((set, get) => ({
-  team: { ...defaultTeam },
-  roles: new Map(),
-  channels: {},
-  subscriptions: {},
-  emissions: {},
-  peerRoutes: [],
-  spawnRules: {},
-  roleModels: {},
-  topologyRoot: '',
-  topologyCompanions: [],
-
-  setTeam: (updates) => {
-    set({ team: { ...get().team, ...updates } });
-  },
-
-  setRole: (name, role) => {
-    const roles = new Map(get().roles);
-    roles.set(name, role);
-    set({ roles });
-  },
-
-  removeRole: (name) => {
-    const roles = new Map(get().roles);
-    roles.delete(name);
-    const { subscriptions, emissions, spawnRules, topologyRoot, topologyCompanions, peerRoutes } = get();
-    const newSubs = { ...subscriptions };
-    delete newSubs[name];
-    const newEmissions = { ...emissions };
-    delete newEmissions[name];
-    const newSpawnRules = { ...spawnRules };
-    delete newSpawnRules[name];
-    // Remove from other spawn rules
-    for (const key of Object.keys(newSpawnRules)) {
-      newSpawnRules[key] = newSpawnRules[key].filter(r => r !== name);
-    }
-    const newModels = { ...get().roleModels };
-    delete newModels[name];
-    set({
-      roles,
-      subscriptions: newSubs,
-      emissions: newEmissions,
-      spawnRules: newSpawnRules,
-      roleModels: newModels,
-      peerRoutes: peerRoutes.filter(r => r.from !== name && r.to !== name),
-      topologyRoot: topologyRoot === name ? '' : topologyRoot,
-      topologyCompanions: topologyCompanions.filter(c => c !== name),
-    });
-  },
-
-  renameRole: (oldName, newName) => {
-    const { roles, subscriptions, emissions, spawnRules, topologyRoot, topologyCompanions, peerRoutes } = get();
-    const newRoles = new Map<string, EditorRoleConfig>();
-    for (const [key, val] of roles) {
-      if (key === oldName) {
-        newRoles.set(newName, { ...val, name: newName });
-      } else {
-        newRoles.set(key, val);
-      }
-    }
-
-    const newSubs: Record<string, SubscriptionEntry[]> = {};
-    for (const [key, val] of Object.entries(subscriptions)) {
-      newSubs[key === oldName ? newName : key] = val;
-    }
-
-    const newEmissions: Record<string, string[]> = {};
-    for (const [key, val] of Object.entries(emissions)) {
-      newEmissions[key === oldName ? newName : key] = val;
-    }
-
-    const newSpawnRules: Record<string, string[]> = {};
-    for (const [key, val] of Object.entries(spawnRules)) {
-      const renamedKey = key === oldName ? newName : key;
-      newSpawnRules[renamedKey] = val.map(r => (r === oldName ? newName : r));
-    }
-
-    const newModels: Record<string, string> = {};
-    for (const [key, val] of Object.entries(get().roleModels)) {
-      newModels[key === oldName ? newName : key] = val;
-    }
-    set({
-      roles: newRoles,
-      subscriptions: newSubs,
-      emissions: newEmissions,
-      spawnRules: newSpawnRules,
-      roleModels: newModels,
-      peerRoutes: peerRoutes.map(r => ({
-        ...r,
-        from: r.from === oldName ? newName : r.from,
-        to: r.to === oldName ? newName : r.to,
-      })),
-      topologyRoot: topologyRoot === oldName ? newName : topologyRoot,
-      topologyCompanions: topologyCompanions.map(c => (c === oldName ? newName : c)),
-    });
-  },
-
-  setChannel: (name, channel) => {
-    set({ channels: { ...get().channels, [name]: channel } });
-  },
-
-  removeChannel: (name) => {
-    const channels = { ...get().channels };
-    delete channels[name];
-    // Remove subscriptions referencing this channel
-    const subs = { ...get().subscriptions };
-    for (const role of Object.keys(subs)) {
-      subs[role] = subs[role].filter(s => s.channel !== name);
-    }
-    set({ channels, subscriptions: subs });
-  },
-
-  setSubscriptions: (role, subs) => {
-    set({ subscriptions: { ...get().subscriptions, [role]: subs } });
-  },
-
-  setEmissions: (role, signals) => {
-    set({ emissions: { ...get().emissions, [role]: signals } });
-  },
-
-  addPeerRoute: (route) => {
-    set({ peerRoutes: [...get().peerRoutes, route] });
-  },
-
-  removePeerRoute: (index) => {
-    set({ peerRoutes: get().peerRoutes.filter((_, i) => i !== index) });
-  },
-
-  setPeerRoutes: (routes) => {
-    set({ peerRoutes: routes });
-  },
-
-  setSpawnRules: (role, canSpawn) => {
-    set({ spawnRules: { ...get().spawnRules, [role]: canSpawn } });
-  },
-
-  setRoleModel: (role, model) => {
-    const models = { ...get().roleModels };
-    if (model) {
-      models[role] = model;
-    } else {
-      delete models[role];
-    }
-    set({ roleModels: models });
-  },
-
-  setTopologyRoot: (role) => set({ topologyRoot: role }),
-  setTopologyCompanions: (roles) => set({ topologyCompanions: roles }),
-
-  clear: () => {
-    set({
-      team: { ...defaultTeam },
-      roles: new Map(),
-      channels: {},
-      subscriptions: {},
-      emissions: {},
-      peerRoutes: [],
-      spawnRules: {},
-      roleModels: {},
-      topologyRoot: '',
-      topologyCompanions: [],
-    });
-  },
-
-  loadFromManifest: (team, roles, channels, subscriptions, emissions, peerRoutes, spawnRules, roleModels, topologyRoot, topologyCompanions) => {
-    set({ team, roles, channels, subscriptions, emissions, peerRoutes, spawnRules, roleModels, topologyRoot, topologyCompanions });
-  },
-}));

package/references/openteams/editor/src/stores/history-store.ts

@@ -1,143 +0,0 @@
-import { create } from 'zustand';
-import { useCanvasStore } from './canvas-store';
-import { useConfigStore } from './config-store';
-import type { EditorNode, EditorEdge } from '../types/editor';
-import type { EditorRoleConfig, EditorTeamConfig } from './config-store';
-import type {
-  ChannelDefinition,
-  SubscriptionEntry,
-  PeerRoute,
-} from '@openteams/template/types';
-
-interface Snapshot {
-  canvas: {
-    nodes: EditorNode[];
-    edges: EditorEdge[];
-  };
-  config: {
-    team: EditorTeamConfig;
-    roles: Map<string, EditorRoleConfig>;
-    channels: Record<string, ChannelDefinition>;
-    subscriptions: Record<string, SubscriptionEntry[]>;
-    emissions: Record<string, string[]>;
-    peerRoutes: PeerRoute[];
-    spawnRules: Record<string, string[]>;
-    roleModels: Record<string, string>;
-    topologyRoot: string;
-    topologyCompanions: string[];
-  };
-}
-
-const MAX_HISTORY = 50;
-
-function deepClone<T>(obj: T): T {
-  if (obj instanceof Map) {
-    const result = new Map();
-    for (const [key, val] of obj) {
-      result.set(key, deepClone(val));
-    }
-    return result as T;
-  }
-  return structuredClone(obj);
-}
-
-function captureSnapshot(): Snapshot {
-  const canvas = useCanvasStore.getState();
-  const config = useConfigStore.getState();
-  return {
-    canvas: {
-      nodes: deepClone(canvas.nodes),
-      edges: deepClone(canvas.edges),
-    },
-    config: {
-      team: deepClone(config.team),
-      roles: deepClone(config.roles),
-      channels: deepClone(config.channels),
-      subscriptions: deepClone(config.subscriptions),
-      emissions: deepClone(config.emissions),
-      peerRoutes: deepClone(config.peerRoutes),
-      spawnRules: deepClone(config.spawnRules),
-      roleModels: deepClone(config.roleModels),
-      topologyRoot: config.topologyRoot,
-      topologyCompanions: [...config.topologyCompanions],
-    },
-  };
-}
-
-function restoreSnapshot(snapshot: Snapshot) {
-  const canvasState = deepClone(snapshot.canvas);
-  const configState = deepClone(snapshot.config);
-
-  useCanvasStore.getState().setNodes(canvasState.nodes);
-  useCanvasStore.getState().setEdges(canvasState.edges);
-  useConfigStore.getState().loadFromManifest(
-    configState.team,
-    configState.roles,
-    configState.channels,
-    configState.subscriptions,
-    configState.emissions,
-    configState.peerRoutes,
-    configState.spawnRules,
-    configState.roleModels,
-    configState.topologyRoot,
-    configState.topologyCompanions,
-  );
-}
-
-interface HistoryStore {
-  undoStack: Snapshot[];
-  redoStack: Snapshot[];
-  pushSnapshot: () => void;
-  undo: () => void;
-  redo: () => void;
-  canUndo: () => boolean;
-  canRedo: () => boolean;
-  clear: () => void;
-}
-
-export const useHistoryStore = create<HistoryStore>((set, get) => ({
-  undoStack: [],
-  redoStack: [],
-
-  pushSnapshot: () => {
-    const snapshot = captureSnapshot();
-    const stack = [...get().undoStack, snapshot];
-    if (stack.length > MAX_HISTORY) stack.shift();
-    set({ undoStack: stack, redoStack: [] });
-  },
-
-  undo: () => {
-    const { undoStack } = get();
-    if (undoStack.length === 0) return;
-
-    const currentSnapshot = captureSnapshot();
-    const previous = undoStack[undoStack.length - 1];
-    const newUndo = undoStack.slice(0, -1);
-
-    restoreSnapshot(previous);
-    set({
-      undoStack: newUndo,
-      redoStack: [...get().redoStack, currentSnapshot],
-    });
-  },
-
-  redo: () => {
-    const { redoStack } = get();
-    if (redoStack.length === 0) return;
-
-    const currentSnapshot = captureSnapshot();
-    const next = redoStack[redoStack.length - 1];
-    const newRedo = redoStack.slice(0, -1);
-
-    restoreSnapshot(next);
-    set({
-      undoStack: [...get().undoStack, currentSnapshot],
-      redoStack: newRedo,
-    });
-  },
-
-  canUndo: () => get().undoStack.length > 0,
-  canRedo: () => get().redoStack.length > 0,
-
-  clear: () => set({ undoStack: [], redoStack: [] }),
-}));

package/references/openteams/editor/src/stores/theme-store.ts

@@ -1,66 +0,0 @@
-/**
- * Theme store: manages dark/light/system theme with persistence.
- * Mirrors the OpenHive theme pattern for visual coherence.
- */
-
-import { create } from 'zustand';
-
-type Theme = 'dark' | 'light' | 'system';
-
-interface ThemeStore {
-  theme: Theme;
-  resolvedTheme: 'dark' | 'light';
-  setTheme: (theme: Theme) => void;
-}
-
-function getSystemTheme(): 'dark' | 'light' {
-  if (typeof window === 'undefined') return 'dark';
-  return window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
-}
-
-function resolveTheme(theme: Theme): 'dark' | 'light' {
-  return theme === 'system' ? getSystemTheme() : theme;
-}
-
-function applyTheme(resolved: 'dark' | 'light') {
-  if (typeof document === 'undefined') return;
-  const root = document.documentElement;
-  root.classList.toggle('dark', resolved === 'dark');
-  root.classList.toggle('light', resolved === 'light');
-}
-
-// Hydrate from localStorage
-function loadPersistedTheme(): Theme {
-  try {
-    const stored = localStorage.getItem('ot-editor-theme');
-    if (stored === 'dark' || stored === 'light' || stored === 'system') return stored;
-  } catch { /* ignore */ }
-  return 'dark';
-}
-
-const initialTheme = loadPersistedTheme();
-const initialResolved = resolveTheme(initialTheme);
-applyTheme(initialResolved);
-
-export const useThemeStore = create<ThemeStore>((set) => ({
-  theme: initialTheme,
-  resolvedTheme: initialResolved,
-  setTheme: (theme: Theme) => {
-    const resolvedTheme = resolveTheme(theme);
-    applyTheme(resolvedTheme);
-    try { localStorage.setItem('ot-editor-theme', theme); } catch { /* ignore */ }
-    set({ theme, resolvedTheme });
-  },
-}));
-
-// Listen for system theme changes
-if (typeof window !== 'undefined') {
-  window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', (e) => {
-    const state = useThemeStore.getState();
-    if (state.theme === 'system') {
-      const resolvedTheme = e.matches ? 'dark' : 'light';
-      applyTheme(resolvedTheme);
-      useThemeStore.setState({ resolvedTheme });
-    }
-  });
-}

package/references/openteams/editor/src/stores/ui-store.ts

@@ -1,46 +0,0 @@
-import { create } from 'zustand';
-
-interface Layers {
-  peerRoutes: boolean;
-  channels: boolean;
-  spawnRules: boolean;
-  inheritance: boolean;
-}
-
-interface UIStore {
-  sidebarOpen: boolean;
-  inspectorOpen: boolean;
-  importModalOpen: boolean;
-  exportModalOpen: boolean;
-  layers: Layers;
-
-  toggleSidebar: () => void;
-  toggleInspector: () => void;
-  setImportModalOpen: (open: boolean) => void;
-  setExportModalOpen: (open: boolean) => void;
-  toggleLayer: (layer: keyof Layers) => void;
-}
-
-export const useUIStore = create<UIStore>((set, get) => ({
-  sidebarOpen: true,
-  inspectorOpen: true,
-  importModalOpen: false,
-  exportModalOpen: false,
-  layers: {
-    peerRoutes: true,
-    channels: true,
-    spawnRules: false,
-    inheritance: false,
-  },
-
-  toggleSidebar: () => set({ sidebarOpen: !get().sidebarOpen }),
-  toggleInspector: () => set({ inspectorOpen: !get().inspectorOpen }),
-  setImportModalOpen: (open) => set({ importModalOpen: open }),
-  setExportModalOpen: (open) => set({ exportModalOpen: open }),
-
-  toggleLayer: (layer) => {
-    const layers = { ...get().layers };
-    layers[layer] = !layers[layer];
-    set({ layers });
-  },
-}));

package/references/openteams/editor/src/stores/validation-store.ts

@@ -1,27 +0,0 @@
-import { create } from 'zustand';
-
-export interface ValidationIssue {
-  path: string;
-  message: string;
-  severity: 'error' | 'warning';
-  nodeId?: string;
-}
-
-interface ValidationStore {
-  errors: ValidationIssue[];
-  warnings: ValidationIssue[];
-  isValidating: boolean;
-  setResults: (errors: ValidationIssue[], warnings: ValidationIssue[]) => void;
-  setValidating: (v: boolean) => void;
-  clear: () => void;
-}
-
-export const useValidationStore = create<ValidationStore>((set) => ({
-  errors: [],
-  warnings: [],
-  isValidating: false,
-
-  setResults: (errors, warnings) => set({ errors, warnings, isValidating: false }),
-  setValidating: (v) => set({ isValidating: v }),
-  clear: () => set({ errors: [], warnings: [], isValidating: false }),
-}));

package/references/openteams/editor/src/types/editor.ts

@@ -1,74 +0,0 @@
-import type { Node, Edge } from '@xyflow/react';
-
-// ── Node Data ──────────────────────────────────────────
-// Index signatures are required by React Flow v12's Node<T> constraint.
-
-export interface RoleNodeData extends Record<string, unknown> {
-  kind: 'role';
-  roleName: string;
-  displayName: string;
-  description: string;
-  topologyPosition: 'root' | 'companion' | 'spawned';
-  model?: string;
-  capabilities: string[];
-  extends?: string;
-  emits: string[];
-  subscribesTo: SubscriptionSummary[];
-  peerRoutesOut: number;
-  peerRoutesIn: number;
-  canSpawn: string[];
-  errors: string[];
-  warnings: string[];
-}
-
-export interface SubscriptionSummary {
-  channel: string;
-  signals: string[] | 'all';
-}
-
-export interface ChannelNodeData extends Record<string, unknown> {
-  kind: 'channel';
-  channelName: string;
-  description: string;
-  signals: string[];
-  emitterCount: number;
-  subscriberCount: number;
-}
-
-// ── Edge Data ──────────────────────────────────────────
-
-export interface PeerRouteEdgeData extends Record<string, unknown> {
-  kind: 'peer-route';
-  signals: string[];
-  via: 'direct' | 'topic' | 'scope';
-}
-
-export interface SignalFlowEdgeData extends Record<string, unknown> {
-  kind: 'signal-flow';
-  direction: 'emission' | 'subscription';
-  channel: string;
-  signals: string[];
-}
-
-export interface SpawnEdgeData extends Record<string, unknown> {
-  kind: 'spawn';
-}
-
-// ── Unions ─────────────────────────────────────────────
-
-export type RoleNode = Node<RoleNodeData, 'role'>;
-export type ChannelNode = Node<ChannelNodeData, 'channel'>;
-
-export type EditorNode = RoleNode | ChannelNode;
-export type EditorEdge =
-  | Edge<PeerRouteEdgeData>
-  | Edge<SignalFlowEdgeData>
-  | Edge<SpawnEdgeData>;
-
-// ── Canvas State ───────────────────────────────────────
-
-export interface CanvasState {
-  nodes: EditorNode[];
-  edges: EditorEdge[];
-  viewport: { x: number; y: number; zoom: number };
-}

package/references/openteams/editor/src/vite-env.d.ts

@@ -1 +0,0 @@
-/// <reference types="vite/client" />