@4pm/cli 1.9.0 → 1.10.0

package/dist/index.js

@@ -29506,17 +29506,38 @@ MCowBQYDK2VwAyEARlfzjaFhe5bhRrMp/ZuH6sVqg/S7f8B1dliuF21iDTw=
 `;
 
 // src/version.ts
+import { execFileSync } from "child_process";
 import { readFileSync as readFileSync4 } from "fs";
 import { dirname, join as join4 } from "path";
 import { fileURLToPath } from "url";
+function gitDescribeVersion(cwd2) {
+  try {
+    const out = execFileSync("git", ["describe", "--tags", "--match", "cli-v*"], {
+      cwd: cwd2,
+      timeout: 3e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).toString().trim();
+    const stripped = out.replace(/^cli-v/, "");
+    return stripped || null;
+  } catch {
+    return null;
+  }
+}
 function readCliVersion() {
+  const envVersion = process.env.FOURPM_CLI_VERSION?.trim();
+  if (envVersion) return envVersion.replace(/^cli-v/, "");
+  let version = "0.0.0";
   try {
     const here = dirname(fileURLToPath(import.meta.url));
     const pkg = JSON.parse(readFileSync4(join4(here, "..", "package.json"), "utf8"));
-    return pkg.version ?? "0.0.0";
+    version = pkg.version ?? "0.0.0";
+    if (version === "0.0.0") {
+      const dev = gitDescribeVersion(here);
+      if (dev) version = dev;
+    }
   } catch {
-    return "0.0.0";
   }
+  return version;
 }
 var CLI_VERSION = readCliVersion();
 
@@ -34318,6 +34339,16 @@ var addRepoRequestSchema = external_exports.object({
     });
   }
 });
+var addProjectRepoRequestSchema = external_exports.object({
+  /** Clone url — `https` or `ssh` (required; ADR-0172). */
+  url: external_exports.string().max(500).regex(GIT_URL_RE, "must be an https or ssh git url"),
+  /** Primary branch to clone / check out (ADR-0292); empty ⇒ the repo's default branch. */
+  branch: external_exports.string().max(200).optional().default(""),
+  /** Role label / folder hint (e.g. "docs" / "web"); empty ⇒ derived from the url basename. */
+  role: external_exports.string().max(60).optional().default(""),
+  /** true = Confirm (clone + scaffold); false = Skip (clone as-is, no template/AI-init). */
+  scaffold: external_exports.boolean()
+});
 
 // vendor/@4pm/dto/user.ts
 var AVATAR_MAX_BYTES = 2 * 1024 * 1024;
@@ -34467,10 +34498,21 @@ function reposOf(spec) {
   const repos = spec?.repos;
   return Array.isArray(repos) ? repos : [];
 }
-function subDirName(repo) {
+function folderName(repo) {
   const raw = (repo.subdir || repo.role || repoName(repo.url ?? "") || "repo").trim();
   return raw.replace(/[^\w.-]+/g, "-").replace(/^-+|-+$/g, "") || "repo";
 }
+function repoFolders(repos) {
+  const used = /* @__PURE__ */ new Set();
+  return repos.map((r) => {
+    const base = folderName(r);
+    let name = base;
+    let n = 2;
+    while (used.has(name)) name = `${base}-${n++}`;
+    used.add(name);
+    return name;
+  });
+}
 function cloneArgs(url, dest, branch) {
   const b = (branch ?? "").trim();
   return b ? ["clone", "-b", b, url, dest] : ["clone", url, dest];
@@ -34482,73 +34524,63 @@ async function updateRepo(dir2, label, branch, emit) {
   if (b) await run2("git", ["checkout", b], { cwd: dir2, timeout: 6e4 });
   await run2("git", ["pull", "--ff-only"], { cwd: dir2, timeout: 12e4 });
 }
+function repoDir(target, repo, folder, legacyRoot) {
+  if (repo.primary && legacyRoot) return target;
+  return join6(target, folder);
+}
 async function provisionRepos(target, repos, emit, opts = {}) {
   const mode = opts.mode ?? "clone";
-  const subDirsToKeep = new Set(repos.filter((r) => !r.primary && r.url).map((r) => subDirName(r)));
-  for (const repo of repos) {
-    if (repo.primary) {
-      if (opts.clonePrimary && repo.url) {
-        if (existsSync4(join6(target, ".git"))) {
-          if (mode === "sync") {
-            await updateRepo(target, "primary repo", repo.branch, emit);
-          } else if (mode === "force") {
-            emit("git", `Re-cloning ${repo.url} (force)\u2026`);
-            const tmp = `${target}.4pm-reclone`;
-            await rm(tmp, { recursive: true, force: true });
-            await run2("git", cloneArgs(repo.url, tmp, repo.branch), { timeout: 12e4 });
-            for (const entry of await readdir(target)) {
-              if (subDirsToKeep.has(entry)) continue;
-              await rm(join6(target, entry), { recursive: true, force: true });
-            }
-            for (const entry of await readdir(tmp)) {
-              if (subDirsToKeep.has(entry)) continue;
-              await rename(join6(tmp, entry), join6(target, entry));
-            }
-            await rm(tmp, { recursive: true, force: true });
-          } else {
-            emit("git", `Primary repo already present \u2014 skipping clone.`);
-          }
-          continue;
-        }
-        emit("git", `Cloning ${repo.url}\u2026`);
-        await run2("git", cloneArgs(repo.url, target, repo.branch), { timeout: 12e4 });
-        continue;
-      }
-      emit("git", "Initializing the primary repo\u2026");
-      await run2("git", ["init"], { cwd: target, timeout: 2e4 });
-      if (repo.url) {
-        await run2("git", ["remote", "add", "origin", repo.url], { cwd: target, timeout: 2e4 }).catch(
-          () => void 0
-        );
+  const legacyRoot = existsSync4(join6(target, ".git"));
+  const folders = repoFolders(repos);
+  const foldersToKeep = new Set(
+    repos.map((r, i) => r.primary && legacyRoot ? null : folders[i]).filter((f) => !!f)
+  );
+  for (const [i, repo] of repos.entries()) {
+    const folder = folders[i];
+    const atRoot = !!repo.primary && legacyRoot;
+    const dir2 = repoDir(target, repo, folder, legacyRoot);
+    const label = repo.primary ? "primary repo" : `repo ${folder}`;
+    if (!repo.url) {
+      if (!existsSync4(join6(dir2, ".git"))) {
+        emit("git", `Initializing ${label}\u2026`);
+        await mkdir(dir2, { recursive: true });
+        await run2("git", ["init"], { cwd: dir2, timeout: 2e4 });
       }
       continue;
     }
-    const dir2 = join6(target, subDirName(repo));
-    if (repo.url) {
-      if (existsSync4(join6(dir2, ".git"))) {
-        if (mode === "sync") {
-          await updateRepo(dir2, `sub-repo ${subDirName(repo)}`, repo.branch, emit);
-        } else if (mode === "force") {
-          emit("git", `Re-cloning sub-repo ${repo.url} (force)\u2026`);
-          await rm(dir2, { recursive: true, force: true });
-          await run2("git", cloneArgs(repo.url, dir2, repo.branch), { timeout: 12e4 });
-        } else {
-          emit("git", `Sub-repo ${subDirName(repo)} already present \u2014 skipping clone.`);
-        }
-        continue;
+    if (existsSync4(join6(dir2, ".git"))) {
+      if (mode === "sync") {
+        await updateRepo(dir2, label, repo.branch, emit);
+      } else if (mode === "force" && atRoot) {
+        emit("git", `Re-cloning ${repo.url} (force)\u2026`);
+        const tmp = `${target}.4pm-reclone`;
+        await rm(tmp, { recursive: true, force: true });
+        await run2("git", cloneArgs(repo.url, tmp, repo.branch), { timeout: 12e4 });
+        for (const entry of await readdir(target)) {
+          if (foldersToKeep.has(entry)) continue;
+          await rm(join6(target, entry), { recursive: true, force: true });
+        }
+        for (const entry of await readdir(tmp)) {
+          if (foldersToKeep.has(entry)) continue;
+          await rename(join6(tmp, entry), join6(target, entry));
+        }
+        await rm(tmp, { recursive: true, force: true });
+      } else if (mode === "force") {
+        emit("git", `Re-cloning ${repo.url} (force)\u2026`);
+        await rm(dir2, { recursive: true, force: true });
+        await run2("git", cloneArgs(repo.url, dir2, repo.branch), { timeout: 12e4 });
+      } else {
+        emit("git", `${label} already present \u2014 skipping clone.`);
       }
-      emit("git", `Cloning sub-repo ${repo.url}\u2026`);
-      await run2("git", cloneArgs(repo.url, dir2, repo.branch), { timeout: 12e4 });
-    } else {
-      emit("git", `Initializing sub-repo ${subDirName(repo)}\u2026`);
-      await mkdir(dir2, { recursive: true });
-      await run2("git", ["init"], { cwd: dir2, timeout: 2e4 });
+      continue;
     }
+    emit("git", `Cloning ${repo.url}\u2026`);
+    await run2("git", cloneArgs(repo.url, dir2, repo.branch), { timeout: 12e4 });
   }
 }
 async function ensureReposCloned(physicRoot, repos, emit) {
   if (repos.length === 0) return;
-  await provisionRepos(physicRoot, repos, emit ?? (() => void 0), { clonePrimary: true });
+  await provisionRepos(physicRoot, repos, emit ?? (() => void 0));
 }
 function sampleDir() {
   if (process.env.SCAFFOLD_SAMPLE_DIR) return process.env.SCAFFOLD_SAMPLE_DIR;
@@ -34569,19 +34601,17 @@ async function scaffoldProject(payload, profileDir2, onProgress) {
     const root = process.env.SCAFFOLD_ROOT ? resolve(process.env.SCAFFOLD_ROOT) : resolve(profileDir2);
     const target = join6(root, payload.projectName);
     await mkdir(target, { recursive: true });
-    emit("copy", "Copying the sample template\u2026");
-    await cp(sampleDir(), target, { recursive: true, force: false, errorOnExist: false });
-    if (payload.spec) {
-      emit("spec", "Writing project.spec.json\u2026");
-      await writeFile(
-        join6(target, "project.spec.json"),
-        JSON.stringify(payload.spec, null, 2),
-        "utf8"
-      );
-    }
     const repos = reposOf(payload.spec);
-    if (repos.length > 0) await provisionRepos(target, repos, emit);
-    if (payload.spec) await aiInit(target, payload.spec, emit);
+    if (repos.length > 0) {
+      emit("git", "Cloning repositories\u2026");
+      await provisionRepos(target, repos, emit);
+      const folders = repoFolders(repos);
+      for (let i = 0; i < repos.length; i++) {
+        await scaffoldRepo(join6(target, folders[i]), folders[i], payload.spec, emit);
+      }
+    } else {
+      await scaffoldRepo(target, payload.projectName, payload.spec, emit);
+    }
     emit("version", "Writing .4pm/.4pm.json\u2026");
     await writeTemplateMarker(target);
     onProgress?.({ projectId: payload.projectId, step: "done", message: "Scaffold complete.", done: true });
@@ -34590,6 +34620,16 @@ async function scaffoldProject(payload, profileDir2, onProgress) {
     return { ok: false, error: err instanceof Error ? err.message : String(err), step: lastStep };
   }
 }
+async function scaffoldRepo(dir2, label, spec, emit) {
+  await mkdir(dir2, { recursive: true });
+  emit("copy", `Copying the sample template into ${label}\u2026`);
+  await cp(sampleDir(), dir2, { recursive: true, force: false, errorOnExist: false });
+  if (spec) {
+    emit("spec", `Writing project.spec.json into ${label}\u2026`);
+    await writeFile(join6(dir2, "project.spec.json"), JSON.stringify(spec, null, 2), "utf8");
+    await aiInit(dir2, spec, emit);
+  }
+}
 async function writeTemplateMarker(target) {
   const dir2 = join6(target, ".4pm");
   await mkdir(dir2, { recursive: true });
@@ -34622,6 +34662,11 @@ ${specJson}`
   await generateFile(
     join6(target, "CLAUDE.md"),
     `Write a CLAUDE.md (Markdown only, no preamble) with guidance/conventions for AI agents working in this project, derived from its spec JSON:
+${specJson}`
+  );
+  await generateFile(
+    join6(target, "AGENT.md"),
+    `Write an AGENT.md (Markdown only, no preamble) with guidance/conventions for AI agents working in this project, derived from its spec JSON:
 ${specJson}`
   );
 }
