create-principles-disciple 1.82.0 → 1.83.0

package/console/dist/server/models/EvolutionConsoleModel.js

@@ -1,179 +0,0 @@
-import * as path from 'path';
-import * as fs from 'fs';
-import { RuntimeStateManager, InternalizationQueueReadModel, } from '@principles/core/runtime-v2';
-export class EvolutionConsoleModel {
-    workspaceDir;
-    stateManager = null;
-    initPromise = null;
-    constructor(workspaceDir) {
-        this.workspaceDir = workspaceDir;
-    }
-    async ensureInitialized() {
-        if (!this.stateManager) {
-            this.stateManager = new RuntimeStateManager({ workspaceDir: this.workspaceDir });
-            this.initPromise = this.stateManager.initialize();
-        }
-        await this.initPromise;
-        return this.stateManager;
-    }
-    async getStats() {
-        const mgr = await this.ensureInitialized();
-        const allTasks = await mgr.listTasks();
-        let pending = 0;
-        let inProgress = 0;
-        let completed = 0;
-        let failed = 0;
-        const stageMap = {};
-        for (const task of allTasks) {
-            switch (task.status) {
-                case 'pending':
-                    pending++;
-                    break;
-                case 'leased':
-                    inProgress++;
-                    break;
-                case 'succeeded':
-                    completed++;
-                    break;
-                case 'retry_wait':
-                    inProgress++;
-                    break;
-                case 'failed':
-                    failed++;
-                    break;
-                default: break;
-            }
-            const stage = task.status;
-            stageMap[stage] = (stageMap[stage] ?? 0) + 1;
-        }
-        const stageDistribution = Object.entries(stageMap)
-            .map(([stage, count]) => ({ stage, count }))
-            .sort((a, b) => b.count - a.count);
-        return {
-            total: allTasks.length,
-            pending,
-            inProgress,
-            completed,
-            failed,
-            stageDistribution,
-        };
-    }
-    async getTasks(filters = {}) {
-        const mgr = await this.ensureInitialized();
-        const page = Math.max(1, filters.page ?? 1);
-        const pageSize = Math.min(Math.max(1, filters.pageSize ?? 20), 100);
-        let tasks = await mgr.listTasks();
-        if (filters.status && filters.status !== 'all') {
-            tasks = tasks.filter(t => t.status === filters.status);
-        }
-        if (filters.taskKind && filters.taskKind !== 'all') {
-            tasks = tasks.filter(t => t.taskKind === filters.taskKind);
-        }
-        tasks.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
-        const total = tasks.length;
-        const offset = (page - 1) * pageSize;
-        const items = tasks.slice(offset, offset + pageSize).map(t => ({
-            taskId: t.taskId,
-            taskKind: t.taskKind,
-            status: t.status,
-            createdAt: t.createdAt,
-            leaseOwner: t.leaseOwner ?? null,
-            leaseExpiresAt: t.leaseExpiresAt ?? null,
-        }));
-        return {
-            items,
-            pagination: {
-                page,
-                pageSize,
-                total,
-                totalPages: total === 0 ? 0 : Math.ceil(total / pageSize),
-            },
-        };
-    }
-    async getPrinciples() {
-        const stateDir = path.join(this.workspaceDir, '.state');
-        const ledgerPath = path.join(stateDir, 'principle_training_state.json');
-        const summary = {
-            candidate: 0,
-            probation: 0,
-            active: 0,
-            deprecated: 0,
-            archived: 0,
-            total: 0,
-        };
-        const recent = [];
-        if (!fs.existsSync(ledgerPath)) {
-            return { summary, recent };
-        }
-        try {
-            const raw = fs.readFileSync(ledgerPath, 'utf8');
-            const parsed = JSON.parse(raw);
-            const principles = Object.values(parsed._tree?.principles ?? parsed.tree?.principles ?? {});
-            for (const p of principles) {
-                summary.total++;
-                switch (p.status) {
-                    case 'candidate':
-                        summary.candidate++;
-                        break;
-                    case 'probation':
-                        summary.probation++;
-                        break;
-                    case 'active':
-                        summary.active++;
-                        break;
-                    case 'deprecated':
-                        summary.deprecated++;
-                        break;
-                    case 'archived':
-                        summary.archived++;
-                        break;
-                }
-            }
-            const sorted = [...principles].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
-            for (const p of sorted.slice(0, 20)) {
-                recent.push({
-                    principleId: p.id,
-                    status: p.status,
-                    text: p.text,
-                    triggerPattern: p.triggerPattern,
-                    action: p.action,
-                    evaluability: p.evaluability,
-                    createdAt: p.createdAt,
-                    updatedAt: p.updatedAt,
-                });
-            }
-        }
-        catch {
-            // Silently skip invalid entries
-        }
-        return { summary, recent };
-    }
-    async getQueueHealth() {
-        const mgr = await this.ensureInitialized();
-        const readModel = new InternalizationQueueReadModel(mgr);
-        try {
-            const snapshot = await readModel.getSnapshot();
-            return {
-                pendingCount: snapshot.pendingCount,
-                retryWaitCount: snapshot.retryWaitCount,
-                countsByTaskKind: snapshot.countsByTaskKind,
-                countsByChannel: snapshot.countsByChannel,
-                invalidMetadataCount: snapshot.invalidMetadataCount,
-                blockedCount: snapshot.blockedSummary.count,
-                dependencyFailedCount: snapshot.dependencyFailedSummary.count,
-                readyTaskCount: snapshot.readyTasks.length,
-                noReadyTasksReason: snapshot.noReadyTasks?.reason ?? null,
-            };
-        }
-        finally {
-            await readModel.close();
-        }
-    }
-    dispose() {
-        if (this.stateManager) {
-            this.stateManager.close().catch((_e) => { });
-            this.stateManager = null;
-        }
-        this.initPromise = null;
-    }
-}

