@sightmap/mcp 0.2.0

package/dist/cli.js

@@ -0,0 +1,1361 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/loadMerged.ts
+var loadMerged_exports = {};
+__export(loadMerged_exports, {
+  mergeSightmaps: () => mergeSightmaps
+});
+import { loadDirectory } from "@sightmap/sightmap";
+async function mergeSightmaps(dirs) {
+  if (dirs.length === 0) {
+    return {
+      version: 1,
+      views: [],
+      globalComponents: [],
+      globalRequests: [],
+      fileMemory: [],
+      diagnostics: [],
+      __brand: "Sightmap"
+    };
+  }
+  const loaded = await Promise.all(dirs.map((d) => loadDirectory(d)));
+  if (loaded.length === 1) return loaded[0];
+  const head = loaded[0];
+  return {
+    ...head,
+    views: loaded.flatMap((s) => s.views),
+    globalComponents: loaded.flatMap((s) => s.globalComponents),
+    globalRequests: loaded.flatMap((s) => s.globalRequests),
+    fileMemory: loaded.flatMap((s) => s.fileMemory),
+    diagnostics: loaded.flatMap((s) => s.diagnostics)
+  };
+}
+var init_loadMerged = __esm({
+  "src/loadMerged.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { resolve } from "path";
+
+// src/server.ts
+import { match as sightmapMatch4 } from "@sightmap/sightmap";
+
+// src/tools/match.ts
+import { match as sightmapMatch } from "@sightmap/sightmap";
+function handleSightmapMatch(sightmap, input) {
+  const result = sightmapMatch(sightmap, {
+    url: input.url,
+    ...input.method !== void 0 ? { method: input.method } : {}
+  });
+  return {
+    view: result.view ? {
+      name: result.view.name,
+      route: result.view.route,
+      ...result.view.description !== void 0 ? { description: result.view.description } : {}
+    } : null,
+    components: result.components.map((c) => ({
+      name: c.name,
+      selector: c.selector,
+      memory: c.memory ?? [],
+      scope: c.scope
+    })),
+    requests: result.requests.map((r) => ({
+      name: r.name,
+      route: r.route,
+      ...r.method !== void 0 ? { method: r.method } : {},
+      memory: r.memory ?? []
+    })),
+    memory: result.memory ?? [],
+    viewMemory: result.view?.memory ?? []
+  };
+}
+
+// src/tools/snapshot.ts
+import { match as sightmapMatch2 } from "@sightmap/sightmap";
+function buildSightmapSnapshotResponse(opts) {
+  const { sightmap, currentUrl, ariaSnapshotText, inPageMatches } = opts;
+  const result = sightmapMatch2(sightmap, { url: currentUrl });
+  const inPageByName = /* @__PURE__ */ new Map();
+  for (const m of inPageMatches) inPageByName.set(m.name, m);
+  const components = result.components.map((c) => {
+    const inPage = inPageByName.get(c.name);
+    return {
+      name: c.name,
+      selector: c.selector,
+      memory: c.memory ?? [],
+      scope: c.scope,
+      matchCount: inPage?.matchCount ?? 0,
+      ...inPage?.samplePosition !== void 0 ? { samplePosition: inPage.samplePosition } : {}
+    };
+  });
+  return {
+    view: result.view ? {
+      name: result.view.name,
+      route: result.view.route,
+      memory: result.view.memory ?? []
+    } : null,
+    components,
+    memory: result.memory ?? [],
+    ariaSnapshot: ariaSnapshotText
+  };
+}
+
+// src/tools/act.ts
+function resolveSightmapAct(sightmap, input) {
+  const found = findComponentByName(sightmap, input.componentName);
+  if (found === null) {
+    return {
+      kind: "error",
+      message: `Component "${input.componentName}" not found in the loaded sightmap.`
+    };
+  }
+  const selectors = Array.isArray(found.selector) ? found.selector : [];
+  if (selectors.length === 0) {
+    return {
+      kind: "error",
+      message: `Component "${input.componentName}" has no selector \u2014 cannot dispatch an action.`
+    };
+  }
+  return {
+    kind: "ok",
+    componentName: input.componentName,
+    selector: selectors[0],
+    allSelectors: selectors
+  };
+}
+function findComponentByName(sightmap, name) {
+  for (const c of sightmap.globalComponents) {
+    if (c.name === name) return c;
+  }
+  for (const v of sightmap.views) {
+    for (const c of v.components ?? []) {
+      if (c.name === name) return c;
+    }
+  }
+  return null;
+}
+
+// src/tools/network.ts
+import { match as sightmapMatch3 } from "@sightmap/sightmap";
+function parseNetworkRequestsText(text) {
+  const lines = text.split(/\r?\n/);
+  const requests = [];
+  const re = /^\s*\d+\.\s*\[([A-Z]+)\]\s+(\S+)\s+=>\s+\[(\d+)\]\s+(.*?)\s*$/;
+  for (const line of lines) {
+    const m = re.exec(line);
+    if (m === null) continue;
+    requests.push({
+      method: m[1] ?? "",
+      url: m[2] ?? "",
+      status: Number.parseInt(m[3] ?? "0", 10),
+      statusText: m[4] ?? ""
+    });
+  }
+  return requests;
+}
+function annotateNetworkRequests(sightmap, requests) {
+  return requests.map((req) => {
+    const result = sightmapMatch3(sightmap, { url: req.url, method: req.method });
+    const first = result.requests[0];
+    if (first === void 0) return req;
+    const annotated = { ...req, sightmapName: first.name };
+    if (first.memory && first.memory.length > 0) {
+      annotated.sightmapMemory = first.memory;
+    }
+    return annotated;
+  });
+}
+
+// src/tools/curate/list.ts
+function handleListViews(sightmap, input) {
+  const detail = input.detail ?? "summary";
+  const sorted = [...sightmap.views].sort(
+    (a, b) => a.name.localeCompare(b.name)
+  );
+  if (detail === "full") {
+    return { views: sorted };
+  }
+  return {
+    views: sorted.map((v) => {
+      const summary = { name: v.name, route: v.route };
+      if (v.description !== void 0) summary.description = v.description;
+      return summary;
+    })
+  };
+}
+
+// src/tools/curate/get.ts
+import { readFile as readFile2 } from "fs/promises";
+import { parse as parse2 } from "@sightmap/sightmap";
+
+// src/curate/locator.ts
+import { readdir, readFile } from "fs/promises";
+import { join } from "path";
+import { parse } from "@sightmap/sightmap";
+async function findFileForView(sightmapDir, viewName, options = {}) {
+  const entries = await readdir(sightmapDir);
+  const yamlFiles = entries.filter((e) => e.endsWith(".yaml") || e.endsWith(".yml")).sort();
+  let firstMatch = null;
+  let matchCount = 0;
+  for (const file of yamlFiles) {
+    const path = join(sightmapDir, file);
+    let parsed;
+    try {
+      const text = await readFile(path, "utf8");
+      parsed = parse(text, { sourceFile: path });
+    } catch {
+      continue;
+    }
+    if (parsed.views?.some((v) => v.name === viewName)) {
+      matchCount++;
+      if (firstMatch === null) firstMatch = path;
+    }
+  }
+  if (matchCount > 1 && options.onWarning) {
+    options.onWarning(
+      `duplicate view name "${viewName}" found in ${matchCount} files; using ${firstMatch}`
+    );
+  }
+  return firstMatch;
+}
+
+// src/tools/curate/get.ts
+async function handleGetView(input) {
+  const file = await findFileForView(input.sightmapDir, input.name);
+  if (file === null) {
+    throw new Error(
+      `View "${input.name}" not found in ${input.sightmapDir}`
+    );
+  }
+  const text = await readFile2(file, "utf8");
+  const parsed = parse2(text, { sourceFile: file });
+  const view = parsed.views?.find((v) => v.name === input.name);
+  if (view === void 0) {
+    throw new Error(
+      `View "${input.name}" not found in ${file} (locator drift?)`
+    );
+  }
+  return { view, file };
+}
+
+// src/tools/curate/check.ts
+import { lint } from "@sightmap/sightmap";
+async function handleCheck(sightmap, input) {
+  const level = input.level ?? "quality";
+  const schemaDiag = [...sightmap.diagnostics];
+  if (level === "schema") return { diagnostics: schemaDiag };
+  const lintDiag = await lint(sightmap);
+  return { diagnostics: [...schemaDiag, ...lintDiag] };
+}
+
+// src/tools/curate/update.ts
+import { readFile as readFile3, writeFile } from "fs/promises";
+import {
+  parse as parse3,
+  format
+} from "@sightmap/sightmap";
+async function handleUpdateView(input) {
+  if (input.patch.memory_append && input.patch.memory_replace) {
+    throw new Error(
+      "cannot use both memory_append and memory_replace in the same patch"
+    );
+  }
+  const file = await findFileForView(input.sightmapDir, input.name);
+  if (file === null) {
+    throw new Error(
+      `View "${input.name}" not found in ${input.sightmapDir}`
+    );
+  }
+  const text = await readFile3(file, "utf8");
+  const parsed = parse3(text, { sourceFile: file });
+  const views = parsed.views ?? [];
+  const idx = views.findIndex((v) => v.name === input.name);
+  if (idx < 0) {
+    throw new Error(
+      `View "${input.name}" not found in ${file} (locator drift?)`
+    );
+  }
+  const before = views[idx];
+  const after = { ...before };
+  if (input.patch.description !== void 0) {
+    after.description = input.patch.description;
+  }
+  if (input.patch.intent !== void 0) {
+    after.intent = input.patch.intent;
+  }
+  if (input.patch.memory_append) {
+    after.memory = [...before.memory ?? [], ...input.patch.memory_append];
+  }
+  if (input.patch.memory_replace) {
+    after.memory = [...input.patch.memory_replace];
+  }
+  const nextViews = [...views];
+  nextViews[idx] = after;
+  const nextDoc = stripFragmentBrand(parsed);
+  nextDoc.views = nextViews;
+  const out = format(nextDoc);
+  await writeFile(file, out, "utf8");
+  return { ok: true, file, written: after };
+}
+function stripFragmentBrand(input) {
+  const out = {};
+  for (const k of Object.keys(input)) {
+    if (k === "__brand" || k === "__sourceFile") continue;
+    out[k] = input[k];
+  }
+  return out;
+}
+
+// src/tools/curate/init.ts
+import { mkdir, writeFile as writeFile2, access } from "fs/promises";
+import { join as join2 } from "path";
+
+// src/curate/scaffolder.ts
+import { format as format2 } from "@sightmap/sightmap";
+function makeStarterSightmap() {
+  return format2({ version: 1 });
+}
+
+// src/tools/curate/init.ts
+async function handleInitProject(input) {
+  const root = input.dir ?? process.cwd();
+  const sightmapDir = join2(root, ".sightmap");
+  const appFile = join2(sightmapDir, "app.yaml");
+  if (input.force !== true) {
+    let exists = false;
+    try {
+      await access(sightmapDir);
+      exists = true;
+    } catch {
+    }
+    if (exists) {
+      throw new Error(
+        `.sightmap/ already exists at ${sightmapDir} \u2014 pass force=true to overwrite`
+      );
+    }
+  }
+  await mkdir(sightmapDir, { recursive: true });
+  await writeFile2(appFile, makeStarterSightmap(), "utf8");
+  return { ok: true, files: [appFile] };
+}
+
+// src/prompts/sepTrack.ts
+var VALID_PHASES = ["draft", "spec", "fixture", "verify"];
+function buildDraftPhase(args) {
+  const slug = args.slug ?? "{slug}";
+  return [
+    `# SEP track \u2014 phase 1 of 4: Draft the SEP`,
+    ``,
+    `You are helping the user author a Sightmap Enhancement Proposal (SEP).`,
+    `An SEP is required for any change to the spec's schema, semantics, or`,
+    `discovery rules. See \`seps/README.md\` for the full list.`,
+    ``,
+    `## Steps for this phase`,
+    ``,
+    `1. **Pick a number.** Look at \`seps/\` and find the lowest unused 4-digit`,
+    `   integer (skip \`0000-template.md\`). Call this NNNN.`,
+    `2. **Copy the template.** \`cp seps/0000-template.md seps/NNNN-${slug}.md\`.`,
+    `3. **Fill in the front-matter.** Title, author, today's date, status: Draft.`,
+    `4. **Write the body.** Sections from the template:`,
+    `   - Summary (one paragraph; treat as the abstract)`,
+    `   - Motivation (concrete user-facing problem; name a real app or pattern)`,
+    `   - Proposal (Shape, Semantics, Conformance \u2014 show YAML, show JSON Schema diff)`,
+    `   - Alternatives considered (at least two, including "do nothing")`,
+    `   - Migration (what changes for existing users)`,
+    `   - Open questions`,
+    `5. **Read it back.** Does it pass the acceptance checklist in \`seps/README.md\`?`,
+    ``,
+    `## STOP HERE`,
+    ``,
+    `Show the draft to the user. Ask for explicit "go" before continuing.`,
+    `Do **not** open the spec edit until the user confirms the SEP draft.`,
+    ``,
+    `When the user is ready, call this prompt again with`,
+    `\`phase: "spec"\` and pass \`sep_number: "NNNN"\` and \`slug: "${slug}"\`.`
+  ].join("\n");
+}
+function buildSpecPhase(args) {
+  const slug = args.slug ?? "{slug}";
+  const sep = args.sep_number ?? "NNNN";
+  return [
+    `# SEP track \u2014 phase 2 of 4: Propose the spec change`,
+    ``,
+    `Building on \`seps/${sep}-${slug}.md\`.`,
+    ``,
+    `## Steps for this phase`,
+    ``,
+    `1. **Identify the spec files affected.** Most changes touch:`,
+    `   - \`spec/v1/sightmap.schema.json\` (the JSON Schema)`,
+    `   - \`spec/v1/sightmap.spec.md\` (the prose spec)`,
+    `   - Possibly \`spec/v1/examples/\` if the change adds a shape worth showing`,
+    `2. **Make the edits.** Keep the diff small. The SEP is the design doc;`,
+    `   the spec edit is the precise textual change.`,
+    `3. **Run \`pnpm -F @sightmap/sightmap test\`.** Existing examples must still`,
+    `   parse and validate, unless the SEP is explicitly breaking \u2014 in which`,
+    `   case the SEP's Migration section must say so.`,
+    `4. **Cross-reference.** Add a "Spec changes:" line near the top of the SEP`,
+    `   listing the touched files. Add a comment in the schema file pointing`,
+    `   back to \`seps/${sep}-${slug}.md\` if the rationale isn't obvious from`,
+    `   the diff alone.`,
+    ``,
+    `## STOP HERE`,
+    ``,
+    `Show the spec diff to the user. Ask for explicit "go" before continuing.`,
+    `Do **not** start the conformance fixture until the user confirms the spec edit.`,
+    ``,
+    `When the user is ready, call this prompt again with`,
+    `\`phase: "fixture"\`, \`sep_number: "${sep}"\`, \`slug: "${slug}"\`.`
+  ].join("\n");
+}
+function buildFixturePhase(args) {
+  const slug = args.slug ?? "{slug}";
+  const sep = args.sep_number ?? "NNNN";
+  const fixtureGuess = sep.startsWith("0") ? sep.slice(1) : sep;
+  return [
+    `# SEP track \u2014 phase 3 of 4: Write the conformance fixture`,
+    ``,
+    `Building on \`seps/${sep}-${slug}.md\` and the spec edit from phase 2.`,
+    ``,
+    `## Steps for this phase`,
+    ``,
+    `1. **Pick a fixture number.** Conformance fixtures use 3-digit numbers`,
+    `   (\`001-minimal\`, \`002-multi-file-merge\`, \u2026). Pick the lowest unused`,
+    `   number \u2014 likely \`${fixtureGuess}\` if the SEP and fixture numberings`,
+    `   line up, but verify against \`conformance/\`.`,
+    `2. **Create the directory.** \`mkdir conformance/${fixtureGuess}-${slug}\`.`,
+    `3. **Write the input.** \`conformance/${fixtureGuess}-${slug}/sightmap/\``,
+    `   contains one or more \`.yaml\` files demonstrating the new behavior.`,
+    `   Keep it minimal \u2014 one fixture, one behavior under test.`,
+    `4. **Write the expected output.** \`conformance/${fixtureGuess}-${slug}/expected.json\``,
+    `   is the canonical merged + resolved sightmap that any spec-conformant`,
+    `   parser must produce. Use the existing \`@sightmap/sightmap\` parser`,
+    `   to generate the baseline, then hand-audit it against the SEP.`,
+    `5. **Run the conformance suite.** \`pnpm -F @sightmap/sightmap test\` should`,
+    `   pick up the new fixture and validate it.`,
+    ``,
+    `## STOP HERE`,
+    ``,
+    `Show the fixture (input + expected.json) to the user. Ask for explicit`,
+    `"go" before continuing. Do **not** declare the SEP ready for review until`,
+    `the user confirms all three artefacts.`,
+    ``,
+    `When the user is ready, call this prompt again with`,
+    `\`phase: "verify"\`, \`sep_number: "${sep}"\`, \`slug: "${slug}"\`.`
+  ].join("\n");
+}
+function buildVerifyPhase(args) {
+  const slug = args.slug ?? "{slug}";
+  const sep = args.sep_number ?? "NNNN";
+  return [
+    `# SEP track \u2014 phase 4 of 4: Verify and hand off`,
+    ``,
+    `## Summary`,
+    ``,
+    `SEP ${sep} \u2190 spec edit \u2190 conformance fixture, ready for review.`,
+    ``,
+    `Three artefacts should now exist on this branch:`,
+    ``,
+    `- \`seps/${sep}-${slug}.md\` (Draft \u2192 flip to Review when filing the PR)`,
+    `- spec/ edits (listed in the SEP's "Spec changes:" line)`,
+    `- \`conformance/<fixture-number>-${slug}/\` with \`sightmap/\` input and`,
+    `  \`expected.json\` output`,
+    ``,
+    `## Next steps for the user`,
+    ``,
+    `1. Open a draft PR titled "SEP ${sep}: <short title>".`,
+    `2. PR description: link the SEP, the spec diff, and the fixture; link any`,
+    `   prior Discussion or Issue.`,
+    `3. Flip the SEP front-matter \`status\` from \`Draft\` to \`Review\` when`,
+    `   ready for substantive feedback.`,
+    `4. Per \`seps/README.md\`: minimum review window is 7 days for minor`,
+    `   changes, 14 days for anything affecting the JSON Schema.`,
+    ``,
+    `Track is complete. No further phases.`
+  ].join("\n");
+}
+function buildPhase(args) {
+  if (typeof args["phase"] !== "string" || args["phase"].length === 0) {
+    throw new Error(`sightmap_sep_track: argument "phase" is required`);
+  }
+  if (!VALID_PHASES.includes(args["phase"])) {
+    throw new Error(
+      `sightmap_sep_track: unknown phase "${args["phase"]}" \u2014 expected one of ${VALID_PHASES.join(", ")}`
+    );
+  }
+  const phase = args["phase"];
+  const phaseArgs = {};
+  if (typeof args["slug"] === "string") phaseArgs.slug = args["slug"];
+  if (typeof args["sep_number"] === "string") phaseArgs.sep_number = args["sep_number"];
+  switch (phase) {
+    case "draft":
+      return buildDraftPhase(phaseArgs);
+    case "spec":
+      return buildSpecPhase(phaseArgs);
+    case "fixture":
+      return buildFixturePhase(phaseArgs);
+    case "verify":
+      return buildVerifyPhase(phaseArgs);
+  }
+}
+var sepTrackPrompt = {
+  definition: {
+    name: "sightmap_sep_track",
+    description: "Walks an author through writing a Sightmap Enhancement Proposal (SEP), the matching spec/ change, and the matching conformance/ fixture in four phases (draft \u2192 spec \u2192 fixture \u2192 verify). Each non-final phase ends with a confirmation gate \u2014 call this prompt again with the next phase only after the user confirms. Inspired by Archcore's architecture_track pattern.",
+    arguments: [
+      {
+        name: "phase",
+        description: 'One of "draft", "spec", "fixture", "verify". Required.',
+        required: true
+      },
+      {
+        name: "slug",
+        description: "Short kebab-case slug for the SEP (e.g. 'extend-memory').",
+        required: false
+      },
+      {
+        name: "sep_number",
+        description: 'Four-digit SEP number assigned in phase "draft" (e.g. "0001").',
+        required: false
+      }
+    ]
+  },
+  handler: (args) => {
+    const text = buildPhase(args);
+    return {
+      messages: [
+        {
+          role: "user",
+          content: { type: "text", text }
+        }
+      ]
+    };
+  }
+};
+
+// src/prompts/index.ts
+var PROMPT_REGISTRY = [sepTrackPrompt];
+
+// src/server.ts
+var SIGHTMAP_MATCH = {
+  name: "sightmap_match",
+  description: "Pure-query lookup against the loaded sightmap. Returns the matched view, applicable components, applicable requests, and aggregated memory for a given URL. Useful for agent planning before navigation. Does not touch the browser.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      url: {
+        type: "string",
+        description: "The URL to resolve against the sightmap's view routes."
+      },
+      method: {
+        type: "string",
+        description: "Optional HTTP method to filter matched requests (e.g., 'GET', 'POST')."
+      }
+    },
+    required: ["url"],
+    additionalProperties: false
+  }
+};
+var SIGHTMAP_SNAPSHOT = {
+  name: "sightmap_snapshot",
+  description: "Returns the upstream ARIA snapshot enriched with sightmap awareness: matched view name, applicable component names with their selectors and live matchCount on the page, view-level memory, and page-aggregated memory. Use this instead of browser_snapshot when you want sightmap-aware semantics in one round-trip.",
+  inputSchema: {
+    type: "object",
+    properties: {},
+    additionalProperties: false
+  }
+};
+var SIGHTMAP_NETWORK_REQUESTS = {
+  name: "sightmap_network_requests",
+  description: "Returns recent network requests captured by the upstream, annotated with sightmap names and memory where the request URL+method matches a sightmap `requests:` entry. Use this in place of browser_network_requests when you want sightmap-aware semantics for network calls.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      static: {
+        type: "boolean",
+        description: "Include successful static resources (images, fonts, scripts). Default false."
+      },
+      filter: {
+        type: "string",
+        description: "Only return requests whose URL matches this regexp."
+      }
+    },
+    additionalProperties: false
+  }
+};
+var SIGHTMAP_INIT_PROJECT = {
+  name: "sightmap_init_project",
+  description: "Scaffold an empty .sightmap/ directory in the target project. Pass `dir` to override the location (default: server cwd). Refuses to overwrite an existing .sightmap/ unless `force=true`.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      dir: { type: "string", description: "Project root. Default: server cwd." },
+      force: { type: "boolean", description: "Default false." }
+    },
+    additionalProperties: false
+  }
+};
+var SIGHTMAP_UPDATE_VIEW = {
+  name: "sightmap_update_view",
+  description: "Apply a partial patch to a view's agent-authored fields (description, intent, memory). Memory edits use either `memory_append` (default operation) or `memory_replace` \u2014 pass exactly one. Component / route / selector edits are NOT supported here \u2014 those are codegen-owned; edit source and re-run sightmap-react gen instead.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      name: { type: "string" },
+      patch: {
+        type: "object",
+        properties: {
+          description: { type: "string" },
+          intent: { type: "string" },
+          memory_append: { type: "array", items: { type: "string" } },
+          memory_replace: { type: "array", items: { type: "string" } }
+        },
+        additionalProperties: false
+      }
+    },
+    required: ["name", "patch"],
+    additionalProperties: false
+  }
+};
+var SIGHTMAP_CHECK = {
+  name: "sightmap_check",
+  description: "Validate the loaded sightmap. level='schema' returns only schema-level diagnostics (parse errors, schema failures, merge collisions). level='quality' (default) also runs lint rules: duplicate routes, route shadowing, selector syntax, unknown source attributions. Returns an array of diagnostics; an empty array means clean.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      level: {
+        type: "string",
+        enum: ["schema", "quality"],
+        description: "Default 'quality'."
+      }
+    },
+    additionalProperties: false
+  }
+};
+var SIGHTMAP_GET_VIEW = {
+  name: "sightmap_get_view",
+  description: "Fetch a single view by name, including all memory, components, and requests. Returns the file path the view was read from for subsequent edits. Use sightmap_list_views first to discover view names.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      name: { type: "string", description: "View name (case-sensitive)." }
+    },
+    required: ["name"],
+    additionalProperties: false
+  }
+};
+var SIGHTMAP_LIST_VIEWS = {
+  name: "sightmap_list_views",
+  description: "List all views in the loaded sightmap. Returns compact summaries (name, route, description) by default; pass detail='full' for the complete view objects including memory and components. Token-efficient: prefer the default for any agent that hasn't yet narrowed to a specific view.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      detail: {
+        type: "string",
+        enum: ["summary", "full"],
+        description: "Default 'summary'."
+      }
+    },
+    additionalProperties: false
+  }
+};
+var SIGHTMAP_ACT = {
+  name: "sightmap_act",
+  description: "Performs an action on a UI element. Prefer `componentName` so the agent operates in sightmap semantics; fall back to a raw `selector` for one-off targets the sightmap doesn't define (e.g., a stray link or a third-party widget). Supported actions: 'click' (browser_click), 'type' (browser_type, requires `text`), 'hover' (browser_hover). Pass exactly one of `componentName` or `selector`.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      componentName: {
+        type: "string",
+        description: "Sightmap component name to act on (case-sensitive). Mutually exclusive with `selector`."
+      },
+      selector: {
+        type: "string",
+        description: "Escape hatch: a raw CSS selector for a target the sightmap doesn't name. Same tagging + dispatch path as componentName. Use this only when no sightmap component fits \u2014 most actions should use `componentName` so the agent's reasoning stays in sightmap semantics. Mutually exclusive with `componentName`."
+      },
+      action: {
+        type: "string",
+        enum: ["click", "type", "hover"],
+        description: "The action to perform on the component."
+      },
+      text: {
+        type: "string",
+        description: "Required for action='type'. Text to enter into the matched element."
+      },
+      submit: {
+        type: "boolean",
+        description: "For action='type' only. Press Enter after typing."
+      },
+      instance: {
+        type: "integer",
+        minimum: 0,
+        description: "Zero-based index of the matching element when the component selector resolves to multiple elements (default 0). Use sightmap_snapshot.matchCount to discover how many instances exist. Mutually exclusive with `containingText`."
+      },
+      containingText: {
+        type: "string",
+        description: "Disambiguator for multi-match components: pick the first element whose visible text contains this substring (case-insensitive). Use this instead of `instance` when you can identify the element by its visible label rather than position. Mutually exclusive with `instance`."
+      }
+    },
+    required: ["componentName", "action"],
+    additionalProperties: false
+  }
+};
+var SHADOWED_UPSTREAM_TOOLS = /* @__PURE__ */ new Set([
+  "browser_snapshot",
+  "browser_click",
+  "browser_type",
+  "browser_hover",
+  "browser_network_requests"
+]);
+var SightmapMcpServer = class {
+  sightmap;
+  upstream;
+  curateRoot;
+  constructor(opts) {
+    this.sightmap = opts.sightmap;
+    this.upstream = opts.upstream;
+    this.curateRoot = opts.curateRoot;
+  }
+  /** Synchronous list of sightmap-aware tools that don't need an upstream. */
+  listTools() {
+    return [
+      SIGHTMAP_MATCH,
+      SIGHTMAP_LIST_VIEWS,
+      SIGHTMAP_GET_VIEW,
+      SIGHTMAP_CHECK,
+      SIGHTMAP_UPDATE_VIEW,
+      SIGHTMAP_INIT_PROJECT
+    ];
+  }
+  /** Full async list including upstream-proxied tools, if configured. */
+  async listToolsAsync() {
+    const own = [
+      SIGHTMAP_MATCH,
+      SIGHTMAP_LIST_VIEWS,
+      SIGHTMAP_GET_VIEW,
+      SIGHTMAP_CHECK,
+      SIGHTMAP_UPDATE_VIEW,
+      SIGHTMAP_INIT_PROJECT
+    ];
+    if (this.upstream !== void 0) {
+      own.push(SIGHTMAP_SNAPSHOT, SIGHTMAP_ACT, SIGHTMAP_NETWORK_REQUESTS);
+    }
+    if (this.upstream === void 0) return own;
+    const upstreamTools = await this.upstream.listTools();
+    const shadowed = SHADOWED_UPSTREAM_TOOLS;
+    const filtered = upstreamTools.filter((t) => !shadowed.has(t.name));
+    return [...own, ...filtered];
+  }
+  /** All prompts the server advertises. Static; no upstream involvement. */
+  listPrompts() {
+    return PROMPT_REGISTRY.map((p) => p.definition);
+  }
+  /**
+   * Resolve a prompt by name, validate args, and produce the prompt result
+   * (the messages the agent will inject). Throws on unknown names or on a
+   * handler that itself throws (e.g., bad phase value).
+   */
+  getPrompt(name, args) {
+    const entry = PROMPT_REGISTRY.find(
+      (p) => p.definition.name === name
+    );
+    if (entry === void 0) throw new Error(`unknown prompt: ${name}`);
+    return entry.handler(args);
+  }
+  async callTool(name, args) {
+    if (isSightmapTool(name)) {
+      switch (name) {
+        case "sightmap_match":
+          return this.callSightmapMatch(args);
+        case "sightmap_list_views":
+          return this.callSightmapListViews(args);
+        case "sightmap_get_view":
+          return this.callSightmapGetView(args);
+        case "sightmap_check":
+          return this.callSightmapCheck(args);
+        case "sightmap_update_view":
+          return this.callSightmapUpdateView(args);
+        case "sightmap_init_project":
+          return this.callSightmapInitProject(args);
+        case "sightmap_snapshot":
+          return this.callSightmapSnapshot();
+        case "sightmap_act":
+          return this.callSightmapAct(args);
+        case "sightmap_network_requests":
+          return this.callSightmapNetworkRequests(args);
+        default:
+          return errorResult(`Unknown sightmap tool: ${name}`);
+      }
+    }
+    if (this.upstream !== void 0) {
+      return this.upstream.callTool(name, args);
+    }
+    return errorResult(`Unknown tool: ${name}`);
+  }
+  /**
+   * Tag a single element matching `selector` with a unique
+   * `data-sm-act-target` attribute and return a CSS selector that resolves
+   * to exactly that element. The selection mode picks WHICH match to tag:
+   *   - `{ kind: "index", index }` — pick the Nth match (default).
+   *   - `{ kind: "containingText", text }` — pick the first match whose
+   *     `textContent` contains `text` (case-insensitive).
+   *
+   * Returns null if no candidate is selected (index out of range, or no
+   * element's text contains the needle).
+   */
+  async tagSingleMatch(selector, selection) {
+    if (this.upstream === void 0) return null;
+    const marker = `sm-${Math.random().toString(36).slice(2, 10)}-${Date.now().toString(36)}`;
+    const pickExpr = selection.kind === "index" ? `els[${selection.index}]` : `els.find((el) => (el.textContent || "").toLowerCase().includes(${JSON.stringify(selection.text.toLowerCase())}))`;
+    const fnBody = `() => {
+      const els = Array.from(document.querySelectorAll(${JSON.stringify(selector)}));
+      const target = ${pickExpr};
+      if (!target) return null;
+      target.setAttribute("data-sm-act-target", ${JSON.stringify(marker)});
+      return "[data-sm-act-target=\\"" + ${JSON.stringify(marker)} + "\\"]";
+    }`;
+    const r = await this.upstream.callTool("browser_evaluate", { function: fnBody });
+    if (r.isError === true) return null;
+    const text = r.content.map((b) => b.text).join("\n");
+    const decoded = decodeMcpEvalResult(text);
+    if (typeof decoded !== "string") return null;
+    if (!decoded.includes(`data-sm-act-target="${marker}"`)) return null;
+    return decoded;
+  }
+  async callSightmapNetworkRequests(args) {
+    if (this.upstream === void 0) {
+      return errorResult(
+        "sightmap_network_requests: requires an upstream (e.g., @playwright/mcp)."
+      );
+    }
+    const upstreamArgs = {};
+    if (typeof args["static"] === "boolean") upstreamArgs["static"] = args["static"];
+    if (typeof args["filter"] === "string") upstreamArgs["filter"] = args["filter"];
+    const r = await this.upstream.callTool("browser_network_requests", upstreamArgs);
+    if (r.isError === true) {
+      return r;
+    }
+    const text = r.content.map((b) => b.text).join("\n");
+    const parsed = parseNetworkRequestsText(text);
+    const annotated = annotateNetworkRequests(this.sightmap, parsed);
+    return {
+      content: [{ type: "text", text: JSON.stringify({ requests: annotated }, null, 2) }]
+    };
+  }
+  async callSightmapAct(args) {
+    if (this.upstream === void 0) {
+      return errorResult(
+        "sightmap_act: requires an upstream (e.g., @playwright/mcp) to be configured."
+      );
+    }
+    const hasComponent = typeof args["componentName"] === "string" && args["componentName"].length > 0;
+    const hasSelector = typeof args["selector"] === "string" && args["selector"].length > 0;
+    if (hasComponent && hasSelector) {
+      return errorResult(
+        "sightmap_act: `componentName` and `selector` are mutually exclusive \u2014 pass one, not both."
+      );
+    }
+    if (!hasComponent && !hasSelector) {
+      return errorResult(
+        "sightmap_act: pass either `componentName` (preferred) or `selector` (escape hatch for off-sightmap targets)."
+      );
+    }
+    if (typeof args["action"] !== "string") {
+      return errorResult("sightmap_act: required argument `action` (string) is missing.");
+    }
+    const action = args["action"];
+    const validActions = /* @__PURE__ */ new Set(["click", "type", "hover"]);
+    if (!validActions.has(action)) {
+      return errorResult(
+        `sightmap_act: unsupported action "${action}". Supported: click, type, hover.`
+      );
+    }
+    if (action === "type" && typeof args["text"] !== "string") {
+      return errorResult("sightmap_act: action='type' requires `text` (string).");
+    }
+    const hasInstance = typeof args["instance"] === "number";
+    const hasContainingText = typeof args["containingText"] === "string" && args["containingText"].length > 0;
+    if (hasInstance && hasContainingText) {
+      return errorResult(
+        "sightmap_act: `instance` and `containingText` are mutually exclusive \u2014 pass one, not both."
+      );
+    }
+    let targetSelector;
+    let targetLabel;
+    if (hasComponent) {
+      const resolved2 = resolveSightmapAct(this.sightmap, {
+        componentName: args["componentName"]
+      });
+      if (resolved2.kind === "error") {
+        return errorResult("sightmap_act: " + resolved2.message);
+      }
+      targetSelector = resolved2.selector;
+      targetLabel = resolved2.componentName;
+    } else {
+      targetSelector = args["selector"];
+      targetLabel = `selector:${targetSelector}`;
+    }
+    const resolved = { kind: "ok", componentName: targetLabel, selector: targetSelector };
+    const selection = hasContainingText ? { kind: "containingText", text: args["containingText"] } : { kind: "index", index: hasInstance ? Math.floor(args["instance"]) : 0 };
+    const taggedSelector = await this.tagSingleMatch(resolved.selector, selection);
+    if (taggedSelector === null) {
+      const reason = selection.kind === "containingText" ? `no instance of "${resolved.componentName}" contains text ${JSON.stringify(selection.text)}` : `could not tag the element at instance=${selection.index} for component "${resolved.componentName}"`;
+      return errorResult(
+        `sightmap_act: ${reason}. The selector ${JSON.stringify(resolved.selector)} may not resolve any matching elements on the current page.`
+      );
+    }
+    const baseArgs = {
+      target: taggedSelector,
+      element: resolved.componentName
+    };
+    let upstreamName;
+    let upstreamArgs;
+    switch (action) {
+      case "click":
+        upstreamName = "browser_click";
+        upstreamArgs = baseArgs;
+        break;
+      case "hover":
+        upstreamName = "browser_hover";
+        upstreamArgs = baseArgs;
+        break;
+      case "type":
+        upstreamName = "browser_type";
+        upstreamArgs = {
+          ...baseArgs,
+          text: args["text"],
+          ...args["submit"] === true ? { submit: true } : {}
+        };
+        break;
+      default:
+        return errorResult(`sightmap_act: unsupported action "${action}".`);
+    }
+    return this.upstream.callTool(upstreamName, upstreamArgs);
+  }
+  async callSightmapSnapshot() {
+    if (this.upstream === void 0) {
+      return errorResult(
+        "sightmap_snapshot: requires an upstream (e.g., @playwright/mcp) to be configured."
+      );
+    }
+    const snapResult = await this.upstream.callTool("browser_snapshot", {});
+    if (snapResult.isError === true) {
+      return errorResult(
+        "sightmap_snapshot: upstream browser_snapshot failed: " + (snapResult.content[0]?.text ?? "unknown error")
+      );
+    }
+    const ariaSnapshotText = snapResult.content.map((b) => b.text).join("\n");
+    const currentUrl = parsePageUrl(ariaSnapshotText) ?? "";
+    const matchResult = sightmapMatch4(this.sightmap, { url: currentUrl });
+    const componentSelectors = matchResult.components.map((c) => ({
+      name: c.name,
+      selector: c.selector
+    }));
+    const evalResult = await this.upstream.callTool("browser_evaluate", {
+      function: buildInPageEvalFunction(componentSelectors)
+    });
+    if (evalResult.isError === true) {
+      return errorResult(
+        "sightmap_snapshot: upstream browser_evaluate failed: " + (evalResult.content[0]?.text ?? "unknown error")
+      );
+    }
+    const inPageMatches = parseInPageEvalResult(
+      evalResult.content.map((b) => b.text).join("\n")
+    );
+    const response = buildSightmapSnapshotResponse({
+      sightmap: this.sightmap,
+      currentUrl,
+      ariaSnapshotText,
+      inPageMatches
+    });
+    return {
+      content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+    };
+  }
+  callSightmapMatch(args) {
+    if (typeof args["url"] !== "string" || args["url"].length === 0) {
+      return errorResult("sightmap_match: required argument `url` (string) is missing or empty.");
+    }
+    const input = { url: args["url"] };
+    if (typeof args["method"] === "string") {
+      input.method = args["method"];
+    }
+    const output = handleSightmapMatch(this.sightmap, input);
+    return {
+      content: [{ type: "text", text: JSON.stringify(output, null, 2) }]
+    };
+  }
+  async callSightmapGetView(args) {
+    if (this.curateRoot === void 0) {
+      return errorResult(
+        "sightmap_get_view: no writable sightmap dir configured (pass --curate-root or --sightmap-dir)."
+      );
+    }
+    if (typeof args["name"] !== "string" || args["name"].length === 0) {
+      return errorResult("sightmap_get_view: required argument `name` (string) is missing or empty.");
+    }
+    try {
+      const result = await handleGetView({
+        sightmapDir: this.curateRoot,
+        name: args["name"]
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    } catch (err) {
+      return errorResult(err instanceof Error ? err.message : String(err));
+    }
+  }
+  async callSightmapInitProject(args) {
+    const input = {};
+    if (typeof args["dir"] === "string") input.dir = args["dir"];
+    if (args["force"] === true) input.force = true;
+    try {
+      const result = await handleInitProject(input);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    } catch (err) {
+      return errorResult(err instanceof Error ? err.message : String(err));
+    }
+  }
+  async callSightmapUpdateView(args) {
+    if (this.curateRoot === void 0) {
+      return errorResult(
+        "sightmap_update_view: no writable sightmap dir configured (pass --curate-root or --sightmap-dir)."
+      );
+    }
+    if (typeof args["name"] !== "string" || args["name"].length === 0) {
+      return errorResult(
+        "sightmap_update_view: required argument `name` (string) is missing or empty."
+      );
+    }
+    if (args["patch"] === null || typeof args["patch"] !== "object" || Array.isArray(args["patch"])) {
+      return errorResult(
+        "sightmap_update_view: required argument `patch` (object) is missing."
+      );
+    }
+    try {
+      const result = await handleUpdateView({
+        sightmapDir: this.curateRoot,
+        name: args["name"],
+        patch: args["patch"]
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    } catch (err) {
+      return errorResult(err instanceof Error ? err.message : String(err));
+    }
+  }
+  async callSightmapCheck(args) {
+    const input = {};
+    if (args["level"] === "schema" || args["level"] === "quality") {
+      input.level = args["level"];
+    } else if (args["level"] !== void 0) {
+      return errorResult(
+        `sightmap_check: level must be "schema" or "quality".`
+      );
+    }
+    const result = await handleCheck(this.sightmap, input);
+    return {
+      content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+    };
+  }
+  callSightmapListViews(args) {
+    const input = {};
+    if (args["detail"] === "summary" || args["detail"] === "full") {
+      input.detail = args["detail"];
+    } else if (args["detail"] !== void 0) {
+      return errorResult(
+        `sightmap_list_views: detail must be "summary" or "full".`
+      );
+    }
+    const output = handleListViews(this.sightmap, input);
+    return {
+      content: [{ type: "text", text: JSON.stringify(output, null, 2) }]
+    };
+  }
+};
+function errorResult(text) {
+  return {
+    content: [{ type: "text", text }],
+    isError: true
+  };
+}
+function isSightmapTool(name) {
+  return name.startsWith("sightmap_");
+}
+function parsePageUrl(text) {
+  const m = /Page URL:\s*(\S+)/.exec(text);
+  return m?.[1] ?? null;
+}
+function buildInPageEvalFunction(components) {
+  const componentsJson = JSON.stringify(components);
+  return `() => {
+    const components = ${componentsJson};
+    const matches = components.map((c) => {
+      const selectors = c.selector || [];
+      const seen = new Set();
+      const elements = [];
+      for (const sel of selectors) {
+        try {
+          const found = document.querySelectorAll(sel);
+          for (const el of Array.from(found)) {
+            if (!seen.has(el)) {
+              seen.add(el);
+              elements.push(el);
+            }
+          }
+        } catch {
+          // Invalid selector \u2014 skip silently.
+        }
+      }
+      const first = elements[0];
+      let samplePosition;
+      if (first && typeof first.getBoundingClientRect === "function") {
+        const r = first.getBoundingClientRect();
+        samplePosition = { x: r.x, y: r.y, width: r.width, height: r.height };
+      }
+      return {
+        name: c.name,
+        selector: selectors,
+        matchCount: elements.length,
+        samplePosition,
+      };
+    });
+    return { url: window.location.href, matches };
+  }`;
+}
+function parseInPageEvalResult(text) {
+  const afterResult = text.split(/^###\s*Result/im)[1] ?? text;
+  const start = afterResult.indexOf("{");
+  if (start < 0) return [];
+  for (let end = afterResult.length; end > start; end--) {
+    try {
+      const parsed = JSON.parse(afterResult.slice(start, end));
+      if (Array.isArray(parsed.matches)) {
+        return parsed.matches.filter(isInPageMatch);
+      }
+    } catch {
+    }
+  }
+  return [];
+}
+function decodeMcpEvalResult(text) {
+  const afterResult = text.split(/^###\s*Result/im)[1] ?? "";
+  const trimmed = afterResult.trim();
+  if (trimmed.length === 0) return void 0;
+  for (let end = trimmed.length; end > 0; end--) {
+    try {
+      return JSON.parse(trimmed.slice(0, end));
+    } catch {
+    }
+  }
+  return void 0;
+}
+function isInPageMatch(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  return typeof v["name"] === "string" && typeof v["matchCount"] === "number";
+}
+
+// src/upstream.ts
+var McpClientUpstream = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async listTools() {
+    const r = await this.client.listTools();
+    return r.tools.map((t) => ({
+      name: t.name,
+      description: t.description ?? "",
+      inputSchema: t.inputSchema
+    }));
+  }
+  async callTool(name, args) {
+    const raw = await this.client.callTool({
+      name,
+      arguments: args
+    });
+    const content = (raw.content ?? []).map((block) => {
+      if (block.type === "text" && typeof block.text === "string") {
+        return { type: "text", text: block.text };
+      }
+      return {
+        type: "text",
+        text: stringifyNonTextBlock(block)
+      };
+    });
+    return {
+      content: content.length > 0 ? content : [{ type: "text", text: "" }],
+      ...raw.isError === true ? { isError: true } : {}
+    };
+  }
+};
+function stringifyNonTextBlock(block) {
+  const parts = [`[${block.type}]`];
+  if (block.mimeType) parts.push(`mimeType=${block.mimeType}`);
+  if (typeof block.data === "string") {
+    const preview = block.data.length > 64 ? block.data.slice(0, 64) + "\u2026" : block.data;
+    parts.push(`data=${preview}`);
+  }
+  return parts.join(" ");
+}
+
+// src/mcpServer.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+function buildMcpServer(dispatcher) {
+  const server = new Server(
+    { name: "sightmap-mcp", version: "0.0.0" },
+    { capabilities: { tools: {}, prompts: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    const tools = await dispatcher.listToolsAsync();
+    return { tools };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const name = req.params.name;
+    const args = req.params.arguments ?? {};
+    const result = await dispatcher.callTool(name, args);
+    return result;
+  });
+  server.setRequestHandler(ListPromptsRequestSchema, async () => {
+    return { prompts: dispatcher.listPrompts() };
+  });
+  server.setRequestHandler(GetPromptRequestSchema, async (req) => {
+    const name = req.params.name;
+    const args = req.params.arguments ?? {};
+    return dispatcher.getPrompt(name, args);
+  });
+  return server;
+}
+
+// src/cli.ts
+function parseArgv(argv) {
+  const collectedDirs = [];
+  let explicitCurateRoot;
+  const out = {
+    sightmapDirs: [],
+    curateRoot: "",
+    upstreamCommand: "npx",
+    upstreamArgs: ["-y", "@playwright/mcp@latest"]
+  };
+  let i = 0;
+  while (i < argv.length) {
+    const a = argv[i] ?? "";
+    if (a === "--sightmap-dir") {
+      const v = argv[++i];
+      if (v !== void 0) collectedDirs.push(v);
+    } else if (a.startsWith("--sightmap-dir=")) {
+      collectedDirs.push(a.slice("--sightmap-dir=".length));
+    } else if (a === "--curate-root") {
+      const v = argv[++i];
+      if (v !== void 0) explicitCurateRoot = v;
+    } else if (a.startsWith("--curate-root=")) {
+      explicitCurateRoot = a.slice("--curate-root=".length);
+    } else if (a === "--upstream-command") {
+      out.upstreamCommand = argv[++i] ?? out.upstreamCommand;
+    } else if (a === "--") {
+      out.upstreamArgs = argv.slice(i + 1);
+      i = argv.length;
+    } else if (a === "--help" || a === "-h") {
+      printHelp();
+      process.exit(0);
+    } else {
+      process.stderr.write(`sightmap-mcp: unknown argument: ${a}
+`);
+      printHelp();
+      process.exit(2);
+    }
+    i++;
+  }
+  out.sightmapDirs = collectedDirs.length > 0 ? collectedDirs : [".sightmap"];
+  out.curateRoot = explicitCurateRoot !== void 0 ? resolve(explicitCurateRoot) : resolve(out.sightmapDirs[0]);
+  return out;
+}
+function printHelp() {
+  process.stderr.write(
+    [
+      "Usage: sightmap-mcp [options]",
+      "",
+      "  --sightmap-dir <path>     Directory of sightmap YAML files. Repeatable.",
+      "                            Default: .sightmap",
+      "  --curate-root <path>      Writable .sightmap/ for curation tools.",
+      "                            Default: the first --sightmap-dir.",
+      "  --upstream-command <cmd>  Command to spawn the upstream MCP server. Default: npx",
+      "  -- <args...>              Args for the upstream command. Default: -y @playwright/mcp@latest",
+      "  -h, --help                Show this help and exit",
+      ""
+    ].join("\n")
+  );
+}
+async function main() {
+  const args = parseArgv(process.argv.slice(2));
+  const { mergeSightmaps: mergeSightmaps2 } = await Promise.resolve().then(() => (init_loadMerged(), loadMerged_exports));
+  const sightmap = await mergeSightmaps2(args.sightmapDirs.map((d) => resolve(d)));
+  if (sightmap.diagnostics.some((d) => d.severity === "error")) {
+    process.stderr.write(
+      `sightmap-mcp: ${sightmap.diagnostics.length} diagnostic(s) loading sightmap; continuing
+`
+    );
+  }
+  const upstreamTransport = new StdioClientTransport({
+    command: args.upstreamCommand,
+    args: args.upstreamArgs
+  });
+  const upstreamClient = new Client(
+    { name: "sightmap-mcp-bridge", version: "0.0.0" },
+    { capabilities: {} }
+  );
+  await upstreamClient.connect(upstreamTransport);
+  const dispatcher = new SightmapMcpServer({
+    sightmap,
+    upstream: new McpClientUpstream(upstreamClient),
+    curateRoot: args.curateRoot
+  });
+  const server = buildMcpServer(dispatcher);
+  await server.connect(new StdioServerTransport());
+  const cleanup = async () => {
+    try {
+      await upstreamClient.close();
+    } catch {
+    }
+    process.exit(0);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+}
+var isMain = process.argv[1] !== void 0 && (process.argv[1].endsWith("/cli.js") || process.argv[1].endsWith("\\cli.js"));
+if (isMain) {
+  main().catch((err) => {
+    const msg = err instanceof Error ? err.stack ?? err.message : String(err);
+    process.stderr.write(`sightmap-mcp: fatal: ${msg}
+`);
+    process.exit(1);
+  });
+}
+export {
+  parseArgv
+};
+//# sourceMappingURL=cli.js.map