principles-disciple 1.5.4

package/dist/core/evolution-types.js

@@ -0,0 +1,56 @@
+/**
+ * Evolution Points System V2.0 - MVP
+ *
+ * Core Philosophy: Growth-driven替代Penalty-driven
+ * - 起点0分，只能增加，不扣分
+ * - 失败记录教训，不扣分
+ * - 同类任务失败后首次成功 = 双倍奖励（1小时冷却）
+ * - 5级成长路径：Seed → Forest
+ */
+// ===== 等级定义 =====
+export var EvolutionTier;
+(function (EvolutionTier) {
+    EvolutionTier[EvolutionTier["Seed"] = 1] = "Seed";
+    EvolutionTier[EvolutionTier["Sprout"] = 2] = "Sprout";
+    EvolutionTier[EvolutionTier["Sapling"] = 3] = "Sapling";
+    EvolutionTier[EvolutionTier["Tree"] = 4] = "Tree";
+    EvolutionTier[EvolutionTier["Forest"] = 5] = "Forest"; // 森林：完全自主
+})(EvolutionTier || (EvolutionTier = {}));
+export const TIER_DEFINITIONS = [
+    { tier: EvolutionTier.Seed, name: 'Seed', requiredPoints: 0, permissions: { maxLinesPerWrite: 20, maxFilesPerTask: 1, allowRiskPath: false, allowSubagentSpawn: false } },
+    { tier: EvolutionTier.Sprout, name: 'Sprout', requiredPoints: 50, permissions: { maxLinesPerWrite: 50, maxFilesPerTask: 2, allowRiskPath: false, allowSubagentSpawn: false } },
+    { tier: EvolutionTier.Sapling, name: 'Sapling', requiredPoints: 200, permissions: { maxLinesPerWrite: 200, maxFilesPerTask: 5, allowRiskPath: false, allowSubagentSpawn: true } },
+    { tier: EvolutionTier.Tree, name: 'Tree', requiredPoints: 500, permissions: { maxLinesPerWrite: 500, maxFilesPerTask: 10, allowRiskPath: true, allowSubagentSpawn: true } },
+    { tier: EvolutionTier.Forest, name: 'Forest', requiredPoints: 1000, permissions: { maxLinesPerWrite: Infinity, maxFilesPerTask: Infinity, allowRiskPath: true, allowSubagentSpawn: true } },
+];
+export function getTierDefinition(tier) {
+    return TIER_DEFINITIONS[tier - 1];
+}
+export function getTierByPoints(totalPoints) {
+    // 从高到低检查，找到最高匹配等级
+    for (let i = TIER_DEFINITIONS.length - 1; i >= 0; i--) {
+        if (totalPoints >= TIER_DEFINITIONS[i].requiredPoints) {
+            return TIER_DEFINITIONS[i].tier;
+        }
+    }
+    return EvolutionTier.Seed;
+}
+export const TASK_DIFFICULTY_CONFIG = {
+    trivial: { basePoints: 1, description: '简单任务：读取、搜索、状态查询' },
+    normal: { basePoints: 3, description: '常规任务：单文件编辑、测试编写' },
+    hard: { basePoints: 8, description: '困难任务：多文件重构、架构变更' },
+};
+export const DEFAULT_EVOLUTION_CONFIG = {
+    doubleRewardCooldownMs: 60 * 60 * 1000, // 1小时
+    maxRecentEvents: 50,
+    difficultyPenalty: {
+        tier4Trivial: 0.1,
+        tier4Normal: 0.5,
+        tier5Trivial: 0.1,
+        tier5Normal: 0.5,
+    },
+    dualTrack: {
+        enabled: true,
+        primarySystem: 'evolution',
+    },
+};

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

@@ -0,0 +1,22 @@
+import { HygieneStats, PersistenceAction } from '../../types/hygiene-types.js';
+import { 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;
+}

package/dist/core/hygiene/tracker.js