package/console/dist/server/models/FeedbackConsoleModel.d.ts

@@ -1,38 +0,0 @@
-import type { GateBlockItem, EmpathyEvent } from '../types/index.js';
-export declare class FeedbackConsoleModel {
-    private readonly workspaceDir;
-    private readonly stateDir;
-    private gateModel;
-    private eventLogReadModel;
-    constructor(workspaceDir: string);
-    getGfi(): Promise<{
-        current: number;
-        peakToday: number;
-        threshold: number;
-        trend: {
-            hour: string;
-            value: number;
-        }[];
-        sources: Record<string, number>;
-    }>;
-    getEmpathyEvents(_limit?: number): Promise<EmpathyEvent[]>;
-    getEmpathySummary(): Promise<{
-        totalEvents: number;
-        totalPenaltyScore: number;
-        rollbackCount: number;
-        bySeverity: Record<string, number>;
-        byOrigin: Record<string, number>;
-    }>;
-    getGateBlocks(limit?: number): Promise<GateBlockItem[]>;
-    getRuleHostSummary(): Promise<{
-        totalEvaluated: number;
-        totalBlocked: number;
-        totalRequireApproval: number;
-        blockRate: number;
-    }>;
-    private static convertScoreToSeverity;
-    private readDailyStats;
-    private getGateModel;
-    private getEventLogReadModel;
-    dispose(): void;
-}

package/console/dist/server/models/FeedbackConsoleModel.js

