create-principles-disciple 1.82.0 → 1.83.0

package/console/dist/server/routes/agents.js

@@ -1,442 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import Database from 'better-sqlite3';
-import { RuntimeStateManager } from '@principles/core/runtime-v2';
-import { sendSuccess, sendError, sendNotFound, sendBadRequest } from '../utils/response.js';
-const AGENT_REGISTRY = [
-    {
-        id: 'evolution-worker',
-        name: 'Evolution Worker',
-        nameZh: '进化工作者',
-        description: '总调度引擎，驱动整个进化管道的心跳服务',
-        descriptionZh: '总调度引擎，驱动整个进化管道的心跳服务',
-        icon: 'Cpu',
-        category: 'scheduler',
-        taskKind: null,
-        prompt: 'N/A - Heartbeat-driven scheduler, no LLM prompt',
-        tools: ['processCompilationBackfill', 'processEvolutionQueue', 'processDetectionQueue', 'sweepExpiredWorkflows', 'runWorkflowWatchdog'],
-        subAgents: ['correction-observer'],
-    },
-    {
-        id: 'diagnostician',
-        name: 'Diagnostician',
-        nameZh: '诊断者',
-        description: 'Uses 5-Whys method for root cause analysis, extracting principles from pain signals',
-        descriptionZh: '使用 5-Whys 方法进行根因分析，从痛苦信号中提取原则',
-        icon: 'Stethoscope',
-        category: 'analyzer',
-        taskKind: 'diagnostician',
-        prompt: '## Diagnostic Protocol (5 Whys)\nPhase 1 - Evidence Gathering\nPhase 2 - Causal Chain (5 Whys)\nPhase 3 - Root Cause Classification\nPhase 4 - Principle Extraction',
-        tools: ['PainSignalBridge', 'DiagnosticianRunner', 'SqliteContextAssembler'],
-        subAgents: [],
-    },
-    {
-        id: 'correction-observer',
-        name: 'Correction Observer',
-        nameZh: '纠正观察者',
-        description: 'Optimizes the correction keyword store by analyzing hit rates and false positive rates',
-        descriptionZh: '通过分析命中率和误报率来优化纠正关键词库',
-        icon: 'SearchCheck',
-        category: 'optimizer',
-        taskKind: 'keyword_optimization',
-        prompt: 'You are a correction keyword optimizer.\nAnalyze the current correction keyword store and recent user messages.\nRecommend ADD/UPDATE/REMOVE actions to improve correction cue accuracy.\nOutput: {"updated": boolean, "updates": {...}, "fpTerms": [...], "summary": string}',
-        tools: ['KeywordOptimizationService', 'CorrectionCueLearner'],
-        subAgents: [],
-    },
-    {
-        id: 'pain-diagnostic-gate',
-        name: 'Pain Diagnostic Gate',
-        nameZh: '痛苦诊断门控',
-        description: 'Gatekeeper that decides which pain signals warrant diagnostic analysis based on source, score, and GFI',
-        descriptionZh: '守门人，基于来源、分数和 GFI 决定哪些痛苦信号值得诊断分析',
-        icon: 'ShieldCheck',
-        category: 'gate',
-        taskKind: null,
-        prompt: 'N/A - Rule-based gate, no LLM prompt. Evaluates: source type, score thresholds (40-70 depending on source), GFI, consecutive errors, cooldown.',
-        tools: ['evaluatePainDiagnosticGate'],
-        subAgents: [],
-    },
-];
-const WORKER_STALE_THRESHOLD_MS = 30 * 60 * 1000;
-function mapTaskStatusToAgentStatus(taskStatus) {
-    switch (taskStatus) {
-        case 'pending':
-        case 'leased':
-            return 'running';
-        case 'succeeded':
-            return 'idle';
-        case 'failed':
-            return 'failed';
-        case 'retry_wait':
-            return 'cooldown';
-        default:
-            return 'unknown';
-    }
-}
-function mapTaskStatusToLastStatus(taskStatus) {
-    switch (taskStatus) {
-        case 'succeeded':
-            return 'succeeded';
-        case 'failed':
-            return 'failed';
-        case 'pending':
-            return 'pending';
-        case 'leased':
-            return 'leased';
-        default:
-            return null;
-    }
-}
-function formatCooldownRemaining(leaseExpiresAt) {
-    if (!leaseExpiresAt)
-        return null;
-    const remaining = new Date(leaseExpiresAt).getTime() - Date.now();
-    if (remaining <= 0)
-        return null;
-    const totalSeconds = Math.floor(remaining / 1000);
-    const hours = Math.floor(totalSeconds / 3600);
-    const minutes = Math.floor((totalSeconds % 3600) / 60);
-    const seconds = totalSeconds % 60;
-    const parts = [];
-    if (hours > 0)
-        parts.push(`${hours}h`);
-    if (minutes > 0)
-        parts.push(`${minutes}m`);
-    if (seconds > 0 || parts.length === 0)
-        parts.push(`${seconds}s`);
-    return parts.join(' ');
-}
-const models = new Map();
-class AgentConsoleModel {
-    workspaceDir;
-    stateManager = null;
-    initPromise = null;
-    stageEventsCache = new Map();
-    constructor(workspaceDir) {
-        this.workspaceDir = workspaceDir;
-    }
-    async ensureInitialized() {
-        if (this.stateManager)
-            return this.stateManager;
-        if (this.initPromise) {
-            try {
-                await this.initPromise;
-                if (this.stateManager)
-                    return this.stateManager;
-                throw new Error('initPromise resolved but stateManager is null');
-            }
-            catch {
-                this.initPromise = null;
-            }
-        }
-        const manager = new RuntimeStateManager({ workspaceDir: this.workspaceDir });
-        this.initPromise = manager.initialize();
-        try {
-            await this.initPromise;
-            this.stateManager = manager;
-            return manager;
-        }
-        catch {
-            this.stateManager = null;
-            this.initPromise = null;
-            throw new Error('Failed to initialize RuntimeStateManager');
-        }
-    }
-    readWorkerStatus() {
-        const statusPath = path.join(this.workspaceDir, '.state', 'worker-status.json');
-        if (!fs.existsSync(statusPath))
-            return null;
-        try {
-            const raw = fs.readFileSync(statusPath, 'utf8');
-            return JSON.parse(raw);
-        }
-        catch {
-            return null;
-        }
-    }
-    readWorkflowData() {
-        const dbPath = path.join(this.workspaceDir, '.state', 'subagent_workflows.db');
-        if (!fs.existsSync(dbPath))
-            return [];
-        let db = null;
-        try {
-            db = new Database(dbPath, { readonly: true });
-            const rows = db.prepare(`
-        SELECT workflow_id, workflow_type, state, created_at, updated_at, duration_ms
-        FROM subagent_workflows
-        ORDER BY updated_at DESC
-        LIMIT 50
-      `).all();
-            return rows;
-        }
-        catch {
-            return [];
-        }
-        finally {
-            db?.close();
-        }
-    }
-    getEvolutionWorkerStatus() {
-        const report = this.readWorkerStatus();
-        if (!report)
-            return { status: 'unknown', lastRunAt: null };
-        const lastRun = new Date(report.timestamp).getTime();
-        const isFresh = Date.now() - lastRun < WORKER_STALE_THRESHOLD_MS;
-        return {
-            status: isFresh ? 'running' : 'idle',
-            lastRunAt: report.timestamp,
-        };
-    }
-    getStageEvents(workflowId) {
-        const cached = this.stageEventsCache.get(workflowId);
-        if (cached)
-            return cached;
-        return {};
-    }
-    refreshStageEvents() {
-        const dbPath = path.join(this.workspaceDir, '.state', 'subagent_workflows.db');
-        if (!fs.existsSync(dbPath))
-            return;
-        let db = null;
-        try {
-            db = new Database(dbPath, { readonly: true });
-            const events = db.prepare(`
-        SELECT workflow_id, event_type, payload_json
-        FROM subagent_workflow_events
-        WHERE event_type LIKE 'trinity_%'
-        ORDER BY created_at DESC
-      `).all();
-            const grouped = new Map();
-            for (const ev of events) {
-                const states = grouped.get(ev.workflow_id) || {};
-                const stage = ev.event_type.replace('trinity_', '').replace('_start', '').replace('_complete', '').replace('_failed', '');
-                if (!states[stage]) {
-                    if (ev.event_type.endsWith('_failed'))
-                        states[stage] = 'failed';
-                    else if (ev.event_type.endsWith('_complete'))
-                        states[stage] = 'completed';
-                    else if (ev.event_type.endsWith('_start'))
-                        states[stage] = 'started';
-                }
-                grouped.set(ev.workflow_id, states);
-            }
-            this.stageEventsCache = grouped;
-        }
-        catch {
-            this.stageEventsCache.clear();
-        }
-        finally {
-            db?.close();
-        }
-    }
-    async buildAgentInfo(agent, allTasks, _workflows) {
-        let status = 'unknown';
-        let lastRunAt = null;
-        let lastStatus = null;
-        let recentTaskCount = 0;
-        let failedTaskCount = 0;
-        let cooldownRemaining = null;
-        if (agent.id === 'evolution-worker') {
-            const workerStatus = this.getEvolutionWorkerStatus();
-            ({ status, lastRunAt } = workerStatus);
-            const queueTasks = allTasks.filter(t => t.taskKind === 'diagnostician' || t.taskKind === 'keyword_optimization');
-            recentTaskCount = queueTasks.length;
-            failedTaskCount = queueTasks.filter(t => t.status === 'failed').length;
-            if (queueTasks.length > 0) {
-                const latest = queueTasks.reduce((a, b) => (a.updatedAt > b.updatedAt ? a : b));
-                lastStatus = mapTaskStatusToLastStatus(latest.status);
-            }
-        }
-        else if (agent.taskKind) {
-            const agentTasks = allTasks.filter(t => t.taskKind === agent.taskKind);
-            recentTaskCount = agentTasks.length;
-            failedTaskCount = agentTasks.filter(t => t.status === 'failed').length;
-            if (agentTasks.length > 0) {
-                const sorted = [...agentTasks].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
-                const [latest] = sorted;
-                status = mapTaskStatusToAgentStatus(latest.status);
-                lastRunAt = latest.updatedAt;
-                lastStatus = mapTaskStatusToLastStatus(latest.status);
-                if (latest.status === 'retry_wait') {
-                    cooldownRemaining = formatCooldownRemaining(latest.leaseExpiresAt);
-                }
-            }
-            else {
-                status = 'idle';
-            }
-        }
-        else if (agent.id === 'pain-diagnostic-gate') {
-            status = 'idle';
-        }
-        return {
-            id: agent.id,
-            name: agent.name,
-            nameZh: agent.nameZh,
-            description: agent.description,
-            descriptionZh: agent.descriptionZh,
-            icon: agent.icon,
-            category: agent.category,
-            status,
-            lastRunAt,
-            lastStatus,
-            recentTaskCount,
-            failedTaskCount,
-            subAgents: agent.subAgents,
-            prompt: agent.prompt,
-            tools: agent.tools,
-            taskKind: agent.taskKind,
-            cooldownRemaining,
-        };
-    }
-    async listAgents() {
-        const mgr = await this.ensureInitialized();
-        const allTasks = await mgr.listTasks();
-        const workflows = this.readWorkflowData();
-        this.refreshStageEvents();
-        const results = [];
-        for (const agent of AGENT_REGISTRY) {
-            results.push(await this.buildAgentInfo(agent, allTasks, workflows));
-        }
-        return results;
-    }
-    async getAgentDetail(agentId) {
-        const agent = AGENT_REGISTRY.find(a => a.id === agentId);
-        if (!agent)
-            return null;
-        const mgr = await this.ensureInitialized();
-        const allTasks = await mgr.listTasks();
-        const workflows = this.readWorkflowData();
-        this.refreshStageEvents();
-        const info = await this.buildAgentInfo(agent, allTasks, workflows);
-        let agentTasks = agent.taskKind
-            ? allTasks.filter(t => t.taskKind === agent.taskKind)
-            : [];
-        agentTasks = [...agentTasks].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
-        const recentTasks = agentTasks.slice(0, 20).map(t => ({
-            taskId: t.taskId,
-            status: t.status,
-            createdAt: t.createdAt,
-            updatedAt: t.updatedAt,
-            lastError: t.lastError ?? null,
-            attemptCount: t.attemptCount,
-        }));
-        return { ...info, recentTasks };
-    }
-    async getAgentTasks(agentId) {
-        const agent = AGENT_REGISTRY.find(a => a.id === agentId);
-        if (!agent)
-            return null;
-        if (!agent.taskKind)
-            return { tasks: [] };
-        const mgr = await this.ensureInitialized();
-        const agentTasks = await mgr.listTasks({ taskKind: agent.taskKind });
-        const sorted = [...agentTasks].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
-        return {
-            tasks: sorted.map(t => ({
-                taskId: t.taskId,
-                taskKind: t.taskKind,
-                status: t.status,
-                createdAt: t.createdAt,
-                updatedAt: t.updatedAt,
-                lastError: t.lastError ?? null,
-                attemptCount: t.attemptCount,
-                inputRef: t.inputRef ?? null,
-                resultRef: t.resultRef ?? null,
-            })),
-        };
-    }
-    dispose() {
-        if (this.stateManager) {
-            this.stateManager.close().catch((_e) => { });
-            this.stateManager = null;
-        }
-        this.initPromise = null;
-    }
-}
-function getModel(workspaceDir) {
-    let model = models.get(workspaceDir);
-    if (!model) {
-        model = new AgentConsoleModel(workspaceDir);
-        models.set(workspaceDir, model);
-    }
-    return model;
-}
-/* eslint-disable @typescript-eslint/max-params */
-export async function handleAgentsRoute(req, res, workspaceDir, subPath) {
-    if (req.method !== 'GET') {
-        sendNotFound(res, `Route /api/agents${subPath} not found`);
-        return;
-    }
-    const model = getModel(workspaceDir);
-    if (subPath === '' || subPath === '/') {
-        try {
-            const result = await model.listAgents();
-            sendSuccess(res, result);
-        }
-        catch (err) {
-            sendError(res, 500, 'agents_list_error', err.message);
-        }
-        return;
-    }
-    const tasksMatch = /^\/([^/]+)\/tasks\/?$/.exec(subPath);
-    if (tasksMatch) {
-        const agentId = (() => {
-            try {
-                return decodeURIComponent(tasksMatch[1]);
-            }
-            catch {
-                return null;
-            }
-        })();
-        if (!agentId) {
-            sendBadRequest(res, 'Invalid agent ID encoding');
-            return;
-        }
-        try {
-            const result = await model.getAgentTasks(agentId);
-            if (!result) {
-                sendNotFound(res, `Agent '${agentId}' not found`);
-                return;
-            }
-            sendSuccess(res, result);
-        }
-        catch (err) {
-            sendError(res, 500, 'agent_tasks_error', err.message);
-        }
-        return;
-    }
-    const detailMatch = /^\/([^/]+)\/?$/.exec(subPath);
-    if (detailMatch) {
-        const agentId = (() => {
-            try {
-                return decodeURIComponent(detailMatch[1]);
-            }
-            catch {
-                return null;
-            }
-        })();
-        if (!agentId) {
-            sendBadRequest(res, 'Invalid agent ID encoding');
-            return;
-        }
-        try {
-            const result = await model.getAgentDetail(agentId);
-            if (!result) {
-                sendNotFound(res, `Agent '${agentId}' not found`);
-                return;
-            }
-            sendSuccess(res, result);
-        }
-        catch (err) {
-            sendError(res, 500, 'agent_detail_error', err.message);
-        }
-        return;
-    }
-    sendNotFound(res, `Route /api/agents${subPath} not found`);
-}
-export function disposeAgentModels() {
-    for (const model of models.values()) {
-        model.dispose();
-    }
-    models.clear();
-}

