@askviraj/ai-plugins 1.0.0 → 1.1.0

package/bin/installer.js

@@ -49,6 +49,12 @@ const SUBAGENT_STATUS_LINE = {
 const MARKETPLACE_REF = "virajp/ai-plugins";
 const MARKETPLACE_NAME = "virajp-plugins";
 
+// Sources for the latest versions (used by --version and --upgrade): the
+// marketplace manifest on the repo's main branch, and the published CLI on npm.
+const REMOTE_MARKETPLACE_URL =
+  "https://raw.githubusercontent.com/virajp/ai-plugins/main/.claude-plugin/marketplace.json";
+const NPM_LATEST_URL = "https://registry.npmjs.org/@askviraj/ai-plugins/latest";
+
 // All plugins published by the virajp-plugins marketplace.
 const PLUGINS = ["vwf", "typescript-lsp", "dart-lsp", "context7", "mempalace"];
 
@@ -83,22 +89,122 @@ const PLUGIN_EXTRA_DEPS = {
 class Installer extends Command {
   async run() {
     const { flags } = await this.parse(Installer);
+
+    if (flags.version) {
+      await this.printVersions();
+      return;
+    }
+
     const plan = this.resolvePlan(flags);
+    const hasInstall = plan.plugins.length
+      || plan.statusLine
+      || plan.subagentStatusLine;
 
-    if (!plan.plugins.length && !plan.statusLine && !plan.subagentStatusLine) {
+    if (!hasInstall && !flags.upgrade) {
       this.error(
-        "Nothing to do. Pass --all, --plugins, --plugin <name>, --statusline, and/or --subagentstatusline.",
+        "Nothing to do. Pass --all, --plugins, --plugin <name>, --statusline, --subagentstatusline, --upgrade, or --version.",
       );
     }
 
-    this.checkDeps(plan);
+    // Install first — so a fresh machine ends up with the requested plugins…
+    if (hasInstall) {
+      this.checkDeps(plan);
+      if (plan.plugins.length) {
+        this.installPlugins(plan.plugins);
+      }
+      if (plan.statusLine || plan.subagentStatusLine) {
+        await this.installStatusline(plan, flags.yes);
+      }
+    }
 
-    if (plan.plugins.length) {
-      this.installPlugins(plan.plugins);
+    // …then upgrade everything that is installed to the latest versions.
+    if (flags.upgrade) {
+      await this.upgrade();
     }
+  }
 
-    if (plan.statusLine || plan.subagentStatusLine) {
-      await this.installStatusline(plan, flags.yes);
+  // Print the CLI version (vs npm latest), the bundled statusline version, and
+  // each plugin's installed version (from `claude plugin list`) vs the latest in
+  // the remote marketplace, flagging updates. Errors out if the network or the
+  // claude CLI is unavailable.
+  async printVersions() {
+    const cli = this.config.version;
+    const cliLatest = (await fetchJson(NPM_LATEST_URL)).version;
+    const latest = await remoteLatest();
+    const installed = installedPlugins();
+
+    this.log(`${this.config.name}  ${cli}${updateNote(cli, cliLatest)}`);
+    this.log(`  ${"statusline".padEnd(16)} ${cli}  (bundled with the CLI)`);
+
+    this.log(`\nPlugins (${MARKETPLACE_NAME}):`);
+    for (const name of PLUGINS) {
+      this.log(
+        `  ${name.padEnd(16)} ${
+          pluginVersionLine(installed[name], latest[name])
+        }`,
+      );
+    }
+  }
+
+  // Upgrade every installed virajp-plugins plugin to its latest version, refresh
+  // the statusline (if installed) to this CLI's bundled version, and note a newer
+  // CLI. Runs after the install phase, so newly installed plugins are already
+  // latest and only pre-existing ones get bumped. Installing missing plugins is
+  // the install flags' job — this only upgrades what is present. Errors out if
+  // the network or the claude CLI is unavailable.
+  async upgrade() {
+    if (!hasBin("claude")) {
+      this.error("claude CLI not found. Install it first, then re-run.");
+    }
+    // Fail fast on the remote reads before mutating anything.
+    const latest = await remoteLatest();
+    const cliLatest = (await fetchJson(NPM_LATEST_URL)).version;
+    const installed = installedPlugins();
+    const ours = PLUGINS.filter(name => installed[name]);
+
+    this.log(
+      `\nUpgrading installed plugins (marketplace ${MARKETPLACE_NAME})…`,
+    );
+    this.runClaude(["plugin", "marketplace", "update", MARKETPLACE_NAME]);
+
+    if (!ours.length) {
+      this.log("No virajp-plugins plugins are installed — nothing to upgrade.");
+    }
+    else {
+      let updated = 0;
+      for (const name of ours) {
+        const have = installed[name];
+        const want = latest[name];
+        if (want && cmpVer(want, have) > 0) {
+          this.log(`\nUpdating ${name} (${have} → ${want})…`);
+          this.runClaude(["plugin", "update", `${name}@${MARKETPLACE_NAME}`]);
+          updated++;
+        }
+        else {
+          this.log(
+            `${name} is up to date (${have}${want ? "" : ", external"}).`,
+          );
+        }
+      }
+      if (updated) {
+        this.log(
+          "\nPlugin updates applied — restart Claude Code to load them.",
+        );
+      }
+    }
+
+    // Refresh the installed statusline script + config (no settings.json change).
+    if (existsSync(INSTALLED_SCRIPT)) {
+      this.log("\nRefreshing statusline…");
+      await this.installScript();
+      await this.seedUserConfig();
+    }
+
+    if (cmpVer(cliLatest, this.config.version) > 0) {
+      this.log(
+        `\nA newer CLI is available: ${this.config.version} → ${cliLatest}`,
+      );
+      this.log("Re-run with: pnpx @askviraj/ai-plugins@latest --upgrade");
     }
   }
 
@@ -290,17 +396,32 @@ class Installer extends Command {
   }
 }
 
-Installer.description =
+// Use `summary` (not `description`) so oclif prints this once at the top of
+// --help; setting `description` would also render a duplicate DESCRIPTION block.
+Installer.summary =
   "Install Viraj Patel's Claude Code toolkit: marketplace plugins (via the `claude` CLI) and the powerline statusline. Checks required tools (brew/mise/claude/rtk/pnpm/…) first and prints install hints for any that are missing.";
 
+// Users invoke this via pnpx (npx works too), never the bare `ai-plugins` bin,
+// so spell the runnable command out rather than using <%= config.bin %>.
 Installer.examples = [
-  "<%= config.bin %> --all",
-  "<%= config.bin %> --plugins",
-  "<%= config.bin %> --plugin vwf --plugin dart-lsp",
-  "<%= config.bin %> --statusline --subagentstatusline --yes",
+  "pnpx @askviraj/ai-plugins --all",
+  "pnpx @askviraj/ai-plugins --plugins",
+  "pnpx @askviraj/ai-plugins --plugin vwf --plugin dart-lsp",
+  "pnpx @askviraj/ai-plugins --statusline --subagentstatusline --yes",
+  "pnpx @askviraj/ai-plugins --all --upgrade",
+  "pnpx @askviraj/ai-plugins --version",
 ];
 
 Installer.flags = {
+  version: Flags.boolean({
+    char: "v",
+    description:
+      "Show CLI, statusline, and plugin versions (installed vs latest)",
+  }),
+  upgrade: Flags.boolean({
+    description:
+      "After any install, upgrade installed plugins to latest + refresh the statusline + check for a CLI update. Combine with --all for an idempotent install+upgrade (safe in setup scripts)",
+  }),
   all: Flags.boolean({
     description:
       "Install everything: every marketplace plugin plus both statusline keys",
@@ -328,6 +449,101 @@ Installer.flags = {
   }),
 };
 
+// Fetch and parse JSON over HTTP with a bounded timeout. Throws on any failure
+// (network down, non-2xx, bad JSON) so callers can hard-error per the offline
+// policy.
+async function fetchJson(url) {
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), 5000);
+  try {
+    const res = await fetch(url, {
+      signal: ctrl.signal,
+      headers: { "user-agent": "askviraj-ai-plugins" },
+    });
+    if (!res.ok) {
+      throw new Error(`HTTP ${res.status} for ${url}`);
+    }
+    return await res.json();
+  }
+  finally {
+    clearTimeout(timer);
+  }
+}
+
+// Map of plugin name → latest version from the remote marketplace manifest
+// (null for url-sourced entries like mempalace, which pin no version here).
+async function remoteLatest() {
+  const mp = await fetchJson(REMOTE_MARKETPLACE_URL);
+  const out = {};
+  for (const p of mp.plugins || []) {
+    out[p.name] = p.version || null;
+  }
+  return out;
+}
+
+// Map of plugin name → installed version, parsed from `claude plugin list`,
+// restricted to the virajp-plugins marketplace. Throws if claude fails.
+function installedPlugins() {
+  const res = spawnSync("claude", ["plugin", "list"], { encoding: "utf8" });
+  if (res.error || res.status !== 0) {
+    throw new Error(
+      "`claude plugin list` failed — is the claude CLI installed?",
+    );
+  }
+  const out = {};
+  let current = null;
+  for (const line of (res.stdout || "").split("\n")) {
+    const name = line.match(/([A-Za-z0-9_-]+)@virajp-plugins\b/);
+    if (name) {
+      current = name[1];
+      continue;
+    }
+    if (current) {
+      const ver = line.match(/Version:\s*(\S+)/);
+      if (ver) {
+        out[current] = ver[1];
+        current = null;
+      }
+    }
+  }
+  return out;
+}
+
+// Numeric semver compare of dotted versions: 1 if a>b, -1 if a<b, 0 if equal.
+function cmpVer(a, b) {
+  const pa = String(a).split(".").map(n => parseInt(n, 10) || 0);
+  const pb = String(b).split(".").map(n => parseInt(n, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] || 0) > (pb[i] || 0)) {
+      return 1;
+    }
+    if ((pa[i] || 0) < (pb[i] || 0)) {
+      return -1;
+    }
+  }
+  return 0;
+}
+
+// " → X (update available)" when latest beats current, else " (latest)".
+function updateNote(current, latest) {
+  return latest && cmpVer(latest, current) > 0
+    ? `  →  ${latest}  (update available)`
+    : "  (latest)";
+}
+
+// The version column for one plugin given its installed and latest versions.
+function pluginVersionLine(installed, latest) {
+  if (!latest) {
+    return installed
+      ? `${installed}  (external; not tracked here)`
+      : "not installed  (external)";
+  }
+  if (!installed) {
+    return `not installed  (latest ${latest})`;
+  }
+  return `${installed}${updateNote(installed, latest)}`;
+}
+
 // True if `bin` is an executable found on PATH.
 function hasBin(bin) {
   return (process.env.PATH || "")

package/package.json

@@ -7,6 +7,25 @@
     "@oclif/core": "latest"
   },
   "description": "CLI to install Viraj Patel's Claude Code toolkit: marketplace plugins (via the claude CLI) and the powerline statusline",
+  "keywords": [
+    "claude",
+    "claude-code",
+    "claude-code-plugin",
+    "claude-code-plugins",
+    "marketplace",
+    "statusline",
+    "powerline",
+    "subagent",
+    "cli",
+    "mcp",
+    "lsp",
+    "vwf",
+    "context7",
+    "mempalace",
+    "ai",
+    "anthropic",
+    "oclif"
+  ],
   "engines": {
     "node": ">=18"
   },
@@ -28,5 +47,5 @@
     "url": "github:virajp/ai-plugins"
   },
   "type": "commonjs",
-  "version": "1.0.0"
+  "version": "1.1.0"
 }

