create-principles-disciple 1.78.0 → 1.80.0

package/plugin/dist/utils/workspace-resolver.js

@@ -2,11 +2,17 @@
  * Workspace Directory Resolution Utilities
  *
  * Shared helpers for resolving workspace directories across commands and hooks.
+ *
+ * Hook resolution priority (PRI-259): PD canonical config → OpenClaw fallback.
+ * PD canonical sources: PD_WORKSPACE_DIR env → OPENCLAW_WORKSPACE env →
+ * principles-disciple.json → ~/.openclaw/workspace default.
+ * OpenClaw fallback: ctx.workspaceDir → api.runtime.agent.resolveAgentWorkspaceDir().
  */
 import { validateWorkspaceDir } from '../core/workspace-dir-validation.js';
-import { resolveWorkspaceDir } from '../core/workspace-dir-service.js';
 import { resolveWorkspaceDirFromApi } from '../core/path-resolver.js';
 import * as path from 'path';
+import * as os from 'os';
+import * as fs from 'fs';
 /**
  * Resolve workspace directory for command execution.
  *
@@ -69,12 +75,185 @@ export function resolvePluginCommandWorkspaceDir(ctx, source) {
     throw new Error(`[PD:Command:${source}] CRITICAL: workspaceDir is not set in ctx.workspaceDir or ctx.config.workspaceDir. ` +
         `Commands cannot execute without a valid workspace. Set OPENCLAW_WORKSPACE_DIR env var or ensure the workspace is properly initialized.`);
 }
+const PD_CONFIG_FILENAME = 'principles-disciple.json';
+function loadWorkspaceFromPdConfigFile() {
+    const candidates = [
+        path.join(os.homedir(), '.openclaw', PD_CONFIG_FILENAME),
+        path.join(os.homedir(), '.principles', PD_CONFIG_FILENAME),
+        path.join(process.cwd(), PD_CONFIG_FILENAME),
+    ];
+    for (const configPath of candidates) {
+        if (!fs.existsSync(configPath))
+            continue;
+        try {
+            const raw = fs.readFileSync(configPath, 'utf8');
+            const parsed = JSON.parse(raw);
+            if (parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                if (Object.hasOwn(parsed, 'workspace')) {
+                    const workspaceValue = parsed['workspace'];
+                    if (typeof workspaceValue === 'string' && workspaceValue.trim()) {
+                        return workspaceValue.trim();
+                    }
+                }
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+export function resolveCanonicalWorkspaceDir() {
+    const pdEnv = process.env.PD_WORKSPACE_DIR;
+    if (pdEnv && pdEnv.trim()) {
+        const dir = path.resolve(pdEnv.trim());
+        if (!validateWorkspaceDir(dir)) {
+            return { workspaceDir: dir, source: 'pd_env' };
+        }
+    }
+    const ocEnv = process.env.OPENCLAW_WORKSPACE;
+    if (ocEnv && ocEnv.trim()) {
+        const dir = path.resolve(ocEnv.trim());
+        if (!validateWorkspaceDir(dir)) {
+            return { workspaceDir: dir, source: 'openclaw_env' };
+        }
+    }
+    const configWorkspace = loadWorkspaceFromPdConfigFile();
+    if (configWorkspace) {
+        const dir = path.resolve(configWorkspace);
+        if (!validateWorkspaceDir(dir)) {
+            return { workspaceDir: dir, source: 'pd_config' };
+        }
+    }
+    const defaultDir = path.join(os.homedir(), '.openclaw', 'workspace');
+    if (!validateWorkspaceDir(defaultDir)) {
+        return { workspaceDir: defaultDir, source: 'pd_default' };
+    }
+    return null;
+}
+/**
+ * Resolve only PD explicit sources (env vars + config file), excluding pd_default.
+ * Used by hook resolution to ensure ctx.workspaceDir takes priority over the
+ * hardcoded default fallback.
+ */
+function resolveExplicitPdSources() {
+    const pdEnv = process.env.PD_WORKSPACE_DIR;
+    if (pdEnv && pdEnv.trim()) {
+        const dir = path.resolve(pdEnv.trim());
+        if (!validateWorkspaceDir(dir)) {
+            return { workspaceDir: dir, source: 'pd_env' };
+        }
+    }
+    const ocEnv = process.env.OPENCLAW_WORKSPACE;
+    if (ocEnv && ocEnv.trim()) {
+        const dir = path.resolve(ocEnv.trim());
+        if (!validateWorkspaceDir(dir)) {
+            return { workspaceDir: dir, source: 'openclaw_env' };
+        }
+    }
+    const configWorkspace = loadWorkspaceFromPdConfigFile();
+    if (configWorkspace) {
+        const dir = path.resolve(configWorkspace);
+        if (!validateWorkspaceDir(dir)) {
+            return { workspaceDir: dir, source: 'pd_config' };
+        }
+    }
+    return null;
+}
+function tryResolveFromOpenClawApi(api, agentId) {
+    try {
+        const resolved = api.runtime?.agent?.resolveAgentWorkspaceDir?.(api.config, agentId ?? 'main');
+        if (resolved && !validateWorkspaceDir(resolved)) {
+            return resolved;
+        }
+    }
+    catch {
+        // Fall through
+    }
+    return undefined;
+}
+export function resolveHookWorkspaceDir(ctx, api, source, options) {
+    // Priority 1: PD explicit sources (env vars + config file) — these are
+    // owner-declared and intentionally override the live session context.
+    const resolveExplicit = options?.explicitPdResolver ?? resolveExplicitPdSources;
+    const explicit = resolveExplicit();
+    if (explicit) {
+        let consistencyWarning;
+        if (ctx.workspaceDir) {
+            const normalizedCtx = path.resolve(ctx.workspaceDir);
+            const normalizedExplicit = path.resolve(explicit.workspaceDir);
+            if (normalizedCtx !== normalizedExplicit) {
+                consistencyWarning =
+                    `PD explicit workspace (${explicit.source}: ${explicit.workspaceDir}) ` +
+                        `differs from OpenClaw context (${ctx.workspaceDir}). Using PD explicit.`;
+            }
+        }
+        return {
+            ok: true,
+            workspaceDir: explicit.workspaceDir,
+            source: explicit.source,
+            consistencyWarning,
+        };
+    }
+    // Priority 2: OpenClaw live context — the real session workspace.
+    // This MUST take priority over pd_default (the hardcoded fallback).
+    if (ctx.workspaceDir) {
+        const issue = validateWorkspaceDir(ctx.workspaceDir);
+        if (!issue) {
+            return {
+                ok: true,
+                workspaceDir: ctx.workspaceDir,
+                source: 'openclaw_context',
+            };
+        }
+    }
+    // Priority 3: OpenClaw API resolution
+    const apiResolved = tryResolveFromOpenClawApi(api, ctx.agentId);
+    if (apiResolved) {
+        return {
+            ok: true,
+            workspaceDir: apiResolved,
+            source: 'openclaw_api',
+        };
+    }
+    // Priority 4: pd_default (hardcoded fallback) — only when nothing else works
+    const resolveCanonical = options?.canonicalResolver ?? resolveCanonicalWorkspaceDir;
+    const canonical = resolveCanonical();
+    if (canonical && canonical.source === 'pd_default') {
+        return {
+            ok: true,
+            workspaceDir: canonical.workspaceDir,
+            source: 'pd_default',
+            consistencyWarning: 'Using hardcoded default workspace (~/.openclaw/workspace). ' +
+                'Set PD_WORKSPACE_DIR or create ~/.openclaw/principles-disciple.json for stable resolution.',
+        };
+    }
+    return {
+        ok: false,
+        reason: 'workspace_dir_unresolvable',
+        nextAction: 'Set PD_WORKSPACE_DIR environment variable, create ~/.openclaw/principles-disciple.json ' +
+            'with a "workspace" field, or ensure OpenClaw provides workspaceDir in hook context.',
+        message: `[PD:${source}] Cannot resolve workspace directory from any source. ` +
+            `PD explicit config (PD_WORKSPACE_DIR, principles-disciple.json) ` +
+            `and OpenClaw fallback (ctx.workspaceDir, api.resolveAgentWorkspaceDir, ~/.openclaw/workspace) all failed.`,
+    };
+}
 /**
  * Resolve workspace directory for tool hook execution (safe version).
  * Returns undefined instead of throwing if resolution fails.
+ *
+ * PRI-259: Uses PD canonical config as primary source, OpenClaw as fallback.
  */
