principles-disciple 1.8.1 → 1.8.2

package/src/core/hygiene/tracker.ts

@@ -0,0 +1,117 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { HygieneStats, createEmptyHygieneStats, PersistenceAction } from '../../types/hygiene-types.js';
+import { PluginLogger } from '../../openclaw-sdk.js';
+
+/**
+ * HygieneTracker - Tracks agent behavior regarding workspace organization and persistence.
+ */
+export class HygieneTracker {
+  private readonly statsFile: string;
+  private currentStats: HygieneStats;
+  private readonly logger?: PluginLogger;
+
+  constructor(stateDir: string, logger?: PluginLogger) {
+    this.statsFile = path.join(stateDir, 'hygiene-stats.json');
+    this.logger = logger;
+    
+    // Ensure state directory exists
+    if (!fs.existsSync(stateDir)) {
+      try {
+        fs.mkdirSync(stateDir, { recursive: true });
+      } catch (e) {
+        this.logger?.error(`[PD] Failed to create state directory ${stateDir}: ${String(e)}`);
+      }
+    }
+    
+    this.currentStats = this.loadStats();
+  }
+
+  private loadStats(): HygieneStats {
+    const today = new Date().toISOString().split('T')[0];
+    if (fs.existsSync(this.statsFile)) {
+      try {
+        const content = fs.readFileSync(this.statsFile, 'utf-8');
+        if (content.trim()) {
+          const allStats = JSON.parse(content);
+          if (allStats[today]) {
+            return allStats[today];
+          }
+        }
+      } catch (e) {
+        this.logger?.error(`[PD] Failed to load/parse hygiene-stats.json: ${String(e)}`);
+        // If file is corrupted, we might want to back it up and start fresh
+        try {
+          const backupPath = `${this.statsFile}.bak`;
+          fs.renameSync(this.statsFile, backupPath);
+          this.logger?.warn(`[PD] Corrupted hygiene stats backed up to ${backupPath}`);
+        } catch (_renameErr) {}
+      }
+    }
+    return createEmptyHygieneStats(today);
+  }
+
+  private saveStats(): void {
+    let allStats: Record<string, HygieneStats> = {};
+    
+    // Check if we need to rotate date (reset currentStats if date changed)
+    const today = new Date().toISOString().split('T')[0];
+    if (this.currentStats.date !== today) {
+      this.currentStats = createEmptyHygieneStats(today);
+    }
+
+    if (fs.existsSync(this.statsFile)) {
+      try {
+        const content = fs.readFileSync(this.statsFile, 'utf-8');
+        if (content.trim()) {
+          allStats = JSON.parse(content);
+        }
+      } catch (e) {
+        this.logger?.error(`[PD] Failed to parse hygiene-stats.json for saving: ${String(e)}`);
+      }
+    }
+    
+    allStats[this.currentStats.date] = this.currentStats;
+    
+    try {
+      // Use a temporary file for atomic write if possible, or simple write
+      fs.writeFileSync(this.statsFile, JSON.stringify(allStats, null, 2), 'utf-8');
+    } catch (e) {
+      this.logger?.error(`[PD] Failed to write hygiene-stats.json: ${String(e)}`);
+    }
+  }
+
+  /**
+   * Records a persistence action (writing to memory or plan).
+   */
+  recordPersistence(action: PersistenceAction): void {
+    this.currentStats.persistenceCount++;
+    this.currentStats.lastPersistenceTime = action.ts;
+    this.currentStats.totalCharsPersisted += action.contentLength;
+    
+    const fileName = path.basename(action.path);
+    this.currentStats.persistenceByFile[fileName] = (this.currentStats.persistenceByFile[fileName] || 0) + 1;
+    
+    this.saveStats();
+    this.logger?.info(`[PD] Hygiene: Persisted state to ${fileName} (${action.contentLength} chars)`);
+  }
+
+  /**
+   * Records a grooming action (cleaning up the workspace).
+   */
+  recordGrooming(): void {
+    this.currentStats.groomingExecutedCount++;
+    this.currentStats.lastGroomingTime = new Date().toISOString();
+    this.saveStats();
+    this.logger?.info(`[PD] Hygiene: Workspace grooming executed.`);
+  }
+
+  getStats(): HygieneStats {
+    // Check for date change on every get
+    const today = new Date().toISOString().split('T')[0];
+    if (this.currentStats.date !== today) {
+      this.currentStats = createEmptyHygieneStats(today);
+    }
+    return this.currentStats;
+  }
+}

package/{dist/core/init.js → src/core/init.ts}

