magi-ai 0.1.0

package/dist/src/context/manager.js

@@ -0,0 +1,162 @@
+import { readFile, readdir } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { logger } from '../utils/logger.js';
+import { MagiError } from '../utils/errors.js';
+import { safeJsonParse } from '../utils/safe-json-parse.js';
+import { safeMkdir as fsSafeMkdir, safeWriteFile as fsSafeWriteFile } from '../utils/safe-fs.js';
+const UUID_V4_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+export class PathTraversalError extends MagiError {
+    constructor(message) {
+        super(message, 'PATH_TRAVERSAL');
+    }
+}
+/**
+ * File-System-as-State context manager with path traversal prevention.
+ *
+ * Manages the .magi/ workspace directory where deliberation state is persisted.
+ * Each deliberation gets its own subdirectory with round-by-round JSON files.
+ *
+ * Security hardening:
+ * - Deliberation IDs are validated as UUID v4 format
+ * - All paths are resolved and verified to stay within the base directory
+ * - Null bytes are rejected
+ * - Symlinks at target directories are rejected
+ * - File permissions: directories 0o700, files 0o600
+ */
+export class ContextManager {
+    resolvedBaseDir;
+    constructor(baseDir) {
+        this.resolvedBaseDir = resolve(baseDir);
+    }
+    /** Validate deliberation ID format and resolve path safely. */
+    validateAndResolvePath(deliberationId) {
+        // Check for null bytes
+        if (deliberationId.includes('\0')) {
+            throw new PathTraversalError('Deliberation ID contains null bytes');
+        }
+        // Validate UUID v4 format
+        if (!UUID_V4_RE.test(deliberationId)) {
+            throw new PathTraversalError(`Invalid deliberation ID format: expected UUID v4, got "${deliberationId.slice(0, 50)}"`);
+        }
+        // Resolve and verify path prefix
+        const resolved = resolve(this.resolvedBaseDir, deliberationId);
+        if (!resolved.startsWith(this.resolvedBaseDir + '/') && resolved !== this.resolvedBaseDir) {
+            throw new PathTraversalError(`Path traversal detected: resolved path "${resolved}" escapes base directory`);
+        }
+        return resolved;
+    }
+    /** Create directory with 0o700 permissions, rejecting symlinks. */
+    async safeMkdir(dirPath) {
+        try {
+            await fsSafeMkdir(dirPath);
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.startsWith('Symlink detected')) {
+                throw new PathTraversalError(err.message);
+            }
+            throw err;
+        }
+    }
+    /** Write file with 0o600 permissions. */
+    async safeWriteFile(filePath, content) {
+        await fsSafeWriteFile(filePath, content);
+    }
+    /** Write JSON with safe permissions. */
+    async writeJson(path, data) {
+        await this.safeWriteFile(path, JSON.stringify(data, null, 2));
+    }
+    async initWorkspace(deliberationId, task) {
+        const workDir = this.validateAndResolvePath(deliberationId);
+        await this.safeMkdir(workDir);
+        await this.safeMkdir(join(workDir, 'debug'));
+        await this.writeJson(join(workDir, 'task.json'), {
+            ...task,
+            startedAt: new Date().toISOString(),
+        });
+        logger.debug(`Workspace initialized: ${workDir}`);
+        return workDir;
+    }
+    async saveRound(deliberationId, round) {
+        const workDir = this.validateAndResolvePath(deliberationId);
+        const roundDir = join(workDir, `round-${round.roundNumber}`);
+        const debugDir = join(workDir, 'debug');
+        // Create directories first (must precede file writes)
+        await Promise.all([this.safeMkdir(roundDir), this.safeMkdir(debugDir)]);
+        // Collect all file writes and execute in parallel
+        const writes = [];
+        for (const opinion of round.opinions) {
+            const filename = `${opinion.unit.toLowerCase()}-${round.phase}.json`;
+            writes.push(this.writeJson(join(roundDir, filename), {
+                unit: opinion.unit,
+                vote: opinion.vote,
+                confidence: opinion.confidence,
+                reasoning: opinion.reasoning,
+                keyPoints: opinion.keyPoints,
+                suggestions: opinion.suggestions,
+                meta: opinion.meta,
+            }));
+            const debugFile = `${opinion.unit.toLowerCase()}-raw-${round.roundNumber}.txt`;
+            writes.push(this.safeWriteFile(join(debugDir, debugFile), opinion.rawOutput));
+        }
+        writes.push(this.writeJson(join(roundDir, '_round.json'), {
+            roundNumber: round.roundNumber,
+            phase: round.phase,
+            startedAt: round.startedAt.toISOString(),
+            completedAt: round.completedAt.toISOString(),
+            votes: round.opinions.map((o) => ({
+                unit: o.unit,
+                vote: o.vote,
+                confidence: o.confidence,
+            })),
+        }));
+        const results = await Promise.allSettled(writes);
+        const rejected = results.filter((r) => r.status === 'rejected');
+        if (rejected.length > 0) {
+            logger.warn(`Round ${round.roundNumber} save: ${rejected.length}/${results.length} writes failed`, {
+                phase: round.phase,
+                errors: rejected.map(r => String(r.reason)),
+            });
+        }
+        logger.debug(`Round ${round.roundNumber} saved`, {
+            phase: round.phase,
+            succeeded: results.length - rejected.length,
+            failed: rejected.length,
+        });
+    }
+    async saveDeliberation(deliberation) {
+        const workDir = this.validateAndResolvePath(deliberation.id);
+        await this.writeJson(join(workDir, 'consensus.json'), deliberation.consensus);
+        await this.writeJson(join(workDir, 'deliberation.json'), {
+            id: deliberation.id,
+            task: deliberation.task,
+            totalDurationMs: deliberation.totalDurationMs,
+            startedAt: deliberation.startedAt.toISOString(),
+            completedAt: deliberation.completedAt.toISOString(),
+            consensus: deliberation.consensus,
+            roundCount: deliberation.rounds.length,
+        });
+    }
+    async listDeliberations() {
+        try {
+            const entries = await readdir(this.resolvedBaseDir, { withFileTypes: true });
+            return entries
+                .filter((e) => e.isDirectory() && !e.name.startsWith('.'))
+                .map((e) => e.name);
+        }
+        catch (err) {
+            logger.debug('ContextManager: failed to list deliberations', { error: String(err) });
+            return [];
+        }
+    }
+    async loadTask(deliberationId) {
+        try {
+            const workDir = this.validateAndResolvePath(deliberationId);
+            const content = await readFile(join(workDir, 'task.json'), 'utf-8');
+            return safeJsonParse(content);
+        }
+        catch (err) {
+            logger.debug('ContextManager: failed to load task', { deliberationId, error: String(err) });
+            return null;
+        }
+    }
+}