@@ -1,129 +0,0 @@
-import * as path from 'path';
-import * as fs from 'fs';
-import { EventLogReadModel } from './EventLogReadModel.js';
-import { GateConsoleModel } from './GateConsoleModel.js';
-export class FeedbackConsoleModel {
-    workspaceDir;
-    stateDir;
-    gateModel = null;
-    eventLogReadModel = null;
-    constructor(workspaceDir) {
-        this.workspaceDir = workspaceDir;
-        this.stateDir = path.join(workspaceDir, '.state');
-    }
-    async getGfi() {
-        const stats = await this.getGateModel().getGateStats();
-        return {
-            current: stats.gfi.current,
-            peakToday: stats.gfi.peakToday,
-            threshold: stats.gfi.threshold,
-            trend: stats.gfi.trend,
-            sources: stats.gfi.sources,
-        };
-    }
-    async getEmpathyEvents(_limit) {
-        const events = await this.getEventLogReadModel().getEventsByTypes(['empathy_rollback', 'user_empathy', 'pain_signal'], _limit ?? 50);
-        return events
-            .filter(e => e.type === 'empathy_rollback' ||
-            e.type === 'user_empathy' ||
-            (e.type === 'pain_signal' && typeof e.data?.source === 'string'))
-            .map(event => ({
-            timestamp: event.ts,
-            severity: FeedbackConsoleModel.convertScoreToSeverity(event.data?.score ?? 50),
-            score: event.data?.score ?? 50,
-            reason: event.data?.reason ?? '',
-            origin: typeof event.data?.origin === 'string' ? event.data.origin : typeof event.data?.source === 'string' ? event.data.source : 'unknown',
-            gfiAfter: 0,
-        }));
-    }
-    async getEmpathySummary() {
-        const dailyStats = await this.readDailyStats();
-        let totalEvents = 0;
-        let totalPenaltyScore = 0;
-        let rollbackCount = 0;
-        const bySeverity = {};
-        const byOrigin = {};
-        for (const day of Object.values(dailyStats)) {
-            const emp = day?.empathy;
-            if (!emp)
-                continue;
-            totalEvents += Number(emp.totalEvents) || 0;
-            totalPenaltyScore += Number(emp.totalPenaltyScore) || 0;
-            rollbackCount += Number(emp.rollbackCount) || 0;
-            if (emp.bySeverity) {
-                for (const [k, v] of Object.entries(emp.bySeverity)) {
-                    bySeverity[k] = (bySeverity[k] ?? 0) + (Number(v) || 0);
-                }
-            }
-            if (emp.byOrigin) {
-                for (const [k, v] of Object.entries(emp.byOrigin)) {
-                    byOrigin[k] = (byOrigin[k] ?? 0) + (Number(v) || 0);
-                }
-            }
-        }
-        return { totalEvents, totalPenaltyScore, rollbackCount, bySeverity, byOrigin };
-    }
-    async getGateBlocks(limit) {
-        return this.getGateModel().getGateBlocks(limit);
-    }
-    async getRuleHostSummary() {
-        const dailyStats = await this.readDailyStats();
-        let totalEvaluated = 0;
-        let totalBlocked = 0;
-        let totalRequireApproval = 0;
-        for (const day of Object.values(dailyStats)) {
-            const evo = day?.evolution;
-            if (!evo)
-                continue;
-            totalEvaluated += Number(evo.rulehostEvaluated) || 0;
-            totalBlocked += Number(evo.rulehostBlocked) || 0;
-            totalRequireApproval += Number(evo.rulehostRequireApproval) || 0;
-        }
-        return {
-            totalEvaluated,
-            totalBlocked,
-            totalRequireApproval,
-            blockRate: totalEvaluated > 0 ? Math.round((totalBlocked / totalEvaluated) * 10000) / 100 : 0,
-        };
-    }
-    static convertScoreToSeverity(score) {
-        if (score >= 70)
-            return 'high';
-        if (score >= 40)
-            return 'medium';
-        return 'low';
-    }
-    async readDailyStats() {
-        const statsPath = path.join(this.stateDir, 'logs', 'daily-stats.json');
-        try {
-            const raw = await fs.promises.readFile(statsPath, 'utf8');
-            return JSON.parse(raw);
-        }
-        catch {
-            console.warn('[FeedbackConsoleModel] Failed to parse daily-stats.json at ' + statsPath);
-            return {};
-        }
-    }
-    getGateModel() {
-        if (!this.gateModel) {
-            this.gateModel = new GateConsoleModel(this.workspaceDir);
-        }
-        return this.gateModel;
-    }
-    getEventLogReadModel() {
-        if (!this.eventLogReadModel) {
-            this.eventLogReadModel = new EventLogReadModel(this.stateDir);
-        }
-        return this.eventLogReadModel;
-    }
-    dispose() {
-        if (this.gateModel) {
-            this.gateModel.dispose();
-            this.gateModel = null;
-        }
-        if (this.eventLogReadModel) {
-            this.eventLogReadModel.dispose();
-            this.eventLogReadModel = null;
-        }
-    }
-}