@@ -1,54 +1,58 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
+import type { OpenClawPluginApi, PluginLogger } from '../openclaw-sdk.js';
 import { PD_DIRS } from './paths.js';
 import { defaultContextConfig } from '../types.js';
+
 /**
  * Default PROFILE.json content
  */
 const DEFAULT_PROFILE = {
-    name: "Principles Disciple Agent",
-    version: "1.0.0",
-    contextInjection: defaultContextConfig
+  name: "Principles Disciple Agent",
+  version: "1.0.0",
+  contextInjection: defaultContextConfig
 };
+
 const CORE_GUIDANCE_VERSION = 'pd-core-guidance-v2';
 const CORE_GUIDANCE_FILES = new Set(['AGENTS.md', 'TOOLS.md']);
-function getCoreGuidanceVersionMarker() {
+
+function getCoreGuidanceVersionMarker(): string {
     return `pd-core-guidance-version: ${CORE_GUIDANCE_VERSION}`;
 }
-function hasOutdatedCoreGuidance(file, content) {
-    if (!CORE_GUIDANCE_FILES.has(file))
-        return false;
-    if (content.includes(getCoreGuidanceVersionMarker()))
-        return false;
-    if (content.includes('pd_spawn_agent'))
-        return true;
-    if (!content.includes('subagents'))
-        return true;
-    if (!content.includes('sessions_spawn'))
-        return true;
+
+function hasOutdatedCoreGuidance(file: string, content: string): boolean {
+    if (!CORE_GUIDANCE_FILES.has(file)) return false;
+    if (content.includes(getCoreGuidanceVersionMarker())) return false;
+    if (content.includes('pd_spawn_agent')) return true;
+    if (!content.includes('subagents')) return true;
+    if (!content.includes('sessions_spawn')) return true;
     return false;
 }
+
 /**
  * Ensures that the workspace has the necessary template files for Principles Disciple.
  * This function flattens 'core' templates to the root so OpenClaw can find them.
  */
-export function ensureWorkspaceTemplates(api, workspaceDir, language = 'en') {
+export function ensureWorkspaceTemplates(api: OpenClawPluginApi, workspaceDir: string, language: string = 'en') {
     try {
         const __filename = fileURLToPath(import.meta.url);
         const __dirname = path.dirname(__filename);
+        
         // 1. Copy common workspace templates (e.g., docs/*)
         const commonTemplatesDir = path.resolve(__dirname, '..', '..', 'templates', 'workspace');
         if (fs.existsSync(commonTemplatesDir)) {
             api.logger.info(`[PD] Syncing workspace templates: ${workspaceDir}...`);
             copyRecursiveSync(commonTemplatesDir, workspaceDir, api);
         }
+
         // 2. Copy language-specific core templates (AGENTS.md, SOUL.md, etc.)
         // CRITICAL: These MUST be at the root of the workspace for OpenClaw to recognize them.
         let coreTemplatesDir = path.resolve(__dirname, '..', '..', 'templates', 'langs', language, 'core');
         if (!fs.existsSync(coreTemplatesDir)) {
             coreTemplatesDir = path.resolve(__dirname, '..', '..', 'templates', 'langs', 'zh', 'core');
         }
+        
         if (fs.existsSync(coreTemplatesDir)) {
             api.logger.info(`[PD] Flattening ${language} core templates to workspace root...`);
             // We copy contents of 'core' directory directly to workspaceDir root
@@ -56,14 +60,14 @@ export function ensureWorkspaceTemplates(api, workspaceDir, language = 'en') {
             for (const file of coreFiles) {
                 const srcPath = path.join(coreTemplatesDir, file);
                 const destPath = path.join(workspaceDir, file);
+                
                 // If it's a core file and we want to ensure latest templates are used
                 // but don't want to destroy user custom data, we check if we should overwrite.
                 // For now, we only copy if missing to be safe, but log it.
                 if (!fs.existsSync(destPath)) {
                     fs.copyFileSync(srcPath, destPath);
                     api.logger.info(`[PD] Initialized core file: ${file}`);
-                }
-                else if (CORE_GUIDANCE_FILES.has(file)) {
+                } else if (CORE_GUIDANCE_FILES.has(file)) {
                     const existingContent = fs.readFileSync(destPath, 'utf8');
                     if (hasOutdatedCoreGuidance(file, existingContent)) {
                         api.logger.warn(`[PD] Outdated core guidance detected in ${file}. Review the latest template guidance for peer sessions, subagents, and sessions_spawn routing.`);
@@ -71,18 +75,22 @@ export function ensureWorkspaceTemplates(api, workspaceDir, language = 'en') {
                 }
             }
         }
+
         // 3. Copy pain memory seed files
         const painTemplatesDir = path.resolve(__dirname, '..', '..', 'templates', 'langs', language, 'pain');
         const painDestDir = path.join(workspaceDir, PD_DIRS.PAIN_SAMPLES);
+        
         if (fs.existsSync(painTemplatesDir)) {
             if (!fs.existsSync(painDestDir)) {
                 fs.mkdirSync(painDestDir, { recursive: true });
             }
             copyRecursiveSync(painTemplatesDir, painDestDir, api);
         }
+
         // 4. Initialize PROFILE.json with default contextInjection config
         const principlesDir = path.join(workspaceDir, PD_DIRS.IDENTITY);
         const profilePath = path.join(principlesDir, 'PROFILE.json');
+        
         if (!fs.existsSync(profilePath)) {
             // Ensure .principles directory exists
             if (!fs.existsSync(principlesDir)) {
@@ -91,30 +99,31 @@ export function ensureWorkspaceTemplates(api, workspaceDir, language = 'en') {
             fs.writeFileSync(profilePath, JSON.stringify(DEFAULT_PROFILE, null, 2), 'utf-8');
             api.logger.info(`[PD] Initialized PROFILE.json with default contextInjection config`);
         }
-    }
-    catch (err) {
+    } catch (err) {
         api.logger.error(`[PD] Failed to initialize workspace templates: ${String(err)}`);
     }
 }
+
 /**
  * Standard recursive copy that preserves directory structure.
  * Special handling: maps 'okr' directory to 'memory/okr' for runtime compatibility.
  */
-function copyRecursiveSync(srcDir, destDir, api) {
+function copyRecursiveSync(srcDir: string, destDir: string, api: OpenClawPluginApi | { logger: PluginLogger }) {
     const items = fs.readdirSync(srcDir);
+
     for (const item of items) {
         const srcPath = path.join(srcDir, item);
         // Special mapping: okr -> memory/okr (runtime path expects memory/okr/)
         const destItemName = item === 'okr' ? path.join('memory', 'okr') : item;
         const destPath = path.join(destDir, destItemName);
         const stat = fs.statSync(srcPath);
+
         if (stat.isDirectory()) {
             if (!fs.existsSync(destPath)) {
                 fs.mkdirSync(destPath, { recursive: true });
             }
             copyRecursiveSync(srcPath, destPath, api);
-        }
-        else {
+        } else {
             if (!fs.existsSync(destPath)) {
                 // Ensure parent directory exists
                 const destParent = path.dirname(destPath);
@@ -127,16 +136,19 @@ function copyRecursiveSync(srcDir, destDir, api) {
         }
     }
 }
+
 /**
  * Ensures that the state directory has the necessary files (like pain_dictionary.json).
  */
-export function ensureStateTemplates(ctx, stateDir, language = 'en') {
+export function ensureStateTemplates(ctx: { logger: PluginLogger }, stateDir: string, language: string = 'en') {
     try {
         const __filename = fileURLToPath(import.meta.url);
         const __dirname = path.dirname(__filename);
+        
         if (!fs.existsSync(stateDir)) {
             fs.mkdirSync(stateDir, { recursive: true });
         }
+
         // 1. Copy common state files
         const commonFiles = ['pain_settings.json'];
         for (const filename of commonFiles) {
@@ -147,18 +159,19 @@ export function ensureStateTemplates(ctx, stateDir, language = 'en') {
                 ctx.logger.info(`[PD] Initialized ${filename} in stateDir: ${destPath}`);
             }
         }
+
         // 2. Copy language-specific dictionary
         let dictTemplate = path.resolve(__dirname, '..', '..', 'templates', 'langs', language, 'pain_dictionary.json');
         if (!fs.existsSync(dictTemplate)) {
             dictTemplate = path.resolve(__dirname, '..', '..', 'templates', 'langs', 'en', 'pain_dictionary.json');
         }
+        
         const dictDest = path.join(stateDir, 'pain_dictionary.json');
         if (!fs.existsSync(dictDest) && fs.existsSync(dictTemplate)) {
             fs.copyFileSync(dictTemplate, dictDest);
             ctx.logger.info(`[PD] Initialized pain dictionary in stateDir: ${dictDest} (Lang: ${language})`);
         }
-    }
-    catch (err) {
+    } catch (err) {
         ctx.logger.error(`[PD] Failed to initialize state templates: ${String(err)}`);
     }
 }