magi-ai 0.1.0

package/dist/src/repl/terminal-sanitize.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Terminal output sanitizer — strips control characters that could
+ * enable display spoofing, clipboard injection, or cursor manipulation.
+ *
+ * Removes:
+ *   - CSI sequences: ESC [ ... (letter or ~)  — covers all standard CSI including F-keys
+ *   - OSC: ESC ] ... (BEL | ESC \)
+ *   - DCS/APC/PM/SOS: ESC (P|_|^|X) ... (BEL | ESC \)
+ *   - 2-char ESC sequences: ESC + single letter (e.g., ESC c = RIS, ESC 7/8 = save/restore)
+ *   - Charset designation: ESC ( B, ESC ) 0, etc.
+ *   - Bare control chars: NUL, BEL, standalone CR (not followed by LF)
+ * Preserves: printable text, newlines (\n), tabs (\t).
+ */
+export declare function sanitizeForTerminal(s: string): string;

package/dist/src/repl/terminal-sanitize.js

@@ -0,0 +1,19 @@
+/**
+ * Terminal output sanitizer — strips control characters that could
+ * enable display spoofing, clipboard injection, or cursor manipulation.
+ *
+ * Removes:
+ *   - CSI sequences: ESC [ ... (letter or ~)  — covers all standard CSI including F-keys
+ *   - OSC: ESC ] ... (BEL | ESC \)
+ *   - DCS/APC/PM/SOS: ESC (P|_|^|X) ... (BEL | ESC \)
+ *   - 2-char ESC sequences: ESC + single letter (e.g., ESC c = RIS, ESC 7/8 = save/restore)
+ *   - Charset designation: ESC ( B, ESC ) 0, etc.
+ *   - Bare control chars: NUL, BEL, standalone CR (not followed by LF)
+ * Preserves: printable text, newlines (\n), tabs (\t).
+ */
+const CONTROL_RE = 
+// eslint-disable-next-line no-control-regex
+/\x1b(?:\[[0-9;?]*[A-Za-z~]|\][^\x07\x1b]*(?:\x07|\x1b\\)?|[P_^X][^\x07\x1b]*(?:\x07|\x1b\\)?|[()][A-Za-z0-9]|[A-Za-z0-9=<>])|[\x00\x07\x0d](?!\x0a)/g;
+export function sanitizeForTerminal(s) {
+    return s.replace(CONTROL_RE, '');
+}

package/dist/src/reporters/console.d.ts

@@ -0,0 +1,7 @@
+import type { MagiDeliberation, MagiOpinion, DeliberationRound } from '../types/core.js';
+import type { ConsensusResult } from '../types/consensus.js';
+export declare function printHeader(): void;
+export declare function printRound(round: DeliberationRound): void;
+export declare function printOpinion(opinion: MagiOpinion): void;
+export declare function printConsensus(consensus: ConsensusResult): void;
+export declare function printDeliberation(deliberation: MagiDeliberation): void;

package/dist/src/reporters/console.js

