magi-ai 0.1.0

package/dist/src/repl/export-formatter.js

@@ -0,0 +1,73 @@
+/**
+ * Deliberation export formatters (JSON / Markdown).
+ *
+ * Pure functions — no side-effects, no chalk, no filesystem.
+ */
+export function formatDeliberationAsJson(d) {
+    return JSON.stringify(d, (_key, value) => {
+        if (value instanceof Date)
+            return value.toISOString();
+        if (value instanceof Error)
+            return { message: value.message };
+        return value;
+    }, 2);
+}
+export function formatDeliberationAsMarkdown(d) {
+    const lines = [];
+    const c = d.consensus;
+    lines.push(`## MAGI Deliberation: ${d.task.title}`);
+    lines.push('');
+    lines.push(`- **Decision:** ${c.decision}`);
+    lines.push(`- **Confidence:** ${(c.confidence * 100).toFixed(0)}%`);
+    lines.push(`- **Method:** ${c.method}`);
+    lines.push(`- **Duration:** ${(d.totalDurationMs / 1000).toFixed(1)}s`);
+    lines.push(`- **Rounds:** ${d.rounds.length}`);
+    lines.push('');
+    // Unit votes from final round
+    const finalRound = d.rounds[d.rounds.length - 1];
+    if (finalRound?.opinions && finalRound.opinions.length > 0) {
+        lines.push('### Unit Votes');
+        lines.push('');
+        for (const op of finalRound.opinions) {
+            const conf = (op.confidence * 100).toFixed(0);
+            lines.push(`- **${op.unit}:** ${op.vote} (${conf}%)`);
+            if (op.reasoning) {
+                lines.push(`  > ${op.reasoning.replace(/\n/g, ' ').slice(0, 200)}`);
+            }
+        }
+        lines.push('');
+    }
+    // Summary
+    if (c.summary) {
+        lines.push('### Summary');
+        lines.push('');
+        lines.push(c.summary);
+        lines.push('');
+    }
+    // Key points
+    const keyPoints = finalRound?.opinions
+        ?.flatMap(o => o.keyPoints ?? [])
+        .filter((v, i, a) => a.indexOf(v) === i)
+        .slice(0, 5);
+    if (keyPoints && keyPoints.length > 0) {
+        lines.push('### Key Points');
+        lines.push('');
+        for (const kp of keyPoints) {
+            lines.push(`- ${kp}`);
+        }
+        lines.push('');
+    }
+    // Dissent
+    if (c.dissent && c.dissent.length > 0) {
+        lines.push('### Dissent');
+        lines.push('');
+        for (const entry of c.dissent) {
+            lines.push(`- **${entry.unit}:** ${entry.reasoning}`);
+        }
+        lines.push('');
+    }
+    lines.push(`---`);
+    lines.push(`*Exported by MAGI System at ${new Date().toISOString()}*`);
+    lines.push('');
+    return lines.join('\n');
+}

package/dist/src/repl/ghost-text.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Ghost text engine — inline dim gray completion suggestions.
+ *
+ * Renders predicted text after the cursor in dim gray.
+ * Tab accepts the suggestion. Any other key updates/clears it.
+ * Degrades gracefully: disabled in non-TTY / CI / MAGI_NO_GHOST=1.
+ */
+export interface GhostTextSource {
+    getSlashCommands(): string[];
+    getHistory(): string[];
+    getDeliberationTitles(): string[];
+}
+export interface GhostTextEngine {
+    /** Compute suggestion suffix for the current input line. */
+    suggest(currentLine: string): string;
+    /** Render ghost text at cursor position. */
+    render(currentLine: string, prompt: string, suggestion: string, write: (s: string) => void): void;
+    /** Clear previously rendered ghost text. */
+    clear(write: (s: string) => void): void;
+    /** Accept current suggestion — returns accepted text or undefined. */
+    accept(): string | undefined;
+    /** Check and reset the just-accepted flag (used to suppress Tab completion). */
+    consumeAccepted(): boolean;
+    /** Release resources. */
+    dispose(): void;
+}
+export declare function createGhostTextEngine(source: GhostTextSource, options?: {
+    enabled?: boolean;
+}): GhostTextEngine;
+/** Check if ghost text should be disabled based on environment. */
+export declare function isGhostTextDisabled(): boolean;

