@frontman-ai/astro 0.1.0

package/src/FrontmanAstro__Server.res

@@ -0,0 +1,196 @@
+// Request handlers for Frontman Astro endpoints
+
+module Protocol = FrontmanFrontmanProtocol
+module MCP = Protocol.FrontmanProtocol__MCP
+module Relay = Protocol.FrontmanProtocol__Relay
+module Core = FrontmanFrontmanCore
+module CoreServer = Core.FrontmanCore__Server
+module CoreSSE = Core.FrontmanCore__SSE
+module ToolRegistry = FrontmanAstro__ToolRegistry
+module Config = FrontmanAstro__Config
+module WebStreams = FrontmanBindings.WebStreams
+module DOMElementToComponentSource = FrontmanBindings.DOMElementToComponentSource
+
+// GET /frontman/tools
+let handleGetTools = (~registry: ToolRegistry.t, ~config: Config.t): WebAPI.FetchAPI.response => {
+  let response = CoreServer.getToolsResponse(
+    ~registry,
+    ~serverName=config.serverName,
+    ~serverVersion=config.serverVersion,
+  )
+
+  let json = response->S.reverseConvertToJsonOrThrow(Relay.toolsResponseSchema)
+  let headers = WebAPI.HeadersInit.fromDict(Dict.fromArray([("Content-Type", "application/json")]))
+  WebAPI.Response.jsonR(~data=json, ~init={headers: headers})
+}
+
+// POST /frontman/tools/call - executes tool with SSE streaming
+let handleToolCall = async (
+  ~registry: ToolRegistry.t,
+  ~config: Config.t,
+  req: WebAPI.FetchAPI.request,
+): WebAPI.FetchAPI.response => {
+  let body = await req->WebAPI.Request.json
+
+  let request = try {
+    Ok(body->S.parseOrThrow(Relay.toolCallRequestSchema))
+  } catch {
+  | S.Error(e) => Error(e.message)
+  }
+
+  switch request {
+  | Error(msg) =>
+    let errorResult: MCP.callToolResult = {
+      content: [{type_: "text", text: `Invalid request: ${msg}`}],
+      isError: Some(true),
+    }
+    let json = errorResult->S.reverseConvertToJsonOrThrow(MCP.callToolResultSchema)
+    WebAPI.Response.jsonR(~data=json, ~init={status: 400})
+
+  | Ok(request) =>
+    // Execute tool using core
+    let ctx: CoreServer.executionContext = {
+      projectRoot: config.projectRoot,
+      sourceRoot: config.sourceRoot,
+      onProgress: None,
+    }
+
+    let resultPromise = CoreServer.executeTool(
+      ~registry,
+      ~ctx,
+      ~name=request.name,
+      ~arguments=request.arguments,
+    )
+
+    let encoder = WebStreams.makeTextEncoder()
+    let stream = WebStreams.makeReadableStream({
+      start: controller => {
+        let _ = resultPromise->Promise.then(result => {
+          let mcpResult = CoreServer.resultToMCP(result)
+          let eventData = switch mcpResult.isError {
+          | Some(true) => CoreSSE.errorEvent(mcpResult)
+          | _ => CoreSSE.resultEvent(mcpResult)
+          }
+          controller->WebStreams.enqueue(encoder->WebStreams.encode(eventData))
+          controller->WebStreams.close
+          Promise.resolve()
+        })
+      },
+    })
+
+    WebAPI.Response.fromReadableStream(stream, ~init={headers: CoreSSE.headers()})
+  }
+}
+
+// Helper to convert absolute path to relative path (relative to sourceRoot)
+// If the path starts with sourceRoot, strip it; otherwise return as-is
+let toRelativePath = (absolutePath: string, sourceRoot: string): string => {
+  // Ensure sourceRoot ends with / for proper stripping
+  let normalizedRoot = if sourceRoot->String.endsWith("/") {
+    sourceRoot
+  } else {
+    sourceRoot ++ "/"
+  }
+
+  if absolutePath->String.startsWith(normalizedRoot) {
+    absolutePath->String.slice(~start=normalizedRoot->String.length, ~end=absolutePath->String.length)
+  } else if absolutePath->String.startsWith(sourceRoot) {
+    // Handle case where sourceRoot doesn't end with / but path matches exactly
+    absolutePath->String.slice(~start=sourceRoot->String.length, ~end=absolutePath->String.length)
+  } else {
+    absolutePath
+  }
+}
+
+// CORS headers for preflight requests
+let corsHeaders = () => {
+  WebAPI.HeadersInit.fromDict(
+    Dict.fromArray([
+      ("Access-Control-Allow-Origin", "*"),
+      ("Access-Control-Allow-Methods", "GET, POST, OPTIONS"),
+      ("Access-Control-Allow-Headers", "Content-Type"),
+    ]),
+  )
+}
+
+// Handle CORS preflight
+let handleCORS = (): WebAPI.FetchAPI.response => {
+  WebAPI.Response.fromNull(~init={status: 204, headers: corsHeaders()})
+}
+
+// POST /frontman/resolve-source-location - resolves source location via source maps
+let handleResolveSourceLocation = async (
+  ~config: Config.t,
+  req: WebAPI.FetchAPI.request,
+): WebAPI.FetchAPI.response => {
+  let body = await req->WebAPI.Request.json
+
+  let requestObj = body->JSON.Decode.object
+
+  switch requestObj {
+  | None =>
+    WebAPI.Response.jsonR(
+      ~data=JSON.Encode.object(Dict.fromArray([("error", JSON.Encode.string("Invalid request body"))])),
+      ~init={status: 400},
+    )
+  | Some(obj) =>
+    let componentName = obj->Dict.get("componentName")->Option.flatMap(JSON.Decode.string)
+    let file = obj->Dict.get("file")->Option.flatMap(JSON.Decode.string)
+    let line = obj->Dict.get("line")->Option.flatMap(JSON.Decode.float)
+    let column = obj->Dict.get("column")->Option.flatMap(JSON.Decode.float)
+
+    switch (componentName, file, line, column) {
+    | (Some(componentName), Some(file), Some(line), Some(column)) =>
+      try {
+        let sourceLocation: DOMElementToComponentSource.sourceLocation = {
+          componentName,
+          file,
+          line: line->Float.toInt,
+          column: column->Float.toInt,
+          componentProps: None,
+          parent: None,
+        }
+
+        let resolved = await DOMElementToComponentSource.resolveSourceLocationInServer(sourceLocation)
+
+        // Convert absolute path to relative path (relative to sourceRoot)
+        // This ensures the agent can use the path directly with MCP tools
+        let relativeFile = toRelativePath(resolved.file, config.sourceRoot)
+
+        let responseJson = JSON.Encode.object(
+          Dict.fromArray([
+            ("componentName", JSON.Encode.string(resolved.componentName)),
+            ("file", JSON.Encode.string(relativeFile)),
+            ("line", JSON.Encode.float(resolved.line->Int.toFloat)),
+            ("column", JSON.Encode.float(resolved.column->Int.toFloat)),
+          ]),
+        )
+
+        let headers = WebAPI.HeadersInit.fromDict(Dict.fromArray([("Content-Type", "application/json")]))
+        WebAPI.Response.jsonR(~data=responseJson, ~init={headers: headers})
+      } catch {
+      | exn =>
+        let msg =
+          exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("Unknown error")
+        WebAPI.Response.jsonR(
+          ~data=JSON.Encode.object(
+            Dict.fromArray([
+              ("error", JSON.Encode.string("Failed to resolve source location")),
+              ("details", JSON.Encode.string(msg)),
+            ]),
+          ),
+          ~init={status: 500},
+        )
+      }
+    | _ =>
+      WebAPI.Response.jsonR(
+        ~data=JSON.Encode.object(
+          Dict.fromArray([
+            ("error", JSON.Encode.string("Missing required fields: componentName, file, line, column")),
+          ]),
+        ),
+        ~init={status: 400},
+      )
+    }
+  }
+}

