@intentius/chant-lexicon-docker 0.1.4 → 0.1.8

package/dist/integrity.json

@@ -1,19 +1,19 @@
 {
-  "algorithm": "xxhash64",
+  "algorithm": "sha256",
   "artifacts": {
-    "manifest.json": "11a2fcc44f1b0873",
-    "meta.json": "6a8cbb16d88dd81",
-    "types/index.d.ts": "61a04a2aae8fb72d",
-    "rules/no-latest-tag.ts": "9a513a0d0801cfbd",
-    "rules/unused-volume.ts": "b6101cbbfef97481",
-    "rules/no-latest-image.ts": "1730d370550a5f5e",
-    "rules/prefer-copy.ts": "c2eb8a86389a6b1",
-    "rules/ssh-port-exposed.ts": "73a6e5d39eebcc28",
-    "rules/docker-helpers.ts": "667d796e1dd6771f",
-    "rules/apt-no-recommends.ts": "dce8c901982e2d4",
-    "rules/no-root-user.ts": "5aad839aa8ef0407",
-    "skills/chant-docker.md": "419ee2f3187d9527",
-    "skills/chant-docker-patterns.md": "cea0225dd8450081"
+    "manifest.json": "87023f1c5a044cffac469511ec4fa7f58262f6b74e2382dddca406d47eec1ed0",
+    "meta.json": "e39b7b9e67e980b070486b5cc6908b1b1bc16e3360c3356dd0923cf4db80133e",
+    "types/index.d.ts": "f0bb7df2a41a10f7cdb14869dd3b23d3a3f944f2b58ee953bf252f430e0cbbd9",
+    "rules/no-latest-tag.ts": "efd060453d8ca3d5b85c3972906c6650b6f63eb5f67cb6cdb0f16a41cad91228",
+    "rules/apt-no-recommends.ts": "579ea54435b1cbd59088994aaaf7b249a42064facd74b62163b302fe31e769e0",
+    "rules/docker-helpers.ts": "c76ea1294b630df086a23b24c0435c9daac8cdf21dd371a8aabf74e9984e6b13",
+    "rules/no-latest-image.ts": "3e49602822e0645173a961b9c0686b669e846957486781a881693dbe04790b88",
+    "rules/no-root-user.ts": "fb47adc8523e07a8307253dcffeeccd7528e655bf737ef7e313e76a3df2c9a2d",
+    "rules/prefer-copy.ts": "b422a77b94023f7356d6b6326b6552c459cfbd282468f38214e19a105a59b742",
+    "rules/ssh-port-exposed.ts": "1df86b498787cbcc5ac8995c7099956576d9d105b4da71b0c225790be585c4c9",
+    "rules/unused-volume.ts": "ffcfc731782a4443a2eb34b1c0f6230b094c18c6ad104e4b81074bb799a3ce40",
+    "skills/chant-docker.md": "3ff0708e3c76e245f202948949c768464563af2b60cc9aa2ca52f494ef8357f1",
+    "skills/chant-docker-patterns.md": "ad1b0196d8150b2df579a699ff107f604340c799c04f3460ebf65003e287b12a"
   },
-  "composite": "b35b47b51ec2e075"
+  "composite": "ff82c863447932fee4a358399636de04932adb25894772f0e0fd03941ed152d6"
 }

package/dist/manifest.json

