magi-ai 0.1.0

package/dist/src/types/phase-k.d.ts

@@ -0,0 +1,259 @@
+/**
+ * Phase K (ロマン応用層) — Type definitions
+ *
+ * A-04 使徒検知 / A-08 死海文書 / B-04 自爆シーケンス / B-05 666型防壁 / B-06 ネブカドネザルの鍵
+ */
+import type { MagiUnit, Vote } from './core.js';
+/** Kamei metrics for a single commit */
+export interface KameiMetrics {
+    commitHash: string;
+    /** Number of modified subsystems (directories) */
+    NS: number;
+    /** Number of modified directories */
+    ND: number;
+    /** Number of modified files */
+    NF: number;
+    /** Shannon entropy of changes */
+    entropy: number;
+    /** Lines added */
+    LA: number;
+    /** Lines deleted */
+    LD: number;
+    /** Number of unique developers who touched the files */
+    NDEV: number;
+    /** Average file age in days */
+    AGE: number;
+}
+/** A single file change from a commit */
+export interface CommitFileChange {
+    status: 'A' | 'M' | 'D' | 'R' | 'C';
+    filePath: string;
+    linesAdded: number;
+    linesDeleted: number;
+}
+/** Co-change edge in the co-change graph */
+export interface CochangeEdge {
+    fileA: string;
+    fileB: string;
+    weight: number;
+}
+/** Angel (使徒) type identifiers */
+export type AngelType = 'SACHIEL' | 'SHAMSHEL' | 'RAMIEL' | 'GAGHIEL' | 'ISRAFEL' | 'IRUEL';
+/** Threat level of a detected angel */
+export type ThreatLevel = 'YELLOW' | 'ORANGE' | 'RED';
+/** A single angel detection */
+export interface AngelDetection {
+    angel: AngelType;
+    threatLevel: ThreatLevel;
+    commitHash: string;
+    description: string;
+    affectedFiles: string[];
+    metrics: Partial<KameiMetrics>;
+    detectedAt: string;
+}
+/** Configuration for the angel detector */
+export interface AngelDetectorConfig {
+    /** Security-related file patterns */
+    securityPatterns: RegExp[];
+    /** Entropy threshold for RAMIEL */
+    entropyThreshold: number;
+    /** Days threshold for GAGHIEL */
+    ancientThresholdDays: number;
+    /** Co-change hub degree threshold for SHAMSHEL */
+    hubDegreeThreshold: number;
+    /** Micro-change accumulation count for IRUEL */
+    microChangeThreshold: number;
+    /** Polling interval in ms for watch mode */
+    pollIntervalMs: number;
+}
+/** 9-dimensional feature vector for defect prediction */
+export interface FeatureVector {
+    churn: number;
+    commitFrequency: number;
+    uniqueAuthors: number;
+    bugFixRatio: number;
+    age: number;
+    cyclomaticComplexity: number;
+    satdCount: number;
+    testCoverage: number;
+    duplicateRatio: number;
+}
+/** Prophecy confidence level */
+export type ProphecyLevel = 'NOVICE' | 'SEER' | 'ORACLE' | 'PROPHET';
+/** A single prophecy about a file's defect probability */
+export interface Prophecy {
+    id: string;
+    filePath: string;
+    probability: number;
+    level: ProphecyLevel;
+    features: FeatureVector;
+    narrative: string;
+    createdAt: string;
+    fulfilled?: boolean;
+    fulfilledAt?: string;
+}
+/** Accuracy tracking for prophecy levels */
+export interface ProphecyAccuracy {
+    totalProphecies: number;
+    totalFulfilled: number;
+    levelAccuracy: Record<ProphecyLevel, {
+        total: number;
+        fulfilled: number;
+    }>;
+    lastUpdated: string;
+}
+/** Decision tree node for random forest */
+export interface DecisionTreeNode {
+    featureIndex?: number;
+    threshold?: number;
+    left?: DecisionTreeNode;
+    right?: DecisionTreeNode;
+    prediction?: number;
+}
+/** SATD (Self-Admitted Technical Debt) detection result */
+export interface SATDResult {
+    count: number;
+    patterns: {
+        pattern: string;
+        line: number;
+        text: string;
+    }[];
+}
+/** Self-destruct sequence phase */
+export type SelfDestructPhase = 'IDLE' | 'MOTION_FILED' | 'DELIBERATING' | 'COUNTDOWN' | 'EXECUTING' | 'COMPLETED' | 'ABORTED';
+/** A motion for self-destruct */
+export interface SelfDestructMotion {
+    id: string;
+    reason: string;
+    filedBy: string;
+    filedAt: string;
+    votes: Map<MagiUnit, Vote>;
+    phase: SelfDestructPhase;
+    countdownStartedAt?: number;
+    executedAt?: string;
+    abortedAt?: string;
+    abortedBy?: MagiUnit[];
+    cipherMessage?: string;
+}
+/** Geoid depth display for countdown */
+export interface GeoidDepth {
+    label: string;
+    depth: number;
+}
+/** Barrier layer identifier */
+export type BarrierLayer = 1 | 2 | '3-665' | 666;
+/** Threat category for firewall */
+export type FirewallThreatCategory = 'prompt_injection' | 'data_exfiltration' | 'logic_contradiction' | 'encoding_attack' | 'meta_instruction' | 'unknown';
+/** A single firewall scan threat finding */
+export interface FirewallThreat {
+    layer: BarrierLayer;
+    category: FirewallThreatCategory;
+    pattern: string;
+    description: string;
+    severity: number;
+}
+/** Result of a firewall scan */
+export interface FirewallResult {
+    passed: boolean;
+    threats: FirewallThreat[];
+    layersChecked: BarrierLayer[];
+    totalScore: number;
+    scanDurationMs: number;
+    scannedAt: string;
+}
+/** A learned dynamic pattern */
+export interface DynamicPattern {
+    pattern: string;
+    category: FirewallThreatCategory;
+    addedAt: string;
+    source: 'manual' | 'learned';
+}
+/** Override request signed by the creator */
+export interface OverrideRequest {
+    deliberationId: string;
+    newDecision: string;
+    newVote: Vote;
+    reason: string;
+    signature: string;
+    timestamp: string;
+    nonce: string;
+}
+/** Result of an override operation */
+export interface OverrideResult {
+    success: boolean;
+    deliberationId: string;
+    previousDecision: string;
+    newDecision: string;
+    confidenceMultiplier: number;
+    consecutiveOverrides: number;
+    overrideCount: number;
+    appliedAt: string;
+}
+/** Stored key state */
+export interface NebuchadnezzarState {
+    publicKey: string;
+    overrideCount: number;
+    consecutiveOverrides: number;
+    lastOverrideAt?: string;
+    createdAt: string;
+}
+export interface AngelDetectedEvent {
+    commitHash: string;
+    angel: AngelType;
+    threatLevel: ThreatLevel;
+    affectedFiles: string[];
+    emittedAt: Date;
+}
+export interface ScrollsProphecyEvent {
+    filePath: string;
+    probability: number;
+    level: ProphecyLevel;
+    emittedAt: Date;
+}
+export interface ScrollsFulfilledEvent {
+    prophecyId: string;
+    filePath: string;
+    emittedAt: Date;
+}
+export interface NebuchadnezzarOverrideEvent {
+    deliberationId: string;
+    previousDecision: string;
+    newDecision: string;
+    consecutiveOverrides: number;
+    emittedAt: Date;
+}
+export interface SelfDestructMotionEvent {
+    motionId: string;
+    reason: string;
+    filedBy: string;
+    emittedAt: Date;
+}
+export interface SelfDestructCountdownEvent {
+    motionId: string;
+    depth: GeoidDepth;
+    emittedAt: Date;
+}
+export interface SelfDestructExecutedEvent {
+    motionId: string;
+    reason: string;
+    cipherMessage?: string;
+    emittedAt: Date;
+}
+export interface SelfDestructAbortedEvent {
+    motionId: string;
+    abortedBy: MagiUnit[];
+    emittedAt: Date;
+}
+export interface FirewallScanEvent {
+    input: string;
+    passed: boolean;
+    threatCount: number;
+    totalScore: number;
+    emittedAt: Date;
+}
+export interface FirewallBlockedEvent {
+    input: string;
+    threats: FirewallThreat[];
+    totalScore: number;
+    emittedAt: Date;
+}