package/console/dist/server/routes/central.d.ts

@@ -1,5 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import type { WorkspaceService } from '../models/WorkspaceService.js';
-export declare function createCentralRoutes(workspaceService: WorkspaceService): {
-    handleCentralRoute: (req: IncomingMessage, res: ServerResponse, subPath: string) => Promise<void>;
-};

package/console/dist/server/routes/central.js

@@ -1,31 +0,0 @@
-import { sendSuccess, sendError, sendNotFound } from '../utils/response.js';
-export function createCentralRoutes(workspaceService) {
-    async function handleCentralRoute(req, res, subPath) {
-        if (req.method !== 'GET') {
-            sendNotFound(res, 'Method not allowed');
-            return;
-        }
-        if (subPath === '/overview') {
-            try {
-                const overview = await workspaceService.getCentralOverview();
-                sendSuccess(res, overview);
-            }
-            catch (err) {
-                sendError(res, 500, 'central_overview_error', err.message);
-            }
-            return;
-        }
-        if (subPath === '/health') {
-            try {
-                const health = await workspaceService.getCentralHealth();
-                sendSuccess(res, health);
-            }
-            catch (err) {
-                sendError(res, 500, 'central_health_error', err.message);
-            }
-            return;
-        }
-        sendNotFound(res, `Route /api/central${subPath} not found`);
-    }
-    return { handleCentralRoute };
-}

