ai-project-manage-cli 6.0.56 → 6.0.58

package/README.md

@@ -27,8 +27,12 @@ apm init [--name=我的项目]
 ```bash
 apm pull <sessionId>
 apm sync-document <sessionId> --file PRD
+apm sync-project-documents
+apm sync-project-documents --push
 apm update-skills
 apm branch <sessionId>
 ```
 
+`apm pull` 会自动将平台登记的**仓库项目文档**同步到 `.apm/project/`（含 `manifest.json`）。Agent 修改 `.apm/project/` 下文件后，`apm connect` 处理完消息会自动推回平台。
+
 详见仓库根目录 [docs/CLI.md](../../docs/CLI.md)。

package/dist/index.js

@@ -457,6 +457,30 @@ var requestConfig = {
     createPullRequest: defineEndpoint({
       method: "POST",
       path: "/cli/pull-requests"
+    }),
+    getRepositoryProjectDocumentManifest: defineEndpoint({
+      method: "GET",
+      path: "/cli/repository-project-documents/manifest"
+    }),
+    listRepositoryProjectDocuments: defineEndpoint({
+      method: "GET",
+      path: "/cli/repository-project-documents"
+    }),
+    upsertRepositoryProjectDocument: defineEndpoint({
+      method: "PUT",
+      path: "/cli/repository-project-documents/upsert"
+    }),
+    removeRepositoryProjectDocument: defineEndpoint({
+      method: "DELETE",
+      path: "/cli/repository-project-documents"
+    }),
+    updateCoordinatorDeploymentStatus: defineEndpoint({
+      method: "PUT",
+      path: "/cli/coordinator-deployments/status"
+    }),
+    completeCoordinatorDeployment: defineEndpoint({
+      method: "PUT",
+      path: "/cli/coordinator-deployments/complete"
     })
   }
 };
@@ -1086,8 +1110,8 @@ async function runCleanBranches(options = {}) {
 }
 
 // src/commands/pull.ts
-import { writeFileSync as writeFileSync8 } from "fs";
-import { join as join8 } from "path";
+import { writeFileSync as writeFileSync9 } from "fs";
+import { join as join9 } from "path";
 import { stringify as yamlStringify } from "yaml";
 
 // src/session-messages-xml.ts
@@ -1383,6 +1407,218 @@ async function syncPlatformRules(cfg, sessionId, workdirPath, apmRoot) {
   return { written, skipped, removed, repositoryId };
 }
 
