principles-disciple 1.11.0 → 1.13.0

package/src/types/principle-tree-schema.ts

@@ -1,12 +1,12 @@
 /**
  * Principle-Tree Schema Design
- * 
+ *
  * Concept: Principles are the root of a tree that branches into Rules
  * and eventually into concrete Implementations (code, skills, LoRA weights).
- * 
+ *
  * A principle without supporting rules is an empty concept — LLM may ignore it.
  * A rule without a parent principle lacks strategic direction.
- * 
+ *
  * Lifecycle:
  *   Pain Signal → Diagnosis → Principle (root)
  *                              ↓
@@ -15,23 +15,20 @@
  *                    Implementation (leaf)
  *                              ↓
  *                    Rule 100% covered → Principle deprecated
- * 
+ *
  * User Focus:
  *   - Monitor new principles added by diagnostician
  *   - Monitor principles deprecated (solidified into code/weights)
  *   - Track principle value ranking (pain prevented, adherence rate)
  */
 
+import type { PrincipleStatus } from '../core/evolution-types.js';
+import type { PrincipleDetectorSpec } from '../core/evolution-types.js';
+
 // =========================================================================
 // 1. PRINCIPLE (Tree Root) — Highly abstract, cross-scenario, value-driven
 // =========================================================================
 
-export type PrincipleStatus =
-  | 'candidate'    // Just created, needs validation
-  | 'probation'    // Partially validated, under observation
-  | 'active'       // Fully validated, actively enforced
-  | 'deprecated';  // Solidified into code/weights, no longer needed as a principle
-
 export type PrinciplePriority = 'P0' | 'P1' | 'P2';
 
 export type PrincipleScope = 'general' | 'domain';
