@canonical/pragma-cli 0.31.0 → 0.33.0

package/src/domains/info/operations/collectEntityCounts.test.ts

@@ -1,156 +0,0 @@
-import type { Store } from "@canonical/ke";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import { createTestStore, DS_ALL_TTL } from "#testing";
-import listBlocks from "../../block/operations/list.js";
-import listModifiers from "../../modifier/operations/list.js";
-import { TTL_PREFIXES } from "../../shared/prefixes.js";
-import { standardPack } from "../../shared/stories/pack/bundled/standardPack.js";
-import runSelectQuery from "../../shared/stories/pack/runSelectQuery.js";
-import type { FilterConfig } from "../../shared/types/index.js";
-import listTokens from "../../token/operations/list.js";
-import { collectEntityCounts } from "./collectEntityCounts.js";
-
-/**
- * The user-facing standard row count: the bundled pack's list query is
- * what `standard list` serves since the standard cutover, so the info
- * count must stay in lockstep with it (same WHERE grain the retired
- * listStandards op used, including the OPTIONAL fan-out).
- */
-async function countStandardRows(store: Store): Promise<number> {
-  const rows = await runSelectQuery(store, standardPack.list.query, "test");
-  return rows.length;
-}
-
-let store: Store;
-let cleanup: () => void;
-
-beforeAll(async () => {
-  const result = await createTestStore({ ttl: DS_ALL_TTL });
-  store = result.store;
-  cleanup = result.cleanup;
-});
-
-afterAll(() => cleanup());
-
-// The block count is the only filtered count, so its parity must hold under
-// every tier/channel combination the list op supports.
-const configs: Record<string, FilterConfig> = {
-  "no tier, prerelease": { tier: undefined, channel: "prerelease" },
-  "no tier, normal": { tier: undefined, channel: "normal" },
-  "global tier": { tier: "global", channel: "prerelease" },
-  "apps/lxd tier": { tier: "apps/lxd", channel: "normal" },
-};
-
-describe("collectEntityCounts", () => {
-  it.each(
-    Object.entries(configs),
-  )("matches legacy list-op lengths for %s", async (_label, config) => {
-    const counts = await collectEntityCounts(store, config);
-
-    expect(counts.blocks).toBe((await listBlocks(store, config)).length);
-    expect(counts.standards).toBe(await countStandardRows(store));
-    expect(counts.modifierFamilies).toBe((await listModifiers(store)).length);
-    expect(counts.tokens).toBe((await listTokens(store)).length);
-  });
-
-  it("returns positive counts on the full fixture", async () => {
-    const counts = await collectEntityCounts(store, {
-      tier: undefined,
-      channel: "prerelease",
-    });
-
-    expect(counts.blocks).toBeGreaterThan(0);
-    expect(counts.standards).toBeGreaterThan(0);
-    expect(counts.modifierFamilies).toBeGreaterThan(0);
-    expect(counts.tokens).toBeGreaterThan(0);
-  });
-});
-
-// A dedicated fan-out store (kept separate from the shared dsFixtures so its
-// enriched cardinality does not ripple into other suites). Every entity fans
-// its list op to MORE rows than there are distinct subjects, which is exactly
-// where a single-variable `COUNT(DISTINCT ?subject)` would undercount — so
-// these fixtures pin the grain-faithful subquery counts (FIX 4).
-const FAN_OUT_TTL = `
-${TTL_PREFIXES}
-
-# One block asserted as TWO types -> two GROUP BY (?component ?type ?name ?tier)
-# groups, so listBlocks emits two rows for a single subject.
-ds:fanout.multitype a ds:Component, ds:Pattern ;
-  ds:name "MultiType" ;
-  ds:tier ds:global ;
-  ds:release ds:stable .
-
-# A beta-only single-type block -> present under prerelease, filtered under
-# normal, so the block count also tracks channel scoping.
-ds:fanout.solo a ds:Component ;
-  ds:name "Solo" ;
-  ds:tier ds:global ;
-  ds:release ds:beta .
-
-# One modifier family with TWO names -> two GROUP BY (?family ?name) groups.
-ds:fanout.family a ds:ModifierFamily ;
-  ds:name "Alpha", "Beta" .
-
-# One standard in TWO categories -> the OPTIONAL hasCategory fans two rows.
-cs:fanout_cat_a a cs:Category ; cs:slug "cat-a" .
-cs:fanout_cat_b a cs:Category ; cs:slug "cat-b" .
-cs:fanout_std a cs:CodeStandard ;
-  cs:name "fanout/standard" ;
-  cs:description "A standard in two categories." ;
-  cs:hasCategory cs:fanout_cat_a, cs:fanout_cat_b .
-
-# One token with TWO token types -> the OPTIONAL tokenType fans two rows.
-ds:fanout_tt_a a ds:TokenType ; rdfs:label "TypeA" .
-ds:fanout_tt_b a ds:TokenType ; rdfs:label "TypeB" .
-ds:fanout.token a ds:Token ;
-  ds:tokenId "fanout.token" ;
-  ds:tokenType ds:fanout_tt_a, ds:fanout_tt_b .
-`;
-
-describe("collectEntityCounts fan-out parity", () => {
-  let fanStore: Store;
-  let fanCleanup: () => void;
-
-  beforeAll(async () => {
-    const result = await createTestStore({ ttl: FAN_OUT_TTL });
-    fanStore = result.store;
-    fanCleanup = result.cleanup;
-  });
-
-  afterAll(() => fanCleanup());
-
-  const fanConfigs: Record<string, FilterConfig> = {
-    prerelease: { tier: undefined, channel: "prerelease" },
-    normal: { tier: undefined, channel: "normal" },
-  };
-
-  it.each(
-    Object.entries(fanConfigs),
-  )("each count equals its legacy list-op length under %s channel", async (_label, config) => {
-    const counts = await collectEntityCounts(fanStore, config);
-
-    expect(counts.blocks).toBe((await listBlocks(fanStore, config)).length);
-    expect(counts.standards).toBe(await countStandardRows(fanStore));
-    expect(counts.modifierFamilies).toBe(
-      (await listModifiers(fanStore)).length,
-    );
-    expect(counts.tokens).toBe((await listTokens(fanStore)).length);
-  });
-
-  it("actually fans each entity beyond its distinct-subject count", async () => {
-    // These are the cardinalities a naive `COUNT(DISTINCT ?subject)` would
-    // undercount (blocks 3 vs 2 subjects, families 2 vs 1, etc.).
-    const config: FilterConfig = { tier: undefined, channel: "prerelease" };
-    expect((await listBlocks(fanStore, config)).length).toBe(3);
-    expect((await listModifiers(fanStore)).length).toBe(2);
-    expect(await countStandardRows(fanStore)).toBe(2);
-    expect((await listTokens(fanStore)).length).toBe(2);
-
-    // And under normal channel the beta block drops out (2 block rows).
-    expect(
-      (await listBlocks(fanStore, { tier: undefined, channel: "normal" }))
-        .length,
-    ).toBe(2);
-  });
-});

