magi-ai 0.1.0

package/dist/src/engine/umbilical-cable.js

@@ -0,0 +1,192 @@
+/**
+ * B-09 アンビリカルケーブル (UmbilicalCable)
+ *
+ * ユニットの接続状態を監視する。スライディングウィンドウ（直近5回）で
+ * 3回以上失敗するとdisconnected判定。活動限界タイマー付き。
+ */
+/** Window size for failure tracking */
+const WINDOW_SIZE = 5;
+/** Failure threshold within window to trigger disconnect */
+const FAILURE_THRESHOLD = 3;
+/** Degraded threshold (2 failures in window) */
+const DEGRADED_THRESHOLD = 2;
+/** Default battery limit: 5 minutes */
+const DEFAULT_BATTERY_LIMIT_MS = 300_000;
+/** Time in ms before OPEN circuit transitions to HALF_OPEN for probing */
+const CIRCUIT_RECOVERY_MS = 30_000;
+export class UmbilicalCable {
+    states = new Map();
+    circuitStates = new Map();
+    halfOpenProbeInFlight = new Set();
+    constructor(units, batteryLimitMs) {
+        for (const unit of units) {
+            this.states.set(unit, {
+                unit,
+                status: 'connected',
+                recentResults: [],
+                batteryLimitMs: batteryLimitMs ?? DEFAULT_BATTERY_LIMIT_MS,
+            });
+        }
+    }
+    /**
+     * Record a unit's execution result.
+     * Updates the sliding window and recalculates status.
+     */
+    recordResult(unit, result, eventBus) {
+        const state = this.getOrCreateState(unit);
+        const previousStatus = state.status;
+        // Add to sliding window
+        state.recentResults.push(result);
+        if (state.recentResults.length > WINDOW_SIZE) {
+            state.recentResults.shift();
+        }
+        // Count failures in window
+        const failures = state.recentResults.filter(r => r !== 'SUCCESS').length;
+        // Determine new status
+        let newStatus;
+        if (failures >= FAILURE_THRESHOLD) {
+            newStatus = 'disconnected';
+            if (previousStatus !== 'disconnected') {
+                state.disconnectedAt = Date.now();
+            }
+        }
+        else if (failures >= DEGRADED_THRESHOLD) {
+            newStatus = 'degraded';
+            state.disconnectedAt = undefined;
+        }
+        else {
+            newStatus = 'connected';
+            state.disconnectedAt = undefined;
+        }
+        state.status = newStatus;
+        // Circuit breaker state transitions
+        const currentCircuit = this.circuitStates.get(unit) ?? 'CLOSED';
+        if (result === 'SUCCESS' && (currentCircuit === 'HALF_OPEN' || currentCircuit === 'OPEN')) {
+            this.circuitStates.set(unit, 'CLOSED');
+            this.halfOpenProbeInFlight.delete(unit);
+        }
+        else if (newStatus === 'disconnected') {
+            // Reset disconnectedAt when transitioning from HALF_OPEN back to OPEN
+            // so the recovery timer restarts (prevents immediate re-probe)
+            if (currentCircuit === 'HALF_OPEN') {
+                state.disconnectedAt = Date.now();
+            }
+            this.circuitStates.set(unit, 'OPEN');
+            this.halfOpenProbeInFlight.delete(unit);
+        }
+        // Emit event if status changed
+        if (previousStatus !== newStatus && eventBus) {
+            eventBus.emit('umbilical:status_changed', {
+                unit,
+                previousStatus,
+                newStatus,
+                emittedAt: new Date(),
+            });
+        }
+        return newStatus;
+    }
+    /** Check if a request should be allowed through the circuit breaker */
+    shouldAllow(unit) {
+        const circuit = this.circuitStates.get(unit) ?? 'CLOSED';
+        if (circuit === 'CLOSED')
+            return true;
+        if (circuit === 'OPEN') {
+            // Check if enough time has passed for a probe
+            const state = this.states.get(unit);
+            if (state?.disconnectedAt && Date.now() - state.disconnectedAt >= CIRCUIT_RECOVERY_MS) {
+                this.circuitStates.set(unit, 'HALF_OPEN');
+                this.halfOpenProbeInFlight.add(unit);
+                return true; // Allow one probe request
+            }
+            return false; // Fail fast
+        }
+        // HALF_OPEN: only allow if no probe is already in flight
+        if (this.halfOpenProbeInFlight.has(unit)) {
+            return false;
+        }
+        this.halfOpenProbeInFlight.add(unit);
+        return true;
+    }
+    /** Get the circuit state for a unit */
+    getCircuitState(unit) {
+        return this.circuitStates.get(unit) ?? 'CLOSED';
+    }
+    /** Check if a unit's battery is depleted (past activity limit) */
+    isBatteryDepleted(unit) {
+        const state = this.states.get(unit);
+        if (!state || state.status !== 'disconnected' || !state.disconnectedAt) {
+            return false;
+        }
+        return Date.now() - state.disconnectedAt >= state.batteryLimitMs;
+    }
+    /** Get the current status of a unit */
+    getStatus(unit) {
+        return this.states.get(unit)?.status ?? 'connected';
+    }
+    /** Get full state for a unit */
+    getState(unit) {
+        return this.states.get(unit);
+    }
+    /** Get all unit statuses */
+    getAllStatuses() {
+        const result = new Map();
+        for (const [unit, state] of this.states) {
+            result.set(unit, state.status);
+        }
+        return result;
+    }
+    /**
+     * Format countdown timer for a disconnected unit.
+     * Returns null if unit is connected or not tracked.
+     */
+    formatCountdown(unit) {
+        const state = this.states.get(unit);
+        if (!state || state.status !== 'disconnected' || !state.disconnectedAt) {
+            return null;
+        }
+        const elapsed = Date.now() - state.disconnectedAt;
+        const remaining = Math.max(0, state.batteryLimitMs - elapsed);
+        const minutes = Math.floor(remaining / 60_000);
+        const seconds = Math.floor((remaining % 60_000) / 1_000);
+        const mm = String(minutes).padStart(2, '0');
+        const ss = String(seconds).padStart(2, '0');
+        const totalBlocks = 16;
+        const ratio = remaining / state.batteryLimitMs;
+        const filled = Math.round(ratio * totalBlocks);
+        const bar = '█'.repeat(filled) + '░'.repeat(totalBlocks - filled);
+        return `[TIMER] ${bar} 活動限界まで ${mm}:${ss}`;
+    }
+    /** Reset a unit's status (e.g., when it comes back online) */
+    reconnect(unit, eventBus) {
+        const state = this.states.get(unit);
+        if (!state)
+            return;
+        const previousStatus = state.status;
+        state.status = 'connected';
+        state.recentResults = [];
+        state.disconnectedAt = undefined;
+        this.circuitStates.set(unit, 'CLOSED');
+        this.halfOpenProbeInFlight.delete(unit);
+        if (previousStatus !== 'connected' && eventBus) {
+            eventBus.emit('umbilical:status_changed', {
+                unit,
+                previousStatus,
+                newStatus: 'connected',
+                emittedAt: new Date(),
+            });
+        }
+    }
+    getOrCreateState(unit) {
+        let state = this.states.get(unit);
+        if (!state) {
+            state = {
+                unit,
+                status: 'connected',
+                recentResults: [],
+                batteryLimitMs: DEFAULT_BATTERY_LIMIT_MS,
+            };
+            this.states.set(unit, state);
+        }
+        return state;
+    }
+}