package/console/dist/server/models/GateConsoleModel.d.ts

@@ -1,50 +0,0 @@
-import type { GateBlockItem } from '../types/index.js';
-export interface GateStatsOutput {
-    generatedAt: string;
-    today: {
-        gfiBlocks: number;
-        stageBlocks: number;
-        bypassAttempts: number;
-    };
-    trust: {
-        stage: number;
-        score: number;
-        status: 'healthy' | 'warning' | 'critical';
-    };
-    evolution: {
-        tier: string;
-        points: number;
-        status: string;
-    };
-    gfi: {
-        current: number;
-        peakToday: number;
-        threshold: number;
-        trend: {
-            hour: string;
-            value: number;
-        }[];
-        sources: Record<string, number>;
-        stage: 'stable' | 'elevated' | 'critical' | 'saturated';
-    };
-}
-export declare class GateConsoleModel {
-    private readonly workspaceDir;
-    private readonly stateDir;
-    private healthReadModel;
-    private painChainReadModel;
-    private pruningReadModel;
-    private stateManager;
-    private eventLogReadModel;
-    private ownsHealthReadModel;
-    constructor(workspaceDir: string);
-    getGateStats(): Promise<GateStatsOutput>;
-    getGateBlocks(_limit?: number): Promise<GateBlockItem[]>;
-    private static classifyGateType;
-    dispose(): void;
-    private getHealthReadModel;
-    private getPainChainReadModel;
-    private getPruningReadModel;
-    private getStateManager;
-    private getEventLogReadModel;
-}

package/console/dist/server/models/GateConsoleModel.js

