create-principles-disciple 1.0.0 → 1.74.0

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

@@ -0,0 +1,48 @@
+import type { ApprovalListFilter, ApprovalListResult, ApprovalDecisionResult, ApprovalRecord, ApprovalStatus } from '@principles/core/runtime-v2';
+import type { ApprovalWithContext, ActivationDecision } from '@principles/core/runtime-v2';
+type UnsupportedChannelResult = {
+    ok: false;
+    error: 'unsupported_channel';
+    channel: string;
+};
+type ChannelGuardedDecisionResult = ApprovalDecisionResult | UnsupportedChannelResult;
+export type ApproveWithActivationResult = {
+    ok: true;
+    record: ApprovalRecord;
+    activation?: ActivationDecision;
+} | {
+    ok: false;
+    error: 'already_decided';
+    status: ApprovalStatus;
+} | {
+    ok: false;
+    error: 'not_found';
+} | {
+    ok: false;
+    error: 'unsupported_channel';
+    channel: string;
+};
+export declare class ApprovalsConsoleModel {
+    private readConnection;
+    private readQueue;
+    private writeConnection;
+    private writeQueue;
+    private readonly workspaceDir;
+    constructor(workspaceDir: string);
+    private getReadQueue;
+    private getWriteQueue;
+    private getWriteConnection;
+    listApprovals(filter?: ApprovalListFilter): Promise<ApprovalListResult>;
+    getApprovalDetail(approvalId: string): Promise<(ApprovalWithContext & {
+        isMvpProven: boolean;
+    }) | null>;
+    approve(approvalId: string, decidedBy: string, note?: string): Promise<ApproveWithActivationResult>;
+    private dispatchActivationAfterApproval;
+    reject(approvalId: string, decidedBy: string, reason: string): Promise<ChannelGuardedDecisionResult>;
+    /** Returns null when the approvals table does not exist. */
+    private readSafeGetById;
+    /** Returns null when the approvals table does not exist. */
+    private readSafeList;
+    dispose(): void;
+}
+export {};

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

