@agents-uni/zhenhuan 0.1.0

package/dist/palace/dynamics.js

@@ -0,0 +1,192 @@
+/**
+ * Palace Dynamics - 后宫势力与关系
+ *
+ * Manages alliances, betrayals, factions, and influence calculations
+ * within the palace hierarchy.
+ */
+/**
+ * Manages the complex political dynamics of the palace.
+ */
+export class PalaceDynamics {
+    graph;
+    registry;
+    resources;
+    allianceHistory;
+    betrayalHistory;
+    constructor(graph, registry, resources) {
+        this.graph = graph;
+        this.registry = registry;
+        this.resources = resources;
+        this.allianceHistory = [];
+        this.betrayalHistory = [];
+    }
+    /** Form an alliance between two agents */
+    formAlliance(agent1, agent2, reason) {
+        // Verify both agents exist and are active
+        const citizen1 = this.registry.get(agent1);
+        const citizen2 = this.registry.get(agent2);
+        if (!citizen1 || !citizen2)
+            return false;
+        if (citizen1.status !== 'active' && citizen1.status !== 'idle')
+            return false;
+        if (citizen2.status !== 'active' && citizen2.status !== 'idle')
+            return false;
+        // Check if they are already allies
+        const allies = this.graph.getAllies(agent1);
+        if (allies.includes(agent2))
+            return false;
+        // Add mutual ally relationships
+        this.graph.addRelationship({
+            from: agent1,
+            to: agent2,
+            type: 'ally',
+            weight: 0.7,
+            mutable: true,
+        });
+        this.graph.addRelationship({
+            from: agent2,
+            to: agent1,
+            type: 'ally',
+            weight: 0.7,
+            mutable: true,
+        });
+        this.allianceHistory.push({
+            agent1,
+            agent2,
+            reason,
+            formedAt: new Date().toISOString(),
+        });
+        return true;
+    }
+    /** Betray an alliance, creating a rivalry */
+    betrayAlliance(betrayer, betrayed, reason) {
+        // Verify they were allies
+        const allies = this.graph.getAllies(betrayer);
+        if (!allies.includes(betrayed))
+            return false;
+        // Remove ally relationships by setting weight to 0
+        this.graph.updateWeight(betrayer, betrayed, 'ally', 0, `背叛: ${reason}`);
+        this.graph.updateWeight(betrayed, betrayer, 'ally', 0, `被背叛: ${reason}`);
+        // Create rivalry
+        this.graph.addRelationship({
+            from: betrayer,
+            to: betrayed,
+            type: 'rival',
+            weight: 0.9,
+            mutable: true,
+        });
+        this.graph.addRelationship({
+            from: betrayed,
+            to: betrayer,
+            type: 'rival',
+            weight: 0.9,
+            mutable: true,
+        });
+        this.betrayalHistory.push({
+            betrayer,
+            betrayed,
+            reason,
+            occurredAt: new Date().toISOString(),
+        });
+        return true;
+    }
+    /** Calculate an agent's influence based on rank, allies, and favor */
+    calculateInfluence(agentId) {
+        const citizen = this.registry.get(agentId);
+        if (!citizen)
+            return 0;
+        // Base influence from rank (0-100)
+        const rankInfluence = (citizen.definition.rank ?? 0) * 1;
+        // Influence from allies (each ally adds proportional to their rank)
+        const allies = this.graph.getAllies(agentId);
+        let allyInfluence = 0;
+        for (const allyId of allies) {
+            const ally = this.registry.get(allyId);
+            if (ally) {
+                allyInfluence += (ally.definition.rank ?? 0) * 0.3;
+            }
+        }
+        // Influence from favor (圣宠)
+        const favor = this.resources.getBalance(agentId, '圣宠');
+        const favorInfluence = Math.min(favor * 0.1, 50);
+        // Penalty from rivals
+        const rivals = this.graph.getRivals(agentId);
+        const rivalPenalty = rivals.length * 5;
+        return Math.max(0, rankInfluence + allyInfluence + favorInfluence - rivalPenalty);
+    }
+    /** Get all factions (groups of allied agents) */
+    getFactions() {
+        const allAgents = this.registry.getAllIds();
+        const visited = new Set();
+        const factions = [];
+        let factionCounter = 0;
+        for (const agentId of allAgents) {
+            if (visited.has(agentId))
+                continue;
+            const citizen = this.registry.get(agentId);
+            if (!citizen || citizen.status === 'eliminated' || citizen.status === 'suspended') {
+                continue;
+            }
+            // BFS to find all connected allies
+            const faction = [];
+            const queue = [agentId];
+            while (queue.length > 0) {
+                const current = queue.shift();
+                if (visited.has(current))
+                    continue;
+                visited.add(current);
+                faction.push(current);
+                const allies = this.graph.getAllies(current);
+                for (const ally of allies) {
+                    if (!visited.has(ally)) {
+                        const allyCitizen = this.registry.get(ally);
+                        if (allyCitizen && allyCitizen.status !== 'eliminated' && allyCitizen.status !== 'suspended') {
+                            queue.push(ally);
+                        }
+                    }
+                }
+            }
+            if (faction.length > 1) {
+                // Find the leader (highest rank in the faction)
+                const leader = faction.reduce((best, id) => {
+                    const bestCitizen = this.registry.get(best);
+                    const currentCitizen = this.registry.get(id);
+                    const bestRank = bestCitizen?.definition.rank ?? 0;
+                    const currentRank = currentCitizen?.definition.rank ?? 0;
+                    return currentRank > bestRank ? id : best;
+                });
+                const influence = faction.reduce((sum, id) => sum + this.calculateInfluence(id), 0);
+                factions.push({
+                    id: `faction-${++factionCounter}`,
+                    members: faction,
+                    leader,
+                    influence,
+                });
+            }
+        }
+        return factions.sort((a, b) => b.influence - a.influence);
+    }
+    /** Check if a challenger can challenge a target (adjacent ranks only) */
+    canChallenge(challengerId, targetId) {
+        const challenger = this.registry.get(challengerId);
+        const target = this.registry.get(targetId);
+        if (!challenger || !target)
+            return false;
+        if (challenger.status !== 'active' && challenger.status !== 'idle')
+            return false;
+        if (target.status !== 'active' && target.status !== 'idle')
+            return false;
+        const challengerRank = challenger.definition.rank ?? 0;
+        const targetRank = target.definition.rank ?? 0;
+        // Can only challenge adjacent ranks (within 1 level)
+        return Math.abs(challengerRank - targetRank) <= 1 && challengerRank !== targetRank;
+    }
+    /** Get alliance history */
+    getAllianceHistory() {
+        return [...this.allianceHistory];
+    }
+    /** Get betrayal history */
+    getBetrayalHistory() {
+        return [...this.betrayalHistory];
+    }
+}

