@sightmap/mcp 0.7.1 → 0.9.0

package/dist/index.js

@@ -191,6 +191,22 @@ async function handleUpdateView(input) {
   if (input.patch.memory_replace) {
     after.memory = [...input.patch.memory_replace];
   }
+  if (input.patch.name !== void 0) {
+    after.name = input.patch.name;
+  }
+  if (input.patch.route !== void 0) {
+    after.route = input.patch.route;
+  }
+  if (input.patch.components !== void 0) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const c2 of input.patch.components) {
+      if (seen.has(c2.name)) {
+        throw new Error(`duplicate component name in patch: ${c2.name}`);
+      }
+      seen.add(c2.name);
+    }
+    after.components = input.patch.components;
+  }
   const nextViews = [...views];
   nextViews[idx] = after;
   const nextDoc = stripFragmentBrand(parsed);
@@ -210,23 +226,108 @@ function stripFragmentBrand(input) {
   return out;
 }
 
+// src/tools/curate/add.ts
+import { writeFile as writeFile2, readFile as readFile4, readdir as readdir2 } from "fs/promises";
+import { resolve, join as join2 } from "path";
+import {
+  format as format2,
+  canonicalize as canonicalize2
+} from "@sightmap/sightmap";
+async function handleAddView(input) {
+  await ensureNotExists(input.sightmapDir, input.view.name);
+  const filename = input.file ?? kebab(input.view.name) + ".yaml";
+  const path = join2(input.sightmapDir, filename);
+  const doc = {
+    version: 1,
+    views: [input.view]
+  };
+  const out = format2(doc);
+  const c = canonicalize2(out, { file: path });
+  const text = c.kind === "canonical" ? c.text : out;
+  await writeFile2(path, text, "utf8");
+  return { ok: true, file: path, written: input.view };
+}
+async function ensureNotExists(dir, name) {
+  let files;
+  try {
+    files = await readdir2(dir);
+  } catch {
+    return;
+  }
+  for (const f of files) {
+    if (!f.endsWith(".yaml")) continue;
+    const text = await readFile4(resolve(dir, f), "utf8");
+    if (new RegExp(`(^|\\n)\\s*-\\s+name:\\s+${escapeRe(name)}(\\s|$)`).test(text)) {
+      throw new Error(`view "${name}" already exists in ${f}`);
+    }
+  }
+}
+function kebab(s) {
+  return s.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/tools/curate/remove.ts
+import { readFile as readFile5, writeFile as writeFile3, unlink, readdir as readdir3 } from "fs/promises";
+import { resolve as resolve2 } from "path";
+import {
+  parse as parse4,
+  format as format3,
+  canonicalize as canonicalize3
+} from "@sightmap/sightmap";
+async function handleDeleteView(input) {
+  const entries = await readdir3(input.sightmapDir);
+  for (const entry of entries) {
+    if (!entry.endsWith(".yaml")) continue;
+    const path = resolve2(input.sightmapDir, entry);
+    const text = await readFile5(path, "utf8");
+    const parsed = parse4(text, { sourceFile: path });
+    const views = parsed.views ?? [];
+    const idx = views.findIndex((v) => v.name === input.name);
+    if (idx < 0) continue;
+    const remaining = views.filter((_, i) => i !== idx);
+    if (remaining.length === 0) {
+      await unlink(path);
+      return { ok: true, file: path, fileDeleted: true };
+    }
+    const nextDoc = stripFragmentBrand2(parsed);
+    nextDoc.views = remaining;
+    const out = format3(nextDoc);
+    const c = canonicalize3(out, { file: path });
+    const finalText = c.kind === "canonical" ? c.text : out;
+    await writeFile3(path, finalText, "utf8");
+    return { ok: true, file: path, fileDeleted: false };
+  }
+  throw new Error(`view "${input.name}" not found in ${input.sightmapDir}`);
+}
+function stripFragmentBrand2(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";
+import { mkdir, writeFile as writeFile4, access } from "fs/promises";
+import { join as join3 } from "path";
 
 // src/curate/scaffolder.ts
-import { format as format2, canonicalize as canonicalize2 } from "@sightmap/sightmap";
+import { format as format4, canonicalize as canonicalize4 } from "@sightmap/sightmap";
 function makeStarterSightmap() {
-  const text = format2({ version: 1 });
-  const c = canonicalize2(text, { file: "app.yaml" });
+  const text = format4({ version: 1 });
+  const c = canonicalize4(text, { file: "app.yaml" });
   return c.kind === "canonical" ? c.text : text;
 }
 
 // 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");
+  const sightmapDir = join3(root, ".sightmap");
+  const appFile = join3(sightmapDir, "app.yaml");
   if (input.force !== true) {
     let exists = false;
     try {
@@ -241,10 +342,485 @@ async function handleInitProject(input) {
     }
   }
   await mkdir(sightmapDir, { recursive: true });
-  await writeFile2(appFile, makeStarterSightmap(), "utf8");
+  await writeFile4(appFile, makeStarterSightmap(), "utf8");
   return { ok: true, files: [appFile] };
 }
 
+// src/tools/runtime/snapshot.ts
+async function handleRuntimeSnapshot(input, deps = {}) {
+  if (input.source.kind === "endpoint") {
+    return runEndpoint(input.source);
+  }
+  if (input.source.kind === "literal") {
+    return runLiteral(input.source);
+  }
+  return runBrowser(input.source, deps);
+}
+async function runEndpoint(source) {
+  const res = await fetch(source.url);
+  if (res.status === 404) {
+    let detail = "";
+    try {
+      const body = await res.json();
+      detail = body.error ?? "";
+    } catch {
+    }
+    throw new Error(
+      `no snapshot cached yet at ${source.url}${detail ? `: ${detail}` : ""}`
+    );
+  }
+  if (!res.ok) {
+    throw new Error(`snapshot fetch failed: HTTP ${res.status}`);
+  }
+  const snapshot = await res.json();
+  return { ok: true, snapshot, source };
+}
+var REQUIRED_SNAPSHOT_FIELDS = [
+  "capturedAt",
+  "route",
+  "components",
+  "markers",
+  "unmarkedCandidates"
+];
+function runLiteral(source) {
+  validateSnapshotShape(source.snapshot, "literal");
+  return { ok: true, snapshot: source.snapshot, source };
+}
+function validateSnapshotShape(value, label) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(
+      `${label} snapshot: expected an object with fields { capturedAt, route, components, markers, unmarkedCandidates }; got ${value === null ? "null" : Array.isArray(value) ? "array" : typeof value}`
+    );
+  }
+  const s = value;
+  for (const field of REQUIRED_SNAPSHOT_FIELDS) {
+    if (!(field in s)) {
+      throw new Error(`${label} snapshot: missing required field \`${field}\``);
+    }
+  }
+  if (!Array.isArray(s["components"])) {
+    throw new Error(`${label} snapshot: \`components\` must be an array`);
+  }
+  if (!Array.isArray(s["markers"])) {
+    throw new Error(`${label} snapshot: \`markers\` must be an array`);
+  }
+  if (!Array.isArray(s["unmarkedCandidates"])) {
+    throw new Error(`${label} snapshot: \`unmarkedCandidates\` must be an array`);
+  }
+}
+async function runBrowser(source, deps) {
+  if (deps.upstream === void 0) {
+    throw new Error(
+      "browser-mode snapshot requires an upstream MCP server (e.g., @playwright/mcp). Run sightmap-mcp without `--curate-only` so the @playwright/mcp passthrough is wired up."
+    );
+  }
+  const upstream = deps.upstream;
+  const wantInject = source.inject === true;
+  const allowAutoInject = source.inject === void 0;
+  const urls = source.routes !== void 0 && source.routes.length > 0 ? source.routes.map((r) => absolutize(r, source.url)) : [source.url];
+  const captures = [];
+  for (const targetUrl of urls) {
+    const captureOpts = {
+      forceInject: wantInject,
+      autoInject: allowAutoInject
+    };
+    if (deps.getInjectScript !== void 0) {
+      captureOpts.getInjectScript = deps.getInjectScript;
+    }
+    const cap = await captureOneUrl(upstream, targetUrl, captureOpts);
+    validateSnapshotShape(cap, "browser");
+    captures.push({ url: targetUrl, snapshot: cap });
+  }
+  if (source.routes === void 0 || source.routes.length === 0) {
+    return { ok: true, snapshot: captures[0].snapshot, source };
+  }
+  return { ok: true, snapshots: captures, source };
+}
+function absolutize(routeOrUrl, baseUrl) {
+  try {
+    return new URL(routeOrUrl).toString();
+  } catch {
+    const base = new URL(baseUrl);
+    return new URL(routeOrUrl, base).toString();
+  }
+}
+async function captureOneUrl(upstream, url, opts) {
+  const navResult = await upstream.callTool("browser_navigate", { url });
+  if (navResult.isError === true) {
+    throw new Error(
+      `browser_navigate to ${url} failed: ${navResult.content[0]?.text ?? "unknown error"}`
+    );
+  }
+  const probe = await evalAndDecode(
+    upstream,
+    `() => typeof (window.__sightmap__ && window.__sightmap__.snapshot)`
+  );
+  const hasHook = probe === "function";
+  if (!hasHook && (opts.forceInject || opts.autoInject)) {
+    if (opts.getInjectScript === void 0) {
+      throw new Error(
+        "browser-mode snapshot: page has no window.__sightmap__ and no inject script provider was configured. Install @sightmap/react in the target app, or wire `getInjectScript` into the MCP server."
+      );
+    }
+    const script = await opts.getInjectScript();
+    const wrapped = `() => { ${script}
+; return typeof (window.__sightmap__ && window.__sightmap__.snapshot); }`;
+    const injectResult = await evalAndDecode(upstream, wrapped);
+    if (injectResult !== "function") {
+      throw new Error(
+        `browser-mode snapshot: inject script did not install window.__sightmap__.snapshot (typeof after inject: ${String(injectResult)}). The target page may not be a React app.`
+      );
+    }
+  } else if (!hasHook && opts.forceInject === false && opts.autoInject === false) {
+    throw new Error(
+      "browser-mode snapshot: page has no window.__sightmap__.snapshot and `inject: false` was set. Either install @sightmap/react in the app or pass `inject: true`."
+    );
+  }
+  const snap = await evalAndDecode(
+    upstream,
+    `() => JSON.parse(JSON.stringify(window.__sightmap__.snapshot()))`
+  );
+  return snap;
+}
+async function evalAndDecode(upstream, fnSource) {
+  const r = await upstream.callTool("browser_evaluate", { function: fnSource });
+  if (r.isError === true) {
+    throw new Error(
+      `browser_evaluate failed: ${r.content[0]?.text ?? "unknown error"}`
+    );
+  }
+  const text = r.content.map((b) => b.text).join("\n");
+  return decodeEvalText(text);
+}
+function decodeEvalText(text) {
+  const afterResult = text.split(/^###\s*Result/im)[1] ?? text;
+  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;
+}
+
+// src/runtime/inject-script.ts
+import { createRequire } from "module";
+import { readFile as readFile6 } from "fs/promises";
+import { dirname, resolve as resolve3 } from "path";
+var cachedScript;
+async function getInjectScript() {
+  if (cachedScript !== void 0) return cachedScript;
+  const bippyIife = await loadBippyIife();
+  cachedScript = `${bippyIife}
+${BOOTSTRAP_SRC}`;
+  return cachedScript;
+}
+async function loadBippyIife() {
+  const require2 = createRequire(import.meta.url);
+  const bippyPkgJson = require2.resolve("bippy/package.json");
+  const iifePath = resolve3(dirname(bippyPkgJson), "dist/index.iife.js");
+  return readFile6(iifePath, "utf8");
+}
+var BOOTSTRAP_SRC = String.raw`
+(function () {
+  if (typeof window === "undefined") return;
+  if (!window.Bippy || typeof window.Bippy.instrument !== "function") return;
+  if (window.__sightmap__ && typeof window.__sightmap__.snapshot === "function") {
+    // Already installed (e.g. @sightmap/react is present). Don't double-wire.
+    return;
+  }
+
+  var trackedRoots = new Set();
+  window.Bippy.instrument({
+    onCommitFiberRoot: function (_id, root) {
+      trackedRoots.add(root);
+    },
+  });
+
+  var FRAMEWORK_NOISE = new Set([
+    "Routes", "Route", "RenderedRoute", "Outlet", "BrowserRouter",
+    "Router", "RouterProvider", "DataRouterProvider", "RouterProviderImpl",
+    "LinkWithRef", "StrictMode", "SightmapProvider", "Fragment", "Anonymous",
+    "Suspense", "ErrorBoundary", "Provider", "Consumer",
+    "ThemeProvider", "Hydration", "HydrateFallback",
+    "RemixErrorBoundary", "HydratedRouter", "DataRoutes",
+    "WithHydrateFallbackProps2", "RenderErrorBoundary", "Layout",
+  ]);
+
+  var HOST_PORTAL_TAG = 4;
+
+  function cssEsc(v) { return String(v).replace(/"/g, '\\"'); }
+  function isHumanShapedId(id) {
+    if (/[0-9]{6,}/.test(id)) return false;
+    if (/^[a-z]+-[a-f0-9]{8,}/i.test(id)) return false;
+    if (/:r[0-9a-z]+:/i.test(id)) return false;
+    return true;
+  }
+  function rankSelectors(el) {
+    var out = [];
+    var dsm = el.getAttribute("data-sightmap");
+    if (dsm !== null) {
+      out.push({ selector: '[data-sightmap="' + cssEsc(dsm) + '"]', stability: "high", source: "data-sightmap" });
+    }
+    ["data-testid", "data-cy", "data-test"].forEach(function (attr) {
+      var v = el.getAttribute(attr);
+      if (v !== null) {
+        out.push({ selector: "[" + attr + '="' + cssEsc(v) + '"]', stability: "high", source: attr });
+      }
+    });
+    var role = el.getAttribute("role");
+    var aria = el.getAttribute("aria-label");
+    if (role && aria) {
+      out.push({ selector: '[role="' + cssEsc(role) + '"][aria-label="' + cssEsc(aria) + '"]', stability: "medium", source: "aria" });
+    } else if (aria) {
+      out.push({ selector: '[aria-label="' + cssEsc(aria) + '"]', stability: "medium", source: "aria-label" });
+    }
+    var name = el.getAttribute("name");
+    if (name !== null && /^(form|input|button|select|textarea|nav)$/i.test(el.tagName)) {
+      out.push({ selector: el.tagName.toLowerCase() + '[name="' + cssEsc(name) + '"]', stability: "medium", source: "semantic-name" });
+    }
+    if (el.id && isHumanShapedId(el.id)) {
+      out.push({ selector: "#" + cssEsc(el.id), stability: "high", source: "id" });
+    }
+    return out;
+  }
+
+  function findHostElementForFiber(fiber) {
+    if (!fiber.child) return null;
+    var stack = [fiber.child];
+    var walks = 0;
+    while (stack.length > 0 && walks < 5000) {
+      walks++;
+      var f = stack.pop();
+      if (!f) continue;
+      if (f.sibling) stack.push(f.sibling);
+      if (f.tag === HOST_PORTAL_TAG) continue;
+      var sn = f.stateNode;
+      if (sn && typeof sn === "object" && "tagName" in sn && document.contains(sn)) {
+        return sn;
+      }
+      if (f.child) stack.push(f.child);
+    }
+    return null;
+  }
+
+  function bridgeDomToFiber(el) {
+    for (var i = 0, keys = Object.keys(el); i < keys.length; i++) {
+      if (keys[i].indexOf("__reactFiber$") === 0) return el[keys[i]] || null;
+    }
+    return null;
+  }
+
+  function nearestCompositeName(fiber) {
+    var f = fiber, walks = 0;
+    while (f && walks < 50) {
+      if (window.Bippy.isCompositeFiber(f)) {
+        var n = window.Bippy.getDisplayName(f);
+        if (n) return n;
+      }
+      f = f.return;
+      walks++;
+    }
+    return undefined;
+  }
+
+  function domDepth(el) {
+    var d = 0, cur = el.parentElement;
+    while (cur && cur !== document.body) { d++; cur = cur.parentElement; }
+    return d;
+  }
+
+  function collectComponents(rootFiber) {
+    var out = [];
+    var depthByFiber = new Map();
+    depthByFiber.set(rootFiber, 0);
+    window.Bippy.traverseFiber(rootFiber, function (f) {
+      var depth = depthByFiber.get(f) || 0;
+      var c = f.child;
+      while (c) { depthByFiber.set(c, depth + 1); c = c.sibling; }
+      if (!window.Bippy.isCompositeFiber(f)) return false;
+      var name = window.Bippy.getDisplayName(f);
+      if (!name) return false;
+      var childNames = [];
+      var cc = f.child;
+      while (cc) {
+        if (window.Bippy.isCompositeFiber(cc)) {
+          var n = window.Bippy.getDisplayName(cc);
+          if (n) childNames.push(n);
+        }
+        cc = cc.sibling;
+      }
+      out.push({ displayName: name, depth: depth, children: childNames });
+      return false;
+    });
+    return out;
+  }
+
+  function collectMarkers() {
+    var out = [];
+    if (typeof document === "undefined") return out;
+    var els = document.querySelectorAll("[data-sightmap]");
+    for (var i = 0; i < els.length; i++) {
+      var el = els[i];
+      var name = el.getAttribute("data-sightmap") || "";
+      var fiber = bridgeDomToFiber(el);
+      var nc = nearestCompositeName(fiber);
+      var marker = {
+        name: name,
+        hostTag: el.tagName.toLowerCase(),
+        domDepth: domDepth(el),
+        candidateSelectors: rankSelectors(el),
+      };
+      if (nc !== undefined) marker.nearestComponent = nc;
+      out.push(marker);
+    }
+    return out;
+  }
+
+  function collectUnmarkedCandidates(rootFiber) {
+    var out = [];
+    var seen = new Set();
+    window.Bippy.traverseFiber(rootFiber, function (f) {
+      if (!window.Bippy.isCompositeFiber(f)) return false;
+      var name = window.Bippy.getDisplayName(f);
+      if (!name || seen.has(name) || FRAMEWORK_NOISE.has(name)) return false;
+      seen.add(name);
+      var hostEl = findHostElementForFiber(f);
+      if (!hostEl) return false;
+      var selectors = rankSelectors(hostEl);
+      if (selectors.length === 0) return false;
+      out.push({
+        displayName: name,
+        hostTag: hostEl.tagName.toLowerCase(),
+        selectors: selectors,
+        domDepth: domDepth(hostEl),
+      });
+      return false;
+    });
+    return out;
+  }
+
+  function snapshot() {
+    var roots = Array.from(trackedRoots);
+    var now = new Date().toISOString();
+    var loc = (typeof window !== "undefined" && window.location)
+      ? (window.location.pathname + (window.location.search || ""))
+      : "?";
+    if (roots.length === 0) {
+      return { capturedAt: now, route: loc === "?" ? "?" : loc, commits: 0, components: [], markers: [], unmarkedCandidates: [] };
+    }
+    var root = roots.find(function (r) { return r.current && r.current.child !== null; }) || roots[0];
+    if (!root) {
+      return { capturedAt: now, route: loc === "?" ? "?" : loc, commits: 0, components: [], markers: [], unmarkedCandidates: [] };
+    }
+    var rootFiber = root.current;
+    return {
+      capturedAt: now,
+      route: loc,
+      commits: roots.length,
+      components: collectComponents(rootFiber),
+      markers: collectMarkers(),
+      unmarkedCandidates: collectUnmarkedCandidates(rootFiber),
+    };
+  }
+
+  window.__sightmap__ = { snapshot: snapshot };
+})();
+`;
+
+// src/tools/propose/store.ts
+var ProposalStore = class {
+  views = [];
+  components = [];
+  nextId = 1;
+  mintId(prefix) {
+    return `${prefix}_${this.nextId++}`;
+  }
+  appendView(p) {
+    const v = { id: this.mintId("v"), ...p };
+    this.views.push(v);
+    return v;
+  }
+  appendComponent(p) {
+    const c = { id: this.mintId("c"), ...p };
+    this.components.push(c);
+    return c;
+  }
+  review() {
+    return { views: [...this.views], components: [...this.components] };
+  }
+  commit(input = {}) {
+    if (!input.ids) {
+      const out = this.review();
+      this.views = [];
+      this.components = [];
+      return out;
+    }
+    const selected = new Set(input.ids);
+    const consumedViews = this.views.filter((v) => selected.has(v.id));
+    const consumedComponents = this.components.filter((c) => selected.has(c.id));
+    this.views = this.views.filter((v) => !selected.has(v.id));
+    this.components = this.components.filter((c) => !selected.has(c.id));
+    return { views: consumedViews, components: consumedComponents };
+  }
+};
+var proposalStore = new ProposalStore();
+
+// src/tools/propose/view.ts
+async function handleProposeView(input) {
+  const v = proposalStore.appendView(input);
+  return { ok: true, id: v.id };
+}
+
+// src/tools/propose/component.ts
+async function handleProposeComponent(input) {
+  const c = proposalStore.appendComponent(input);
+  return { ok: true, id: c.id };
+}
+
+// src/tools/propose/review.ts
+async function handleReviewProposals() {
+  return proposalStore.review();
+}
+
+// src/tools/propose/commit.ts
+async function handleCommitProposals(input) {
+  if (input.dry_run === true) {
+    const peek = proposalStore.review();
+    const selectedIds = input.ids ? new Set(input.ids) : null;
+    const filtered = {
+      views: selectedIds ? peek.views.filter((v) => selectedIds.has(v.id)) : peek.views,
+      components: selectedIds ? peek.components.filter((c) => selectedIds.has(c.id)) : peek.components
+    };
+    return { ok: true, committed: filtered, writes: [] };
+  }
+  const consumed = proposalStore.commit(
+    input.ids ? { ids: input.ids } : {}
+  );
+  const writes = [];
+  for (const v of consumed.views) {
+    const r = await handleAddView({
+      sightmapDir: input.sightmapDir,
+      view: {
+        name: v.name ?? deriveName(v.route),
+        route: v.route,
+        components: [],
+        ...v.intent !== void 0 ? { intent: v.intent } : {},
+        ...v.memory_notes && v.memory_notes.length > 0 ? { memory: v.memory_notes } : {}
+      }
+    });
+    writes.push({ kind: "view", file: r.file });
+  }
+  return { ok: true, committed: consumed, writes };
+}
+function deriveName(route) {
+  const parts = route.replace(/^\/+|\/+$/g, "").split("/").filter((p) => p.length > 0);
+  const last = parts[parts.length - 1] ?? "Index";
+  return last.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()).replace(/\s+/g, "");
+}
+
 // src/prompts/sepTrack.ts
 var VALID_PHASES = ["draft", "spec", "fixture", "verify"];
 function buildDraftPhase(args) {
@@ -502,7 +1078,7 @@ var SIGHTMAP_INIT_PROJECT = {
 };
 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.",
+  description: "Apply a patch to a view's fields. Accepts both semantic edits (description, intent, memory_append/memory_replace) and structural edits (name, route, components). Memory edits use either `memory_append` (default) or `memory_replace` \u2014 pass exactly one. Components is a full array replacement; use sightmap_add_view/sightmap_delete_view for whole-view lifecycle.",
   inputSchema: {
     type: "object",
     properties: {
@@ -513,7 +1089,22 @@ var SIGHTMAP_UPDATE_VIEW = {
           description: { type: "string" },
           intent: { type: "string" },
           memory_append: { type: "array", items: { type: "string" } },
-          memory_replace: { type: "array", items: { type: "string" } }
+          memory_replace: { type: "array", items: { type: "string" } },
+          name: { type: "string" },
+          route: { type: "string" },
+          components: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                name: { type: "string" },
+                selector: { type: "string" },
+                memory: { type: "array", items: { type: "string" } }
+              },
+              required: ["name", "selector"],
+              additionalProperties: true
+            }
+          }
         },
         additionalProperties: false
       }