package/readme.md

@@ -52,6 +52,19 @@ Available plugin names: `vwf`, `mempalace`, `context7`, `typescript-lsp`,
 > The **statusline** also installs through this CLI — see
 > [Statusline](#statusline) below.
 
+**Check versions, and keep everything up to date:**
+
+```sh
+# CLI, statusline, and each plugin's installed vs latest version
+pnpx @askviraj/ai-plugins --version
+
+# upgrade installed plugins + refresh the statusline (runs after any install)
+pnpx @askviraj/ai-plugins --upgrade
+
+# idempotent install + upgrade — safe to drop in a setup script
+pnpx @askviraj/ai-plugins --all --upgrade
+```
+
 ## Plugins
 
 ### vwf
@@ -161,3 +174,34 @@ Dart language server.
 ```sh
 pnpx @askviraj/ai-plugins --plugin dart-lsp
 ```
+
+## Credits & acknowledgements
+
+This project is a thin layer over a lot of excellent work. It would not exist —
+or would be far poorer — without these. Thank you to their authors and
+maintainers. 🙏
+
+- **[Claude Code](https://claude.ai/code)** by
+  [Anthropic](https://anthropic.com) — the host these plugins, hooks, and
+  statusline plug into.
+- **[MemPalace](https://github.com/MemPalace/mempalace)** — the AI memory system
+  that powers `vwf`'s cross-session recall (re-listed here as a dependency).
+- **[Context7](https://github.com/upstash/context7)** by
+  [Upstash](https://upstash.com) — the MCP docs server behind the `context7`
+  plugin.
+- **[mise](https://mise.jdx.dev/)** by Jeff Dickey — resolves the toolchain the
+  LSP plugins and hooks depend on.
+- **[pnpm](https://pnpm.io/)** — the package manager the `npm→pnpm` hook and
+  `context7` rely on.
+- **[typescript-language-server](https://github.com/typescript-language-server/typescript-language-server)**
+  and the **[Dart SDK](https://dart.dev/)** language server — the engines behind
+  the LSP plugins.
+- **[rtk](https://github.com/rtk-ai/rtk) (Rust Token Killer)** — the
+  token-saving proxy `vwf`'s Bash hook shells out to (installed via
+  `brew install --formulae rtk`).
+- **[graphify](https://github.com/safishamsi/graphify)** — the knowledge-graph
+  tool `vwf` integrates with.
+- **[oclif](https://oclif.io/)** — the framework this installer CLI is built on.
+- **[Nerd Fonts](https://www.nerdfonts.com/)** — the glyphs that make the
+  statusline render, and the **[Gruvbox](https://github.com/morhetz/gruvbox)**
+  palette it ships by default.

package/tools/statusline/statusline

@@ -300,6 +300,20 @@ function gitDirtyMark(cwd) {
   return "";
 }
 
+// Up-arrow marker when the branch is ahead of its upstream (local commits not
+// pushed). Empty when in sync, when there is no upstream, or on any git error.
+// One bounded git call (250ms).
+function gitAheadMark(cwd) {
+  const { execFileSync } = require("child_process");
+  const opts = { cwd, encoding: "utf8", timeout: 250, stdio: ["ignore", "pipe", "ignore"] };
+  try {
+    const out = execFileSync("git", ["rev-list", "--count", "@{upstream}..HEAD"], opts).trim();
+    return parseInt(out, 10) > 0 ? SYM.ahead : "";
+  } catch (_) {
+    return "";
+  }
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Segment registry — each builder takes the resolved context `c` and returns the
 // segment TEXT (a string), or null to omit (when its data is absent). All styling
@@ -323,6 +337,7 @@ const SEGMENTS = {
   branch: (c) => {
     if (!c.branch) return null;
     let t = c.wt ? `${SYM.worktree} ${SYM.branch} ${c.branch}` : `${SYM.branch} ${c.branch}`;
+    if (c.ahead) t += ` ${c.ahead}`;
     if (c.dirty) t += ` ${c.dirty}`;
     return t;
   },
@@ -384,6 +399,7 @@ function renderMain(d) {
     projectSym: SYM.project,
     wt: worktreeSubpath(cwd),
     branch: git.branch,
+    ahead: git.branch ? gitAheadMark(cwd) : "",
     dirty: git.branch ? gitDirtyMark(cwd) : "",
   };
 

package/tools/statusline/statusline.json

@@ -166,6 +166,7 @@
   },
   "symbols": {
     "agent": "",
+    "ahead": "↑",
     "branch": "",
     "context": "",
     "cost": "",