package/dist/src/repl/ghost-text.js

@@ -0,0 +1,119 @@
+/**
+ * Ghost text engine — inline dim gray completion suggestions.
+ *
+ * Renders predicted text after the cursor in dim gray.
+ * Tab accepts the suggestion. Any other key updates/clears it.
+ * Degrades gracefully: disabled in non-TTY / CI / MAGI_NO_GHOST=1.
+ */
+import { SYNC_BEGIN, SYNC_END, RESET } from '../tui/ansi.js';
+import { sanitizeForTerminal } from './terminal-sanitize.js';
+import { visibleWidth } from './display-utils.js';
+const GHOST_STYLE = '\x1b[2m\x1b[90m'; // dim + bright black (gray)
+const ERASE_TO_EOL = '\x1b[K';
+const ERASE_LINE = '\x1b[2K';
+const SAVE_CURSOR = '\x1b7';
+const RESTORE_CURSOR = '\x1b8';
+const CURSOR_DOWN = '\x1b[B';
+const CURSOR_LINE_START = '\r';
+export function createGhostTextEngine(source, options) {
+    let lastSuggestion = '';
+    let rendered = false;
+    let renderedRows = 0;
+    let _justAccepted = false;
+    const enabled = options?.enabled ?? true;
+    function calculateRenderedRows(currentLine, prompt, suggestion) {
+        const columns = Math.max(1, process.stdout.columns ?? 80);
+        const startColumn = (visibleWidth(prompt) + visibleWidth(currentLine)) % columns;
+        const suggestionWidth = visibleWidth(suggestion);
+        if (suggestionWidth <= 0)
+            return 0;
+        return Math.floor((startColumn + suggestionWidth - 1) / columns) + 1;
+    }
+    function suggest(currentLine) {
+        if (!enabled || !currentLine) {
+            lastSuggestion = '';
+            return '';
+        }
+        // Priority 1: Slash command prefix completion (safe: hardcoded names)
+        if (currentLine.startsWith('/') && !currentLine.includes(' ')) {
+            const commands = source.getSlashCommands();
+            const match = commands.find(cmd => cmd.startsWith(currentLine) && cmd !== currentLine);
+            if (match) {
+                lastSuggestion = match.slice(currentLine.length);
+                return lastSuggestion;
+            }
+        }
+        // Priority 2: History prefix match (most recent first)
+        // Sanitize: history/titles may contain ANSI escapes from crafted input
+        const history = source.getHistory();
+        for (let i = history.length - 1; i >= 0; i--) {
+            const entry = history[i];
+            if (entry.startsWith(currentLine) && entry !== currentLine) {
+                lastSuggestion = sanitizeForTerminal(entry.slice(currentLine.length));
+                return lastSuggestion;
+            }
+        }
+        // Priority 3: Deliberation title prefix match (most recent first)
+        const titles = source.getDeliberationTitles();
+        for (let i = titles.length - 1; i >= 0; i--) {
+            const title = titles[i];
+            if (title.startsWith(currentLine) && title !== currentLine) {
+                lastSuggestion = sanitizeForTerminal(title.slice(currentLine.length));
+                return lastSuggestion;
+            }
+        }
+        lastSuggestion = '';
+        return '';
+    }
+    function render(currentLine, prompt, suggestion, write) {
+        if (!suggestion)
+            return;
+        renderedRows = calculateRenderedRows(currentLine, prompt, suggestion);
+        // Save cursor, write ghost text (dim gray), restore cursor
+        write(`${SYNC_BEGIN}${SAVE_CURSOR}${GHOST_STYLE}${suggestion}${RESET}${RESTORE_CURSOR}${SYNC_END}`);
+        rendered = true;
+    }
+    function clear(write) {
+        if (!rendered)
+            return;
+        let sequence = `${SAVE_CURSOR}${ERASE_TO_EOL}`;
+        for (let i = 1; i < renderedRows; i++) {
+            sequence += `${CURSOR_DOWN}${CURSOR_LINE_START}${ERASE_LINE}`;
+        }
+        write(`${sequence}${RESTORE_CURSOR}`);
+        rendered = false;
+        renderedRows = 0;
+    }
+    function accept() {
+        if (!lastSuggestion)
+            return undefined;
+        const accepted = lastSuggestion;
+        lastSuggestion = '';
+        rendered = false;
+        renderedRows = 0;
+        _justAccepted = true;
+        return accepted;
+    }
+    function consumeAccepted() {
+        if (_justAccepted) {
+            _justAccepted = false;
+            return true;
+        }
+        return false;
+    }
+    function dispose() {
+        lastSuggestion = '';
+        rendered = false;
+        renderedRows = 0;
+        _justAccepted = false;
+    }
+    return { suggest, render, clear, accept, consumeAccepted, dispose };
+}
+/** Check if ghost text should be disabled based on environment. */
+export function isGhostTextDisabled() {
+    return (!process.stdin.isTTY ||
+        process.env.CI === 'true' ||
+        process.env.MAGI_NO_GHOST === '1' ||
+        process.env.MAGI_NO_ANIMATION === '1' ||
+        process.env.REDUCE_MOTION === '1');
+}