@@ -0,0 +1,208 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { SqliteConnection, SqliteApprovalQueueStore, SqliteActivationStateStore, SqlitePIArtifactStore, ActivationDispatcher, PromptWriter, DeferArchiveWriter, ApprovalQueue, mapConfidenceToLabel, MVP_CHANNELS, } from '@principles/core/runtime-v2';
+const MVP_PROVEN_CHANNELS = new Set(MVP_CHANNELS);
+const EMPTY_STATS = { pending: 0, approved: 0, rejected: 0, cancelled: 0 };
+function isMissingTableError(err) {
+    if (!(err instanceof Error))
+        return false;
+    return err.message.includes('no such table');
+}
+function stateDbExists(workspaceDir) {
+    return fs.existsSync(path.join(workspaceDir, '.pd', 'state.db'));
+}
+export class ApprovalsConsoleModel {
+    readConnection = null;
+    readQueue = null;
+    writeConnection = null;
+    writeQueue = null;
+    workspaceDir;
+    constructor(workspaceDir) {
+        this.workspaceDir = workspaceDir;
+    }
+    getReadQueue() {
+        if (!this.readQueue) {
+            this.readConnection = new SqliteConnection({ workspaceDir: this.workspaceDir, readonly: true });
+            const store = new SqliteApprovalQueueStore(this.readConnection);
+            this.readQueue = new ApprovalQueue(store);
+        }
+        return this.readQueue;
+    }
+    getWriteQueue() {
+        if (!this.writeQueue) {
+            this.writeConnection = new SqliteConnection({ workspaceDir: this.workspaceDir });
+            const store = new SqliteApprovalQueueStore(this.writeConnection);
+            this.writeQueue = new ApprovalQueue(store);
+        }
+        return this.writeQueue;
+    }
+    getWriteConnection() {
+        this.getWriteQueue();
+        const conn = this.writeConnection;
+        if (!conn)
+            throw new Error('writeConnection not initialized');
+        return conn;
+    }
+    async listApprovals(filter) {
+        if (!stateDbExists(this.workspaceDir)) {
+            return { items: [], total: 0, stats: { ...EMPTY_STATS } };
+        }
+        const allItems = await this.readSafeList(filter);
+        if (!allItems) {
+            return { items: [], total: 0, stats: { ...EMPTY_STATS } };
+        }
+        const mvpItems = allItems.filter((record) => MVP_PROVEN_CHANNELS.has(record.channel));
+        const total = mvpItems.length;
+        const page = filter?.page ?? 1;
+        const pageSize = filter?.pageSize ?? 0;
+        const pageItems = pageSize > 0 ? mvpItems.slice((page - 1) * pageSize, page * pageSize) : mvpItems;
+        const enriched = pageItems.map((record) => ({
+            ...record,
+            confidenceLabel: mapConfidenceToLabel(record.confidence),
+        }));
+        const mvpStats = { pending: 0, approved: 0, rejected: 0, cancelled: 0 };
+        for (const item of mvpItems) {
+            const key = item.status;
+            if (Object.hasOwn(mvpStats, key)) {
+                mvpStats[key]++;
+            }
+        }
+        return {
+            items: enriched,
+            total,
+            stats: mvpStats,
+        };
+    }
+    async getApprovalDetail(approvalId) {
+        if (!stateDbExists(this.workspaceDir)) {
+            return null;
+        }
+        const record = await this.readSafeGetById(approvalId);
+        if (!record)
+            return null;
+        return {
+            ...record,
+            confidenceLabel: mapConfidenceToLabel(record.confidence),
+            isMvpProven: MVP_PROVEN_CHANNELS.has(record.channel),
+        };
+    }
+    async approve(approvalId, decidedBy, note) {
+        if (!stateDbExists(this.workspaceDir)) {
+            return { ok: false, error: 'not_found' };
+        }
+        const existing = await this.readSafeGetById(approvalId);
+        if (!existing)
+            return { ok: false, error: 'not_found' };
+        if (!MVP_PROVEN_CHANNELS.has(existing.channel)) {
+            return { ok: false, error: 'unsupported_channel', channel: existing.channel };
+        }
+        const approvalResult = await this.getWriteQueue().approve(approvalId, decidedBy, note);
+        if (!approvalResult.ok) {
+            if (approvalResult.error === 'already_decided') {
+                return { ok: false, error: 'already_decided', status: approvalResult.status };
+            }
+            return { ok: false, error: 'not_found' };
+        }
+        const activation = await this.dispatchActivationAfterApproval(existing, decidedBy);
+        return { ok: true, record: approvalResult.record, activation };
+    }
+    async dispatchActivationAfterApproval(existing, decidedBy) {
+        try {
+            const conn = this.getWriteConnection();
+            const piArtifactStore = new SqlitePIArtifactStore(conn);
+            const artifactReadModel = {
+                getArtifactById: async (id) => {
+                    const rec = await piArtifactStore.getArtifactById(id);
+                    if (!rec)
+                        return null;
+                    return {
+                        artifactId: rec.artifactId,
+                        artifactKind: rec.artifactKind,
+                        sourceTaskId: rec.sourceTaskId,
+                        sourcePrincipleId: rec.sourcePrincipleId,
+                        sourceRuleId: rec.sourceRuleId,
+                        lineageArtifactIds: rec.lineageArtifactIds,
+                        validationStatus: rec.validationStatus,
+                        contentJson: rec.contentJson,
+                        createdAt: rec.createdAt,
+                        updatedAt: rec.updatedAt,
+                    };
+                },
+            };
+            const activationStateStore = new SqliteActivationStateStore(conn);
+            const approvalQueueStore = new SqliteApprovalQueueStore(conn);
+            const dispatcher = new ActivationDispatcher(artifactReadModel, activationStateStore, { writers: [new PromptWriter(), new DeferArchiveWriter()], approvalQueueStore });
+            return await dispatcher.dispatch({
+                artifactId: existing.artifactId,
+                channel: existing.channel,
+                rolloutDecision: 'auto_activate',
+                actor: { kind: 'human', userId: decidedBy },
+                now: new Date().toISOString(),
+                confirm: true,
+            });
+        }
+        catch (dispatchErr) {
+            const dispatchMsg = dispatchErr instanceof Error ? dispatchErr.message : String(dispatchErr);
+            return {
+                decision: 'refused',
+                reason: `activation_dispatch_failed: ${dispatchMsg}`,
+                channel: existing.channel,
+                riskLevel: 'low',
+            };
+        }
+    }
+    async reject(approvalId, decidedBy, reason) {
+        if (!stateDbExists(this.workspaceDir)) {
+            return { ok: false, error: 'not_found' };
+        }
+        const existing = await this.readSafeGetById(approvalId);
+        if (!existing)
+            return { ok: false, error: 'not_found' };
+        if (!MVP_PROVEN_CHANNELS.has(existing.channel)) {
+            return { ok: false, error: 'unsupported_channel', channel: existing.channel };
+        }
+        return this.getWriteQueue().reject(approvalId, decidedBy, reason);
+    }
+    /** Returns null when the approvals table does not exist. */
+    async readSafeGetById(approvalId) {
+        const queue = this.getReadQueue();
+        try {
+            return await queue.getById(approvalId);
+        }
+        catch (err) {
+            if (isMissingTableError(err))
+                return null;
+            throw err;
+        }
+    }
+    /** Returns null when the approvals table does not exist. */
+    async readSafeList(filter) {
+        const queue = this.getReadQueue();
+        try {
+            return await queue.listAll({ status: filter?.status, channel: filter?.channel });
+        }
+        catch (err) {
+            if (isMissingTableError(err))
+                return null;
+            throw err;
+        }
+    }
+    dispose() {
+        if (this.readConnection) {
+            try {
+                this.readConnection.close();
+            }
+            catch { /* best-effort */ }
+            this.readConnection = null;
+        }
+        this.readQueue = null;
+        if (this.writeConnection) {
+            try {
+                this.writeConnection.close();
+            }
+            catch { /* best-effort */ }
+            this.writeConnection = null;
+        }
+        this.writeQueue = null;
+    }
+}

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

