@mozole/cli 1.4.3 → 2.0.0-b

package/dist/scaffold/standalone.js

@@ -1,374 +0,0 @@
-import { designGuardrails } from "./design.js";
-/** Standalone project tooling: no dependency on the generator at runtime. */
-export const backendCheckScript = `import { spawnSync } from "node:child_process";
-import { readdir } from "node:fs/promises";
-import path from "node:path";
-
-function php(args) {
-  const result = spawnSync("php", args, {
-    encoding: "utf8",
-    shell: false,
-    timeout: 10000,
-  });
-  if (result.error || result.status !== 0)
-    throw new Error(result.error?.message || result.stderr || result.stdout);
-  return result.stdout.trim();
-}
-async function lint(directory) {
-  for (const entry of await readdir(directory, { withFileTypes: true })) {
-    const file = path.join(directory, entry.name);
-    if (entry.isDirectory()) await lint(file);
-    else if (entry.isFile() && entry.name.endsWith(".php")) php(["-l", file]);
-  }
-}
-try {
-  const version = Number(php(["-r", "echo PHP_VERSION_ID;"]));
-  if (!Number.isInteger(version) || version < 80000)
-    throw new Error("PHP 8.0 or newer is required.");
-  await lint("api");
-  console.log("PHP PASS");
-} catch (error) {
-  console.error(\`PHP FAIL\\n\${error.message}\`);
-  process.exitCode = 1;
-}
-`;
-export const deployScript = `import { cp, lstat, mkdir, rename, rm } from "node:fs/promises";
-import path from "node:path";
-
-const target = path.resolve("deploy");
-const staging = \`\${target}.\${process.pid}.tmp\`;
-const backup = \`\${target}.\${process.pid}.backup\`;
-let backedUp = false;
-try {
-  await mkdir(staging);
-  await cp("build/client", staging, { recursive: true, errorOnExist: true });
-  await cp("api", path.join(staging, "api"), { recursive: true });
-  await cp(".htaccess", path.join(staging, ".htaccess"));
-  try {
-    await lstat(target);
-    await rename(target, backup);
-    backedUp = true;
-  } catch (error) {
-    if (error.code !== "ENOENT") throw error;
-  }
-  try {
-    await rename(staging, target);
-  } catch (error) {
-    if (backedUp) await rename(backup, target);
-    throw error;
-  }
-  if (backedUp) await rm(backup, { recursive: true });
-  console.log("DEPLOY READY: deploy/");
-} finally {
-  await rm(staging, { recursive: true, force: true });
-}
-`;
-export const qaScript = `import { spawn, spawnSync } from "node:child_process";
-import { mkdir, readFile } from "node:fs/promises";
-import net from "node:net";
-import { chromium } from "playwright";
-
-const flags = process.argv.slice(2);
-if (
-  flags.some((flag) => !["--visual", "--interactive", "--force"].includes(flag))
-)
-  throw new Error("Unknown QA option");
-const config = JSON.parse(await readFile(".mozole/project.json", "utf8"));
-const routes = config.routes;
-const viewports = config.qa?.viewports;
-const artifactName = (route) =>
-  route === "/"
-    ? "index"
-    : route
-        .replace(/^\\/+/, "")
-        .replaceAll("/", "-")
-        .replace(/[^a-zA-Z0-9._-]+/g, "-")
-        .replace(/-+/g, "-")
-        .replace(/^-+|-+$/g, "") || "route";
-if (
-  !Array.isArray(routes) ||
-  routes.length === 0 ||
-  routes.length > 100 ||
-  new Set(routes).size !== routes.length ||
-  new Set(routes.map(artifactName)).size !== routes.length ||
-  !routes.every(
-    (route) =>
-      typeof route === "string" &&
-      route.startsWith("/") &&
-      !route.startsWith("//") &&
-      route.length <= 2048,
-  ) ||
-  !Array.isArray(viewports) ||
-  viewports.length === 0 ||
-  viewports.length > 20 ||
-  new Set(
-    viewports.map(({ width, height }) => \`\${String(width)}x\${String(height)}\`),
-  ).size !== viewports.length ||
-  !viewports.every(
-    ({ width, height }) =>
-      Number.isInteger(width) &&
-      width > 0 &&
-      width <= 7680 &&
-      Number.isInteger(height) &&
-      height > 0 &&
-      height <= 7680,
-  )
-)
-  throw new Error("Invalid QA routes or viewports");
-function safe(value) {
-  value = String(value);
-  let output = "";
-  for (let index = 0; index < value.length; index++) {
-    const code = value.charCodeAt(index);
-    if (code === 27) {
-      const kind = value[index + 1];
-      if (kind === "[") {
-        index += 2;
-        while (index < value.length) {
-          const byte = value.charCodeAt(index);
-          if (byte >= 64 && byte <= 126) break;
-          index++;
-        }
-      } else if (kind === "]") {
-        index += 2;
-        while (index < value.length) {
-          if (value.charCodeAt(index) === 7) break;
-          if (value.charCodeAt(index) === 27 && value[index + 1] === "\\\\") {
-            index++;
-            break;
-          }
-          index++;
-        }
-      } else if (kind !== undefined) index++;
-      continue;
-    }
-    if (
-      (code >= 0 && code <= 8) ||
-      code === 11 ||
-      code === 12 ||
-      (code >= 14 && code <= 31) ||
-      (code >= 127 && code <= 159)
-    )
-      continue;
-    output += value[index];
-  }
-  return output;
-}
-const socket = net.createServer();
-await new Promise((resolve, reject) => {
-  socket.once("error", reject);
-  socket.listen(0, "127.0.0.1", resolve);
-});
-const port = socket.address().port;
-await new Promise((resolve) => socket.close(resolve));
-const configured = config.qa.server;
-const npmCli = process.env.npm_execpath;
-if (configured.command === "npm" && !npmCli) {
-  throw new Error(
-    "Run QA through npm run qa so npm can be resolved without a shell.",
-  );
-}
-const command =
-  configured.command === "npm" ? process.execPath : configured.command;
-const args = [
-  ...(configured.command === "npm" ? [npmCli] : []),
-  ...configured.args,
-  "--port",
-  String(port),
-  "--strictPort",
-];
-const child = spawn(command, args, {
-  shell: false,
-  detached: process.platform !== "win32",
-  stdio: ["ignore", "pipe", "pipe"],
-});
-let serverLog = "";
-for (const stream of [child.stdout, child.stderr])
-  stream.on("data", (data) => {
-    serverLog = (serverLog + data).slice(-4000);
-  });
-let serverError;
-child.on("error", (error) => {
-  serverError = error;
-});
-let browser;
-let stopping = false;
-async function cleanup() {
-  if (stopping) return;
-  stopping = true;
-  await browser?.close().catch(() => {});
-  if (child.pid) {
-    if (process.platform === "win32")
-      spawnSync("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
-        shell: false,
-        stdio: "ignore",
-      });
-    else {
-      try {
-        process.kill(-child.pid, "SIGTERM");
-      } catch {}
-    }
-  }
-}
-const interrupted = () => {
-  void cleanup().finally(() => process.exit(130));
-};
-process.once("SIGINT", interrupted);
-process.once("SIGTERM", interrupted);
-const deadline = setTimeout(() => {
-  console.error("QA timed out");
-  void cleanup().finally(() => process.exit(1));
-}, 120000);
-const base = \`http://127.0.0.1:\${port}\`;
-try {
-  let ready = false;
-  for (let attempt = 0; attempt < 300; attempt++) {
-    if (serverError || child.exitCode !== null)
-      throw new Error(serverError?.message || serverLog);
-    try {
-      ready = (
-        await fetch(base + config.qa.server.readinessPath, {
-          signal: AbortSignal.timeout(1000),
-        })
-      ).ok;
-    } catch {}
-    if (ready) break;
-    await new Promise((resolve) => setTimeout(resolve, 100));
-  }
-  if (!ready)
-    throw new Error(\`Development server did not become ready.\\n\${serverLog}\`);
-  browser = await chromium.launch();
-  const failures = [];
-  for (const viewport of config.qa.viewports) {
-    const page = await browser.newPage({ viewport });
-    page.on("pageerror", (error) => failures.push(error.message));
-    page.on("console", (message) => {
-      if (message.type() === "error") failures.push(message.text());
-    });
-    page.on("requestfailed", (request) => {
-      if (request.failure()?.errorText !== "net::ERR_ABORTED")
-        failures.push(request.url());
-    });
-    page.on("response", (response) => {
-      if (response.status() >= 400)
-        failures.push(\`\${response.status()} \${response.url()}\`);
-    });
-    for (const route of config.routes) {
-      const response = await page.goto(base + route, {
-        waitUntil: "networkidle",
-      });
-      if (!response?.ok()) failures.push(\`\${route}: HTTP failure\`);
-      const issues = await page.evaluate(() => {
-        const found = [];
-        if (!document.documentElement.lang) found.push("missing lang");
-        if (!document.title.trim()) found.push("missing title");
-        if (!document.querySelector("h1")) found.push("missing h1");
-        if (document.documentElement.scrollWidth > innerWidth + 1)
-          found.push("horizontal overflow");
-        for (const element of document.querySelectorAll(
-          "a, button, input:not([type=hidden]), select, textarea",
-        )) {
-          if (!element.getClientRects().length) continue;
-          const labelled = (element.getAttribute("aria-labelledby") || "")
-            .split(/\\s+/)
-            .some((id) => document.getElementById(id)?.textContent?.trim());
-          if (
-            !element.textContent?.trim() &&
-            !element.getAttribute("aria-label") &&
-            !labelled &&
-            !element.labels?.length &&
-            !element.getAttribute("title") &&
-            !element.getAttribute("alt") &&
-            !element.querySelector("img[alt]")
-          )
-            found.push("unnamed control");
-        }
-        return found;
-      });
-      failures.push(...issues.map((issue) => \`\${route}: \${issue}\`));
-      const links = await page
-        .locator("a[href]")
-        .evaluateAll((anchors) => anchors.map((anchor) => anchor.href));
-      for (const href of new Set(links)) {
-        if (
-          new URL(href).origin === base &&
-          !(await page.request.get(href)).ok()
-        )
-          failures.push(\`broken link: \${href}\`);
-      }
-      if (flags.includes("--interactive")) {
-        await page.keyboard.press("Tab");
-        if (
-          !(await page.evaluate(() => document.activeElement !== document.body))
-        )
-          failures.push(\`\${route}: keyboard focus missing\`);
-      }
-      if (flags.includes("--visual")) {
-        await mkdir(".mozole/qa", { recursive: true });
-        const name = artifactName(route);
-        await page.screenshot({
-          path:
-            ".mozole/qa/" +
-            viewport.width +
-            "x" +
-            viewport.height +
-            "-" +
-            name +
-            ".png",
-          fullPage: true,
-        });
-      }
-    }
-    await page.close();
-  }
-  if (failures.length) throw new Error([...new Set(failures)].join("\\n"));
-  console.log(
-    "QA PASS: " +
-      config.routes.length +
-      " routes, " +
-      config.qa.viewports.length +
-      " viewports",
-  );
-} catch (error) {
-  console.error(\`QA FAIL\\n\${safe(error.message)}\`);
-  process.exitCode = 1;
-} finally {
-  clearTimeout(deadline);
-  process.removeListener("SIGINT", interrupted);
-  process.removeListener("SIGTERM", interrupted);
-  await cleanup();
-}
-`;
-export function basicAgentGuide(backend) {
-    return `# Project guide\n\n## Commands\n\n- \`npm run dev\` — frontend development server\n- \`npm run verify\` — lint, typecheck, tests, production build\n- \`npm run qa\` — browser checks without screenshots\n- \`npm run qa:interactive\` — keyboard checks\n- \`npm run qa:visual\` — explicitly requested screenshots\n${backend ? "- `npm run dev:api` — PHP API in a separate terminal (PHP 8.0+)\n- `npm run check:php` — PHP version and syntax checks\n- `npm run build:deploy` — assemble deploy/ for Apache or LiteSpeed\n" : ""}\n## Architecture\n\nReact Router and Vite source is in \`app/\`; routes are declared in \`app/routes.ts\`. Production HTML and assets are in \`build/client/\`.${backend ? " PHP endpoints are in `api/`; the frontend uses relative `/api/` URLs through Vite's proxy. See `docs/backend-php.md`." : ""}\n\n## Working rules\n\nPreserve user changes. Inspect relevant code before editing. Run verification and relevant browser checks before handoff. Routine QA never captures screenshots; use visual QA only when requested. Report failed checks and remaining limitations.\n\n${designGuardrails}`;
-}
-export const extraVerifierScript = `import { spawnSync } from "node:child_process";
-import { readFile } from "node:fs/promises";
-
-const config = JSON.parse(await readFile(".mozole/project.json", "utf8"));
-for (const check of config.verifiers ?? []) {
-  if (
-    typeof check.command !== "string" ||
-    !Array.isArray(check.args) ||
-    !check.args.every((arg) => typeof arg === "string")
-  )
-    throw new Error("Invalid extra verifier");
-  const npm = check.command === "npm";
-  if (npm && !process.env.npm_execpath)
-    throw new Error("Run verification through npm run verify");
-  const result = spawnSync(
-    npm ? process.execPath : check.command,
-    npm ? [process.env.npm_execpath, ...check.args] : check.args,
-    { shell: false, stdio: "inherit", timeout: 600000 },
-  );
-  if (result.error || result.status !== 0) {
-    console.error(
-      "Extra verifier failed:",
-      check.name,
-      result.error?.message ?? result.status,
-    );
-    process.exit(result.status || 1);
-  }
-}
-`;
-//# sourceMappingURL=standalone.js.map