@@ -34644,7 +34689,10 @@ async function addProject(payload, profileDir2, onProgress) {
     await mkdir(target, { recursive: true });
     const repos = payload.repos ?? [];
     const mode = payload.mode ?? "clone";
-    if (repos.length > 0) await provisionRepos(target, repos, emit, { clonePrimary: true, mode });
+    if (repos.length > 0) await provisionRepos(target, repos, emit, { mode });
+    for (const sub of payload.scaffoldRepos ?? []) {
+      await scaffoldRepo(join6(target, sub), sub, payload.spec, emit);
+    }
     onProgress?.({ projectId: payload.projectId, step: "done", message: "Project added.", done: true });
     return { ok: true, path: target };
   } catch (err) {
@@ -36449,7 +36497,7 @@ var DOC_EXTENSIONS = [".md", ".mdx", ".txt"];
 function kbRoot(profileDir2) {
   return join14(profileDir2, "support-kb");
 }
-function repoDir(profileDir2, url, branch) {
+function repoDir2(profileDir2, url, branch) {
   const key = createHash3("sha1").update(`${url}#${branch}`).digest("hex").slice(0, 16);
   return join14(kbRoot(profileDir2), key);
 }
@@ -36459,7 +36507,7 @@ function authedUrl(url, token) {
   return url;
 }
 async function ensureRepo(profileDir2, repo) {
-  const dir2 = repoDir(profileDir2, repo.url, repo.branch);
+  const dir2 = repoDir2(profileDir2, repo.url, repo.branch);
   if (existsSync10(join14(dir2, ".git"))) return dir2;
   const url = authedUrl(repo.url, repo.token);
   const gitEnv = { ...process.env, GIT_TERMINAL_PROMPT: "0" };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@4pm/cli",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "private": false,
   "description": "4PM CLI — drives Claude/Codex CLIs on AI worker machines (Node + TypeScript)",
   "license": "LicenseRef-4PM-Source-Available",