principles-disciple 1.72.0 → 1.73.0

package/tests/commands/nocturnal-train.test.ts

@@ -1,97 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import { handleNocturnalTrainCommand } from '../../src/commands/nocturnal-train.js';
-import type { PluginCommandContext } from '../../src/openclaw-sdk.js';
-
-function makeTmpDir(): string {
-  return fs.mkdtempSync(path.join(os.tmpdir(), 'pd-nocturnal-train-test-'));
-}
-
-function rmdir(dir: string): void {
-  try {
-    if (fs.existsSync(dir)) {
-      fs.rmSync(dir, { recursive: true, force: true });
-    }
-  } catch {
-    // ignore cleanup errors
-  }
-}
-
-function makeCtx(workspaceDir: string, args = ''): PluginCommandContext {
-  return {
-    config: { workspaceDir, language: 'en' },
-    args,
-  } as unknown as PluginCommandContext;
-}
-
-function setupExport(workspaceDir: string, exportId = 'export-123'): void {
-  const exportDir = path.join(workspaceDir, '.state', 'exports', 'orpo');
-  fs.mkdirSync(exportDir, { recursive: true });
-  const exportPath = path.join(exportDir, `${exportId}.jsonl`);
-  fs.writeFileSync(
-    exportPath,
-    JSON.stringify({
-      sampleFingerprint: 'sf-1',
-      prompt: 'p',
-      chosen: 'c',
-      rejected: 'r',
-      rationale: 'why',
-    }) + '\n',
-    'utf-8'
-  );
-  fs.writeFileSync(
-    path.join(exportDir, `${exportId}-manifest.json`),
-    JSON.stringify({
-      exportId,
-      datasetFingerprint: 'dataset-fp-123',
-      exportPath,
-      targetModelFamily: 'qwen2.5-7b-reader',
-      sampleCount: 1,
-      createdAt: new Date().toISOString(),
-    }),
-    'utf-8'
-  );
-}
-
-describe('nocturnal-train command', () => {
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = makeTmpDir();
-    setupExport(tmpDir);
-  });
-
-  afterEach(() => {
-    rmdir(tmpDir);
-  });
-
-  it('persists durable spec files for manual create-experiment flow', async () => {
-    const result = await handleNocturnalTrainCommand(
-      makeCtx(
-        tmpDir,
-        'create-experiment --backend=peft-trl-orpo --family=qwen2.5-7b-reader --dataset=export-123'
-      )
-    );
-
-    expect(result.text).toContain('Experiment created');
-
-    const match = result.text.match(/Experiment ID:\s+([^\s]+)/);
-    expect(match?.[1]).toBeTruthy();
-    const experimentId = match![1];
-
-    const pathLines = result.text
-      .split('\n')
-      .map((line) => line.trim())
-      .map((line) => line.replace(/^-+ \s*/, ''))
-      .filter((line) => path.isAbsolute(line));
-
-    expect(pathLines).toHaveLength(2);
-    const [trainerSpecPath, workspaceSpecPath] = pathLines;
-
-    expect(fs.existsSync(trainerSpecPath)).toBe(true);
-    expect(fs.existsSync(workspaceSpecPath)).toBe(true);
-    expect(result.text).toContain(trainerSpecPath);
-  });
-});

package/tests/commands/pd-reflect.test.ts