package/dist/src/repl/handoff-animation.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Handoff animation — visual transition from REPL → TUI deliberation.
+ *
+ * Displays a 4-line NERV-style status readout before TUI takes over.
+ * Does NOT use raw mode or alt screen — Ctrl+C safe.
+ */
+export interface HandoffOptions {
+    write: (s: string) => void;
+    taskTitle: string;
+    berserk: boolean;
+    unitCount: number;
+    delayFn?: (ms: number) => Promise<void>;
+    signal?: AbortSignal;
+}
+export declare function runHandoffAnimation(opts: HandoffOptions): Promise<number>;

package/dist/src/repl/handoff-animation.js

@@ -0,0 +1,65 @@
+/**
+ * Handoff animation — visual transition from REPL → TUI deliberation.
+ *
+ * Displays a 4-line NERV-style status readout before TUI takes over.
+ * Does NOT use raw mode or alt screen — Ctrl+C safe.
+ */
+import chalk from 'chalk';
+import { EVA_PALETTE } from '../tui/colors.js';
+import { truncateToDisplayWidth } from '../tui/screen-buffer.js';
+import { shouldSkipAnimation } from './accessibility.js';
+import { sanitizeForTerminal } from './terminal-sanitize.js';
+const { scanline, frame, warning } = EVA_PALETTE;
+const GREEN = chalk.rgb(scanline.r, scanline.g, scanline.b);
+const ORANGE = chalk.rgb(frame.r, frame.g, frame.b);
+const WARN = chalk.rgb(warning.r, warning.g, warning.b);
+function defaultDelay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+function normalizeInlineTitle(text) {
+    return sanitizeForTerminal(text)
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function unitNames(count) {
+    const names = ['MELCHIOR', 'BALTHASAR', 'CASPER'];
+    if (count <= 3)
+        return names.slice(0, count).join('/');
+    return `${names.join('/')}+${count - 3}`;
+}
+export async function runHandoffAnimation(opts) {
+    if (shouldSkipAnimation())
+        return 0;
+    const { write, taskTitle, berserk, unitCount, signal } = opts;
+    const delay = opts.delayFn ?? defaultDelay;
+    // Sanitize and truncate title to terminal width (leave room for prefix)
+    const maxTitleLen = Math.min((process.stdout.columns ?? 80) - 30, 50);
+    const title = truncateToDisplayWidth(normalizeInlineTitle(taskTitle), maxTitleLen);
+    const lines = [
+        GREEN(`  [TASK ] deliberation :: ${title}`),
+        GREEN(`  [ROUTE] MAGI core link ................. LOCKED`),
+        GREEN(`  [SYNC ] ${unitNames(unitCount)} ...... 100%`),
+        ORANGE(`  [TUI  ] Switching to tactical display...`),
+    ];
+    let lineCount = 0;
+    write('\n');
+    lineCount++;
+    for (const line of lines) {
+        if (signal?.aborted)
+            return lineCount;
+        write(line + '\n');
+        lineCount++;
+        await delay(70);
+    }
+    if (berserk) {
+        if (signal?.aborted)
+            return lineCount;
+        await delay(60);
+        const bar = WARN.bgRed.bold('  ⚠ BERSERK MODE — ALL LIMITERS RELEASED ⚠  ');
+        write(bar + '\n');
+        lineCount++;
+    }
+    write('\n');
+    lineCount++;
+    return lineCount;
+}

package/dist/src/repl/history.d.ts

@@ -0,0 +1,16 @@
+/**
+ * REPL history persistence — ~/.magi/repl_history
+ *
+ * JSON format with atomic writes (tmp + rename), debounced saves,
+ * corrupt file recovery, and sensitive input filtering.
+ * No file locking: last-write-wins under concurrent sessions.
+ */
+export interface ReplHistory {
+    load(): Promise<string[]>;
+    addEntry(line: string): void;
+    getEntries(): string[];
+    flush(): Promise<void>;
+    dispose(): void;
+}
+export declare function looksSensitive(line: string): boolean;
+export declare function createReplHistory(historyDir?: string): ReplHistory;

package/dist/src/repl/history.js

@@ -0,0 +1,130 @@
+/**
+ * REPL history persistence — ~/.magi/repl_history
+ *
+ * JSON format with atomic writes (tmp + rename), debounced saves,
+ * corrupt file recovery, and sensitive input filtering.
+ * No file locking: last-write-wins under concurrent sessions.
+ */
+import { readFile, rename } from 'node:fs/promises';
+import { randomBytes } from 'node:crypto';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { safeMkdir, safeWriteFile } from '../utils/safe-fs.js';
+import { logger } from '../utils/logger.js';
+import { safeJsonParse } from '../utils/safe-json-parse.js';
+const MAX_ENTRIES = 1000;
+const MAX_FILE_BYTES = 1_048_576; // 1 MiB
+const DEBOUNCE_MS = 2_000;
+const SENSITIVE_PATTERN = /password|secret|token|api[_-]?key|private[_ ]key|credential/i;
+export function looksSensitive(line) {
+    return SENSITIVE_PATTERN.test(line);
+}
+export function createReplHistory(historyDir) {
+    const dir = historyDir ?? join(homedir(), '.magi');
+    const filePath = join(dir, 'repl_history');
+    let entries = [];
+    let dirty = false;
+    let debounceTimer;
+    let savePromise;
+    async function load() {
+        try {
+            const raw = await readFile(filePath, 'utf-8');
+            if (!raw.trim())
+                return (entries = []);
+            const data = safeJsonParse(raw);
+            if (data.version !== 1 || !Array.isArray(data.entries)) {
+                throw new Error('Invalid history format');
+            }
+            entries = data.entries.slice(-MAX_ENTRIES);
+            return [...entries];
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === 'ENOENT')
+                return (entries = []);
+            // Corrupt file — rename and start fresh
+            const ts = new Date().toISOString().replace(/[:.]/g, '').slice(0, 15);
+            try {
+                await rename(filePath, `${filePath}.corrupt-${ts}`);
+            }
+            catch {
+                logger.debug('history: failed to rename corrupt file');
+            }
+            entries = [];
+            return [];
+        }
+    }
+    function addEntry(line) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return;
+        if (looksSensitive(trimmed))
+            return;
+        // Skip consecutive duplicate
+        if (entries.length > 0 && entries[entries.length - 1] === trimmed)
+            return;
+        entries.push(trimmed);
+        if (entries.length > MAX_ENTRIES) {
+            entries = entries.slice(-MAX_ENTRIES);
+        }
+        dirty = true;
+        scheduleSave();
+    }
+    function scheduleSave() {
+        if (debounceTimer !== undefined)
+            clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(() => { save().catch(() => { }); }, DEBOUNCE_MS);
+    }
+    async function save() {
+        if (!dirty || savePromise)
+            return;
+        // Snapshot dirty state before async I/O — if addEntry() sets dirty=true
+        // during our save, we must NOT clear it afterwards.
+        dirty = false;
+        const doSave = async () => {
+            try {
+                const data = { version: 1, entries };
+                let json = JSON.stringify(data, null, 2);
+                // Enforce 1 MiB limit — trim oldest entries until it fits
+                while (Buffer.byteLength(json, 'utf-8') > MAX_FILE_BYTES && entries.length > 0) {
+                    entries.shift();
+                    json = JSON.stringify({ version: 1, entries }, null, 2);
+                }
+                await safeMkdir(dir);
+                // Unique tmp name to avoid collision with concurrent sessions
+                const tmpPath = `${filePath}.tmp-${randomBytes(4).toString('hex')}`;
+                await safeWriteFile(tmpPath, json);
+                await rename(tmpPath, filePath);
+            }
+            catch {
+                // Save failed — mark dirty again so next attempt retries
+                dirty = true;
+            }
+            finally {
+                savePromise = undefined;
+            }
+        };
+        savePromise = doSave();
+        await savePromise;
+    }
+    async function flush() {
+        if (debounceTimer !== undefined) {
+            clearTimeout(debounceTimer);
+            debounceTimer = undefined;
+        }
+        // Wait for in-flight save to complete, then re-save if dirty
+        if (savePromise)
+            await savePromise;
+        await save();
+    }
+    function dispose() {
+        if (debounceTimer !== undefined) {
+            clearTimeout(debounceTimer);
+            debounceTimer = undefined;
+        }
+    }
+    function getEntries() {
+        return [...entries];
+    }
+    return { load, addEntry, getEntries, flush, dispose };
+}

