@canonical/pragma-cli 0.33.0 → 0.34.0

package/src/capabilities/token/pack.ts

@@ -1,58 +0,0 @@
-/**
- * The bundled `token` pack — design tokens as data.
- *
- * SPARQL-sourced on both verbs: there is no `ds:Token` GraphQL type to project
- * against when the graph ships no tokens, and the lookup reads a property path
- * (`ds:tokenType/rdfs:label`) only SPARQL can express. `token add-config` (a
- * mutation) is out of PR3; the `emptyRecovery` install hint is the story users
- * see on an empty store.
- */
-
-import type { PackDefinition } from "../../kernel/packs/types.js";
-
-export const tokenPack: PackDefinition = {
-  noun: "token",
-  description: "List all design tokens.",
-  toolDescription:
-    "List all design tokens with their type. Use when browsing which tokens exist under the active scope. Example: token_list {}.",
-  list: {
-    query: [
-      "SELECT ?uri ?name ?category WHERE {",
-      "  ?uri a ds:Token ;",
-      "       ds:tokenId ?name .",
-      "  OPTIONAL {",
-      "    ?uri ds:tokenType ?type .",
-      "    ?type rdfs:label ?category .",
-      "  }",
-      "}",
-      "ORDER BY ?name",
-    ].join("\n"),
-    columns: [
-      { field: "uri", label: "IRI" },
-      { field: "name", label: "Name" },
-      { field: "category", label: "Type" },
-    ],
-    emptyRecovery: {
-      message:
-        "No tokens in the store. Build it from the configured design-system packages.",
-      cli: "pragma sources update",
-    },
-  },
-  lookup: {
-    source: "sparql",
-    by: "ds:tokenId",
-    type: "ds:Token",
-    toolDescription:
-      'Get type and theme values for one or more design tokens by name. Use when resolving specific tokens\' light/dark values. Example: token_lookup { names: ["color.primary"] }.',
-    fields: [
-      { name: "category", property: "ds:tokenType/rdfs:label", label: "Type" },
-      { name: "valueLight", property: "ds:valueLight", label: "Light value" },
-      { name: "valueDark", property: "ds:valueDark", label: "Dark value" },
-    ],
-    sample: {
-      fixedCount: true,
-      toolDescription:
-        "Return randomly selected complete design tokens (with theme values) as exemplars. Use BEFORE writing queries to see actual data shapes.",
-    },
-  },
-};

package/src/capabilities/token/runAddConfig.ts

@@ -1,95 +0,0 @@
-/**
- * The `token add-config` write body (lazily imported, off the fast path).
- *
- * A store-backed mutation: it counts the design tokens in the active graph (so
- * the plan reports how many tokens the config will cover) and derives the
- * terrazzo token-source globs from the configured design-system packages, then
- * returns a Task that writes `tokens.config.mjs`. The store read happens in the
- * async setup; the file write is the Task's single `WriteFile` effect, so a
- * plan-only preview (`mutation.preview`) describes the write without performing
- * it. Ported from the old shell's `token add-config` (terrazzo `defineConfig`).
- */
-
-import { resolve } from "node:path";
-import { $, exists, gen, type Task, writeFile } from "@canonical/task";
-import type { PragmaRuntime } from "../../kernel/runtime/types.js";
-
-/** The default token source when no design-system packages are configured. */
-const DEFAULT_TOKEN_SOURCE =
-  "node_modules/@canonical/ds-global/tokens/**/*.json";
-
-/** The result of generating a terrazzo tokens config. */
-export interface AddConfigResult {
-  /** The absolute path written. */
-  readonly path: string;
-  /** How many `ds:Token` entities the active graph holds. */
-  readonly tokenCount: number;
-  /** The token-source globs written into the config. */
-  readonly sources: readonly string[];
-  /** Whether a `tokens.config.mjs` already existed (it is overwritten). */
-  readonly alreadyExisted: boolean;
-}
-
-/** Count the `ds:Token` entities in the booted store (best-effort). */
-async function countTokens(rt: PragmaRuntime): Promise<number> {
-  try {
-    const result = (await rt.query.sparql(
-      "SELECT (COUNT(DISTINCT ?token) AS ?count) WHERE { ?token a ds:Token }",
-    )) as { type?: string; bindings?: { count?: string }[] };
-    const raw = result.bindings?.[0]?.count;
-    return raw ? Number(raw) : 0;
-  } catch {
-    return 0;
-  }
-}
-
-/** Derive the terrazzo token-source globs from the configured packages. */
-async function resolveSources(rt: PragmaRuntime): Promise<string[]> {
-  const { config } = await rt.loadConfig();
-  const packages = config.packages ?? [];
-  if (packages.length === 0) return [DEFAULT_TOKEN_SOURCE];
-  return packages.map((pkg) => {
-    const name = typeof pkg === "string" ? pkg : pkg.name;
-    return `node_modules/${name}/tokens/**/*.json`;
-  });
-}
-
-/** Render the terrazzo `tokens.config.mjs` content. */
-function generateConfig(sources: readonly string[]): string {
-  const sourceList = sources
-    .map((source) => `    ${JSON.stringify(source)}`)
-    .join(",\n");
-  return `// tokens.config.mjs — generated by \`pragma token add-config\`
-import { defineConfig } from "@canonical/terrazzo";
-
-export default defineConfig({
-  tokens: [
-${sourceList},
-  ],
-  outDir: "./tokens/",
-  plugins: [],
-});
-`;
-}
-
-/**
- * Build the Task that writes `tokens.config.mjs` for the terrazzo pipeline.
- *
- * @param rt - The runtime (its store is booted by the projector for needsStore).
- * @returns A Task yielding the write outcome.
- * @note Impure — reads the store + config; the write is the Task's effect.
- */
-export async function runAddConfig(
-  rt: PragmaRuntime,
-): Promise<Task<AddConfigResult>> {
-  const tokenCount = await countTokens(rt);
-  const sources = await resolveSources(rt);
-  const path = resolve(rt.cwd, "tokens.config.mjs");
-  const content = generateConfig(sources);
-
-  return gen(function* () {
-    const alreadyExisted = yield* $(exists(path));
-    yield* $(writeFile(path, content));
-    return { path, tokenCount, sources, alreadyExisted };
-  });
-}

