create-principles-disciple 1.0.0 → 1.74.0

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

@@ -0,0 +1,75 @@
+import * as fs from 'fs';
+import * as path from 'path';
+function extractTag(content, tagName) {
+    const regex = new RegExp(`<${tagName}>([\\s\\S]*?)</${tagName}>`, 'i');
+    const match = content.match(regex);
+    if (!match)
+        return '';
+    return match[1].trim().replace(/\s+/g, ' ');
+}
+function parseThinkingOsMd(content) {
+    const directives = [];
+    const directiveRegex = /<directive\s+([^>]*)>([\s\S]*?)<\/directive>/gi;
+    let match = null; // eslint-disable-line no-useless-assignment
+    while ((match = directiveRegex.exec(content)) !== null) {
+        const [, attrs, body] = match;
+        const idMatch = /id="([^"]+)"/i.exec(attrs);
+        const nameMatch = /name="([^"]+)"/i.exec(attrs);
+        if (!idMatch)
+            continue;
+        directives.push({
+            id: idMatch[1],
+            name: nameMatch ? nameMatch[1] : '',
+            trigger: extractTag(body, 'trigger'),
+            must: extractTag(body, 'must'),
+            forbidden: extractTag(body, 'forbidden'),
+        });
+    }
+    return directives;
+}
+export class ThinkingModelsConsoleModel {
+    workspaceDir;
+    cachedOverview = null;
+    cacheTimestamp = 0;
+    static CACHE_TTL_MS = 5000;
+    constructor(workspaceDir) {
+        this.workspaceDir = workspaceDir;
+    }
+    getOverview() {
+        const now = Date.now();
+        if (this.cachedOverview && (now - this.cacheTimestamp) < ThinkingModelsConsoleModel.CACHE_TTL_MS) {
+            return this.cachedOverview;
+        }
+        const candidates = [
+            path.join(this.workspaceDir, 'THINKING_OS.md'),
+            path.join(this.workspaceDir, '.state', 'THINKING_OS.md'),
+            path.join(this.workspaceDir, '.pd', 'THINKING_OS.md'),
+        ];
+        for (const filePath of candidates) {
+            if (fs.existsSync(filePath)) {
+                try {
+                    const content = fs.readFileSync(filePath, 'utf8');
+                    const models = parseThinkingOsMd(content);
+                    if (models.length > 0) {
+                        this.cachedOverview = { totalModels: models.length, models, source: 'workspace' };
+                        this.cacheTimestamp = now;
+                        return this.cachedOverview;
+                    }
+                }
+                catch {
+                    // try next candidate
+                }
+            }
+        }
+        this.cachedOverview = { totalModels: 0, models: [], source: 'none' };
+        this.cacheTimestamp = now;
+        return this.cachedOverview;
+    }
+    getModelDetail(modelId) {
+        const overview = this.getOverview();
+        return overview.models.find(m => m.id === modelId) ?? null;
+    }
+    dispose() {
+        this.cachedOverview = null;
+    }
+}

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

@@ -0,0 +1,34 @@
+import type { WorkspaceConfigStore } from '../config/WorkspaceConfigStore.js';
+import type { SyncResult } from '../types/index.js';
+export interface CentralOverviewOutput {
+    generatedAt: string;
+    workspaceCount: number;
+    workspaces: {
+        name: string;
+        path: string;
+        status: 'healthy' | 'degraded' | 'error';
+        gfi: number;
+        principleCount: number;
+    }[];
+}
+export interface CentralHealthOutput {
+    generatedAt: string;
+    overallStatus: 'healthy' | 'degraded' | 'error';
+    workspaces: {
+        name: string;
+        status: 'healthy' | 'degraded' | 'error';
+        gfi: number;
+        activePrinciples: number;
+        pendingTasks: number;
+    }[];
+}
+export declare class WorkspaceService {
+    private readonly configStore;
+    private readonly models;
+    constructor(configStore: WorkspaceConfigStore);
+    getCentralOverview(): Promise<CentralOverviewOutput>;
+    getCentralHealth(): Promise<CentralHealthOutput>;
+    syncWorkspace(name: string): Promise<SyncResult>;
+    dispose(): void;
+    private getModel;
+}

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

@@ -0,0 +1,105 @@
+import { OverviewConsoleModel } from './OverviewConsoleModel.js';
+export class WorkspaceService {
+    configStore;
+    models = new Map();
+    constructor(configStore) {
+        this.configStore = configStore;
+    }
+    async getCentralOverview() {
+        const workspaces = this.configStore.getWorkspaces().filter(w => w.config?.enabled !== false);
+        const results = [];
+        for (const ws of workspaces) {
+            try {
+                const model = this.getModel(ws);
+                const overview = await model.getOverview();
+                results.push({
+                    name: ws.name,
+                    path: ws.path,
+                    status: overview.health.status,
+                    gfi: overview.health.gfi.current,
+                    principleCount: overview.summary.principleEventCount,
+                });
+            }
+            catch {
+                results.push({
+                    name: ws.name,
+                    path: ws.path,
+                    status: 'error',
+                    gfi: -1,
+                    principleCount: 0,
+                });
+            }
+        }
+        return {
+            generatedAt: new Date().toISOString(),
+            workspaceCount: workspaces.length,
+            workspaces: results,
+        };
+    }
+    async getCentralHealth() {
+        const workspaces = this.configStore.getWorkspaces().filter(w => w.config?.enabled !== false);
+        const results = [];
+        let overallStatus = 'healthy';
+        for (const ws of workspaces) {
+            try {
+                const model = this.getModel(ws);
+                const health = await model.getHealth();
+                if (health.status === 'error') {
+                    overallStatus = 'error';
+                }
+                else if (health.status !== 'healthy' && overallStatus === 'healthy') {
+                    overallStatus = 'degraded';
+                }
+                results.push({
+                    name: ws.name,
+                    status: health.status,
+                    gfi: health.gfi.current,
+                    activePrinciples: health.principles.active,
+                    pendingTasks: health.queue.pending,
+                });
+            }
+            catch {
+                overallStatus = 'error';
+                results.push({
+                    name: ws.name,
+                    status: 'error',
+                    gfi: -1,
+                    activePrinciples: 0,
+                    pendingTasks: 0,
+                });
+            }
+        }
+        return {
+            generatedAt: new Date().toISOString(),
+            overallStatus,
+            workspaces: results,
+        };
+    }
+    async syncWorkspace(name) {
+        const entry = this.configStore.getWorkspace(name);
+        if (!entry) {
+            throw new Error(`Workspace "${name}" not found`);
+        }
+        this.models.delete(name);
+        this.configStore.updateSyncTime(name);
+        return {
+            success: true,
+            syncedAt: new Date().toISOString(),
+            items: {},
+        };
+    }
+    dispose() {
+        for (const model of this.models.values()) {
+            model.dispose();
+        }
+        this.models.clear();
+    }
+    getModel(entry) {
+        let model = this.models.get(entry.name);
+        if (!model) {
+            model = new OverviewConsoleModel(entry.path);
+            this.models.set(entry.name, model);
+        }
+        return model;
+    }
+}

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

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

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

@@ -0,0 +1,442 @@
+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/approvals.d.ts

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