principles-disciple 1.6.0 → 1.7.0

package/dist/http/principles-console-route.js

@@ -0,0 +1,257 @@
+import fs from 'fs';
+import path from 'path';
+import { ControlUiQueryService } from '../service/control-ui-query-service.js';
+const ROUTE_PREFIX = '/plugins/principles';
+const API_PREFIX = `${ROUTE_PREFIX}/api`;
+const ASSETS_PREFIX = `${ROUTE_PREFIX}/assets`;
+function json(res, statusCode, payload) {
+    const body = JSON.stringify(payload, null, 2);
+    res.statusCode = statusCode;
+    res.setHeader('Content-Type', 'application/json; charset=utf-8');
+    res.end(body);
+}
+function text(res, statusCode, body) {
+    res.statusCode = statusCode;
+    res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+    res.end(body);
+}
+function contentTypeFor(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    switch (ext) {
+        case '.html':
+            return 'text/html; charset=utf-8';
+        case '.css':
+            return 'text/css; charset=utf-8';
+        case '.js':
+            return 'application/javascript; charset=utf-8';
+        case '.json':
+            return 'application/json; charset=utf-8';
+        case '.svg':
+            return 'image/svg+xml';
+        default:
+            return 'application/octet-stream';
+    }
+}
+async function readJsonBody(req) {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    if (chunks.length === 0)
+        return {};
+    const body = Buffer.concat(chunks).toString('utf8');
+    try {
+        return JSON.parse(body);
+    }
+    catch {
+        throw new Error('invalid_json');
+    }
+}
+function safeStaticPath(rootDir, requestPath) {
+    const relative = requestPath.startsWith(ASSETS_PREFIX)
+        ? requestPath.slice(ASSETS_PREFIX.length).replace(/^\/+/, '')
+        : '';
+    const normalized = path.normalize(relative);
+    const webRoot = path.join(rootDir, 'dist', 'web');
+    const assetsRoot = path.join(webRoot, 'assets');
+    const target = path.join(assetsRoot, normalized);
+    const relativeTarget = path.relative(assetsRoot, target);
+    if (relativeTarget.startsWith('..') || path.isAbsolute(relativeTarget)) {
+        return null;
+    }
+    return target;
+}
+function serveFile(res, filePath) {
+    if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) {
+        return false;
+    }
+    res.statusCode = 200;
+    res.setHeader('Content-Type', contentTypeFor(filePath));
+    const stream = fs.createReadStream(filePath);
+    stream.on('error', () => {
+        res.statusCode = 500;
+        res.end('Internal Server Error');
+    });
+    stream.pipe(res);
+    return true;
+}
+function createService(api) {
+    const workspaceDir = api.resolvePath('.');
+    return new ControlUiQueryService(workspaceDir);
+}
+function handleApiRoute(api, pathname, req, res) {
+    const service = createService(api);
+    const url = new URL(req.url || pathname, 'http://127.0.0.1');
+    const method = (req.method || 'GET').toUpperCase();
+    const done = (fn) => {
+        try {
+            const payload = fn();
+            json(res, 200, payload);
+            return true;
+        }
+        catch (error) {
+            api.logger.warn(`[PD:ControlUI] API request failed for ${pathname}: ${String(error)}`);
+            json(res, 500, { error: 'internal_error', message: String(error) });
+            return true;
+        }
+        finally {
+            service.dispose();
+        }
+    };
+    if (pathname === `${API_PREFIX}/overview` && method === 'GET') {
+        return done(() => service.getOverview());
+    }
+    if (pathname === `${API_PREFIX}/samples` && method === 'GET') {
+        return done(() => service.listSamples({
+            status: url.searchParams.get('status') ?? undefined,
+            qualityMin: url.searchParams.has('qualityMin') ? Number(url.searchParams.get('qualityMin')) : undefined,
+            dateFrom: url.searchParams.get('dateFrom') ?? undefined,
+            dateTo: url.searchParams.get('dateTo') ?? undefined,
+            failureMode: url.searchParams.get('failureMode') ?? undefined,
+            page: url.searchParams.has('page') ? Number(url.searchParams.get('page')) : undefined,
+            pageSize: url.searchParams.has('pageSize') ? Number(url.searchParams.get('pageSize')) : undefined,
+        }));
+    }
+    const sampleDetailMatch = pathname.match(/^\/plugins\/principles\/api\/samples\/([^/]+)$/);
+    if (sampleDetailMatch && method === 'GET') {
+        try {
+            const detail = service.getSampleDetail(decodeURIComponent(sampleDetailMatch[1]));
+            if (!detail) {
+                json(res, 404, { error: 'not_found', message: 'Sample not found.' });
+                return true;
+            }
+            json(res, 200, detail);
+            return true;
+        }
+        catch (error) {
+            api.logger.warn(`[PD:ControlUI] API request failed for ${pathname}: ${String(error)}`);
+            json(res, 500, { error: 'internal_error', message: String(error) });
+            return true;
+        }
+        finally {
+            service.dispose();
+        }
+    }
+    const sampleReviewMatch = pathname.match(/^\/plugins\/principles\/api\/samples\/([^/]+)\/review$/);
+    if (sampleReviewMatch && method === 'POST') {
+        return (async () => {
+            try {
+                const body = await readJsonBody(req);
+                const decision = body.decision === 'approved' || body.decision === 'rejected'
+                    ? body.decision
+                    : null;
+                if (!decision) {
+                    json(res, 400, { error: 'bad_request', message: 'decision must be approved or rejected' });
+                    return true;
+                }
+                const record = service.reviewSample(decodeURIComponent(sampleReviewMatch[1]), decision, typeof body.note === 'string' ? body.note : undefined);
+                json(res, 200, record);
+                return true;
+            }
+            catch (error) {
+                if (error instanceof Error && error.message === 'invalid_json') {
+                    json(res, 400, { error: 'bad_request', message: 'Request body must be valid JSON.' });
+                    return true;
+                }
+                api.logger.warn(`[PD:ControlUI] Review request failed for ${pathname}: ${String(error)}`);
+                json(res, 500, { error: 'internal_error', message: String(error) });
+                return true;
+            }
+            finally {
+                service.dispose();
+            }
+        })();
+    }
+    if (pathname === `${API_PREFIX}/thinking` && method === 'GET') {
+        return done(() => service.getThinkingOverview());
+    }
+    const thinkingDetailMatch = pathname.match(/^\/plugins\/principles\/api\/thinking\/models\/([^/]+)$/);
+    if (thinkingDetailMatch && method === 'GET') {
+        try {
+            const detail = service.getThinkingModelDetail(decodeURIComponent(thinkingDetailMatch[1]));
+            if (!detail) {
+                json(res, 404, { error: 'not_found', message: 'Thinking model not found.' });
+                return true;
+            }
+            json(res, 200, detail);
+            return true;
+        }
+        catch (error) {
+            api.logger.warn(`[PD:ControlUI] API request failed for ${pathname}: ${String(error)}`);
+            json(res, 500, { error: 'internal_error', message: String(error) });
+            return true;
+        }
+        finally {
+            service.dispose();
+        }
+    }
+    if (pathname === `${API_PREFIX}/export/corrections` && method === 'GET') {
+        try {
+            const mode = url.searchParams.get('mode') === 'redacted' ? 'redacted' : 'raw';
+            const result = service.exportCorrections(mode);
+            if (!fs.existsSync(result.filePath)) {
+                json(res, 404, { error: 'not_found', message: 'Export file not found.' });
+                return true;
+            }
+            res.statusCode = 200;
+            res.setHeader('Content-Type', 'application/x-ndjson; charset=utf-8');
+            res.setHeader('Content-Disposition', `attachment; filename="${path.basename(result.filePath)}"`);
+            const stream = fs.createReadStream(result.filePath);
+            stream.on('error', () => {
+                res.statusCode = 500;
+                res.end('Internal Server Error');
+            });
+            stream.pipe(res);
+            return true;
+        }
+        catch (error) {
+            api.logger.warn(`[PD:ControlUI] Export request failed for ${pathname}: ${String(error)}`);
+            json(res, 500, { error: 'internal_error', message: String(error) });
+            return true;
+        }
+        finally {
+            service.dispose();
+        }
+    }
+    service.dispose();
+    json(res, 404, { error: 'not_found', message: 'Unknown Principles Console API route.' });
+    return true;
+}
+export function createPrinciplesConsoleRoute(api) {
+    return {
+        path: ROUTE_PREFIX,
+        auth: 'gateway',
+        match: 'prefix',
+        async handler(req, res) {
+            const url = new URL(req.url || ROUTE_PREFIX, 'http://127.0.0.1');
+            const pathname = url.pathname;
+            const method = (req.method || 'GET').toUpperCase();
+            if (!pathname.startsWith(ROUTE_PREFIX)) {
+                return false;
+            }
+            if (pathname.startsWith(API_PREFIX)) {
+                return handleApiRoute(api, pathname, req, res);
+            }
+            if (pathname.startsWith(ASSETS_PREFIX)) {
+                if (method !== 'GET' && method !== 'HEAD') {
+                    text(res, 405, 'Method Not Allowed');
+                    return true;
+                }
+                const assetPath = safeStaticPath(api.rootDir, pathname);
+                if (!assetPath || !serveFile(res, assetPath)) {
+                    text(res, 404, 'Asset Not Found');
+                }
+                return true;
+            }
+            if (method !== 'GET' && method !== 'HEAD') {
+                text(res, 405, 'Method Not Allowed');
+                return true;
+            }
+            const indexPath = path.join(api.rootDir, 'dist', 'web', 'index.html');
+            if (!serveFile(res, indexPath)) {
+                text(res, 503, 'Principles Console UI is not built yet.');
+            }
+            return true;
+        },
+    };
+}