package/dist/palace/ranks.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Palace Rank Hierarchy - 后宫品级制度
+ *
+ * Defines the complete rank structure of the imperial harem,
+ * from 答应 (lowest) to 皇后 (highest).
+ */
+export interface PalaceRank {
+    /** Rank level (1 = lowest, 8 = highest) */
+    level: number;
+    /** Chinese title */
+    title: string;
+    /** Maximum number of agents allowed at this rank */
+    maxSlots: number;
+    /** Monthly resource allowance */
+    monthlyAllowance: number;
+    /** Minimum ELO rating required to hold this rank */
+    minElo: number;
+}
+export declare const PALACE_RANKS: readonly PalaceRank[];
+/** Get a rank by its level number */
+export declare function getRankByLevel(level: number): PalaceRank | undefined;
+/** Get a rank by its Chinese title */
+export declare function getRankByTitle(title: string): PalaceRank | undefined;
+/** Get the next higher rank */
+export declare function getNextRank(currentLevel: number): PalaceRank | undefined;
+/** Get the next lower rank */
+export declare function getPreviousRank(currentLevel: number): PalaceRank | undefined;
+/** Check if an agent can be promoted to the next rank based on ELO and slot availability */
+export declare function canPromote(currentLevel: number, elo: number): boolean;
+/** Check if a rank has reached its maximum number of occupants */
+export declare function isRankFull(level: number, currentOccupants: number): boolean;

