easy-coding-harness 0.5.0 → 0.5.1

package/CHANGELOG.md

@@ -6,6 +6,12 @@
 - `y`：常规功能升级
 - `z`：日常 bug 修复
 
+## 0.5.1
+
+- 修复 Claude Code hook 命令使用相对路径导致在子目录 cwd 下找不到 `.claude/hooks/*.py` 的问题；Claude、Codex、Qoder 的 hook 配置现在安装时渲染为带引号的绝对脚本路径。
+- `easy-coding upgrade` 可直接刷新存量 0.5.0 项目的 hook 配置并解决该问题；升级后 `ec-init` 合规扫描会校验 hook 配置是否已使用当前版本要求的绝对路径。
+- `easy-coding clear` 和 `install-manifest.json` 兼容新绝对 hook 命令，清理时仍按项目相对 hook 路径识别托管注册项。
+
 ## 0.5.0
 
 - 新增 supermodule 支持：`easy-coding init` 会识别 `.gitmodules`，父仓必装，已检出的一级子仓可按交互或参数选择分层安装。

package/dist/cli.js

@@ -350,7 +350,7 @@ async function writeInstallManifest(cwd, params) {
       const registration = {
         config_path: configPath2,
         command: artifact.command,
-        hook_path: artifact.hookPath,
+        hook_path: artifact.hookPath ? normalizeHookPath(cwd, artifact.hookPath) : null,
         platform: artifact.platform
       };
       hookRegistrations.set(`${configPath2}\0${normalizeCommand(artifact.command)}`, registration);
@@ -465,9 +465,75 @@ function collectHookCommands(hooks) {
   return commands;
 }
 function extractHookPathFromCommand(command) {
-  const match = normalizeCommand(command).match(/(?:^|\s)(\S+\/hooks\/\S+\.py)(?:\s|$)/);
+  return extractQuotedHookPath(command) ?? extractUnquotedHookPath(command);
+}
+function extractQuotedHookPath(command) {
+  for (let index = 0; index < command.length; index += 1) {
+    const quote = command[index];
+    if (quote !== '"' && quote !== "'") {
+      continue;
+    }
+    if (index > 0 && !/\s/.test(command[index - 1])) {
+      continue;
+    }
+    const parsed = parseQuotedToken(command, index, quote);
+    if (!parsed) {
+      continue;
+    }
+    const suffix = readPathSuffix(command, parsed.endIndex);
+    for (const candidate of [parsed.value + suffix, parsed.value]) {
+      if (isHookPythonPath(candidate)) {
+        return candidate;
+      }
+    }
+    index = parsed.endIndex;
+  }
+  return null;
+}
+function parseQuotedToken(command, startIndex, quote) {
+  let value = "";
+  for (let index = startIndex + 1; index < command.length; index += 1) {
+    const char = command[index];
+    if (quote === '"' && char === "\\" && index + 1 < command.length) {
+      value += command[index + 1];
+      index += 1;
+      continue;
+    }
+    if (char === quote) {
+      return { value, endIndex: index + 1 };
+    }
+    value += char;
+  }
+  return null;
+}
+function readPathSuffix(command, startIndex) {
+  if (command[startIndex] !== "/") {
+    return "";
+  }
+  let suffix = "";
+  for (let index = startIndex; index < command.length; index += 1) {
+    const char = command[index];
+    if (/\s/.test(char)) {
+      break;
+    }
+    suffix += char;
+  }
+  return suffix;
+}
+function extractUnquotedHookPath(command) {
+  const match = command.match(/(?:^|\s)(\S+\/hooks\/\S+\.py)(?:\s|$)/);
   return match?.[1] ?? null;
 }
+function isHookPythonPath(candidate) {
+  return /\/hooks\/\S+\.py$/.test(candidate);
+}
+function normalizeHookPath(cwd, hookPath) {
+  const normalized = hookPath.replace(/\\/g, "/").replace(/^\.\//, "");
+  if (path4.isAbsolute(hookPath) || path4.posix.isAbsolute(normalized) || path4.win32.isAbsolute(hookPath)) {
+    return toProjectPath(cwd, hookPath);
+  }
+  return normalized;
+}
 function byPath(a, b) {
   return a.path.localeCompare(b.path);
 }
@@ -696,6 +762,33 @@ function resolvePlaceholders(content, ctx, contentName = "template") {
   }
   return resolved;
 }
+function withInstallPaths(cwd, ctx) {
+  const hooksDir = toPosixPath(path8.resolve(cwd, ctx.platform_config_dir, "hooks"));
+  return {
+    ...ctx,
+    platform_hooks_dir_abs: hooksDir,
+    platform_hooks_dir_shell: jsonStringContent(shellDoubleQuoteArg(hooksDir))
+  };
+}
+function renderHookCommand(cwd, ctx, scriptName, platform = process.platform) {
+  const hooksDir = toPosixPath(path8.resolve(cwd, ctx.platform_config_dir, "hooks"));
+  return `${ctx.python_cmd} ${shellDoubleQuoteArg(hooksDir, platform)}/${scriptName}`;
+}
+function shellDoubleQuoteArg(value, platform = process.platform) {
+  if (platform === "win32") {
+    if (value.includes('"')) {
+      throw new Error("Windows hook paths cannot contain double quotes.");
+    }
+    return `"${value}"`;
+  }
+  return `"${value.replace(/(["\\$`])/g, "\\$1")}"`;
+}
+function toPosixPath(filePath) {
+  return filePath.split(path8.sep).join("/");
+}
+function jsonStringContent(value) {
+  return JSON.stringify(value).slice(1, -1);
+}
 async function resolveSkills(ctx) {
   const skillsRoot = getTemplatePath("common", "skills");
   const entries = await readdir2(skillsRoot);
@@ -851,7 +944,7 @@ function stripTemplateExtension(fileName) {
 async function configureClaude(cwd, opts = {}) {
   const platform = "claude-code";
   const meta = PLATFORM_META[platform];
-  const ctx = meta.templateContext;
+  const ctx = withInstallPaths(cwd, meta.templateContext);
   const dest = path9.join(cwd, ".claude");
   const hookConfigPath = path9.join(cwd, meta.hookConfigFile);
   const artifacts = [];
@@ -889,7 +982,7 @@ import path10 from "path";
 async function configureCodex(cwd, opts = {}) {
   const platform = "codex";
   const meta = PLATFORM_META[platform];
-  const ctx = meta.templateContext;
+  const ctx = withInstallPaths(cwd, meta.templateContext);
   const hookConfigPath = path10.join(cwd, meta.hookConfigFile);
   const artifacts = [];
   artifacts.push(
@@ -1005,7 +1098,7 @@ async function existingManagedSkillArtifacts(skillsDir, skillNames, platform) {
 async function configureQoder(cwd, opts = {}) {
   const platform = "qoder";
   const meta = resolvePlatformMeta(cwd, platform);
-  const ctx = meta.templateContext;
+  const ctx = withInstallPaths(cwd, meta.templateContext);
   const dest = path12.join(cwd, ctx.platform_config_dir);
   const hookConfigPath = path12.join(cwd, meta.hookConfigFile);
   const artifacts = [];
@@ -1770,11 +1863,12 @@ async function buildManifestClearPlan(cwd, agents, manifest) {
     if (!agentSet.has(registration.platform)) {
       continue;
     }
+    const managedHookPaths = registration.hook_path ? managedHookPathsForRegistration(cwd, registration.hook_path) : [];
     addHookConfigPrune(
       plan.pruneHookConfigs,
       plan.pruneHookCommands,
       manifestPath(cwd, registration.config_path),
-      registration.hook_path ? [registration.hook_path] : [],
+      managedHookPaths,
       [registration.command]
     );
   }
@@ -1822,7 +1916,7 @@ async function addTemplateClearEntries(plan, cwd, platform, metas, managedSkills
       plan.pruneHookConfigs,
       plan.pruneHookCommands,
       path16.join(cwd, meta.hookConfigFile),
-      hookFileNames.map((name) => `${meta.templateContext.platform_config_dir}/hooks/${name}`),
+      managedHookPathsForTemplate(cwd, meta, hookFileNames),
       []
     );
     plan.constraints.add(path16.join(cwd, meta.mainConstraint));
@@ -1873,6 +1967,51 @@ function addHookConfigPrune(pruneHookConfigs, pruneHookCommands, filePath, manag
   }
   pruneHookCommands.set(filePath, existingCommands);
 }
+function managedHookPathsForRegistration(cwd, hookPath) {
+  const paths = [hookPath];
+  try {
+    paths.push(...managedHookPathTokens(manifestPath(cwd, hookPath)));
+  } catch {
+    if (path16.isAbsolute(hookPath)) {
+      paths.push(...managedHookPathTokens(hookPath));
+    }
+  }
+  return paths;
+}
+function managedHookPathsForTemplate(cwd, meta, hookFileNames) {
+  const relativePaths = hookFileNames.map(
+    (name) => `${meta.templateContext.platform_config_dir}/hooks/${name}`
+  );
+  const absolutePaths = hookFileNames.flatMap(
+    (name) => managedHookPathTokens(path16.join(cwd, meta.hooksDir, name))
+  );
+  return [...relativePaths, ...absolutePaths];
+}
+function managedHookPathTokens(filePath) {
+  const tokens = /* @__PURE__ */ new Set();
+  for (const equivalentPath of equivalentAbsolutePaths(filePath)) {
+    const normalized = equivalentPath.replace(/\\/g, "/");
+    const dir = path16.posix.dirname(normalized);
+    const basename = path16.posix.basename(normalized);
+    tokens.add(normalized);
+    tokens.add(shellDoubleQuoteArg2(normalized));
+    tokens.add(`${shellDoubleQuoteArg2(dir)}/${basename}`);
+  }
+  return [...tokens];
+}
+function equivalentAbsolutePaths(filePath) {
+  const normalized = path16.resolve(filePath).replace(/\\/g, "/");
+  const equivalents = [normalized];
+  if (normalized.startsWith("/private/var/")) {
+    equivalents.push(normalized.replace(/^\/private\/var\//, "/var/"));
+  } else if (normalized.startsWith("/var/")) {
+    equivalents.push(normalized.replace(/^\/var\//, "/private/var/"));
+  }
+  return equivalents;
+}
+function shellDoubleQuoteArg2(value) {
+  return `"${value.replace(/(["\\$`])/g, "\\$1")}"`;
+}
 function createClearPlan() {
   return {
     remove: /* @__PURE__ */ new Set(),
@@ -2057,7 +2196,7 @@ function isManagedHook(hook, managedHookPaths, managedHookCommands) {
   if (normalizedManagedCommands.includes(normalizeCommand(command))) {
     return true;
   }
-  const normalizedCommand = command.replace(/\\/g, "/");
+  const normalizedCommand = command;
   return managedHookPaths.some(
     (hookPath) => commandContainsPathToken(normalizedCommand, hookPath.replace(/\\/g, "/"))
   );
@@ -2543,8 +2682,35 @@ async function update(opts) {
 }
 
 // src/commands/upgrade.ts
+import path22 from "path";
 import { cancel as cancel5, confirm as confirm4, outro as outro5 } from "@clack/prompts";
 import chalk7 from "chalk";
+var EXPECTED_HOOK_REGISTRATION_SCRIPTS = {
+  "claude-code": [
+    { event: "SessionStart", scriptName: "session-start.py" },
+    { event: "UserPromptSubmit", scriptName: "session-start.py" },
+    { event: "UserPromptSubmit", scriptName: "inject-workflow-state.py" },
+    { event: "PreToolUse", scriptName: "inject-subagent-context.py" }
+  ],
+  codex: [
+    { event: "UserPromptSubmit", scriptName: "session-start.py" },
+    { event: "UserPromptSubmit", scriptName: "inject-workflow-state.py" }
+  ],
+  qoder: [
+    { event: "UserPromptSubmit", scriptName: "session-start.py" },
+    { event: "UserPromptSubmit", scriptName: "inject-workflow-state.py" },
+    { event: "PreToolUse", scriptName: "inject-subagent-context.py" }
+  ]
+};
+var MANAGED_HOOK_SCRIPT_NAMES = {
+  "claude-code": [
+    ...new Set(
+      EXPECTED_HOOK_REGISTRATION_SCRIPTS["claude-code"].map(({ scriptName }) => scriptName)
+    )
+  ],
+  codex: [...new Set(EXPECTED_HOOK_REGISTRATION_SCRIPTS.codex.map(({ scriptName }) => scriptName))],
+  qoder: [...new Set(EXPECTED_HOOK_REGISTRATION_SCRIPTS.qoder.map(({ scriptName }) => scriptName))]
+};
 async function upgrade(opts) {
   renderBanner();
   const cwd = process.cwd();
@@ -2645,12 +2811,149 @@ async function resolvePendingUpgradeTargets(targets) {
         `${target.label} harness version ${installedVersion} is newer than CLI ${VERSION}. Update the CLI first.`
       );
     }
-    if (relation === -1) {
+    if (relation === -1 || relation === 0 && await needsHookConfigRefresh(target, config.agents)) {
       pending.push({ target, config });
     }
   }
   return pending;
 }
+async function needsHookConfigRefresh(target, agents) {
+  const manifest = await readInstallManifest(target.dir);
+  for (const agent of agents) {
+    const meta = resolvePlatformMeta(target.dir, agent);
+    const configPath2 = path22.join(target.dir, meta.hookConfigFile);
+    const content = await readTextIfExists(configPath2);
+    if (content === null) {
+      return true;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(content);
+    } catch {
+      return true;
+    }
+    const commandsByEvent = collectHookCommandsByEvent(parsed.hooks);
+    const commands = [...commandsByEvent.values()].flat();
+    const expectedRegistrations = expectedHookRegistrations(target.dir, meta, agent);
+    const expectedCommandSet = new Set(
+      expectedRegistrations.map((registration) => registration.command)
+    );
+    if (!hasExpectedHookRegistrations(commandsByEvent, expectedRegistrations)) {
+      return true;
+    }
+    const manifestManagedCommands = new Set(
+      manifest?.hook_registrations.filter((registration) => registration.platform === agent).map((registration) => registration.command) ?? []
+    );
+    if (commands.some(
+      (command) => isUnexpectedManagedHookCommand(
+        command,
+        expectedCommandSet,
+        target.dir,
+        meta,
+        agent,
+        manifestManagedCommands
+      )
+    )) {
+      return true;
+    }
+  }
+  return false;
+}
+function expectedHookRegistrations(cwd, meta, platform) {
+  return EXPECTED_HOOK_REGISTRATION_SCRIPTS[platform].map(({ event, scriptName }) => ({
+    event,
+    command: renderHookCommand(cwd, meta.templateContext, scriptName)
+  }));
+}
+function hasExpectedHookRegistrations(commandsByEvent, expectedRegistrations) {
+  const actualCounts = countRegistrations(
+    [...commandsByEvent.entries()].flatMap(
+      ([event, commands]) => commands.map((command) => ({ event, command }))
+    )
+  );
+  const expectedCounts = countRegistrations(expectedRegistrations);
+  return [...expectedCounts.entries()].every(
+    ([registrationKey, expectedCount]) => (actualCounts.get(registrationKey) ?? 0) >= expectedCount
+  );
+}
+function countRegistrations(registrations) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const registration of registrations) {
+    const key = hookRegistrationKey(registration);
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  return counts;
+}
+function hookRegistrationKey(registration) {
+  return `${registration.event}\0${registration.command}`;
+}
+function collectHookCommandsByEvent(hooks) {
+  if (!hooks || typeof hooks !== "object" || Array.isArray(hooks)) {
+    return /* @__PURE__ */ new Map();
+  }
+  const commandsByEvent = /* @__PURE__ */ new Map();
+  for (const [event, value] of Object.entries(hooks)) {
+    if (!Array.isArray(value)) {
+      continue;
+    }
+    for (const group of value) {
+      if (!group || typeof group !== "object") {
+        continue;
+      }
+      const hookItems = group.hooks;
+      if (!Array.isArray(hookItems)) {
+        continue;
+      }
+      for (const hook of hookItems) {
+        if (!hook || typeof hook !== "object") {
+          continue;
+        }
+        const command = hook.command;
+        if (typeof command === "string") {
+          const eventCommands = commandsByEvent.get(event) ?? [];
+          eventCommands.push(command);
+          commandsByEvent.set(event, eventCommands);
+        }
+      }
+    }
+  }
+  return commandsByEvent;
+}
+function isUnexpectedManagedHookCommand(command, expectedCommands, cwd, meta, platform, manifestManagedCommands) {
+  if (expectedCommands.has(command)) {
+    return false;
+  }
+  if (manifestManagedCommands.has(command)) {
+    return true;
+  }
+  const hookPath = extractHookPathFromCommand(command);
+  return hookPath === null ? false : isCurrentProjectManagedHookPath(cwd, hookPath, meta, platform);
+}
+function isCurrentProjectManagedHookPath(cwd, hookPath, meta, platform) {
+  const normalizedHookPath = normalizePathForHookComparison(hookPath);
+  const configDir = normalizePathForHookComparison(meta.templateContext.platform_config_dir);
+  return MANAGED_HOOK_SCRIPT_NAMES[platform].some((scriptName) => {
+    const relativeHookPath = `${configDir}/hooks/${scriptName}`;
+    if (normalizedHookPath === relativeHookPath) {
+      return true;
+    }
+    return pathAliases(
+      normalizePathForHookComparison(path22.resolve(cwd, relativeHookPath))
+    ).includes(normalizedHookPath);
+  });
+}
+function normalizePathForHookComparison(value) {
+  return value.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function pathAliases(value) {
+  const aliases = /* @__PURE__ */ new Set([value]);
+  if (value.startsWith("/private/var/")) {
+    aliases.add(value.replace(/^\/private\/var\//, "/var/"));
+  } else if (value.startsWith("/var/")) {
+    aliases.add(`/private${value}`);
+  }
+  return [...aliases];
+}
 async function resolveParentTopologyRefresh(targets, pending) {
   const parent = targets.find(
     (target) => target.label === "." && target.supermodule.role === "super-parent"