create-principles-disciple 1.104.0 → 1.104.2

package/plugin/dist/core/evolution-types.js

@@ -1,11 +0,0 @@
-/**
- * Evolution Points System V2.0 - MVP
- *
- * Canonical definitions moved to @principles/core/runtime-v2/evolution/
- * This file re-exports everything for backward compatibility.
- *
- * NOTE: Principle → EvolutionPrinciple, PrincipleStatus → EvolutionPrincipleStatus
- *       to avoid collision with runtime-v2/types/principle-schema.ts Principle.
- *       Backward-compatible aliases are provided below.
- */
-export { EvolutionTier, TIER_DEFINITIONS, getTierDefinition, getTierByPoints, TASK_DIFFICULTY_CONFIG, DEFAULT_EVOLUTION_CONFIG, isCompleteDetectorMetadata, } from '@principles/core/runtime-v2';

package/plugin/dist/core/file-store.js

@@ -1,46 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { atomicWriteFileSync } from '../utils/io.js';
-/**
- * JSON-backed FileStore implementation.
- *
- * Uses atomicWriteFileSync for crash-safe writes.
- * Handles missing/corrupt files by returning the provided default factory result.
- */
-export class JsonFileStore {
-    filePath;
-    defaultFactory;
-    constructor(filePath, defaultFactory) {
-        this.filePath = filePath;
-        this.defaultFactory = defaultFactory;
-    }
-    load() {
-        try {
-            if (!fs.existsSync(this.filePath)) {
-                return this.defaultFactory();
-            }
-            const raw = fs.readFileSync(this.filePath, 'utf8');
-            if (!raw) {
-                return this.defaultFactory();
-            }
-            return JSON.parse(raw);
-        }
-        catch {
-            console.warn(`[JsonFileStore] File corrupt or unreadable, using defaults: ${this.filePath}`);
-            return this.defaultFactory();
-        }
-    }
-    save(data) {
-        const dir = path.dirname(this.filePath);
-        if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir, { recursive: true });
-        }
-        atomicWriteFileSync(this.filePath, JSON.stringify(data, null, 2));
-    }
-    mutate(fn) {
-        const current = this.load();
-        const result = fn(current);
-        this.save(current);
-        return result;
-    }
-}

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

@@ -1,574 +0,0 @@
-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')[0] ?? '';
-        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: []
-    };
-}