package/dist/palace/ranks.js

@@ -0,0 +1,46 @@
+/**
+ * Palace Rank Hierarchy - 后宫品级制度
+ *
+ * Defines the complete rank structure of the imperial harem,
+ * from 答应 (lowest) to 皇后 (highest).
+ */
+export const PALACE_RANKS = [
+    { level: 1, title: '答应', maxSlots: 999, monthlyAllowance: 10, minElo: 0 },
+    { level: 2, title: '常在', maxSlots: 999, monthlyAllowance: 20, minElo: 1000 },
+    { level: 3, title: '贵人', maxSlots: 6, monthlyAllowance: 50, minElo: 1100 },
+    { level: 4, title: '嫔', maxSlots: 6, monthlyAllowance: 100, minElo: 1200 },
+    { level: 5, title: '妃', maxSlots: 4, monthlyAllowance: 200, minElo: 1300 },
+    { level: 6, title: '贵妃', maxSlots: 2, monthlyAllowance: 400, minElo: 1400 },
+    { level: 7, title: '皇贵妃', maxSlots: 1, monthlyAllowance: 800, minElo: 1500 },
+    { level: 8, title: '皇后', maxSlots: 1, monthlyAllowance: 1000, minElo: 1600 },
+];
+/** Get a rank by its level number */
+export function getRankByLevel(level) {
+    return PALACE_RANKS.find(r => r.level === level);
+}
+/** Get a rank by its Chinese title */
+export function getRankByTitle(title) {
+    return PALACE_RANKS.find(r => r.title === title);
+}
+/** Get the next higher rank */
+export function getNextRank(currentLevel) {
+    return PALACE_RANKS.find(r => r.level === currentLevel + 1);
+}
+/** Get the next lower rank */
+export function getPreviousRank(currentLevel) {
+    return PALACE_RANKS.find(r => r.level === currentLevel - 1);
+}
+/** Check if an agent can be promoted to the next rank based on ELO and slot availability */
+export function canPromote(currentLevel, elo) {
+    const nextRank = getNextRank(currentLevel);
+    if (!nextRank)
+        return false;
+    return elo >= nextRank.minElo;
+}
+/** Check if a rank has reached its maximum number of occupants */
+export function isRankFull(level, currentOccupants) {
+    const rank = getRankByLevel(level);
+    if (!rank)
+        return true;
+    return currentOccupants >= rank.maxSlots;
+}