@@ -0,0 +1,33 @@
+import type { EventLogEntry, GateBlockEvent } from '../types/index.js';
+export declare class EventLogReadModel {
+    private readonly logsDir;
+    constructor(stateDir: string);
+    private readFilesWithConcurrency;
+    getEventsPaginated(options: {
+        types?: string[];
+        startDate?: string;
+        endDate?: string;
+        searchQuery?: string;
+        page?: number;
+        pageSize?: number;
+    }): Promise<{
+        events: EventLogEntry[];
+        total: number;
+        totalPages: number;
+    }>;
+    countEventsGroupedByType(dateRange?: {
+        startDate?: string;
+        endDate?: string;
+    }): Promise<Record<string, number>>;
+    getRelatedEvents(eventId: string, maxDistance?: number): Promise<EventLogEntry[]>;
+    getGateBlocks(limit?: number): Promise<GateBlockEvent[]>;
+    countGateBlocksToday(): Promise<number>;
+    countEventsByTypeToday(eventType: string): Promise<number>;
+    getEventsByTypes(types: string[], limit?: number): Promise<EventLogEntry[]>;
+    countEventsByTypeAndDate(eventType: string, date: string): Promise<number>;
+    countEventsByCategoryAndDate(category: string, date: string): Promise<number>;
+    private getEventFiles;
+    private readEventsOfFile;
+    private readLines;
+    dispose(): void;
+}

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