@@ -1,151 +0,0 @@
-import * as path from 'path';
-import { OperatorHealthReadModel, PainChainReadModel, PruningReadModel, RuntimeStateManager, classifyGfiWorkspaceHealth, } from '@principles/core/runtime-v2';
-import { EventLogReadModel } from './EventLogReadModel.js';
-export class GateConsoleModel {
-    workspaceDir;
-    stateDir;
-    healthReadModel = null;
-    painChainReadModel = null;
-    pruningReadModel = null;
-    stateManager = null;
-    eventLogReadModel = null;
-    ownsHealthReadModel = false;
-    constructor(workspaceDir) {
-        this.workspaceDir = workspaceDir;
-        this.stateDir = path.join(workspaceDir, '.state');
-    }
-    async getGateStats() {
-        const snapshot = await this.getHealthReadModel().getSnapshot();
-        const gfiSnapshot = snapshot.gfi;
-        const { active } = gfiSnapshot;
-        const currentGfi = active?.currentGfi ?? 0;
-        const health = classifyGfiWorkspaceHealth(gfiSnapshot);
-        const trustStatus = health.status === 'degraded' ? 'warning' : 'healthy';
-        const sources = {};
-        if (active?.sources) {
-            for (const [key, value] of Object.entries(active.sources)) {
-                if (value !== undefined) {
-                    sources[key] = value;
-                }
-            }
-        }
-        const eventLog = this.getEventLogReadModel();
-        const [gfiBlocks, stageBlocks, bypassAttempts] = await Promise.all([
-            eventLog.countEventsByTypeToday('gate_block'),
-            eventLog.countEventsByTypeToday('stage_block'),
-            eventLog.countEventsByTypeToday('gate_bypass'),
-        ]);
-        return {
-            generatedAt: snapshot.generatedAt,
-            today: {
-                gfiBlocks,
-                stageBlocks,
-                bypassAttempts,
-            },
-            trust: {
-                stage: 0,
-                score: 0,
-                status: trustStatus,
-            },
-            evolution: {
-                tier: '',
-                points: 0,
-                status: '',
-            },
-            gfi: {
-                current: currentGfi,
-                peakToday: active?.dailyGfiPeak ?? 0,
-                threshold: active?.policy?.criticalThreshold ?? 80,
-                trend: [],
-                sources,
-                stage: active?.stage ?? 'stable',
-            },
-        };
-    }
-    async getGateBlocks(_limit) {
-        const events = await this.getEventLogReadModel().getGateBlocks(_limit ?? 100);
-        return events.map(event => ({
-            timestamp: event.ts,
-            toolName: event.data.toolName ?? 'unknown',
-            filePath: event.data.filePath ?? null,
-            reason: event.data.reason ?? '',
-            gateType: GateConsoleModel.classifyGateType(event.data.blockSource),
-            gfi: 0,
-            trustStage: 0,
-        }));
-    }
-    static classifyGateType(source) {
-        if (!source)
-            return 'other';
-        if (source.includes('gfi') || source.includes('GFI'))
-            return 'gfi';
-        if (source.includes('stage') || source.includes('trust'))
-            return 'stage';
-        if (source.includes('p03') || source.includes('P03'))
-            return 'p03';
-        return 'other';
-    }
-    dispose() {
-        if (this.healthReadModel && this.ownsHealthReadModel) {
-            this.healthReadModel.close().catch((err) => {
-                console.error('[GateConsoleModel] Failed to close health read model:', err);
-            });
-        }
-        if (this.painChainReadModel) {
-            this.painChainReadModel.close().catch((err) => {
-                console.error('[GateConsoleModel] Failed to close pain chain read model:', err);
-            });
-        }
-        if (this.stateManager) {
-            this.stateManager.close().catch((err) => {
-                console.error('[GateConsoleModel] Failed to close state manager:', err);
-            });
-        }
-        if (this.eventLogReadModel) {
-            this.eventLogReadModel.dispose();
-            this.eventLogReadModel = null;
-        }
-    }
-    getHealthReadModel() {
-        if (!this.healthReadModel) {
-            const painChainReadModel = this.getPainChainReadModel();
-            const pruningReadModel = this.getPruningReadModel();
-            this.healthReadModel = new OperatorHealthReadModel({
-                workspaceDir: this.workspaceDir,
-                painChainReadModel,
-                pruningReadModel,
-            });
-            this.ownsHealthReadModel = true;
-        }
-        return this.healthReadModel;
-    }
-    getPainChainReadModel() {
-        if (!this.painChainReadModel) {
-            this.painChainReadModel = new PainChainReadModel({
-                workspaceDir: this.workspaceDir,
-                stateManager: this.getStateManager(),
-            });
-        }
-        return this.painChainReadModel;
-    }
-    getPruningReadModel() {
-        if (!this.pruningReadModel) {
-            this.pruningReadModel = new PruningReadModel({
-                workspaceDir: this.workspaceDir,
-            });
-        }
-        return this.pruningReadModel;
-    }
-    getStateManager() {
-        if (!this.stateManager) {
-            this.stateManager = new RuntimeStateManager({ workspaceDir: this.workspaceDir });
-        }
-        return this.stateManager;
-    }
-    getEventLogReadModel() {
-        if (!this.eventLogReadModel) {
-            this.eventLogReadModel = new EventLogReadModel(this.stateDir);
-        }
-        return this.eventLogReadModel;
-    }
-}

package/console/dist/server/models/OverviewConsoleModel.d.ts

@@ -1,22 +0,0 @@
-import type { OverviewOutput, OverviewHealthOutput } from '../types/index.js';
-export declare class OverviewConsoleModel {
-    private readonly workspaceDir;
-    private readonly stateDir;
-    private healthReadModel;
-    private painChainReadModel;
-    private pruningReadModel;
-    private stateManager;
-    private eventLogReadModel;
-    private ownsHealthReadModel;
-    constructor(workspaceDir: string);
-    getHealth(): Promise<OverviewHealthOutput>;
-    getOverview(_days?: number): Promise<OverviewOutput>;
-    private getInProgressCount;
-    private getDailyTrend;
-    dispose(): void;
-    private getHealthReadModel;
-    private getPainChainReadModel;
-    private getPruningReadModel;
-    private getStateManager;
-    private getEventLogReadModel;
-}