@sweny-ai/core 0.1.65 → 0.1.67

package/dist/cli/upgrade.js

@@ -0,0 +1,219 @@
+import * as path from "node:path";
+import chalk from "chalk";
+/**
+ * Detect the package manager that owns this install by walking the parent
+ * chain of the CLI entrypoint. The rules are ordered by specificity — more
+ * distinctive roots (bun, volta, pnpm, homebrew) beat the generic
+ * `lib/node_modules` npm layout.
+ */
+export function detectPackageManager(installPath) {
+    // Normalize to forward slashes so Windows paths match the same patterns.
+    const p = installPath.replace(/\\/g, "/").toLowerCase();
+    if (p.includes("/homebrew/") || p.includes("/cellar/"))
+        return "brew";
+    if (p.includes("/.volta/"))
+        return "volta";
+    if (p.includes("/.bun/"))
+        return "bun";
+    // pnpm global store lives under ~/.local/share/pnpm or ~/Library/pnpm, and
+    // the actual binary is a symlink — the resolved path typically contains
+    // either `/pnpm/` or the global store marker `/pnpm-global/`.
+    if (p.includes("/pnpm/") || p.includes("/pnpm-global/") || p.includes("/.pnpm-store/"))
+        return "pnpm";
+    // Yarn's global install folder is ~/.config/yarn/global or
+    // ~/.yarn/global — check for both.
+    if (p.includes("/.yarn/") || p.includes("/yarn/global/"))
+        return "yarn";
+    // Default: assume npm if we see node_modules — covers nvm, fnm, asdf,
+    // vanilla Node, and every CI runner.
+    if (p.includes("/node_modules/"))
+        return "npm";
+    return "unknown";
+}
+/**
+ * Resolve the install-root directory for writability checks. For npm-style
+ * layouts, walk up until we find `node_modules/@sweny-ai/core` and return
+ * the parent of `node_modules` (the writable prefix). Returns null if the
+ * install path doesn't look like a package-manager install.
+ */
+export function resolveInstallRoot(installPath) {
+    let cur = path.dirname(installPath);
+    const visited = new Set();
+    while (cur && !visited.has(cur) && path.dirname(cur) !== cur) {
+        visited.add(cur);
+        if (path.basename(cur) === "@sweny-ai") {
+            // cur = .../node_modules/@sweny-ai — parent of node_modules is the root
+            const nodeModules = path.dirname(cur);
+            if (path.basename(nodeModules) === "node_modules") {
+                return path.dirname(nodeModules);
+            }
+        }
+        cur = path.dirname(cur);
+    }
+    return null;
+}
+/** Build the (cmd, args) pair for a given package manager + tag. */
+export function installCommandFor(pm, tag) {
+    const ref = `@sweny-ai/core@${tag}`;
+    switch (pm) {
+        case "npm":
+            return { cmd: "npm", args: ["install", "-g", ref] };
+        case "pnpm":
+            return { cmd: "pnpm", args: ["add", "-g", ref] };
+        case "yarn":
+            return { cmd: "yarn", args: ["global", "add", ref] };
+        case "bun":
+            return { cmd: "bun", args: ["add", "-g", ref] };
+        case "volta":
+            return { cmd: "volta", args: ["install", `@sweny-ai/core@${tag}`] };
+        case "brew":
+        case "unknown":
+            return null;
+    }
+}
+/**
+ * Compare two semver-ish version strings. Returns:
+ *  - `>0` when `a > b`
+ *  - `<0` when `a < b`
+ *  - `0` when equal
+ *
+ * Handles numeric core (`major.minor.patch`) and pre-release strings
+ * conservatively: any pre-release (`-alpha.1`) is treated as *lower* than
+ * the same core without one, matching npm's semver ordering at the level
+ * of precision we need for "is the registry newer than me."
+ */
+export function compareVersions(a, b) {
+    const parse = (v) => {
+        const [core, pre] = v.split("-", 2);
+        const nums = core.split(".").map((n) => {
+            const parsed = Number.parseInt(n, 10);
+            return Number.isFinite(parsed) ? parsed : 0;
+        });
+        return { nums, pre: pre ?? "" };
+    };
+    const pa = parse(a);
+    const pb = parse(b);
+    const len = Math.max(pa.nums.length, pb.nums.length);
+    for (let i = 0; i < len; i++) {
+        const av = pa.nums[i] ?? 0;
+        const bv = pb.nums[i] ?? 0;
+        if (av !== bv)
+            return av - bv;
+    }
+    // Core equal — a pre-release ranks lower than a release.
+    if (pa.pre && !pb.pre)
+        return -1;
+    if (!pa.pre && pb.pre)
+        return 1;
+    if (pa.pre < pb.pre)
+        return -1;
+    if (pa.pre > pb.pre)
+        return 1;
+    return 0;
+}
+/**
+ * Fetch the latest published version of `@sweny-ai/core` from the npm
+ * registry. Uses the dist-tag endpoint which returns a small, cacheable JSON
+ * document — no tarball download.
+ */
+export async function fetchLatestFromNpm(tag) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5000);
+    try {
+        const res = await fetch(`https://registry.npmjs.org/@sweny-ai/core/${encodeURIComponent(tag)}`, {
+            signal: controller.signal,
+            headers: { accept: "application/json" },
+        });
+        if (!res.ok) {
+            throw new Error(`npm registry returned ${res.status} ${res.statusText}`);
+        }
+        const body = (await res.json());
+        if (typeof body.version !== "string" || body.version.length === 0) {
+            throw new Error("npm registry response missing `version` field");
+        }
+        return body.version;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+const BREW_HINT = "This CLI looks like it was installed via Homebrew. Run `brew upgrade sweny` or `brew update && brew upgrade sweny`.";
+const UNKNOWN_HINT = "Couldn't detect your package manager. Install the latest manually with:\n    npm install -g @sweny-ai/core@latest";
+/**
+ * Main `sweny upgrade` entrypoint. Resolves the latest version, decides
+ * whether an install is needed, dispatches to the right package manager,
+ * and surfaces permission problems as actionable copy-paste commands.
+ */
+export async function runUpgrade(options, deps) {
+    const stdout = deps.stdout ?? process.stdout;
+    const stderr = deps.stderr ?? process.stderr;
+    const exit = deps.exit ?? ((code) => process.exit(code));
+    const tag = options.tag && options.tag.length > 0 ? options.tag : "latest";
+    let latest;
+    try {
+        latest = await deps.fetchLatestVersion(tag);
+    }
+    catch (err) {
+        stderr.write(chalk.red(`  Error: couldn't reach the npm registry — ${err instanceof Error ? err.message : String(err)}`) +
+            "\n");
+        stderr.write(chalk.dim("  Check your network connection and try again.") + "\n");
+        exit(1);
+        return;
+    }
+    const current = deps.currentVersion;
+    const cmp = compareVersions(current, latest);
+    if (cmp >= 0 && !options.force) {
+        if (cmp === 0) {
+            stdout.write(chalk.green(`  ✓ sweny ${current} is already the latest.`) + "\n");
+        }
+        else {
+            stdout.write(chalk.yellow(`  You're running sweny ${current}, which is newer than the published ${latest}. Nothing to do.`) +
+                "\n");
+        }
+        exit(0);
+        return;
+    }
+    const pm = detectPackageManager(deps.installPath);
+    // Homebrew has its own update cadence — we don't try to drive it from here.
+    if (pm === "brew") {
+        stdout.write(chalk.cyan(`  sweny ${latest} is available (you have ${current}).`) + "\n");
+        stderr.write(chalk.dim(`  ${BREW_HINT}`) + "\n");
+        exit(options.check ? 0 : 1);
+        return;
+    }
+    const installCmd = installCommandFor(pm, tag);
+    if (!installCmd) {
+        stdout.write(chalk.cyan(`  sweny ${latest} is available (you have ${current}).`) + "\n");
+        stderr.write(chalk.dim(`  ${UNKNOWN_HINT}`) + "\n");
+        exit(options.check ? 0 : 1);
+        return;
+    }
+    const fullCmd = [installCmd.cmd, ...installCmd.args].join(" ");
+    if (options.check) {
+        stdout.write(chalk.cyan(`  sweny ${latest} is available (you have ${current}).`) + "\n");
+        stdout.write(chalk.dim(`  Run: ${fullCmd}`) + "\n");
+        exit(0);
+        return;
+    }
+    // Permissions probe — for npm-style layouts, the user needs write access to
+    // the prefix. If not, we print the exact sudo-prefixed command so they can
+    // copy-paste without guessing.
+    const root = resolveInstallRoot(deps.installPath);
+    if (root && !deps.canWrite(root)) {
+        stderr.write(chalk.red(`  Error: no write permission on ${root}`) + "\n");
+        stderr.write(chalk.dim(`  Try: sudo ${fullCmd}`) + "\n");
+        stderr.write(chalk.dim(`  Or reinstall Node with a user-writable prefix (nvm, fnm, volta) to avoid sudo.`) + "\n");
+        exit(1);
+        return;
+    }
+    stdout.write(chalk.cyan(`  Upgrading sweny ${current} → ${latest} via ${pm}…`) + "\n");
+    stdout.write(chalk.dim(`  $ ${fullCmd}`) + "\n");
+    const code = deps.runInstall(installCmd.cmd, installCmd.args);
+    if (code !== 0) {
+        stderr.write(chalk.red(`  Error: ${installCmd.cmd} exited with code ${code}`) + "\n");
+        exit(code);
+        return;
+    }
+    stdout.write(chalk.green(`  ✓ Upgraded sweny to ${latest}.`) + "\n");
+    exit(0);
+}

package/dist/cli/version-check.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Passive "a new sweny is out" nudge. Runs as a commander `postAction` hook
+ * so every command prints at most one dim footer line when behind.
+ *
+ * Design goals:
+ *   1. Never block the user's command. Cache reads are sync; network refresh
+ *      happens inline but bounded to a tight budget — if the registry is slow
+ *      we swallow the error silently and try again in 24h.
+ *   2. Never nag in contexts where nobody's watching — CI, pipes, or when the
+ *      user has explicitly opted out.
+ *   3. Never fire from inside `sweny upgrade` itself (would double-print the
+ *      upgrade hint right before/after running the install).
+ */
+export declare const CACHE_TTL_MS: number;
+/** Budget for the background registry refresh. Short on purpose. */
+export declare const REFRESH_BUDGET_MS = 1500;
+export interface CacheEntry {
+    latest: string;
+    checkedAt: number;
+}
+export interface VersionCheckDeps {
+    currentVersion: string;
+    cachePath: string;
+    now: number;
+    env: NodeJS.ProcessEnv;
+    isTty: boolean;
+    /** The command the user ran, so we can suppress the nudge for self-referential commands. */
+    commandName?: string;
+    stderr?: NodeJS.WritableStream;
+    fetchLatestVersion?: (tag: string) => Promise<string>;
+    /** Injected so tests can make the refresh synchronous + deterministic. */
+    now_fn?: () => number;
+}
+/**
+ * Decide whether any version-check work should run at all. We bail early for:
+ *   - `CI=1`: noise in pipelines and reads tokens
+ *   - `SWENY_NO_UPDATE_CHECK=1`: explicit opt-out
+ *   - `SWENY_OFFLINE=1`: users behind airgaps
+ *   - Non-TTY stderr: scripts and pipes
+ *   - `upgrade` / `update` commands: the command itself handles the hint
+ */
+export declare function shouldSkip(env: NodeJS.ProcessEnv, isTty: boolean, commandName: string | undefined): boolean;
+export declare function readCache(cachePath: string): CacheEntry | null;
+export declare function writeCache(cachePath: string, entry: CacheEntry): void;
+export declare function isCacheFresh(entry: CacheEntry, now: number, ttl?: number): boolean;
+export declare function formatNudge(current: string, latest: string): string;
+/**
+ * Resolve the cache path on disk. Honors `XDG_CACHE_HOME` and falls back to
+ * `~/.cache/sweny/version-check.json`. We isolate this so tests can inject a
+ * tmpdir without touching the real cache.
+ */
+export declare function defaultCachePath(env?: NodeJS.ProcessEnv, home?: string): string;
+/**
+ * Run the check. Prints a nudge if the cache shows a newer version, then
+ * refreshes the cache in the background if it's stale or missing.
+ *
+ * The refresh is awaited with a short timeout so we don't hang the CLI, but
+ * we also don't surface its result on *this* run — that keeps the code paths
+ * simple and avoids "first run after install" printing a nudge before the
+ * user's command finishes rendering.
+ */
+export declare function maybeNudge(deps: VersionCheckDeps): Promise<void>;

package/dist/cli/version-check.js

@@ -0,0 +1,123 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import chalk from "chalk";
+import { compareVersions, fetchLatestFromNpm } from "./upgrade.js";
+/**
+ * Passive "a new sweny is out" nudge. Runs as a commander `postAction` hook
+ * so every command prints at most one dim footer line when behind.
+ *
+ * Design goals:
+ *   1. Never block the user's command. Cache reads are sync; network refresh
+ *      happens inline but bounded to a tight budget — if the registry is slow
+ *      we swallow the error silently and try again in 24h.
+ *   2. Never nag in contexts where nobody's watching — CI, pipes, or when the
+ *      user has explicitly opted out.
+ *   3. Never fire from inside `sweny upgrade` itself (would double-print the
+ *      upgrade hint right before/after running the install).
+ */
+export const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+/** Budget for the background registry refresh. Short on purpose. */
+export const REFRESH_BUDGET_MS = 1500;
+/**
+ * Decide whether any version-check work should run at all. We bail early for:
+ *   - `CI=1`: noise in pipelines and reads tokens
+ *   - `SWENY_NO_UPDATE_CHECK=1`: explicit opt-out
+ *   - `SWENY_OFFLINE=1`: users behind airgaps
+ *   - Non-TTY stderr: scripts and pipes
+ *   - `upgrade` / `update` commands: the command itself handles the hint
+ */
+export function shouldSkip(env, isTty, commandName) {
+    if (env.CI)
+        return true;
+    if (env.SWENY_NO_UPDATE_CHECK)
+        return true;
+    if (env.SWENY_OFFLINE)
+        return true;
+    if (!isTty)
+        return true;
+    if (commandName === "upgrade" || commandName === "update")
+        return true;
+    return false;
+}
+export function readCache(cachePath) {
+    try {
+        const raw = fs.readFileSync(cachePath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.latest !== "string" || typeof parsed.checkedAt !== "number") {
+            return null;
+        }
+        if (parsed.latest.length === 0)
+            return null;
+        return { latest: parsed.latest, checkedAt: parsed.checkedAt };
+    }
+    catch {
+        return null;
+    }
+}
+export function writeCache(cachePath, entry) {
+    try {
+        fs.mkdirSync(path.dirname(cachePath), { recursive: true });
+        fs.writeFileSync(cachePath, JSON.stringify(entry));
+    }
+    catch {
+        // Cache-write failures are non-fatal — we'll just retry next run.
+    }
+}
+export function isCacheFresh(entry, now, ttl = CACHE_TTL_MS) {
+    return now - entry.checkedAt < ttl;
+}
+export function formatNudge(current, latest) {
+    return chalk.dim(`  › sweny ${latest} is available (you have ${current}). Run \`sweny upgrade\``);
+}
+/**
+ * Resolve the cache path on disk. Honors `XDG_CACHE_HOME` and falls back to
+ * `~/.cache/sweny/version-check.json`. We isolate this so tests can inject a
+ * tmpdir without touching the real cache.
+ */
+export function defaultCachePath(env = process.env, home = os.homedir()) {
+    const xdg = env.XDG_CACHE_HOME && env.XDG_CACHE_HOME.length > 0 ? env.XDG_CACHE_HOME : path.join(home, ".cache");
+    return path.join(xdg, "sweny", "version-check.json");
+}
+/**
+ * Run the check. Prints a nudge if the cache shows a newer version, then
+ * refreshes the cache in the background if it's stale or missing.
+ *
+ * The refresh is awaited with a short timeout so we don't hang the CLI, but
+ * we also don't surface its result on *this* run — that keeps the code paths
+ * simple and avoids "first run after install" printing a nudge before the
+ * user's command finishes rendering.
+ */
+export async function maybeNudge(deps) {
+    if (shouldSkip(deps.env, deps.isTty, deps.commandName))
+        return;
+    const stderr = deps.stderr ?? process.stderr;
+    const cache = readCache(deps.cachePath);
+    if (cache && compareVersions(deps.currentVersion, cache.latest) < 0) {
+        stderr.write(formatNudge(deps.currentVersion, cache.latest) + "\n");
+    }
+    if (cache && isCacheFresh(cache, deps.now))
+        return;
+    // Stale or missing — refresh in the background with a hard timeout. We
+    // race the fetch against a timer so the process can exit promptly even if
+    // the registry hangs.
+    const fetchFn = deps.fetchLatestVersion ?? fetchLatestFromNpm;
+    try {
+        const latest = await Promise.race([
+            fetchFn("latest").catch(() => null),
+            new Promise((resolve) => {
+                const t = setTimeout(() => resolve(null), REFRESH_BUDGET_MS);
+                // Don't keep the event loop alive purely for this timer.
+                if (typeof t.unref === "function") {
+                    t.unref();
+                }
+            }),
+        ]);
+        if (latest) {
+            writeCache(deps.cachePath, { latest, checkedAt: deps.now });
+        }
+    }
+    catch {
+        // Swallow — network hiccups shouldn't be user-visible here.
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sweny-ai/core",
-  "version": "0.1.65",
+  "version": "0.1.67",
   "type": "module",
   "bin": {
     "sweny": "./dist/cli/main.js"