package/src/kernel/completion/bashDrive.test.ts

@@ -1,73 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { mkdtempSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { describe, expect, it } from "vitest";
-import { completionFixture } from "../../testing/fixtures/completionFixture.js";
-import { emitScripts } from "./emitScripts.js";
-
-/**
- * M1 regression: the generated bash script must complete the `--flag=value`
- * wordbreak form. With `=` in COMP_WORDBREAKS, bash splits `--format=` into
- * `--format` `=` `` (or `` after `=`); without the normalization at the top of
- * `_pragma`, the value slot falls through to the noun/positional arm and
- * offers the WRONG candidates. These tests drive the REAL bash to prove the
- * fix, so the static tier answers `--format=<TAB>` as a flag value with zero
- * exec (the resolver is only reached for `{kind:"entity"}` contexts).
- */
-
-/** Whether a usable bash is on PATH (the package pins os:["linux"], so it is). */
-const bashOk =
-  spawnSync("bash", ["-c", "printf ok"], { encoding: "utf-8" }).stdout === "ok";
-
-/** The bash completion script for the fixture grammar (has the global --format). */
-const script = emitScripts([completionFixture]).bash;
-
-/**
- * Source the generated script in a real bash, place the cursor per COMP_WORDS
- * / COMP_CWORD, invoke `_pragma`, and return COMPREPLY line-by-line.
- */
-function driveBash(words: readonly string[], cword: number): string[] {
-  const dir = mkdtempSync(join(tmpdir(), "pragma-bashdrive-"));
-  const file = join(dir, "completion.bash");
-  writeFileSync(file, script);
-  const wordsLiteral = words
-    .map((word) => `'${word.replace(/'/g, "'\\''")}'`)
-    .join(" ");
-  const driver = [
-    `source '${file}'`,
-    `COMP_WORDS=(${wordsLiteral})`,
-    `COMP_CWORD=${cword}`,
-    "_pragma",
-    `printf '%s\\n' "\${COMPREPLY[@]}"`,
-  ].join("\n");
-  const result = spawnSync("bash", ["--norc", "--noprofile", "-c", driver], {
-    encoding: "utf-8",
-  });
-  return result.stdout.split("\n").filter((line) => line.length > 0);
-}
-
-describe.skipIf(!bashOk)("generated bash — --flag=value wordbreak (M1)", () => {
-  it("routes --format=<TAB> to the format values (not nouns/positionals)", () => {
-    // Default COMP_WORDBREAKS split: `--format` `=` `` (empty current word).
-    const reply = driveBash(["pragma", "--format", "=", ""], 3);
-    expect(reply.sort()).toEqual(["json", "llm", "plain"]);
-  });
-
-  it("filters the value by the partial typed after =", () => {
-    const reply = driveBash(["pragma", "--format", "=", "j"], 3);
-    expect(reply).toEqual(["json"]);
-  });
-
-  it("routes a verb-scoped --format=<TAB> the same way", () => {
-    // After a noun/verb the value must still route as a flag value, never as
-    // block's positional (which would offer entity/enum candidates instead).
-    const reply = driveBash(["pragma", "block", "get", "--format", "=", ""], 5);
-    expect(reply.sort()).toEqual(["json", "llm", "plain"]);
-  });
-
-  it("still completes the space form --format <TAB> (unbroken)", () => {
-    const reply = driveBash(["pragma", "--format", ""], 2);
-    expect(reply.sort()).toEqual(["json", "llm", "plain"]);
-  });
-});

package/src/kernel/runtime/graphpack/embedded/sample.ttl

@@ -1,39 +0,0 @@
-# Embedded fallback pack source — a small, self-contained sample ontology.
-#
-# Compiled by `scripts/genEmbedded.ts` into `pack.generated.ts`. It exists so a
-# fresh install (no configured packages, no lock) can answer store-backed reads
-# without a network round-trip. Keep it tiny: it ships inside the binary.
-
-@prefix ex:   <https://pragma.canonical.com/sample#> .
-@prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
-@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
-@prefix owl:  <http://www.w3.org/2002/07/owl#> .
-@prefix xsd:  <http://www.w3.org/2001/XMLSchema#> .
-
-ex:Component a owl:Class ;
-  rdfs:label "Component" ;
-  rdfs:comment "A reusable design-system building block." .
-
-ex:componentName a owl:DatatypeProperty ;
-  rdfs:label "component name" ;
-  rdfs:domain ex:Component ;
-  rdfs:range xsd:string .
-
-ex:dependsOn a owl:ObjectProperty ;
-  rdfs:label "depends on" ;
-  rdfs:domain ex:Component ;
-  rdfs:range ex:Component .
-
-ex:Button a ex:Component ;
-  rdfs:label "Button" ;
-  ex:componentName "Button" .
-
-ex:Card a ex:Component ;
-  rdfs:label "Card" ;
-  ex:componentName "Card" ;
-  ex:dependsOn ex:Button .
-
-ex:Dialog a ex:Component ;
-  rdfs:label "Dialog" ;
-  ex:componentName "Dialog" ;
-  ex:dependsOn ex:Button , ex:Card .

package/src/kernel/runtime/lock.ts

@@ -1,90 +0,0 @@
-/**
- * The project lock — `pragma.lock.json`, committed at the project root.
- *
- * It pins the single combined pack the store boots from: `contentHash` names
- * the pack's cache directory, and `packs[]` records the resolved provenance of
- * every configured source (so `sources status` reports it and a `--frozen`
- * update re-resolves to exactly these commits). Serialization is canonical —
- * fixed field order, packs sorted by name, one trailing newline — so a
- * `--frozen` update that changes nothing rewrites a byte-identical file.
- *
- * Pure: zod + fs only, no store code, so both the storeless `sources status`
- * verb and the store-boot decision table read it without booting oxigraph.
- */
-
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { z } from "zod";
-import { lockPath } from "./paths.js";
-
-/** One resolved source's provenance in the lock. */
-export const lockPackageSchema = z.object({
-  /** Package name (config `packages` entry name / npm name). */
-  name: z.string(),
-  /** The config `packages` source ref, verbatim (e.g. `git+https://…#main`). */
-  source: z.string(),
-  /** The resolved commit / version / absolute path this ref pinned to. */
-  resolved: z.string(),
-  /** ISO timestamp the ref was resolved. */
-  resolvedAt: z.string(),
-});
-
-/** The lock document. */
-export const pragmaLockSchema = z.object({
-  version: z.literal(1),
-  /** The combined pack's content hash — names its cache directory. */
-  contentHash: z.string(),
-  packs: z.array(lockPackageSchema),
-});
-
-/** One resolved source's provenance in the lock. */
-export type PragmaLockPackage = z.infer<typeof lockPackageSchema>;
-/** The parsed lock document. */
-export type PragmaLock = z.infer<typeof pragmaLockSchema>;
-
-/**
- * Read and validate the lock for a working directory.
- *
- * @param cwd - The project directory.
- * @returns The parsed lock, or `undefined` when absent or invalid.
- * @note Impure — reads from disk.
- */
-export function readLock(cwd: string): PragmaLock | undefined {
-  const path = lockPath(cwd);
-  if (!existsSync(path)) return undefined;
-  try {
-    return pragmaLockSchema.parse(JSON.parse(readFileSync(path, "utf-8")));
-  } catch {
-    return undefined;
-  }
-}
-
-/** Serialize a lock canonically — stable field order, sorted packs, newline. */
-export function serializeLock(lock: PragmaLock): string {
-  const packs = [...lock.packs]
-    .sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0))
-    .map((pack) => ({
-      name: pack.name,
-      source: pack.source,
-      resolved: pack.resolved,
-      resolvedAt: pack.resolvedAt,
-    }));
-  return `${JSON.stringify(
-    { version: lock.version, contentHash: lock.contentHash, packs },
-    null,
-    2,
-  )}\n`;
-}
-
-/**
- * Write the lock for a working directory.
- *
- * @param cwd - The project directory.
- * @param lock - The lock to persist.
- * @returns The exact bytes written (for the write effect / assertions).
- * @note Impure — writes `pragma.lock.json`.
- */
-export function writeLock(cwd: string, lock: PragmaLock): string {
-  const content = serializeLock(lock);
-  writeFileSync(lockPath(cwd), content);
-  return content;
-}