create-principles-disciple 1.0.0 → 1.74.0

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

@@ -0,0 +1,129 @@
+import * as path from 'path';
+import { EventLogReadModel } from './EventLogReadModel.js';
+import { RuntimeStateManager } from '@principles/core/runtime-v2';
+const STAGE_CONFIG = [
+    { id: 'pain_signal', name: 'Pain Signal', eventTypes: ['pain_signal'] },
+    { id: 'task_created', name: 'Task Created', eventTypes: ['diagnosis_task', 'heartbeat_diagnosis', 'evolution_task'] },
+    { id: 'candidate_generated', name: 'Candidate Generated', eventTypes: ['principle_candidate'] },
+    { id: 'principle_added', name: 'Principle Added', eventTypes: ['rule_promotion'] },
+];
+const THRESHOLD_MINUTES = {
+    slow: 15,
+    stuck: 30,
+    bottleneckWarning: 5,
+    bottleneckCritical: 15,
+};
+const noop = () => { };
+export class PipelineStatsModel {
+    workspaceDir;
+    stateDir;
+    eventLog = null;
+    runtime = null;
+    constructor(workspaceDir) {
+        this.workspaceDir = workspaceDir;
+        this.stateDir = path.join(workspaceDir, '.state');
+    }
+    async getPipelineStats() {
+        const eventLog = this.getEventLogReadModel();
+        const now = new Date();
+        const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+        const todayISO = today.toISOString();
+        const stages = [];
+        const bottlenecks = [];
+        let totalProcessed = 0;
+        const stageEvents = await Promise.all(STAGE_CONFIG.map(async (config) => {
+            const events = await eventLog.getEventsByTypes(config.eventTypes, 1000);
+            const todayEvents = events.filter(e => e.ts >= todayISO);
+            return { config, events: todayEvents, allEvents: events };
+        }));
+        for (let i = 0; i < stageEvents.length; i++) {
+            const { config, events: todayEvents, allEvents } = stageEvents[i];
+            const count = todayEvents.length;
+            totalProcessed += count;
+            const [firstEvent] = allEvents;
+            const lastProcessed = firstEvent ? firstEvent.ts : null;
+            let gapMinutes = null;
+            let status = 'normal';
+            if (lastProcessed) {
+                const lastTime = new Date(lastProcessed);
+                gapMinutes = (now.getTime() - lastTime.getTime()) / (1000 * 60);
+                if (gapMinutes > THRESHOLD_MINUTES.stuck) {
+                    status = 'stuck';
+                }
+                else if (gapMinutes > THRESHOLD_MINUTES.slow) {
+                    status = 'slow';
+                }
+            }
+            else if (count === 0) {
+                status = 'stuck';
+            }
+            let avgDuration = null;
+            if (allEvents.length > 1) {
+                const timestamps = allEvents.map(e => new Date(e.ts).getTime());
+                const intervals = [];
+                for (let j = 0; j < timestamps.length - 1; j++) {
+                    intervals.push(timestamps[j] - timestamps[j + 1]);
+                }
+                avgDuration = intervals.reduce((a, b) => a + b, 0) / intervals.length;
+            }
+            stages.push({
+                id: config.id,
+                name: config.name,
+                status,
+                count,
+                avgDuration,
+                lastProcessed,
+                gapMinutes,
+            });
+            if (i < stageEvents.length - 1) {
+                const currentLastProcessed = lastProcessed;
+                const [nextFirstEvent] = stageEvents[i + 1].allEvents;
+                const nextLastProcessed = nextFirstEvent?.ts ?? null;
+                if (currentLastProcessed && nextLastProcessed) {
+                    const currentTime = new Date(currentLastProcessed);
+                    const nextTime = new Date(nextLastProcessed);
+                    const gap = (nextTime.getTime() - currentTime.getTime()) / (1000 * 60);
+                    if (gap > THRESHOLD_MINUTES.bottleneckWarning) {
+                        bottlenecks.push({
+                            fromStage: config.name,
+                            toStage: stageEvents[i + 1].config.name,
+                            gapMinutes: gap,
+                            severity: gap > THRESHOLD_MINUTES.bottleneckCritical ? 'critical' : 'warning',
+                            description: `从 ${config.name} 到 ${stageEvents[i + 1].config.name} 延迟 ${Math.floor(gap)} 分钟`,
+                        });
+                    }
+                }
+            }
+        }
+        const throughput = totalProcessed / 24;
+        return {
+            generatedAt: now.toISOString(),
+            stages,
+            bottlenecks,
+            totalProcessed,
+            throughput: Math.round(throughput * 10) / 10,
+        };
+    }
+    getEventLogReadModel() {
+        if (!this.eventLog) {
+            this.eventLog = new EventLogReadModel(this.stateDir);
+        }
+        return this.eventLog;
+    }
+    getRuntime() {
+        if (!this.runtime) {
+            this.runtime = new RuntimeStateManager({ workspaceDir: this.workspaceDir });
+        }
+        return this.runtime;
+    }
+    dispose() {
+        if (this.eventLog) {
+            this.eventLog.dispose();
+            this.eventLog = null;
+        }
+        if (this.runtime) {
+            this.runtime.close().catch(noop);
+            this.runtime = null;
+        }
+    }
+}

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