package/dist/src/index.d.ts

@@ -0,0 +1,106 @@
+/**
+ * MAGI System - Public API
+ *
+ * Usage:
+ *   import { Magi } from 'magi-ai';
+ *   const magi = new Magi();
+ *   const result = await magi.deliberate({ type: 'code-review', ... });
+ */
+import type { MagiTask, MagiDeliberation } from './types/core.js';
+import type { MagiConfig } from './types/config.js';
+import type { MagiRuntime, MagiDiagnostics, MagiAdmin } from './types/magi-api.js';
+import { MagiEventBus } from './engine/events.js';
+import { EngramManager } from './engine/engram-manager.js';
+import type { MagiEventMap, MagiEventName } from './engine/events.js';
+import type { DeliberationTokenSummary } from './metrics/token-tracker.js';
+export interface MagiSystemStatus {
+    units: Array<{
+        unit: string;
+        health: string | Error;
+        cableStatus: string;
+        syncRate: number;
+    }>;
+    atFieldStreak: number;
+}
+export declare class Magi {
+    private orchestrator;
+    private berserkOrchestrator;
+    private adapters;
+    private pipelines;
+    private contextManager;
+    private config;
+    private eventBus;
+    private tokenTracker;
+    private engramManager;
+    private syncRateTracker;
+    private umbilicalCable;
+    private atField;
+    private initPromise;
+    private initialized;
+    private gospel;
+    private driftDetector;
+    private lclManager;
+    private type666Firewall;
+    private nebuchadnezzarKey;
+    private secretCipher;
+    private objectiveJudge;
+    private dummyPlug;
+    private offlineMode;
+    private iruelBattle;
+    private _angelDetector?;
+    private _deadSeaScrolls?;
+    private _selfEvolution?;
+    private _seeleCouncil?;
+    private _selfDestruct?;
+    private _neonGenesis?;
+    private _runtime?;
+    private _diagnostics?;
+    private _admin?;
+    constructor(config?: Partial<MagiConfig>);
+    private ensureInitialized;
+    private get angelDetector();
+    private get deadSeaScrolls();
+    private get selfEvolution();
+    private get seeleCouncil();
+    private get selfDestructSequence();
+    private get neonGenesis();
+    get runtime(): Readonly<MagiRuntime>;
+    get diagnostics(): Readonly<MagiDiagnostics>;
+    get admin(): Readonly<MagiAdmin>;
+    deliberate(task: MagiTask, options?: {
+        signal?: AbortSignal;
+    }): Promise<MagiDeliberation>;
+    deliberateBerserk(task: MagiTask, options?: {
+        signal?: AbortSignal;
+    }): Promise<MagiDeliberation>;
+    on<K extends MagiEventName>(event: K, listener: (payload: MagiEventMap[K]) => void): this;
+    once<K extends MagiEventName>(event: K, listener: (payload: MagiEventMap[K]) => void): this;
+    off<K extends MagiEventName>(event: K, listener: (payload: MagiEventMap[K]) => void): this;
+    getTokenSummary(deliberationId?: string): DeliberationTokenSummary;
+    loadAllTokens(): Promise<DeliberationTokenSummary[]>;
+    getEventBus(): MagiEventBus;
+    getEngramManager(): EngramManager;
+    getSystemStatus(): Promise<MagiSystemStatus>;
+    healthCheck(): Promise<Map<string, string | Error>>;
+}
+export type { MagiTask, MagiDeliberation, MagiConfig };
+export type { MagiOpinion, MagiUnit, Vote, TaskType } from './types/core.js';
+export type { MagiRuntime, MagiDiagnostics, MagiAdmin, WatchHandle } from './types/magi-api.js';
+export type { ConsensusResult, ConsensusDecision, DecisionProperties } from './types/consensus.js';
+export { getDecisionProps, isApproval, isRejection, isUnanimous, isMajority, isDeadlock, getMajorityVote, } from './types/consensus.js';
+export type { MagiEventMap, MagiEventName } from './engine/events.js';
+export { MagiEventBus } from './engine/events.js';
+export { StreamingProgressReporter } from './reporters/streaming.js';
+export type { DeliberationTokenSummary } from './metrics/token-tracker.js';
+export { MagiTui, type MagiTuiOptions } from './tui/index.js';
+export { AngelDetector } from './engine/angel-detector.js';
+export { DeadSeaScrolls } from './engine/dead-sea-scrolls.js';
+export { NebuchadnezzarKey } from './engine/nebuchadnezzar-key.js';
+export { SelfDestructSequence } from './engine/self-destruct.js';
+export { Type666Firewall } from './engine/type666-firewall.js';
+export type { AngelDetection, AngelType, Prophecy, ProphecyLevel } from './types/phase-k.js';
+export { NeonGenesis } from './engine/neon-genesis.js';
+export { IruelBattleSystem } from './engine/iruel-battle.js';
+export { SelfEvolutionEngine } from './engine/self-evolution.js';
+export { SeeleCouncil } from './engine/seele-council.js';
+export type { GenesisLog, CorruptionLevel, ConsistencyCheck, IruelBattlePhase, DiagnosticStats, EvolutionGeneration, EvolutionLineage, MagiNodeId, SeeleSession, } from './types/phase-l.js';