@@ -1,49 +0,0 @@
-import { beforeEach, describe, expect, it } from 'vitest';
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { handlePdReflect } from '../../src/commands/pd-reflect.js';
-
-describe('pd-reflect command', () => {
-  let tempDir: string;
-  let workspaceDir: string;
-  let queuePath: string;
-
-  beforeEach(() => {
-    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-reflect-'));
-    workspaceDir = path.join(tempDir, 'workspace-a');
-    fs.mkdirSync(path.join(workspaceDir, '.state'), { recursive: true });
-    queuePath = path.join(workspaceDir, '.state', 'evolution_queue.json');
-    fs.writeFileSync(queuePath, '[]', 'utf8');
-  });
-
-  it('requires an explicit resolved workspace directory', async () => {
-    const result = await handlePdReflect.handler({} as any);
-    expect(result.isError).toBe(true);
-    expect(result.text).toContain('workspaceDir is not set');
-  });
-
-  it('enqueues into the provided active workspace', async () => {
-    const result = await handlePdReflect.handler({ workspaceDir } as any);
-    expect(result.isError).toBeUndefined();
-
-    const queue = JSON.parse(fs.readFileSync(queuePath, 'utf8')) as Array<Record<string, unknown>>;
-    expect(queue).toHaveLength(1);
-    expect(queue[0].taskKind).toBe('sleep_reflection');
-    expect(result.text).toContain('Nocturnal reflection task enqueued');
-  });
-
-  it('does not hardcode another workspace when context already provides one', async () => {
-    const otherWorkspace = path.join(tempDir, 'workspace-b');
-    fs.mkdirSync(path.join(otherWorkspace, '.state'), { recursive: true });
-    const otherQueuePath = path.join(otherWorkspace, '.state', 'evolution_queue.json');
-    fs.writeFileSync(otherQueuePath, '[]', 'utf8');
-
-    await handlePdReflect.handler({ workspaceDir } as any);
-
-    const activeQueue = JSON.parse(fs.readFileSync(queuePath, 'utf8')) as Array<Record<string, unknown>>;
-    const otherQueue = JSON.parse(fs.readFileSync(otherQueuePath, 'utf8')) as Array<Record<string, unknown>>;
-    expect(activeQueue).toHaveLength(1);
-    expect(otherQueue).toHaveLength(0);
-  });
-});

package/tests/core/adaptive-thresholds.test.ts