package/src/FrontmanAstro__Server.res.mjs

@@ -0,0 +1,241 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Web from "stream/web";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as FrontmanCore__SSE$FrontmanFrontmanCore from "@frontman/frontman-core/src/FrontmanCore__SSE.res.mjs";
+import * as Server from "dom-element-to-component-source/server";
+import * as FrontmanCore__Server$FrontmanFrontmanCore from "@frontman/frontman-core/src/FrontmanCore__Server.res.mjs";
+import * as FrontmanProtocol__MCP$FrontmanFrontmanProtocol from "@frontman/frontman-protocol/src/FrontmanProtocol__MCP.res.mjs";
+import * as FrontmanProtocol__Relay$FrontmanFrontmanProtocol from "@frontman/frontman-protocol/src/FrontmanProtocol__Relay.res.mjs";
+
+function handleGetTools(registry, config) {
+  let response = FrontmanCore__Server$FrontmanFrontmanCore.getToolsResponse(registry, config.serverName, config.serverVersion);
+  let json = S.reverseConvertToJsonOrThrow(response, FrontmanProtocol__Relay$FrontmanFrontmanProtocol.toolsResponseSchema);
+  let headers = Object.fromEntries([[
+      "Content-Type",
+      "application/json"
+    ]]);
+  return Response.json(json, {
+    headers: Primitive_option.some(headers)
+  });
+}
+
+async function handleToolCall(registry, config, req) {
+  let body = await req.json();
+  let request;
+  try {
+    request = {
+      TAG: "Ok",
+      _0: S.parseOrThrow(body, FrontmanProtocol__Relay$FrontmanFrontmanProtocol.toolCallRequestSchema)
+    };
+  } catch (raw_e) {
+    let e = Primitive_exceptions.internalToException(raw_e);
+    if (e.RE_EXN_ID === S.$$Error) {
+      request = {
+        TAG: "Error",
+        _0: e._1.message
+      };
+    } else {
+      throw e;
+    }
+  }
+  if (request.TAG === "Ok") {
+    let request$1 = request._0;
+    let ctx_projectRoot = config.projectRoot;
+    let ctx_sourceRoot = config.sourceRoot;
+    let ctx = {
+      projectRoot: ctx_projectRoot,
+      sourceRoot: ctx_sourceRoot,
+      onProgress: undefined
+    };
+    let resultPromise = FrontmanCore__Server$FrontmanFrontmanCore.executeTool(registry, ctx, request$1.name, request$1.arguments);
+    let encoder = new TextEncoder();
+    let stream = new Web.ReadableStream({
+      start: controller => {
+        resultPromise.then(result => {
+          let mcpResult = FrontmanCore__Server$FrontmanFrontmanCore.resultToMCP(result);
+          let match = mcpResult.isError;
+          let eventData = match !== undefined && match ? FrontmanCore__SSE$FrontmanFrontmanCore.errorEvent(mcpResult) : FrontmanCore__SSE$FrontmanFrontmanCore.resultEvent(mcpResult);
+          controller.enqueue(encoder.encode(eventData));
+          controller.close();
+          return Promise.resolve();
+        });
+      }
+    });
+    return new Response(stream, {
+      headers: Primitive_option.some(FrontmanCore__SSE$FrontmanFrontmanCore.headers())
+    });
+  }
+  let errorResult_content = [{
+      type: "text",
+      text: `Invalid request: ` + request._0
+    }];
+  let errorResult_isError = true;
+  let errorResult = {
+    content: errorResult_content,
+    isError: errorResult_isError
+  };
+  let json = S.reverseConvertToJsonOrThrow(errorResult, FrontmanProtocol__MCP$FrontmanFrontmanProtocol.callToolResultSchema);
+  return Response.json(json, {
+    status: 400
+  });
+}
+
+function toRelativePath(absolutePath, sourceRoot) {
+  let normalizedRoot = sourceRoot.endsWith("/") ? sourceRoot : sourceRoot + "/";
+  if (absolutePath.startsWith(normalizedRoot)) {
+    return absolutePath.slice(normalizedRoot.length, absolutePath.length);
+  } else if (absolutePath.startsWith(sourceRoot)) {
+    return absolutePath.slice(sourceRoot.length, absolutePath.length);
+  } else {
+    return absolutePath;
+  }
+}
+
+function corsHeaders() {
+  return Object.fromEntries([
+    [
+      "Access-Control-Allow-Origin",
+      "*"
+    ],
+    [
+      "Access-Control-Allow-Methods",
+      "GET, POST, OPTIONS"
+    ],
+    [
+      "Access-Control-Allow-Headers",
+      "Content-Type"
+    ]
+  ]);
+}
+
+function handleCORS() {
+  return new Response(null, {
+    status: 204,
+    headers: Primitive_option.some(corsHeaders())
+  });
+}
+
+async function handleResolveSourceLocation(config, req) {
+  let body = await req.json();
+  let requestObj = Stdlib_JSON.Decode.object(body);
+  if (requestObj === undefined) {
+    return Response.json(Object.fromEntries([[
+        "error",
+        "Invalid request body"
+      ]]), {
+      status: 400
+    });
+  }
+  let componentName = Stdlib_Option.flatMap(requestObj["componentName"], Stdlib_JSON.Decode.string);
+  let file = Stdlib_Option.flatMap(requestObj["file"], Stdlib_JSON.Decode.string);
+  let line = Stdlib_Option.flatMap(requestObj["line"], Stdlib_JSON.Decode.float);
+  let column = Stdlib_Option.flatMap(requestObj["column"], Stdlib_JSON.Decode.float);
+  if (componentName !== undefined && file !== undefined && line !== undefined && column !== undefined) {
+    try {
+      let sourceLocation_line = line | 0;
+      let sourceLocation_column = column | 0;
+      let sourceLocation = {
+        componentName: componentName,
+        file: file,
+        line: sourceLocation_line,
+        column: sourceLocation_column,
+        componentProps: undefined,
+        parent: undefined
+      };
+      let resolved = await Server.resolveSourceLocationInServer(sourceLocation);
+      let relativeFile = toRelativePath(resolved.file, config.sourceRoot);
+      let responseJson = Object.fromEntries([
+        [
+          "componentName",
+          resolved.componentName
+        ],
+        [
+          "file",
+          relativeFile
+        ],
+        [
+          "line",
+          resolved.line
+        ],
+        [
+          "column",
+          resolved.column
+        ]
+      ]);
+      let headers = Object.fromEntries([[
+          "Content-Type",
+          "application/json"
+        ]]);
+      return Response.json(responseJson, {
+        headers: Primitive_option.some(headers)
+      });
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      let msg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "Unknown error");
+      return Response.json(Object.fromEntries([
+        [
+          "error",
+          "Failed to resolve source location"
+        ],
+        [
+          "details",
+          msg
+        ]
+      ]), {
+        status: 500
+      });
+    }
+  }
+  return Response.json(Object.fromEntries([[
+      "error",
+      "Missing required fields: componentName, file, line, column"
+    ]]), {
+    status: 400
+  });
+}
+
+let Protocol;
+
+let MCP;
+
+let Relay;
+
+let Core;
+
+let CoreServer;
+
+let CoreSSE;
+
+let ToolRegistry;
+
+let Config;
+
+let WebStreams;
+
+let DOMElementToComponentSource;
+
+export {
+  Protocol,
+  MCP,
+  Relay,
+  Core,
+  CoreServer,
+  CoreSSE,
+  ToolRegistry,
+  Config,
+  WebStreams,
+  DOMElementToComponentSource,
+  handleGetTools,
+  handleToolCall,
+  toRelativePath,
+  corsHeaders,
+  handleCORS,
+  handleResolveSourceLocation,
+}
+/* S Not a pure module */