package/dist/scaffold/standalone.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"standalone.js","sourceRoot":"","sources":["../../src/scaffold/standalone.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C,6EAA6E;AAC7E,MAAM,CAAC,MAAM,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BjC,CAAC;AAEF,MAAM,CAAC,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8B3B,CAAC;AAEF,MAAM,CAAC,MAAM,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmRvB,CAAC;AAEF,MAAM,UAAU,eAAe,CAAC,OAAgB;IAC9C,OAAO,0TAA0T,OAAO,CAAC,CAAC,CAAC,+LAA+L,CAAC,CAAC,CAAC,EAAE,mKAAmK,OAAO,CAAC,CAAC,CAAC,wHAAwH,CAAC,CAAC,CAAC,EAAE,kRAAkR,gBAAgB,EAAE,CAAC;AAChmC,CAAC;AAED,MAAM,CAAC,MAAM,mBAAmB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BlC,CAAC"}

package/dist/scaffold/templates.d.ts

@@ -1,9 +0,0 @@
-import type { MozoleConfig } from "../config/project.js";
-export interface ProjectTemplateOptions {
-    scaffold?: boolean | undefined;
-    backend?: boolean | undefined;
-    sharedDependencies?: boolean | undefined;
-}
-export declare function projectConfig(name: string, options?: ProjectTemplateOptions): MozoleConfig;
-export declare function projectTemplates(name: string, options?: ProjectTemplateOptions): Record<string, string>;
-//# sourceMappingURL=templates.d.ts.map

package/dist/scaffold/templates.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"templates.d.ts","sourceRoot":"","sources":["../../src/scaffold/templates.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAczD,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC/B,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9B,kBAAkB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC1C;AAED,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,sBAA2B,GACnC,YAAY,CAmDd;AAID,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,sBAA2B,GACnC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAsTxB"}