principles-disciple 1.8.1 → 1.8.2

package/dist/utils/io.js

@@ -1,106 +0,0 @@
-import * as path from 'path';
-import * as fs from 'fs';
-import { resolvePdPath } from '../core/paths.js';
-export function normalizePath(filePath, projectDir) {
-    if (!filePath)
-        return '';
-    const projectIsWin = projectDir.includes('\\') || (projectDir.length >= 2 && projectDir[1] === ':');
-    const fileIsWin = filePath.includes('\\') || (filePath.length >= 2 && filePath[1] === ':');
-    let normalizedFilePath = filePath;
-    if (projectIsWin !== fileIsWin) {
-        if (fileIsWin) {
-            // Basic WSL conversion D:\path -> /mnt/d/path
-            normalizedFilePath = `/mnt/${filePath.charAt(0).toLowerCase()}${filePath.slice(2).replace(/\\/g, '/')}`;
-        }
-    }
-    let rel;
-    if (projectIsWin) {
-        const projectAbs = path.resolve(projectDir);
-        const fileAbs = path.isAbsolute(normalizedFilePath) ? normalizedFilePath : path.join(projectAbs, normalizedFilePath);
-        rel = path.relative(projectAbs, fileAbs);
-    }
-    else {
-        const projectPosix = projectDir.replace(/\\/g, '/');
-        const filePosix = path.isAbsolute(normalizedFilePath) ? normalizedFilePath : path.posix.join(projectPosix, normalizedFilePath.replace(/\\/g, '/'));
-        rel = path.posix.relative(projectPosix, filePosix);
-    }
-    rel = rel.replace(/\\/g, '/');
-    if (rel.startsWith('../')) {
-        return normalizedFilePath;
-    }
-    return rel;
-}
-export function normalizeRiskPath(p) {
-    let normalized = p.replace(/\\/g, '/');
-    if (normalized.endsWith('/')) {
-        normalized = normalized.slice(0, -1);
-    }
-    return normalized;
-}
-export function isRisky(relPath, riskPaths) {
-    if (!relPath || !riskPaths || riskPaths.length === 0)
-        return false;
-    const normalizedRel = normalizeRiskPath(relPath);
-    for (const pattern of riskPaths) {
-        const normalizedPattern = normalizeRiskPath(pattern);
-        if (normalizedRel.startsWith(normalizedPattern)) {
-            // If it starts with the pattern, and either they are exactly equal OR the next char is a slash
-            // (prevents "src/db_backup" matching "src/db")
-            if (normalizedRel === normalizedPattern || normalizedRel.charAt(normalizedPattern.length) === '/') {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-export function parseKvLines(text) {
-    const result = {};
-    const lines = text.split('\n');
-    for (const line of lines) {
-        const idx = line.indexOf(':');
-        if (idx !== -1) {
-            const key = line.slice(0, idx).trim();
-            const value = line.slice(idx + 1).trim();
-            result[key] = value;
-        }
-    }
-    return result;
-}
-export function serializeKvLines(data) {
-    const lines = [];
-    const keys = Object.keys(data).sort();
-    for (const k of keys) {
-        const v = data[k];
-        if (Array.isArray(v)) {
-            lines.push(`${k}: ${v.join(',')}`);
-        }
-        else if (typeof v === 'object' && v !== null) {
-            lines.push(`${k}: ${JSON.stringify(v)}`);
-        }
-        else {
-            lines.push(`${k}: ${v}`);
-        }
-    }
-    return lines.join('\n');
-}
-export function planStatus(projectDir) {
-    const planPath = resolvePdPath(projectDir, 'PLAN');
-    try {
-        if (!fs.existsSync(planPath))
-            return '';
-        const content = fs.readFileSync(planPath, 'utf8');
-        const lines = content.split('\n');
-        for (const line of lines) {
-            if (line.startsWith('STATUS:')) {
-                const parts = line.split(':');
-                if (parts.length > 1) {
-                    return parts[1].trim().split(/\s+/)[0] || '';
-                }
-            }
-        }
-    }
-    catch (e) {
-        // Ignore read errors
-    }
-    return '';
-}

package/dist/utils/nlp.d.ts

@@ -1,9 +0,0 @@
-/**
- * Extracts common phrases (N-grams) that appear in a majority of the given samples.
- */
-export declare function extractCommonPhrases(samples: string[], minOccurrence?: number): string[];
-/**
- * Extracts the longest common substring present in a high percentage of samples.
- * Suitable for Chinese or languages without clear word boundaries.
- */
-export declare function extractCommonSubstring(samples: string[], minLen?: number): string[];

package/dist/utils/plugin-logger.d.ts

@@ -1,39 +0,0 @@
-export interface PluginLogger {
-    info(message: string, meta?: Record<string, unknown>): void;
-    warn(message: string, meta?: Record<string, unknown>): void;
-    error(message: string, meta?: Record<string, unknown>): void;
-    debug(message: string, meta?: Record<string, unknown>): void;
-}
-export interface PluginLoggerConfig {
-    /** Directory to store log files (typically stateDir) */
-    logDir: string;
-    /** Plugin identifier for log file naming */
-    pluginId: string;
-    /** Console logger from OpenClaw API (for dual output) */
-    consoleLogger?: PluginLogger;
-    /** Whether to also output to console */
-    echoToConsole?: boolean;
-}
-/**
- * Creates a plugin-specific logger that writes to its own log file.
- *
- * Log file location: {logDir}/logs/{pluginId}.log
- *
- * Example:
- * ```
- * const logger = createPluginLogger({
- *   logDir: stateDir,  // e.g. ~/.openclaw/
- *   pluginId: 'principles-disciple',
- *   consoleLogger: api.logger,
- *   echoToConsole: true
- * });
- *
- * logger.info('Evolution task completed', { taskId: 'abc123' });
- * ```
- */
-export declare function createPluginLogger(config: PluginLoggerConfig): PluginLogger;
-/**
- * Log file path for the plugin.
- * Returns the path where plugin logs are stored.
- */
-export declare function getPluginLogPath(logDir: string, pluginId: string): string;

package/dist/utils/subagent-probe.d.ts

@@ -1,34 +0,0 @@
-/**
- * Subagent Runtime Availability Probe
- *
- * OpenClaw has two runtime modes:
- * - Gateway mode: api.runtime.subagent methods are real async functions
- * - Embedded mode: api.runtime.subagent is a Proxy that throws synchronously
- *
- * This utility provides a reliable way to detect which mode we're in.
- */
-import type { OpenClawPluginApi } from '../openclaw-sdk.js';
-type SubagentRuntime = NonNullable<OpenClawPluginApi['runtime']>['subagent'];
-/**
- * Check if the subagent runtime is actually functional.
- *
- * In gateway mode, subagent.run is an AsyncFunction (constructor.name === 'AsyncFunction').
- * In embedded mode, subagent.run is a regular Function that throws synchronously.
- *
- * We use constructor check first because it's fast and has no side effects.
- *
- * @param subagent - The subagent runtime object from api.runtime.subagent
- * @returns true if the runtime is functional (gateway mode), false otherwise
- */
-export declare function isSubagentRuntimeAvailable(subagent: {
-    run?: unknown;
-} | undefined): boolean;
-/**
- * Get the actual subagent runtime, preferring the global gateway subagent
- * if the passed one is not available.
- *
- * This is useful for cases where the plugin was loaded with allowGatewaySubagentBinding
- * but the late-binding proxy isn't resolving correctly.
- */
-export declare function getAvailableSubagentRuntime(subagent: SubagentRuntime | undefined): SubagentRuntime | undefined;
-export {};

package/dist/utils/subagent-probe.js

@@ -1,81 +0,0 @@
-/**
- * Subagent Runtime Availability Probe
- *
- * OpenClaw has two runtime modes:
- * - Gateway mode: api.runtime.subagent methods are real async functions
- * - Embedded mode: api.runtime.subagent is a Proxy that throws synchronously
- *
- * This utility provides a reliable way to detect which mode we're in.
- */
-/**
- * Try to access the global gateway subagent runtime.
- * This is a fallback for cases where the plugin was loaded with
- * allowGatewaySubagentBinding but the late-binding proxy isn't working.
- */
-function getGlobalGatewaySubagent() {
-    try {
-        // Access the global symbol that OpenClaw uses for gateway subagent
-        const symbol = Symbol.for('openclaw.plugin.gatewaySubagentRuntime');
-        const globalState = globalThis[symbol];
-        return globalState?.subagent ?? null;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Check if the subagent runtime is actually functional.
- *
- * In gateway mode, subagent.run is an AsyncFunction (constructor.name === 'AsyncFunction').
- * In embedded mode, subagent.run is a regular Function that throws synchronously.
- *
- * We use constructor check first because it's fast and has no side effects.
- *
- * @param subagent - The subagent runtime object from api.runtime.subagent
- * @returns true if the runtime is functional (gateway mode), false otherwise
- */
-export function isSubagentRuntimeAvailable(subagent) {
-    if (!subagent)
-        return false;
-    try {
-        const runFn = subagent.run;
-        if (typeof runFn !== 'function')
-            return false;
-        // In gateway mode, methods are AsyncFunction instances
-        // In embedded mode, methods are regular Function instances that throw
-        const isAsync = runFn.constructor?.name === 'AsyncFunction';
-        if (isAsync)
-            return true;
-        // Fallback: Check if it's a Proxy that might late-bind to the gateway subagent
-        // This handles the case where the plugin was loaded with allowGatewaySubagentBinding
-        // but the proxy hasn't resolved yet
-        const globalGateway = getGlobalGatewaySubagent();
-        if (globalGateway && typeof globalGateway.run === 'function') {
-            return globalGateway.run.constructor?.name === 'AsyncFunction';
-        }
-        return false;
-    }
-    catch {
-        // Any error means unavailable
-        return false;
-    }
-}
-/**
- * Get the actual subagent runtime, preferring the global gateway subagent
- * if the passed one is not available.
- *
- * This is useful for cases where the plugin was loaded with allowGatewaySubagentBinding
- * but the late-binding proxy isn't resolving correctly.
- */
-export function getAvailableSubagentRuntime(subagent) {
-    // First check if the passed subagent is available
-    if (isSubagentRuntimeAvailable(subagent)) {
-        return subagent;
-    }
-    // Fallback to global gateway subagent
-    const globalGateway = getGlobalGatewaySubagent();
-    if (globalGateway && isSubagentRuntimeAvailable(globalGateway)) {
-        return globalGateway;
-    }
-    return undefined;
-}