@yagni-app/code-staging 0.0.0 → 0.1.0-staging.1002.1

package/dist/upgrade.js

@@ -0,0 +1,284 @@
+/**
+ * `yagni upgrade` + the launch-time update nudge.
+ *
+ * npm is the only distribution channel, so "upgrade" means re-running the
+ * user's own global installer (`npm`/`pnpm`/`bun`, detected from where the
+ * running bin lives) against the published package. The nudge follows the
+ * desktop updater's posture: it must never cost anybody a launch. It reads
+ * only a local cache (`~/.yagni-code/update-check.json`) — zero network
+ * before the agent starts — and refreshes that cache in the background while
+ * the session runs, so the NEXT launch nudges from fresh data. Every network
+ * path fails soft to "say nothing".
+ *
+ * Set YAGNI_DISABLE_UPDATE_CHECK=1 to silence the nudge and the background
+ * check entirely (managed/enterprise environments); an explicit
+ * `yagni upgrade` still works there.
+ */
+import { spawn } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { credentialsDir } from "./credentials.js";
+import { DISTRIBUTION } from "./distribution.js";
+export const PACKAGE_NAME = DISTRIBUTION.packageName;
+export const UPDATE_CHECK_DISABLE_ENV = "YAGNI_DISABLE_UPDATE_CHECK";
+const DEFAULT_REGISTRY = "https://registry.npmjs.org";
+const FETCH_TIMEOUT_MS = 5_000;
+const SEMVER_RE = /^(0|[1-9]\d{0,5})\.(0|[1-9]\d{0,5})\.(0|[1-9]\d{0,5})(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$/;
+const INSTALL_METHODS = ["npm", "pnpm", "bun"];
+/**
+ * The CLI's own version, read from this package's package.json. Resolved
+ * relative to the module (src/ and dist/ both sit one level below the package
+ * root), so it is correct under tsx in tests and in the published tarball.
+ */
+export function currentCliVersion() {
+    const pkgPath = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+    return pkg.version ?? "0.0.0";
+}
+/** `"1"`/anything truthy disables; unset, empty, and `"0"` keep checks on. */
+export function updateChecksDisabled(env) {
+    const value = env[UPDATE_CHECK_DISABLE_ENV];
+    return value !== undefined && value !== "" && value !== "0";
+}
+/** Honors a private-registry override (proxy/mirror setups) like npm does. */
+export function registryUrl(env) {
+    const raw = env.npm_config_registry ?? env.NPM_CONFIG_REGISTRY ?? DEFAULT_REGISTRY;
+    return raw.replace(/\/+$/, "");
+}
+function parseVersion(value) {
+    const match = SEMVER_RE.exec(value);
+    if (!match)
+        return null;
+    const prerelease = [];
+    for (const identifier of match[4]?.split(".") ?? []) {
+        if (/^\d+$/.test(identifier)) {
+            if (identifier.length > 1 && identifier.startsWith("0"))
+                return null;
+            prerelease.push(Number(identifier));
+        }
+        else {
+            prerelease.push(identifier);
+        }
+    }
+    return { core: [Number(match[1]), Number(match[2]), Number(match[3])], prerelease };
+}
+function compareVersions(a, b) {
+    const parsedA = parseVersion(a);
+    const parsedB = parseVersion(b);
+    if (!parsedA || !parsedB)
+        return null;
+    for (let i = 0; i < 3; i += 1) {
+        if (parsedA.core[i] !== parsedB.core[i])
+            return parsedA.core[i] - parsedB.core[i];
+    }
+    if (parsedA.prerelease.length === 0 && parsedB.prerelease.length > 0)
+        return 1;
+    if (parsedB.prerelease.length === 0 && parsedA.prerelease.length > 0)
+        return -1;
+    const length = Math.max(parsedA.prerelease.length, parsedB.prerelease.length);
+    for (let i = 0; i < length; i += 1) {
+        const left = parsedA.prerelease[i];
+        const right = parsedB.prerelease[i];
+        if (left === undefined)
+            return -1;
+        if (right === undefined)
+            return 1;
+        if (left === right)
+            continue;
+        if (typeof left === "number" && typeof right === "number")
+            return left - right;
+        if (typeof left === "number")
+            return -1;
+        if (typeof right === "number")
+            return 1;
+        return left < right ? -1 : 1;
+    }
+    return 0;
+}
+/** Whether `candidate` is strictly newer than `current`. */
+export function isNewerVersion(current, candidate) {
+    const comparison = compareVersions(candidate, current);
+    return comparison !== null && comparison > 0;
+}
+/**
+ * Extract `dist-tags.latest` from a registry packument. Strict: this string
+ * gets printed to the terminal and interpolated into an install command, so
+ * anything that is not a plain version is treated as absent.
+ */
+export function parsePublishedVersion(body, tag) {
+    if (!body || typeof body !== "object")
+        return null;
+    const tags = body["dist-tags"];
+    if (!tags || typeof tags !== "object")
+        return null;
+    const version = tags[tag];
+    return typeof version === "string" && parseVersion(version) ? version : null;
+}
+export function parseLatestVersion(body) {
+    return parsePublishedVersion(body, DISTRIBUTION.updateTag);
+}
+/** One fail-soft registry lookup: the latest published version, or null. */
+export async function fetchLatestVersion(deps = {}) {
+    const env = deps.env ?? process.env;
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    try {
+        // Scoped names encode the slash; every registry accepts this form.
+        const url = `${registryUrl(env)}/${PACKAGE_NAME.replace("/", "%2f")}`;
+        const res = await fetchImpl(url, {
+            headers: { accept: "application/vnd.npm.install-v1+json" },
+            signal: AbortSignal.timeout(deps.timeoutMs ?? FETCH_TIMEOUT_MS),
+        });
+        if (!res.ok)
+            return null;
+        return parsePublishedVersion(await res.json(), DISTRIBUTION.updateTag);
+    }
+    catch {
+        return null;
+    }
+}
+export function updateCheckCachePath() {
+    return join(credentialsDir(), "update-check.json");
+}
+export async function readUpdateCache() {
+    try {
+        const raw = await readFile(updateCheckCachePath(), "utf8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed?.latest !== "string" || !SEMVER_RE.test(parsed.latest))
+            return null;
+        return { checkedAt: typeof parsed.checkedAt === "string" ? parsed.checkedAt : "", latest: parsed.latest };
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeUpdateCache(latest) {
+    const path = updateCheckCachePath();
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    const cache = { checkedAt: new Date().toISOString(), latest };
+    await writeFile(path, `${JSON.stringify(cache, null, 2)}\n`, "utf8");
+}
+/** The one line the nudge is allowed, or null when there is nothing to say. */
+export function updateNudge(current, latest) {
+    if (!latest || !isNewerVersion(current, latest))
+        return null;
+    return `${DISTRIBUTION.displayName} ${latest} is available (you have ${current}). Run \`${DISTRIBUTION.commandName} upgrade\`.`;
+}
+/**
+ * Print the (cache-backed) nudge, then kick off the background cache refresh.
+ * The caller awaits this function — a local file read — but must NOT await
+ * `refresh`; it completes during the session and is fire-and-forget.
+ */
+export async function maybeNudgeAndRefresh(deps) {
+    const env = deps.env ?? process.env;
+    if (updateChecksDisabled(env))
+        return { nudged: false, refresh: Promise.resolve() };
+    const log = deps.log ?? ((line) => process.stderr.write(`${line}\n`));
+    const cache = await readUpdateCache();
+    const nudge = updateNudge(deps.current, cache?.latest);
+    if (nudge)
+        log(nudge);
+    const fetchLatest = deps.fetchLatest ?? (() => fetchLatestVersion({ env }));
+    const refresh = fetchLatest()
+        .then((latest) => (latest ? writeUpdateCache(latest) : undefined))
+        .catch(() => undefined);
+    return { nudged: nudge !== null, refresh };
+}
+// ── `yagni upgrade` ─────────────────────────────────────────────────────────
+/**
+ * Which global installer owns the running bin, from its (real) path. The
+ * heuristic covers the three installers the package supports; `--method` is
+ * the escape hatch when a layout defeats it.
+ */
+export function detectInstallMethod(binPath) {
+    const normalized = binPath.replaceAll("\\", "/").toLowerCase();
+    if (normalized.includes("/.bun/"))
+        return "bun";
+    if (normalized.includes("pnpm"))
+        return "pnpm";
+    return "npm";
+}
+const UPGRADE_USAGE = `Usage: ${DISTRIBUTION.commandName} upgrade [version] [--method npm|pnpm|bun]`;
+export function parseUpgradeArgs(args) {
+    let target;
+    let method;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        let methodValue;
+        if (arg === "--method")
+            methodValue = args[++i];
+        else if (arg.startsWith("--method="))
+            methodValue = arg.slice("--method=".length);
+        else if (arg.startsWith("-"))
+            return { ok: false, error: `Unknown option: ${arg}\n${UPGRADE_USAGE}` };
+        if (methodValue !== undefined) {
+            if (!INSTALL_METHODS.includes(methodValue)) {
+                return { ok: false, error: `Unknown method: ${methodValue}\n${UPGRADE_USAGE}` };
+            }
+            method = methodValue;
+            continue;
+        }
+        if (arg.startsWith("-"))
+            continue; // already handled above
+        if (target !== undefined)
+            return { ok: false, error: `Unexpected argument: ${arg}\n${UPGRADE_USAGE}` };
+        const version = arg.replace(/^v/, "");
+        if (!SEMVER_RE.test(version)) {
+            return { ok: false, error: `Not a version: ${arg} (expected MAJOR.MINOR.PATCH)\n${UPGRADE_USAGE}` };
+        }
+        target = version;
+    }
+    return { ok: true, target, method };
+}
+function installArgv(method, target) {
+    const spec = `${PACKAGE_NAME}@${target}`;
+    return method === "npm" ? ["install", "-g", spec] : ["add", "-g", spec];
+}
+function defaultRunInstall(command, args) {
+    return new Promise((resolve) => {
+        // npm/pnpm/bun are .cmd shims on Windows; a shell is required to run them.
+        const child = spawn(command, args, { stdio: "inherit", shell: process.platform === "win32" });
+        child.on("exit", (code) => resolve(code ?? 1));
+        child.on("error", (err) => {
+            process.stderr.write(`Failed to run ${command}: ${err.message}\n`);
+            resolve(1);
+        });
+    });
+}
+export async function upgradeCommand(args, deps) {
+    const log = deps.log ?? ((line) => process.stdout.write(`${line}\n`));
+    const logError = deps.logError ?? ((line) => process.stderr.write(`${line}\n`));
+    const parsed = parseUpgradeArgs(args);
+    if (!parsed.ok) {
+        logError(parsed.error);
+        return 1;
+    }
+    const env = deps.env ?? process.env;
+    const method = parsed.method ?? detectInstallMethod(deps.binPath ?? process.argv[1] ?? "");
+    const fetchLatest = deps.fetchLatest ?? (() => fetchLatestVersion({ env }));
+    const target = parsed.target ?? (await fetchLatest());
+    if (!target) {
+        logError("Could not reach the npm registry to find the latest version. " +
+            `Check your connection, or pass one explicitly: ${DISTRIBUTION.commandName} upgrade <version>`);
+        return 1;
+    }
+    if (target === deps.current) {
+        log(`${DISTRIBUTION.displayName} ${target} is already installed.`);
+        await writeUpdateCache(target).catch(() => undefined);
+        return 0;
+    }
+    log(`Upgrading ${DISTRIBUTION.displayName} ${deps.current} → ${target} (${method})…`);
+    const runInstall = deps.runInstall ?? defaultRunInstall;
+    const code = await runInstall(method, installArgv(method, target));
+    if (code !== 0) {
+        logError(`Upgrade failed (${method} exited ${code}). ` +
+            `If it was a permissions error, fix your ${method} global prefix or retry with elevated permissions.`);
+        return 1;
+    }
+    // Keep the nudge honest: the freshly installed version is the known latest.
+    await writeUpdateCache(target).catch(() => undefined);
+    log(`${DISTRIBUTION.displayName} ${target} installed. Run \`${DISTRIBUTION.commandName} version\` to confirm.`);
+    return 0;
+}
+//# sourceMappingURL=upgrade.js.map

package/package.json

@@ -1,6 +1,42 @@
 {
   "name": "@yagni-app/code-staging",
-  "version": "0.0.0",
-  "description": "Placeholder. Install with: npm install -g @yagni-app/code-staging@staging",
-  "license": "UNLICENSED"
+  "version": "0.1.0-staging.1002.1",
+  "description": "YAGNI Code: a terminal coding agent that already knows your company. One YAGNI login routes the model and grounds the agent in your team's context.",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "author": "YAGNI, Inc. <jack@yagni.app> (https://yagni.app)",
+  "publishConfig": {
+    "access": "public"
+  },
+  "homepage": "https://yagni.app/code",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/YAGNI-App/YAGNI.git",
+    "directory": "packages/yagni-code-cli"
+  },
+  "keywords": [
+    "yagni",
+    "coding-agent",
+    "ai",
+    "cli",
+    "terminal"
+  ],
+  "type": "module",
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "bin": {
+    "yagni-staging": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map"
+  ],
+  "main": "./dist/cli.js",
+  "types": "./dist/cli.d.ts",
+  "dependencies": {
+    "@earendil-works/pi-coding-agent": "0.83.0",
+    "@earendil-works/pi-tui": "0.83.0",
+    "typebox": "^1.1.38"
+  },
+  "yagniSourceSha": "b173c9b46d20c3399724503b72e2d83b65f3dedb"
 }