package/dist/src/context/serializer.d.ts

@@ -0,0 +1,20 @@
+import type { MagiOpinion, DeliberationRound } from '../types/core.js';
+/**
+ * Truncate a string to maxLen characters, appending "…" if truncated.
+ */
+export declare function truncate(text: string, maxLen: number): string;
+/**
+ * Compact serialization for cross-examination prompts.
+ * Omits suggestions, truncates reasoning to 500 chars.
+ */
+export declare function serializeOpinionCompact(opinion: MagiOpinion): string;
+/**
+ * Minimal serialization for summary views.
+ * Vote + confidence + key points only, no reasoning.
+ */
+export declare function serializeOpinionMinimal(opinion: MagiOpinion): string;
+/**
+ * Compact serialization for multiple rounds (final-vote prompts).
+ * Uses compact opinions for the latest round, minimal for earlier rounds.
+ */
+export declare function serializeRoundsCompact(rounds: DeliberationRound[]): string;

package/dist/src/context/serializer.js

@@ -0,0 +1,52 @@
+/**
+ * Truncate a string to maxLen characters, appending "…" if truncated.
+ */
+export function truncate(text, maxLen) {
+    if (text.length <= maxLen)
+        return text;
+    return text.slice(0, maxLen - 1) + '…';
+}
+/**
+ * Compact serialization for cross-examination prompts.
+ * Omits suggestions, truncates reasoning to 500 chars.
+ */
+export function serializeOpinionCompact(opinion) {
+    return [
+        `### ${opinion.unit}`,
+        `Vote: ${opinion.vote} (${opinion.confidence.toFixed(2)})`,
+        `Reasoning: ${truncate(opinion.reasoning, 500)}`,
+        opinion.keyPoints.length > 0
+            ? `Key Points:\n${opinion.keyPoints.map((p) => `- ${p}`).join('\n')}`
+            : '',
+    ]
+        .filter(Boolean)
+        .join('\n');
+}
+/**
+ * Minimal serialization for summary views.
+ * Vote + confidence + key points only, no reasoning.
+ */
+export function serializeOpinionMinimal(opinion) {
+    return [
+        `### ${opinion.unit}`,
+        `Vote: ${opinion.vote} (${opinion.confidence.toFixed(2)})`,
+        opinion.keyPoints.length > 0
+            ? opinion.keyPoints.map((p) => `- ${p}`).join('\n')
+            : '',
+    ]
+        .filter(Boolean)
+        .join('\n');
+}
+/**
+ * Compact serialization for multiple rounds (final-vote prompts).
+ * Uses compact opinions for the latest round, minimal for earlier rounds.
+ */
+export function serializeRoundsCompact(rounds) {
+    return rounds.map((round, i) => {
+        const isLast = i === rounds.length - 1;
+        const header = `## Round ${round.roundNumber} (${round.phase})`;
+        const serialize = isLast ? serializeOpinionCompact : serializeOpinionMinimal;
+        const opinions = round.opinions.map(serialize).join('\n\n');
+        return `${header}\n\n${opinions}`;
+    }).join('\n\n---\n\n');
+}

