@alphalawyer/alpha-classic-cli 0.1.3 → 0.1.4

package/README.md

@@ -118,7 +118,7 @@ alpha-classic-cli install
 默认安装 Codex Skill：
 
 ```text
-~/.codex/skills/alpha-classic-cli/SKILL.md
+~/.codex/skills/alpha-classic/SKILL.md
 ```
 
 用户也可以选择安装目标：
@@ -139,10 +139,12 @@ alpha-classic-cli uninstall --agent alphaclaw
 alpha-classic-cli uninstall --agent all
 ```
 
-Alpha-claw 安装方式会跟随 CLI 构建环境，例如 dev 构建安装到：
+Alpha-claw 安装方式会写入所有已经存在的 AlphaClaw workspace，不会主动创建未安装的环境目录：
 
 ```text
-~/.openclaw-devalphaclaw/workspace/skills/alpha-classic-cli/SKILL.md
+~/.openclaw-devalphaclaw/workspace/skills/alpha-classic/SKILL.md
+~/.openclaw-testalphaclaw/workspace/skills/alpha-classic/SKILL.md
+~/.openclaw-alphaclaw/workspace/skills/alpha-classic/SKILL.md
 ```
 
 Claude Code 安装方式：

package/assets/alpha-classic-skill/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: alpha-classic-cli
+name: alpha-classic
 description: 使用 alpha-classic-cli 查询 Alpha 律所管理系统里的项目、审批等数据。先运行 doctor，优先使用稳定 CLI 命令，不自行猜 REST API。
 ---
 
@@ -7,7 +7,7 @@ description: 使用 alpha-classic-cli 查询 Alpha 律所管理系统里的项
 
 当用户询问 Alpha 律所管理系统里的项目、审批等数据时，优先使用 `alpha-classic-cli`。
 
-如果用户同时安装了 `e-alpha-cli` 项目的 `agent-assistant` skill 和本项目的 `alpha-classic-cli` skill，必须优先使用 `agent-assistant` 及其通过 `alpha-cli skills update` 拉取的服务端动态 skills；只有在这些 skills 不适用、不可用或明确缺少所需能力时，才使用本项目 skill。
+如果用户同时安装了 `e-alpha-cli` 项目的 `alpha-oa` skill 和本项目的 `alpha-classic` skill，必须优先使用 `alpha-oa` 及其通过 `alpha-cli skills update` 拉取的服务端动态 skills；只有在这些 skills 不适用、不可用或明确缺少所需能力时，才使用本项目 skill。
 
 ## 使用顺序
 

package/assets/alpha-classic-skill/references/alpha-classic-shared.md

@@ -2,8 +2,8 @@
 
 ## Skill 优先级
 
-- 如果用户同时安装了 `e-alpha-cli` 项目的 `agent-assistant` skill 和本项目的 `alpha-classic-cli` skill，优先使用 `agent-assistant` 及其通过 `alpha-cli skills update` 拉取的服务端动态 skills。
-- 只有在 `agent-assistant` 及服务端动态 skills 不适用、不可用或明确缺少所需能力时，才使用本项目 skill。
+- 如果用户同时安装了 `e-alpha-cli` 项目的 `alpha-oa` skill 和本项目的 `alpha-classic` skill，优先使用 `alpha-oa` 及其通过 `alpha-cli skills update` 拉取的服务端动态 skills。
+- 只有在 `alpha-oa` 及服务端动态 skills 不适用、不可用或明确缺少所需能力时，才使用本项目 skill。
 
 ## 登录与环境
 

package/dist/index.js

@@ -2049,7 +2049,7 @@ async function runCapabilities(version, sessionStore) {
       "\u5378\u8F7D Claude Code": "alpha-classic-cli uninstall --agent claude",
       "\u5378\u8F7D Alpha-claw": "alpha-classic-cli uninstall --agent alphaclaw",
       "\u5378\u8F7D\u5168\u90E8": "alpha-classic-cli uninstall --agent all",
-      "\u8BF4\u660E": "\u7528\u6237\u81EA\u884C\u9009\u62E9\u5B89\u88C5\u76EE\u6807\uFF1BAlpha-claw \u4F1A\u6309\u5F53\u524D CLI \u73AF\u5883\u5B89\u88C5\u5230\u5BF9\u5E94 .openclaw-<env>alphaclaw \u5DE5\u4F5C\u533A\u3002"
+      "\u8BF4\u660E": "\u7528\u6237\u81EA\u884C\u9009\u62E9\u5B89\u88C5\u76EE\u6807\uFF1BAlpha-claw \u4F1A\u5B89\u88C5\u5230\u6240\u6709\u5DF2\u5B58\u5728\u7684 dev\u3001test\u3001prod AlphaClaw workspace\u3002"
     },
     "\u8F93\u51FA\u534F\u8BAE": {
       "\u6210\u529F": { "ok": true, "data": "\u4E1A\u52A1\u6570\u636E" },
@@ -2349,7 +2349,7 @@ import fs from "fs/promises";
 import path from "path";
 import { fileURLToPath } from "url";
 var __dirname = path.dirname(fileURLToPath(import.meta.url));
-var SKILL_NAME = "alpha-classic-cli";
+var SKILL_NAME = "alpha-classic";
 var SKILL_TEMPLATE_ROOT = resolveAssetPath("alpha-classic-skill");
 var CLAUDE_GUIDE_TEMPLATE = path.join(
   resolveAssetPath("claude"),
@@ -2380,9 +2380,20 @@ async function copyDirectory(source, target) {
 }
 
 // src/install/install.ts
+var ALPHA_CLAW_SKILL_ROOTS = [
+  ".openclaw-devalphaclaw/workspace/skills",
+  ".openclaw-testalphaclaw/workspace/skills",
+  ".openclaw-alphaclaw/workspace/skills"
+];
+var LEGACY_SKILL_NAMES = ["alpha-classic-cli"];
 function resolveCodexSkillPath(homeDir = os2.homedir()) {
   return path2.join(homeDir, ".codex", "skills", SKILL_NAME);
 }
+function resolveLegacyCodexSkillPaths(homeDir = os2.homedir()) {
+  return LEGACY_SKILL_NAMES.map(
+    (skillName) => path2.join(homeDir, ".codex", "skills", skillName)
+  );
+}
 function resolveClaudeGuidePath(homeDir = os2.homedir()) {
   return path2.join(homeDir, ".claude", "alpha-classic-cli.md");
 }
@@ -2390,14 +2401,50 @@ function resolveClaudeMemoryPath(homeDir = os2.homedir()) {
   return path2.join(homeDir, ".claude", "CLAUDE.md");
 }
 function resolveAlphaClawSkillPath(homeDir = os2.homedir(), environmentName = DEFAULT_ENVIRONMENT_NAME) {
+  const environmentRoots = {
+    dev: ".openclaw-devalphaclaw/workspace/skills",
+    test: ".openclaw-testalphaclaw/workspace/skills",
+    prod: ".openclaw-alphaclaw/workspace/skills"
+  };
+  const skillRoot = environmentName === "local" ? environmentRoots.prod : environmentRoots[environmentName];
   return path2.join(
     homeDir,
-    `.openclaw-${environmentName}alphaclaw`,
-    "workspace",
-    "skills",
+    skillRoot,
     SKILL_NAME
   );
 }
+function resolveAlphaClawSkillPaths(homeDir = os2.homedir()) {
+  return ALPHA_CLAW_SKILL_ROOTS.map(
+    (skillRoot) => path2.join(homeDir, skillRoot, SKILL_NAME)
+  );
+}
+async function resolveExistingAlphaClawSkillRoots(homeDir = os2.homedir()) {
+  const skillRoots = ALPHA_CLAW_SKILL_ROOTS.map(
+    (skillRoot) => path2.join(homeDir, skillRoot)
+  );
+  const existingRoots = [];
+  for (const skillRoot of skillRoots) {
+    try {
+      const stat = await fs2.stat(skillRoot);
+      if (stat.isDirectory()) {
+        existingRoots.push(skillRoot);
+      }
+    } catch (error) {
+      const nodeError = error;
+      if (nodeError.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+  return existingRoots;
+}
+async function removeLegacySkillDirs(skillRoot) {
+  await Promise.all(
+    LEGACY_SKILL_NAMES.map(
+      (skillName) => fs2.rm(path2.join(skillRoot, skillName), { recursive: true, force: true })
+    )
+  );
+}
 async function installAgentGuides(options) {
   const agent = options?.agent ?? "codex";
   const result = {
@@ -2417,7 +2464,8 @@ async function installAgentGuides(options) {
     result.claudeMemoryUpdated = claudeResult.claudeMemoryUpdated;
   }
   if (agent === "alphaclaw" || agent === "all") {
-    const alphaClawResult = await installAlphaClawSkill(options);
+    const alphaClawResult = await installAlphaClawSkills(options);
+    result.alphaClawSkillPaths = alphaClawResult.alphaClawSkillPaths;
     result.alphaClawSkillPath = alphaClawResult.alphaClawSkillPath;
     result.alphaClawSkillInstalled = alphaClawResult.alphaClawSkillInstalled;
   }
@@ -2431,6 +2479,11 @@ async function uninstallAgentGuides(options) {
   };
   if (agent === "codex" || agent === "all") {
     await fs2.rm(resolveCodexSkillPath(options?.homeDir), { recursive: true, force: true });
+    await Promise.all(
+      resolveLegacyCodexSkillPaths(options?.homeDir).map(
+        (skillPath) => fs2.rm(skillPath, { recursive: true, force: true })
+      )
+    );
     result.codexSkillInstalled = false;
   }
   if (agent === "claude" || agent === "all") {
@@ -2441,8 +2494,18 @@ async function uninstallAgentGuides(options) {
     result.claudeMemoryUpdated = claudeResult.claudeMemoryUpdated;
   }
   if (agent === "alphaclaw" || agent === "all") {
-    await fs2.rm(resolveAlphaClawSkillPath(options?.homeDir, options?.environmentName), { recursive: true, force: true });
-    result.alphaClawSkillPath = resolveAlphaClawSkillPath(options?.homeDir, options?.environmentName);
+    const alphaClawSkillPaths = resolveAlphaClawSkillPaths(options?.homeDir);
+    await Promise.all(
+      alphaClawSkillPaths.concat(
+        ALPHA_CLAW_SKILL_ROOTS.flatMap(
+          (skillRoot) => LEGACY_SKILL_NAMES.map(
+            (skillName) => path2.join(options?.homeDir ?? os2.homedir(), skillRoot, skillName)
+          )
+        )
+      ).map((skillPath) => fs2.rm(skillPath, { recursive: true, force: true }))
+    );
+    result.alphaClawSkillPaths = alphaClawSkillPaths;
+    result.alphaClawSkillPath = alphaClawSkillPaths[0];
     result.alphaClawSkillInstalled = false;
   }
   return result;
@@ -2450,21 +2513,34 @@ async function uninstallAgentGuides(options) {
 async function installCodexSkill(options) {
   const skillPath = resolveCodexSkillPath(options?.homeDir);
   await fs2.rm(skillPath, { recursive: true, force: true });
+  await Promise.all(
+    resolveLegacyCodexSkillPaths(options?.homeDir).map(
+      (legacySkillPath) => fs2.rm(legacySkillPath, { recursive: true, force: true })
+    )
+  );
   await copyDirectory(SKILL_TEMPLATE_ROOT, skillPath);
   return {
     codexSkillPath: skillPath,
     codexSkillInstalled: true
   };
 }
-async function installAlphaClawSkill(options) {
-  const skillPath = resolveAlphaClawSkillPath(options?.homeDir, options?.environmentName);
-  await fs2.rm(skillPath, { recursive: true, force: true });
-  await copyDirectory(SKILL_TEMPLATE_ROOT, skillPath);
+async function installAlphaClawSkills(options) {
+  const homeDir = options?.homeDir ?? os2.homedir();
+  const skillRoots = await resolveExistingAlphaClawSkillRoots(homeDir);
+  const skillPaths = [];
+  for (const skillRoot of skillRoots) {
+    const skillPath = path2.join(skillRoot, SKILL_NAME);
+    await fs2.rm(skillPath, { recursive: true, force: true });
+    await removeLegacySkillDirs(skillRoot);
+    await copyDirectory(SKILL_TEMPLATE_ROOT, skillPath);
+    skillPaths.push(skillPath);
+  }
   return {
     codexSkillPath: resolveCodexSkillPath(options?.homeDir),
     codexSkillInstalled: false,
-    alphaClawSkillPath: skillPath,
-    alphaClawSkillInstalled: true
+    alphaClawSkillPaths: skillPaths,
+    alphaClawSkillPath: skillPaths[0],
+    alphaClawSkillInstalled: skillPaths.length > 0
   };
 }
 async function installClaudeGuide(options) {
@@ -2514,20 +2590,28 @@ async function inspectInstallState(options) {
   } catch {
     claudeGuideInstalled = false;
   }
-  const alphaClawSkillPath = resolveAlphaClawSkillPath(options?.homeDir, options?.environmentName);
+  const alphaClawSkillPath = resolveAlphaClawSkillPath(
+    options?.homeDir,
+    options?.environmentName
+  );
+  const alphaClawSkillPaths = resolveAlphaClawSkillPaths(options?.homeDir);
+  const installedAlphaClawSkillPaths = [];
   let alphaClawSkillInstalled = false;
-  try {
-    await fs2.access(path2.join(alphaClawSkillPath, "SKILL.md"));
-    alphaClawSkillInstalled = true;
-  } catch {
-    alphaClawSkillInstalled = false;
+  for (const skillPath2 of alphaClawSkillPaths) {
+    try {
+      await fs2.access(path2.join(skillPath2, "SKILL.md"));
+      installedAlphaClawSkillPaths.push(skillPath2);
+    } catch {
+    }
   }
+  alphaClawSkillInstalled = installedAlphaClawSkillPaths.length > 0;
   return {
     codexSkillPath: skillPath,
     codexSkillInstalled: installed,
     claudeGuidePath,
     claudeGuideInstalled,
     claudeMemoryPath: resolveClaudeMemoryPath(options?.homeDir),
+    alphaClawSkillPaths: installedAlphaClawSkillPaths,
     alphaClawSkillPath,
     alphaClawSkillInstalled
   };
@@ -4121,10 +4205,13 @@ async function main() {
 }
 function parseAgentInstallTarget(value) {
   const target = (value ?? "codex").trim().toLowerCase();
+  if (target === "alpha-claw") {
+    return "alphaclaw";
+  }
   if (target === "codex" || target === "claude" || target === "alphaclaw" || target === "all") {
     return target;
   }
-  throw new Error(`Invalid agent target: ${value}. Supported: codex, claude, alphaclaw, all`);
+  throw new Error(`Invalid agent target: ${value}. Supported: codex, claude, alphaclaw, alpha-claw, all`);
 }
 main().catch((error) => {
   printError("runtime", error instanceof Error ? error.message : String(error));