@@ -0,0 +1,218 @@
+import * as fs from 'fs';
+import * as path from 'path';
+function extractFileDate(filePath) {
+    const match = /events_(\d{4}-\d{2}-\d{2})\.jsonl/.exec(filePath);
+    return match ? match[1] : null;
+}
+export class EventLogReadModel {
+    logsDir;
+    constructor(stateDir) {
+        this.logsDir = path.join(stateDir, 'logs');
+    }
+    async readFilesWithConcurrency(files, processor, concurrency = 5) {
+        void this;
+        const results = [];
+        for (let i = 0; i < files.length; i += concurrency) {
+            const batch = files.slice(i, i + concurrency);
+            const batchResults = await Promise.all(batch.map(processor));
+            for (const batchResult of batchResults) {
+                results.push(...batchResult);
+            }
+        }
+        return results;
+    }
+    async getEventsPaginated(options) {
+        const { types, startDate, endDate, searchQuery, page = 1, pageSize = 50, } = options;
+        const allFiles = this.getEventFiles().reverse(); // newest first
+        const filteredFiles = allFiles.filter(file => {
+            if (!startDate && !endDate)
+                return true;
+            const fileDate = extractFileDate(file);
+            if (!fileDate)
+                return true;
+            if (startDate && fileDate < startDate)
+                return false;
+            if (endDate && fileDate > endDate)
+                return false;
+            return true;
+        });
+        const allEntries = await this.readFilesWithConcurrency(filteredFiles, (file) => this.readEventsOfFile(file));
+        const allMatchingEvents = [];
+        for (const entry of allEntries.reverse()) {
+            if (types && types.length > 0 && !types.includes(entry.type))
+                continue;
+            if (searchQuery) {
+                const entryStr = JSON.stringify(entry).toLowerCase();
+                if (!entryStr.includes(searchQuery.toLowerCase()))
+                    continue;
+            }
+            allMatchingEvents.push(entry);
+        }
+        const total = allMatchingEvents.length;
+        const totalPages = Math.ceil(total / pageSize);
+        const startIndex = (page - 1) * pageSize;
+        const events = allMatchingEvents.slice(startIndex, startIndex + pageSize);
+        return { events, total, totalPages };
+    }
+    async countEventsGroupedByType(dateRange) {
+        const allFiles = this.getEventFiles().reverse();
+        const filteredFiles = allFiles.filter(file => {
+            if (!dateRange?.startDate && !dateRange?.endDate)
+                return true;
+            const fileDate = extractFileDate(file);
+            if (!fileDate)
+                return true;
+            if (dateRange.startDate && fileDate < dateRange.startDate)
+                return false;
+            if (dateRange.endDate && fileDate > dateRange.endDate)
+                return false;
+            return true;
+        });
+        const allEntries = await this.readFilesWithConcurrency(filteredFiles, (file) => this.readEventsOfFile(file));
+        const counts = {};
+        for (const entry of allEntries) {
+            counts[entry.type] = (counts[entry.type] || 0) + 1;
+        }
+        return counts;
+    }
+    async getRelatedEvents(eventId, maxDistance = 10) {
+        const allFiles = this.getEventFiles().reverse();
+        const allEntries = await this.readFilesWithConcurrency(allFiles, (file) => this.readEventsOfFile(file));
+        const relatedEvents = [];
+        let foundTarget = false;
+        let distance = 0;
+        for (const entry of allEntries) {
+            if (entry.id === eventId) {
+                foundTarget = true;
+                relatedEvents.push(entry);
+            }
+            else if (foundTarget && distance < maxDistance) {
+                relatedEvents.push(entry);
+                distance++;
+            }
+        }
+        return relatedEvents;
+    }
+    async getGateBlocks(limit = 100) {
+        const files = this.getEventFiles();
+        const allEntries = await this.readFilesWithConcurrency(files, (file) => this.readEventsOfFile(file));
+        const blocks = [];
+        for (const entry of allEntries.reverse()) {
+            if (entry.type === 'gate_block' && blocks.length < limit) {
+                blocks.push(entry);
+            }
+            if (blocks.length >= limit)
+                break;
+        }
+        return blocks;
+    }
+    async countGateBlocksToday() {
+        const [today] = new Date().toISOString().split('T');
+        const file = path.join(this.logsDir, `events_${today}.jsonl`);
+        if (!fs.existsSync(file))
+            return 0;
+        let count = 0;
+        for await (const line of this.readLines(file)) {
+            try {
+                const entry = JSON.parse(line);
+                if (entry.type === 'gate_block')
+                    count++;
+            }
+            catch { /* skip malformed */ }
+        }
+        return count;
+    }
+    async countEventsByTypeToday(eventType) {
+        const [today] = new Date().toISOString().split('T');
+        const file = path.join(this.logsDir, `events_${today}.jsonl`);
+        if (!fs.existsSync(file))
+            return 0;
+        let count = 0;
+        for await (const line of this.readLines(file)) {
+            try {
+                const entry = JSON.parse(line);
+                if (entry.type === eventType)
+                    count++;
+            }
+            catch { /* skip malformed */ }
+        }
+        return count;
+    }
+    async getEventsByTypes(types, limit = 50) {
+        const files = this.getEventFiles();
+        const allEntries = await this.readFilesWithConcurrency(files, (file) => this.readEventsOfFile(file));
+        const results = [];
+        for (const entry of allEntries.reverse()) {
+            if (types.includes(entry.type) && results.length < limit) {
+                results.push(entry);
+            }
+            if (results.length >= limit)
+                break;
+        }
+        return results;
+    }
+    async countEventsByTypeAndDate(eventType, date) {
+        const file = path.join(this.logsDir, `events_${date}.jsonl`);
+        if (!fs.existsSync(file))
+            return 0;
+        let count = 0;
+        for await (const line of this.readLines(file)) {
+            try {
+                const entry = JSON.parse(line);
+                if (entry.type === eventType)
+                    count++;
+            }
+            catch { /* skip malformed */ }
+        }
+        return count;
+    }
+    async countEventsByCategoryAndDate(category, date) {
+        const file = path.join(this.logsDir, `events_${date}.jsonl`);
+        if (!fs.existsSync(file))
+            return 0;
+        let count = 0;
+        for await (const line of this.readLines(file)) {
+            try {
+                const entry = JSON.parse(line);
+                if (entry.category === category)
+                    count++;
+            }
+            catch { /* skip malformed */ }
+        }
+        return count;
+    }
+    getEventFiles() {
+        if (!fs.existsSync(this.logsDir))
+            return [];
+        return fs.readdirSync(this.logsDir)
+            .filter(f => f.startsWith('events_') && f.endsWith('.jsonl'))
+            .sort()
+            .map(f => path.join(this.logsDir, f));
+    }
+    async readEventsOfFile(filePath) {
+        const entries = [];
+        for await (const line of this.readLines(filePath)) {
+            try {
+                entries.push(JSON.parse(line));
+            }
+            catch { /* skip malformed */ }
+        }
+        return entries;
+    }
+    async *readLines(filePath) {
+        const fileStream = fs.createReadStream(filePath, { encoding: 'utf8' });
+        const readline = await import('readline');
+        const rl = readline.createInterface({
+            input: fileStream,
+            crlfDelay: Infinity,
+        });
+        for await (const line of rl) {
+            if (line.trim())
+                yield line;
+        }
+        void this.logsDir;
+    }
+    dispose() {
+        void this.logsDir;
+    }
+}

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