package/dist/src/demo/recorded-deliberation.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Pre-recorded deliberation events for `magi demo`.
+ *
+ * Simulates a 3-body deliberation on "REST vs GraphQL for a new API"
+ * with realistic timing and opinions.
+ */
+import type { MagiEventName } from '../engine/events.js';
+export interface RecordedEvent {
+    type: MagiEventName;
+    payload: Record<string, unknown>;
+    delayMs: number;
+}
+export declare const DEMO_EVENTS: RecordedEvent[];

package/dist/src/demo/recorded-deliberation.js

@@ -0,0 +1,277 @@
+/**
+ * Pre-recorded deliberation events for `magi demo`.
+ *
+ * Simulates a 3-body deliberation on "REST vs GraphQL for a new API"
+ * with realistic timing and opinions.
+ */
+const DELIB_ID = 'demo-rest-vs-graphql';
+export const DEMO_EVENTS = [
+    // ── Deliberation Start ───────────────────────────────────────
+    {
+        type: 'deliberation:start',
+        payload: {
+            deliberationId: DELIB_ID,
+            taskType: 'architecture-decision',
+            taskTitle: 'REST vs GraphQL for new public API',
+            emittedAt: new Date(),
+        },
+        delayMs: 0,
+    },
+    // ── Phase 1: Initial Opinion ─────────────────────────────────
+    {
+        type: 'phase:start',
+        payload: {
+            deliberationId: DELIB_ID,
+            phase: 'initial-opinion',
+            roundNumber: 1,
+            emittedAt: new Date(),
+        },
+        delayMs: 500,
+    },
+    // MELCHIOR starts
+    {
+        type: 'unit:start',
+        payload: { deliberationId: DELIB_ID, unit: 'MELCHIOR', phase: 'initial-opinion', emittedAt: new Date() },
+        delayMs: 200,
+    },
+    // BALTHASAR starts
+    {
+        type: 'unit:start',
+        payload: { deliberationId: DELIB_ID, unit: 'BALTHASAR', phase: 'initial-opinion', emittedAt: new Date() },
+        delayMs: 100,
+    },
+    // CASPER starts
+    {
+        type: 'unit:start',
+        payload: { deliberationId: DELIB_ID, unit: 'CASPER', phase: 'initial-opinion', emittedAt: new Date() },
+        delayMs: 100,
+    },
+    // Streaming chunks (simulate LLM output)
+    {
+        type: 'unit:chunk',
+        payload: { deliberationId: DELIB_ID, unit: 'MELCHIOR', chunk: 'Analyzing API patterns...', stream: 'stdout', emittedAt: new Date() },
+        delayMs: 800,
+    },
+    {
+        type: 'unit:chunk',
+        payload: { deliberationId: DELIB_ID, unit: 'BALTHASAR', chunk: 'Evaluating implementation complexity...', stream: 'stdout', emittedAt: new Date() },
+        delayMs: 400,
+    },
+    {
+        type: 'unit:chunk',
+        payload: { deliberationId: DELIB_ID, unit: 'CASPER', chunk: 'Assessing security implications...', stream: 'stdout', emittedAt: new Date() },
+        delayMs: 600,
+    },
+    // MELCHIOR completes — APPROVE (GraphQL)
+    {
+        type: 'unit:complete',
+        payload: {
+            deliberationId: DELIB_ID,
+            unit: 'MELCHIOR',
+            phase: 'initial-opinion',
+            vote: 'APPROVE',
+            confidence: 0.78,
+            durationMs: 3200,
+            reasoningSummary: 'GraphQL enables precise data fetching, reducing over-fetching by ~60%. Type system provides compile-time contract validation. Subscription support enables real-time features without additional infrastructure.',
+            emittedAt: new Date(),
+        },
+        delayMs: 1500,
+    },
+    // CASPER completes — REJECT (prefers REST)
+    {
+        type: 'unit:complete',
+        payload: {
+            deliberationId: DELIB_ID,
+            unit: 'CASPER',
+            phase: 'initial-opinion',
+            vote: 'REJECT',
+            confidence: 0.72,
+            durationMs: 3800,
+            reasoningSummary: 'REST is safer for public APIs: simpler auth model, built-in HTTP caching, no query complexity attacks. GraphQL\'s N+1 problem and lack of native rate limiting create operational risk for public-facing services.',
+            emittedAt: new Date(),
+        },
+        delayMs: 800,
+    },
+    // BALTHASAR completes — APPROVE (GraphQL, but cautious)
+    {
+        type: 'unit:complete',
+        payload: {
+            deliberationId: DELIB_ID,
+            unit: 'BALTHASAR',
+            phase: 'initial-opinion',
+            vote: 'APPROVE',
+            confidence: 0.65,
+            durationMs: 4100,
+            reasoningSummary: 'GraphQL reduces frontend-backend coordination overhead. Code generation from schema accelerates development. However, caching strategy needs careful design — persisted queries recommended for public API.',
+            emittedAt: new Date(),
+        },
+        delayMs: 1000,
+    },
+    // Phase 1 complete
+    {
+        type: 'phase:complete',
+        payload: { deliberationId: DELIB_ID, phase: 'initial-opinion', roundNumber: 1, durationMs: 4100, emittedAt: new Date() },
+        delayMs: 300,
+    },
+    // ── Phase 2: Cross-Examination ───────────────────────────────
+    {
+        type: 'phase:start',
+        payload: { deliberationId: DELIB_ID, phase: 'cross-examination', roundNumber: 1, emittedAt: new Date() },
+        delayMs: 500,
+    },
+    {
+        type: 'unit:start',
+        payload: { deliberationId: DELIB_ID, unit: 'MELCHIOR', phase: 'cross-examination', emittedAt: new Date() },
+        delayMs: 200,
+    },
+    {
+        type: 'unit:start',
+        payload: { deliberationId: DELIB_ID, unit: 'BALTHASAR', phase: 'cross-examination', emittedAt: new Date() },
+        delayMs: 100,
+    },
+    {
+        type: 'unit:start',
+        payload: { deliberationId: DELIB_ID, unit: 'CASPER', phase: 'cross-examination', emittedAt: new Date() },
+        delayMs: 100,
+    },
+    // Cross-exam chunks
+    {
+        type: 'unit:chunk',
+        payload: { deliberationId: DELIB_ID, unit: 'MELCHIOR', chunk: 'Reviewing CASPER\'s security concerns...', stream: 'stdout', emittedAt: new Date() },
+        delayMs: 1200,
+    },
+    {
+        type: 'unit:chunk',
+        payload: { deliberationId: DELIB_ID, unit: 'CASPER', chunk: 'Examining MELCHIOR\'s performance claims...', stream: 'stdout', emittedAt: new Date() },
+        delayMs: 800,
+    },
+    // Cross-exam completes
+    {
+        type: 'unit:complete',
+        payload: {
+            deliberationId: DELIB_ID,
+            unit: 'MELCHIOR',
+            phase: 'cross-examination',
+            vote: 'APPROVE',
+            confidence: 0.82,
+            durationMs: 5200,
+            reasoningSummary: 'CASPER raises valid security points. Mitigation: query depth limiting (max 10), persisted queries for public API, cost analysis middleware. These are solved problems in production GraphQL (Shopify, GitHub).',
+            emittedAt: new Date(),
+        },
+        delayMs: 2000,
+    },
+    {
+        type: 'unit:complete',
+        payload: {
+            deliberationId: DELIB_ID,
+            unit: 'CASPER',
+            phase: 'cross-examination',
+            vote: 'CONDITIONAL',
+            confidence: 0.68,
+            durationMs: 5800,
+            reasoningSummary: 'MELCHIOR\'s mitigations are viable if properly implemented. Revised position: GraphQL acceptable WITH mandatory persisted queries, query complexity budget, and REST fallback for critical auth endpoints.',
+            emittedAt: new Date(),
+        },
+        delayMs: 1500,
+    },
+    {
+        type: 'unit:complete',
+        payload: {
+            deliberationId: DELIB_ID,
+            unit: 'BALTHASAR',
+            phase: 'cross-examination',
+            vote: 'APPROVE',
+            confidence: 0.75,
+            durationMs: 5500,
+            reasoningSummary: 'Hybrid approach is pragmatic. GraphQL for data queries, REST for auth/webhooks. Apollo Server + Express coexistence is well-documented. Estimated 2-week setup overhead, offset by 30% faster feature velocity.',
+            emittedAt: new Date(),
+        },
+        delayMs: 800,
+    },
+    {
+        type: 'phase:complete',
+        payload: { deliberationId: DELIB_ID, phase: 'cross-examination', roundNumber: 1, durationMs: 5800, emittedAt: new Date() },
+        delayMs: 300,
+    },
+    // ── Phase 3: Final Vote ──────────────────────────────────────
+    {
+        type: 'phase:start',
+        payload: { deliberationId: DELIB_ID, phase: 'final-vote', roundNumber: 1, emittedAt: new Date() },
+        delayMs: 500,
+    },
+    {
+        type: 'unit:start',
+        payload: { deliberationId: DELIB_ID, unit: 'MELCHIOR', phase: 'final-vote', emittedAt: new Date() },
+        delayMs: 200,
+    },
+    {
+        type: 'unit:start',
+        payload: { deliberationId: DELIB_ID, unit: 'BALTHASAR', phase: 'final-vote', emittedAt: new Date() },
+        delayMs: 100,
+    },
+    {
+        type: 'unit:start',
+        payload: { deliberationId: DELIB_ID, unit: 'CASPER', phase: 'final-vote', emittedAt: new Date() },
+        delayMs: 100,
+    },
+    {
+        type: 'unit:complete',
+        payload: {
+            deliberationId: DELIB_ID,
+            unit: 'MELCHIOR',
+            phase: 'final-vote',
+            vote: 'APPROVE',
+            confidence: 0.85,
+            durationMs: 2200,
+            reasoningSummary: 'GraphQL with security guardrails. Query depth limit, persisted queries, complexity budget.',
+            emittedAt: new Date(),
+        },
+        delayMs: 1500,
+    },
+    {
+        type: 'unit:complete',
+        payload: {
+            deliberationId: DELIB_ID,
+            unit: 'BALTHASAR',
+            phase: 'final-vote',
+            vote: 'APPROVE',
+            confidence: 0.80,
+            durationMs: 2000,
+            reasoningSummary: 'Hybrid GraphQL + REST. Apollo Server for queries, Express for auth/webhooks.',
+            emittedAt: new Date(),
+        },
+        delayMs: 800,
+    },
+    {
+        type: 'unit:complete',
+        payload: {
+            deliberationId: DELIB_ID,
+            unit: 'CASPER',
+            phase: 'final-vote',
+            vote: 'APPROVE',
+            confidence: 0.72,
+            durationMs: 2500,
+            reasoningSummary: 'Conditional approval. GraphQL acceptable with: persisted queries mandatory, depth ≤10, complexity budget, REST fallback for auth.',
+            emittedAt: new Date(),
+        },
+        delayMs: 1200,
+    },
+    {
+        type: 'phase:complete',
+        payload: { deliberationId: DELIB_ID, phase: 'final-vote', roundNumber: 1, durationMs: 2500, emittedAt: new Date() },
+        delayMs: 300,
+    },
+    // ── Deliberation Complete (Unanimous) ────────────────────────
+    {
+        type: 'deliberation:complete',
+        payload: {
+            deliberationId: DELIB_ID,
+            decision: 'UNANIMOUS_APPROVE',
+            totalDurationMs: 18500,
+            rounds: 1,
+            fromCache: false,
+            emittedAt: new Date(),
+        },
+        delayMs: 500,
+    },
+];