package/src/domains/info/operations/collectEntityCounts.ts

@@ -1,123 +0,0 @@
-import type { Store } from "@canonical/ke";
-import { buildQuery } from "../../shared/buildQuery.js";
-import { buildFilters } from "../../shared/filters/buildFilters.js";
-import { P } from "../../shared/prefixes.js";
-import type { FilterConfig } from "../../shared/types/index.js";
-import type { EntityCounts } from "../types.js";
-
-/**
- * Run a `COUNT` query and parse its single `?count` binding.
- *
- * SPARQL `COUNT` yields a typed literal serialized as a string, so the
- * value is parsed defensively and falls back to `0` when the query does
- * not resolve to a select result.
- *
- * @param store - The ke store to query.
- * @param query - A `SELECT (COUNT(...) AS ?count)` query string.
- * @returns The parsed count, or `0` when unavailable.
- * @note Queries ke store
- */
-async function countRows(store: Store, query: string): Promise<number> {
-  const result = await store.query(buildQuery(query));
-  if (result.type !== "select") return 0;
-  const first = result.bindings[0];
-  return first ? Number.parseInt(first.count ?? "0", 10) || 0 : 0;
-}
-
-/**
- * Count blocks, standards, modifier families, and tokens for the
- * `pragma llm` orientation summary.
- *
- * Each `COUNT` reproduces the row cardinality of the matching leaf list
- * operation, so the results equal `(await listX(...)).length` exactly:
- *
- * - **blocks** count the distinct `(?component, ?type, ?name, ?tier)` groups
- *   `listBlocks` emits via `GROUP BY ?component ?type ?name ?tier`, so a
- *   `COUNT(*)` over a `SELECT DISTINCT` of that exact grain (incl.
- *   `buildFilters` for identical tier/channel scoping). This stays exact even
- *   for a block asserted as several types or tiers, which would fan a
- *   single-variable `COUNT(DISTINCT ?component)` short of the grouped rows.
- * - **modifier families** count the distinct `(?family, ?name)` groups
- *   `listModifiers` emits via `GROUP BY ?family ?name`, so a `COUNT(*)` over a
- *   `SELECT DISTINCT` of that grain — exact even for a family with two names.
- * - **standards** and **tokens** have no `GROUP BY` and an `OPTIONAL` that
- *   fans rows out, so `COUNT(*)` over the identical `WHERE` matches row for
- *   row (including the fan-out).
- *
- * @note Queries ke store
- *
- * @param store - The ke store to query.
- * @param config - Filter config providing tier and channel settings.
- * @returns Entity counts matching the four leaf list operations' lengths.
- */
-async function collectEntityCounts(
-  store: Store,
-  config: FilterConfig,
-): Promise<EntityCounts> {
-  const filterClauses = buildFilters(config);
-
-  const [blocks, standards, modifierFamilies, tokens] = await Promise.all([
-    countRows(
-      store,
-      `
-      SELECT (COUNT(*) AS ?count)
-      WHERE {
-        SELECT DISTINCT ?component ?type ?name ?tier
-        WHERE {
-          VALUES ?type { ${P.ds}Component ${P.ds}Pattern ${P.ds}Layout ${P.ds}Subcomponent }
-          ?component a ?type ;
-                     ${P.ds}name ?name ;
-                     ${P.ds}tier ?tier .
-          ${filterClauses}
-        }
-      }
-    `,
-    ),
-    countRows(
-      store,
-      `
-      SELECT (COUNT(*) AS ?count)
-      WHERE {
-        ?standard a ${P.cs}CodeStandard ;
-                  ${P.cs}name ?name ;
-                  ${P.cs}description ?description .
-        OPTIONAL {
-          ?standard ${P.cs}hasCategory ?cat .
-          ?cat ${P.cs}slug ?categoryName .
-        }
-      }
-    `,
-    ),
-    countRows(
-      store,
-      `
-      SELECT (COUNT(*) AS ?count)
-      WHERE {
-        SELECT DISTINCT ?family ?name
-        WHERE {
-          ?family a ${P.ds}ModifierFamily ;
-                  ${P.ds}name ?name .
-        }
-      }
-    `,
-    ),
-    countRows(
-      store,
-      `
-      SELECT (COUNT(*) AS ?count)
-      WHERE {
-        ?token a ${P.ds}Token ;
-               ${P.ds}tokenId ?tokenId .
-        OPTIONAL {
-          ?token ${P.ds}tokenType ?type .
-          ?type ${P.rdfs}label ?typeName .
-        }
-      }
-    `,
-    ),
-  ]);
-
-  return { blocks, standards, modifierFamilies, tokens };
-}
-
-export { collectEntityCounts };