@@ -0,0 +1,79 @@
+export type PrincipleStatus = 'candidate' | 'active' | 'archived' | 'deprecated' | 'probation';
+export interface EvolutionStats {
+    total: number;
+    pending: number;
+    inProgress: number;
+    completed: number;
+    failed: number;
+    stageDistribution: {
+        stage: string;
+        count: number;
+    }[];
+}
+export interface EvolutionTaskItem {
+    taskId: string;
+    taskKind: string;
+    status: string;
+    createdAt: string;
+    leaseOwner: string | null;
+    leaseExpiresAt: string | null;
+}
+export interface EvolutionTasksOutput {
+    items: EvolutionTaskItem[];
+    pagination: {
+        page: number;
+        pageSize: number;
+        total: number;
+        totalPages: number;
+    };
+}
+export interface PrincipleLifecycleSummary {
+    candidate: number;
+    probation: number;
+    active: number;
+    deprecated: number;
+    archived: number;
+    total: number;
+}
+export interface PrincipleTransition {
+    principleId: string;
+    status: PrincipleStatus;
+    text: string;
+    triggerPattern: string;
+    action: string;
+    evaluability: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface EvolutionPrinciplesOutput {
+    summary: PrincipleLifecycleSummary;
+    recent: PrincipleTransition[];
+}
+export interface QueueHealthOutput {
+    pendingCount: number;
+    retryWaitCount: number;
+    countsByTaskKind: Record<string, number>;
+    countsByChannel: Record<string, number>;
+    invalidMetadataCount: number;
+    blockedCount: number;
+    dependencyFailedCount: number;
+    readyTaskCount: number;
+    noReadyTasksReason: string | null;
+}
+export declare class EvolutionConsoleModel {
+    private readonly workspaceDir;
+    private stateManager;
+    private initPromise;
+    constructor(workspaceDir: string);
+    private ensureInitialized;
+    getStats(): Promise<EvolutionStats>;
+    getTasks(filters?: {
+        status?: string;
+        taskKind?: string;
+        page?: number;
+        pageSize?: number;
+    }): Promise<EvolutionTasksOutput>;
+    getPrinciples(): Promise<EvolutionPrinciplesOutput>;
+    getQueueHealth(): Promise<QueueHealthOutput>;
+    dispose(): void;
+}