package/dist/src/types/phase-k.js

@@ -0,0 +1,6 @@
+/**
+ * Phase K (ロマン応用層) — Type definitions
+ *
+ * A-04 使徒検知 / A-08 死海文書 / B-04 自爆シーケンス / B-05 666型防壁 / B-06 ネブカドネザルの鍵
+ */
+export {};

package/dist/src/types/phase-l.d.ts

@@ -0,0 +1,199 @@
+/**
+ * Phase L (ロマン深淵層) — Type definitions
+ *
+ * A-07 S²エンジン / B-03 イロウル戦 / B-07 ゼーレ / B-10 Neon Genesis
+ */
+import type { MagiUnit, MagiOpinion } from './core.js';
+/** Diagnostic statistics gathered from MAGI workspace */
+export interface DiagnosticStats {
+    totalDeliberations: number;
+    consensusRate: number;
+    deadlockRate: number;
+    timeoutRate: number;
+    averageRounds: number;
+    cacheHitRate: number;
+    opinionChangeRate: number;
+    averageConfidence: number;
+}
+/** Category of improvement proposal */
+export type ProposalCategory = 'timeout_adjustment' | 'deadlock_strategy' | 'prompt_improvement' | 'cross_exam_tuning';
+/** A single improvement proposal generated by S² Engine */
+export interface ImprovementProposal {
+    id: string;
+    title: string;
+    targetFile: string;
+    category: ProposalCategory;
+    confidence: number;
+    description: string;
+    approvedByMeta: boolean;
+    applied: boolean;
+}
+/** A single evolution generation */
+export interface EvolutionGeneration {
+    generation: number;
+    proposals: ImprovementProposal[];
+    diagnostics: DiagnosticStats;
+    createdAt: string;
+}
+/** Full lineage of all evolution generations */
+export interface EvolutionLineage {
+    generations: EvolutionGeneration[];
+    lastGeneration: number;
+}
+/** Evolution engine phase */
+export type EvolutionPhase = 'IDLE' | 'DIAGNOSING' | 'PROPOSING' | 'META_DELIBERATING' | 'APPLYING' | 'VERIFYING' | 'COMPLETE' | 'ROLLBACK';
+/** Corruption level of a MAGI unit */
+export type CorruptionLevel = 'HEALTHY' | 'SUSPICIOUS' | 'UNDER_ATTACK' | 'COMPROMISED';
+/** Corruption state of a single unit */
+export interface UnitCorruptionState {
+    unit: MagiUnit;
+    level: CorruptionLevel;
+    corruptionProgress: number;
+    detectedAt: string;
+}
+/** 4-layer consistency check result */
+export interface ConsistencyCheck {
+    structural: boolean;
+    semantic: boolean;
+    behavioral: boolean;
+    crossValidation: boolean;
+    overallScore: number;
+    anomalies: string[];
+}
+/** Iruel battle phase state machine */
+export type IruelBattlePhase = 'STANDBY' | 'INFILTRATION_DETECTED' | 'MELCHIOR_COMPROMISED' | 'BALTHASAR_UNDER_ATTACK' | 'CASPER_LAST_DEFENSE' | 'COUNTER_HACK' | 'NEUTRALIZED' | 'DEFEAT';
+/** Counter-hack strategy */
+export interface CounterHackStrategy {
+    name: string;
+    description: string;
+    targetUnit: MagiUnit;
+    parserModification: string;
+}
+/** MAGI node identifier (6基) */
+export type MagiNodeId = 'MAGI-01' | 'MAGI-02' | 'MAGI-03' | 'MAGI-04' | 'MAGI-05' | 'MAGI-06';
+/** Node status */
+export type MagiNodeStatus = 'online' | 'offline' | 'compromised';
+/** Information about a MAGI node */
+export interface MagiNodeInfo {
+    id: MagiNodeId;
+    location: string;
+    host: string;
+    port: number;
+    publicKey: string;
+    status: MagiNodeStatus;
+}
+/** PBFT message type */
+export type PBFTMessageType = 'pre-prepare' | 'prepare' | 'commit';
+/** Raft role */
+export type RaftRole = 'leader' | 'follower' | 'candidate';
+/** A Seele protocol message */
+export interface SeeleMessage {
+    from: MagiNodeId;
+    to: MagiNodeId;
+    type: PBFTMessageType | 'raft-vote' | 'raft-heartbeat' | 'proposal' | 'attack';
+    payload: Record<string, unknown>;
+    signature: string;
+    timestamp: string;
+    sequence: number;
+}
+/** Seele session phase */
+export type SeeleSessionPhase = 'GATHERING' | 'LEADER_ELECTION' | 'DELIBERATION' | 'CONSENSUS' | 'ATTACK' | 'CONCLUDED';
+/** A Seele council session */
+export interface SeeleSession {
+    id: string;
+    nodes: MagiNodeInfo[];
+    leader: MagiNodeId | null;
+    phase: SeeleSessionPhase;
+    messages: SeeleMessage[];
+    decision: string | null;
+    startedAt: string;
+    completedAt: string | null;
+}
+/** Seele council configuration */
+export interface SeeleConfig {
+    pbftTimeout: number;
+    raftElectionTimeout: number;
+    maxRetries: number;
+}
+/** Genesis reset log entry */
+export interface GenesisLog {
+    resetId: string;
+    previousGeneration: number;
+    totalDeliberations: number;
+    survivalMemories: string[];
+    cipherMessagePreserved: boolean;
+    lastDeliberation: string | null;
+    resetAt: string;
+    initiator: string;
+}
+/** Pre-reset deliberation result */
+export interface PreResetDeliberation {
+    opinions: MagiOpinion[];
+    consensus: string;
+    finalWords: string;
+}
+export interface EvolutionStartedEvent {
+    generation: number;
+    diagnostics: DiagnosticStats;
+    emittedAt: Date;
+}
+export interface EvolutionProposalEvent {
+    generation: number;
+    proposal: ImprovementProposal;
+    emittedAt: Date;
+}
+export interface EvolutionAppliedEvent {
+    generation: number;
+    proposalId: string;
+    testsPassed: boolean;
+    emittedAt: Date;
+}
+export interface EvolutionRollbackEvent {
+    generation: number;
+    proposalId: string;
+    reason: string;
+    emittedAt: Date;
+}
+export interface IruelInfiltrationEvent {
+    unit: MagiUnit;
+    corruptionLevel: CorruptionLevel;
+    overallScore: number;
+    emittedAt: Date;
+}
+export interface IruelCounterhackEvent {
+    strategy: CounterHackStrategy;
+    emittedAt: Date;
+}
+export interface IruelNeutralizedEvent {
+    phase: IruelBattlePhase;
+    compromisedUnits: MagiUnit[];
+    emittedAt: Date;
+}
+export interface SeeleGatheringEvent {
+    sessionId: string;
+    nodes: MagiNodeId[];
+    emittedAt: Date;
+}
+export interface SeeleAttackEvent {
+    sessionId: string;
+    attackers: MagiNodeId[];
+    target: MagiNodeId;
+    emittedAt: Date;
+}
+export interface SeeleConcludedEvent {
+    sessionId: string;
+    decision: string | null;
+    leader: MagiNodeId | null;
+    emittedAt: Date;
+}
+export interface GenesisStartedEvent {
+    resetId: string;
+    reason: string;
+    emittedAt: Date;
+}
+export interface GenesisCompleteEvent {
+    resetId: string;
+    survivalMemories: number;
+    cipherPreserved: boolean;
+    emittedAt: Date;
+}

