@pracht/cli 1.2.1 → 1.2.2

package/src/commands/inspect.ts

@@ -1,212 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { resolve } from "node:path";
-
-import { defineCommand } from "citty";
-import { createServer, type ViteDevServer } from "vite";
-
-import { handleCliError } from "../utils.js";
-import { readClientBuildAssets } from "../build-metadata.js";
-import { HTTP_METHODS, type HttpMethod } from "../constants.js";
-import { readProjectConfig, resolveProjectPath } from "../project.js";
-
-const INSPECT_TARGETS = new Set(["routes", "api", "build", "all"]);
-const METHOD_ORDER: HttpMethod[] = [...HTTP_METHODS];
-
-export default defineCommand({
-  meta: {
-    name: "inspect",
-    description: "Inspect resolved app graph",
-  },
-  args: {
-    target: {
-      type: "positional",
-      description: "Inspect target: routes, api, build, or all",
-      required: false,
-    },
-    json: {
-      type: "boolean",
-      description: "Output as JSON",
-    },
-  },
-  async run({ args }) {
-    const target = args.target || "all";
-
-    if (!INSPECT_TARGETS.has(target)) {
-      handleCliError(new Error(`Unknown inspect target: ${target}`), {
-        json: Boolean(args.json),
-      });
-    }
-
-    const report = await runInspect(process.cwd(), { target });
-
-    if (args.json) {
-      console.log(JSON.stringify(report, null, 2));
-      return;
-    }
-
-    printInspectReport(report);
-  },
-});
-
-interface InspectReport {
-  api?: { file: string; methods: string[]; path: string }[];
-  build?: {
-    adapterTarget: string;
-    clientEntryUrl: string | null;
-    cssManifest: Record<string, string[]>;
-    jsManifest: Record<string, string[]>;
-  };
-  mode: string;
-  routes?: {
-    file: string;
-    id: string;
-    loaderFile: string | null;
-    middleware: string[];
-    path: string;
-    render: string | null;
-    revalidate: unknown;
-    shell: string | null;
-    shellFile: string | null;
-  }[];
-}
-
-async function runInspect(root: string, { target = "all" } = {}): Promise<InspectReport> {
-  const project = readProjectConfig(root);
-
-  if (!project.configFile) {
-    throw new Error(
-      "Missing vite config. `pracht inspect` requires a project with pracht configured.",
-    );
-  }
-
-  if (!project.hasPrachtPlugin) {
-    throw new Error("vite.config does not appear to register the pracht plugin.");
-  }
-
-  if (project.mode === "manifest") {
-    const manifestPath = resolveProjectPath(project.root, project.appFile);
-    if (!existsSync(manifestPath)) {
-      throw new Error(`App manifest is missing at ${project.appFile}.`);
-    }
-  }
-
-  const server = await createServer({
-    root,
-    logLevel: "silent",
-    server: {
-      middlewareMode: true,
-    },
-  });
-
-  try {
-    const serverModule = await server.ssrLoadModule("virtual:pracht/server");
-    const report: InspectReport = {
-      mode: project.mode,
-    };
-
-    if (target === "routes" || target === "all") {
-      report.routes = serializeRoutes(serverModule.resolvedApp.routes);
-    }
-
-    if (target === "api" || target === "all") {
-      report.api = await Promise.all(
-        serverModule.apiRoutes.map(async (route: { file: string; path: string }) => ({
-          file: route.file,
-          methods: await detectApiMethods(server, root, route.file),
-          path: route.path,
-        })),
-      );
-    }
-
-    if (target === "build" || target === "all") {
-      const buildAssets = readClientBuildAssets(root);
-      report.build = {
-        adapterTarget: serverModule.buildTarget,
-        clientEntryUrl: buildAssets.clientEntryUrl,
-        cssManifest: buildAssets.cssManifest,
-        jsManifest: buildAssets.jsManifest,
-      };
-    }
-
-    return report;
-  } finally {
-    await server.close();
-  }
-}
-
-interface RouteEntry {
-  file: string;
-  id: string;
-  loaderFile?: string;
-  middleware: string[];
-  path: string;
-  render?: string;
-  revalidate?: unknown;
-  shell?: string;
-  shellFile?: string;
-}
-
-function serializeRoutes(routes: RouteEntry[]) {
-  return routes.map((route) => ({
-    file: route.file,
-    id: route.id,
-    loaderFile: route.loaderFile ?? null,
-    middleware: route.middleware,
-    path: route.path,
-    render: route.render ?? null,
-    revalidate: route.revalidate ?? null,
-    shell: route.shell ?? null,
-    shellFile: route.shellFile ?? null,
-  }));
-}
-
-async function detectApiMethods(
-  server: ViteDevServer,
-  root: string,
-  file: string,
-): Promise<string[]> {
-  const resolvedFile = resolve(root, `.${file}`);
-  const source = readFileSync(resolvedFile, "utf-8");
-
-  try {
-    const module = await server.ssrLoadModule(file);
-    return METHOD_ORDER.filter((method) => typeof module[method] === "function");
-  } catch {
-    return METHOD_ORDER.filter((method) =>
-      new RegExp(`export\\s+(?:async\\s+)?(?:function|const|let|var)\\s+${method}\\b`).test(source),
-    );
-  }
-}
-
-function printInspectReport(report: InspectReport): void {
-  console.log(`Pracht inspect (${report.mode} mode)`);
-
-  if (report.routes) {
-    console.log("\nRoutes");
-    for (const route of report.routes) {
-      console.log(
-        `  ${route.path}  id=${route.id}  render=${route.render ?? "n/a"}  file=${route.file}`,
-      );
-    }
-  }
-
-  if (report.api) {
-    console.log("\nAPI");
-    if (report.api.length === 0) {
-      console.log("  No API routes found.");
-    } else {
-      for (const route of report.api) {
-        const methods = route.methods.length > 0 ? route.methods.join(",") : "none";
-        console.log(`  ${route.path}  methods=${methods}  file=${route.file}`);
-      }
-    }
-  }
-
-  if (report.build) {
-    console.log("\nBuild");
-    console.log(`  adapterTarget=${report.build.adapterTarget}`);
-    console.log(`  clientEntryUrl=${report.build.clientEntryUrl ?? "null"}`);
-    console.log(`  cssManifestKeys=${Object.keys(report.build.cssManifest).length}`);
-    console.log(`  jsManifestKeys=${Object.keys(report.build.jsManifest).length}`);
-  }
-}

