ai-project-manage-cli 6.0.37 → 6.0.39

package/dist/index.js

@@ -84,13 +84,55 @@ import { join as join3 } from "path";
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
 
 // src/command-utils.ts
-import { cpSync, existsSync, mkdirSync as mkdirSync2, readdirSync, statSync } from "fs";
-import { basename, dirname, extname, join as join2, resolve } from "path";
+import { copyFileSync, existsSync, mkdirSync as mkdirSync2, readdirSync, statSync } from "fs";
+import { basename, dirname, extname, join as join2, resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
+
+// src/workdir-path.ts
+import { realpathSync } from "fs";
+import { platform } from "os";
+import { resolve } from "path";
+function toFsPath(inputPath) {
+  const absolute = resolve(inputPath);
+  if (platform() !== "win32") return absolute;
+  if (absolute.startsWith("\\\\?\\")) return absolute;
+  const normalized = absolute.replace(/\//g, "\\");
+  if (normalized.startsWith("\\\\")) {
+    return `\\\\?\\UNC\\${normalized.slice(2)}`;
+  }
+  return `\\\\?\\${normalized}`;
+}
+function normalizeWorkdirPath(path10) {
+  let normalized = path10.trim().replace(/\\/g, "/").normalize("NFC");
+  if (normalized.startsWith("//?/")) {
+    normalized = normalized.slice(4);
+  }
+  const windowsDrive = /^([A-Za-z]:)\/*(.*)$/.exec(normalized);
+  if (windowsDrive) {
+    const drive = windowsDrive[1].toLowerCase();
+    const rest = windowsDrive[2].replace(/\/+/g, "/").replace(/\/$/, "");
+    return rest ? `${drive}/${rest}` : drive;
+  }
+  normalized = normalized.replace(/\/+/g, "/");
+  if (normalized.length > 1 && normalized.endsWith("/")) {
+    normalized = normalized.slice(0, -1);
+  }
+  return normalized;
+}
+function resolveWorkdirPath(cwd = process.cwd()) {
+  const absolute = resolve(cwd);
+  try {
+    return normalizeWorkdirPath(realpathSync.native(absolute));
+  } catch {
+    return normalizeWorkdirPath(absolute);
+  }
+}
+
+// src/command-utils.ts
 var __dirname = dirname(fileURLToPath(import.meta.url));
-var CLI_TEMPLATE_DIR = resolve(__dirname, "../template");
-function workspaceApmDir(cwd = process.cwd()) {
-  return resolve(cwd, ".apm");
+var CLI_TEMPLATE_DIR = resolve2(__dirname, "../template");
+function workspaceApmDir(cwd = resolveWorkdirPath()) {
+  return resolve2(resolve2(cwd), ".apm");
 }
 var SESSIONS_SUBDIR = "sessions";
 var SESSION_DOCS_SUBDIR = "docs";
@@ -147,78 +189,106 @@ async function ensureLoggedConfig() {
 async function ensureDirExists(dir) {
   mkdirSync2(dir, { recursive: true });
 }
-async function ensureWorkspaceApmDirForInit() {
-  const dir = workspaceApmDir();
-  if (!existsSync(dir)) {
-    mkdirSync2(dir, { recursive: true });
+async function ensureWorkspaceApmDirForInit(cwd = resolveWorkdirPath()) {
+  const dir = workspaceApmDir(cwd);
+  const fsDir = toFsPath(dir);
+  if (!existsSync(fsDir)) {
+    mkdirSync2(fsDir, { recursive: true });
     return;
   }
-  const st = statSync(dir);
+  const st = statSync(fsDir);
   if (!st.isDirectory()) {
     throw new Error(`[apm] \u8DEF\u5F84\u5DF2\u5B58\u5728\u4F46\u4E0D\u662F\u76EE\u5F55: ${dir}`);
   }
-  if (readdirSync(dir).length > 0) {
+  if (readdirSync(fsDir).length > 0) {
     throw new Error(
       "[apm] .apm \u76EE\u5F55\u5DF2\u5B58\u5728\u4E14\u975E\u7A7A\uFF0C\u8BF7\u5148\u5907\u4EFD\u3001\u6E05\u7A7A\u6216\u5220\u9664\u540E\u518D\u6267\u884C init"
     );
   }
 }
-async function copyTemplateFiles(targetDir) {
-  if (!existsSync(CLI_TEMPLATE_DIR)) {
-    throw new Error(`[apm] \u672A\u627E\u5230 CLI \u6A21\u677F\u76EE\u5F55: ${CLI_TEMPLATE_DIR}`);
-  }
-  const dirStat = statSync(CLI_TEMPLATE_DIR);
-  if (!dirStat.isDirectory()) {
-    throw new Error(`[apm] CLI \u6A21\u677F\u8DEF\u5F84\u4E0D\u662F\u76EE\u5F55: ${CLI_TEMPLATE_DIR}`);
+var WORKSPACE_TEMPLATE_SUBDIRS = [
+  "sessions",
+  "skills",
+  "rules",
+  "deploy"
+];
+function shouldSkipTemplateEntry(name) {
+  return name === ".DS_Store" || name === "Thumbs.db";
+}
+function copyTemplateEntry(src, dest) {
+  const fsSrc = toFsPath(src);
+  const fsDest = toFsPath(dest);
+  const st = statSync(fsSrc);
+  if (st.isDirectory()) {
+    mkdirSync2(fsDest, { recursive: true });
+    for (const name of readdirSync(fsSrc)) {
+      if (shouldSkipTemplateEntry(name)) continue;
+      copyTemplateEntry(join2(src, name), join2(dest, name));
+    }
+    return;
   }
-  const entries = readdirSync(CLI_TEMPLATE_DIR);
-  if (entries.length === 0) {
-    throw new Error(`[apm] CLI \u6A21\u677F\u76EE\u5F55\u4E3A\u7A7A: ${CLI_TEMPLATE_DIR}`);
+  if (!st.isFile()) return;
+  mkdirSync2(toFsPath(dirname(dest)), { recursive: true });
+  copyFileSync(fsSrc, fsDest);
+}
+function assertTemplateCopiedToApm(apmDir, workdir) {
+  const required = [
+    "AGENTS.md",
+    "apm.config.json",
+    "rules",
+    "skills",
+    "sessions"
+  ];
+  for (const item of required) {
+    const path10 = join2(apmDir, item);
+    if (!existsSync(toFsPath(path10))) {
+      throw new Error(`[apm] \u521D\u59CB\u5316\u4E0D\u5B8C\u6574\uFF0C\u7F3A\u5C11: ${path10}`);
+    }
   }
-  for (const name of entries) {
-    const src = join2(CLI_TEMPLATE_DIR, name);
-    const dest = join2(targetDir, name);
-    cpSync(src, dest, { recursive: true, force: false });
+  const leakedRules = join2(workdir, "rules");
+  const apmRules = join2(apmDir, "rules");
+  if (existsSync(toFsPath(leakedRules)) && !existsSync(toFsPath(join2(apmRules, "reply.md")))) {
+    throw new Error(
+      `[apm] \u6A21\u677F\u88AB\u590D\u5236\u5230\u9519\u8BEF\u4F4D\u7F6E: ${leakedRules}\uFF08\u5E94\u5728 ${apmRules}\uFF09`
+    );
   }
 }
-
-// src/workdir-path.ts
-import { realpathSync } from "fs";
-import { resolve as resolve2 } from "path";
-function normalizeWorkdirPath(path10) {
-  let normalized = path10.trim().replace(/\\/g, "/").normalize("NFC");
-  if (normalized.startsWith("//?/")) {
-    normalized = normalized.slice(4);
+async function copyTemplateFiles(targetDir, workdir = resolveWorkdirPath()) {
+  const resolvedTarget = resolve2(targetDir);
+  const templateDir = resolve2(CLI_TEMPLATE_DIR);
+  const fsTemplateDir = toFsPath(templateDir);
+  if (!existsSync(fsTemplateDir)) {
+    throw new Error(`[apm] \u672A\u627E\u5230 CLI \u6A21\u677F\u76EE\u5F55: ${templateDir}`);
   }
-  const windowsDrive = /^([A-Za-z]:)\/*(.*)$/.exec(normalized);
-  if (windowsDrive) {
-    const drive = windowsDrive[1].toLowerCase();
-    const rest = windowsDrive[2].replace(/\/+/g, "/").replace(/\/$/, "");
-    return rest ? `${drive}/${rest}` : drive;
+  const dirStat = statSync(fsTemplateDir);
+  if (!dirStat.isDirectory()) {
+    throw new Error(`[apm] CLI \u6A21\u677F\u8DEF\u5F84\u4E0D\u662F\u76EE\u5F55: ${templateDir}`);
   }
-  normalized = normalized.replace(/\/+/g, "/");
-  if (normalized.length > 1 && normalized.endsWith("/")) {
-    normalized = normalized.slice(0, -1);
+  const entries = readdirSync(fsTemplateDir).filter(
+    (name) => !shouldSkipTemplateEntry(name)
+  );
+  if (entries.length === 0) {
+    throw new Error(`[apm] CLI \u6A21\u677F\u76EE\u5F55\u4E3A\u7A7A: ${templateDir}`);
   }
-  return normalized;
-}
-function resolveWorkdirPath(cwd = process.cwd()) {
-  const absolute = resolve2(cwd);
-  try {
-    return normalizeWorkdirPath(realpathSync.native(absolute));
-  } catch {
-    return normalizeWorkdirPath(absolute);
+  mkdirSync2(toFsPath(resolvedTarget), { recursive: true });
+  for (const name of entries) {
+    copyTemplateEntry(join2(templateDir, name), join2(resolvedTarget, name));
+  }
+  for (const subdir of WORKSPACE_TEMPLATE_SUBDIRS) {
+    mkdirSync2(toFsPath(join2(resolvedTarget, subdir)), { recursive: true });
   }
+  assertTemplateCopiedToApm(resolvedTarget, resolve2(workdir));
 }
 
 // src/commands/init.ts
 async function runInit(name) {
-  await ensureWorkspaceApmDirForInit();
-  const apmDir = workspaceApmDir();
-  await copyTemplateFiles(apmDir);
+  const workdir = resolveWorkdirPath();
+  await ensureWorkspaceApmDirForInit(workdir);
+  const apmDir = workspaceApmDir(workdir);
+  await copyTemplateFiles(apmDir, workdir);
   const trimmedName = name?.trim();
   if (trimmedName) {
-    const apmConfigPath = join3(apmDir, "apm.config.json");
+    const apmConfigPath = toFsPath(join3(apmDir, "apm.config.json"));
     const config = readFileSync2(apmConfigPath, "utf8");
     const configJson = JSON.parse(config);
     configJson.name = trimmedName;
@@ -229,7 +299,6 @@ async function runInit(name) {
       "utf8"
     );
   }
-  const workdir = resolveWorkdirPath();
   console.log(`[apm] \u5DF2\u521D\u59CB\u5316\u5DE5\u4F5C\u533A\uFF1A${apmDir}`);
   console.log(`[apm] \u5DE5\u4F5C\u76EE\u5F55\u8DEF\u5F84\uFF1A${workdir}`);
   console.log("[apm] \u8BF7\u5728\u5E73\u53F0\u300C\u5BA2\u6237\u673A\u7BA1\u7406 \u2192 \u5DE5\u4F5C\u7A7A\u95F4\u300D\u767B\u8BB0\u4E0A\u8FF0\u76EE\u5F55\u8DEF\u5F84");
@@ -245,10 +314,12 @@ import { createApiClient } from "listpage-http";
 import { defineEndpoint } from "listpage-http";
 var requestConfig = {
   cli: {
-    me: defineEndpoint({
-      method: "GET",
-      path: "/cli/me"
-    }),
+    me: defineEndpoint(
+      {
+        method: "GET",
+        path: "/cli/me"
+      }
+    ),
     sessionDetail: defineEndpoint({
       method: "GET",
       path: "/cli/sessions/detail"
@@ -298,6 +369,10 @@ var requestConfig = {
     listSkills: defineEndpoint({
       method: "GET",
       path: "/cli/skills"
+    }),
+    listRules: defineEndpoint({
+      method: "GET",
+      path: "/cli/rules"
     })
   }
 };
@@ -535,8 +610,8 @@ async function runBranch(sessionId, options = {}) {
 }
 
 // src/commands/pull.ts
-import { writeFileSync as writeFileSync4 } from "fs";
-import { join as join5 } from "path";
+import { writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname2, join as join7 } from "path";
 import { stringify as yamlStringify } from "yaml";
 
 // src/session-messages-xml.ts
@@ -644,7 +719,201 @@ async function syncSessionAttachments(cfg, sessionId, attachments, apmRoot) {
   saveManifest(dir, nextManifest);
 }
 
+// src/rules-sync.ts
+import { basename as basename2, extname as extname2, join as join6 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync4, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "fs";
+
+// src/skills-sync.ts
+import {
+  copyFileSync as copyFileSync2,
+  cpSync,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync3,
+  readdirSync as readdirSync2,
+  rmSync,
+  statSync as statSync2,
+  writeFileSync as writeFileSync4
+} from "fs";
+import { join as join5 } from "path";
+var AGENTS_TEMPLATE_PATH = join5(CLI_TEMPLATE_DIR, "AGENTS.md");
+var BASE_SKILLS_TEMPLATE_DIR = join5(CLI_TEMPLATE_DIR, "skills");
+var BASE_RULES_TEMPLATE_DIR = join5(CLI_TEMPLATE_DIR, "rules");
+function sanitizeSkillDirName(name) {
+  const trimmed = name.trim();
+  if (!trimmed) return "skill";
+  return trimmed.replace(/[/\\:*?"<>|]/g, "_");
+}
+function listBaseSkillDirNames() {
+  if (!existsSync3(BASE_SKILLS_TEMPLATE_DIR)) return [];
+  return readdirSync2(BASE_SKILLS_TEMPLATE_DIR).filter((name) => {
+    const path10 = join5(BASE_SKILLS_TEMPLATE_DIR, name);
+    return statSync2(path10).isDirectory();
+  });
+}
+function syncAgentsGuide(apmDir) {
+  if (!existsSync3(AGENTS_TEMPLATE_PATH)) return false;
+  mkdirSync3(apmDir, { recursive: true });
+  copyFileSync2(AGENTS_TEMPLATE_PATH, join5(apmDir, "AGENTS.md"));
+  return true;
+}
+function listBaseRuleFileNames() {
+  if (!existsSync3(BASE_RULES_TEMPLATE_DIR)) return [];
+  return readdirSync2(BASE_RULES_TEMPLATE_DIR).filter((name) => {
+    const path10 = join5(BASE_RULES_TEMPLATE_DIR, name);
+    return statSync2(path10).isFile();
+  });
+}
+function syncBaseRules(rulesDir) {
+  mkdirSync3(rulesDir, { recursive: true });
+  const names = listBaseRuleFileNames();
+  for (const name of names) {
+    const src = join5(BASE_RULES_TEMPLATE_DIR, name);
+    const dest = join5(rulesDir, name);
+    copyFileSync2(src, dest);
+  }
+  return names;
+}
+function syncBaseSkills(skillsDir) {
+  mkdirSync3(skillsDir, { recursive: true });
+  const names = listBaseSkillDirNames();
+  for (const name of names) {
+    const src = join5(BASE_SKILLS_TEMPLATE_DIR, name);
+    const dest = join5(skillsDir, name);
+    cpSync(src, dest, { recursive: true, force: true });
+  }
+  return names;
+}
+function syncSupplementarySkills(skillsDir, list) {
+  const baseNames = new Set(listBaseSkillDirNames());
+  const apiDirNames = /* @__PURE__ */ new Set();
+  const written = [];
+  const skipped = [];
+  for (const skill of list) {
+    const dirName = sanitizeSkillDirName(skill.name);
+    apiDirNames.add(dirName);
+    if (baseNames.has(dirName)) {
+      skipped.push(dirName);
+      continue;
+    }
+    const skillDir = join5(skillsDir, dirName);
+    mkdirSync3(skillDir, { recursive: true });
+    writeFileSync4(join5(skillDir, "SKILL.md"), skill.content ?? "", "utf8");
+    written.push(dirName);
+  }
+  const removed = [];
+  if (!existsSync3(skillsDir)) return { written, skipped, removed };
+  for (const entry of readdirSync2(skillsDir)) {
+    const full = join5(skillsDir, entry);
+    if (!statSync2(full).isDirectory()) continue;
+    if (baseNames.has(entry)) continue;
+    if (apiDirNames.has(entry)) continue;
+    rmSync(full, { recursive: true, force: true });
+    removed.push(entry);
+  }
+  return { written, skipped, removed };
+}
+
+// src/rules-sync.ts
+var MANIFEST_FILE2 = ".rules-sync-manifest.json";
+function ruleLocalFileName(ruleName) {
+  const trimmed = ruleName.trim();
+  if (!trimmed) return "rule.md";
+  const sanitized = trimmed.replace(/[/\\:*?"<>|]/g, "_");
+  if (extname2(sanitized).toLowerCase() === ".md") return sanitized;
+  return `${sanitized}.md`;
+}
+function loadManifest2(rulesDir) {
+  const path10 = join6(rulesDir, MANIFEST_FILE2);
+  if (!existsSync4(toFsPath(path10))) {
+    return { version: 1, rules: {} };
+  }
+  try {
+    const parsed = JSON.parse(
+      readFileSync4(toFsPath(path10), "utf8")
+    );
+    if (parsed?.version === 1 && parsed.rules && typeof parsed.rules === "object") {
+      return parsed;
+    }
+  } catch {
+  }
+  return { version: 1, rules: {} };
+}
+function saveManifest2(rulesDir, manifest) {
+  writeFileSync5(
+    toFsPath(join6(rulesDir, MANIFEST_FILE2)),
+    `${JSON.stringify(manifest, null, 2)}
+`,
+    "utf8"
+  );
+}
+function isBaseRuleFileName(fileName) {
+  return listBaseRuleFileNames().includes(basename2(fileName));
+}
+function isRuleUpToDate(entry, rule, dest) {
+  if (!entry || !existsSync4(toFsPath(dest))) return false;
+  if (entry.fileName !== ruleLocalFileName(rule.name)) return false;
+  const updatedAt = rule.updatedAt ?? "";
+  if (entry.updatedAt !== updatedAt) return false;
+  const localContent = readFileSync4(toFsPath(dest), "utf8");
+  return localContent === (rule.content ?? "");
+}
+async function syncPlatformRules(cfg, sessionId, workdirPath, apmRoot) {
+  const api = createApmApiClient(cfg);
+  const baseline = await api.cli.branchBaseline({ sessionId, workdirPath });
+  const repositoryId = baseline.repositoryId;
+  const rulesDir = join6(apmRoot ?? workspaceApmDir(workdirPath), "rules");
+  await ensureDirExists(rulesDir);
+  if (!repositoryId) {
+    console.log(
+      `[apm] \u672A\u5339\u914D\u5230\u7ED1\u5B9A\u4ED3\u5E93\u7684\u5DE5\u4F5C\u7A7A\u95F4\uFF0C\u8DF3\u8FC7\u5E73\u53F0\u89C4\u5219\u540C\u6B65\uFF08\u8DEF\u5F84\uFF1A${workdirPath}\uFF09`
+    );
+    return { written: [], skipped: [], removed: [], repositoryId: null };
+  }
+  const { list } = await api.cli.listRules({ repositoryId });
+  const manifest = loadManifest2(rulesDir);
+  const nextManifest = { version: 1, rules: {} };
+  const remoteIds = /* @__PURE__ */ new Set();
+  const written = [];
+  const skipped = [];
+  for (const rule of list) {
+    remoteIds.add(rule.id);
+    const fileName = ruleLocalFileName(rule.name);
+    const dest = join6(rulesDir, fileName);
+    const entry = manifest.rules[rule.id];
+    const updatedAt = rule.updatedAt ?? "";
+    if (isRuleUpToDate(entry, rule, dest)) {
+      nextManifest.rules[rule.id] = entry;
+      skipped.push(fileName);
+      console.log(`[apm] \u89C4\u5219\u65E0\u53D8\u5316\uFF0C\u5DF2\u8DF3\u8FC7: rules/${fileName}`);
+      continue;
+    }
+    writeFileSync5(toFsPath(dest), rule.content ?? "", "utf8");
+    nextManifest.rules[rule.id] = { fileName, updatedAt };
+    written.push(fileName);
+    console.log(`[apm] \u5DF2\u540C\u6B65\u5E73\u53F0\u89C4\u5219: rules/${fileName}`);
+  }
+  const removed = [];
+  for (const [ruleId, entry] of Object.entries(manifest.rules)) {
+    if (remoteIds.has(ruleId)) continue;
+    if (isBaseRuleFileName(entry.fileName)) continue;
+    const dest = join6(rulesDir, entry.fileName);
+    if (existsSync4(toFsPath(dest))) {
+      rmSync2(toFsPath(dest), { force: true });
+    }
+    removed.push(entry.fileName);
+    console.log(`[apm] \u5DF2\u79FB\u9664\u5DF2\u4E0B\u7EBF\u7684\u5E73\u53F0\u89C4\u5219: rules/${entry.fileName}`);
+  }
+  saveManifest2(rulesDir, nextManifest);
+  return { written, skipped, removed, repositoryId };
+}
+
 // src/commands/pull.ts
+function resolvePullWorkdir(apmRoot) {
+  if (apmRoot) {
+    return resolveWorkdirPath(dirname2(apmRoot));
+  }
+  return resolveWorkdirPath();
+}
 async function runPull(sessionId, apmRoot) {
   const trimmedId = sessionId.trim();
   if (!trimmedId) {
@@ -665,20 +934,20 @@ async function runPull(sessionId, apmRoot) {
   const dir = sessionDir(trimmedId, apmRoot);
   const docsDir = sessionDocsDir(trimmedId, apmRoot);
   await ensureDirExists(docsDir);
-  writeFileSync4(
+  writeFileSync6(
     sessionRulePath(trimmedId, apmRoot),
     detail.description ?? "",
     "utf8"
   );
-  writeFileSync4(
+  writeFileSync6(
     sessionTaskPath(trimmedId, apmRoot),
     detail.task.description ?? "",
     "utf8"
   );
-  writeFileSync4(sessionTodoPath(trimmedId, apmRoot), detail.todo ?? "", "utf8");
+  writeFileSync6(sessionTodoPath(trimmedId, apmRoot), detail.todo ?? "", "utf8");
   for (const doc of documents) {
     const fileName = documentLocalFileName(doc.name);
-    writeFileSync4(join5(docsDir, fileName), doc.content ?? "", "utf8");
+    writeFileSync6(join7(docsDir, fileName), doc.content ?? "", "utf8");
   }
   const sessionYaml = yamlStringify(
     {
@@ -695,18 +964,20 @@ async function runPull(sessionId, apmRoot) {
     },
     { lineWidth: 0 }
   );
-  writeFileSync4(
+  writeFileSync6(
     sessionYamlPath(trimmedId, apmRoot),
     sessionYaml.endsWith("\n") ? sessionYaml : `${sessionYaml}
 `,
     "utf8"
   );
-  writeFileSync4(
+  writeFileSync6(
     sessionMessagesXmlPath(trimmedId, apmRoot),
     formatSessionMessagesXml(trimmedId, messages),
     "utf8"
   );
   await syncSessionAttachments(cfg, trimmedId, attachments, apmRoot);
+  const workdirPath = resolvePullWorkdir(apmRoot);
+  await syncPlatformRules(cfg, trimmedId, workdirPath, apmRoot);
   console.log(`[apm] \u5DF2\u540C\u6B65\u4F1A\u8BDD\u5DE5\u4F5C\u533A: ${dir}`);
   return dir;
 }
@@ -715,15 +986,15 @@ async function runPull(sessionId, apmRoot) {
 import { spawnSync } from "child_process";
 
 // src/version.ts
-import { readFileSync as readFileSync4 } from "fs";
-import { dirname as dirname2, join as join6 } from "path";
+import { readFileSync as readFileSync5 } from "fs";
+import { dirname as dirname3, join as join8 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var CLI_PACKAGE_NAME = "ai-project-manage-cli";
 function readCliVersion() {
   try {
-    const dir = dirname2(fileURLToPath2(import.meta.url));
-    const pkgPath = join6(dir, "..", "package.json");
-    const pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
+    const dir = dirname3(fileURLToPath2(import.meta.url));
+    const pkgPath = join8(dir, "..", "package.json");
+    const pkg = JSON.parse(readFileSync5(pkgPath, "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -790,103 +1061,11 @@ async function runUpdate() {
 }
 
 // src/commands/update-skills.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync4, statSync as statSync3 } from "fs";
-import { join as join8 } from "path";
-
-// src/skills-sync.ts
-import {
-  copyFileSync,
-  cpSync as cpSync2,
-  existsSync as existsSync3,
-  mkdirSync as mkdirSync3,
-  readdirSync as readdirSync2,
-  rmSync,
-  statSync as statSync2,
-  writeFileSync as writeFileSync5
-} from "fs";
-import { join as join7 } from "path";
-var AGENTS_TEMPLATE_PATH = join7(CLI_TEMPLATE_DIR, "AGENTS.md");
-var BASE_SKILLS_TEMPLATE_DIR = join7(CLI_TEMPLATE_DIR, "skills");
-var BASE_RULES_TEMPLATE_DIR = join7(CLI_TEMPLATE_DIR, "rules");
-function sanitizeSkillDirName(name) {
-  const trimmed = name.trim();
-  if (!trimmed) return "skill";
-  return trimmed.replace(/[/\\:*?"<>|]/g, "_");
-}
-function listBaseSkillDirNames() {
-  if (!existsSync3(BASE_SKILLS_TEMPLATE_DIR)) return [];
-  return readdirSync2(BASE_SKILLS_TEMPLATE_DIR).filter((name) => {
-    const path10 = join7(BASE_SKILLS_TEMPLATE_DIR, name);
-    return statSync2(path10).isDirectory();
-  });
-}
-function syncAgentsGuide(apmDir) {
-  if (!existsSync3(AGENTS_TEMPLATE_PATH)) return false;
-  mkdirSync3(apmDir, { recursive: true });
-  copyFileSync(AGENTS_TEMPLATE_PATH, join7(apmDir, "AGENTS.md"));
-  return true;
-}
-function listBaseRuleFileNames() {
-  if (!existsSync3(BASE_RULES_TEMPLATE_DIR)) return [];
-  return readdirSync2(BASE_RULES_TEMPLATE_DIR).filter((name) => {
-    const path10 = join7(BASE_RULES_TEMPLATE_DIR, name);
-    return statSync2(path10).isFile();
-  });
-}
-function syncBaseRules(rulesDir) {
-  mkdirSync3(rulesDir, { recursive: true });
-  const names = listBaseRuleFileNames();
-  for (const name of names) {
-    const src = join7(BASE_RULES_TEMPLATE_DIR, name);
-    const dest = join7(rulesDir, name);
-    copyFileSync(src, dest);
-  }
-  return names;
-}
-function syncBaseSkills(skillsDir) {
-  mkdirSync3(skillsDir, { recursive: true });
-  const names = listBaseSkillDirNames();
-  for (const name of names) {
-    const src = join7(BASE_SKILLS_TEMPLATE_DIR, name);
-    const dest = join7(skillsDir, name);
-    cpSync2(src, dest, { recursive: true, force: true });
-  }
-  return names;
-}
-function syncSupplementarySkills(skillsDir, list) {
-  const baseNames = new Set(listBaseSkillDirNames());
-  const apiDirNames = /* @__PURE__ */ new Set();
-  const written = [];
-  const skipped = [];
-  for (const skill of list) {
-    const dirName = sanitizeSkillDirName(skill.name);
-    apiDirNames.add(dirName);
-    if (baseNames.has(dirName)) {
-      skipped.push(dirName);
-      continue;
-    }
-    const skillDir = join7(skillsDir, dirName);
-    mkdirSync3(skillDir, { recursive: true });
-    writeFileSync5(join7(skillDir, "SKILL.md"), skill.content ?? "", "utf8");
-    written.push(dirName);
-  }
-  const removed = [];
-  if (!existsSync3(skillsDir)) return { written, skipped, removed };
-  for (const entry of readdirSync2(skillsDir)) {
-    const full = join7(skillsDir, entry);
-    if (!statSync2(full).isDirectory()) continue;
-    if (baseNames.has(entry)) continue;
-    if (apiDirNames.has(entry)) continue;
-    rmSync(full, { recursive: true, force: true });
-    removed.push(entry);
-  }
-  return { written, skipped, removed };
-}
-
-// src/commands/update-skills.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, statSync as statSync3 } from "fs";
+import { join as join9 } from "path";
 async function runUpdateSkills() {
   const apmDir = workspaceApmDir();
-  if (!existsSync4(apmDir)) {
+  if (!existsSync5(apmDir)) {
     console.error("[apm] \u672A\u627E\u5230 .apm \u76EE\u5F55\uFF0C\u8BF7\u5148\u6267\u884C apm init");
     process.exit(1);
   }
@@ -900,12 +1079,12 @@ async function runUpdateSkills() {
   if (syncAgentsGuide(apmDir)) {
     console.log("[apm] \u5DF2\u540C\u6B65 APM \u6307\u5357: .apm/AGENTS.md");
   }
-  const rulesDir = join8(apmDir, "rules");
+  const rulesDir = join9(apmDir, "rules");
   const ruleNames = syncBaseRules(rulesDir);
   for (const name of ruleNames) {
     console.log(`[apm] \u5DF2\u540C\u6B65\u57FA\u7840\u89C4\u5219: rules/${name}`);
   }
-  const skillsDir = join8(apmDir, "skills");
+  const skillsDir = join9(apmDir, "skills");
   mkdirSync4(skillsDir, { recursive: true });
   const baseNames = syncBaseSkills(skillsDir);
   for (const name of baseNames) {
@@ -932,14 +1111,14 @@ async function runUpdateSkills() {
 }
 
 // src/commands/sync-document.ts
-import { existsSync as existsSync6 } from "fs";
-import { basename as basename2 } from "path";
+import { existsSync as existsSync7 } from "fs";
+import { basename as basename3 } from "path";
 
 // src/commands/sync-session-documents.ts
-import { existsSync as existsSync5, readdirSync as readdirSync3, readFileSync as readFileSync5 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync6, readdirSync as readdirSync3, readFileSync as readFileSync6 } from "fs";
+import { join as join10 } from "path";
 function listLocalMarkdownFiles(docsDir) {
-  if (!existsSync5(docsDir)) {
+  if (!existsSync6(docsDir)) {
     return [];
   }
   return readdirSync3(docsDir).filter(
@@ -954,8 +1133,8 @@ function remoteDocumentByLocalName(remoteDocuments, localFileName) {
   });
 }
 async function upsertLocalDocumentFile(api, sessionId, docsDir, fileName) {
-  const absPath = join9(docsDir, fileName);
-  const content = readFileSync5(absPath, "utf8");
+  const absPath = join10(docsDir, fileName);
+  const content = readFileSync6(absPath, "utf8");
   const name = documentPlatformName(absPath);
   return api.cli.upsertDocument({
     sessionId,
@@ -977,8 +1156,8 @@ async function syncSessionDocuments(cfg, sessionId, apmRoot, options) {
   const remoteDocuments = options?.remoteDocuments ?? await api.cli.listDocuments({ sessionId: trimmedSessionId });
   let synced = 0;
   for (const fileName of localFiles) {
-    const absPath = join9(docsDir, fileName);
-    const content = readFileSync5(absPath, "utf8");
+    const absPath = join10(docsDir, fileName);
+    const content = readFileSync6(absPath, "utf8");
     const remote = remoteDocumentByLocalName(remoteDocuments, fileName);
     if (remote && remote.content === content) {
       continue;
@@ -1011,7 +1190,7 @@ async function runSyncDocument(sessionId, options) {
     process.exit(1);
   }
   const absPath = resolveSessionDocumentPath(trimmedSessionId, fileArg);
-  if (!existsSync6(absPath)) {
+  if (!existsSync7(absPath)) {
     const docsDir2 = sessionDocsDir(trimmedSessionId);
     console.error(
       `[apm] \u6587\u6863\u4E0D\u5B58\u5728: ${absPath}
@@ -1026,7 +1205,7 @@ async function runSyncDocument(sessionId, options) {
     api,
     trimmedSessionId,
     docsDir,
-    basename2(absPath)
+    basename3(absPath)
   );
   console.log(`[apm] \u5DF2\u540C\u6B65\u6587\u6863: ${doc.name} (id=${doc.id})`);
 }
@@ -1904,19 +2083,19 @@ async function runConnect(options) {
 import path5 from "node:path";
 
 // src/commands/deploy/internal/apm-config.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6 } from "node:fs";
+import { existsSync as existsSync8, readFileSync as readFileSync7 } from "node:fs";
 import { resolve as resolve4 } from "node:path";
 function loadApmConfig(options) {
   const p = resolve4(
     process.cwd(),
     options?.configPath ?? resolve4(workspaceApmDir(), "apm.config.json")
   );
-  if (!existsSync7(p)) {
+  if (!existsSync8(p)) {
     console.error(`\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6\uFF1A${p}`);
     process.exit(1);
   }
   try {
-    const raw = readFileSync6(p, "utf8");
+    const raw = readFileSync7(p, "utf8");
     return JSON.parse(raw);
   } catch (e) {
     console.error(`\u65E0\u6CD5\u89E3\u6790 apm.config.json\uFF1A${p}`, e);
@@ -2038,7 +2217,7 @@ import path4 from "node:path";
 import Docker from "dockerode";
 
 // src/commands/deploy/internal/backend-deploy/dockerode-client/connection-options.ts
-import { existsSync as existsSync8, readFileSync as readFileSync7 } from "node:fs";
+import { existsSync as existsSync9, readFileSync as readFileSync8 } from "node:fs";
 import path from "node:path";
 function asOptionalTlsBuffer(value) {
   if (typeof value !== "string") {
@@ -2050,8 +2229,8 @@ function asOptionalTlsBuffer(value) {
   if (normalized === "") {
     return void 0;
   }
-  if (existsSync8(normalized)) {
-    return readFileSync7(normalized);
+  if (existsSync9(normalized)) {
+    return readFileSync8(normalized);
   }
   const looksLikePath = /[\\/]/.test(normalized) || normalized.endsWith(".pem");
   if (looksLikePath) {
@@ -2261,7 +2440,7 @@ var DockerodeClient = class {
 var createDockerodeClient = (config) => new DockerodeClient(config);
 
 // src/commands/deploy/internal/backend-deploy/dockerode-client/env.ts
-import { existsSync as existsSync9, readFileSync as readFileSync8, statSync as statSync4 } from "node:fs";
+import { existsSync as existsSync10, readFileSync as readFileSync9, statSync as statSync4 } from "node:fs";
 import path2 from "node:path";
 function stripSurroundingQuotes(value) {
   const t = value.trim();
@@ -2278,10 +2457,10 @@ function loadEnvFromFile(envFilePath) {
     return {};
   }
   const targetPath = path2.resolve(envFilePath);
-  if (!existsSync9(targetPath) || !statSync4(targetPath).isFile()) {
+  if (!existsSync10(targetPath) || !statSync4(targetPath).isFile()) {
     return {};
   }
-  const raw = readFileSync8(targetPath, "utf-8");
+  const raw = readFileSync9(targetPath, "utf-8");
   const result = {};
   for (const line of raw.split(/\r?\n/)) {
     const normalized = line.trim();
@@ -2346,7 +2525,7 @@ function assertDeployImageTag(tag) {
 }
 
 // src/commands/deploy/internal/backend-deploy/local-docker-build.ts
-import { platform } from "node:os";
+import { platform as platform2 } from "node:os";
 
 // src/commands/deploy/internal/backend-deploy/command-runner.ts
 import { execSync } from "child_process";
@@ -2406,7 +2585,7 @@ var CommandRunner = class {
 
 // src/commands/deploy/internal/backend-deploy/local-docker-build.ts
 function dockerBuildPlatformFlags() {
-  return platform() === "darwin" ? ["--platform", "linux/amd64"] : [];
+  return platform2() === "darwin" ? ["--platform", "linux/amd64"] : [];
 }
 function buildDockerImageLocally(params, cwd) {
   const platformFlags = dockerBuildPlatformFlags();
@@ -2452,12 +2631,12 @@ function dockerPushImage(params, cwd) {
 }
 
 // src/commands/deploy/internal/backend-deploy/resolve-dockerfile.ts
-import { existsSync as existsSync10 } from "node:fs";
+import { existsSync as existsSync11 } from "node:fs";
 import path3 from "node:path";
 function resolveDockerBuildPaths(cwd) {
   const dockerfilePath = path3.join(cwd, "Dockerfile");
   Logger.info(`\u67E5\u627EDockerfile\u6587\u4EF6\uFF0C\u8DEF\u5F84: ${dockerfilePath}`);
-  if (!existsSync10(dockerfilePath)) {
+  if (!existsSync11(dockerfilePath)) {
     throw new Error(`Dockerfile \u4E0D\u5B58\u5728\uFF1A${dockerfilePath}`);
   }
   Logger.info("\u2713 Dockerfile \u5B58\u5728");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-project-manage-cli",
-  "version": "6.0.37",
+  "version": "6.0.39",
   "description": "命令行工具：后续用于调用平台后端 API 完成运维与自动化操作",
   "type": "module",
   "private": false,

package/template/deploy/README.md

@@ -0,0 +1,15 @@
+## 前端部署
+
+部署测试环境： `npm run deploy:test`
+部署线上环境： `npm run deploy:online`
+
+## 后端部署（不区分正式环境和测试环境）
+`python scripts/deploy.py`
+
+## 前端产物下载地址
+
+http://<服务器地址>/dist.zip
+http://<服务器地址>/backend_update_jar.zip
+
+## 测试地址
+http://<测试环境>