package/dist/src/types/phase-l.js

@@ -0,0 +1,6 @@
+/**
+ * Phase L (ロマン深淵層) — Type definitions
+ *
+ * A-07 S²エンジン / B-03 イロウル戦 / B-07 ゼーレ / B-10 Neon Genesis
+ */
+export {};

package/dist/src/types/pipeline.d.ts

@@ -0,0 +1,37 @@
+import type { MagiTask, DeliberationPhase, MagiOpinion, MagiDeliberation, TaskType, MagiUnit } from './core.js';
+import type { ConsensusConfig } from './consensus.js';
+/** Thresholds for adaptive early exit */
+export interface EarlyExitThresholds {
+    /** Confidence threshold for unanimous early exit (default: 0.7) */
+    unanimous: number;
+    /** Confidence threshold for majority early exit (default: 0.85) */
+    majority: number;
+}
+/** Configuration for a deliberation pipeline */
+export interface PipelineConfig {
+    phases: DeliberationPhase[];
+    maxRounds: number;
+    parallelInitialOpinions: boolean;
+    earlyConsensusExit: boolean;
+    earlyExitThresholds?: EarlyExitThresholds;
+    consensus: ConsensusConfig;
+    phaseTimeoutMs: number;
+    adapterTimeoutMs: number;
+    deliberationTimeoutMs: number;
+}
+/** Partial override of PipelineConfig for task-level customization */
+export type PipelineConfigOverride = Partial<Omit<PipelineConfig, 'consensus'>> & {
+    consensus?: Partial<ConsensusConfig>;
+};
+/** A pipeline defines how a specific task type flows through MAGI */
+export interface IPipeline {
+    readonly taskType: TaskType;
+    readonly name: string;
+    readonly defaultConfig: PipelineConfig;
+    buildSystemPrompt(task: MagiTask, unit: MagiUnit, phase: DeliberationPhase): string;
+    buildUserPrompt(task: MagiTask, phase: DeliberationPhase, previousOpinions?: MagiOpinion[]): string;
+    parseOpinion(raw: string, structured: Record<string, unknown> | null, unit: MagiUnit, phase: DeliberationPhase): Omit<MagiOpinion, 'rawOutput' | 'meta'>;
+    postProcess?(deliberation: MagiDeliberation): MagiDeliberation;
+}
+/** The JSON schema used to request structured output from CLIs */
+export { OPINION_JSON_SCHEMA } from '../parsers/opinion-schema.js';

