magi-ai 0.1.0

package/dist/src/engine/consensus.js

@@ -0,0 +1,146 @@
+import { getMajorityVote } from '../types/consensus.js';
+/**
+ * MAGI Consensus Engine
+ *
+ * Calculates consensus from N MAGI units' opinions (2-7) using:
+ * - Unanimous: all agree
+ * - Majority: more than half of non-abstain voters
+ * - Deadlock resolution: configurable strategy
+ */
+export class ConsensusEngine {
+    config;
+    constructor(config) {
+        this.config = config;
+        if (!config) {
+            throw new Error('ConsensusEngine requires a ConsensusConfig');
+        }
+    }
+    calculate(opinions) {
+        const votes = this.tallyVotes(opinions);
+        const nonAbstainCount = votes.approve.length + votes.reject.length;
+        // Check quorum
+        if (nonAbstainCount < this.config.quorum) {
+            return this.buildResult('INSUFFICIENT', 'escalated', votes, opinions);
+        }
+        // Unanimous check (excluding dummy plug units if configured)
+        const excluded = new Set(this.config.excludeFromUnanimous ?? []);
+        const eligibleOpinions = opinions.filter(o => !excluded.has(o.unit));
+        const eligibleCount = eligibleOpinions.length;
+        if (eligibleCount > 0) {
+            const eligibleApprove = eligibleOpinions.filter(o => o.vote === 'APPROVE').length;
+            const eligibleReject = eligibleOpinions.filter(o => o.vote === 'REJECT').length;
+            if (eligibleApprove === eligibleCount) {
+                return this.buildResult('UNANIMOUS_APPROVE', 'unanimous', votes, opinions);
+            }
+            if (eligibleReject === eligibleCount) {
+                return this.buildResult('UNANIMOUS_REJECT', 'unanimous', votes, opinions);
+            }
+        }
+        // Majority check: proper majority threshold (floor(nonAbstain / 2) + 1)
+        const majorityThreshold = Math.floor(nonAbstainCount / 2) + 1;
+        if (votes.approve.length >= majorityThreshold) {
+            return this.buildResult('MAJORITY_APPROVE', 'majority', votes, opinions);
+        }
+        if (votes.reject.length >= majorityThreshold) {
+            return this.buildResult('MAJORITY_REJECT', 'majority', votes, opinions);
+        }
+        // Deadlock: neither side reaches majority
+        return this.resolveDeadlock(votes, opinions);
+    }
+    tallyVotes(opinions) {
+        const approve = [];
+        const reject = [];
+        const abstain = [];
+        let weightedApprove = 0;
+        let weightedReject = 0;
+        for (const opinion of opinions) {
+            const weight = this.getUnitWeight(opinion.unit) * opinion.confidence;
+            switch (opinion.vote) {
+                case 'APPROVE':
+                    approve.push(opinion.unit);
+                    weightedApprove += weight;
+                    break;
+                case 'REJECT':
+                    reject.push(opinion.unit);
+                    weightedReject += weight;
+                    break;
+                case 'ABSTAIN':
+                    abstain.push(opinion.unit);
+                    break;
+            }
+        }
+        return { approve, reject, abstain, weightedApprove, weightedReject };
+    }
+    resolveDeadlock(votes, opinions) {
+        switch (this.config.deadlockStrategy) {
+            case 'melchior-tiebreak': {
+                const melchior = opinions.find((o) => o.unit === 'MELCHIOR');
+                if (melchior && melchior.vote !== 'ABSTAIN') {
+                    const decision = melchior.vote === 'APPROVE' ? 'MAJORITY_APPROVE' : 'MAJORITY_REJECT';
+                    return this.buildResult(decision, 'tiebreak', votes, opinions);
+                }
+                // Fallback: highest-confidence when MELCHIOR not present
+                const nonAbstain = opinions.filter((o) => o.vote !== 'ABSTAIN');
+                const sorted = [...nonAbstain].sort((a, b) => b.confidence - a.confidence);
+                const highest = sorted[0];
+                if (highest) {
+                    const decision = highest.vote === 'APPROVE' ? 'MAJORITY_APPROVE' : 'MAJORITY_REJECT';
+                    return this.buildResult(decision, 'weighted', votes, opinions);
+                }
+                return this.buildResult('DEADLOCK', 'escalated', votes, opinions);
+            }
+            case 'highest-confidence': {
+                const nonAbstain = opinions.filter((o) => o.vote !== 'ABSTAIN');
+                const sorted = [...nonAbstain].sort((a, b) => b.confidence - a.confidence);
+                const highest = sorted[0];
+                if (highest) {
+                    const decision = highest.vote === 'APPROVE' ? 'MAJORITY_APPROVE' : 'MAJORITY_REJECT';
+                    return this.buildResult(decision, 'weighted', votes, opinions);
+                }
+                return this.buildResult('DEADLOCK', 'escalated', votes, opinions);
+            }
+            case 'human-in-the-loop':
+            case 'escalate':
+            default:
+                return this.buildResult('DEADLOCK', 'escalated', votes, opinions);
+        }
+    }
+    getUnitWeight(unit) {
+        return this.config.unitWeights?.[unit] ?? 1.0;
+    }
+    buildResult(decision, method, votes, opinions) {
+        const majorityVote = getMajorityVote(decision);
+        const dissent = opinions
+            .filter((o) => o.vote !== majorityVote && o.vote !== 'ABSTAIN')
+            .map((o) => ({
+            unit: o.unit,
+            vote: o.vote,
+            reasoning: o.reasoning,
+        }));
+        const confidences = opinions.map((o) => o.confidence);
+        const avgConfidence = confidences.length > 0
+            ? confidences.reduce((sum, c) => sum + c, 0) / confidences.length
+            : 0;
+        return {
+            decision,
+            method,
+            votes,
+            confidence: avgConfidence,
+            summary: this.buildSummary(decision, method, votes),
+            dissent: dissent.length > 0 ? dissent : undefined,
+        };
+    }
+    buildSummary(decision, method, votes) {
+        const decisionLabel = decision.replace(/_/g, ' ');
+        const methodLabel = method.toUpperCase();
+        const approveNames = votes.approve.join(', ') || 'none';
+        const rejectNames = votes.reject.join(', ') || 'none';
+        const abstainNames = votes.abstain.join(', ') || 'none';
+        return [
+            `MAGI DECISION: ${decisionLabel} (via ${methodLabel})`,
+            `APPROVE: ${approveNames}`,
+            `REJECT: ${rejectNames}`,
+            `ABSTAIN: ${abstainNames}`,
+        ].join('\n');
+    }
+}