@@ -1,6 +1,6 @@
 {
   "name": "docker",
-  "version": "0.1.4",
+  "version": "0.1.8",
   "chantVersion": ">=0.1.0",
   "namespace": "Docker",
   "intrinsics": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant-lexicon-docker",
-  "version": "0.1.4",
+  "version": "0.1.8",
   "description": "Docker lexicon for chant — declarative IaC in TypeScript",
   "license": "Apache-2.0",
   "homepage": "https://intentius.io/chant",
@@ -37,14 +37,14 @@
     "./types": "./dist/types/index.d.ts"
   },
   "scripts": {
-    "generate": "bun run src/codegen/generate-cli.ts",
-    "bundle": "bun run src/package-cli.ts",
-    "validate": "bun run src/validate-cli.ts",
-    "docs": "bun run src/codegen/docs-cli.ts",
-    "prepack": "bun run generate && bun run bundle && bun run validate"
+    "generate": "tsx src/codegen/generate-cli.ts",
+    "bundle": "tsx src/package-cli.ts",
+    "validate": "tsx src/validate-cli.ts",
+    "docs": "tsx src/codegen/docs-cli.ts",
+    "prepack": "npm run generate && npm run bundle && npm run validate"
   },
   "devDependencies": {
-    "@intentius/chant": "0.1.4",
+    "@intentius/chant": "*",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {

package/src/codegen/docs-cli.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env bun
+#!/usr/bin/env tsx
 /**
  * CLI entry for Docker lexicon docs generation.
  */

package/src/codegen/generate-cli.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env bun
+#!/usr/bin/env tsx
 /**
  * CLI entry point for Docker lexicon generation.
  */

package/src/codegen/generate.test.ts

@@ -1,15 +1,15 @@
-import { describe, test, expect, mock } from "bun:test";
+import { describe, test, expect, vi } from "vitest";
 import { generate, writeGeneratedFiles } from "./generate";
 import { mkdirSync, rmSync, existsSync, readFileSync } from "fs";
 import { join } from "path";
 import { tmpdir } from "os";
 
 // Mock the network fetches so tests run offline and fast
-mock.module("../spec/fetch-compose", () => ({
+vi.mock("../spec/fetch-compose", () => ({
   fetchComposeSpec: async () => Buffer.from("{}"),
 }));
 
-mock.module("../spec/fetch-engine", () => ({
+vi.mock("../spec/fetch-engine", () => ({
   fetchEngineApi: async () => Buffer.from("{}"),
 }));
 

package/src/codegen/naming.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import {
   entityTypeToTsName,
   tsNameToEntityType,

package/src/codegen/package.ts

@@ -2,9 +2,8 @@
  * Docker lexicon packaging — delegates to core packagePipeline.
  */
 
-import { createRequire } from "module";
 import { readFileSync } from "fs";
-const require = createRequire(import.meta.url);
+import { dockerPlugin } from "../plugin";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import type { IntrinsicDef } from "@intentius/chant/lexicon";
@@ -52,9 +51,7 @@ export async function packageLexicon(opts: PackageOptions = {}): Promise<Package
 
       srcDir: pkgDir,
 
-      collectSkills: () => {
-        const { dockerPlugin } = require("../plugin");
-        const skillDefs = dockerPlugin.skills?.() ?? [];
+      collectSkills: () => {        const skillDefs = dockerPlugin.skills?.() ?? [];
         return collectSkills(skillDefs);
       },
 

package/src/coverage.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { analyzeDockerCoverage, computeCoverage } from "./coverage";
 
 describe("analyzeDockerCoverage", () => {

package/src/default-labels.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import {
   DEFAULT_LABELS_MARKER,
   DEFAULT_ANNOTATIONS_MARKER,

package/src/import/generator.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { DockerGenerator } from "./generator";
 import type { ServiceIR, VolumeIR, NetworkIR, ConfigIR, SecretIR, DockerfileIR } from "./parser";
 

package/src/import/parser.test.ts

@@ -1,10 +1,10 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { readFileSync } from "fs";
 import { join } from "path";
 import { DockerParser, DockerfileParser } from "./parser";
 
 const testdata = (file: string) =>
-  readFileSync(join(import.meta.dir, "testdata", file), "utf8");
+  readFileSync(join(import.meta.dirname, "testdata", file), "utf8");
 
 describe("DockerParser — services", () => {
   test("image extracted correctly", () => {

package/src/import/roundtrip.test.ts

@@ -1,11 +1,11 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { readFileSync } from "fs";
 import { join } from "path";
 import { DockerParser, DockerfileParser } from "./parser";
 import { DockerGenerator } from "./generator";
 
 const testdata = (file: string) =>
-  readFileSync(join(import.meta.dir, "testdata", file), "utf8");
+  readFileSync(join(import.meta.dirname, "testdata", file), "utf8");
 
 describe("roundtrip: parse → generate", () => {
   test("simple.yaml → Service + Volume constructors", () => {

package/src/index.ts

@@ -17,7 +17,7 @@ export { defaultLabels, defaultAnnotations, isDefaultLabels, isDefaultAnnotation
 export { DEFAULT_LABELS_MARKER, DEFAULT_ANNOTATIONS_MARKER } from "./default-labels";
 export type { DefaultLabels, DefaultAnnotations } from "./default-labels";
 
-// Generated entities — populated by `bun run generate`
+// Generated entities — populated by `npm run generate`
 export * from "./generated/index";
 
 // Composites (to be added in Tier 2)

package/src/interpolation.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { env } from "./interpolation";
 import { INTRINSIC_MARKER } from "@intentius/chant/intrinsic";
 

package/src/lint/post-synth/post-synth.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import type { PostSynthContext } from "@intentius/chant/lint/post-synth";
 import { dkrd001 } from "./no-latest-image";
 import { dkrd002 } from "./unused-volume";

package/src/lint/rules/rules.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { noLatestTagRule } from "./no-latest-tag";
 import type { LintContext } from "@intentius/chant/lint/rule";
 import * as ts from "typescript";

package/src/list-artifacts.test.ts

@@ -0,0 +1,141 @@
+import { describe, test, expect, vi, beforeEach } from "vitest";
+
+const execMock = vi.fn();
+vi.mock("node:child_process", async () => {
+  const actual = await vi.importActual<typeof import("node:child_process")>("node:child_process");
+  return { ...actual, exec: (cmd: string, cb: (err: Error | null, out: { stdout: string; stderr: string }) => void) => {
+    Promise.resolve(execMock(cmd)).then(
+      (out) => cb(null, out),
+      (err) => cb(err as Error, { stdout: "", stderr: "" }),
+    );
+  } };
+});
+
+const { listArtifacts } = await import("./list-artifacts");
+
+describe("docker listArtifacts", () => {
+  beforeEach(() => {
+    execMock.mockReset();
+  });
+
+  test("happy path: containers + images + networks all reported", async () => {
+    execMock.mockImplementation((cmd: string) => {
+      if (cmd.startsWith("docker ps")) {
+        return {
+          stdout: [
+            JSON.stringify({ Names: "web", ID: "abc123", Image: "nginx:latest", State: "running", Status: "Up 5 minutes" }),
+            JSON.stringify({ Names: "db",  ID: "def456", Image: "postgres:16", State: "running", Status: "Up 2 hours" }),
+          ].join("\n"),
+          stderr: "",
+        };
+      }
+      if (cmd.startsWith("docker image ls")) {
+        return {
+          stdout: [
+            JSON.stringify({ ID: "img1", Repository: "nginx",    Tag: "latest", Size: "187MB", CreatedAt: "2026-04-01" }),
+            JSON.stringify({ ID: "img2", Repository: "postgres", Tag: "16",     Size: "412MB", CreatedAt: "2026-03-20" }),
+          ].join("\n"),
+          stderr: "",
+        };
+      }
+      if (cmd.startsWith("docker network ls")) {
+        return {
+          stdout: [
+            JSON.stringify({ ID: "net1", Name: "bridge", Driver: "bridge", Scope: "local" }),
+          ].join("\n"),
+          stderr: "",
+        };
+      }
+      throw new Error(`unexpected cmd: ${cmd}`);
+    });
+
+    const result = await listArtifacts({ environment: "prod", entities: new Map() });
+
+    expect(Object.keys(result).sort()).toEqual([
+      "container/db",
+      "container/web",
+      "image/nginx:latest",
+      "image/postgres:16",
+      "network/bridge",
+    ]);
+    expect(result["container/web"]).toMatchObject({
+      type: "Docker::Container",
+      physicalId: "abc123",
+      status: "running",
+    });
+    expect(result["image/nginx:latest"]).toMatchObject({ type: "Docker::Image", physicalId: "img1" });
+    expect(result["network/bridge"]).toMatchObject({ type: "Docker::Network", physicalId: "net1" });
+  });
+
+  test("daemon unreachable on all queries → returns {}", async () => {
+    execMock.mockImplementation(() => { throw new Error("Cannot connect to the Docker daemon"); });
+    const result = await listArtifacts({ environment: "prod", entities: new Map() });
+    expect(result).toEqual({});
+  });
+
+  test("per-query failure isolation: containers fail → still get images + networks", async () => {
+    execMock.mockImplementation((cmd: string) => {
+      if (cmd.startsWith("docker ps")) {
+        throw new Error("ps failed");
+      }
+      if (cmd.startsWith("docker image ls")) {
+        return { stdout: JSON.stringify({ ID: "img1", Repository: "alpine", Tag: "3.20", Size: "8MB" }), stderr: "" };
+      }
+      if (cmd.startsWith("docker network ls")) {
+        return { stdout: JSON.stringify({ ID: "net1", Name: "host", Driver: "host", Scope: "local" }), stderr: "" };
+      }
+      throw new Error(`unexpected cmd: ${cmd}`);
+    });
+
+    const result = await listArtifacts({ environment: "prod", entities: new Map() });
+
+    expect(Object.keys(result).filter((k) => k.startsWith("container/"))).toEqual([]);
+    expect(result["image/alpine:3.20"]).toBeDefined();
+    expect(result["network/host"]).toBeDefined();
+  });
+
+  test("container Status surfaces in attributes.fullStatus", async () => {
+    execMock.mockImplementation((cmd: string) => {
+      if (cmd.startsWith("docker ps")) {
+        return { stdout: JSON.stringify({ Names: "web", ID: "x", Image: "i", State: "running", Status: "Up 5 minutes" }), stderr: "" };
+      }
+      return { stdout: "", stderr: "" };
+    });
+    const result = await listArtifacts({ environment: "prod", entities: new Map() });
+    expect(result["container/web"].attributes).toMatchObject({ fullStatus: "Up 5 minutes" });
+  });
+
+  test("dangling images (Repository=<none>) are skipped", async () => {
+    execMock.mockImplementation((cmd: string) => {
+      if (cmd.startsWith("docker image ls")) {
+        return {
+          stdout: [
+            JSON.stringify({ ID: "img1", Repository: "<none>", Tag: "<none>", Size: "8MB" }),
+            JSON.stringify({ ID: "img2", Repository: "nginx", Tag: "latest", Size: "187MB" }),
+          ].join("\n"),
+          stderr: "",
+        };
+      }
+      return { stdout: "", stderr: "" };
+    });
+    const result = await listArtifacts({ environment: "prod", entities: new Map() });
+    expect(Object.keys(result).filter((k) => k.startsWith("image/"))).toEqual(["image/nginx:latest"]);
+  });
+
+  test("malformed NDJSON line is skipped, others still parsed", async () => {
+    execMock.mockImplementation((cmd: string) => {
+      if (cmd.startsWith("docker ps")) {
+        return {
+          stdout: [
+            "this is not json",
+            JSON.stringify({ Names: "web", ID: "x", State: "running", Status: "Up", Image: "i" }),
+          ].join("\n"),
+          stderr: "",
+        };
+      }
+      return { stdout: "", stderr: "" };
+    });
+    const result = await listArtifacts({ environment: "prod", entities: new Map() });
+    expect(result["container/web"]).toBeDefined();
+  });
+});

package/src/list-artifacts.ts

@@ -0,0 +1,164 @@
+/**
+ * Live introspection of a Docker host via three independent CLI queries.
+ *
+ * The Docker lexicon's chant entities describe Compose / Dockerfile
+ * authoring primitives. The runtime concept (running containers, local
+ * images, networks) is created by `docker compose up` / `docker run` /
+ * `docker network create` outside chant's entity model.
+ *
+ *   docker ps         --format '{{json .}}'  → running containers
+ *   docker image ls   --format '{{json .}}'  → local images
+ *   docker network ls --format '{{json .}}'  → networks
+ *
+ * Output is one JSON object per line (NDJSON), not a JSON array. Daemon
+ * unreachable on any query → that query returns nothing; other queries
+ * still proceed.
+ */
+
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import type { ArtifactMetadata } from "@intentius/chant/lexicon";
+
+const execAsync = promisify(exec);
+
+interface DockerContainer {
+  Names?: string;
+  ID?: string;
+  Image?: string;
+  Command?: string;
+  State?: string;        // "running" | "exited" | "created" | ...
+  Status?: string;       // "Up 5 minutes" | "Exited (0) 1 hour ago" | ...
+  Ports?: string;
+  Mounts?: string;
+}
+
+interface DockerImage {
+  ID?: string;
+  Repository?: string;
+  Tag?: string;
+  CreatedAt?: string;
+  Size?: string;
+}
+
+interface DockerNetwork {
+  ID?: string;
+  Name?: string;
+  Driver?: string;
+  Scope?: string;
+  CreatedAt?: string;
+}
+
+function parseNdjson<T>(stdout: string): T[] {
+  const out: T[] = [];
+  for (const line of stdout.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      out.push(JSON.parse(trimmed));
+    } catch {
+      // skip malformed lines
+    }
+  }
+  return out;
+}
+
+function pruneUndefined<T extends Record<string, unknown>>(obj: T): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (v !== undefined && v !== "") out[k] = v;
+  }
+  return out;
+}
+
+async function listContainers(): Promise<Record<string, ArtifactMetadata>> {
+  const result: Record<string, ArtifactMetadata> = {};
+  try {
+    const { stdout } = await execAsync("docker ps --format '{{json .}}'");
+    const containers = parseNdjson<DockerContainer>(stdout);
+    for (const c of containers) {
+      const name = c.Names;
+      if (!name) continue;
+      result[`container/${name}`] = {
+        type: "Docker::Container",
+        physicalId: c.ID,
+        status: c.State ?? c.Status ?? "PRESENT",
+        attributes: pruneUndefined({
+          image: c.Image,
+          command: c.Command,
+          ports: c.Ports,
+          mounts: c.Mounts,
+          fullStatus: c.Status,
+        }),
+      };
+    }
+  } catch {
+    // Docker daemon unreachable — return empty, don't fail the lexicon
+  }
+  return result;
+}
+
+async function listImages(): Promise<Record<string, ArtifactMetadata>> {
+  const result: Record<string, ArtifactMetadata> = {};
+  try {
+    const { stdout } = await execAsync("docker image ls --format '{{json .}}'");
+    const images = parseNdjson<DockerImage>(stdout);
+    for (const img of images) {
+      if (!img.Repository || img.Repository === "<none>") continue;
+      const tag = img.Tag && img.Tag !== "<none>" ? img.Tag : "latest";
+      const key = `image/${img.Repository}:${tag}`;
+      result[key] = {
+        type: "Docker::Image",
+        physicalId: img.ID,
+        status: "PRESENT",
+        lastUpdated: img.CreatedAt,
+        attributes: pruneUndefined({
+          repository: img.Repository,
+          tag,
+          size: img.Size,
+        }),
+      };
+    }
+  } catch {
+    // Docker daemon unreachable
+  }
+  return result;
+}
+
+async function listNetworks(): Promise<Record<string, ArtifactMetadata>> {
+  const result: Record<string, ArtifactMetadata> = {};
+  try {
+    const { stdout } = await execAsync("docker network ls --format '{{json .}}'");
+    const networks = parseNdjson<DockerNetwork>(stdout);
+    for (const net of networks) {
+      const name = net.Name;
+      if (!name) continue;
+      result[`network/${name}`] = {
+        type: "Docker::Network",
+        physicalId: net.ID,
+        status: "PRESENT",
+        lastUpdated: net.CreatedAt,
+        attributes: pruneUndefined({
+          driver: net.Driver,
+          scope: net.Scope,
+        }),
+      };
+    }
+  } catch {
+    // Docker daemon unreachable
+  }
+  return result;
+}
+
+export async function listArtifacts(_options: {
+  environment: string;
+  entities: Map<string, { entityType: string; props: Record<string, unknown> }>;
+}): Promise<Record<string, ArtifactMetadata>> {
+  // Three independent queries — failure of one doesn't block the others.
+  const [containers, images, networks] = await Promise.all([
+    listContainers(),
+    listImages(),
+    listNetworks(),
+  ]);
+
+  return { ...containers, ...images, ...networks };
+}

package/src/lsp/completions.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { dockerCompletions } from "./completions";
 import type { CompletionContext } from "@intentius/chant/lsp/types";
 

package/src/lsp/hover.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { dockerHover } from "./hover";
 import type { HoverContext } from "@intentius/chant/lsp/types";
 

package/src/package-cli.ts

@@ -1,6 +1,6 @@
-#!/usr/bin/env bun
+#!/usr/bin/env tsx
 /**
- * Thin entry point for `bun run bundle` in lexicon-docker.
+ * Thin entry point for `npm run bundle` in lexicon-docker.
  */
 import { generate, writeGeneratedFiles } from "./codegen/generate";
 import { packageLexicon } from "./codegen/package";

package/src/plugin.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { dockerPlugin } from "./plugin";
 
 describe("dockerPlugin", () => {
@@ -105,13 +105,13 @@ describe("dockerPlugin", () => {
   test("provides MCP tools", () => {
     const tools = dockerPlugin.mcpTools!();
     expect(tools.length).toBe(1);
-    expect(tools[0].name).toBe("diff");
+    expect(tools[0].name).toBe("docker:diff");
   });
 
   test("provides MCP resources", () => {
     const resources = dockerPlugin.mcpResources!();
     expect(resources.length).toBe(2);
-    expect(resources[0].uri).toBe("resource-catalog");
+    expect(resources[0].uri).toBe("docker:resource-catalog");
     expect(resources[1].uri).toBe("examples/basic-app");
   });
 });

package/src/plugin.ts

@@ -5,22 +5,24 @@
  * and code generation for Docker Compose and Dockerfile resources.
  */
 
-import { createRequire } from "module";
 import type { LexiconPlugin, IntrinsicDef, InitTemplateSet } from "@intentius/chant/lexicon";
-const require = createRequire(import.meta.url);
 import type { LintRule } from "@intentius/chant/lint/rule";
 import { discoverPostSynthChecks } from "@intentius/chant/lint/discover";
 import { createSkillsLoader, createDiffTool, createCatalogResource } from "@intentius/chant/lexicon-plugin-helpers";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import { dockerSerializer } from "./serializer";
+import { noLatestTagRule } from "./lint/rules/no-latest-tag";
+import { dockerCompletions } from "./lsp/completions";
+import { dockerHover } from "./lsp/hover";
+import { DockerParser } from "./import/parser";
+import { DockerGenerator } from "./import/generator";
 
 export const dockerPlugin: LexiconPlugin = {
   name: "docker",
   serializer: dockerSerializer,
 
   lintRules(): LintRule[] {
-    const { noLatestTagRule } = require("./lint/rules/no-latest-tag");
     return [noLatestTagRule];
   },
 
@@ -94,22 +96,18 @@ export const api = new Service({
   },
 
   completionProvider(ctx: import("@intentius/chant/lsp/types").CompletionContext) {
-    const { dockerCompletions } = require("./lsp/completions");
     return dockerCompletions(ctx);
   },
 
   hoverProvider(ctx: import("@intentius/chant/lsp/types").HoverContext) {
-    const { dockerHover } = require("./lsp/hover");
     return dockerHover(ctx);
   },
 
   templateParser() {
-    const { DockerParser } = require("./import/parser");
     return new DockerParser();
   },
 
   templateGenerator() {
-    const { DockerGenerator } = require("./import/generator");
     return new DockerGenerator();
   },
 
@@ -161,12 +159,12 @@ export const api = new Service({
   },
 
   mcpTools() {
-    return [createDiffTool(dockerSerializer, "Compare current build output against previous output for Docker Compose")];
+    return [createDiffTool(dockerSerializer, "Compare current build output against previous output for Docker Compose", "docker")];
   },
 
   mcpResources() {
     return [
-      createCatalogResource(import.meta.url, "Docker Entity Catalog", "JSON list of all supported Docker entity types", "lexicon-docker.json"),
+      createCatalogResource(import.meta.url, "Docker Entity Catalog", "JSON list of all supported Docker entity types", "lexicon-docker.json", "docker"),
       {
         uri: "examples/basic-app",
         name: "Basic App Example",
@@ -247,4 +245,9 @@ export const api = new Service({
       ],
     },
   ]),
+
+  async listArtifacts(options) {
+    const { listArtifacts } = await import("./list-artifacts");
+    return listArtifacts(options);
+  },
 };

package/src/serializer.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { dockerSerializer } from "./serializer";
 import { DECLARABLE_MARKER, type Declarable } from "@intentius/chant/declarable";
 import { INTRINSIC_MARKER } from "@intentius/chant/intrinsic";

package/src/validate-cli.ts

@@ -1,6 +1,6 @@
-#!/usr/bin/env bun
+#!/usr/bin/env tsx
 /**
- * Thin entry point for `bun run validate` in lexicon-docker.
+ * Thin entry point for `npm run validate` in lexicon-docker.
  */
 import { validate } from "./validate";
 

package/src/validate.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { validate } from "./validate";
 
 describe("validate", () => {

package/src/variables.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { DOCKER_VARS, COMPOSE_VARS } from "./variables";
 
 describe("DOCKER_VARS", () => {