package/src/commands/verify.ts

@@ -1,37 +0,0 @@
-import { defineCommand } from "citty";
-
-import { runVerification } from "../verification.js";
-
-export default defineCommand({
-  meta: {
-    name: "verify",
-    description: "Fast framework-aware verification",
-  },
-  args: {
-    changed: {
-      type: "boolean",
-      description: "Only check changed files",
-    },
-    json: {
-      type: "boolean",
-      description: "Output as JSON",
-    },
-  },
-  async run({ args }) {
-    const report = runVerification(process.cwd(), { changed: Boolean(args.changed) });
-
-    if (args.json) {
-      console.log(JSON.stringify(report, null, 2));
-    } else {
-      console.log(`Pracht verify (${report.mode} mode, ${report.scope} scope)`);
-      for (const check of report.checks) {
-        console.log(`${check.status.toUpperCase().padEnd(7)} ${check.message}`);
-      }
-      console.log(report.ok ? "\nNo blocking issues found." : "\nBlocking issues found.");
-    }
-
-    if (!report.ok) {
-      process.exitCode = 1;
-    }
-  },
-});

package/src/constants.ts

@@ -1,26 +0,0 @@
-import type { HttpMethod } from "@pracht/core";
-
-export type { HttpMethod };
-
-export const VERSION = "0.0.0";
-
-export const PROJECT_DEFAULTS = {
-  apiDir: "/src/api",
-  appFile: "/src/routes.ts",
-  middlewareDir: "/src/middleware",
-  pagesDefaultRender: "ssr",
-  pagesDir: "",
-  routesDir: "/src/routes",
-  serverDir: "/src/server",
-  shellsDir: "/src/shells",
-};
-
-export const HTTP_METHODS = new Set<HttpMethod>([
-  "GET",
-  "POST",
-  "PUT",
-  "PATCH",
-  "DELETE",
-  "HEAD",
-  "OPTIONS",
-]);

package/src/index.ts

@@ -1,21 +0,0 @@
-import { defineCommand, runMain } from "citty";
-
-import { VERSION } from "./constants.js";
-
-const main = defineCommand({
-  meta: {
-    name: "pracht",
-    version: VERSION,
-    description: "The pracht CLI",
-  },
-  subCommands: {
-    build: () => import("./commands/build.js").then((m) => m.default),
-    dev: () => import("./commands/dev.js").then((m) => m.default),
-    doctor: () => import("./commands/doctor.js").then((m) => m.default),
-    generate: () => import("./commands/generate.js").then((m) => m.default),
-    inspect: () => import("./commands/inspect.js").then((m) => m.default),
-    verify: () => import("./commands/verify.js").then((m) => m.default),
-  },
-});
-
-runMain(main);