package/dist/i18n/commands.js

@@ -66,9 +66,25 @@ export const commandDescriptions = {
         zh: '管理 CURRENT_FOCUS.md [status|history|compress|rollback] - 查看/压缩/回滚焦点文件',
         en: 'Manage CURRENT_FOCUS.md [status|history|compress|rollback] - View/compress/rollback focus file'
     },
+    'pd-evolution-status': {
+        zh: '查看 evolution 闭环状态（candidate/probation/active）',
+        en: 'Show evolution loop status (candidate/probation/active)'
+    },
+    'pd-principle-rollback': {
+        zh: '回滚原则并加入黑名单 <principle-id> [reason]',
+        en: 'Rollback principle and blacklist pattern <principle-id> [reason]'
+    },
     'pd-rollback': {
         zh: '回滚情绪事件惩罚 <event-id>|last',
         en: 'Rollback empathy event penalty <event-id>|last'
+    },
+    'pd-export': {
+        zh: '导出 analytics 或纠错样本 [analytics|corrections --redacted]',
+        en: 'Export analytics or correction samples [analytics|corrections --redacted]'
+    },
+    'pd-samples': {
+        zh: '查看或审核纠错样本 [review approve|reject <sample-id> [note]]',
+        en: 'List or review correction samples [review approve|reject <sample-id> [note]]'
     }
 };
 /**

package/dist/index.js

@@ -15,13 +15,19 @@ import { handlePainCommand } from './commands/pain.js';
 import { handleContextCommand } from './commands/context.js';
 import { handleFocusCommand } from './commands/focus.js';
 import { handleRollbackCommand } from './commands/rollback.js';
+import { handleEvolutionStatusCommand } from './commands/evolution-status.js';
+import { handlePrincipleRollbackCommand } from './commands/principle-rollback.js';
+import { handleExportCommand } from './commands/export.js';
+import { handleSamplesCommand } from './commands/samples.js';
 import { EvolutionWorkerService } from './service/evolution-worker.js';
+import { TrajectoryService } from './service/trajectory-service.js';
 import { ensureWorkspaceTemplates } from './core/init.js';
 import { migrateDirectoryStructure } from './core/migration.js';
 import { SystemLogger } from './core/system-logger.js';
-import { deepReflectTool } from './tools/deep-reflect.js';
-import { agentSpawnTool } from './tools/agent-spawn.js';
+import { createDeepReflectTool } from './tools/deep-reflect.js';
+import { createAgentSpawnTool } from './tools/agent-spawn.js';
 import { PathResolver } from './core/path-resolver.js';
+import { createPrinciplesConsoleRoute } from './http/principles-console-route.js';
 // Track initialization to avoid repeated calls
 let workspaceInitialized = false;
 const plugin = {
@@ -30,6 +36,7 @@ const plugin = {
     register(api) {
         api.logger.info("Principles Disciple Plugin registered.");
         PathResolver.setExtensionRoot(api.rootDir);
+        api.registerHttpRoute(createPrinciplesConsoleRoute(api));
         const language = api.pluginConfig?.language || 'en';
         // ── Hook: Prompt Building ──
         api.on('before_prompt_build', async (event, ctx) => {
@@ -121,6 +128,7 @@ const plugin = {
         try {
             EvolutionWorkerService.api = api;
             api.registerService(EvolutionWorkerService);
+            api.registerService(TrajectoryService);
         }
         catch (err) {
             api.logger.error(`[PD] Failed to register EvolutionWorkerService: ${String(err)}`);
@@ -196,6 +204,8 @@ const plugin = {
 | \`/pd-status\` | 查看进化状态 | 想了解当前 GFI 和 Pain 情况 |
 | \`/pd-trust\` | 查看信任分数 | 想知道自己的权限等级 |
 | \`/pd-focus\` | 焦点文件管理 | 查看/压缩/回滚历史版本 |
+| \`/pd-export\` | 导出分析/样本 | 导出 analytics 或纠错样本 |
+| \`/pd-samples\` | 审核纠错样本 | 查看待审核样本并批准/拒绝 |
 
 ## ⚙️ 配置管理
 | 命令 | 用途 | 使用时机 |
@@ -253,6 +263,8 @@ const plugin = {
 | \`/pd-status\` | View evolution status | Check GFI and Pain status |
 | \`/pd-trust\` | View trust score | Check your permission level |
 | \`/pd-focus\` | Focus file management | View/compress/rollback history |
+| \`/pd-export\` | Export analytics/samples | Export analytics or correction samples |
+| \`/pd-samples\` | Review correction samples | Review pending correction samples |
 
 ## ⚙️ Configuration
 | Command | Purpose | When to Use |
@@ -356,6 +368,39 @@ const plugin = {
                 }
             }
         });
+        api.registerCommand({
+            name: "pd-evolution-status",
+            description: getCommandDescription('pd-evolution-status', language),
+            handler: (ctx) => {
+                try {
+                    const workspaceDir = api.resolvePath('.');
+                    if (ctx.config)
+                        ctx.config.workspaceDir = workspaceDir;
+                    return handleEvolutionStatusCommand(ctx);
+                }
+                catch (err) {
+                    api.logger.error(`[PD] Command /pd-evolution-status failed: ${String(err)}`);
+                    return { text: language === 'zh' ? "命令执行失败，请检查日志。" : "Command failed. Check logs." };
+                }
+            }
+        });
+        api.registerCommand({
+            name: "pd-principle-rollback",
+            description: getCommandDescription('pd-principle-rollback', language),
+            acceptsArgs: true,
+            handler: (ctx) => {
+                try {
+                    const workspaceDir = api.resolvePath('.');
+                    if (ctx.config)
+                        ctx.config.workspaceDir = workspaceDir;
+                    return handlePrincipleRollbackCommand(ctx);
+                }
+                catch (err) {
+                    api.logger.error(`[PD] Command /pd-principle-rollback failed: ${String(err)}`);
+                    return { text: language === 'zh' ? "命令执行失败，请检查日志。" : "Command failed. Check logs." };
+                }
+            }
+        });
         api.registerCommand({
             name: "pd-rollback",
             description: getCommandDescription('pd-rollback', language),
@@ -374,8 +419,42 @@ const plugin = {
             }
         });
         // ── Tools ──
-        api.registerTool(deepReflectTool);
-        api.registerTool(agentSpawnTool);
+        api.registerCommand({
+            name: "pd-export",
+            description: getCommandDescription('pd-export', language),
+            acceptsArgs: true,
+            handler: (ctx) => {
+                try {
+                    const workspaceDir = api.resolvePath('.');
+                    if (ctx.config)
+                        ctx.config.workspaceDir = workspaceDir;
+                    return handleExportCommand(ctx);
+                }
+                catch (err) {
+                    api.logger.error(`[PD] Command /pd-export failed: ${String(err)}`);
+                    return { text: language === 'zh' ? "导出失败，请检查日志。" : "Export failed. Check logs." };
+                }
+            }
+        });
+        api.registerCommand({
+            name: "pd-samples",
+            description: getCommandDescription('pd-samples', language),
+            acceptsArgs: true,
+            handler: (ctx) => {
+                try {
+                    const workspaceDir = api.resolvePath('.');
+                    if (ctx.config)
+                        ctx.config.workspaceDir = workspaceDir;
+                    return handleSamplesCommand(ctx);
+                }
+                catch (err) {
+                    api.logger.error(`[PD] Command /pd-samples failed: ${String(err)}`);
+                    return { text: language === 'zh' ? "样本命令执行失败，请检查日志。" : "Samples command failed. Check logs." };
+                }
+            }
+        });
+        api.registerTool(createDeepReflectTool(api));
+        api.registerTool(createAgentSpawnTool(api));
     }
 };
 export default plugin;

package/dist/service/control-ui-query-service.d.ts

@@ -0,0 +1,217 @@
+export interface OverviewResponse {
+    workspaceDir: string;
+    generatedAt: string;
+    dataFreshness: string | null;
+    summary: {
+        repeatErrorRate: number;
+        userCorrectionRate: number;
+        pendingSamples: number;
+        approvedSamples: number;
+        thinkingCoverageRate: number;
+        painEvents: number;
+        principleEventCount: number;
+    };
+    dailyTrend: Array<{
+        day: string;
+        toolCalls: number;
+        failures: number;
+        userCorrections: number;
+        thinkingTurns: number;
+    }>;
+    topRegressions: Array<{
+        toolName: string;
+        errorType: string;
+        occurrences: number;
+    }>;
+    sampleQueue: {
+        counters: Record<string, number>;
+        preview: Array<{
+            sampleId: string;
+            sessionId: string;
+            qualityScore: number;
+            reviewStatus: string;
+            createdAt: string;
+        }>;
+    };
+    thinkingSummary: {
+        activeModels: number;
+        dormantModels: number;
+        effectiveModels: number;
+        coverageRate: number;
+    };
+}
+export interface SampleListFilters {
+    status?: string;
+    qualityMin?: number;
+    dateFrom?: string;
+    dateTo?: string;
+    failureMode?: string;
+    page?: number;
+    pageSize?: number;
+}
+export interface SamplesResponse {
+    counters: Record<string, number>;
+    items: Array<{
+        sampleId: string;
+        sessionId: string;
+        reviewStatus: string;
+        qualityScore: number;
+        failureMode: string;
+        relatedThinkingCount: number;
+        createdAt: string;
+        updatedAt: string;
+        diffExcerpt: string;
+    }>;
+    pagination: {
+        page: number;
+        pageSize: number;
+        total: number;
+        totalPages: number;
+    };
+}
+export interface SampleDetailResponse {
+    sampleId: string;
+    sessionId: string;
+    reviewStatus: string;
+    qualityScore: number;
+    createdAt: string;
+    updatedAt: string;
+    badAttempt: {
+        assistantTurnId: number;
+        rawText: string;
+        sanitizedText: string;
+        createdAt: string;
+    };
+    userCorrection: {
+        userTurnId: number;
+        rawText: string;
+        correctionCue: string | null;
+        createdAt: string;
+    };
+    recoveryToolSpan: Array<{
+        id: number;
+        toolName: string;
+    }>;
+    relatedPrinciples: Array<{
+        principleId: string | null;
+        eventType: string;
+        createdAt: string;
+    }>;
+    relatedThinkingHits: Array<{
+        id: number;
+        modelId: string;
+        modelName: string;
+        matchedPattern: string;
+        scenarios: string[];
+        createdAt: string;
+        triggerExcerpt: string;
+    }>;
+    reviewHistory: Array<{
+        reviewStatus: string;
+        note: string | null;
+        createdAt: string;
+    }>;
+}
+export interface ThinkingModelSummary {
+    modelId: string;
+    name: string;
+    description: string;
+    hits: number;
+    coverageRate: number;
+    successRate: number;
+    failureRate: number;
+    painRate: number;
+    correctionRate: number;
+    correctionSampleRate: number;
+    commonScenarios: string[];
+    recommendation: 'reinforce' | 'rework' | 'archive';
+}
+export interface ThinkingOverviewResponse {
+    summary: {
+        totalModels: number;
+        activeModels: number;
+        dormantModels: number;
+        effectiveModels: number;
+        coverageRate: number;
+    };
+    topModels: ThinkingModelSummary[];
+    dormantModels: Array<{
+        modelId: string;
+        name: string;
+        description: string;
+    }>;
+    effectiveModels: ThinkingModelSummary[];
+    scenarioMatrix: Array<{
+        modelId: string;
+        modelName: string;
+        scenario: string;
+        hits: number;
+    }>;
+    coverageTrend: Array<{
+        day: string;
+        assistantTurns: number;
+        thinkingTurns: number;
+        coverageRate: number;
+    }>;
+}
+export interface ThinkingModelDetailResponse {
+    modelMeta: {
+        modelId: string;
+        name: string;
+        description: string;
+        hits: number;
+        coverageRate: number;
+        recommendation: 'reinforce' | 'rework' | 'archive';
+    };
+    usageTrend: Array<{
+        day: string;
+        hits: number;
+    }>;
+    scenarioDistribution: Array<{
+        scenario: string;
+        hits: number;
+    }>;
+    outcomeStats: {
+        events: number;
+        successRate: number;
+        failureRate: number;
+        painRate: number;
+        correctionRate: number;
+        correctionSampleRate: number;
+    };
+    recentEvents: Array<{
+        id: number;
+        createdAt: string;
+        matchedPattern: string;
+        scenarios: string[];
+        triggerExcerpt: string;
+        toolContext: Array<{
+            toolName: string;
+            outcome: string;
+            errorType?: string | null;
+        }>;
+        painContext: Array<{
+            source: string;
+            score: number;
+        }>;
+        principleContext: Array<{
+            principleId: string | null;
+            eventType: string;
+        }>;
+    }>;
+}
+export declare class ControlUiQueryService {
+    private readonly workspaceDir;
+    private readonly trajectory;
+    private readonly uiDb;
+    constructor(workspaceDir: string);
+    dispose(): void;
+    getOverview(): OverviewResponse;
+    listSamples(filters?: SampleListFilters): SamplesResponse;
+    getSampleDetail(sampleId: string): SampleDetailResponse | null;
+    reviewSample(sampleId: string, decision: 'approved' | 'rejected', note?: string): import("../core/trajectory.js").CorrectionSampleRecord;
+    exportCorrections(mode: 'raw' | 'redacted'): import("../core/trajectory.js").TrajectoryExportResult;
+    getThinkingOverview(): ThinkingOverviewResponse;
+    getThinkingModelDetail(modelId: string): ThinkingModelDetailResponse | null;
+    private loadThinkingModelSummaries;
+}