create-egregore 0.15.0 → 0.16.0

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) {
@@ -168,6 +189,43 @@ function cloneRepo(url, dir, token, ui, label) {
   ui.success(`Cloned ${label}`);
 }
 
+/**
+ * Convert HTTPS GitHub URL to SSH format.
+ * https://github.com/org/repo.git → git@github.com:org/repo.git
+ */
+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.
+ * GIT_TERMINAL_PROMPT=0 prevents the hanging username/password prompt.
+ */
+function cloneWithFallback(httpsUrl, dir, timeout = 60000) {
+  const env = { ...process.env, GIT_TERMINAL_PROMPT: "0" };
+  const sshUrl = toSSH(httpsUrl);
+
+  // Try SSH first (most devs have SSH keys; GitHub no longer supports HTTPS password auth)
+  if (sshUrl) {
+    try {
+      execFileSync("git", ["clone", sshUrl, dir], { stdio: "pipe", encoding: "utf-8", timeout, env });
+      return true;
+    } catch {
+      // Clean up partial clone so HTTPS fallback can use the same dir
+      try { fs.rmSync(dir, { recursive: true, force: true }); } catch {}
+    }
+  }
+
+  // Fall back to HTTPS (works if user has gh CLI or a credential helper configured)
+  try {
+    execFileSync("git", ["clone", httpsUrl, dir], { stdio: "pipe", encoding: "utf-8", timeout, env });
+    return true;
+  } catch {}
+
+  return false;
+}
+
 function setGitIdentity(dir, user) {
   try {
     run(`git config user.name "${user.name}"`, { cwd: dir });
@@ -280,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("");
@@ -360,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`);
@@ -401,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) {
@@ -422,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");
@@ -482,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.`);
     }
   }
 
@@ -508,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
@@ -548,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.`);
@@ -602,16 +703,16 @@ async function localJoinFlow(orgArg, ui) {
 
   console.log("");
   const s2 = ui.spinner(`Cloning ${orgLogin}/${repoName}...`);
-  try {
-    execFileSync("git", ["clone", `https://github.com/${orgLogin}/${repoName}.git`, egregoreDir], { stdio: "pipe", encoding: "utf-8", timeout: 60000 });
+  if (cloneWithFallback(`https://github.com/${orgLogin}/${repoName}.git`, egregoreDir)) {
     s2.stop(`Cloned ${repoName}`);
-  } catch (err) {
+  } else {
     s2.fail(`Could not clone ${orgLogin}/${repoName}`);
     ui.error("Make sure you have git credentials set up (SSH keys or gh auth login).");
     ui.error("Also verify the org admin has set up Egregore and invited you.");
     process.exit(1);
   }
   setGitIdentity(egregoreDir, user);
+  ensureDevelop(egregoreDir);
 
   // 6. Read egregore.json from local clone
   const configPath = path.join(egregoreDir, "egregore.json");
@@ -642,12 +743,11 @@ async function localJoinFlow(orgArg, ui) {
   // Store the invite token for later use (invitation acceptance, not cloning)
   const inviteToken = githubToken;
 
-  // Clone memory using git credentials (same as main repo — no token in URL)
+  // Clone memory using SSH-first fallback (same as main repo)
   ui.step(1, totalSteps, "Cloning shared memory...");
-  try {
-    execFileSync("git", ["clone", memoryUrl, memoryDir], { stdio: "pipe", encoding: "utf-8", timeout: 60000 });
+  if (cloneWithFallback(memoryUrl, memoryDir)) {
     ui.success("Cloned memory");
-  } catch {
+  } else {
     ui.warn("Could not clone memory repo — you may not have access yet.");
   }
   setGitIdentity(memoryDir, user);
@@ -683,17 +783,17 @@ async function localJoinFlow(orgArg, ui) {
   registerInstance(repoName, orgName, egregoreDir);
   const alias = await installShellAlias(egregoreDir, ui);
 
-  // Clone managed repos using git credentials
+  // 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);
-    try {
-      execFileSync("git", ["clone", `https://github.com/${orgLogin}/${mr}.git`, repoDir], { stdio: "pipe", encoding: "utf-8", timeout: 60000 });
+    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}`);
-    } catch {
-      ui.warn(`Could not clone ${mr} — you may not have access yet.`);
+      ui.success(`Cloned ${mrName}`);
+    } else {
+      ui.warn(`Could not clone ${mrName} — you may not have access yet.`);
     }
   }
 
@@ -727,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

@@ -138,6 +138,7 @@ async function install(data, ui, targetDir) {
     try { run(`git remote set-url origin ${fork_url}`, { cwd: egregoreDir }); } catch {}
   }
   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)
@@ -246,6 +247,7 @@ async function install(data, ui, targetDir) {
         try { run(`git remote set-url origin ${repoUrl}`, { cwd: repoDir }); } catch {}
       }
       try { run("git config credential.helper store", { cwd: repoDir }); } catch {}
+      ensureDevelop(repoDir);
       clonedRepos.push(repoName);
       ui.success(`Cloned ${repoName}`);
     } catch {
@@ -274,6 +276,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/`);
@@ -415,5 +462,6 @@ module.exports = {
   embedToken,
   configureGitCredentials,
   initMemoryDirs,
+  ensureDevelop,
   run,
 };

package/package.json

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