package/dist/src/engine/dead-sea-scrolls.d.ts

@@ -0,0 +1,132 @@
+/**
+ * DeadSeaScrolls --- 死海文書 預言エンジン (A-08)
+ *
+ * ファイルの9次元特徴量ベクトルからランダムフォレストで欠陥確率を予測し、
+ * エヴァンゲリオン風の預言ナラティブを生成する。
+ * 外部ML依存なし --- ランダムフォレストをスクラッチ実装。
+ */
+import type { ProphecyLevel, Prophecy, ProphecyAccuracy, DecisionTreeNode, SATDResult } from '../types/phase-k.js';
+import type { MagiEventBus } from './events.js';
+/**
+ * Calculate Gini impurity for a set of labels.
+ * Gini = 1 - sum(p_i^2) where labels are binned into [0,0.5) and [0.5,1].
+ */
+export declare function giniImpurity(labels: number[]): number;
+interface TrainingPoint {
+    features: number[];
+    label: number;
+}
+/**
+ * Build a decision tree recursively.
+ */
+export declare function buildTree(data: TrainingPoint[], depth: number, maxDepth: number, featureSubset: number[]): DecisionTreeNode;
+/**
+ * Traverse a decision tree to get a prediction.
+ */
+export declare function predictTree(node: DecisionTreeNode, features: number[]): number;
+/**
+ * Create a bootstrap sample (with replacement) of the same size as the input.
+ */
+export declare function bootstrapSample(data: TrainingPoint[], rng: () => number): TrainingPoint[];
+/**
+ * Train a random forest: 50 trees, each on a bootstrap sample
+ * with sqrt(9)=3 randomly selected features per split.
+ */
+export declare function trainForest(data: TrainingPoint[], rng: () => number): DecisionTreeNode[];
+/**
+ * Predict using the random forest: average prediction across all trees.
+ */
+export declare function predictForest(trees: DecisionTreeNode[], features: number[]): number;
+/**
+ * Generate a pre-trained default forest using a seeded PRNG.
+ * Creates realistic trees that split on sensible thresholds for
+ * the 9-dimensional feature vector.
+ *
+ * Feature semantics and typical ranges:
+ * 0: churn (0-5000)          - higher = more risky
+ * 1: commitFrequency (0-100) - moderate is best
+ * 2: uniqueAuthors (1-20)    - too many authors = risky
+ * 3: bugFixRatio (0-1)       - higher = more risky
+ * 4: age (0-3650 days)       - very old = risky
+ * 5: cyclomaticComplexity (0-100) - higher = more risky
+ * 6: satdCount (0-50)        - higher = more risky
+ * 7: testCoverage (0-1)      - lower = more risky
+ * 8: duplicateRatio (0-1)    - higher = more risky
+ */
+export declare function generateDefaultForest(): DecisionTreeNode[];
+/**
+ * Scan file content line by line for Self-Admitted Technical Debt patterns.
+ */
+export declare function detectSATD(content: string): SATDResult;
+/**
+ * Map defect probability to prophecy level.
+ */
+export declare function getProphecyLevel(probability: number): ProphecyLevel;
+/**
+ * Generate Evangelion-themed prophecy narrative text.
+ */
+export declare function generateNarrative(prophecy: Prophecy): string;
+/**
+ * Estimate cyclomatic complexity from source code by counting
+ * branching constructs: if, else, for, while, switch, case, &&, ||.
+ */
+export declare function estimateCyclomaticComplexity(content: string): number;
+export declare class DeadSeaScrolls {
+    private readonly scrollsDir;
+    private readonly eventBus?;
+    private _forest;
+    private prophecies;
+    private accuracy;
+    /** Lazy-initialized random forest. Built on first access to avoid startup cost. */
+    private get forest();
+    constructor(workspaceDir: string, eventBus?: MagiEventBus);
+    /**
+     * Extract 9-dimensional feature vector for a file.
+     */
+    private extractFeatures;
+    /**
+     * Convert FeatureVector to numeric array for the forest.
+     */
+    private featuresToArray;
+    /**
+     * Analyze a single file and produce a prophecy.
+     */
+    analyze(filePath: string, cwd?: string): Promise<Prophecy>;
+    /**
+     * Analyze all TypeScript files in a directory.
+     */
+    analyzeAll(dirPath: string, cwd?: string): Promise<Prophecy[]>;
+    /**
+     * Recursively find all .ts files in a directory.
+     */
+    private findTsFiles;
+    /**
+     * Detect SATD patterns in content.
+     */
+    detectSATD(content: string): SATDResult;
+    /**
+     * Generate prophecy narrative.
+     */
+    generateNarrative(prophecy: Prophecy): string;
+    /**
+     * Record that a prophecy was fulfilled (defect actually occurred).
+     */
+    recordFulfillment(prophecyId: string): Promise<boolean>;
+    /**
+     * Get current accuracy statistics.
+     */
+    getAccuracy(): ProphecyAccuracy;
+    /**
+     * Load prophecies and accuracy from persistence.
+     */
+    load(): Promise<void>;
+    /**
+     * Persist prophecies and accuracy to disk.
+     */
+    persist(): Promise<void>;
+    /** Get the current forest (for testing). */
+    getForest(): DecisionTreeNode[];
+    /** Get stored prophecies (for testing). */
+    getProphecies(): Map<string, Prophecy>;
+}
+export {};