@@ -522,6 +1113,164 @@ var SIGHTMAP_UPDATE_VIEW = {
     additionalProperties: false
   }
 };
+var SIGHTMAP_ADD_VIEW = {
+  name: "sightmap_add_view",
+  description: "Create a new view in a new .yaml file. Filename defaults to kebab(view.name) + '.yaml' unless overridden via `file`. Rejects names that collide with an existing view.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      view: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          route: { type: "string" },
+          description: { type: "string" },
+          memory: { type: "array", items: { type: "string" } },
+          components: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                name: { type: "string" },
+                selector: { type: "string" },
+                memory: { type: "array", items: { type: "string" } }
+              },
+              required: ["name", "selector"],
+              additionalProperties: true
+            }
+          }
+        },
+        required: ["name", "route"],
+        additionalProperties: true
+      },
+      file: {
+        type: "string",
+        description: "Optional filename hint (relative to the curate root). Defaults to kebab(view.name) + '.yaml'."
+      }
+    },
+    required: ["view"],
+    additionalProperties: false
+  }
+};
+var SIGHTMAP_RUNTIME_SNAPSHOT = {
+  name: "sightmap_runtime_snapshot",
+  description: "Fetch a SightmapSnapshot (fiber-tree introspection from bippy). Three sources:\n  - { kind: 'endpoint', url } \u2014 HTTP GET against the @sightmap/react Vite plugin endpoint (zero-config for Vite users).\n  - { kind: 'browser', url, routes?, inject? } \u2014 drive the live browser via @playwright/mcp; works on any React app (Webpack, RR 5.x, etc.) and, with `inject: true`, on apps that haven't installed @sightmap/react.\n  - { kind: 'literal', snapshot } \u2014 accept a pre-captured snapshot from any source (subtext live-eval-script, devtools console paste, custom Playwright scripts, CI capture). Validates the shape; returns it.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      source: {
+        type: "object",
+        oneOf: [
+          {
+            type: "object",
+            properties: {
+              kind: { type: "string", const: "endpoint" },
+              url: { type: "string", description: "Plugin endpoint URL, e.g. http://localhost:5173/__sightmap__/snapshot.json." }
+            },
+            required: ["kind", "url"],
+            additionalProperties: false
+          },
+          {
+            type: "object",
+            properties: {
+              kind: { type: "string", const: "browser" },
+              url: { type: "string", description: "Target URL to navigate to." },
+              routes: {
+                type: "array",
+                items: { type: "string" },
+                description: "Optional list of routes (absolute or relative to `url`) to capture in sequence."
+              },
+              inject: {
+                type: "boolean",
+                description: "When true, inject bippy + the snapshot bootstrap before navigation so non-@sightmap/react apps work. Omit to auto-inject only when the page lacks window.__sightmap__."
+              }
+            },
+            required: ["kind", "url"],
+            additionalProperties: false
+          },
+          {
+            type: "object",
+            properties: {
+              kind: { type: "string", const: "literal" },
+              snapshot: {
+                description: "A pre-captured SightmapSnapshot object. Must include capturedAt, route, components, markers, unmarkedCandidates."
+              }
+            },
+            required: ["kind", "snapshot"],
+            additionalProperties: false
+          }
+        ]
+      }
+    },
+    required: ["source"],
+    additionalProperties: false
+  }
+};
+var SIGHTMAP_PROPOSE_VIEW = {
+  name: "sightmap_propose_view",
+  description: "Stage a proposed view from runtime observation. Does NOT write disk. Use sightmap_commit_proposals to persist.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      route: { type: "string", description: "URL path for the observed view (e.g., '/dashboard')." },
+      name: { type: "string", description: "Optional display name. If omitted, derived from route at commit time." },
+      intent: { type: "string", description: "Optional one-liner describing the view's purpose." },
+      observed: { type: "string", description: "Free-form note about what was observed on this view." },
+      observed_components: { type: "array", items: { type: "string" } },
+      memory_notes: { type: "array", items: { type: "string" } }
+    },
+    required: ["route"],
+    additionalProperties: false
+  }
+};
+var SIGHTMAP_PROPOSE_COMPONENT = {
+  name: "sightmap_propose_component",
+  description: "Stage a proposed component observation. Does NOT write disk.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      name: { type: "string", description: "Component name (e.g., 'KpiCard')." },
+      selector_candidate: { type: "string", description: "Best-guess CSS selector for the component." },
+      observed_routes: { type: "array", items: { type: "string" } },
+      notes: { type: "array", items: { type: "string" } }
+    },
+    required: ["name"],
+    additionalProperties: false
+  }
+};
+var SIGHTMAP_REVIEW_PROPOSALS = {
+  name: "sightmap_review_proposals",
+  description: "Return the current staged proposals (views + components).",
+  inputSchema: {
+    type: "object",
+    properties: {},
+    additionalProperties: false
+  }
+};
+var SIGHTMAP_COMMIT_PROPOSALS = {
+  name: "sightmap_commit_proposals",
+  description: "Promote staged proposals to disk via add_view. Pass dry_run:true to preview without consuming the queue. Pass ids:[...] to commit a selection only.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      ids: { type: "array", items: { type: "string" }, description: "Optional subset of proposal ids to commit. Omit to commit everything." },
+      dry_run: { type: "boolean", description: "If true, preview without consuming the queue and without writing." }
+    },
+    additionalProperties: false
+  }
+};
+var SIGHTMAP_DELETE_VIEW = {
+  name: "sightmap_delete_view",
+  description: "Delete a view by name. If the containing .yaml file has only this view, the file is removed; otherwise the view is spliced out and the file rewritten.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      name: { type: "string" }
+    },
+    required: ["name"],
+    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.",
@@ -628,8 +1377,15 @@ var SightmapMcpServer = class {
       SIGHTMAP_LIST_VIEWS,
       SIGHTMAP_GET_VIEW,
       SIGHTMAP_CHECK,
+      SIGHTMAP_ADD_VIEW,
       SIGHTMAP_UPDATE_VIEW,
-      SIGHTMAP_INIT_PROJECT
+      SIGHTMAP_DELETE_VIEW,
+      SIGHTMAP_INIT_PROJECT,
+      SIGHTMAP_RUNTIME_SNAPSHOT,
+      SIGHTMAP_PROPOSE_VIEW,
+      SIGHTMAP_PROPOSE_COMPONENT,
+      SIGHTMAP_REVIEW_PROPOSALS,
+      SIGHTMAP_COMMIT_PROPOSALS
     ];
   }
   /** Full async list including upstream-proxied tools, if configured. */
