@canonical/pragma-cli 0.30.0 → 0.31.0

package/src/domains/setup/commands/setup.ts

@@ -0,0 +1,70 @@
+/**
+ * Wires the top-level `pragma setup` command.
+ *
+ * `setup` is one level more general than `create <thing>`: it configures the
+ * whole local environment (completions, LSP, MCP). Unlike `create`, its steps
+ * perform *read* effects whose results drive control flow — detecting AI
+ * harnesses, checking what is already installed — so it must run for real and
+ * report the real outcome. It therefore executes through {@link runSetupTask}
+ * (real execution, streamed output) rather than the generator preview-then-
+ * execute path, which would render a dry-run preview whose stubbed reads report
+ * the wrong state (e.g. "no harnesses detected").
+ */
+
+import type { CommandDefinition, CommandResult } from "@canonical/cli-core";
+import runSetupTask from "../helpers/runSetupTask.js";
+import setupAll from "../operations/setupAll.js";
+
+/**
+ * Build the top-level `pragma setup` command definition.
+ *
+ * @returns The command definition for `pragma setup`.
+ * @note Impure
+ */
+export default function buildSetupCommand(): CommandDefinition {
+  return {
+    path: ["setup"],
+    description:
+      "Configure this project's environment: completions, LSP, and MCP",
+    parameters: [
+      {
+        name: "dryRun",
+        description: "Preview changes without writing",
+        type: "boolean",
+        default: false,
+      },
+      {
+        name: "undo",
+        description: "Reverse a previous setup",
+        type: "boolean",
+        default: false,
+      },
+      {
+        name: "yes",
+        description: "Skip all confirmation prompts",
+        type: "boolean",
+        default: false,
+      },
+    ],
+    meta: {
+      examples: [
+        "pragma setup",
+        "pragma setup --yes",
+        "pragma setup --dry-run",
+        "pragma setup --undo",
+      ],
+    },
+    execute: async (
+      params: Record<string, unknown>,
+      ctx,
+    ): Promise<CommandResult> =>
+      runSetupTask(setupAll(ctx.cwd), {
+        dryRun: params.dryRun === true,
+        undo: params.undo === true,
+        yes: params.yes === true,
+        verbose: ctx.globalFlags.verbose,
+        llm: ctx.globalFlags.llm,
+        format: ctx.globalFlags.format,
+      }),
+  };
+}

package/src/domains/setup/index.ts

