genesis-ai-cli 13.11.0 → 13.12.0

package/dist/src/morphogenetic/index.d.ts

@@ -0,0 +1,279 @@
+/**
+ * Morphogenetic Module - Bio-inspired Self-Repair
+ *
+ * Implements Michael Levin's morphogenetic principles:
+ * - Target morphology (desired functional shape)
+ * - Bioelectric-inspired error signals
+ * - Cellular automata for collective repair
+ * - Self-correcting agent colonies
+ *
+ * Agents know their target state and work collectively
+ * to achieve and maintain it, like cells in a regenerating organism.
+ *
+ * Based on:
+ * - Michael Levin's bioelectric research
+ * - Neural Cellular Automata (NCA)
+ * - Morphogenetic fields
+ */
+import { EventEmitter } from 'events';
+export interface Capability {
+    id: string;
+    name: string;
+    level: number;
+    required: number;
+    dependencies: string[];
+}
+export interface AgentMorphology {
+    capabilities: Map<string, Capability>;
+    connections: Map<string, string[]>;
+    position: number[];
+    health: number;
+}
+export interface TargetMorphology {
+    requiredCapabilities: Map<string, number>;
+    minHealth: number;
+    optimalConnections: number;
+    description: string;
+}
+export interface MorphogeneticError {
+    type: 'missing' | 'degraded' | 'disconnected' | 'excess';
+    capability?: string;
+    magnitude: number;
+    priority: number;
+}
+export interface RepairAction {
+    type: 'regenerate' | 'strengthen' | 'connect' | 'prune';
+    target: string;
+    parameters: Record<string, unknown>;
+    estimatedCost: number;
+    estimatedTime: number;
+}
+export interface CellState {
+    id: string;
+    type: CellType;
+    potential: number;
+    neighbors: string[];
+    alive: boolean;
+    age: number;
+}
+export type CellType = 'stem' | 'sensor' | 'processor' | 'effector' | 'memory' | 'communicator';
+export interface MorphogeneticConfig {
+    errorThreshold: number;
+    degradationRate: number;
+    regenerationRate: number;
+    healingCost: number;
+    gridSize: number;
+    updateInterval: number;
+    minQuorum: number;
+    consensusThreshold: number;
+}
+export interface MorphogeneticMetrics {
+    totalErrors: number;
+    repairsAttempted: number;
+    repairsSucceeded: number;
+    regenerations: number;
+    currentHealth: number;
+    morphogeneticDistance: number;
+}
+export declare class MorphogeneticAgent extends EventEmitter {
+    readonly id: string;
+    private morphology;
+    private targetMorphology;
+    private config;
+    private errors;
+    private metrics;
+    constructor(id: string, targetMorphology: TargetMorphology, config?: Partial<MorphogeneticConfig>);
+    /**
+     * Initialize morphology from target
+     */
+    private initializeMorphology;
+    /**
+     * Calculate morphogenetic error
+     * Returns distance from current state to target morphology
+     */
+    morphogeneticError(): number;
+    /**
+     * Detect errors in current morphology
+     */
+    detectErrors(): MorphogeneticError[];
+    /**
+     * Get missing capabilities
+     */
+    missingCapabilities(): string[];
+    /**
+     * Self-correct toward target morphology
+     */
+    selfCorrect(): RepairAction[];
+    /**
+     * Execute a repair action
+     */
+    executeRepair(action: RepairAction): Promise<boolean>;
+    /**
+     * Regenerate a capability
+     */
+    private regenerate;
+    /**
+     * Strengthen a capability or health
+     */
+    private strengthen;
+    /**
+     * Connect to another capability/agent
+     */
+    private connect;
+    /**
+     * Prune an excess capability
+     */
+    private prune;
+    /**
+     * Update overall health based on capabilities
+     */
+    private updateHealth;
+    /**
+     * Apply degradation over time
+     */
+    degrade(): void;
+    /**
+     * Get current morphology
+     */
+    getMorphology(): AgentMorphology;
+    /**
+     * Get target morphology
+     */
+    getTarget(): TargetMorphology;
+    /**
+     * Get metrics
+     */
+    getMetrics(): MorphogeneticMetrics;
+    /**
+     * Get current errors
+     */
+    getErrors(): MorphogeneticError[];
+    /**
+     * Helper delay function
+     */
+    private delay;
+}
+export declare class NeuralCellularAutomata extends EventEmitter {
+    private grid;
+    private config;
+    private generation;
+    private targetPattern;
+    constructor(config?: Partial<MorphogeneticConfig>);
+    /**
+     * Initialize grid with stem cells
+     */
+    private initializeGrid;
+    /**
+     * Get neighbor cell IDs
+     */
+    private getNeighborIds;
+    /**
+     * Set target pattern
+     */
+    setTargetPattern(pattern: Map<string, CellType>): void;
+    /**
+     * Update one generation
+     */
+    step(): void;
+    /**
+     * Update single cell based on neighbors
+     */
+    private updateCell;
+    /**
+     * Differentiate stem cell based on potential and neighbors
+     */
+    private differentiate;
+    /**
+     * Calculate distance from target pattern
+     */
+    patternError(): number;
+    /**
+     * Run until pattern converges or max generations
+     */
+    runUntilConverged(maxGenerations?: number): Promise<number>;
+    /**
+     * Get grid state
+     */
+    getGrid(): Map<string, CellState>;
+    /**
+     * Get cell at position
+     */
+    getCell(x: number, y: number): CellState | undefined;
+    /**
+     * Get generation count
+     */
+    getGeneration(): number;
+    /**
+     * Count cells by type
+     */
+    getCellCounts(): Map<CellType, number>;
+    /**
+     * Reset grid
+     */
+    reset(): void;
+}
+export declare class AgentColony extends EventEmitter {
+    private agents;
+    private config;
+    private sharedKnowledge;
+    constructor(config?: Partial<MorphogeneticConfig>);
+    /**
+     * Add agent to colony
+     */
+    addAgent(agent: MorphogeneticAgent): void;
+    /**
+     * Remove agent from colony
+     */
+    removeAgent(id: string): boolean;
+    /**
+     * Share knowledge across colony
+     */
+    shareKnowledge(key: string, value: unknown): void;
+    /**
+     * Collective repair - agents work together
+     */
+    solveCollectively(problem: string): Promise<{
+        success: boolean;
+        solution: unknown;
+    }>;
+    /**
+     * Find consensus among agent proposals
+     */
+    private findConsensus;
+    /**
+     * Get colony health (average agent health)
+     */
+    getColonyHealth(): number;
+    /**
+     * Get all agents
+     */
+    getAgents(): MorphogeneticAgent[];
+    /**
+     * Get shared knowledge
+     */
+    getSharedKnowledge(): Map<string, unknown>;
+}
+/**
+ * Create a target morphology
+ */
+export declare function createTargetMorphology(capabilities: Record<string, number>, minHealth?: number, description?: string): TargetMorphology;
+/**
+ * Create a morphogenetic agent
+ */
+export declare function createMorphogeneticAgent(id: string, capabilities: Record<string, number>, config?: Partial<MorphogeneticConfig>): MorphogeneticAgent;
+/**
+ * Get global agent colony
+ */
+export declare function getColony(config?: Partial<MorphogeneticConfig>): AgentColony;
+/**
+ * Reset global colony
+ */
+export declare function resetColony(): void;
+/**
+ * Get global NCA
+ */
+export declare function getNCA(config?: Partial<MorphogeneticConfig>): NeuralCellularAutomata;
+/**
+ * Reset global NCA
+ */
+export declare function resetNCA(): void;