@@ -0,0 +1,106 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { createEmptyHygieneStats } from '../../types/hygiene-types.js';
+/**
+ * HygieneTracker - Tracks agent behavior regarding workspace organization and persistence.
+ */
+export class HygieneTracker {
+    statsFile;
+    currentStats;
+    logger;
+    constructor(stateDir, logger) {
+        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();
+    }
+    loadStats() {
+        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);
+    }
+    saveStats() {
+        let allStats = {};
+        // 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) {
+        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() {
+        this.currentStats.groomingExecutedCount++;
+        this.currentStats.lastGroomingTime = new Date().toISOString();
+        this.saveStats();
+        this.logger?.info(`[PD] Hygiene: Workspace grooming executed.`);
+    }
+    getStats() {
+        // 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.d.ts

@@ -0,0 +1,12 @@
+import type { OpenClawPluginApi, PluginLogger } from '../openclaw-sdk.js';
+/**
+ * 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 declare function ensureWorkspaceTemplates(api: OpenClawPluginApi, workspaceDir: string, language?: string): void;
+/**
+ * Ensures that the state directory has the necessary files (like pain_dictionary.json).
+ */
+export declare function ensureStateTemplates(ctx: {
+    logger: PluginLogger;
+}, stateDir: string, language?: string): void;

package/dist/core/init.js

@@ -0,0 +1,117 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { PD_DIRS } from './paths.js';
+/**
+ * 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') {
+    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
+            const coreFiles = fs.readdirSync(coreTemplatesDir);
+            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}`);
+                }
+            }
+        }
+        // 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);
+        }
+    }
+    catch (err) {
+        api.logger.error(`[PD] Failed to initialize workspace templates: ${String(err)}`);
+    }
+}
+/**
+ * Standard recursive copy that preserves directory structure.
+ */
+function copyRecursiveSync(srcDir, destDir, api) {
+    const items = fs.readdirSync(srcDir);
+    for (const item of items) {
+        const srcPath = path.join(srcDir, item);
+        const destPath = path.join(destDir, item);
+        const stat = fs.statSync(srcPath);
+        if (stat.isDirectory()) {
+            if (!fs.existsSync(destPath)) {
+                fs.mkdirSync(destPath, { recursive: true });
+            }
+            copyRecursiveSync(srcPath, destPath, api);
+        }
+        else {
+            if (!fs.existsSync(destPath)) {
+                try {
+                    fs.copyFileSync(srcPath, destPath);
+                }
+                catch (err) {
+                    if ('logger' in api)
+                        api.logger.warn(`[PD] Failed to copy ${item}: ${String(err)}`);
+                }
+            }
+        }
+    }
+}
+/**
+ * Ensures that the state directory has the necessary files (like pain_dictionary.json).
+ */
+export function ensureStateTemplates(ctx, stateDir, language = '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) {
+            const templatePath = path.resolve(__dirname, '..', '..', 'templates', filename);
+            const destPath = path.join(stateDir, filename);
+            if (!fs.existsSync(destPath) && fs.existsSync(templatePath)) {
+                fs.copyFileSync(templatePath, destPath);
+                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) {
+        ctx.logger.error(`[PD] Failed to initialize state templates: ${String(err)}`);
+    }
+}

package/dist/core/migration.d.ts

@@ -0,0 +1,6 @@
+import type { OpenClawPluginApi } from '../openclaw-sdk.js';
+/**
+ * Handles migration of Principles Disciple files from legacy directories
+ * (docs/ and memory/.state/) to the new hidden directory structure (.principles/ and .state/).
+ */
+export declare function migrateDirectoryStructure(api: OpenClawPluginApi, workspaceDir: string): void;

package/dist/core/migration.js

@@ -0,0 +1,90 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { resolvePdPath } from './paths.js';
+/**
+ * Handles migration of Principles Disciple files from legacy directories
+ * (docs/ and memory/.state/) to the new hidden directory structure (.principles/ and .state/).
+ */
+export function migrateDirectoryStructure(api, workspaceDir) {
+    try {
+        const legacyDocsDir = path.join(workspaceDir, 'docs');
+        const legacyStateDir = path.join(workspaceDir, 'memory', '.state');
+        // Comprehensive migration map covering ALL legacy locations
+        const migrationMap = [
+            // From docs/
+            { legacy: path.join(legacyDocsDir, 'PROFILE.json'), newKey: 'PROFILE' },
+            { legacy: path.join(legacyDocsDir, 'PRINCIPLES.md'), newKey: 'PRINCIPLES' },
+            { legacy: path.join(legacyDocsDir, 'THINKING_OS.md'), newKey: 'THINKING_OS' },
+            { legacy: path.join(legacyDocsDir, '00-kernel.md'), newKey: 'KERNEL' },
+            { legacy: path.join(legacyDocsDir, 'DECISION_POLICY.json'), newKey: 'DECISION_POLICY' },
+            { legacy: path.join(legacyDocsDir, 'PLAN.md'), newKey: 'PLAN' },
+            { legacy: path.join(legacyDocsDir, 'evolution_queue.json'), newKey: 'EVOLUTION_QUEUE' },
+            { legacy: path.join(legacyDocsDir, 'AGENT_SCORECARD.json'), newKey: 'AGENT_SCORECARD' },
+            { legacy: path.join(legacyDocsDir, '.pain_flag'), newKey: 'PAIN_FLAG' },
+            { legacy: path.join(legacyDocsDir, 'SYSTEM_CAPABILITIES.json'), newKey: 'SYSTEM_CAPABILITIES' },
+            { legacy: path.join(legacyDocsDir, 'SYSTEM.log'), newKey: 'SYSTEM_LOG' },
+            { legacy: path.join(legacyDocsDir, 'THINKING_OS_CANDIDATES.md'), newKey: 'THINKING_OS_CANDIDATES' },
+            // From memory/.state/ (The hidden legacy state)
+            { legacy: path.join(legacyStateDir, 'pain_dictionary.json'), newKey: 'DICTIONARY' },
+            { legacy: path.join(legacyStateDir, 'pain_settings.json'), newKey: 'PAIN_SETTINGS' },
+            { legacy: path.join(legacyStateDir, 'thinking_os_usage.json'), newKey: 'THINKING_OS_USAGE' },
+            { legacy: path.join(legacyStateDir, 'pain_candidates.json'), newKey: 'PAIN_CANDIDATES' },
+            { legacy: path.join(legacyStateDir, 'evolution_directive.json'), newKey: 'EVOLUTION_QUEUE' },
+            { legacy: path.join(legacyStateDir, 'sessions'), newKey: 'SESSION_DIR' },
+            { legacy: path.join(legacyStateDir, 'logs', 'events.jsonl'), newKey: 'SYSTEM_LOG' }, // Backup plan for logs
+        ];
+        let migratedCount = 0;
+        for (const entry of migrationMap) {
+            if (fs.existsSync(entry.legacy)) {
+                const newPath = resolvePdPath(workspaceDir, entry.newKey);
+                const newDir = path.dirname(newPath);
+                if (!fs.existsSync(newDir)) {
+                    fs.mkdirSync(newDir, { recursive: true });
+                }
+                // If it's a file, rename it. If it's a directory (sessions), handle carefully.
+                if (!fs.existsSync(newPath)) {
+                    try {
+                        fs.renameSync(entry.legacy, newPath);
+                        api.logger.info(`[PD:Migration] Migrated ${path.basename(entry.legacy)} to ${newPath.replace(workspaceDir, '')}`);
+                        migratedCount++;
+                    }
+                    catch (renameErr) {
+                        api.logger.error(`[PD:Migration] Failed to rename ${entry.legacy}: ${String(renameErr)}`);
+                    }
+                }
+                else {
+                    // Special case: Log append instead of overwrite if it's SYSTEM_LOG? 
+                    // For now, keep it simple and skip if exists to avoid data corruption.
+                    api.logger?.warn?.(`[PD:Migration] Skipping ${path.basename(entry.legacy)}: already exists at destination.`);
+                }
+            }
+        }
+        if (migratedCount > 0) {
+            api.logger.info(`[PD:Migration] Successfully migrated ${migratedCount} files/folders to new architecture.`);
+        }
+        // Final cleanup: Try to remove legacy state dir if empty
+        if (fs.existsSync(legacyStateDir)) {
+            try {
+                // Check if dir is empty (recursive check not needed here as we moved main subdirs)
+                const items = fs.readdirSync(legacyStateDir);
+                if (items.length === 0 || (items.length === 1 && items[0] === 'logs')) {
+                    // Try to clean up logs dir if empty too
+                    const logsDir = path.join(legacyStateDir, 'logs');
+                    if (fs.existsSync(logsDir) && fs.readdirSync(logsDir).length === 0) {
+                        fs.rmdirSync(logsDir);
+                    }
+                    if (fs.readdirSync(legacyStateDir).length === 0) {
+                        fs.rmdirSync(legacyStateDir);
+                        api.logger.info(`[PD:Migration] Cleaned up empty legacy state directory.`);
+                    }
+                }
+            }
+            catch (_e) {
+                api.logger.debug?.(`[PD:Migration] Failed to cleanup legacy state dir: ${String(_e)}`);
+            }
+        }
+    }
+    catch (err) {
+        api.logger.error(`[PD:Migration] Directory refactor migration failed: ${String(err)}`);
+    }
+}

package/dist/core/pain.d.ts

@@ -0,0 +1,4 @@
+export declare function computePainScore(rc: number, isSpiral: boolean, missingTestCommand: boolean, softScore: number, projectDir?: string): number;
+export declare function painSeverityLabel(painScore: number, isSpiral?: boolean, projectDir?: string): string;
+export declare function writePainFlag(projectDir: string, painData: Record<string, string>): void;
+export declare function readPainFlagData(projectDir: string): Record<string, string>;

package/dist/core/pain.js

@@ -0,0 +1,70 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { serializeKvLines, parseKvLines } from '../utils/io.js';
+import { resolvePdPath } from './paths.js';
+import { ConfigService } from './config-service.js';
+export function computePainScore(rc, isSpiral, missingTestCommand, softScore, projectDir) {
+    let score = Math.max(0, softScore || 0);
+    const stateDir = projectDir ? resolvePdPath(projectDir, 'STATE_DIR') : undefined;
+    const config = stateDir ? ConfigService.get(stateDir) : null;
+    const scoreSettings = config ? config.get('scores') : {
+        exit_code_penalty: 70,
+        spiral_penalty: 40,
+        missing_test_command_penalty: 30
+    };
+    if (rc !== 0) {
+        score += scoreSettings.exit_code_penalty;
+    }
+    if (isSpiral) {
+        score += scoreSettings.spiral_penalty;
+    }
+    if (missingTestCommand) {
+        score += scoreSettings.missing_test_command_penalty;
+    }
+    return Math.min(100, score);
+}
+export function painSeverityLabel(painScore, isSpiral = false, projectDir) {
+    if (isSpiral) {
+        return "critical";
+    }
+    const stateDir = projectDir ? resolvePdPath(projectDir, 'STATE_DIR') : undefined;
+    const config = stateDir ? ConfigService.get(stateDir) : null;
+    const thresholds = config ? config.get('severity_thresholds') : {
+        high: 70,
+        medium: 40,
+        low: 20
+    };
+    if (painScore >= thresholds.high) {
+        return "high";
+    }
+    else if (painScore >= thresholds.medium) {
+        return "medium";
+    }
+    else if (painScore >= thresholds.low) {
+        return "low";
+    }
+    else {
+        return "info";
+    }
+}
+export function writePainFlag(projectDir, painData) {
+    const painFlagPath = resolvePdPath(projectDir, 'PAIN_FLAG');
+    const dir = path.dirname(painFlagPath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(painFlagPath, serializeKvLines(painData), "utf-8");
+}
+export function readPainFlagData(projectDir) {
+    const painFlagPath = resolvePdPath(projectDir, 'PAIN_FLAG');
+    try {
+        if (!fs.existsSync(painFlagPath)) {
+            return {};
+        }
+        const content = fs.readFileSync(painFlagPath, "utf-8");
+        return parseKvLines(content);
+    }
+    catch (e) {
+        return {};
+    }
+}

package/dist/core/path-resolver.d.ts

@@ -0,0 +1,43 @@
+export interface PathResolverOptions {
+    workspaceDir?: string;
+    normalizeWorkspace?: boolean;
+    logger?: {
+        debug?: (msg: string) => void;
+        info?: (msg: string) => void;
+        warn?: (msg: string) => void;
+        error?: (msg: string) => void;
+    };
+}
+export declare const PD_ENV_VARS: {
+    readonly WORKSPACE_DIR: "PD_WORKSPACE_DIR";
+    readonly STATE_DIR: "PD_STATE_DIR";
+    readonly DEBUG: "DEBUG";
+};
+export declare const PD_ENV_DESCRIPTIONS: Record<keyof typeof PD_ENV_VARS, {
+    desc: string;
+    example: string;
+}>;
+export declare function printEnvVarHelp(): void;
+export interface PDConfig {
+    workspace?: string;
+    state?: string;
+    debug?: boolean;
+}
+export declare class PathResolver {
+    private workspaceDir;
+    private stateDir;
+    private readonly logger?;
+    private readonly normalizeWorkspace;
+    private initialized;
+    constructor(options?: PathResolverOptions);
+    private log;
+    private detectWorkspaceDir;
+    private normalizePath;
+    normalizeWorkspacePath(inputPath: string): string;
+    getWorkspaceDir(): string;
+    getStateDir(): string;
+    resolve(key: string): string;
+    ensureStateDir(): void;
+    static createFromHookContext(ctx: any): PathResolver;
+}
+export declare function createDefaultConfig(targetPath?: string): string;