getrelay 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 VoltAgent
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,40 @@
+# RelayDesgins
+
+RelayDesgins runs through `npx getrelay@latest`.
+
+It lets users pick a website style from the bundled collection and creates `Relay.md` in the project where the command runs.
+
+## Use
+
+Local checkout:
+
+```bash
+node .\RelayDesgins\bin\relay.js
+```
+
+Public command:
+
+```bash
+npx getrelay@latest
+```
+
+Relay displays the website list, lets you choose one, and creates:
+
+```text
+Relay.md
+```
+
+Then tell your AI coding agent:
+
+```text
+Use Relay.md as the design source for this page.
+```
+
+## Commands
+
+```bash
+npx getrelay@latest
+npx getrelay@latest list
+npx getrelay@latest vercel
+npx getrelay@latest apple --out docs/Relay.md
+```

package/bin/relay.js

@@ -0,0 +1,362 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const fs = require("node:fs/promises");
+const fsSync = require("node:fs");
+const path = require("node:path");
+const process = require("node:process");
+const readline = require("node:readline/promises");
+const readlineSync = require("node:readline");
+
+const PACKAGE_ROOT = path.resolve(__dirname, "..");
+const DESIGN_ROOT = path.join(PACKAGE_ROOT, "design-md");
+const DEFAULT_OUTPUT_FILE = "Relay.md";
+const MENU_SIZE = 16;
+const color = {
+  reset: "\x1b[0m",
+  cyan: "\x1b[36m",
+  green: "\x1b[32m",
+  gray: "\x1b[90m",
+  inverse: "\x1b[7m",
+  bold: "\x1b[1m",
+  clearLine: "\x1b[2K",
+  cursorUp: (count) => `\x1b[${count}A`,
+};
+
+const helpText = `Relay
+
+Copy a website-inspired design file into the current project as Relay.md.
+
+Usage:
+  npx getrelay@latest                    Choose a layout interactively
+  npx getrelay@latest <layout>           Create Relay.md from a layout slug
+  npx getrelay@latest list               Show available layouts
+
+Options:
+  -o, --out <file>         Output file path. Default: Relay.md
+  -f, --force              Overwrite the output file if it already exists
+  -h, --help               Show help
+
+Examples:
+  npx getrelay@latest
+  npx getrelay@latest vercel
+  npx getrelay@latest apple --out docs/Relay.md
+  npx getrelay@latest list
+`;
+
+function parseArgs(argv) {
+  const options = {
+    command: null,
+    outFile: DEFAULT_OUTPUT_FILE,
+    force: false,
+    help: false,
+    list: false,
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+
+    if (arg === "-h" || arg === "--help") {
+      options.help = true;
+      continue;
+    }
+
+    if (arg === "-f" || arg === "--force") {
+      options.force = true;
+      continue;
+    }
+
+    if (arg === "-o" || arg === "--out") {
+      const value = argv[index + 1];
+      if (!value || value.startsWith("-")) {
+        throw new Error("Missing value for --out.");
+      }
+      options.outFile = value;
+      index += 1;
+      continue;
+    }
+
+    if (arg.startsWith("--out=")) {
+      const value = arg.slice("--out=".length);
+      if (!value) {
+        throw new Error("Missing value for --out.");
+      }
+      options.outFile = value;
+      continue;
+    }
+
+    if (arg.startsWith("-")) {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+
+    if (options.command) {
+      throw new Error(`Unexpected argument: ${arg}`);
+    }
+    options.command = arg;
+  }
+
+  if (options.command === "help") {
+    options.help = true;
+  }
+
+  if (options.command === "list" || options.command === "layouts") {
+    options.list = true;
+    options.command = null;
+  }
+
+  if (options.outFile.trim() === "") {
+    throw new Error("Output file path cannot be empty.");
+  }
+
+  return options;
+}
+
+async function loadLayouts() {
+  const entries = await fs.readdir(DESIGN_ROOT, { withFileTypes: true });
+  const layouts = [];
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+
+    const slug = entry.name;
+    const designPath = path.join(DESIGN_ROOT, slug, "DESIGN.md");
+
+    if (!fsSync.existsSync(designPath)) {
+      continue;
+    }
+
+    const content = await fs.readFile(designPath, "utf8");
+    layouts.push({
+      slug,
+      name: extractFrontmatterValue(content, "name") || toTitle(slug),
+      description: extractFrontmatterValue(content, "description") || "",
+      designPath,
+    });
+  }
+
+  return layouts.sort((left, right) => left.name.localeCompare(right.name));
+}
+
+function extractFrontmatterValue(content, key) {
+  const frontmatterEnd = content.indexOf("\n---", 3);
+  const frontmatter = frontmatterEnd === -1 ? content : content.slice(0, frontmatterEnd);
+  const pattern = new RegExp(`^${escapeRegExp(key)}:\\s*(.+)$`, "im");
+  const match = frontmatter.match(pattern);
+
+  if (!match) {
+    return "";
+  }
+
+  return match[1].trim().replace(/^["']|["']$/g, "");
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function toTitle(slug) {
+  return slug
+    .split(/[-.]/g)
+    .filter(Boolean)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join(" ");
+}
+
+function printLayouts(layouts) {
+  for (const layout of layouts) {
+    console.log(`${color.gray}${layout.slug.padEnd(16)}${color.reset} ${color.cyan}${layout.name}${color.reset}`);
+  }
+}
+
+async function chooseLayout(layouts) {
+  if (!process.stdin.isTTY) {
+    throw new Error("No layout was provided. Run `npx getrelay@latest list`, then pass a layout slug like `npx getrelay@latest vercel`.");
+  }
+
+  return chooseLayoutWithKeyboard(layouts);
+}
+
+function findLayout(layouts, value) {
+  const normalized = value.trim().toLowerCase();
+
+  if (!normalized) {
+    return null;
+  }
+
+  const number = Number.parseInt(normalized, 10);
+  if (String(number) === normalized && number >= 1 && number <= layouts.length) {
+    return layouts[number - 1];
+  }
+
+  return layouts.find((layout) => {
+    return layout.slug.toLowerCase() === normalized || layout.name.toLowerCase() === normalized;
+  });
+}
+
+async function confirmOverwrite(targetPath) {
+  if (!process.stdin.isTTY) {
+    return false;
+  }
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  try {
+    const answer = await rl.question(`${targetPath} already exists. Overwrite it? [y/N] `);
+    return answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes";
+  } finally {
+    rl.close();
+  }
+}
+
+async function copyLayout(layout, targetPath, force) {
+  const outputRoot = process.env.RELAY_OUTPUT_CWD || process.cwd();
+  const resolvedTarget = path.resolve(outputRoot, targetPath);
+
+  if (fsSync.existsSync(resolvedTarget) && !force) {
+    const overwrite = await confirmOverwrite(resolvedTarget);
+    if (!overwrite) {
+      return {
+        path: resolvedTarget,
+        skipped: true,
+      };
+    }
+  }
+
+  await fs.mkdir(path.dirname(resolvedTarget), { recursive: true });
+  await fs.copyFile(layout.designPath, resolvedTarget);
+
+  return {
+    path: resolvedTarget,
+    skipped: false,
+  };
+}
+
+function chooseLayoutWithKeyboard(layouts) {
+  return new Promise((resolve, reject) => {
+    let selectedIndex = 0;
+    let renderedLines = 0;
+
+    const render = () => {
+      if (renderedLines > 0) {
+        process.stdout.write(color.cursorUp(renderedLines));
+      }
+
+      const halfWindow = Math.floor(MENU_SIZE / 2);
+      const maxStart = Math.max(layouts.length - MENU_SIZE, 0);
+      const start = Math.min(Math.max(selectedIndex - halfWindow, 0), maxStart);
+      const visible = layouts.slice(start, start + MENU_SIZE);
+      const lines = [];
+
+      lines.push(`${color.bold}Choose the website layout to copy into Relay.md${color.reset}`);
+      lines.push(`${color.gray}Use Up/Down, Enter to select, Ctrl+C to quit.${color.reset}`);
+      lines.push("");
+
+      for (let offset = 0; offset < visible.length; offset += 1) {
+        const layout = visible[offset];
+        const index = start + offset;
+        const marker = index === selectedIndex ? ">" : " ";
+        const plainRow = `${marker} ${layout.name.padEnd(18)} ${layout.slug}`;
+        const colorRow = `${marker} ${color.cyan}${layout.name.padEnd(18)}${color.reset} ${color.gray}${layout.slug}${color.reset}`;
+        lines.push(index === selectedIndex ? `${color.inverse}${plainRow}${color.reset}` : colorRow);
+      }
+
+      lines.push("");
+      lines.push(`${color.gray}Enter selects the highlighted website.${color.reset}`);
+
+      for (const line of lines) {
+        process.stdout.write(`${color.clearLine}${line}\n`);
+      }
+
+      renderedLines = lines.length;
+    };
+
+    const cleanup = () => {
+      process.stdin.off("keypress", onKeypress);
+      if (process.stdin.isRaw) {
+        process.stdin.setRawMode(false);
+      }
+      process.stdin.pause();
+    };
+
+    const onKeypress = (_text, key) => {
+      if (key.name === "c" && key.ctrl) {
+        cleanup();
+        process.stdout.write("\n");
+        reject(new Error("Aborted."));
+        return;
+      }
+
+      if (key.name === "up") {
+        selectedIndex = selectedIndex === 0 ? layouts.length - 1 : selectedIndex - 1;
+        render();
+        return;
+      }
+
+      if (key.name === "down") {
+        selectedIndex = selectedIndex === layouts.length - 1 ? 0 : selectedIndex + 1;
+        render();
+        return;
+      }
+
+      if (key.name === "return" || key.name === "enter") {
+        const layout = layouts[selectedIndex];
+        cleanup();
+        process.stdout.write("\n");
+        resolve(layout);
+      }
+    };
+
+    readlineSync.emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on("keypress", onKeypress);
+    render();
+  });
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+
+  if (options.help) {
+    console.log(helpText);
+    return;
+  }
+
+  const layouts = await loadLayouts();
+  if (layouts.length === 0) {
+    throw new Error(`No layouts were found in ${DESIGN_ROOT}.`);
+  }
+
+  if (options.list) {
+    printLayouts(layouts);
+    return;
+  }
+
+  const layout = options.command ? findLayout(layouts, options.command) : await chooseLayout(layouts);
+  if (!layout) {
+    throw new Error(`Unknown layout: ${options.command}. Run \`relay list\` to see available layouts.`);
+  }
+
+  const result = await copyLayout(layout, options.outFile, options.force);
+  const relativeTargetPath = path.relative(process.cwd(), result.path);
+
+  if (result.skipped) {
+    console.log(`Skipped ${relativeTargetPath}. Existing file was left unchanged.`);
+    console.log("Run `npx getrelay@latest --force` to overwrite it, or use `npx getrelay@latest --out <file>` to write somewhere else.");
+    return;
+  }
+
+  console.log(`Created ${relativeTargetPath} from ${layout.name}.`);
+  console.log("Tell your AI coding agent to use Relay.md as the design source for your page.");
+}
+
+main().catch((error) => {
+  console.error(`Relay error: ${error.message}`);
+  process.exitCode = 1;
+});