bc-atlas 0.13.0 → 0.15.0

package/CHANGELOG.md

@@ -4,6 +4,38 @@ All notable changes to BC Atlas will be documented here. The format is based on
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the project
 follows [Semantic Versioning](https://semver.org/).
 
+## 0.15.0 - 2026-11-05
+
+### Added
+
+- Saved graphs are a reusable platform: analyze once, query repeatedly, and
+  render for a specific use case without re-analyzing AL.
+- `bca graph query` and the MCP tool `bc_atlas_graph_query` select roots,
+  named root groups, traversal depth, dependency or caller direction,
+  relation kinds, graph levels, and temporal presence frames. Native Atlas
+  graphs and version 1 nodes/edges snapshots retain their original IDs,
+  evidence, unresolved boundaries, and metadata in reusable JSON slices.
+- `bca graph render` and `bc_atlas_graph_render` write SVG, self-contained
+  static HTML, Graphviz DOT, or JSON. SVG and HTML use the existing local
+  renderer without requiring Graphviz; roots are highlighted and every
+  selected node and edge is retained.
+- Graph validation rejects unsupported versions, invalid roots, and missing
+  endpoints, prevents overwriting the input, and rejects oversized visual
+  selections explicitly rather than truncating dependencies.
+
+## 0.14.0 - 2026-11-05
+
+### Added
+
+- A root `.mcp.json` starts BC Atlas from the local checkout for direct MCP
+  tool calls in Copilot-compatible hosts. The MCP integration test uses the
+  same configuration, and the agent guide explains setup and server approval.
+
+### Fixed
+
+- Git-history analysis waits for its `git cat-file` reader to exit before
+  removing temporary snapshots, avoiding file-lock failures on Windows.
+
 ## 0.13.0 - 2026-11-04
 
 ### Added

package/README.md

@@ -41,10 +41,12 @@ In VS Code, install the **BC Atlas** extension and open an AL project:
 | **Get started** | `bca setup` | Guided setup in the terminal or through your AI agent (Claude Code, Copilot, Cursor): a starter `.bca.json`, features, Husky or Git hooks, GitHub Actions or Azure Pipelines, cron schedule, and sync. |
 | **Analyze** | `bca check` | Health findings - cycles, forbidden dependencies, architecture violations, hot spots, diagnostics, and AL compiler and CodeCop/UICop/AppSourceCop findings - with a CI exit code, also as SARIF for code scanning. |
 | | `bca architecture` | Find a target architecture (components, layers), list every dependency that blocks it with how to resolve it, and enforce it with a shrinking baseline. [Guide](./docs/clean-architecture.md) |
+| | `bca graph query` | Reuse a saved graph for impact analysis or message migrations without re-analyzing AL; keep IDs, directions, evidence, and metadata. [Guide](./docs/dependency-explorer.md#query-and-render-saved-graphs) |
 | **Export** | `bca export` | Everything the extension shows, as files: the BC Atlas pages as one offline HTML file to share (default), the Markdown report ([example](./examples/report/README.md)), the 3D explorer, one Markdown page per object, any of ten diagram views as D2, SVG, PNG, PDF, or JSON, with `--watch`, and the project as a knowledge graph in RDF with an OWL ontology ([Turtle, RDF/XML, OWL, N-Triples, JSON-LD](./docs/knowledge-graph.md)). |
 | | `bca docs` | User guides and test cases from AL UI tests (`[SCENARIO]`, `[GIVEN]`, `[WHEN]`, `[THEN]`) as Markdown, HTML, DITA 1.3, or Azure DevOps CSV, with real captions and translations, a flow diagram per scenario, and BPMN 2.0 processes per use case. [Example](./examples/docs/index.md) |
+| | `bca graph render` | Render saved graph selections as SVG, static HTML, DOT, or JSON through the CLI or MCP, locally and without Graphviz. |
 | **Integrate** | `bca run` | One entry point for Git hooks, schedules, and pipelines; verifies, stages, or publishes generated files. Also available as a [GitHub Action](./docs/automation-and-ci.md#github-actions). |
-| | `bca update` | "BC Atlas 0.14.0 is available": release notes, one-step update, and regenerated hooks, tasks, and pipelines. Dependabot pull requests on request. |
+| | `bca update` | "BC Atlas 0.15.0 is available": release notes, one-step update, and regenerated hooks, tasks, and pipelines. Dependabot pull requests on request. |
 | | `bca mcp` | A Model Context Protocol server for AI agents; `bca help --format json` is the versioned command contract. |
 
 Run `bca` for the same overview in your terminal and `bca help <command>` for

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bc-atlas",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "description": "BC Atlas maps Microsoft Dynamics 365 Business Central AL projects: architecture diagrams, health checks, reports, and documentation generated from source.",
   "homepage": "https://github.com/SchulzOli/BC-Atlas#readme",
   "bugs": {

package/src/capabilities.js

@@ -140,6 +140,16 @@ const pathsOption = string("Only analyze AL files in this folder or matching thi
   value: "path"
 });
 
+const graphOptions = {
+  root: string("Exact node ID, label, or Atlas key; repeat for multiple roots.", { group: FILTERS, repeatable: true, value: "selector" }),
+  rootGroup: string("Named root group in the saved graph, e.g. legacy.", { group: FILTERS, value: "name" }),
+  depth: string("Traversal depth; 0 selects only roots. Without roots the entire graph is returned.", { group: FILTERS, value: "n", default: "1" }),
+  direction: string("Follow dependencies, callers, or both; edge directions remain unchanged.", { group: FILTERS, enum: ["outgoing", "incoming", "both"], default: "outgoing" }),
+  kind: string("Traverse edges containing this relation kind; aggregated evidence stays intact.", { group: FILTERS, repeatable: true, value: "kind" }),
+  level: string("Temporal graph level: object, app, module, or component.", { group: FILTERS, value: "name", default: "object" }),
+  frame: string("Temporal presence frame index (default: latest); labels/evidence reflect the saved document.", { group: FILTERS, value: "n" })
+};
+
 const exportOptions = {
   view: string("What to write: app, report, explorer, catalog, or a diagram view.", {
     group: OUTPUT,
@@ -345,6 +355,42 @@ export function createCapabilities(version) {
           "bca check ./app --format markdown -o health.md"
         ]
       }),
+      command({
+        id: "graph.query",
+        area: "analyze",
+        argv: ["bca", "graph", "query", "<graph.json>"],
+        purpose: "Query a saved Atlas graph or nodes/edges snapshot without analyzing AL; retain IDs and evidence as reusable JSON.",
+        options: {
+          ...graphOptions,
+          output: string("Write the reusable graph slice to this file; otherwise JSON goes to stdout.", { group: OUTPUT, value: "path", short: "o" })
+        },
+        output: { type: "json", schema: "bc-atlas.graph.slice" },
+        rules: ["Input must be a version 1 graph with valid nodes and edges; output never overwrites the input.", "Depth limits traversal, not an induced subgraph: only edges visited from expanded roots are retained."],
+        examples: [
+          "bca graph query graph.json --root-group legacy --depth 2 -o orders.json",
+          "bca graph query graph.json --root \"Sales-Post\" --direction incoming"
+        ]
+      }),
+      command({
+        id: "graph.render",
+        area: "export",
+        argv: ["bca", "graph", "render", "<graph.json>"],
+        purpose: "Render a saved graph selection as local SVG/HTML, Graphviz DOT, or reusable JSON without analyzing AL.",
+        options: {
+          ...graphOptions,
+          output: string("Output file; its extension selects the format when --format is omitted.", { group: OUTPUT, value: "path", short: "o", default: "bc-atlas-graph.svg" }),
+          format: string("Output format.", { group: OUTPUT, enum: ["json", "dot", "svg", "html"], short: "f" }),
+          title: string("Graph title.", { group: OUTPUT, value: "text" }),
+          maxNodes: string("SVG/HTML node limit; oversized selections fail explicitly instead of being truncated.", { group: RENDERING, value: "n", default: "1500" }),
+          maxEdges: string("SVG/HTML edge limit.", { group: RENDERING, value: "n", default: "5000" })
+        },
+        output: { type: "file", pathOption: "output" },
+        rules: ["SVG and HTML use the built-in local renderer; Graphviz is not required.", "Roots are blue, unresolved boundaries orange; every selected edge keeps its original direction."],
+        examples: [
+          "bca graph render graph.json --root-group legacy -o orders.svg",
+          "bca graph render orders.json -o orders.html"
+        ]
+      }),
       command({
         id: "architecture",
         area: "analyze",

package/src/cli/help.js

@@ -33,6 +33,7 @@ const SHORT = {
   architecture: "Find a target architecture, resolve what stands in its way, and enforce it with a baseline",
   refactor: "Move objects between components, lock a component's public surface (move, surface)",
   export: "Write files: the pages as one offline HTML file, report, explorer, catalog, or one diagram",
+  graph: "Query and render saved graphs without analyzing AL (query, render)",
   run: "Run the features configured for a Git hook, pipeline, or schedule",
   update: "Update BC Atlas together with the generated setup files",
   mcp: "Start the Model Context Protocol server for AI agents"

package/src/cli.js

@@ -9,6 +9,7 @@ import { checkCommand } from "./commands/check.js";
 import { architectureCommand } from "./commands/blueprint.js";
 import { refactorMoveCommand, refactorSurfaceCommand } from "./commands/refactor.js";
 import { exportCommand } from "./commands/export.js";
+import { graphQueryCommand, graphRenderCommand } from "./commands/graph.js";
 import { runCommand } from "./commands/run.js";
 import { updateCommand } from "./commands/update.js";
 import { maybeNotifyUpdate } from "./update.js";
@@ -33,6 +34,8 @@ const HANDLERS = {
   "refactor.move": refactorMoveCommand,
   "refactor.surface": refactorSurfaceCommand,
   export: exportCommand,
+  "graph.query": graphQueryCommand,
+  "graph.render": graphRenderCommand,
   run: runCommand,
   update: updateCommand,
   mcp: mcpCommand,
@@ -61,6 +64,11 @@ function resolveCommand(args) {
     return { id, args: rest };
   }
   if (first === "setup" && findCommand(capabilities, `setup.${second}`)) return { id: `setup.${second}`, args: rest };
+  if (first === "graph") {
+    if (findCommand(capabilities, `graph.${second}`)) return { id: `graph.${second}`, args: rest };
+    if (!second || ["-h", "--help", "help"].includes(second)) return { id: "graph.query", args: ["--help"] };
+    throw new UsageError(`unknown graph command "${second}"; use "bca graph query" or "bca graph render"`);
+  }
   if (first === "refactor") {
     if (findCommand(capabilities, `refactor.${second}`)) return { id: `refactor.${second}`, args: rest };
     if (["-h", "--help", "help"].includes(second)) return { id: "refactor.move", args: ["--help"] };

package/src/commands/graph.js

@@ -0,0 +1,13 @@
+import { renderGraph, writeGraphQuery } from "../graph/platform.js";
+import { displayPath } from "../output.js";
+
+export async function graphQueryCommand(input, values) {
+  const { graph, file } = await writeGraphQuery(input, values);
+  if (file) console.error(`Wrote ${displayPath(file)} (${graph.nodes.length} nodes, ${graph.edges.length} edges)`);
+  else process.stdout.write(`${JSON.stringify(graph, null, 2)}\n`);
+}
+
+export async function graphRenderCommand(input, values) {
+  const result = await renderGraph(input, values);
+  console.log(`Wrote ${displayPath(result.output)} (${result.nodes} nodes, ${result.edges} edges)`);
+}

package/src/graph/history.js

@@ -76,7 +76,14 @@ function blobReader(cwd) {
       });
     },
     close() {
-      child.stdin.end();
+      return new Promise((resolve, reject) => {
+        child.once("error", reject);
+        child.once("close", (code) => {
+          if (code === 0) resolve();
+          else reject(new Error(`git cat-file --batch exited with code ${code}`));
+        });
+        child.stdin.end();
+      });
     }
   };
 }
@@ -273,8 +280,11 @@ export async function replayHistory(projectRoot, { by = "commits", maxCommits =
       previous = commit;
     }
   } finally {
-    reader.close();
-    await fs.rm(directory, { recursive: true, force: true });
+    try {
+      await reader.close();
+    } finally {
+      await fs.rm(directory, { recursive: true, force: true });
+    }
   }
 
   const dirty = git(repository, ["status", "--porcelain", "-z", "--untracked-files=all"])

package/src/graph/platform.js

@@ -0,0 +1,217 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { MAX_DIAGRAM_NODES, renderScene } from "../diagram/index.js";
+
+export const GRAPH_RENDER_FORMATS = Object.freeze(["json", "dot", "svg", "html"]);
+const SLICE_SCHEMA = "bc-atlas.graph.slice";
+
+function integer(value, name, fallback) {
+  const number = value === undefined ? fallback : Number(value);
+  if (!Number.isSafeInteger(number) || number < 0 || value === "") {
+    throw new Error(`${name} must be a nonnegative integer`);
+  }
+  return number;
+}
+
+function validateGraph(graph) {
+  if (!Array.isArray(graph?.nodes) || !Array.isArray(graph?.edges) || !graph.nodes.length) {
+    throw new Error("graph must contain a nonempty nodes array and an edges array");
+  }
+  const ids = new Set();
+  for (const node of graph.nodes) {
+    if (!node || typeof node.id !== "string" || !node.id || typeof node.label !== "string" || ids.has(node.id)) {
+      throw new Error(`invalid or duplicate graph node: ${node?.id}`);
+    }
+    ids.add(node.id);
+  }
+  const edgeIds = new Set();
+  for (const edge of graph.edges) {
+    if (!edge || typeof edge.id !== "string" || !edge.id || edgeIds.has(edge.id) || !ids.has(edge.source) || !ids.has(edge.target)) {
+      throw new Error(`invalid graph edge or missing endpoint: ${edge?.id}`);
+    }
+    edgeIds.add(edge.id);
+  }
+}
+
+/** Loads a saved Atlas graph or a nodes/edges snapshot, without reading AL. */
+export async function queryGraph(input, values = {}) {
+  const document = JSON.parse(await fs.readFile(input, "utf8"));
+  if (!document || document.schemaVersion !== 1 || (document.schema && !["bc-atlas.graph", SLICE_SCHEMA].includes(document.schema))) {
+    throw new Error("unsupported graph schema; expected version 1 of bc-atlas.graph or a nodes/edges snapshot");
+  }
+  const level = values.level ?? "object";
+  let graph = document;
+  let frame;
+  if (document.schema === "bc-atlas.graph") {
+    graph = document.levels?.[level];
+    if (!graph) throw new Error(`unknown graph level: ${level}`);
+    const frames = document.timeline?.frames;
+    if (!Array.isArray(frames) || !frames.length) throw new Error("graph timeline must contain frames");
+    frame = integer(values.frame, "frame", frames.length - 1);
+    if (frame >= frames.length) throw new Error(`frame must be between 0 and ${frames.length - 1}`);
+    validateGraph(graph);
+    const present = (item) => {
+      if (!Array.isArray(item.presence) || item.presence.some((span) =>
+        !Array.isArray(span) || span.length !== 2 || !Number.isInteger(span[0]) || span[0] < 0 ||
+        (span[1] !== null && (!Number.isInteger(span[1]) || span[1] <= span[0]))
+      )) throw new Error(`invalid presence spans for ${item.id}`);
+      return item.presence.some(([start, end]) => start <= frame && (end === null || frame < end));
+    };
+    graph = { nodes: graph.nodes.filter(present), edges: graph.edges.filter(present) };
+  } else if (values.frame !== undefined || (values.level !== undefined && values.level !== "object")) {
+    throw new Error("frame and non-object level selections require a temporal bc-atlas.graph document");
+  }
+  validateGraph(graph);
+  const roots = new Set();
+  const selectors = values.root === undefined ? [] : [values.root].flat();
+  const rootGroups = document.roots ?? {};
+  if (typeof rootGroups !== "object" || Array.isArray(rootGroups) || Object.values(rootGroups).some((ids) =>
+    !Array.isArray(ids) || ids.some((id) => typeof id !== "string" || !id)
+  )) throw new Error("invalid graph root groups; expected named arrays of node IDs");
+  if (document.schema === SLICE_SCHEMA && (!Array.isArray(document.selection?.roots) ||
+    document.selection.roots.some((id) => !graph.nodes.some((node) => node.id === id))
+  )) throw new Error("invalid graph slice selection roots");
+  if (values.rootGroup !== undefined) {
+    const group = rootGroups[values.rootGroup];
+    if (!Array.isArray(group) || !group.length) throw new Error(`unknown or empty root group: ${values.rootGroup}`);
+    selectors.push(...group);
+  }
+  for (const selector of selectors) {
+    const exact = graph.nodes.find(({ id }) => id === selector);
+    const matches = exact ? [exact] : graph.nodes.filter(({ label, atlasKey }) => label === selector || atlasKey === selector);
+    if (matches.length !== 1) throw new Error(`root "${selector}" is ${matches.length ? "ambiguous; use a node ID" : "not present in the selected graph"}`);
+    roots.add(matches[0].id);
+  }
+  const depth = integer(values.depth, "depth", 1);
+  const direction = values.direction ?? "outgoing";
+  if (!["outgoing", "incoming", "both"].includes(direction)) throw new Error(`unsupported graph direction: ${direction}`);
+  const kinds = values.kind === undefined ? [] : [values.kind].flat();
+  const edges = graph.edges.filter((edge) => !kinds.length || kinds.some((kind) =>
+    Object.hasOwn(edge.kinds ?? {}, kind) || edge.kind === kind
+  ));
+  const selected = new Set(roots);
+  const selectedEdges = new Set();
+  if (roots.size) {
+    const adjacency = new Map(graph.nodes.map(({ id }) => [id, []]));
+    for (const edge of edges) {
+      if (direction !== "incoming") adjacency.get(edge.source).push([edge, edge.target]);
+      if (direction !== "outgoing") adjacency.get(edge.target).push([edge, edge.source]);
+    }
+    let frontier = [...roots];
+    for (let step = 0; step < depth && frontier.length; step++) {
+      const next = [];
+      for (const id of frontier) {
+        for (const [edge, neighbor] of adjacency.get(id)) {
+          selectedEdges.add(edge.id);
+          if (!selected.has(neighbor)) {
+            selected.add(neighbor);
+            next.push(neighbor);
+          }
+        }
+      }
+      frontier = next;
+    }
+  }
+  const nodes = roots.size ? graph.nodes.filter(({ id }) => selected.has(id)) : graph.nodes;
+  const nodeIds = new Set(nodes.map(({ id }) => id));
+  const { nodes: _nodes, edges: _edges, levels: _levels, roots: _roots, selection: _selection, ...metadata } = document;
+  return {
+    schema: SLICE_SCHEMA,
+    schemaVersion: 1,
+    metadata: document.schema === SLICE_SCHEMA ? document.metadata : metadata,
+    roots: Object.fromEntries(Object.entries(rootGroups).map(([name, ids]) => [name, ids.filter((id) => nodeIds.has(id))])),
+    selection: document.schema === SLICE_SCHEMA && !roots.size
+      ? { ...document.selection, ...(values.kind === undefined ? {} : { kinds }) }
+      : { level, ...(frame === undefined ? {} : { frame }), roots: [...roots], depth, direction, kinds },
+    nodes,
+    edges: roots.size ? edges.filter(({ id }) => selectedEdges.has(id)) : edges
+  };
+}
+
+async function writeGraphFile(input, output, content) {
+  const source = await fs.realpath(input);
+  let destination = path.resolve(output);
+  try {
+    destination = await fs.realpath(destination);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  if (process.platform === "win32" ? source.toLowerCase() === destination.toLowerCase() : source === destination) {
+    throw new Error("graph output must not overwrite the input graph");
+  }
+  await fs.mkdir(path.dirname(destination), { recursive: true });
+  await fs.writeFile(destination, content);
+  return destination;
+}
+
+export async function writeGraphQuery(input, values = {}) {
+  const graph = await queryGraph(input, values);
+  const file = values.output ? await writeGraphFile(input, values.output, `${JSON.stringify(graph, null, 2)}\n`) : undefined;
+  return { graph, file };
+}
+
+const quote = (value) => JSON.stringify(String(value));
+const edgeLabel = (edge) => Object.keys(edge.kinds ?? {}).join(", ") || edge.kind || "dependency";
+const nodeLabel = (node) => [node.type && `${node.type}${node.objectId ? ` ${node.objectId}` : ""}`, node.label].filter(Boolean).join("\n");
+const fill = (node, roots) => roots.has(node.id) ? "#dbeafe" : node.origin === "unresolved" ? "#ffedd5" : "#f1f5f9";
+
+function graphDot(graph, title) {
+  const roots = new Set(graph.selection.roots);
+  return [
+    "digraph BCAtlas {",
+    `graph [rankdir=LR, label=${quote(title)}, labelloc=t];`,
+    'node [shape=box, style="rounded,filled"];',
+    ...graph.nodes.map((node) => `${quote(node.id)} [label=${quote(nodeLabel(node))}, fillcolor=${quote(fill(node, roots))}];`),
+    ...graph.edges.map((edge) => `${quote(edge.source)} -> ${quote(edge.target)} [label=${quote(edgeLabel(edge))}];`),
+    "}", ""
+  ].join("\n");
+}
+
+function graphScene(graph, title) {
+  const roots = new Set(graph.selection.roots);
+  const paths = new Map(graph.nodes.map(({ id }, index) => [id, `g0.n${index}`]));
+  return {
+    title, direction: "right", omitted: 0, maxEdges: graph.edges.length,
+    groups: [{
+      key: "g0", label: "Roots: blue | Unresolved boundaries: orange", dash: 3,
+      nodes: graph.nodes.map((node, index) => ({
+        key: `n${index}`, path: paths.get(node.id), object: node.id, type: node.type,
+        label: nodeLabel(node), fill: fill(node, roots), stroke: "#64748b",
+        tooltip: [node.id, node.file, node.line, node.origin].filter((value) => value !== undefined).join("\n")
+      }))
+    }],
+    edges: graph.edges.map((edge) => ({
+      from: paths.get(edge.source), to: paths.get(edge.target), kind: edgeLabel(edge),
+      arrow: "->", label: edgeLabel(edge), color: edge.inCycle ? "#b91c1c" : "#64748b",
+      tooltip: [edge.id, edge.evidenceSampled ? "Evidence sampled" : "", JSON.stringify(edge.evidence ?? [])].filter(Boolean).join("\n")
+    }))
+  };
+}
+
+/** Renders a query result using Atlas's local SVG renderer, or portable JSON/DOT. */
+export async function renderGraph(input, values = {}) {
+  const requested = path.resolve(values.output ?? "bc-atlas-graph.svg");
+  const extension = path.extname(requested).slice(1).toLowerCase();
+  const format = values.format ?? (extension || "svg");
+  if (!GRAPH_RENDER_FORMATS.includes(format)) throw new Error(`unsupported graph format: ${format}`);
+  const output = extension === format ? requested
+    : `${GRAPH_RENDER_FORMATS.includes(extension) ? requested.slice(0, -extension.length - 1) : requested}.${format}`;
+  const graph = await queryGraph(input, values);
+  const title = values.title ?? "BC Atlas graph";
+  let content;
+  if (format === "json") content = `${JSON.stringify(graph, null, 2)}\n`;
+  else if (format === "dot") content = graphDot(graph, title);
+  else {
+    const maxNodes = integer(values.maxNodes, "max-nodes", MAX_DIAGRAM_NODES);
+    const maxEdges = integer(values.maxEdges, "max-edges", 5000);
+    if (graph.nodes.length > maxNodes || graph.edges.length > maxEdges) {
+      throw new Error(`graph has ${graph.nodes.length} nodes and ${graph.edges.length} edges; focus it with graph query/root/depth or raise max-nodes/max-edges`);
+    }
+    const svg = await renderScene(graphScene(graph, title), "svg");
+    const escape = (value) => String(value).replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+    content = format === "svg" ? svg
+      : `<!doctype html>\n<html lang="en"><meta charset="utf-8"><title>${escape(title)}</title><body>${svg}</body></html>\n`;
+  }
+  const file = await writeGraphFile(input, output, content);
+  return { output: file, format, nodes: graph.nodes.length, edges: graph.edges.length, roots: graph.selection.roots.length };
+}

package/src/mcp.js

@@ -17,6 +17,7 @@ import { runAutomation } from "./automation/run.js";
 import { applySetup, createPlan } from "./automation/setup.js";
 import { checkForUpdate } from "./commands/update.js";
 import { writeExplorer } from "./commands/explore.js";
+import { queryGraph, renderGraph } from "./graph/platform.js";
 import { assessArchitecture } from "./blueprint/index.js";
 import { architectureJson } from "./blueprint/report.js";
 import { planExtraction } from "./blueprint/extract.js";
@@ -125,6 +126,17 @@ const projectFields = {
   compilerLog: z.string().optional().describe("Import diagnostics from an AL compiler error log file or folder")
 };
 
+const graphFields = {
+  path: z.string().min(1).describe("Saved version 1 Atlas graph or nodes/edges JSON file; no AL analysis is performed"),
+  root: z.array(z.string().min(1)).optional().describe("Exact node IDs, labels, or Atlas keys"),
+  rootGroup: z.string().min(1).optional().describe("Named root group in the saved graph"),
+  depth: z.number().int().nonnegative().optional(),
+  direction: z.enum(["outgoing", "incoming", "both"]).optional(),
+  kind: z.array(z.string().min(1)).optional(),
+  level: z.string().min(1).optional(),
+  frame: z.number().int().nonnegative().optional()
+};
+
 export function createMcpServer(version = pkg.version) {
   const server = new McpServer({ name: "bc-atlas", version });
 
@@ -140,6 +152,25 @@ export function createMcpServer(version = pkg.version) {
     annotations: { readOnlyHint: true, idempotentHint: true }
   }, tool(async (args) => (await createArchitectureModel(args.path, architectureOptions(args))).model));
 
+  server.registerTool("bc_atlas_graph_query", {
+    description: "Query a saved graph without analyzing AL. Return a reusable graph slice with original IDs, directions, unresolved boundaries and evidence; select roots, relation kinds, traversal depth and temporal presence.",
+    inputSchema: z.object(graphFields),
+    annotations: { readOnlyHint: true, idempotentHint: true }
+  }, tool(async ({ path: input, ...values }) => queryGraph(input, values)));
+
+  server.registerTool("bc_atlas_graph_render", {
+    description: "Render a saved graph query as self-contained SVG/HTML, DOT, or JSON using the local Atlas renderer. No Graphviz installation or AL analysis is required.",
+    inputSchema: z.object({
+      ...graphFields,
+      output: z.string().min(1),
+      format: z.enum(["json", "dot", "svg", "html"]).optional(),
+      title: z.string().optional(),
+      maxNodes: z.number().int().nonnegative().optional(),
+      maxEdges: z.number().int().nonnegative().optional()
+    }),
+    annotations: { idempotentHint: true }
+  }, tool(async ({ path: input, ...values }) => renderGraph(input, values)));
+
   server.registerTool("bc_atlas_generate_diagram", {
     description: "Analyze AL source and write a D2, JSON, or SVG architecture file.",
     inputSchema: z.object({