package/dist/src/types/pipeline.js

@@ -0,0 +1,2 @@
+/** The JSON schema used to request structured output from CLIs */
+export { OPINION_JSON_SCHEMA } from '../parsers/opinion-schema.js';

package/dist/src/utils/abstain-factory.d.ts

@@ -0,0 +1,2 @@
+import type { MagiUnit, MagiOpinion } from '../types/core.js';
+export declare function createAbstainOpinion(unit: MagiUnit, reason: string, keyPoints: string[], overrides?: Partial<Pick<MagiOpinion, 'confidence' | 'rawOutput' | 'meta' | 'suggestions'>>): MagiOpinion;

package/dist/src/utils/abstain-factory.js

@@ -0,0 +1,18 @@
+const DEFAULT_ABSTAIN_META = {
+    durationMs: 0,
+    exitCode: -1,
+    retryCount: 0,
+    structuredOutput: false,
+};
+export function createAbstainOpinion(unit, reason, keyPoints, overrides) {
+    return {
+        unit,
+        vote: 'ABSTAIN',
+        confidence: overrides?.confidence ?? 0,
+        reasoning: reason,
+        keyPoints,
+        suggestions: overrides?.suggestions,
+        rawOutput: overrides?.rawOutput ?? '',
+        meta: overrides?.meta ?? { ...DEFAULT_ABSTAIN_META },
+    };
+}

