@canonical/pragma-cli 0.27.1-experimental.0 → 0.30.0

package/src/domains/doctor/operations/runChecks.test.ts

@@ -8,12 +8,14 @@ vi.mock("./checks/index.js", () => ({
   checkKeStore: vi.fn(),
   checkShellCompletions: vi.fn(),
   checkMcpConfigured: vi.fn(),
+  checkMcpCommands: vi.fn(),
   checkSkillsSymlinked: vi.fn(),
 }));
 
 import {
   checkConfigFile,
   checkKeStore,
+  checkMcpCommands,
   checkMcpConfigured,
   checkNodeVersion,
   checkPackageRefs,
@@ -22,6 +24,7 @@ import {
   checkSkillsSymlinked,
 } from "./checks/index.js";
 import runChecks from "./runChecks.js";
+import type { CheckResult } from "./types.js";
 
 const pass = (name: string) => ({
   name,
@@ -49,13 +52,14 @@ describe("runChecks", () => {
     vi.mocked(checkKeStore).mockResolvedValue(pass("store"));
     vi.mocked(checkShellCompletions).mockResolvedValue(pass("completions"));
     vi.mocked(checkMcpConfigured).mockResolvedValue(pass("mcp"));
+    vi.mocked(checkMcpCommands).mockResolvedValue(pass("mcp commands"));
     vi.mocked(checkSkillsSymlinked).mockResolvedValue(pass("skills"));
 
     const data = await runChecks({ cwd: "/test" });
-    expect(data.passed).toBe(8);
+    expect(data.passed).toBe(9);
     expect(data.failed).toBe(0);
     expect(data.skipped).toBe(0);
-    expect(data.checks).toHaveLength(8);
+    expect(data.checks).toHaveLength(9);
   });
 
   it("counts failures and skips correctly", async () => {
@@ -66,10 +70,11 @@ describe("runChecks", () => {
     vi.mocked(checkKeStore).mockResolvedValue(fail("store"));
     vi.mocked(checkShellCompletions).mockResolvedValue(fail("completions"));
     vi.mocked(checkMcpConfigured).mockResolvedValue(pass("mcp"));
+    vi.mocked(checkMcpCommands).mockResolvedValue(pass("mcp commands"));
     vi.mocked(checkSkillsSymlinked).mockResolvedValue(skip("skills"));
 
     const data = await runChecks({ cwd: "/test" });
-    expect(data.passed).toBe(4);
+    expect(data.passed).toBe(5);
     expect(data.failed).toBe(3);
     expect(data.skipped).toBe(1);
   });
@@ -82,6 +87,7 @@ describe("runChecks", () => {
     vi.mocked(checkKeStore).mockResolvedValue(pass("store"));
     vi.mocked(checkShellCompletions).mockResolvedValue(pass("completions"));
     vi.mocked(checkMcpConfigured).mockResolvedValue(pass("mcp"));
+    vi.mocked(checkMcpCommands).mockResolvedValue(pass("mcp commands"));
     vi.mocked(checkSkillsSymlinked).mockResolvedValue(pass("skills"));
 
     const data = await runChecks({ cwd: "/test" });
@@ -90,6 +96,81 @@ describe("runChecks", () => {
     expect(data.checks[2].name).toBe("config");
     expect(data.checks[3].name).toBe("refs");
     expect(data.checks[4].name).toBe("store");
-    expect(data.checks[7].name).toBe("skills");
+    expect(data.checks[8].name).toBe("skills");
+  });
+
+  it("preserves order even when checks resolve out of order", async () => {
+    const delayed = (result: CheckResult, ms: number) =>
+      new Promise<CheckResult>((resolve) =>
+        setTimeout(() => resolve(result), ms),
+      );
+
+    // Resolve the first check slowest and the last fastest to prove the report
+    // order follows declaration order, not completion order.
+    vi.mocked(checkNodeVersion).mockReturnValue(delayed(pass("Node"), 30));
+    vi.mocked(checkPragmaVersion).mockResolvedValue(pass("pragma"));
+    vi.mocked(checkConfigFile).mockResolvedValue(pass("config"));
+    vi.mocked(checkPackageRefs).mockResolvedValue(pass("refs"));
+    vi.mocked(checkKeStore).mockResolvedValue(pass("store"));
+    vi.mocked(checkShellCompletions).mockResolvedValue(pass("completions"));
+    vi.mocked(checkMcpConfigured).mockResolvedValue(pass("mcp"));
+    vi.mocked(checkMcpCommands).mockResolvedValue(pass("mcp commands"));
+    vi.mocked(checkSkillsSymlinked).mockReturnValue(delayed(pass("skills"), 0));
+
+    const data = await runChecks({ cwd: "/test" });
+    expect(data.checks.map((c) => c.name)).toEqual([
+      "Node",
+      "pragma",
+      "config",
+      "refs",
+      "store",
+      "completions",
+      "mcp",
+      "mcp commands",
+      "skills",
+    ]);
+  });
+
+  it("surfaces a thrown check as an attributable fail instead of aborting", async () => {
+    vi.mocked(checkNodeVersion).mockResolvedValue(pass("Node"));
+    vi.mocked(checkPragmaVersion).mockResolvedValue(pass("pragma"));
+    vi.mocked(checkConfigFile).mockRejectedValue(new Error("disk on fire"));
+    vi.mocked(checkPackageRefs).mockResolvedValue(pass("refs"));
+    vi.mocked(checkKeStore).mockResolvedValue(pass("store"));
+    vi.mocked(checkShellCompletions).mockResolvedValue(pass("completions"));
+    vi.mocked(checkMcpConfigured).mockResolvedValue(pass("mcp"));
+    vi.mocked(checkMcpCommands).mockResolvedValue(pass("mcp commands"));
+    vi.mocked(checkSkillsSymlinked).mockResolvedValue(pass("skills"));
+
+    const data = await runChecks({ cwd: "/test" });
+
+    // The whole run still completes; the thrown check becomes a fail in place.
+    expect(data.checks).toHaveLength(9);
+    expect(data.passed).toBe(8);
+    expect(data.failed).toBe(1);
+    const failed = data.checks[2];
+    expect(failed.status).toBe("fail");
+    // Fallback name matches checkConfigFile's own `name` so a thrown check
+    // reports the same label as a normal pass/fail.
+    expect(failed.name).toBe("pragma.config.json");
+    expect(failed.detail).toContain("disk on fire");
+    expect(failed.remedy).toBeDefined();
+  });
+
+  it("handles a non-Error rejection without crashing", async () => {
+    vi.mocked(checkNodeVersion).mockResolvedValue(pass("Node"));
+    vi.mocked(checkPragmaVersion).mockResolvedValue(pass("pragma"));
+    vi.mocked(checkConfigFile).mockResolvedValue(pass("config"));
+    vi.mocked(checkPackageRefs).mockResolvedValue(pass("refs"));
+    vi.mocked(checkKeStore).mockRejectedValue("string failure");
+    vi.mocked(checkShellCompletions).mockResolvedValue(pass("completions"));
+    vi.mocked(checkMcpConfigured).mockResolvedValue(pass("mcp"));
+    vi.mocked(checkMcpCommands).mockResolvedValue(pass("mcp commands"));
+    vi.mocked(checkSkillsSymlinked).mockResolvedValue(pass("skills"));
+
+    const data = await runChecks({ cwd: "/test" });
+    expect(data.failed).toBe(1);
+    expect(data.checks[4].name).toBe("ke store");
+    expect(data.checks[4].detail).toContain("string failure");
   });
 });

package/src/domains/doctor/operations/runChecks.ts

@@ -1,6 +1,7 @@
 import {
   checkConfigFile,
   checkKeStore,
+  checkMcpCommands,
   checkMcpConfigured,
   checkNodeVersion,
   checkPackageRefs,
@@ -11,8 +12,36 @@ import {
 import type { CheckContext, CheckResult, DoctorData } from "./types.js";
 
 /**
- * Orchestrate all environment health checks sequentially and return
- * a DoctorData summary with pass/fail/skip counts.
+ * Each check paired with the display name used if it rejects. The checks are
+ * mutually independent, so they run concurrently; this list also fixes the
+ * stable display order of the results. The fallback name must match the
+ * `name` each check returns on success, so a thrown check reports the same
+ * label as a normal pass/fail and stays correlatable.
+ */
+function buildChecks(
+  ctx: CheckContext,
+): readonly [string, Promise<CheckResult>][] {
+  return [
+    ["Node version", checkNodeVersion()],
+    ["pragma version", checkPragmaVersion()],
+    ["pragma.config.json", checkConfigFile(ctx)],
+    ["package refs", checkPackageRefs(ctx)],
+    ["ke store", checkKeStore(ctx)],
+    ["Shell completions", checkShellCompletions()],
+    ["MCP configured", checkMcpConfigured(ctx)],
+    ["MCP commands", checkMcpCommands(ctx)],
+    ["Skills symlinked", checkSkillsSymlinked(ctx)],
+  ];
+}
+
+/**
+ * Orchestrate all environment health checks concurrently and return a
+ * DoctorData summary with pass/fail/skip counts.
+ *
+ * Checks run concurrently; results are collected in declaration order so the
+ * report is deterministic. A check that throws is surfaced as a fail (rather
+ * than aborting `pragma doctor`), tagged with the check's name so the failure
+ * remains attributable.
  *
  * @param ctx - Check context containing the working directory.
  * @returns Aggregated check results.
@@ -21,16 +50,25 @@ import type { CheckContext, CheckResult, DoctorData } from "./types.js";
 export default async function runChecks(
   ctx: CheckContext,
 ): Promise<DoctorData> {
-  const checks: CheckResult[] = [];
-
-  checks.push(await checkNodeVersion());
-  checks.push(await checkPragmaVersion());
-  checks.push(await checkConfigFile(ctx));
-  checks.push(await checkPackageRefs(ctx));
-  checks.push(await checkKeStore(ctx));
-  checks.push(await checkShellCompletions());
-  checks.push(await checkMcpConfigured(ctx));
-  checks.push(await checkSkillsSymlinked(ctx));
+  // buildChecks starts every check eagerly, so they run concurrently; each is
+  // guarded so a thrown check becomes an attributable fail rather than
+  // rejecting the whole run. Mapping preserves declaration order.
+  const checks: CheckResult[] = await Promise.all(
+    buildChecks(ctx).map(async ([name, promise]): Promise<CheckResult> => {
+      try {
+        return await promise;
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        return {
+          name,
+          status: "fail",
+          detail: `Check threw an unexpected error: ${reason}`,
+          remedy:
+            "Re-run `pragma doctor`; if it persists, report this as a bug.",
+        };
+      }
+    }),
+  );
 
   const passed = checks.filter((c) => c.status === "pass").length;
   const failed = checks.filter((c) => c.status === "fail").length;

package/src/domains/graph/helpers/resolveUri.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from "vitest";
+import { PragmaError } from "#error";
+import resolveUri from "./resolveUri.js";
+
+const prefixes = {
+  ds: "https://ds.canonical.com/",
+  cs: "http://pragma.canonical.com/codestandards#",
+} as const;
+
+describe("resolveUri", () => {
+  it("expands a registered prefix", () => {
+    expect(resolveUri("ds:UIBlock", prefixes)).toBe(
+      "https://ds.canonical.com/UIBlock",
+    );
+  });
+
+  it("passes through a full http(s) IRI", () => {
+    expect(resolveUri("https://ds.canonical.com/global", prefixes)).toBe(
+      "https://ds.canonical.com/global",
+    );
+  });
+
+  it("passes through a urn: IRI", () => {
+    expect(resolveUri("urn:isbn:0451450523", prefixes)).toBe(
+      "urn:isbn:0451450523",
+    );
+  });
+
+  it("passes through a foreign scheme:// IRI", () => {
+    expect(resolveUri("ftp://example.org/thing", prefixes)).toBe(
+      "ftp://example.org/thing",
+    );
+  });
+
+  it("throws for an unknown prefix", () => {
+    expect(() => resolveUri("unknown:something", prefixes)).toThrow(
+      PragmaError,
+    );
+  });
+
+  it("throws for a bare string without a prefix", () => {
+    expect(() => resolveUri("button", prefixes)).toThrow(PragmaError);
+  });
+
+  it("throws for an IRI with unsafe characters", () => {
+    expect(() =>
+      resolveUri("https://example.com/<injected>", prefixes),
+    ).toThrow(PragmaError);
+  });
+});

package/src/domains/graph/helpers/resolveUri.ts

@@ -6,12 +6,20 @@ import { PragmaError } from "#error";
  */
 const UNSAFE_IRI_PATTERN = /[<>"{}|\\^`\s]/;
 
+/**
+ * Matches a general absolute IRI: any scheme with an authority (`scheme://…`,
+ * covering http, https, ftp, ws, and foreign schemes) or a `urn:` opaque IRI.
+ * Broader than an http(s)-only check so foreign ontologies resolve.
+ */
+const ABSOLUTE_IRI_PATTERN = /^(?:[A-Za-z][A-Za-z0-9+.-]*:\/\/|urn:)\S/i;
+
 /**
  * Resolves a potentially prefixed URI (e.g. `ds:UIBlock`) to a full URI.
  *
- * If the URI is already a full URI (starts with `http`), validates IRI safety
- * and returns it as-is. Otherwise, expands the prefix using the provided
- * prefix map.
+ * A registered prefix always wins: `ds:UIBlock` expands via the prefix map.
+ * Otherwise a general absolute IRI (`scheme://…` or `urn:…`) is validated and
+ * returned as-is, so foreign ontologies are not rejected as unknown prefixes.
+ * Any other `token:rest` is treated as an unknown prefix.
  *
  * @param uri - A full or prefixed URI string.
  * @param prefixes - Registered prefix-to-namespace mapping from the store.
@@ -22,11 +30,6 @@ export default function resolveUri(
   uri: string,
   prefixes: Readonly<Record<string, string>>,
 ): string {
-  if (uri.startsWith("http://") || uri.startsWith("https://")) {
-    assertSafeIri(uri);
-    return uri;
-  }
-
   const colonIdx = uri.indexOf(":");
   if (colonIdx === -1) {
     throw PragmaError.invalidInput("uri", uri, {
@@ -38,23 +41,27 @@ export default function resolveUri(
   }
 
   const prefix = uri.slice(0, colonIdx);
-  const localName = uri.slice(colonIdx + 1);
   const namespace = prefixes[prefix];
 
-  if (namespace === undefined) {
-    throw PragmaError.invalidInput("prefix", prefix, {
-      validOptions: Object.keys(prefixes),
-      recovery: {
-        message: "List known ontology prefixes.",
-        cli: "pragma ontology list",
-        mcp: { tool: "ontology_list" },
-      },
-    });
+  if (namespace !== undefined) {
+    const resolved = `${namespace}${uri.slice(colonIdx + 1)}`;
+    assertSafeIri(resolved);
+    return resolved;
+  }
+
+  if (ABSOLUTE_IRI_PATTERN.test(uri)) {
+    assertSafeIri(uri);
+    return uri;
   }
 
-  const resolved = `${namespace}${localName}`;
-  assertSafeIri(resolved);
-  return resolved;
+  throw PragmaError.invalidInput("prefix", prefix, {
+    validOptions: Object.keys(prefixes),
+    recovery: {
+      message: "List known ontology prefixes.",
+      cli: "pragma ontology list",
+      mcp: { tool: "ontology_list" },
+    },
+  });
 }
 
 /**

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

@@ -0,0 +1,196 @@
+import {
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { CommandDefinition } from "@canonical/cli-core";
+import { hashSources } from "@canonical/ke-graphql";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  EX_PREFIX_ENTRY,
+  GRAPHQL_CLEAN_TTL,
+  GRAPHQL_ERROR_TTL,
+  GRAPHQL_FATAL_TTL,
+} from "#testing";
+import type { PragmaContext } from "../../shared/context.js";
+import type { GraphqlCompileReport } from "../types.js";
+import buildCommand from "./build.js";
+
+let dir: string;
+let stdoutSpy: ReturnType<typeof vi.spyOn>;
+
+beforeEach(() => {
+  dir = mkdtempSync(join(tmpdir(), "pragma-graphql-build-"));
+  writeFileSync(join(dir, "clean.ttl"), GRAPHQL_CLEAN_TTL);
+  writeFileSync(join(dir, "error.ttl"), GRAPHQL_ERROR_TTL);
+  writeFileSync(join(dir, "fatal.ttl"), GRAPHQL_FATAL_TTL);
+  stdoutSpy = vi.spyOn(process.stdout, "write").mockImplementation(() => true);
+});
+
+afterEach(() => {
+  stdoutSpy.mockRestore();
+  rmSync(dir, { recursive: true, force: true });
+});
+
+function makeCtx(overrides: Partial<PragmaContext> = {}): PragmaContext {
+  return {
+    cwd: dir,
+    globalFlags: { llm: false, format: "text" as const, verbose: false },
+    store: {} as PragmaContext["store"],
+    config: { tier: undefined, channel: "normal" },
+    ...overrides,
+  } as PragmaContext;
+}
+
+async function executeOutput(
+  cmd: CommandDefinition,
+  params: Record<string, unknown>,
+  ctx: PragmaContext,
+): Promise<{ value: GraphqlCompileReport; text: string }> {
+  const result = await cmd.execute(params, ctx);
+  expect(result.tag).toBe("output");
+  if (result.tag !== "output") throw new Error("Expected output result");
+  return {
+    value: result.value as GraphqlCompileReport,
+    text: result.render.plain(result.value),
+  };
+}
+
+describe("graphql build command", () => {
+  it("writes the SDL and extraction artifacts to the default paths", async () => {
+    const ctx = makeCtx();
+    const { value } = await executeOutput(
+      buildCommand,
+      { sources: ["clean.ttl"], prefix: [EX_PREFIX_ENTRY] },
+      ctx,
+    );
+
+    const sdl = readFileSync(join(dir, "schema.graphql"), "utf-8");
+    expect(sdl).toContain("type Thing");
+
+    const artifact = JSON.parse(
+      readFileSync(join(dir, "extraction.json"), "utf-8"),
+    ) as { version: number; sourcesHash: string };
+    expect(artifact.version).toBe(1);
+
+    const raw = readFileSync(join(dir, "clean.ttl"), "utf-8");
+    expect(artifact.sourcesHash).toBe(hashSources([raw]));
+    expect(value.artifacts).toEqual({
+      sdl: join(dir, "schema.graphql"),
+      extraction: join(dir, "extraction.json"),
+    });
+  });
+
+  it("writes artifacts to custom --sdl and --extraction paths", async () => {
+    const ctx = makeCtx();
+    await executeOutput(
+      buildCommand,
+      {
+        sources: ["clean.ttl"],
+        prefix: [EX_PREFIX_ENTRY],
+        sdl: "out/api.graphql",
+        extraction: "out/api-extraction.json",
+      },
+      ctx,
+    );
+
+    expect(readFileSync(join(dir, "out", "api.graphql"), "utf-8")).toContain(
+      "type Thing",
+    );
+    expect(
+      JSON.parse(
+        readFileSync(join(dir, "out", "api-extraction.json"), "utf-8"),
+      ),
+    ).toMatchObject({ version: 1 });
+  });
+
+  it("renders plain output with a summary and artifact paths", async () => {
+    const ctx = makeCtx();
+    const { text } = await executeOutput(
+      buildCommand,
+      { sources: ["clean.ttl"], prefix: [EX_PREFIX_ENTRY] },
+      ctx,
+    );
+
+    expect(text).toContain("1 source file: 0 errors, 0 warnings, 0 info");
+    expect(text).toContain(`Wrote ${join(dir, "schema.graphql")}`);
+    expect(text).toContain(`Wrote ${join(dir, "extraction.json")}`);
+  });
+
+  it("prints error diagnostics but still writes artifacts", async () => {
+    const ctx = makeCtx();
+    const { text } = await executeOutput(
+      buildCommand,
+      { sources: ["error.ttl"], prefix: [EX_PREFIX_ENTRY] },
+      ctx,
+    );
+
+    expect(text).toContain("M001");
+    expect(text).toContain("1 error");
+    expect(existsSync(join(dir, "schema.graphql"))).toBe(true);
+    expect(existsSync(join(dir, "extraction.json"))).toBe(true);
+  });
+
+  it("renders llm output", async () => {
+    const ctx = makeCtx({
+      globalFlags: { llm: true, format: "text" as const, verbose: false },
+    });
+    const { text } = await executeOutput(
+      buildCommand,
+      { sources: ["clean.ttl"], prefix: [EX_PREFIX_ENTRY] },
+      ctx,
+    );
+
+    expect(text).toContain("## GraphQL Compile");
+    expect(text).toContain("**Summary:**");
+  });
+
+  it("renders json output", async () => {
+    const ctx = makeCtx({
+      globalFlags: { llm: false, format: "json" as const, verbose: false },
+    });
+    const { text } = await executeOutput(
+      buildCommand,
+      { sources: ["clean.ttl"], prefix: [EX_PREFIX_ENTRY] },
+      ctx,
+    );
+
+    const parsed = JSON.parse(text) as GraphqlCompileReport;
+    expect(parsed.diagnostics).toEqual([]);
+    expect(parsed.files).toEqual([join(dir, "clean.ttl")]);
+  });
+
+  it("exits non-zero and writes no artifacts when compilation fails", async () => {
+    const ctx = makeCtx();
+    const result = await buildCommand.execute(
+      { sources: ["fatal.ttl"], prefix: [EX_PREFIX_ENTRY] },
+      ctx,
+    );
+
+    expect(result.tag).toBe("exit");
+    if (result.tag !== "exit") throw new Error("Expected exit result");
+    expect(result.code).toBe(1);
+    expect(existsSync(join(dir, "schema.graphql"))).toBe(false);
+    expect(existsSync(join(dir, "extraction.json"))).toBe(false);
+
+    const printed = stdoutSpy.mock.calls.map((call) => call[0]).join("");
+    expect(printed).toContain("C003");
+  });
+
+  it("throws a structured error when explicit sources match nothing", async () => {
+    const ctx = makeCtx();
+
+    await expect(
+      buildCommand.execute({ sources: ["no-such-*.ttl"] }, ctx),
+    ).rejects.toMatchObject({
+      code: "INVALID_INPUT",
+      recovery: {
+        message: "No files matched the given paths or glob patterns.",
+      },
+    });
+  });
+});

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

@@ -0,0 +1,117 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import {
+  type CommandDefinition,
+  type CommandResult,
+  createExitResult,
+  createOutputResult,
+} from "@canonical/cli-core";
+import { serializeExtraction } from "@canonical/ke-graphql";
+import { selectFormatter } from "../../shared/formatters.js";
+import { DEFAULT_EXTRACTION_PATH, DEFAULT_SDL_PATH } from "../constants.js";
+import { reportFormatters } from "../formatters/index.js";
+import { gatherSources, parsePrefixes } from "../helpers/index.js";
+import { compileSchema } from "../operations/index.js";
+import type { GraphqlCompileReport } from "../types.js";
+
+/** Narrow an unknown param to a string array. */
+function readStringArray(value: unknown): string[] {
+  return Array.isArray(value)
+    ? value.filter((item): item is string => typeof item === "string")
+    : [];
+}
+
+/**
+ * Builds the `pragma graphql build` command definition.
+ *
+ * Compiles TTL sources into a GraphQL schema, writes the SDL and the
+ * extraction artifact, and prints all compiler diagnostics. Exits
+ * non-zero when schema composition fails.
+ */
+const buildCommand: CommandDefinition = {
+  path: ["graphql", "build"],
+  description: "Compile TTL sources into GraphQL schema artifacts",
+  parameters: [
+    {
+      name: "sources",
+      description:
+        "TTL files or globs (default: the configured semantic packages)",
+      type: "multiselect",
+      positional: true,
+    },
+    {
+      name: "sdl",
+      description: "Output path for the GraphQL SDL",
+      type: "string",
+      default: DEFAULT_SDL_PATH,
+    },
+    {
+      name: "extraction",
+      description: "Output path for the extraction artifact",
+      type: "string",
+      default: DEFAULT_EXTRACTION_PATH,
+    },
+    {
+      name: "prefix",
+      description: "Ontology prefix as name=namespace (repeatable)",
+      type: "multiselect",
+    },
+  ],
+  meta: {
+    examples: [
+      "pragma graphql build ontology.ttl",
+      'pragma graphql build "data/*.ttl" --sdl out/schema.graphql --extraction out/extraction.json',
+      "pragma graphql build ontology.ttl --prefix ds=https://ds.canonical.com/",
+    ],
+  },
+  async execute(params, ctx): Promise<CommandResult> {
+    const sources = await gatherSources(
+      readStringArray(params.sources),
+      ctx.cwd,
+    );
+    const prefixes = parsePrefixes(readStringArray(params.prefix));
+    const outcome = await compileSchema({ sources, prefixes, cwd: ctx.cwd });
+    const format = selectFormatter(ctx, reportFormatters);
+
+    if (outcome.status === "failed" || !outcome.compiled) {
+      const report: GraphqlCompileReport = {
+        diagnostics: outcome.diagnostics,
+        files: outcome.files,
+        sourcesHash: outcome.sourcesHash,
+      };
+      process.stdout.write(`${format(report)}\n`);
+      return createExitResult(1);
+    }
+
+    const sdlPath = resolve(
+      ctx.cwd,
+      typeof params.sdl === "string" ? params.sdl : DEFAULT_SDL_PATH,
+    );
+    const extractionPath = resolve(
+      ctx.cwd,
+      typeof params.extraction === "string"
+        ? params.extraction
+        : DEFAULT_EXTRACTION_PATH,
+    );
+
+    mkdirSync(dirname(sdlPath), { recursive: true });
+    writeFileSync(sdlPath, outcome.compiled.sdl, "utf-8");
+    mkdirSync(dirname(extractionPath), { recursive: true });
+    writeFileSync(
+      extractionPath,
+      serializeExtraction(outcome.compiled.extraction, outcome.sourcesHash),
+      "utf-8",
+    );
+
+    const report: GraphqlCompileReport = {
+      diagnostics: outcome.diagnostics,
+      files: outcome.files,
+      sourcesHash: outcome.sourcesHash,
+      artifacts: { sdl: sdlPath, extraction: extractionPath },
+    };
+
+    return createOutputResult(report, { plain: format });
+  },
+};
+
+export default buildCommand;