package/src/domains/info/operations/collectInfo.test.ts

@@ -1,122 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const readConfigLayersMock = vi.fn();
-const detectInstallSourceMock = vi.fn();
-const bootStoreMock = vi.fn();
-const checkRegistryVersionMock = vi.fn();
-const collectStoreSummaryMock = vi.fn();
-
-vi.mock("#config", async (importOriginal) => ({
-  ...(await importOriginal<typeof import("#config")>()),
-  readConfigLayers: readConfigLayersMock,
-}));
-
-vi.mock("#package-manager", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("#package-manager")>();
-  return {
-    ...actual,
-    detectInstallSource: detectInstallSourceMock,
-    PM_COMMANDS: {
-      ...actual.PM_COMMANDS,
-      bun: {
-        ...actual.PM_COMMANDS.bun,
-        update: (pkg: string) => `bun update ${pkg}`,
-      },
-    },
-  };
-});
-
-vi.mock("../../shared/bootStore.js", () => ({
-  bootStore: bootStoreMock,
-}));
-
-vi.mock("./checkRegistryVersion.js", () => ({
-  default: checkRegistryVersionMock,
-}));
-
-vi.mock("./collectStoreSummary.js", () => ({
-  collectStoreSummary: collectStoreSummaryMock,
-}));
-
-describe("collectInfo", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    detectInstallSourceMock.mockReturnValue({
-      packageManager: "bun",
-      scope: "global",
-      label: "bun (global)",
-    });
-    readConfigLayersMock.mockReturnValue({
-      config: { tier: "apps/lxd", channel: "normal" },
-      origins: {
-        tier: "project",
-        channel: "default",
-        packages: "default",
-        trace: "default",
-        framework: "default",
-      },
-      global: { path: "/home/u/.config/pragma/config.json", exists: false },
-      project: { path: "/repo/pragma.config.json", exists: true },
-    });
-  });
-
-  it("includes update information and store summary when available", async () => {
-    const dispose = vi.fn();
-    bootStoreMock.mockResolvedValue({ store: { dispose }, packages: [] });
-    checkRegistryVersionMock.mockResolvedValue({
-      latest: "9.9.9",
-      distTag: "latest",
-    });
-    collectStoreSummaryMock.mockResolvedValue({
-      tripleCount: 42,
-      graphNames: ["default"],
-    });
-
-    const { default: collectInfo } = await import("./collectInfo.js");
-    const result = await collectInfo("/workspace");
-
-    expect(result.update).toEqual({
-      current: expect.any(String),
-      latest: "9.9.9",
-      command: "bun update @canonical/pragma-cli",
-    });
-    expect(result.installSource).toBe("bun (global)");
-    expect(result.updateSkipped).toBe(false);
-    expect(result.store).toEqual({ tripleCount: 42, graphNames: ["default"] });
-    expect(result.tierChain.length).toBeGreaterThan(0);
-    expect(dispose).toHaveBeenCalledTimes(1);
-  });
-
-  it("marks update as skipped and omits store when registry and store are unavailable", async () => {
-    checkRegistryVersionMock.mockResolvedValue(undefined);
-    bootStoreMock.mockRejectedValue(new Error("store unavailable"));
-
-    const { default: collectInfo } = await import("./collectInfo.js");
-    const result = await collectInfo("/workspace");
-
-    expect(result.update).toBeUndefined();
-    expect(result.updateSkipped).toBe(true);
-    expect(result.store).toBeUndefined();
-  });
-
-  it("omits the update section when already on the latest version", async () => {
-    const { VERSION } = await import("#constants");
-    const dispose = vi.fn();
-    bootStoreMock.mockResolvedValue({ store: { dispose }, packages: [] });
-    checkRegistryVersionMock.mockResolvedValue({
-      latest: VERSION,
-      distTag: "latest",
-    });
-    collectStoreSummaryMock.mockResolvedValue({
-      tripleCount: 10,
-      graphNames: ["default"],
-    });
-
-    const { default: collectInfo } = await import("./collectInfo.js");
-    const result = await collectInfo("/workspace");
-
-    expect(result.update).toBeUndefined();
-    expect(result.updateSkipped).toBe(false);
-    expect(result.store?.tripleCount).toBe(10);
-  });
-});

