@canonical/pragma-cli 0.30.0 → 0.31.0

package/src/domains/graph/operations/inspectUri.test.ts

@@ -2,7 +2,7 @@ import type { Store } from "@canonical/ke";
 import { afterAll, beforeAll, describe, expect, it } from "vitest";
 import { PragmaError } from "#error";
 import { createTestStore, DS_ALL_TTL } from "#testing";
-import { P, PREFIX_MAP } from "../../shared/prefixes.js";
+import { DEFAULT_PREFIX_MAP, P } from "../../shared/prefixes.js";
 import inspectUri from "./inspectUri.js";
 
 let store: Store;
@@ -19,7 +19,7 @@ afterAll(() => cleanup());
 describe("inspectUri", () => {
   it("returns grouped triples for a known URI", async () => {
     const result = await inspectUri(store, `${P.ds}global.component.button`);
-    expect(result.uri).toBe(`${PREFIX_MAP.ds}global.component.button`);
+    expect(result.uri).toBe(`${DEFAULT_PREFIX_MAP.ds}global.component.button`);
     expect(result.groups.length).toBeGreaterThan(0);
 
     const predicates = result.groups.map((g) => g.predicate);
@@ -30,15 +30,15 @@ describe("inspectUri", () => {
 
   it("resolves prefixed URIs", async () => {
     const result = await inspectUri(store, `${P.ds}global.component.button`);
-    expect(result.uri).toBe(`${PREFIX_MAP.ds}global.component.button`);
+    expect(result.uri).toBe(`${DEFAULT_PREFIX_MAP.ds}global.component.button`);
   });
 
   it("accepts full URIs", async () => {
     const result = await inspectUri(
       store,
-      `${PREFIX_MAP.ds}global.component.button`,
+      `${DEFAULT_PREFIX_MAP.ds}global.component.button`,
     );
-    expect(result.uri).toBe(`${PREFIX_MAP.ds}global.component.button`);
+    expect(result.uri).toBe(`${DEFAULT_PREFIX_MAP.ds}global.component.button`);
     expect(result.groups.length).toBeGreaterThan(0);
   });
 

package/src/domains/graphql/commands/serve.test.ts

@@ -1,4 +1,5 @@
 import { afterEach, describe, expect, it } from "vitest";
+import { PragmaError } from "#error";
 import type { PragmaContext } from "../../shared/context.js";
 import serveCommand, { readPort } from "./serve.js";
 
@@ -7,15 +8,20 @@ describe("readPort", () => {
     expect(readPort("4001")).toBe(4001);
   });
 
-  it("falls back to the default for non-string values", () => {
+  it("uses the default when the flag is absent", () => {
     expect(readPort(undefined)).toBe(4000);
-    expect(readPort(4001)).toBe(4000);
+    expect(readPort("")).toBe(4000);
   });
 
-  it("falls back to the default for out-of-range or unparseable values", () => {
-    expect(readPort("0")).toBe(4000);
-    expect(readPort("70000")).toBe(4000);
-    expect(readPort("not-a-port")).toBe(4000);
+  it("rejects an out-of-range or unparseable provided port", () => {
+    for (const value of ["0", "70000", "not-a-port"]) {
+      expect(() => readPort(value)).toThrowError(PragmaError);
+      try {
+        readPort(value);
+      } catch (error) {
+        expect((error as PragmaError).code).toBe("INVALID_INPUT");
+      }
+    }
   });
 });
 

package/src/domains/graphql/commands/serve.ts

@@ -18,15 +18,25 @@ function readStringArray(value: unknown): string[] {
     : [];
 }
 
-/** Parse the --port flag, falling back to the default on anything invalid. */
+/**
+ * Parse the `--port` flag. A missing flag uses the default; a provided value
+ * must be a valid port (1–65535), otherwise it is rejected rather than
+ * silently falling back and masking the user's mistake.
+ *
+ * @throws PragmaError INVALID_INPUT when a provided `--port` is not a valid port.
+ */
 export function readPort(value: unknown): number {
-  if (typeof value !== "string") {
+  if (value === undefined || value === null || value === "") {
     return DEFAULT_PORT;
   }
-  const port = Number.parseInt(value, 10);
-  return Number.isInteger(port) && port > 0 && port < 65536
-    ? port
-    : DEFAULT_PORT;
+  const text = String(value).trim();
+  const port = Number(text);
+  if (!/^\d+$/.test(text) || port < 1 || port > 65535) {
+    throw PragmaError.invalidInput("port", String(value), {
+      recovery: { message: "Provide a port between 1 and 65535." },
+    });
+  }
+  return port;
 }
 
 /**

package/src/domains/graphql/helpers/parsePrefixes.test.ts

@@ -1,17 +1,17 @@
 import { describe, expect, it } from "vitest";
-import { PREFIX_MAP } from "../../shared/prefixes.js";
+import { DEFAULT_PREFIX_MAP } from "../../shared/prefixes.js";
 import parsePrefixes from "./parsePrefixes.js";
 
 describe("parsePrefixes", () => {
   it("returns the default prefix map for no entries", () => {
     const prefixes = parsePrefixes([]);
-    expect(prefixes).toEqual(PREFIX_MAP);
+    expect(prefixes).toEqual(DEFAULT_PREFIX_MAP);
   });
 
   it("merges entries on top of the defaults", () => {
     const prefixes = parsePrefixes(["ex=http://example.org/"]);
     expect(prefixes.ex).toBe("http://example.org/");
-    expect(prefixes.ds).toBe(PREFIX_MAP.ds);
+    expect(prefixes.ds).toBe(DEFAULT_PREFIX_MAP.ds);
   });
 
   it("lets entries override default prefixes", () => {

package/src/domains/graphql/helpers/parsePrefixes.ts

@@ -1,11 +1,11 @@
 import { PragmaError } from "#error";
-import { PREFIX_MAP } from "../../shared/prefixes.js";
+import { DEFAULT_PREFIX_MAP } from "../../shared/prefixes.js";
 
 /**
  * Parse repeated `--prefix name=namespace` entries into a prefix map.
  *
  * User-supplied prefixes are merged on top of pragma's default
- * {@link PREFIX_MAP}, so `ds:` and the W3C vocabularies stay available
+ * {@link DEFAULT_PREFIX_MAP}, so `ds:` and the W3C vocabularies stay available
  * unless explicitly overridden.
  *
  * @param entries - Raw `name=namespace` strings from the CLI.
@@ -15,7 +15,7 @@ import { PREFIX_MAP } from "../../shared/prefixes.js";
 export default function parsePrefixes(
   entries: readonly string[],
 ): Record<string, string> {
-  const prefixes: Record<string, string> = { ...PREFIX_MAP };
+  const prefixes: Record<string, string> = { ...DEFAULT_PREFIX_MAP };
 
   for (const entry of entries) {
     const separator = entry.indexOf("=");

package/src/domains/graphql/helpers/resolveSourceFiles.test.ts

@@ -53,4 +53,13 @@ describe("resolveSourceFiles", () => {
     const files = resolveSourceFiles(["b.ttl", "nested/*.ttl"], dir);
     expect(files).toEqual([join(dir, "b.ttl"), join(dir, "nested", "c.ttl")]);
   });
+
+  it("skips a directory path instead of treating it as a file", () => {
+    // A directory would later crash readFileSync with EISDIR.
+    expect(resolveSourceFiles(["nested"], dir)).toEqual([]);
+  });
+
+  it("resolves the empty string (the cwd directory) to no files", () => {
+    expect(resolveSourceFiles([""], dir)).toEqual([]);
+  });
 });

package/src/domains/graphql/helpers/resolveSourceFiles.ts

@@ -8,9 +8,27 @@
  * @note Impure — reads filesystem to expand globs and check existence.
  */
 
-import { existsSync, globSync } from "node:fs";
+import { globSync, statSync } from "node:fs";
 import { resolve } from "node:path";
 
+/**
+ * Whether a path points at an existing regular file.
+ *
+ * Guards against a directory (or the empty-string path, which resolves to the
+ * cwd directory) slipping through as a "source" and later crashing readFileSync
+ * with EISDIR.
+ *
+ * @param absPath - Absolute path to check.
+ * @returns True when the path exists and is a regular file.
+ */
+function isRegularFile(absPath: string): boolean {
+  try {
+    return statSync(absPath).isFile();
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Expand file paths and glob patterns into absolute file paths.
  *
@@ -31,11 +49,14 @@ export default function resolveSourceFiles(
       pattern.includes("[")
     ) {
       for (const file of globSync(pattern, { cwd })) {
-        files.push(resolve(cwd, file));
+        const absPath = resolve(cwd, file);
+        if (isRegularFile(absPath)) {
+          files.push(absPath);
+        }
       }
     } else {
       const absPath = resolve(cwd, pattern);
-      if (existsSync(absPath)) {
+      if (isRegularFile(absPath)) {
         files.push(absPath);
       }
     }

package/src/domains/graphql/operations/compileSchema.test.ts

@@ -6,10 +6,10 @@ import {
   GRAPHQL_ERROR_TTL,
   GRAPHQL_FATAL_TTL,
 } from "#testing";
-import { PREFIX_MAP } from "../../shared/prefixes.js";
+import { DEFAULT_PREFIX_MAP } from "../../shared/prefixes.js";
 import compileSchema from "./compileSchema.js";
 
-const PREFIXES = { ...PREFIX_MAP, ex: EX_NAMESPACE };
+const PREFIXES = { ...DEFAULT_PREFIX_MAP, ex: EX_NAMESPACE };
 
 const inline = (content: string, path: string) => ({
   content,

package/src/domains/graphql/operations/createSchemaServer.test.ts

@@ -1,9 +1,9 @@
 import { afterEach, describe, expect, it } from "vitest";
 import { EX_NAMESPACE, GRAPHQL_CLEAN_TTL } from "#testing";
-import { PREFIX_MAP } from "../../shared/prefixes.js";
+import { DEFAULT_PREFIX_MAP } from "../../shared/prefixes.js";
 import createSchemaServer, { type SchemaServer } from "./createSchemaServer.js";
 
-const PREFIXES = { ...PREFIX_MAP, ex: EX_NAMESPACE };
+const PREFIXES = { ...DEFAULT_PREFIX_MAP, ex: EX_NAMESPACE };
 
 describe("createSchemaServer", () => {
   let server: SchemaServer | undefined;

package/src/domains/graphql/operations/ensureSchemaArtifact.test.ts

@@ -0,0 +1,167 @@
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
+import { EX_NAMESPACE, GRAPHQL_CLEAN_TTL, GRAPHQL_FATAL_TTL } from "#testing";
+import { DEFAULT_PREFIX_MAP } from "../../shared/prefixes.js";
+import type { SemanticPackage } from "../../shared/semanticPackage.js";
+import ensureSchemaArtifact, {
+  resolveSchemaArtifactPath,
+} from "./ensureSchemaArtifact.js";
+
+const PREFIXES = { ...DEFAULT_PREFIX_MAP, ex: EX_NAMESPACE };
+
+let dataDir: string;
+let cwd: string;
+let originalXdgData: string | undefined;
+
+beforeAll(() => {
+  dataDir = mkdtempSync(join(tmpdir(), "pragma-schema-artifact-data-"));
+  cwd = mkdtempSync(join(tmpdir(), "pragma-schema-artifact-cwd-"));
+  originalXdgData = process.env.XDG_DATA_HOME;
+  process.env.XDG_DATA_HOME = dataDir;
+  // The global test setup disables artifact emission; this suite tests it.
+  delete process.env.PRAGMA_SCHEMA_ARTIFACT;
+});
+
+afterAll(() => {
+  if (originalXdgData === undefined) {
+    delete process.env.XDG_DATA_HOME;
+  } else {
+    process.env.XDG_DATA_HOME = originalXdgData;
+  }
+  process.env.PRAGMA_SCHEMA_ARTIFACT = "off";
+  rmSync(dataDir, { recursive: true, force: true });
+  rmSync(cwd, { recursive: true, force: true });
+});
+
+afterEach(() => {
+  delete process.env.PRAGMA_SCHEMA_ARTIFACT;
+  rmSync(join(dataDir, "pragma"), { recursive: true, force: true });
+});
+
+function makeRuntime(ttl: string): Parameters<typeof ensureSchemaArtifact>[0] {
+  const pkg: SemanticPackage = {
+    name: "@test/ontology",
+    version: "1.0.0",
+    source: "local",
+    graphs: [{ path: "ontology.ttl", content: ttl, format: "turtle" }],
+    skills: [],
+    stories: [],
+  };
+  return {
+    cwd,
+    packages: [pkg],
+    store: { prefixes: PREFIXES } as never,
+  };
+}
+
+describe("resolveSchemaArtifactPath", () => {
+  it("uses the XDG data dir when no project config is in tree", () => {
+    expect(resolveSchemaArtifactPath(cwd)).toBe(
+      join(dataDir, "pragma", "schema.graphql"),
+    );
+  });
+
+  it("uses .pragma/ beside the project config when one is in tree", () => {
+    const project = mkdtempSync(join(tmpdir(), "pragma-schema-project-"));
+    try {
+      writeFileSync(join(project, "pragma.config.json"), "{}", "utf-8");
+      const nested = join(project, "src");
+      mkdirSync(nested);
+      expect(resolveSchemaArtifactPath(nested)).toBe(
+        join(project, ".pragma", "schema.graphql"),
+      );
+    } finally {
+      rmSync(project, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("ensureSchemaArtifact", () => {
+  it("writes the artifact with a source-hash header on first use", async () => {
+    const result = await ensureSchemaArtifact(makeRuntime(GRAPHQL_CLEAN_TTL));
+
+    expect(result.status).toBe("written");
+    expect(existsSync(result.path)).toBe(true);
+
+    const content = readFileSync(result.path, "utf-8");
+    expect(content.startsWith("# pragma:sources ")).toBe(true);
+    expect(content).toContain("type Thing");
+  });
+
+  it("is fresh on a second run with unchanged sources", async () => {
+    const runtime = makeRuntime(GRAPHQL_CLEAN_TTL);
+    await ensureSchemaArtifact(runtime);
+
+    const second = await ensureSchemaArtifact(runtime);
+    expect(second.status).toBe("fresh");
+  });
+
+  it("rewrites when the sources change", async () => {
+    await ensureSchemaArtifact(makeRuntime(GRAPHQL_CLEAN_TTL));
+
+    const changed = await ensureSchemaArtifact(
+      makeRuntime(`${GRAPHQL_CLEAN_TTL}\n# changed`),
+    );
+    expect(changed.status).toBe("written");
+  });
+
+  it("leaves a stale artifact in place when compilation fails", async () => {
+    const first = await ensureSchemaArtifact(makeRuntime(GRAPHQL_CLEAN_TTL));
+    const before = readFileSync(first.path, "utf-8");
+
+    const failed = await ensureSchemaArtifact(makeRuntime(GRAPHQL_FATAL_TTL));
+    expect(failed.status).toBe("failed");
+    expect(readFileSync(first.path, "utf-8")).toBe(before);
+  });
+
+  it("compiles from the parseable sources when one is malformed", async () => {
+    const pkg: SemanticPackage = {
+      name: "@test/ontology",
+      version: "1.0.0",
+      source: "local",
+      graphs: [
+        { path: "clean.ttl", content: GRAPHQL_CLEAN_TTL, format: "turtle" },
+        {
+          path: "broken.ttl",
+          content: "this is not turtle .",
+          format: "turtle",
+        },
+      ],
+      skills: [],
+      stories: [],
+    };
+    const result = await ensureSchemaArtifact({
+      cwd,
+      packages: [pkg],
+      store: { prefixes: PREFIXES } as never,
+    });
+
+    expect(result.status).toBe("written");
+    expect(readFileSync(result.path, "utf-8")).toContain("type Thing");
+  });
+
+  it("skips when no sources resolve", async () => {
+    const result = await ensureSchemaArtifact({
+      cwd,
+      packages: [],
+      store: { prefixes: PREFIXES } as never,
+    });
+    expect(result.status).toBe("skipped");
+  });
+
+  it("skips when disabled via PRAGMA_SCHEMA_ARTIFACT=off", async () => {
+    process.env.PRAGMA_SCHEMA_ARTIFACT = "off";
+    const result = await ensureSchemaArtifact(makeRuntime(GRAPHQL_CLEAN_TTL));
+    expect(result.status).toBe("skipped");
+    expect(existsSync(result.path)).toBe(false);
+  });
+});

package/src/domains/graphql/operations/ensureSchemaArtifact.ts

@@ -0,0 +1,178 @@
+/**
+ * Hash-gated `schema.graphql` artifact.
+ *
+ * pragma keeps one compiled GraphQL schema per data set so downstream
+ * tooling (codegen, IDEs, `graphql serve` clients) always has a current
+ * SDL without anyone running `pragma graphql build` by hand:
+ *
+ * - **Location** — next to the project's `pragma.config.json`
+ *   (`<projectRoot>/.pragma/schema.graphql`) when one is in tree, else the
+ *   XDG data dir (`$XDG_DATA_HOME/pragma/schema.graphql`).
+ * - **Emission** — on first use of pragma (any command that boots the
+ *   runtime) the artifact is generated if missing.
+ * - **Renewal** — the artifact's first line records the hash of the TTL
+ *   sources it was compiled from (`# pragma:sources <hash>`); it is
+ *   recompiled only when the resolved sources no longer match that hash.
+ *
+ * Failure is never fatal: a schema that does not compile leaves the
+ * previous artifact in place and the boot proceeds with a warning.
+ */
+
+import {
+  closeSync,
+  existsSync,
+  mkdirSync,
+  openSync,
+  readSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+import { createStore, definePlugin, type InlineSource } from "@canonical/ke";
+import { hashSources } from "@canonical/ke-graphql";
+import { findProjectConfigPath } from "#config";
+import { dataRoot } from "../../refs/operations/paths.js";
+import type { PragmaRuntime } from "../../shared/runtime.js";
+import compileSchema from "./compileSchema.js";
+
+/** First-line marker carrying the source fingerprint. */
+const HASH_HEADER = "# pragma:sources ";
+
+/** Environment kill-switch (CI, tests, air-gapped boots). */
+const DISABLE_ENV = "PRAGMA_SCHEMA_ARTIFACT";
+
+export interface SchemaArtifactResult {
+  /** Absolute path of the artifact. */
+  readonly path: string;
+  /**
+   * What happened: `fresh` (hash matched, nothing to do), `written`
+   * (compiled and saved), `failed` (compilation failed, artifact left
+   * as-is), `skipped` (no sources, or disabled via env).
+   */
+  readonly status: "fresh" | "written" | "failed" | "skipped";
+}
+
+/**
+ * Where the schema artifact lives for a working directory: project-local
+ * (`.pragma/` beside the nearest `pragma.config.json`) when the project is
+ * configured, global XDG data dir otherwise.
+ */
+export function resolveSchemaArtifactPath(cwd: string): string {
+  const configPath = findProjectConfigPath(cwd);
+  return configPath
+    ? join(dirname(configPath), ".pragma", "schema.graphql")
+    : join(dataRoot(), "schema.graphql");
+}
+
+/**
+ * Ensure the schema artifact exists and matches the runtime's resolved
+ * TTL sources, recompiling only on hash mismatch.
+ *
+ * @note Impure — reads and writes the artifact; compiles via a throwaway
+ *   ke store when stale.
+ */
+export default async function ensureSchemaArtifact(
+  runtime: Pick<PragmaRuntime, "cwd" | "packages" | "store">,
+): Promise<SchemaArtifactResult> {
+  const path = resolveSchemaArtifactPath(runtime.cwd);
+
+  if (process.env[DISABLE_ENV] === "off") {
+    return { path, status: "skipped" };
+  }
+
+  // Sort by provenance path so the fingerprint is stable across boots
+  // regardless of package resolution order.
+  const sources: InlineSource[] = runtime.packages
+    .flatMap((pkg) =>
+      pkg.graphs.map((graph) => ({
+        content: graph.content,
+        format: "turtle" as const,
+        path: graph.path,
+      })),
+    )
+    .sort((a, b) => a.path.localeCompare(b.path));
+
+  if (sources.length === 0) {
+    return { path, status: "skipped" };
+  }
+
+  const hash = hashSources(sources.map((source) => source.content));
+
+  if (existsSync(path) && readFirstLine(path) === `${HASH_HEADER}${hash}`) {
+    return { path, status: "fresh" };
+  }
+
+  // Mirror boot's "one bad file cannot break boot": compile from the
+  // parseable sources only. The runtime already warned about any malformed
+  // graph while booting the main store, so the filter here is silent.
+  // The fingerprint above covers ALL sources, so fixing a malformed file
+  // changes the hash and triggers recompilation.
+  const parseable = await filterParseableSources(sources);
+  if (parseable.length === 0) {
+    return { path, status: "failed" };
+  }
+
+  const outcome = await compileSchema({
+    sources: parseable,
+    prefixes: runtime.store.prefixes,
+    cwd: runtime.cwd,
+  });
+
+  if (outcome.status === "failed" || !outcome.compiled) {
+    return { path, status: "failed" };
+  }
+
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(
+    path,
+    `${HASH_HEADER}${hash}\n${outcome.compiled.sdl}`,
+    "utf-8",
+  );
+
+  return { path, status: "written" };
+}
+
+/**
+ * Read just the artifact's header line — the freshness probe runs on every
+ * booted invocation, so it must not scale with the SDL's size.
+ */
+function readFirstLine(path: string, max = 96): string {
+  const fd = openSync(path, "r");
+  try {
+    const buffer = Buffer.alloc(max);
+    const bytes = readSync(fd, buffer, 0, max, 0);
+    const text = buffer.subarray(0, bytes).toString("utf-8");
+    const newline = text.indexOf("\n");
+    return newline === -1 ? text : text.slice(0, newline);
+  } finally {
+    closeSync(fd);
+  }
+}
+
+/**
+ * Drop sources the Turtle parser rejects, keeping the rest — the same
+ * tolerance the main store's graph loader applies at boot. Probes with a
+ * throwaway store so the strict `graphql check` semantics of
+ * {@link compileSchema} stay untouched.
+ */
+async function filterParseableSources(
+  sources: readonly InlineSource[],
+): Promise<InlineSource[]> {
+  const parseable: InlineSource[] = [];
+  const probe = definePlugin({
+    name: "pragma-schema-artifact-probe",
+    onReady(ctx) {
+      for (const source of sources) {
+        try {
+          ctx.load(source.content, { format: source.format });
+          parseable.push(source);
+        } catch {
+          // Already warned at boot by the main store's graph loader.
+        }
+      }
+    },
+  });
+
+  const store = await createStore({ sources: [], plugins: [probe] });
+  store.dispose();
+  return parseable;
+}

package/src/domains/graphql/operations/index.ts

@@ -10,3 +10,8 @@ export type {
   SchemaServer,
 } from "./createSchemaServer.js";
 export { default as createSchemaServer } from "./createSchemaServer.js";
+export type { SchemaArtifactResult } from "./ensureSchemaArtifact.js";
+export {
+  default as ensureSchemaArtifact,
+  resolveSchemaArtifactPath,
+} from "./ensureSchemaArtifact.js";

package/src/domains/info/formatters/upgrade.test.ts

@@ -8,7 +8,9 @@ import {
 
 function createUpgradeData(overrides: Partial<UpgradeData> = {}): UpgradeData {
   return {
-    pm: "bun",
+    // `pm` is the install label, which already carries the scope (as the
+    // command populates it from source.label).
+    pm: "bun (global)",
     current: "0.18.0",
     latest: "0.19.0",
     command: "bun update -g @canonical/pragma-cli",
@@ -21,9 +23,10 @@ function createUpgradeData(overrides: Partial<UpgradeData> = {}): UpgradeData {
 }
 
 describe("renderUpgradePlain", () => {
-  it("shows PM info", () => {
+  it("shows PM info without doubling the scope suffix", () => {
     const output = renderUpgradePlain(createUpgradeData());
-    expect(output).toContain("bun (global)");
+    expect(output).toContain("Installed via: bun (global)");
+    expect(output).not.toContain("(global) (global)");
   });
 
   it("shows version transition", () => {
@@ -107,7 +110,7 @@ describe("renderUpgradeJson", () => {
   it("produces valid JSON", () => {
     const data = createUpgradeData();
     const parsed = JSON.parse(renderUpgradeJson(data));
-    expect(parsed.pm).toBe("bun");
+    expect(parsed.pm).toBe("bun (global)");
     expect(parsed.current).toBe("0.18.0");
     expect(parsed.latest).toBe("0.19.0");
   });

package/src/domains/info/formatters/upgrade.ts

@@ -12,7 +12,9 @@ import type { UpgradeData } from "../types.js";
 function renderUpgradePlain(data: UpgradeData): string {
   const lines: string[] = [];
 
-  lines.push(`Installed via: ${data.pm} (global)`);
+  // `data.pm` is the install label (e.g. "bun (global)"), which already carries
+  // the scope — do not append another "(global)".
+  lines.push(`Installed via: ${data.pm}`);
 
   if (data.offline) {
     lines.push("Could not reach registry");