@@ -48,6 +45,7 @@ export interface Principle {
 
   // Core content
   text: string;                   // One-line abstract principle statement
+  coreAxiomId?: string;           // Associated core axiom (e.g., "T-01")
   triggerPattern: string;         // Regex/keywords for auto-matching pain signals
   action: string;                 // What to do when triggered
 
@@ -135,6 +133,12 @@ export interface Rule {
 // 3. IMPLEMENTATION (Tree Leaf) — Concrete, executable
 // =========================================================================
 
+export type ImplementationLifecycleState =
+  | 'candidate'    // Newly created, awaiting replay evaluation
+  | 'active'       // Currently active for this rule
+  | 'disabled'     // Manually disabled (e.g., regression)
+  | 'archived';    // Permanently archived
+
 export type ImplementationType = 'code' | 'skill' | 'lora' | 'test' | 'prompt';
 
 export interface Implementation {
@@ -151,6 +155,20 @@ export interface Implementation {
   coversCondition: string;        // What condition this implementation covers
   coveragePercentage: number;     // 0-100, how much of the rule this covers
 
+  // Lifecycle state
+  lifecycleState: ImplementationLifecycleState;
+
+  // Rollback support: tracks which implementation was active before this one
+  previousActive?: string;        // Implementation ID that was active before promotion
+
+  // Disable metadata
+  disabledAt?: string;            // ISO timestamp of disable
+  disabledBy?: string;            // Who disabled (session/user)
+  disabledReason?: string;        // Human-readable reason
+
+  // Archive metadata
+  archivedAt?: string;            // ISO timestamp of archive
+
   // Metadata
   createdAt: string;
   updatedAt: string;
@@ -193,19 +211,7 @@ export interface PrincipleValueMetrics {
 }
 
 // =========================================================================
-// 6. DETECTOR METADATA (For auto-training eligibility)
-// =========================================================================
-
-export interface PrincipleDetectorSpec {
-  applicabilityTags: string[];    // Tags that identify when this principle applies
-  positiveSignals: string[];      // Indicators that the principle should activate
-  negativeSignals: string[];      // Indicators that the principle should NOT activate
-  toolSequenceHints?: string[][]; // Expected tool call sequences
-  confidence: 'high' | 'medium' | 'low';
-}
-
-// =========================================================================
-// 7. LIFECYCLE EVENTS (Event stream format for evolution.jsonl)
+// 6. LIFECYCLE EVENTS (Event stream format for evolution.jsonl)
 // =========================================================================
 
 export type PrincipleEventType =

package/src/utils/file-lock.ts

@@ -8,7 +8,7 @@
  * 4. 锁获取后二次验证
  * 5. 数据不丢失：失败时抛出异常而非静默返回
  */
-
+/* global NodeJS */
 import * as fs from 'fs';
 import * as path from 'path';
 
@@ -237,7 +237,7 @@ function tryAcquireWithStaleCleanup(filePath: string, opts: Required<LockOptions
  */
 export function acquireLock(filePath: string, options: LockOptions = {}): LockContext {
   const opts = { ...DEFAULT_OPTIONS, ...options };
-  const pid = process.pid;
+  const {pid} = process;
 
   for (let attempt = 0; attempt < opts.maxRetries; attempt++) {
     const ctx = tryAcquireWithStaleCleanup(filePath, opts, pid);
@@ -256,7 +256,7 @@ export function acquireLock(filePath: string, options: LockOptions = {}): LockCo
 
 export async function acquireLockAsync(filePath: string, options: LockOptions = {}): Promise<LockContext> {
   const opts = { ...DEFAULT_OPTIONS, ...options };
-  const pid = process.pid;
+  const {pid} = process;
 
   for (let attempt = 0; attempt < opts.maxRetries; attempt++) {
     const ctx = tryAcquireWithStaleCleanup(filePath, opts, pid);
@@ -334,6 +334,7 @@ export async function withAsyncLock<T>(
   let queue = asyncLockQueues.get(lockPath);
   
   // 创建新的 Promise 链
+  // eslint-disable-next-line @typescript-eslint/init-declarations -- assigned in Promise executor before use
   let resolveRelease: () => void;
   const releasePromise = new Promise<void>(resolve => {
     resolveRelease = resolve;
@@ -350,6 +351,7 @@ export async function withAsyncLock<T>(
   try {
     return await fn();
   } finally {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- Reason: resolveRelease is assigned in Promise constructor before finally runs
     resolveRelease!();
     // 清理已完成的队列
     if (asyncLockQueues.get(lockPath) === currentQueue) {

package/src/utils/io.ts

@@ -1,6 +1,6 @@
 import * as path from 'path';
 import * as fs from 'fs';
-import { PD_FILES, resolvePdPath } from '../core/paths.js';
+import { resolvePdPath } from '../core/paths.js';
 
 export function normalizePath(filePath: string, projectDir: string): string {
   if (!filePath) return '';
@@ -16,6 +16,7 @@ export function normalizePath(filePath: string, projectDir: string): string {
     }
   }
 
+  // eslint-disable-next-line @typescript-eslint/init-declarations -- assigned in both if/else branches
   let rel: string;
   if (projectIsWin) {
     const projectAbs = path.resolve(projectDir);
@@ -73,6 +74,7 @@ export function parseKvLines(text: string): Record<string, string> {
   return result;
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- Reason: serializeKvLines handles arbitrary object shapes for kv line serialization
 export function serializeKvLines(data: Record<string, any>): string {
   const lines: string[] = [];
   const keys = Object.keys(data).sort();
@@ -103,7 +105,8 @@ export function planStatus(projectDir: string): string {
         }
       }
     }
-  } catch (e) {
+  /* eslint-disable @typescript-eslint/no-unused-vars, no-unused-vars -- Reason: Error is intentionally ignored for graceful degradation */
+  } catch (_e) {
     // Ignore read errors
   }
   return '';

package/src/utils/nlp.ts

@@ -1,7 +1,7 @@
 /**
  * Extracts common phrases (N-grams) that appear in a majority of the given samples.
  */
-export function extractCommonPhrases(samples: string[], minOccurrence: number = 3): string[] {
+export function extractCommonPhrases(samples: string[], minOccurrence = 3): string[] {
     if (samples.length < minOccurrence) return [];
 
     const phrases = new Map<string, number>();
@@ -10,7 +10,7 @@ export function extractCommonPhrases(samples: string[], minOccurrence: number =
     for (const sample of samples) {
         // Keep all words, lowercased, remove basic punctuation
         const words = sample.toLowerCase().replace(/[.,!?;:()]/g, '').split(/\s+/).filter(w => w.length > 0);
-        
+
         for (let i = 0; i <= words.length - n; i++) {
             const ngram = words.slice(i, i + n).join(' ');
             phrases.set(ngram, (phrases.get(ngram) || 0) + 1);
@@ -19,48 +19,7 @@ export function extractCommonPhrases(samples: string[], minOccurrence: number =
 
     // Filter phrases that meet the threshold
     return Array.from(phrases.entries())
-        .filter(([_, count]) => count >= minOccurrence)
-        .map(([phrase, _]) => phrase);
-}
-
-/**
- * Extracts the longest common substring present in a high percentage of samples.
- * Suitable for Chinese or languages without clear word boundaries.
- */
-export function extractCommonSubstring(samples: string[], minLen: number = 4): string[] {
-    if (samples.length < 2) return [];
-    
-    const requiredMatches = Math.ceil(samples.length * 0.8); // Must appear in 80% of samples
-    const baseStr = samples[0];
-    let bestSubstrings: string[] = [];
-    let maxLength = 0;
-
-    // Generate all possible substrings from the first sample
-    for (let i = 0; i < baseStr.length; i++) {
-        for (let j = i + minLen; j <= baseStr.length; j++) {
-            const sub = baseStr.substring(i, j);
-            
-            // If we already found a longer one, we only care if this one can beat it
-            if (sub.length < maxLength) continue;
-
-            // Check how many other samples contain this substring
-            let matchCount = 1; // It's in the first sample
-            for (let k = 1; k < samples.length; k++) {
-                if (samples[k].includes(sub)) {
-                    matchCount++;
-                }
-            }
-
-            if (matchCount >= requiredMatches) {
-                if (sub.length > maxLength) {
-                    maxLength = sub.length;
-                    bestSubstrings = [sub];
-                } else if (sub.length === maxLength && !bestSubstrings.includes(sub)) {
-                    bestSubstrings.push(sub);
-                }
-            }
-        }
-    }
-    
-    return bestSubstrings;
+        /* eslint-disable @typescript-eslint/no-unused-vars, no-unused-vars -- Reason: Destructuring with _placeholder for unused array element */
+        .filter(([_elem, count]) => count >= minOccurrence)
+        .map(([phrase, _count]) => phrase);
 }

package/src/utils/node-vm-polyfill.ts

@@ -0,0 +1,11 @@
+/**
+ * Node VM Polyfill — Thin wrapper around node:vm module
+ *
+ * PURPOSE: Provide a single import point for vm compilation functionality
+ * used by the Rule Host. Isolates the node:vm dependency so it can be
+ * easily mocked in tests.
+ */
+
+import * as vm from 'node:vm';
+
+export const nodeVm = vm;

package/src/utils/plugin-logger.ts

@@ -2,10 +2,12 @@ import * as fs from 'fs';
 import * as path from 'path';
 
 export interface PluginLogger {
+    /* eslint-disable no-unused-vars -- Reason: interface method params are type signatures, implementations use actual values */
     info(message: string, meta?: Record<string, unknown>): void;
     warn(message: string, meta?: Record<string, unknown>): void;
     error(message: string, meta?: Record<string, unknown>): void;
     debug(message: string, meta?: Record<string, unknown>): void;
+    /* eslint-enable no-unused-vars */
 }
 
 export interface PluginLoggerConfig {