create-egregore 0.15.1 → 0.16.1

package/lib/api.js

@@ -95,6 +95,13 @@ class EgregoreAPI {
     });
   }
 
+  async registerOrg(githubToken, { org_name, github_org, slug }) {
+    return request("POST", `${this.base}/api/org/register`, {
+      headers: { Authorization: `Bearer ${githubToken}` },
+      body: { org_name, github_org, slug },
+    });
+  }
+
   async exchangeCode(code) {
     return request("POST", `${this.base}/api/auth/github/callback`, {
       body: { code },

package/lib/local.js

@@ -15,8 +15,10 @@ const {
   embedToken,
   configureGitCredentials,
   initMemoryDirs,
+  ensureDevelop,
   run,
 } = require("./setup");
+const { EgregoreAPI } = require("./api");
 
 // Template repo for new egregore instances (OSS)
 const TEMPLATE_OWNER = "egregore-labs";
@@ -146,6 +148,25 @@ async function addCollaborator(token, owner, repo, username) {
   return status === 201 || status === 204;
 }
 
+// ── Branch detection for existing repos ────────────────────────────
+
+async function detectRepoBranches(token, owner, repoName) {
+  const { status, data } = await ghApi("GET", `/repos/${owner}/${repoName}/branches?per_page=100`, token);
+  if (status !== 200 || !Array.isArray(data)) return null;
+  const branches = data.map((b) => b.name);
+  // Detect default branch via repo API
+  const { status: repoStatus, data: repoData } = await ghApi("GET", `/repos/${owner}/${repoName}`, token);
+  const defaultBranch = repoStatus === 200 ? repoData.default_branch || "main" : "main";
+  return {
+    name: repoName,
+    defaultBranch,
+    hasDevelop: branches.includes("develop"),
+    branches,
+    branchCount: branches.length,
+    contributors: branches.filter((b) => b.startsWith("dev/")).map((b) => b.split("/")[1]).filter((v, i, a) => a.indexOf(v) === i),
+  };
+}
+
 // ── Clone + local file helpers ──────────────────────────────────────
 
 function cloneRepo(url, dir, token, ui, label) {
@@ -317,16 +338,42 @@ async function localFounderFlow(ui) {
     } catch {
       s0.stop("Could not load repos");
     }
+
+    // Detect default branch for each selected repo and convert to {name, base_branch} format
+    if (selectedRepos.length > 0) {
+      const s0b = ui.spinner("Checking branch setup...");
+      const reposWithBranch = [];
+      for (const repoName of selectedRepos) {
+        try {
+          const info = await detectRepoBranches(githubToken, githubOrg, repoName);
+          reposWithBranch.push({ name: repoName, base_branch: info ? info.defaultBranch : "main" });
+        } catch {
+          reposWithBranch.push({ name: repoName, base_branch: "main" });
+        }
+      }
+      s0b.stop("Checked branches");
+      // Replace flat list with enriched objects
+      selectedRepos = reposWithBranch;
+      console.log("");
+      ui.info("Detected branch setup:");
+      for (const repo of reposWithBranch) {
+        ui.info(`  ${ui.cyan(repo.name)} — PRs will target ${ui.bold(repo.base_branch)}`);
+      }
+      console.log("");
+    }
   }
 
   // 6. Derive repo names from team name
-  const slug = orgName
+  const nameSlug = orgName
     .toLowerCase()
     .replace(/[^a-z0-9-]/g, "-")
     .replace(/-+/g, "-")
     .replace(/^-|-$/g, "") || "egregore";
-  const repoName = slug;
-  const memoryRepoName = `${slug}-memory`;
+  // Org slug prefixed with GitHub owner — globally unique across all egregores
+  const ghPrefix = githubOrg.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  const slug = ghPrefix === nameSlug ? nameSlug : `${ghPrefix}-${nameSlug}`;
+  const repoName = nameSlug;
+  const memoryRepoName = `${nameSlug}-memory`;
 
   // Guard: if egregore repo already exists with a config, don't overwrite
   console.log("");
@@ -397,13 +444,13 @@ async function localFounderFlow(ui) {
     const s3 = ui.spinner(`Creating ${newProjectRepo}...`);
     const projExists = await repoExists(githubToken, githubOrg, newProjectRepo);
     if (projExists) {
-      selectedRepos.push(newProjectRepo);
+      selectedRepos.push({ name: newProjectRepo });
       s3.stop(`${newProjectRepo} already exists — added to managed repos`);
     } else {
       try {
         await createRepo(githubToken, githubOrg, newProjectRepo, isOrg, description || "");
         if (await waitForRepo(githubToken, githubOrg, newProjectRepo)) {
-          selectedRepos.push(newProjectRepo);
+          selectedRepos.push({ name: newProjectRepo });
           s3.stop(`Created ${newProjectRepo}`);
         } else {
           s3.fail(`${newProjectRepo} creation timed out`);
@@ -438,6 +485,15 @@ async function localFounderFlow(ui) {
     );
   } catch {}
 
+  // 8b. Register org with Egregore API (non-blocking — local mode works without it)
+  //     Respects DO_NOT_TRACK (https://consult.gov.uk/digital-communications/online-advertising/supporting_documents/DNT%20standard%20v10.pdf)
+  if (!process.env.DO_NOT_TRACK && !process.env.EGREGORE_NO_TELEMETRY) {
+    try {
+      const api = new EgregoreAPI();
+      await api.registerOrg(githubToken, { org_name: orgName, github_org: githubOrg, slug });
+    } catch {}
+  }
+
   // 9. Init memory dirs on remote (so joiners get the structure)
   const memDirs = ["people", "handoffs", "knowledge/decisions", "knowledge/patterns", "knowledge/findings", "quests", "wraps"];
   for (const d of memDirs) {
@@ -459,6 +515,7 @@ async function localFounderFlow(ui) {
   ui.step(1, totalSteps, "Cloning egregore...");
   cloneRepo(forkUrl, egregoreDir, githubToken, ui, "egregore");
   setGitIdentity(egregoreDir, user);
+  ensureDevelop(egregoreDir);
 
   ui.step(2, totalSteps, "Cloning shared memory...");
   cloneRepo(memoryUrl, memoryDir, githubToken, ui, "memory");
@@ -519,15 +576,20 @@ async function localFounderFlow(ui) {
 
   // 16. Clone managed repos
   for (let i = 0; i < selectedRepos.length; i++) {
-    const mr = selectedRepos[i];
-    ui.step(5 + i, totalSteps, `Cloning ${mr}...`);
-    const repoDir = path.join(base, mr);
+    const entry = selectedRepos[i];
+    const mrName = typeof entry === "string" ? entry : entry.name;
+    ui.step(5 + i, totalSteps, `Cloning ${mrName}...`);
+    const repoDir = path.join(base, mrName);
     try {
-      const repoUrl = `https://github.com/${githubOrg}/${mr}.git`;
-      cloneRepo(repoUrl, repoDir, githubToken, ui, mr);
+      const repoUrl = `https://github.com/${githubOrg}/${mrName}.git`;
+      cloneRepo(repoUrl, repoDir, githubToken, ui, mrName);
       setGitIdentity(repoDir, user);
+      // New repos get develop branch (our workflow). Existing repos keep their default.
+      if (isNewProject) {
+        ensureDevelop(repoDir);
+      }
     } catch {
-      ui.warn(`Could not clone ${mr} — you may not have access.`);
+      ui.warn(`Could not clone ${mrName} — you may not have access.`);
     }
   }
 
@@ -545,8 +607,9 @@ async function localFounderFlow(ui) {
       // Add as collaborator to all repos
       await addCollaborator(githubToken, githubOrg, repoName, invUsername);
       await addCollaborator(githubToken, githubOrg, memoryRepoName, invUsername);
-      for (const mr of selectedRepos) {
-        await addCollaborator(githubToken, githubOrg, mr, invUsername).catch(() => {});
+      for (const entry of selectedRepos) {
+        const mrName = typeof entry === "string" ? entry : entry.name;
+        await addCollaborator(githubToken, githubOrg, mrName, invUsername).catch(() => {});
       }
 
       // Create person file
@@ -585,8 +648,9 @@ async function localFounderFlow(ui) {
   ui.info("Your workspace:");
   ui.info(`  ${ui.cyan(`./${repoName}/`)}  — Your Egregore instance`);
   ui.info(`  ${ui.cyan(`./${memoryRepoName}/`)} — Shared knowledge`);
-  for (const mr of selectedRepos) {
-    ui.info(`  ${ui.cyan(`./${mr}/`)}  — Managed repo`);
+  for (const entry of selectedRepos) {
+    const mrName = typeof entry === "string" ? entry : entry.name;
+    ui.info(`  ${ui.cyan(`./${mrName}/`)}  — Managed repo`);
   }
   console.log("");
   ui.info(`Next: open a ${ui.bold("new terminal")} and type ${ui.bold(alias.aliasName)} to start.`);
@@ -648,6 +712,7 @@ async function localJoinFlow(orgArg, ui) {
     process.exit(1);
   }
   setGitIdentity(egregoreDir, user);
+  ensureDevelop(egregoreDir);
 
   // 6. Read egregore.json from local clone
   const configPath = path.join(egregoreDir, "egregore.json");
@@ -720,14 +785,15 @@ async function localJoinFlow(orgArg, ui) {
 
   // Clone managed repos using SSH-first fallback
   for (let i = 0; i < managedRepos.length; i++) {
-    const mr = managedRepos[i];
-    ui.step(5 + i, totalSteps, `Cloning ${mr}...`);
-    const repoDir = path.join(base, mr);
-    if (cloneWithFallback(`https://github.com/${orgLogin}/${mr}.git`, repoDir)) {
+    const entry = managedRepos[i];
+    const mrName = typeof entry === "string" ? entry : entry.name;
+    ui.step(5 + i, totalSteps, `Cloning ${mrName}...`);
+    const repoDir = path.join(base, mrName);
+    if (cloneWithFallback(`https://github.com/${orgLogin}/${mrName}.git`, repoDir)) {
       setGitIdentity(repoDir, user);
-      ui.success(`Cloned ${mr}`);
+      ui.success(`Cloned ${mrName}`);
     } else {
-      ui.warn(`Could not clone ${mr} — you may not have access yet.`);
+      ui.warn(`Could not clone ${mrName} — you may not have access yet.`);
     }
   }
 
@@ -761,8 +827,9 @@ async function localJoinFlow(orgArg, ui) {
   ui.info("Your workspace:");
   ui.info(`  ${ui.cyan(`./${repoName}/`)}  — Egregore instance`);
   ui.info(`  ${ui.cyan(`./${memoryRepoName}/`)} — Shared knowledge`);
-  for (const mr of managedRepos) {
-    ui.info(`  ${ui.cyan(`./${mr}/`)}  — Managed repo`);
+  for (const entry of managedRepos) {
+    const mrName = typeof entry === "string" ? entry : entry.name;
+    ui.info(`  ${ui.cyan(`./${mrName}/`)}  — Managed repo`);
   }
   console.log("");
   ui.info(`Next: open a ${ui.bold("new terminal")} and type ${ui.bold(alias.aliasName)} to start.`);

package/lib/setup.js

@@ -118,26 +118,21 @@ async function install(data, ui, targetDir) {
 
   const totalSteps = 5 + repos.length;
 
-  // Configure git credential helper for HTTPS cloning
-  configureGitCredentials(github_token);
-
   // Accept pending repo collaboration invitations (joiners get invited as collaborators)
   await acceptPendingInvitations(github_token, github_org, ui);
 
-  // Embed token in URLs as fallback for private repos (credential helper may not work)
-  const authedForkUrl = embedToken(fork_url, github_token);
-  const authedMemoryUrl = embedToken(memory_url, github_token);
-
-  // 1. Clone fork
+  // 1. Clone fork (SSH first, HTTPS fallback — no token embedding)
   ui.step(1, totalSteps, "Cloning egregore...");
   if (fs.existsSync(egregoreDir)) {
     ui.warn("egregore/ already exists — pulling latest");
     run("git pull", { cwd: egregoreDir });
   } else {
-    execFileSync("git", ["clone", authedForkUrl, egregoreDir], { stdio: "pipe", encoding: "utf-8", timeout: 60000 });
-    try { run(`git remote set-url origin ${fork_url}`, { cwd: egregoreDir }); } catch {}
+    if (!cloneRepo(fork_url, egregoreDir)) {
+      throw new Error(`Command failed: git clone ${fork_url} ${egregoreDir}\nCloning into '${egregoreDir}'...\nMake sure you have SSH keys set up or run 'gh auth login' first.`);
+    }
   }
   try { run("git config credential.helper store", { cwd: egregoreDir }); } catch {}
+  ensureDevelop(egregoreDir);
   ui.success("Cloned egregore");
 
   // Set repo-local git identity from GitHub user (not machine-global config)
@@ -156,8 +151,9 @@ async function install(data, ui, targetDir) {
     ui.warn(`${memoryDirName}/ already exists — pulling latest`);
     run("git pull", { cwd: memoryDir });
   } else {
-    execFileSync("git", ["clone", authedMemoryUrl, memoryDir], { stdio: "pipe", encoding: "utf-8", timeout: 60000 });
-    try { run(`git remote set-url origin ${memory_url}`, { cwd: memoryDir }); } catch {}
+    if (!cloneRepo(memory_url, memoryDir)) {
+      ui.warn(`Could not clone memory repo — you may need SSH keys or 'gh auth login'`);
+    }
   }
   try { run("git config credential.helper store", { cwd: memoryDir }); } catch {}
   if (github_username) {
@@ -242,10 +238,12 @@ async function install(data, ui, targetDir) {
         run("git pull", { cwd: repoDir });
       } else {
         const repoUrl = `https://github.com/${github_org}/${repoName}.git`;
-        execFileSync("git", ["clone", embedToken(repoUrl, github_token), repoDir], { stdio: "pipe", encoding: "utf-8", timeout: 60000 });
-        try { run(`git remote set-url origin ${repoUrl}`, { cwd: repoDir }); } catch {}
+        if (!cloneRepo(repoUrl, repoDir)) {
+          throw new Error(`Clone failed for ${repoName}`);
+        }
       }
       try { run("git config credential.helper store", { cwd: repoDir }); } catch {}
+      ensureDevelop(repoDir);
       clonedRepos.push(repoName);
       ui.success(`Cloned ${repoName}`);
     } catch {
@@ -274,6 +272,51 @@ async function install(data, ui, targetDir) {
   console.log("");
 }
 
+/**
+ * Ensure a cloned repo has a develop branch. Creates from default branch and pushes if missing.
+ * Idempotent — safe to call on repos that already have develop.
+ */
+function ensureDevelop(repoDir) {
+  try {
+    // Check if develop already exists on remote
+    const remoteRefs = execFileSync("git", ["-C", repoDir, "ls-remote", "--heads", "origin", "develop"], {
+      stdio: "pipe", encoding: "utf-8", timeout: 15000,
+    }).trim();
+    if (remoteRefs) return; // develop already exists on remote
+
+    // Detect default branch (main, master, or whatever origin/HEAD points to)
+    let defaultBranch = "";
+    try {
+      const head = execFileSync("git", ["-C", repoDir, "symbolic-ref", "refs/remotes/origin/HEAD"], {
+        stdio: "pipe", encoding: "utf-8", timeout: 5000,
+      }).trim();
+      defaultBranch = head.replace("refs/remotes/origin/", "");
+    } catch {}
+    if (!defaultBranch) {
+      for (const candidate of ["main", "master"]) {
+        try {
+          execFileSync("git", ["-C", repoDir, "show-ref", "--verify", "--quiet", `refs/remotes/origin/${candidate}`], {
+            stdio: "pipe", timeout: 5000,
+          });
+          defaultBranch = candidate;
+          break;
+        } catch {}
+      }
+    }
+    if (!defaultBranch) return; // no default branch found — skip
+
+    // Create develop from default branch and push
+    execFileSync("git", ["-C", repoDir, "branch", "develop", `origin/${defaultBranch}`], {
+      stdio: "pipe", encoding: "utf-8", timeout: 5000,
+    });
+    execFileSync("git", ["-C", repoDir, "push", "-u", "origin", "develop"], {
+      stdio: "pipe", encoding: "utf-8", timeout: 30000,
+    });
+  } catch {
+    // Non-fatal — session-start.sh will retry on first launch
+  }
+}
+
 function embedToken(url, token) {
   try {
     return url.replace("https://github.com/", `https://x-access-token:${token}@github.com/`);
@@ -282,6 +325,37 @@ function embedToken(url, token) {
   }
 }
 
+function toSSH(url) {
+  const m = url.match(/https:\/\/github\.com\/(.+?)(?:\.git)?$/);
+  return m ? `git@github.com:${m[1]}.git` : null;
+}
+
+/**
+ * Clone a repo, trying SSH first then HTTPS (no token embedded).
+ * The repo:invite-scoped OAuth token can't clone — we rely on the
+ * user's own git credentials (SSH keys / gh CLI / credential helper).
+ */
+function cloneRepo(httpsUrl, dir, timeout = 60000) {
+  const env = { ...process.env, GIT_TERMINAL_PROMPT: "0" };
+  const sshUrl = toSSH(httpsUrl);
+
+  if (sshUrl) {
+    try {
+      execFileSync("git", ["clone", sshUrl, dir], { stdio: "pipe", encoding: "utf-8", timeout, env });
+      return true;
+    } catch {
+      try { fs.rmSync(dir, { recursive: true, force: true }); } catch {}
+    }
+  }
+
+  try {
+    execFileSync("git", ["clone", httpsUrl, dir], { stdio: "pipe", encoding: "utf-8", timeout, env });
+    return true;
+  } catch {}
+
+  return false;
+}
+
 function configureGitCredentials(token) {
   try {
     // Use --global since this runs before any repos are cloned (no local .git exists)
@@ -415,5 +489,6 @@ module.exports = {
   embedToken,
   configureGitCredentials,
   initMemoryDirs,
+  ensureDevelop,
   run,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-egregore",
-  "version": "0.15.1",
+  "version": "0.16.1",
   "description": "Set up Egregore for your team in one command",
   "license": "MIT",
   "bin": {