-export function resolveToolHookWorkspaceDirSafe(ctx, api, source) {
-    return resolveWorkspaceDir(api, ctx, { source });
+export function resolveToolHookWorkspaceDirSafe(ctx, api, source, options) {
+    const result = resolveHookWorkspaceDir(ctx, api, source, options);
+    if (!result.ok) {
+        api.logger.warn(result.message);
+        return undefined;
+    }
+    if (result.consistencyWarning) {
+        api.logger.warn(`[PD:${source}] ${result.consistencyWarning}`);
+    }
+    return result.workspaceDir;
 }
 export class WorkspaceResolutionError extends Error {
     reason;

package/plugin/package.json

@@ -52,12 +52,12 @@
     "@types/ws": "^8.5.13",
     "@typescript-eslint/eslint-plugin": "^8.58.2",
     "@typescript-eslint/parser": "^8.58.0",
-    "@vitest/coverage-v8": "^4.1.5",
+    "@vitest/coverage-v8": "^4.1.8",
     "esbuild": "^0.28.0",
-    "eslint": "^10.2.1",
+    "eslint": "^10.4.1",
     "jsdom": "^29.1.1",
     "typescript": "^6.0.3",
-    "vitest": "^4.1.5",
+    "vitest": "^4.1.8",
     "ws": "^8.18.0"
   },
   "peerDependencies": {