package/dist/palace/resources.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Palace Resource Manager - 后宫资源管理
+ *
+ * Wraps agents-uni-core ResourcePool with palace-specific semantics:
+ * - 圣宠 (favor): finite, competitive, decays over time
+ * - 月例 (allowance): renewable, distributed by hierarchy
+ * - 宫殿 (palaces): positional, 12 total palaces
+ * - 侍女 (maids): finite, distributed by merit, 100 total
+ */
+import { ResourcePool } from '@agents-uni/core';
+import type { ResourceDefinition } from '@agents-uni/core';
+/** Palace-specific resource definitions */
+export declare const PALACE_RESOURCE_DEFINITIONS: ResourceDefinition[];
+/** Palace names for the 12 available palaces */
+export declare const PALACE_NAMES: readonly ["景仁宫", "承乾宫", "钟粹宫", "延禧宫", "永和宫", "景阳宫", "翊坤宫", "永寿宫", "启祥宫", "长春宫", "咸福宫", "储秀宫"];
+export interface ResourceSummary {
+    agentId: string;
+    favor: number;
+    allowance: number;
+    palace: string | null;
+    maids: number;
+}
+/**
+ * Manages palace-specific resources on top of the core ResourcePool.
+ */
+export declare class PalaceResourceManager {
+    private pool;
+    private palaceAssignments;
+    constructor(pool?: ResourcePool);
+    /** Get the underlying ResourcePool */
+    getPool(): ResourcePool;
+    /** Grant imperial favor to an agent */
+    grantFavor(agentId: string, amount: number, reason: string): boolean;
+    /** Revoke favor from an agent */
+    revokeFavor(agentId: string, amount: number, reason: string): boolean;
+    /** Distribute monthly allowance based on each agent's rank level */
+    distributeMonthlyAllowance(agents: Array<{
+        id: string;
+        rankLevel: number;
+    }>): Map<string, number>;
+    /** Assign a palace residence to an agent */
+    assignPalace(agentId: string, palaceName: string): boolean;
+    /** Get the palace assigned to an agent */
+    getPalace(agentId: string): string | null;
+    /** Release an agent's palace assignment */
+    releasePalace(agentId: string): void;
+    /** Get available (unassigned) palaces */
+    getAvailablePalaces(): string[];
+    /** Get a summary of all resources for an agent */
+    getResourceSummary(agentId: string): ResourceSummary;
+    /** Apply favor decay to all agents */
+    applyFavorDecay(): void;
+    /** Allocate maids to an agent */
+    allocateMaids(agentId: string, count: number, reason: string): boolean;
+}

package/dist/palace/resources.js