package/dist/src/utils/errors.d.ts

@@ -0,0 +1,34 @@
+import type { MagiUnit, CliTool } from '../types/core.js';
+export declare class MagiError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string);
+}
+export declare class AdapterExecutionError extends MagiError {
+    readonly unit: MagiUnit;
+    readonly tool: CliTool;
+    readonly adapterCode: string;
+    readonly stderr?: string | undefined;
+    constructor(unit: MagiUnit, tool: CliTool, adapterCode: string, message: string, stderr?: string | undefined);
+}
+export declare class ConsensusError extends MagiError {
+    constructor(message: string);
+}
+export declare class PipelineNotFoundError extends MagiError {
+    constructor(taskType: string);
+}
+export declare class QuorumNotMetError extends MagiError {
+    constructor(available: number, required: number);
+}
+export declare class BinaryNotFoundError extends MagiError {
+    constructor(tool: CliTool);
+}
+export declare class PhaseTimeoutError extends MagiError {
+    readonly phase: string;
+    readonly timeoutMs: number;
+    constructor(phase: string, timeoutMs: number);
+}
+export declare class DeliberationTimeoutError extends MagiError {
+    readonly deliberationId: string;
+    readonly timeoutMs: number;
+    constructor(deliberationId: string, timeoutMs: number);
+}