package/src/FrontmanAstro__ToolRegistry.res

@@ -0,0 +1,21 @@
+// Tool registry for Astro - composes core tools with Astro specific tools
+
+module Core = FrontmanFrontmanCore
+module CoreRegistry = Core.FrontmanCore__ToolRegistry
+
+// Re-export types from core
+type tool = CoreRegistry.tool
+type t = CoreRegistry.t
+
+// Astro specific tools
+let astroTools: array<tool> = [module(FrontmanAstro__Tool__GetPages)]
+
+let make = (): t => {
+  CoreRegistry.coreTools()->CoreRegistry.addTools(astroTools)
+}
+
+// Re-export functions from core
+let getToolByName = CoreRegistry.getToolByName
+let getToolDefinitions = CoreRegistry.getToolDefinitions
+let addTools = CoreRegistry.addTools
+let count = CoreRegistry.count

package/src/FrontmanAstro__ToolRegistry.res.mjs

@@ -0,0 +1,41 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as FrontmanAstro__Tool__GetPages$FrontmanAiAstro from "./tools/FrontmanAstro__Tool__GetPages.res.mjs";
+import * as FrontmanCore__ToolRegistry$FrontmanFrontmanCore from "@frontman/frontman-core/src/FrontmanCore__ToolRegistry.res.mjs";
+
+let astroTools = [{
+    name: FrontmanAstro__Tool__GetPages$FrontmanAiAstro.name,
+    description: FrontmanAstro__Tool__GetPages$FrontmanAiAstro.description,
+    inputSchema: FrontmanAstro__Tool__GetPages$FrontmanAiAstro.inputSchema,
+    outputSchema: FrontmanAstro__Tool__GetPages$FrontmanAiAstro.outputSchema,
+    execute: FrontmanAstro__Tool__GetPages$FrontmanAiAstro.execute,
+    visibleToAgent: true
+  }];
+
+function make() {
+  return FrontmanCore__ToolRegistry$FrontmanFrontmanCore.addTools(FrontmanCore__ToolRegistry$FrontmanFrontmanCore.coreTools(), astroTools);
+}
+
+let Core;
+
+let CoreRegistry;
+
+let getToolByName = FrontmanCore__ToolRegistry$FrontmanFrontmanCore.getToolByName;
+
+let getToolDefinitions = FrontmanCore__ToolRegistry$FrontmanFrontmanCore.getToolDefinitions;
+
+let addTools = FrontmanCore__ToolRegistry$FrontmanFrontmanCore.addTools;
+
+let count = FrontmanCore__ToolRegistry$FrontmanFrontmanCore.count;
+
+export {
+  Core,
+  CoreRegistry,
+  astroTools,
+  make,
+  getToolByName,
+  getToolDefinitions,
+  addTools,
+  count,
+}
+/* FrontmanAstro__Tool__GetPages-FrontmanAiAstro Not a pure module */