package/src/domains/info/operations/collectInfo.ts

@@ -1,94 +0,0 @@
-import { readConfigLayers } from "#config";
-import { VERSION } from "#constants";
-import { detectInstallSource, PM_COMMANDS } from "#package-manager";
-import type {
-  PackageRef,
-  RawPackageEntry,
-} from "../../refs/operations/parseRef.js";
-import { bootStore } from "../../shared/bootStore.js";
-import { CHANNEL_RELEASES } from "../../shared/filters/buildChannelFilter.js";
-import { resolveTierChain } from "../../shared/filters/buildTierFilter.js";
-import { mergeAndParseRefs } from "../../shared/mergeAndParseRefs.js";
-import type { InfoData, PackageRefSummary } from "../types.js";
-import checkRegistryVersion from "./checkRegistryVersion.js";
-import { collectStoreSummary } from "./collectStoreSummary.js";
-
-/**
- * Collects all data for the `pragma info` command.
- *
- * Reads local config, detects the package manager, checks the npm registry
- * for updates, boots a ke store, and gathers store summary statistics.
- *
- * @note Impure
- *
- * @param cwd - The current working directory used to locate `pragma.config.json`.
- * @returns A fully populated {@link InfoData} object.
- */
-export default async function collectInfo(cwd: string): Promise<InfoData> {
-  const install = detectInstallSource();
-  const pm = install.packageManager;
-  const layers = readConfigLayers(cwd);
-  const config = layers.config;
-  const tierChain = resolveTierChain(config.tier);
-  const channelReleases = CHANNEL_RELEASES[config.channel];
-
-  const registryResult = await checkRegistryVersion(
-    "@canonical/pragma-cli",
-    config.channel,
-  );
-
-  let update: InfoData["update"];
-  const updateSkipped = registryResult === undefined;
-  if (registryResult && registryResult.latest !== VERSION) {
-    update = {
-      current: VERSION,
-      latest: registryResult.latest,
-      command: PM_COMMANDS[pm].update("@canonical/pragma-cli"),
-    };
-  }
-
-  let store: InfoData["store"];
-  let bootResult: Awaited<ReturnType<typeof bootStore>> | undefined;
-  try {
-    bootResult = await bootStore({ cwd });
-    store = await collectStoreSummary(bootResult.store);
-  } catch {
-    // Store unavailable — show info without store section
-  } finally {
-    bootResult?.store.dispose();
-  }
-
-  // Collect package ref summaries
-  const packageRefs = collectPackageRefSummaries(config.packages);
-
-  return {
-    version: VERSION,
-    pm,
-    installSource: install.label,
-    configPath: layers.project.exists
-      ? layers.project.path
-      : layers.global.path,
-    tier: config.tier,
-    tierChain,
-    channel: config.channel,
-    channelReleases: [...channelReleases],
-    update,
-    updateSkipped,
-    store,
-    packageRefs,
-  };
-}
-
-function collectPackageRefSummaries(
-  configPackages?: ReadonlyArray<RawPackageEntry>,
-): PackageRefSummary[] {
-  return mergeAndParseRefs(configPackages).map(refToSummary);
-}
-
-function refToSummary(ref: PackageRef): PackageRefSummary {
-  if (ref.kind === "file")
-    return { pkg: ref.pkg, source: "file", detail: ref.path };
-  if (ref.kind === "git")
-    return { pkg: ref.pkg, source: "git", detail: `${ref.url}#${ref.ref}` };
-  return { pkg: ref.pkg, source: "npm", detail: "node_modules" };
-}

