@pracht/cli 0.0.0 → 1.0.0

package/lib/manifest.js

@@ -0,0 +1,147 @@
+export function ensureCoreNamedImport(source, name) {
+  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, key, entry) {
+  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, key, item) {
+  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, targetFilePath) {
+  const relativePath = targetFilePath
+    .replaceAll("\\", "/")
+    .replace(manifestPath.replaceAll("\\", "/").replace(/\/[^/]+$/, ""), "")
+    .replace(/^\//, "");
+
+  return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+}
+
+export function extractRegistryEntries(source, key) {
+  const block = findNamedBlock(source, key, "{", "}");
+  if (!block) return [];
+  const inner = source.slice(block.openIndex + 1, block.closeIndex);
+  const entries = [];
+  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) {
+  const results = new Set();
+  for (const match of source.matchAll(/["'`]((?:\.\.\/|\.\/)[^"'`]+)["'`]/g)) {
+    results.add(match[1]);
+  }
+  return results;
+}
+
+function insertBlockEntry(source, block, entry) {
+  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, key, openChar, closeChar) {
+  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, openIndex, openChar, closeChar) {
+  let depth = 0;
+  let quoteChar = 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, indent) {
+  return value
+    .split("\n")
+    .map((line) => `${indent}${line}`)
+    .join("\n");
+}

package/lib/project.js

@@ -0,0 +1,143 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, dirname, relative, resolve } from "node:path";
+
+import { ensureTrailingNewline } from "./cli.js";
+import { PROJECT_DEFAULTS } from "./constants.js";
+
+export function readProjectConfig(root) {
+  const configFile = findConfigFile(root);
+  const rawConfig = configFile ? readFileSync(configFile, "utf-8") : "";
+  const config = {
+    ...PROJECT_DEFAULTS,
+    configFile,
+    hasPrachtPlugin: /\bpracht\s*\(/.test(rawConfig),
+    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;
+}
+
+export function resolveProjectPath(root, configPath) {
+  return resolve(root, `.${configPath}`);
+}
+
+export function resolveScopedFile(root, configDir, fileName) {
+  return resolve(resolveProjectPath(root, configDir), fileName);
+}
+
+export function resolveRouteModulePath(project, routePath, extension) {
+  const segments = segmentsFromRoutePath(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, routePath, extension) {
+  const segments = segmentsFromRoutePath(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, endpointPath) {
+  const segments = segmentsFromApiPath(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, filePath) {
+  return relative(root, filePath) || ".";
+}
+
+export function writeGeneratedFile(filePath, source) {
+  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, message) {
+  if (!existsSync(filePath)) {
+    throw new Error(message);
+  }
+}
+
+export function listFilesRecursively(dir) {
+  const files = [];
+  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) {
+  return /^_app\.(ts|tsx|js|jsx)$/.test(basename(filePath));
+}
+
+function findConfigFile(root) {
+  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, key) {
+  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) {
+  if (!value) return value;
+  return value.startsWith("/") ? value : `/${value}`;
+}
+
+function segmentsFromRoutePath(routePath) {
+  return routePath
+    .split("/")
+    .filter(Boolean)
+    .map((segment) => {
+      if (segment.startsWith(":")) return `[${segment.slice(1)}]`;
+      if (segment === "*") return "[...slug]";
+      return segment;
+    });
+}
+
+function segmentsFromApiPath(endpointPath) {
+  return endpointPath
+    .split("/")
+    .filter(Boolean)
+    .map((segment) => {
+      if (segment.startsWith(":")) return `[${segment.slice(1)}]`;
+      if (segment === "*") return "[...slug]";
+      return segment;
+    });
+}