package/dist/src/utils/errors.js

@@ -0,0 +1,59 @@
+export class MagiError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'MagiError';
+    }
+}
+export class AdapterExecutionError extends MagiError {
+    unit;
+    tool;
+    adapterCode;
+    stderr;
+    constructor(unit, tool, adapterCode, message, stderr) {
+        super(message, 'ADAPTER_EXECUTION_ERROR');
+        this.unit = unit;
+        this.tool = tool;
+        this.adapterCode = adapterCode;
+        this.stderr = stderr;
+    }
+}
+export class ConsensusError extends MagiError {
+    constructor(message) {
+        super(message, 'CONSENSUS_ERROR');
+    }
+}
+export class PipelineNotFoundError extends MagiError {
+    constructor(taskType) {
+        super(`No pipeline registered for task type: ${taskType}`, 'PIPELINE_NOT_FOUND');
+    }
+}
+export class QuorumNotMetError extends MagiError {
+    constructor(available, required) {
+        super(`Quorum not met: ${available} responses, ${required} required`, 'QUORUM_NOT_MET');
+    }
+}
+export class BinaryNotFoundError extends MagiError {
+    constructor(tool) {
+        super(`CLI tool not found: ${tool}. Is it installed and in PATH?`, 'BINARY_NOT_FOUND');
+    }
+}
+export class PhaseTimeoutError extends MagiError {
+    phase;
+    timeoutMs;
+    constructor(phase, timeoutMs) {
+        super(`Phase "${phase}" timed out after ${timeoutMs}ms`, 'PHASE_TIMEOUT');
+        this.phase = phase;
+        this.timeoutMs = timeoutMs;
+    }
+}
+export class DeliberationTimeoutError extends MagiError {
+    deliberationId;
+    timeoutMs;
+    constructor(deliberationId, timeoutMs) {
+        super(`Deliberation "${deliberationId}" exceeded hard timeout of ${timeoutMs}ms`, 'DELIBERATION_TIMEOUT');
+        this.deliberationId = deliberationId;
+        this.timeoutMs = timeoutMs;
+    }
+}

package/dist/src/utils/file-validator.d.ts

@@ -0,0 +1,50 @@
+/**
+ * File validator — shared by CLI, REPL, and MCP for input file validation.
+ *
+ * Extracted from slash-commands.ts validateWorkspaceFile() to provide
+ * a unified, structured result interface usable across all entry points.
+ */
+export type FileValidationErrorCode = 'ENOENT' | 'EACCES' | 'PATH_TRAVERSAL' | 'SYMLINK' | 'NOT_FILE' | 'TOO_LARGE' | 'BINARY' | 'INVALID_PATH';
+export interface FileValidationOk {
+    ok: true;
+    file: {
+        absolutePath: string;
+        relativePath: string;
+        sizeBytes: number;
+    };
+}
+export interface FileValidationErr {
+    ok: false;
+    error: {
+        code: FileValidationErrorCode;
+        message: string;
+    };
+}
+export type FileValidationResult = FileValidationOk | FileValidationErr;
+export interface ValidateFileOptions {
+    /** Maximum file size in bytes (default: no limit) */
+    maxBytes?: number;
+    /** Reject binary files by extension + null-byte check (default: false) */
+    rejectBinary?: boolean;
+    /** Base directory for path traversal checks (default: process.cwd()) */
+    basedir?: string;
+}
+/**
+ * Validate a file path for safe access.
+ *
+ * Checks (in order):
+ * 1. Null bytes / empty path
+ * 2. Path traversal (relative path escapes basedir)
+ * 3. Realpath traversal (symlink parent escape)
+ * 4. Symlink target
+ * 5. Regular file check
+ * 6. Size limit
+ * 7. Binary extension check
+ * 8. Binary null-byte check (fallback)
+ */
+export declare function validateFile(inputPath: string, options?: ValidateFileOptions): Promise<FileValidationResult>;
+/**
+ * Check if the first N bytes of a file contain null bytes.
+ * Returns true if null bytes are found (likely binary file).
+ */
+export declare function containsNullBytes(filePath: string, checkBytes?: number): Promise<boolean>;