mover-os 4.5.1 → 4.5.3

package/install.js

@@ -92,17 +92,10 @@ function waveGradient(text, frame, totalFrames) {
 // ─── TUI: Alternate screen buffer ────────────────────────────────────────────
 let _inAltScreen = false;
 function enterAltScreen() {
-  if (!IS_TTY || _inAltScreen) return;
-  w("\x1b[?1049h");   // Enter alternate screen
-  w("\x1b[2J\x1b[H"); // Clear + cursor home
-  w(S.hide);
-  _inAltScreen = true;
+  // Disabled: keep output in terminal scrollback history
 }
 function exitAltScreen() {
-  if (!IS_TTY || !_inAltScreen) return;
-  w("\x1b[?1049l");   // Restore original screen
-  w(S.show);
-  _inAltScreen = false;
+  // Disabled: no alt screen to exit
 }
 function clearContent() {
   w("\x1b[2J\x1b[H"); // Clear screen + cursor to top
@@ -954,14 +947,17 @@ function compareVersions(a, b) {
 // ─── Change detection (update mode) ─────────────────────────────────────────
 function detectChanges(bundleDir, vaultPath, selectedAgentIds) {
   const home = os.homedir();
-  const result = { workflows: [], hooks: [], rules: null, templates: [] };
+  const result = { workflows: [], hooks: [], rules: null, templates: [], skills: [], statusline: "unchanged" };
+
+  // Expand selection IDs to target IDs (e.g. "gemini-cli" → includes "antigravity")
+  const targetIds = expandTargetIds(selectedAgentIds);
 
   // --- Workflows: compare source vs first installed destination ---
   const wfSrc = path.join(bundleDir, "src", "workflows");
   const wfDests = [
-    selectedAgentIds.includes("claude-code") && path.join(home, ".claude", "commands"),
-    selectedAgentIds.includes("cursor") && path.join(home, ".cursor", "commands"),
-    selectedAgentIds.includes("antigravity") && path.join(home, ".gemini", "antigravity", "global_workflows"),
+    targetIds.includes("claude-code") && path.join(home, ".claude", "commands"),
+    targetIds.includes("cursor") && path.join(home, ".cursor", "commands"),
+    targetIds.includes("antigravity") && path.join(home, ".gemini", "antigravity", "global_workflows"),
   ].filter(Boolean);
   const wfDest = wfDests.find((d) => fs.existsSync(d));
 
@@ -984,7 +980,7 @@ function detectChanges(bundleDir, vaultPath, selectedAgentIds) {
   // --- Hooks: compare with CRLF normalization ---
   const hooksSrc = path.join(bundleDir, "src", "hooks");
   const hooksDest = path.join(home, ".claude", "hooks");
-  if (fs.existsSync(hooksSrc) && selectedAgentIds.includes("claude-code")) {
+  if (fs.existsSync(hooksSrc) && targetIds.includes("claude-code")) {
     for (const file of fs.readdirSync(hooksSrc).filter((f) => f.endsWith(".sh") || f.endsWith(".md"))) {
       const srcContent = fs.readFileSync(path.join(hooksSrc, file), "utf8")
         .replace(/\r\n/g, "\n").replace(/\r/g, "\n");
@@ -1005,9 +1001,9 @@ function detectChanges(bundleDir, vaultPath, selectedAgentIds) {
   // --- Rules: compare source vs first installed destination ---
   const rulesSrc = path.join(bundleDir, "src", "system", "Mover_Global_Rules.md");
   const rulesDests = [
-    selectedAgentIds.includes("claude-code") && path.join(home, ".claude", "CLAUDE.md"),
-    selectedAgentIds.includes("cursor") && path.join(home, ".cursor", "rules", "mover-os.mdc"),
-    selectedAgentIds.includes("gemini-cli") && path.join(home, ".gemini", "GEMINI.md"),
+    targetIds.includes("claude-code") && path.join(home, ".claude", "CLAUDE.md"),
+    targetIds.includes("cursor") && path.join(home, ".cursor", "rules", "mover-os.mdc"),
+    targetIds.includes("gemini-cli") && path.join(home, ".gemini", "GEMINI.md"),
   ].filter(Boolean);
   const rulesDest = rulesDests.find((d) => fs.existsSync(d));
   if (fs.existsSync(rulesSrc) && rulesDest) {
@@ -1046,6 +1042,49 @@ function detectChanges(bundleDir, vaultPath, selectedAgentIds) {
     walkTemplates(structDir, "");
   }
 
+  // --- Skills: compare source vs installed ---
+  const skillsSrc = path.join(bundleDir, "src", "skills");
+  const skillsDests = [
+    targetIds.includes("claude-code") && path.join(home, ".claude", "skills"),
+    targetIds.includes("cursor") && path.join(home, ".cursor", "skills"),
+    targetIds.includes("cline") && path.join(home, ".cline", "skills"),
+  ].filter(Boolean);
+  const skillsDest = skillsDests.find((d) => fs.existsSync(d));
+  if (fs.existsSync(skillsSrc) && skillsDest) {
+    const walkSkills = (dir) => {
+      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          const skillFile = path.join(full, "SKILL.md");
+          if (fs.existsSync(skillFile)) {
+            const srcContent = fs.readFileSync(skillFile, "utf8");
+            const destSkill = path.join(skillsDest, entry.name, "SKILL.md");
+            if (!fs.existsSync(destSkill)) {
+              result.skills.push({ file: entry.name, status: "new" });
+            } else {
+              const destContent = fs.readFileSync(destSkill, "utf8");
+              result.skills.push({ file: entry.name, status: srcContent === destContent ? "unchanged" : "changed" });
+            }
+          } else {
+            walkSkills(full);
+          }
+        }
+      }
+    };
+    walkSkills(skillsSrc);
+  }
+
+  // --- Statusline ---
+  const slSrc = path.join(bundleDir, "src", "hooks", "statusline.js");
+  const slDest = path.join(home, ".claude", "statusline.js");
+  if (fs.existsSync(slSrc) && fs.existsSync(slDest) && targetIds.includes("claude-code")) {
+    const srcSl = fs.readFileSync(slSrc, "utf8").replace(/\r\n/g, "\n");
+    const destSl = fs.readFileSync(slDest, "utf8").replace(/\r\n/g, "\n");
+    result.statusline = srcSl === destSl ? "unchanged" : "changed";
+  } else if (fs.existsSync(slSrc) && !fs.existsSync(slDest) && targetIds.includes("claude-code")) {
+    result.statusline = "new";
+  }
+
   return result;
 }
 
@@ -1055,6 +1094,8 @@ function countChanges(changes) {
   n += changes.hooks.filter((f) => f.status !== "unchanged").length;
   if (changes.rules === "changed") n++;
   n += changes.templates.filter((f) => f.status !== "unchanged").length;
+  n += (changes.skills || []).filter((f) => f.status !== "unchanged").length;
+  if (changes.statusline === "changed" || changes.statusline === "new") n++;
   return n;
 }
 
@@ -1102,6 +1143,22 @@ function displayChangeSummary(changes, installedVersion, newVersion) {
   } else {
     barLn(`  Templates: ${dim("unchanged")}`);
   }
+
+  // Skills
+  const skChanged = (changes.skills || []).filter((f) => f.status === "changed");
+  const skNew = (changes.skills || []).filter((f) => f.status === "new");
+  const skUnchanged = (changes.skills || []).filter((f) => f.status === "unchanged");
+  if (skChanged.length > 0 || skNew.length > 0 || skUnchanged.length > 0) {
+    barLn(`  Skills ${dim(`(${skChanged.length + skNew.length} changed, ${skUnchanged.length} unchanged)`)}:`);
+    for (const f of skChanged) barLn(`    ${yellow("✦")} ${f.file}`);
+    for (const f of skNew) barLn(`    ${green("+")} ${f.file} ${dim("(new)")}`);
+    if (skChanged.length === 0 && skNew.length === 0) barLn(`    ${dim("all up to date")}`);
+  }
+
+  // Statusline
+  if (changes.statusline === "changed") barLn(`  Statusline: ${yellow("changed")}`);
+  else if (changes.statusline === "new") barLn(`  Statusline: ${green("new")}`);
+
   barLn();
 }
 
@@ -1566,6 +1623,17 @@ const AGENTS = AGENT_SELECTIONS.map((s) => ({
   detect: AGENT_REGISTRY[s.targets[0]].detect,
 }));
 
+// Expand selection IDs to install target IDs (e.g. "gemini-cli" → ["gemini-cli", "antigravity"])
+function expandTargetIds(selectionIds) {
+  const result = [];
+  for (const id of selectionIds) {
+    const sel = AGENT_SELECTIONS.find((s) => s.id === id);
+    if (sel) { for (const t of sel.targets) result.push(t); }
+    else result.push(id);
+  }
+  return [...new Set(result)];
+}
+
 // ─── Utility functions ──────────────────────────────────────────────────────
 function cmdExists(cmd) {
   try {
@@ -2052,6 +2120,8 @@ function writeMoverConfig(vaultPath, agentIds, licenseKey, opts = {}) {
       if (existing.settings) config.settings = { ...existing.settings };
       // Preserve prayer_times fallback
       if (existing.prayer_times) config.prayer_times = existing.prayer_times;
+      // Preserve frecency data
+      if (existing.cli_usage) config.cli_usage = existing.cli_usage;
       config.updatedAt = new Date().toISOString();
     } catch {}
   }
@@ -2970,7 +3040,8 @@ async function cmdDoctor(opts) {
   // Per-agent checks
   barLn();
   barLn(dim("  Agents:"));
-  const cfgData = fs.existsSync(cfg) ? JSON.parse(fs.readFileSync(cfg, "utf8")) : {};
+  let cfgData = {};
+  if (fs.existsSync(cfg)) { try { cfgData = JSON.parse(fs.readFileSync(cfg, "utf8")); } catch { statusLine("warn", "Config", "corrupt JSON"); } }
   const installedAgents = cfgData.agents || [];
   if (installedAgents.length === 0) {
     barLn(dim("    No agents recorded in config."));
@@ -2996,7 +3067,7 @@ async function cmdDoctor(opts) {
       const hasCmds = fs.existsSync(cp) && fs.readdirSync(cp).length > 0;
       checks.push(hasCmds ? "commands" : dim("no commands"));
     }
-    const allOk = checks.every((c) => !c.includes("missing"));
+    const allOk = checks.every((c) => c === strip(c)); // styled text = problem
     statusLine(allOk ? "ok" : "warn", `  ${reg.name}`, checks.join(", "));
   }
 
@@ -3041,7 +3112,7 @@ async function cmdPulse(opts) {
     const focusMatch = ac.match(/\*\*Focus:\*\*\s*(.+)/i) || ac.match(/Single Test:\s*(.+)/i);
     if (focusMatch) focus = focusMatch[1].trim();
     // Blockers
-    const blockerSection = ac.match(/##.*Blocker[s]?[\s\S]*?(?=\n##|\n---|\Z)/i);
+    const blockerSection = ac.match(/##.*Blocker[s]?[\s\S]*?(?=\n##|\n---|$)/i);
     if (blockerSection) {
       const lines = blockerSection[0].split("\n").filter((l) => l.trim().startsWith("-") || l.trim().startsWith("*"));
       blockers = lines.map((l) => l.replace(/^[\s*-]+/, "").trim()).filter(Boolean).slice(0, 3);
@@ -3430,7 +3501,7 @@ async function cmdReplay(opts) {
   const daily = fs.readFileSync(dailyPath, "utf8");
 
   // Extract session log entries
-  const logMatch = daily.match(/##\s*Session Log[\s\S]*?(?=\n## [^#]|\Z)/i);
+  const logMatch = daily.match(/##\s*Session Log[\s\S]*?(?=\n## [^#]|$)/i);
   if (!logMatch) {
     barLn(dim("  No session log found in this Daily Note."));
     return;
@@ -3985,10 +4056,11 @@ async function cmdRestore(opts) {
   const archivesDir = path.join(vault, "04_Archives");
   if (!fs.existsSync(archivesDir)) { barLn(yellow("  No archives found.")); return; }
 
+  const backupPrefixes = ["Backup_", "Engine_Backup_", "Areas_Backup_", "Agent_Backup_"];
   const backups = fs.readdirSync(archivesDir)
     .filter((d) => {
       const full = path.join(archivesDir, d);
-      return fs.statSync(full).isDirectory() && (d.startsWith("Backup_") || d.startsWith("Engine_Backup_"));
+      return fs.statSync(full).isDirectory() && backupPrefixes.some((p) => d.startsWith(p));
     })
     .sort()
     .reverse();
@@ -4016,25 +4088,67 @@ async function cmdRestore(opts) {
 
   const backupPath = path.join(archivesDir, selected);
 
-  // Check for engine dir in backup
-  const engPath = path.join(backupPath, "engine");
-  if (fs.existsSync(engPath)) {
-    const engineDir = path.join(vault, "02_Areas", "Engine");
-    let restored = 0;
-    for (const f of fs.readdirSync(engPath).filter((f) => fs.statSync(path.join(engPath, f)).isFile())) {
-      fs.copyFileSync(path.join(engPath, f), path.join(engineDir, f));
-      restored++;
+  let totalRestored = 0;
+
+  if (selected.startsWith("Areas_Backup_")) {
+    // Areas backup: restore entire 02_Areas folder
+    const areasTarget = path.join(vault, "02_Areas");
+    copyDirRecursive(backupPath, areasTarget);
+    statusLine("ok", "Areas", "folder restored");
+    totalRestored++;
+  } else if (selected.startsWith("Agent_Backup_")) {
+    // Agent backup: restore rules/skills per agent
+    let agentCount = 0;
+    for (const agDir of fs.readdirSync(backupPath).filter((d) => fs.statSync(path.join(backupPath, d)).isDirectory())) {
+      const reg = AGENT_REGISTRY[agDir];
+      if (!reg) continue;
+      const srcDir = path.join(backupPath, agDir);
+      // Restore rules file
+      if (reg.rules && reg.rules.dest) {
+        const rulesFile = fs.readdirSync(srcDir).find((f) => !f.startsWith("skills") && fs.statSync(path.join(srcDir, f)).isFile());
+        if (rulesFile) {
+          try {
+            const dest = reg.rules.dest(vault);
+            fs.mkdirSync(path.dirname(dest), { recursive: true });
+            fs.copyFileSync(path.join(srcDir, rulesFile), dest);
+            agentCount++;
+          } catch {}
+        }
+      }
+      // Restore skills directory
+      const skillsSrc = path.join(srcDir, "skills");
+      if (fs.existsSync(skillsSrc) && reg.skills && reg.skills.dest) {
+        try {
+          copyDirRecursive(skillsSrc, reg.skills.dest(vault));
+          agentCount++;
+        } catch {}
+      }
     }
-    statusLine("ok", "Engine", `${restored} files restored`);
+    statusLine("ok", "Agents", `${agentCount} items restored`);
+    totalRestored = agentCount;
   } else {
-    // Legacy backup format (files directly in backup dir)
-    const engineDir = path.join(vault, "02_Areas", "Engine");
-    let restored = 0;
-    for (const f of fs.readdirSync(backupPath).filter((f) => f.endsWith(".md") && f !== ".backup-manifest.json")) {
-      fs.copyFileSync(path.join(backupPath, f), path.join(engineDir, f));
-      restored++;
+    // Engine backup (Engine_Backup_ or legacy Backup_)
+    const engPath = path.join(backupPath, "engine");
+    if (fs.existsSync(engPath)) {
+      const engineDir = path.join(vault, "02_Areas", "Engine");
+      let restored = 0;
+      for (const f of fs.readdirSync(engPath).filter((f) => fs.statSync(path.join(engPath, f)).isFile())) {
+        fs.copyFileSync(path.join(engPath, f), path.join(engineDir, f));
+        restored++;
+      }
+      statusLine("ok", "Engine", `${restored} files restored`);
+      totalRestored = restored;
+    } else {
+      // Legacy backup format (files directly in backup dir)
+      const engineDir = path.join(vault, "02_Areas", "Engine");
+      let restored = 0;
+      for (const f of fs.readdirSync(backupPath).filter((f) => f.endsWith(".md") && f !== ".backup-manifest.json")) {
+        fs.copyFileSync(path.join(backupPath, f), path.join(engineDir, f));
+        restored++;
+      }
+      if (restored > 0) statusLine("ok", "Engine", `${restored} files restored`);
+      totalRestored = restored;
     }
-    if (restored > 0) statusLine("ok", "Engine", `${restored} files restored`);
   }
 
   barLn();
@@ -4631,14 +4745,20 @@ async function cmdUpdateComprehensive(opts, bundleDir, startTime) {
     createVaultStructure(vaultPath);
     installTemplateFiles(bundleDir, vaultPath);
     const writtenFiles = new Set();
-    const skillOpts = { install: true, categories: null, workflows: null };
+    const skillOpts = { install: true, categories: null, workflows: null, statusLine: changes.statusline !== "unchanged" };
     for (const agent of detectedAgents) {
-      const fn = AGENT_INSTALLERS[agent.id];
-      if (!fn) continue;
-      const sp = spinner(agent.name);
-      const steps = fn(bundleDir, vaultPath, skillOpts, writtenFiles, agent.id);
-      await sleep(200);
-      sp.stop(steps.length > 0 ? `${agent.name}  ${dim(steps.join(", "))}` : `${agent.name}  ${dim("configured")}`);
+      const sel = AGENT_SELECTIONS.find((s) => s.id === agent.id);
+      const targets = sel ? sel.targets : [agent.id];
+      for (const targetId of targets) {
+        const fn = AGENT_INSTALLERS[targetId];
+        if (!fn) continue;
+        const targetReg = AGENT_REGISTRY[targetId];
+        const displayName = targetReg ? targetReg.name : agent.name;
+        const sp = spinner(displayName);
+        const steps = fn(bundleDir, vaultPath, skillOpts, writtenFiles, targetId);
+        await sleep(200);
+        sp.stop(steps.length > 0 ? `${displayName}  ${dim(steps.join(", "))}` : `${displayName}  ${dim("configured")}`);
+      }
     }
     fs.writeFileSync(path.join(vaultPath, ".mover-version"), `${require("./package.json").version}\n`, "utf8");
     writeMoverConfig(vaultPath, selectedIds);
@@ -4697,15 +4817,36 @@ async function cmdUpdateComprehensive(opts, bundleDir, startTime) {
           fs.mkdirSync(agentBackupDir, { recursive: true });
           let agentsBacked = 0;
           for (const ag of AGENTS.filter((a) => a.detect())) {
-            const agDir = path.join(agentBackupDir, ag.id);
-            fs.mkdirSync(agDir, { recursive: true });
-            for (const cp of (ag.configPaths || [])) {
-              if (fs.existsSync(cp.src)) {
-                try { fs.copyFileSync(cp.src, path.join(agDir, path.basename(cp.src))); agentsBacked++; } catch {}
+            const sel = AGENT_SELECTIONS.find((s) => s.id === ag.id);
+            const targets = sel ? sel.targets : [ag.id];
+            for (const targetId of targets) {
+              const reg = AGENT_REGISTRY[targetId];
+              if (!reg) continue;
+              const agDir = path.join(agentBackupDir, targetId);
+              fs.mkdirSync(agDir, { recursive: true });
+              // Back up rules file
+              if (reg.rules && reg.rules.dest) {
+                try {
+                  const rulesPath = reg.rules.dest(vaultPath);
+                  if (fs.existsSync(rulesPath)) {
+                    fs.copyFileSync(rulesPath, path.join(agDir, path.basename(rulesPath)));
+                    agentsBacked++;
+                  }
+                } catch {}
+              }
+              // Back up skills directory
+              if (reg.skills && reg.skills.dest) {
+                try {
+                  const skillsDir = reg.skills.dest(vaultPath);
+                  if (fs.existsSync(skillsDir)) {
+                    copyDirRecursive(skillsDir, path.join(agDir, "skills"));
+                    agentsBacked++;
+                  }
+                } catch {}
               }
             }
           }
-          statusLine("ok", "Backed up", `${agentsBacked} agent config files`);
+          statusLine("ok", "Backed up", `${agentsBacked} agent config items`);
         } catch (err) { barLn(yellow(`  Agent backup failed: ${err.message}`)); }
       }
     }
@@ -4806,7 +4947,7 @@ async function cmdUpdateComprehensive(opts, bundleDir, startTime) {
   }
 
   const writtenFiles = new Set();
-  const skillOpts = { install: true, categories: null, workflows: selectedWorkflows, skipHooks, skipRules, skipTemplates };
+  const skillOpts = { install: true, categories: null, workflows: selectedWorkflows, skipHooks, skipRules, skipTemplates, statusLine: changes.statusline !== "unchanged" };
   for (const agent of selectedAgents) {
     const sel = AGENT_SELECTIONS.find((s) => s.id === agent.id);
     const targets = sel ? sel.targets : [agent.id];
@@ -4839,8 +4980,12 @@ async function cmdUpdateComprehensive(opts, bundleDir, startTime) {
       const catSet = new Set(selectedCatIds);
       const refreshOpts = { install: true, categories: catSet, workflows: null };
       for (const agent of selectedAgents) {
-        const fn = AGENT_INSTALLERS[agent.id];
-        if (fn) fn(bundleDir, vaultPath, refreshOpts, writtenFiles, agent.id);
+        const sel = AGENT_SELECTIONS.find((s) => s.id === agent.id);
+        const targets = sel ? sel.targets : [agent.id];
+        for (const targetId of targets) {
+          const fn = AGENT_INSTALLERS[targetId];
+          if (fn) fn(bundleDir, vaultPath, refreshOpts, writtenFiles, targetId);
+        }
       }
       const skillCount = allSkills.filter((s) => s.category === "tools" || catSet.has(s.category)).length;
       statusLine("ok", "Skills refreshed", `${skillCount} across ${selectedAgents.length} agent(s)`);
@@ -5223,8 +5368,8 @@ async function main() {
       ],
       { multi: false, defaultIndex: 1 }
     );
-    if (!ptChoice) return;
-    if (ptChoice === "yes") {
+    if (!ptChoice || ptChoice === "no") { /* skip prayer setup */ }
+    else if (ptChoice === "yes") {
       prayerSetup = true;
       barLn();
       question("How would you like to set up prayer times?");
@@ -5238,7 +5383,9 @@ async function main() {
         ],
         { multi: false, defaultIndex: 0 }
       );
-      if (!method || method === "later") { /* skip */ }
+      if (!method || method === "later") {
+        // User cancelled method pick — still enable the setting, no timetable
+      } else {
 
       const moverDir = path.join(os.homedir(), ".mover");
       if (!fs.existsSync(moverDir)) fs.mkdirSync(moverDir, { recursive: true, mode: 0o700 });
@@ -5290,9 +5437,7 @@ async function main() {
       } else if (method === "fetch") {
         barLn();
         const city = await textInput({ label: "City (e.g. London, Watford, Istanbul)", placeholder: "London" });
-        if (city === null) return;
-        const country = await textInput({ label: "Country", placeholder: "United Kingdom" });
-        if (country === null) return;
+        const country = city ? await textInput({ label: "Country", placeholder: "United Kingdom" }) : null;
         barLn();
 
         if (city && country) {
@@ -5310,6 +5455,7 @@ async function main() {
         }
       }
       // method === "later" → just enable the setting, no timetable yet
+      } // end if method !== "later"
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mover-os",
-  "version": "4.5.1",
+  "version": "4.5.3",
   "description": "The self-improving OS for AI agents. Turns Obsidian into an execution engine.",
   "bin": {
     "moveros": "install.js"