+// src/repository-project-documents-sync.ts
+import {
+  existsSync as existsSync6,
+  readdirSync as readdirSync3,
+  readFileSync as readFileSync6,
+  rmSync as rmSync3,
+  writeFileSync as writeFileSync8
+} from "fs";
+import { createHash } from "crypto";
+import { dirname as dirname2, join as join8, relative, sep } from "path";
+var MANIFEST_FILE3 = "manifest.json";
+function projectDocumentsDir(apmRoot) {
+  return join8(apmRoot ?? workspaceApmDir(), "project");
+}
+function projectDocumentLocalPath(apmRoot, documentPath) {
+  const normalized = normalizeLocalDocumentPath(documentPath);
+  return join8(projectDocumentsDir(apmRoot), ...normalized.split("/"));
+}
+function normalizeLocalDocumentPath(path10) {
+  const trimmed = path10.trim().replace(/\\/g, "/");
+  if (!trimmed || trimmed.startsWith("/") || /^[a-zA-Z]:/.test(trimmed)) {
+    throw new Error(`\u975E\u6CD5\u6587\u6863\u8DEF\u5F84: ${path10}`);
+  }
+  const segments = trimmed.split("/").filter(Boolean);
+  if (segments.some((segment) => segment === ".." || segment === ".")) {
+    throw new Error(`\u975E\u6CD5\u6587\u6863\u8DEF\u5F84: ${path10}`);
+  }
+  return segments.join("/");
+}
+function hashLocalFileContent(content) {
+  return createHash("sha256").update(content, "utf8").digest("hex");
+}
+function readLocalManifest(apmRoot) {
+  const manifestPath2 = join8(projectDocumentsDir(apmRoot), MANIFEST_FILE3);
+  if (!existsSync6(manifestPath2)) {
+    return null;
+  }
+  try {
+    return JSON.parse(
+      readFileSync6(manifestPath2, "utf8")
+    );
+  } catch {
+    return null;
+  }
+}
+function listLocalDocumentPaths(apmRoot) {
+  const root = projectDocumentsDir(apmRoot);
+  if (!existsSync6(root)) {
+    return [];
+  }
+  const paths = [];
+  const walk = (dir) => {
+    for (const entry of readdirSync3(dir, { withFileTypes: true })) {
+      const abs = join8(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(abs);
+        continue;
+      }
+      if (entry.isFile() && entry.name === MANIFEST_FILE3) {
+        continue;
+      }
+      const rel = relative(root, abs).split(sep).join("/");
+      paths.push(rel);
+    }
+  };
+  walk(root);
+  return paths.sort();
+}
+function diffManifestPaths(remote, local) {
+  const remoteMap = new Map(
+    (remote?.documents ?? []).map((doc) => [doc.path, doc.contentHash])
+  );
+  const localMap = new Map(
+    (local?.documents ?? []).map((doc) => [doc.path, doc.contentHash])
+  );
+  const download = [];
+  for (const [path10, hash] of remoteMap) {
+    if (localMap.get(path10) !== hash) {
+      download.push(path10);
+    }
+  }
+  const deleteLocal = [];
+  for (const path10 of localMap.keys()) {
+    if (!remoteMap.has(path10)) {
+      deleteLocal.push(path10);
+    }
+  }
+  return { download, deleteLocal };
+}
+async function syncRepositoryProjectDocumentsPull(workdirPath, apmDir) {
+  const empty = {
+    synced: false,
+    repositoryId: null,
+    downloaded: 0,
+    deleted: 0
+  };
+  const cfg = await tryReadApmConfig();
+  if (!cfg || !resolveApiKey(cfg)) {
+    console.log(
+      "[apm] \u672A\u68C0\u6D4B\u5230\u767B\u5F55\u4FE1\u606F\uFF0C\u8DF3\u8FC7\u4ED3\u5E93\u9879\u76EE\u6587\u6863\u540C\u6B65\u3002\n[apm] \u8BF7\u5148\u6267\u884C apm login\u3002"
+    );
+    return empty;
+  }
+  const api = createApmApiClient(cfg);
+  const { repositoryId, diagnostic } = await resolveRepositoryIdForSync(
+    api,
+    workdirPath
+  );
+  if (!repositoryId) {
+    console.log(
+      `[apm] \u672A\u80FD\u540C\u6B65\u4ED3\u5E93\u9879\u76EE\u6587\u6863\u3002
+${diagnostic ?? ""}`
+    );
+    return empty;
+  }
+  const targetApmDir = apmDir ?? workspaceApmDir(workdirPath);
+  const projectDir = projectDocumentsDir(targetApmDir);
+  await ensureDirExists(projectDir);
+  const { manifest: remoteManifest } = await api.cli.getRepositoryProjectDocumentManifest({ repositoryId });
+  if (!remoteManifest) {
+    console.log(
+      `[apm] \u4ED3\u5E93 ${repositoryId} \u65E0\u9879\u76EE\u6587\u6863 manifest\uFF0C\u8DF3\u8FC7\u540C\u6B65\u3002`
+    );
+    return { ...empty, repositoryId };
+  }
+  const localManifest = readLocalManifest(targetApmDir);
+  const { download, deleteLocal } = diffManifestPaths(
+    remoteManifest,
+    localManifest
+  );
+  let downloaded = 0;
+  if (download.length > 0) {
+    const { list } = await api.cli.listRepositoryProjectDocuments({
+      repositoryId,
+      paths: download.join(",")
+    });
+    for (const doc of list) {
+      const absPath = toFsPath(projectDocumentLocalPath(targetApmDir, doc.path));
+      await ensureDirExists(dirname2(absPath));
+      writeFileSync8(absPath, doc.content, "utf8");
+      downloaded += 1;
+    }
+  }
+  let deleted = 0;
+  for (const path10 of deleteLocal) {
+    const absPath = toFsPath(projectDocumentLocalPath(targetApmDir, path10));
+    if (existsSync6(absPath)) {
+      rmSync3(absPath, { force: true });
+      deleted += 1;
+    }
+  }
+  writeFileSync8(
+    toFsPath(join8(projectDir, MANIFEST_FILE3)),
+    `${JSON.stringify(remoteManifest, null, 2)}
+`,
+    "utf8"
+  );
+  console.log(
+    `[apm] \u5DF2\u540C\u6B65\u4ED3\u5E93\u9879\u76EE\u6587\u6863: \u4E0B\u8F7D ${downloaded}\uFF0C\u5220\u9664\u672C\u5730 ${deleted}`
+  );
+  return {
+    synced: true,
+    repositoryId,
+    downloaded,
+    deleted
+  };
+}
+async function syncRepositoryProjectDocumentsPush(cfg, workdirPath, apmRoot) {
+  const api = createApmApiClient(cfg);
+  const { repositoryId } = await resolveRepositoryIdForSync(api, workdirPath);
+  if (!repositoryId) {
+    return 0;
+  }
+  const targetApmDir = apmRoot ?? workspaceApmDir(workdirPath);
+  const localPaths = listLocalDocumentPaths(targetApmDir);
+  if (localPaths.length === 0) {
+    console.log("[apm] \u4ED3\u5E93\u9879\u76EE\u6587\u6863\u65E0\u672C\u5730\u6587\u4EF6\uFF0C\u8DF3\u8FC7\u63A8\u9001");
+    return 0;
+  }
+  const remoteManifest = (await api.cli.getRepositoryProjectDocumentManifest({ repositoryId })).manifest ?? null;
+  const remoteHashByPath = new Map(
+    (remoteManifest?.documents ?? []).map((doc) => [doc.path, doc.contentHash])
+  );
+  const remoteDescriptionByPath = new Map(
+    (remoteManifest?.documents ?? []).map((doc) => [
+      doc.path,
+      doc.description
+    ])
+  );
+  let synced = 0;
+  for (const path10 of localPaths) {
+    const absPath = toFsPath(projectDocumentLocalPath(targetApmDir, path10));
+    const content = readFileSync6(absPath, "utf8");
+    const contentHash = hashLocalFileContent(content);
+    if (remoteHashByPath.get(path10) === contentHash) {
+      continue;
+    }
+    await api.cli.upsertRepositoryProjectDocument({
+      repositoryId,
+      path: path10,
+      content,
+      description: remoteDescriptionByPath.get(path10) ?? void 0
+    });
+    synced += 1;
+    console.log(`[apm] \u5DF2\u540C\u6B65\u4ED3\u5E93\u9879\u76EE\u6587\u6863: ${path10}`);
+  }
+  if (synced === 0) {
+    console.log("[apm] \u4ED3\u5E93\u9879\u76EE\u6587\u6863\u65E0\u53D8\u5316\uFF0C\u8DF3\u8FC7\u63A8\u9001");
+  }
+  return synced;
+}
+
 // src/commands/pull.ts
 async function runPull(sessionId, remoteWorkdir) {
   const trimmedId = sessionId.trim();
@@ -1406,20 +1642,20 @@ async function runPull(sessionId, remoteWorkdir) {
   const dir = sessionDir(trimmedId, apmRoot);
   const docsDir = sessionDocsDir(trimmedId, apmRoot);
   await ensureDirExists(docsDir);
-  writeFileSync8(
+  writeFileSync9(
     sessionRulePath(trimmedId, apmRoot),
     detail.description ?? "",
     "utf8"
   );
-  writeFileSync8(
+  writeFileSync9(
     sessionTaskPath(trimmedId, apmRoot),
     detail.task.description ?? "",
     "utf8"
   );
-  writeFileSync8(sessionTodoPath(trimmedId, apmRoot), detail.todo ?? "", "utf8");
+  writeFileSync9(sessionTodoPath(trimmedId, apmRoot), detail.todo ?? "", "utf8");
   for (const doc of documents) {
     const fileName = documentLocalFileName(doc.name);
-    writeFileSync8(join8(docsDir, fileName), doc.content ?? "", "utf8");
+    writeFileSync9(join9(docsDir, fileName), doc.content ?? "", "utf8");
   }
   const sessionYaml = yamlStringify(
     {
@@ -1436,19 +1672,21 @@ async function runPull(sessionId, remoteWorkdir) {
     },
     { lineWidth: 0 }
   );
-  writeFileSync8(
+  writeFileSync9(
     sessionYamlPath(trimmedId, apmRoot),
     sessionYaml.endsWith("\n") ? sessionYaml : `${sessionYaml}
 `,
     "utf8"
   );
-  writeFileSync8(
+  writeFileSync9(
     sessionMessagesXmlPath(trimmedId, apmRoot),
     formatSessionMessagesXml(trimmedId, messages),
     "utf8"
   );
   await syncSessionAttachments(cfg, trimmedId, attachments, apmRoot);
   await syncPlatformRules(cfg, trimmedId, workdir, apmRoot);
+  await syncRemoteDeploymentConfig(workdir, apmRoot);
+  await syncRepositoryProjectDocumentsPull(workdir, apmRoot);
   console.log(`[apm] \u5DF2\u540C\u6B65\u4F1A\u8BDD\u5DE5\u4F5C\u533A: ${dir}`);
   return dir;
 }
@@ -1457,15 +1695,15 @@ async function runPull(sessionId, remoteWorkdir) {
 import { spawnSync } from "child_process";
 
 // src/version.ts
-import { readFileSync as readFileSync6 } from "fs";
-import { dirname as dirname2, join as join9 } from "path";
+import { readFileSync as readFileSync7 } from "fs";
+import { dirname as dirname3, join as join10 } 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 = join9(dir, "..", "package.json");
-    const pkg = JSON.parse(readFileSync6(pkgPath, "utf8"));
+    const dir = dirname3(fileURLToPath2(import.meta.url));
+    const pkgPath = join10(dir, "..", "package.json");
+    const pkg = JSON.parse(readFileSync7(pkgPath, "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -1538,12 +1776,12 @@ async function runUpdate() {
 }
 
 // src/commands/update-skills.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync4, statSync as statSync3 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, statSync as statSync3 } from "fs";
+import { join as join11 } from "path";
 async function syncWorkspaceSkills(cfg, workdir) {
   const apmDir = workspaceApmDir(workdir);
   const fsApmDir = toFsPath(apmDir);
-  if (!existsSync6(fsApmDir)) {
+  if (!existsSync7(fsApmDir)) {
     throw new Error("[apm] \u672A\u627E\u5230 .apm \u76EE\u5F55\uFF0C\u8BF7\u5148\u6267\u884C apm init");
   }
   const apmStat = statSync3(fsApmDir);
@@ -1555,12 +1793,12 @@ async function syncWorkspaceSkills(cfg, workdir) {
   if (syncAgentsGuide(apmDir)) {
     console.log("[apm] \u5DF2\u540C\u6B65 APM \u6307\u5357: .apm/AGENTS.md");
   }
-  const rulesDir = join10(apmDir, "rules");
+  const rulesDir = join11(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 = join10(apmDir, "skills");
+  const skillsDir = join11(apmDir, "skills");
   mkdirSync4(toFsPath(skillsDir), { recursive: true });
   const baseNames = syncBaseSkills(skillsDir);
   for (const name of baseNames) {
@@ -1587,7 +1825,7 @@ async function syncWorkspaceSkills(cfg, workdir) {
 }
 async function runUpdateSkills() {
   const apmDir = workspaceApmDir();
-  if (!existsSync6(apmDir)) {
+  if (!existsSync7(apmDir)) {
     console.error("[apm] \u672A\u627E\u5230 .apm \u76EE\u5F55\uFF0C\u8BF7\u5148\u6267\u884C apm init");
     process.exit(1);
   }
@@ -1600,11 +1838,11 @@ async function runUpdateSkills() {
 }
 
 // src/commands/sync-deploy-config.ts
-import { existsSync as existsSync7, statSync as statSync4 } from "fs";
+import { existsSync as existsSync8, statSync as statSync4 } from "fs";
 async function runSyncDeployConfig() {
   const workdir = resolveWorkdirPath();
   const apmDir = workspaceApmDir(workdir);
-  if (!existsSync7(apmDir)) {
+  if (!existsSync8(apmDir)) {
     console.error("[apm] \u672A\u627E\u5230 .apm \u76EE\u5F55\uFF0C\u8BF7\u5148\u6267\u884C apm init");
     process.exit(1);
   }
@@ -1619,18 +1857,33 @@ async function runSyncDeployConfig() {
   }
 }
 
+// src/commands/sync-project-documents.ts
+async function runSyncProjectDocuments(options) {
+  const pull = options?.pull ?? !options?.push;
+  const push = options?.push ?? false;
+  const workdir = resolveWorkdirPath();
+  const apmRoot = workspaceApmDir(workdir);
+  if (pull) {
+    await syncRepositoryProjectDocumentsPull(workdir, apmRoot);
+  }
+  if (push) {
+    const cfg = await ensureLoggedConfig();
+    await syncRepositoryProjectDocumentsPush(cfg, workdir, apmRoot);
+  }
+}
+
 // src/commands/sync-document.ts
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { basename as basename3 } from "path";
 
 // src/commands/sync-session-documents.ts
-import { existsSync as existsSync8, readdirSync as readdirSync3, readFileSync as readFileSync7 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync9, readdirSync as readdirSync4, readFileSync as readFileSync8 } from "fs";
+import { join as join12 } from "path";
 function listLocalMarkdownFiles(docsDir) {
-  if (!existsSync8(docsDir)) {
+  if (!existsSync9(docsDir)) {
     return [];
   }
-  return readdirSync3(docsDir).filter(
+  return readdirSync4(docsDir).filter(
     (name) => name.toLowerCase().endsWith(".md")
   );
 }
@@ -1642,8 +1895,8 @@ function remoteDocumentByLocalName(remoteDocuments, localFileName) {
   });
 }
 async function upsertLocalDocumentFile(api, sessionId, docsDir, fileName) {
-  const absPath = join11(docsDir, fileName);
-  const content = readFileSync7(absPath, "utf8");
+  const absPath = join12(docsDir, fileName);
+  const content = readFileSync8(absPath, "utf8");
   const name = documentPlatformName(absPath);
   return api.cli.upsertDocument({
     sessionId,
@@ -1665,8 +1918,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 = join11(docsDir, fileName);
-    const content = readFileSync7(absPath, "utf8");
+    const absPath = join12(docsDir, fileName);
+    const content = readFileSync8(absPath, "utf8");
     const remote = remoteDocumentByLocalName(remoteDocuments, fileName);
     if (remote && remote.content === content) {
       continue;
@@ -1699,7 +1952,7 @@ async function runSyncDocument(sessionId, options) {
     process.exit(1);
   }
   const absPath = resolveSessionDocumentPath(trimmedSessionId, fileArg);
-  if (!existsSync9(absPath)) {
+  if (!existsSync10(absPath)) {
     const docsDir2 = sessionDocsDir(trimmedSessionId);
     console.error(
       `[apm] \u6587\u6863\u4E0D\u5B58\u5728: ${absPath}
@@ -1853,13 +2106,37 @@ function validateCancel(o) {
     data: { type: "cancel", messageId: o.messageId.trim() }
   };
 }
+function validateDeployPush(o) {
+  if (o.type !== "deploy") {
+    return { ok: false, reason: "\u671F\u671B deploy" };
+  }
+  if (!nonEmptyString(o.deploymentRunId)) {
+    return { ok: false, reason: "deploy \u7F3A\u5C11 deploymentRunId" };
+  }
+  if (!nonEmptyString(o.workdir)) {
+    return { ok: false, reason: "deploy \u7F3A\u5C11 workdir" };
+  }
+  const environment = o.environment;
+  if (environment !== "test" && environment !== "online") {
+    return { ok: false, reason: "deploy.environment \u65E0\u6548" };
+  }
+  return {
+    ok: true,
+    data: {
+      type: "deploy",
+      deploymentRunId: o.deploymentRunId.trim(),
+      workdir: o.workdir.trim(),
+      environment
+    }
+  };
+}
 function validateAgentWsMessage(value, kind) {
   if (typeof value !== "object" || value === null) {
     return { ok: false, reason: "\u6D88\u606F\u4F53\u4E0D\u662F JSON \u5BF9\u8C61" };
   }
   const o = value;
   const type = o.type;
-  if (type !== "heartbeat" && type !== "message" && type !== "cancel") {
+  if (type !== "heartbeat" && type !== "message" && type !== "cancel" && type !== "deploy") {
     return { ok: false, reason: `\u672A\u77E5 type: ${String(type)}` };
   }
   if (kind === "heartbeat" || type === "heartbeat") {
@@ -1868,9 +2145,125 @@ function validateAgentWsMessage(value, kind) {
   if (type === "cancel") {
     return validateCancel(o);
   }
+  if (type === "deploy") {
+    return validateDeployPush(o);
+  }
   return validateMessagePush(o);
 }
 
+// src/commands/connect/deploy-run.ts
+import { spawn } from "node:child_process";
+import { readFileSync as readFileSync9 } from "node:fs";
+import { join as join13 } from "node:path";
+function readDeployConfig(workdir) {
+  const configPath = join13(workspaceApmDir(workdir), "apm.config.json");
+  try {
+    const raw = readFileSync9(configPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed.deploy;
+  } catch {
+    return void 0;
+  }
+}
+function resolveDeployCommand(workdir, environment) {
+  const command = readDeployConfig(workdir)?.[environment];
+  if (typeof command === "string" && command.trim()) {
+    return command.trim();
+  }
+  return null;
+}
+function missingDeployCommandMessage(environment) {
+  return `deploy.${environment} \u90E8\u7F72\u547D\u4EE4\u672A\u914D\u7F6E\uFF0C\u8BF7\u5148\u914D\u7F6E`;
+}
+function runShellCommand(command, cwd, signal) {
+  return new Promise((resolve5, reject) => {
+    const child = spawn(command, {
+      cwd,
+      shell: true,
+      env: process.env,
+      windowsHide: true
+    });
+    let stdout = "";
+    let stderr = "";
+    const onAbort = () => {
+      child.kill("SIGTERM");
+    };
+    if (signal.aborted) {
+      onAbort();
+    } else {
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+    child.stdout.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.on("error", (error) => {
+      signal.removeEventListener("abort", onAbort);
+      reject(error);
+    });
+    child.on("close", (code) => {
+      signal.removeEventListener("abort", onAbort);
+      const log = [stdout, stderr].filter(Boolean).join("\n");
+      if (code === 0) {
+        resolve5({ log });
+        return;
+      }
+      const error = new Error(
+        `\u90E8\u7F72\u547D\u4EE4\u9000\u51FA\u7801 ${code ?? "unknown"}: ${command}`
+      );
+      error.log = log;
+      reject(error);
+    });
+  });
+}
+async function handleInboundDeploy(cfg, msg, signal) {
+  const api = createApmApiClient(cfg);
+  const deploymentRunId = msg.deploymentRunId;
+  if (signal.aborted) return;
+  await api.cli.updateCoordinatorDeploymentStatus({
+    id: deploymentRunId,
+    status: "DEPLOYING"
+  });
+  const workdir = requireRemoteWorkdir(msg.workdir);
+  const command = resolveDeployCommand(workdir, msg.environment);
+  if (!command) {
+    const error = missingDeployCommandMessage(msg.environment);
+    console.error(`[apm] ${error}`);
+    await api.cli.completeCoordinatorDeployment({
+      id: deploymentRunId,
+      status: "FAILED",
+      log: error,
+      error
+    });
+    return;
+  }
+  console.log(
+    `[apm] deploy start id=${deploymentRunId} env=${msg.environment} cwd=${workdir}`
+  );
+  console.log(`[apm] deploy command: ${command}`);
+  try {
+    const { log } = await runShellCommand(command, workdir, signal);
+    await api.cli.completeCoordinatorDeployment({
+      id: deploymentRunId,
+      status: "SUCCESS",
+      log
+    });
+    console.log(`[apm] deploy success id=${deploymentRunId}`);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    const log = error && typeof error === "object" && "log" in error ? String(error.log ?? "") : "";
+    await api.cli.completeCoordinatorDeployment({
+      id: deploymentRunId,
+      status: "FAILED",
+      log,
+      error: detail
+    });
+    console.error(`[apm] deploy failed id=${deploymentRunId}: ${detail}`);
+  }
+}
+
 // src/commands/connect/abort-signal-debug.ts
 import {
   getEventListeners,
@@ -2100,17 +2493,17 @@ ${JSON.stringify(event, null, 2)}
 }
 
 // src/commands/connect/agent-session-registry.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync9 } from "node:fs";
-import { dirname as dirname3, resolve as resolve3 } from "node:path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync5, readFileSync as readFileSync10, writeFileSync as writeFileSync10 } from "node:fs";
+import { dirname as dirname4, resolve as resolve3 } from "node:path";
 function registryPath(workdir, sessionId) {
   return resolve3(workdir, ".apm", "sessions", sessionId, "cursor-agents.json");
 }
 function readRegistry(path10) {
-  if (!existsSync10(path10)) {
+  if (!existsSync11(path10)) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync8(path10, "utf8"));
+    const parsed = JSON.parse(readFileSync10(path10, "utf8"));
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       const result = {};
       for (const [key, value] of Object.entries(
@@ -2127,8 +2520,8 @@ function readRegistry(path10) {
   return {};
 }
 function writeRegistry(path10, registry) {
-  mkdirSync5(dirname3(path10), { recursive: true });
-  writeFileSync9(path10, `${JSON.stringify(registry, null, 2)}
+  mkdirSync5(dirname4(path10), { recursive: true });
+  writeFileSync10(path10, `${JSON.stringify(registry, null, 2)}
 `, "utf8");
 }
 function loadSessionAgentId(workdir, sessionId, user) {
@@ -2432,20 +2825,20 @@ async function runCursorAgent(cfg, ctx, options) {
 }
 
 // src/commands/connect/cli-version-sync.ts
-import { existsSync as existsSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync10 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync11, writeFileSync as writeFileSync11 } from "fs";
+import { join as join14 } from "path";
 var CLI_VERSION_FILE = ".cli-version.json";
 function manifestPath(apmDir) {
-  return join12(apmDir, CLI_VERSION_FILE);
+  return join14(apmDir, CLI_VERSION_FILE);
 }
 function loadManifest3(apmDir) {
   const path10 = toFsPath(manifestPath(apmDir));
-  if (!existsSync11(path10)) {
+  if (!existsSync12(path10)) {
     return null;
   }
   try {
     const parsed = JSON.parse(
-      readFileSync9(path10, "utf8")
+      readFileSync11(path10, "utf8")
     );
     if (parsed?.version === 1 && typeof parsed.cliVersion === "string" && parsed.cliVersion.trim()) {
       return parsed;
@@ -2456,7 +2849,7 @@ function loadManifest3(apmDir) {
 }
 function saveManifest3(apmDir, cliVersion) {
   const manifest = { version: 1, cliVersion };
-  writeFileSync10(
+  writeFileSync11(
     toFsPath(manifestPath(apmDir)),
     `${JSON.stringify(manifest, null, 2)}
 `,
@@ -2633,6 +3026,10 @@ async function handleInboundMessage(cfg, msg, signal, ctx) {
       "sync-documents",
       () => syncSessionDocuments(cfg, msg.sessionId, apmRoot)
     );
+    await runStep(
+      "sync-project-documents",
+      () => syncRepositoryProjectDocumentsPush(cfg, workdir, apmRoot)
+    );
     await runStep(
       "commit-files",
       () => commitWorkingTreeIfDirty(workdir, "chore(apm): commit working tree")
@@ -2770,6 +3167,27 @@ async function runConnect(options) {
         activeRuns.get(messageId)?.abort();
         return;
       }
+      if (validated.data.type === "deploy") {
+        const msg2 = validated.data;
+        const perDeployController = new AbortController();
+        const signal2 = AbortSignal.any([
+          shutdownAbort.signal,
+          perDeployController.signal
+        ]);
+        const task2 = (async () => {
+          await runSlots.acquire();
+          try {
+            await handleInboundDeploy(cfg, msg2, signal2);
+          } finally {
+            runSlots.release();
+          }
+        })();
+        activeTasks.add(task2);
+        void task2.finally(() => {
+          activeTasks.delete(task2);
+        });
+        return;
+      }
       if (validated.data.type !== "message") {
         return;
       }
@@ -2852,19 +3270,19 @@ async function runCreatePr(options) {
 import path5 from "node:path";
 
 // src/commands/deploy/internal/apm-config.ts
-import { existsSync as existsSync12, readFileSync as readFileSync10 } from "node:fs";
+import { existsSync as existsSync13, readFileSync as readFileSync12 } 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 (!existsSync12(p)) {
+  if (!existsSync13(p)) {
     console.error(`\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6\uFF1A${p}`);
     process.exit(1);
   }
   try {
-    const raw = readFileSync10(p, "utf8");
+    const raw = readFileSync12(p, "utf8");
     return JSON.parse(raw);
   } catch (e) {
     console.error(`\u65E0\u6CD5\u89E3\u6790 apm.config.json\uFF1A${p}`, e);
@@ -2986,7 +3404,7 @@ import path4 from "node:path";
 import Docker from "dockerode";
 
 // src/commands/deploy/internal/backend-deploy/dockerode-client/connection-options.ts
-import { existsSync as existsSync13, readFileSync as readFileSync11 } from "node:fs";
+import { existsSync as existsSync14, readFileSync as readFileSync13 } from "node:fs";
 import path from "node:path";
 function asOptionalTlsBuffer(value) {
   if (typeof value !== "string") {
@@ -2998,8 +3416,8 @@ function asOptionalTlsBuffer(value) {
   if (normalized === "") {
     return void 0;
   }
-  if (existsSync13(normalized)) {
-    return readFileSync11(normalized);
+  if (existsSync14(normalized)) {
+    return readFileSync13(normalized);
   }
   const looksLikePath = /[\\/]/.test(normalized) || normalized.endsWith(".pem");
   if (looksLikePath) {
@@ -3209,7 +3627,7 @@ var DockerodeClient = class {
 var createDockerodeClient = (config) => new DockerodeClient(config);
 
 // src/commands/deploy/internal/backend-deploy/dockerode-client/env.ts
-import { existsSync as existsSync14, readFileSync as readFileSync12, statSync as statSync5 } from "node:fs";
+import { existsSync as existsSync15, readFileSync as readFileSync14, statSync as statSync5 } from "node:fs";
 import path2 from "node:path";
 function stripSurroundingQuotes(value) {
   const t = value.trim();
@@ -3226,10 +3644,10 @@ function loadEnvFromFile(envFilePath) {
     return {};
   }
   const targetPath = path2.resolve(envFilePath);
-  if (!existsSync14(targetPath) || !statSync5(targetPath).isFile()) {
+  if (!existsSync15(targetPath) || !statSync5(targetPath).isFile()) {
     return {};
   }
-  const raw = readFileSync12(targetPath, "utf-8");
+  const raw = readFileSync14(targetPath, "utf-8");
   const result = {};
   for (const line of raw.split(/\r?\n/)) {
     const normalized = line.trim();
@@ -3400,12 +3818,12 @@ function dockerPushImage(params, cwd) {
 }
 
 // src/commands/deploy/internal/backend-deploy/resolve-dockerfile.ts
-import { existsSync as existsSync15 } from "node:fs";
+import { existsSync as existsSync16 } 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 (!existsSync15(dockerfilePath)) {
+  if (!existsSync16(dockerfilePath)) {
     throw new Error(`Dockerfile \u4E0D\u5B58\u5728\uFF1A${dockerfilePath}`);
   }
   Logger.info("\u2713 Dockerfile \u5B58\u5728");
@@ -4034,8 +4452,13 @@ function buildProgram() {
   ).action(async () => {
     await runSyncDeployConfig();
   });
+  program.command("sync-project-documents").description(
+    "\u540C\u6B65\u4ED3\u5E93\u9879\u76EE\u6587\u6863\uFF1A\u9ED8\u8BA4 pull \u5230 .apm/project/\uFF1B\u52A0 --push \u5C06\u672C\u5730\u53D8\u66F4\u63A8\u9001\u5230\u5E73\u53F0"
+  ).option("--push", "\u63A8\u9001\u672C\u5730 .apm/project/ \u5230\u5E73\u53F0").option("--pull", "\u4ECE\u5E73\u53F0\u62C9\u53D6\u5230 .apm/project/").action(async (opts) => {
+    await runSyncProjectDocuments(opts);
+  });
   program.command("pull").description(
-    "\u62C9\u53D6\u6C9F\u901A\u7FA4\u6570\u636E\u5230 .apm/sessions/<sessionId>/\uFF08session.yaml\u3001RULE.md\u3001TASK.md\u3001TODO.md\u3001docs\u3001attachments\uFF09"
+    "\u62C9\u53D6\u6C9F\u901A\u7FA4\u6570\u636E\u5230 .apm/sessions/<sessionId>/\uFF0C\u5E76\u540C\u6B65\u90E8\u7F72\u914D\u7F6E\u4E0E\u4ED3\u5E93\u9879\u76EE\u6587\u6863\u5230 .apm/project/"
   ).argument("<sessionId>", "\u6C9F\u901A\u7FA4 ID").action(async (sessionId) => {
     await runPull(sessionId);
   });

package/package.json

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

package/template/AGENTS.md

@@ -30,6 +30,11 @@
     - reply.md：当需要回复消息时需要读取这个文档，记住回复规则
     - write_doc.md：当需要写文档时需要读取这个文档，记住写文档的规则
 
+- 仓库项目上下文（`.apm/project/`）:
+  - 索引: `.apm/project/manifest.json` — 本仓库在平台登记的文档列表
+  - 文档文件: `.apm/project/{path}` — 与 manifest 中 path 对应；`apm pull` 自动同步，`apm connect` 消息结束后自动推回平台
+  - 任务涉及菜单名、路由、业务术语等时，**先 Read manifest 与相关文档**，禁止猜测路径
+
 - 本轮任务需要关注的文档指引（.apm/sessions/<会话 ID>/\*）:
   - 本轮会话状态: `session.yaml`，从这里可以看到每个成员的信息，找到可以协助你一起解决问题的人，可以结合 `RULE.md`一起看
   - 群文档: `docs/xxxx.md`，当需要相关上下文可以在这里查找，按需阅读

package/template/apm.config.json

@@ -1,3 +1,7 @@
 {
-  "name": ""
-}
+  "name": "",
+  "deploy": {
+    "test": "npm run deploy:test && python .apm/deploy/deploy.py",
+    "online": "npm run deploy:online && python .apm/deploy/deploy.py"
+  }
+}

package/template/rules/write_doc.md

@@ -25,6 +25,7 @@
 
 - 须标注**目标数据库**（库名/实例名、类型如 MySQL；同一变更涉及多库时分别标注）
 - 待执行的 SQL 语句须放在 ` ```sql ` 代码块中，按执行顺序逐条列出
+- SQL 须写完整、可直接复制执行，**禁止**用 `...` 或「省略」占位代替表名、字段名、条件等任何片段
 
 ## 文档同步
 

package/template/skills/apm-dev/SKILL.md

@@ -52,9 +52,9 @@
 
 - **目标数据库**（库名/实例名、类型如 MySQL；同一变更涉及多库时分别标注）
 - 变更摘要（改了什么表/数据、为什么）
-- 完整 SQL 语句（按执行顺序排列；**每条须放在 ` ```sql ` 代码块中**，便于复制执行）
+- 完整 SQL 语句（按执行顺序排列；**每条须放在 ` ```sql ` 代码块中**，便于复制执行；**禁止**用 `...` 或「省略」占位代替任何片段）
 - 执行环境说明（测试/生产是否一致、是否需人工执行）
-- 回滚方案（如适用；回滚 SQL 同样用 ` ```sql ` 代码块）
+- 回滚方案（如适用；回滚 SQL 同样用 ` ```sql ` 代码块，须完整可执行，禁止省略）
 
 示例：
 

package/template/skills/apm-diff-review/SKILL.md

@@ -18,12 +18,12 @@
 
 ### 步骤 2：四项检查
 
-| 检查项         | 判定                                                                                                                                          |
-| -------------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
-| **白名单对账** | diff 中出现白名单之外的文件，且计划未更新说明 → **不通过**                                                                                    |
-| **需求相关性** | 存在与本需求无关的改动（顺手重构、改格式、动了无关逻辑）→ **不通过**                                                                          |
-| **计划落实**   | 计划「实现步骤」中的关键点在 diff 中找不到对应实现 → **不通过**                                                                               |
-| **SQL 文档**   | **仅后端**：diff 涉及 SQL 改动（DDL/DML、表结构、Mapper/XML 中 SQL 等），但 `docs/SQL.md` 缺失、未标注目标数据库、或与改动不一致 → **不通过** |
+| 检查项         | 判定                                                                                                                                                                            |
+| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **白名单对账** | diff 中出现白名单之外的文件，且计划未更新说明 → **不通过**                                                                                                                      |
+| **需求相关性** | 存在与本需求无关的改动（顺手重构、改格式、动了无关逻辑）→ **不通过**                                                                                                            |
+| **计划落实**   | 计划「实现步骤」中的关键点在 diff 中找不到对应实现 → **不通过**                                                                                                                 |
+| **SQL 文档**   | **仅后端**：diff 涉及 SQL 改动（DDL/DML、表结构、Mapper/XML 中 SQL 等），但 `docs/SQL.md` 缺失、未标注目标数据库、与改动不一致、或 SQL 代码块含 `...`/「省略」占位 → **不通过** |
 
 注意事项：