@rafiqui987/markode 0.4.0 → 0.4.2

package/README.md

@@ -382,12 +382,18 @@ markode features            # which modules are on, with what each one does
 markode features live off   # turn a module on or off (same as Settings → Features)
 markode translate           # choose languages to review the docs in (also: markode --translate)
 markode link                # only CLAUDE.md or only AGENTS.md? add the other one, pointing to it
+markode update              # install the latest version now (see below)
 markode -v                  # version
 ```
 
 To keep it installed: `npm install -g @rafiqui987/markode` (or `pnpm add -g @rafiqui987/markode`).
 Installing it also makes the Claude Code hooks faster than running through `npx`.
 
+**A new version right away.** pnpm (and npm with `min-release-age`) wait a day before installing a
+version just published. `markode update` asks the npm registry for the latest version and installs it
+now, with the same package manager that installed markode (`--pnpm` or `--npm` to choose);
+`markode update --check` only says whether there is one.
+
 ## For AI agents
 
 The AI agent module installs the `markode` skill where the project's agents read skills

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-import fs21 from "fs";
-import path21 from "path";
+import fs22 from "fs";
+import path22 from "path";
 
 // src/core/changes.ts
 import crypto from "crypto";
@@ -1834,9 +1834,42 @@ function keepLanguage(root2, rel) {
 
 // src/core/server.ts
 import { spawn } from "child_process";
+import fs18 from "fs";
+import path18 from "path";
+
+// src/core/update.ts
+import { spawnSync as spawnSync2 } from "child_process";
 import fs17 from "fs";
 import path17 from "path";
-var serverFile = (root2) => path17.join(stateDir(root2), "server.json");
+var PKG = JSON.parse(fs17.readFileSync(path17.join(PKG_ROOT, "package.json"), "utf8"));
+var CURRENT_VERSION = PKG.version;
+function installer() {
+  const dir = PKG_ROOT.split(path17.sep).join("/");
+  if (dir.includes("/_npx/")) return "npx";
+  if (!dir.includes("/node_modules/")) return null;
+  return dir.includes("/pnpm/") || dir.includes("/.pnpm/") ? "pnpm" : "npm";
+}
+async function latestVersion() {
+  const res = await fetch(`https://registry.npmjs.org/${PKG.name}/latest`, { headers: { accept: "application/json" }, signal: AbortSignal.timeout(15e3) });
+  if (!res.ok) throw new Error(`The npm registry answered ${res.status}`);
+  return (await res.json()).version;
+}
+function isNewer(a, b) {
+  const pa = a.split(".").map((n) => parseInt(n, 10));
+  const pb = b.split(".").map((n) => parseInt(n, 10));
+  for (let i = 0; i < 3; i++) if ((pa[i] ?? 0) !== (pb[i] ?? 0)) return (pa[i] ?? 0) > (pb[i] ?? 0);
+  return false;
+}
+function installCommand2(via, version) {
+  const spec = `${PKG.name}@${version}`;
+  return via === "pnpm" ? ["pnpm", "add", "-g", spec, "--config.minimum-release-age=0"] : ["npm", "install", "-g", spec, "--min-release-age=0", "--prefer-online"];
+}
+function runInstall(cmd) {
+  return spawnSync2(cmd[0], cmd.slice(1), { stdio: "inherit", shell: process.platform === "win32" }).status === 0;
+}
+
+// src/core/server.ts
+var serverFile = (root2) => path18.join(stateDir(root2), "server.json");
 var isAlive = (pid) => {
   try {
     process.kill(pid, 0);
@@ -1847,18 +1880,18 @@ var isAlive = (pid) => {
 };
 function recordServer(root2, port) {
   const file = serverFile(root2);
-  fs17.mkdirSync(path17.dirname(file), { recursive: true });
+  fs18.mkdirSync(path18.dirname(file), { recursive: true });
   assertInside(file);
-  fs17.writeFileSync(file, JSON.stringify({ port, pid: process.pid }));
+  fs18.writeFileSync(file, JSON.stringify({ port, pid: process.pid, version: CURRENT_VERSION }));
   process.once("exit", () => {
-    if (runningServer(root2)?.pid === process.pid) fs17.rmSync(file, { force: true });
+    if (runningServer(root2)?.pid === process.pid) fs18.rmSync(file, { force: true });
   });
   for (const sig of ["SIGINT", "SIGTERM", "SIGHUP"]) process.once(sig, () => process.exit(130));
 }
 function runningServer(root2) {
   try {
-    const s = JSON.parse(fs17.readFileSync(serverFile(root2), "utf8"));
-    return Number.isInteger(s.port) && Number.isInteger(s.pid) && isAlive(s.pid) ? { port: s.port, pid: s.pid } : null;
+    const s = JSON.parse(fs18.readFileSync(serverFile(root2), "utf8"));
+    return Number.isInteger(s.port) && Number.isInteger(s.pid) && isAlive(s.pid) ? { port: s.port, pid: s.pid, version: s.version } : null;
   } catch {
     return null;
   }
@@ -1872,7 +1905,11 @@ async function responds(port) {
 }
 async function ensureServer(root2, cli2, port) {
   const running = runningServer(root2);
-  if (running && await responds(running.port)) return running;
+  if (running && running.version !== CURRENT_VERSION) {
+    process.kill(running.pid);
+    for (let i = 0; i < 50 && isAlive(running.pid); i++) await new Promise((r) => setTimeout(r, 100));
+    port = running.port;
+  } else if (running && await responds(running.port)) return running;
   const child = spawn(process.execPath, [...process.execArgv, cli2, "serve", "--no-open", "--port", String(port)], {
     cwd: root2,
     env: { ...process.env, MARKODE_ROOT: root2 },
@@ -1890,11 +1927,11 @@ async function ensureServer(root2, cli2, port) {
 var editorUrl = (port, doc) => `http://localhost:${port}/${doc ? `open?path=${encodeURIComponent(doc).replace(/%2F/g, "/")}` : ""}`;
 
 // src/core/wait.ts
-import fs18 from "fs";
-import path18 from "path";
+import fs19 from "fs";
+import path19 from "path";
 import YAML5 from "yaml";
-var waitsDir = (root2) => path18.join(stateDir(root2), "waits");
-var pidFile = (root2, rel) => path18.join(waitsDir(root2), `${encodeURIComponent(rel)}.pid`);
+var waitsDir = (root2) => path19.join(stateDir(root2), "waits");
+var pidFile = (root2, rel) => path19.join(waitsDir(root2), `${encodeURIComponent(rel)}.pid`);
 var frontmatter2 = (text3) => {
   try {
     return YAML5.parse(/^---\r?\n([\s\S]*?)\r?\n---/.exec(text3)?.[1] ?? "", { logLevel: "error" }) ?? {};
@@ -1913,27 +1950,27 @@ var isAlive2 = (pid) => {
 function waitingOn(root2) {
   let names2 = [];
   try {
-    names2 = fs18.readdirSync(waitsDir(root2)).filter((f) => f.endsWith(".pid"));
+    names2 = fs19.readdirSync(waitsDir(root2)).filter((f) => f.endsWith(".pid"));
   } catch {
   }
   return names2.flatMap((f) => {
-    const pid = Number(fs18.readFileSync(path18.join(waitsDir(root2), f), "utf8"));
+    const pid = Number(fs19.readFileSync(path19.join(waitsDir(root2), f), "utf8"));
     return isAlive2(pid) ? [decodeURIComponent(f.slice(0, -4))] : [];
   });
 }
 function waitForAnswer(root2, rel) {
-  const abs = path18.join(root2, rel);
-  fs18.mkdirSync(waitsDir(root2), { recursive: true });
+  const abs = path19.join(root2, rel);
+  fs19.mkdirSync(waitsDir(root2), { recursive: true });
   assertInside(pidFile(root2, rel));
-  fs18.writeFileSync(pidFile(root2, rel), String(process.pid));
-  const cleanup = () => fs18.rmSync(pidFile(root2, rel), { force: true });
+  fs19.writeFileSync(pidFile(root2, rel), String(process.pid));
+  const cleanup = () => fs19.rmSync(pidFile(root2, rel), { force: true });
   process.once("exit", cleanup);
   for (const sig of ["SIGINT", "SIGTERM", "SIGHUP"]) process.once(sig, () => process.exit(130));
   return new Promise((resolve) => {
     const poll = () => {
       let text3;
       try {
-        text3 = fs18.readFileSync(abs, "utf8");
+        text3 = fs19.readFileSync(abs, "utf8");
       } catch {
         return resolve("gone");
       }
@@ -1947,7 +1984,7 @@ function waitForAnswer(root2, rel) {
 }
 var COMMENT = /^\s*<!-- (comment|reply) by (.+?), (\d{4}-\d{2}-\d{2})(?:, on "((?:[^"\\]|\\.)*)")?:\s?([\s\S]*?)\s*-->\s*$/;
 function answerSummary(root2, rel) {
-  const text3 = fs18.readFileSync(path18.join(root2, rel), "utf8");
+  const text3 = fs19.readFileSync(path19.join(root2, rel), "utf8");
   const fm = frontmatter2(text3);
   const body = text3.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, "");
   const lines = body.split("\n");
@@ -2022,9 +2059,9 @@ function answerSummary(root2, rel) {
 
 // src/server/index.ts
 import crypto3 from "crypto";
-import fs19 from "fs";
+import fs20 from "fs";
 import http from "http";
-import path19 from "path";
+import path20 from "path";
 import { watch } from "chokidar";
 import open from "open";
 import pc from "picocolors";
@@ -2092,7 +2129,7 @@ async function startServer({ root: root2, port, open: openBrowser }) {
     if (typeof rel !== "string" || !rel.trim()) throw new HttpError(400, "Expected a path");
     const abs = safeResolve(root2, rel);
     if (abs === root2) throw new HttpError(400, "Refusing to delete the project root");
-    if (!fs19.existsSync(abs)) throw new HttpError(404, "Not found");
+    if (!fs20.existsSync(abs)) throw new HttpError(404, "Not found");
     return abs;
   };
   const translationFile = (lang, rel) => {
@@ -2104,7 +2141,7 @@ async function startServer({ root: root2, port, open: openBrowser }) {
     "GET /api/info": () => {
       const c = config();
       return {
-        name: path19.basename(root2),
+        name: path20.basename(root2),
         mainDoc: c.mainDoc ?? null,
         sourceLang: sourceLang(),
         langs: langs().filter((l) => l !== sourceLang()),
@@ -2131,7 +2168,7 @@ async function startServer({ root: root2, port, open: openBrowser }) {
       }
       if (isLang(body.sourceLang) && body.sourceLang !== sourceLang()) {
         if (!c.mainDoc) throw new HttpError(400, "No main document configured; run `markode init`");
-        applyRulesToFile(path19.join(root2, c.mainDoc), void 0, body.sourceLang);
+        applyRulesToFile(path20.join(root2, c.mainDoc), void 0, body.sourceLang);
       }
       writeConfig(root2, c);
       return { ...c, langs: c.langs.filter((l) => l !== sourceLang()) };
@@ -2162,10 +2199,10 @@ async function startServer({ root: root2, port, open: openBrowser }) {
     "GET /api/file": (url3) => {
       const rel = mdPath(url3.searchParams.get("path"));
       const l = viewLang(url3.searchParams.get("lang"));
-      const source = fs19.readFileSync(safeResolve(root2, rel), "utf8");
+      const source = fs20.readFileSync(safeResolve(root2, rel), "utf8");
       if (l) {
         const tPath = translationFile(l, rel);
-        if (fs19.existsSync(tPath)) return { path: rel, content: fs19.readFileSync(tPath, "utf8"), target: "translation", status: fileStatus(root2, l, rel) };
+        if (fs20.existsSync(tPath)) return { path: rel, content: fs20.readFileSync(tPath, "utf8"), target: "translation", status: fileStatus(root2, l, rel) };
         return { path: rel, content: source, target: "source", status: "missing" };
       }
       return { path: rel, content: source, target: "source", status: null };
@@ -2174,19 +2211,19 @@ async function startServer({ root: root2, port, open: openBrowser }) {
       const rel = mdPath(body.path);
       const l = viewLang(body.lang);
       const file = body.target === "translation" && l ? translationFile(l, rel) : safeResolve(root2, rel);
-      fs19.mkdirSync(path19.dirname(file), { recursive: true });
+      fs20.mkdirSync(path20.dirname(file), { recursive: true });
       const content = String(body.content ?? "");
-      if (!l && featureState(root2).agent) logSave(root2, rel, fs19.existsSync(file) ? fs19.readFileSync(file, "utf8") : "", content);
-      fs19.writeFileSync(file, content);
+      if (!l && featureState(root2).agent) logSave(root2, rel, fs20.existsSync(file) ? fs20.readFileSync(file, "utf8") : "", content);
+      fs20.writeFileSync(file, content);
       return { ok: true, status: l ? fileStatus(root2, l, rel) : null };
     },
     "POST /api/file": (_, body) => {
       const rel = mdPath(body.path);
       const file = safeResolve(root2, rel);
-      if (fs19.existsSync(file)) throw new HttpError(409, "File already exists");
-      fs19.mkdirSync(path19.dirname(file), { recursive: true });
-      const title = path19.basename(rel, ".md").replace(/^\d+[-_]/, "").replace(/[-_]/g, " ");
-      fs19.writeFileSync(file, `# ${title.charAt(0).toUpperCase() + title.slice(1)}
+      if (fs20.existsSync(file)) throw new HttpError(409, "File already exists");
+      fs20.mkdirSync(path20.dirname(file), { recursive: true });
+      const title = path20.basename(rel, ".md").replace(/^\d+[-_]/, "").replace(/[-_]/g, " ");
+      fs20.writeFileSync(file, `# ${title.charAt(0).toUpperCase() + title.slice(1)}
 
 `);
       return { ok: true, path: rel };
@@ -2196,20 +2233,20 @@ async function startServer({ root: root2, port, open: openBrowser }) {
       if (typeof body.path !== "string" || !body.path.trim()) throw new HttpError(400, "Expected a path");
       const dir = safeResolve(root2, body.path);
       if (dir === root2) throw new HttpError(400, "Expected a path");
-      if (fs19.existsSync(dir)) throw new HttpError(409, "A file or folder with that name already exists");
-      fs19.mkdirSync(dir, { recursive: true });
-      return { ok: true, path: toPosix(path19.relative(root2, dir)) };
+      if (fs20.existsSync(dir)) throw new HttpError(409, "A file or folder with that name already exists");
+      fs20.mkdirSync(dir, { recursive: true });
+      return { ok: true, path: toPosix(path20.relative(root2, dir)) };
     },
     "GET /api/delete-preview": (url3) => {
       const abs = deletable(url3.searchParams.get("path"));
-      if (!fs19.statSync(abs).isDirectory()) return { kind: "file", files: 1, md: 1 };
-      const files = fs19.readdirSync(abs, { recursive: true, withFileTypes: true }).filter((e) => e.isFile());
+      if (!fs20.statSync(abs).isDirectory()) return { kind: "file", files: 1, md: 1 };
+      const files = fs20.readdirSync(abs, { recursive: true, withFileTypes: true }).filter((e) => e.isFile());
       return { kind: "dir", files: files.length, md: files.filter((e) => e.name.toLowerCase().endsWith(".md")).length };
     },
     "DELETE /api/path": (url3) => {
-      const rel = toPosix(path19.relative(root2, deletable(url3.searchParams.get("path"))));
-      fs19.rmSync(safeResolve(root2, rel), { recursive: true });
-      for (const l of config().langs) fs19.rmSync(translationFile(l, rel), { recursive: true, force: true });
+      const rel = toPosix(path20.relative(root2, deletable(url3.searchParams.get("path"))));
+      fs20.rmSync(safeResolve(root2, rel), { recursive: true });
+      for (const l of config().langs) fs20.rmSync(translationFile(l, rel), { recursive: true, force: true });
       return { ok: true };
     },
     "POST /api/ignore": (_, body) => {
@@ -2226,7 +2263,7 @@ async function startServer({ root: root2, port, open: openBrowser }) {
     },
     "GET /api/rules": () => {
       const mainDoc = readConfig(root2)?.mainDoc;
-      const text3 = mainDoc && fs19.existsSync(path19.join(root2, mainDoc)) ? fs19.readFileSync(path19.join(root2, mainDoc), "utf8") : "";
+      const text3 = mainDoc && fs20.existsSync(path20.join(root2, mainDoc)) ? fs20.readFileSync(path20.join(root2, mainDoc), "utf8") : "";
       return { rules: listRules(), applied: appliedRuleIds(text3), mainDoc: mainDoc ?? null };
     },
     "PUT /api/rules": (_, body) => saveRule(body),
@@ -2242,12 +2279,12 @@ async function startServer({ root: root2, port, open: openBrowser }) {
     },
     "GET /api/skills/file": (url3) => {
       const skill = getSkill(root2, url3.searchParams.get("key"));
-      return { path: skill.key, content: fs19.readFileSync(path19.join(skill.key, "SKILL.md"), "utf8"), target: "source", status: null };
+      return { path: skill.key, content: fs20.readFileSync(path20.join(skill.key, "SKILL.md"), "utf8"), target: "source", status: null };
     },
     "PUT /api/skills/file": (_, body) => {
       const skill = getSkill(root2, body.key);
       if (skill.managed) throw new HttpError(403, "This skill is managed by the app that installed it");
-      fs19.writeFileSync(path19.join(skill.key, "SKILL.md"), String(body.content ?? ""));
+      fs20.writeFileSync(path20.join(skill.key, "SKILL.md"), String(body.content ?? ""));
       return { ok: true, status: null };
     },
     "POST /api/skills/install": (_, body) => {
@@ -2260,7 +2297,7 @@ async function startServer({ root: root2, port, open: openBrowser }) {
     "POST /api/rules/apply": (_, body) => {
       const mainDoc = readConfig(root2)?.mainDoc;
       if (!mainDoc) throw new HttpError(400, "No main document configured; run `markode init`");
-      applyRulesToFile(path19.join(root2, mainDoc), body.ids ?? []);
+      applyRulesToFile(path20.join(root2, mainDoc), body.ids ?? []);
       return { ok: true };
     }
   };
@@ -2295,13 +2332,13 @@ async function startServer({ root: root2, port, open: openBrowser }) {
       res.writeHead(404).end();
       return;
     }
-    const type = IMAGE_MIME[path19.extname(file).toLowerCase()];
-    if (!type || !fs19.existsSync(file) || !fs19.statSync(file).isFile()) {
+    const type = IMAGE_MIME[path20.extname(file).toLowerCase()];
+    if (!type || !fs20.existsSync(file) || !fs20.statSync(file).isFile()) {
       res.writeHead(404).end();
       return;
     }
     res.writeHead(200, { "content-type": type, "cache-control": "no-cache", "content-security-policy": "sandbox; frame-ancestors 'none'" });
-    fs19.createReadStream(file).pipe(res);
+    fs20.createReadStream(file).pipe(res);
   }
   function openDoc(rel, res) {
     let doc;
@@ -2335,16 +2372,16 @@ async function startServer({ root: root2, port, open: openBrowser }) {
     // Unreadable folders (e.g. caches owned by another user) are skipped instead of failing.
     ignorePermissionErrors: true,
     ignored: (p3, stats) => {
-      const rel = toPosix(path19.relative(root2, p3));
+      const rel = toPosix(path20.relative(root2, p3));
       if (rel === ".markode") return false;
       if (rel.startsWith(".markode/")) return !rel.startsWith(".markode/i18n") && rel !== ".markode/state.json" && rel !== ".markode/config.json";
       return skips(rel, stats ? stats.isDirectory() : void 0);
     }
   }).on("error", (err) => console.warn(pc.yellow(`  file watcher: ${err.message}`))).on("all", (event, file) => {
-    const abs = path19.resolve(file);
+    const abs = path20.resolve(file);
     if (!abs.endsWith(".md") && !abs.endsWith(".json") && !abs.endsWith(".markodeignore") && event !== "addDir" && event !== "unlinkDir") return;
-    let rel = toPosix(path19.relative(root2, abs));
-    const i18n = toPosix(path19.relative(root2, path19.join(stateDir(root2), "i18n")));
+    let rel = toPosix(path20.relative(root2, abs));
+    const i18n = toPosix(path20.relative(root2, path20.join(stateDir(root2), "i18n")));
     if (rel.startsWith(i18n + "/")) rel = rel.split("/").slice(3).join("/");
     broadcast({ type: "fs", event, path: rel });
   });
@@ -2353,7 +2390,7 @@ async function startServer({ root: root2, port, open: openBrowser }) {
   console.log(`
   ${pc.bold("markode")} ${pc.dim("\u2192")} ${pc.cyan(url2)}  ${pc.dim(root2)}
 `);
-  if (!fs19.existsSync(WEB_DIR)) console.log(pc.yellow("  Web UI not built: run `pnpm build`, or `pnpm dev` and open http://localhost:4320\n"));
+  if (!fs20.existsSync(WEB_DIR)) console.log(pc.yellow("  Web UI not built: run `pnpm build`, or `pnpm dev` and open http://localhost:4320\n"));
   else if (openBrowser) open(url2).catch(() => {
   });
 }
@@ -2373,19 +2410,19 @@ function listen(server, port) {
   });
 }
 function serveStatic(pathname, res) {
-  let file = path19.join(WEB_DIR, path19.normalize(pathname).replace(/^(\.\.[/\\])+/, ""));
-  if (!file.startsWith(WEB_DIR) || !fs19.existsSync(file) || fs19.statSync(file).isDirectory()) file = path19.join(WEB_DIR, "index.html");
-  if (!fs19.existsSync(file)) {
+  let file = path20.join(WEB_DIR, path20.normalize(pathname).replace(/^(\.\.[/\\])+/, ""));
+  if (!file.startsWith(WEB_DIR) || !fs20.existsSync(file) || fs20.statSync(file).isDirectory()) file = path20.join(WEB_DIR, "index.html");
+  if (!fs20.existsSync(file)) {
     res.writeHead(404).end("Web UI not built. Run `pnpm build`.");
     return;
   }
-  res.writeHead(200, { "content-type": MIME[path19.extname(file)] ?? "application/octet-stream", "content-security-policy": "frame-ancestors 'none'" });
-  fs19.createReadStream(file).pipe(res);
+  res.writeHead(200, { "content-type": MIME[path20.extname(file)] ?? "application/octet-stream", "content-security-policy": "frame-ancestors 'none'" });
+  fs20.createReadStream(file).pipe(res);
 }
 
 // src/cli/init.ts
-import fs20 from "fs";
-import path20 from "path";
+import fs21 from "fs";
+import path21 from "path";
 import * as p from "@clack/prompts";
 import pc2 from "picocolors";
 function check(value) {
@@ -2396,12 +2433,12 @@ function check(value) {
   return value;
 }
 async function offerClaudeLink(root2, d) {
-  if (fs20.existsSync(path20.join(root2, "CLAUDE.md"))) return;
+  if (fs21.existsSync(path21.join(root2, "CLAUDE.md"))) return;
   const link2 = d ? d.mainDoc === "CLAUDE.md" : check(await p.confirm({ message: "Claude Code reads CLAUDE.md, not AGENTS.md. Add a CLAUDE.md that imports AGENTS.md?", initialValue: true }));
   if (link2 && linkAgentsDoc(root2)) p.log.success("Created CLAUDE.md (imports AGENTS.md)");
 }
 async function chooseMainDoc(root2, d) {
-  const existing = MAIN_DOCS.filter((d2) => fs20.existsSync(path20.join(root2, d2)) && !isPointer(fs20.readFileSync(path20.join(root2, d2), "utf8"), d2));
+  const existing = MAIN_DOCS.filter((d2) => fs21.existsSync(path21.join(root2, d2)) && !isPointer(fs21.readFileSync(path21.join(root2, d2), "utf8"), d2));
   if (d) {
     if (existing.length === 1 && existing[0] === "AGENTS.md") await offerClaudeLink(root2, d);
     if (existing.length) return existing.includes(d.mainDoc) ? d.mainDoc : existing[0];
@@ -2518,7 +2555,7 @@ async function chooseAreas(root2) {
   return areas;
 }
 async function chooseKind(root2, dir) {
-  const guess = guessKind(path20.join(root2, dir));
+  const guess = guessKind(path21.join(root2, dir));
   if (!guess.unclear) return guess.kind;
   const where = dir ? `${dir}/` : "this project";
   const seen = guess.signals.length ? `found: ${guess.signals.join(", ")}` : "no code yet";
@@ -2531,7 +2568,7 @@ async function chooseKind(root2, dir) {
   );
 }
 async function askProfile(root2, dir, kind) {
-  const base = detectProfile(path20.join(root2, dir), kind);
+  const base = detectProfile(path21.join(root2, dir), kind);
   if (kind === "app") return base;
   const where = dir ? ` (${dir}/)` : "";
   if (kind === "library") return { kind, published: check(await p.confirm({ message: `Is the library${where} published (npm, PyPI\u2026)?`, initialValue: base.published })) };
@@ -2608,7 +2645,7 @@ async function chooseWorkflow(root2, mainDoc, previous, quiet) {
       const profile = areas.length ? void 0 : await askProfile(root2, "", await chooseKind(root2, ""));
       const created = scaffoldMethod(root2, mainDoc, areas);
       installMethodSkills(root2);
-      applyWorkflowToFile(path20.join(root2, mainDoc), "markode", methodSection(areas, root2, { profile, contracts, existing }));
+      applyWorkflowToFile(path21.join(root2, mainDoc), "markode", methodSection(areas, root2, { profile, contracts, existing }));
       const big = !areas.length && flattenFiles(scanTree(root2)).length > 40;
       const layout = areas.length ? "structured" : !big ? "general" : check(await p.select({ message: PROPOSALS_QUESTION, options: PROPOSAL_OPTIONS }));
       activateProposals(root2, layout, mainDoc);
@@ -2673,10 +2710,10 @@ async function runInit(root2, plan2) {
   let workflow = previous?.workflow ?? "none";
   if (has2("agent")) {
     mainDoc = await chooseMainDoc(root2, d);
-    const mainFile = path20.join(root2, mainDoc);
+    const mainFile = path21.join(root2, mainDoc);
     if (has2("dashboard")) workflow = await chooseWorkflow(root2, mainDoc, previous?.workflow, d);
     if (workflow === "openspec" || workflow === "speckit") applyWorkflowToFile(mainFile, workflow);
-    const mainText = fs20.readFileSync(mainFile, "utf8");
+    const mainText = fs21.readFileSync(mainFile, "utf8");
     const sourceLang = d ? SOURCE_LANG_MARK.test(mainText) ? sourceLangOf(mainText) : detectedLang : check(await p.select({ message: SOURCE_LANG_QUESTION, options: LANG_OPTIONS, initialValue: SOURCE_LANG_MARK.test(mainText) ? sourceLangOf(mainText) : detectedLang }));
     const rules = listRules();
     const applied = appliedRuleIds(mainText);
@@ -2691,7 +2728,7 @@ async function runInit(root2, plan2) {
           required: false
         })
       );
-      for (const dir of targets) applyRulesToFile(contentDoc(path20.join(root2, dir)), selected, sourceLang);
+      for (const dir of targets) applyRulesToFile(contentDoc(path21.join(root2, dir)), selected, sourceLang);
     }
     installAgentSkill(root2);
     const proposals = proposalsState(root2);
@@ -2848,6 +2885,8 @@ Usage
   markode changes [--json] what the user edited or commented in markode since the agent was last told
   markode changes --start  a new agent session: what happened before is old news
   markode changes --hook <event>  the same, as Claude Code hook output (silent when nothing changed)
+  markode update [--check] install the latest version now, without the day npm/pnpm wait for new releases
+  markode update --pnpm|--npm  the same, choosing the package manager to install it with
 
 For the agent's /markode translate:
   markode translate --status [--json]                    translations + files not in the source language
@@ -2873,18 +2912,20 @@ var option = (name) => {
 var command = args[0] && !args[0].startsWith("-") ? args[0] : "start";
 var root = process.env.MARKODE_ROOT ?? process.cwd();
 async function main() {
-  if (fs21.existsSync(root)) setProjectRoot(root);
+  if (fs22.existsSync(root)) setProjectRoot(root);
   if (flag("--help") || flag("-h")) return console.log(HELP);
-  if (flag("--version") || flag("-v")) return console.log(JSON.parse(fs21.readFileSync(path21.join(PKG_ROOT, "package.json"), "utf8")).version);
+  if (flag("--version") || flag("-v")) return console.log(JSON.parse(fs22.readFileSync(path22.join(PKG_ROOT, "package.json"), "utf8")).version);
   const translation = flag("--status") || flag("--mark") || flag("--keep");
   if ((command === "sync" || command === "translate") && translation) return sync();
   if (command === "translate" || flag("--translate")) return runTranslate(root);
+  if (["check", "url", "link"].includes(command) || command === "changes" && flag("--start")) refreshInstalled(root);
   if (command === "check") return check3();
   if (command === "wait") return wait();
   if (command === "link") return link();
   if (command === "changes") return changes();
   if (command === "url") return url();
   if (command === "stop") return stop();
+  if (command === "update") return update();
   if (command === "features") return features();
   if (command === "setup") {
     await runSetup(false, flag("--custom"));
@@ -2972,7 +3013,7 @@ function link() {
 }
 async function url() {
   const doc = args[1] && !args[1].startsWith("-") ? args[1] : void 0;
-  if (doc && (!doc.toLowerCase().endsWith(".md") || !fs21.existsSync(path21.join(root, doc)))) {
+  if (doc && (!doc.toLowerCase().endsWith(".md") || !fs22.existsSync(path22.join(root, doc)))) {
     console.error(`Usage: markode url [<doc.md>] (relative to ${root})`);
     process.exitCode = 1;
     return;
@@ -2986,6 +3027,20 @@ function stop() {
   process.kill(running.pid);
   console.log(`Stopped the editor on port ${running.port}.`);
 }
+async function update() {
+  const latest = await latestVersion();
+  if (!isNewer(latest, CURRENT_VERSION)) return console.log(`markode ${CURRENT_VERSION} is the latest version.`);
+  console.log(`markode ${latest} is out (you have ${CURRENT_VERSION}).`);
+  if (flag("--check")) return;
+  const via = flag("--pnpm") ? "pnpm" : flag("--npm") ? "npm" : installer();
+  if (via === "npx") return console.log(`Running through npx: use \`npx -y @rafiqui987/markode@${latest}\` once to fetch it, or install it with \`markode update --pnpm\` (or --npm).`);
+  if (!via) return console.log("This copy runs from a clone of the repository: pull and build it, or install it with `markode update --pnpm` (or --npm).");
+  const cmd = installCommand2(via, latest);
+  console.log(`$ ${cmd.join(" ")}`);
+  if (runInstall(cmd)) return console.log(`Updated to ${latest}. The next \`markode url\` (or /markode) restarts a running editor with it.`);
+  console.error("The install failed; the output above says why.");
+  process.exitCode = 1;
+}
 function changes() {
   if (flag("--start")) return startSession(root);
   const list = takeChanges(root);
@@ -3000,7 +3055,7 @@ function changes() {
 }
 async function wait() {
   const rel = args[1];
-  if (!rel || !fs21.existsSync(path21.join(root, rel))) {
+  if (!rel || !fs22.existsSync(path22.join(root, rel))) {
     console.error(`Usage: markode wait <proposal.md> (relative to ${root})`);
     process.exitCode = 1;
     return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rafiqui987/markode",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Visual editor for CLAUDE.md, AGENTS.md and /docs — humans edit comfortably, the AI keeps reading plain Markdown.",
   "keywords": [
     "markdown",