@@ -1,261 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs';
-import * as path from 'path';
-import {
-  loadThresholdState,
-  updateThresholdState,
-  resetThresholdState,
-  getEffectiveThresholds,
-  getDetailedThresholdState,
-  DEFAULT_THRESHOLDS,
-  MAX_ADJUSTMENT_PER_STEP,
-  THRESHOLD_STATE_FILE,
-} from '../../src/core/adaptive-thresholds.js';
-
-// ---------------------------------------------------------------------------
-// Test Helpers
-// ---------------------------------------------------------------------------
-
-function createTempStateDir(): string {
-  const tmpDir = path.join(__dirname, '..', '..', '.tmp', `threshold-test-${Date.now()}`);
-  fs.mkdirSync(tmpDir, { recursive: true });
-  return tmpDir;
-}
-
-function cleanupStateDir(stateDir: string): void {
-  if (fs.existsSync(stateDir)) {
-    fs.rmSync(stateDir, { recursive: true, force: true });
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Tests: loadThresholdState
-// ---------------------------------------------------------------------------
-
-describe('loadThresholdState', () => {
-  let stateDir: string;
-
-  beforeEach(() => {
-    stateDir = createTempStateDir();
-  });
-
-  afterEach(() => {
-    cleanupStateDir(stateDir);
-  });
-
-  it('returns default thresholds when no state file exists', () => {
-    const result = loadThresholdState(stateDir);
-    expect(result.success).toBe(true);
-    expect(result.usedDefaults).toBe(true);
-    expect(result.thresholds).toEqual(DEFAULT_THRESHOLDS);
-  });
-
-  it('loads persisted thresholds', () => {
-    // Step constraint limits adjustment to MAX_ADJUSTMENT_PER_STEP per call
-    // schemaCompletenessMin: 0.6 + 0.05 = 0.65 (one step)
-    updateThresholdState(stateDir, 'schemaCompletenessMin', 0.65, 'test adjustment');
-
-    // Then load it back
-    const result = loadThresholdState(stateDir);
-    expect(result.success).toBe(true);
-    expect(result.usedDefaults).toBe(false);
-    expect(result.thresholds.schemaCompletenessMin).toBe(0.65);
-  });
-
-  it('clamps values to bounds', () => {
-    // Try to set above maximum
-    updateThresholdState(stateDir, 'principleAlignmentMin', 1.5, 'test');
-    const result = loadThresholdState(stateDir);
-    expect(result.thresholds.principleAlignmentMin).toBeLessThanOrEqual(1.0);
-  });
-
-  it('returns defaults on corrupted state', () => {
-    // Write corrupted JSON
-    const statePath = path.join(stateDir, THRESHOLD_STATE_FILE);
-    fs.writeFileSync(statePath, 'not valid json{', 'utf-8');
-
-    const result = loadThresholdState(stateDir);
-    expect(result.success).toBe(true);
-    expect(result.usedDefaults).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Tests: updateThresholdState
-// ---------------------------------------------------------------------------
-
-describe('updateThresholdState', () => {
-  let stateDir: string;
-
-  beforeEach(() => {
-    stateDir = createTempStateDir();
-  });
-
-  afterEach(() => {
-    cleanupStateDir(stateDir);
-  });
-
-  it('updates a threshold value', () => {
-    // Step constraint limits adjustment per call
-    // schemaCompletenessMin: 0.6 + 0.05 (max step) = 0.65
-    const result = updateThresholdState(stateDir, 'schemaCompletenessMin', 0.65, 'test adjustment');
-    expect(result.success).toBe(true);
-    expect(result.changed).toBe(true);
-    expect(result.oldValue).toBe(DEFAULT_THRESHOLDS.schemaCompletenessMin);
-    expect(result.newValue).toBe(0.65);
-    expect(result.reason).toBe('test adjustment');
-  });
-
-  it('enforces max adjustment per step', () => {
-    const largeDelta = DEFAULT_THRESHOLDS.schemaCompletenessMin + MAX_ADJUSTMENT_PER_STEP + 0.1;
-    const result = updateThresholdState(stateDir, 'schemaCompletenessMin', largeDelta, 'large step');
-    expect(result.success).toBe(true);
-    expect(result.changed).toBe(true);
-    // Should only move by MAX_ADJUSTMENT_PER_STEP
-    expect(result.newValue).toBe(DEFAULT_THRESHOLDS.schemaCompletenessMin + MAX_ADJUSTMENT_PER_STEP);
-  });
-
-  it('ignores changes smaller than minimum', () => {
-    const smallChange = DEFAULT_THRESHOLDS.schemaCompletenessMin + 0.001;
-    const result = updateThresholdState(stateDir, 'schemaCompletenessMin', smallChange, 'tiny step');
-    expect(result.success).toBe(true);
-    expect(result.changed).toBe(false);
-  });
-
-  it('rejects unknown threshold names', () => {
-    const result = updateThresholdState(stateDir, 'unknownThreshold' as any, 0.5, 'test');
-    expect(result.success).toBe(false);
-    expect(result.error).toContain('Unknown threshold');
-  });
-
-  it('persists changes to disk', () => {
-    // Step constraint limits adjustment to MAX_ADJUSTMENT_PER_STEP per call
-    // executabilityMin: 0.65 + 0.05 (max step) = 0.70
-    updateThresholdState(stateDir, 'executabilityMin', 0.70, 'persistence test');
-    const loaded = loadThresholdState(stateDir);
-    expect(loaded.thresholds.executabilityMin).toBe(0.70);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Tests: resetThresholdState
-// ---------------------------------------------------------------------------
-
-describe('resetThresholdState', () => {
-  let stateDir: string;
-
-  beforeEach(() => {
-    stateDir = createTempStateDir();
-  });
-
-  afterEach(() => {
-    cleanupStateDir(stateDir);
-  });
-
-  it('resets all thresholds to defaults', () => {
-    // Change some values
-    updateThresholdState(stateDir, 'schemaCompletenessMin', 0.9, 'change 1');
-    updateThresholdState(stateDir, 'principleAlignmentMin', 0.95, 'change 2');
-
-    // Reset
-    resetThresholdState(stateDir);
-
-    // Verify defaults
-    const result = loadThresholdState(stateDir);
-    expect(result.thresholds).toEqual(DEFAULT_THRESHOLDS);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Tests: getEffectiveThresholds
-// ---------------------------------------------------------------------------
-
-describe('getEffectiveThresholds', () => {
-  let stateDir: string;
-
-  beforeEach(() => {
-    stateDir = createTempStateDir();
-  });
-
-  afterEach(() => {
-    cleanupStateDir(stateDir);
-  });
-
-  it('returns default thresholds when no state file exists', () => {
-    const thresholds = getEffectiveThresholds(stateDir);
-    expect(thresholds).toEqual(DEFAULT_THRESHOLDS);
-  });
-
-  it('returns persisted thresholds', () => {
-    // Note: step constraint limits adjustment per call
-    // Set to a value within one step: default (0.5) + MAX_ADJUSTMENT_PER_STEP (0.05) = 0.55
-    updateThresholdState(stateDir, 'boundednessMin', 0.55, 'test');
-    const thresholds = getEffectiveThresholds(stateDir);
-    expect(thresholds.boundednessMin).toBe(0.55);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Tests: getDetailedThresholdState
-// ---------------------------------------------------------------------------
-
-describe('getDetailedThresholdState', () => {
-  let stateDir: string;
-
-  beforeEach(() => {
-    stateDir = createTempStateDir();
-  });
-
-  afterEach(() => {
-    cleanupStateDir(stateDir);
-  });
-
-  it('returns null when no state file exists', () => {
-    const state = getDetailedThresholdState(stateDir);
-    expect(state).toBeNull();
-  });
-
-  it('returns detailed state with metadata', () => {
-    updateThresholdState(stateDir, 'confidenceMin', 0.75, 'test adjustment');
-    const state = getDetailedThresholdState(stateDir);
-    expect(state).not.toBeNull();
-    expect(state!.thresholds.confidenceMin).toBeDefined();
-    expect(state!.thresholds.confidenceMin!.lastUpdatedAt).toBeDefined();
-    expect(state!.thresholds.confidenceMin!.adjustmentCount).toBe(1);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Tests: Default values integrity
-// ---------------------------------------------------------------------------
-
-describe('DEFAULT_THRESHOLDS', () => {
-  it('has values in valid range (0-1)', () => {
-    for (const value of Object.values(DEFAULT_THRESHOLDS)) {
-      expect(value).toBeGreaterThanOrEqual(0);
-      expect(value).toBeLessThanOrEqual(1);
-    }
-  });
-
-  it('has aggregateMin higher than minimum possible weighted aggregate', () => {
-    // aggregateMin (0.65) should be higher than the minimum possible
-    // aggregate score given all thresholds at minimum values.
-    // This ensures aggregateMin provides an additional quality gate.
-    const weights = {
-      schemaCompletenessMin: 0.15,
-      principleAlignmentMin: 0.30,
-      executabilityMin: 0.20,
-      boundednessMin: 0.20,
-      confidenceMin: 0.15,
-    };
-    const minPossibleAggregate =
-      DEFAULT_THRESHOLDS.schemaCompletenessMin * weights.schemaCompletenessMin +
-      DEFAULT_THRESHOLDS.principleAlignmentMin * weights.principleAlignmentMin +
-      DEFAULT_THRESHOLDS.executabilityMin * weights.executabilityMin +
-      DEFAULT_THRESHOLDS.boundednessMin * weights.boundednessMin +
-      DEFAULT_THRESHOLDS.confidenceMin * weights.confidenceMin;
-    
-    // aggregateMin should be at or above the minimum possible aggregate
-    expect(DEFAULT_THRESHOLDS.aggregateMin).toBeGreaterThanOrEqual(minPossibleAggregate);
-  });
-});