@@ -2,21 +2,25 @@
 
 import type { CommandDefinition } from "@canonical/cli-core";
 import {
-  allCommand,
   completionsCommand,
   lspCommand,
   mcpCommand,
+  setupCommand,
   skillsCommand,
 } from "./commands/index.js";
 
 /**
  * Return all setup command definitions.
  *
- * @returns An array of CommandDefinitions for the setup subcommands.
+ * The top-level `pragma setup` is a summon-generator-backed command (replacing
+ * the former `setup all`); the granular `setup <step>` verbs remain for
+ * targeted, scriptable configuration of a single concern.
+ *
+ * @returns An array of CommandDefinitions for the setup command and its verbs.
  */
 export function commands(): CommandDefinition[] {
   return [
-    allCommand,
+    setupCommand(),
     lspCommand,
     mcpCommand,
     completionsCommand,

package/src/domains/setup/operations/setupLsp.test.ts

@@ -18,8 +18,9 @@ describe("setupLsp", () => {
   it("logs info messages before and after exec", () => {
     const result = dryRun(setupLsp("/project"));
     const logs = result.effects.filter((e) => e._tag === "Log");
-    expect(logs.some((l) => l.message.includes("Installing"))).toBe(true);
-    expect(logs.some((l) => l.message.includes("✓"))).toBe(true);
+    expect(logs.some((l) => l.message.includes("Ensuring"))).toBe(true);
+    // Reports an idempotent "up to date" outcome, not a fresh install claim.
+    expect(logs.some((l) => l.message.includes("up to date"))).toBe(true);
   });
 
   it("collects effects without execution", () => {

package/src/domains/setup/operations/setupLsp.ts

@@ -10,8 +10,13 @@ import { $, exec, gen, info, type Task } from "@canonical/task";
  */
 export default function setupLsp(root: string): Task<void> {
   return gen(function* () {
-    yield* $(info("Installing Terrazzo LSP extension for VS Code..."));
+    yield* $(
+      info("Ensuring the Terrazzo LSP VS Code extension is installed..."),
+    );
+    // The extension installer is idempotent — it installs if missing and is a
+    // no-op if already present — so this reports "ensured", not a fresh install
+    // (pragma does not inspect VS Code's extension state to tell them apart).
     yield* $(exec("bunx", ["@canonical/terrazzo-lsp-extension"], root));
-    yield* $(info("✓ Terrazzo LSP extension installed."));
+    yield* $(info("✓ Terrazzo LSP extension is installed (up to date)."));
   });
 }

package/src/domains/shared/bootStore.bareCore.test.ts

@@ -0,0 +1,63 @@
+/**
+ * Bare-core boot — pragma must serve the generic `graph`, `graphql`, and
+ * `ontology` surfaces with zero semantic packages loaded. This pins the P0
+ * invariant that the core no longer depends on the design-system packages:
+ * a store booted with no packages resolves generic queries and each
+ * generic operation returns cleanly instead of crashing.
+ */
+
+import type { Store } from "@canonical/ke";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { EX_NAMESPACE, GRAPHQL_CLEAN_TTL } from "#testing";
+import inspectUri from "../graph/operations/inspectUri.js";
+import compileSchema from "../graphql/operations/compileSchema.js";
+import listOntologies from "../ontology/operations/listOntologies.js";
+import { bootStore } from "./bootStore.js";
+import { PREFIX_MAP, resolvePrefixes } from "./prefixes.js";
+
+let store: Store;
+
+beforeAll(async () => {
+  // The `sources` override boots with zero resolved packages (bare core).
+  const boot = await bootStore({ sources: [] });
+  store = boot.store;
+  expect(boot.packages).toEqual([]);
+});
+
+afterAll(() => store?.dispose());
+
+describe("bare-core boot", () => {
+  it("carries the generic core prefixes on the store", () => {
+    expect(store.prefixes.rdf).toBe(PREFIX_MAP.rdf);
+    expect(store.prefixes.owl).toBe(PREFIX_MAP.owl);
+  });
+
+  it("serves generic SPARQL without any packages loaded", async () => {
+    const result = await store.query(
+      "SELECT (COUNT(*) AS ?n) WHERE { ?s ?p ?o }",
+    );
+    expect(result.type).toBe("select");
+  });
+
+  it("serves `ontology` — listOntologies returns cleanly, not a crash", async () => {
+    await expect(listOntologies(store)).resolves.toEqual([]);
+  });
+
+  it("serves `graph` — inspecting an unknown URI reports not-found, not a crash", async () => {
+    await expect(
+      inspectUri(store, "https://example.org/nothing"),
+    ).rejects.toMatchObject({ code: "ENTITY_NOT_FOUND" });
+  });
+
+  it("serves `graphql` — compiles a generic ontology with core-only prefixes", async () => {
+    const outcome = await compileSchema({
+      sources: [
+        { content: GRAPHQL_CLEAN_TTL, format: "turtle", path: "x.ttl" },
+      ],
+      // Package-style prefix layered over the bare core — no DS packages.
+      prefixes: resolvePrefixes([{ prefixes: { ex: EX_NAMESPACE } }]),
+    });
+    expect(outcome.status).toBe("ok");
+    expect(outcome.compiled?.sdl).toContain("type Thing");
+  });
+});

package/src/domains/shared/bootStore.test.ts

@@ -0,0 +1,82 @@
+import { createStore } from "@canonical/ke";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { createGraphLoaderPlugin } from "./bootStore.js";
+
+const PREFIXES = { ds: "https://ds.canonical.com/" };
+
+const goodGraph = (path: string, subject: string) => ({
+  path,
+  content: `@prefix ds: <https://ds.canonical.com/>.\nds:${subject} a ds:Component.\n`,
+  format: "turtle" as const,
+});
+
+/** Mirrors the malformed `ds:hasSubcomponent ds:global..` shipped by upstream. */
+const badGraph = (path: string) => ({
+  path,
+  content:
+    "@prefix ds: <https://ds.canonical.com/>.\nds:global.component.broken a ds:Component;\n    ds:hasSubcomponent ds:global...\n",
+  format: "turtle" as const,
+});
+
+async function countTriples(
+  graphs: readonly ReturnType<typeof goodGraph>[],
+): Promise<number> {
+  const store = await createStore({
+    sources: [],
+    prefixes: PREFIXES,
+    plugins: [createGraphLoaderPlugin(graphs)],
+  });
+  // Always dispose the WASM-backed store so it can't leak across tests.
+  try {
+    const result = await store.query(
+      "SELECT (COUNT(*) AS ?n) WHERE { ?s ?p ?o }",
+    );
+    return Number(
+      result.type === "select" ? (result.bindings[0]?.n ?? "0") : "0",
+    );
+  } finally {
+    store.dispose();
+  }
+}
+
+let stderrSpy: ReturnType<typeof vi.spyOn>;
+
+beforeEach(() => {
+  stderrSpy = vi.spyOn(process.stderr, "write").mockImplementation(() => true);
+});
+
+afterEach(() => {
+  stderrSpy.mockRestore();
+});
+
+const stderrText = (): string =>
+  stderrSpy.mock.calls.map((call) => String(call[0])).join("");
+
+describe("createGraphLoaderPlugin", () => {
+  it("loads every graph when all are well-formed", async () => {
+    const count = await countTriples([
+      goodGraph("a.ttl", "global.component.a"),
+      goodGraph("b.ttl", "global.component.b"),
+    ]);
+    expect(count).toBe(2);
+    expect(stderrText()).toBe("");
+  });
+
+  it("skips a malformed graph but still boots and loads the good ones", async () => {
+    const count = await countTriples([
+      goodGraph("a.ttl", "global.component.a"),
+      badGraph("data/global/component/broken.ttl"),
+      goodGraph("b.ttl", "global.component.b"),
+    ]);
+    // The two good graphs load; the malformed one is skipped, not fatal.
+    expect(count).toBe(2);
+  });
+
+  it("warns with the offending file path and parse error", async () => {
+    await countTriples([badGraph("data/global/component/broken.ttl")]);
+    const text = stderrText();
+    expect(text).toContain("skipping malformed graph");
+    expect(text).toContain("data/global/component/broken.ttl");
+    expect(text).toContain("Check the TTL syntax");
+  });
+});

package/src/domains/shared/bootStore.ts

@@ -23,8 +23,8 @@ import {
   createLocalLoader,
 } from "./loaders/index.js";
 import { DEFAULT_PACKAGES } from "./packages.js";
-import { PREFIX_MAP } from "./prefixes.js";
-import type { SemanticPackage } from "./semanticPackage.js";
+import { resolvePrefixes } from "./prefixes.js";
+import type { GraphContent, SemanticPackage } from "./semanticPackage.js";
 import { resolveSemanticPackages } from "./semanticPackage.js";
 
 export interface BootStoreOptions {
@@ -61,13 +61,14 @@ export interface BootResult {
 export async function bootStore(
   options: BootStoreOptions = {},
 ): Promise<BootResult> {
-  const prefixes = { ...PREFIX_MAP, ...options.prefixes };
   try {
-    // Testing/programmatic override — use explicit sources
+    // Testing/programmatic override — use explicit sources. No packages are
+    // resolved, so the prefix map is the core base plus the transitional DS
+    // fallback and any caller override.
     if (options.sources) {
       const store = await createStore({
         sources: options.sources,
-        prefixes,
+        prefixes: resolvePrefixes([], options.prefixes),
         cache: options.cache,
         cwd: options.cwd,
       });
@@ -90,19 +91,11 @@ export async function bootStore(
     // Collect all graph content from resolved packages
     const allGraphs = packages.flatMap((pkg) => pkg.graphs);
 
-    // Use a ke plugin to load graph content during store creation.
-    // The onReady hook has access to ctx.load() which loads raw content.
-    const graphLoaderPlugin = definePlugin({
-      name: "pragma-graph-loader",
-      onReady(ctx) {
-        for (const graph of allGraphs) {
-          ctx.load(graph.content, { format: graph.format });
-        }
-      },
-    });
-
-    // biome-ignore lint: Plugin generic variance requires explicit unknown
-    const plugins: Plugin<any>[] = [graphLoaderPlugin];
+    // `Plugin<T>` is invariant in its API type and createStore expects
+    // `Plugin<void>[]`, so heterogeneous plugins (graph loader + trace) can only
+    // share an array via `any`. `unknown` does not satisfy `Plugin<void>`.
+    // biome-ignore lint/suspicious/noExplicitAny: intentional — see above
+    const plugins: Plugin<any>[] = [createGraphLoaderPlugin(allGraphs)];
     const traceEnabled =
       process.env.PRAGMA_TRACE === "1" || options.trace === true;
     if (traceEnabled) {
@@ -111,9 +104,12 @@ export async function bootStore(
       plugins.push(createTracePlugin({ traceDir: traceDir() }));
     }
 
+    // Merge every resolved package's declared prefixes (and the transitional
+    // DS fallback) over the generic core, then config overrides — so the
+    // store and every query see the packages' own namespaces.
     const store = await createStore({
       sources: [],
-      prefixes,
+      prefixes: resolvePrefixes(packages, options.prefixes),
       cache: options.cache,
       cwd: options.cwd,
       plugins,
@@ -127,9 +123,49 @@ export async function bootStore(
       {
         recovery: {
           message:
-            "Ensure design system packages are installed: bun add -D @canonical/design-system @canonical/code-standards @canonical/anatomy-dsl",
+            "If this is a parser error, check the TTL syntax of the source graphs " +
+            "(the message above names the line and column). Otherwise ensure design " +
+            "system packages are installed: bun add -D @canonical/design-system " +
+            "@canonical/code-standards @canonical/anatomy-dsl",
         },
       },
     );
   }
 }
+
+/**
+ * Build the ke plugin that loads resolved graph content into the store.
+ *
+ * Each graph is loaded independently inside its own try/catch: a single
+ * malformed TTL file (e.g. invalid Turtle emitted by an upstream authoring
+ * tool) must not abort the entire boot and take the whole CLI down with it.
+ * Failed graphs are skipped and surfaced as warnings, mirroring the
+ * resilience the story loader already provides ("one bad file cannot break
+ * boot"). A store built from N-1 good graphs is far more useful than a store
+ * that refuses to boot because of one bad graph.
+ *
+ * @note Impure — writes warnings to stderr on parse failure.
+ */
+export function createGraphLoaderPlugin(
+  graphs: readonly GraphContent[],
+): Plugin {
+  return definePlugin({
+    name: "pragma-graph-loader",
+    onReady(ctx) {
+      for (const graph of graphs) {
+        try {
+          ctx.load(graph.content, { format: graph.format });
+        } catch (error) {
+          const reason = error instanceof Error ? error.message : String(error);
+          // Name the offending file and the parse error, and point at the fix.
+          // The store still boots from the remaining graphs, so this is a
+          // warning, not a fatal error.
+          process.stderr.write(
+            `Warning: skipping malformed graph "${graph.path}" — ${reason}. ` +
+              "Check the TTL syntax of this source file; the remaining graphs still load.\n",
+          );
+        }
+      }
+    },
+  });
+}

package/src/domains/shared/emptyErrorRecovery.test.ts

@@ -4,8 +4,7 @@ import blockSpecs from "../block/mcp/specs.js";
 import blockEmptyError from "../block/orchestration/blockEmptyError.js";
 import modifierSpecs from "../modifier/mcp/specs.js";
 import modifierEmptyError from "../modifier/orchestration/modifierEmptyError.js";
-import standardSpecs from "../standard/mcp/specs.js";
-import standardEmptyError from "../standard/orchestration/standardEmptyError.js";
+import { TOKEN_READ_SURFACE_ENABLED } from "../token/featureFlag.js";
 import tokenSpecs from "../token/mcp/specs.js";
 import tokenEmptyError from "../token/orchestration/tokenEmptyError.js";
 import type { FilterConfig } from "./types/index.js";
@@ -40,36 +39,34 @@ const cases: ReadonlyArray<{
     toolNames: new Set(blockSpecs.map((s) => s.name)),
     storeEmpty: false,
   },
-  {
-    domain: "token (category active)",
-    error: tokenEmptyError("color"),
-    toolNames: new Set(tokenSpecs.map((s) => s.name)),
-    storeEmpty: false,
-  },
-  {
-    domain: "token (store-empty)",
-    error: tokenEmptyError(),
-    toolNames: new Set(tokenSpecs.map((s) => s.name)),
-    storeEmpty: true,
-  },
+  // The token read surface (and with it the paths that raise
+  // tokenEmptyError) is gated behind the token feature flag; its recovery
+  // hints can only point at registered tools while the surface is live.
+  ...(TOKEN_READ_SURFACE_ENABLED
+    ? [
+        {
+          domain: "token (category active)",
+          error: tokenEmptyError("color"),
+          toolNames: new Set(tokenSpecs.map((s) => s.name)),
+          storeEmpty: false,
+        },
+        {
+          domain: "token (store-empty)",
+          error: tokenEmptyError(),
+          toolNames: new Set(tokenSpecs.map((s) => s.name)),
+          storeEmpty: true,
+        },
+      ]
+    : []),
   {
     domain: "modifier (store-empty)",
     error: modifierEmptyError(),
     toolNames: new Set(modifierSpecs.map((s) => s.name)),
     storeEmpty: true,
   },
-  {
-    domain: "standard (filter active)",
-    error: standardEmptyError({ category: "react" }),
-    toolNames: new Set(standardSpecs.map((s) => s.name)),
-    storeEmpty: false,
-  },
-  {
-    domain: "standard (store-empty)",
-    error: standardEmptyError({}),
-    toolNames: new Set(standardSpecs.map((s) => s.name)),
-    storeEmpty: true,
-  },
+  // `standard` left this contract with its domain: the bundled pack has no
+  // emptyError hook (a pinned PARITY_GAP), so an empty standard list renders
+  // zero rows instead of an EMPTY_RESULTS recovery.
 ];
 
 describe("empty-error recovery contract (cross-domain)", () => {

package/src/domains/shared/extractLocalName.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
 import extractLocalName from "./extractLocalName.js";
-import { PREFIX_MAP } from "./prefixes.js";
+import { DEFAULT_PREFIX_MAP } from "./prefixes.js";
 
 describe("extractLocalName", () => {
   it("extracts after hash", () => {
@@ -8,7 +8,7 @@ describe("extractLocalName", () => {
   });
 
   it("extracts after last slash", () => {
-    expect(extractLocalName(`${PREFIX_MAP.ds}global`)).toBe("global");
+    expect(extractLocalName(`${DEFAULT_PREFIX_MAP.ds}global`)).toBe("global");
   });
 
   it("returns full string when no separator", () => {
@@ -16,6 +16,6 @@ describe("extractLocalName", () => {
   });
 
   it("handles nested path", () => {
-    expect(extractLocalName(`${PREFIX_MAP.ds}apps/lxd`)).toBe("lxd");
+    expect(extractLocalName(`${DEFAULT_PREFIX_MAP.ds}apps/lxd`)).toBe("lxd");
   });
 });

package/src/domains/shared/formatters.ts

@@ -70,13 +70,34 @@ export function renderLookupResults<TResult, TInput>(
 
   const parts = result.results.map((item) => formatOne(mapResult(item)));
   if (result.errors.length > 0) {
+    const heading = ctx.globalFlags.llm ? "**Errors:**" : "Errors:";
     parts.push(
       [
-        "Errors:",
-        ...result.errors.map((error) => `- ${error.query}: ${error.message}`),
+        heading,
+        ...result.errors.flatMap((error) => formatErrorLines(error)),
       ].join("\n"),
     );
   }
 
   return parts.join("\n\n");
 }
+
+/**
+ * Render one lookup error as display lines: the query and message, plus any
+ * fuzzy-match suggestions carried on the error (which the JSON mode surfaces
+ * but the text modes previously dropped).
+ *
+ * @param error - A single lookup error entry.
+ * @returns One or more display lines for this error.
+ */
+function formatErrorLines(error: {
+  query: string;
+  message: string;
+  suggestions?: readonly string[];
+}): string[] {
+  const lines = [`- ${error.query}: ${error.message}`];
+  if (error.suggestions && error.suggestions.length > 0) {
+    lines.push(`  Did you mean: ${error.suggestions.join(", ")}?`);
+  }
+  return lines;
+}

package/src/domains/shared/listTiers.ts

@@ -0,0 +1,40 @@
+/**
+ * List the tiers defined in the loaded ontology, ordered by name.
+ *
+ * Shared operation: the `tier list` CLI/MCP surface is served by the bundled
+ * `tier` story pack, but `config tier` validation still needs the tier set
+ * programmatically, and this stays part of the package's public API. Kept in
+ * the shared layer so it has no dependency on any DS-specific domain module.
+ *
+ * @param store - ke store to query.
+ * @returns Array of tier entries, empty when none exist.
+ * @note Impure — queries the ke store.
+ */
+
+import type { Store, URI } from "@canonical/ke";
+import { buildQuery } from "./buildQuery.js";
+import { P } from "./prefixes.js";
+import type { TierEntry } from "./types/index.js";
+
+export async function listTiers(store: Store): Promise<TierEntry[]> {
+  const result = await store.query(
+    buildQuery(`
+      SELECT ?tier ?name
+      WHERE {
+        ?tier a ${P.ds}Tier ;
+              ${P.ds}name ?name .
+      }
+      ORDER BY ?name
+    `),
+  );
+
+  if (result.type !== "select") return [];
+
+  return result.bindings.map((b) => ({
+    uri: (b.tier ?? "") as URI,
+    path: b.name ?? "",
+    depth: 0,
+  }));
+}
+
+export default listTiers;

package/src/domains/shared/loaders/bundledLoader.ts

@@ -96,12 +96,14 @@ export default function createBundledLoader(): PackageLoader {
       if (graphs.length === 0 && stories.length === 0) return undefined;
 
       const version = await readEmbeddedVersion(blobs);
+      const prefixes = await readEmbeddedPrefixes(blobs);
 
       cached = {
         name: "(bundled)",
         version,
         source: "bundled",
         graphs,
+        ...(prefixes ? { prefixes } : {}),
         skills: [],
         stories,
       };
@@ -179,6 +181,52 @@ async function readEmbeddedStories(
 // Version reading
 // ---------------------------------------------------------------------------
 
+/**
+ * Aggregate `pragma.prefixes` declared across embedded package manifests.
+ *
+ * The bundled loader collapses every embedded package into one aggregate
+ * SemanticPackage, so their prefix declarations are merged here (later
+ * manifests win on key collisions). Only string→string entries are kept;
+ * malformed shapes are ignored so one bad manifest cannot break boot.
+ *
+ * @returns The merged prefix map, or `undefined` when none is declared.
+ */
+async function readEmbeddedPrefixes(
+  blobs: ReadonlyArray<Blob & { name: string }>,
+): Promise<Readonly<Record<string, string>> | undefined> {
+  const prefixes: Record<string, string> = {};
+
+  for (const blob of blobs) {
+    if (!isPackageManifest(blob.name)) continue;
+
+    try {
+      const parsed = JSON.parse(await blob.text()) as { pragma?: unknown };
+      const pragma = parsed.pragma;
+      if (typeof pragma !== "object" || pragma === null) continue;
+      const raw = (pragma as { prefixes?: unknown }).prefixes;
+      if (typeof raw !== "object" || raw === null) continue;
+      for (const [name, namespace] of Object.entries(raw)) {
+        if (typeof namespace !== "string") continue;
+        // These collapse into one aggregate package, so a cross-manifest
+        // collision would never reach resolvePrefixes' warning — surface it
+        // here, naming the manifest, instead of silently last-winning.
+        if (name in prefixes && prefixes[name] !== namespace) {
+          warn(
+            `embedded manifest "${blob.name}" overrides prefix "${name}" ` +
+              `(was <${prefixes[name]}>, now <${namespace}>)`,
+          );
+        }
+        prefixes[name] = namespace;
+      }
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      warn(`skipping prefixes in embedded manifest "${blob.name}": ${reason}`);
+    }
+  }
+
+  return Object.keys(prefixes).length > 0 ? prefixes : undefined;
+}
+
 async function readEmbeddedVersion(
   blobs: ReadonlyArray<Blob & { name: string }>,
 ): Promise<string> {

package/src/domains/shared/loaders/gitLoader.ts

@@ -24,8 +24,7 @@ export default function createGitLoader(): PackageLoader {
       const dir = gitCacheDir(ref.pkg, ref.ref);
       if (!existsSync(dir)) return undefined;
 
-      const { version, graphs, skills, stories } = readPackageDir(dir);
-      return { name: ref.pkg, version, source: "git", graphs, skills, stories };
+      return { name: ref.pkg, source: "git", ...readPackageDir(dir) };
     },
   };
 }