package/src/manifest.ts

@@ -1,166 +0,0 @@
-export function ensureCoreNamedImport(source: string, name: string): string {
-  const match = source.match(/import\s*\{([^}]+)\}\s*from\s*["']@pracht\/core["'];?/);
-  if (!match) {
-    return `import { ${name} } from "@pracht/core";\n${source}`;
-  }
-
-  const names = match[1]
-    .split(",")
-    .map((item) => item.trim())
-    .filter(Boolean);
-  if (!names.includes(name)) {
-    names.push(name);
-  }
-
-  return source.replace(match[0], `import { ${names.join(", ")} } from "@pracht/core";`);
-}
-
-export function upsertObjectEntry(source: string, key: string, entry: string): string {
-  const property = findNamedBlock(source, key, "{", "}");
-  if (!property) {
-    const routesMatch = source.match(/^(\s*)routes\s*:/m);
-    if (!routesMatch || routesMatch.index == null) {
-      throw new Error(`Could not find a "${key}" or "routes" block in the app manifest.`);
-    }
-
-    const indent = routesMatch[1];
-    const block = `${indent}${key}: {\n${indent}  ${entry},\n${indent}},\n`;
-    return `${source.slice(0, routesMatch.index)}${block}${source.slice(routesMatch.index)}`;
-  }
-
-  return insertBlockEntry(source, property, entry);
-}
-
-export function insertArrayItem(source: string, key: string, item: string): string {
-  const property = findNamedBlock(source, key, "[", "]");
-  if (!property) {
-    throw new Error(`Could not find "${key}" in the app manifest.`);
-  }
-
-  return insertBlockEntry(source, property, item);
-}
-
-export function toManifestModulePath(manifestPath: string, targetFilePath: string): string {
-  const relativePath = targetFilePath
-    .replaceAll("\\", "/")
-    .replace(manifestPath.replaceAll("\\", "/").replace(/\/[^/]+$/, ""), "")
-    .replace(/^\//, "");
-
-  return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
-}
-
-export function extractRegistryEntries(
-  source: string,
-  key: string,
-): { name: string; path: string }[] {
-  const block = findNamedBlock(source, key, "{", "}");
-  if (!block) return [];
-  const inner = source.slice(block.openIndex + 1, block.closeIndex);
-  const entries: { name: string; path: string }[] = [];
-  const pattern =
-    /([A-Za-z0-9_-]+)\s*:\s*(?:(["'`])([^"'`]+)\2|\(\)\s*=>\s*import\(\s*(["'`])([^"'`]+)\4\s*\))/g;
-
-  for (const match of inner.matchAll(pattern)) {
-    entries.push({ name: match[1], path: match[3] ?? match[5] });
-  }
-
-  return entries;
-}
-
-export function extractRelativeModulePaths(source: string): Set<string> {
-  const results = new Set<string>();
-  for (const match of source.matchAll(/["'`]((?:\.\.\/|\.\/)[^"'`]+)["'`]/g)) {
-    results.add(match[1]);
-  }
-  return results;
-}
-
-interface BlockLocation {
-  closeIndex: number;
-  indent: string;
-  openIndex: number;
-}
-
-function insertBlockEntry(source: string, block: BlockLocation, entry: string): string {
-  const inner = source.slice(block.openIndex + 1, block.closeIndex);
-  const closingIndent = block.indent;
-  const childIndent = `${closingIndent}  `;
-  const trimmed = inner.trim();
-
-  if (!trimmed) {
-    return `${source.slice(0, block.openIndex + 1)}\n${indentMultiline(entry, childIndent)}\n${closingIndent}${source.slice(block.closeIndex)}`;
-  }
-
-  const needsComma = !/[,[{(]\s*$/.test(inner) && !/,\s*$/.test(trimmed);
-  const insertPrefix = needsComma ? "," : "";
-  return `${source.slice(0, block.closeIndex)}${insertPrefix}\n${indentMultiline(entry, childIndent)}\n${closingIndent}${source.slice(block.closeIndex)}`;
-}
-
-function findNamedBlock(
-  source: string,
-  key: string,
-  openChar: string,
-  closeChar: string,
-): BlockLocation | null {
-  const pattern = new RegExp(`^([ \\t]*)${key}\\s*:\\s*\\${openChar}`, "m");
-  const match = source.match(pattern);
-  if (!match || match.index == null) {
-    return null;
-  }
-
-  const openIndex = source.indexOf(openChar, match.index);
-  const closeIndex = findMatchingDelimiter(source, openIndex, openChar, closeChar);
-  return {
-    closeIndex,
-    indent: match[1],
-    openIndex,
-  };
-}
-
-function findMatchingDelimiter(
-  source: string,
-  openIndex: number,
-  openChar: string,
-  closeChar: string,
-): number {
-  let depth = 0;
-  let quoteChar: string | null = null;
-  let escaping = false;
-
-  for (let index = openIndex; index < source.length; index += 1) {
-    const current = source[index];
-    if (quoteChar) {
-      if (escaping) {
-        escaping = false;
-        continue;
-      }
-      if (current === "\\") {
-        escaping = true;
-        continue;
-      }
-      if (current === quoteChar) {
-        quoteChar = null;
-      }
-      continue;
-    }
-
-    if (current === '"' || current === "'" || current === "`") {
-      quoteChar = current;
-      continue;
-    }
-    if (current === openChar) depth += 1;
-    if (current === closeChar) {
-      depth -= 1;
-      if (depth === 0) return index;
-    }
-  }
-
-  throw new Error(`Could not find matching ${closeChar} for ${openChar}.`);
-}
-
-function indentMultiline(value: string, indent: string): string {
-  return value
-    .split("\n")
-    .map((line) => `${indent}${line}`)
-    .join("\n");
-}

package/src/project.ts

@@ -1,160 +0,0 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
-import { basename, dirname, relative, resolve } from "node:path";
-
-import { ensureTrailingNewline } from "./utils.js";
-import { PROJECT_DEFAULTS } from "./constants.js";
-
-export interface ProjectConfig {
-  apiDir: string;
-  appFile: string;
-  configFile: string | null;
-  hasPrachtPlugin: boolean;
-  middlewareDir: string;
-  mode: "manifest" | "pages";
-  pagesDefaultRender: string;
-  pagesDir: string;
-  rawConfig: string;
-  root: string;
-  routesDir: string;
-  serverDir: string;
-  shellsDir: string;
-}
-
-export function readProjectConfig(root: string): ProjectConfig {
-  const configFile = findConfigFile(root);
-  const rawConfig = configFile ? readFileSync(configFile, "utf-8") : "";
-  const config: Record<string, unknown> = {
-    ...PROJECT_DEFAULTS,
-    configFile,
-    hasPrachtPlugin: /\bpracht\s*\(/.test(rawConfig),
-    mode: "manifest" as const,
-    rawConfig,
-    root,
-  };
-
-  for (const key of Object.keys(PROJECT_DEFAULTS)) {
-    const value = readQuotedConfigValue(rawConfig, key);
-    if (typeof value === "string") {
-      config[key] = normalizeConfigPath(value);
-    }
-  }
-
-  config.mode = config.pagesDir ? "pages" : "manifest";
-  return config as unknown as ProjectConfig;
-}
-
-export function resolveProjectPath(root: string, configPath: string): string {
-  return resolve(root, `.${configPath}`);
-}
-
-export function resolveScopedFile(root: string, configDir: string, fileName: string): string {
-  return resolve(resolveProjectPath(root, configDir), fileName);
-}
-
-export function resolveRouteModulePath(
-  project: ProjectConfig,
-  routePath: string,
-  extension: string,
-): { absolutePath: string; relativePath: string } {
-  const segments = segmentsFromPath(routePath);
-  const relativePath =
-    segments.length === 0 ? `index${extension}` : `${segments.join("/")}${extension}`;
-  const absolutePath = resolve(resolveProjectPath(project.root, project.routesDir), relativePath);
-  return { absolutePath, relativePath };
-}
-
-export function resolvePagesRouteModulePath(
-  project: ProjectConfig,
-  routePath: string,
-  extension: string,
-): { absolutePath: string; relativePath: string } {
-  const segments = segmentsFromPath(routePath);
-  const relativePath =
-    segments.length === 0 ? `index${extension}` : `${segments.join("/")}${extension}`;
-  const absolutePath = resolve(resolveProjectPath(project.root, project.pagesDir), relativePath);
-  return { absolutePath, relativePath };
-}
-
-export function resolveApiModulePath(
-  project: ProjectConfig,
-  endpointPath: string,
-): { absolutePath: string; relativePath: string } {
-  const segments = segmentsFromPath(endpointPath);
-  const relativePath = segments.length === 0 ? "index.ts" : `${segments.join("/")}.ts`;
-  const absolutePath = resolve(resolveProjectPath(project.root, project.apiDir), relativePath);
-  return { absolutePath, relativePath };
-}
-
-export function displayPath(root: string, filePath: string): string {
-  return relative(root, filePath) || ".";
-}
-
-export function writeGeneratedFile(filePath: string, source: string): void {
-  if (existsSync(filePath)) {
-    throw new Error(`Refusing to overwrite existing file ${filePath}.`);
-  }
-
-  mkdirSync(dirname(filePath), { recursive: true });
-  writeFileSync(filePath, ensureTrailingNewline(source), "utf-8");
-}
-
-export function assertFileExists(filePath: string, message: string): void {
-  if (!existsSync(filePath)) {
-    throw new Error(message);
-  }
-}
-
-export function listFilesRecursively(dir: string): string[] {
-  const files: string[] = [];
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = resolve(dir, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...listFilesRecursively(fullPath));
-    } else {
-      files.push(fullPath);
-    }
-  }
-  return files;
-}
-
-export function hasPagesAppShell(filePath: string): boolean {
-  return /^_app\.(ts|tsx|js|jsx)$/.test(basename(filePath));
-}
-
-function findConfigFile(root: string): string | null {
-  for (const name of [
-    "vite.config.ts",
-    "vite.config.mts",
-    "vite.config.js",
-    "vite.config.mjs",
-    "vite.config.cjs",
-    "vite.config.cts",
-  ]) {
-    const file = resolve(root, name);
-    if (existsSync(file)) return file;
-  }
-  return null;
-}
-
-function readQuotedConfigValue(source: string, key: string): string | null {
-  if (!source) return null;
-  const pattern = new RegExp(`${key}\\s*:\\s*(["'\\\`])([^"'\\\`]+)\\1`);
-  const match = source.match(pattern);
-  return match ? match[2] : null;
-}
-
-function normalizeConfigPath(value: string): string {
-  if (!value) return value;
-  return value.startsWith("/") ? value : `/${value}`;
-}
-
-function segmentsFromPath(path: string): string[] {
-  return path
-    .split("/")
-    .filter(Boolean)
-    .map((segment) => {
-      if (segment.startsWith(":")) return `[${segment.slice(1)}]`;
-      if (segment === "*") return "[...slug]";
-      return segment;
-    });
-}

package/src/utils.ts

@@ -1,72 +0,0 @@
-import { HTTP_METHODS, type HttpMethod } from "./constants.js";
-
-export function quote(value: string): string {
-  return JSON.stringify(value);
-}
-
-export function ensureTrailingNewline(value: string): string {
-  return value.endsWith("\n") ? value : `${value}\n`;
-}
-
-export function parseCommaList(value: string | string[] | boolean | undefined): string[] {
-  if (!value || typeof value === "boolean") return [];
-  const values = Array.isArray(value) ? value : [value];
-  return values
-    .flatMap((entry) => String(entry).split(","))
-    .map((entry) => entry.trim())
-    .filter(Boolean);
-}
-
-export function parseApiMethods(value: string | string[] | boolean | undefined): HttpMethod[] {
-  const methods = parseCommaList(value);
-  const normalized =
-    methods.length === 0
-      ? (["GET"] as HttpMethod[])
-      : methods.map((entry) => entry.toUpperCase() as HttpMethod);
-
-  for (const method of normalized) {
-    if (!HTTP_METHODS.has(method)) {
-      throw new Error(`Unsupported HTTP method "${method}".`);
-    }
-  }
-
-  return [...new Set(normalized)];
-}
-
-export function requireEnum(
-  value: string | undefined,
-  key: string,
-  allowed: string[],
-  fallback: string,
-): string {
-  const val = value ?? fallback;
-  if (!allowed.includes(val)) {
-    throw new Error(`Invalid value for --${key}. Expected one of ${allowed.join(", ")}.`);
-  }
-  return val;
-}
-
-export function requirePositiveInteger(
-  value: string | undefined,
-  key: string,
-  fallback: number,
-): number {
-  const parsed = value == null ? fallback : Number.parseInt(value, 10);
-  if (!Number.isInteger(parsed) || parsed <= 0) {
-    throw new Error(`--${key} must be a positive integer.`);
-  }
-  return parsed;
-}
-
-export function handleCliError(error: unknown, { json }: { json: boolean }): never {
-  const message = error instanceof Error ? error.message : String(error);
-  if (json) {
-    console.error(JSON.stringify({ ok: false, error: message }, null, 2));
-  } else {
-    console.error(message);
-    if (error instanceof Error && error.stack && process.env.DEBUG) {
-      console.error(error.stack);
-    }
-  }
-  process.exit(1);
-}