package/src/domains/info/operations/collectStoreSummary.test.ts

@@ -1,61 +0,0 @@
-import type { Store } from "@canonical/ke";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import { createTestStore, DS_ONTOLOGY_TTL, DS_TIERS_TTL } from "#testing";
-import { collectStoreSummary } from "./collectStoreSummary.js";
-
-describe("collectStoreSummary", () => {
-  describe("with default graph only", () => {
-    let store: Store;
-    let cleanup: () => void;
-
-    beforeAll(async () => {
-      const result = await createTestStore({
-        ttl: [DS_ONTOLOGY_TTL, DS_TIERS_TTL].join("\n"),
-      });
-      store = result.store;
-      cleanup = result.cleanup;
-    });
-
-    afterAll(() => {
-      cleanup();
-    });
-
-    it("returns a positive triple count", async () => {
-      const summary = await collectStoreSummary(store);
-      expect(summary.tripleCount).toBeGreaterThan(0);
-    });
-
-    it("returns empty graph names when no named graphs", async () => {
-      const summary = await collectStoreSummary(store);
-      expect(summary.graphNames).toEqual([]);
-    });
-  });
-
-  describe("with named graphs", () => {
-    let store: Store;
-    let cleanup: () => void;
-
-    beforeAll(async () => {
-      const result = await createTestStore({
-        ttl: DS_ONTOLOGY_TTL,
-        graphs: [{ graph: "urn:test:tiers", ttl: DS_TIERS_TTL }],
-      });
-      store = result.store;
-      cleanup = result.cleanup;
-    });
-
-    afterAll(() => {
-      cleanup();
-    });
-
-    it("returns triple count including named graphs", async () => {
-      const summary = await collectStoreSummary(store);
-      expect(summary.tripleCount).toBeGreaterThan(0);
-    });
-
-    it("lists named graph URIs", async () => {
-      const summary = await collectStoreSummary(store);
-      expect(summary.graphNames).toContain("urn:test:tiers");
-    });
-  });
-});