package/console/dist/server/routes/events.d.ts

@@ -1,10 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-interface EventsRouteContext {
-    req: IncomingMessage;
-    res: ServerResponse;
-    workspaceDir: string;
-    subPath: string;
-}
-export declare function handleEventsRoute(ctx: EventsRouteContext): Promise<void>;
-export declare function disposeEventsModels(): void;
-export {};

package/console/dist/server/routes/events.js

@@ -1,99 +0,0 @@
-import * as path from 'path';
-import { EventLogReadModel } from '../models/EventLogReadModel.js';
-import { sendSuccess, sendError, sendNotFound } from '../utils/response.js';
-const MAX_PAGE_SIZE = 1000;
-const MODEL_CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
-const models = new Map();
-function getModel(workspaceDir) {
-    const stateDir = path.join(workspaceDir, '.state');
-    const cached = models.get(stateDir);
-    if (cached && Date.now() - cached.cachedAt < MODEL_CACHE_TTL_MS) {
-        return cached.model;
-    }
-    const model = new EventLogReadModel(stateDir);
-    models.set(stateDir, { model, cachedAt: Date.now() });
-    return model;
-}
-export async function handleEventsRoute(ctx) {
-    const { req, res, workspaceDir, subPath } = ctx;
-    const model = getModel(workspaceDir);
-    const parsedUrl = new URL(req.url || '', 'http://localhost');
-    const { searchParams } = parsedUrl;
-    // GET /api/events
-    if (subPath === '' || subPath === '/') {
-        if (req.method !== 'GET') {
-            sendError(res, 405, 'method_not_allowed', 'Only GET method is allowed');
-            return;
-        }
-        const types = searchParams.getAll('type');
-        const startDate = searchParams.get('startDate') || undefined;
-        const endDate = searchParams.get('endDate') || undefined;
-        const searchQuery = searchParams.get('q') || undefined;
-        const pageStr = searchParams.get('page');
-        const pageSizeStr = searchParams.get('pageSize');
-        const page = pageStr ? parseInt(pageStr, 10) : 1;
-        const pageSize = pageSizeStr ? Math.min(parseInt(pageSizeStr, 10), MAX_PAGE_SIZE) : 50;
-        try {
-            const result = await model.getEventsPaginated({
-                types: types.length > 0 ? types : undefined,
-                startDate,
-                endDate,
-                searchQuery,
-                page,
-                pageSize,
-            });
-            sendSuccess(res, result);
-        }
-        catch (err) {
-            sendError(res, 500, 'server_error', err.message);
-        }
-        return;
-    }
-    // GET /api/events/grouped
-    if (subPath === '/grouped') {
-        if (req.method !== 'GET') {
-            sendError(res, 405, 'method_not_allowed', 'Only GET method is allowed');
-            return;
-        }
-        const startDate = searchParams.get('startDate') || undefined;
-        const endDate = searchParams.get('endDate') || undefined;
-        try {
-            const counts = await model.countEventsGroupedByType({ startDate, endDate });
-            sendSuccess(res, counts);
-        }
-        catch (err) {
-            sendError(res, 500, 'server_error', err.message);
-        }
-        return;
-    }
-    // GET /api/events/:id/related
-    if (subPath.startsWith('/') && subPath.endsWith('/related')) {
-        if (req.method !== 'GET') {
-            sendError(res, 405, 'method_not_allowed', 'Only GET method is allowed');
-            return;
-        }
-        const match = /\/([^/]+)\/related$/.exec(subPath);
-        if (!match) {
-            sendNotFound(res, 'Invalid event ID');
-            return;
-        }
-        const [, eventId] = match;
-        const maxDistanceStr = searchParams.get('maxDistance');
-        const maxDistance = maxDistanceStr ? parseInt(maxDistanceStr, 10) : 10;
-        try {
-            const relatedEvents = await model.getRelatedEvents(eventId, maxDistance);
-            sendSuccess(res, { events: relatedEvents });
-        }
-        catch (err) {
-            sendError(res, 500, 'server_error', err.message);
-        }
-        return;
-    }
-    sendNotFound(res, 'Route not found');
-}
-export function disposeEventsModels() {
-    for (const [, cached] of models) {
-        cached.model.dispose();
-    }
-    models.clear();
-}

