@frontman-ai/astro 0.1.0

package/src/cli/FrontmanAstro__Cli__Detect.res.mjs

@@ -0,0 +1,345 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Fs from "fs";
+import * as Nodepath from "node:path";
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+async function fileExists(path) {
+  try {
+    await Fs.promises.access(path);
+    return true;
+  } catch (exn) {
+    return false;
+  }
+}
+
+async function readFile(path) {
+  try {
+    return await Fs.promises.readFile(path, "utf8");
+  } catch (exn) {
+    return;
+  }
+}
+
+let astroPkgJsonSchema = S.schema(s => ({
+  version: s.m(S.string)
+}));
+
+async function detectAstroVersion(projectDir) {
+  let astroPkgPath = Nodepath.join(projectDir, "node_modules", "astro", "package.json");
+  let content = await readFile(astroPkgPath);
+  if (content === undefined) {
+    return;
+  }
+  try {
+    let pkg = S.parseJsonStringOrThrow(content, astroPkgJsonSchema);
+    let version = pkg.version;
+    let parts = version.split(".");
+    let match = parts[0];
+    let match$1 = parts[1];
+    if (match === undefined) {
+      return;
+    }
+    if (match$1 === undefined) {
+      return;
+    }
+    let major = Stdlib_Option.getOrThrow(Stdlib_Int.fromString(match, undefined), undefined);
+    let minorClean = match$1.split("-")[0];
+    let minor = Stdlib_Option.getOrThrow(Stdlib_Int.fromString(minorClean, undefined), undefined);
+    return {
+      major: major,
+      minor: minor,
+      raw: version
+    };
+  } catch (exn) {
+    return;
+  }
+}
+
+async function detectConfigFile(projectDir) {
+  let variants = [
+    "astro.config.mjs",
+    "astro.config.ts",
+    "astro.config.mts",
+    "astro.config.js"
+  ];
+  let check = async remaining => {
+    let name = remaining[0];
+    if (name === undefined) {
+      return;
+    }
+    let path = Nodepath.join(projectDir, name);
+    if (await fileExists(path)) {
+      return name;
+    }
+    let rest = remaining.slice(1, remaining.length);
+    return await check(rest);
+  };
+  return await check(variants);
+}
+
+let frontmanImportPattern = /@frontman-ai\/astro|@frontman\/frontman-astro|frontman-astro\/integration/;
+
+let hostPattern = /host:\s*['\"]([^'\"]+)['\"]/;
+
+async function analyzeFile(filePath) {
+  let content = await readFile(filePath);
+  if (content === undefined) {
+    return "NotFound";
+  }
+  if (!frontmanImportPattern.test(content)) {
+    return "NeedsManualEdit";
+  }
+  let result = hostPattern.exec(content);
+  if (result == null) {
+    return {
+      TAG: "HasFrontman",
+      host: ""
+    };
+  }
+  let maybeHost = Stdlib_Option.flatMap(result.slice(1)[0], x => x);
+  if (maybeHost !== undefined) {
+    return {
+      TAG: "HasFrontman",
+      host: maybeHost
+    };
+  } else {
+    return {
+      TAG: "HasFrontman",
+      host: ""
+    };
+  }
+}
+
+async function detectPackageManager(projectDir) {
+  let checkDir = async dir => {
+    let lockFiles = [
+      [
+        Nodepath.join(dir, "bun.lockb"),
+        "Bun"
+      ],
+      [
+        Nodepath.join(dir, "bun.lock"),
+        "Bun"
+      ],
+      [
+        Nodepath.join(dir, "deno.lock"),
+        "Deno"
+      ],
+      [
+        Nodepath.join(dir, "pnpm-lock.yaml"),
+        "Pnpm"
+      ],
+      [
+        Nodepath.join(dir, "yarn.lock"),
+        "Yarn"
+      ],
+      [
+        Nodepath.join(dir, "package-lock.json"),
+        "Npm"
+      ]
+    ];
+    let check = async remaining => {
+      let match = remaining[0];
+      if (match === undefined) {
+        return;
+      }
+      if (await fileExists(match[0])) {
+        return match[1];
+      }
+      let rest = remaining.slice(1, remaining.length);
+      return await check(rest);
+    };
+    return await check(lockFiles);
+  };
+  let parentDir = Nodepath.dirname(projectDir);
+  let grandparentDir = Nodepath.dirname(parentDir);
+  let dirsToCheck = [
+    projectDir,
+    parentDir,
+    grandparentDir
+  ].filter(d => {
+    if (d !== projectDir) {
+      return true;
+    } else {
+      return d === projectDir;
+    }
+  });
+  let seen = {};
+  let uniqueDirs = dirsToCheck.filter(d => {
+    let match = seen[d];
+    if (match !== undefined) {
+      return false;
+    } else {
+      seen[d] = true;
+      return true;
+    }
+  });
+  let tryDirs = async remaining => {
+    let dir = remaining[0];
+    if (dir === undefined) {
+      return "Npm";
+    }
+    let pm = await checkDir(dir);
+    if (pm !== undefined) {
+      return pm;
+    }
+    let rest = remaining.slice(1, remaining.length);
+    return await tryDirs(rest);
+  };
+  return await tryDirs(uniqueDirs);
+}
+
+async function hasPackageJson(projectDir) {
+  return await fileExists(Nodepath.join(projectDir, "package.json"));
+}
+
+async function detect(projectDir) {
+  let hasPackage = await hasPackageJson(projectDir);
+  if (!hasPackage) {
+    return {
+      TAG: "Error",
+      _0: "No package.json found. Please run from your Astro project root."
+    };
+  }
+  let astroVersion = await detectAstroVersion(projectDir);
+  if (astroVersion === undefined) {
+    return {
+      TAG: "Error",
+      _0: "Could not find Astro in node_modules. Please run 'npm install' first or verify this is an Astro project."
+    };
+  }
+  let name = await detectConfigFile(projectDir);
+  let configFileName = name !== undefined ? name : "astro.config.mjs";
+  let configPath = Nodepath.join(projectDir, configFileName);
+  let config = await analyzeFile(configPath);
+  let middlewareTsPath = Nodepath.join(projectDir, "src", "middleware.ts");
+  let middlewareJsPath = Nodepath.join(projectDir, "src", "middleware.js");
+  let match = await fileExists(middlewareTsPath) ? [
+      await analyzeFile(middlewareTsPath),
+      "src/middleware.ts"
+    ] : (
+      await fileExists(middlewareJsPath) ? [
+          await analyzeFile(middlewareJsPath),
+          "src/middleware.js"
+        ] : [
+          "NotFound",
+          "src/middleware.ts"
+        ]
+    );
+  let packageManager = await detectPackageManager(projectDir);
+  return {
+    TAG: "Ok",
+    _0: {
+      astroVersion: astroVersion,
+      config: config,
+      middleware: match[0],
+      configFileName: configFileName,
+      middlewareFileName: match[1],
+      packageManager: packageManager
+    }
+  };
+}
+
+function getPackageManagerCommand(pm) {
+  switch (pm) {
+    case "Npm" :
+      return "npm";
+    case "Yarn" :
+      return "npx yarn";
+    case "Pnpm" :
+      return "npx pnpm";
+    case "Bun" :
+      return "bun";
+    case "Deno" :
+      return "deno";
+  }
+}
+
+function getDevCommand(pm) {
+  switch (pm) {
+    case "Npm" :
+      return "npm run dev";
+    case "Yarn" :
+      return "yarn dev";
+    case "Pnpm" :
+      return "pnpm dev";
+    case "Bun" :
+      return "bun dev";
+    case "Deno" :
+      return "deno task dev";
+  }
+}
+
+function getInstallArgs(pm, isDevOpt) {
+  let isDev = isDevOpt !== undefined ? isDevOpt : false;
+  switch (pm) {
+    case "Npm" :
+      if (isDev) {
+        return [
+          "install",
+          "-D"
+        ];
+      } else {
+        return ["install"];
+      }
+    case "Yarn" :
+      if (isDev) {
+        return [
+          "add",
+          "-D"
+        ];
+      } else {
+        return ["add"];
+      }
+    case "Pnpm" :
+      if (isDev) {
+        return [
+          "add",
+          "--save-dev"
+        ];
+      } else {
+        return ["add"];
+      }
+    case "Bun" :
+    case "Deno" :
+      break;
+  }
+  if (isDev) {
+    return [
+      "add",
+      "--dev"
+    ];
+  } else {
+    return ["add"];
+  }
+}
+
+let Bindings;
+
+let Fs$1;
+
+let Path;
+
+export {
+  Bindings,
+  Fs$1 as Fs,
+  Path,
+  fileExists,
+  readFile,
+  astroPkgJsonSchema,
+  detectAstroVersion,
+  detectConfigFile,
+  frontmanImportPattern,
+  hostPattern,
+  analyzeFile,
+  detectPackageManager,
+  hasPackageJson,
+  detect,
+  getPackageManagerCommand,
+  getDevCommand,
+  getInstallArgs,
+}
+/* astroPkgJsonSchema Not a pure module */

package/src/cli/FrontmanAstro__Cli__Files.res

@@ -0,0 +1,244 @@
+// File operations module for CLI installer
+module Bindings = FrontmanBindings
+module Fs = Bindings.Fs
+module Path = Bindings.Path
+
+module Detect = FrontmanAstro__Cli__Detect
+module Templates = FrontmanAstro__Cli__Templates
+module AutoEdit = FrontmanAstro__Cli__AutoEdit
+module Style = FrontmanAstro__Cli__Style
+
+// Result type for file operations
+type fileResult =
+  | Created(string)
+  | Updated({fileName: string, oldHost: string, newHost: string})
+  | Skipped(string)
+  | ManualEditRequired({fileName: string, details: string})
+  | AutoEdited(string)
+
+// Pattern to match and replace host in existing file
+let hostPattern = %re("/host:\s*['\"]([^'\"]+)['\"]/")
+
+// Escape special replacement patterns ($1, $&, etc.) in a string used as
+// the replacement argument to String.replaceRegExp
+let escapeReplacement: string => string = %raw(`
+  function(str) { return str.replace(/\$/g, '$$$$'); }
+`)
+
+// Update host in existing file content
+let updateHostInContent = (content: string, newHost: string): string => {
+  let safeHost = escapeReplacement(newHost)
+  content->String.replaceRegExp(hostPattern, `host: '${safeHost}'`)
+}
+
+// Read file content
+let readFile = async (path: string): option<string> => {
+  try {
+    let content = await Fs.Promises.readFile(path)
+    Some(content)
+  } catch {
+  | _ => None
+  }
+}
+
+// Write file content
+let writeFile = async (path: string, content: string): result<unit, string> => {
+  try {
+    await Fs.Promises.writeFile(path, content)
+    Ok()
+  } catch {
+  | _ => Error(`Failed to write ${path}`)
+  }
+}
+
+// Info about a file that needs auto-editing (collected before prompting)
+type pendingAutoEdit = {
+  filePath: string,
+  fileName: string,
+  fileType: AutoEdit.fileType,
+  manualDetails: string,
+}
+
+// Handle the NeedsManualEdit case — when autoEdit is true, perform the edit;
+// when false, return manual instructions
+let handleNeedsManualEdit = async (
+  ~filePath: string,
+  ~fileName: string,
+  ~host: string,
+  ~fileType: AutoEdit.fileType,
+  ~dryRun: bool,
+  ~autoEdit: bool,
+  ~manualDetails: string,
+): result<fileResult, string> => {
+  switch dryRun {
+  | true => Ok(ManualEditRequired({fileName, details: manualDetails}))
+  | false =>
+    switch autoEdit {
+    | false => Ok(ManualEditRequired({fileName, details: manualDetails}))
+    | true =>
+      switch await readFile(filePath) {
+      | None => Ok(ManualEditRequired({fileName, details: manualDetails}))
+      | Some(existingContent) =>
+        switch await AutoEdit.autoEditFile(
+          ~filePath,
+          ~fileName,
+          ~existingContent,
+          ~fileType,
+          ~host,
+        ) {
+        | AutoEdit.AutoEdited(name) => Ok(AutoEdited(name))
+        | AutoEdit.AutoEditFailed(err) =>
+          Console.log(Templates.SuccessMessages.autoEditFailed(fileName, err))
+          Console.log(`     Falling back to manual instructions.`)
+          Ok(ManualEditRequired({fileName, details: manualDetails}))
+        }
+      }
+    }
+  }
+}
+
+// Check if a file handler would need auto-editing (without prompting)
+let getPendingAutoEdit = (
+  ~existingFile: Detect.existingFile,
+  ~filePath: string,
+  ~fileName: string,
+  ~fileType: AutoEdit.fileType,
+  ~manualDetails: string,
+): option<pendingAutoEdit> => {
+  switch existingFile {
+  | NeedsManualEdit => Some({filePath, fileName, fileType, manualDetails})
+  | NotFound | HasFrontman(_) => None
+  }
+}
+
+// Handle astro.config.mjs file
+let handleConfig = async (
+  ~projectDir: string,
+  ~host: string,
+  ~configFileName: string,
+  ~existingFile: Detect.existingFile,
+  ~dryRun: bool,
+  ~autoEdit: bool=false,
+): result<fileResult, string> => {
+  let filePath = Path.join([projectDir, configFileName])
+  let fileName = configFileName
+
+  switch existingFile {
+  | NotFound =>
+    switch dryRun {
+    | true => Ok(Created(fileName))
+    | false =>
+      let content = Templates.configTemplate(host)
+      switch await writeFile(filePath, content) {
+      | Ok() => Ok(Created(fileName))
+      | Error(e) => Error(e)
+      }
+    }
+
+  | HasFrontman({host: existingHost}) =>
+    // Config files don't contain host themselves (host is in middleware),
+    // so an empty existingHost means Frontman is already configured — skip.
+    switch existingHost == host || existingHost == "" {
+    | true => Ok(Skipped(fileName))
+    | false =>
+      switch dryRun {
+      | true => Ok(Updated({fileName, oldHost: existingHost, newHost: host}))
+      | false =>
+        switch await readFile(filePath) {
+        | None => Error(`Failed to read ${fileName}`)
+        | Some(content) =>
+          let newContent = updateHostInContent(content, host)
+          switch await writeFile(filePath, newContent) {
+          | Ok() => Ok(Updated({fileName, oldHost: existingHost, newHost: host}))
+          | Error(e) => Error(e)
+          }
+        }
+      }
+    }
+
+  | NeedsManualEdit =>
+    await handleNeedsManualEdit(
+      ~filePath,
+      ~fileName,
+      ~host,
+      ~fileType=AutoEdit.Config,
+      ~dryRun,
+      ~autoEdit,
+      ~manualDetails=Templates.ManualInstructions.config(fileName, host),
+    )
+  }
+}
+
+// Handle src/middleware.ts (or .js) file
+let handleMiddleware = async (
+  ~projectDir: string,
+  ~host: string,
+  ~middlewareFileName: string,
+  ~existingFile: Detect.existingFile,
+  ~dryRun: bool,
+  ~autoEdit: bool=false,
+): result<fileResult, string> => {
+  let filePath = Path.join([projectDir, middlewareFileName])
+  let fileName = middlewareFileName
+
+  switch existingFile {
+  | NotFound =>
+    switch dryRun {
+    | true => Ok(Created(fileName))
+    | false =>
+      // Ensure src/ directory exists
+      let srcDir = Path.join([projectDir, "src"])
+      let _ = await Fs.Promises.mkdir(srcDir, {recursive: true})
+      let content = Templates.middlewareTemplate(host)
+      switch await writeFile(filePath, content) {
+      | Ok() => Ok(Created(fileName))
+      | Error(e) => Error(e)
+      }
+    }
+
+  | HasFrontman({host: existingHost}) =>
+    // When analyzeFile can't extract a host (e.g. host: process.env.FRONTMAN_HOST),
+    // it returns HasFrontman({host: ""}). Treat empty host as already configured
+    // to avoid rewriting the file unchanged with a misleading "Updated" message.
+    switch existingHost == host || existingHost == "" {
+    | true => Ok(Skipped(fileName))
+    | false =>
+      switch dryRun {
+      | true => Ok(Updated({fileName, oldHost: existingHost, newHost: host}))
+      | false =>
+        switch await readFile(filePath) {
+        | None => Error(`Failed to read ${fileName}`)
+        | Some(content) =>
+          let newContent = updateHostInContent(content, host)
+          switch await writeFile(filePath, newContent) {
+          | Ok() => Ok(Updated({fileName, oldHost: existingHost, newHost: host}))
+          | Error(e) => Error(e)
+          }
+        }
+      }
+    }
+
+  | NeedsManualEdit =>
+    await handleNeedsManualEdit(
+      ~filePath,
+      ~fileName,
+      ~host,
+      ~fileType=AutoEdit.Middleware,
+      ~dryRun,
+      ~autoEdit,
+      ~manualDetails=Templates.ManualInstructions.middleware(fileName, host),
+    )
+  }
+}
+
+// Format file result for display (short one-liner)
+let formatResult = (result: fileResult): string => {
+  switch result {
+  | Created(fileName) => Templates.SuccessMessages.fileCreated(fileName)
+  | Updated({fileName, oldHost, newHost}) =>
+    Templates.SuccessMessages.hostUpdated(fileName, oldHost, newHost)
+  | Skipped(fileName) => Templates.SuccessMessages.fileSkipped(fileName)
+  | ManualEditRequired({fileName, _}) => Templates.SuccessMessages.manualEditRequired(fileName)
+  | AutoEdited(fileName) => Templates.SuccessMessages.fileAutoEdited(fileName)
+  }
+}