@@ -0,0 +1,69 @@
+export type PrincipleStatus = 'candidate' | 'active' | 'archived' | 'deprecated' | 'probation';
+export type PrinciplePriority = 'P0' | 'P1' | 'P2';
+export type PrincipleScope = 'general' | 'domain';
+export type PrincipleEvaluability = 'manual_only' | 'deterministic' | 'weak_heuristic';
+export type RuleStatus = 'proposed' | 'implemented' | 'enforced' | 'retired';
+export type RuleType = 'hook' | 'gate' | 'skill' | 'lora' | 'test' | 'prompt';
+export interface PrincipleListItem {
+    id: string;
+    text: string;
+    triggerPattern: string;
+    action: string;
+    status: PrincipleStatus;
+    priority: PrinciplePriority;
+    scope: PrincipleScope;
+    domain: string | null;
+    evaluability: PrincipleEvaluability;
+    valueScore: number;
+    adherenceRate: number;
+    painPreventedCount: number;
+    ruleCount: number;
+    conflictsWithCount: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface RuleItem {
+    id: string;
+    name: string;
+    description: string;
+    type: RuleType;
+    triggerCondition: string;
+    enforcement: 'block' | 'warn' | 'log';
+    action: string;
+    status: RuleStatus;
+    coverageRate: number;
+    falsePositiveRate: number;
+}
+export interface PrincipleDetail extends PrincipleListItem {
+    coreAxiomId: string | null;
+    lastPainPreventedAt: string | null;
+    derivedFromPainIds: string[];
+    ruleIds: string[];
+    conflictsWithPrincipleIds: string[];
+    supersedesPrincipleId: string | null;
+    rules: RuleItem[];
+}
+export interface PrinciplesListOutput {
+    principles: PrincipleListItem[];
+    summary: {
+        candidate: number;
+        probation: number;
+        active: number;
+        deprecated: number;
+        archived: number;
+        total: number;
+    };
+}
+export interface PrincipleDetailOutput {
+    principle: PrincipleDetail;
+}
+export declare class PrinciplesConsoleModel {
+    private readonly workspaceDir;
+    private cachedLedger;
+    private cacheTimestamp;
+    constructor(workspaceDir: string);
+    private getLedgerPath;
+    private loadLedger;
+    listPrinciples(): Promise<PrinciplesListOutput>;
+    getPrincipleDetail(principleId: string): Promise<PrincipleDetailOutput | null>;
+}

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

@@ -0,0 +1,200 @@
+import * as path from 'path';
+import * as fs from 'fs';
+const VALID_STATUSES = ['candidate', 'active', 'archived', 'deprecated', 'probation'];
+const VALID_PRIORITIES = ['P0', 'P1', 'P2'];
+const VALID_SCOPES = ['general', 'domain'];
+const VALID_EVALUABILITIES = ['manual_only', 'deterministic', 'weak_heuristic'];
+const VALID_RULE_TYPES = ['hook', 'gate', 'skill', 'lora', 'test', 'prompt'];
+const VALID_RULE_STATUSES = ['proposed', 'implemented', 'enforced', 'retired'];
+const VALID_ENFORCEMENTS = ['block', 'warn', 'log'];
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function createEmptyTree() {
+    return {
+        principles: {},
+        rules: {},
+        implementations: {},
+        metrics: {},
+        lastUpdated: new Date(0).toISOString(),
+    };
+}
+function parseTree(raw) {
+    if (!isRecord(raw)) {
+        return createEmptyTree();
+    }
+    const principles = {};
+    if (isRecord(raw.principles)) {
+        for (const [id, value] of Object.entries(raw.principles)) {
+            if (isRecord(value)) {
+                principles[id] = { ...value, id };
+            }
+        }
+    }
+    const rules = {};
+    if (isRecord(raw.rules)) {
+        for (const [id, value] of Object.entries(raw.rules)) {
+            if (isRecord(value)) {
+                rules[id] = { ...value, id };
+            }
+        }
+    }
+    return {
+        principles,
+        rules,
+        implementations: isRecord(raw.implementations) ? raw.implementations : {},
+        metrics: isRecord(raw.metrics) ? raw.metrics : {},
+        lastUpdated: typeof raw.lastUpdated === 'string' ? raw.lastUpdated : new Date(0).toISOString(),
+    };
+}
+function readLedgerFromFile(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return { trainingStore: {}, tree: createEmptyTree() };
+    }
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        if (!content || content.trim() === '') {
+            return { trainingStore: {}, tree: createEmptyTree() };
+        }
+        const parsed = JSON.parse(content);
+        const raw = isRecord(parsed) ? parsed : {};
+        const treeRaw = raw._tree ?? raw.tree;
+        return {
+            trainingStore: {},
+            tree: parseTree(treeRaw),
+        };
+    }
+    catch {
+        return { trainingStore: {}, tree: createEmptyTree() };
+    }
+}
+function safeCastEnum(value, valid, fallback) {
+    if (value && valid.includes(value)) {
+        return value;
+    }
+    return fallback;
+}
+const CACHE_TTL_MS = 5_000;
+export class PrinciplesConsoleModel {
+    workspaceDir;
+    cachedLedger = null;
+    cacheTimestamp = 0;
+    constructor(workspaceDir) {
+        this.workspaceDir = workspaceDir;
+    }
+    getLedgerPath() {
+        return path.join(this.workspaceDir, '.state', 'principle_training_state.json');
+    }
+    loadLedger() {
+        const now = Date.now();
+        if (this.cachedLedger && now - this.cacheTimestamp < CACHE_TTL_MS) {
+            return this.cachedLedger;
+        }
+        const ledger = readLedgerFromFile(this.getLedgerPath());
+        this.cachedLedger = ledger;
+        this.cacheTimestamp = now;
+        return ledger;
+    }
+    async listPrinciples() {
+        const ledger = this.loadLedger();
+        const principles = Object.values(ledger.tree.principles);
+        const summary = {
+            candidate: 0,
+            probation: 0,
+            active: 0,
+            deprecated: 0,
+            archived: 0,
+            total: principles.length,
+        };
+        const items = [];
+        for (const p of principles) {
+            const status = safeCastEnum(p.status, VALID_STATUSES, 'candidate');
+            switch (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;
+            }
+            items.push({
+                id: p.id,
+                text: p.text ?? '',
+                triggerPattern: p.triggerPattern ?? '',
+                action: p.action ?? '',
+                status,
+                priority: safeCastEnum(p.priority, VALID_PRIORITIES, 'P2'),
+                scope: safeCastEnum(p.scope, VALID_SCOPES, 'general'),
+                domain: p.domain ?? null,
+                evaluability: safeCastEnum(p.evaluability, VALID_EVALUABILITIES, 'manual_only'),
+                valueScore: p.valueScore ?? 0,
+                adherenceRate: p.adherenceRate ?? 0,
+                painPreventedCount: p.painPreventedCount ?? 0,
+                ruleCount: (p.ruleIds ?? []).length,
+                conflictsWithCount: (p.conflictsWithPrincipleIds ?? []).length,
+                createdAt: p.createdAt ?? '',
+                updatedAt: p.updatedAt ?? '',
+            });
+        }
+        items.sort((a, b) => b.valueScore - a.valueScore);
+        return { principles: items, summary };
+    }
+    async getPrincipleDetail(principleId) {
+        const ledger = this.loadLedger();
+        const p = ledger.tree.principles[principleId];
+        if (!p) {
+            return null;
+        }
+        const rules = (p.ruleIds ?? [])
+            .map((ruleId) => ledger.tree.rules[ruleId])
+            .filter((r) => r !== undefined)
+            .map((r) => ({
+            id: r.id,
+            name: r.name ?? '',
+            description: r.description ?? '',
+            type: safeCastEnum(r.type, VALID_RULE_TYPES, 'hook'),
+            triggerCondition: r.triggerCondition ?? '',
+            enforcement: safeCastEnum(r.enforcement, VALID_ENFORCEMENTS, 'log'),
+            action: r.action ?? '',
+            status: safeCastEnum(r.status, VALID_RULE_STATUSES, 'proposed'),
+            coverageRate: r.coverageRate ?? 0,
+            falsePositiveRate: r.falsePositiveRate ?? 0,
+        }));
+        const status = safeCastEnum(p.status, VALID_STATUSES, 'candidate');
+        const principle = {
+            id: p.id,
+            text: p.text ?? '',
+            triggerPattern: p.triggerPattern ?? '',
+            action: p.action ?? '',
+            status,
+            priority: safeCastEnum(p.priority, VALID_PRIORITIES, 'P2'),
+            scope: safeCastEnum(p.scope, VALID_SCOPES, 'general'),
+            domain: p.domain ?? null,
+            evaluability: safeCastEnum(p.evaluability, VALID_EVALUABILITIES, 'manual_only'),
+            valueScore: p.valueScore ?? 0,
+            adherenceRate: p.adherenceRate ?? 0,
+            painPreventedCount: p.painPreventedCount ?? 0,
+            ruleCount: (p.ruleIds ?? []).length,
+            conflictsWithCount: (p.conflictsWithPrincipleIds ?? []).length,
+            coreAxiomId: p.coreAxiomId ?? null,
+            lastPainPreventedAt: p.lastPainPreventedAt ?? null,
+            derivedFromPainIds: p.derivedFromPainIds ?? [],
+            ruleIds: p.ruleIds ?? [],
+            conflictsWithPrincipleIds: p.conflictsWithPrincipleIds ?? [],
+            supersedesPrincipleId: p.supersedesPrincipleId ?? null,
+            createdAt: p.createdAt ?? '',
+            updatedAt: p.updatedAt ?? '',
+            rules,
+        };
+        return { principle };
+    }
+}

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

