create-kedge 0.10.1 → 0.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-kedge",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/create.mjs

@@ -80,6 +80,31 @@ export function render(template, { name, suffix: sfx, packs }) {
   return files;
 }
 
+/** The folder's entries, none when it doesn't exist yet. */
+const existing = (dir) => (existsSync(dir) ? readdirSync(dir) : []);
+
+/** The top-level names the template writes. */
+const ownedTop = (files) => new Set(Object.keys(files).map((p) => p.split("/")[0]));
+
+/** An existing .gitignore with each of the starter's lines it lacks appended, its own lines as they were. */
+/** Where the CLI and kedge dev write credentials and keys: never tracked (p0.10 §4, §6.2). */
+const CREDENTIAL_PATHS = [".env.local", ".env.development.local", ".dev.vars", ".kedge/state.db"];
+
+export function mergeIgnore(mine, starter) {
+  const lines = mine.split("\n").map((l) => l.trim());
+  // A rule counts as present only if no exception follows it: `.env*` then `!.env.local` would commit
+  // the credentials the starter's `.env*` keeps out (codex code r4), so such a rule is appended again, last.
+  const holds = (rule) => {
+    const at = lines.lastIndexOf(rule);
+    return at >= 0 && !lines.slice(at + 1).some((l) => l.startsWith("!"));
+  };
+  const add = starter
+    .split("\n")
+    .filter((l) => l.trim() && (l.trim().startsWith("#") ? !lines.includes(l.trim()) : !holds(l.trim())));
+  if (!add.length) return mine;
+  return `${mine.replace(/\n*$/, "\n")}# Kedge's starter (create-kedge):\n${add.join("\n")}\n`;
+}
+
 export function write(dir, files) {
   for (const [path, text] of Object.entries(files)) {
     if (isAbsolute(path) || path.split("/").includes("..")) throw new Error(`template path ${path} escapes the store`);
@@ -130,10 +155,6 @@ export function main(
   const positional = argv.filter((a, i) => !a.startsWith("--") && !["--name", "--from-packs"].includes(argv[i - 1]));
   // No directory: the folder it's run in, as `npm create kedge@latest` alone leaves it (p0.10.1 §1, 1).
   const target = positional[0] ?? ".";
-  if (positional[0] === undefined && readdirSync(resolve(target)).length > 0) {
-    error(`this folder isn't empty: run it in an empty one, or name a new one: npm create kedge@latest my-store`);
-    return 2;
-  }
   // Before anything is written: a half-made store on a machine that can't install it helps no one.
   const pnpm = flags.has("--no-install") ? null : run("pnpm", ["--version"], { encoding: "utf8" });
   const problem = environmentProblem({
@@ -146,10 +167,6 @@ export function main(
     return 1;
   }
   const dir = resolve(target);
-  if (existsSync(dir) && readdirSync(dir).length > 0) {
-    error(`${dir} isn't empty`);
-    return 1;
-  }
   const chosen = value("--name");
   const name = chosen ?? storeNameOf(basename(dir));
   if (!chosen) log(`store name ${name}, from the folder; --name to choose another`);
@@ -162,10 +179,39 @@ export function main(
     error(e.message);
     return 1;
   }
+  // A workspace's own dot-entries (.git, .salve, .vscode) may already be here: a platform like salve
+  // loads AGENTS.md and skills only from its root (p0.11 row 11). Anything the template writes may not.
+  const clash = existing(dir).filter((e) => !e.startsWith(".") || (e !== ".gitignore" && ownedTop(files).has(e)));
+  if (clash.length) {
+    error(
+      `${dir} already holds ${clash.join(", ")}: run it in an empty folder, or one holding only its own dot-files, or name a new one: npm create kedge@latest my-store`,
+    );
+    return positional[0] === undefined ? 2 : 1;
+  }
   mkdirSync(dir, { recursive: true });
+  const ignore = join(dir, ".gitignore");
+  if (existsSync(ignore) && files[".gitignore"] !== undefined)
+    files[".gitignore"] = mergeIgnore(readFileSync(ignore, "utf8"), files[".gitignore"]);
   write(dir, files);
   log(`created ${name} in ${dir} (Kedge ${t.version})`);
-  if (!flags.has("--no-git")) run("git", ["init", "-q"], { cwd: dir, stdio: "inherit" });
+  // Inside a repository already (a workspace's), the store is part of it: no repository inside another (p0.11 row 12).
+  const inRepo =
+    String(run("git", ["rev-parse", "--is-inside-work-tree"], { cwd: dir, encoding: "utf8" })?.stdout ?? "").trim() ===
+    "true";
+  if (!flags.has("--no-git") && !inRepo) run("git", ["init", "-q"], { cwd: dir, stdio: "inherit" });
+  // Whatever else the repository's ignore files say, the credentials the CLI saves stay out of Git.
+  if (inRepo || !flags.has("--no-git")) {
+    const kept = CREDENTIAL_PATHS.filter(
+      // 1 is "not ignored"; no git, or no repository (128), is no answer.
+      (p) => run("git", ["check-ignore", "-q", p], { cwd: dir, stdio: "ignore" })?.status === 1,
+    );
+    if (kept.length) {
+      error(
+        `Git here wouldn't ignore ${kept.join(", ")}, where the CLI saves credentials and keys: add them to .gitignore (an exception such as !.env.local overrides the starter's rule) before anything is committed`,
+      );
+      return 1;
+    }
+  }
   if (!flags.has("--no-install")) {
     const r = run("pnpm", ["install"], { cwd: dir, stdio: "inherit" });
     if (r.status !== 0) {