package/dist/src/repl/job-registry.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Background job registry for MAGI REPL.
+ * Manages long-running tasks (e.g., angel watch daemon).
+ */
+export interface BackgroundJob {
+    id: number;
+    name: string;
+    status: 'running' | 'done' | 'failed';
+    abort: AbortController;
+    startedAt: number;
+    error?: string;
+}
+interface AddJobOptions {
+    onSettled?: (job: Readonly<BackgroundJob>) => void;
+}
+export declare class JobRegistry {
+    private jobs;
+    private nextId;
+    add(name: string, run: (signal: AbortSignal) => Promise<void>, options?: AddJobOptions): BackgroundJob;
+    cancel(id: number): boolean;
+    list(): readonly BackgroundJob[];
+    get(id: number): Readonly<BackgroundJob> | undefined;
+    getRunningCount(): number;
+    dispose(): void;
+}
+export {};

package/dist/src/repl/job-registry.js

@@ -0,0 +1,80 @@
+/**
+ * Background job registry for MAGI REPL.
+ * Manages long-running tasks (e.g., angel watch daemon).
+ */
+const MAX_CONCURRENT_JOBS = 10;
+export class JobRegistry {
+    jobs = new Map();
+    nextId = 1;
+    add(name, run, options) {
+        if (this.getRunningCount() >= MAX_CONCURRENT_JOBS) {
+            throw new Error(`Maximum concurrent jobs (${MAX_CONCURRENT_JOBS}) reached. Cancel a job first.`);
+        }
+        const abort = new AbortController();
+        const job = {
+            id: this.nextId++,
+            name,
+            status: 'running',
+            abort,
+            startedAt: Date.now(),
+        };
+        this.jobs.set(job.id, job);
+        const notifySettled = () => {
+            options?.onSettled?.(job);
+        };
+        run(abort.signal)
+            .then(() => {
+            // Guard: cancel() may have already set status to 'done'
+            if (job.status === 'running')
+                job.status = 'done';
+            notifySettled();
+        })
+            .catch((err) => {
+            // Guard: cancel() may have already set status to 'done'
+            if (job.status !== 'running') {
+                notifySettled();
+                return;
+            }
+            if (abort.signal.aborted) {
+                job.status = 'done';
+            }
+            else {
+                job.status = 'failed';
+                job.error = String(err);
+            }
+            notifySettled();
+        });
+        return job;
+    }
+    cancel(id) {
+        const job = this.jobs.get(id);
+        if (!job || job.status !== 'running')
+            return false;
+        job.status = 'done';
+        job.abort.abort();
+        return true;
+    }
+    list() {
+        return [...this.jobs.values()];
+    }
+    get(id) {
+        return this.jobs.get(id);
+    }
+    getRunningCount() {
+        let count = 0;
+        for (const j of this.jobs.values()) {
+            if (j.status === 'running')
+                count++;
+        }
+        return count;
+    }
+    dispose() {
+        for (const job of this.jobs.values()) {
+            if (job.status === 'running') {
+                job.abort.abort();
+                job.status = 'done';
+            }
+        }
+        this.jobs.clear();
+    }
+}

