85bf1341f3
Frontend Enhancements: - Complete React TypeScript frontend with modern UI components - Distributed workflows management interface with real-time updates - Socket.IO integration for live agent status monitoring - Agent management dashboard with cluster visualization - Project management interface with metrics and task tracking - Responsive design with proper error handling and loading states Backend Infrastructure: - Distributed coordinator for multi-agent workflow orchestration - Cluster management API with comprehensive agent operations - Enhanced database models for agents and projects - Project service for filesystem-based project discovery - Performance monitoring and metrics collection - Comprehensive API documentation and error handling Documentation: - Complete distributed development guide (README_DISTRIBUTED.md) - Comprehensive development report with architecture insights - System configuration templates and deployment guides The platform now provides a complete web interface for managing the distributed AI cluster with real-time monitoring, workflow orchestration, and agent coordination capabilities. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
89 lines
2.2 KiB
TypeScript
89 lines
2.2 KiB
TypeScript
import type {
|
|
AnyEqualityComparator,
|
|
Cache,
|
|
CircularState,
|
|
Dictionary,
|
|
State,
|
|
TypeEqualityComparator,
|
|
} from './internalTypes';
|
|
|
|
const { getOwnPropertyNames, getOwnPropertySymbols } = Object;
|
|
const { hasOwnProperty } = Object.prototype;
|
|
|
|
/**
|
|
* Combine two comparators into a single comparators.
|
|
*/
|
|
export function combineComparators<Meta>(
|
|
comparatorA: AnyEqualityComparator<Meta>,
|
|
comparatorB: AnyEqualityComparator<Meta>,
|
|
) {
|
|
return function isEqual<A, B>(a: A, b: B, state: State<Meta>) {
|
|
return comparatorA(a, b, state) && comparatorB(a, b, state);
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Wrap the provided `areItemsEqual` method to manage the circular state, allowing
|
|
* for circular references to be safely included in the comparison without creating
|
|
* stack overflows.
|
|
*/
|
|
export function createIsCircular<
|
|
AreItemsEqual extends TypeEqualityComparator<any, any>,
|
|
>(areItemsEqual: AreItemsEqual): AreItemsEqual {
|
|
return function isCircular(
|
|
a: any,
|
|
b: any,
|
|
state: CircularState<Cache<any, any>>,
|
|
) {
|
|
if (!a || !b || typeof a !== 'object' || typeof b !== 'object') {
|
|
return areItemsEqual(a, b, state);
|
|
}
|
|
|
|
const { cache } = state;
|
|
|
|
const cachedA = cache.get(a);
|
|
const cachedB = cache.get(b);
|
|
|
|
if (cachedA && cachedB) {
|
|
return cachedA === b && cachedB === a;
|
|
}
|
|
|
|
cache.set(a, b);
|
|
cache.set(b, a);
|
|
|
|
const result = areItemsEqual(a, b, state);
|
|
|
|
cache.delete(a);
|
|
cache.delete(b);
|
|
|
|
return result;
|
|
} as AreItemsEqual;
|
|
}
|
|
|
|
/**
|
|
* Get the properties to strictly examine, which include both own properties that are
|
|
* not enumerable and symbol properties.
|
|
*/
|
|
export function getStrictProperties(
|
|
object: Dictionary,
|
|
): Array<string | symbol> {
|
|
return (getOwnPropertyNames(object) as Array<string | symbol>).concat(
|
|
getOwnPropertySymbols(object),
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Whether the object contains the property passed as an own property.
|
|
*/
|
|
export const hasOwn =
|
|
Object.hasOwn ||
|
|
((object: Dictionary, property: number | string | symbol) =>
|
|
hasOwnProperty.call(object, property));
|
|
|
|
/**
|
|
* Whether the values passed are strictly equal or both NaN.
|
|
*/
|
|
export function sameValueZeroEqual(a: any, b: any): boolean {
|
|
return a === b || (!a && !b && a !== a && b !== b);
|
|
}
|