@looop-games/cli 0.1.12 → 0.1.13

package/CHANGELOG.md

@@ -14,6 +14,24 @@ Versions: [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.1.13] - 2026-07-12
+
+### Fixed
+- **`looop update` deleted your engine.** The engine is not an npm package — it
+  installs without a record in `package.json`, so *any* `npm install` in your game
+  treats it as junk and removes it. `looop update` then updated the `looop` command
+  itself with an npm install — **after** putting the engine in place — and wiped it
+  out every time. The update said it succeeded; `node_modules/@looop-games/engine`
+  was gone. Everything that reads the engine then failed, and re-running
+  `looop update` cheerfully said "already up to date" and fixed nothing.
+
+  The engine is now the last thing installed, and an update that finds it missing
+  puts it back (from the local cache — instant, no download). If you hit this, one
+  `npx looop update` repairs it.
+- `looop lint` said "this engine ships no rules yet" when the real problem was that
+  the engine was not installed at all — sending you to `looop update`, the one
+  command that could not help. It now tells you which of the two it is.
+
 ## [0.1.12] - 2026-07-12
 
 ### Added

package/lib/lint.mjs

@@ -38,17 +38,23 @@ async function loadFromProject(projectDir) {
 }
 
 // The shareable config, out of the installed engine artifact.
+//
+// The two ways this can come up empty are DIFFERENT problems with different
+// fixes, and conflating them sends people in a circle: the first version of this
+// said "engine ships no rules — run looop update" when the engine was not
+// installed at all, so `looop update` was the one command that could never help.
+// Say which it is.
 async function loadRulesFromEngine(projectDir) {
   let engineDir;
   try {
     ({ dir: engineDir } = resolveEngine(projectDir));
   } catch {
-    return null; // no engine installed yet — `looop dev` installs it
+    return { configs: null, why: 'no-engine' };
   }
   const entry = join(engineDir, 'eslint', 'index.js');
-  if (!existsSync(entry)) return null; // engine predates the rules
+  if (!existsSync(entry)) return { configs: null, why: 'engine-too-old' };
   const mod = await import(pathToFileURL(entry).href);
-  return mod.configs ?? mod.default?.configs ?? null;
+  return { configs: mod.configs ?? mod.default?.configs ?? null, why: 'ok' };
 }
 
 export async function lintCmd({
@@ -68,10 +74,19 @@ export async function lintCmd({
     return { ok: true, skipped: true, errorCount: 0, warningCount: 0 };
   }
 
-  const configs = await loadRules(project.dir);
+  const { configs, why } = await loadRules(project.dir);
   if (!configs) {
-    log('⚠️  looop lint: this engine ships no rules yet — skipping.');
-    log('   Get the latest engine (it carries them): looop update');
+    if (why === 'no-engine') {
+      // The engine is not on disk. Usually it was PRUNED: it installs with
+      // `npm install --no-save`, so npm has no record of it and any later
+      // `npm install` in this game deletes it. It is not lost — it is cached.
+      log('⚠️  looop lint: the Looop engine is not installed in this game — skipping.');
+      log('   (A plain `npm install` removes it; it is cached, so putting it back is instant.)');
+      log('   Restore it with:  looop update');
+    } else {
+      log('⚠️  looop lint: your engine is older than the Looop rules — skipping.');
+      log('   Get an engine that carries them:  looop update');
+    }
     return { ok: true, skipped: true, errorCount: 0, warningCount: 0 };
   }
 

package/lib/update.mjs

@@ -97,19 +97,52 @@ export async function update({
         .sort((a, b) => compareVersions(b.version, a.version))
     : null;
 
+  // ── The `looop` command FIRST, before the engine lands ─────────────────────
+  //
+  // Order is load-bearing, and getting it wrong deleted the engine. The engine is
+  // not an npm package — it installs with `npm install --no-save`, so npm has no
+  // record of it and treats it as extraneous. ANY later `npm install` in the game
+  // prunes it. syncCli runs exactly such an install (`--save-dev` the new CLI), so
+  // running it AFTER the engine install wiped the engine every single time: the
+  // update reported success and left node_modules/@looop-games/engine gone. The
+  // next `looop lint` then found no engine at all (caught on a real game).
+  //
+  // So: do every npm install that this command is going to do BEFORE the engine
+  // is put on disk, and let the engine be the last thing to land.
+  //
+  // Wrapped: syncCli is already fail-soft, and a bug in it must not stop the
+  // engine update that is the point of this command.
+  let cli;
+  try {
+    cli = await syncCliFn({ projectDir: project.dir, log });
+  } catch (err) {
+    cli = { updated: false, error: err };
+  }
+
   let engineDir = null;
   let updated = false;
 
   if (from === latest) {
-    log(`✅ Engine ${latest} — already up to date.`);
     // Reconcile anyway. A repo can sit on the latest engine and STILL have an
     // out-of-date surface: one scaffolded before this mechanism existed has
     // never had its skills adopted, and would otherwise wait forever for a
     // release it already has.
     try {
       engineDir = resolveEngine(project.dir).dir;
+      log(`✅ Engine ${latest} — already up to date.`);
     } catch {
-      engineDir = null; // engine not installed yet — the next `dev` fetches it
+      // Pinned to the latest, but NOT on disk. The pin is a claim about what this
+      // game runs; node_modules is the truth, and they disagree — because a plain
+      // `npm install` (the creator's own, or ours above) prunes the engine, which
+      // npm never recorded. "Already up to date" while the engine is missing is a
+      // lie that leaves every engine-reading command broken, and re-running update
+      // could never fix it. Put it back — from the local cache, so this is fast and
+      // works offline.
+      log(`Engine ${latest} is pinned but missing from node_modules — reinstalling it.`);
+      const engine = await ensure(project.dir, { apiBase, log, fetchImpl });
+      engineDir = engine.dir ?? null;
+      log('');
+      log(`✅ Engine ${latest} — restored.`);
     }
   } else {
     // Rewrite the pin first; ensureEngine honors it (download → install → pin).
@@ -125,21 +158,18 @@ export async function update({
   if (!surface.skipped) report(log, surface.engineVersion ?? latest, surface);
 
   // The third lane: the `looop` command itself (see self-update.mjs). The skills
-  // we just reconciled ship WITH the engine and can name any command they like —
-  // riven ended up on an engine whose skills say `looop changelog` while its CLI
-  // was four versions too old to have it. So update moves this too.
+  // we reconciled ship WITH the engine and can name any command they like — a real
+  // game ended up on an engine whose skills say `looop changelog` while its CLI was
+  // four versions too old to have it. So update moves this too.
   //
-  // Wrapped: syncCli is already fail-soft, but a bug in it must not undo an
-  // engine update that has already landed on disk.
-  let cli;
-  try {
-    cli = await syncCliFn({ projectDir: project.dir, log });
-    reportCli(log, cli);
-  } catch (err) {
-    cli = { updated: false, error: err };
+  // It already RAN, at the top: its npm install has to happen before the engine
+  // lands or it prunes it. This is only the report.
+  if (cli?.error) {
     log('');
-    log(`   The looop command could not be updated (${err.message}).`);
+    log(`   The looop command could not be updated (${cli.error.message}).`);
     log('   Your engine and skills are up to date. Retry with: npm update @looop-games/cli');
+  } else {
+    reportCli(log, cli);
   }
 
   if (updated) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@looop-games/cli",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "description": "Looop game development CLI — dev server, login, and publishing for standalone Looop games.",
   "type": "module",
   "license": "Apache-2.0",