package/dist/src/repl/magi-repl.d.ts

@@ -0,0 +1,72 @@
+/**
+ * MagiRepl — Interactive REPL for the MAGI System.
+ *
+ * Provides a Claude Code-like experience: type questions naturally,
+ * context persists across turns, and the full-screen Evangelion TUI
+ * takes over during deliberation.
+ *
+ * Key design decision (Gemini review):
+ *   readline is **close → recreate** per deliberation rather than
+ *   pause/resume, to avoid stdin state conflicts with the TUI's raw mode.
+ */
+import { type ReplState } from './repl-state.js';
+import type { MagiConfig } from '../types/config.js';
+export interface MagiReplOptions {
+    /** Magi engine configuration (passed through to Magi constructor) */
+    magiConfig?: Partial<MagiConfig>;
+    /** Skip boot animation (for testing / CI) */
+    skipBootAnimation?: boolean;
+    /** Initial sound state */
+    soundEnabled?: boolean;
+    /** TUI enabled (from user config; default true) */
+    tuiEnabled?: boolean;
+    /** History directory override (for testing) */
+    historyDir?: string;
+}
+export declare class MagiRepl {
+    private magi;
+    private context;
+    private slashCommands;
+    private soundEnabled;
+    private state;
+    private abortController?;
+    private sessionState;
+    private history;
+    private completerFn;
+    private shownEngramIds;
+    private stats;
+    private multilineCollector;
+    private lastSigintTime;
+    private lastDeliberation?;
+    private readonly options;
+    private ghostEngine;
+    private jobRegistry;
+    private currentRl?;
+    private watchJobId?;
+    private watchPollIntervalMs?;
+    constructor(options?: MagiReplOptions);
+    get currentState(): ReplState;
+    private get running();
+    private transition;
+    start(): Promise<void>;
+    private readInputLoop;
+    private createReadline;
+    private handleInput;
+    private handleSlashCommand;
+    private handleConfirmation;
+    private drainPendingInput;
+    private createConfirmationToken;
+    private handleWatchCommand;
+    private handleJobsCommand;
+    private writeAbovePrompt;
+    private injectEngramContext;
+    private runDeliberation;
+    private checkUnitsOnStartup;
+    /**
+     * Graceful resource cleanup — idempotent, callable from any state.
+     * Use for programmatic shutdown without process.exit().
+     */
+    dispose(): Promise<void>;
+    private exportDeliberation;
+    private clearRecentLines;
+}