useathena 0.2.0 → 0.2.1

package/README.md

@@ -165,6 +165,9 @@ installs the browser-sensor API as a login service, and prints the extension set
 with its token. `--yes` takes the first detected provider and says yes to all of it;
 opt out per-piece with `--no-hook`, `--no-service`, `--skip-test`, or `--model <spec>`.
 
+Already installed? `athena update` pulls the latest published version and
+restarts the background serve service on the new code.
+
 Model providers are spec strings, set once by `setup` (or per-run via `ATHENA_MODEL`):
 
 ```text

package/dist/cli/service.js

@@ -43,6 +43,13 @@ Restart=always
 WantedBy=default.target
 `;
 }
+export function serviceInstalled(platform = process.platform) {
+    if (platform === "darwin")
+        return existsSync(join(homedir(), "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`));
+    if (platform === "linux")
+        return existsSync(join(homedir(), ".config", "systemd", "user", SYSTEMD_UNIT));
+    return false;
+}
 export function installService(athenaBin, platform = process.platform) {
     const logPath = join(dirname(dbPath()), "serve.log");
     if (platform === "darwin") {

package/dist/cli/update.js

@@ -0,0 +1,81 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { installService, serviceInstalled } from "./service.js";
+import { bold, dim, green, red, yellow } from "./format.js";
+export function compareVersions(a, b) {
+    const left = a.split(".").map(Number);
+    const right = b.split(".").map(Number);
+    for (let i = 0; i < Math.max(left.length, right.length); i += 1) {
+        const diff = (left[i] ?? 0) - (right[i] ?? 0);
+        if (diff !== 0)
+            return Math.sign(diff);
+    }
+    return 0;
+}
+export function planUpdate(opts) {
+    if (opts.devCheckout)
+        return "dev-checkout";
+    return compareVersions(opts.current, opts.latest) < 0 ? "install" : "up-to-date";
+}
+export function readPackageInfo(packageRoot) {
+    const pkg = JSON.parse(readFileSync(join(packageRoot, "package.json"), "utf8"));
+    return { name: pkg.name, version: pkg.version };
+}
+export async function fetchLatestVersion(name, timeoutMs = 10_000) {
+    const response = await fetch(`https://registry.npmjs.org/${name}/latest`, { signal: AbortSignal.timeout(timeoutMs) });
+    if (!response.ok)
+        throw new Error(`npm registry lookup failed: HTTP ${response.status}`);
+    const body = (await response.json());
+    if (!body.version)
+        throw new Error("npm registry reply had no version");
+    return body.version;
+}
+export function nudgeLine(current, latest) {
+    if (compareVersions(current, latest) >= 0)
+        return undefined;
+    return `\n${yellow("↑")} ${latest} is out (you run ${current}) — update with ${bold("athena update")}`;
+}
+/** One quiet line at the end of `athena status` when the registry is ahead; silent offline. */
+export async function updateNudge(packageRoot) {
+    try {
+        const { name, version } = readPackageInfo(packageRoot);
+        return nudgeLine(version, await fetchLatestVersion(name, 1_500));
+    }
+    catch {
+        return undefined;
+    }
+}
+function globalAthenaBin() {
+    const prefix = spawnSync("npm", ["prefix", "-g"], { encoding: "utf8" }).stdout?.trim();
+    if (!prefix)
+        return undefined;
+    const bin = join(prefix, "bin", "athena");
+    return existsSync(bin) ? bin : undefined;
+}
+export async function runUpdate(packageRoot, athenaBin) {
+    const { name, version } = readPackageInfo(packageRoot);
+    const latest = await fetchLatestVersion(name);
+    const plan = planUpdate({ current: version, latest, devCheckout: existsSync(join(packageRoot, ".git")) });
+    if (plan === "dev-checkout") {
+        console.log(`${yellow("dev checkout")} at ${packageRoot} — update with ${bold("git pull")} (running ${version}, registry has ${latest})`);
+        return;
+    }
+    if (plan === "up-to-date") {
+        console.log(`${green("✓")} athena ${version} is up to date`);
+        return;
+    }
+    console.log(dim(`updating ${name} ${version} → ${latest} (npm install -g)…`));
+    const install = spawnSync("npm", ["install", "-g", `${name}@latest`], { encoding: "utf8" });
+    if (install.status !== 0) {
+        console.log(red(`✗ update failed: ${(install.stderr ?? "").trim().slice(-300)}`));
+        console.log(yellow(`  retry manually: npm install -g ${name}@latest`));
+        process.exitCode = 1;
+        return;
+    }
+    console.log(`${green("✓")} athena ${latest} installed`);
+    if (serviceInstalled()) {
+        const result = installService(globalAthenaBin() ?? athenaBin);
+        console.log(result.installed ? `${green("✓")} serve service restarted on ${latest}` : yellow(result.message));
+    }
+}

package/dist/cli.js

@@ -15,6 +15,7 @@ import { maybeAutoLearn } from "./serve/auto-learn.js";
 import { recordOutcome } from "./serve/outcome.js";
 import { loadConfig } from "./config.js";
 import { installClaudeCodeHook, runSetup } from "./cli/setup.js";
+import { readPackageInfo, runUpdate, updateNudge } from "./cli/update.js";
 import { bold, dim, green, red, yellow } from "./cli/format.js";
 const packageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
 const athenaBin = join(packageRoot, "bin", "athena");
@@ -43,6 +44,7 @@ usage: athena <command> [args]
   ${bold("hook")} install [--print]    install the Claude Code sensor hook into ~/.claude/settings.json
   ${bold("serve")} [--port n]          local API for browser sensors (default 127.0.0.1:4517)
   ${bold("serve")} install|uninstall   run the API at login (launchd/systemd user service)
+  ${bold("update")}                    update to the latest published version (restarts serve)
   ${bold("mcp")}                       run the MCP stdio server (claude mcp add athena -- athena mcp)
 
 store: ${dbPath()}  ${dim("(override with ATHENA_DB)")}
@@ -57,6 +59,10 @@ async function main() {
         console.log(HELP);
         return;
     }
+    if (command === "version" || command === "--version") {
+        console.log(readPackageInfo(packageRoot).version);
+        return;
+    }
     if (command === "hook") {
         await runHook(args);
         return;
@@ -76,9 +82,13 @@ async function main() {
                 console.log(dim(`\nfor the guided version (model provider, sensors): athena setup`));
                 break;
             }
-            case "status":
+            case "status": {
                 console.log(cmdStatus(store));
+                const nudge = await updateNudge(packageRoot);
+                if (nudge)
+                    console.log(nudge);
                 break;
+            }
             case "rules": {
                 const domain = flag(args, "domain");
                 console.log(cmdRules(store, {
@@ -206,6 +216,10 @@ async function main() {
                 });
                 break;
             }
+            case "update": {
+                await runUpdate(packageRoot, athenaBin);
+                break;
+            }
             case "mcp": {
                 // stdio transport: stdout belongs to the protocol, so print nothing.
                 const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "useathena",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "athena captures tacit knowledge from real work so agents become truly autonomous and reliable.",
   "license": "UNLICENSED",
   "repository": {