package/src/FrontmanAstro__ToolbarApp.res

@@ -0,0 +1,50 @@
+// Frontman Dev Toolbar App
+
+module Bindings = FrontmanAstro__AstroBindings
+
+// Type for the annotations API exposed on window
+type annotation = {
+  file: string,
+  loc: string,
+}
+
+type annotationsApi = {
+  get: WebAPI.DOMAPI.element => option<annotation>,
+  has: WebAPI.DOMAPI.element => bool,
+  size: unit => int,
+}
+
+// External binding to window.__frontman_annotations__
+@val @scope("window")
+external annotations: option<annotationsApi> = "__frontman_annotations__"
+
+// The toolbar app definition
+let app: Bindings.toolbarAppConfig = {
+  init: (_canvas, _app, _server) => {
+    switch annotations {
+    | Some(api) if api.size() > 0 =>
+      Console.log(`[Frontman] SUCCESS - Captured ${api.size()->Int.toString} elements`)
+
+      // Test retrieval on first h1 or body child
+      let testEl =
+        WebAPI.Global.document->WebAPI.Document.querySelector("h1")->Null.toOption
+      switch testEl {
+      | Some(el) =>
+        switch api.get(el) {
+        | Some(data) =>
+          Console.log(`[Frontman] Test element: H1 -> ${data.file}:${data.loc}`)
+        | None =>
+          Console.log("[Frontman] Test element H1 has no annotation (might be in layout)")
+        }
+      | None => ()
+      }
+    | Some(_) =>
+      Console.log("[Frontman] WARNING - Annotations API exists but captured 0 elements")
+    | None =>
+      Console.log("[Frontman] FAILED - window.__frontman_annotations__ not found")
+    }
+  },
+}
+
+// Export as default for Astro to pick up
+let default = Bindings.defineToolbarApp(app)

package/src/FrontmanAstro__ToolbarApp.res.mjs

@@ -0,0 +1,39 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Toolbar from "astro/toolbar";
+
+let app = {
+  init: (_canvas, _app, _server) => {
+    let api = window.__frontman_annotations__;
+    if (api !== undefined) {
+      if (api.size() > 0) {
+        console.log(`[Frontman] SUCCESS - Captured ` + api.size().toString() + ` elements`);
+        let testEl = document.querySelector("h1");
+        if (testEl === null) {
+          return;
+        }
+        let data = api.get(testEl);
+        if (data !== undefined) {
+          console.log(`[Frontman] Test element: H1 -> ` + data.file + `:` + data.loc);
+        } else {
+          console.log("[Frontman] Test element H1 has no annotation (might be in layout)");
+        }
+        return;
+      }
+      console.log("[Frontman] WARNING - Annotations API exists but captured 0 elements");
+      return;
+    }
+    console.log("[Frontman] FAILED - window.__frontman_annotations__ not found");
+  }
+};
+
+let $$default = Toolbar.defineToolbarApp(app);
+
+let Bindings;
+
+export {
+  Bindings,
+  app,
+  $$default as default,
+}
+/* default Not a pure module */