@@ -0,0 +1,146 @@
+/**
+ * Palace Resource Manager - 后宫资源管理
+ *
+ * Wraps agents-uni-core ResourcePool with palace-specific semantics:
+ * - 圣宠 (favor): finite, competitive, decays over time
+ * - 月例 (allowance): renewable, distributed by hierarchy
+ * - 宫殿 (palaces): positional, 12 total palaces
+ * - 侍女 (maids): finite, distributed by merit, 100 total
+ */
+import { ResourcePool } from '@agents-uni/core';
+import { getRankByLevel } from './ranks.js';
+/** Palace-specific resource definitions */
+export const PALACE_RESOURCE_DEFINITIONS = [
+    {
+        name: '圣宠',
+        type: 'finite',
+        total: 1000,
+        distribution: 'competitive',
+        decayRate: 0.05,
+        description: 'Imperial favor - won through competition, decays over time',
+    },
+    {
+        name: '月例',
+        type: 'renewable',
+        total: 10000,
+        distribution: 'hierarchy',
+        refreshInterval: 30 * 24 * 60 * 60 * 1000, // 30 days
+        description: 'Monthly allowance - distributed based on rank',
+    },
+    {
+        name: '宫殿',
+        type: 'positional',
+        total: 12,
+        distribution: 'hierarchy',
+        description: 'Palace residences - tied to rank and position',
+    },
+    {
+        name: '侍女',
+        type: 'finite',
+        total: 100,
+        distribution: 'merit',
+        description: 'Maids - assigned based on merit and performance',
+    },
+];
+/** Palace names for the 12 available palaces */
+export const PALACE_NAMES = [
+    '景仁宫', '承乾宫', '钟粹宫', '延禧宫',
+    '永和宫', '景阳宫', '翊坤宫', '永寿宫',
+    '启祥宫', '长春宫', '咸福宫', '储秀宫',
+];
+/**
+ * Manages palace-specific resources on top of the core ResourcePool.
+ */
+export class PalaceResourceManager {
+    pool;
+    palaceAssignments; // agentId -> palaceName
+    constructor(pool) {
+        this.pool = pool ?? new ResourcePool(PALACE_RESOURCE_DEFINITIONS);
+        this.palaceAssignments = new Map();
+    }
+    /** Get the underlying ResourcePool */
+    getPool() {
+        return this.pool;
+    }
+    /** Grant imperial favor to an agent */
+    grantFavor(agentId, amount, reason) {
+        return this.pool.allocate(agentId, '圣宠', amount, `恩赐圣宠: ${reason}`);
+    }
+    /** Revoke favor from an agent */
+    revokeFavor(agentId, amount, reason) {
+        return this.pool.revoke(agentId, '圣宠', amount, `收回圣宠: ${reason}`);
+    }
+    /** Distribute monthly allowance based on each agent's rank level */
+    distributeMonthlyAllowance(agents) {
+        const distributions = new Map();
+        for (const agent of agents) {
+            const rank = getRankByLevel(agent.rankLevel);
+            if (!rank)
+                continue;
+            const amount = rank.monthlyAllowance;
+            const success = this.pool.allocate(agent.id, '月例', amount, `月例发放 - ${rank.title}`);
+            if (success) {
+                distributions.set(agent.id, amount);
+            }
+        }
+        return distributions;
+    }
+    /** Assign a palace residence to an agent */
+    assignPalace(agentId, palaceName) {
+        // Check if the palace name is valid
+        if (!PALACE_NAMES.includes(palaceName)) {
+            return false;
+        }
+        // Check if the palace is already assigned
+        for (const [existingAgent, existingPalace] of this.palaceAssignments) {
+            if (existingPalace === palaceName && existingAgent !== agentId) {
+                return false;
+            }
+        }
+        // Remove agent's previous palace assignment
+        this.palaceAssignments.delete(agentId);
+        // Assign the new palace
+        this.palaceAssignments.set(agentId, palaceName);
+        // Track in the resource pool (1 unit = 1 palace)
+        const currentBalance = this.pool.getBalance(agentId, '宫殿');
+        if (currentBalance === 0) {
+            this.pool.allocate(agentId, '宫殿', 1, `入住${palaceName}`);
+        }
+        return true;
+    }
+    /** Get the palace assigned to an agent */
+    getPalace(agentId) {
+        return this.palaceAssignments.get(agentId) ?? null;
+    }
+    /** Release an agent's palace assignment */
+    releasePalace(agentId) {
+        const palace = this.palaceAssignments.get(agentId);
+        if (palace) {
+            this.palaceAssignments.delete(agentId);
+            this.pool.revoke(agentId, '宫殿', 1, `迁出${palace}`);
+        }
+    }
+    /** Get available (unassigned) palaces */
+    getAvailablePalaces() {
+        const assigned = new Set(this.palaceAssignments.values());
+        return PALACE_NAMES.filter(p => !assigned.has(p));
+    }
+    /** Get a summary of all resources for an agent */
+    getResourceSummary(agentId) {
+        return {
+            agentId,
+            favor: this.pool.getBalance(agentId, '圣宠'),
+            allowance: this.pool.getBalance(agentId, '月例'),
+            palace: this.palaceAssignments.get(agentId) ?? null,
+            maids: this.pool.getBalance(agentId, '侍女'),
+        };
+    }
+    /** Apply favor decay to all agents */
+    applyFavorDecay() {
+        this.pool.applyDecay('圣宠');
+    }
+    /** Allocate maids to an agent */
+    allocateMaids(agentId, count, reason) {
+        return this.pool.allocate(agentId, '侍女', count, `分配侍女: ${reason}`);
+    }
+}

package/dist/server/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Zhen Huan Palace Server - 后宫服务器
+ *
+ * HTTP API server for the palace competition system.
+ * Integrates agents-uni-core Dashboard as the homepage,
+ * and injects palace-specific extension panels (ELO, race history, factions, etc.)
+ * Uses Hono for lightweight, high-performance routing.
+ */
+export interface ServerConfig {
+    port: number;
+    specPath: string;
+    openclawDir?: string;
+}
+export declare function startServer(config: ServerConfig): Promise<void>;