package/dist/src/engine/angel-detector.d.ts

@@ -0,0 +1,83 @@
+/**
+ * AngelDetector -- 使徒検知システム (A-04)
+ *
+ * Monitors git diffs for 6 types of suspicious patterns (Angels):
+ *
+ * SACHIEL  - Security-sensitive file changes
+ * SHAMSHEL - High-coupling hub node changes (co-change graph)
+ * RAMIEL   - High-entropy (scattered) changes
+ * GAGHIEL  - Ancient code modification
+ * ISRAFEL  - Multi-developer conflict zones
+ * IRUEL    - Boil-frog micro changes (death by a thousand cuts)
+ *
+ * Each detection returns a ThreatLevel (YELLOW / ORANGE / RED)
+ * and emits 'angel:detected' events via the MagiEventBus.
+ */
+import type { AngelDetection, AngelDetectorConfig, CochangeEdge } from '../types/phase-k.js';
+import type { MagiEventBus } from './events.js';
+export declare class AngelDetector {
+    private readonly config;
+    private readonly eventBus?;
+    private cochangeGraph;
+    private microChangeHistory;
+    private watchTimer;
+    private lastWatchedCommit;
+    constructor(config?: Partial<AngelDetectorConfig>, eventBus?: MagiEventBus);
+    /**
+     * Run all 6 angel detectors against a single commit.
+     * Returns all detected angels (may be empty).
+     */
+    detectFromCommit(commitHash: string, cwd?: string): Promise<AngelDetection[]>;
+    /**
+     * Start polling for new commits and running detection.
+     */
+    startWatch(cwd?: string): void;
+    /**
+     * Stop the watch polling.
+     */
+    stopWatch(): void;
+    /**
+     * Get the current co-change graph.
+     */
+    getCochangeGraph(): CochangeEdge[];
+    /**
+     * Rebuild the internal co-change graph from a set of commits.
+     */
+    updateCochangeGraph(commitHashes: string[], cwd?: string): Promise<void>;
+    /**
+     * SACHIEL: Detect security-sensitive file changes.
+     * Checks if any changed file matches securityPatterns.
+     * ThreatLevel based on LA + LD: >100 RED, >30 ORANGE, else YELLOW.
+     */
+    private detectSachiel;
+    /**
+     * SHAMSHEL: Detect high-coupling hub node changes.
+     * If any changed file has degree >= hubDegreeThreshold in the co-change graph.
+     * RED if degree > 2x threshold, ORANGE if > 1.5x.
+     */
+    private detectShamshel;
+    /**
+     * RAMIEL: Detect high-entropy (scattered) changes.
+     * If computeEntropy(changes) > entropyThreshold.
+     * RED if > 0.95, ORANGE if > threshold.
+     */
+    private detectRamiel;
+    /**
+     * GAGHIEL: Detect ancient code modification.
+     * If any file age > ancientThresholdDays.
+     * RED if > 3x threshold, ORANGE if > 2x, else YELLOW.
+     */
+    private detectGaghiel;
+    /**
+     * ISRAFEL: Detect multi-developer conflict zones.
+     * If any file has NDEV >= 3 and changes from multiple devs.
+     * RED if NDEV >= 5, ORANGE if NDEV >= 3.
+     */
+    private detectIsrafel;
+    /**
+     * IRUEL: Detect boil-frog micro changes.
+     * Track commits with < 5 total lines changed.
+     * If accumulated micro-change count exceeds threshold, alert.
+     */
+    private detectIruel;
+}