@@ -0,0 +1,78 @@
+import chalk from 'chalk';
+const UNIT_COLORS = {
+    MELCHIOR: chalk.blue,
+    BALTHASAR: chalk.green,
+    CASPER: chalk.magenta,
+};
+const VOTE_COLORS = {
+    APPROVE: chalk.green.bold,
+    REJECT: chalk.red.bold,
+    ABSTAIN: chalk.gray,
+};
+const DECISION_COLORS = {
+    UNANIMOUS_APPROVE: chalk.bgGreen.black.bold,
+    MAJORITY_APPROVE: chalk.green.bold,
+    UNANIMOUS_REJECT: chalk.bgRed.white.bold,
+    MAJORITY_REJECT: chalk.red.bold,
+    DEADLOCK: chalk.bgYellow.black.bold,
+    INSUFFICIENT: chalk.bgGray.white,
+};
+export function printHeader() {
+    console.log('');
+    console.log(chalk.cyan.bold('  ╔══════════════════════════════════════╗'));
+    console.log(chalk.cyan.bold('  ║          M A G I  S Y S T E M       ║'));
+    console.log(chalk.cyan.bold('  ║  Multi-AI Deliberation Framework    ║'));
+    console.log(chalk.cyan.bold('  ╚══════════════════════════════════════╝'));
+    console.log('');
+}
+export function printRound(round) {
+    console.log(chalk.yellow(`\n━━━ Round ${round.roundNumber}: ${round.phase.toUpperCase()} ━━━\n`));
+    for (const opinion of round.opinions) {
+        printOpinion(opinion);
+    }
+}
+export function printOpinion(opinion) {
+    const unitColor = UNIT_COLORS[opinion.unit] ?? chalk.white;
+    const voteColor = VOTE_COLORS[opinion.vote] ?? chalk.white;
+    console.log(unitColor(`  ┌─ ${opinion.unit} ─────────────────────`));
+    console.log(unitColor(`  │`) + ` Vote: ${voteColor(opinion.vote)} (confidence: ${opinion.confidence.toFixed(2)})`);
+    console.log(unitColor(`  │`) + ` ${opinion.reasoning.slice(0, 200)}${opinion.reasoning.length > 200 ? '...' : ''}`);
+    if (opinion.keyPoints.length > 0) {
+        for (const point of opinion.keyPoints.slice(0, 3)) {
+            console.log(unitColor(`  │`) + chalk.dim(`  • ${point}`));
+        }
+    }
+    console.log(unitColor(`  └──────────────────────────────────`));
+    console.log('');
+}
+export function printConsensus(consensus) {
+    const decisionColor = DECISION_COLORS[consensus.decision] ?? chalk.white;
+    console.log(chalk.yellow('\n━━━ MAGI CONSENSUS ━━━━━━━━━━━━━━━━━━━\n'));
+    console.log(`  Decision: ${decisionColor(` ${consensus.decision.replace(/_/g, ' ')} `)}`);
+    console.log(`  Method:   ${consensus.method}`);
+    console.log(`  Confidence: ${(consensus.confidence * 100).toFixed(0)}%`);
+    console.log('');
+    console.log(`  APPROVE: ${consensus.votes.approve.join(', ') || 'none'}`);
+    console.log(`  REJECT:  ${consensus.votes.reject.join(', ') || 'none'}`);
+    console.log(`  ABSTAIN: ${consensus.votes.abstain.join(', ') || 'none'}`);
+    if (consensus.dissent && consensus.dissent.length > 0) {
+        console.log(chalk.yellow('\n  Dissenting opinions:'));
+        for (const d of consensus.dissent) {
+            console.log(chalk.dim(`    ${d.unit}: ${d.reasoning.slice(0, 100)}...`));
+        }
+    }
+    console.log(chalk.yellow('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+}
+export function printDeliberation(deliberation) {
+    printHeader();
+    console.log(chalk.dim(`  Task: ${deliberation.task.title}`));
+    console.log(chalk.dim(`  Type: ${deliberation.task.type}`));
+    console.log(chalk.dim(`  ID:   ${deliberation.id}`));
+    for (const round of deliberation.rounds) {
+        printRound(round);
+    }
+    printConsensus(deliberation.consensus);
+    console.log(chalk.dim(`  Duration: ${(deliberation.totalDurationMs / 1000).toFixed(1)}s`));
+    console.log(chalk.dim(`  Rounds:   ${deliberation.rounds.length}`));
+    console.log('');
+}

package/dist/src/reporters/json.d.ts

@@ -0,0 +1,2 @@
+import type { MagiDeliberation } from '../types/core.js';
+export declare function formatDeliberationJson(deliberation: MagiDeliberation): string;

package/dist/src/reporters/json.js

@@ -0,0 +1,3 @@
+export function formatDeliberationJson(deliberation) {
+    return JSON.stringify(deliberation, null, 2);
+}

package/dist/src/reporters/markdown.d.ts

@@ -0,0 +1,2 @@
+import type { MagiDeliberation } from '../types/core.js';
+export declare function formatDeliberationMarkdown(deliberation: MagiDeliberation): string;

package/dist/src/reporters/markdown.js

@@ -0,0 +1,65 @@
+export function formatDeliberationMarkdown(deliberation) {
+    const lines = [];
+    lines.push(`# MAGI Deliberation Report`);
+    lines.push('');
+    lines.push(`- **Task:** ${deliberation.task.title}`);
+    lines.push(`- **Type:** ${deliberation.task.type}`);
+    lines.push(`- **ID:** ${deliberation.id}`);
+    lines.push(`- **Duration:** ${(deliberation.totalDurationMs / 1000).toFixed(1)}s`);
+    lines.push(`- **Decision:** ${deliberation.consensus.decision}`);
+    lines.push('');
+    for (const round of deliberation.rounds) {
+        lines.push(formatRound(round));
+    }
+    lines.push(formatConsensus(deliberation.consensus));
+    return lines.join('\n');
+}
+function formatRound(round) {
+    const lines = [];
+    lines.push(`## Round ${round.roundNumber}: ${round.phase}`);
+    lines.push('');
+    for (const opinion of round.opinions) {
+        lines.push(formatOpinion(opinion));
+    }
+    return lines.join('\n');
+}
+function formatOpinion(opinion) {
+    const lines = [];
+    lines.push(`### ${opinion.unit}`);
+    lines.push('');
+    lines.push(`- **Vote:** ${opinion.vote} (confidence: ${opinion.confidence.toFixed(2)})`);
+    lines.push(`- **Reasoning:** ${opinion.reasoning}`);
+    if (opinion.keyPoints.length > 0) {
+        lines.push('- **Key Points:**');
+        for (const point of opinion.keyPoints) {
+            lines.push(`  - ${point}`);
+        }
+    }
+    if (opinion.suggestions && opinion.suggestions.length > 0) {
+        lines.push('- **Suggestions:**');
+        for (const s of opinion.suggestions) {
+            lines.push(`  - ${s}`);
+        }
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+function formatConsensus(consensus) {
+    const lines = [];
+    lines.push('## Consensus');
+    lines.push('');
+    lines.push(`- **Decision:** ${consensus.decision}`);
+    lines.push(`- **Method:** ${consensus.method}`);
+    lines.push(`- **Confidence:** ${(consensus.confidence * 100).toFixed(0)}%`);
+    lines.push(`- **Approve:** ${consensus.votes.approve.join(', ') || 'none'}`);
+    lines.push(`- **Reject:** ${consensus.votes.reject.join(', ') || 'none'}`);
+    lines.push(`- **Abstain:** ${consensus.votes.abstain.join(', ') || 'none'}`);
+    if (consensus.dissent && consensus.dissent.length > 0) {
+        lines.push('');
+        lines.push('### Dissenting Opinions');
+        for (const d of consensus.dissent) {
+            lines.push(`- **${d.unit}:** ${d.reasoning}`);
+        }
+    }
+    return lines.join('\n');
+}

package/dist/src/reporters/streaming.d.ts

@@ -0,0 +1,20 @@
+import type { MagiEventBus } from '../engine/events.js';
+/**
+ * Real-time streaming reporter that listens to MagiEventBus
+ * and displays progress as events arrive.
+ *
+ * In non-TTY mode (CI/pipe), falls back to plain log lines.
+ *
+ * Call `dispose()` to remove all event listeners.
+ */
+export declare class StreamingProgressReporter {
+    private readonly isTTY;
+    private unitTimers;
+    private readonly bus;
+    private readonly registrations;
+    constructor(eventBus: MagiEventBus);
+    /** Remove all event listeners registered by this reporter. */
+    dispose(): void;
+    private track;
+    private bind;
+}

package/dist/src/reporters/streaming.js

@@ -0,0 +1,178 @@
+import chalk from 'chalk';
+import { detectOutputMode } from '../utils/tty.js';
+import { unitChalk, EVA_PALETTE } from '../tui/colors.js';
+const { approve, reject, abstain } = EVA_PALETTE;
+const VOTE_ICONS = {
+    APPROVE: chalk.rgb(approve.r, approve.g, approve.b)('APPROVE'),
+    REJECT: chalk.rgb(reject.r, reject.g, reject.b)('REJECT'),
+    ABSTAIN: chalk.rgb(abstain.r, abstain.g, abstain.b)('ABSTAIN'),
+};
+function colorUnit(unit) {
+    return unitChalk(unit)(unit);
+}
+/**
+ * Real-time streaming reporter that listens to MagiEventBus
+ * and displays progress as events arrive.
+ *
+ * In non-TTY mode (CI/pipe), falls back to plain log lines.
+ *
+ * Call `dispose()` to remove all event listeners.
+ */
+export class StreamingProgressReporter {
+    isTTY;
+    unitTimers = new Map();
+    bus;
+    // Store handler references for cleanup — use Function to avoid variance issues
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+    registrations = [];
+    constructor(eventBus) {
+        this.isTTY = detectOutputMode() === 'interactive';
+        this.bus = eventBus;
+        this.bind();
+    }
+    /** Remove all event listeners registered by this reporter. */
+    dispose() {
+        for (const { event, handler } of this.registrations) {
+            // removeListener accepts Function via underlying EventEmitter
+            this.bus.removeListener(event, handler);
+        }
+        this.registrations.length = 0;
+        this.unitTimers.clear();
+    }
+    track(event, handler) {
+        this.registrations.push({ event, handler });
+        this.bus.on(event, handler);
+    }
+    bind() {
+        this.track('deliberation:start', (e) => {
+            if (this.isTTY) {
+                console.error(chalk.cyan(`  Deliberation started: ${e.taskType} — ${e.taskTitle}`));
+            }
+            else {
+                console.error(`[MAGI] start: ${e.taskType} — ${e.taskTitle}`);
+            }
+        });
+        this.track('phase:start', (e) => {
+            if (this.isTTY) {
+                console.error(chalk.cyan(`\n  Phase ${e.roundNumber}: ${e.phase}`));
+            }
+            else {
+                console.error(`[MAGI] phase: ${e.phase} (round ${e.roundNumber})`);
+            }
+        });
+        this.track('unit:start', (e) => {
+            this.unitTimers.set(e.unit, Date.now());
+            if (this.isTTY) {
+                console.error(chalk.gray(`    ${colorUnit(e.unit)} thinking...`));
+            }
+        });
+        this.track('unit:complete', (e) => {
+            const elapsed = Date.now() - (this.unitTimers.get(e.unit) ?? Date.now());
+            const vote = VOTE_ICONS[e.vote] ?? e.vote;
+            const conf = `${(e.confidence * 100).toFixed(0)}%`;
+            if (this.isTTY) {
+                console.error(`    ${colorUnit(e.unit)} ${vote} (${conf}) [${elapsed}ms]`);
+            }
+            else {
+                console.error(`[MAGI] ${e.unit}: ${e.vote} (${conf}) [${elapsed}ms]`);
+            }
+        });
+        this.track('unit:error', (e) => {
+            if (this.isTTY) {
+                console.error(chalk.red(`    ${colorUnit(e.unit)} FAILED — ${e.error.slice(0, 80)}`));
+            }
+            else {
+                console.error(`[MAGI] ${e.unit}: FAILED — ${e.error.slice(0, 80)}`);
+            }
+        });
+        this.track('phase:skipped', (e) => {
+            const label = e.reason === 'unanimous_early_exit' ? 'unanimous' : 'majority';
+            if (this.isTTY) {
+                console.error(chalk.yellow(`\n  Phase skipped: ${e.phase} (${label} early exit)`));
+            }
+            else {
+                console.error(`[MAGI] phase skipped: ${e.phase} (${label})`);
+            }
+        });
+        this.track('deliberation:complete', (e) => {
+            if (this.isTTY) {
+                console.error(chalk.bold(`\n  MAGI DECISION: ${e.decision} (${e.rounds} rounds, ${e.totalDurationMs}ms)`));
+                if (e.fromCache)
+                    console.error(chalk.gray('  (from cache)'));
+            }
+            else {
+                console.error(`[MAGI] decision: ${e.decision} (${e.rounds} rounds, ${e.totalDurationMs}ms)`);
+            }
+        });
+        // Phase H events
+        this.track('syncrate:updated', (e) => {
+            const rateStr = Object.entries(e.rates)
+                .map(([unit, rate]) => `${unit} ${(rate * 100).toFixed(1)}%`)
+                .join(' | ');
+            if (this.isTTY) {
+                console.error(chalk.cyan(`    シンクロ率: ${rateStr}`));
+            }
+            else {
+                console.error(`[MAGI] syncrate: ${rateStr}`);
+            }
+        });
+        this.track('berserk:warning', (e) => {
+            const msg = `暴走警告: 合計シンクロ率 ${e.totalSyncRate.toFixed(2)} > ${e.threshold}`;
+            if (this.isTTY) {
+                console.error(chalk.red.bold(`    [BERSERK] ${msg}`));
+            }
+            else {
+                console.error(`[MAGI] BERSERK: ${msg}`);
+            }
+        });
+        this.track('bias:detected', (e) => {
+            if (e.level !== 1) {
+                const levelStr = e.level === 'MAX' ? 'MAX' : `Level ${e.level}`;
+                if (this.isTTY) {
+                    console.error(chalk.yellow(`    [A.T. FIELD ${levelStr}] バイアス検出 (エントロピー: ${e.voteEntropy.toFixed(3)})`));
+                }
+                else {
+                    console.error(`[MAGI] AT-FIELD: ${levelStr} (entropy: ${e.voteEntropy.toFixed(3)})`);
+                }
+            }
+        });
+        this.track('gospel:milestone', (e) => {
+            const labels = {
+                first_deliberation: '最初の審議完了',
+                first_unanimous: '初の全会一致',
+                first_deadlock: '初のデッドロック',
+                centenary: '100回到達',
+                millennium: '1000回到達',
+            };
+            const label = labels[e.milestone] ?? e.milestone;
+            if (this.isTTY) {
+                console.error(chalk.yellow.bold(`    [GOSPEL] ${label} (第${e.count}審議)`));
+            }
+            else {
+                console.error(`[MAGI] GOSPEL: ${label} (#${e.count})`);
+            }
+        });
+        this.track('umbilical:status_changed', (e) => {
+            const statusColors = {
+                connected: chalk.green,
+                degraded: chalk.yellow,
+                disconnected: chalk.red,
+            };
+            const colorFn = statusColors[e.newStatus] ?? chalk.white;
+            if (this.isTTY) {
+                console.error(`    [CABLE] ${colorUnit(e.unit)} ${e.previousStatus} → ${colorFn(e.newStatus)}`);
+            }
+            else {
+                console.error(`[MAGI] CABLE: ${e.unit} ${e.previousStatus} -> ${e.newStatus}`);
+            }
+        });
+        this.track('dummyplug:activated', (e) => {
+            if (this.isTTY) {
+                console.error(chalk.magenta(`    [DUMMY PLUG] ${colorUnit(e.unit)} 起動 (confidence: ${(e.confidence * 100).toFixed(0)}%, samples: ${e.profileSamples})`));
+            }
+            else {
+                console.error(`[MAGI] DUMMY-PLUG: ${e.unit} activated (confidence: ${(e.confidence * 100).toFixed(0)}%)`);
+            }
+        });
+    }
+}

package/dist/src/tui/activity-log.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Scrolling activity log displayed above the status bar.
+ * Shows recent events with ▶ prefix.
+ */
+import type { ScreenBuffer } from './screen-buffer.js';
+import type { Rect } from './layout.js';
+import { type RGBColor } from './colors.js';
+export declare class ActivityLog {
+    private entries;
+    private liveEntry?;
+    private readonly maxLines;
+    constructor(maxLines: number);
+    /** Add a log entry. Oldest entries are discarded when full. */
+    push(message: string, color?: RGBColor): void;
+    /** Set or clear the live status line shown at the bottom of the log area. */
+    setLive(message?: string, color?: RGBColor): void;
+    /** Draw the log entries into the screen buffer. */
+    draw(buf: ScreenBuffer, rect: Rect): void;
+    /** Clear all entries. */
+    clear(): void;
+    /** Get current entry count. */
+    get length(): number;
+}

package/dist/src/tui/activity-log.js

@@ -0,0 +1,67 @@
+/**
+ * Scrolling activity log displayed above the status bar.
+ * Shows recent events with ▶ prefix.
+ */
+import { truncateToDisplayWidth } from './screen-buffer.js';
+import { EVA_PALETTE } from './colors.js';
+// ── Activity Log ────────────────────────────────────────────
+export class ActivityLog {
+    entries = [];
+    liveEntry;
+    maxLines;
+    constructor(maxLines) {
+        this.maxLines = maxLines;
+    }
+    /** Add a log entry. Oldest entries are discarded when full. */
+    push(message, color) {
+        this.entries.push({ message, color: color ?? EVA_PALETTE.textPrimary });
+        if (this.entries.length > this.maxLines) {
+            this.entries.shift();
+        }
+    }
+    /** Set or clear the live status line shown at the bottom of the log area. */
+    setLive(message, color) {
+        if (!message) {
+            this.liveEntry = undefined;
+            return;
+        }
+        this.liveEntry = { message, color: color ?? EVA_PALETTE.magi };
+    }
+    /** Draw the log entries into the screen buffer. */
+    draw(buf, rect) {
+        const { row, col, width, height } = rect;
+        const maxWidth = width - 4; // 2 for borders + 2 for "▶ " prefix
+        const historyRows = this.liveEntry ? Math.max(0, height - 1) : height;
+        for (let i = 0; i < height; i++) {
+            const y = row + i;
+            // Clear line
+            for (let x = col + 1; x < col + width - 1; x++) {
+                buf.writeAt(y, x, ' ');
+            }
+            if (this.liveEntry && i === height - 1) {
+                const liveColor = this.liveEntry.color;
+                buf.writeAt(y, col + 2, '▷', EVA_PALETTE.magi.r, EVA_PALETTE.magi.g, EVA_PALETTE.magi.b);
+                const liveMsg = truncateToDisplayWidth(this.liveEntry.message, maxWidth - 2);
+                buf.writeAt(y, col + 4, liveMsg, liveColor.r, liveColor.g, liveColor.b);
+                continue;
+            }
+            const entryIdx = this.entries.length - historyRows + i;
+            if (i < historyRows && entryIdx >= 0 && entryIdx < this.entries.length) {
+                const entry = this.entries[entryIdx];
+                const c = entry.color;
+                buf.writeAt(y, col + 2, '▶', EVA_PALETTE.frame.r, EVA_PALETTE.frame.g, EVA_PALETTE.frame.b);
+                const msg = truncateToDisplayWidth(entry.message, maxWidth - 2);
+                buf.writeAt(y, col + 4, msg, c.r, c.g, c.b);
+            }
+        }
+    }
+    /** Clear all entries. */
+    clear() {
+        this.entries = [];
+        this.liveEntry = undefined;
+    }
+    /** Get current entry count. */
+    get length() {
+        return this.entries.length;
+    }
+}

package/dist/src/tui/animations.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Animation controller for TUI effects.
+ * Manages breathing, cascade, flash, and overlay animations.
+ */
+import type { ConsensusDecision } from '../types/consensus.js';
+type FrameCallback = (value: number) => void;
+type PulseCallback = (index: number) => void;
+export declare class AnimationController {
+    private timers;
+    private disposed;
+    /**
+     * Start breathing animation for a unit.
+     * Calls onFrame with a phase value (0.0 ~ 1.0) cycling at ~16fps.
+     */
+    startBreathing(unitId: string, onFrame: FrameCallback): void;
+    startBreathingWithOffset(unitId: string, phaseOffset: number, onFrame: FrameCallback): void;
+    /** Stop breathing animation for a unit. */
+    stopBreathing(unitId: string): void;
+    /**
+     * Cascade reveal: call onReveal for each unit with a staggered delay.
+     * Returns a promise that resolves when all reveals are done.
+     */
+    cascade(units: string[], onReveal: (unit: string) => void): Promise<void>;
+    /**
+     * BERSERK flash: toggle red flash on/off multiple times.
+     */
+    berserkFlash(onFlash: (isRed: boolean) => void): Promise<void>;
+    /**
+     * UNANIMOUS reveal: show overlay text after a brief pause.
+     */
+    unanimousReveal(decision: ConsensusDecision, onOverlay: (text: string, isApprove: boolean) => void): Promise<void>;
+    verdictLock(decision: ConsensusDecision, onOverlay: (text: string, tone: 'approve' | 'reject' | 'deadlock', blink: boolean) => void): Promise<void>;
+    linePulse(length: number, onPulse: PulseCallback): Promise<void>;
+    /** Stop all animations and prevent new ones. */
+    dispose(): void;
+    /** Check if a breathing animation is active. */
+    isBreathing(unitId: string): boolean;
+}
+export {};