@@ -0,0 +1,21 @@
+import type { SampleDetail, SamplesListOutput, SampleReviewInput } from '../types/index.js';
+export declare class SampleConsoleModel {
+    private readonly workspaceDir;
+    private stateManager;
+    private intakeService;
+    private initPromise;
+    constructor(workspaceDir: string);
+    private ensureInitialized;
+    private getIntakeService;
+    listSamples(filters?: {
+        status?: string;
+        page?: number;
+        pageSize?: number;
+    }): Promise<SamplesListOutput>;
+    getSampleDetail(sampleId: string): Promise<SampleDetail | null>;
+    reviewSample(sampleId: string, input: SampleReviewInput): Promise<{
+        success: boolean;
+        reviewStatus: string;
+    }>;
+    dispose(): void;
+}

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

@@ -0,0 +1,188 @@
+import * as path from 'path';
+import { RuntimeStateManager, CandidateIntakeService, PrincipleTreeLedgerAdapter, } from '@principles/core/runtime-v2';
+function mapReviewStatus(status) {
+    switch (status) {
+        case 'consumed': return 'approved';
+        case 'expired': return 'rejected';
+        default: return 'pending';
+    }
+}
+export class SampleConsoleModel {
+    workspaceDir;
+    stateManager = null;
+    intakeService = null;
+    initPromise = null;
+    constructor(workspaceDir) {
+        this.workspaceDir = workspaceDir;
+    }
+    async ensureInitialized() {
+        if (this.initPromise) {
+            await this.initPromise;
+            return this.stateManager;
+        }
+        this.stateManager = new RuntimeStateManager({ workspaceDir: this.workspaceDir });
+        this.initPromise = this.stateManager.initialize().catch((err) => {
+            this.stateManager = null;
+            this.initPromise = null;
+            throw err;
+        });
+        await this.initPromise;
+        return this.stateManager;
+    }
+    async getIntakeService() {
+        if (!this.intakeService) {
+            const mgr = await this.ensureInitialized();
+            const stateDir = path.join(this.workspaceDir, '.state');
+            const ledgerAdapter = new PrincipleTreeLedgerAdapter({ stateDir });
+            this.intakeService = new CandidateIntakeService({
+                stateManager: mgr,
+                ledgerAdapter,
+            });
+        }
+        return this.intakeService;
+    }
+    async listSamples(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);
+        const tasks = await mgr.listTasks();
+        const allCandidates = [];
+        for (const task of tasks) {
+            const candidates = await mgr.getCandidatesByTaskId(task.taskId);
+            for (const c of candidates) {
+                const reviewStatus = mapReviewStatus(c.status);
+                if (filters.status && filters.status !== 'all' && reviewStatus !== filters.status) {
+                    continue;
+                }
+                allCandidates.push({
+                    sampleId: c.candidateId,
+                    taskId: c.taskId,
+                    title: c.title,
+                    description: c.description,
+                    reviewStatus,
+                    confidence: c.confidence ?? null,
+                    createdAt: c.createdAt,
+                });
+            }
+        }
+        allCandidates.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+        const counters = {};
+        for (const item of allCandidates) {
+            counters[item.reviewStatus] = (counters[item.reviewStatus] ?? 0) + 1;
+        }
+        const total = allCandidates.length;
+        const offset = (page - 1) * pageSize;
+        const items = allCandidates.slice(offset, offset + pageSize);
+        return {
+            counters,
+            items,
+            pagination: {
+                page,
+                pageSize,
+                total,
+                totalPages: total === 0 ? 0 : Math.ceil(total / pageSize),
+            },
+        };
+    }
+    async getSampleDetail(sampleId) {
+        const mgr = await this.ensureInitialized();
+        const candidate = await mgr.getCandidate(sampleId);
+        if (!candidate)
+            return null;
+        const reviewStatus = mapReviewStatus(candidate.status);
+        let artifactContent = null;
+        let recommendation = null;
+        try {
+            const artifact = await mgr.getArtifact(candidate.artifactId);
+            if (artifact) {
+                try {
+                    artifactContent = JSON.parse(artifact.contentJson);
+                }
+                catch {
+                    artifactContent = { raw: artifact.contentJson };
+                }
+            }
+        }
+        catch {
+            // artifact may not be available
+        }
+        try {
+            if (candidate.sourceRecommendationJson) {
+                const parsed = JSON.parse(candidate.sourceRecommendationJson);
+                if (parsed && typeof parsed === 'object') {
+                    recommendation = {
+                        title: typeof parsed.title === 'string' ? parsed.title : undefined,
+                        text: typeof parsed.text === 'string' ? parsed.text : undefined,
+                        triggerPattern: typeof parsed.triggerPattern === 'string' ? parsed.triggerPattern : undefined,
+                        action: typeof parsed.action === 'string' ? parsed.action : undefined,
+                        abstractedPrinciple: typeof parsed.abstractedPrinciple === 'string' ? parsed.abstractedPrinciple : undefined,
+                    };
+                }
+            }
+        }
+        catch {
+            // recommendation parsing failed
+        }
+        return {
+            sampleId: candidate.candidateId,
+            taskId: candidate.taskId,
+            title: candidate.title,
+            description: candidate.description,
+            reviewStatus,
+            confidence: candidate.confidence ?? null,
+            createdAt: candidate.createdAt,
+            artifactContent,
+            recommendation,
+        };
+    }
+    async reviewSample(sampleId, input) {
+        const mgr = await this.ensureInitialized();
+        const candidate = await mgr.getCandidate(sampleId);
+        if (!candidate) {
+            throw new Error(`Sample ${sampleId} not found`);
+        }
+        if (candidate.status !== 'pending') {
+            throw new Error(`Sample is not pending (current status: ${candidate.status})`);
+        }
+        if (input.decision === 'approved') {
+            const transitioned = await mgr.transitionCandidateStatus(sampleId, 'pending', 'consumed');
+            if (!transitioned) {
+                throw new Error('Failed to transition sample status to consumed');
+            }
+            try {
+                const intake = await this.getIntakeService();
+                await intake.intake(sampleId);
+            }
+            catch (intakeErr) {
+                try {
+                    await mgr.updateCandidateStatus(sampleId, { status: 'pending' });
+                }
+                catch (rollbackErr) {
+                    const combinedError = new Error(`Intake failed and rollback also failed. Sample ${sampleId} may be in inconsistent state.`);
+                    combinedError.cause = { intakeErr, rollbackErr };
+                    throw combinedError;
+                }
+                throw intakeErr;
+            }
+            return { success: true, reviewStatus: 'approved' };
+        }
+        if (input.decision === 'rejected') {
+            const transitioned = await mgr.transitionCandidateStatus(sampleId, 'pending', 'expired');
+            if (!transitioned) {
+                throw new Error('Failed to transition sample status to expired');
+            }
+            return { success: true, reviewStatus: 'rejected' };
+        }
+        throw new Error(`Invalid decision: ${input.decision}`);
+    }
+    dispose() {
+        if (this.stateManager) {
+            this.stateManager.close().catch((err) => {
+                console.error('[SampleConsoleModel] Failed to close state manager:', err);
+            });
+            this.stateManager = null;
+        }
+        this.intakeService = null;
+        this.initPromise = null;
+    }
+}

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

@@ -0,0 +1,22 @@
+export interface ThinkingOsDirective {
+    id: string;
+    name: string;
+    trigger: string;
+    must: string;
+    forbidden: string;
+}
+export interface ThinkingModelOverview {
+    totalModels: number;
+    models: ThinkingOsDirective[];
+    source: 'workspace' | 'none';
+}
+export declare class ThinkingModelsConsoleModel {
+    private readonly workspaceDir;
+    private cachedOverview;
+    private cacheTimestamp;
+    private static readonly CACHE_TTL_MS;
+    constructor(workspaceDir: string);
+    getOverview(): ThinkingModelOverview;
+    getModelDetail(modelId: string): ThinkingOsDirective | null;
+    dispose(): void;
+}