@@ -639,8 +1395,15 @@ var SightmapMcpServer = class {
       SIGHTMAP_LIST_VIEWS,
       SIGHTMAP_GET_VIEW,
       SIGHTMAP_CHECK,
+      SIGHTMAP_ADD_VIEW,
       SIGHTMAP_UPDATE_VIEW,
-      SIGHTMAP_INIT_PROJECT
+      SIGHTMAP_DELETE_VIEW,
+      SIGHTMAP_INIT_PROJECT,
+      SIGHTMAP_RUNTIME_SNAPSHOT,
+      SIGHTMAP_PROPOSE_VIEW,
+      SIGHTMAP_PROPOSE_COMPONENT,
+      SIGHTMAP_REVIEW_PROPOSALS,
+      SIGHTMAP_COMMIT_PROPOSALS
     ];
     if (this.upstream !== void 0) {
       own.push(SIGHTMAP_SNAPSHOT, SIGHTMAP_ACT, SIGHTMAP_NETWORK_REQUESTS);
@@ -678,10 +1441,24 @@ var SightmapMcpServer = class {
           return this.callSightmapGetView(args);
         case "sightmap_check":
           return this.callSightmapCheck(args);
+        case "sightmap_add_view":
+          return this.callSightmapAddView(args);
         case "sightmap_update_view":
           return this.callSightmapUpdateView(args);
+        case "sightmap_delete_view":
+          return this.callSightmapDeleteView(args);
         case "sightmap_init_project":
           return this.callSightmapInitProject(args);
+        case "sightmap_runtime_snapshot":
+          return this.callSightmapRuntimeSnapshot(args);
+        case "sightmap_propose_view":
+          return this.callSightmapProposeView(args);
+        case "sightmap_propose_component":
+          return this.callSightmapProposeComponent(args);
+        case "sightmap_review_proposals":
+          return this.callSightmapReviewProposals();
+        case "sightmap_commit_proposals":
+          return this.callSightmapCommitProposals(args);
         case "sightmap_snapshot":
           return this.callSightmapSnapshot();
         case "sightmap_act":
@@ -924,6 +1701,196 @@ var SightmapMcpServer = class {
       return errorResult(err instanceof Error ? err.message : String(err));
     }
   }
+  async callSightmapRuntimeSnapshot(args) {
+    const source = args["source"];
+    if (source === null || typeof source !== "object" || Array.isArray(source)) {
+      return errorResult(
+        "sightmap_runtime_snapshot: required argument `source` (object) is missing."
+      );
+    }
+    const s = source;
+    const kind = s["kind"];
+    if (kind !== "endpoint" && kind !== "browser" && kind !== "literal") {
+      return errorResult(
+        "sightmap_runtime_snapshot: `source.kind` must be 'endpoint', 'browser', or 'literal'."
+      );
+    }
+    let input;
+    if (kind === "endpoint") {
+      if (typeof s["url"] !== "string" || s["url"].length === 0) {
+        return errorResult(
+          "sightmap_runtime_snapshot: endpoint mode requires `source.url` (string)."
+        );
+      }
+      input = { source: { kind: "endpoint", url: s["url"] } };
+    } else if (kind === "browser") {
+      if (typeof s["url"] !== "string" || s["url"].length === 0) {
+        return errorResult(
+          "sightmap_runtime_snapshot: browser mode requires `source.url` (string)."
+        );
+      }
+      const browserSrc = {
+        kind: "browser",
+        url: s["url"]
+      };
+      if (Array.isArray(s["routes"])) {
+        browserSrc.routes = s["routes"].filter(
+          (r) => typeof r === "string"
+        );
+      }
+      if (typeof s["inject"] === "boolean") {
+        browserSrc.inject = s["inject"];
+      }
+      input = { source: browserSrc };
+    } else {
+      if (!("snapshot" in s)) {
+        return errorResult(
+          "sightmap_runtime_snapshot: literal mode requires `source.snapshot`."
+        );
+      }
+      input = { source: { kind: "literal", snapshot: s["snapshot"] } };
+    }
+    try {
+      const deps = {
+        getInjectScript
+      };
+      if (this.upstream !== void 0) deps.upstream = this.upstream;
+      const result = await handleRuntimeSnapshot(input, deps);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    } catch (err) {
+      return errorResult(err instanceof Error ? err.message : String(err));
+    }
+  }
+  async callSightmapProposeView(args) {
+    if (typeof args["route"] !== "string" || args["route"].length === 0) {
+      return errorResult(
+        "sightmap_propose_view: required argument `route` (string) is missing or empty."
+      );
+    }
+    const input = { route: args["route"] };
+    if (typeof args["name"] === "string") input.name = args["name"];
+    if (typeof args["intent"] === "string") input.intent = args["intent"];
+    if (typeof args["observed"] === "string") input.observed = args["observed"];
+    if (Array.isArray(args["observed_components"])) {
+      input.observed_components = args["observed_components"].filter(
+        (s) => typeof s === "string"
+      );
+    }
+    if (Array.isArray(args["memory_notes"])) {
+      input.memory_notes = args["memory_notes"].filter(
+        (s) => typeof s === "string"
+      );
+    }
+    try {
+      const result = await handleProposeView(input);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    } catch (err) {
+      return errorResult(err instanceof Error ? err.message : String(err));
+    }
+  }
+  async callSightmapProposeComponent(args) {
+    if (typeof args["name"] !== "string" || args["name"].length === 0) {
+      return errorResult(
+        "sightmap_propose_component: required argument `name` (string) is missing or empty."
+      );
+    }
+    const input = { name: args["name"] };
+    if (typeof args["selector_candidate"] === "string") {
+      input.selector_candidate = args["selector_candidate"];
+    }
+    if (Array.isArray(args["observed_routes"])) {
+      input.observed_routes = args["observed_routes"].filter(
+        (s) => typeof s === "string"
+      );
+    }
+    if (Array.isArray(args["notes"])) {
+      input.notes = args["notes"].filter(
+        (s) => typeof s === "string"
+      );
+    }
+    try {
+      const result = await handleProposeComponent(input);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    } catch (err) {
+      return errorResult(err instanceof Error ? err.message : String(err));
+    }
+  }
+  async callSightmapReviewProposals() {
+    try {
+      const result = await handleReviewProposals();
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    } catch (err) {
+      return errorResult(err instanceof Error ? err.message : String(err));
+    }
+  }
+  async callSightmapCommitProposals(args) {
+    if (this.curateRoot === void 0) {
+      return errorResult(
+        "sightmap_commit_proposals: no writable sightmap dir configured (pass --curate-root or --sightmap-dir)."
+      );
+    }
+    const input = { sightmapDir: this.curateRoot };
+    if (Array.isArray(args["ids"])) {
+      input.ids = args["ids"].filter(
+        (s) => typeof s === "string"
+      );
+    }
+    if (args["dry_run"] === true) input.dry_run = true;
+    try {
+      const result = await handleCommitProposals(input);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    } catch (err) {
+      return errorResult(err instanceof Error ? err.message : String(err));
+    }
+  }
+  async callSightmapAddView(args) {
+    if (this.curateRoot === void 0) {
+      return errorResult(
+        "sightmap_add_view: no writable sightmap dir configured (pass --curate-root or --sightmap-dir)."
+      );
+    }
+    if (args["view"] === null || typeof args["view"] !== "object" || Array.isArray(args["view"])) {
+      return errorResult(
+        "sightmap_add_view: required argument `view` (object) is missing."
+      );
+    }
+    const view = args["view"];
+    if (typeof view["name"] !== "string" || view["name"].length === 0) {
+      return errorResult(
+        "sightmap_add_view: `view.name` (string) is required."
+      );
+    }
+    if (typeof view["route"] !== "string" || view["route"].length === 0) {
+      return errorResult(
+        "sightmap_add_view: `view.route` (string) is required."
+      );
+    }
+    const input = {
+      sightmapDir: this.curateRoot,
+      view
+    };
+    if (typeof args["file"] === "string" && args["file"].length > 0) {
+      input.file = args["file"];
+    }
+    try {
+      const result = await handleAddView(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(
@@ -953,6 +1920,29 @@ var SightmapMcpServer = class {
       return errorResult(err instanceof Error ? err.message : String(err));
     }
   }
+  async callSightmapDeleteView(args) {
+    if (this.curateRoot === void 0) {
+      return errorResult(
+        "sightmap_delete_view: no writable sightmap dir configured (pass --curate-root or --sightmap-dir)."
+      );
+    }
+    if (typeof args["name"] !== "string" || args["name"].length === 0) {
+      return errorResult(
+        "sightmap_delete_view: required argument `name` (string) is missing or empty."
+      );
+    }
+    try {
+      const result = await handleDeleteView({
+        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 callSightmapCheck(args) {
     const input = {};
     if (args["level"] === "schema" || args["level"] === "quality") {