create-principles-disciple 1.0.0 → 1.74.0

package/plugin/dist/core/focus-history.js

@@ -0,0 +1,574 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { atomicWriteFileSync } from '../utils/io.js';
+import { extractVersion, extractDate, validateCurrentFocus, compressFocusContent, cleanupStaleInfoPure, extractDescription, extractProblems, extractNextActions, deduplicateArtifacts, } from '@principles/core/prompt-builder';
+export { extractVersion, extractDate, extractSummary, parseWorkingMemorySection, workingMemoryToInjection, extractMilestones, validateCurrentFocus, mergeWorkingMemory, compressFocusContent, } from '@principles/core/prompt-builder';
+function logError(message, error) {
+    const timestamp = new Date().toISOString();
+    const errorStr = error instanceof Error ? error.message : String(error);
+    console.error(`[focus-history] ${timestamp} ERROR: ${message}${errorStr ? ' - ' + errorStr : ''}`);
+}
+const MAX_HISTORY_FILES = 10;
+const FULL_MODE_HISTORY_COUNT = 3;
+const MAX_ARTIFACTS = 20;
+const MAX_PROBLEMS = 5;
+const MAX_NEXT_ACTIONS = 5;
+const LAST_COMPRESS_FILE = '.last_compress';
+const CURRENT_FOCUS_TEMPLATE_PATH = 'templates/workspace/okr/CURRENT_FOCUS.md';
+const DEFAULT_COMPRESSION_CONFIG = {
+    lineThreshold: 100,
+    sizeThreshold: 15 * 1024,
+    intervalMs: 24 * 60 * 60 * 1000,
+    keepCompletedTasks: 3,
+    maxWorkingMemoryArtifacts: 10,
+};
+export function getHistoryDir(focusPath) {
+    return path.join(path.dirname(focusPath), '.history');
+}
+export function backupToHistory(focusPath, content) {
+    try {
+        const historyDir = getHistoryDir(focusPath);
+        if (!fs.existsSync(historyDir)) {
+            try {
+                fs.mkdirSync(historyDir, { recursive: true });
+            }
+            catch (error) {
+                logError(`Failed to create history directory: ${historyDir}`, error);
+                return null;
+            }
+        }
+        const version = extractVersion(content);
+        const date = extractDate(content);
+        const timestamp = Date.now();
+        const backupName = `CURRENT_FOCUS.v${version}.${date}.${timestamp}.md`;
+        const backupPath = path.join(historyDir, backupName);
+        if (fs.existsSync(backupPath)) {
+            return null;
+        }
+        try {
+            atomicWriteFileSync(backupPath, content);
+            return backupPath;
+        }
+        catch (error) {
+            logError(`Failed to write backup file: ${backupPath}`, error);
+            return null;
+        }
+    }
+    catch (error) {
+        logError('Unexpected error in backupToHistory', error);
+        return null;
+    }
+}
+export function cleanupHistory(focusPath, maxFiles = MAX_HISTORY_FILES) {
+    try {
+        const historyDir = getHistoryDir(focusPath);
+        if (!fs.existsSync(historyDir)) {
+            return;
+        }
+        const files = fs.readdirSync(historyDir)
+            .filter(f => f.startsWith('CURRENT_FOCUS.v') && f.endsWith('.md'))
+            .map(f => ({
+            name: f,
+            path: path.join(historyDir, f),
+            mtime: fs.statSync(path.join(historyDir, f)).mtime.getTime()
+        }))
+            .sort((a, b) => b.mtime - a.mtime);
+        const toDelete = files.slice(maxFiles);
+        for (const file of toDelete) {
+            try {
+                fs.unlinkSync(file.path);
+            }
+            catch (error) {
+                logError(`Failed to delete history file: ${file.path}`, error);
+            }
+        }
+    }
+    catch (error) {
+        logError('Unexpected error in cleanupHistory', error);
+    }
+}
+export async function getHistoryVersions(focusPath, count = FULL_MODE_HISTORY_COUNT) {
+    const historyDir = getHistoryDir(focusPath);
+    let allFiles;
+    try {
+        allFiles = await fs.promises.readdir(historyDir);
+    }
+    catch (err) {
+        if (typeof err === 'object' && err !== null && 'code' in err && err.code === 'ENOENT') {
+            return [];
+        }
+        throw err;
+    }
+    const historyFiles = allFiles.filter(f => f.startsWith('CURRENT_FOCUS.v') && f.endsWith('.md'));
+    const statResults = await Promise.allSettled(historyFiles.map(async (f) => {
+        const filePath = path.join(historyDir, f);
+        const stat = await fs.promises.stat(filePath);
+        return {
+            path: filePath,
+            mtime: stat.mtime.getTime()
+        };
+    }));
+    const filesWithStat = statResults
+        .filter((r) => r.status === 'fulfilled')
+        .map(r => r.value);
+    const selectedFiles = filesWithStat
+        .sort((a, b) => b.mtime - a.mtime)
+        .slice(0, count);
+    const readResults = await Promise.allSettled(selectedFiles.map(f => fs.promises.readFile(f.path, 'utf-8')));
+    return readResults
+        .filter((r) => r.status === 'fulfilled')
+        .map(r => r.value);
+}
+export function compressFocus(focusPath, newContent) {
+    let oldContent = '';
+    if (fs.existsSync(focusPath)) {
+        oldContent = fs.readFileSync(focusPath, 'utf-8');
+    }
+    const backupPath = oldContent ? backupToHistory(focusPath, oldContent) : null;
+    const oldVersion = extractVersion(oldContent);
+    const versionParts = oldVersion.split('.');
+    const majorVersion = parseInt(versionParts[0], 10) || 1;
+    const newVersion = `${majorVersion + 1}`;
+    const [today] = new Date().toISOString().split('T');
+    const updatedContent = newContent
+        .replace(/\*\*版本\*\*:\s*v[\d.]+/i, `**版本**: v${newVersion}`)
+        .replace(/\*\*更新\*\*:\s*\d{4}-\d{2}-\d{2}/, `**更新**: ${today}`);
+    atomicWriteFileSync(focusPath, updatedContent);
+    const historyDir = getHistoryDir(focusPath);
+    const beforeCount = fs.existsSync(historyDir)
+        ? fs.readdirSync(historyDir).filter(f => f.startsWith('CURRENT_FOCUS.v')).length
+        : 0;
+    cleanupHistory(focusPath);
+    const afterCount = fs.existsSync(historyDir)
+        ? fs.readdirSync(historyDir).filter(f => f.startsWith('CURRENT_FOCUS.v')).length
+        : 0;
+    return {
+        backupPath,
+        cleanedCount: beforeCount - afterCount
+    };
+}
+export function extractWorkingMemory(messages, workspaceDir) {
+    const snapshot = {
+        lastUpdated: new Date().toISOString(),
+        artifacts: [],
+        activeProblems: [],
+        nextActions: []
+    };
+    const recentMessages = messages
+        .filter(m => m.role === 'assistant')
+        .slice(-10);
+    for (const msg of recentMessages) {
+        let text = '';
+        const toolUses = [];
+        if (typeof msg.content === 'string') {
+            text = msg.content;
+        }
+        else if (Array.isArray(msg.content)) {
+            const textParts = [];
+            for (const c of msg.content) {
+                if (!c || typeof c !== 'object')
+                    continue;
+                const obj = c;
+                if (obj.type === 'text' && typeof obj.text === 'string') {
+                    textParts.push(obj.text);
+                }
+                if (obj.type === 'tool_use' && typeof obj.name === 'string' && typeof obj.input === 'object') {
+                    toolUses.push({
+                        name: obj.name,
+                        input: obj.input
+                    });
+                }
+            }
+            text = textParts.join('\n');
+        }
+        for (const toolUse of toolUses) {
+            if (['write_file', 'replace', 'create_file'].includes(toolUse.name)) {
+                const filePath = toolUse.input.file_path || toolUse.input.absolute_path || toolUse.input.path;
+                if (typeof filePath === 'string' && filePath.trim()) {
+                    if (filePath.includes('node_modules') ||
+                        filePath.endsWith('.d.ts') ||
+                        filePath.includes('.config.')) {
+                        continue;
+                    }
+                    const displayPath = workspaceDir && filePath.startsWith(workspaceDir)
+                        ? path.relative(workspaceDir, filePath)
+                        : filePath;
+                    const action = toolUse.name === 'write_file' || toolUse.name === 'create_file' ? 'created' : 'modified';
+                    const description = extractDescription(text, filePath);
+                    snapshot.artifacts.push({
+                        path: displayPath,
+                        action,
+                        description
+                    });
+                }
+            }
+        }
+        if (!text)
+            continue;
+        extractFileArtifacts(text, snapshot.artifacts, workspaceDir);
+        extractProblems(text, snapshot.activeProblems);
+        extractNextActions(text, snapshot.nextActions);
+    }
+    snapshot.artifacts = deduplicateArtifacts(snapshot.artifacts).slice(-MAX_ARTIFACTS);
+    snapshot.activeProblems = snapshot.activeProblems.slice(-MAX_PROBLEMS);
+    snapshot.nextActions = snapshot.nextActions.slice(-MAX_NEXT_ACTIONS);
+    return snapshot;
+}
+function extractFileArtifacts(text, artifacts, workspaceDir) {
+    const filePathRegex = /(?:file_path|absolute_path)["']?\s*[:=]\s*["']([^"']+\.(ts|js|json|md|yaml|yml|py|sh|mjs|cjs))["']/gi;
+    let match;
+    while ((match = filePathRegex.exec(text)) !== null) {
+        const [, filePath] = match;
+        if (filePath.includes('node_modules') ||
+            filePath.endsWith('.d.ts') ||
+            filePath.includes('.config.')) {
+            continue;
+        }
+        const displayPath = workspaceDir && filePath.startsWith(workspaceDir)
+            ? path.relative(workspaceDir, filePath)
+            : filePath;
+        let action = 'modified';
+        const contextBefore = text.substring(Math.max(0, match.index - 200), match.index);
+        if (contextBefore.toLowerCase().includes('created') ||
+            contextBefore.includes('新建') ||
+            contextBefore.includes('创建')) {
+            action = 'created';
+        }
+        else if (contextBefore.toLowerCase().includes('deleted') ||
+            contextBefore.includes('删除')) {
+            action = 'deleted';
+        }
+        const description = extractDescription(text, filePath);
+        artifacts.push({
+            path: displayPath,
+            action,
+            description
+        });
+    }
+    const genericPathRegex = /[`"']([a-zA-Z0-9_./]+\.(ts|js|mjs|cjs|py))[`"']/g;
+    while ((match = genericPathRegex.exec(text)) !== null) {
+        const [, filePath] = match;
+        if (filePath.length < 10 ||
+            filePath.includes('node_modules') ||
+            filePath.includes('.config.') ||
+            filePath.endsWith('.d.ts') ||
+            filePath.endsWith('.test.ts') ||
+            filePath.endsWith('.spec.ts')) {
+            continue;
+        }
+        if (artifacts.some(a => a.path === filePath || a.path.endsWith(filePath) || filePath.endsWith(a.path))) {
+            continue;
+        }
+        const description = extractDescription(text, filePath);
+        artifacts.push({
+            path: filePath,
+            action: 'modified',
+            description
+        });
+    }
+}
+export function cleanupStaleInfo(content, workspaceDir, config) {
+    const effectiveConfig = config || DEFAULT_COMPRESSION_CONFIG;
+    const coreOptions = {
+        lineThreshold: effectiveConfig.lineThreshold,
+        sizeThreshold: effectiveConfig.sizeThreshold,
+        keepCompletedTasks: effectiveConfig.keepCompletedTasks,
+        maxWorkingMemoryArtifacts: workspaceDir ? Infinity : effectiveConfig.maxWorkingMemoryArtifacts,
+    };
+    let result = cleanupStaleInfoPure(content, coreOptions);
+    if (workspaceDir) {
+        const lines = result.split('\n');
+        const filtered = [];
+        let inFileTable = false;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (/^\|\s*文件路径/.test(trimmed)) {
+                inFileTable = true;
+                filtered.push(line);
+                continue;
+            }
+            if (inFileTable && /^\|[^|]+\|[^|]+\|[^|]+\|/.test(trimmed)) {
+                if (/^\|[-\s|:]+\|$/.test(trimmed)) {
+                    filtered.push(line);
+                    continue;
+                }
+                const match = /^\|\s*`?([^`|\n]+)`?\s*\|/.exec(trimmed);
+                if (match && match[1]) {
+                    const filePath = match[1].trim();
+                    const fullPath = path.join(workspaceDir, filePath);
+                    if (!fs.existsSync(fullPath)) {
+                        continue;
+                    }
+                }
+            }
+            else if (inFileTable && /^##\s/.test(trimmed)) {
+                inFileTable = false;
+            }
+            filtered.push(line);
+        }
+        result = filtered.join('\n');
+    }
+    return result;
+}
+function loadCompressionConfig(stateDir) {
+    if (!stateDir) {
+        return DEFAULT_COMPRESSION_CONFIG;
+    }
+    try {
+        const configPath = path.join(stateDir, 'pain_settings.json');
+        if (!fs.existsSync(configPath)) {
+            return DEFAULT_COMPRESSION_CONFIG;
+        }
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        const compression = config?.compression || {};
+        return {
+            lineThreshold: compression.line_threshold ?? DEFAULT_COMPRESSION_CONFIG.lineThreshold,
+            sizeThreshold: (compression.size_threshold_kb ?? 15) * 1024,
+            intervalMs: (compression.interval_hours ?? 24) * 60 * 60 * 1000,
+            keepCompletedTasks: compression.keep_completed_tasks ?? DEFAULT_COMPRESSION_CONFIG.keepCompletedTasks,
+            maxWorkingMemoryArtifacts: compression.max_working_memory_artifacts ?? DEFAULT_COMPRESSION_CONFIG.maxWorkingMemoryArtifacts,
+        };
+    }
+    catch {
+        return DEFAULT_COMPRESSION_CONFIG;
+    }
+}
+function canAutoCompress(stateDir) {
+    const lastCompressPath = path.join(stateDir, LAST_COMPRESS_FILE);
+    if (!fs.existsSync(lastCompressPath)) {
+        return true;
+    }
+    try {
+        const config = loadCompressionConfig(stateDir);
+        const lastCompressTime = parseInt(fs.readFileSync(lastCompressPath, 'utf-8'), 10);
+        const now = Date.now();
+        return (now - lastCompressTime) >= config.intervalMs;
+    }
+    catch {
+        return true;
+    }
+}
+function recordCompressTime(stateDir) {
+    try {
+        if (!fs.existsSync(stateDir)) {
+            fs.mkdirSync(stateDir, { recursive: true });
+        }
+        atomicWriteFileSync(path.join(stateDir, LAST_COMPRESS_FILE), Date.now().toString());
+    }
+    catch (error) {
+        logError('Failed to record compress time', error);
+    }
+}
+export function autoCompressFocus(focusPath, workspaceDir, stateDir) {
+    if (!fs.existsSync(focusPath)) {
+        return {
+            compressed: false,
+            oldLines: 0,
+            newLines: 0,
+            milestonesArchived: false,
+            backupPath: null,
+            reason: 'File not found'
+        };
+    }
+    const config = loadCompressionConfig(stateDir);
+    const oldContent = fs.readFileSync(focusPath, 'utf-8');
+    const oldLines = oldContent.split('\n').length;
+    const oldSize = Buffer.byteLength(oldContent, 'utf-8');
+    const needsCompression = oldLines > config.lineThreshold ||
+        oldSize > config.sizeThreshold;
+    if (!needsCompression) {
+        return {
+            compressed: false,
+            oldLines,
+            newLines: oldLines,
+            milestonesArchived: false,
+            backupPath: null,
+            reason: 'Below threshold'
+        };
+    }
+    if (stateDir && !canAutoCompress(stateDir)) {
+        return {
+            compressed: false,
+            oldLines,
+            newLines: oldLines,
+            milestonesArchived: false,
+            backupPath: null,
+            reason: 'Rate limited (24h interval)'
+        };
+    }
+    const coreOptions = {
+        lineThreshold: config.lineThreshold,
+        sizeThreshold: config.sizeThreshold,
+        keepCompletedTasks: config.keepCompletedTasks,
+        maxWorkingMemoryArtifacts: config.maxWorkingMemoryArtifacts,
+    };
+    const prefilteredContent = workspaceDir
+        ? cleanupStaleInfo(oldContent, workspaceDir, config)
+        : oldContent;
+    const coreResult = compressFocusContent(prefilteredContent, coreOptions);
+    if (!coreResult.compressed) {
+        return {
+            compressed: false,
+            oldLines,
+            newLines: oldLines,
+            milestonesArchived: false,
+            backupPath: null,
+            reason: 'Compression returned no content'
+        };
+    }
+    let milestonesArchived = false;
+    if (workspaceDir) {
+        const archivePath = archiveMilestonesToDaily(workspaceDir, coreResult.milestones, coreResult.newVersion);
+        milestonesArchived = archivePath !== null;
+    }
+    const backupPath = backupToHistory(focusPath, oldContent);
+    cleanupHistory(focusPath);
+    atomicWriteFileSync(focusPath, coreResult.newContent);
+    if (stateDir) {
+        recordCompressTime(stateDir);
+    }
+    const newLines = coreResult.newContent.split('\n').length;
+    return {
+        compressed: true,
+        oldLines,
+        newLines,
+        milestonesArchived,
+        backupPath,
+        newContent: coreResult.newContent,
+        reason: `Auto-compressed: ${oldLines} → ${newLines} lines`
+    };
+}
+export function needsAutoCompression(focusPath, stateDir) {
+    if (!fs.existsSync(focusPath)) {
+        return false;
+    }
+    try {
+        const config = stateDir ? loadCompressionConfig(stateDir) : DEFAULT_COMPRESSION_CONFIG;
+        const content = fs.readFileSync(focusPath, 'utf-8');
+        const lines = content.split('\n').length;
+        const size = Buffer.byteLength(content, 'utf-8');
+        return lines > config.lineThreshold || size > config.sizeThreshold;
+    }
+    catch {
+        return false;
+    }
+}
+export function archiveMilestonesToDaily(workspaceDir, milestones, version) {
+    if (milestones.completedTasks.length === 0 && milestones.fileArtifacts.length === 0) {
+        return null;
+    }
+    const [dateStr] = new Date().toISOString().split('T');
+    const memoryDir = path.join(workspaceDir, 'memory');
+    const dailyLogPath = path.join(memoryDir, `${dateStr}.md`);
+    const timestamp = new Date().toISOString();
+    if (!fs.existsSync(memoryDir)) {
+        fs.mkdirSync(memoryDir, { recursive: true });
+    }
+    const lines = [];
+    lines.push(`\n## 🏆 里程碑 [CURRENT_FOCUS v${version} 压缩]`);
+    lines.push(`> 时间: ${timestamp}`);
+    lines.push('');
+    if (milestones.completedTasks.length > 0) {
+        lines.push('### 已完成任务');
+        for (const task of milestones.completedTasks) {
+            lines.push(`- [x] ${task}`);
+        }
+        lines.push('');
+    }
+    if (milestones.fileArtifacts.length > 0) {
+        lines.push('### 相关文件');
+        for (const file of milestones.fileArtifacts) {
+            lines.push(`- \`${file}\``);
+        }
+        lines.push('');
+    }
+    lines.push('---');
+    lines.push('');
+    try {
+        fs.appendFileSync(dailyLogPath, lines.join('\n'), 'utf-8');
+        return dailyLogPath;
+    }
+    catch (error) {
+        logError(`Failed to archive milestones to ${dailyLogPath}`, error);
+        return null;
+    }
+}
+export function recoverFromTemplate(focusPath, extensionRoot) {
+    try {
+        const templatePath = path.join(extensionRoot, CURRENT_FOCUS_TEMPLATE_PATH);
+        if (!fs.existsSync(templatePath)) {
+            return {
+                success: false,
+                error: `Template not found: ${templatePath}`
+            };
+        }
+        let template = fs.readFileSync(templatePath, 'utf-8');
+        const [today] = new Date().toISOString().split('T');
+        template = template.replace(/{YYYY-MM-DD}/g, today);
+        if (fs.existsSync(focusPath)) {
+            const backupPath = `${focusPath}.corrupted.${Date.now()}.md`;
+            fs.copyFileSync(focusPath, backupPath);
+        }
+        const focusDir = path.dirname(focusPath);
+        if (!fs.existsSync(focusDir)) {
+            fs.mkdirSync(focusDir, { recursive: true });
+        }
+        atomicWriteFileSync(focusPath, template);
+        return {
+            success: true,
+            templatePath
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: String(error)
+        };
+    }
+}
+export function safeReadCurrentFocus(focusPath, extensionRoot, logger) {
+    if (!fs.existsSync(focusPath)) {
+        const result = recoverFromTemplate(focusPath, extensionRoot);
+        if (result.success) {
+            logger?.info?.(`[PD:Focus] Created CURRENT_FOCUS.md from template`);
+            return {
+                content: fs.readFileSync(focusPath, 'utf-8'),
+                recovered: true,
+                validationErrors: []
+            };
+        }
+        return {
+            content: '',
+            recovered: false,
+            validationErrors: [`Failed to create from template: ${result.error}`]
+        };
+    }
+    const content = fs.readFileSync(focusPath, 'utf-8');
+    const validation = validateCurrentFocus(content);
+    if (validation.warnings.length > 0) {
+        logger?.warn?.(`[PD:Focus] CURRENT_FOCUS.md warnings: ${validation.warnings.join(', ')}`);
+    }
+    if (!validation.valid) {
+        logger?.warn?.(`[PD:Focus] CURRENT_FOCUS.md corrupted: ${validation.errors.join(', ')}`);
+        const result = recoverFromTemplate(focusPath, extensionRoot);
+        if (result.success) {
+            logger?.info?.(`[PD:Focus] Recovered CURRENT_FOCUS.md from template`);
+            return {
+                content: fs.readFileSync(focusPath, 'utf-8'),
+                recovered: true,
+                validationErrors: validation.errors
+            };
+        }
+        logger?.warn?.(`[PD:Focus] Failed to recover: ${result.error}`);
+        return {
+            content,
+            recovered: false,
+            validationErrors: validation.errors
+        };
+    }
+    return {
+        content,
+        recovered: false,
+        validationErrors: []
+    };
+}

package/plugin/dist/core/hygiene/tracker.d.ts

@@ -0,0 +1,22 @@
+import type { HygieneStats, PersistenceAction } from '../../types/hygiene-types.js';
+import type { PluginLogger } from '../../openclaw-sdk.js';
+/**
+ * HygieneTracker - Tracks agent behavior regarding workspace organization and persistence.
+ */
+export declare class HygieneTracker {
+    private readonly statsFile;
+    private currentStats;
+    private readonly logger?;
+    constructor(stateDir: string, logger?: PluginLogger);
+    private loadStats;
+    private saveStats;
+    /**
+     * Records a persistence action (writing to memory or plan).
+     */
+    recordPersistence(action: PersistenceAction): void;
+    /**
+     * Records a grooming action (cleaning up the workspace).
+     */
+    recordGrooming(): void;
+    getStats(): HygieneStats;
+}