package/console/dist/server/routes/evolution.js

@@ -1,73 +0,0 @@
-import { EvolutionConsoleModel } from '../models/EvolutionConsoleModel.js';
-import { sendSuccess, sendError, sendNotFound } from '../utils/response.js';
-import { parseQuery, safeParseInt } from '../utils/request.js';
-const models = new Map();
-function getModel(workspaceDir) {
-    let model = models.get(workspaceDir);
-    if (!model) {
-        model = new EvolutionConsoleModel(workspaceDir);
-        models.set(workspaceDir, model);
-    }
-    return model;
-}
-/* eslint-disable @typescript-eslint/max-params */
-export async function handleEvolutionRoute(req, res, workspaceDir, subPath) {
-    if (req.method !== 'GET') {
-        sendNotFound(res, `Route /api/evolution${subPath} not found`);
-        return;
-    }
-    const model = getModel(workspaceDir);
-    if (subPath === '/stats' || subPath === '/stats/') {
-        try {
-            const result = await model.getStats();
-            sendSuccess(res, result);
-        }
-        catch (err) {
-            sendError(res, 500, 'evolution_stats_error', err.message);
-        }
-        return;
-    }
-    if (subPath === '/tasks' || subPath === '/tasks/') {
-        try {
-            const query = parseQuery(req.url ?? '');
-            const result = await model.getTasks({
-                status: query.status,
-                taskKind: query.taskKind,
-                page: safeParseInt(query.page, 1, 1, 10000),
-                pageSize: safeParseInt(query.pageSize, 20, 1, 100),
-            });
-            sendSuccess(res, result);
-        }
-        catch (err) {
-            sendError(res, 500, 'evolution_tasks_error', err.message);
-        }
-        return;
-    }
-    if (subPath === '/principles' || subPath === '/principles/') {
-        try {
-            const result = await model.getPrinciples();
-            sendSuccess(res, result);
-        }
-        catch (err) {
-            sendError(res, 500, 'evolution_principles_error', err.message);
-        }
-        return;
-    }
-    if (subPath === '/queue' || subPath === '/queue/') {
-        try {
-            const result = await model.getQueueHealth();
-            sendSuccess(res, result);
-        }
-        catch (err) {
-            sendError(res, 500, 'evolution_queue_error', err.message);
-        }
-        return;
-    }
-    sendNotFound(res, `Route /api/evolution${subPath} not found`);
-}
-export function disposeEvolutionModels() {
-    for (const model of models.values()) {
-        model.dispose();
-    }
-    models.clear();
-}

package/console/dist/server/routes/feedback.d.ts

@@ -1,3 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-export declare function handleFeedbackRoute(req: IncomingMessage, res: ServerResponse, workspaceDir: string, subPath: string): Promise<void>;
-export declare function disposeFeedbackModels(): void;