@webmaster-droid/cli 0.4.0 → 0.4.2

package/dist/index.js

@@ -22,20 +22,89 @@ import generateImport from "@babel/generator";
 import * as t from "@babel/types";
 var traverse = traverseImport.default ?? traverseImport;
 var generate = generateImport.default ?? generateImport;
+var PARSER_PLUGINS = ["typescript", "jsx"];
+function parseModule(source) {
+  return parse(source, {
+    sourceType: "module",
+    plugins: PARSER_PLUGINS
+  });
+}
 function normalizeText(text) {
   return text.replace(/\s+/g, " ").trim();
 }
 function defaultPathFor(file, line, kind) {
-  const stem = file.replace(/\\/g, "/").replace(/^\//, "").replace(/\.[tj]sx?$/, "").replace(/[^a-zA-Z0-9/]+/g, "-").replace(/\//g, ".");
-  return `pages.todo.${stem}.${kind}.${line}`;
+  const normalized = file.replace(/\\/g, "/").replace(/^\//, "").replace(/\.[tj]sx?$/, "");
+  const stem = normalized.split("/").filter((segment) => segment && segment !== "." && segment !== "..").map(
+    (segment) => segment.replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+/, "").replace(/-+$/, "")
+  ).filter(Boolean).join(".");
+  return `pages.todo.${stem || "file"}.${kind}.${line}`;
+}
+function escapeJsxString(value) {
+  return JSON.stringify(value);
+}
+function applyReplacements(source, replacements) {
+  if (replacements.length === 0) {
+    return source;
+  }
+  const sorted = [...replacements].sort((a, b) => b.start - a.start);
+  let out = source;
+  for (const replacement of sorted) {
+    out = out.slice(0, replacement.start) + replacement.value + out.slice(replacement.end);
+  }
+  return out;
+}
+function hasEditableTextImportDeclaration(node) {
+  return node.source.value === "@webmaster-droid/web" && node.specifiers.some(
+    (specifier) => t.isImportSpecifier(specifier) && t.isIdentifier(specifier.imported) && specifier.imported.name === "EditableText"
+  );
+}
+function ensureEditableTextImport(source) {
+  const ast = parseModule(source);
+  const body = ast.program.body;
+  let lastImportEnd = 0;
+  let moduleImport = null;
+  for (const node of body) {
+    if (!t.isImportDeclaration(node)) {
+      break;
+    }
+    lastImportEnd = node.end ?? lastImportEnd;
+    if (node.source.value === "@webmaster-droid/web" && node.importKind !== "type" && !moduleImport) {
+      moduleImport = node;
+    }
+  }
+  if (moduleImport && hasEditableTextImportDeclaration(moduleImport)) {
+    return source;
+  }
+  if (moduleImport) {
+    const hasNamespaceSpecifier = moduleImport.specifiers.some(
+      (specifier) => t.isImportNamespaceSpecifier(specifier)
+    );
+    if (!hasNamespaceSpecifier && moduleImport.start !== null && moduleImport.end !== null) {
+      const updatedImport = t.cloneNode(moduleImport);
+      updatedImport.specifiers.push(
+        t.importSpecifier(t.identifier("EditableText"), t.identifier("EditableText"))
+      );
+      const importSource = generate(updatedImport, { compact: false }).code;
+      return source.slice(0, moduleImport.start) + importSource + source.slice(moduleImport.end);
+    }
+  }
+  const importLine = `import { EditableText } from "@webmaster-droid/web";
+`;
+  if (lastImportEnd > 0) {
+    let insertionPoint = lastImportEnd;
+    if (source.slice(insertionPoint, insertionPoint + 2) === "\r\n") {
+      insertionPoint += 2;
+    } else if (source[insertionPoint] === "\n") {
+      insertionPoint += 1;
+    }
+    return source.slice(0, insertionPoint) + importLine + source.slice(insertionPoint);
+  }
+  return `${importLine}${source}`;
 }
 function transformEditableTextCodemod(source, filePath, cwd) {
-  const ast = parse(source, {
-    sourceType: "module",
-    plugins: ["typescript", "jsx"]
-  });
+  const ast = parseModule(source);
   let touched = false;
-  let needsEditableTextImport = false;
+  const replacements = [];
   traverse(ast, {
     JSXElement(pathNode) {
       const children = pathNode.node.children;
@@ -52,22 +121,17 @@ function transformEditableTextCodemod(source, filePath, cwd) {
       const loc = nonWhitespace[0].loc?.start.line ?? 0;
       const rel = path.relative(cwd, filePath);
       const pathHint = defaultPathFor(rel, loc, "text");
-      const editableEl = t.jsxElement(
-        t.jsxOpeningElement(
-          t.jsxIdentifier("EditableText"),
-          [
-            t.jsxAttribute(t.jsxIdentifier("path"), t.stringLiteral(pathHint)),
-            t.jsxAttribute(t.jsxIdentifier("fallback"), t.stringLiteral(text))
-          ],
-          true
-        ),
-        null,
-        [],
-        true
-      );
-      pathNode.node.children = [t.jsxExpressionContainer(editableEl)];
+      const targetNode = nonWhitespace[0];
+      if (typeof targetNode.start !== "number" || typeof targetNode.end !== "number") {
+        return;
+      }
+      const replacement = `<EditableText path=${escapeJsxString(pathHint)} fallback=${escapeJsxString(text)} />`;
+      replacements.push({
+        start: targetNode.start,
+        end: targetNode.end,
+        value: replacement
+      });
       touched = true;
-      needsEditableTextImport = true;
     }
   });
   if (!touched) {
@@ -76,28 +140,12 @@ function transformEditableTextCodemod(source, filePath, cwd) {
       next: source
     };
   }
-  if (needsEditableTextImport) {
-    const body = ast.program.body;
-    const hasImport = body.some(
-      (node) => t.isImportDeclaration(node) && node.source.value === "@webmaster-droid/web" && node.specifiers.some(
-        (specifier) => t.isImportSpecifier(specifier) && t.isIdentifier(specifier.imported) && specifier.imported.name === "EditableText"
-      )
-    );
-    if (!hasImport) {
-      body.unshift(
-        t.importDeclaration(
-          [
-            t.importSpecifier(
-              t.identifier("EditableText"),
-              t.identifier("EditableText")
-            )
-          ],
-          t.stringLiteral("@webmaster-droid/web")
-        )
-      );
-    }
+  let next = applyReplacements(source, replacements);
+  next = ensureEditableTextImport(next);
+  parseModule(next);
+  if (source.endsWith("\n") && !next.endsWith("\n")) {
+    next += "\n";
   }
-  const next = generate(ast, { retainLines: true }, source).code;
   return {
     changed: next !== source,
     next
@@ -126,6 +174,195 @@ async function readJson(filePath) {
   const raw = await fs.readFile(filePath, "utf8");
   return JSON.parse(raw);
 }
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function splitPath(pathValue) {
+  return pathValue.replace(/\[(\d+)\]/g, ".$1").split(".").map((segment) => segment.trim()).filter(Boolean);
+}
+function readByPath(input, pathValue) {
+  const segments = splitPath(pathValue);
+  let current = input;
+  for (const segment of segments) {
+    if (Array.isArray(current)) {
+      const index = Number(segment);
+      if (Number.isNaN(index)) {
+        return void 0;
+      }
+      current = current[index];
+      continue;
+    }
+    if (!isRecord(current)) {
+      return void 0;
+    }
+    current = current[segment];
+  }
+  return current;
+}
+function writeByPath(input, pathValue, value) {
+  const segments = splitPath(pathValue);
+  if (segments.length === 0) {
+    return false;
+  }
+  let current = input;
+  for (let index = 0; index < segments.length - 1; index += 1) {
+    const segment = segments[index];
+    if (Array.isArray(current)) {
+      const itemIndex = Number(segment);
+      if (Number.isNaN(itemIndex)) {
+        return false;
+      }
+      if (current[itemIndex] === void 0) {
+        const next = segments[index + 1];
+        current[itemIndex] = /^\d+$/.test(next) ? [] : {};
+      }
+      current = current[itemIndex];
+      continue;
+    }
+    if (!isRecord(current)) {
+      return false;
+    }
+    if (current[segment] === void 0) {
+      const next = segments[index + 1];
+      current[segment] = /^\d+$/.test(next) ? [] : {};
+    }
+    current = current[segment];
+  }
+  const leaf = segments.at(-1);
+  if (!leaf) {
+    return false;
+  }
+  if (Array.isArray(current)) {
+    const itemIndex = Number(leaf);
+    if (Number.isNaN(itemIndex)) {
+      return false;
+    }
+    current[itemIndex] = value;
+    return true;
+  }
+  if (!isRecord(current)) {
+    return false;
+  }
+  current[leaf] = value;
+  return true;
+}
+function createSeedDocument() {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    meta: {
+      schemaVersion: 1,
+      contentVersion: "seed_v1",
+      updatedAt: now,
+      updatedBy: "seed-generator"
+    },
+    themeTokens: {},
+    layout: {},
+    pages: {},
+    seo: {}
+  };
+}
+function normalizeSeedDocument(input) {
+  const defaults = createSeedDocument();
+  if (!isRecord(input)) {
+    return defaults;
+  }
+  const output = {
+    ...defaults,
+    ...input
+  };
+  const metaValue = isRecord(output.meta) ? output.meta : {};
+  output.meta = {
+    ...defaults.meta,
+    ...metaValue
+  };
+  for (const key of ["themeTokens", "layout", "pages", "seo"]) {
+    if (!isRecord(output[key])) {
+      output[key] = {};
+    }
+  }
+  return output;
+}
+function extractIdentifierName(value) {
+  if (t2.isJSXIdentifier(value)) {
+    return value.name;
+  }
+  return null;
+}
+function staticTemplateLiteralValue(template) {
+  if (template.expressions.length > 0) {
+    return null;
+  }
+  return template.quasis.map((part) => part.value.cooked ?? part.value.raw).join("");
+}
+function resolveAttributeValue(value) {
+  if (!value) {
+    return { kind: "missing" };
+  }
+  if (t2.isStringLiteral(value)) {
+    return { kind: "static", value: value.value };
+  }
+  if (!t2.isJSXExpressionContainer(value)) {
+    return { kind: "dynamic" };
+  }
+  const expression = value.expression;
+  if (t2.isStringLiteral(expression)) {
+    return { kind: "static", value: expression.value };
+  }
+  if (t2.isTemplateLiteral(expression)) {
+    const staticValue = staticTemplateLiteralValue(expression);
+    if (staticValue !== null) {
+      return { kind: "static", value: staticValue };
+    }
+  }
+  return { kind: "dynamic" };
+}
+function findAttribute(node, name) {
+  for (const attribute of node.attributes) {
+    if (!t2.isJSXAttribute(attribute)) {
+      continue;
+    }
+    if (!t2.isJSXIdentifier(attribute.name)) {
+      continue;
+    }
+    if (attribute.name.name === name) {
+      return attribute;
+    }
+  }
+  return null;
+}
+var SEEDABLE_ROOT_PREFIXES = ["pages.", "layout.", "seo.", "themeTokens."];
+var EDITABLE_COMPONENT_PATHS = {
+  EditableText: [{ pathProp: "path", fallbackProp: "fallback" }],
+  EditableRichText: [{ pathProp: "path", fallbackProp: "fallback" }],
+  EditableImage: [
+    { pathProp: "path", fallbackProp: "fallbackSrc" },
+    { pathProp: "altPath", fallbackProp: "fallbackAlt" }
+  ],
+  EditableLink: [
+    { pathProp: "hrefPath", fallbackProp: "fallbackHref" },
+    { pathProp: "labelPath", fallbackProp: "fallbackLabel" }
+  ]
+};
+function isSeedableEditablePath(pathValue) {
+  return SEEDABLE_ROOT_PREFIXES.some((prefix) => pathValue.startsWith(prefix));
+}
+function formatSourceLocation(file, line) {
+  return line ? `${file}:${line}` : file;
+}
+function printSkipDetails(heading, entries) {
+  if (entries.length === 0) {
+    return;
+  }
+  console.log(heading);
+  const MAX_PREVIEW = 25;
+  const shown = entries.slice(0, MAX_PREVIEW);
+  for (const entry of shown) {
+    console.log(`  - ${entry}`);
+  }
+  if (entries.length > shown.length) {
+    console.log(`  - ... ${entries.length - shown.length} more`);
+  }
+}
 program.name("webmaster-droid").description("Webmaster Droid CLI").version(CLI_VERSION);
 program.command("init").description("Initialize webmaster-droid environment template in current project").option("--backend <backend>", "backend (supabase|aws)", "supabase").option("--out <dir>", "output dir", ".").action(async (opts) => {
   const backendRaw = String(opts.backend ?? "supabase").trim().toLowerCase();
@@ -165,6 +402,8 @@ program.command("init").description("Initialize webmaster-droid environment temp
         "MODEL_OPENAI_ENABLED=true",
         "MODEL_GEMINI_ENABLED=true",
         "DEFAULT_MODEL_ID=openai:gpt-5.2",
+        "OPENAI_API_KEY=",
+        "GOOGLE_GENERATIVE_AI_API_KEY=",
         "",
         "# AWS (optional backend)",
         "CMS_S3_BUCKET=",
@@ -222,6 +461,205 @@ schema.command("build").description("Compile schema file to runtime manifest JSO
   await fs.writeFile(output, JSON.stringify(manifest, null, 2) + "\n", "utf8");
   console.log(`Wrote manifest: ${output}`);
 });
+program.command("seed").description("Generate CMS seed document from Editable component paths").argument("<srcDir>", "source directory").option("--out <file>", "seed output file", "cms/seed.from-editables.json").option("--base <file>", "merge into an existing seed document").option("--json", "emit machine-readable JSON output", false).action(async (srcDir, opts) => {
+  try {
+    const root = path2.resolve(process.cwd(), srcDir);
+    let rootStat;
+    try {
+      rootStat = await fs.stat(root);
+    } catch {
+      throw new Error(`Source directory not found: ${root}`);
+    }
+    if (!rootStat.isDirectory()) {
+      throw new Error(`Source path is not a directory: ${root}`);
+    }
+    const files = await glob("**/*.{ts,tsx,js,jsx}", {
+      cwd: root,
+      absolute: true,
+      ignore: ["**/*.d.ts", "**/node_modules/**", "**/.next/**", "**/dist/**"]
+    });
+    const staticPaths = /* @__PURE__ */ new Map();
+    const dynamicPaths = [];
+    const invalidPaths = [];
+    for (const file of files) {
+      const code = await fs.readFile(file, "utf8");
+      const ast = parse2(code, {
+        sourceType: "module",
+        plugins: ["typescript", "jsx"]
+      });
+      traverse2(ast, {
+        JSXOpeningElement(pathNode) {
+          const componentName = extractIdentifierName(pathNode.node.name);
+          if (!componentName) {
+            return;
+          }
+          const specs = EDITABLE_COMPONENT_PATHS[componentName];
+          if (!specs) {
+            return;
+          }
+          for (const spec of specs) {
+            const pathAttr = findAttribute(pathNode.node, spec.pathProp);
+            const pathValue = resolveAttributeValue(pathAttr?.value);
+            if (pathValue.kind === "missing") {
+              continue;
+            }
+            const relFile = path2.relative(process.cwd(), file);
+            if (pathValue.kind === "dynamic") {
+              dynamicPaths.push({
+                file: relFile,
+                line: pathAttr?.loc?.start.line,
+                component: componentName,
+                prop: spec.pathProp
+              });
+              continue;
+            }
+            const normalizedPath = pathValue.value.trim();
+            if (!normalizedPath) {
+              continue;
+            }
+            if (!isSeedableEditablePath(normalizedPath)) {
+              invalidPaths.push({
+                file: relFile,
+                line: pathAttr?.loc?.start.line,
+                component: componentName,
+                prop: spec.pathProp,
+                path: normalizedPath
+              });
+              continue;
+            }
+            const fallbackAttr = findAttribute(pathNode.node, spec.fallbackProp);
+            const fallbackValue = resolveAttributeValue(fallbackAttr?.value);
+            const fallback = fallbackValue.kind === "static" ? fallbackValue.value : "";
+            const existing = staticPaths.get(normalizedPath);
+            if (!existing) {
+              staticPaths.set(normalizedPath, {
+                fallback,
+                source: relFile,
+                line: pathAttr?.loc?.start.line
+              });
+              continue;
+            }
+            if (!existing.fallback && fallback) {
+              staticPaths.set(normalizedPath, {
+                fallback,
+                source: relFile,
+                line: pathAttr?.loc?.start.line
+              });
+            }
+          }
+        }
+      });
+    }
+    const baseFile = opts.base ? path2.resolve(process.cwd(), String(opts.base)) : null;
+    const baseSeed = baseFile ? await readJson(baseFile) : createSeedDocument();
+    const seedDocument = normalizeSeedDocument(baseSeed);
+    let writtenPaths = 0;
+    let preservedPaths = 0;
+    let writeFailures = 0;
+    for (const [seedPath, entry] of staticPaths.entries()) {
+      const existingValue = readByPath(seedDocument, seedPath);
+      if (existingValue !== void 0) {
+        preservedPaths += 1;
+        continue;
+      }
+      const written = writeByPath(seedDocument, seedPath, entry.fallback);
+      if (written) {
+        writtenPaths += 1;
+      } else {
+        writeFailures += 1;
+      }
+    }
+    const output = path2.resolve(process.cwd(), opts.out);
+    await ensureDir(output);
+    await fs.writeFile(output, JSON.stringify(seedDocument, null, 2) + "\n", "utf8");
+    const report = {
+      outputPath: output,
+      source: root,
+      baseFile,
+      totalFiles: files.length,
+      discoveredStaticPaths: staticPaths.size,
+      writtenPaths,
+      preservedPaths,
+      dynamicPathSkips: dynamicPaths.length,
+      invalidPathSkips: invalidPaths.length,
+      writeFailures,
+      allowedRootPrefixes: [...SEEDABLE_ROOT_PREFIXES],
+      dynamicPathDetails: dynamicPaths.map((entry) => ({
+        ...entry,
+        location: formatSourceLocation(entry.file, entry.line),
+        reason: "Path prop uses a dynamic expression and cannot be seeded automatically. Convert to concrete indexed paths."
+      })),
+      invalidPathDetails: invalidPaths.map((entry) => ({
+        ...entry,
+        location: formatSourceLocation(entry.file, entry.line),
+        reason: `Path root is outside supported prefixes (${SEEDABLE_ROOT_PREFIXES.join(", ")}).`
+      })),
+      manualMigrationRequired: dynamicPaths.length > 0 || invalidPaths.length > 0
+    };
+    if (opts.json) {
+      emitCliEnvelope({
+        ok: writeFailures === 0,
+        command: "seed",
+        version: CLI_VERSION,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        data: report,
+        errors: writeFailures > 0 ? [`Failed to write ${writeFailures} discovered path(s) into seed document.`] : void 0
+      }, writeFailures > 0);
+      if (writeFailures > 0) {
+        process.exitCode = 1;
+      }
+      return;
+    }
+    console.log(
+      `Seed generated. Static paths: ${staticPaths.size}. Written: ${writtenPaths}. Preserved: ${preservedPaths}. Output: ${output}`
+    );
+    if (dynamicPaths.length > 0) {
+      console.log(
+        `Skipped ${dynamicPaths.length} dynamic path expression(s). Manual migration required before first edit.`
+      );
+      printSkipDetails(
+        "Dynamic path locations:",
+        dynamicPaths.map(
+          (entry) => `${formatSourceLocation(entry.file, entry.line)} <${entry.component} ${entry.prop}=...>`
+        )
+      );
+    }
+    if (invalidPaths.length > 0) {
+      console.log(
+        `Skipped ${invalidPaths.length} non-editable path(s) outside allowed roots (${SEEDABLE_ROOT_PREFIXES.join(", ")}).`
+      );
+      printSkipDetails(
+        "Invalid root path locations:",
+        invalidPaths.map(
+          (entry) => `${formatSourceLocation(entry.file, entry.line)} <${entry.component} ${entry.prop}="${entry.path}">`
+        )
+      );
+    }
+    if (dynamicPaths.length > 0 || invalidPaths.length > 0) {
+      console.log(
+        "Seed report includes all skipped entries. Resolve these paths manually, then rerun `webmaster-droid seed`."
+      );
+    }
+    if (writeFailures > 0) {
+      throw new Error(`Failed to write ${writeFailures} discovered path(s) into seed document.`);
+    }
+  } catch (error) {
+    if (!opts.json) {
+      throw error;
+    }
+    emitCliEnvelope(
+      {
+        ok: false,
+        command: "seed",
+        version: CLI_VERSION,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        errors: [errorToMessage(error)]
+      },
+      true
+    );
+    process.exitCode = 1;
+  }
+});
 program.command("scan").description("Scan source files for static content candidates").argument("<srcDir>", "source directory").option("--out <file>", "report output", ".webmaster-droid/scan-report.json").option("--json", "emit machine-readable JSON output", false).action(async (srcDir, opts) => {
   try {
     const root = path2.resolve(process.cwd(), srcDir);
@@ -323,20 +761,28 @@ program.command("codemod").description("Apply deterministic JSX codemods to Edit
       ignore: ["**/node_modules/**", "**/.next/**", "**/dist/**"]
     });
     const changed = [];
+    const failures = [];
     for (const file of files) {
-      const source = await fs.readFile(file, "utf8");
-      const transformed = transformEditableTextCodemod(source, file, process.cwd());
-      if (!transformed.changed) {
-        continue;
-      }
-      const next = transformed.next;
       const relFile = path2.relative(process.cwd(), file);
-      changed.push({
-        file: relFile,
-        patch: createTwoFilesPatch(relFile, relFile, source, next)
-      });
-      if (opts.apply) {
-        await fs.writeFile(file, next, "utf8");
+      try {
+        const source = await fs.readFile(file, "utf8");
+        const transformed = transformEditableTextCodemod(source, file, root);
+        if (!transformed.changed) {
+          continue;
+        }
+        const next = transformed.next;
+        changed.push({
+          file: relFile,
+          patch: createTwoFilesPatch(relFile, relFile, source, next)
+        });
+        if (opts.apply) {
+          await fs.writeFile(file, next, "utf8");
+        }
+      } catch (error) {
+        failures.push({
+          file: relFile,
+          error: errorToMessage(error)
+        });
       }
     }
     const output = path2.resolve(process.cwd(), opts.out);
@@ -345,10 +791,41 @@ program.command("codemod").description("Apply deterministic JSX codemods to Edit
       source: root,
       apply: Boolean(opts.apply),
       changedFiles: changed.length,
+      failedFiles: failures.length,
+      failures,
       changes: changed
     };
     await ensureDir(output);
     await fs.writeFile(output, JSON.stringify(report, null, 2) + "\n", "utf8");
+    if (failures.length > 0) {
+      const errorMessage = failures.map((item) => `${item.file}: ${item.error}`).join("; ");
+      if (opts.json) {
+        emitCliEnvelope(
+          {
+            ok: false,
+            command: "codemod",
+            version: CLI_VERSION,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            data: {
+              reportPath: output,
+              source: root,
+              apply: Boolean(opts.apply),
+              changedFiles: changed.length
+            },
+            errors: [errorMessage]
+          },
+          true
+        );
+        process.exitCode = 1;
+        return;
+      }
+      console.error(`Codemod encountered ${failures.length} file error(s). Report: ${output}`);
+      for (const failure of failures) {
+        console.error(`- ${failure.file}: ${failure.error}`);
+      }
+      process.exitCode = 1;
+      return;
+    }
     if (opts.json) {
       emitCliEnvelope({
         ok: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webmaster-droid/cli",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "type": "module",
   "bin": {
     "webmaster-droid": "dist/index.js"