package/src/domains/info/operations/collectStoreSummary.ts

@@ -1,42 +0,0 @@
-import type { Store } from "@canonical/ke";
-import { buildQuery } from "../../shared/buildQuery.js";
-import type { StoreSummary } from "../types.js";
-
-/**
- * Queries the ke store for total triple count and named graph URIs.
- *
- * @note Queries ke store
- *
- * @param store - The ke store to query.
- * @returns A {@link StoreSummary} with `tripleCount` and `graphNames`.
- */
-async function collectStoreSummary(store: Store): Promise<StoreSummary> {
-  const countResult = await store.query(
-    buildQuery("SELECT (COUNT(*) AS ?count) WHERE { ?s ?p ?o }"),
-  );
-
-  let tripleCount = 0;
-  if (countResult.type === "select") {
-    const first = countResult.bindings[0];
-    if (first) {
-      tripleCount = Number.parseInt(first.count ?? "0", 10) || 0;
-    }
-  }
-
-  const graphResult = await store.query(
-    buildQuery(
-      "SELECT DISTINCT ?g WHERE { GRAPH ?g { ?s ?p ?o } } ORDER BY ?g",
-    ),
-  );
-
-  const graphNames: string[] = [];
-  if (graphResult.type === "select") {
-    for (const binding of graphResult.bindings) {
-      if (binding.g) graphNames.push(binding.g);
-    }
-  }
-
-  return { tripleCount, graphNames };
-}
-
-export { collectStoreSummary };

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

@@ -1,6 +0,0 @@
-/** @module Barrel for info operations. */
-
-export { default as checkRegistryVersion } from "./checkRegistryVersion.js";
-export { collectEntityCounts } from "./collectEntityCounts.js";
-export { default as collectInfo } from "./collectInfo.js";
-export { collectStoreSummary } from "./collectStoreSummary.js";

package/src/domains/info/types.test-d.ts

@@ -1,35 +0,0 @@
-/**
- * Compile-time type tests for info + upgrade domain types.
- *
- * Checked by `tsc --noEmit`, not executed at runtime.
- */
-
-import { expectTypeOf } from "expect-type";
-import type {
-  InfoData,
-  RegistryCheckResult,
-  StoreSummary,
-  UpgradeData,
-} from "./types.js";
-
-// InfoData
-expectTypeOf<InfoData["version"]>().toBeString();
-expectTypeOf<InfoData["pm"]>().toBeString();
-expectTypeOf<InfoData["tier"]>().toEqualTypeOf<string | undefined>();
-expectTypeOf<InfoData["tierChain"]>().toEqualTypeOf<readonly string[]>();
-expectTypeOf<InfoData["updateSkipped"]>().toBeBoolean();
-
-// UpgradeData
-expectTypeOf<UpgradeData["current"]>().toBeString();
-expectTypeOf<UpgradeData["latest"]>().toEqualTypeOf<string | undefined>();
-expectTypeOf<UpgradeData["dryRun"]>().toBeBoolean();
-expectTypeOf<UpgradeData["offline"]>().toBeBoolean();
-expectTypeOf<UpgradeData["executed"]>().toBeBoolean();
-
-// RegistryCheckResult
-expectTypeOf<RegistryCheckResult["latest"]>().toBeString();
-expectTypeOf<RegistryCheckResult["distTag"]>().toBeString();
-
-// StoreSummary
-expectTypeOf<StoreSummary["tripleCount"]>().toBeNumber();
-expectTypeOf<StoreSummary["graphNames"]>().toEqualTypeOf<readonly string[]>();