create-egregore 0.16.3 → 0.17.1

package/bin/cli.js

@@ -10,10 +10,13 @@
  *   npx create-egregore join <org>         (local mode — join existing)
  */
 
+const fs = require("node:fs");
+const path = require("node:path");
 const ui = require("../lib/ui");
 const { EgregoreAPI } = require("../lib/api");
 const { deviceFlow } = require("../lib/auth");
 const { install, ghApi } = require("../lib/setup");
+const { detectContext, isWritable, isSystemDir } = require("../lib/context");
 
 const API_URL = process.env.EGREGORE_API_URL || "https://egregore-production-55f2.up.railway.app";
 
@@ -29,6 +32,8 @@ function parseArgs(argv) {
       args.api = argv[++i];
     } else if (argv[i] === "--open") {
       args.open = true;
+    } else if (argv[i] === "--force") {
+      args.force = true;
     } else if (argv[i] === "--help" || argv[i] === "-h") {
       args.help = true;
     } else if (!argv[i].startsWith("-")) {
@@ -42,6 +47,104 @@ function parseArgs(argv) {
   return args;
 }
 
+/**
+ * If cwd is inside a git repo, show the "sibling shell" notice and offer a
+ * redirect. Returns { targetDir, prefilledRepo } — prefilledRepo is non-null
+ * only when we detected a repo. Caller passes both through to downstream flows.
+ *
+ * Bypassed entirely by --force.
+ */
+async function maybeRedirect(force) {
+  if (force) return { targetDir: process.cwd(), prefilledRepo: null };
+
+  const ctx = detectContext();
+  if (!ctx) return { targetDir: process.cwd(), prefilledRepo: null };
+
+  const { repoName, parentDir, originOwner, originName } = ctx;
+
+  // Non-TTY guard: we can't prompt. Fail loudly so CI/Docker/piped scripts
+  // don't hang forever on readline.
+  if (!process.stdin.isTTY) {
+    console.log("");
+    ui.error(`Detected a git repo at ./${repoName} but stdin is not a TTY — cannot prompt.`);
+    ui.info("Re-run from outside the repo, or pass --force to install here anyway.");
+    process.exit(1);
+  }
+
+  const parentWritable = isWritable(parentDir);
+  const parentIsSystem = isSystemDir(parentDir);
+
+  console.log("");
+  ui.warn(`You're inside a git repo: ${ui.bold(`./${repoName}`)}`);
+  console.log("");
+  ui.info("Egregore lives as a sibling shell that manages your repos,");
+  ui.info("not inside them. Your repo stays where it is.");
+
+  if (parentIsSystem) {
+    console.log("");
+    ui.warn(`The parent directory (${parentDir}) looks like a system or home root — not a good place for an Egregore workspace.`);
+  }
+
+  const choices = [];
+  // Offer the parent redirect only if it's writable AND not a system dir.
+  if (parentWritable && !parentIsSystem) {
+    choices.push({
+      label: `Install in ${parentDir}`,
+      description: `Set up alongside ${repoName} and add it to managed repos (Recommended)`,
+      action: "parent",
+    });
+  }
+  choices.push({
+    label: "Pick a different directory",
+    description: "Choose where to install Egregore",
+    action: "pick",
+  });
+  choices.push({
+    label: "Cancel",
+    description: "Exit without changes",
+    action: "cancel",
+  });
+
+  const choice = await ui.choose("How would you like to proceed?", choices);
+
+  if (choice.action === "cancel") {
+    console.log("");
+    ui.info("Cancelled. Run from a clean directory, or pass --force to override.");
+    process.exit(0);
+  }
+
+  let targetDir = parentDir;
+  if (choice.action === "pick") {
+    const answer = await ui.prompt("Install directory (absolute path):");
+    if (!answer) {
+      ui.error("No directory provided");
+      process.exit(1);
+    }
+    targetDir = path.resolve(answer);
+    if (isSystemDir(targetDir)) {
+      ui.error(`${targetDir} looks like a system directory — pick something under your home or projects folder.`);
+      process.exit(1);
+    }
+    try {
+      if (!fs.existsSync(targetDir)) fs.mkdirSync(targetDir, { recursive: true });
+      fs.accessSync(targetDir, fs.constants.W_OK);
+    } catch (err) {
+      ui.error(`Cannot write to ${targetDir}: ${err.message}`);
+      process.exit(1);
+    }
+  }
+
+  return {
+    targetDir,
+    prefilledRepo: {
+      name: originName || repoName,
+      owner: originOwner,
+      localName: repoName,
+      toplevel: ctx.toplevel,
+    },
+  };
+}
+
 function showHelp() {
   ui.banner();
   ui.info("Usage:");
@@ -51,9 +154,10 @@ function showHelp() {
   ui.info("  npx create-egregore --token <setup-token>    Install from website");
   ui.info("");
   ui.info("Options:");
-  ui.info("  --open           Local mode — no API server needed");
+  ui.info("  --open            Local mode — no API server needed");
   ui.info("  --token <token>   Setup token from egregore.xyz");
   ui.info("  --api <url>       API URL override");
+  ui.info("  --force           Skip the in-repo detection check");
   ui.info("  -h, --help        Show this help");
   ui.info("");
 }
@@ -68,10 +172,12 @@ async function main() {
 
   ui.banner();
 
+  const ctx = await maybeRedirect(args.force);
+
   if (args.token) {
-    // ===== Connected mode: token provided (unchanged) =====
+    // ===== Connected mode: token provided =====
     const api = new EgregoreAPI(args.api || API_URL);
-    await tokenFlow(api, args.token);
+    await tokenFlow(api, args.token, ctx);
   } else if (args.subcommand === "join") {
     // ===== Local mode: join existing =====
     if (!args.joinOrg) {
@@ -79,19 +185,19 @@ async function main() {
       process.exit(1);
     }
     const { localJoinFlow } = require("../lib/local");
-    await localJoinFlow(args.joinOrg, ui);
+    await localJoinFlow(args.joinOrg, ui, ctx);
   } else if (args.open) {
     // ===== Local mode: founder (explicit opt-in) =====
     const { localFounderFlow } = require("../lib/local");
-    await localFounderFlow(ui);
+    await localFounderFlow(ui, ctx);
   } else {
     // ===== Interactive API flow (default — existing behavior) =====
     const api = new EgregoreAPI(args.api || API_URL);
-    await interactiveFlow(api);
+    await interactiveFlow(api, ctx);
   }
 }
 
-async function tokenFlow(api, token) {
+async function tokenFlow(api, token, ctx) {
   const s = ui.spinner("Claiming setup token...");
   let data;
   try {
@@ -119,15 +225,30 @@ async function tokenFlow(api, token) {
     }
   }
 
+  // Token-mode setups already have their repo list baked in server-side. If
+  // the user's current working repo happens to match a managed-repo name, skip
+  // the clone/pull/configure step for it so we don't clobber uncommitted work.
+  const skipRepos = new Set();
+  if (ctx.prefilledRepo && Array.isArray(data.repos)) {
+    for (const r of data.repos) {
+      const n = typeof r === "string" ? r : r && r.name;
+      if (n && n === ctx.prefilledRepo.name) skipRepos.add(n);
+    }
+  }
   try {
-    await install(data, ui);
+    await install(data, ui, ctx.targetDir, { skipRepos });
+    if (ctx.prefilledRepo && skipRepos.size === 0) {
+      console.log("");
+      ui.info(`Tip: add your current repo to managed_repos with:`);
+      ui.info(`  /add ${ctx.prefilledRepo.toplevel || `../${ctx.prefilledRepo.localName}`}`);
+    }
   } catch (err) {
     ui.error(`Install failed: ${err.message}`);
     process.exit(1);
   }
 }
 
-async function interactiveFlow(api) {
+async function interactiveFlow(api, ctx) {
   // 1. GitHub auth
   ui.info("Let's set up Egregore. First, sign in with GitHub.\n");
   let githubToken;
@@ -227,13 +348,13 @@ async function interactiveFlow(api) {
   // 5. Execute
   console.log("");
   if (choice.action === "join") {
-    await joinFlow(api, githubToken, choice);
+    await joinFlow(api, githubToken, choice, ctx);
   } else {
-    await setupFlow(api, githubToken, choice);
+    await setupFlow(api, githubToken, choice, ctx);
   }
 }
 
-async function setupFlow(api, githubToken, choice) {
+async function setupFlow(api, githubToken, choice, ctx) {
   const orgName = await ui.prompt(`Organization display name [${choice.login}]:`);
   const name = orgName || choice.login;
 
@@ -241,19 +362,37 @@ async function setupFlow(api, githubToken, choice) {
   const instanceInput = await ui.prompt(`Instance name (e.g. "ops", "research") [leave blank for default]:`);
   const instanceName = instanceInput || undefined;
 
+  // If user was inside a repo owned by the chosen org, auto-adopt it.
+  const autoAdopt =
+    ctx.prefilledRepo &&
+    ctx.prefilledRepo.owner &&
+    ctx.prefilledRepo.owner.toLowerCase() === choice.login.toLowerCase()
+      ? ctx.prefilledRepo.name
+      : null;
+
   // Repo picker — show org repos for selection
   let selectedRepos = [];
   try {
     const repoData = await api.getOrgRepos(githubToken, choice.login);
     if (repoData.repos && repoData.repos.length > 0) {
+      const filtered = autoAdopt
+        ? repoData.repos.filter((r) => r.name !== autoAdopt)
+        : repoData.repos;
+      if (autoAdopt) {
+        console.log("");
+        ui.info(`${ui.cyan(autoAdopt)} will be managed automatically (your current repo)`);
+      }
       selectedRepos = await ui.multiSelect(
-        "Which repos should Egregore manage?",
-        repoData.repos,
+        "Which other repos should Egregore manage?",
+        filtered,
       );
     }
   } catch {
     // Non-fatal — continue without repos
   }
+  if (autoAdopt && !selectedRepos.includes(autoAdopt)) {
+    selectedRepos.unshift(autoAdopt);
+  }
 
   // Offer to create a new project repo
   console.log("");
@@ -306,7 +445,8 @@ async function setupFlow(api, githubToken, choice) {
 
     // Claim the token immediately
     const data = await api.claimToken(result.setup_token);
-    await install(data, ui);
+    const skipRepos = autoAdopt ? new Set([autoAdopt]) : new Set();
+    await install(data, ui, ctx.targetDir, { skipRepos });
 
     if (result.telegram_invite_link) {
       console.log("");
@@ -319,7 +459,7 @@ async function setupFlow(api, githubToken, choice) {
   }
 }
 
-async function joinFlow(api, githubToken, choice) {
+async function joinFlow(api, githubToken, choice, ctx) {
   const displayName = choice.repo_name ? `${choice.login} (${choice.repo_name})` : choice.login;
   const s = ui.spinner(`Joining ${ui.bold(displayName)}...`);
   try {
@@ -330,7 +470,14 @@ async function joinFlow(api, githubToken, choice) {
     s.stop("Joined");
 
     const data = await api.claimToken(result.setup_token);
-    await install(data, ui);
+    const skipRepos = new Set();
+    if (ctx.prefilledRepo && Array.isArray(data.repos)) {
+      for (const r of data.repos) {
+        const n = typeof r === "string" ? r : r && r.name;
+        if (n && n === ctx.prefilledRepo.name) skipRepos.add(n);
+      }
+    }
+    await install(data, ui, ctx.targetDir, { skipRepos });
   } catch (err) {
     s.fail("Join failed");
     ui.error(err.message);

package/lib/context.js

@@ -0,0 +1,107 @@
+/**
+ * Detect whether cwd is inside a git work-tree.
+ *
+ * Egregore installs as a sibling shell alongside managed repos. If a user runs
+ * `npx create-egregore` from inside an existing git repo, we want to redirect
+ * them to the repo's parent directory and auto-adopt their repo as a managed
+ * repo. This module is the single source of truth for that detection.
+ */
+
+const { execFileSync } = require("node:child_process");
+const path = require("node:path");
+const fs = require("node:fs");
+
+function gitOut(args, cwd) {
+  try {
+    return execFileSync("git", args, {
+      cwd,
+      stdio: ["ignore", "pipe", "ignore"],
+      encoding: "utf-8",
+      timeout: 5000,
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * @param {string} [cwd=process.cwd()]
+ * @returns {null | { toplevel: string, repoName: string, parentDir: string, originOwner: string|null, originName: string|null }}
+ */
+function detectContext(cwd = process.cwd()) {
+  let toplevel = gitOut(["rev-parse", "--show-toplevel"], cwd);
+  if (!toplevel) return null;
+
+  // Submodule → resolve to superproject
+  const sup = gitOut(["rev-parse", "--show-superproject-working-tree"], cwd);
+  if (sup) toplevel = sup;
+
+  // Worktree → resolve to main work-tree so parentDir isn't under .git/worktrees
+  const commonDir = gitOut(["rev-parse", "--git-common-dir"], toplevel);
+  if (commonDir) {
+    const absCommon = path.isAbsolute(commonDir) ? commonDir : path.resolve(toplevel, commonDir);
+    if (path.basename(absCommon) === ".git") {
+      const mainWorktree = path.dirname(absCommon);
+      if (mainWorktree && mainWorktree !== toplevel && fs.existsSync(mainWorktree)) {
+        toplevel = mainWorktree;
+      }
+    }
+  }
+
+  const repoName = path.basename(toplevel);
+  const parentDir = path.dirname(toplevel);
+
+  let originOwner = null;
+  let originName = null;
+  const origin = gitOut(["-C", toplevel, "remote", "get-url", "origin"]);
+  if (origin) {
+    const m = origin.match(/(?:github\.com[:/])([^/]+)\/([^/.]+?)(?:\.git)?$/);
+    if (m) {
+      originOwner = m[1];
+      originName = m[2];
+    }
+  }
+
+  return { toplevel, repoName, parentDir, originOwner, originName };
+}
+
+function isWritable(dir) {
+  try {
+    fs.accessSync(dir, fs.constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Return true if `dir` looks like a system or shared location where planting
+ * an egregore instance + memory repo + managed-repo clones would be disruptive
+ * or confusing. Detected: filesystem root, OS user roots, tmp/opt/usr/var,
+ * and the user's $HOME itself (which happens when someone runs `git init ~`
+ * for dotfile management).
+ */
+function isSystemDir(dir) {
+  if (!dir) return true;
+  const resolved = path.resolve(dir);
+  const blocklist = new Set([
+    "/",
+    "/Users",
+    "/home",
+    "/root",
+    "/tmp",
+    "/private/tmp",
+    "/opt",
+    "/usr",
+    "/usr/local",
+    "/var",
+    "/etc",
+    "/private/var",
+  ]);
+  if (blocklist.has(resolved)) return true;
+  const home = require("node:os").homedir();
+  if (home && path.resolve(home) === resolved) return true;
+  return false;
+}
+
+module.exports = { detectContext, isWritable, isSystemDir };

package/lib/local.js

@@ -250,7 +250,9 @@ const APP_INSTALL_URL = "https://github.com/apps/egregore-labs/installations/new
 
 // ── Flow 1: Founder (local mode) ───────────────────────────────────
 
-async function localFounderFlow(ui) {
+async function localFounderFlow(ui, ctx = {}) {
+  // Names of repos already on disk as the user's own workdir — skip clone/pull.
+  const skipRepos = ctx.skipRepos instanceof Set ? new Set(ctx.skipRepos) : new Set();
   // 1. Install GitHub App — user picks which repos/accounts to grant access to
   ui.info("Let's set up Egregore.\n");
   ui.info("First, install the Egregore app on your GitHub account.");
@@ -294,11 +296,21 @@ async function localFounderFlow(ui) {
   }
 
   // 4. What — new or existing?
-  const action = await ui.choose("What are you working on?", [
-    { label: "Starting something new", description: "Create a project from scratch" },
-    { label: "Existing project", description: "Connect repos I already have" },
-  ]);
-  const isNewProject = action.label.startsWith("Starting");
+  // If the user came in via the in-repo detection and chose "install
+  // alongside", they already told us they have an existing project — don't
+  // re-ask. Go straight to the existing-project path.
+  let isNewProject;
+  if (ctx.prefilledRepo) {
+    isNewProject = false;
+    console.log("");
+    ui.info(`Existing project — we'll manage ${ui.cyan(ctx.prefilledRepo.localName)} plus any others you pick.`);
+  } else {
+    const action = await ui.choose("What are you working on?", [
+      { label: "Starting something new", description: "Create a project from scratch" },
+      { label: "Existing project", description: "Connect repos I already have" },
+    ]);
+    isNewProject = action.label.startsWith("Starting");
+  }
 
   // 5. Collect project info
   let orgName, description, selectedRepos = [], newProjectRepo = null;
@@ -325,19 +337,36 @@ async function localFounderFlow(ui) {
     orgName = nameInput || githubOrg;
     description = "";
 
+    // Auto-adopt the user's current repo if it's under the chosen GitHub owner.
+    const autoAdopt =
+      ctx.prefilledRepo &&
+      ctx.prefilledRepo.owner &&
+      ctx.prefilledRepo.owner.toLowerCase() === githubOrg.toLowerCase()
+        ? ctx.prefilledRepo.name
+        : null;
+
     // Multi-select repos to manage
     const s0 = ui.spinner("Loading repos...");
     try {
       const repos = await listOrgRepos(githubToken, githubOrg, isOrg);
       s0.stop("Loaded repos");
       if (repos.length > 0) {
-        selectedRepos = await ui.multiSelect("Which repos should Egregore manage?", repos);
+        const filtered = autoAdopt ? repos.filter((r) => r.name !== autoAdopt) : repos;
+        if (autoAdopt) {
+          console.log("");
+          ui.info(`${ui.cyan(autoAdopt)} will be managed automatically (your current repo)`);
+        }
+        selectedRepos = await ui.multiSelect("Which other repos should Egregore manage?", filtered);
       } else {
         ui.info("No repos found yet.");
       }
     } catch {
       s0.stop("Could not load repos");
     }
+    if (autoAdopt && !selectedRepos.includes(autoAdopt)) {
+      selectedRepos.unshift(autoAdopt);
+    }
+    if (autoAdopt) skipRepos.add(autoAdopt);
 
     // Detect default branch for each selected repo and convert to {name, base_branch} format
     if (selectedRepos.length > 0) {
@@ -503,7 +532,7 @@ async function localFounderFlow(ui) {
   }
 
   // 10. Clone locally
-  const base = process.cwd();
+  const base = ctx.targetDir || process.cwd();
   const egregoreDir = path.join(base, repoName);
   const memoryDir = path.join(base, memoryRepoName);
   const forkUrl = `https://github.com/${githubOrg}/${repoName}.git`;
@@ -574,11 +603,16 @@ async function localFounderFlow(ui) {
     } catch {}
   }
 
-  // 16. Clone managed repos
+  // 16. Clone managed repos — skipRepos contains the user's current working
+  // repo if auto-adopted, so we don't pull/reconfigure their live workdir.
   for (let i = 0; i < selectedRepos.length; i++) {
     const entry = selectedRepos[i];
     const mrName = typeof entry === "string" ? entry : entry.name;
     ui.step(5 + i, totalSteps, `Cloning ${mrName}...`);
+    if (skipRepos.has(mrName)) {
+      ui.success(`Using existing ${mrName}/ (your current repo)`);
+      continue;
+    }
     const repoDir = path.join(base, mrName);
     try {
       const repoUrl = `https://github.com/${githubOrg}/${mrName}.git`;
@@ -659,7 +693,7 @@ async function localFounderFlow(ui) {
 
 // ── Flow 2: Join (local mode) ──────────────────────────────────────
 
-async function localJoinFlow(orgArg, ui) {
+async function localJoinFlow(orgArg, ui, ctx = {}) {
   // Parse org/repo if provided (e.g., "acme-org/ops-team")
   let orgLogin, explicitRepo;
   if (orgArg.includes("/")) {
@@ -698,7 +732,7 @@ async function localJoinFlow(orgArg, ui) {
 
   // 5. Clone repos using git credentials (SSH keys / gh CLI / credential helper)
   //    The OAuth token only has repo:invite scope — cloning uses the joiner's own git setup.
-  const base = process.cwd();
+  const base = ctx.targetDir || process.cwd();
   const egregoreDir = path.join(base, repoName);
 
   console.log("");

package/lib/setup.js

@@ -101,11 +101,16 @@ async function acceptPendingInvitations(githubToken, githubOrg, ui) {
  *
  * @param {object} data - from /api/org/claim/{token}
  * @param {object} ui - UI module for output
- * @param {string} targetDir - where to install (default: cwd)
+ * @param {string} [targetDir] - where to install (default: cwd)
+ * @param {object} [opts] - optional { skipRepos: Set<string> } — names of managed
+ *   repos that already exist on disk as the user's own working repo. Skipped
+ *   entirely (no clone, no pull, no config writes, no develop-branch push) to
+ *   avoid clobbering uncommitted work or pushing branches to their origin.
  */
-async function install(data, ui, targetDir) {
+async function install(data, ui, targetDir, opts = {}) {
   const { fork_url, memory_url, github_token, org_name, github_org, slug, api_key, repos = [], telegram_group_link, github_username, github_name, transcript_sharing } = data;
   const base = targetDir || process.cwd();
+  const skipRepos = opts.skipRepos instanceof Set ? opts.skipRepos : new Set();
 
   // Directory name from fork URL (what git clone would use), e.g. "egregore-core"
   const forkDirName = fork_url.split("/").pop().replace(/\.git$/, "");
@@ -233,6 +238,12 @@ async function install(data, ui, targetDir) {
     const repoName = typeof repoEntry === 'string' ? repoEntry : repoEntry.name;
     ui.step(6 + i, totalSteps, `Cloning ${repoName}...`);
     const repoDir = path.join(base, repoName);
+    // Auto-adopted from user's current working repo — already on disk, don't touch it.
+    if (skipRepos.has(repoName)) {
+      ui.success(`Using existing ${repoName}/ (your current repo)`);
+      clonedRepos.push(repoName);
+      continue;
+    }
     try {
       if (fs.existsSync(repoDir)) {
         ui.warn(`${repoName}/ already exists — pulling latest`);

package/package.json

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